gdb/objc-lang.c

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