gdb/objc-lang.c

   1 /* Objective-C language support routines for GDB, the GNU debugger.
   2
   3    Copyright 2002, 2003, 2004, 2005 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 2 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, write to the Free Software
  22    Foundation, Inc., 59 Temple Place - Suite 330,
  23    Boston, MA 02111-1307, USA.  */
  24
  25 #include "defs.h"
  26 #include "symtab.h"
  27 #include "gdbtypes.h"
  28 #include "expression.h"
  29 #include "parser-defs.h"
  30 #include "language.h"
  31 #include "c-lang.h"
  32 #include "objc-lang.h"
  33 #include "exceptions.h"
  34 #include "complaints.h"
  35 #include "value.h"
  36 #include "symfile.h"
  37 #include "objfiles.h"
  38 #include "gdb_string.h"         /* for strchr */
  39 #include "target.h"             /* for target_has_execution */
  40 #include "gdbcore.h"
  41 #include "gdbcmd.h"
  42 #include "frame.h"
  43 #include "gdb_regex.h"
  44 #include "regcache.h"
  45 #include "block.h"
  46 #include "infcall.h"
  47 #include "valprint.h"
  48 #include "gdb_assert.h"
  49
  50 #include <ctype.h>
  51
  52 struct objc_object {
  53   CORE_ADDR isa;
  54 };
  55
  56 struct objc_class {
  57   CORE_ADDR isa;
  58   CORE_ADDR super_class;
  59   CORE_ADDR name;
  60   long version;
  61   long info;
  62   long instance_size;
  63   CORE_ADDR ivars;
  64   CORE_ADDR methods;
  65   CORE_ADDR cache;
  66   CORE_ADDR protocols;
  67 };
  68
  69 struct objc_super {
  70   CORE_ADDR receiver;
  71   CORE_ADDR class;
  72 };
  73
  74 struct objc_method {
  75   CORE_ADDR name;
  76   CORE_ADDR types;
  77   CORE_ADDR imp;
  78 };
  79
  80 /* 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, struct block *block, int noerr)
  86 {
  87   struct symbol *sym;
  88
  89   sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0,
  90                        (struct symtab **) NULL);
  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 (TYPE_CODE (SYMBOL_TYPE (sym)) != 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 (char *classname)
 112 {
 113   struct value * function, *classval;
 114
 115   if (! target_has_execution)
 116     {
 117       /* Can't call into inferior to lookup class.  */
 118       return 0;
 119     }
 120
 121   if (lookup_minimal_symbol("objc_lookUpClass", 0, 0))
 122     function = find_function_in_inferior("objc_lookUpClass");
 123   else if (lookup_minimal_symbol ("objc_lookup_class", 0, 0))
 124     function = find_function_in_inferior("objc_lookup_class");
 125   else
 126     {
 127       complaint (&symfile_complaints, "no way to lookup Objective-C classes");
 128       return 0;
 129     }
 130
 131   classval = value_string (classname, strlen (classname) + 1);
 132   classval = value_coerce_array (classval);
 133   return (CORE_ADDR) value_as_long (call_function_by_hand (function,
 134                                                            1, &classval));
 135 }
 136
 137 CORE_ADDR
 138 lookup_child_selector (char *selname)
 139 {
 140   struct value * function, *selstring;
 141
 142   if (! target_has_execution)
 143     {
 144       /* Can't call into inferior to lookup selector.  */
 145       return 0;
 146     }
 147
 148   if (lookup_minimal_symbol("sel_getUid", 0, 0))
 149     function = find_function_in_inferior("sel_getUid");
 150   else if (lookup_minimal_symbol ("sel_get_any_uid", 0, 0))
 151     function = find_function_in_inferior("sel_get_any_uid");
 152   else
 153     {
 154       complaint (&symfile_complaints, "no way to lookup Objective-C selectors");
 155       return 0;
 156     }
 157
 158   selstring = value_coerce_array (value_string (selname,
 159                                                 strlen (selname) + 1));
 160   return value_as_long (call_function_by_hand (function, 1, &selstring));
 161 }
 162
 163 struct value *
 164 value_nsstring (char *ptr, int len)
 165 {
 166   struct value *stringValue[3];
 167   struct value *function, *nsstringValue;
 168   struct symbol *sym;
 169   struct type *type;
 170
 171   if (!target_has_execution)
 172     return 0;           /* Can't call into inferior to create NSString.  */
 173
 174   sym = lookup_struct_typedef("NSString", 0, 1);
 175   if (sym == NULL)
 176     sym = lookup_struct_typedef("NXString", 0, 1);
 177   if (sym == NULL)
 178     type = lookup_pointer_type(builtin_type_void);
 179   else
 180     type = lookup_pointer_type(SYMBOL_TYPE (sym));
 181
 182   stringValue[2] = value_string(ptr, len);
 183   stringValue[2] = value_coerce_array(stringValue[2]);
 184   /* _NSNewStringFromCString replaces "istr" after Lantern2A.  */
 185   if (lookup_minimal_symbol("_NSNewStringFromCString", 0, 0))
 186     {
 187       function = find_function_in_inferior("_NSNewStringFromCString");
 188       nsstringValue = call_function_by_hand(function, 1, &stringValue[2]);
 189     }
 190   else if (lookup_minimal_symbol("istr", 0, 0))
 191     {
 192       function = find_function_in_inferior("istr");
 193       nsstringValue = call_function_by_hand(function, 1, &stringValue[2]);
 194     }
 195   else if (lookup_minimal_symbol("+[NSString stringWithCString:]", 0, 0))
 196     {
 197       function = find_function_in_inferior("+[NSString stringWithCString:]");
 198       stringValue[0] = value_from_longest
 199         (builtin_type_long, lookup_objc_class ("NSString"));
 200       stringValue[1] = value_from_longest
 201         (builtin_type_long, lookup_child_selector ("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   deprecated_set_value_type (nsstringValue, type);
 208   return nsstringValue;
 209 }
 210
 211 /* Objective-C name demangling.  */
 212
 213 char *
 214 objc_demangle (const char *mangled, int options)
 215 {
 216   char *demangled, *cp;
 217
 218   if (mangled[0] == '_' &&
 219      (mangled[1] == 'i' || mangled[1] == 'c') &&
 220       mangled[2] == '_')
 221     {
 222       cp = demangled = xmalloc(strlen(mangled) + 2);
 223
 224       if (mangled[1] == 'i')
 225         *cp++ = '-';            /* for instance method */
 226       else
 227         *cp++ = '+';            /* for class    method */
 228
 229       *cp++ = '[';              /* opening left brace  */
 230       strcpy(cp, mangled+3);    /* tack on the rest of the mangled name */
 231
 232       while (*cp && *cp == '_')
 233         cp++;                   /* skip any initial underbars in class name */
 234
 235       cp = strchr(cp, '_');
 236       if (!cp)                  /* find first non-initial underbar */
 237         {
 238           xfree(demangled);     /* not mangled name */
 239           return NULL;
 240         }
 241       if (cp[1] == '_') {       /* easy case: no category name     */
 242         *cp++ = ' ';            /* replace two '_' with one ' '    */
 243         strcpy(cp, mangled + (cp - demangled) + 2);
 244       }
 245       else {
 246         *cp++ = '(';            /* less easy case: category name */
 247         cp = strchr(cp, '_');
 248         if (!cp)
 249           {
 250             xfree(demangled);   /* not mangled name */
 251             return NULL;
 252           }
 253         *cp++ = ')';
 254         *cp++ = ' ';            /* overwriting 1st char of method name...  */
 255         strcpy(cp, mangled + (cp - demangled)); /* get it back */
 256       }
 257
 258       while (*cp && *cp == '_')
 259         cp++;                   /* skip any initial underbars in method name */
 260
 261       for (; *cp; cp++)
 262         if (*cp == '_')
 263           *cp = ':';            /* replace remaining '_' with ':' */
 264
 265       *cp++ = ']';              /* closing right brace */
 266       *cp++ = 0;                /* string terminator */
 267       return demangled;
 268     }
 269   else
 270     return NULL;        /* Not an objc mangled name.  */
 271 }
 272
 273 /* Print the character C on STREAM as part of the contents of a
 274    literal string whose delimiter is QUOTER.  Note that that format
 275    for printing characters and strings is language specific.  */
 276
 277 static void
 278 objc_emit_char (int c, struct ui_file *stream, int quoter)
 279 {
 280
 281   c &= 0xFF;                    /* Avoid sign bit follies.  */
 282
 283   if (PRINT_LITERAL_FORM (c))
 284     {
 285       if (c == '\\' || c == quoter)
 286         {
 287           fputs_filtered ("\\", stream);
 288         }
 289       fprintf_filtered (stream, "%c", c);
 290     }
 291   else
 292     {
 293       switch (c)
 294         {
 295         case '\n':
 296           fputs_filtered ("\\n", stream);
 297           break;
 298         case '\b':
 299           fputs_filtered ("\\b", stream);
 300           break;
 301         case '\t':
 302           fputs_filtered ("\\t", stream);
 303           break;
 304         case '\f':
 305           fputs_filtered ("\\f", stream);
 306           break;
 307         case '\r':
 308           fputs_filtered ("\\r", stream);
 309           break;
 310         case '\033':
 311           fputs_filtered ("\\e", stream);
 312           break;
 313         case '\007':
 314           fputs_filtered ("\\a", stream);
 315           break;
 316         default:
 317           fprintf_filtered (stream, "\\%.3o", (unsigned int) c);
 318           break;
 319         }
 320     }
 321 }
 322
 323 static void
 324 objc_printchar (int c, struct ui_file *stream)
 325 {
 326   fputs_filtered ("'", stream);
 327   objc_emit_char (c, stream, '\'');
 328   fputs_filtered ("'", stream);
 329 }
 330
 331 /* Print the character string STRING, printing at most LENGTH
 332    characters.  Printing stops early if the number hits print_max;
 333    repeat counts are printed as appropriate.  Print ellipses at the
 334    end if we had to stop before printing LENGTH characters, or if
 335    FORCE_ELLIPSES.  */
 336
 337 static void
 338 objc_printstr (struct ui_file *stream, const bfd_byte *string,
 339                unsigned int length, int width, int force_ellipses)
 340 {
 341   unsigned int i;
 342   unsigned int things_printed = 0;
 343   int in_quotes = 0;
 344   int need_comma = 0;
 345
 346   /* If the string was not truncated due to `set print elements', and
 347      the last byte of it is a null, we don't print that, in
 348      traditional C style.  */
 349   if ((!force_ellipses) && length > 0 && string[length-1] == '\0')
 350     length--;
 351
 352   if (length == 0)
 353     {
 354       fputs_filtered ("\"\"", stream);
 355       return;
 356     }
 357
 358   for (i = 0; i < length && things_printed < print_max; ++i)
 359     {
 360       /* Position of the character we are examining to see whether it
 361          is repeated.  */
 362       unsigned int rep1;
 363       /* Number of repetitions we have detected so far.  */
 364       unsigned int reps;
 365
 366       QUIT;
 367
 368       if (need_comma)
 369         {
 370           fputs_filtered (", ", stream);
 371           need_comma = 0;
 372         }
 373
 374       rep1 = i + 1;
 375       reps = 1;
 376       while (rep1 < length && string[rep1] == string[i])
 377         {
 378           ++rep1;
 379           ++reps;
 380         }
 381
 382       if (reps > repeat_count_threshold)
 383         {
 384           if (in_quotes)
 385             {
 386               if (inspect_it)
 387                 fputs_filtered ("\\\", ", stream);
 388               else
 389                 fputs_filtered ("\", ", stream);
 390               in_quotes = 0;
 391             }
 392           objc_printchar (string[i], stream);
 393           fprintf_filtered (stream, " <repeats %u times>", reps);
 394           i = rep1 - 1;
 395           things_printed += repeat_count_threshold;
 396           need_comma = 1;
 397         }
 398       else
 399         {
 400           if (!in_quotes)
 401             {
 402               if (inspect_it)
 403                 fputs_filtered ("\\\"", stream);
 404               else
 405                 fputs_filtered ("\"", stream);
 406               in_quotes = 1;
 407             }
 408           objc_emit_char (string[i], stream, '"');
 409           ++things_printed;
 410         }
 411     }
 412
 413   /* Terminate the quotes if necessary.  */
 414   if (in_quotes)
 415     {
 416       if (inspect_it)
 417         fputs_filtered ("\\\"", stream);
 418       else
 419         fputs_filtered ("\"", stream);
 420     }
 421
 422   if (force_ellipses || i < length)
 423     fputs_filtered ("...", stream);
 424 }
 425
 426 /* Create a fundamental C type using default reasonable for the
 427    current target.
 428
 429    Some object/debugging file formats (DWARF version 1, COFF, etc) do
 430    not define fundamental types such as "int" or "double".  Others
 431    (stabs or DWARF version 2, etc) do define fundamental types.  For
 432    the formats which don't provide fundamental types, gdb can create
 433    such types using this function.
 434
 435    FIXME: Some compilers distinguish explicitly signed integral types
 436    (signed short, signed int, signed long) from "regular" integral
 437    types (short, int, long) in the debugging information.  There is
 438    some disagreement as to how useful this feature is.  In particular,
 439    gcc does not support this.  Also, only some debugging formats allow
 440    the distinction to be passed on to a debugger.  For now, we always
 441    just use "short", "int", or "long" as the type name, for both the
 442    implicit and explicitly signed types.  This also makes life easier
 443    for the gdb test suite since we don't have to account for the
 444    differences in output depending upon what the compiler and
 445    debugging format support.  We will probably have to re-examine the
 446    issue when gdb starts taking it's fundamental type information
 447    directly from the debugging information supplied by the compiler.
 448    fnf@cygnus.com */
 449
 450 static struct type *
 451 objc_create_fundamental_type (struct objfile *objfile, int typeid)
 452 {
 453   struct type *type = NULL;
 454
 455   switch (typeid)
 456     {
 457       default:
 458         /* FIXME: For now, if we are asked to produce a type not in
 459            this language, create the equivalent of a C integer type
 460            with the name "<?type?>".  When all the dust settles from
 461            the type reconstruction work, this should probably become
 462            an error.  */
 463         type = init_type (TYPE_CODE_INT,
 464                           TARGET_INT_BIT / TARGET_CHAR_BIT,
 465                           0, "<?type?>", objfile);
 466         warning ("internal error: no C/C++ fundamental type %d", typeid);
 467         break;
 468       case FT_VOID:
 469         type = init_type (TYPE_CODE_VOID,
 470                           TARGET_CHAR_BIT / TARGET_CHAR_BIT,
 471                           0, "void", objfile);
 472         break;
 473       case FT_CHAR:
 474         type = init_type (TYPE_CODE_INT,
 475                           TARGET_CHAR_BIT / TARGET_CHAR_BIT,
 476                           0, "char", objfile);
 477         break;
 478       case FT_SIGNED_CHAR:
 479         type = init_type (TYPE_CODE_INT,
 480                           TARGET_CHAR_BIT / TARGET_CHAR_BIT,
 481                           0, "signed char", objfile);
 482         break;
 483       case FT_UNSIGNED_CHAR:
 484         type = init_type (TYPE_CODE_INT,
 485                           TARGET_CHAR_BIT / TARGET_CHAR_BIT,
 486                           TYPE_FLAG_UNSIGNED, "unsigned char", objfile);
 487         break;
 488       case FT_SHORT:
 489         type = init_type (TYPE_CODE_INT,
 490                           TARGET_SHORT_BIT / TARGET_CHAR_BIT,
 491                           0, "short", objfile);
 492         break;
 493       case FT_SIGNED_SHORT:
 494         type = init_type (TYPE_CODE_INT,
 495                           TARGET_SHORT_BIT / TARGET_CHAR_BIT,
 496                           0, "short", objfile); /* FIXME-fnf */
 497         break;
 498       case FT_UNSIGNED_SHORT:
 499         type = init_type (TYPE_CODE_INT,
 500                           TARGET_SHORT_BIT / TARGET_CHAR_BIT,
 501                           TYPE_FLAG_UNSIGNED, "unsigned short", objfile);
 502         break;
 503       case FT_INTEGER:
 504         type = init_type (TYPE_CODE_INT,
 505                           TARGET_INT_BIT / TARGET_CHAR_BIT,
 506                           0, "int", objfile);
 507         break;
 508       case FT_SIGNED_INTEGER:
 509         type = init_type (TYPE_CODE_INT,
 510                           TARGET_INT_BIT / TARGET_CHAR_BIT,
 511                           0, "int", objfile); /* FIXME -fnf */
 512         break;
 513       case FT_UNSIGNED_INTEGER:
 514         type = init_type (TYPE_CODE_INT,
 515                           TARGET_INT_BIT / TARGET_CHAR_BIT,
 516                           TYPE_FLAG_UNSIGNED, "unsigned int", objfile);
 517         break;
 518       case FT_LONG:
 519         type = init_type (TYPE_CODE_INT,
 520                           TARGET_LONG_BIT / TARGET_CHAR_BIT,
 521                           0, "long", objfile);
 522         break;
 523       case FT_SIGNED_LONG:
 524         type = init_type (TYPE_CODE_INT,
 525                           TARGET_LONG_BIT / TARGET_CHAR_BIT,
 526                           0, "long", objfile); /* FIXME -fnf */
 527         break;
 528       case FT_UNSIGNED_LONG:
 529         type = init_type (TYPE_CODE_INT,
 530                           TARGET_LONG_BIT / TARGET_CHAR_BIT,
 531                           TYPE_FLAG_UNSIGNED, "unsigned long", objfile);
 532         break;
 533       case FT_LONG_LONG:
 534         type = init_type (TYPE_CODE_INT,
 535                           TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
 536                           0, "long long", objfile);
 537         break;
 538       case FT_SIGNED_LONG_LONG:
 539         type = init_type (TYPE_CODE_INT,
 540                           TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
 541                           0, "signed long long", objfile);
 542         break;
 543       case FT_UNSIGNED_LONG_LONG:
 544         type = init_type (TYPE_CODE_INT,
 545                           TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
 546                           TYPE_FLAG_UNSIGNED, "unsigned long long", objfile);
 547         break;
 548       case FT_FLOAT:
 549         type = init_type (TYPE_CODE_FLT,
 550                           TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
 551                           0, "float", objfile);
 552         break;
 553       case FT_DBL_PREC_FLOAT:
 554         type = init_type (TYPE_CODE_FLT,
 555                           TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
 556                           0, "double", objfile);
 557         break;
 558       case FT_EXT_PREC_FLOAT:
 559         type = init_type (TYPE_CODE_FLT,
 560                           TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT,
 561                           0, "long double", objfile);
 562         break;
 563       }
 564   return (type);
 565 }
 566
 567 /* Determine if we are currently in the Objective-C dispatch function.
 568    If so, get the address of the method function that the dispatcher
 569    would call and use that as the function to step into instead. Also
 570    skip over the trampoline for the function (if any).  This is better
 571    for the user since they are only interested in stepping into the
 572    method function anyway.  */
 573 static CORE_ADDR
 574 objc_skip_trampoline (CORE_ADDR stop_pc)
 575 {
 576   CORE_ADDR real_stop_pc;
 577   CORE_ADDR method_stop_pc;
 578
 579   real_stop_pc = SKIP_TRAMPOLINE_CODE (stop_pc);
 580
 581   if (real_stop_pc != 0)
 582     find_objc_msgcall (real_stop_pc, &method_stop_pc);
 583   else
 584     find_objc_msgcall (stop_pc, &method_stop_pc);
 585
 586   if (method_stop_pc)
 587     {
 588       real_stop_pc = SKIP_TRAMPOLINE_CODE (method_stop_pc);
 589       if (real_stop_pc == 0)
 590         real_stop_pc = method_stop_pc;
 591     }
 592
 593   return real_stop_pc;
 594 }
 595
 596
 597 /* Table mapping opcodes into strings for printing operators
 598    and precedences of the operators.  */
 599
 600 static const struct op_print objc_op_print_tab[] =
 601   {
 602     {",",  BINOP_COMMA, PREC_COMMA, 0},
 603     {"=",  BINOP_ASSIGN, PREC_ASSIGN, 1},
 604     {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
 605     {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
 606     {"|",  BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
 607     {"^",  BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
 608     {"&",  BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
 609     {"==", BINOP_EQUAL, PREC_EQUAL, 0},
 610     {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
 611     {"<=", BINOP_LEQ, PREC_ORDER, 0},
 612     {">=", BINOP_GEQ, PREC_ORDER, 0},
 613     {">",  BINOP_GTR, PREC_ORDER, 0},
 614     {"<",  BINOP_LESS, PREC_ORDER, 0},
 615     {">>", BINOP_RSH, PREC_SHIFT, 0},
 616     {"<<", BINOP_LSH, PREC_SHIFT, 0},
 617     {"+",  BINOP_ADD, PREC_ADD, 0},
 618     {"-",  BINOP_SUB, PREC_ADD, 0},
 619     {"*",  BINOP_MUL, PREC_MUL, 0},
 620     {"/",  BINOP_DIV, PREC_MUL, 0},
 621     {"%",  BINOP_REM, PREC_MUL, 0},
 622     {"@",  BINOP_REPEAT, PREC_REPEAT, 0},
 623     {"-",  UNOP_NEG, PREC_PREFIX, 0},
 624     {"!",  UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
 625     {"~",  UNOP_COMPLEMENT, PREC_PREFIX, 0},
 626     {"*",  UNOP_IND, PREC_PREFIX, 0},
 627     {"&",  UNOP_ADDR, PREC_PREFIX, 0},
 628     {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
 629     {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
 630     {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
 631     {NULL, OP_NULL, PREC_NULL, 0}
 632 };
 633
 634 struct type ** const (objc_builtin_types[]) =
 635 {
 636   &builtin_type_int,
 637   &builtin_type_long,
 638   &builtin_type_short,
 639   &builtin_type_char,
 640   &builtin_type_float,
 641   &builtin_type_double,
 642   &builtin_type_void,
 643   &builtin_type_long_long,
 644   &builtin_type_signed_char,
 645   &builtin_type_unsigned_char,
 646   &builtin_type_unsigned_short,
 647   &builtin_type_unsigned_int,
 648   &builtin_type_unsigned_long,
 649   &builtin_type_unsigned_long_long,
 650   &builtin_type_long_double,
 651   &builtin_type_complex,
 652   &builtin_type_double_complex,
 653   0
 654 };
 655
 656 const struct language_defn objc_language_defn = {
 657   "objective-c",                /* Language name */
 658   language_objc,
 659   objc_builtin_types,
 660   range_check_off,
 661   type_check_off,
 662   case_sensitive_on,
 663   array_row_major,
 664   &exp_descriptor_standard,
 665   objc_parse,
 666   objc_error,
 667   null_post_parser,
 668   objc_printchar,               /* Print a character constant */
 669   objc_printstr,                /* Function to print string constant */
 670   objc_emit_char,
 671   objc_create_fundamental_type, /* Create fundamental type in this language */
 672   c_print_type,                 /* Print a type using appropriate syntax */
 673   c_val_print,                  /* Print a value using appropriate syntax */
 674   c_value_print,                /* Print a top-level value */
 675   objc_skip_trampoline,         /* Language specific skip_trampoline */
 676   value_of_this,                /* value_of_this */
 677   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
 678   basic_lookup_transparent_type,/* lookup_transparent_type */
 679   objc_demangle,                /* Language specific symbol demangler */
 680   NULL,                         /* Language specific class_name_from_physname */
 681   objc_op_print_tab,            /* Expression operators for printing */
 682   1,                            /* C-style arrays */
 683   0,                            /* String lower bound */
 684   &builtin_type_char,           /* Type of string elements */
 685   default_word_break_characters,
 686   NULL, /* FIXME: la_language_arch_info.  */
 687   LANG_MAGIC
 688 };
 689
 690 /*
 691  * ObjC:
 692  * Following functions help construct Objective-C message calls
 693  */
 694
 695 struct selname          /* For parsing Objective-C.  */
 696   {
 697     struct selname *next;
 698     char *msglist_sel;
 699     int msglist_len;
 700   };
 701
 702 static int msglist_len;
 703 static struct selname *selname_chain;
 704 static char *msglist_sel;
 705
 706 void
 707 start_msglist(void)
 708 {
 709   struct selname *new =
 710     (struct selname *) xmalloc (sizeof (struct selname));
 711
 712   new->next = selname_chain;
 713   new->msglist_len = msglist_len;
 714   new->msglist_sel = msglist_sel;
 715   msglist_len = 0;
 716   msglist_sel = (char *)xmalloc(1);
 717   *msglist_sel = 0;
 718   selname_chain = new;
 719 }
 720
 721 void
 722 add_msglist(struct stoken *str, int addcolon)
 723 {
 724   char *s, *p;
 725   int len, plen;
 726
 727   if (str == 0) {               /* Unnamed arg, or...  */
 728     if (addcolon == 0) {        /* variable number of args.  */
 729       msglist_len++;
 730       return;
 731     }
 732     p = "";
 733     plen = 0;
 734   } else {
 735     p = str->ptr;
 736     plen = str->length;
 737   }
 738   len = plen + strlen(msglist_sel) + 2;
 739   s = (char *)xmalloc(len);
 740   strcpy(s, msglist_sel);
 741   strncat(s, p, plen);
 742   xfree(msglist_sel);
 743   msglist_sel = s;
 744   if (addcolon) {
 745     s[len-2] = ':';
 746     s[len-1] = 0;
 747     msglist_len++;
 748   } else
 749     s[len-2] = '\0';
 750 }
 751
 752 int
 753 end_msglist(void)
 754 {
 755   int val = msglist_len;
 756   struct selname *sel = selname_chain;
 757   char *p = msglist_sel;
 758   CORE_ADDR selid;
 759
 760   selname_chain = sel->next;
 761   msglist_len = sel->msglist_len;
 762   msglist_sel = sel->msglist_sel;
 763   selid = lookup_child_selector(p);
 764   if (!selid)
 765     error("Can't find selector \"%s\"", p);
 766   write_exp_elt_longcst (selid);
 767   xfree(p);
 768   write_exp_elt_longcst (val);  /* Number of args */
 769   xfree(sel);
 770
 771   return val;
 772 }
 773
 774 /*
 775  * Function: specialcmp (char *a, char *b)
 776  *
 777  * Special strcmp: treats ']' and ' ' as end-of-string.
 778  * Used for qsorting lists of objc methods (either by class or selector).
 779  */
 780
 781 static int
 782 specialcmp (char *a, char *b)
 783 {
 784   while (*a && *a != ' ' && *a != ']' && *b && *b != ' ' && *b != ']')
 785     {
 786       if (*a != *b)
 787         return *a - *b;
 788       a++, b++;
 789     }
 790   if (*a && *a != ' ' && *a != ']')
 791     return  1;          /* a is longer therefore greater */
 792   if (*b && *b != ' ' && *b != ']')
 793     return -1;          /* a is shorter therefore lesser */
 794   return    0;          /* a and b are identical */
 795 }
 796
 797 /*
 798  * Function: compare_selectors (const void *, const void *)
 799  *
 800  * Comparison function for use with qsort.  Arguments are symbols or
 801  * msymbols Compares selector part of objc method name alphabetically.
 802  */
 803
 804 static int
 805 compare_selectors (const void *a, const void *b)
 806 {
 807   char *aname, *bname;
 808
 809   aname = SYMBOL_PRINT_NAME (*(struct symbol **) a);
 810   bname = SYMBOL_PRINT_NAME (*(struct symbol **) b);
 811   if (aname == NULL || bname == NULL)
 812     error ("internal: compare_selectors(1)");
 813
 814   aname = strchr(aname, ' ');
 815   bname = strchr(bname, ' ');
 816   if (aname == NULL || bname == NULL)
 817     error ("internal: compare_selectors(2)");
 818
 819   return specialcmp (aname+1, bname+1);
 820 }
 821
 822 /*
 823  * Function: selectors_info (regexp, from_tty)
 824  *
 825  * Implements the "Info selectors" command.  Takes an optional regexp
 826  * arg.  Lists all objective c selectors that match the regexp.  Works
 827  * by grepping thru all symbols for objective c methods.  Output list
 828  * is sorted and uniqued.
 829  */
 830
 831 static void
 832 selectors_info (char *regexp, int from_tty)
 833 {
 834   struct objfile        *objfile;
 835   struct minimal_symbol *msymbol;
 836   char                  *name;
 837   char                  *val;
 838   int                    matches = 0;
 839   int                    maxlen  = 0;
 840   int                    ix;
 841   char                   myregexp[2048];
 842   char                   asel[256];
 843   struct symbol        **sym_arr;
 844   int                    plusminus = 0;
 845
 846   if (regexp == NULL)
 847     strcpy(myregexp, ".*]");    /* Null input, match all objc methods.  */
 848   else
 849     {
 850       if (*regexp == '+' || *regexp == '-')
 851         { /* User wants only class methods or only instance methods.  */
 852           plusminus = *regexp++;
 853           while (*regexp == ' ' || *regexp == '\t')
 854             regexp++;
 855         }
 856       if (*regexp == '\0')
 857         strcpy(myregexp, ".*]");
 858       else
 859         {
 860           strcpy(myregexp, regexp);
 861           if (myregexp[strlen(myregexp) - 1] == '$') /* end of selector */
 862             myregexp[strlen(myregexp) - 1] = ']';    /* end of method name */
 863           else
 864             strcat(myregexp, ".*]");
 865         }
 866     }
 867
 868   if (regexp != NULL)
 869     {
 870       val = re_comp (myregexp);
 871       if (val != 0)
 872         error ("Invalid regexp (%s): %s", val, regexp);
 873     }
 874
 875   /* First time thru is JUST to get max length and count.  */
 876   ALL_MSYMBOLS (objfile, msymbol)
 877     {
 878       QUIT;
 879       name = SYMBOL_NATURAL_NAME (msymbol);
 880       if (name &&
 881          (name[0] == '-' || name[0] == '+') &&
 882           name[1] == '[')               /* Got a method name.  */
 883         {
 884           /* Filter for class/instance methods.  */
 885           if (plusminus && name[0] != plusminus)
 886             continue;
 887           /* Find selector part.  */
 888           name = (char *) strchr(name+2, ' ');
 889           if (regexp == NULL || re_exec(++name) != 0)
 890             {
 891               char *mystart = name;
 892               char *myend   = (char *) strchr(mystart, ']');
 893
 894               if (myend && (myend - mystart > maxlen))
 895                 maxlen = myend - mystart;       /* Get longest selector.  */
 896               matches++;
 897             }
 898         }
 899     }
 900   if (matches)
 901     {
 902       printf_filtered ("Selectors matching \"%s\":\n\n",
 903                        regexp ? regexp : "*");
 904
 905       sym_arr = alloca (matches * sizeof (struct symbol *));
 906       matches = 0;
 907       ALL_MSYMBOLS (objfile, msymbol)
 908         {
 909           QUIT;
 910           name = SYMBOL_NATURAL_NAME (msymbol);
 911           if (name &&
 912              (name[0] == '-' || name[0] == '+') &&
 913               name[1] == '[')           /* Got a method name.  */
 914             {
 915               /* Filter for class/instance methods.  */
 916               if (plusminus && name[0] != plusminus)
 917                 continue;
 918               /* Find selector part.  */
 919               name = (char *) strchr(name+2, ' ');
 920               if (regexp == NULL || re_exec(++name) != 0)
 921                 sym_arr[matches++] = (struct symbol *) msymbol;
 922             }
 923         }
 924
 925       qsort (sym_arr, matches, sizeof (struct minimal_symbol *),
 926              compare_selectors);
 927       /* Prevent compare on first iteration.  */
 928       asel[0] = 0;
 929       for (ix = 0; ix < matches; ix++)  /* Now do the output.  */
 930         {
 931           char *p = asel;
 932
 933           QUIT;
 934           name = SYMBOL_NATURAL_NAME (sym_arr[ix]);
 935           name = strchr (name, ' ') + 1;
 936           if (p[0] && specialcmp(name, p) == 0)
 937             continue;           /* Seen this one already (not unique).  */
 938
 939           /* Copy selector part.  */
 940           while (*name && *name != ']')
 941             *p++ = *name++;
 942           *p++ = '\0';
 943           /* Print in columns.  */
 944           puts_filtered_tabular(asel, maxlen + 1, 0);
 945         }
 946       begin_line();
 947     }
 948   else
 949     printf_filtered ("No selectors matching \"%s\"\n", regexp ? regexp : "*");
 950 }
 951
 952 /*
 953  * Function: compare_classes (const void *, const void *)
 954  *
 955  * Comparison function for use with qsort.  Arguments are symbols or
 956  * msymbols Compares class part of objc method name alphabetically.
 957  */
 958
 959 static int
 960 compare_classes (const void *a, const void *b)
 961 {
 962   char *aname, *bname;
 963
 964   aname = SYMBOL_PRINT_NAME (*(struct symbol **) a);
 965   bname = SYMBOL_PRINT_NAME (*(struct symbol **) b);
 966   if (aname == NULL || bname == NULL)
 967     error ("internal: compare_classes(1)");
 968
 969   return specialcmp (aname+1, bname+1);
 970 }
 971
 972 /*
 973  * Function: classes_info(regexp, from_tty)
 974  *
 975  * Implements the "info classes" command for objective c classes.
 976  * Lists all objective c classes that match the optional regexp.
 977  * Works by grepping thru the list of objective c methods.  List will
 978  * be sorted and uniqued (since one class may have many methods).
 979  * BUGS: will not list a class that has no methods.
 980  */
 981
 982 static void
 983 classes_info (char *regexp, int from_tty)
 984 {
 985   struct objfile        *objfile;
 986   struct minimal_symbol *msymbol;
 987   char                  *name;
 988   char                  *val;
 989   int                    matches = 0;
 990   int                    maxlen  = 0;
 991   int                    ix;
 992   char                   myregexp[2048];
 993   char                   aclass[256];
 994   struct symbol        **sym_arr;
 995
 996   if (regexp == NULL)
 997     strcpy(myregexp, ".* ");    /* Null input: match all objc classes.  */
 998   else
 999     {
1000       strcpy(myregexp, regexp);
1001       if (myregexp[strlen(myregexp) - 1] == '$')
1002         /* In the method name, the end of the class name is marked by ' '.  */
1003         myregexp[strlen(myregexp) - 1] = ' ';
1004       else
1005         strcat(myregexp, ".* ");
1006     }
1007
1008   if (regexp != NULL)
1009     {
1010       val = re_comp (myregexp);
1011       if (val != 0)
1012         error ("Invalid regexp (%s): %s", val, regexp);
1013     }
1014
1015   /* First time thru is JUST to get max length and count.  */
1016   ALL_MSYMBOLS (objfile, msymbol)
1017     {
1018       QUIT;
1019       name = SYMBOL_NATURAL_NAME (msymbol);
1020       if (name &&
1021          (name[0] == '-' || name[0] == '+') &&
1022           name[1] == '[')                       /* Got a method name.  */
1023         if (regexp == NULL || re_exec(name+2) != 0)
1024           {
1025             /* Compute length of classname part.  */
1026             char *mystart = name + 2;
1027             char *myend   = (char *) strchr(mystart, ' ');
1028
1029             if (myend && (myend - mystart > maxlen))
1030               maxlen = myend - mystart;
1031             matches++;
1032           }
1033     }
1034   if (matches)
1035     {
1036       printf_filtered ("Classes matching \"%s\":\n\n",
1037                        regexp ? regexp : "*");
1038       sym_arr = alloca (matches * sizeof (struct symbol *));
1039       matches = 0;
1040       ALL_MSYMBOLS (objfile, msymbol)
1041         {
1042           QUIT;
1043           name = SYMBOL_NATURAL_NAME (msymbol);
1044           if (name &&
1045              (name[0] == '-' || name[0] == '+') &&
1046               name[1] == '[')                   /* Got a method name.  */
1047             if (regexp == NULL || re_exec(name+2) != 0)
1048                 sym_arr[matches++] = (struct symbol *) msymbol;
1049         }
1050
1051       qsort (sym_arr, matches, sizeof (struct minimal_symbol *),
1052              compare_classes);
1053       /* Prevent compare on first iteration.  */
1054       aclass[0] = 0;
1055       for (ix = 0; ix < matches; ix++)  /* Now do the output.  */
1056         {
1057           char *p = aclass;
1058
1059           QUIT;
1060           name = SYMBOL_NATURAL_NAME (sym_arr[ix]);
1061           name += 2;
1062           if (p[0] && specialcmp(name, p) == 0)
1063             continue;   /* Seen this one already (not unique).  */
1064
1065           /* Copy class part of method name.  */
1066           while (*name && *name != ' ')
1067             *p++ = *name++;
1068           *p++ = '\0';
1069           /* Print in columns.  */
1070           puts_filtered_tabular(aclass, maxlen + 1, 0);
1071         }
1072       begin_line();
1073     }
1074   else
1075     printf_filtered ("No classes matching \"%s\"\n", regexp ? regexp : "*");
1076 }
1077
1078 /*
1079  * Function: find_imps (char *selector, struct symbol **sym_arr)
1080  *
1081  * Input:  a string representing a selector
1082  *         a pointer to an array of symbol pointers
1083  *         possibly a pointer to a symbol found by the caller.
1084  *
1085  * Output: number of methods that implement that selector.  Side
1086  * effects: The array of symbol pointers is filled with matching syms.
1087  *
1088  * By analogy with function "find_methods" (symtab.c), builds a list
1089  * of symbols matching the ambiguous input, so that "decode_line_2"
1090  * (symtab.c) can list them and ask the user to choose one or more.
1091  * In this case the matches are objective c methods
1092  * ("implementations") matching an objective c selector.
1093  *
1094  * Note that it is possible for a normal (c-style) function to have
1095  * the same name as an objective c selector.  To prevent the selector
1096  * from eclipsing the function, we allow the caller (decode_line_1) to
1097  * search for such a function first, and if it finds one, pass it in
1098  * to us.  We will then integrate it into the list.  We also search
1099  * for one here, among the minsyms.
1100  *
1101  * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be divided
1102  *       into two parts: debuggable (struct symbol) syms, and
1103  *       non_debuggable (struct minimal_symbol) syms.  The debuggable
1104  *       ones will come first, before NUM_DEBUGGABLE (which will thus
1105  *       be the index of the first non-debuggable one).
1106  */
1107
1108 /*
1109  * Function: total_number_of_imps (char *selector);
1110  *
1111  * Input:  a string representing a selector
1112  * Output: number of methods that implement that selector.
1113  *
1114  * By analogy with function "total_number_of_methods", this allows
1115  * decode_line_1 (symtab.c) to detect if there are objective c methods
1116  * matching the input, and to allocate an array of pointers to them
1117  * which can be manipulated by "decode_line_2" (also in symtab.c).
1118  */
1119
1120 char *
1121 parse_selector (char *method, char **selector)
1122 {
1123   char *s1 = NULL;
1124   char *s2 = NULL;
1125   int found_quote = 0;
1126
1127   char *nselector = NULL;
1128
1129   gdb_assert (selector != NULL);
1130
1131   s1 = method;
1132
1133   while (isspace (*s1))
1134     s1++;
1135   if (*s1 == '\'')
1136     {
1137       found_quote = 1;
1138       s1++;
1139     }
1140   while (isspace (*s1))
1141     s1++;
1142
1143   nselector = s1;
1144   s2 = s1;
1145
1146   for (;;) {
1147     if (isalnum (*s2) || (*s2 == '_') || (*s2 == ':'))
1148       *s1++ = *s2;
1149     else if (isspace (*s2))
1150       ;
1151     else if ((*s2 == '\0') || (*s2 == '\''))
1152       break;
1153     else
1154       return NULL;
1155     s2++;
1156   }
1157   *s1++ = '\0';
1158
1159   while (isspace (*s2))
1160     s2++;
1161   if (found_quote)
1162     {
1163       if (*s2 == '\'')
1164         s2++;
1165       while (isspace (*s2))
1166         s2++;
1167     }
1168
1169   if (selector != NULL)
1170     *selector = nselector;
1171
1172   return s2;
1173 }
1174
1175 char *
1176 parse_method (char *method, char *type, char **class,
1177               char **category, char **selector)
1178 {
1179   char *s1 = NULL;
1180   char *s2 = NULL;
1181   int found_quote = 0;
1182
1183   char ntype = '\0';
1184   char *nclass = NULL;
1185   char *ncategory = NULL;
1186   char *nselector = NULL;
1187
1188   gdb_assert (type != NULL);
1189   gdb_assert (class != NULL);
1190   gdb_assert (category != NULL);
1191   gdb_assert (selector != NULL);
1192
1193   s1 = method;
1194
1195   while (isspace (*s1))
1196     s1++;
1197   if (*s1 == '\'')
1198     {
1199       found_quote = 1;
1200       s1++;
1201     }
1202   while (isspace (*s1))
1203     s1++;
1204
1205   if ((s1[0] == '+') || (s1[0] == '-'))
1206     ntype = *s1++;
1207
1208   while (isspace (*s1))
1209     s1++;
1210
1211   if (*s1 != '[')
1212     return NULL;
1213   s1++;
1214
1215   nclass = s1;
1216   while (isalnum (*s1) || (*s1 == '_'))
1217     s1++;
1218
1219   s2 = s1;
1220   while (isspace (*s2))
1221     s2++;
1222
1223   if (*s2 == '(')
1224     {
1225       s2++;
1226       while (isspace (*s2))
1227         s2++;
1228       ncategory = s2;
1229       while (isalnum (*s2) || (*s2 == '_'))
1230         s2++;
1231       *s2++ = '\0';
1232     }
1233
1234   /* Truncate the class name now that we're not using the open paren.  */
1235   *s1++ = '\0';
1236
1237   nselector = s2;
1238   s1 = s2;
1239
1240   for (;;) {
1241     if (isalnum (*s2) || (*s2 == '_') || (*s2 == ':'))
1242       *s1++ = *s2;
1243     else if (isspace (*s2))
1244       ;
1245     else if (*s2 == ']')
1246       break;
1247     else
1248       return NULL;
1249     s2++;
1250   }
1251   *s1++ = '\0';
1252   s2++;
1253
1254   while (isspace (*s2))
1255     s2++;
1256   if (found_quote)
1257     {
1258       if (*s2 != '\'')
1259         return NULL;
1260       s2++;
1261       while (isspace (*s2))
1262         s2++;
1263     }
1264
1265   if (type != NULL)
1266     *type = ntype;
1267   if (class != NULL)
1268     *class = nclass;
1269   if (category != NULL)
1270     *category = ncategory;
1271   if (selector != NULL)
1272     *selector = nselector;
1273
1274   return s2;
1275 }
1276
1277 static void
1278 find_methods (struct symtab *symtab, char type,
1279               const char *class, const char *category,
1280               const char *selector, struct symbol **syms,
1281               unsigned int *nsym, unsigned int *ndebug)
1282 {
1283   struct objfile *objfile = NULL;
1284   struct minimal_symbol *msymbol = NULL;
1285   struct block *block = NULL;
1286   struct symbol *sym = NULL;
1287
1288   char *symname = NULL;
1289
1290   char ntype = '\0';
1291   char *nclass = NULL;
1292   char *ncategory = NULL;
1293   char *nselector = NULL;
1294
1295   unsigned int csym = 0;
1296   unsigned int cdebug = 0;
1297
1298   static char *tmp = NULL;
1299   static unsigned int tmplen = 0;
1300
1301   gdb_assert (nsym != NULL);
1302   gdb_assert (ndebug != NULL);
1303
1304   if (symtab)
1305     block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK);
1306
1307   ALL_MSYMBOLS (objfile, msymbol)
1308     {
1309       QUIT;
1310
1311       if ((msymbol->type != mst_text) && (msymbol->type != mst_file_text))
1312         /* Not a function or method.  */
1313         continue;
1314
1315       if (symtab)
1316         if ((SYMBOL_VALUE_ADDRESS (msymbol) <  BLOCK_START (block)) ||
1317             (SYMBOL_VALUE_ADDRESS (msymbol) >= BLOCK_END (block)))
1318           /* Not in the specified symtab.  */
1319           continue;
1320
1321       symname = SYMBOL_NATURAL_NAME (msymbol);
1322       if (symname == NULL)
1323         continue;
1324
1325       if ((symname[0] != '-' && symname[0] != '+') || (symname[1] != '['))
1326         /* Not a method name.  */
1327         continue;
1328
1329       while ((strlen (symname) + 1) >= tmplen)
1330         {
1331           tmplen = (tmplen == 0) ? 1024 : tmplen * 2;
1332           tmp = xrealloc (tmp, tmplen);
1333         }
1334       strcpy (tmp, symname);
1335
1336       if (parse_method (tmp, &ntype, &nclass, &ncategory, &nselector) == NULL)
1337         continue;
1338
1339       if ((type != '\0') && (ntype != type))
1340         continue;
1341
1342       if ((class != NULL)
1343           && ((nclass == NULL) || (strcmp (class, nclass) != 0)))
1344         continue;
1345
1346       if ((category != NULL) &&
1347           ((ncategory == NULL) || (strcmp (category, ncategory) != 0)))
1348         continue;
1349
1350       if ((selector != NULL) &&
1351           ((nselector == NULL) || (strcmp (selector, nselector) != 0)))
1352         continue;
1353
1354       sym = find_pc_function (SYMBOL_VALUE_ADDRESS (msymbol));
1355       if (sym != NULL)
1356         {
1357           const char *newsymname = SYMBOL_NATURAL_NAME (sym);
1358
1359           if (strcmp (symname, newsymname) == 0)
1360             {
1361               /* Found a high-level method sym: swap it into the
1362                  lower part of sym_arr (below num_debuggable).  */
1363               if (syms != NULL)
1364                 {
1365                   syms[csym] = syms[cdebug];
1366                   syms[cdebug] = sym;
1367                 }
1368               csym++;
1369               cdebug++;
1370             }
1371           else
1372             {
1373               warning (
1374 "debugging symbol \"%s\" does not match minimal symbol (\"%s\"); ignoring",
1375                        newsymname, symname);
1376               if (syms != NULL)
1377                 syms[csym] = (struct symbol *) msymbol;
1378               csym++;
1379             }
1380         }
1381       else
1382         {
1383           /* Found a non-debuggable method symbol.  */
1384           if (syms != NULL)
1385             syms[csym] = (struct symbol *) msymbol;
1386           csym++;
1387         }
1388     }
1389
1390   if (nsym != NULL)
1391     *nsym = csym;
1392   if (ndebug != NULL)
1393     *ndebug = cdebug;
1394 }
1395
1396 char *find_imps (struct symtab *symtab, struct block *block,
1397                  char *method, struct symbol **syms,
1398                  unsigned int *nsym, unsigned int *ndebug)
1399 {
1400   char type = '\0';
1401   char *class = NULL;
1402   char *category = NULL;
1403   char *selector = NULL;
1404
1405   unsigned int csym = 0;
1406   unsigned int cdebug = 0;
1407
1408   unsigned int ncsym = 0;
1409   unsigned int ncdebug = 0;
1410
1411   char *buf = NULL;
1412   char *tmp = NULL;
1413
1414   gdb_assert (nsym != NULL);
1415   gdb_assert (ndebug != NULL);
1416
1417   if (nsym != NULL)
1418     *nsym = 0;
1419   if (ndebug != NULL)
1420     *ndebug = 0;
1421
1422   buf = (char *) alloca (strlen (method) + 1);
1423   strcpy (buf, method);
1424   tmp = parse_method (buf, &type, &class, &category, &selector);
1425
1426   if (tmp == NULL) {
1427
1428     struct symbol *sym = NULL;
1429     struct minimal_symbol *msym = NULL;
1430
1431     strcpy (buf, method);
1432     tmp = parse_selector (buf, &selector);
1433
1434     if (tmp == NULL)
1435       return NULL;
1436
1437     sym = lookup_symbol (selector, block, VAR_DOMAIN, 0, NULL);
1438     if (sym != NULL)
1439       {
1440         if (syms)
1441           syms[csym] = sym;
1442         csym++;
1443         cdebug++;
1444       }
1445
1446     if (sym == NULL)
1447       msym = lookup_minimal_symbol (selector, 0, 0);
1448
1449     if (msym != NULL)
1450       {
1451         if (syms)
1452           syms[csym] = (struct symbol *)msym;
1453         csym++;
1454       }
1455   }
1456
1457   if (syms != NULL)
1458     find_methods (symtab, type, class, category, selector,
1459                   syms + csym, &ncsym, &ncdebug);
1460   else
1461     find_methods (symtab, type, class, category, selector,
1462                   NULL, &ncsym, &ncdebug);
1463
1464   /* If we didn't find any methods, just return.  */
1465   if (ncsym == 0 && ncdebug == 0)
1466     return method;
1467
1468   /* Take debug symbols from the second batch of symbols and swap them
1469    * with debug symbols from the first batch.  Repeat until either the
1470    * second section is out of debug symbols or the first section is
1471    * full of debug symbols.  Either way we have all debug symbols
1472    * packed to the beginning of the buffer.
1473    */
1474
1475   if (syms != NULL)
1476     {
1477       while ((cdebug < csym) && (ncdebug > 0))
1478         {
1479           struct symbol *s = NULL;
1480           /* First non-debugging symbol.  */
1481           unsigned int i = cdebug;
1482           /* Last of second batch of debug symbols.  */
1483           unsigned int j = csym + ncdebug - 1;
1484
1485           s = syms[j];
1486           syms[j] = syms[i];
1487           syms[i] = s;
1488
1489           /* We've moved a symbol from the second debug section to the
1490              first one.  */
1491           cdebug++;
1492           ncdebug--;
1493         }
1494     }
1495
1496   csym += ncsym;
1497   cdebug += ncdebug;
1498
1499   if (nsym != NULL)
1500     *nsym = csym;
1501   if (ndebug != NULL)
1502     *ndebug = cdebug;
1503
1504   if (syms == NULL)
1505     return method + (tmp - buf);
1506
1507   if (csym > 1)
1508     {
1509       /* Sort debuggable symbols.  */
1510       if (cdebug > 1)
1511         qsort (syms, cdebug, sizeof (struct minimal_symbol *),
1512                compare_classes);
1513
1514       /* Sort minimal_symbols.  */
1515       if ((csym - cdebug) > 1)
1516         qsort (&syms[cdebug], csym - cdebug,
1517                sizeof (struct minimal_symbol *), compare_classes);
1518     }
1519   /* Terminate the sym_arr list.  */
1520   syms[csym] = 0;
1521
1522   return method + (tmp - buf);
1523 }
1524
1525 static void
1526 print_object_command (char *args, int from_tty)
1527 {
1528   struct value *object, *function, *description;
1529   CORE_ADDR string_addr, object_addr;
1530   int i = 0;
1531   char c = -1;
1532
1533   if (!args || !*args)
1534     error (
1535 "The 'print-object' command requires an argument (an Objective-C object)");
1536
1537   {
1538     struct expression *expr = parse_expression (args);
1539     struct cleanup *old_chain =
1540       make_cleanup (free_current_contents, &expr);
1541     int pc = 0;
1542
1543     object = expr->language_defn->la_exp_desc->evaluate_exp
1544       (builtin_type_void_data_ptr, expr, &pc, EVAL_NORMAL);
1545     do_cleanups (old_chain);
1546   }
1547
1548   /* Validate the address for sanity.  */
1549   object_addr = value_as_long (object);
1550   read_memory (object_addr, &c, 1);
1551
1552   function = find_function_in_inferior ("_NSPrintForDebugger");
1553   if (function == NULL)
1554     error ("Unable to locate _NSPrintForDebugger in child process");
1555
1556   description = call_function_by_hand (function, 1, &object);
1557
1558   string_addr = value_as_long (description);
1559   if (string_addr == 0)
1560     error ("object returns null description");
1561
1562   read_memory (string_addr + i++, &c, 1);
1563   if (c != '\0')
1564     do
1565       { /* Read and print characters up to EOS.  */
1566         QUIT;
1567         printf_filtered ("%c", c);
1568         read_memory (string_addr + i++, &c, 1);
1569       } while (c != 0);
1570   else
1571     printf_filtered("<object returns empty description>");
1572   printf_filtered ("\n");
1573 }
1574
1575 /* The data structure 'methcalls' is used to detect method calls (thru
1576  * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1577  * and ultimately find the method being called.
1578  */
1579
1580 struct objc_methcall {
1581   char *name;
1582  /* Return instance method to be called.  */
1583   int (*stop_at) (CORE_ADDR, CORE_ADDR *);
1584   /* Start of pc range corresponding to method invocation.  */
1585   CORE_ADDR begin;
1586   /* End of pc range corresponding to method invocation.  */
1587   CORE_ADDR end;
1588 };
1589
1590 static int resolve_msgsend (CORE_ADDR pc, CORE_ADDR *new_pc);
1591 static int resolve_msgsend_stret (CORE_ADDR pc, CORE_ADDR *new_pc);
1592 static int resolve_msgsend_super (CORE_ADDR pc, CORE_ADDR *new_pc);
1593 static int resolve_msgsend_super_stret (CORE_ADDR pc, CORE_ADDR *new_pc);
1594
1595 static struct objc_methcall methcalls[] = {
1596   { "_objc_msgSend", resolve_msgsend, 0, 0},
1597   { "_objc_msgSend_stret", resolve_msgsend_stret, 0, 0},
1598   { "_objc_msgSendSuper", resolve_msgsend_super, 0, 0},
1599   { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret, 0, 0},
1600   { "_objc_getClass", NULL, 0, 0},
1601   { "_objc_getMetaClass", NULL, 0, 0}
1602 };
1603
1604 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1605
1606 /* The following function, "find_objc_msgsend", fills in the data
1607  * structure "objc_msgs" by finding the addresses of each of the
1608  * (currently four) functions that it holds (of which objc_msgSend is
1609  * the first).  This must be called each time symbols are loaded, in
1610  * case the functions have moved for some reason.
1611  */
1612
1613 static void
1614 find_objc_msgsend (void)
1615 {
1616   unsigned int i;
1617   for (i = 0; i < nmethcalls; i++) {
1618
1619     struct minimal_symbol *func;
1620
1621     /* Try both with and without underscore.  */
1622     func = lookup_minimal_symbol (methcalls[i].name, NULL, NULL);
1623     if ((func == NULL) && (methcalls[i].name[0] == '_')) {
1624       func = lookup_minimal_symbol (methcalls[i].name + 1, NULL, NULL);
1625     }
1626     if (func == NULL) {
1627       methcalls[i].begin = 0;
1628       methcalls[i].end = 0;
1629       continue;
1630     }
1631
1632     methcalls[i].begin = SYMBOL_VALUE_ADDRESS (func);
1633     do {
1634       methcalls[i].end = SYMBOL_VALUE_ADDRESS (++func);
1635     } while (methcalls[i].begin == methcalls[i].end);
1636   }
1637 }
1638
1639 /* find_objc_msgcall (replaces pc_off_limits)
1640  *
1641  * ALL that this function now does is to determine whether the input
1642  * address ("pc") is the address of one of the Objective-C message
1643  * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1644  * if so, it returns the address of the method that will be called.
1645  *
1646  * The old function "pc_off_limits" used to do a lot of other things
1647  * in addition, such as detecting shared library jump stubs and
1648  * returning the address of the shlib function that would be called.
1649  * That functionality has been moved into the SKIP_TRAMPOLINE_CODE and
1650  * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
1651  * dependent modules.
1652  */
1653
1654 struct objc_submethod_helper_data {
1655   int (*f) (CORE_ADDR, CORE_ADDR *);
1656   CORE_ADDR pc;
1657   CORE_ADDR *new_pc;
1658 };
1659
1660 static int
1661 find_objc_msgcall_submethod_helper (void * arg)
1662 {
1663   struct objc_submethod_helper_data *s =
1664     (struct objc_submethod_helper_data *) arg;
1665
1666   if (s->f (s->pc, s->new_pc) == 0)
1667     return 1;
1668   else
1669     return 0;
1670 }
1671
1672 static int
1673 find_objc_msgcall_submethod (int (*f) (CORE_ADDR, CORE_ADDR *),
1674                              CORE_ADDR pc,
1675                              CORE_ADDR *new_pc)
1676 {
1677   struct objc_submethod_helper_data s;
1678
1679   s.f = f;
1680   s.pc = pc;
1681   s.new_pc = new_pc;
1682
1683   if (catch_errors (find_objc_msgcall_submethod_helper,
1684                     (void *) &s,
1685                     "Unable to determine target of Objective-C method call (ignoring):\n",
1686                     RETURN_MASK_ALL) == 0)
1687     return 1;
1688   else
1689     return 0;
1690 }
1691
1692 int
1693 find_objc_msgcall (CORE_ADDR pc, CORE_ADDR *new_pc)
1694 {
1695   unsigned int i;
1696
1697   find_objc_msgsend ();
1698   if (new_pc != NULL)
1699     {
1700       *new_pc = 0;
1701     }
1702
1703   for (i = 0; i < nmethcalls; i++)
1704     if ((pc >= methcalls[i].begin) && (pc < methcalls[i].end))
1705       {
1706         if (methcalls[i].stop_at != NULL)
1707           return find_objc_msgcall_submethod (methcalls[i].stop_at,
1708                                               pc, new_pc);
1709         else
1710           return 0;
1711       }
1712
1713   return 0;
1714 }
1715
1716 extern initialize_file_ftype _initialize_objc_language; /* -Wmissing-prototypes */
1717
1718 void
1719 _initialize_objc_language (void)
1720 {
1721   add_language (&objc_language_defn);
1722   add_info ("selectors", selectors_info,    /* INFO SELECTORS command.  */
1723             "All Objective-C selectors, or those matching REGEXP.");
1724   add_info ("classes", classes_info,        /* INFO CLASSES   command.  */
1725             "All Objective-C classes, or those matching REGEXP.");
1726   add_com ("print-object", class_vars, print_object_command,
1727            "Ask an Objective-C object to print itself.");
1728   add_com_alias ("po", "print-object", class_vars, 1);
1729 }
1730
1731 static void
1732 read_objc_method (CORE_ADDR addr, struct objc_method *method)
1733 {
1734   method->name  = read_memory_unsigned_integer (addr + 0, 4);
1735   method->types = read_memory_unsigned_integer (addr + 4, 4);
1736   method->imp   = read_memory_unsigned_integer (addr + 8, 4);
1737 }
1738
1739 static
1740 unsigned long read_objc_methlist_nmethods (CORE_ADDR addr)
1741 {
1742   return read_memory_unsigned_integer (addr + 4, 4);
1743 }
1744
1745 static void
1746 read_objc_methlist_method (CORE_ADDR addr, unsigned long num,
1747                            struct objc_method *method)
1748 {
1749   gdb_assert (num < read_objc_methlist_nmethods (addr));
1750   read_objc_method (addr + 8 + (12 * num), method);
1751 }
1752
1753 static void
1754 read_objc_object (CORE_ADDR addr, struct objc_object *object)
1755 {
1756   object->isa = read_memory_unsigned_integer (addr, 4);
1757 }
1758
1759 static void
1760 read_objc_super (CORE_ADDR addr, struct objc_super *super)
1761 {
1762   super->receiver = read_memory_unsigned_integer (addr, 4);
1763   super->class = read_memory_unsigned_integer (addr + 4, 4);
1764 };
1765
1766 static void
1767 read_objc_class (CORE_ADDR addr, struct objc_class *class)
1768 {
1769   class->isa = read_memory_unsigned_integer (addr, 4);
1770   class->super_class = read_memory_unsigned_integer (addr + 4, 4);
1771   class->name = read_memory_unsigned_integer (addr + 8, 4);
1772   class->version = read_memory_unsigned_integer (addr + 12, 4);
1773   class->info = read_memory_unsigned_integer (addr + 16, 4);
1774   class->instance_size = read_memory_unsigned_integer (addr + 18, 4);
1775   class->ivars = read_memory_unsigned_integer (addr + 24, 4);
1776   class->methods = read_memory_unsigned_integer (addr + 28, 4);
1777   class->cache = read_memory_unsigned_integer (addr + 32, 4);
1778   class->protocols = read_memory_unsigned_integer (addr + 36, 4);
1779 }
1780
1781 static CORE_ADDR
1782 find_implementation_from_class (CORE_ADDR class, CORE_ADDR sel)
1783 {
1784   CORE_ADDR subclass = class;
1785
1786   while (subclass != 0)
1787     {
1788
1789       struct objc_class class_str;
1790       unsigned mlistnum = 0;
1791
1792       read_objc_class (subclass, &class_str);
1793
1794       for (;;)
1795         {
1796           CORE_ADDR mlist;
1797           unsigned long nmethods;
1798           unsigned long i;
1799
1800           mlist = read_memory_unsigned_integer (class_str.methods +
1801                                                 (4 * mlistnum), 4);
1802           if (mlist == 0)
1803             break;
1804
1805           nmethods = read_objc_methlist_nmethods (mlist);
1806
1807           for (i = 0; i < nmethods; i++)
1808             {
1809               struct objc_method meth_str;
1810               read_objc_methlist_method (mlist, i, &meth_str);
1811
1812 #if 0
1813               fprintf (stderr,
1814                        "checking method 0x%lx against selector 0x%lx\n",
1815                        meth_str.name, sel);
1816 #endif
1817
1818               if (meth_str.name == sel)
1819                 /* FIXME: hppa arch was doing a pointer dereference
1820                    here. There needs to be a better way to do that.  */
1821                 return meth_str.imp;
1822             }
1823           mlistnum++;
1824         }
1825       subclass = class_str.super_class;
1826     }
1827
1828   return 0;
1829 }
1830
1831 static CORE_ADDR
1832 find_implementation (CORE_ADDR object, CORE_ADDR sel)
1833 {
1834   struct objc_object ostr;
1835
1836   if (object == 0)
1837     return 0;
1838   read_objc_object (object, &ostr);
1839   if (ostr.isa == 0)
1840     return 0;
1841
1842   return find_implementation_from_class (ostr.isa, sel);
1843 }
1844
1845 #define OBJC_FETCH_POINTER_ARGUMENT(argi) \
1846   FETCH_POINTER_ARGUMENT (get_current_frame (), argi, builtin_type_void_func_ptr)
1847
1848 static int
1849 resolve_msgsend (CORE_ADDR pc, CORE_ADDR *new_pc)
1850 {
1851   CORE_ADDR object;
1852   CORE_ADDR sel;
1853   CORE_ADDR res;
1854
1855   object = OBJC_FETCH_POINTER_ARGUMENT (0);
1856   sel = OBJC_FETCH_POINTER_ARGUMENT (1);
1857
1858   res = find_implementation (object, sel);
1859   if (new_pc != 0)
1860     *new_pc = res;
1861   if (res == 0)
1862     return 1;
1863   return 0;
1864 }
1865
1866 static int
1867 resolve_msgsend_stret (CORE_ADDR pc, CORE_ADDR *new_pc)
1868 {
1869   CORE_ADDR object;
1870   CORE_ADDR sel;
1871   CORE_ADDR res;
1872
1873   object = OBJC_FETCH_POINTER_ARGUMENT (1);
1874   sel = OBJC_FETCH_POINTER_ARGUMENT (2);
1875
1876   res = find_implementation (object, sel);
1877   if (new_pc != 0)
1878     *new_pc = res;
1879   if (res == 0)
1880     return 1;
1881   return 0;
1882 }
1883
1884 static int
1885 resolve_msgsend_super (CORE_ADDR pc, CORE_ADDR *new_pc)
1886 {
1887   struct objc_super sstr;
1888
1889   CORE_ADDR super;
1890   CORE_ADDR sel;
1891   CORE_ADDR res;
1892
1893   super = OBJC_FETCH_POINTER_ARGUMENT (0);
1894   sel = OBJC_FETCH_POINTER_ARGUMENT (1);
1895
1896   read_objc_super (super, &sstr);
1897   if (sstr.class == 0)
1898     return 0;
1899
1900   res = find_implementation_from_class (sstr.class, sel);
1901   if (new_pc != 0)
1902     *new_pc = res;
1903   if (res == 0)
1904     return 1;
1905   return 0;
1906 }
1907
1908 static int
1909 resolve_msgsend_super_stret (CORE_ADDR pc, CORE_ADDR *new_pc)
1910 {
1911   struct objc_super sstr;
1912
1913   CORE_ADDR super;
1914   CORE_ADDR sel;
1915   CORE_ADDR res;
1916
1917   super = OBJC_FETCH_POINTER_ARGUMENT (1);
1918   sel = OBJC_FETCH_POINTER_ARGUMENT (2);
1919
1920   read_objc_super (super, &sstr);
1921   if (sstr.class == 0)
1922     return 0;
1923
1924   res = find_implementation_from_class (sstr.class, sel);
1925   if (new_pc != 0)
1926     *new_pc = res;
1927   if (res == 0)
1928     return 1;
1929   return 0;
1930 }