gdb/objc-lang.c

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