contrib/gdb/gdb/objc-lang.c

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