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