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