contrib/gdb-6.2.1/gdb/objc-lang.c

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