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