gdb/objc-lang.c

   1 /* Objective-C language support routines for GDB, the GNU debugger.
   2
   3    Copyright (C) 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011
   4    Free Software Foundation, Inc.
   5
   6    Contributed by Apple Computer, Inc.
   7    Written by Michael Snyder.
   8
   9    This file is part of GDB.
  10
  11    This program is free software; you can redistribute it and/or modify
  12    it under the terms of the GNU General Public License as published by
  13    the Free Software Foundation; either version 3 of the License, or
  14    (at your option) any later version.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  23
  24 #include "defs.h"
  25 #include "symtab.h"
  26 #include "gdbtypes.h"
  27 #include "expression.h"
  28 #include "parser-defs.h"
  29 #include "language.h"
  30 #include "c-lang.h"
  31 #include "objc-lang.h"
  32 #include "exceptions.h"
  33 #include "complaints.h"
  34 #include "value.h"
  35 #include "symfile.h"
  36 #include "objfiles.h"
  37 #include "gdb_string.h"         /* for strchr */
  38 #include "target.h"             /* for target_has_execution */
  39 #include "gdbcore.h"
  40 #include "gdbcmd.h"
  41 #include "frame.h"
  42 #include "gdb_regex.h"
  43 #include "regcache.h"
  44 #include "block.h"
  45 #include "infcall.h"
  46 #include "valprint.h"
  47 #include "gdb_assert.h"
  48
  49 #include <ctype.h>
  50
  51 struct objc_object {
  52   CORE_ADDR isa;
  53 };
  54
  55 struct objc_class {
  56   CORE_ADDR isa;
  57   CORE_ADDR super_class;
  58   CORE_ADDR name;
  59   long version;
  60   long info;
  61   long instance_size;
  62   CORE_ADDR ivars;
  63   CORE_ADDR methods;
  64   CORE_ADDR cache;
  65   CORE_ADDR protocols;
  66 };
  67
  68 struct objc_super {
  69   CORE_ADDR receiver;
  70   CORE_ADDR class;
  71 };
  72
  73 struct objc_method {
  74   CORE_ADDR name;
  75   CORE_ADDR types;
  76   CORE_ADDR imp;
  77 };
  78
  79 static const struct objfile_data *objc_objfile_data;
  80
  81 /* Lookup a structure type named "struct NAME", visible in lexical
  82    block BLOCK.  If NOERR is nonzero, return zero if NAME is not
  83    suitably defined.  */
  84
  85 struct symbol *
  86 lookup_struct_typedef (char *name, struct block *block, int noerr)
  87 {
  88   struct symbol *sym;
  89
  90   sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
  91
  92   if (sym == NULL)
  93     {
  94       if (noerr)
  95         return 0;
  96       else
  97         error (_("No struct type named %s."), name);
  98     }
  99   if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
 100     {
 101       if (noerr)
 102         return 0;
 103       else
 104         error (_("This context has class, union or enum %s, not a struct."),
 105                name);
 106     }
 107   return sym;
 108 }
 109
 110 CORE_ADDR
 111 lookup_objc_class (struct gdbarch *gdbarch, char *classname)
 112 {
 113   struct type *char_type = builtin_type (gdbarch)->builtin_char;
 114   struct value * function, *classval;
 115
 116   if (! target_has_execution)
 117     {
 118       /* Can't call into inferior to lookup class.  */
 119       return 0;
 120     }
 121
 122   if (lookup_minimal_symbol("objc_lookUpClass", 0, 0))
 123     function = find_function_in_inferior("objc_lookUpClass", NULL);
 124   else if (lookup_minimal_symbol ("objc_lookup_class", 0, 0))
 125     function = find_function_in_inferior("objc_lookup_class", NULL);
 126   else
 127     {
 128       complaint (&symfile_complaints,
 129                  _("no way to lookup Objective-C classes"));
 130       return 0;
 131     }
 132
 133   classval = value_string (classname, strlen (classname) + 1, char_type);
 134   classval = value_coerce_array (classval);
 135   return (CORE_ADDR) value_as_long (call_function_by_hand (function,
 136                                                            1, &classval));
 137 }
 138
 139 CORE_ADDR
 140 lookup_child_selector (struct gdbarch *gdbarch, char *selname)
 141 {
 142   struct type *char_type = builtin_type (gdbarch)->builtin_char;
 143   struct value * function, *selstring;
 144
 145   if (! target_has_execution)
 146     {
 147       /* Can't call into inferior to lookup selector.  */
 148       return 0;
 149     }
 150
 151   if (lookup_minimal_symbol("sel_getUid", 0, 0))
 152     function = find_function_in_inferior("sel_getUid", NULL);
 153   else if (lookup_minimal_symbol ("sel_get_any_uid", 0, 0))
 154     function = find_function_in_inferior("sel_get_any_uid", NULL);
 155   else
 156     {
 157       complaint (&symfile_complaints,
 158                  _("no way to lookup Objective-C selectors"));
 159       return 0;
 160     }
 161
 162   selstring = value_coerce_array (value_string (selname,
 163                                                 strlen (selname) + 1,
 164                                                 char_type));
 165   return value_as_long (call_function_by_hand (function, 1, &selstring));
 166 }
 167
 168 struct value *
 169 value_nsstring (struct gdbarch *gdbarch, char *ptr, int len)
 170 {
 171   struct type *char_type = builtin_type (gdbarch)->builtin_char;
 172   struct value *stringValue[3];
 173   struct value *function, *nsstringValue;
 174   struct symbol *sym;
 175   struct type *type;
 176
 177   if (!target_has_execution)
 178     return 0;           /* Can't call into inferior to create NSString.  */
 179
 180   stringValue[2] = value_string(ptr, len, char_type);
 181   stringValue[2] = value_coerce_array(stringValue[2]);
 182   /* _NSNewStringFromCString replaces "istr" after Lantern2A.  */
 183   if (lookup_minimal_symbol("_NSNewStringFromCString", 0, 0))
 184     {
 185       function = find_function_in_inferior("_NSNewStringFromCString", NULL);
 186       nsstringValue = call_function_by_hand(function, 1, &stringValue[2]);
 187     }
 188   else if (lookup_minimal_symbol("istr", 0, 0))
 189     {
 190       function = find_function_in_inferior("istr", NULL);
 191       nsstringValue = call_function_by_hand(function, 1, &stringValue[2]);
 192     }
 193   else if (lookup_minimal_symbol("+[NSString stringWithCString:]", 0, 0))
 194     {
 195       function
 196         = find_function_in_inferior("+[NSString stringWithCString:]", NULL);
 197       type = builtin_type (gdbarch)->builtin_long;
 198
 199       stringValue[0] = value_from_longest
 200         (type, lookup_objc_class (gdbarch, "NSString"));
 201       stringValue[1] = value_from_longest
 202         (type, lookup_child_selector (gdbarch, "stringWithCString:"));
 203       nsstringValue = call_function_by_hand(function, 3, &stringValue[0]);
 204     }
 205   else
 206     error (_("NSString: internal error -- no way to create new NSString"));
 207
 208   sym = lookup_struct_typedef("NSString", 0, 1);
 209   if (sym == NULL)
 210     sym = lookup_struct_typedef("NXString", 0, 1);
 211   if (sym == NULL)
 212     type = builtin_type (gdbarch)->builtin_data_ptr;
 213   else
 214     type = lookup_pointer_type(SYMBOL_TYPE (sym));
 215
 216   deprecated_set_value_type (nsstringValue, type);
 217   return nsstringValue;
 218 }
 219
 220 /* Objective-C name demangling.  */
 221
 222 char *
 223 objc_demangle (const char *mangled, int options)
 224 {
 225   char *demangled, *cp;
 226
 227   if (mangled[0] == '_' &&
 228      (mangled[1] == 'i' || mangled[1] == 'c') &&
 229       mangled[2] == '_')
 230     {
 231       cp = demangled = xmalloc(strlen(mangled) + 2);
 232
 233       if (mangled[1] == 'i')
 234         *cp++ = '-';            /* for instance method */
 235       else
 236         *cp++ = '+';            /* for class    method */
 237
 238       *cp++ = '[';              /* opening left brace  */
 239       strcpy(cp, mangled+3);    /* Tack on the rest of the mangled name.  */
 240
 241       while (*cp && *cp == '_')
 242         cp++;                   /* Skip any initial underbars in class
 243                                    name.  */
 244
 245       cp = strchr(cp, '_');
 246       if (!cp)                  /* Find first non-initial underbar.  */
 247         {
 248           xfree(demangled);     /* not mangled name */
 249           return NULL;
 250         }
 251       if (cp[1] == '_')         /* Easy case: no category name.    */
 252         {
 253           *cp++ = ' ';          /* Replace two '_' with one ' '.   */
 254           strcpy(cp, mangled + (cp - demangled) + 2);
 255         }
 256       else
 257         {
 258           *cp++ = '(';          /* Less easy case: category name.  */
 259           cp = strchr(cp, '_');
 260           if (!cp)
 261             {
 262               xfree(demangled); /* not mangled name */
 263               return NULL;
 264             }
 265           *cp++ = ')';
 266           *cp++ = ' ';          /* Overwriting 1st char of method name...  */
 267           strcpy(cp, mangled + (cp - demangled));       /* Get it back.  */
 268         }
 269
 270       while (*cp && *cp == '_')
 271         cp++;                   /* Skip any initial underbars in
 272                                    method name.  */
 273
 274       for (; *cp; cp++)
 275         if (*cp == '_')
 276           *cp = ':';            /* Replace remaining '_' with ':'.  */
 277
 278       *cp++ = ']';              /* closing right brace */
 279       *cp++ = 0;                /* string terminator */
 280       return demangled;
 281     }
 282   else
 283     return NULL;        /* Not an objc mangled name.  */
 284 }
 285
 286 /* Print the character C on STREAM as part of the contents of a
 287    literal string whose delimiter is QUOTER.  Note that that format
 288    for printing characters and strings is language specific.  */
 289
 290 static void
 291 objc_emit_char (int c, struct type *type, struct ui_file *stream, int quoter)
 292 {
 293   c &= 0xFF;                    /* Avoid sign bit follies.  */
 294
 295   if (PRINT_LITERAL_FORM (c))
 296     {
 297       if (c == '\\' || c == quoter)
 298         {
 299           fputs_filtered ("\\", stream);
 300         }
 301       fprintf_filtered (stream, "%c", c);
 302     }
 303   else
 304     {
 305       switch (c)
 306         {
 307         case '\n':
 308           fputs_filtered ("\\n", stream);
 309           break;
 310         case '\b':
 311           fputs_filtered ("\\b", stream);
 312           break;
 313         case '\t':
 314           fputs_filtered ("\\t", stream);
 315           break;
 316         case '\f':
 317           fputs_filtered ("\\f", stream);
 318           break;
 319         case '\r':
 320           fputs_filtered ("\\r", stream);
 321           break;
 322         case '\033':
 323           fputs_filtered ("\\e", stream);
 324           break;
 325         case '\007':
 326           fputs_filtered ("\\a", stream);
 327           break;
 328         default:
 329           fprintf_filtered (stream, "\\%.3o", (unsigned int) c);
 330           break;
 331         }
 332     }
 333 }
 334
 335 static void
 336 objc_printchar (int c, struct type *type, struct ui_file *stream)
 337 {
 338   fputs_filtered ("'", stream);
 339   objc_emit_char (c, type, stream, '\'');
 340   fputs_filtered ("'", stream);
 341 }
 342
 343 /* Print the character string STRING, printing at most LENGTH
 344    characters.  Printing stops early if the number hits print_max;
 345    repeat counts are printed as appropriate.  Print ellipses at the
 346    end if we had to stop before printing LENGTH characters, or if
 347    FORCE_ELLIPSES.  */
 348
 349 static void
 350 objc_printstr (struct ui_file *stream, struct type *type,
 351                const gdb_byte *string, unsigned int length,
 352                const char *encoding, int force_ellipses,
 353                const struct value_print_options *options)
 354 {
 355   unsigned int i;
 356   unsigned int things_printed = 0;
 357   int in_quotes = 0;
 358   int need_comma = 0;
 359
 360   /* If the string was not truncated due to `set print elements', and
 361      the last byte of it is a null, we don't print that, in
 362      traditional C style.  */
 363   if ((!force_ellipses) && length > 0 && string[length-1] == '\0')
 364     length--;
 365
 366   if (length == 0)
 367     {
 368       fputs_filtered ("\"\"", stream);
 369       return;
 370     }
 371
 372   for (i = 0; i < length && things_printed < options->print_max; ++i)
 373     {
 374       /* Position of the character we are examining to see whether it
 375          is repeated.  */
 376       unsigned int rep1;
 377       /* Number of repetitions we have detected so far.  */
 378       unsigned int reps;
 379
 380       QUIT;
 381
 382       if (need_comma)
 383         {
 384           fputs_filtered (", ", stream);
 385           need_comma = 0;
 386         }
 387
 388       rep1 = i + 1;
 389       reps = 1;
 390       while (rep1 < length && string[rep1] == string[i])
 391         {
 392           ++rep1;
 393           ++reps;
 394         }
 395
 396       if (reps > options->repeat_count_threshold)
 397         {
 398           if (in_quotes)
 399             {
 400               if (options->inspect_it)
 401                 fputs_filtered ("\\\", ", stream);
 402               else
 403                 fputs_filtered ("\", ", stream);
 404               in_quotes = 0;
 405             }
 406           objc_printchar (string[i], type, stream);
 407           fprintf_filtered (stream, " <repeats %u times>", reps);
 408           i = rep1 - 1;
 409           things_printed += options->repeat_count_threshold;
 410           need_comma = 1;
 411         }
 412       else
 413         {
 414           if (!in_quotes)
 415             {
 416               if (options->inspect_it)
 417                 fputs_filtered ("\\\"", stream);
 418               else
 419                 fputs_filtered ("\"", stream);
 420               in_quotes = 1;
 421             }
 422           objc_emit_char (string[i], type, stream, '"');
 423           ++things_printed;
 424         }
 425     }
 426
 427   /* Terminate the quotes if necessary.  */
 428   if (in_quotes)
 429     {
 430       if (options->inspect_it)
 431         fputs_filtered ("\\\"", stream);
 432       else
 433         fputs_filtered ("\"", stream);
 434     }
 435
 436   if (force_ellipses || i < length)
 437     fputs_filtered ("...", stream);
 438 }
 439
 440 /* Determine if we are currently in the Objective-C dispatch function.
 441    If so, get the address of the method function that the dispatcher
 442    would call and use that as the function to step into instead.  Also
 443    skip over the trampoline for the function (if any).  This is better
 444    for the user since they are only interested in stepping into the
 445    method function anyway.  */
 446 static CORE_ADDR
 447 objc_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc)
 448 {
 449   struct gdbarch *gdbarch = get_frame_arch (frame);
 450   CORE_ADDR real_stop_pc;
 451   CORE_ADDR method_stop_pc;
 452
 453   real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc);
 454
 455   if (real_stop_pc != 0)
 456     find_objc_msgcall (real_stop_pc, &method_stop_pc);
 457   else
 458     find_objc_msgcall (stop_pc, &method_stop_pc);
 459
 460   if (method_stop_pc)
 461     {
 462       real_stop_pc = gdbarch_skip_trampoline_code
 463                        (gdbarch, frame, method_stop_pc);
 464       if (real_stop_pc == 0)
 465         real_stop_pc = method_stop_pc;
 466     }
 467
 468   return real_stop_pc;
 469 }
 470
 471
 472 /* Table mapping opcodes into strings for printing operators
 473    and precedences of the operators.  */
 474
 475 static const struct op_print objc_op_print_tab[] =
 476   {
 477     {",",  BINOP_COMMA, PREC_COMMA, 0},
 478     {"=",  BINOP_ASSIGN, PREC_ASSIGN, 1},
 479     {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
 480     {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
 481     {"|",  BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
 482     {"^",  BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
 483     {"&",  BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
 484     {"==", BINOP_EQUAL, PREC_EQUAL, 0},
 485     {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
 486     {"<=", BINOP_LEQ, PREC_ORDER, 0},
 487     {">=", BINOP_GEQ, PREC_ORDER, 0},
 488     {">",  BINOP_GTR, PREC_ORDER, 0},
 489     {"<",  BINOP_LESS, PREC_ORDER, 0},
 490     {">>", BINOP_RSH, PREC_SHIFT, 0},
 491     {"<<", BINOP_LSH, PREC_SHIFT, 0},
 492     {"+",  BINOP_ADD, PREC_ADD, 0},
 493     {"-",  BINOP_SUB, PREC_ADD, 0},
 494     {"*",  BINOP_MUL, PREC_MUL, 0},
 495     {"/",  BINOP_DIV, PREC_MUL, 0},
 496     {"%",  BINOP_REM, PREC_MUL, 0},
 497     {"@",  BINOP_REPEAT, PREC_REPEAT, 0},
 498     {"-",  UNOP_NEG, PREC_PREFIX, 0},
 499     {"!",  UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
 500     {"~",  UNOP_COMPLEMENT, PREC_PREFIX, 0},
 501     {"*",  UNOP_IND, PREC_PREFIX, 0},
 502     {"&",  UNOP_ADDR, PREC_PREFIX, 0},
 503     {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
 504     {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
 505     {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
 506     {NULL, OP_NULL, PREC_NULL, 0}
 507 };
 508
 509 const struct language_defn objc_language_defn = {
 510   "objective-c",                /* Language name */
 511   language_objc,
 512   range_check_off,
 513   type_check_off,
 514   case_sensitive_on,
 515   array_row_major,
 516   macro_expansion_c,
 517   &exp_descriptor_standard,
 518   objc_parse,
 519   objc_error,
 520   null_post_parser,
 521   objc_printchar,               /* Print a character constant */
 522   objc_printstr,                /* Function to print string constant */
 523   objc_emit_char,
 524   c_print_type,                 /* Print a type using appropriate syntax */
 525   c_print_typedef,              /* Print a typedef using appropriate syntax */
 526   c_val_print,                  /* Print a value using appropriate syntax */
 527   c_value_print,                /* Print a top-level value */
 528   objc_skip_trampoline,         /* Language specific skip_trampoline */
 529   "self",                       /* name_of_this */
 530   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
 531   basic_lookup_transparent_type,/* lookup_transparent_type */
 532   objc_demangle,                /* Language specific symbol demangler */
 533   NULL,                         /* Language specific
 534                                    class_name_from_physname */
 535   objc_op_print_tab,            /* Expression operators for printing */
 536   1,                            /* C-style arrays */
 537   0,                            /* String lower bound */
 538   default_word_break_characters,
 539   default_make_symbol_completion_list,
 540   c_language_arch_info,
 541   default_print_array_index,
 542   default_pass_by_reference,
 543   default_get_string,
 544   strcmp_iw_ordered,
 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 (char *a, 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 (char *a, 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   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   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               char *mystart = name;
 767               char *myend   = (char *) 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   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   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             char *mystart = name + 2;
 906             char *myend   = (char *) 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   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 void
1771 _initialize_objc_lang (void)
1772 {
1773   objc_objfile_data = register_objfile_data ();
1774 }