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