gdb/objc-lang.c

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