gdb/objc-lang.c

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