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