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
   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                const char *encoding, 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           /* Check the symbol name first as this can be done entirely without
1182              sending any query to the target.  */
1183           symname = SYMBOL_NATURAL_NAME (msymbol);
1184           if (symname == NULL)
1185             continue;
1186
1187           if ((symname[0] != '-' && symname[0] != '+') || (symname[1] != '['))
1188             /* Not a method name.  */
1189             continue;
1190
1191           /* The minimal symbol might point to a function descriptor;
1192              resolve it to the actual code address instead.  */
1193           pc = gdbarch_convert_from_func_ptr_addr (gdbarch, pc,
1194                                                    &current_target);
1195
1196           if (symtab)
1197             if (pc < BLOCK_START (block) || pc >= BLOCK_END (block))
1198               /* Not in the specified symtab.  */
1199               continue;
1200
1201           /* Now that thinks are a bit sane, clean up the symname.  */
1202           while ((strlen (symname) + 1) >= tmplen)
1203             {
1204               tmplen = (tmplen == 0) ? 1024 : tmplen * 2;
1205               tmp = xrealloc (tmp, tmplen);
1206             }
1207           strcpy (tmp, symname);
1208
1209           if (parse_method (tmp, &ntype, &nclass, &ncategory, &nselector) == NULL)
1210             continue;
1211
1212           objfile_csym++;
1213
1214           if ((type != '\0') && (ntype != type))
1215             continue;
1216
1217           if ((class != NULL)
1218               && ((nclass == NULL) || (strcmp (class, nclass) != 0)))
1219             continue;
1220
1221           if ((category != NULL) &&
1222               ((ncategory == NULL) || (strcmp (category, ncategory) != 0)))
1223             continue;
1224
1225           if ((selector != NULL) &&
1226               ((nselector == NULL) || (strcmp (selector, nselector) != 0)))
1227             continue;
1228
1229           sym = find_pc_function (pc);
1230           if (sym != NULL)
1231             {
1232               const char *newsymname = SYMBOL_NATURAL_NAME (sym);
1233
1234               if (strcmp (symname, newsymname) == 0)
1235                 {
1236                   /* Found a high-level method sym: swap it into the
1237                      lower part of sym_arr (below num_debuggable).  */
1238                   if (syms != NULL)
1239                     {
1240                       syms[csym] = syms[cdebug];
1241                       syms[cdebug] = sym;
1242                     }
1243                   csym++;
1244                   cdebug++;
1245                 }
1246               else
1247                 {
1248                   warning (
1249 "debugging symbol \"%s\" does not match minimal symbol (\"%s\"); ignoring",
1250                            newsymname, symname);
1251                   if (syms != NULL)
1252                     syms[csym] = (struct symbol *) msymbol;
1253                   csym++;
1254                 }
1255             }
1256           else
1257             {
1258               /* Found a non-debuggable method symbol.  */
1259               if (syms != NULL)
1260                 syms[csym] = (struct symbol *) msymbol;
1261               csym++;
1262             }
1263         }
1264       if (objc_csym == NULL)
1265         {
1266           objc_csym = obstack_alloc (&objfile->objfile_obstack,
1267                                      sizeof (*objc_csym));
1268           *objc_csym = objfile_csym;
1269           set_objfile_data (objfile, objc_objfile_data, objc_csym);
1270         }
1271       else
1272         /* Count of ObjC methods in this objfile should be constant.  */
1273         gdb_assert (*objc_csym == objfile_csym);
1274     }
1275
1276   if (nsym != NULL)
1277     *nsym = csym;
1278   if (ndebug != NULL)
1279     *ndebug = cdebug;
1280 }
1281
1282 char *find_imps (struct symtab *symtab, struct block *block,
1283                  char *method, struct symbol **syms,
1284                  unsigned int *nsym, unsigned int *ndebug)
1285 {
1286   char type = '\0';
1287   char *class = NULL;
1288   char *category = NULL;
1289   char *selector = NULL;
1290
1291   unsigned int csym = 0;
1292   unsigned int cdebug = 0;
1293
1294   unsigned int ncsym = 0;
1295   unsigned int ncdebug = 0;
1296
1297   char *buf = NULL;
1298   char *tmp = NULL;
1299
1300   gdb_assert (nsym != NULL);
1301   gdb_assert (ndebug != NULL);
1302
1303   if (nsym != NULL)
1304     *nsym = 0;
1305   if (ndebug != NULL)
1306     *ndebug = 0;
1307
1308   buf = (char *) alloca (strlen (method) + 1);
1309   strcpy (buf, method);
1310   tmp = parse_method (buf, &type, &class, &category, &selector);
1311
1312   if (tmp == NULL) {
1313
1314     struct symbol *sym = NULL;
1315     struct minimal_symbol *msym = NULL;
1316
1317     strcpy (buf, method);
1318     tmp = parse_selector (buf, &selector);
1319
1320     if (tmp == NULL)
1321       return NULL;
1322
1323     sym = lookup_symbol (selector, block, VAR_DOMAIN, 0);
1324     if (sym != NULL)
1325       {
1326         if (syms)
1327           syms[csym] = sym;
1328         csym++;
1329         cdebug++;
1330       }
1331
1332     if (sym == NULL)
1333       msym = lookup_minimal_symbol (selector, 0, 0);
1334
1335     if (msym != NULL)
1336       {
1337         if (syms)
1338           syms[csym] = (struct symbol *)msym;
1339         csym++;
1340       }
1341   }
1342
1343   if (syms != NULL)
1344     find_methods (symtab, type, class, category, selector,
1345                   syms + csym, &ncsym, &ncdebug);
1346   else
1347     find_methods (symtab, type, class, category, selector,
1348                   NULL, &ncsym, &ncdebug);
1349
1350   /* If we didn't find any methods, just return.  */
1351   if (ncsym == 0 && ncdebug == 0)
1352     return method;
1353
1354   /* Take debug symbols from the second batch of symbols and swap them
1355    * with debug symbols from the first batch.  Repeat until either the
1356    * second section is out of debug symbols or the first section is
1357    * full of debug symbols.  Either way we have all debug symbols
1358    * packed to the beginning of the buffer.
1359    */
1360
1361   if (syms != NULL)
1362     {
1363       while ((cdebug < csym) && (ncdebug > 0))
1364         {
1365           struct symbol *s = NULL;
1366           /* First non-debugging symbol.  */
1367           unsigned int i = cdebug;
1368           /* Last of second batch of debug symbols.  */
1369           unsigned int j = csym + ncdebug - 1;
1370
1371           s = syms[j];
1372           syms[j] = syms[i];
1373           syms[i] = s;
1374
1375           /* We've moved a symbol from the second debug section to the
1376              first one.  */
1377           cdebug++;
1378           ncdebug--;
1379         }
1380     }
1381
1382   csym += ncsym;
1383   cdebug += ncdebug;
1384
1385   if (nsym != NULL)
1386     *nsym = csym;
1387   if (ndebug != NULL)
1388     *ndebug = cdebug;
1389
1390   if (syms == NULL)
1391     return method + (tmp - buf);
1392
1393   if (csym > 1)
1394     {
1395       /* Sort debuggable symbols.  */
1396       if (cdebug > 1)
1397         qsort (syms, cdebug, sizeof (struct minimal_symbol *),
1398                compare_classes);
1399
1400       /* Sort minimal_symbols.  */
1401       if ((csym - cdebug) > 1)
1402         qsort (&syms[cdebug], csym - cdebug,
1403                sizeof (struct minimal_symbol *), compare_classes);
1404     }
1405   /* Terminate the sym_arr list.  */
1406   syms[csym] = 0;
1407
1408   return method + (tmp - buf);
1409 }
1410
1411 static void
1412 print_object_command (char *args, int from_tty)
1413 {
1414   struct value *object, *function, *description;
1415   CORE_ADDR string_addr, object_addr;
1416   int i = 0;
1417   gdb_byte c = 0;
1418
1419   if (!args || !*args)
1420     error (
1421 "The 'print-object' command requires an argument (an Objective-C object)");
1422
1423   {
1424     struct expression *expr = parse_expression (args);
1425     struct cleanup *old_chain =
1426       make_cleanup (free_current_contents, &expr);
1427     int pc = 0;
1428
1429     object = evaluate_subexp (builtin_type (expr->gdbarch)->builtin_data_ptr,
1430                               expr, &pc, EVAL_NORMAL);
1431     do_cleanups (old_chain);
1432   }
1433
1434   /* Validate the address for sanity.  */
1435   object_addr = value_as_long (object);
1436   read_memory (object_addr, &c, 1);
1437
1438   function = find_function_in_inferior ("_NSPrintForDebugger", NULL);
1439   if (function == NULL)
1440     error (_("Unable to locate _NSPrintForDebugger in child process"));
1441
1442   description = call_function_by_hand (function, 1, &object);
1443
1444   string_addr = value_as_long (description);
1445   if (string_addr == 0)
1446     error (_("object returns null description"));
1447
1448   read_memory (string_addr + i++, &c, 1);
1449   if (c != 0)
1450     do
1451       { /* Read and print characters up to EOS.  */
1452         QUIT;
1453         printf_filtered ("%c", c);
1454         read_memory (string_addr + i++, &c, 1);
1455       } while (c != 0);
1456   else
1457     printf_filtered(_("<object returns empty description>"));
1458   printf_filtered ("\n");
1459 }
1460
1461 /* The data structure 'methcalls' is used to detect method calls (thru
1462  * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1463  * and ultimately find the method being called.
1464  */
1465
1466 struct objc_methcall {
1467   char *name;
1468  /* Return instance method to be called.  */
1469   int (*stop_at) (CORE_ADDR, CORE_ADDR *);
1470   /* Start of pc range corresponding to method invocation.  */
1471   CORE_ADDR begin;
1472   /* End of pc range corresponding to method invocation.  */
1473   CORE_ADDR end;
1474 };
1475
1476 static int resolve_msgsend (CORE_ADDR pc, CORE_ADDR *new_pc);
1477 static int resolve_msgsend_stret (CORE_ADDR pc, CORE_ADDR *new_pc);
1478 static int resolve_msgsend_super (CORE_ADDR pc, CORE_ADDR *new_pc);
1479 static int resolve_msgsend_super_stret (CORE_ADDR pc, CORE_ADDR *new_pc);
1480
1481 static struct objc_methcall methcalls[] = {
1482   { "_objc_msgSend", resolve_msgsend, 0, 0},
1483   { "_objc_msgSend_stret", resolve_msgsend_stret, 0, 0},
1484   { "_objc_msgSendSuper", resolve_msgsend_super, 0, 0},
1485   { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret, 0, 0},
1486   { "_objc_getClass", NULL, 0, 0},
1487   { "_objc_getMetaClass", NULL, 0, 0}
1488 };
1489
1490 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1491
1492 /* The following function, "find_objc_msgsend", fills in the data
1493  * structure "objc_msgs" by finding the addresses of each of the
1494  * (currently four) functions that it holds (of which objc_msgSend is
1495  * the first).  This must be called each time symbols are loaded, in
1496  * case the functions have moved for some reason.
1497  */
1498
1499 static void
1500 find_objc_msgsend (void)
1501 {
1502   unsigned int i;
1503   for (i = 0; i < nmethcalls; i++) {
1504
1505     struct minimal_symbol *func;
1506
1507     /* Try both with and without underscore.  */
1508     func = lookup_minimal_symbol (methcalls[i].name, NULL, NULL);
1509     if ((func == NULL) && (methcalls[i].name[0] == '_')) {
1510       func = lookup_minimal_symbol (methcalls[i].name + 1, NULL, NULL);
1511     }
1512     if (func == NULL) {
1513       methcalls[i].begin = 0;
1514       methcalls[i].end = 0;
1515       continue;
1516     }
1517
1518     methcalls[i].begin = SYMBOL_VALUE_ADDRESS (func);
1519     do {
1520       methcalls[i].end = SYMBOL_VALUE_ADDRESS (++func);
1521     } while (methcalls[i].begin == methcalls[i].end);
1522   }
1523 }
1524
1525 /* find_objc_msgcall (replaces pc_off_limits)
1526  *
1527  * ALL that this function now does is to determine whether the input
1528  * address ("pc") is the address of one of the Objective-C message
1529  * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1530  * if so, it returns the address of the method that will be called.
1531  *
1532  * The old function "pc_off_limits" used to do a lot of other things
1533  * in addition, such as detecting shared library jump stubs and
1534  * returning the address of the shlib function that would be called.
1535  * That functionality has been moved into the gdbarch_skip_trampoline_code and
1536  * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
1537  * dependent modules.
1538  */
1539
1540 struct objc_submethod_helper_data {
1541   int (*f) (CORE_ADDR, CORE_ADDR *);
1542   CORE_ADDR pc;
1543   CORE_ADDR *new_pc;
1544 };
1545
1546 static int
1547 find_objc_msgcall_submethod_helper (void * arg)
1548 {
1549   struct objc_submethod_helper_data *s =
1550     (struct objc_submethod_helper_data *) arg;
1551
1552   if (s->f (s->pc, s->new_pc) == 0)
1553     return 1;
1554   else
1555     return 0;
1556 }
1557
1558 static int
1559 find_objc_msgcall_submethod (int (*f) (CORE_ADDR, CORE_ADDR *),
1560                              CORE_ADDR pc,
1561                              CORE_ADDR *new_pc)
1562 {
1563   struct objc_submethod_helper_data s;
1564
1565   s.f = f;
1566   s.pc = pc;
1567   s.new_pc = new_pc;
1568
1569   if (catch_errors (find_objc_msgcall_submethod_helper,
1570                     (void *) &s,
1571                     "Unable to determine target of Objective-C method call (ignoring):\n",
1572                     RETURN_MASK_ALL) == 0)
1573     return 1;
1574   else
1575     return 0;
1576 }
1577
1578 int
1579 find_objc_msgcall (CORE_ADDR pc, CORE_ADDR *new_pc)
1580 {
1581   unsigned int i;
1582
1583   find_objc_msgsend ();
1584   if (new_pc != NULL)
1585     {
1586       *new_pc = 0;
1587     }
1588
1589   for (i = 0; i < nmethcalls; i++)
1590     if ((pc >= methcalls[i].begin) && (pc < methcalls[i].end))
1591       {
1592         if (methcalls[i].stop_at != NULL)
1593           return find_objc_msgcall_submethod (methcalls[i].stop_at,
1594                                               pc, new_pc);
1595         else
1596           return 0;
1597       }
1598
1599   return 0;
1600 }
1601
1602 extern initialize_file_ftype _initialize_objc_language; /* -Wmissing-prototypes */
1603
1604 void
1605 _initialize_objc_language (void)
1606 {
1607   add_language (&objc_language_defn);
1608   add_info ("selectors", selectors_info,    /* INFO SELECTORS command.  */
1609             _("All Objective-C selectors, or those matching REGEXP."));
1610   add_info ("classes", classes_info,        /* INFO CLASSES   command.  */
1611             _("All Objective-C classes, or those matching REGEXP."));
1612   add_com ("print-object", class_vars, print_object_command,
1613            _("Ask an Objective-C object to print itself."));
1614   add_com_alias ("po", "print-object", class_vars, 1);
1615 }
1616
1617 static void
1618 read_objc_method (struct gdbarch *gdbarch, CORE_ADDR addr,
1619                   struct objc_method *method)
1620 {
1621   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1622   method->name  = read_memory_unsigned_integer (addr + 0, 4, byte_order);
1623   method->types = read_memory_unsigned_integer (addr + 4, 4, byte_order);
1624   method->imp   = read_memory_unsigned_integer (addr + 8, 4, byte_order);
1625 }
1626
1627 static unsigned long
1628 read_objc_methlist_nmethods (struct gdbarch *gdbarch, CORE_ADDR addr)
1629 {
1630   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1631   return read_memory_unsigned_integer (addr + 4, 4, byte_order);
1632 }
1633
1634 static void
1635 read_objc_methlist_method (struct gdbarch *gdbarch, CORE_ADDR addr,
1636                            unsigned long num, struct objc_method *method)
1637 {
1638   gdb_assert (num < read_objc_methlist_nmethods (gdbarch, addr));
1639   read_objc_method (gdbarch, addr + 8 + (12 * num), method);
1640 }
1641
1642 static void
1643 read_objc_object (struct gdbarch *gdbarch, CORE_ADDR addr,
1644                   struct objc_object *object)
1645 {
1646   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1647   object->isa = read_memory_unsigned_integer (addr, 4, byte_order);
1648 }
1649
1650 static void
1651 read_objc_super (struct gdbarch *gdbarch, CORE_ADDR addr,
1652                  struct objc_super *super)
1653 {
1654   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1655   super->receiver = read_memory_unsigned_integer (addr, 4, byte_order);
1656   super->class = read_memory_unsigned_integer (addr + 4, 4, byte_order);
1657 };
1658
1659 static void
1660 read_objc_class (struct gdbarch *gdbarch, CORE_ADDR addr,
1661                  struct objc_class *class)
1662 {
1663   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1664   class->isa = read_memory_unsigned_integer (addr, 4, byte_order);
1665   class->super_class = read_memory_unsigned_integer (addr + 4, 4, byte_order);
1666   class->name = read_memory_unsigned_integer (addr + 8, 4, byte_order);
1667   class->version = read_memory_unsigned_integer (addr + 12, 4, byte_order);
1668   class->info = read_memory_unsigned_integer (addr + 16, 4, byte_order);
1669   class->instance_size = read_memory_unsigned_integer (addr + 18, 4, byte_order);
1670   class->ivars = read_memory_unsigned_integer (addr + 24, 4, byte_order);
1671   class->methods = read_memory_unsigned_integer (addr + 28, 4, byte_order);
1672   class->cache = read_memory_unsigned_integer (addr + 32, 4, byte_order);
1673   class->protocols = read_memory_unsigned_integer (addr + 36, 4, byte_order);
1674 }
1675
1676 static CORE_ADDR
1677 find_implementation_from_class (struct gdbarch *gdbarch,
1678                                 CORE_ADDR class, CORE_ADDR sel)
1679 {
1680   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1681   CORE_ADDR subclass = class;
1682
1683   while (subclass != 0)
1684     {
1685
1686       struct objc_class class_str;
1687       unsigned mlistnum = 0;
1688
1689       read_objc_class (gdbarch, subclass, &class_str);
1690
1691       for (;;)
1692         {
1693           CORE_ADDR mlist;
1694           unsigned long nmethods;
1695           unsigned long i;
1696
1697           mlist = read_memory_unsigned_integer (class_str.methods +
1698                                                 (4 * mlistnum),
1699                                                 4, byte_order);
1700           if (mlist == 0)
1701             break;
1702
1703           nmethods = read_objc_methlist_nmethods (gdbarch, mlist);
1704
1705           for (i = 0; i < nmethods; i++)
1706             {
1707               struct objc_method meth_str;
1708               read_objc_methlist_method (gdbarch, mlist, i, &meth_str);
1709
1710 #if 0
1711               fprintf (stderr,
1712                        "checking method 0x%lx against selector 0x%lx\n",
1713                        meth_str.name, sel);
1714 #endif
1715
1716               if (meth_str.name == sel)
1717                 /* FIXME: hppa arch was doing a pointer dereference
1718                    here. There needs to be a better way to do that.  */
1719                 return meth_str.imp;
1720             }
1721           mlistnum++;
1722         }
1723       subclass = class_str.super_class;
1724     }
1725
1726   return 0;
1727 }
1728
1729 static CORE_ADDR
1730 find_implementation (struct gdbarch *gdbarch,
1731                      CORE_ADDR object, CORE_ADDR sel)
1732 {
1733   struct objc_object ostr;
1734
1735   if (object == 0)
1736     return 0;
1737   read_objc_object (gdbarch, object, &ostr);
1738   if (ostr.isa == 0)
1739     return 0;
1740
1741   return find_implementation_from_class (gdbarch, ostr.isa, sel);
1742 }
1743
1744 static int
1745 resolve_msgsend (CORE_ADDR pc, CORE_ADDR *new_pc)
1746 {
1747   struct frame_info *frame = get_current_frame ();
1748   struct gdbarch *gdbarch = get_frame_arch (frame);
1749   struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1750
1751   CORE_ADDR object;
1752   CORE_ADDR sel;
1753   CORE_ADDR res;
1754
1755   object = gdbarch_fetch_pointer_argument (gdbarch, frame, 0, ptr_type);
1756   sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1757
1758   res = find_implementation (gdbarch, object, sel);
1759   if (new_pc != 0)
1760     *new_pc = res;
1761   if (res == 0)
1762     return 1;
1763   return 0;
1764 }
1765
1766 static int
1767 resolve_msgsend_stret (CORE_ADDR pc, CORE_ADDR *new_pc)
1768 {
1769   struct frame_info *frame = get_current_frame ();
1770   struct gdbarch *gdbarch = get_frame_arch (frame);
1771   struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1772
1773   CORE_ADDR object;
1774   CORE_ADDR sel;
1775   CORE_ADDR res;
1776
1777   object = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1778   sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 2, ptr_type);
1779
1780   res = find_implementation (gdbarch, object, sel);
1781   if (new_pc != 0)
1782     *new_pc = res;
1783   if (res == 0)
1784     return 1;
1785   return 0;
1786 }
1787
1788 static int
1789 resolve_msgsend_super (CORE_ADDR pc, CORE_ADDR *new_pc)
1790 {
1791   struct frame_info *frame = get_current_frame ();
1792   struct gdbarch *gdbarch = get_frame_arch (frame);
1793   struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1794
1795   struct objc_super sstr;
1796
1797   CORE_ADDR super;
1798   CORE_ADDR sel;
1799   CORE_ADDR res;
1800
1801   super = gdbarch_fetch_pointer_argument (gdbarch, frame, 0, ptr_type);
1802   sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1803
1804   read_objc_super (gdbarch, super, &sstr);
1805   if (sstr.class == 0)
1806     return 0;
1807
1808   res = find_implementation_from_class (gdbarch, sstr.class, sel);
1809   if (new_pc != 0)
1810     *new_pc = res;
1811   if (res == 0)
1812     return 1;
1813   return 0;
1814 }
1815
1816 static int
1817 resolve_msgsend_super_stret (CORE_ADDR pc, CORE_ADDR *new_pc)
1818 {
1819   struct frame_info *frame = get_current_frame ();
1820   struct gdbarch *gdbarch = get_frame_arch (frame);
1821   struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1822
1823   struct objc_super sstr;
1824
1825   CORE_ADDR super;
1826   CORE_ADDR sel;
1827   CORE_ADDR res;
1828
1829   super = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1830   sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 2, ptr_type);
1831
1832   read_objc_super (gdbarch, super, &sstr);
1833   if (sstr.class == 0)
1834     return 0;
1835
1836   res = find_implementation_from_class (gdbarch, sstr.class, sel);
1837   if (new_pc != 0)
1838     *new_pc = res;
1839   if (res == 0)
1840     return 1;
1841   return 0;
1842 }
1843
1844 void
1845 _initialize_objc_lang (void)
1846 {
1847   objc_objfile_data = register_objfile_data ();
1848 }