gdb/objc-lang.c

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