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