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 (msymbol) != mst_text)
1158           && (MSYMBOL_TYPE (msymbol) != mst_file_text))
1159         /* Not a function or method.  */
1160         continue;
1161
1162       if (symtab)
1163         if ((SYMBOL_VALUE_ADDRESS (msymbol) <  BLOCK_START (block)) ||
1164             (SYMBOL_VALUE_ADDRESS (msymbol) >= BLOCK_END (block)))
1165           /* Not in the specified symtab.  */
1166           continue;
1167
1168       symname = SYMBOL_NATURAL_NAME (msymbol);
1169       if (symname == NULL)
1170         continue;
1171
1172       if ((symname[0] != '-' && symname[0] != '+') || (symname[1] != '['))
1173         /* Not a method name.  */
1174         continue;
1175
1176       while ((strlen (symname) + 1) >= tmplen)
1177         {
1178           tmplen = (tmplen == 0) ? 1024 : tmplen * 2;
1179           tmp = xrealloc (tmp, tmplen);
1180         }
1181       strcpy (tmp, symname);
1182
1183       if (parse_method (tmp, &ntype, &nclass, &ncategory, &nselector) == NULL)
1184         continue;
1185
1186       if ((type != '\0') && (ntype != type))
1187         continue;
1188
1189       if ((class != NULL)
1190           && ((nclass == NULL) || (strcmp (class, nclass) != 0)))
1191         continue;
1192
1193       if ((category != NULL) &&
1194           ((ncategory == NULL) || (strcmp (category, ncategory) != 0)))
1195         continue;
1196
1197       if ((selector != NULL) &&
1198           ((nselector == NULL) || (strcmp (selector, nselector) != 0)))
1199         continue;
1200
1201       sym = find_pc_function (SYMBOL_VALUE_ADDRESS (msymbol));
1202       if (sym != NULL)
1203         {
1204           const char *newsymname = SYMBOL_NATURAL_NAME (sym);
1205
1206           if (strcmp (symname, newsymname) == 0)
1207             {
1208               /* Found a high-level method sym: swap it into the
1209                  lower part of sym_arr (below num_debuggable).  */
1210               if (syms != NULL)
1211                 {
1212                   syms[csym] = syms[cdebug];
1213                   syms[cdebug] = sym;
1214                 }
1215               csym++;
1216               cdebug++;
1217             }
1218           else
1219             {
1220               warning (
1221 "debugging symbol \"%s\" does not match minimal symbol (\"%s\"); ignoring",
1222                        newsymname, symname);
1223               if (syms != NULL)
1224                 syms[csym] = (struct symbol *) msymbol;
1225               csym++;
1226             }
1227         }
1228       else
1229         {
1230           /* Found a non-debuggable method symbol.  */
1231           if (syms != NULL)
1232             syms[csym] = (struct symbol *) msymbol;
1233           csym++;
1234         }
1235     }
1236
1237   if (nsym != NULL)
1238     *nsym = csym;
1239   if (ndebug != NULL)
1240     *ndebug = cdebug;
1241 }
1242
1243 char *find_imps (struct symtab *symtab, struct block *block,
1244                  char *method, struct symbol **syms,
1245                  unsigned int *nsym, unsigned int *ndebug)
1246 {
1247   char type = '\0';
1248   char *class = NULL;
1249   char *category = NULL;
1250   char *selector = NULL;
1251
1252   unsigned int csym = 0;
1253   unsigned int cdebug = 0;
1254
1255   unsigned int ncsym = 0;
1256   unsigned int ncdebug = 0;
1257
1258   char *buf = NULL;
1259   char *tmp = NULL;
1260
1261   gdb_assert (nsym != NULL);
1262   gdb_assert (ndebug != NULL);
1263
1264   if (nsym != NULL)
1265     *nsym = 0;
1266   if (ndebug != NULL)
1267     *ndebug = 0;
1268
1269   buf = (char *) alloca (strlen (method) + 1);
1270   strcpy (buf, method);
1271   tmp = parse_method (buf, &type, &class, &category, &selector);
1272
1273   if (tmp == NULL) {
1274
1275     struct symbol *sym = NULL;
1276     struct minimal_symbol *msym = NULL;
1277
1278     strcpy (buf, method);
1279     tmp = parse_selector (buf, &selector);
1280
1281     if (tmp == NULL)
1282       return NULL;
1283
1284     sym = lookup_symbol (selector, block, VAR_DOMAIN, 0);
1285     if (sym != NULL)
1286       {
1287         if (syms)
1288           syms[csym] = sym;
1289         csym++;
1290         cdebug++;
1291       }
1292
1293     if (sym == NULL)
1294       msym = lookup_minimal_symbol (selector, 0, 0);
1295
1296     if (msym != NULL)
1297       {
1298         if (syms)
1299           syms[csym] = (struct symbol *)msym;
1300         csym++;
1301       }
1302   }
1303
1304   if (syms != NULL)
1305     find_methods (symtab, type, class, category, selector,
1306                   syms + csym, &ncsym, &ncdebug);
1307   else
1308     find_methods (symtab, type, class, category, selector,
1309                   NULL, &ncsym, &ncdebug);
1310
1311   /* If we didn't find any methods, just return.  */
1312   if (ncsym == 0 && ncdebug == 0)
1313     return method;
1314
1315   /* Take debug symbols from the second batch of symbols and swap them
1316    * with debug symbols from the first batch.  Repeat until either the
1317    * second section is out of debug symbols or the first section is
1318    * full of debug symbols.  Either way we have all debug symbols
1319    * packed to the beginning of the buffer.
1320    */
1321
1322   if (syms != NULL)
1323     {
1324       while ((cdebug < csym) && (ncdebug > 0))
1325         {
1326           struct symbol *s = NULL;
1327           /* First non-debugging symbol.  */
1328           unsigned int i = cdebug;
1329           /* Last of second batch of debug symbols.  */
1330           unsigned int j = csym + ncdebug - 1;
1331
1332           s = syms[j];
1333           syms[j] = syms[i];
1334           syms[i] = s;
1335
1336           /* We've moved a symbol from the second debug section to the
1337              first one.  */
1338           cdebug++;
1339           ncdebug--;
1340         }
1341     }
1342
1343   csym += ncsym;
1344   cdebug += ncdebug;
1345
1346   if (nsym != NULL)
1347     *nsym = csym;
1348   if (ndebug != NULL)
1349     *ndebug = cdebug;
1350
1351   if (syms == NULL)
1352     return method + (tmp - buf);
1353
1354   if (csym > 1)
1355     {
1356       /* Sort debuggable symbols.  */
1357       if (cdebug > 1)
1358         qsort (syms, cdebug, sizeof (struct minimal_symbol *),
1359                compare_classes);
1360
1361       /* Sort minimal_symbols.  */
1362       if ((csym - cdebug) > 1)
1363         qsort (&syms[cdebug], csym - cdebug,
1364                sizeof (struct minimal_symbol *), compare_classes);
1365     }
1366   /* Terminate the sym_arr list.  */
1367   syms[csym] = 0;
1368
1369   return method + (tmp - buf);
1370 }
1371
1372 static void
1373 print_object_command (char *args, int from_tty)
1374 {
1375   struct value *object, *function, *description;
1376   CORE_ADDR string_addr, object_addr;
1377   int i = 0;
1378   gdb_byte c = 0;
1379
1380   if (!args || !*args)
1381     error (
1382 "The 'print-object' command requires an argument (an Objective-C object)");
1383
1384   {
1385     struct expression *expr = parse_expression (args);
1386     struct cleanup *old_chain =
1387       make_cleanup (free_current_contents, &expr);
1388     int pc = 0;
1389
1390     object = expr->language_defn->la_exp_desc->evaluate_exp
1391       (builtin_type (expr->gdbarch)->builtin_data_ptr, expr, &pc, EVAL_NORMAL);
1392     do_cleanups (old_chain);
1393   }
1394
1395   /* Validate the address for sanity.  */
1396   object_addr = value_as_long (object);
1397   read_memory (object_addr, &c, 1);
1398
1399   function = find_function_in_inferior ("_NSPrintForDebugger", NULL);
1400   if (function == NULL)
1401     error (_("Unable to locate _NSPrintForDebugger in child process"));
1402
1403   description = call_function_by_hand (function, 1, &object);
1404
1405   string_addr = value_as_long (description);
1406   if (string_addr == 0)
1407     error (_("object returns null description"));
1408
1409   read_memory (string_addr + i++, &c, 1);
1410   if (c != 0)
1411     do
1412       { /* Read and print characters up to EOS.  */
1413         QUIT;
1414         printf_filtered ("%c", c);
1415         read_memory (string_addr + i++, &c, 1);
1416       } while (c != 0);
1417   else
1418     printf_filtered(_("<object returns empty description>"));
1419   printf_filtered ("\n");
1420 }
1421
1422 /* The data structure 'methcalls' is used to detect method calls (thru
1423  * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1424  * and ultimately find the method being called.
1425  */
1426
1427 struct objc_methcall {
1428   char *name;
1429  /* Return instance method to be called.  */
1430   int (*stop_at) (CORE_ADDR, CORE_ADDR *);
1431   /* Start of pc range corresponding to method invocation.  */
1432   CORE_ADDR begin;
1433   /* End of pc range corresponding to method invocation.  */
1434   CORE_ADDR end;
1435 };
1436
1437 static int resolve_msgsend (CORE_ADDR pc, CORE_ADDR *new_pc);
1438 static int resolve_msgsend_stret (CORE_ADDR pc, CORE_ADDR *new_pc);
1439 static int resolve_msgsend_super (CORE_ADDR pc, CORE_ADDR *new_pc);
1440 static int resolve_msgsend_super_stret (CORE_ADDR pc, CORE_ADDR *new_pc);
1441
1442 static struct objc_methcall methcalls[] = {
1443   { "_objc_msgSend", resolve_msgsend, 0, 0},
1444   { "_objc_msgSend_stret", resolve_msgsend_stret, 0, 0},
1445   { "_objc_msgSendSuper", resolve_msgsend_super, 0, 0},
1446   { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret, 0, 0},
1447   { "_objc_getClass", NULL, 0, 0},
1448   { "_objc_getMetaClass", NULL, 0, 0}
1449 };
1450
1451 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1452
1453 /* The following function, "find_objc_msgsend", fills in the data
1454  * structure "objc_msgs" by finding the addresses of each of the
1455  * (currently four) functions that it holds (of which objc_msgSend is
1456  * the first).  This must be called each time symbols are loaded, in
1457  * case the functions have moved for some reason.
1458  */
1459
1460 static void
1461 find_objc_msgsend (void)
1462 {
1463   unsigned int i;
1464   for (i = 0; i < nmethcalls; i++) {
1465
1466     struct minimal_symbol *func;
1467
1468     /* Try both with and without underscore.  */
1469     func = lookup_minimal_symbol (methcalls[i].name, NULL, NULL);
1470     if ((func == NULL) && (methcalls[i].name[0] == '_')) {
1471       func = lookup_minimal_symbol (methcalls[i].name + 1, NULL, NULL);
1472     }
1473     if (func == NULL) {
1474       methcalls[i].begin = 0;
1475       methcalls[i].end = 0;
1476       continue;
1477     }
1478
1479     methcalls[i].begin = SYMBOL_VALUE_ADDRESS (func);
1480     do {
1481       methcalls[i].end = SYMBOL_VALUE_ADDRESS (++func);
1482     } while (methcalls[i].begin == methcalls[i].end);
1483   }
1484 }
1485
1486 /* find_objc_msgcall (replaces pc_off_limits)
1487  *
1488  * ALL that this function now does is to determine whether the input
1489  * address ("pc") is the address of one of the Objective-C message
1490  * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1491  * if so, it returns the address of the method that will be called.
1492  *
1493  * The old function "pc_off_limits" used to do a lot of other things
1494  * in addition, such as detecting shared library jump stubs and
1495  * returning the address of the shlib function that would be called.
1496  * That functionality has been moved into the gdbarch_skip_trampoline_code and
1497  * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
1498  * dependent modules.
1499  */
1500
1501 struct objc_submethod_helper_data {
1502   int (*f) (CORE_ADDR, CORE_ADDR *);
1503   CORE_ADDR pc;
1504   CORE_ADDR *new_pc;
1505 };
1506
1507 static int
1508 find_objc_msgcall_submethod_helper (void * arg)
1509 {
1510   struct objc_submethod_helper_data *s =
1511     (struct objc_submethod_helper_data *) arg;
1512
1513   if (s->f (s->pc, s->new_pc) == 0)
1514     return 1;
1515   else
1516     return 0;
1517 }
1518
1519 static int
1520 find_objc_msgcall_submethod (int (*f) (CORE_ADDR, CORE_ADDR *),
1521                              CORE_ADDR pc,
1522                              CORE_ADDR *new_pc)
1523 {
1524   struct objc_submethod_helper_data s;
1525
1526   s.f = f;
1527   s.pc = pc;
1528   s.new_pc = new_pc;
1529
1530   if (catch_errors (find_objc_msgcall_submethod_helper,
1531                     (void *) &s,
1532                     "Unable to determine target of Objective-C method call (ignoring):\n",
1533                     RETURN_MASK_ALL) == 0)
1534     return 1;
1535   else
1536     return 0;
1537 }
1538
1539 int
1540 find_objc_msgcall (CORE_ADDR pc, CORE_ADDR *new_pc)
1541 {
1542   unsigned int i;
1543
1544   find_objc_msgsend ();
1545   if (new_pc != NULL)
1546     {
1547       *new_pc = 0;
1548     }
1549
1550   for (i = 0; i < nmethcalls; i++)
1551     if ((pc >= methcalls[i].begin) && (pc < methcalls[i].end))
1552       {
1553         if (methcalls[i].stop_at != NULL)
1554           return find_objc_msgcall_submethod (methcalls[i].stop_at,
1555                                               pc, new_pc);
1556         else
1557           return 0;
1558       }
1559
1560   return 0;
1561 }
1562
1563 extern initialize_file_ftype _initialize_objc_language; /* -Wmissing-prototypes */
1564
1565 void
1566 _initialize_objc_language (void)
1567 {
1568   add_language (&objc_language_defn);
1569   add_info ("selectors", selectors_info,    /* INFO SELECTORS command.  */
1570             _("All Objective-C selectors, or those matching REGEXP."));
1571   add_info ("classes", classes_info,        /* INFO CLASSES   command.  */
1572             _("All Objective-C classes, or those matching REGEXP."));
1573   add_com ("print-object", class_vars, print_object_command,
1574            _("Ask an Objective-C object to print itself."));
1575   add_com_alias ("po", "print-object", class_vars, 1);
1576 }
1577
1578 static void
1579 read_objc_method (CORE_ADDR addr, struct objc_method *method)
1580 {
1581   method->name  = read_memory_unsigned_integer (addr + 0, 4);
1582   method->types = read_memory_unsigned_integer (addr + 4, 4);
1583   method->imp   = read_memory_unsigned_integer (addr + 8, 4);
1584 }
1585
1586 static
1587 unsigned long read_objc_methlist_nmethods (CORE_ADDR addr)
1588 {
1589   return read_memory_unsigned_integer (addr + 4, 4);
1590 }
1591
1592 static void
1593 read_objc_methlist_method (CORE_ADDR addr, unsigned long num,
1594                            struct objc_method *method)
1595 {
1596   gdb_assert (num < read_objc_methlist_nmethods (addr));
1597   read_objc_method (addr + 8 + (12 * num), method);
1598 }
1599
1600 static void
1601 read_objc_object (CORE_ADDR addr, struct objc_object *object)
1602 {
1603   object->isa = read_memory_unsigned_integer (addr, 4);
1604 }
1605
1606 static void
1607 read_objc_super (CORE_ADDR addr, struct objc_super *super)
1608 {
1609   super->receiver = read_memory_unsigned_integer (addr, 4);
1610   super->class = read_memory_unsigned_integer (addr + 4, 4);
1611 };
1612
1613 static void
1614 read_objc_class (CORE_ADDR addr, struct objc_class *class)
1615 {
1616   class->isa = read_memory_unsigned_integer (addr, 4);
1617   class->super_class = read_memory_unsigned_integer (addr + 4, 4);
1618   class->name = read_memory_unsigned_integer (addr + 8, 4);
1619   class->version = read_memory_unsigned_integer (addr + 12, 4);
1620   class->info = read_memory_unsigned_integer (addr + 16, 4);
1621   class->instance_size = read_memory_unsigned_integer (addr + 18, 4);
1622   class->ivars = read_memory_unsigned_integer (addr + 24, 4);
1623   class->methods = read_memory_unsigned_integer (addr + 28, 4);
1624   class->cache = read_memory_unsigned_integer (addr + 32, 4);
1625   class->protocols = read_memory_unsigned_integer (addr + 36, 4);
1626 }
1627
1628 static CORE_ADDR
1629 find_implementation_from_class (CORE_ADDR class, CORE_ADDR sel)
1630 {
1631   CORE_ADDR subclass = class;
1632
1633   while (subclass != 0)
1634     {
1635
1636       struct objc_class class_str;
1637       unsigned mlistnum = 0;
1638
1639       read_objc_class (subclass, &class_str);
1640
1641       for (;;)
1642         {
1643           CORE_ADDR mlist;
1644           unsigned long nmethods;
1645           unsigned long i;
1646
1647           mlist = read_memory_unsigned_integer (class_str.methods +
1648                                                 (4 * mlistnum), 4);
1649           if (mlist == 0)
1650             break;
1651
1652           nmethods = read_objc_methlist_nmethods (mlist);
1653
1654           for (i = 0; i < nmethods; i++)
1655             {
1656               struct objc_method meth_str;
1657               read_objc_methlist_method (mlist, i, &meth_str);
1658
1659 #if 0
1660               fprintf (stderr,
1661                        "checking method 0x%lx against selector 0x%lx\n",
1662                        meth_str.name, sel);
1663 #endif
1664
1665               if (meth_str.name == sel)
1666                 /* FIXME: hppa arch was doing a pointer dereference
1667                    here. There needs to be a better way to do that.  */
1668                 return meth_str.imp;
1669             }
1670           mlistnum++;
1671         }
1672       subclass = class_str.super_class;
1673     }
1674
1675   return 0;
1676 }
1677
1678 static CORE_ADDR
1679 find_implementation (CORE_ADDR object, CORE_ADDR sel)
1680 {
1681   struct objc_object ostr;
1682
1683   if (object == 0)
1684     return 0;
1685   read_objc_object (object, &ostr);
1686   if (ostr.isa == 0)
1687     return 0;
1688
1689   return find_implementation_from_class (ostr.isa, sel);
1690 }
1691
1692 static int
1693 resolve_msgsend (CORE_ADDR pc, CORE_ADDR *new_pc)
1694 {
1695   struct frame_info *frame = get_current_frame ();
1696   struct gdbarch *gdbarch = get_frame_arch (frame);
1697   struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1698
1699   CORE_ADDR object;
1700   CORE_ADDR sel;
1701   CORE_ADDR res;
1702
1703   object = gdbarch_fetch_pointer_argument (gdbarch, frame, 0, ptr_type);
1704   sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1705
1706   res = find_implementation (object, sel);
1707   if (new_pc != 0)
1708     *new_pc = res;
1709   if (res == 0)
1710     return 1;
1711   return 0;
1712 }
1713
1714 static int
1715 resolve_msgsend_stret (CORE_ADDR pc, CORE_ADDR *new_pc)
1716 {
1717   struct frame_info *frame = get_current_frame ();
1718   struct gdbarch *gdbarch = get_frame_arch (frame);
1719   struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1720
1721   CORE_ADDR object;
1722   CORE_ADDR sel;
1723   CORE_ADDR res;
1724
1725   object = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1726   sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 2, ptr_type);
1727
1728   res = find_implementation (object, sel);
1729   if (new_pc != 0)
1730     *new_pc = res;
1731   if (res == 0)
1732     return 1;
1733   return 0;
1734 }
1735
1736 static int
1737 resolve_msgsend_super (CORE_ADDR pc, CORE_ADDR *new_pc)
1738 {
1739   struct frame_info *frame = get_current_frame ();
1740   struct gdbarch *gdbarch = get_frame_arch (frame);
1741   struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1742
1743   struct objc_super sstr;
1744
1745   CORE_ADDR super;
1746   CORE_ADDR sel;
1747   CORE_ADDR res;
1748
1749   super = gdbarch_fetch_pointer_argument (gdbarch, frame, 0, ptr_type);
1750   sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1751
1752   read_objc_super (super, &sstr);
1753   if (sstr.class == 0)
1754     return 0;
1755
1756   res = find_implementation_from_class (sstr.class, sel);
1757   if (new_pc != 0)
1758     *new_pc = res;
1759   if (res == 0)
1760     return 1;
1761   return 0;
1762 }
1763
1764 static int
1765 resolve_msgsend_super_stret (CORE_ADDR pc, CORE_ADDR *new_pc)
1766 {
1767   struct frame_info *frame = get_current_frame ();
1768   struct gdbarch *gdbarch = get_frame_arch (frame);
1769   struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1770
1771   struct objc_super sstr;
1772
1773   CORE_ADDR super;
1774   CORE_ADDR sel;
1775   CORE_ADDR res;
1776
1777   super = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1778   sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 2, ptr_type);
1779
1780   read_objc_super (super, &sstr);
1781   if (sstr.class == 0)
1782     return 0;
1783
1784   res = find_implementation_from_class (sstr.class, sel);
1785   if (new_pc != 0)
1786     *new_pc = res;
1787   if (res == 0)
1788     return 1;
1789   return 0;
1790 }