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