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