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   LANG_MAGIC
 413 };
 414
 415 /*
 416  * ObjC:
 417  * Following functions help construct Objective-C message calls.
 418  */
 419
 420 struct selname          /* For parsing Objective-C.  */
 421   {
 422     struct selname *next;
 423     char *msglist_sel;
 424     int msglist_len;
 425   };
 426
 427 static int msglist_len;
 428 static struct selname *selname_chain;
 429 static char *msglist_sel;
 430
 431 void
 432 start_msglist(void)
 433 {
 434   struct selname *newobj = XNEW (struct selname);
 435
 436   newobj->next = selname_chain;
 437   newobj->msglist_len = msglist_len;
 438   newobj->msglist_sel = msglist_sel;
 439   msglist_len = 0;
 440   msglist_sel = (char *)xmalloc(1);
 441   *msglist_sel = 0;
 442   selname_chain = newobj;
 443 }
 444
 445 void
 446 add_msglist(struct stoken *str, int addcolon)
 447 {
 448   char *s;
 449   const char *p;
 450   int len, plen;
 451
 452   if (str == 0)                 /* Unnamed arg, or...  */
 453     {
 454       if (addcolon == 0)        /* variable number of args.  */
 455         {
 456           msglist_len++;
 457           return;
 458         }
 459       p = "";
 460       plen = 0;
 461     }
 462   else
 463     {
 464       p = str->ptr;
 465       plen = str->length;
 466     }
 467   len = plen + strlen(msglist_sel) + 2;
 468   s = (char *)xmalloc(len);
 469   strcpy(s, msglist_sel);
 470   strncat(s, p, plen);
 471   xfree(msglist_sel);
 472   msglist_sel = s;
 473   if (addcolon)
 474     {
 475       s[len-2] = ':';
 476       s[len-1] = 0;
 477       msglist_len++;
 478     }
 479   else
 480     s[len-2] = '\0';
 481 }
 482
 483 int
 484 end_msglist (struct parser_state *ps)
 485 {
 486   int val = msglist_len;
 487   struct selname *sel = selname_chain;
 488   char *p = msglist_sel;
 489   CORE_ADDR selid;
 490
 491   selname_chain = sel->next;
 492   msglist_len = sel->msglist_len;
 493   msglist_sel = sel->msglist_sel;
 494   selid = lookup_child_selector (parse_gdbarch (ps), p);
 495   if (!selid)
 496     error (_("Can't find selector \"%s\""), p);
 497   write_exp_elt_longcst (ps, selid);
 498   xfree(p);
 499   write_exp_elt_longcst (ps, val);      /* Number of args */
 500   xfree(sel);
 501
 502   return val;
 503 }
 504
 505 /*
 506  * Function: specialcmp (const char *a, const char *b)
 507  *
 508  * Special strcmp: treats ']' and ' ' as end-of-string.
 509  * Used for qsorting lists of objc methods (either by class or selector).
 510  */
 511
 512 static int
 513 specialcmp (const char *a, const char *b)
 514 {
 515   while (*a && *a != ' ' && *a != ']' && *b && *b != ' ' && *b != ']')
 516     {
 517       if (*a != *b)
 518         return *a - *b;
 519       a++, b++;
 520     }
 521   if (*a && *a != ' ' && *a != ']')
 522     return  1;          /* a is longer therefore greater.  */
 523   if (*b && *b != ' ' && *b != ']')
 524     return -1;          /* a is shorter therefore lesser.  */
 525   return    0;          /* a and b are identical.  */
 526 }
 527
 528 /*
 529  * Function: compare_selectors (const void *, const void *)
 530  *
 531  * Comparison function for use with qsort.  Arguments are symbols or
 532  * msymbols Compares selector part of objc method name alphabetically.
 533  */
 534
 535 static int
 536 compare_selectors (const void *a, const void *b)
 537 {
 538   const char *aname, *bname;
 539
 540   aname = SYMBOL_PRINT_NAME (*(struct symbol **) a);
 541   bname = SYMBOL_PRINT_NAME (*(struct symbol **) b);
 542   if (aname == NULL || bname == NULL)
 543     error (_("internal: compare_selectors(1)"));
 544
 545   aname = strchr(aname, ' ');
 546   bname = strchr(bname, ' ');
 547   if (aname == NULL || bname == NULL)
 548     error (_("internal: compare_selectors(2)"));
 549
 550   return specialcmp (aname+1, bname+1);
 551 }
 552
 553 /*
 554  * Function: selectors_info (regexp, from_tty)
 555  *
 556  * Implements the "Info selectors" command.  Takes an optional regexp
 557  * arg.  Lists all objective c selectors that match the regexp.  Works
 558  * by grepping thru all symbols for objective c methods.  Output list
 559  * is sorted and uniqued.
 560  */
 561
 562 static void
 563 info_selectors_command (const char *regexp, int from_tty)
 564 {
 565   struct objfile        *objfile;
 566   struct minimal_symbol *msymbol;
 567   const char            *name;
 568   char                  *val;
 569   int                    matches = 0;
 570   int                    maxlen  = 0;
 571   int                    ix;
 572   char                   myregexp[2048];
 573   char                   asel[256];
 574   struct symbol        **sym_arr;
 575   int                    plusminus = 0;
 576
 577   if (regexp == NULL)
 578     strcpy(myregexp, ".*]");    /* Null input, match all objc methods.  */
 579   else
 580     {
 581       if (*regexp == '+' || *regexp == '-')
 582         { /* User wants only class methods or only instance methods.  */
 583           plusminus = *regexp++;
 584           while (*regexp == ' ' || *regexp == '\t')
 585             regexp++;
 586         }
 587       if (*regexp == '\0')
 588         strcpy(myregexp, ".*]");
 589       else
 590         {
 591           /* Allow a few extra bytes because of the strcat below.  */
 592           if (sizeof (myregexp) < strlen (regexp) + 4)
 593             error (_("Regexp is too long: %s"), regexp);
 594           strcpy(myregexp, regexp);
 595           if (myregexp[strlen(myregexp) - 1] == '$') /* end of selector */
 596             myregexp[strlen(myregexp) - 1] = ']';    /* end of method name */
 597           else
 598             strcat(myregexp, ".*]");
 599         }
 600     }
 601
 602   if (regexp != NULL)
 603     {
 604       val = re_comp (myregexp);
 605       if (val != 0)
 606         error (_("Invalid regexp (%s): %s"), val, regexp);
 607     }
 608
 609   /* First time thru is JUST to get max length and count.  */
 610   ALL_MSYMBOLS (objfile, msymbol)
 611     {
 612       QUIT;
 613       name = MSYMBOL_NATURAL_NAME (msymbol);
 614       if (name
 615           && (name[0] == '-' || name[0] == '+')
 616           && name[1] == '[')            /* Got a method name.  */
 617         {
 618           /* Filter for class/instance methods.  */
 619           if (plusminus && name[0] != plusminus)
 620             continue;
 621           /* Find selector part.  */
 622           name = (char *) strchr (name+2, ' ');
 623           if (name == NULL)
 624             {
 625               complaint (_("Bad method name '%s'"),
 626                          MSYMBOL_NATURAL_NAME (msymbol));
 627               continue;
 628             }
 629           if (regexp == NULL || re_exec(++name) != 0)
 630             {
 631               const char *mystart = name;
 632               const char *myend   = strchr (mystart, ']');
 633
 634               if (myend && (myend - mystart > maxlen))
 635                 maxlen = myend - mystart;       /* Get longest selector.  */
 636               matches++;
 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       ALL_MSYMBOLS (objfile, msymbol)
 648         {
 649           QUIT;
 650           name = MSYMBOL_NATURAL_NAME (msymbol);
 651           if (name &&
 652              (name[0] == '-' || name[0] == '+') &&
 653               name[1] == '[')           /* Got a method name.  */
 654             {
 655               /* Filter for class/instance methods.  */
 656               if (plusminus && name[0] != plusminus)
 657                 continue;
 658               /* Find selector part.  */
 659               name = (char *) strchr(name+2, ' ');
 660               if (regexp == NULL || re_exec(++name) != 0)
 661                 sym_arr[matches++] = (struct symbol *) msymbol;
 662             }
 663         }
 664
 665       qsort (sym_arr, matches, sizeof (struct minimal_symbol *),
 666              compare_selectors);
 667       /* Prevent compare on first iteration.  */
 668       asel[0] = 0;
 669       for (ix = 0; ix < matches; ix++)  /* Now do the output.  */
 670         {
 671           char *p = asel;
 672
 673           QUIT;
 674           name = SYMBOL_NATURAL_NAME (sym_arr[ix]);
 675           name = strchr (name, ' ') + 1;
 676           if (p[0] && specialcmp(name, p) == 0)
 677             continue;           /* Seen this one already (not unique).  */
 678
 679           /* Copy selector part.  */
 680           while (*name && *name != ']')
 681             *p++ = *name++;
 682           *p++ = '\0';
 683           /* Print in columns.  */
 684           puts_filtered_tabular(asel, maxlen + 1, 0);
 685         }
 686       begin_line();
 687     }
 688   else
 689     printf_filtered (_("No selectors matching \"%s\"\n"),
 690                      regexp ? regexp : "*");
 691 }
 692
 693 /*
 694  * Function: compare_classes (const void *, const void *)
 695  *
 696  * Comparison function for use with qsort.  Arguments are symbols or
 697  * msymbols Compares class part of objc method name alphabetically.
 698  */
 699
 700 static int
 701 compare_classes (const void *a, const void *b)
 702 {
 703   const char *aname, *bname;
 704
 705   aname = SYMBOL_PRINT_NAME (*(struct symbol **) a);
 706   bname = SYMBOL_PRINT_NAME (*(struct symbol **) b);
 707   if (aname == NULL || bname == NULL)
 708     error (_("internal: compare_classes(1)"));
 709
 710   return specialcmp (aname+1, bname+1);
 711 }
 712
 713 /*
 714  * Function: classes_info(regexp, from_tty)
 715  *
 716  * Implements the "info classes" command for objective c classes.
 717  * Lists all objective c classes that match the optional regexp.
 718  * Works by grepping thru the list of objective c methods.  List will
 719  * be sorted and uniqued (since one class may have many methods).
 720  * BUGS: will not list a class that has no methods.
 721  */
 722
 723 static void
 724 info_classes_command (const char *regexp, int from_tty)
 725 {
 726   struct objfile        *objfile;
 727   struct minimal_symbol *msymbol;
 728   const char            *name;
 729   char                  *val;
 730   int                    matches = 0;
 731   int                    maxlen  = 0;
 732   int                    ix;
 733   char                   myregexp[2048];
 734   char                   aclass[256];
 735   struct symbol        **sym_arr;
 736
 737   if (regexp == NULL)
 738     strcpy(myregexp, ".* ");    /* Null input: match all objc classes.  */
 739   else
 740     {
 741       /* Allow a few extra bytes because of the strcat below.  */
 742       if (sizeof (myregexp) < strlen (regexp) + 4)
 743         error (_("Regexp is too long: %s"), regexp);
 744       strcpy(myregexp, regexp);
 745       if (myregexp[strlen(myregexp) - 1] == '$')
 746         /* In the method name, the end of the class name is marked by ' '.  */
 747         myregexp[strlen(myregexp) - 1] = ' ';
 748       else
 749         strcat(myregexp, ".* ");
 750     }
 751
 752   if (regexp != NULL)
 753     {
 754       val = re_comp (myregexp);
 755       if (val != 0)
 756         error (_("Invalid regexp (%s): %s"), val, regexp);
 757     }
 758
 759   /* First time thru is JUST to get max length and count.  */
 760   ALL_MSYMBOLS (objfile, msymbol)
 761     {
 762       QUIT;
 763       name = MSYMBOL_NATURAL_NAME (msymbol);
 764       if (name &&
 765          (name[0] == '-' || name[0] == '+') &&
 766           name[1] == '[')                       /* Got a method name.  */
 767         if (regexp == NULL || re_exec(name+2) != 0)
 768           {
 769             /* Compute length of classname part.  */
 770             const char *mystart = name + 2;
 771             const char *myend   = strchr (mystart, ' ');
 772
 773             if (myend && (myend - mystart > maxlen))
 774               maxlen = myend - mystart;
 775             matches++;
 776           }
 777     }
 778   if (matches)
 779     {
 780       printf_filtered (_("Classes matching \"%s\":\n\n"),
 781                        regexp ? regexp : "*");
 782       sym_arr = XALLOCAVEC (struct symbol *, matches);
 783       matches = 0;
 784       ALL_MSYMBOLS (objfile, msymbol)
 785         {
 786           QUIT;
 787           name = MSYMBOL_NATURAL_NAME (msymbol);
 788           if (name &&
 789              (name[0] == '-' || name[0] == '+') &&
 790               name[1] == '[')                   /* Got a method name.  */
 791             if (regexp == NULL || re_exec(name+2) != 0)
 792                 sym_arr[matches++] = (struct symbol *) msymbol;
 793         }
 794
 795       qsort (sym_arr, matches, sizeof (struct minimal_symbol *),
 796              compare_classes);
 797       /* Prevent compare on first iteration.  */
 798       aclass[0] = 0;
 799       for (ix = 0; ix < matches; ix++)  /* Now do the output.  */
 800         {
 801           char *p = aclass;
 802
 803           QUIT;
 804           name = SYMBOL_NATURAL_NAME (sym_arr[ix]);
 805           name += 2;
 806           if (p[0] && specialcmp(name, p) == 0)
 807             continue;   /* Seen this one already (not unique).  */
 808
 809           /* Copy class part of method name.  */
 810           while (*name && *name != ' ')
 811             *p++ = *name++;
 812           *p++ = '\0';
 813           /* Print in columns.  */
 814           puts_filtered_tabular(aclass, maxlen + 1, 0);
 815         }
 816       begin_line();
 817     }
 818   else
 819     printf_filtered (_("No classes matching \"%s\"\n"), regexp ? regexp : "*");
 820 }
 821
 822 static char *
 823 parse_selector (char *method, char **selector)
 824 {
 825   char *s1 = NULL;
 826   char *s2 = NULL;
 827   int found_quote = 0;
 828
 829   char *nselector = NULL;
 830
 831   gdb_assert (selector != NULL);
 832
 833   s1 = method;
 834
 835   s1 = skip_spaces (s1);
 836   if (*s1 == '\'')
 837     {
 838       found_quote = 1;
 839       s1++;
 840     }
 841   s1 = skip_spaces (s1);
 842
 843   nselector = s1;
 844   s2 = s1;
 845
 846   for (;;)
 847     {
 848       if (isalnum (*s2) || (*s2 == '_') || (*s2 == ':'))
 849         *s1++ = *s2;
 850       else if (isspace (*s2))
 851         ;
 852       else if ((*s2 == '\0') || (*s2 == '\''))
 853         break;
 854       else
 855         return NULL;
 856       s2++;
 857     }
 858   *s1++ = '\0';
 859
 860   s2 = skip_spaces (s2);
 861   if (found_quote)
 862     {
 863       if (*s2 == '\'')
 864         s2++;
 865       s2 = skip_spaces (s2);
 866     }
 867
 868   if (selector != NULL)
 869     *selector = nselector;
 870
 871   return s2;
 872 }
 873
 874 static char *
 875 parse_method (char *method, char *type, char **theclass,
 876               char **category, char **selector)
 877 {
 878   char *s1 = NULL;
 879   char *s2 = NULL;
 880   int found_quote = 0;
 881
 882   char ntype = '\0';
 883   char *nclass = NULL;
 884   char *ncategory = NULL;
 885   char *nselector = NULL;
 886
 887   gdb_assert (type != NULL);
 888   gdb_assert (theclass != NULL);
 889   gdb_assert (category != NULL);
 890   gdb_assert (selector != NULL);
 891
 892   s1 = method;
 893
 894   s1 = skip_spaces (s1);
 895   if (*s1 == '\'')
 896     {
 897       found_quote = 1;
 898       s1++;
 899     }
 900   s1 = skip_spaces (s1);
 901
 902   if ((s1[0] == '+') || (s1[0] == '-'))
 903     ntype = *s1++;
 904
 905   s1 = skip_spaces (s1);
 906
 907   if (*s1 != '[')
 908     return NULL;
 909   s1++;
 910
 911   nclass = s1;
 912   while (isalnum (*s1) || (*s1 == '_'))
 913     s1++;
 914
 915   s2 = s1;
 916   s2 = skip_spaces (s2);
 917
 918   if (*s2 == '(')
 919     {
 920       s2++;
 921       s2 = skip_spaces (s2);
 922       ncategory = s2;
 923       while (isalnum (*s2) || (*s2 == '_'))
 924         s2++;
 925       *s2++ = '\0';
 926     }
 927
 928   /* Truncate the class name now that we're not using the open paren.  */
 929   *s1++ = '\0';
 930
 931   nselector = s2;
 932   s1 = s2;
 933
 934   for (;;)
 935     {
 936       if (isalnum (*s2) || (*s2 == '_') || (*s2 == ':'))
 937         *s1++ = *s2;
 938       else if (isspace (*s2))
 939         ;
 940       else if (*s2 == ']')
 941         break;
 942       else
 943         return NULL;
 944       s2++;
 945     }
 946   *s1++ = '\0';
 947   s2++;
 948
 949   s2 = skip_spaces (s2);
 950   if (found_quote)
 951     {
 952       if (*s2 != '\'')
 953         return NULL;
 954       s2++;
 955       s2 = skip_spaces (s2);
 956     }
 957
 958   if (type != NULL)
 959     *type = ntype;
 960   if (theclass != NULL)
 961     *theclass = nclass;
 962   if (category != NULL)
 963     *category = ncategory;
 964   if (selector != NULL)
 965     *selector = nselector;
 966
 967   return s2;
 968 }
 969
 970 static void
 971 find_methods (char type, const char *theclass, const char *category,
 972               const char *selector,
 973               std::vector<const char *> *symbol_names)
 974 {
 975   const char *symname = NULL;
 976
 977   char ntype = '\0';
 978   char *nclass = NULL;
 979   char *ncategory = NULL;
 980   char *nselector = NULL;
 981
 982   static char *tmp = NULL;
 983   static unsigned int tmplen = 0;
 984
 985   gdb_assert (symbol_names != NULL);
 986
 987   for (objfile *objfile : all_objfiles (current_program_space))
 988     {
 989       unsigned int *objc_csym;
 990       struct minimal_symbol *msymbol = NULL;
 991
 992       /* The objfile_csym variable counts the number of ObjC methods
 993          that this objfile defines.  We save that count as a private
 994          objfile data.  If we have already determined that this objfile
 995          provides no ObjC methods, we can skip it entirely.  */
 996
 997       unsigned int objfile_csym = 0;
 998
 999       objc_csym = (unsigned int *) objfile_data (objfile, objc_objfile_data);
1000       if (objc_csym != NULL && *objc_csym == 0)
1001         /* There are no ObjC symbols in this objfile.  Skip it entirely.  */
1002         continue;
1003
1004       ALL_OBJFILE_MSYMBOLS (objfile, msymbol)
1005         {
1006           QUIT;
1007
1008           /* Check the symbol name first as this can be done entirely without
1009              sending any query to the target.  */
1010           symname = MSYMBOL_NATURAL_NAME (msymbol);
1011           if (symname == NULL)
1012             continue;
1013
1014           if ((symname[0] != '-' && symname[0] != '+') || (symname[1] != '['))
1015             /* Not a method name.  */
1016             continue;
1017
1018           objfile_csym++;
1019
1020           /* Now that thinks are a bit sane, clean up the symname.  */
1021           while ((strlen (symname) + 1) >= tmplen)
1022             {
1023               tmplen = (tmplen == 0) ? 1024 : tmplen * 2;
1024               tmp = (char *) xrealloc (tmp, tmplen);
1025             }
1026           strcpy (tmp, symname);
1027
1028           if (parse_method (tmp, &ntype, &nclass,
1029                             &ncategory, &nselector) == NULL)
1030             continue;
1031
1032           if ((type != '\0') && (ntype != type))
1033             continue;
1034
1035           if ((theclass != NULL)
1036               && ((nclass == NULL) || (strcmp (theclass, nclass) != 0)))
1037             continue;
1038
1039           if ((category != NULL) &&
1040               ((ncategory == NULL) || (strcmp (category, ncategory) != 0)))
1041             continue;
1042
1043           if ((selector != NULL) &&
1044               ((nselector == NULL) || (strcmp (selector, nselector) != 0)))
1045             continue;
1046
1047           symbol_names->push_back (symname);
1048         }
1049
1050       if (objc_csym == NULL)
1051         {
1052           objc_csym = XOBNEW (&objfile->objfile_obstack, unsigned int);
1053           *objc_csym = objfile_csym;
1054           set_objfile_data (objfile, objc_objfile_data, objc_csym);
1055         }
1056       else
1057         /* Count of ObjC methods in this objfile should be constant.  */
1058         gdb_assert (*objc_csym == objfile_csym);
1059     }
1060 }
1061
1062 /* Uniquify a VEC of strings.  */
1063
1064 static void
1065 uniquify_strings (std::vector<const char *> *strings)
1066 {
1067   if (strings->empty ())
1068     return;
1069
1070   std::sort (strings->begin (), strings->end (), compare_cstrings);
1071   strings->erase (std::unique (strings->begin (), strings->end (), streq),
1072                   strings->end ());
1073 }
1074
1075 /*
1076  * Function: find_imps (const char *selector, struct symbol **sym_arr)
1077  *
1078  * Input:  a string representing a selector
1079  *         a pointer to an array of symbol pointers
1080  *         possibly a pointer to a symbol found by the caller.
1081  *
1082  * Output: number of methods that implement that selector.  Side
1083  * effects: The array of symbol pointers is filled with matching syms.
1084  *
1085  * By analogy with function "find_methods" (symtab.c), builds a list
1086  * of symbols matching the ambiguous input, so that "decode_line_2"
1087  * (symtab.c) can list them and ask the user to choose one or more.
1088  * In this case the matches are objective c methods
1089  * ("implementations") matching an objective c selector.
1090  *
1091  * Note that it is possible for a normal (c-style) function to have
1092  * the same name as an objective c selector.  To prevent the selector
1093  * from eclipsing the function, we allow the caller (decode_line_1) to
1094  * search for such a function first, and if it finds one, pass it in
1095  * to us.  We will then integrate it into the list.  We also search
1096  * for one here, among the minsyms.
1097  *
1098  * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be divided
1099  *       into two parts: debuggable (struct symbol) syms, and
1100  *       non_debuggable (struct minimal_symbol) syms.  The debuggable
1101  *       ones will come first, before NUM_DEBUGGABLE (which will thus
1102  *       be the index of the first non-debuggable one).
1103  */
1104
1105 const char *
1106 find_imps (const char *method, std::vector<const char *> *symbol_names)
1107 {
1108   char type = '\0';
1109   char *theclass = NULL;
1110   char *category = NULL;
1111   char *selector = NULL;
1112
1113   char *buf = NULL;
1114   char *tmp = NULL;
1115
1116   int selector_case = 0;
1117
1118   gdb_assert (symbol_names != NULL);
1119
1120   buf = (char *) alloca (strlen (method) + 1);
1121   strcpy (buf, method);
1122   tmp = parse_method (buf, &type, &theclass, &category, &selector);
1123
1124   if (tmp == NULL)
1125     {
1126       strcpy (buf, method);
1127       tmp = parse_selector (buf, &selector);
1128
1129       if (tmp == NULL)
1130         return NULL;
1131
1132       selector_case = 1;
1133     }
1134
1135   find_methods (type, theclass, category, selector, symbol_names);
1136
1137   /* If we hit the "selector" case, and we found some methods, then
1138      add the selector itself as a symbol, if it exists.  */
1139   if (selector_case && !symbol_names->empty ())
1140     {
1141       struct symbol *sym = lookup_symbol (selector, NULL, VAR_DOMAIN,
1142                                           0).symbol;
1143
1144       if (sym != NULL)
1145         symbol_names->push_back (SYMBOL_NATURAL_NAME (sym));
1146       else
1147         {
1148           struct bound_minimal_symbol msym
1149             = lookup_minimal_symbol (selector, 0, 0);
1150
1151           if (msym.minsym != NULL)
1152             symbol_names->push_back (MSYMBOL_NATURAL_NAME (msym.minsym));
1153         }
1154     }
1155
1156   uniquify_strings (symbol_names);
1157
1158   return method + (tmp - buf);
1159 }
1160
1161 static void
1162 print_object_command (const char *args, int from_tty)
1163 {
1164   struct value *object, *function, *description;
1165   CORE_ADDR string_addr, object_addr;
1166   int i = 0;
1167   gdb_byte c = 0;
1168
1169   if (!args || !*args)
1170     error (
1171 "The 'print-object' command requires an argument (an Objective-C object)");
1172
1173   {
1174     expression_up expr = parse_expression (args);
1175     int pc = 0;
1176
1177     object = evaluate_subexp (builtin_type (expr->gdbarch)->builtin_data_ptr,
1178                               expr.get (), &pc, EVAL_NORMAL);
1179   }
1180
1181   /* Validate the address for sanity.  */
1182   object_addr = value_as_long (object);
1183   read_memory (object_addr, &c, 1);
1184
1185   function = find_function_in_inferior ("_NSPrintForDebugger", NULL);
1186   if (function == NULL)
1187     error (_("Unable to locate _NSPrintForDebugger in child process"));
1188
1189   description = call_function_by_hand (function, NULL, object);
1190
1191   string_addr = value_as_long (description);
1192   if (string_addr == 0)
1193     error (_("object returns null description"));
1194
1195   read_memory (string_addr + i++, &c, 1);
1196   if (c != 0)
1197     do
1198       { /* Read and print characters up to EOS.  */
1199         QUIT;
1200         printf_filtered ("%c", c);
1201         read_memory (string_addr + i++, &c, 1);
1202       } while (c != 0);
1203   else
1204     printf_filtered(_("<object returns empty description>"));
1205   printf_filtered ("\n");
1206 }
1207
1208 /* The data structure 'methcalls' is used to detect method calls (thru
1209  * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1210  * and ultimately find the method being called.
1211  */
1212
1213 struct objc_methcall {
1214   const char *name;
1215  /* Return instance method to be called.  */
1216   int (*stop_at) (CORE_ADDR, CORE_ADDR *);
1217   /* Start of pc range corresponding to method invocation.  */
1218   CORE_ADDR begin;
1219   /* End of pc range corresponding to method invocation.  */
1220   CORE_ADDR end;
1221 };
1222
1223 static int resolve_msgsend (CORE_ADDR pc, CORE_ADDR *new_pc);
1224 static int resolve_msgsend_stret (CORE_ADDR pc, CORE_ADDR *new_pc);
1225 static int resolve_msgsend_super (CORE_ADDR pc, CORE_ADDR *new_pc);
1226 static int resolve_msgsend_super_stret (CORE_ADDR pc, CORE_ADDR *new_pc);
1227
1228 static struct objc_methcall methcalls[] = {
1229   { "_objc_msgSend", resolve_msgsend, 0, 0},
1230   { "_objc_msgSend_stret", resolve_msgsend_stret, 0, 0},
1231   { "_objc_msgSendSuper", resolve_msgsend_super, 0, 0},
1232   { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret, 0, 0},
1233   { "_objc_getClass", NULL, 0, 0},
1234   { "_objc_getMetaClass", NULL, 0, 0}
1235 };
1236
1237 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1238
1239 /* The following function, "find_objc_msgsend", fills in the data
1240  * structure "objc_msgs" by finding the addresses of each of the
1241  * (currently four) functions that it holds (of which objc_msgSend is
1242  * the first).  This must be called each time symbols are loaded, in
1243  * case the functions have moved for some reason.
1244  */
1245
1246 static void
1247 find_objc_msgsend (void)
1248 {
1249   unsigned int i;
1250
1251   for (i = 0; i < nmethcalls; i++)
1252     {
1253       struct bound_minimal_symbol func;
1254
1255       /* Try both with and without underscore.  */
1256       func = lookup_bound_minimal_symbol (methcalls[i].name);
1257       if ((func.minsym == NULL) && (methcalls[i].name[0] == '_'))
1258         {
1259           func = lookup_bound_minimal_symbol (methcalls[i].name + 1);
1260         }
1261       if (func.minsym == NULL)
1262         {
1263           methcalls[i].begin = 0;
1264           methcalls[i].end = 0;
1265           continue;
1266         }
1267
1268       methcalls[i].begin = BMSYMBOL_VALUE_ADDRESS (func);
1269       methcalls[i].end = minimal_symbol_upper_bound (func);
1270     }
1271 }
1272
1273 /* find_objc_msgcall (replaces pc_off_limits)
1274  *
1275  * ALL that this function now does is to determine whether the input
1276  * address ("pc") is the address of one of the Objective-C message
1277  * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1278  * if so, it returns the address of the method that will be called.
1279  *
1280  * The old function "pc_off_limits" used to do a lot of other things
1281  * in addition, such as detecting shared library jump stubs and
1282  * returning the address of the shlib function that would be called.
1283  * That functionality has been moved into the gdbarch_skip_trampoline_code and
1284  * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
1285  * dependent modules.
1286  */
1287
1288 static int
1289 find_objc_msgcall_submethod (int (*f) (CORE_ADDR, CORE_ADDR *),
1290                              CORE_ADDR pc,
1291                              CORE_ADDR *new_pc)
1292 {
1293   TRY
1294     {
1295       if (f (pc, new_pc) == 0)
1296         return 1;
1297     }
1298   CATCH (ex, RETURN_MASK_ALL)
1299     {
1300       exception_fprintf (gdb_stderr, ex,
1301                          "Unable to determine target of "
1302                          "Objective-C method call (ignoring):\n");
1303     }
1304   END_CATCH
1305
1306   return 0;
1307 }
1308
1309 int
1310 find_objc_msgcall (CORE_ADDR pc, CORE_ADDR *new_pc)
1311 {
1312   unsigned int i;
1313
1314   find_objc_msgsend ();
1315   if (new_pc != NULL)
1316     {
1317       *new_pc = 0;
1318     }
1319
1320   for (i = 0; i < nmethcalls; i++)
1321     if ((pc >= methcalls[i].begin) && (pc < methcalls[i].end))
1322       {
1323         if (methcalls[i].stop_at != NULL)
1324           return find_objc_msgcall_submethod (methcalls[i].stop_at,
1325                                               pc, new_pc);
1326         else
1327           return 0;
1328       }
1329
1330   return 0;
1331 }
1332
1333 void
1334 _initialize_objc_language (void)
1335 {
1336   add_info ("selectors", info_selectors_command,
1337             _("All Objective-C selectors, or those matching REGEXP."));
1338   add_info ("classes", info_classes_command,
1339             _("All Objective-C classes, or those matching REGEXP."));
1340   add_com ("print-object", class_vars, print_object_command,
1341            _("Ask an Objective-C object to print itself."));
1342   add_com_alias ("po", "print-object", class_vars, 1);
1343 }
1344
1345 static void
1346 read_objc_method (struct gdbarch *gdbarch, CORE_ADDR addr,
1347                   struct objc_method *method)
1348 {
1349   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1350
1351   method->name  = read_memory_unsigned_integer (addr + 0, 4, byte_order);
1352   method->types = read_memory_unsigned_integer (addr + 4, 4, byte_order);
1353   method->imp   = read_memory_unsigned_integer (addr + 8, 4, byte_order);
1354 }
1355
1356 static unsigned long
1357 read_objc_methlist_nmethods (struct gdbarch *gdbarch, CORE_ADDR addr)
1358 {
1359   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1360
1361   return read_memory_unsigned_integer (addr + 4, 4, byte_order);
1362 }
1363
1364 static void
1365 read_objc_methlist_method (struct gdbarch *gdbarch, CORE_ADDR addr,
1366                            unsigned long num, struct objc_method *method)
1367 {
1368   gdb_assert (num < read_objc_methlist_nmethods (gdbarch, addr));
1369   read_objc_method (gdbarch, addr + 8 + (12 * num), method);
1370 }
1371
1372 static void
1373 read_objc_object (struct gdbarch *gdbarch, CORE_ADDR addr,
1374                   struct objc_object *object)
1375 {
1376   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1377
1378   object->isa = read_memory_unsigned_integer (addr, 4, byte_order);
1379 }
1380
1381 static void
1382 read_objc_super (struct gdbarch *gdbarch, CORE_ADDR addr,
1383                  struct objc_super *super)
1384 {
1385   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1386
1387   super->receiver = read_memory_unsigned_integer (addr, 4, byte_order);
1388   super->theclass = read_memory_unsigned_integer (addr + 4, 4, byte_order);
1389 };
1390
1391 static void
1392 read_objc_class (struct gdbarch *gdbarch, CORE_ADDR addr,
1393                  struct objc_class *theclass)
1394 {
1395   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1396
1397   theclass->isa = read_memory_unsigned_integer (addr, 4, byte_order);
1398   theclass->super_class = read_memory_unsigned_integer (addr + 4, 4, byte_order);
1399   theclass->name = read_memory_unsigned_integer (addr + 8, 4, byte_order);
1400   theclass->version = read_memory_unsigned_integer (addr + 12, 4, byte_order);
1401   theclass->info = read_memory_unsigned_integer (addr + 16, 4, byte_order);
1402   theclass->instance_size = read_memory_unsigned_integer (addr + 18, 4,
1403                                                        byte_order);
1404   theclass->ivars = read_memory_unsigned_integer (addr + 24, 4, byte_order);
1405   theclass->methods = read_memory_unsigned_integer (addr + 28, 4, byte_order);
1406   theclass->cache = read_memory_unsigned_integer (addr + 32, 4, byte_order);
1407   theclass->protocols = read_memory_unsigned_integer (addr + 36, 4, byte_order);
1408 }
1409
1410 static CORE_ADDR
1411 find_implementation_from_class (struct gdbarch *gdbarch,
1412                                 CORE_ADDR theclass, CORE_ADDR sel)
1413 {
1414   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1415   CORE_ADDR subclass = theclass;
1416
1417   while (subclass != 0)
1418     {
1419
1420       struct objc_class class_str;
1421       unsigned mlistnum = 0;
1422
1423       read_objc_class (gdbarch, subclass, &class_str);
1424
1425       for (;;)
1426         {
1427           CORE_ADDR mlist;
1428           unsigned long nmethods;
1429           unsigned long i;
1430
1431           mlist = read_memory_unsigned_integer (class_str.methods +
1432                                                 (4 * mlistnum),
1433                                                 4, byte_order);
1434           if (mlist == 0)
1435             break;
1436
1437           nmethods = read_objc_methlist_nmethods (gdbarch, mlist);
1438
1439           for (i = 0; i < nmethods; i++)
1440             {
1441               struct objc_method meth_str;
1442
1443               read_objc_methlist_method (gdbarch, mlist, i, &meth_str);
1444
1445               if (meth_str.name == sel)
1446                 /* FIXME: hppa arch was doing a pointer dereference
1447                    here.  There needs to be a better way to do that.  */
1448                 return meth_str.imp;
1449             }
1450           mlistnum++;
1451         }
1452       subclass = class_str.super_class;
1453     }
1454
1455   return 0;
1456 }
1457
1458 static CORE_ADDR
1459 find_implementation (struct gdbarch *gdbarch,
1460                      CORE_ADDR object, CORE_ADDR sel)
1461 {
1462   struct objc_object ostr;
1463
1464   if (object == 0)
1465     return 0;
1466   read_objc_object (gdbarch, object, &ostr);
1467   if (ostr.isa == 0)
1468     return 0;
1469
1470   return find_implementation_from_class (gdbarch, ostr.isa, sel);
1471 }
1472
1473 static int
1474 resolve_msgsend (CORE_ADDR pc, CORE_ADDR *new_pc)
1475 {
1476   struct frame_info *frame = get_current_frame ();
1477   struct gdbarch *gdbarch = get_frame_arch (frame);
1478   struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1479
1480   CORE_ADDR object;
1481   CORE_ADDR sel;
1482   CORE_ADDR res;
1483
1484   object = gdbarch_fetch_pointer_argument (gdbarch, frame, 0, ptr_type);
1485   sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1486
1487   res = find_implementation (gdbarch, object, sel);
1488   if (new_pc != 0)
1489     *new_pc = res;
1490   if (res == 0)
1491     return 1;
1492   return 0;
1493 }
1494
1495 static int
1496 resolve_msgsend_stret (CORE_ADDR pc, CORE_ADDR *new_pc)
1497 {
1498   struct frame_info *frame = get_current_frame ();
1499   struct gdbarch *gdbarch = get_frame_arch (frame);
1500   struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1501
1502   CORE_ADDR object;
1503   CORE_ADDR sel;
1504   CORE_ADDR res;
1505
1506   object = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1507   sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 2, ptr_type);
1508
1509   res = find_implementation (gdbarch, object, sel);
1510   if (new_pc != 0)
1511     *new_pc = res;
1512   if (res == 0)
1513     return 1;
1514   return 0;
1515 }
1516
1517 static int
1518 resolve_msgsend_super (CORE_ADDR pc, CORE_ADDR *new_pc)
1519 {
1520   struct frame_info *frame = get_current_frame ();
1521   struct gdbarch *gdbarch = get_frame_arch (frame);
1522   struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1523
1524   struct objc_super sstr;
1525
1526   CORE_ADDR super;
1527   CORE_ADDR sel;
1528   CORE_ADDR res;
1529
1530   super = gdbarch_fetch_pointer_argument (gdbarch, frame, 0, ptr_type);
1531   sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1532
1533   read_objc_super (gdbarch, super, &sstr);
1534   if (sstr.theclass == 0)
1535     return 0;
1536
1537   res = find_implementation_from_class (gdbarch, sstr.theclass, sel);
1538   if (new_pc != 0)
1539     *new_pc = res;
1540   if (res == 0)
1541     return 1;
1542   return 0;
1543 }
1544
1545 static int
1546 resolve_msgsend_super_stret (CORE_ADDR pc, CORE_ADDR *new_pc)
1547 {
1548   struct frame_info *frame = get_current_frame ();
1549   struct gdbarch *gdbarch = get_frame_arch (frame);
1550   struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1551
1552   struct objc_super sstr;
1553
1554   CORE_ADDR super;
1555   CORE_ADDR sel;
1556   CORE_ADDR res;
1557
1558   super = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1559   sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 2, ptr_type);
1560
1561   read_objc_super (gdbarch, super, &sstr);
1562   if (sstr.theclass == 0)
1563     return 0;
1564
1565   res = find_implementation_from_class (gdbarch, sstr.theclass, sel);
1566   if (new_pc != 0)
1567     *new_pc = res;
1568   if (res == 0)
1569     return 1;
1570   return 0;
1571 }
1572
1573 void
1574 _initialize_objc_lang (void)
1575 {
1576   objc_objfile_data = register_objfile_data ();
1577 }