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           if (sizeof (myregexp) < strlen (regexp) + 4)
 724             error (_("Regexp is too long: %s"), regexp);
 725           strcpy(myregexp, regexp);
 726           if (myregexp[strlen(myregexp) - 1] == '$') /* end of selector */
 727             myregexp[strlen(myregexp) - 1] = ']';    /* end of method name */
 728           else
 729             strcat(myregexp, ".*]");
 730         }
 731     }
 732
 733   if (regexp != NULL)
 734     {
 735       val = re_comp (myregexp);
 736       if (val != 0)
 737         error (_("Invalid regexp (%s): %s"), val, regexp);
 738     }
 739
 740   /* First time thru is JUST to get max length and count.  */
 741   ALL_MSYMBOLS (objfile, msymbol)
 742     {
 743       QUIT;
 744       name = SYMBOL_NATURAL_NAME (msymbol);
 745       if (name &&
 746          (name[0] == '-' || name[0] == '+') &&
 747           name[1] == '[')               /* Got a method name.  */
 748         {
 749           /* Filter for class/instance methods.  */
 750           if (plusminus && name[0] != plusminus)
 751             continue;
 752           /* Find selector part.  */
 753           name = (char *) strchr(name+2, ' ');
 754           if (regexp == NULL || re_exec(++name) != 0)
 755             {
 756               char *mystart = name;
 757               char *myend   = (char *) strchr(mystart, ']');
 758
 759               if (myend && (myend - mystart > maxlen))
 760                 maxlen = myend - mystart;       /* Get longest selector.  */
 761               matches++;
 762             }
 763         }
 764     }
 765   if (matches)
 766     {
 767       printf_filtered (_("Selectors matching \"%s\":\n\n"),
 768                        regexp ? regexp : "*");
 769
 770       sym_arr = alloca (matches * sizeof (struct symbol *));
 771       matches = 0;
 772       ALL_MSYMBOLS (objfile, msymbol)
 773         {
 774           QUIT;
 775           name = SYMBOL_NATURAL_NAME (msymbol);
 776           if (name &&
 777              (name[0] == '-' || name[0] == '+') &&
 778               name[1] == '[')           /* Got a method name.  */
 779             {
 780               /* Filter for class/instance methods.  */
 781               if (plusminus && name[0] != plusminus)
 782                 continue;
 783               /* Find selector part.  */
 784               name = (char *) strchr(name+2, ' ');
 785               if (regexp == NULL || re_exec(++name) != 0)
 786                 sym_arr[matches++] = (struct symbol *) msymbol;
 787             }
 788         }
 789
 790       qsort (sym_arr, matches, sizeof (struct minimal_symbol *),
 791              compare_selectors);
 792       /* Prevent compare on first iteration.  */
 793       asel[0] = 0;
 794       for (ix = 0; ix < matches; ix++)  /* Now do the output.  */
 795         {
 796           char *p = asel;
 797
 798           QUIT;
 799           name = SYMBOL_NATURAL_NAME (sym_arr[ix]);
 800           name = strchr (name, ' ') + 1;
 801           if (p[0] && specialcmp(name, p) == 0)
 802             continue;           /* Seen this one already (not unique).  */
 803
 804           /* Copy selector part.  */
 805           while (*name && *name != ']')
 806             *p++ = *name++;
 807           *p++ = '\0';
 808           /* Print in columns.  */
 809           puts_filtered_tabular(asel, maxlen + 1, 0);
 810         }
 811       begin_line();
 812     }
 813   else
 814     printf_filtered (_("No selectors matching \"%s\"\n"),
 815                      regexp ? regexp : "*");
 816 }
 817
 818 /*
 819  * Function: compare_classes (const void *, const void *)
 820  *
 821  * Comparison function for use with qsort.  Arguments are symbols or
 822  * msymbols Compares class part of objc method name alphabetically.
 823  */
 824
 825 static int
 826 compare_classes (const void *a, const void *b)
 827 {
 828   char *aname, *bname;
 829
 830   aname = SYMBOL_PRINT_NAME (*(struct symbol **) a);
 831   bname = SYMBOL_PRINT_NAME (*(struct symbol **) b);
 832   if (aname == NULL || bname == NULL)
 833     error (_("internal: compare_classes(1)"));
 834
 835   return specialcmp (aname+1, bname+1);
 836 }
 837
 838 /*
 839  * Function: classes_info(regexp, from_tty)
 840  *
 841  * Implements the "info classes" command for objective c classes.
 842  * Lists all objective c classes that match the optional regexp.
 843  * Works by grepping thru the list of objective c methods.  List will
 844  * be sorted and uniqued (since one class may have many methods).
 845  * BUGS: will not list a class that has no methods.
 846  */
 847
 848 static void
 849 classes_info (char *regexp, int from_tty)
 850 {
 851   struct objfile        *objfile;
 852   struct minimal_symbol *msymbol;
 853   char                  *name;
 854   char                  *val;
 855   int                    matches = 0;
 856   int                    maxlen  = 0;
 857   int                    ix;
 858   char                   myregexp[2048];
 859   char                   aclass[256];
 860   struct symbol        **sym_arr;
 861
 862   if (regexp == NULL)
 863     strcpy(myregexp, ".* ");    /* Null input: match all objc classes.  */
 864   else
 865     {
 866       if (sizeof (myregexp) < strlen (regexp) + 4)
 867         error (_("Regexp is too long: %s"), regexp);
 868       strcpy(myregexp, regexp);
 869       if (myregexp[strlen(myregexp) - 1] == '$')
 870         /* In the method name, the end of the class name is marked by ' '.  */
 871         myregexp[strlen(myregexp) - 1] = ' ';
 872       else
 873         strcat(myregexp, ".* ");
 874     }
 875
 876   if (regexp != NULL)
 877     {
 878       val = re_comp (myregexp);
 879       if (val != 0)
 880         error (_("Invalid regexp (%s): %s"), val, regexp);
 881     }
 882
 883   /* First time thru is JUST to get max length and count.  */
 884   ALL_MSYMBOLS (objfile, msymbol)
 885     {
 886       QUIT;
 887       name = SYMBOL_NATURAL_NAME (msymbol);
 888       if (name &&
 889          (name[0] == '-' || name[0] == '+') &&
 890           name[1] == '[')                       /* Got a method name.  */
 891         if (regexp == NULL || re_exec(name+2) != 0)
 892           {
 893             /* Compute length of classname part.  */
 894             char *mystart = name + 2;
 895             char *myend   = (char *) strchr(mystart, ' ');
 896
 897             if (myend && (myend - mystart > maxlen))
 898               maxlen = myend - mystart;
 899             matches++;
 900           }
 901     }
 902   if (matches)
 903     {
 904       printf_filtered (_("Classes matching \"%s\":\n\n"),
 905                        regexp ? regexp : "*");
 906       sym_arr = alloca (matches * sizeof (struct symbol *));
 907       matches = 0;
 908       ALL_MSYMBOLS (objfile, msymbol)
 909         {
 910           QUIT;
 911           name = SYMBOL_NATURAL_NAME (msymbol);
 912           if (name &&
 913              (name[0] == '-' || name[0] == '+') &&
 914               name[1] == '[')                   /* Got a method name.  */
 915             if (regexp == NULL || re_exec(name+2) != 0)
 916                 sym_arr[matches++] = (struct symbol *) msymbol;
 917         }
 918
 919       qsort (sym_arr, matches, sizeof (struct minimal_symbol *),
 920              compare_classes);
 921       /* Prevent compare on first iteration.  */
 922       aclass[0] = 0;
 923       for (ix = 0; ix < matches; ix++)  /* Now do the output.  */
 924         {
 925           char *p = aclass;
 926
 927           QUIT;
 928           name = SYMBOL_NATURAL_NAME (sym_arr[ix]);
 929           name += 2;
 930           if (p[0] && specialcmp(name, p) == 0)
 931             continue;   /* Seen this one already (not unique).  */
 932
 933           /* Copy class part of method name.  */
 934           while (*name && *name != ' ')
 935             *p++ = *name++;
 936           *p++ = '\0';
 937           /* Print in columns.  */
 938           puts_filtered_tabular(aclass, maxlen + 1, 0);
 939         }
 940       begin_line();
 941     }
 942   else
 943     printf_filtered (_("No classes matching \"%s\"\n"), regexp ? regexp : "*");
 944 }
 945
 946 /*
 947  * Function: find_imps (char *selector, struct symbol **sym_arr)
 948  *
 949  * Input:  a string representing a selector
 950  *         a pointer to an array of symbol pointers
 951  *         possibly a pointer to a symbol found by the caller.
 952  *
 953  * Output: number of methods that implement that selector.  Side
 954  * effects: The array of symbol pointers is filled with matching syms.
 955  *
 956  * By analogy with function "find_methods" (symtab.c), builds a list
 957  * of symbols matching the ambiguous input, so that "decode_line_2"
 958  * (symtab.c) can list them and ask the user to choose one or more.
 959  * In this case the matches are objective c methods
 960  * ("implementations") matching an objective c selector.
 961  *
 962  * Note that it is possible for a normal (c-style) function to have
 963  * the same name as an objective c selector.  To prevent the selector
 964  * from eclipsing the function, we allow the caller (decode_line_1) to
 965  * search for such a function first, and if it finds one, pass it in
 966  * to us.  We will then integrate it into the list.  We also search
 967  * for one here, among the minsyms.
 968  *
 969  * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be divided
 970  *       into two parts: debuggable (struct symbol) syms, and
 971  *       non_debuggable (struct minimal_symbol) syms.  The debuggable
 972  *       ones will come first, before NUM_DEBUGGABLE (which will thus
 973  *       be the index of the first non-debuggable one).
 974  */
 975
 976 /*
 977  * Function: total_number_of_imps (char *selector);
 978  *
 979  * Input:  a string representing a selector
 980  * Output: number of methods that implement that selector.
 981  *
 982  * By analogy with function "total_number_of_methods", this allows
 983  * decode_line_1 (symtab.c) to detect if there are objective c methods
 984  * matching the input, and to allocate an array of pointers to them
 985  * which can be manipulated by "decode_line_2" (also in symtab.c).
 986  */
 987
 988 char *
 989 parse_selector (char *method, char **selector)
 990 {
 991   char *s1 = NULL;
 992   char *s2 = NULL;
 993   int found_quote = 0;
 994
 995   char *nselector = NULL;
 996
 997   gdb_assert (selector != NULL);
 998
 999   s1 = method;
1000
1001   while (isspace (*s1))
1002     s1++;
1003   if (*s1 == '\'')
1004     {
1005       found_quote = 1;
1006       s1++;
1007     }
1008   while (isspace (*s1))
1009     s1++;
1010
1011   nselector = s1;
1012   s2 = s1;
1013
1014   for (;;)
1015     {
1016       if (isalnum (*s2) || (*s2 == '_') || (*s2 == ':'))
1017         *s1++ = *s2;
1018       else if (isspace (*s2))
1019         ;
1020       else if ((*s2 == '\0') || (*s2 == '\''))
1021         break;
1022       else
1023         return NULL;
1024       s2++;
1025     }
1026   *s1++ = '\0';
1027
1028   while (isspace (*s2))
1029     s2++;
1030   if (found_quote)
1031     {
1032       if (*s2 == '\'')
1033         s2++;
1034       while (isspace (*s2))
1035         s2++;
1036     }
1037
1038   if (selector != NULL)
1039     *selector = nselector;
1040
1041   return s2;
1042 }
1043
1044 char *
1045 parse_method (char *method, char *type, char **class,
1046               char **category, char **selector)
1047 {
1048   char *s1 = NULL;
1049   char *s2 = NULL;
1050   int found_quote = 0;
1051
1052   char ntype = '\0';
1053   char *nclass = NULL;
1054   char *ncategory = NULL;
1055   char *nselector = NULL;
1056
1057   gdb_assert (type != NULL);
1058   gdb_assert (class != NULL);
1059   gdb_assert (category != NULL);
1060   gdb_assert (selector != NULL);
1061
1062   s1 = method;
1063
1064   while (isspace (*s1))
1065     s1++;
1066   if (*s1 == '\'')
1067     {
1068       found_quote = 1;
1069       s1++;
1070     }
1071   while (isspace (*s1))
1072     s1++;
1073
1074   if ((s1[0] == '+') || (s1[0] == '-'))
1075     ntype = *s1++;
1076
1077   while (isspace (*s1))
1078     s1++;
1079
1080   if (*s1 != '[')
1081     return NULL;
1082   s1++;
1083
1084   nclass = s1;
1085   while (isalnum (*s1) || (*s1 == '_'))
1086     s1++;
1087
1088   s2 = s1;
1089   while (isspace (*s2))
1090     s2++;
1091
1092   if (*s2 == '(')
1093     {
1094       s2++;
1095       while (isspace (*s2))
1096         s2++;
1097       ncategory = s2;
1098       while (isalnum (*s2) || (*s2 == '_'))
1099         s2++;
1100       *s2++ = '\0';
1101     }
1102
1103   /* Truncate the class name now that we're not using the open paren.  */
1104   *s1++ = '\0';
1105
1106   nselector = s2;
1107   s1 = s2;
1108
1109   for (;;)
1110     {
1111       if (isalnum (*s2) || (*s2 == '_') || (*s2 == ':'))
1112         *s1++ = *s2;
1113       else if (isspace (*s2))
1114         ;
1115       else if (*s2 == ']')
1116         break;
1117       else
1118         return NULL;
1119       s2++;
1120     }
1121   *s1++ = '\0';
1122   s2++;
1123
1124   while (isspace (*s2))
1125     s2++;
1126   if (found_quote)
1127     {
1128       if (*s2 != '\'')
1129         return NULL;
1130       s2++;
1131       while (isspace (*s2))
1132         s2++;
1133     }
1134
1135   if (type != NULL)
1136     *type = ntype;
1137   if (class != NULL)
1138     *class = nclass;
1139   if (category != NULL)
1140     *category = ncategory;
1141   if (selector != NULL)
1142     *selector = nselector;
1143
1144   return s2;
1145 }
1146
1147 static void
1148 find_methods (struct symtab *symtab, char type,
1149               const char *class, const char *category,
1150               const char *selector, struct symbol **syms,
1151               unsigned int *nsym, unsigned int *ndebug)
1152 {
1153   struct objfile *objfile = NULL;
1154   struct minimal_symbol *msymbol = NULL;
1155   struct block *block = NULL;
1156   struct symbol *sym = NULL;
1157
1158   char *symname = NULL;
1159
1160   char ntype = '\0';
1161   char *nclass = NULL;
1162   char *ncategory = NULL;
1163   char *nselector = NULL;
1164
1165   unsigned int csym = 0;
1166   unsigned int cdebug = 0;
1167
1168   static char *tmp = NULL;
1169   static unsigned int tmplen = 0;
1170
1171   gdb_assert (nsym != NULL);
1172   gdb_assert (ndebug != NULL);
1173
1174   if (symtab)
1175     block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK);
1176
1177   ALL_OBJFILES (objfile)
1178     {
1179       unsigned int *objc_csym;
1180
1181       /* The objfile_csym variable counts the number of ObjC methods
1182          that this objfile defines.  We save that count as a private
1183          objfile data.  If we have already determined that this objfile
1184          provides no ObjC methods, we can skip it entirely.  */
1185
1186       unsigned int objfile_csym = 0;
1187
1188       objc_csym = objfile_data (objfile, objc_objfile_data);
1189       if (objc_csym != NULL && *objc_csym == 0)
1190         /* There are no ObjC symbols in this objfile.  Skip it entirely.  */
1191         continue;
1192
1193       ALL_OBJFILE_MSYMBOLS (objfile, msymbol)
1194         {
1195           struct gdbarch *gdbarch = get_objfile_arch (objfile);
1196           CORE_ADDR pc = SYMBOL_VALUE_ADDRESS (msymbol);
1197
1198           QUIT;
1199
1200           /* Check the symbol name first as this can be done entirely without
1201              sending any query to the target.  */
1202           symname = SYMBOL_NATURAL_NAME (msymbol);
1203           if (symname == NULL)
1204             continue;
1205
1206           if ((symname[0] != '-' && symname[0] != '+') || (symname[1] != '['))
1207             /* Not a method name.  */
1208             continue;
1209
1210           /* The minimal symbol might point to a function descriptor;
1211              resolve it to the actual code address instead.  */
1212           pc = gdbarch_convert_from_func_ptr_addr (gdbarch, pc,
1213                                                    &current_target);
1214
1215           if (symtab)
1216             if (pc < BLOCK_START (block) || pc >= BLOCK_END (block))
1217               /* Not in the specified symtab.  */
1218               continue;
1219
1220           /* Now that thinks are a bit sane, clean up the symname.  */
1221           while ((strlen (symname) + 1) >= tmplen)
1222             {
1223               tmplen = (tmplen == 0) ? 1024 : tmplen * 2;
1224               tmp = xrealloc (tmp, tmplen);
1225             }
1226           strcpy (tmp, symname);
1227
1228           if (parse_method (tmp, &ntype, &nclass,
1229                             &ncategory, &nselector) == NULL)
1230             continue;
1231
1232           objfile_csym++;
1233
1234           if ((type != '\0') && (ntype != type))
1235             continue;
1236
1237           if ((class != NULL)
1238               && ((nclass == NULL) || (strcmp (class, nclass) != 0)))
1239             continue;
1240
1241           if ((category != NULL) &&
1242               ((ncategory == NULL) || (strcmp (category, ncategory) != 0)))
1243             continue;
1244
1245           if ((selector != NULL) &&
1246               ((nselector == NULL) || (strcmp (selector, nselector) != 0)))
1247             continue;
1248
1249           sym = find_pc_function (pc);
1250           if (sym != NULL)
1251             {
1252               const char *newsymname = SYMBOL_NATURAL_NAME (sym);
1253
1254               if (strcmp (symname, newsymname) == 0)
1255                 {
1256                   /* Found a high-level method sym: swap it into the
1257                      lower part of sym_arr (below num_debuggable).  */
1258                   if (syms != NULL)
1259                     {
1260                       syms[csym] = syms[cdebug];
1261                       syms[cdebug] = sym;
1262                     }
1263                   csym++;
1264                   cdebug++;
1265                 }
1266               else
1267                 {
1268                   warning (
1269 "debugging symbol \"%s\" does not match minimal symbol (\"%s\"); ignoring",
1270                            newsymname, symname);
1271                   if (syms != NULL)
1272                     syms[csym] = (struct symbol *) msymbol;
1273                   csym++;
1274                 }
1275             }
1276           else
1277             {
1278               /* Found a non-debuggable method symbol.  */
1279               if (syms != NULL)
1280                 syms[csym] = (struct symbol *) msymbol;
1281               csym++;
1282             }
1283         }
1284       if (objc_csym == NULL)
1285         {
1286           objc_csym = obstack_alloc (&objfile->objfile_obstack,
1287                                      sizeof (*objc_csym));
1288           *objc_csym = objfile_csym;
1289           set_objfile_data (objfile, objc_objfile_data, objc_csym);
1290         }
1291       else
1292         /* Count of ObjC methods in this objfile should be constant.  */
1293         gdb_assert (*objc_csym == objfile_csym);
1294     }
1295
1296   if (nsym != NULL)
1297     *nsym = csym;
1298   if (ndebug != NULL)
1299     *ndebug = cdebug;
1300 }
1301
1302 char *find_imps (struct symtab *symtab, struct block *block,
1303                  char *method, struct symbol **syms,
1304                  unsigned int *nsym, unsigned int *ndebug)
1305 {
1306   char type = '\0';
1307   char *class = NULL;
1308   char *category = NULL;
1309   char *selector = NULL;
1310
1311   unsigned int csym = 0;
1312   unsigned int cdebug = 0;
1313
1314   unsigned int ncsym = 0;
1315   unsigned int ncdebug = 0;
1316
1317   char *buf = NULL;
1318   char *tmp = NULL;
1319
1320   gdb_assert (nsym != NULL);
1321   gdb_assert (ndebug != NULL);
1322
1323   if (nsym != NULL)
1324     *nsym = 0;
1325   if (ndebug != NULL)
1326     *ndebug = 0;
1327
1328   buf = (char *) alloca (strlen (method) + 1);
1329   strcpy (buf, method);
1330   tmp = parse_method (buf, &type, &class, &category, &selector);
1331
1332   if (tmp == NULL)
1333     {
1334       struct symbol *sym = NULL;
1335       struct minimal_symbol *msym = NULL;
1336
1337       strcpy (buf, method);
1338       tmp = parse_selector (buf, &selector);
1339
1340       if (tmp == NULL)
1341         return NULL;
1342
1343       sym = lookup_symbol (selector, block, VAR_DOMAIN, 0);
1344       if (sym != NULL)
1345         {
1346           if (syms)
1347             syms[csym] = sym;
1348           csym++;
1349           cdebug++;
1350         }
1351
1352       if (sym == NULL)
1353         msym = lookup_minimal_symbol (selector, 0, 0);
1354
1355       if (msym != NULL)
1356         {
1357           if (syms)
1358             syms[csym] = (struct symbol *)msym;
1359           csym++;
1360         }
1361     }
1362
1363   if (syms != NULL)
1364     find_methods (symtab, type, class, category, selector,
1365                   syms + csym, &ncsym, &ncdebug);
1366   else
1367     find_methods (symtab, type, class, category, selector,
1368                   NULL, &ncsym, &ncdebug);
1369
1370   /* If we didn't find any methods, just return.  */
1371   if (ncsym == 0 && ncdebug == 0)
1372     return method;
1373
1374   /* Take debug symbols from the second batch of symbols and swap them
1375    * with debug symbols from the first batch.  Repeat until either the
1376    * second section is out of debug symbols or the first section is
1377    * full of debug symbols.  Either way we have all debug symbols
1378    * packed to the beginning of the buffer.
1379    */
1380
1381   if (syms != NULL)
1382     {
1383       while ((cdebug < csym) && (ncdebug > 0))
1384         {
1385           struct symbol *s = NULL;
1386           /* First non-debugging symbol.  */
1387           unsigned int i = cdebug;
1388           /* Last of second batch of debug symbols.  */
1389           unsigned int j = csym + ncdebug - 1;
1390
1391           s = syms[j];
1392           syms[j] = syms[i];
1393           syms[i] = s;
1394
1395           /* We've moved a symbol from the second debug section to the
1396              first one.  */
1397           cdebug++;
1398           ncdebug--;
1399         }
1400     }
1401
1402   csym += ncsym;
1403   cdebug += ncdebug;
1404
1405   if (nsym != NULL)
1406     *nsym = csym;
1407   if (ndebug != NULL)
1408     *ndebug = cdebug;
1409
1410   if (syms == NULL)
1411     return method + (tmp - buf);
1412
1413   if (csym > 1)
1414     {
1415       /* Sort debuggable symbols.  */
1416       if (cdebug > 1)
1417         qsort (syms, cdebug, sizeof (struct minimal_symbol *),
1418                compare_classes);
1419
1420       /* Sort minimal_symbols.  */
1421       if ((csym - cdebug) > 1)
1422         qsort (&syms[cdebug], csym - cdebug,
1423                sizeof (struct minimal_symbol *), compare_classes);
1424     }
1425   /* Terminate the sym_arr list.  */
1426   syms[csym] = 0;
1427
1428   return method + (tmp - buf);
1429 }
1430
1431 static void
1432 print_object_command (char *args, int from_tty)
1433 {
1434   struct value *object, *function, *description;
1435   CORE_ADDR string_addr, object_addr;
1436   int i = 0;
1437   gdb_byte c = 0;
1438
1439   if (!args || !*args)
1440     error (
1441 "The 'print-object' command requires an argument (an Objective-C object)");
1442
1443   {
1444     struct expression *expr = parse_expression (args);
1445     struct cleanup *old_chain =
1446       make_cleanup (free_current_contents, &expr);
1447     int pc = 0;
1448
1449     object = evaluate_subexp (builtin_type (expr->gdbarch)->builtin_data_ptr,
1450                               expr, &pc, EVAL_NORMAL);
1451     do_cleanups (old_chain);
1452   }
1453
1454   /* Validate the address for sanity.  */
1455   object_addr = value_as_long (object);
1456   read_memory (object_addr, &c, 1);
1457
1458   function = find_function_in_inferior ("_NSPrintForDebugger", NULL);
1459   if (function == NULL)
1460     error (_("Unable to locate _NSPrintForDebugger in child process"));
1461
1462   description = call_function_by_hand (function, 1, &object);
1463
1464   string_addr = value_as_long (description);
1465   if (string_addr == 0)
1466     error (_("object returns null description"));
1467
1468   read_memory (string_addr + i++, &c, 1);
1469   if (c != 0)
1470     do
1471       { /* Read and print characters up to EOS.  */
1472         QUIT;
1473         printf_filtered ("%c", c);
1474         read_memory (string_addr + i++, &c, 1);
1475       } while (c != 0);
1476   else
1477     printf_filtered(_("<object returns empty description>"));
1478   printf_filtered ("\n");
1479 }
1480
1481 /* The data structure 'methcalls' is used to detect method calls (thru
1482  * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1483  * and ultimately find the method being called.
1484  */
1485
1486 struct objc_methcall {
1487   char *name;
1488  /* Return instance method to be called.  */
1489   int (*stop_at) (CORE_ADDR, CORE_ADDR *);
1490   /* Start of pc range corresponding to method invocation.  */
1491   CORE_ADDR begin;
1492   /* End of pc range corresponding to method invocation.  */
1493   CORE_ADDR end;
1494 };
1495
1496 static int resolve_msgsend (CORE_ADDR pc, CORE_ADDR *new_pc);
1497 static int resolve_msgsend_stret (CORE_ADDR pc, CORE_ADDR *new_pc);
1498 static int resolve_msgsend_super (CORE_ADDR pc, CORE_ADDR *new_pc);
1499 static int resolve_msgsend_super_stret (CORE_ADDR pc, CORE_ADDR *new_pc);
1500
1501 static struct objc_methcall methcalls[] = {
1502   { "_objc_msgSend", resolve_msgsend, 0, 0},
1503   { "_objc_msgSend_stret", resolve_msgsend_stret, 0, 0},
1504   { "_objc_msgSendSuper", resolve_msgsend_super, 0, 0},
1505   { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret, 0, 0},
1506   { "_objc_getClass", NULL, 0, 0},
1507   { "_objc_getMetaClass", NULL, 0, 0}
1508 };
1509
1510 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1511
1512 /* The following function, "find_objc_msgsend", fills in the data
1513  * structure "objc_msgs" by finding the addresses of each of the
1514  * (currently four) functions that it holds (of which objc_msgSend is
1515  * the first).  This must be called each time symbols are loaded, in
1516  * case the functions have moved for some reason.
1517  */
1518
1519 static void
1520 find_objc_msgsend (void)
1521 {
1522   unsigned int i;
1523
1524   for (i = 0; i < nmethcalls; i++)
1525     {
1526       struct minimal_symbol *func;
1527
1528       /* Try both with and without underscore.  */
1529       func = lookup_minimal_symbol (methcalls[i].name, NULL, NULL);
1530       if ((func == NULL) && (methcalls[i].name[0] == '_'))
1531         {
1532           func = lookup_minimal_symbol (methcalls[i].name + 1, NULL, NULL);
1533         }
1534       if (func == NULL)
1535         {
1536           methcalls[i].begin = 0;
1537           methcalls[i].end = 0;
1538           continue;
1539         }
1540
1541       methcalls[i].begin = SYMBOL_VALUE_ADDRESS (func);
1542       do {
1543         methcalls[i].end = SYMBOL_VALUE_ADDRESS (++func);
1544       } while (methcalls[i].begin == methcalls[i].end);
1545     }
1546 }
1547
1548 /* find_objc_msgcall (replaces pc_off_limits)
1549  *
1550  * ALL that this function now does is to determine whether the input
1551  * address ("pc") is the address of one of the Objective-C message
1552  * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1553  * if so, it returns the address of the method that will be called.
1554  *
1555  * The old function "pc_off_limits" used to do a lot of other things
1556  * in addition, such as detecting shared library jump stubs and
1557  * returning the address of the shlib function that would be called.
1558  * That functionality has been moved into the gdbarch_skip_trampoline_code and
1559  * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
1560  * dependent modules.
1561  */
1562
1563 struct objc_submethod_helper_data {
1564   int (*f) (CORE_ADDR, CORE_ADDR *);
1565   CORE_ADDR pc;
1566   CORE_ADDR *new_pc;
1567 };
1568
1569 static int
1570 find_objc_msgcall_submethod_helper (void * arg)
1571 {
1572   struct objc_submethod_helper_data *s =
1573     (struct objc_submethod_helper_data *) arg;
1574
1575   if (s->f (s->pc, s->new_pc) == 0)
1576     return 1;
1577   else
1578     return 0;
1579 }
1580
1581 static int
1582 find_objc_msgcall_submethod (int (*f) (CORE_ADDR, CORE_ADDR *),
1583                              CORE_ADDR pc,
1584                              CORE_ADDR *new_pc)
1585 {
1586   struct objc_submethod_helper_data s;
1587
1588   s.f = f;
1589   s.pc = pc;
1590   s.new_pc = new_pc;
1591
1592   if (catch_errors (find_objc_msgcall_submethod_helper,
1593                     (void *) &s,
1594                     "Unable to determine target of "
1595                     "Objective-C method call (ignoring):\n",
1596                     RETURN_MASK_ALL) == 0)
1597     return 1;
1598   else
1599     return 0;
1600 }
1601
1602 int
1603 find_objc_msgcall (CORE_ADDR pc, CORE_ADDR *new_pc)
1604 {
1605   unsigned int i;
1606
1607   find_objc_msgsend ();
1608   if (new_pc != NULL)
1609     {
1610       *new_pc = 0;
1611     }
1612
1613   for (i = 0; i < nmethcalls; i++)
1614     if ((pc >= methcalls[i].begin) && (pc < methcalls[i].end))
1615       {
1616         if (methcalls[i].stop_at != NULL)
1617           return find_objc_msgcall_submethod (methcalls[i].stop_at,
1618                                               pc, new_pc);
1619         else
1620           return 0;
1621       }
1622
1623   return 0;
1624 }
1625
1626 /* -Wmissing-prototypes */
1627 extern initialize_file_ftype _initialize_objc_language;
1628
1629 void
1630 _initialize_objc_language (void)
1631 {
1632   add_language (&objc_language_defn);
1633   add_info ("selectors", selectors_info,    /* INFO SELECTORS command.  */
1634             _("All Objective-C selectors, or those matching REGEXP."));
1635   add_info ("classes", classes_info,        /* INFO CLASSES   command.  */
1636             _("All Objective-C classes, or those matching REGEXP."));
1637   add_com ("print-object", class_vars, print_object_command,
1638            _("Ask an Objective-C object to print itself."));
1639   add_com_alias ("po", "print-object", class_vars, 1);
1640 }
1641
1642 static void
1643 read_objc_method (struct gdbarch *gdbarch, CORE_ADDR addr,
1644                   struct objc_method *method)
1645 {
1646   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1647
1648   method->name  = read_memory_unsigned_integer (addr + 0, 4, byte_order);
1649   method->types = read_memory_unsigned_integer (addr + 4, 4, byte_order);
1650   method->imp   = read_memory_unsigned_integer (addr + 8, 4, byte_order);
1651 }
1652
1653 static unsigned long
1654 read_objc_methlist_nmethods (struct gdbarch *gdbarch, CORE_ADDR addr)
1655 {
1656   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1657
1658   return read_memory_unsigned_integer (addr + 4, 4, byte_order);
1659 }
1660
1661 static void
1662 read_objc_methlist_method (struct gdbarch *gdbarch, CORE_ADDR addr,
1663                            unsigned long num, struct objc_method *method)
1664 {
1665   gdb_assert (num < read_objc_methlist_nmethods (gdbarch, addr));
1666   read_objc_method (gdbarch, addr + 8 + (12 * num), method);
1667 }
1668
1669 static void
1670 read_objc_object (struct gdbarch *gdbarch, CORE_ADDR addr,
1671                   struct objc_object *object)
1672 {
1673   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1674
1675   object->isa = read_memory_unsigned_integer (addr, 4, byte_order);
1676 }
1677
1678 static void
1679 read_objc_super (struct gdbarch *gdbarch, CORE_ADDR addr,
1680                  struct objc_super *super)
1681 {
1682   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1683
1684   super->receiver = read_memory_unsigned_integer (addr, 4, byte_order);
1685   super->class = read_memory_unsigned_integer (addr + 4, 4, byte_order);
1686 };
1687
1688 static void
1689 read_objc_class (struct gdbarch *gdbarch, CORE_ADDR addr,
1690                  struct objc_class *class)
1691 {
1692   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1693
1694   class->isa = read_memory_unsigned_integer (addr, 4, byte_order);
1695   class->super_class = read_memory_unsigned_integer (addr + 4, 4, byte_order);
1696   class->name = read_memory_unsigned_integer (addr + 8, 4, byte_order);
1697   class->version = read_memory_unsigned_integer (addr + 12, 4, byte_order);
1698   class->info = read_memory_unsigned_integer (addr + 16, 4, byte_order);
1699   class->instance_size = read_memory_unsigned_integer (addr + 18, 4,
1700                                                        byte_order);
1701   class->ivars = read_memory_unsigned_integer (addr + 24, 4, byte_order);
1702   class->methods = read_memory_unsigned_integer (addr + 28, 4, byte_order);
1703   class->cache = read_memory_unsigned_integer (addr + 32, 4, byte_order);
1704   class->protocols = read_memory_unsigned_integer (addr + 36, 4, byte_order);
1705 }
1706
1707 static CORE_ADDR
1708 find_implementation_from_class (struct gdbarch *gdbarch,
1709                                 CORE_ADDR class, CORE_ADDR sel)
1710 {
1711   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1712   CORE_ADDR subclass = class;
1713
1714   while (subclass != 0)
1715     {
1716
1717       struct objc_class class_str;
1718       unsigned mlistnum = 0;
1719
1720       read_objc_class (gdbarch, subclass, &class_str);
1721
1722       for (;;)
1723         {
1724           CORE_ADDR mlist;
1725           unsigned long nmethods;
1726           unsigned long i;
1727
1728           mlist = read_memory_unsigned_integer (class_str.methods +
1729                                                 (4 * mlistnum),
1730                                                 4, byte_order);
1731           if (mlist == 0)
1732             break;
1733
1734           nmethods = read_objc_methlist_nmethods (gdbarch, mlist);
1735
1736           for (i = 0; i < nmethods; i++)
1737             {
1738               struct objc_method meth_str;
1739
1740               read_objc_methlist_method (gdbarch, mlist, i, &meth_str);
1741 #if 0
1742               fprintf (stderr,
1743                        "checking method 0x%lx against selector 0x%lx\n",
1744                        meth_str.name, sel);
1745 #endif
1746
1747               if (meth_str.name == sel)
1748                 /* FIXME: hppa arch was doing a pointer dereference
1749                    here.  There needs to be a better way to do that.  */
1750                 return meth_str.imp;
1751             }
1752           mlistnum++;
1753         }
1754       subclass = class_str.super_class;
1755     }
1756
1757   return 0;
1758 }
1759
1760 static CORE_ADDR
1761 find_implementation (struct gdbarch *gdbarch,
1762                      CORE_ADDR object, CORE_ADDR sel)
1763 {
1764   struct objc_object ostr;
1765
1766   if (object == 0)
1767     return 0;
1768   read_objc_object (gdbarch, object, &ostr);
1769   if (ostr.isa == 0)
1770     return 0;
1771
1772   return find_implementation_from_class (gdbarch, ostr.isa, sel);
1773 }
1774
1775 static int
1776 resolve_msgsend (CORE_ADDR pc, CORE_ADDR *new_pc)
1777 {
1778   struct frame_info *frame = get_current_frame ();
1779   struct gdbarch *gdbarch = get_frame_arch (frame);
1780   struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1781
1782   CORE_ADDR object;
1783   CORE_ADDR sel;
1784   CORE_ADDR res;
1785
1786   object = gdbarch_fetch_pointer_argument (gdbarch, frame, 0, ptr_type);
1787   sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1788
1789   res = find_implementation (gdbarch, object, sel);
1790   if (new_pc != 0)
1791     *new_pc = res;
1792   if (res == 0)
1793     return 1;
1794   return 0;
1795 }
1796
1797 static int
1798 resolve_msgsend_stret (CORE_ADDR pc, CORE_ADDR *new_pc)
1799 {
1800   struct frame_info *frame = get_current_frame ();
1801   struct gdbarch *gdbarch = get_frame_arch (frame);
1802   struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1803
1804   CORE_ADDR object;
1805   CORE_ADDR sel;
1806   CORE_ADDR res;
1807
1808   object = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1809   sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 2, ptr_type);
1810
1811   res = find_implementation (gdbarch, object, sel);
1812   if (new_pc != 0)
1813     *new_pc = res;
1814   if (res == 0)
1815     return 1;
1816   return 0;
1817 }
1818
1819 static int
1820 resolve_msgsend_super (CORE_ADDR pc, CORE_ADDR *new_pc)
1821 {
1822   struct frame_info *frame = get_current_frame ();
1823   struct gdbarch *gdbarch = get_frame_arch (frame);
1824   struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1825
1826   struct objc_super sstr;
1827
1828   CORE_ADDR super;
1829   CORE_ADDR sel;
1830   CORE_ADDR res;
1831
1832   super = gdbarch_fetch_pointer_argument (gdbarch, frame, 0, ptr_type);
1833   sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1834
1835   read_objc_super (gdbarch, super, &sstr);
1836   if (sstr.class == 0)
1837     return 0;
1838
1839   res = find_implementation_from_class (gdbarch, sstr.class, sel);
1840   if (new_pc != 0)
1841     *new_pc = res;
1842   if (res == 0)
1843     return 1;
1844   return 0;
1845 }
1846
1847 static int
1848 resolve_msgsend_super_stret (CORE_ADDR pc, CORE_ADDR *new_pc)
1849 {
1850   struct frame_info *frame = get_current_frame ();
1851   struct gdbarch *gdbarch = get_frame_arch (frame);
1852   struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1853
1854   struct objc_super sstr;
1855
1856   CORE_ADDR super;
1857   CORE_ADDR sel;
1858   CORE_ADDR res;
1859
1860   super = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1861   sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 2, ptr_type);
1862
1863   read_objc_super (gdbarch, super, &sstr);
1864   if (sstr.class == 0)
1865     return 0;
1866
1867   res = find_implementation_from_class (gdbarch, sstr.class, sel);
1868   if (new_pc != 0)
1869     *new_pc = res;
1870   if (res == 0)
1871     return 1;
1872   return 0;
1873 }
1874
1875 void
1876 _initialize_objc_lang (void)
1877 {
1878   objc_objfile_data = register_objfile_data ();
1879 }