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