1 /* Objective-C language support routines for GDB, the GNU debugger. 2 3 Copyright (C) 2002-2013 Free Software Foundation, Inc. 4 5 Contributed by Apple Computer, Inc. 6 Written by Michael Snyder. 7 8 This file is part of GDB. 9 10 This program is free software; you can redistribute it and/or modify 11 it under the terms of the GNU General Public License as published by 12 the Free Software Foundation; either version 3 of the License, or 13 (at your option) any later version. 14 15 This program is distributed in the hope that it will be useful, 16 but WITHOUT ANY WARRANTY; without even the implied warranty of 17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 GNU General Public License for more details. 19 20 You should have received a copy of the GNU General Public License 21 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 22 23 #include "defs.h" 24 #include "symtab.h" 25 #include "gdbtypes.h" 26 #include "expression.h" 27 #include "parser-defs.h" 28 #include "language.h" 29 #include "c-lang.h" 30 #include "objc-lang.h" 31 #include "exceptions.h" 32 #include "complaints.h" 33 #include "value.h" 34 #include "symfile.h" 35 #include "objfiles.h" 36 #include "gdb_string.h" /* for strchr */ 37 #include "target.h" /* for target_has_execution */ 38 #include "gdbcore.h" 39 #include "gdbcmd.h" 40 #include "frame.h" 41 #include "gdb_regex.h" 42 #include "regcache.h" 43 #include "block.h" 44 #include "infcall.h" 45 #include "valprint.h" 46 #include "gdb_assert.h" 47 #include "cli/cli-utils.h" 48 49 #include <ctype.h> 50 51 struct objc_object { 52 CORE_ADDR isa; 53 }; 54 55 struct objc_class { 56 CORE_ADDR isa; 57 CORE_ADDR super_class; 58 CORE_ADDR name; 59 long version; 60 long info; 61 long instance_size; 62 CORE_ADDR ivars; 63 CORE_ADDR methods; 64 CORE_ADDR cache; 65 CORE_ADDR protocols; 66 }; 67 68 struct objc_super { 69 CORE_ADDR receiver; 70 CORE_ADDR class; 71 }; 72 73 struct objc_method { 74 CORE_ADDR name; 75 CORE_ADDR types; 76 CORE_ADDR imp; 77 }; 78 79 static const struct objfile_data *objc_objfile_data; 80 81 /* Lookup a structure type named "struct NAME", visible in lexical 82 block BLOCK. If NOERR is nonzero, return zero if NAME is not 83 suitably defined. */ 84 85 struct symbol * 86 lookup_struct_typedef (char *name, const struct block *block, int noerr) 87 { 88 struct symbol *sym; 89 90 sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0); 91 92 if (sym == NULL) 93 { 94 if (noerr) 95 return 0; 96 else 97 error (_("No struct type named %s."), name); 98 } 99 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT) 100 { 101 if (noerr) 102 return 0; 103 else 104 error (_("This context has class, union or enum %s, not a struct."), 105 name); 106 } 107 return sym; 108 } 109 110 CORE_ADDR 111 lookup_objc_class (struct gdbarch *gdbarch, char *classname) 112 { 113 struct type *char_type = builtin_type (gdbarch)->builtin_char; 114 struct value * function, *classval; 115 116 if (! target_has_execution) 117 { 118 /* Can't call into inferior to lookup class. */ 119 return 0; 120 } 121 122 if (lookup_minimal_symbol("objc_lookUpClass", 0, 0)) 123 function = find_function_in_inferior("objc_lookUpClass", NULL); 124 else if (lookup_minimal_symbol ("objc_lookup_class", 0, 0)) 125 function = find_function_in_inferior("objc_lookup_class", NULL); 126 else 127 { 128 complaint (&symfile_complaints, 129 _("no way to lookup Objective-C classes")); 130 return 0; 131 } 132 133 classval = value_string (classname, strlen (classname) + 1, char_type); 134 classval = value_coerce_array (classval); 135 return (CORE_ADDR) value_as_long (call_function_by_hand (function, 136 1, &classval)); 137 } 138 139 CORE_ADDR 140 lookup_child_selector (struct gdbarch *gdbarch, char *selname) 141 { 142 struct type *char_type = builtin_type (gdbarch)->builtin_char; 143 struct value * function, *selstring; 144 145 if (! target_has_execution) 146 { 147 /* Can't call into inferior to lookup selector. */ 148 return 0; 149 } 150 151 if (lookup_minimal_symbol("sel_getUid", 0, 0)) 152 function = find_function_in_inferior("sel_getUid", NULL); 153 else if (lookup_minimal_symbol ("sel_get_any_uid", 0, 0)) 154 function = find_function_in_inferior("sel_get_any_uid", NULL); 155 else 156 { 157 complaint (&symfile_complaints, 158 _("no way to lookup Objective-C selectors")); 159 return 0; 160 } 161 162 selstring = value_coerce_array (value_string (selname, 163 strlen (selname) + 1, 164 char_type)); 165 return value_as_long (call_function_by_hand (function, 1, &selstring)); 166 } 167 168 struct value * 169 value_nsstring (struct gdbarch *gdbarch, char *ptr, int len) 170 { 171 struct type *char_type = builtin_type (gdbarch)->builtin_char; 172 struct value *stringValue[3]; 173 struct value *function, *nsstringValue; 174 struct symbol *sym; 175 struct type *type; 176 177 if (!target_has_execution) 178 return 0; /* Can't call into inferior to create NSString. */ 179 180 stringValue[2] = value_string(ptr, len, char_type); 181 stringValue[2] = value_coerce_array(stringValue[2]); 182 /* _NSNewStringFromCString replaces "istr" after Lantern2A. */ 183 if (lookup_minimal_symbol("_NSNewStringFromCString", 0, 0)) 184 { 185 function = find_function_in_inferior("_NSNewStringFromCString", NULL); 186 nsstringValue = call_function_by_hand(function, 1, &stringValue[2]); 187 } 188 else if (lookup_minimal_symbol("istr", 0, 0)) 189 { 190 function = find_function_in_inferior("istr", NULL); 191 nsstringValue = call_function_by_hand(function, 1, &stringValue[2]); 192 } 193 else if (lookup_minimal_symbol("+[NSString stringWithCString:]", 0, 0)) 194 { 195 function 196 = find_function_in_inferior("+[NSString stringWithCString:]", NULL); 197 type = builtin_type (gdbarch)->builtin_long; 198 199 stringValue[0] = value_from_longest 200 (type, lookup_objc_class (gdbarch, "NSString")); 201 stringValue[1] = value_from_longest 202 (type, lookup_child_selector (gdbarch, "stringWithCString:")); 203 nsstringValue = call_function_by_hand(function, 3, &stringValue[0]); 204 } 205 else 206 error (_("NSString: internal error -- no way to create new NSString")); 207 208 sym = lookup_struct_typedef("NSString", 0, 1); 209 if (sym == NULL) 210 sym = lookup_struct_typedef("NXString", 0, 1); 211 if (sym == NULL) 212 type = builtin_type (gdbarch)->builtin_data_ptr; 213 else 214 type = lookup_pointer_type(SYMBOL_TYPE (sym)); 215 216 deprecated_set_value_type (nsstringValue, type); 217 return nsstringValue; 218 } 219 220 /* Objective-C name demangling. */ 221 222 char * 223 objc_demangle (const char *mangled, int options) 224 { 225 char *demangled, *cp; 226 227 if (mangled[0] == '_' && 228 (mangled[1] == 'i' || mangled[1] == 'c') && 229 mangled[2] == '_') 230 { 231 cp = demangled = xmalloc(strlen(mangled) + 2); 232 233 if (mangled[1] == 'i') 234 *cp++ = '-'; /* for instance method */ 235 else 236 *cp++ = '+'; /* for class method */ 237 238 *cp++ = '['; /* opening left brace */ 239 strcpy(cp, mangled+3); /* Tack on the rest of the mangled name. */ 240 241 while (*cp && *cp == '_') 242 cp++; /* Skip any initial underbars in class 243 name. */ 244 245 cp = strchr(cp, '_'); 246 if (!cp) /* Find first non-initial underbar. */ 247 { 248 xfree(demangled); /* not mangled name */ 249 return NULL; 250 } 251 if (cp[1] == '_') /* Easy case: no category name. */ 252 { 253 *cp++ = ' '; /* Replace two '_' with one ' '. */ 254 strcpy(cp, mangled + (cp - demangled) + 2); 255 } 256 else 257 { 258 *cp++ = '('; /* Less easy case: category name. */ 259 cp = strchr(cp, '_'); 260 if (!cp) 261 { 262 xfree(demangled); /* not mangled name */ 263 return NULL; 264 } 265 *cp++ = ')'; 266 *cp++ = ' '; /* Overwriting 1st char of method name... */ 267 strcpy(cp, mangled + (cp - demangled)); /* Get it back. */ 268 } 269 270 while (*cp && *cp == '_') 271 cp++; /* Skip any initial underbars in 272 method name. */ 273 274 for (; *cp; cp++) 275 if (*cp == '_') 276 *cp = ':'; /* Replace remaining '_' with ':'. */ 277 278 *cp++ = ']'; /* closing right brace */ 279 *cp++ = 0; /* string terminator */ 280 return demangled; 281 } 282 else 283 return NULL; /* Not an objc mangled name. */ 284 } 285 286 /* Determine if we are currently in the Objective-C dispatch function. 287 If so, get the address of the method function that the dispatcher 288 would call and use that as the function to step into instead. Also 289 skip over the trampoline for the function (if any). This is better 290 for the user since they are only interested in stepping into the 291 method function anyway. */ 292 static CORE_ADDR 293 objc_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc) 294 { 295 struct gdbarch *gdbarch = get_frame_arch (frame); 296 CORE_ADDR real_stop_pc; 297 CORE_ADDR method_stop_pc; 298 299 real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc); 300 301 if (real_stop_pc != 0) 302 find_objc_msgcall (real_stop_pc, &method_stop_pc); 303 else 304 find_objc_msgcall (stop_pc, &method_stop_pc); 305 306 if (method_stop_pc) 307 { 308 real_stop_pc = gdbarch_skip_trampoline_code 309 (gdbarch, frame, method_stop_pc); 310 if (real_stop_pc == 0) 311 real_stop_pc = method_stop_pc; 312 } 313 314 return real_stop_pc; 315 } 316 317 318 /* Table mapping opcodes into strings for printing operators 319 and precedences of the operators. */ 320 321 static const struct op_print objc_op_print_tab[] = 322 { 323 {",", BINOP_COMMA, PREC_COMMA, 0}, 324 {"=", BINOP_ASSIGN, PREC_ASSIGN, 1}, 325 {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0}, 326 {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0}, 327 {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0}, 328 {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0}, 329 {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0}, 330 {"==", BINOP_EQUAL, PREC_EQUAL, 0}, 331 {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0}, 332 {"<=", BINOP_LEQ, PREC_ORDER, 0}, 333 {">=", BINOP_GEQ, PREC_ORDER, 0}, 334 {">", BINOP_GTR, PREC_ORDER, 0}, 335 {"<", BINOP_LESS, PREC_ORDER, 0}, 336 {">>", BINOP_RSH, PREC_SHIFT, 0}, 337 {"<<", BINOP_LSH, PREC_SHIFT, 0}, 338 {"+", BINOP_ADD, PREC_ADD, 0}, 339 {"-", BINOP_SUB, PREC_ADD, 0}, 340 {"*", BINOP_MUL, PREC_MUL, 0}, 341 {"/", BINOP_DIV, PREC_MUL, 0}, 342 {"%", BINOP_REM, PREC_MUL, 0}, 343 {"@", BINOP_REPEAT, PREC_REPEAT, 0}, 344 {"-", UNOP_NEG, PREC_PREFIX, 0}, 345 {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0}, 346 {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0}, 347 {"*", UNOP_IND, PREC_PREFIX, 0}, 348 {"&", UNOP_ADDR, PREC_PREFIX, 0}, 349 {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0}, 350 {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0}, 351 {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0}, 352 {NULL, OP_NULL, PREC_NULL, 0} 353 }; 354 355 const struct language_defn objc_language_defn = { 356 "objective-c", /* Language name */ 357 language_objc, 358 range_check_off, 359 case_sensitive_on, 360 array_row_major, 361 macro_expansion_c, 362 &exp_descriptor_standard, 363 c_parse, 364 c_error, 365 null_post_parser, 366 c_printchar, /* Print a character constant */ 367 c_printstr, /* Function to print string constant */ 368 c_emit_char, 369 c_print_type, /* Print a type using appropriate syntax */ 370 c_print_typedef, /* Print a typedef using appropriate syntax */ 371 c_val_print, /* Print a value using appropriate syntax */ 372 c_value_print, /* Print a top-level value */ 373 default_read_var_value, /* la_read_var_value */ 374 objc_skip_trampoline, /* Language specific skip_trampoline */ 375 "self", /* name_of_this */ 376 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */ 377 basic_lookup_transparent_type,/* lookup_transparent_type */ 378 objc_demangle, /* Language specific symbol demangler */ 379 NULL, /* Language specific 380 class_name_from_physname */ 381 objc_op_print_tab, /* Expression operators for printing */ 382 1, /* C-style arrays */ 383 0, /* String lower bound */ 384 default_word_break_characters, 385 default_make_symbol_completion_list, 386 c_language_arch_info, 387 default_print_array_index, 388 default_pass_by_reference, 389 default_get_string, 390 NULL, /* la_get_symbol_name_cmp */ 391 iterate_over_symbols, 392 LANG_MAGIC 393 }; 394 395 /* 396 * ObjC: 397 * Following functions help construct Objective-C message calls. 398 */ 399 400 struct selname /* For parsing Objective-C. */ 401 { 402 struct selname *next; 403 char *msglist_sel; 404 int msglist_len; 405 }; 406 407 static int msglist_len; 408 static struct selname *selname_chain; 409 static char *msglist_sel; 410 411 void 412 start_msglist(void) 413 { 414 struct selname *new = 415 (struct selname *) xmalloc (sizeof (struct selname)); 416 417 new->next = selname_chain; 418 new->msglist_len = msglist_len; 419 new->msglist_sel = msglist_sel; 420 msglist_len = 0; 421 msglist_sel = (char *)xmalloc(1); 422 *msglist_sel = 0; 423 selname_chain = new; 424 } 425 426 void 427 add_msglist(struct stoken *str, int addcolon) 428 { 429 char *s, *p; 430 int len, plen; 431 432 if (str == 0) /* Unnamed arg, or... */ 433 { 434 if (addcolon == 0) /* variable number of args. */ 435 { 436 msglist_len++; 437 return; 438 } 439 p = ""; 440 plen = 0; 441 } 442 else 443 { 444 p = str->ptr; 445 plen = str->length; 446 } 447 len = plen + strlen(msglist_sel) + 2; 448 s = (char *)xmalloc(len); 449 strcpy(s, msglist_sel); 450 strncat(s, p, plen); 451 xfree(msglist_sel); 452 msglist_sel = s; 453 if (addcolon) 454 { 455 s[len-2] = ':'; 456 s[len-1] = 0; 457 msglist_len++; 458 } 459 else 460 s[len-2] = '\0'; 461 } 462 463 int 464 end_msglist(void) 465 { 466 int val = msglist_len; 467 struct selname *sel = selname_chain; 468 char *p = msglist_sel; 469 CORE_ADDR selid; 470 471 selname_chain = sel->next; 472 msglist_len = sel->msglist_len; 473 msglist_sel = sel->msglist_sel; 474 selid = lookup_child_selector (parse_gdbarch, p); 475 if (!selid) 476 error (_("Can't find selector \"%s\""), p); 477 write_exp_elt_longcst (selid); 478 xfree(p); 479 write_exp_elt_longcst (val); /* Number of args */ 480 xfree(sel); 481 482 return val; 483 } 484 485 /* 486 * Function: specialcmp (const char *a, const char *b) 487 * 488 * Special strcmp: treats ']' and ' ' as end-of-string. 489 * Used for qsorting lists of objc methods (either by class or selector). 490 */ 491 492 static int 493 specialcmp (const char *a, const char *b) 494 { 495 while (*a && *a != ' ' && *a != ']' && *b && *b != ' ' && *b != ']') 496 { 497 if (*a != *b) 498 return *a - *b; 499 a++, b++; 500 } 501 if (*a && *a != ' ' && *a != ']') 502 return 1; /* a is longer therefore greater. */ 503 if (*b && *b != ' ' && *b != ']') 504 return -1; /* a is shorter therefore lesser. */ 505 return 0; /* a and b are identical. */ 506 } 507 508 /* 509 * Function: compare_selectors (const void *, const void *) 510 * 511 * Comparison function for use with qsort. Arguments are symbols or 512 * msymbols Compares selector part of objc method name alphabetically. 513 */ 514 515 static int 516 compare_selectors (const void *a, const void *b) 517 { 518 const char *aname, *bname; 519 520 aname = SYMBOL_PRINT_NAME (*(struct symbol **) a); 521 bname = SYMBOL_PRINT_NAME (*(struct symbol **) b); 522 if (aname == NULL || bname == NULL) 523 error (_("internal: compare_selectors(1)")); 524 525 aname = strchr(aname, ' '); 526 bname = strchr(bname, ' '); 527 if (aname == NULL || bname == NULL) 528 error (_("internal: compare_selectors(2)")); 529 530 return specialcmp (aname+1, bname+1); 531 } 532 533 /* 534 * Function: selectors_info (regexp, from_tty) 535 * 536 * Implements the "Info selectors" command. Takes an optional regexp 537 * arg. Lists all objective c selectors that match the regexp. Works 538 * by grepping thru all symbols for objective c methods. Output list 539 * is sorted and uniqued. 540 */ 541 542 static void 543 selectors_info (char *regexp, int from_tty) 544 { 545 struct objfile *objfile; 546 struct minimal_symbol *msymbol; 547 const char *name; 548 char *val; 549 int matches = 0; 550 int maxlen = 0; 551 int ix; 552 char myregexp[2048]; 553 char asel[256]; 554 struct symbol **sym_arr; 555 int plusminus = 0; 556 557 if (regexp == NULL) 558 strcpy(myregexp, ".*]"); /* Null input, match all objc methods. */ 559 else 560 { 561 if (*regexp == '+' || *regexp == '-') 562 { /* User wants only class methods or only instance methods. */ 563 plusminus = *regexp++; 564 while (*regexp == ' ' || *regexp == '\t') 565 regexp++; 566 } 567 if (*regexp == '\0') 568 strcpy(myregexp, ".*]"); 569 else 570 { 571 /* Allow a few extra bytes because of the strcat below. */ 572 if (sizeof (myregexp) < strlen (regexp) + 4) 573 error (_("Regexp is too long: %s"), regexp); 574 strcpy(myregexp, regexp); 575 if (myregexp[strlen(myregexp) - 1] == '$') /* end of selector */ 576 myregexp[strlen(myregexp) - 1] = ']'; /* end of method name */ 577 else 578 strcat(myregexp, ".*]"); 579 } 580 } 581 582 if (regexp != NULL) 583 { 584 val = re_comp (myregexp); 585 if (val != 0) 586 error (_("Invalid regexp (%s): %s"), val, regexp); 587 } 588 589 /* First time thru is JUST to get max length and count. */ 590 ALL_MSYMBOLS (objfile, msymbol) 591 { 592 QUIT; 593 name = SYMBOL_NATURAL_NAME (msymbol); 594 if (name 595 && (name[0] == '-' || name[0] == '+') 596 && name[1] == '[') /* Got a method name. */ 597 { 598 /* Filter for class/instance methods. */ 599 if (plusminus && name[0] != plusminus) 600 continue; 601 /* Find selector part. */ 602 name = (char *) strchr (name+2, ' '); 603 if (name == NULL) 604 { 605 complaint (&symfile_complaints, 606 _("Bad method name '%s'"), 607 SYMBOL_NATURAL_NAME (msymbol)); 608 continue; 609 } 610 if (regexp == NULL || re_exec(++name) != 0) 611 { 612 const char *mystart = name; 613 const char *myend = strchr (mystart, ']'); 614 615 if (myend && (myend - mystart > maxlen)) 616 maxlen = myend - mystart; /* Get longest selector. */ 617 matches++; 618 } 619 } 620 } 621 if (matches) 622 { 623 printf_filtered (_("Selectors matching \"%s\":\n\n"), 624 regexp ? regexp : "*"); 625 626 sym_arr = alloca (matches * sizeof (struct symbol *)); 627 matches = 0; 628 ALL_MSYMBOLS (objfile, msymbol) 629 { 630 QUIT; 631 name = SYMBOL_NATURAL_NAME (msymbol); 632 if (name && 633 (name[0] == '-' || name[0] == '+') && 634 name[1] == '[') /* Got a method name. */ 635 { 636 /* Filter for class/instance methods. */ 637 if (plusminus && name[0] != plusminus) 638 continue; 639 /* Find selector part. */ 640 name = (char *) strchr(name+2, ' '); 641 if (regexp == NULL || re_exec(++name) != 0) 642 sym_arr[matches++] = (struct symbol *) msymbol; 643 } 644 } 645 646 qsort (sym_arr, matches, sizeof (struct minimal_symbol *), 647 compare_selectors); 648 /* Prevent compare on first iteration. */ 649 asel[0] = 0; 650 for (ix = 0; ix < matches; ix++) /* Now do the output. */ 651 { 652 char *p = asel; 653 654 QUIT; 655 name = SYMBOL_NATURAL_NAME (sym_arr[ix]); 656 name = strchr (name, ' ') + 1; 657 if (p[0] && specialcmp(name, p) == 0) 658 continue; /* Seen this one already (not unique). */ 659 660 /* Copy selector part. */ 661 while (*name && *name != ']') 662 *p++ = *name++; 663 *p++ = '\0'; 664 /* Print in columns. */ 665 puts_filtered_tabular(asel, maxlen + 1, 0); 666 } 667 begin_line(); 668 } 669 else 670 printf_filtered (_("No selectors matching \"%s\"\n"), 671 regexp ? regexp : "*"); 672 } 673 674 /* 675 * Function: compare_classes (const void *, const void *) 676 * 677 * Comparison function for use with qsort. Arguments are symbols or 678 * msymbols Compares class part of objc method name alphabetically. 679 */ 680 681 static int 682 compare_classes (const void *a, const void *b) 683 { 684 const char *aname, *bname; 685 686 aname = SYMBOL_PRINT_NAME (*(struct symbol **) a); 687 bname = SYMBOL_PRINT_NAME (*(struct symbol **) b); 688 if (aname == NULL || bname == NULL) 689 error (_("internal: compare_classes(1)")); 690 691 return specialcmp (aname+1, bname+1); 692 } 693 694 /* 695 * Function: classes_info(regexp, from_tty) 696 * 697 * Implements the "info classes" command for objective c classes. 698 * Lists all objective c classes that match the optional regexp. 699 * Works by grepping thru the list of objective c methods. List will 700 * be sorted and uniqued (since one class may have many methods). 701 * BUGS: will not list a class that has no methods. 702 */ 703 704 static void 705 classes_info (char *regexp, int from_tty) 706 { 707 struct objfile *objfile; 708 struct minimal_symbol *msymbol; 709 const char *name; 710 char *val; 711 int matches = 0; 712 int maxlen = 0; 713 int ix; 714 char myregexp[2048]; 715 char aclass[256]; 716 struct symbol **sym_arr; 717 718 if (regexp == NULL) 719 strcpy(myregexp, ".* "); /* Null input: match all objc classes. */ 720 else 721 { 722 /* Allow a few extra bytes because of the strcat below. */ 723 if (sizeof (myregexp) < strlen (regexp) + 4) 724 error (_("Regexp is too long: %s"), regexp); 725 strcpy(myregexp, regexp); 726 if (myregexp[strlen(myregexp) - 1] == '$') 727 /* In the method name, the end of the class name is marked by ' '. */ 728 myregexp[strlen(myregexp) - 1] = ' '; 729 else 730 strcat(myregexp, ".* "); 731 } 732 733 if (regexp != NULL) 734 { 735 val = re_comp (myregexp); 736 if (val != 0) 737 error (_("Invalid regexp (%s): %s"), val, regexp); 738 } 739 740 /* First time thru is JUST to get max length and count. */ 741 ALL_MSYMBOLS (objfile, msymbol) 742 { 743 QUIT; 744 name = SYMBOL_NATURAL_NAME (msymbol); 745 if (name && 746 (name[0] == '-' || name[0] == '+') && 747 name[1] == '[') /* Got a method name. */ 748 if (regexp == NULL || re_exec(name+2) != 0) 749 { 750 /* Compute length of classname part. */ 751 const char *mystart = name + 2; 752 const char *myend = strchr (mystart, ' '); 753 754 if (myend && (myend - mystart > maxlen)) 755 maxlen = myend - mystart; 756 matches++; 757 } 758 } 759 if (matches) 760 { 761 printf_filtered (_("Classes matching \"%s\":\n\n"), 762 regexp ? regexp : "*"); 763 sym_arr = alloca (matches * sizeof (struct symbol *)); 764 matches = 0; 765 ALL_MSYMBOLS (objfile, msymbol) 766 { 767 QUIT; 768 name = SYMBOL_NATURAL_NAME (msymbol); 769 if (name && 770 (name[0] == '-' || name[0] == '+') && 771 name[1] == '[') /* Got a method name. */ 772 if (regexp == NULL || re_exec(name+2) != 0) 773 sym_arr[matches++] = (struct symbol *) msymbol; 774 } 775 776 qsort (sym_arr, matches, sizeof (struct minimal_symbol *), 777 compare_classes); 778 /* Prevent compare on first iteration. */ 779 aclass[0] = 0; 780 for (ix = 0; ix < matches; ix++) /* Now do the output. */ 781 { 782 char *p = aclass; 783 784 QUIT; 785 name = SYMBOL_NATURAL_NAME (sym_arr[ix]); 786 name += 2; 787 if (p[0] && specialcmp(name, p) == 0) 788 continue; /* Seen this one already (not unique). */ 789 790 /* Copy class part of method name. */ 791 while (*name && *name != ' ') 792 *p++ = *name++; 793 *p++ = '\0'; 794 /* Print in columns. */ 795 puts_filtered_tabular(aclass, maxlen + 1, 0); 796 } 797 begin_line(); 798 } 799 else 800 printf_filtered (_("No classes matching \"%s\"\n"), regexp ? regexp : "*"); 801 } 802 803 static char * 804 parse_selector (char *method, char **selector) 805 { 806 char *s1 = NULL; 807 char *s2 = NULL; 808 int found_quote = 0; 809 810 char *nselector = NULL; 811 812 gdb_assert (selector != NULL); 813 814 s1 = method; 815 816 s1 = skip_spaces (s1); 817 if (*s1 == '\'') 818 { 819 found_quote = 1; 820 s1++; 821 } 822 s1 = skip_spaces (s1); 823 824 nselector = s1; 825 s2 = s1; 826 827 for (;;) 828 { 829 if (isalnum (*s2) || (*s2 == '_') || (*s2 == ':')) 830 *s1++ = *s2; 831 else if (isspace (*s2)) 832 ; 833 else if ((*s2 == '\0') || (*s2 == '\'')) 834 break; 835 else 836 return NULL; 837 s2++; 838 } 839 *s1++ = '\0'; 840 841 s2 = skip_spaces (s2); 842 if (found_quote) 843 { 844 if (*s2 == '\'') 845 s2++; 846 s2 = skip_spaces (s2); 847 } 848 849 if (selector != NULL) 850 *selector = nselector; 851 852 return s2; 853 } 854 855 static char * 856 parse_method (char *method, char *type, char **class, 857 char **category, char **selector) 858 { 859 char *s1 = NULL; 860 char *s2 = NULL; 861 int found_quote = 0; 862 863 char ntype = '\0'; 864 char *nclass = NULL; 865 char *ncategory = NULL; 866 char *nselector = NULL; 867 868 gdb_assert (type != NULL); 869 gdb_assert (class != NULL); 870 gdb_assert (category != NULL); 871 gdb_assert (selector != NULL); 872 873 s1 = method; 874 875 s1 = skip_spaces (s1); 876 if (*s1 == '\'') 877 { 878 found_quote = 1; 879 s1++; 880 } 881 s1 = skip_spaces (s1); 882 883 if ((s1[0] == '+') || (s1[0] == '-')) 884 ntype = *s1++; 885 886 s1 = skip_spaces (s1); 887 888 if (*s1 != '[') 889 return NULL; 890 s1++; 891 892 nclass = s1; 893 while (isalnum (*s1) || (*s1 == '_')) 894 s1++; 895 896 s2 = s1; 897 s2 = skip_spaces (s2); 898 899 if (*s2 == '(') 900 { 901 s2++; 902 s2 = skip_spaces (s2); 903 ncategory = s2; 904 while (isalnum (*s2) || (*s2 == '_')) 905 s2++; 906 *s2++ = '\0'; 907 } 908 909 /* Truncate the class name now that we're not using the open paren. */ 910 *s1++ = '\0'; 911 912 nselector = s2; 913 s1 = s2; 914 915 for (;;) 916 { 917 if (isalnum (*s2) || (*s2 == '_') || (*s2 == ':')) 918 *s1++ = *s2; 919 else if (isspace (*s2)) 920 ; 921 else if (*s2 == ']') 922 break; 923 else 924 return NULL; 925 s2++; 926 } 927 *s1++ = '\0'; 928 s2++; 929 930 s2 = skip_spaces (s2); 931 if (found_quote) 932 { 933 if (*s2 != '\'') 934 return NULL; 935 s2++; 936 s2 = skip_spaces (s2); 937 } 938 939 if (type != NULL) 940 *type = ntype; 941 if (class != NULL) 942 *class = nclass; 943 if (category != NULL) 944 *category = ncategory; 945 if (selector != NULL) 946 *selector = nselector; 947 948 return s2; 949 } 950 951 static void 952 find_methods (char type, const char *class, const char *category, 953 const char *selector, 954 VEC (const_char_ptr) **symbol_names) 955 { 956 struct objfile *objfile = NULL; 957 958 const char *symname = NULL; 959 960 char ntype = '\0'; 961 char *nclass = NULL; 962 char *ncategory = NULL; 963 char *nselector = NULL; 964 965 static char *tmp = NULL; 966 static unsigned int tmplen = 0; 967 968 gdb_assert (symbol_names != NULL); 969 970 ALL_OBJFILES (objfile) 971 { 972 unsigned int *objc_csym; 973 struct minimal_symbol *msymbol = NULL; 974 975 /* The objfile_csym variable counts the number of ObjC methods 976 that this objfile defines. We save that count as a private 977 objfile data. If we have already determined that this objfile 978 provides no ObjC methods, we can skip it entirely. */ 979 980 unsigned int objfile_csym = 0; 981 982 objc_csym = objfile_data (objfile, objc_objfile_data); 983 if (objc_csym != NULL && *objc_csym == 0) 984 /* There are no ObjC symbols in this objfile. Skip it entirely. */ 985 continue; 986 987 ALL_OBJFILE_MSYMBOLS (objfile, msymbol) 988 { 989 QUIT; 990 991 /* Check the symbol name first as this can be done entirely without 992 sending any query to the target. */ 993 symname = SYMBOL_NATURAL_NAME (msymbol); 994 if (symname == NULL) 995 continue; 996 997 if ((symname[0] != '-' && symname[0] != '+') || (symname[1] != '[')) 998 /* Not a method name. */ 999 continue; 1000 1001 objfile_csym++; 1002 1003 /* Now that thinks are a bit sane, clean up the symname. */ 1004 while ((strlen (symname) + 1) >= tmplen) 1005 { 1006 tmplen = (tmplen == 0) ? 1024 : tmplen * 2; 1007 tmp = xrealloc (tmp, tmplen); 1008 } 1009 strcpy (tmp, symname); 1010 1011 if (parse_method (tmp, &ntype, &nclass, 1012 &ncategory, &nselector) == NULL) 1013 continue; 1014 1015 if ((type != '\0') && (ntype != type)) 1016 continue; 1017 1018 if ((class != NULL) 1019 && ((nclass == NULL) || (strcmp (class, nclass) != 0))) 1020 continue; 1021 1022 if ((category != NULL) && 1023 ((ncategory == NULL) || (strcmp (category, ncategory) != 0))) 1024 continue; 1025 1026 if ((selector != NULL) && 1027 ((nselector == NULL) || (strcmp (selector, nselector) != 0))) 1028 continue; 1029 1030 VEC_safe_push (const_char_ptr, *symbol_names, symname); 1031 } 1032 1033 if (objc_csym == NULL) 1034 { 1035 objc_csym = obstack_alloc (&objfile->objfile_obstack, 1036 sizeof (*objc_csym)); 1037 *objc_csym = objfile_csym; 1038 set_objfile_data (objfile, objc_objfile_data, objc_csym); 1039 } 1040 else 1041 /* Count of ObjC methods in this objfile should be constant. */ 1042 gdb_assert (*objc_csym == objfile_csym); 1043 } 1044 } 1045 1046 /* Uniquify a VEC of strings. */ 1047 1048 static void 1049 uniquify_strings (VEC (const_char_ptr) **strings) 1050 { 1051 int ix; 1052 const char *elem, *last = NULL; 1053 int out; 1054 1055 qsort (VEC_address (const_char_ptr, *strings), 1056 VEC_length (const_char_ptr, *strings), 1057 sizeof (const_char_ptr), 1058 compare_strings); 1059 out = 0; 1060 for (ix = 0; VEC_iterate (const_char_ptr, *strings, ix, elem); ++ix) 1061 { 1062 if (last == NULL || strcmp (last, elem) != 0) 1063 { 1064 /* Keep ELEM. */ 1065 VEC_replace (const_char_ptr, *strings, out, elem); 1066 ++out; 1067 } 1068 last = elem; 1069 } 1070 VEC_truncate (const_char_ptr, *strings, out); 1071 } 1072 1073 /* 1074 * Function: find_imps (char *selector, struct symbol **sym_arr) 1075 * 1076 * Input: a string representing a selector 1077 * a pointer to an array of symbol pointers 1078 * possibly a pointer to a symbol found by the caller. 1079 * 1080 * Output: number of methods that implement that selector. Side 1081 * effects: The array of symbol pointers is filled with matching syms. 1082 * 1083 * By analogy with function "find_methods" (symtab.c), builds a list 1084 * of symbols matching the ambiguous input, so that "decode_line_2" 1085 * (symtab.c) can list them and ask the user to choose one or more. 1086 * In this case the matches are objective c methods 1087 * ("implementations") matching an objective c selector. 1088 * 1089 * Note that it is possible for a normal (c-style) function to have 1090 * the same name as an objective c selector. To prevent the selector 1091 * from eclipsing the function, we allow the caller (decode_line_1) to 1092 * search for such a function first, and if it finds one, pass it in 1093 * to us. We will then integrate it into the list. We also search 1094 * for one here, among the minsyms. 1095 * 1096 * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be divided 1097 * into two parts: debuggable (struct symbol) syms, and 1098 * non_debuggable (struct minimal_symbol) syms. The debuggable 1099 * ones will come first, before NUM_DEBUGGABLE (which will thus 1100 * be the index of the first non-debuggable one). 1101 */ 1102 1103 char * 1104 find_imps (char *method, VEC (const_char_ptr) **symbol_names) 1105 { 1106 char type = '\0'; 1107 char *class = NULL; 1108 char *category = NULL; 1109 char *selector = NULL; 1110 1111 char *buf = NULL; 1112 char *tmp = NULL; 1113 1114 int selector_case = 0; 1115 1116 gdb_assert (symbol_names != NULL); 1117 1118 buf = (char *) alloca (strlen (method) + 1); 1119 strcpy (buf, method); 1120 tmp = parse_method (buf, &type, &class, &category, &selector); 1121 1122 if (tmp == NULL) 1123 { 1124 strcpy (buf, method); 1125 tmp = parse_selector (buf, &selector); 1126 1127 if (tmp == NULL) 1128 return NULL; 1129 1130 selector_case = 1; 1131 } 1132 1133 find_methods (type, class, category, selector, symbol_names); 1134 1135 /* If we hit the "selector" case, and we found some methods, then 1136 add the selector itself as a symbol, if it exists. */ 1137 if (selector_case && !VEC_empty (const_char_ptr, *symbol_names)) 1138 { 1139 struct symbol *sym = lookup_symbol (selector, NULL, VAR_DOMAIN, 0); 1140 1141 if (sym != NULL) 1142 VEC_safe_push (const_char_ptr, *symbol_names, 1143 SYMBOL_NATURAL_NAME (sym)); 1144 else 1145 { 1146 struct minimal_symbol *msym = lookup_minimal_symbol (selector, 0, 0); 1147 1148 if (msym != NULL) 1149 VEC_safe_push (const_char_ptr, *symbol_names, 1150 SYMBOL_NATURAL_NAME (msym)); 1151 } 1152 } 1153 1154 uniquify_strings (symbol_names); 1155 1156 return method + (tmp - buf); 1157 } 1158 1159 static void 1160 print_object_command (char *args, int from_tty) 1161 { 1162 struct value *object, *function, *description; 1163 CORE_ADDR string_addr, object_addr; 1164 int i = 0; 1165 gdb_byte c = 0; 1166 1167 if (!args || !*args) 1168 error ( 1169 "The 'print-object' command requires an argument (an Objective-C object)"); 1170 1171 { 1172 struct expression *expr = parse_expression (args); 1173 struct cleanup *old_chain = 1174 make_cleanup (free_current_contents, &expr); 1175 int pc = 0; 1176 1177 object = evaluate_subexp (builtin_type (expr->gdbarch)->builtin_data_ptr, 1178 expr, &pc, EVAL_NORMAL); 1179 do_cleanups (old_chain); 1180 } 1181 1182 /* Validate the address for sanity. */ 1183 object_addr = value_as_long (object); 1184 read_memory (object_addr, &c, 1); 1185 1186 function = find_function_in_inferior ("_NSPrintForDebugger", NULL); 1187 if (function == NULL) 1188 error (_("Unable to locate _NSPrintForDebugger in child process")); 1189 1190 description = call_function_by_hand (function, 1, &object); 1191 1192 string_addr = value_as_long (description); 1193 if (string_addr == 0) 1194 error (_("object returns null description")); 1195 1196 read_memory (string_addr + i++, &c, 1); 1197 if (c != 0) 1198 do 1199 { /* Read and print characters up to EOS. */ 1200 QUIT; 1201 printf_filtered ("%c", c); 1202 read_memory (string_addr + i++, &c, 1); 1203 } while (c != 0); 1204 else 1205 printf_filtered(_("<object returns empty description>")); 1206 printf_filtered ("\n"); 1207 } 1208 1209 /* The data structure 'methcalls' is used to detect method calls (thru 1210 * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.), 1211 * and ultimately find the method being called. 1212 */ 1213 1214 struct objc_methcall { 1215 char *name; 1216 /* Return instance method to be called. */ 1217 int (*stop_at) (CORE_ADDR, CORE_ADDR *); 1218 /* Start of pc range corresponding to method invocation. */ 1219 CORE_ADDR begin; 1220 /* End of pc range corresponding to method invocation. */ 1221 CORE_ADDR end; 1222 }; 1223 1224 static int resolve_msgsend (CORE_ADDR pc, CORE_ADDR *new_pc); 1225 static int resolve_msgsend_stret (CORE_ADDR pc, CORE_ADDR *new_pc); 1226 static int resolve_msgsend_super (CORE_ADDR pc, CORE_ADDR *new_pc); 1227 static int resolve_msgsend_super_stret (CORE_ADDR pc, CORE_ADDR *new_pc); 1228 1229 static struct objc_methcall methcalls[] = { 1230 { "_objc_msgSend", resolve_msgsend, 0, 0}, 1231 { "_objc_msgSend_stret", resolve_msgsend_stret, 0, 0}, 1232 { "_objc_msgSendSuper", resolve_msgsend_super, 0, 0}, 1233 { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret, 0, 0}, 1234 { "_objc_getClass", NULL, 0, 0}, 1235 { "_objc_getMetaClass", NULL, 0, 0} 1236 }; 1237 1238 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0])) 1239 1240 /* The following function, "find_objc_msgsend", fills in the data 1241 * structure "objc_msgs" by finding the addresses of each of the 1242 * (currently four) functions that it holds (of which objc_msgSend is 1243 * the first). This must be called each time symbols are loaded, in 1244 * case the functions have moved for some reason. 1245 */ 1246 1247 static void 1248 find_objc_msgsend (void) 1249 { 1250 unsigned int i; 1251 1252 for (i = 0; i < nmethcalls; i++) 1253 { 1254 struct minimal_symbol *func; 1255 1256 /* Try both with and without underscore. */ 1257 func = lookup_minimal_symbol (methcalls[i].name, NULL, NULL); 1258 if ((func == NULL) && (methcalls[i].name[0] == '_')) 1259 { 1260 func = lookup_minimal_symbol (methcalls[i].name + 1, NULL, NULL); 1261 } 1262 if (func == NULL) 1263 { 1264 methcalls[i].begin = 0; 1265 methcalls[i].end = 0; 1266 continue; 1267 } 1268 1269 methcalls[i].begin = SYMBOL_VALUE_ADDRESS (func); 1270 do { 1271 methcalls[i].end = SYMBOL_VALUE_ADDRESS (++func); 1272 } while (methcalls[i].begin == methcalls[i].end); 1273 } 1274 } 1275 1276 /* find_objc_msgcall (replaces pc_off_limits) 1277 * 1278 * ALL that this function now does is to determine whether the input 1279 * address ("pc") is the address of one of the Objective-C message 1280 * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and 1281 * if so, it returns the address of the method that will be called. 1282 * 1283 * The old function "pc_off_limits" used to do a lot of other things 1284 * in addition, such as detecting shared library jump stubs and 1285 * returning the address of the shlib function that would be called. 1286 * That functionality has been moved into the gdbarch_skip_trampoline_code and 1287 * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target- 1288 * dependent modules. 1289 */ 1290 1291 struct objc_submethod_helper_data { 1292 int (*f) (CORE_ADDR, CORE_ADDR *); 1293 CORE_ADDR pc; 1294 CORE_ADDR *new_pc; 1295 }; 1296 1297 static int 1298 find_objc_msgcall_submethod_helper (void * arg) 1299 { 1300 struct objc_submethod_helper_data *s = 1301 (struct objc_submethod_helper_data *) arg; 1302 1303 if (s->f (s->pc, s->new_pc) == 0) 1304 return 1; 1305 else 1306 return 0; 1307 } 1308 1309 static int 1310 find_objc_msgcall_submethod (int (*f) (CORE_ADDR, CORE_ADDR *), 1311 CORE_ADDR pc, 1312 CORE_ADDR *new_pc) 1313 { 1314 struct objc_submethod_helper_data s; 1315 1316 s.f = f; 1317 s.pc = pc; 1318 s.new_pc = new_pc; 1319 1320 if (catch_errors (find_objc_msgcall_submethod_helper, 1321 (void *) &s, 1322 "Unable to determine target of " 1323 "Objective-C method call (ignoring):\n", 1324 RETURN_MASK_ALL) == 0) 1325 return 1; 1326 else 1327 return 0; 1328 } 1329 1330 int 1331 find_objc_msgcall (CORE_ADDR pc, CORE_ADDR *new_pc) 1332 { 1333 unsigned int i; 1334 1335 find_objc_msgsend (); 1336 if (new_pc != NULL) 1337 { 1338 *new_pc = 0; 1339 } 1340 1341 for (i = 0; i < nmethcalls; i++) 1342 if ((pc >= methcalls[i].begin) && (pc < methcalls[i].end)) 1343 { 1344 if (methcalls[i].stop_at != NULL) 1345 return find_objc_msgcall_submethod (methcalls[i].stop_at, 1346 pc, new_pc); 1347 else 1348 return 0; 1349 } 1350 1351 return 0; 1352 } 1353 1354 /* -Wmissing-prototypes */ 1355 extern initialize_file_ftype _initialize_objc_language; 1356 1357 void 1358 _initialize_objc_language (void) 1359 { 1360 add_language (&objc_language_defn); 1361 add_info ("selectors", selectors_info, /* INFO SELECTORS command. */ 1362 _("All Objective-C selectors, or those matching REGEXP.")); 1363 add_info ("classes", classes_info, /* INFO CLASSES command. */ 1364 _("All Objective-C classes, or those matching REGEXP.")); 1365 add_com ("print-object", class_vars, print_object_command, 1366 _("Ask an Objective-C object to print itself.")); 1367 add_com_alias ("po", "print-object", class_vars, 1); 1368 } 1369 1370 static void 1371 read_objc_method (struct gdbarch *gdbarch, CORE_ADDR addr, 1372 struct objc_method *method) 1373 { 1374 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 1375 1376 method->name = read_memory_unsigned_integer (addr + 0, 4, byte_order); 1377 method->types = read_memory_unsigned_integer (addr + 4, 4, byte_order); 1378 method->imp = read_memory_unsigned_integer (addr + 8, 4, byte_order); 1379 } 1380 1381 static unsigned long 1382 read_objc_methlist_nmethods (struct gdbarch *gdbarch, CORE_ADDR addr) 1383 { 1384 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 1385 1386 return read_memory_unsigned_integer (addr + 4, 4, byte_order); 1387 } 1388 1389 static void 1390 read_objc_methlist_method (struct gdbarch *gdbarch, CORE_ADDR addr, 1391 unsigned long num, struct objc_method *method) 1392 { 1393 gdb_assert (num < read_objc_methlist_nmethods (gdbarch, addr)); 1394 read_objc_method (gdbarch, addr + 8 + (12 * num), method); 1395 } 1396 1397 static void 1398 read_objc_object (struct gdbarch *gdbarch, CORE_ADDR addr, 1399 struct objc_object *object) 1400 { 1401 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 1402 1403 object->isa = read_memory_unsigned_integer (addr, 4, byte_order); 1404 } 1405 1406 static void 1407 read_objc_super (struct gdbarch *gdbarch, CORE_ADDR addr, 1408 struct objc_super *super) 1409 { 1410 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 1411 1412 super->receiver = read_memory_unsigned_integer (addr, 4, byte_order); 1413 super->class = read_memory_unsigned_integer (addr + 4, 4, byte_order); 1414 }; 1415 1416 static void 1417 read_objc_class (struct gdbarch *gdbarch, CORE_ADDR addr, 1418 struct objc_class *class) 1419 { 1420 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 1421 1422 class->isa = read_memory_unsigned_integer (addr, 4, byte_order); 1423 class->super_class = read_memory_unsigned_integer (addr + 4, 4, byte_order); 1424 class->name = read_memory_unsigned_integer (addr + 8, 4, byte_order); 1425 class->version = read_memory_unsigned_integer (addr + 12, 4, byte_order); 1426 class->info = read_memory_unsigned_integer (addr + 16, 4, byte_order); 1427 class->instance_size = read_memory_unsigned_integer (addr + 18, 4, 1428 byte_order); 1429 class->ivars = read_memory_unsigned_integer (addr + 24, 4, byte_order); 1430 class->methods = read_memory_unsigned_integer (addr + 28, 4, byte_order); 1431 class->cache = read_memory_unsigned_integer (addr + 32, 4, byte_order); 1432 class->protocols = read_memory_unsigned_integer (addr + 36, 4, byte_order); 1433 } 1434 1435 static CORE_ADDR 1436 find_implementation_from_class (struct gdbarch *gdbarch, 1437 CORE_ADDR class, CORE_ADDR sel) 1438 { 1439 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 1440 CORE_ADDR subclass = class; 1441 1442 while (subclass != 0) 1443 { 1444 1445 struct objc_class class_str; 1446 unsigned mlistnum = 0; 1447 1448 read_objc_class (gdbarch, subclass, &class_str); 1449 1450 for (;;) 1451 { 1452 CORE_ADDR mlist; 1453 unsigned long nmethods; 1454 unsigned long i; 1455 1456 mlist = read_memory_unsigned_integer (class_str.methods + 1457 (4 * mlistnum), 1458 4, byte_order); 1459 if (mlist == 0) 1460 break; 1461 1462 nmethods = read_objc_methlist_nmethods (gdbarch, mlist); 1463 1464 for (i = 0; i < nmethods; i++) 1465 { 1466 struct objc_method meth_str; 1467 1468 read_objc_methlist_method (gdbarch, mlist, i, &meth_str); 1469 #if 0 1470 fprintf (stderr, 1471 "checking method 0x%lx against selector 0x%lx\n", 1472 meth_str.name, sel); 1473 #endif 1474 1475 if (meth_str.name == sel) 1476 /* FIXME: hppa arch was doing a pointer dereference 1477 here. There needs to be a better way to do that. */ 1478 return meth_str.imp; 1479 } 1480 mlistnum++; 1481 } 1482 subclass = class_str.super_class; 1483 } 1484 1485 return 0; 1486 } 1487 1488 static CORE_ADDR 1489 find_implementation (struct gdbarch *gdbarch, 1490 CORE_ADDR object, CORE_ADDR sel) 1491 { 1492 struct objc_object ostr; 1493 1494 if (object == 0) 1495 return 0; 1496 read_objc_object (gdbarch, object, &ostr); 1497 if (ostr.isa == 0) 1498 return 0; 1499 1500 return find_implementation_from_class (gdbarch, ostr.isa, sel); 1501 } 1502 1503 static int 1504 resolve_msgsend (CORE_ADDR pc, CORE_ADDR *new_pc) 1505 { 1506 struct frame_info *frame = get_current_frame (); 1507 struct gdbarch *gdbarch = get_frame_arch (frame); 1508 struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr; 1509 1510 CORE_ADDR object; 1511 CORE_ADDR sel; 1512 CORE_ADDR res; 1513 1514 object = gdbarch_fetch_pointer_argument (gdbarch, frame, 0, ptr_type); 1515 sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type); 1516 1517 res = find_implementation (gdbarch, object, sel); 1518 if (new_pc != 0) 1519 *new_pc = res; 1520 if (res == 0) 1521 return 1; 1522 return 0; 1523 } 1524 1525 static int 1526 resolve_msgsend_stret (CORE_ADDR pc, CORE_ADDR *new_pc) 1527 { 1528 struct frame_info *frame = get_current_frame (); 1529 struct gdbarch *gdbarch = get_frame_arch (frame); 1530 struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr; 1531 1532 CORE_ADDR object; 1533 CORE_ADDR sel; 1534 CORE_ADDR res; 1535 1536 object = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type); 1537 sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 2, ptr_type); 1538 1539 res = find_implementation (gdbarch, object, sel); 1540 if (new_pc != 0) 1541 *new_pc = res; 1542 if (res == 0) 1543 return 1; 1544 return 0; 1545 } 1546 1547 static int 1548 resolve_msgsend_super (CORE_ADDR pc, CORE_ADDR *new_pc) 1549 { 1550 struct frame_info *frame = get_current_frame (); 1551 struct gdbarch *gdbarch = get_frame_arch (frame); 1552 struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr; 1553 1554 struct objc_super sstr; 1555 1556 CORE_ADDR super; 1557 CORE_ADDR sel; 1558 CORE_ADDR res; 1559 1560 super = gdbarch_fetch_pointer_argument (gdbarch, frame, 0, ptr_type); 1561 sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type); 1562 1563 read_objc_super (gdbarch, super, &sstr); 1564 if (sstr.class == 0) 1565 return 0; 1566 1567 res = find_implementation_from_class (gdbarch, sstr.class, sel); 1568 if (new_pc != 0) 1569 *new_pc = res; 1570 if (res == 0) 1571 return 1; 1572 return 0; 1573 } 1574 1575 static int 1576 resolve_msgsend_super_stret (CORE_ADDR pc, CORE_ADDR *new_pc) 1577 { 1578 struct frame_info *frame = get_current_frame (); 1579 struct gdbarch *gdbarch = get_frame_arch (frame); 1580 struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr; 1581 1582 struct objc_super sstr; 1583 1584 CORE_ADDR super; 1585 CORE_ADDR sel; 1586 CORE_ADDR res; 1587 1588 super = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type); 1589 sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 2, ptr_type); 1590 1591 read_objc_super (gdbarch, super, &sstr); 1592 if (sstr.class == 0) 1593 return 0; 1594 1595 res = find_implementation_from_class (gdbarch, sstr.class, sel); 1596 if (new_pc != 0) 1597 *new_pc = res; 1598 if (res == 0) 1599 return 1; 1600 return 0; 1601 } 1602 1603 /* Provide a prototype to silence -Wmissing-prototypes. */ 1604 extern initialize_file_ftype _initialize_objc_lang; 1605 1606 void 1607 _initialize_objc_lang (void) 1608 { 1609 objc_objfile_data = register_objfile_data (); 1610 } 1611