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