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   default_read_var_value,       /* la_read_var_value */
 528   objc_skip_trampoline,         /* Language specific skip_trampoline */
 529   "self",                       /* name_of_this */
 530   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
 531   basic_lookup_transparent_type,/* lookup_transparent_type */
 532   objc_demangle,                /* Language specific symbol demangler */
 533   NULL,                         /* Language specific
 534                                    class_name_from_physname */
 535   objc_op_print_tab,            /* Expression operators for printing */
 536   1,                            /* C-style arrays */
 537   0,                            /* String lower bound */
 538   default_word_break_characters,
 539   default_make_symbol_completion_list,
 540   c_language_arch_info,
 541   default_print_array_index,
 542   default_pass_by_reference,
 543   default_get_string,
 544   NULL,                         /* la_get_symbol_name_cmp */
 545   iterate_over_symbols,
 546   LANG_MAGIC
 547 };
 548
 549 /*
 550  * ObjC:
 551  * Following functions help construct Objective-C message calls.
 552  */
 553
 554 struct selname          /* For parsing Objective-C.  */
 555   {
 556     struct selname *next;
 557     char *msglist_sel;
 558     int msglist_len;
 559   };
 560
 561 static int msglist_len;
 562 static struct selname *selname_chain;
 563 static char *msglist_sel;
 564
 565 void
 566 start_msglist(void)
 567 {
 568   struct selname *new =
 569     (struct selname *) xmalloc (sizeof (struct selname));
 570
 571   new->next = selname_chain;
 572   new->msglist_len = msglist_len;
 573   new->msglist_sel = msglist_sel;
 574   msglist_len = 0;
 575   msglist_sel = (char *)xmalloc(1);
 576   *msglist_sel = 0;
 577   selname_chain = new;
 578 }
 579
 580 void
 581 add_msglist(struct stoken *str, int addcolon)
 582 {
 583   char *s, *p;
 584   int len, plen;
 585
 586   if (str == 0)                 /* Unnamed arg, or...  */
 587     {
 588       if (addcolon == 0)        /* variable number of args.  */
 589         {
 590           msglist_len++;
 591           return;
 592         }
 593       p = "";
 594       plen = 0;
 595     }
 596   else
 597     {
 598       p = str->ptr;
 599       plen = str->length;
 600     }
 601   len = plen + strlen(msglist_sel) + 2;
 602   s = (char *)xmalloc(len);
 603   strcpy(s, msglist_sel);
 604   strncat(s, p, plen);
 605   xfree(msglist_sel);
 606   msglist_sel = s;
 607   if (addcolon)
 608     {
 609       s[len-2] = ':';
 610       s[len-1] = 0;
 611       msglist_len++;
 612     }
 613   else
 614     s[len-2] = '\0';
 615 }
 616
 617 int
 618 end_msglist(void)
 619 {
 620   int val = msglist_len;
 621   struct selname *sel = selname_chain;
 622   char *p = msglist_sel;
 623   CORE_ADDR selid;
 624
 625   selname_chain = sel->next;
 626   msglist_len = sel->msglist_len;
 627   msglist_sel = sel->msglist_sel;
 628   selid = lookup_child_selector (parse_gdbarch, p);
 629   if (!selid)
 630     error (_("Can't find selector \"%s\""), p);
 631   write_exp_elt_longcst (selid);
 632   xfree(p);
 633   write_exp_elt_longcst (val);  /* Number of args */
 634   xfree(sel);
 635
 636   return val;
 637 }
 638
 639 /*
 640  * Function: specialcmp (const char *a, const char *b)
 641  *
 642  * Special strcmp: treats ']' and ' ' as end-of-string.
 643  * Used for qsorting lists of objc methods (either by class or selector).
 644  */
 645
 646 static int
 647 specialcmp (const char *a, const char *b)
 648 {
 649   while (*a && *a != ' ' && *a != ']' && *b && *b != ' ' && *b != ']')
 650     {
 651       if (*a != *b)
 652         return *a - *b;
 653       a++, b++;
 654     }
 655   if (*a && *a != ' ' && *a != ']')
 656     return  1;          /* a is longer therefore greater.  */
 657   if (*b && *b != ' ' && *b != ']')
 658     return -1;          /* a is shorter therefore lesser.  */
 659   return    0;          /* a and b are identical.  */
 660 }
 661
 662 /*
 663  * Function: compare_selectors (const void *, const void *)
 664  *
 665  * Comparison function for use with qsort.  Arguments are symbols or
 666  * msymbols Compares selector part of objc method name alphabetically.
 667  */
 668
 669 static int
 670 compare_selectors (const void *a, const void *b)
 671 {
 672   const char *aname, *bname;
 673
 674   aname = SYMBOL_PRINT_NAME (*(struct symbol **) a);
 675   bname = SYMBOL_PRINT_NAME (*(struct symbol **) b);
 676   if (aname == NULL || bname == NULL)
 677     error (_("internal: compare_selectors(1)"));
 678
 679   aname = strchr(aname, ' ');
 680   bname = strchr(bname, ' ');
 681   if (aname == NULL || bname == NULL)
 682     error (_("internal: compare_selectors(2)"));
 683
 684   return specialcmp (aname+1, bname+1);
 685 }
 686
 687 /*
 688  * Function: selectors_info (regexp, from_tty)
 689  *
 690  * Implements the "Info selectors" command.  Takes an optional regexp
 691  * arg.  Lists all objective c selectors that match the regexp.  Works
 692  * by grepping thru all symbols for objective c methods.  Output list
 693  * is sorted and uniqued.
 694  */
 695
 696 static void
 697 selectors_info (char *regexp, int from_tty)
 698 {
 699   struct objfile        *objfile;
 700   struct minimal_symbol *msymbol;
 701   const char            *name;
 702   char                  *val;
 703   int                    matches = 0;
 704   int                    maxlen  = 0;
 705   int                    ix;
 706   char                   myregexp[2048];
 707   char                   asel[256];
 708   struct symbol        **sym_arr;
 709   int                    plusminus = 0;
 710
 711   if (regexp == NULL)
 712     strcpy(myregexp, ".*]");    /* Null input, match all objc methods.  */
 713   else
 714     {
 715       if (*regexp == '+' || *regexp == '-')
 716         { /* User wants only class methods or only instance methods.  */
 717           plusminus = *regexp++;
 718           while (*regexp == ' ' || *regexp == '\t')
 719             regexp++;
 720         }
 721       if (*regexp == '\0')
 722         strcpy(myregexp, ".*]");
 723       else
 724         {
 725           /* Allow a few extra bytes because of the strcat below.  */
 726           if (sizeof (myregexp) < strlen (regexp) + 4)
 727             error (_("Regexp is too long: %s"), regexp);
 728           strcpy(myregexp, regexp);
 729           if (myregexp[strlen(myregexp) - 1] == '$') /* end of selector */
 730             myregexp[strlen(myregexp) - 1] = ']';    /* end of method name */
 731           else
 732             strcat(myregexp, ".*]");
 733         }
 734     }
 735
 736   if (regexp != NULL)
 737     {
 738       val = re_comp (myregexp);
 739       if (val != 0)
 740         error (_("Invalid regexp (%s): %s"), val, regexp);
 741     }
 742
 743   /* First time thru is JUST to get max length and count.  */
 744   ALL_MSYMBOLS (objfile, msymbol)
 745     {
 746       QUIT;
 747       name = SYMBOL_NATURAL_NAME (msymbol);
 748       if (name
 749           && (name[0] == '-' || name[0] == '+')
 750           && name[1] == '[')            /* Got a method name.  */
 751         {
 752           /* Filter for class/instance methods.  */
 753           if (plusminus && name[0] != plusminus)
 754             continue;
 755           /* Find selector part.  */
 756           name = (char *) strchr (name+2, ' ');
 757           if (name == NULL)
 758             {
 759               complaint (&symfile_complaints,
 760                          _("Bad method name '%s'"),
 761                          SYMBOL_NATURAL_NAME (msymbol));
 762               continue;
 763             }
 764           if (regexp == NULL || re_exec(++name) != 0)
 765             {
 766               const char *mystart = name;
 767               const char *myend   = strchr (mystart, ']');
 768
 769               if (myend && (myend - mystart > maxlen))
 770                 maxlen = myend - mystart;       /* Get longest selector.  */
 771               matches++;
 772             }
 773         }
 774     }
 775   if (matches)
 776     {
 777       printf_filtered (_("Selectors matching \"%s\":\n\n"),
 778                        regexp ? regexp : "*");
 779
 780       sym_arr = alloca (matches * sizeof (struct symbol *));
 781       matches = 0;
 782       ALL_MSYMBOLS (objfile, msymbol)
 783         {
 784           QUIT;
 785           name = SYMBOL_NATURAL_NAME (msymbol);
 786           if (name &&
 787              (name[0] == '-' || name[0] == '+') &&
 788               name[1] == '[')           /* Got a method name.  */
 789             {
 790               /* Filter for class/instance methods.  */
 791               if (plusminus && name[0] != plusminus)
 792                 continue;
 793               /* Find selector part.  */
 794               name = (char *) strchr(name+2, ' ');
 795               if (regexp == NULL || re_exec(++name) != 0)
 796                 sym_arr[matches++] = (struct symbol *) msymbol;
 797             }
 798         }
 799
 800       qsort (sym_arr, matches, sizeof (struct minimal_symbol *),
 801              compare_selectors);
 802       /* Prevent compare on first iteration.  */
 803       asel[0] = 0;
 804       for (ix = 0; ix < matches; ix++)  /* Now do the output.  */
 805         {
 806           char *p = asel;
 807
 808           QUIT;
 809           name = SYMBOL_NATURAL_NAME (sym_arr[ix]);
 810           name = strchr (name, ' ') + 1;
 811           if (p[0] && specialcmp(name, p) == 0)
 812             continue;           /* Seen this one already (not unique).  */
 813
 814           /* Copy selector part.  */
 815           while (*name && *name != ']')
 816             *p++ = *name++;
 817           *p++ = '\0';
 818           /* Print in columns.  */
 819           puts_filtered_tabular(asel, maxlen + 1, 0);
 820         }
 821       begin_line();
 822     }
 823   else
 824     printf_filtered (_("No selectors matching \"%s\"\n"),
 825                      regexp ? regexp : "*");
 826 }
 827
 828 /*
 829  * Function: compare_classes (const void *, const void *)
 830  *
 831  * Comparison function for use with qsort.  Arguments are symbols or
 832  * msymbols Compares class part of objc method name alphabetically.
 833  */
 834
 835 static int
 836 compare_classes (const void *a, const void *b)
 837 {
 838   const char *aname, *bname;
 839
 840   aname = SYMBOL_PRINT_NAME (*(struct symbol **) a);
 841   bname = SYMBOL_PRINT_NAME (*(struct symbol **) b);
 842   if (aname == NULL || bname == NULL)
 843     error (_("internal: compare_classes(1)"));
 844
 845   return specialcmp (aname+1, bname+1);
 846 }
 847
 848 /*
 849  * Function: classes_info(regexp, from_tty)
 850  *
 851  * Implements the "info classes" command for objective c classes.
 852  * Lists all objective c classes that match the optional regexp.
 853  * Works by grepping thru the list of objective c methods.  List will
 854  * be sorted and uniqued (since one class may have many methods).
 855  * BUGS: will not list a class that has no methods.
 856  */
 857
 858 static void
 859 classes_info (char *regexp, int from_tty)
 860 {
 861   struct objfile        *objfile;
 862   struct minimal_symbol *msymbol;
 863   const char            *name;
 864   char                  *val;
 865   int                    matches = 0;
 866   int                    maxlen  = 0;
 867   int                    ix;
 868   char                   myregexp[2048];
 869   char                   aclass[256];
 870   struct symbol        **sym_arr;
 871
 872   if (regexp == NULL)
 873     strcpy(myregexp, ".* ");    /* Null input: match all objc classes.  */
 874   else
 875     {
 876       /* Allow a few extra bytes because of the strcat below.  */
 877       if (sizeof (myregexp) < strlen (regexp) + 4)
 878         error (_("Regexp is too long: %s"), regexp);
 879       strcpy(myregexp, regexp);
 880       if (myregexp[strlen(myregexp) - 1] == '$')
 881         /* In the method name, the end of the class name is marked by ' '.  */
 882         myregexp[strlen(myregexp) - 1] = ' ';
 883       else
 884         strcat(myregexp, ".* ");
 885     }
 886
 887   if (regexp != NULL)
 888     {
 889       val = re_comp (myregexp);
 890       if (val != 0)
 891         error (_("Invalid regexp (%s): %s"), val, regexp);
 892     }
 893
 894   /* First time thru is JUST to get max length and count.  */
 895   ALL_MSYMBOLS (objfile, msymbol)
 896     {
 897       QUIT;
 898       name = SYMBOL_NATURAL_NAME (msymbol);
 899       if (name &&
 900          (name[0] == '-' || name[0] == '+') &&
 901           name[1] == '[')                       /* Got a method name.  */
 902         if (regexp == NULL || re_exec(name+2) != 0)
 903           {
 904             /* Compute length of classname part.  */
 905             const char *mystart = name + 2;
 906             const char *myend   = strchr (mystart, ' ');
 907
 908             if (myend && (myend - mystart > maxlen))
 909               maxlen = myend - mystart;
 910             matches++;
 911           }
 912     }
 913   if (matches)
 914     {
 915       printf_filtered (_("Classes matching \"%s\":\n\n"),
 916                        regexp ? regexp : "*");
 917       sym_arr = alloca (matches * sizeof (struct symbol *));
 918       matches = 0;
 919       ALL_MSYMBOLS (objfile, msymbol)
 920         {
 921           QUIT;
 922           name = SYMBOL_NATURAL_NAME (msymbol);
 923           if (name &&
 924              (name[0] == '-' || name[0] == '+') &&
 925               name[1] == '[')                   /* Got a method name.  */
 926             if (regexp == NULL || re_exec(name+2) != 0)
 927                 sym_arr[matches++] = (struct symbol *) msymbol;
 928         }
 929
 930       qsort (sym_arr, matches, sizeof (struct minimal_symbol *),
 931              compare_classes);
 932       /* Prevent compare on first iteration.  */
 933       aclass[0] = 0;
 934       for (ix = 0; ix < matches; ix++)  /* Now do the output.  */
 935         {
 936           char *p = aclass;
 937
 938           QUIT;
 939           name = SYMBOL_NATURAL_NAME (sym_arr[ix]);
 940           name += 2;
 941           if (p[0] && specialcmp(name, p) == 0)
 942             continue;   /* Seen this one already (not unique).  */
 943
 944           /* Copy class part of method name.  */
 945           while (*name && *name != ' ')
 946             *p++ = *name++;
 947           *p++ = '\0';
 948           /* Print in columns.  */
 949           puts_filtered_tabular(aclass, maxlen + 1, 0);
 950         }
 951       begin_line();
 952     }
 953   else
 954     printf_filtered (_("No classes matching \"%s\"\n"), regexp ? regexp : "*");
 955 }
 956
 957 static char *
 958 parse_selector (char *method, char **selector)
 959 {
 960   char *s1 = NULL;
 961   char *s2 = NULL;
 962   int found_quote = 0;
 963
 964   char *nselector = NULL;
 965
 966   gdb_assert (selector != NULL);
 967
 968   s1 = method;
 969
 970   while (isspace (*s1))
 971     s1++;
 972   if (*s1 == '\'')
 973     {
 974       found_quote = 1;
 975       s1++;
 976     }
 977   while (isspace (*s1))
 978     s1++;
 979
 980   nselector = s1;
 981   s2 = s1;
 982
 983   for (;;)
 984     {
 985       if (isalnum (*s2) || (*s2 == '_') || (*s2 == ':'))
 986         *s1++ = *s2;
 987       else if (isspace (*s2))
 988         ;
 989       else if ((*s2 == '\0') || (*s2 == '\''))
 990         break;
 991       else
 992         return NULL;
 993       s2++;
 994     }
 995   *s1++ = '\0';
 996
 997   while (isspace (*s2))
 998     s2++;
 999   if (found_quote)
1000     {
1001       if (*s2 == '\'')
1002         s2++;
1003       while (isspace (*s2))
1004         s2++;
1005     }
1006
1007   if (selector != NULL)
1008     *selector = nselector;
1009
1010   return s2;
1011 }
1012
1013 static char *
1014 parse_method (char *method, char *type, char **class,
1015               char **category, char **selector)
1016 {
1017   char *s1 = NULL;
1018   char *s2 = NULL;
1019   int found_quote = 0;
1020
1021   char ntype = '\0';
1022   char *nclass = NULL;
1023   char *ncategory = NULL;
1024   char *nselector = NULL;
1025
1026   gdb_assert (type != NULL);
1027   gdb_assert (class != NULL);
1028   gdb_assert (category != NULL);
1029   gdb_assert (selector != NULL);
1030
1031   s1 = method;
1032
1033   while (isspace (*s1))
1034     s1++;
1035   if (*s1 == '\'')
1036     {
1037       found_quote = 1;
1038       s1++;
1039     }
1040   while (isspace (*s1))
1041     s1++;
1042
1043   if ((s1[0] == '+') || (s1[0] == '-'))
1044     ntype = *s1++;
1045
1046   while (isspace (*s1))
1047     s1++;
1048
1049   if (*s1 != '[')
1050     return NULL;
1051   s1++;
1052
1053   nclass = s1;
1054   while (isalnum (*s1) || (*s1 == '_'))
1055     s1++;
1056
1057   s2 = s1;
1058   while (isspace (*s2))
1059     s2++;
1060
1061   if (*s2 == '(')
1062     {
1063       s2++;
1064       while (isspace (*s2))
1065         s2++;
1066       ncategory = s2;
1067       while (isalnum (*s2) || (*s2 == '_'))
1068         s2++;
1069       *s2++ = '\0';
1070     }
1071
1072   /* Truncate the class name now that we're not using the open paren.  */
1073   *s1++ = '\0';
1074
1075   nselector = s2;
1076   s1 = s2;
1077
1078   for (;;)
1079     {
1080       if (isalnum (*s2) || (*s2 == '_') || (*s2 == ':'))
1081         *s1++ = *s2;
1082       else if (isspace (*s2))
1083         ;
1084       else if (*s2 == ']')
1085         break;
1086       else
1087         return NULL;
1088       s2++;
1089     }
1090   *s1++ = '\0';
1091   s2++;
1092
1093   while (isspace (*s2))
1094     s2++;
1095   if (found_quote)
1096     {
1097       if (*s2 != '\'')
1098         return NULL;
1099       s2++;
1100       while (isspace (*s2))
1101         s2++;
1102     }
1103
1104   if (type != NULL)
1105     *type = ntype;
1106   if (class != NULL)
1107     *class = nclass;
1108   if (category != NULL)
1109     *category = ncategory;
1110   if (selector != NULL)
1111     *selector = nselector;
1112
1113   return s2;
1114 }
1115
1116 static void
1117 find_methods (char type, const char *class, const char *category,
1118               const char *selector,
1119               VEC (const_char_ptr) **symbol_names)
1120 {
1121   struct objfile *objfile = NULL;
1122
1123   const char *symname = NULL;
1124
1125   char ntype = '\0';
1126   char *nclass = NULL;
1127   char *ncategory = NULL;
1128   char *nselector = NULL;
1129
1130   static char *tmp = NULL;
1131   static unsigned int tmplen = 0;
1132
1133   gdb_assert (symbol_names != NULL);
1134
1135   ALL_OBJFILES (objfile)
1136     {
1137       unsigned int *objc_csym;
1138       struct minimal_symbol *msymbol = NULL;
1139
1140       /* The objfile_csym variable counts the number of ObjC methods
1141          that this objfile defines.  We save that count as a private
1142          objfile data.  If we have already determined that this objfile
1143          provides no ObjC methods, we can skip it entirely.  */
1144
1145       unsigned int objfile_csym = 0;
1146
1147       objc_csym = objfile_data (objfile, objc_objfile_data);
1148       if (objc_csym != NULL && *objc_csym == 0)
1149         /* There are no ObjC symbols in this objfile.  Skip it entirely.  */
1150         continue;
1151
1152       ALL_OBJFILE_MSYMBOLS (objfile, msymbol)
1153         {
1154           struct gdbarch *gdbarch = get_objfile_arch (objfile);
1155
1156           QUIT;
1157
1158           /* Check the symbol name first as this can be done entirely without
1159              sending any query to the target.  */
1160           symname = SYMBOL_NATURAL_NAME (msymbol);
1161           if (symname == NULL)
1162             continue;
1163
1164           if ((symname[0] != '-' && symname[0] != '+') || (symname[1] != '['))
1165             /* Not a method name.  */
1166             continue;
1167
1168           objfile_csym++;
1169
1170           /* Now that thinks are a bit sane, clean up the symname.  */
1171           while ((strlen (symname) + 1) >= tmplen)
1172             {
1173               tmplen = (tmplen == 0) ? 1024 : tmplen * 2;
1174               tmp = xrealloc (tmp, tmplen);
1175             }
1176           strcpy (tmp, symname);
1177
1178           if (parse_method (tmp, &ntype, &nclass,
1179                             &ncategory, &nselector) == NULL)
1180             continue;
1181
1182           if ((type != '\0') && (ntype != type))
1183             continue;
1184
1185           if ((class != NULL)
1186               && ((nclass == NULL) || (strcmp (class, nclass) != 0)))
1187             continue;
1188
1189           if ((category != NULL) &&
1190               ((ncategory == NULL) || (strcmp (category, ncategory) != 0)))
1191             continue;
1192
1193           if ((selector != NULL) &&
1194               ((nselector == NULL) || (strcmp (selector, nselector) != 0)))
1195             continue;
1196
1197           VEC_safe_push (const_char_ptr, *symbol_names, symname);
1198         }
1199
1200       if (objc_csym == NULL)
1201         {
1202           objc_csym = obstack_alloc (&objfile->objfile_obstack,
1203                                      sizeof (*objc_csym));
1204           *objc_csym = objfile_csym;
1205           set_objfile_data (objfile, objc_objfile_data, objc_csym);
1206         }
1207       else
1208         /* Count of ObjC methods in this objfile should be constant.  */
1209         gdb_assert (*objc_csym == objfile_csym);
1210     }
1211 }
1212
1213 /* Uniquify a VEC of strings.  */
1214
1215 static void
1216 uniquify_strings (VEC (const_char_ptr) **strings)
1217 {
1218   int ix;
1219   const char *elem, *last = NULL;
1220   int out;
1221
1222   qsort (VEC_address (const_char_ptr, *strings),
1223          VEC_length (const_char_ptr, *strings),
1224          sizeof (const_char_ptr),
1225          compare_strings);
1226   out = 0;
1227   for (ix = 0; VEC_iterate (const_char_ptr, *strings, ix, elem); ++ix)
1228     {
1229       if (last == NULL || strcmp (last, elem) != 0)
1230         {
1231           /* Keep ELEM.  */
1232           VEC_replace (const_char_ptr, *strings, out, elem);
1233           ++out;
1234         }
1235       last = elem;
1236     }
1237   VEC_truncate (const_char_ptr, *strings, out);
1238 }
1239
1240 /*
1241  * Function: find_imps (char *selector, struct symbol **sym_arr)
1242  *
1243  * Input:  a string representing a selector
1244  *         a pointer to an array of symbol pointers
1245  *         possibly a pointer to a symbol found by the caller.
1246  *
1247  * Output: number of methods that implement that selector.  Side
1248  * effects: The array of symbol pointers is filled with matching syms.
1249  *
1250  * By analogy with function "find_methods" (symtab.c), builds a list
1251  * of symbols matching the ambiguous input, so that "decode_line_2"
1252  * (symtab.c) can list them and ask the user to choose one or more.
1253  * In this case the matches are objective c methods
1254  * ("implementations") matching an objective c selector.
1255  *
1256  * Note that it is possible for a normal (c-style) function to have
1257  * the same name as an objective c selector.  To prevent the selector
1258  * from eclipsing the function, we allow the caller (decode_line_1) to
1259  * search for such a function first, and if it finds one, pass it in
1260  * to us.  We will then integrate it into the list.  We also search
1261  * for one here, among the minsyms.
1262  *
1263  * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be divided
1264  *       into two parts: debuggable (struct symbol) syms, and
1265  *       non_debuggable (struct minimal_symbol) syms.  The debuggable
1266  *       ones will come first, before NUM_DEBUGGABLE (which will thus
1267  *       be the index of the first non-debuggable one).
1268  */
1269
1270 char *
1271 find_imps (char *method, VEC (const_char_ptr) **symbol_names)
1272 {
1273   char type = '\0';
1274   char *class = NULL;
1275   char *category = NULL;
1276   char *selector = NULL;
1277
1278   char *buf = NULL;
1279   char *tmp = NULL;
1280
1281   int selector_case = 0;
1282
1283   gdb_assert (symbol_names != NULL);
1284
1285   buf = (char *) alloca (strlen (method) + 1);
1286   strcpy (buf, method);
1287   tmp = parse_method (buf, &type, &class, &category, &selector);
1288
1289   if (tmp == NULL)
1290     {
1291       strcpy (buf, method);
1292       tmp = parse_selector (buf, &selector);
1293
1294       if (tmp == NULL)
1295         return NULL;
1296
1297       selector_case = 1;
1298     }
1299
1300   find_methods (type, class, category, selector, symbol_names);
1301
1302   /* If we hit the "selector" case, and we found some methods, then
1303      add the selector itself as a symbol, if it exists.  */
1304   if (selector_case && !VEC_empty (const_char_ptr, *symbol_names))
1305     {
1306       struct symbol *sym = lookup_symbol (selector, NULL, VAR_DOMAIN, 0);
1307
1308       if (sym != NULL)
1309         VEC_safe_push (const_char_ptr, *symbol_names,
1310                        SYMBOL_NATURAL_NAME (sym));
1311       else
1312         {
1313           struct minimal_symbol *msym = lookup_minimal_symbol (selector, 0, 0);
1314
1315           if (msym != NULL)
1316             VEC_safe_push (const_char_ptr, *symbol_names,
1317                            SYMBOL_NATURAL_NAME (msym));
1318         }
1319     }
1320
1321   uniquify_strings (symbol_names);
1322
1323   return method + (tmp - buf);
1324 }
1325
1326 static void
1327 print_object_command (char *args, int from_tty)
1328 {
1329   struct value *object, *function, *description;
1330   CORE_ADDR string_addr, object_addr;
1331   int i = 0;
1332   gdb_byte c = 0;
1333
1334   if (!args || !*args)
1335     error (
1336 "The 'print-object' command requires an argument (an Objective-C object)");
1337
1338   {
1339     struct expression *expr = parse_expression (args);
1340     struct cleanup *old_chain =
1341       make_cleanup (free_current_contents, &expr);
1342     int pc = 0;
1343
1344     object = evaluate_subexp (builtin_type (expr->gdbarch)->builtin_data_ptr,
1345                               expr, &pc, EVAL_NORMAL);
1346     do_cleanups (old_chain);
1347   }
1348
1349   /* Validate the address for sanity.  */
1350   object_addr = value_as_long (object);
1351   read_memory (object_addr, &c, 1);
1352
1353   function = find_function_in_inferior ("_NSPrintForDebugger", NULL);
1354   if (function == NULL)
1355     error (_("Unable to locate _NSPrintForDebugger in child process"));
1356
1357   description = call_function_by_hand (function, 1, &object);
1358
1359   string_addr = value_as_long (description);
1360   if (string_addr == 0)
1361     error (_("object returns null description"));
1362
1363   read_memory (string_addr + i++, &c, 1);
1364   if (c != 0)
1365     do
1366       { /* Read and print characters up to EOS.  */
1367         QUIT;
1368         printf_filtered ("%c", c);
1369         read_memory (string_addr + i++, &c, 1);
1370       } while (c != 0);
1371   else
1372     printf_filtered(_("<object returns empty description>"));
1373   printf_filtered ("\n");
1374 }
1375
1376 /* The data structure 'methcalls' is used to detect method calls (thru
1377  * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1378  * and ultimately find the method being called.
1379  */
1380
1381 struct objc_methcall {
1382   char *name;
1383  /* Return instance method to be called.  */
1384   int (*stop_at) (CORE_ADDR, CORE_ADDR *);
1385   /* Start of pc range corresponding to method invocation.  */
1386   CORE_ADDR begin;
1387   /* End of pc range corresponding to method invocation.  */
1388   CORE_ADDR end;
1389 };
1390
1391 static int resolve_msgsend (CORE_ADDR pc, CORE_ADDR *new_pc);
1392 static int resolve_msgsend_stret (CORE_ADDR pc, CORE_ADDR *new_pc);
1393 static int resolve_msgsend_super (CORE_ADDR pc, CORE_ADDR *new_pc);
1394 static int resolve_msgsend_super_stret (CORE_ADDR pc, CORE_ADDR *new_pc);
1395
1396 static struct objc_methcall methcalls[] = {
1397   { "_objc_msgSend", resolve_msgsend, 0, 0},
1398   { "_objc_msgSend_stret", resolve_msgsend_stret, 0, 0},
1399   { "_objc_msgSendSuper", resolve_msgsend_super, 0, 0},
1400   { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret, 0, 0},
1401   { "_objc_getClass", NULL, 0, 0},
1402   { "_objc_getMetaClass", NULL, 0, 0}
1403 };
1404
1405 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1406
1407 /* The following function, "find_objc_msgsend", fills in the data
1408  * structure "objc_msgs" by finding the addresses of each of the
1409  * (currently four) functions that it holds (of which objc_msgSend is
1410  * the first).  This must be called each time symbols are loaded, in
1411  * case the functions have moved for some reason.
1412  */
1413
1414 static void
1415 find_objc_msgsend (void)
1416 {
1417   unsigned int i;
1418
1419   for (i = 0; i < nmethcalls; i++)
1420     {
1421       struct minimal_symbol *func;
1422
1423       /* Try both with and without underscore.  */
1424       func = lookup_minimal_symbol (methcalls[i].name, NULL, NULL);
1425       if ((func == NULL) && (methcalls[i].name[0] == '_'))
1426         {
1427           func = lookup_minimal_symbol (methcalls[i].name + 1, NULL, NULL);
1428         }
1429       if (func == NULL)
1430         {
1431           methcalls[i].begin = 0;
1432           methcalls[i].end = 0;
1433           continue;
1434         }
1435
1436       methcalls[i].begin = SYMBOL_VALUE_ADDRESS (func);
1437       do {
1438         methcalls[i].end = SYMBOL_VALUE_ADDRESS (++func);
1439       } while (methcalls[i].begin == methcalls[i].end);
1440     }
1441 }
1442
1443 /* find_objc_msgcall (replaces pc_off_limits)
1444  *
1445  * ALL that this function now does is to determine whether the input
1446  * address ("pc") is the address of one of the Objective-C message
1447  * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1448  * if so, it returns the address of the method that will be called.
1449  *
1450  * The old function "pc_off_limits" used to do a lot of other things
1451  * in addition, such as detecting shared library jump stubs and
1452  * returning the address of the shlib function that would be called.
1453  * That functionality has been moved into the gdbarch_skip_trampoline_code and
1454  * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
1455  * dependent modules.
1456  */
1457
1458 struct objc_submethod_helper_data {
1459   int (*f) (CORE_ADDR, CORE_ADDR *);
1460   CORE_ADDR pc;
1461   CORE_ADDR *new_pc;
1462 };
1463
1464 static int
1465 find_objc_msgcall_submethod_helper (void * arg)
1466 {
1467   struct objc_submethod_helper_data *s =
1468     (struct objc_submethod_helper_data *) arg;
1469
1470   if (s->f (s->pc, s->new_pc) == 0)
1471     return 1;
1472   else
1473     return 0;
1474 }
1475
1476 static int
1477 find_objc_msgcall_submethod (int (*f) (CORE_ADDR, CORE_ADDR *),
1478                              CORE_ADDR pc,
1479                              CORE_ADDR *new_pc)
1480 {
1481   struct objc_submethod_helper_data s;
1482
1483   s.f = f;
1484   s.pc = pc;
1485   s.new_pc = new_pc;
1486
1487   if (catch_errors (find_objc_msgcall_submethod_helper,
1488                     (void *) &s,
1489                     "Unable to determine target of "
1490                     "Objective-C method call (ignoring):\n",
1491                     RETURN_MASK_ALL) == 0)
1492     return 1;
1493   else
1494     return 0;
1495 }
1496
1497 int
1498 find_objc_msgcall (CORE_ADDR pc, CORE_ADDR *new_pc)
1499 {
1500   unsigned int i;
1501
1502   find_objc_msgsend ();
1503   if (new_pc != NULL)
1504     {
1505       *new_pc = 0;
1506     }
1507
1508   for (i = 0; i < nmethcalls; i++)
1509     if ((pc >= methcalls[i].begin) && (pc < methcalls[i].end))
1510       {
1511         if (methcalls[i].stop_at != NULL)
1512           return find_objc_msgcall_submethod (methcalls[i].stop_at,
1513                                               pc, new_pc);
1514         else
1515           return 0;
1516       }
1517
1518   return 0;
1519 }
1520
1521 /* -Wmissing-prototypes */
1522 extern initialize_file_ftype _initialize_objc_language;
1523
1524 void
1525 _initialize_objc_language (void)
1526 {
1527   add_language (&objc_language_defn);
1528   add_info ("selectors", selectors_info,    /* INFO SELECTORS command.  */
1529             _("All Objective-C selectors, or those matching REGEXP."));
1530   add_info ("classes", classes_info,        /* INFO CLASSES   command.  */
1531             _("All Objective-C classes, or those matching REGEXP."));
1532   add_com ("print-object", class_vars, print_object_command,
1533            _("Ask an Objective-C object to print itself."));
1534   add_com_alias ("po", "print-object", class_vars, 1);
1535 }
1536
1537 static void
1538 read_objc_method (struct gdbarch *gdbarch, CORE_ADDR addr,
1539                   struct objc_method *method)
1540 {
1541   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1542
1543   method->name  = read_memory_unsigned_integer (addr + 0, 4, byte_order);
1544   method->types = read_memory_unsigned_integer (addr + 4, 4, byte_order);
1545   method->imp   = read_memory_unsigned_integer (addr + 8, 4, byte_order);
1546 }
1547
1548 static unsigned long
1549 read_objc_methlist_nmethods (struct gdbarch *gdbarch, CORE_ADDR addr)
1550 {
1551   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1552
1553   return read_memory_unsigned_integer (addr + 4, 4, byte_order);
1554 }
1555
1556 static void
1557 read_objc_methlist_method (struct gdbarch *gdbarch, CORE_ADDR addr,
1558                            unsigned long num, struct objc_method *method)
1559 {
1560   gdb_assert (num < read_objc_methlist_nmethods (gdbarch, addr));
1561   read_objc_method (gdbarch, addr + 8 + (12 * num), method);
1562 }
1563
1564 static void
1565 read_objc_object (struct gdbarch *gdbarch, CORE_ADDR addr,
1566                   struct objc_object *object)
1567 {
1568   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1569
1570   object->isa = read_memory_unsigned_integer (addr, 4, byte_order);
1571 }
1572
1573 static void
1574 read_objc_super (struct gdbarch *gdbarch, CORE_ADDR addr,
1575                  struct objc_super *super)
1576 {
1577   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1578
1579   super->receiver = read_memory_unsigned_integer (addr, 4, byte_order);
1580   super->class = read_memory_unsigned_integer (addr + 4, 4, byte_order);
1581 };
1582
1583 static void
1584 read_objc_class (struct gdbarch *gdbarch, CORE_ADDR addr,
1585                  struct objc_class *class)
1586 {
1587   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1588
1589   class->isa = read_memory_unsigned_integer (addr, 4, byte_order);
1590   class->super_class = read_memory_unsigned_integer (addr + 4, 4, byte_order);
1591   class->name = read_memory_unsigned_integer (addr + 8, 4, byte_order);
1592   class->version = read_memory_unsigned_integer (addr + 12, 4, byte_order);
1593   class->info = read_memory_unsigned_integer (addr + 16, 4, byte_order);
1594   class->instance_size = read_memory_unsigned_integer (addr + 18, 4,
1595                                                        byte_order);
1596   class->ivars = read_memory_unsigned_integer (addr + 24, 4, byte_order);
1597   class->methods = read_memory_unsigned_integer (addr + 28, 4, byte_order);
1598   class->cache = read_memory_unsigned_integer (addr + 32, 4, byte_order);
1599   class->protocols = read_memory_unsigned_integer (addr + 36, 4, byte_order);
1600 }
1601
1602 static CORE_ADDR
1603 find_implementation_from_class (struct gdbarch *gdbarch,
1604                                 CORE_ADDR class, CORE_ADDR sel)
1605 {
1606   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1607   CORE_ADDR subclass = class;
1608
1609   while (subclass != 0)
1610     {
1611
1612       struct objc_class class_str;
1613       unsigned mlistnum = 0;
1614
1615       read_objc_class (gdbarch, subclass, &class_str);
1616
1617       for (;;)
1618         {
1619           CORE_ADDR mlist;
1620           unsigned long nmethods;
1621           unsigned long i;
1622
1623           mlist = read_memory_unsigned_integer (class_str.methods +
1624                                                 (4 * mlistnum),
1625                                                 4, byte_order);
1626           if (mlist == 0)
1627             break;
1628
1629           nmethods = read_objc_methlist_nmethods (gdbarch, mlist);
1630
1631           for (i = 0; i < nmethods; i++)
1632             {
1633               struct objc_method meth_str;
1634
1635               read_objc_methlist_method (gdbarch, mlist, i, &meth_str);
1636 #if 0
1637               fprintf (stderr,
1638                        "checking method 0x%lx against selector 0x%lx\n",
1639                        meth_str.name, sel);
1640 #endif
1641
1642               if (meth_str.name == sel)
1643                 /* FIXME: hppa arch was doing a pointer dereference
1644                    here.  There needs to be a better way to do that.  */
1645                 return meth_str.imp;
1646             }
1647           mlistnum++;
1648         }
1649       subclass = class_str.super_class;
1650     }
1651
1652   return 0;
1653 }
1654
1655 static CORE_ADDR
1656 find_implementation (struct gdbarch *gdbarch,
1657                      CORE_ADDR object, CORE_ADDR sel)
1658 {
1659   struct objc_object ostr;
1660
1661   if (object == 0)
1662     return 0;
1663   read_objc_object (gdbarch, object, &ostr);
1664   if (ostr.isa == 0)
1665     return 0;
1666
1667   return find_implementation_from_class (gdbarch, ostr.isa, sel);
1668 }
1669
1670 static int
1671 resolve_msgsend (CORE_ADDR pc, CORE_ADDR *new_pc)
1672 {
1673   struct frame_info *frame = get_current_frame ();
1674   struct gdbarch *gdbarch = get_frame_arch (frame);
1675   struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1676
1677   CORE_ADDR object;
1678   CORE_ADDR sel;
1679   CORE_ADDR res;
1680
1681   object = gdbarch_fetch_pointer_argument (gdbarch, frame, 0, ptr_type);
1682   sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1683
1684   res = find_implementation (gdbarch, object, sel);
1685   if (new_pc != 0)
1686     *new_pc = res;
1687   if (res == 0)
1688     return 1;
1689   return 0;
1690 }
1691
1692 static int
1693 resolve_msgsend_stret (CORE_ADDR pc, CORE_ADDR *new_pc)
1694 {
1695   struct frame_info *frame = get_current_frame ();
1696   struct gdbarch *gdbarch = get_frame_arch (frame);
1697   struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1698
1699   CORE_ADDR object;
1700   CORE_ADDR sel;
1701   CORE_ADDR res;
1702
1703   object = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1704   sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 2, ptr_type);
1705
1706   res = find_implementation (gdbarch, object, sel);
1707   if (new_pc != 0)
1708     *new_pc = res;
1709   if (res == 0)
1710     return 1;
1711   return 0;
1712 }
1713
1714 static int
1715 resolve_msgsend_super (CORE_ADDR pc, CORE_ADDR *new_pc)
1716 {
1717   struct frame_info *frame = get_current_frame ();
1718   struct gdbarch *gdbarch = get_frame_arch (frame);
1719   struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1720
1721   struct objc_super sstr;
1722
1723   CORE_ADDR super;
1724   CORE_ADDR sel;
1725   CORE_ADDR res;
1726
1727   super = gdbarch_fetch_pointer_argument (gdbarch, frame, 0, ptr_type);
1728   sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1729
1730   read_objc_super (gdbarch, super, &sstr);
1731   if (sstr.class == 0)
1732     return 0;
1733
1734   res = find_implementation_from_class (gdbarch, sstr.class, sel);
1735   if (new_pc != 0)
1736     *new_pc = res;
1737   if (res == 0)
1738     return 1;
1739   return 0;
1740 }
1741
1742 static int
1743 resolve_msgsend_super_stret (CORE_ADDR pc, CORE_ADDR *new_pc)
1744 {
1745   struct frame_info *frame = get_current_frame ();
1746   struct gdbarch *gdbarch = get_frame_arch (frame);
1747   struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1748
1749   struct objc_super sstr;
1750
1751   CORE_ADDR super;
1752   CORE_ADDR sel;
1753   CORE_ADDR res;
1754
1755   super = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1756   sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 2, ptr_type);
1757
1758   read_objc_super (gdbarch, super, &sstr);
1759   if (sstr.class == 0)
1760     return 0;
1761
1762   res = find_implementation_from_class (gdbarch, sstr.class, sel);
1763   if (new_pc != 0)
1764     *new_pc = res;
1765   if (res == 0)
1766     return 1;
1767   return 0;
1768 }
1769
1770 /* Provide a prototype to silence -Wmissing-prototypes.  */
1771 extern initialize_file_ftype _initialize_objc_lang;
1772
1773 void
1774 _initialize_objc_lang (void)
1775 {
1776   objc_objfile_data = register_objfile_data ();
1777 }