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