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).minsym)
 124     function = find_function_in_inferior("objc_lookUpClass", NULL);
 125   else if (lookup_minimal_symbol ("objc_lookup_class", 0, 0).minsym)
 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).minsym)
 153     function = find_function_in_inferior("sel_getUid", NULL);
 154   else if (lookup_minimal_symbol ("sel_get_any_uid", 0, 0).minsym)
 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).minsym)
 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).minsym)
 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).minsym)
 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 = MSYMBOL_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                          MSYMBOL_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 = MSYMBOL_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 = MSYMBOL_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 = MSYMBOL_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 = MSYMBOL_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 bound_minimal_symbol msym
1156             = lookup_minimal_symbol (selector, 0, 0);
1157
1158           if (msym.minsym != NULL)
1159             VEC_safe_push (const_char_ptr, *symbol_names,
1160                            MSYMBOL_NATURAL_NAME (msym.minsym));
1161         }
1162     }
1163
1164   uniquify_strings (symbol_names);
1165
1166   return method + (tmp - buf);
1167 }
1168
1169 static void
1170 print_object_command (char *args, int from_tty)
1171 {
1172   struct value *object, *function, *description;
1173   CORE_ADDR string_addr, object_addr;
1174   int i = 0;
1175   gdb_byte c = 0;
1176
1177   if (!args || !*args)
1178     error (
1179 "The 'print-object' command requires an argument (an Objective-C object)");
1180
1181   {
1182     struct expression *expr = parse_expression (args);
1183     struct cleanup *old_chain =
1184       make_cleanup (free_current_contents, &expr);
1185     int pc = 0;
1186
1187     object = evaluate_subexp (builtin_type (expr->gdbarch)->builtin_data_ptr,
1188                               expr, &pc, EVAL_NORMAL);
1189     do_cleanups (old_chain);
1190   }
1191
1192   /* Validate the address for sanity.  */
1193   object_addr = value_as_long (object);
1194   read_memory (object_addr, &c, 1);
1195
1196   function = find_function_in_inferior ("_NSPrintForDebugger", NULL);
1197   if (function == NULL)
1198     error (_("Unable to locate _NSPrintForDebugger in child process"));
1199
1200   description = call_function_by_hand (function, 1, &object);
1201
1202   string_addr = value_as_long (description);
1203   if (string_addr == 0)
1204     error (_("object returns null description"));
1205
1206   read_memory (string_addr + i++, &c, 1);
1207   if (c != 0)
1208     do
1209       { /* Read and print characters up to EOS.  */
1210         QUIT;
1211         printf_filtered ("%c", c);
1212         read_memory (string_addr + i++, &c, 1);
1213       } while (c != 0);
1214   else
1215     printf_filtered(_("<object returns empty description>"));
1216   printf_filtered ("\n");
1217 }
1218
1219 /* The data structure 'methcalls' is used to detect method calls (thru
1220  * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1221  * and ultimately find the method being called.
1222  */
1223
1224 struct objc_methcall {
1225   char *name;
1226  /* Return instance method to be called.  */
1227   int (*stop_at) (CORE_ADDR, CORE_ADDR *);
1228   /* Start of pc range corresponding to method invocation.  */
1229   CORE_ADDR begin;
1230   /* End of pc range corresponding to method invocation.  */
1231   CORE_ADDR end;
1232 };
1233
1234 static int resolve_msgsend (CORE_ADDR pc, CORE_ADDR *new_pc);
1235 static int resolve_msgsend_stret (CORE_ADDR pc, CORE_ADDR *new_pc);
1236 static int resolve_msgsend_super (CORE_ADDR pc, CORE_ADDR *new_pc);
1237 static int resolve_msgsend_super_stret (CORE_ADDR pc, CORE_ADDR *new_pc);
1238
1239 static struct objc_methcall methcalls[] = {
1240   { "_objc_msgSend", resolve_msgsend, 0, 0},
1241   { "_objc_msgSend_stret", resolve_msgsend_stret, 0, 0},
1242   { "_objc_msgSendSuper", resolve_msgsend_super, 0, 0},
1243   { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret, 0, 0},
1244   { "_objc_getClass", NULL, 0, 0},
1245   { "_objc_getMetaClass", NULL, 0, 0}
1246 };
1247
1248 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1249
1250 /* The following function, "find_objc_msgsend", fills in the data
1251  * structure "objc_msgs" by finding the addresses of each of the
1252  * (currently four) functions that it holds (of which objc_msgSend is
1253  * the first).  This must be called each time symbols are loaded, in
1254  * case the functions have moved for some reason.
1255  */
1256
1257 static void
1258 find_objc_msgsend (void)
1259 {
1260   unsigned int i;
1261
1262   for (i = 0; i < nmethcalls; i++)
1263     {
1264       struct bound_minimal_symbol func;
1265
1266       /* Try both with and without underscore.  */
1267       func = lookup_bound_minimal_symbol (methcalls[i].name);
1268       if ((func.minsym == NULL) && (methcalls[i].name[0] == '_'))
1269         {
1270           func = lookup_bound_minimal_symbol (methcalls[i].name + 1);
1271         }
1272       if (func.minsym == NULL)
1273         {
1274           methcalls[i].begin = 0;
1275           methcalls[i].end = 0;
1276           continue;
1277         }
1278
1279       methcalls[i].begin = BMSYMBOL_VALUE_ADDRESS (func);
1280       methcalls[i].end = minimal_symbol_upper_bound (func);
1281     }
1282 }
1283
1284 /* find_objc_msgcall (replaces pc_off_limits)
1285  *
1286  * ALL that this function now does is to determine whether the input
1287  * address ("pc") is the address of one of the Objective-C message
1288  * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1289  * if so, it returns the address of the method that will be called.
1290  *
1291  * The old function "pc_off_limits" used to do a lot of other things
1292  * in addition, such as detecting shared library jump stubs and
1293  * returning the address of the shlib function that would be called.
1294  * That functionality has been moved into the gdbarch_skip_trampoline_code and
1295  * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
1296  * dependent modules.
1297  */
1298
1299 struct objc_submethod_helper_data {
1300   int (*f) (CORE_ADDR, CORE_ADDR *);
1301   CORE_ADDR pc;
1302   CORE_ADDR *new_pc;
1303 };
1304
1305 static int
1306 find_objc_msgcall_submethod_helper (void * arg)
1307 {
1308   struct objc_submethod_helper_data *s =
1309     (struct objc_submethod_helper_data *) arg;
1310
1311   if (s->f (s->pc, s->new_pc) == 0)
1312     return 1;
1313   else
1314     return 0;
1315 }
1316
1317 static int
1318 find_objc_msgcall_submethod (int (*f) (CORE_ADDR, CORE_ADDR *),
1319                              CORE_ADDR pc,
1320                              CORE_ADDR *new_pc)
1321 {
1322   struct objc_submethod_helper_data s;
1323
1324   s.f = f;
1325   s.pc = pc;
1326   s.new_pc = new_pc;
1327
1328   if (catch_errors (find_objc_msgcall_submethod_helper,
1329                     (void *) &s,
1330                     "Unable to determine target of "
1331                     "Objective-C method call (ignoring):\n",
1332                     RETURN_MASK_ALL) == 0)
1333     return 1;
1334   else
1335     return 0;
1336 }
1337
1338 int
1339 find_objc_msgcall (CORE_ADDR pc, CORE_ADDR *new_pc)
1340 {
1341   unsigned int i;
1342
1343   find_objc_msgsend ();
1344   if (new_pc != NULL)
1345     {
1346       *new_pc = 0;
1347     }
1348
1349   for (i = 0; i < nmethcalls; i++)
1350     if ((pc >= methcalls[i].begin) && (pc < methcalls[i].end))
1351       {
1352         if (methcalls[i].stop_at != NULL)
1353           return find_objc_msgcall_submethod (methcalls[i].stop_at,
1354                                               pc, new_pc);
1355         else
1356           return 0;
1357       }
1358
1359   return 0;
1360 }
1361
1362 /* -Wmissing-prototypes */
1363 extern initialize_file_ftype _initialize_objc_language;
1364
1365 void
1366 _initialize_objc_language (void)
1367 {
1368   add_language (&objc_language_defn);
1369   add_info ("selectors", selectors_info,    /* INFO SELECTORS command.  */
1370             _("All Objective-C selectors, or those matching REGEXP."));
1371   add_info ("classes", classes_info,        /* INFO CLASSES   command.  */
1372             _("All Objective-C classes, or those matching REGEXP."));
1373   add_com ("print-object", class_vars, print_object_command,
1374            _("Ask an Objective-C object to print itself."));
1375   add_com_alias ("po", "print-object", class_vars, 1);
1376 }
1377
1378 static void
1379 read_objc_method (struct gdbarch *gdbarch, CORE_ADDR addr,
1380                   struct objc_method *method)
1381 {
1382   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1383
1384   method->name  = read_memory_unsigned_integer (addr + 0, 4, byte_order);
1385   method->types = read_memory_unsigned_integer (addr + 4, 4, byte_order);
1386   method->imp   = read_memory_unsigned_integer (addr + 8, 4, byte_order);
1387 }
1388
1389 static unsigned long
1390 read_objc_methlist_nmethods (struct gdbarch *gdbarch, CORE_ADDR addr)
1391 {
1392   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1393
1394   return read_memory_unsigned_integer (addr + 4, 4, byte_order);
1395 }
1396
1397 static void
1398 read_objc_methlist_method (struct gdbarch *gdbarch, CORE_ADDR addr,
1399                            unsigned long num, struct objc_method *method)
1400 {
1401   gdb_assert (num < read_objc_methlist_nmethods (gdbarch, addr));
1402   read_objc_method (gdbarch, addr + 8 + (12 * num), method);
1403 }
1404
1405 static void
1406 read_objc_object (struct gdbarch *gdbarch, CORE_ADDR addr,
1407                   struct objc_object *object)
1408 {
1409   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1410
1411   object->isa = read_memory_unsigned_integer (addr, 4, byte_order);
1412 }
1413
1414 static void
1415 read_objc_super (struct gdbarch *gdbarch, CORE_ADDR addr,
1416                  struct objc_super *super)
1417 {
1418   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1419
1420   super->receiver = read_memory_unsigned_integer (addr, 4, byte_order);
1421   super->class = read_memory_unsigned_integer (addr + 4, 4, byte_order);
1422 };
1423
1424 static void
1425 read_objc_class (struct gdbarch *gdbarch, CORE_ADDR addr,
1426                  struct objc_class *class)
1427 {
1428   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1429
1430   class->isa = read_memory_unsigned_integer (addr, 4, byte_order);
1431   class->super_class = read_memory_unsigned_integer (addr + 4, 4, byte_order);
1432   class->name = read_memory_unsigned_integer (addr + 8, 4, byte_order);
1433   class->version = read_memory_unsigned_integer (addr + 12, 4, byte_order);
1434   class->info = read_memory_unsigned_integer (addr + 16, 4, byte_order);
1435   class->instance_size = read_memory_unsigned_integer (addr + 18, 4,
1436                                                        byte_order);
1437   class->ivars = read_memory_unsigned_integer (addr + 24, 4, byte_order);
1438   class->methods = read_memory_unsigned_integer (addr + 28, 4, byte_order);
1439   class->cache = read_memory_unsigned_integer (addr + 32, 4, byte_order);
1440   class->protocols = read_memory_unsigned_integer (addr + 36, 4, byte_order);
1441 }
1442
1443 static CORE_ADDR
1444 find_implementation_from_class (struct gdbarch *gdbarch,
1445                                 CORE_ADDR class, CORE_ADDR sel)
1446 {
1447   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1448   CORE_ADDR subclass = class;
1449
1450   while (subclass != 0)
1451     {
1452
1453       struct objc_class class_str;
1454       unsigned mlistnum = 0;
1455
1456       read_objc_class (gdbarch, subclass, &class_str);
1457
1458       for (;;)
1459         {
1460           CORE_ADDR mlist;
1461           unsigned long nmethods;
1462           unsigned long i;
1463
1464           mlist = read_memory_unsigned_integer (class_str.methods +
1465                                                 (4 * mlistnum),
1466                                                 4, byte_order);
1467           if (mlist == 0)
1468             break;
1469
1470           nmethods = read_objc_methlist_nmethods (gdbarch, mlist);
1471
1472           for (i = 0; i < nmethods; i++)
1473             {
1474               struct objc_method meth_str;
1475
1476               read_objc_methlist_method (gdbarch, mlist, i, &meth_str);
1477 #if 0
1478               fprintf (stderr,
1479                        "checking method 0x%lx against selector 0x%lx\n",
1480                        meth_str.name, sel);
1481 #endif
1482
1483               if (meth_str.name == sel)
1484                 /* FIXME: hppa arch was doing a pointer dereference
1485                    here.  There needs to be a better way to do that.  */
1486                 return meth_str.imp;
1487             }
1488           mlistnum++;
1489         }
1490       subclass = class_str.super_class;
1491     }
1492
1493   return 0;
1494 }
1495
1496 static CORE_ADDR
1497 find_implementation (struct gdbarch *gdbarch,
1498                      CORE_ADDR object, CORE_ADDR sel)
1499 {
1500   struct objc_object ostr;
1501
1502   if (object == 0)
1503     return 0;
1504   read_objc_object (gdbarch, object, &ostr);
1505   if (ostr.isa == 0)
1506     return 0;
1507
1508   return find_implementation_from_class (gdbarch, ostr.isa, sel);
1509 }
1510
1511 static int
1512 resolve_msgsend (CORE_ADDR pc, CORE_ADDR *new_pc)
1513 {
1514   struct frame_info *frame = get_current_frame ();
1515   struct gdbarch *gdbarch = get_frame_arch (frame);
1516   struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1517
1518   CORE_ADDR object;
1519   CORE_ADDR sel;
1520   CORE_ADDR res;
1521
1522   object = gdbarch_fetch_pointer_argument (gdbarch, frame, 0, ptr_type);
1523   sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1524
1525   res = find_implementation (gdbarch, object, sel);
1526   if (new_pc != 0)
1527     *new_pc = res;
1528   if (res == 0)
1529     return 1;
1530   return 0;
1531 }
1532
1533 static int
1534 resolve_msgsend_stret (CORE_ADDR pc, CORE_ADDR *new_pc)
1535 {
1536   struct frame_info *frame = get_current_frame ();
1537   struct gdbarch *gdbarch = get_frame_arch (frame);
1538   struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1539
1540   CORE_ADDR object;
1541   CORE_ADDR sel;
1542   CORE_ADDR res;
1543
1544   object = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1545   sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 2, ptr_type);
1546
1547   res = find_implementation (gdbarch, object, sel);
1548   if (new_pc != 0)
1549     *new_pc = res;
1550   if (res == 0)
1551     return 1;
1552   return 0;
1553 }
1554
1555 static int
1556 resolve_msgsend_super (CORE_ADDR pc, CORE_ADDR *new_pc)
1557 {
1558   struct frame_info *frame = get_current_frame ();
1559   struct gdbarch *gdbarch = get_frame_arch (frame);
1560   struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1561
1562   struct objc_super sstr;
1563
1564   CORE_ADDR super;
1565   CORE_ADDR sel;
1566   CORE_ADDR res;
1567
1568   super = gdbarch_fetch_pointer_argument (gdbarch, frame, 0, ptr_type);
1569   sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1570
1571   read_objc_super (gdbarch, super, &sstr);
1572   if (sstr.class == 0)
1573     return 0;
1574
1575   res = find_implementation_from_class (gdbarch, sstr.class, sel);
1576   if (new_pc != 0)
1577     *new_pc = res;
1578   if (res == 0)
1579     return 1;
1580   return 0;
1581 }
1582
1583 static int
1584 resolve_msgsend_super_stret (CORE_ADDR pc, CORE_ADDR *new_pc)
1585 {
1586   struct frame_info *frame = get_current_frame ();
1587   struct gdbarch *gdbarch = get_frame_arch (frame);
1588   struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1589
1590   struct objc_super sstr;
1591
1592   CORE_ADDR super;
1593   CORE_ADDR sel;
1594   CORE_ADDR res;
1595
1596   super = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1597   sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 2, ptr_type);
1598
1599   read_objc_super (gdbarch, super, &sstr);
1600   if (sstr.class == 0)
1601     return 0;
1602
1603   res = find_implementation_from_class (gdbarch, sstr.class, sel);
1604   if (new_pc != 0)
1605     *new_pc = res;
1606   if (res == 0)
1607     return 1;
1608   return 0;
1609 }
1610
1611 /* Provide a prototype to silence -Wmissing-prototypes.  */
1612 extern initialize_file_ftype _initialize_objc_lang;
1613
1614 void
1615 _initialize_objc_lang (void)
1616 {
1617   objc_objfile_data = register_objfile_data ();
1618 }