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   array_row_major,
 663   &exp_descriptor_standard,
 664   objc_parse,
 665   objc_error,
 666   null_post_parser,
 667   objc_printchar,               /* Print a character constant */
 668   objc_printstr,                /* Function to print string constant */
 669   objc_emit_char,
 670   objc_create_fundamental_type, /* Create fundamental type in this language */
 671   c_print_type,                 /* Print a type using appropriate syntax */
 672   c_val_print,                  /* Print a value using appropriate syntax */
 673   c_value_print,                /* Print a top-level value */
 674   objc_skip_trampoline,         /* Language specific skip_trampoline */
 675   value_of_this,                /* value_of_this */
 676   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
 677   basic_lookup_transparent_type,/* lookup_transparent_type */
 678   objc_demangle,                /* Language specific symbol demangler */
 679   NULL,                         /* Language specific class_name_from_physname */
 680   {"",     "",    "",  ""},     /* Binary format info */
 681   {"0%lo",  "0",   "o", ""},    /* Octal format info */
 682   {"%ld",   "",    "d", ""},    /* Decimal format info */
 683   {"0x%lx", "0x",  "x", ""},    /* Hex format info */
 684   objc_op_print_tab,            /* Expression operators for printing */
 685   1,                            /* C-style arrays */
 686   0,                            /* String lower bound */
 687   &builtin_type_char,           /* Type of string elements */
 688   default_word_break_characters,
 689   NULL, /* FIXME: la_language_arch_info.  */
 690   LANG_MAGIC
 691 };
 692
 693 /*
 694  * ObjC:
 695  * Following functions help construct Objective-C message calls
 696  */
 697
 698 struct selname          /* For parsing Objective-C.  */
 699   {
 700     struct selname *next;
 701     char *msglist_sel;
 702     int msglist_len;
 703   };
 704
 705 static int msglist_len;
 706 static struct selname *selname_chain;
 707 static char *msglist_sel;
 708
 709 void
 710 start_msglist(void)
 711 {
 712   struct selname *new =
 713     (struct selname *) xmalloc (sizeof (struct selname));
 714
 715   new->next = selname_chain;
 716   new->msglist_len = msglist_len;
 717   new->msglist_sel = msglist_sel;
 718   msglist_len = 0;
 719   msglist_sel = (char *)xmalloc(1);
 720   *msglist_sel = 0;
 721   selname_chain = new;
 722 }
 723
 724 void
 725 add_msglist(struct stoken *str, int addcolon)
 726 {
 727   char *s, *p;
 728   int len, plen;
 729
 730   if (str == 0) {               /* Unnamed arg, or...  */
 731     if (addcolon == 0) {        /* variable number of args.  */
 732       msglist_len++;
 733       return;
 734     }
 735     p = "";
 736     plen = 0;
 737   } else {
 738     p = str->ptr;
 739     plen = str->length;
 740   }
 741   len = plen + strlen(msglist_sel) + 2;
 742   s = (char *)xmalloc(len);
 743   strcpy(s, msglist_sel);
 744   strncat(s, p, plen);
 745   xfree(msglist_sel);
 746   msglist_sel = s;
 747   if (addcolon) {
 748     s[len-2] = ':';
 749     s[len-1] = 0;
 750     msglist_len++;
 751   } else
 752     s[len-2] = '\0';
 753 }
 754
 755 int
 756 end_msglist(void)
 757 {
 758   int val = msglist_len;
 759   struct selname *sel = selname_chain;
 760   char *p = msglist_sel;
 761   CORE_ADDR selid;
 762
 763   selname_chain = sel->next;
 764   msglist_len = sel->msglist_len;
 765   msglist_sel = sel->msglist_sel;
 766   selid = lookup_child_selector(p);
 767   if (!selid)
 768     error("Can't find selector \"%s\"", p);
 769   write_exp_elt_longcst (selid);
 770   xfree(p);
 771   write_exp_elt_longcst (val);  /* Number of args */
 772   xfree(sel);
 773
 774   return val;
 775 }
 776
 777 /*
 778  * Function: specialcmp (char *a, char *b)
 779  *
 780  * Special strcmp: treats ']' and ' ' as end-of-string.
 781  * Used for qsorting lists of objc methods (either by class or selector).
 782  */
 783
 784 static int
 785 specialcmp (char *a, char *b)
 786 {
 787   while (*a && *a != ' ' && *a != ']' && *b && *b != ' ' && *b != ']')
 788     {
 789       if (*a != *b)
 790         return *a - *b;
 791       a++, b++;
 792     }
 793   if (*a && *a != ' ' && *a != ']')
 794     return  1;          /* a is longer therefore greater */
 795   if (*b && *b != ' ' && *b != ']')
 796     return -1;          /* a is shorter therefore lesser */
 797   return    0;          /* a and b are identical */
 798 }
 799
 800 /*
 801  * Function: compare_selectors (const void *, const void *)
 802  *
 803  * Comparison function for use with qsort.  Arguments are symbols or
 804  * msymbols Compares selector part of objc method name alphabetically.
 805  */
 806
 807 static int
 808 compare_selectors (const void *a, const void *b)
 809 {
 810   char *aname, *bname;
 811
 812   aname = SYMBOL_PRINT_NAME (*(struct symbol **) a);
 813   bname = SYMBOL_PRINT_NAME (*(struct symbol **) b);
 814   if (aname == NULL || bname == NULL)
 815     error ("internal: compare_selectors(1)");
 816
 817   aname = strchr(aname, ' ');
 818   bname = strchr(bname, ' ');
 819   if (aname == NULL || bname == NULL)
 820     error ("internal: compare_selectors(2)");
 821
 822   return specialcmp (aname+1, bname+1);
 823 }
 824
 825 /*
 826  * Function: selectors_info (regexp, from_tty)
 827  *
 828  * Implements the "Info selectors" command.  Takes an optional regexp
 829  * arg.  Lists all objective c selectors that match the regexp.  Works
 830  * by grepping thru all symbols for objective c methods.  Output list
 831  * is sorted and uniqued.
 832  */
 833
 834 static void
 835 selectors_info (char *regexp, int from_tty)
 836 {
 837   struct objfile        *objfile;
 838   struct minimal_symbol *msymbol;
 839   char                  *name;
 840   char                  *val;
 841   int                    matches = 0;
 842   int                    maxlen  = 0;
 843   int                    ix;
 844   char                   myregexp[2048];
 845   char                   asel[256];
 846   struct symbol        **sym_arr;
 847   int                    plusminus = 0;
 848
 849   if (regexp == NULL)
 850     strcpy(myregexp, ".*]");    /* Null input, match all objc methods.  */
 851   else
 852     {
 853       if (*regexp == '+' || *regexp == '-')
 854         { /* User wants only class methods or only instance methods.  */
 855           plusminus = *regexp++;
 856           while (*regexp == ' ' || *regexp == '\t')
 857             regexp++;
 858         }
 859       if (*regexp == '\0')
 860         strcpy(myregexp, ".*]");
 861       else
 862         {
 863           strcpy(myregexp, regexp);
 864           if (myregexp[strlen(myregexp) - 1] == '$') /* end of selector */
 865             myregexp[strlen(myregexp) - 1] = ']';    /* end of method name */
 866           else
 867             strcat(myregexp, ".*]");
 868         }
 869     }
 870
 871   if (regexp != NULL)
 872     {
 873       val = re_comp (myregexp);
 874       if (val != 0)
 875         error ("Invalid regexp (%s): %s", val, regexp);
 876     }
 877
 878   /* First time thru is JUST to get max length and count.  */
 879   ALL_MSYMBOLS (objfile, msymbol)
 880     {
 881       QUIT;
 882       name = SYMBOL_NATURAL_NAME (msymbol);
 883       if (name &&
 884          (name[0] == '-' || name[0] == '+') &&
 885           name[1] == '[')               /* Got a method name.  */
 886         {
 887           /* Filter for class/instance methods.  */
 888           if (plusminus && name[0] != plusminus)
 889             continue;
 890           /* Find selector part.  */
 891           name = (char *) strchr(name+2, ' ');
 892           if (regexp == NULL || re_exec(++name) != 0)
 893             {
 894               char *mystart = name;
 895               char *myend   = (char *) strchr(mystart, ']');
 896
 897               if (myend && (myend - mystart > maxlen))
 898                 maxlen = myend - mystart;       /* Get longest selector.  */
 899               matches++;
 900             }
 901         }
 902     }
 903   if (matches)
 904     {
 905       printf_filtered ("Selectors matching \"%s\":\n\n",
 906                        regexp ? regexp : "*");
 907
 908       sym_arr = alloca (matches * sizeof (struct symbol *));
 909       matches = 0;
 910       ALL_MSYMBOLS (objfile, msymbol)
 911         {
 912           QUIT;
 913           name = SYMBOL_NATURAL_NAME (msymbol);
 914           if (name &&
 915              (name[0] == '-' || name[0] == '+') &&
 916               name[1] == '[')           /* Got a method name.  */
 917             {
 918               /* Filter for class/instance methods.  */
 919               if (plusminus && name[0] != plusminus)
 920                 continue;
 921               /* Find selector part.  */
 922               name = (char *) strchr(name+2, ' ');
 923               if (regexp == NULL || re_exec(++name) != 0)
 924                 sym_arr[matches++] = (struct symbol *) msymbol;
 925             }
 926         }
 927
 928       qsort (sym_arr, matches, sizeof (struct minimal_symbol *),
 929              compare_selectors);
 930       /* Prevent compare on first iteration.  */
 931       asel[0] = 0;
 932       for (ix = 0; ix < matches; ix++)  /* Now do the output.  */
 933         {
 934           char *p = asel;
 935
 936           QUIT;
 937           name = SYMBOL_NATURAL_NAME (sym_arr[ix]);
 938           name = strchr (name, ' ') + 1;
 939           if (p[0] && specialcmp(name, p) == 0)
 940             continue;           /* Seen this one already (not unique).  */
 941
 942           /* Copy selector part.  */
 943           while (*name && *name != ']')
 944             *p++ = *name++;
 945           *p++ = '\0';
 946           /* Print in columns.  */
 947           puts_filtered_tabular(asel, maxlen + 1, 0);
 948         }
 949       begin_line();
 950     }
 951   else
 952     printf_filtered ("No selectors matching \"%s\"\n", regexp ? regexp : "*");
 953 }
 954
 955 /*
 956  * Function: compare_classes (const void *, const void *)
 957  *
 958  * Comparison function for use with qsort.  Arguments are symbols or
 959  * msymbols Compares class part of objc method name alphabetically.
 960  */
 961
 962 static int
 963 compare_classes (const void *a, const void *b)
 964 {
 965   char *aname, *bname;
 966
 967   aname = SYMBOL_PRINT_NAME (*(struct symbol **) a);
 968   bname = SYMBOL_PRINT_NAME (*(struct symbol **) b);
 969   if (aname == NULL || bname == NULL)
 970     error ("internal: compare_classes(1)");
 971
 972   return specialcmp (aname+1, bname+1);
 973 }
 974
 975 /*
 976  * Function: classes_info(regexp, from_tty)
 977  *
 978  * Implements the "info classes" command for objective c classes.
 979  * Lists all objective c classes that match the optional regexp.
 980  * Works by grepping thru the list of objective c methods.  List will
 981  * be sorted and uniqued (since one class may have many methods).
 982  * BUGS: will not list a class that has no methods.
 983  */
 984
 985 static void
 986 classes_info (char *regexp, int from_tty)
 987 {
 988   struct objfile        *objfile;
 989   struct minimal_symbol *msymbol;
 990   char                  *name;
 991   char                  *val;
 992   int                    matches = 0;
 993   int                    maxlen  = 0;
 994   int                    ix;
 995   char                   myregexp[2048];
 996   char                   aclass[256];
 997   struct symbol        **sym_arr;
 998
 999   if (regexp == NULL)
1000     strcpy(myregexp, ".* ");    /* Null input: match all objc classes.  */
1001   else
1002     {
1003       strcpy(myregexp, regexp);
1004       if (myregexp[strlen(myregexp) - 1] == '$')
1005         /* In the method name, the end of the class name is marked by ' '.  */
1006         myregexp[strlen(myregexp) - 1] = ' ';
1007       else
1008         strcat(myregexp, ".* ");
1009     }
1010
1011   if (regexp != NULL)
1012     {
1013       val = re_comp (myregexp);
1014       if (val != 0)
1015         error ("Invalid regexp (%s): %s", val, regexp);
1016     }
1017
1018   /* First time thru is JUST to get max length and count.  */
1019   ALL_MSYMBOLS (objfile, msymbol)
1020     {
1021       QUIT;
1022       name = SYMBOL_NATURAL_NAME (msymbol);
1023       if (name &&
1024          (name[0] == '-' || name[0] == '+') &&
1025           name[1] == '[')                       /* Got a method name.  */
1026         if (regexp == NULL || re_exec(name+2) != 0)
1027           {
1028             /* Compute length of classname part.  */
1029             char *mystart = name + 2;
1030             char *myend   = (char *) strchr(mystart, ' ');
1031
1032             if (myend && (myend - mystart > maxlen))
1033               maxlen = myend - mystart;
1034             matches++;
1035           }
1036     }
1037   if (matches)
1038     {
1039       printf_filtered ("Classes matching \"%s\":\n\n",
1040                        regexp ? regexp : "*");
1041       sym_arr = alloca (matches * sizeof (struct symbol *));
1042       matches = 0;
1043       ALL_MSYMBOLS (objfile, msymbol)
1044         {
1045           QUIT;
1046           name = SYMBOL_NATURAL_NAME (msymbol);
1047           if (name &&
1048              (name[0] == '-' || name[0] == '+') &&
1049               name[1] == '[')                   /* Got a method name.  */
1050             if (regexp == NULL || re_exec(name+2) != 0)
1051                 sym_arr[matches++] = (struct symbol *) msymbol;
1052         }
1053
1054       qsort (sym_arr, matches, sizeof (struct minimal_symbol *),
1055              compare_classes);
1056       /* Prevent compare on first iteration.  */
1057       aclass[0] = 0;
1058       for (ix = 0; ix < matches; ix++)  /* Now do the output.  */
1059         {
1060           char *p = aclass;
1061
1062           QUIT;
1063           name = SYMBOL_NATURAL_NAME (sym_arr[ix]);
1064           name += 2;
1065           if (p[0] && specialcmp(name, p) == 0)
1066             continue;   /* Seen this one already (not unique).  */
1067
1068           /* Copy class part of method name.  */
1069           while (*name && *name != ' ')
1070             *p++ = *name++;
1071           *p++ = '\0';
1072           /* Print in columns.  */
1073           puts_filtered_tabular(aclass, maxlen + 1, 0);
1074         }
1075       begin_line();
1076     }
1077   else
1078     printf_filtered ("No classes matching \"%s\"\n", regexp ? regexp : "*");
1079 }
1080
1081 /*
1082  * Function: find_imps (char *selector, struct symbol **sym_arr)
1083  *
1084  * Input:  a string representing a selector
1085  *         a pointer to an array of symbol pointers
1086  *         possibly a pointer to a symbol found by the caller.
1087  *
1088  * Output: number of methods that implement that selector.  Side
1089  * effects: The array of symbol pointers is filled with matching syms.
1090  *
1091  * By analogy with function "find_methods" (symtab.c), builds a list
1092  * of symbols matching the ambiguous input, so that "decode_line_2"
1093  * (symtab.c) can list them and ask the user to choose one or more.
1094  * In this case the matches are objective c methods
1095  * ("implementations") matching an objective c selector.
1096  *
1097  * Note that it is possible for a normal (c-style) function to have
1098  * the same name as an objective c selector.  To prevent the selector
1099  * from eclipsing the function, we allow the caller (decode_line_1) to
1100  * search for such a function first, and if it finds one, pass it in
1101  * to us.  We will then integrate it into the list.  We also search
1102  * for one here, among the minsyms.
1103  *
1104  * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be divided
1105  *       into two parts: debuggable (struct symbol) syms, and
1106  *       non_debuggable (struct minimal_symbol) syms.  The debuggable
1107  *       ones will come first, before NUM_DEBUGGABLE (which will thus
1108  *       be the index of the first non-debuggable one).
1109  */
1110
1111 /*
1112  * Function: total_number_of_imps (char *selector);
1113  *
1114  * Input:  a string representing a selector
1115  * Output: number of methods that implement that selector.
1116  *
1117  * By analogy with function "total_number_of_methods", this allows
1118  * decode_line_1 (symtab.c) to detect if there are objective c methods
1119  * matching the input, and to allocate an array of pointers to them
1120  * which can be manipulated by "decode_line_2" (also in symtab.c).
1121  */
1122
1123 char *
1124 parse_selector (char *method, char **selector)
1125 {
1126   char *s1 = NULL;
1127   char *s2 = NULL;
1128   int found_quote = 0;
1129
1130   char *nselector = NULL;
1131
1132   gdb_assert (selector != NULL);
1133
1134   s1 = method;
1135
1136   while (isspace (*s1))
1137     s1++;
1138   if (*s1 == '\'')
1139     {
1140       found_quote = 1;
1141       s1++;
1142     }
1143   while (isspace (*s1))
1144     s1++;
1145
1146   nselector = s1;
1147   s2 = s1;
1148
1149   for (;;) {
1150     if (isalnum (*s2) || (*s2 == '_') || (*s2 == ':'))
1151       *s1++ = *s2;
1152     else if (isspace (*s2))
1153       ;
1154     else if ((*s2 == '\0') || (*s2 == '\''))
1155       break;
1156     else
1157       return NULL;
1158     s2++;
1159   }
1160   *s1++ = '\0';
1161
1162   while (isspace (*s2))
1163     s2++;
1164   if (found_quote)
1165     {
1166       if (*s2 == '\'')
1167         s2++;
1168       while (isspace (*s2))
1169         s2++;
1170     }
1171
1172   if (selector != NULL)
1173     *selector = nselector;
1174
1175   return s2;
1176 }
1177
1178 char *
1179 parse_method (char *method, char *type, char **class,
1180               char **category, char **selector)
1181 {
1182   char *s1 = NULL;
1183   char *s2 = NULL;
1184   int found_quote = 0;
1185
1186   char ntype = '\0';
1187   char *nclass = NULL;
1188   char *ncategory = NULL;
1189   char *nselector = NULL;
1190
1191   gdb_assert (type != NULL);
1192   gdb_assert (class != NULL);
1193   gdb_assert (category != NULL);
1194   gdb_assert (selector != NULL);
1195
1196   s1 = method;
1197
1198   while (isspace (*s1))
1199     s1++;
1200   if (*s1 == '\'')
1201     {
1202       found_quote = 1;
1203       s1++;
1204     }
1205   while (isspace (*s1))
1206     s1++;
1207
1208   if ((s1[0] == '+') || (s1[0] == '-'))
1209     ntype = *s1++;
1210
1211   while (isspace (*s1))
1212     s1++;
1213
1214   if (*s1 != '[')
1215     return NULL;
1216   s1++;
1217
1218   nclass = s1;
1219   while (isalnum (*s1) || (*s1 == '_'))
1220     s1++;
1221
1222   s2 = s1;
1223   while (isspace (*s2))
1224     s2++;
1225
1226   if (*s2 == '(')
1227     {
1228       s2++;
1229       while (isspace (*s2))
1230         s2++;
1231       ncategory = s2;
1232       while (isalnum (*s2) || (*s2 == '_'))
1233         s2++;
1234       *s2++ = '\0';
1235     }
1236
1237   /* Truncate the class name now that we're not using the open paren.  */
1238   *s1++ = '\0';
1239
1240   nselector = s2;
1241   s1 = s2;
1242
1243   for (;;) {
1244     if (isalnum (*s2) || (*s2 == '_') || (*s2 == ':'))
1245       *s1++ = *s2;
1246     else if (isspace (*s2))
1247       ;
1248     else if (*s2 == ']')
1249       break;
1250     else
1251       return NULL;
1252     s2++;
1253   }
1254   *s1++ = '\0';
1255   s2++;
1256
1257   while (isspace (*s2))
1258     s2++;
1259   if (found_quote)
1260     {
1261       if (*s2 != '\'')
1262         return NULL;
1263       s2++;
1264       while (isspace (*s2))
1265         s2++;
1266     }
1267
1268   if (type != NULL)
1269     *type = ntype;
1270   if (class != NULL)
1271     *class = nclass;
1272   if (category != NULL)
1273     *category = ncategory;
1274   if (selector != NULL)
1275     *selector = nselector;
1276
1277   return s2;
1278 }
1279
1280 static void
1281 find_methods (struct symtab *symtab, char type,
1282               const char *class, const char *category,
1283               const char *selector, struct symbol **syms,
1284               unsigned int *nsym, unsigned int *ndebug)
1285 {
1286   struct objfile *objfile = NULL;
1287   struct minimal_symbol *msymbol = NULL;
1288   struct block *block = NULL;
1289   struct symbol *sym = NULL;
1290
1291   char *symname = NULL;
1292
1293   char ntype = '\0';
1294   char *nclass = NULL;
1295   char *ncategory = NULL;
1296   char *nselector = NULL;
1297
1298   unsigned int csym = 0;
1299   unsigned int cdebug = 0;
1300
1301   static char *tmp = NULL;
1302   static unsigned int tmplen = 0;
1303
1304   gdb_assert (nsym != NULL);
1305   gdb_assert (ndebug != NULL);
1306
1307   if (symtab)
1308     block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK);
1309
1310   ALL_MSYMBOLS (objfile, msymbol)
1311     {
1312       QUIT;
1313
1314       if ((msymbol->type != mst_text) && (msymbol->type != mst_file_text))
1315         /* Not a function or method.  */
1316         continue;
1317
1318       if (symtab)
1319         if ((SYMBOL_VALUE_ADDRESS (msymbol) <  BLOCK_START (block)) ||
1320             (SYMBOL_VALUE_ADDRESS (msymbol) >= BLOCK_END (block)))
1321           /* Not in the specified symtab.  */
1322           continue;
1323
1324       symname = SYMBOL_NATURAL_NAME (msymbol);
1325       if (symname == NULL)
1326         continue;
1327
1328       if ((symname[0] != '-' && symname[0] != '+') || (symname[1] != '['))
1329         /* Not a method name.  */
1330         continue;
1331
1332       while ((strlen (symname) + 1) >= tmplen)
1333         {
1334           tmplen = (tmplen == 0) ? 1024 : tmplen * 2;
1335           tmp = xrealloc (tmp, tmplen);
1336         }
1337       strcpy (tmp, symname);
1338
1339       if (parse_method (tmp, &ntype, &nclass, &ncategory, &nselector) == NULL)
1340         continue;
1341
1342       if ((type != '\0') && (ntype != type))
1343         continue;
1344
1345       if ((class != NULL)
1346           && ((nclass == NULL) || (strcmp (class, nclass) != 0)))
1347         continue;
1348
1349       if ((category != NULL) &&
1350           ((ncategory == NULL) || (strcmp (category, ncategory) != 0)))
1351         continue;
1352
1353       if ((selector != NULL) &&
1354           ((nselector == NULL) || (strcmp (selector, nselector) != 0)))
1355         continue;
1356
1357       sym = find_pc_function (SYMBOL_VALUE_ADDRESS (msymbol));
1358       if (sym != NULL)
1359         {
1360           const char *newsymname = SYMBOL_NATURAL_NAME (sym);
1361
1362           if (strcmp (symname, newsymname) == 0)
1363             {
1364               /* Found a high-level method sym: swap it into the
1365                  lower part of sym_arr (below num_debuggable).  */
1366               if (syms != NULL)
1367                 {
1368                   syms[csym] = syms[cdebug];
1369                   syms[cdebug] = sym;
1370                 }
1371               csym++;
1372               cdebug++;
1373             }
1374           else
1375             {
1376               warning (
1377 "debugging symbol \"%s\" does not match minimal symbol (\"%s\"); ignoring",
1378                        newsymname, symname);
1379               if (syms != NULL)
1380                 syms[csym] = (struct symbol *) msymbol;
1381               csym++;
1382             }
1383         }
1384       else
1385         {
1386           /* Found a non-debuggable method symbol.  */
1387           if (syms != NULL)
1388             syms[csym] = (struct symbol *) msymbol;
1389           csym++;
1390         }
1391     }
1392
1393   if (nsym != NULL)
1394     *nsym = csym;
1395   if (ndebug != NULL)
1396     *ndebug = cdebug;
1397 }
1398
1399 char *find_imps (struct symtab *symtab, struct block *block,
1400                  char *method, struct symbol **syms,
1401                  unsigned int *nsym, unsigned int *ndebug)
1402 {
1403   char type = '\0';
1404   char *class = NULL;
1405   char *category = NULL;
1406   char *selector = NULL;
1407
1408   unsigned int csym = 0;
1409   unsigned int cdebug = 0;
1410
1411   unsigned int ncsym = 0;
1412   unsigned int ncdebug = 0;
1413
1414   char *buf = NULL;
1415   char *tmp = NULL;
1416
1417   gdb_assert (nsym != NULL);
1418   gdb_assert (ndebug != NULL);
1419
1420   if (nsym != NULL)
1421     *nsym = 0;
1422   if (ndebug != NULL)
1423     *ndebug = 0;
1424
1425   buf = (char *) alloca (strlen (method) + 1);
1426   strcpy (buf, method);
1427   tmp = parse_method (buf, &type, &class, &category, &selector);
1428
1429   if (tmp == NULL) {
1430
1431     struct symbol *sym = NULL;
1432     struct minimal_symbol *msym = NULL;
1433
1434     strcpy (buf, method);
1435     tmp = parse_selector (buf, &selector);
1436
1437     if (tmp == NULL)
1438       return NULL;
1439
1440     sym = lookup_symbol (selector, block, VAR_DOMAIN, 0, NULL);
1441     if (sym != NULL)
1442       {
1443         if (syms)
1444           syms[csym] = sym;
1445         csym++;
1446         cdebug++;
1447       }
1448
1449     if (sym == NULL)
1450       msym = lookup_minimal_symbol (selector, 0, 0);
1451
1452     if (msym != NULL)
1453       {
1454         if (syms)
1455           syms[csym] = (struct symbol *)msym;
1456         csym++;
1457       }
1458   }
1459
1460   if (syms != NULL)
1461     find_methods (symtab, type, class, category, selector,
1462                   syms + csym, &ncsym, &ncdebug);
1463   else
1464     find_methods (symtab, type, class, category, selector,
1465                   NULL, &ncsym, &ncdebug);
1466
1467   /* If we didn't find any methods, just return.  */
1468   if (ncsym == 0 && ncdebug == 0)
1469     return method;
1470
1471   /* Take debug symbols from the second batch of symbols and swap them
1472    * with debug symbols from the first batch.  Repeat until either the
1473    * second section is out of debug symbols or the first section is
1474    * full of debug symbols.  Either way we have all debug symbols
1475    * packed to the beginning of the buffer.
1476    */
1477
1478   if (syms != NULL)
1479     {
1480       while ((cdebug < csym) && (ncdebug > 0))
1481         {
1482           struct symbol *s = NULL;
1483           /* First non-debugging symbol.  */
1484           unsigned int i = cdebug;
1485           /* Last of second batch of debug symbols.  */
1486           unsigned int j = csym + ncdebug - 1;
1487
1488           s = syms[j];
1489           syms[j] = syms[i];
1490           syms[i] = s;
1491
1492           /* We've moved a symbol from the second debug section to the
1493              first one.  */
1494           cdebug++;
1495           ncdebug--;
1496         }
1497     }
1498
1499   csym += ncsym;
1500   cdebug += ncdebug;
1501
1502   if (nsym != NULL)
1503     *nsym = csym;
1504   if (ndebug != NULL)
1505     *ndebug = cdebug;
1506
1507   if (syms == NULL)
1508     return method + (tmp - buf);
1509
1510   if (csym > 1)
1511     {
1512       /* Sort debuggable symbols.  */
1513       if (cdebug > 1)
1514         qsort (syms, cdebug, sizeof (struct minimal_symbol *),
1515                compare_classes);
1516
1517       /* Sort minimal_symbols.  */
1518       if ((csym - cdebug) > 1)
1519         qsort (&syms[cdebug], csym - cdebug,
1520                sizeof (struct minimal_symbol *), compare_classes);
1521     }
1522   /* Terminate the sym_arr list.  */
1523   syms[csym] = 0;
1524
1525   return method + (tmp - buf);
1526 }
1527
1528 static void
1529 print_object_command (char *args, int from_tty)
1530 {
1531   struct value *object, *function, *description;
1532   CORE_ADDR string_addr, object_addr;
1533   int i = 0;
1534   char c = -1;
1535
1536   if (!args || !*args)
1537     error (
1538 "The 'print-object' command requires an argument (an Objective-C object)");
1539
1540   {
1541     struct expression *expr = parse_expression (args);
1542     struct cleanup *old_chain =
1543       make_cleanup (free_current_contents, &expr);
1544     int pc = 0;
1545
1546     object = expr->language_defn->la_exp_desc->evaluate_exp
1547       (builtin_type_void_data_ptr, expr, &pc, EVAL_NORMAL);
1548     do_cleanups (old_chain);
1549   }
1550
1551   /* Validate the address for sanity.  */
1552   object_addr = value_as_long (object);
1553   read_memory (object_addr, &c, 1);
1554
1555   function = find_function_in_inferior ("_NSPrintForDebugger");
1556   if (function == NULL)
1557     error ("Unable to locate _NSPrintForDebugger in child process");
1558
1559   description = call_function_by_hand (function, 1, &object);
1560
1561   string_addr = value_as_long (description);
1562   if (string_addr == 0)
1563     error ("object returns null description");
1564
1565   read_memory (string_addr + i++, &c, 1);
1566   if (c != '\0')
1567     do
1568       { /* Read and print characters up to EOS.  */
1569         QUIT;
1570         printf_filtered ("%c", c);
1571         read_memory (string_addr + i++, &c, 1);
1572       } while (c != 0);
1573   else
1574     printf_filtered("<object returns empty description>");
1575   printf_filtered ("\n");
1576 }
1577
1578 /* The data structure 'methcalls' is used to detect method calls (thru
1579  * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1580  * and ultimately find the method being called.
1581  */
1582
1583 struct objc_methcall {
1584   char *name;
1585  /* Return instance method to be called.  */
1586   int (*stop_at) (CORE_ADDR, CORE_ADDR *);
1587   /* Start of pc range corresponding to method invocation.  */
1588   CORE_ADDR begin;
1589   /* End of pc range corresponding to method invocation.  */
1590   CORE_ADDR end;
1591 };
1592
1593 static int resolve_msgsend (CORE_ADDR pc, CORE_ADDR *new_pc);
1594 static int resolve_msgsend_stret (CORE_ADDR pc, CORE_ADDR *new_pc);
1595 static int resolve_msgsend_super (CORE_ADDR pc, CORE_ADDR *new_pc);
1596 static int resolve_msgsend_super_stret (CORE_ADDR pc, CORE_ADDR *new_pc);
1597
1598 static struct objc_methcall methcalls[] = {
1599   { "_objc_msgSend", resolve_msgsend, 0, 0},
1600   { "_objc_msgSend_stret", resolve_msgsend_stret, 0, 0},
1601   { "_objc_msgSendSuper", resolve_msgsend_super, 0, 0},
1602   { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret, 0, 0},
1603   { "_objc_getClass", NULL, 0, 0},
1604   { "_objc_getMetaClass", NULL, 0, 0}
1605 };
1606
1607 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1608
1609 /* The following function, "find_objc_msgsend", fills in the data
1610  * structure "objc_msgs" by finding the addresses of each of the
1611  * (currently four) functions that it holds (of which objc_msgSend is
1612  * the first).  This must be called each time symbols are loaded, in
1613  * case the functions have moved for some reason.
1614  */
1615
1616 static void
1617 find_objc_msgsend (void)
1618 {
1619   unsigned int i;
1620   for (i = 0; i < nmethcalls; i++) {
1621
1622     struct minimal_symbol *func;
1623
1624     /* Try both with and without underscore.  */
1625     func = lookup_minimal_symbol (methcalls[i].name, NULL, NULL);
1626     if ((func == NULL) && (methcalls[i].name[0] == '_')) {
1627       func = lookup_minimal_symbol (methcalls[i].name + 1, NULL, NULL);
1628     }
1629     if (func == NULL) {
1630       methcalls[i].begin = 0;
1631       methcalls[i].end = 0;
1632       continue;
1633     }
1634
1635     methcalls[i].begin = SYMBOL_VALUE_ADDRESS (func);
1636     do {
1637       methcalls[i].end = SYMBOL_VALUE_ADDRESS (++func);
1638     } while (methcalls[i].begin == methcalls[i].end);
1639   }
1640 }
1641
1642 /* find_objc_msgcall (replaces pc_off_limits)
1643  *
1644  * ALL that this function now does is to determine whether the input
1645  * address ("pc") is the address of one of the Objective-C message
1646  * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1647  * if so, it returns the address of the method that will be called.
1648  *
1649  * The old function "pc_off_limits" used to do a lot of other things
1650  * in addition, such as detecting shared library jump stubs and
1651  * returning the address of the shlib function that would be called.
1652  * That functionality has been moved into the SKIP_TRAMPOLINE_CODE and
1653  * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
1654  * dependent modules.
1655  */
1656
1657 struct objc_submethod_helper_data {
1658   int (*f) (CORE_ADDR, CORE_ADDR *);
1659   CORE_ADDR pc;
1660   CORE_ADDR *new_pc;
1661 };
1662
1663 static int
1664 find_objc_msgcall_submethod_helper (void * arg)
1665 {
1666   struct objc_submethod_helper_data *s =
1667     (struct objc_submethod_helper_data *) arg;
1668
1669   if (s->f (s->pc, s->new_pc) == 0)
1670     return 1;
1671   else
1672     return 0;
1673 }
1674
1675 static int
1676 find_objc_msgcall_submethod (int (*f) (CORE_ADDR, CORE_ADDR *),
1677                              CORE_ADDR pc,
1678                              CORE_ADDR *new_pc)
1679 {
1680   struct objc_submethod_helper_data s;
1681
1682   s.f = f;
1683   s.pc = pc;
1684   s.new_pc = new_pc;
1685
1686   if (catch_errors (find_objc_msgcall_submethod_helper,
1687                     (void *) &s,
1688                     "Unable to determine target of Objective-C method call (ignoring):\n",
1689                     RETURN_MASK_ALL) == 0)
1690     return 1;
1691   else
1692     return 0;
1693 }
1694
1695 int
1696 find_objc_msgcall (CORE_ADDR pc, CORE_ADDR *new_pc)
1697 {
1698   unsigned int i;
1699
1700   find_objc_msgsend ();
1701   if (new_pc != NULL)
1702     {
1703       *new_pc = 0;
1704     }
1705
1706   for (i = 0; i < nmethcalls; i++)
1707     if ((pc >= methcalls[i].begin) && (pc < methcalls[i].end))
1708       {
1709         if (methcalls[i].stop_at != NULL)
1710           return find_objc_msgcall_submethod (methcalls[i].stop_at,
1711                                               pc, new_pc);
1712         else
1713           return 0;
1714       }
1715
1716   return 0;
1717 }
1718
1719 extern initialize_file_ftype _initialize_objc_language; /* -Wmissing-prototypes */
1720
1721 void
1722 _initialize_objc_language (void)
1723 {
1724   add_language (&objc_language_defn);
1725   add_info ("selectors", selectors_info,    /* INFO SELECTORS command.  */
1726             "All Objective-C selectors, or those matching REGEXP.");
1727   add_info ("classes", classes_info,        /* INFO CLASSES   command.  */
1728             "All Objective-C classes, or those matching REGEXP.");
1729   add_com ("print-object", class_vars, print_object_command,
1730            "Ask an Objective-C object to print itself.");
1731   add_com_alias ("po", "print-object", class_vars, 1);
1732 }
1733
1734 static void
1735 read_objc_method (CORE_ADDR addr, struct objc_method *method)
1736 {
1737   method->name  = read_memory_unsigned_integer (addr + 0, 4);
1738   method->types = read_memory_unsigned_integer (addr + 4, 4);
1739   method->imp   = read_memory_unsigned_integer (addr + 8, 4);
1740 }
1741
1742 static
1743 unsigned long read_objc_methlist_nmethods (CORE_ADDR addr)
1744 {
1745   return read_memory_unsigned_integer (addr + 4, 4);
1746 }
1747
1748 static void
1749 read_objc_methlist_method (CORE_ADDR addr, unsigned long num,
1750                            struct objc_method *method)
1751 {
1752   gdb_assert (num < read_objc_methlist_nmethods (addr));
1753   read_objc_method (addr + 8 + (12 * num), method);
1754 }
1755
1756 static void
1757 read_objc_object (CORE_ADDR addr, struct objc_object *object)
1758 {
1759   object->isa = read_memory_unsigned_integer (addr, 4);
1760 }
1761
1762 static void
1763 read_objc_super (CORE_ADDR addr, struct objc_super *super)
1764 {
1765   super->receiver = read_memory_unsigned_integer (addr, 4);
1766   super->class = read_memory_unsigned_integer (addr + 4, 4);
1767 };
1768
1769 static void
1770 read_objc_class (CORE_ADDR addr, struct objc_class *class)
1771 {
1772   class->isa = read_memory_unsigned_integer (addr, 4);
1773   class->super_class = read_memory_unsigned_integer (addr + 4, 4);
1774   class->name = read_memory_unsigned_integer (addr + 8, 4);
1775   class->version = read_memory_unsigned_integer (addr + 12, 4);
1776   class->info = read_memory_unsigned_integer (addr + 16, 4);
1777   class->instance_size = read_memory_unsigned_integer (addr + 18, 4);
1778   class->ivars = read_memory_unsigned_integer (addr + 24, 4);
1779   class->methods = read_memory_unsigned_integer (addr + 28, 4);
1780   class->cache = read_memory_unsigned_integer (addr + 32, 4);
1781   class->protocols = read_memory_unsigned_integer (addr + 36, 4);
1782 }
1783
1784 static CORE_ADDR
1785 find_implementation_from_class (CORE_ADDR class, CORE_ADDR sel)
1786 {
1787   CORE_ADDR subclass = class;
1788
1789   while (subclass != 0)
1790     {
1791
1792       struct objc_class class_str;
1793       unsigned mlistnum = 0;
1794
1795       read_objc_class (subclass, &class_str);
1796
1797       for (;;)
1798         {
1799           CORE_ADDR mlist;
1800           unsigned long nmethods;
1801           unsigned long i;
1802
1803           mlist = read_memory_unsigned_integer (class_str.methods +
1804                                                 (4 * mlistnum), 4);
1805           if (mlist == 0)
1806             break;
1807
1808           nmethods = read_objc_methlist_nmethods (mlist);
1809
1810           for (i = 0; i < nmethods; i++)
1811             {
1812               struct objc_method meth_str;
1813               read_objc_methlist_method (mlist, i, &meth_str);
1814
1815 #if 0
1816               fprintf (stderr,
1817                        "checking method 0x%lx against selector 0x%lx\n",
1818                        meth_str.name, sel);
1819 #endif
1820
1821               if (meth_str.name == sel)
1822                 /* FIXME: hppa arch was doing a pointer dereference
1823                    here. There needs to be a better way to do that.  */
1824                 return meth_str.imp;
1825             }
1826           mlistnum++;
1827         }
1828       subclass = class_str.super_class;
1829     }
1830
1831   return 0;
1832 }
1833
1834 static CORE_ADDR
1835 find_implementation (CORE_ADDR object, CORE_ADDR sel)
1836 {
1837   struct objc_object ostr;
1838
1839   if (object == 0)
1840     return 0;
1841   read_objc_object (object, &ostr);
1842   if (ostr.isa == 0)
1843     return 0;
1844
1845   return find_implementation_from_class (ostr.isa, sel);
1846 }
1847
1848 #define OBJC_FETCH_POINTER_ARGUMENT(argi) \
1849   FETCH_POINTER_ARGUMENT (get_current_frame (), argi, builtin_type_void_func_ptr)
1850
1851 static int
1852 resolve_msgsend (CORE_ADDR pc, CORE_ADDR *new_pc)
1853 {
1854   CORE_ADDR object;
1855   CORE_ADDR sel;
1856   CORE_ADDR res;
1857
1858   object = OBJC_FETCH_POINTER_ARGUMENT (0);
1859   sel = OBJC_FETCH_POINTER_ARGUMENT (1);
1860
1861   res = find_implementation (object, sel);
1862   if (new_pc != 0)
1863     *new_pc = res;
1864   if (res == 0)
1865     return 1;
1866   return 0;
1867 }
1868
1869 static int
1870 resolve_msgsend_stret (CORE_ADDR pc, CORE_ADDR *new_pc)
1871 {
1872   CORE_ADDR object;
1873   CORE_ADDR sel;
1874   CORE_ADDR res;
1875
1876   object = OBJC_FETCH_POINTER_ARGUMENT (1);
1877   sel = OBJC_FETCH_POINTER_ARGUMENT (2);
1878
1879   res = find_implementation (object, sel);
1880   if (new_pc != 0)
1881     *new_pc = res;
1882   if (res == 0)
1883     return 1;
1884   return 0;
1885 }
1886
1887 static int
1888 resolve_msgsend_super (CORE_ADDR pc, CORE_ADDR *new_pc)
1889 {
1890   struct objc_super sstr;
1891
1892   CORE_ADDR super;
1893   CORE_ADDR sel;
1894   CORE_ADDR res;
1895
1896   super = OBJC_FETCH_POINTER_ARGUMENT (0);
1897   sel = OBJC_FETCH_POINTER_ARGUMENT (1);
1898
1899   read_objc_super (super, &sstr);
1900   if (sstr.class == 0)
1901     return 0;
1902
1903   res = find_implementation_from_class (sstr.class, sel);
1904   if (new_pc != 0)
1905     *new_pc = res;
1906   if (res == 0)
1907     return 1;
1908   return 0;
1909 }
1910
1911 static int
1912 resolve_msgsend_super_stret (CORE_ADDR pc, CORE_ADDR *new_pc)
1913 {
1914   struct objc_super sstr;
1915
1916   CORE_ADDR super;
1917   CORE_ADDR sel;
1918   CORE_ADDR res;
1919
1920   super = OBJC_FETCH_POINTER_ARGUMENT (1);
1921   sel = OBJC_FETCH_POINTER_ARGUMENT (2);
1922
1923   read_objc_super (super, &sstr);
1924   if (sstr.class == 0)
1925     return 0;
1926
1927   res = find_implementation_from_class (sstr.class, sel);
1928   if (new_pc != 0)
1929     *new_pc = res;
1930   if (res == 0)
1931     return 1;
1932   return 0;
1933 }