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