gdb/objc-lang.c

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