gdb/objc-lang.c

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