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