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