gdb/objc-lang.c

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