gdb/objc-lang.c

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