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