contrib/gdb-7/gdb/objc-lang.c

   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 }