gdb/objc-lang.c

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