gdb/objc-lang.c

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