gdb/objc-lang.c

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