contrib/gdb-7/gdb/objc-lang.c

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