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