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