gdb/stabsread.c

   1 /* Support routines for decoding "stabs" debugging information format.
   2
   3    Copyright (C) 1986-2017 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 /* Support routines for reading and decoding debugging information in
  21    the "stabs" format.  This format is used by some systems that use
  22    COFF or ELF where the stabs data is placed in a special section (as
  23    well as with many old systems that used the a.out object file
  24    format).  Avoid placing any object file format specific code in
  25    this file.  */
  26
  27 #include "defs.h"
  28 #include "bfd.h"
  29 #include "gdb_obstack.h"
  30 #include "symtab.h"
  31 #include "gdbtypes.h"
  32 #include "expression.h"
  33 #include "symfile.h"
  34 #include "objfiles.h"
  35 #include "aout/stab_gnu.h"      /* We always use GNU stabs, not native.  */
  36 #include "libaout.h"
  37 #include "aout/aout64.h"
  38 #include "gdb-stabs.h"
  39 #include "buildsym.h"
  40 #include "complaints.h"
  41 #include "demangle.h"
  42 #include "gdb-demangle.h"
  43 #include "language.h"
  44 #include "doublest.h"
  45 #include "cp-abi.h"
  46 #include "cp-support.h"
  47 #include <ctype.h>
  48
  49 /* Ask stabsread.h to define the vars it normally declares `extern'.  */
  50 #define EXTERN
  51 /**/
  52 #include "stabsread.h"          /* Our own declarations */
  53 #undef  EXTERN
  54
  55 extern void _initialize_stabsread (void);
  56
  57 struct nextfield
  58 {
  59   struct nextfield *next;
  60
  61   /* This is the raw visibility from the stab.  It is not checked
  62      for being one of the visibilities we recognize, so code which
  63      examines this field better be able to deal.  */
  64   int visibility;
  65
  66   struct field field;
  67 };
  68
  69 struct next_fnfieldlist
  70 {
  71   struct next_fnfieldlist *next;
  72   struct fn_fieldlist fn_fieldlist;
  73 };
  74
  75 /* The routines that read and process a complete stabs for a C struct or
  76    C++ class pass lists of data member fields and lists of member function
  77    fields in an instance of a field_info structure, as defined below.
  78    This is part of some reorganization of low level C++ support and is
  79    expected to eventually go away...  (FIXME) */
  80
  81 struct field_info
  82   {
  83     struct nextfield *list;
  84     struct next_fnfieldlist *fnlist;
  85   };
  86
  87 static void
  88 read_one_struct_field (struct field_info *, const char **, const char *,
  89                        struct type *, struct objfile *);
  90
  91 static struct type *dbx_alloc_type (int[2], struct objfile *);
  92
  93 static long read_huge_number (const char **, int, int *, int);
  94
  95 static struct type *error_type (const char **, struct objfile *);
  96
  97 static void
  98 patch_block_stabs (struct pending *, struct pending_stabs *,
  99                    struct objfile *);
 100
 101 static void fix_common_block (struct symbol *, CORE_ADDR);
 102
 103 static int read_type_number (const char **, int *);
 104
 105 static struct type *read_type (const char **, struct objfile *);
 106
 107 static struct type *read_range_type (const char **, int[2],
 108                                      int, struct objfile *);
 109
 110 static struct type *read_sun_builtin_type (const char **,
 111                                            int[2], struct objfile *);
 112
 113 static struct type *read_sun_floating_type (const char **, int[2],
 114                                             struct objfile *);
 115
 116 static struct type *read_enum_type (const char **, struct type *, struct objfile *);
 117
 118 static struct type *rs6000_builtin_type (int, struct objfile *);
 119
 120 static int
 121 read_member_functions (struct field_info *, const char **, struct type *,
 122                        struct objfile *);
 123
 124 static int
 125 read_struct_fields (struct field_info *, const char **, struct type *,
 126                     struct objfile *);
 127
 128 static int
 129 read_baseclasses (struct field_info *, const char **, struct type *,
 130                   struct objfile *);
 131
 132 static int
 133 read_tilde_fields (struct field_info *, const char **, struct type *,
 134                    struct objfile *);
 135
 136 static int attach_fn_fields_to_type (struct field_info *, struct type *);
 137
 138 static int attach_fields_to_type (struct field_info *, struct type *,
 139                                   struct objfile *);
 140
 141 static struct type *read_struct_type (const char **, struct type *,
 142                                       enum type_code,
 143                                       struct objfile *);
 144
 145 static struct type *read_array_type (const char **, struct type *,
 146                                      struct objfile *);
 147
 148 static struct field *read_args (const char **, int, struct objfile *,
 149                                 int *, int *);
 150
 151 static void add_undefined_type (struct type *, int[2]);
 152
 153 static int
 154 read_cpp_abbrev (struct field_info *, const char **, struct type *,
 155                  struct objfile *);
 156
 157 static const char *find_name_end (const char *name);
 158
 159 static int process_reference (const char **string);
 160
 161 void stabsread_clear_cache (void);
 162
 163 static const char vptr_name[] = "_vptr$";
 164 static const char vb_name[] = "_vb$";
 165
 166 static void
 167 invalid_cpp_abbrev_complaint (const char *arg1)
 168 {
 169   complaint (&symfile_complaints, _("invalid C++ abbreviation `%s'"), arg1);
 170 }
 171
 172 static void
 173 reg_value_complaint (int regnum, int num_regs, const char *sym)
 174 {
 175   complaint (&symfile_complaints,
 176              _("bad register number %d (max %d) in symbol %s"),
 177              regnum, num_regs - 1, sym);
 178 }
 179
 180 static void
 181 stabs_general_complaint (const char *arg1)
 182 {
 183   complaint (&symfile_complaints, "%s", arg1);
 184 }
 185
 186 /* Make a list of forward references which haven't been defined.  */
 187
 188 static struct type **undef_types;
 189 static int undef_types_allocated;
 190 static int undef_types_length;
 191 static struct symbol *current_symbol = NULL;
 192
 193 /* Make a list of nameless types that are undefined.
 194    This happens when another type is referenced by its number
 195    before this type is actually defined.  For instance "t(0,1)=k(0,2)"
 196    and type (0,2) is defined only later.  */
 197
 198 struct nat
 199 {
 200   int typenums[2];
 201   struct type *type;
 202 };
 203 static struct nat *noname_undefs;
 204 static int noname_undefs_allocated;
 205 static int noname_undefs_length;
 206
 207 /* Check for and handle cretinous stabs symbol name continuation!  */
 208 #define STABS_CONTINUE(pp,objfile)                              \
 209   do {                                                  \
 210     if (**(pp) == '\\' || (**(pp) == '?' && (*(pp))[1] == '\0')) \
 211       *(pp) = next_symbol_text (objfile);       \
 212   } while (0)
 213
 214 /* Vector of types defined so far, indexed by their type numbers.
 215    (In newer sun systems, dbx uses a pair of numbers in parens,
 216    as in "(SUBFILENUM,NUMWITHINSUBFILE)".
 217    Then these numbers must be translated through the type_translations
 218    hash table to get the index into the type vector.)  */
 219
 220 static struct type **type_vector;
 221
 222 /* Number of elements allocated for type_vector currently.  */
 223
 224 static int type_vector_length;
 225
 226 /* Initial size of type vector.  Is realloc'd larger if needed, and
 227    realloc'd down to the size actually used, when completed.  */
 228
 229 #define INITIAL_TYPE_VECTOR_LENGTH 160
 230 \f
 231
 232 /* Look up a dbx type-number pair.  Return the address of the slot
 233    where the type for that number-pair is stored.
 234    The number-pair is in TYPENUMS.
 235
 236    This can be used for finding the type associated with that pair
 237    or for associating a new type with the pair.  */
 238
 239 static struct type **
 240 dbx_lookup_type (int typenums[2], struct objfile *objfile)
 241 {
 242   int filenum = typenums[0];
 243   int index = typenums[1];
 244   unsigned old_len;
 245   int real_filenum;
 246   struct header_file *f;
 247   int f_orig_length;
 248
 249   if (filenum == -1)            /* -1,-1 is for temporary types.  */
 250     return 0;
 251
 252   if (filenum < 0 || filenum >= n_this_object_header_files)
 253     {
 254       complaint (&symfile_complaints,
 255                  _("Invalid symbol data: type number "
 256                    "(%d,%d) out of range at symtab pos %d."),
 257                  filenum, index, symnum);
 258       goto error_return;
 259     }
 260
 261   if (filenum == 0)
 262     {
 263       if (index < 0)
 264         {
 265           /* Caller wants address of address of type.  We think
 266              that negative (rs6k builtin) types will never appear as
 267              "lvalues", (nor should they), so we stuff the real type
 268              pointer into a temp, and return its address.  If referenced,
 269              this will do the right thing.  */
 270           static struct type *temp_type;
 271
 272           temp_type = rs6000_builtin_type (index, objfile);
 273           return &temp_type;
 274         }
 275
 276       /* Type is defined outside of header files.
 277          Find it in this object file's type vector.  */
 278       if (index >= type_vector_length)
 279         {
 280           old_len = type_vector_length;
 281           if (old_len == 0)
 282             {
 283               type_vector_length = INITIAL_TYPE_VECTOR_LENGTH;
 284               type_vector = XNEWVEC (struct type *, type_vector_length);
 285             }
 286           while (index >= type_vector_length)
 287             {
 288               type_vector_length *= 2;
 289             }
 290           type_vector = (struct type **)
 291             xrealloc ((char *) type_vector,
 292                       (type_vector_length * sizeof (struct type *)));
 293           memset (&type_vector[old_len], 0,
 294                   (type_vector_length - old_len) * sizeof (struct type *));
 295         }
 296       return (&type_vector[index]);
 297     }
 298   else
 299     {
 300       real_filenum = this_object_header_files[filenum];
 301
 302       if (real_filenum >= N_HEADER_FILES (objfile))
 303         {
 304           static struct type *temp_type;
 305
 306           warning (_("GDB internal error: bad real_filenum"));
 307
 308         error_return:
 309           temp_type = objfile_type (objfile)->builtin_error;
 310           return &temp_type;
 311         }
 312
 313       f = HEADER_FILES (objfile) + real_filenum;
 314
 315       f_orig_length = f->length;
 316       if (index >= f_orig_length)
 317         {
 318           while (index >= f->length)
 319             {
 320               f->length *= 2;
 321             }
 322           f->vector = (struct type **)
 323             xrealloc ((char *) f->vector, f->length * sizeof (struct type *));
 324           memset (&f->vector[f_orig_length], 0,
 325                   (f->length - f_orig_length) * sizeof (struct type *));
 326         }
 327       return (&f->vector[index]);
 328     }
 329 }
 330
 331 /* Make sure there is a type allocated for type numbers TYPENUMS
 332    and return the type object.
 333    This can create an empty (zeroed) type object.
 334    TYPENUMS may be (-1, -1) to return a new type object that is not
 335    put into the type vector, and so may not be referred to by number.  */
 336
 337 static struct type *
 338 dbx_alloc_type (int typenums[2], struct objfile *objfile)
 339 {
 340   struct type **type_addr;
 341
 342   if (typenums[0] == -1)
 343     {
 344       return (alloc_type (objfile));
 345     }
 346
 347   type_addr = dbx_lookup_type (typenums, objfile);
 348
 349   /* If we are referring to a type not known at all yet,
 350      allocate an empty type for it.
 351      We will fill it in later if we find out how.  */
 352   if (*type_addr == 0)
 353     {
 354       *type_addr = alloc_type (objfile);
 355     }
 356
 357   return (*type_addr);
 358 }
 359
 360 /* Allocate a floating-point type of size BITS.  */
 361
 362 static struct type *
 363 dbx_init_float_type (struct objfile *objfile, int bits)
 364 {
 365   struct gdbarch *gdbarch = get_objfile_arch (objfile);
 366   const struct floatformat **format;
 367   struct type *type;
 368
 369   format = gdbarch_floatformat_for_type (gdbarch, NULL, bits);
 370   if (format)
 371     type = init_float_type (objfile, bits, NULL, format);
 372   else
 373     type = init_type (objfile, TYPE_CODE_ERROR, bits / TARGET_CHAR_BIT, NULL);
 374
 375   return type;
 376 }
 377
 378 /* for all the stabs in a given stab vector, build appropriate types
 379    and fix their symbols in given symbol vector.  */
 380
 381 static void
 382 patch_block_stabs (struct pending *symbols, struct pending_stabs *stabs,
 383                    struct objfile *objfile)
 384 {
 385   int ii;
 386   char *name;
 387   const char *pp;
 388   struct symbol *sym;
 389
 390   if (stabs)
 391     {
 392       /* for all the stab entries, find their corresponding symbols and
 393          patch their types!  */
 394
 395       for (ii = 0; ii < stabs->count; ++ii)
 396         {
 397           name = stabs->stab[ii];
 398           pp = (char *) strchr (name, ':');
 399           gdb_assert (pp);      /* Must find a ':' or game's over.  */
 400           while (pp[1] == ':')
 401             {
 402               pp += 2;
 403               pp = (char *) strchr (pp, ':');
 404             }
 405           sym = find_symbol_in_list (symbols, name, pp - name);
 406           if (!sym)
 407             {
 408               /* FIXME-maybe: it would be nice if we noticed whether
 409                  the variable was defined *anywhere*, not just whether
 410                  it is defined in this compilation unit.  But neither
 411                  xlc or GCC seem to need such a definition, and until
 412                  we do psymtabs (so that the minimal symbols from all
 413                  compilation units are available now), I'm not sure
 414                  how to get the information.  */
 415
 416               /* On xcoff, if a global is defined and never referenced,
 417                  ld will remove it from the executable.  There is then
 418                  a N_GSYM stab for it, but no regular (C_EXT) symbol.  */
 419               sym = allocate_symbol (objfile);
 420               SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
 421               SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
 422               SYMBOL_SET_LINKAGE_NAME
 423                 (sym, (char *) obstack_copy0 (&objfile->objfile_obstack,
 424                                               name, pp - name));
 425               pp += 2;
 426               if (*(pp - 1) == 'F' || *(pp - 1) == 'f')
 427                 {
 428                   /* I don't think the linker does this with functions,
 429                      so as far as I know this is never executed.
 430                      But it doesn't hurt to check.  */
 431                   SYMBOL_TYPE (sym) =
 432                     lookup_function_type (read_type (&pp, objfile));
 433                 }
 434               else
 435                 {
 436                   SYMBOL_TYPE (sym) = read_type (&pp, objfile);
 437                 }
 438               add_symbol_to_list (sym, &global_symbols);
 439             }
 440           else
 441             {
 442               pp += 2;
 443               if (*(pp - 1) == 'F' || *(pp - 1) == 'f')
 444                 {
 445                   SYMBOL_TYPE (sym) =
 446                     lookup_function_type (read_type (&pp, objfile));
 447                 }
 448               else
 449                 {
 450                   SYMBOL_TYPE (sym) = read_type (&pp, objfile);
 451                 }
 452             }
 453         }
 454     }
 455 }
 456 \f
 457
 458 /* Read a number by which a type is referred to in dbx data,
 459    or perhaps read a pair (FILENUM, TYPENUM) in parentheses.
 460    Just a single number N is equivalent to (0,N).
 461    Return the two numbers by storing them in the vector TYPENUMS.
 462    TYPENUMS will then be used as an argument to dbx_lookup_type.
 463
 464    Returns 0 for success, -1 for error.  */
 465
 466 static int
 467 read_type_number (const char **pp, int *typenums)
 468 {
 469   int nbits;
 470
 471   if (**pp == '(')
 472     {
 473       (*pp)++;
 474       typenums[0] = read_huge_number (pp, ',', &nbits, 0);
 475       if (nbits != 0)
 476         return -1;
 477       typenums[1] = read_huge_number (pp, ')', &nbits, 0);
 478       if (nbits != 0)
 479         return -1;
 480     }
 481   else
 482     {
 483       typenums[0] = 0;
 484       typenums[1] = read_huge_number (pp, 0, &nbits, 0);
 485       if (nbits != 0)
 486         return -1;
 487     }
 488   return 0;
 489 }
 490 \f
 491
 492 #define VISIBILITY_PRIVATE      '0'     /* Stabs character for private field */
 493 #define VISIBILITY_PROTECTED    '1'     /* Stabs character for protected fld */
 494 #define VISIBILITY_PUBLIC       '2'     /* Stabs character for public field */
 495 #define VISIBILITY_IGNORE       '9'     /* Optimized out or zero length */
 496
 497 /* Structure for storing pointers to reference definitions for fast lookup
 498    during "process_later".  */
 499
 500 struct ref_map
 501 {
 502   const char *stabs;
 503   CORE_ADDR value;
 504   struct symbol *sym;
 505 };
 506
 507 #define MAX_CHUNK_REFS 100
 508 #define REF_CHUNK_SIZE (MAX_CHUNK_REFS * sizeof (struct ref_map))
 509 #define REF_MAP_SIZE(ref_chunk) ((ref_chunk) * REF_CHUNK_SIZE)
 510
 511 static struct ref_map *ref_map;
 512
 513 /* Ptr to free cell in chunk's linked list.  */
 514 static int ref_count = 0;
 515
 516 /* Number of chunks malloced.  */
 517 static int ref_chunk = 0;
 518
 519 /* This file maintains a cache of stabs aliases found in the symbol
 520    table.  If the symbol table changes, this cache must be cleared
 521    or we are left holding onto data in invalid obstacks.  */
 522 void
 523 stabsread_clear_cache (void)
 524 {
 525   ref_count = 0;
 526   ref_chunk = 0;
 527 }
 528
 529 /* Create array of pointers mapping refids to symbols and stab strings.
 530    Add pointers to reference definition symbols and/or their values as we
 531    find them, using their reference numbers as our index.
 532    These will be used later when we resolve references.  */
 533 void
 534 ref_add (int refnum, struct symbol *sym, const char *stabs, CORE_ADDR value)
 535 {
 536   if (ref_count == 0)
 537     ref_chunk = 0;
 538   if (refnum >= ref_count)
 539     ref_count = refnum + 1;
 540   if (ref_count > ref_chunk * MAX_CHUNK_REFS)
 541     {
 542       int new_slots = ref_count - ref_chunk * MAX_CHUNK_REFS;
 543       int new_chunks = new_slots / MAX_CHUNK_REFS + 1;
 544
 545       ref_map = (struct ref_map *)
 546         xrealloc (ref_map, REF_MAP_SIZE (ref_chunk + new_chunks));
 547       memset (ref_map + ref_chunk * MAX_CHUNK_REFS, 0,
 548               new_chunks * REF_CHUNK_SIZE);
 549       ref_chunk += new_chunks;
 550     }
 551   ref_map[refnum].stabs = stabs;
 552   ref_map[refnum].sym = sym;
 553   ref_map[refnum].value = value;
 554 }
 555
 556 /* Return defined sym for the reference REFNUM.  */
 557 struct symbol *
 558 ref_search (int refnum)
 559 {
 560   if (refnum < 0 || refnum > ref_count)
 561     return 0;
 562   return ref_map[refnum].sym;
 563 }
 564
 565 /* Parse a reference id in STRING and return the resulting
 566    reference number.  Move STRING beyond the reference id.  */
 567
 568 static int
 569 process_reference (const char **string)
 570 {
 571   const char *p;
 572   int refnum = 0;
 573
 574   if (**string != '#')
 575     return 0;
 576
 577   /* Advance beyond the initial '#'.  */
 578   p = *string + 1;
 579
 580   /* Read number as reference id.  */
 581   while (*p && isdigit (*p))
 582     {
 583       refnum = refnum * 10 + *p - '0';
 584       p++;
 585     }
 586   *string = p;
 587   return refnum;
 588 }
 589
 590 /* If STRING defines a reference, store away a pointer to the reference
 591    definition for later use.  Return the reference number.  */
 592
 593 int
 594 symbol_reference_defined (const char **string)
 595 {
 596   const char *p = *string;
 597   int refnum = 0;
 598
 599   refnum = process_reference (&p);
 600
 601   /* Defining symbols end in '='.  */
 602   if (*p == '=')
 603     {
 604       /* Symbol is being defined here.  */
 605       *string = p + 1;
 606       return refnum;
 607     }
 608   else
 609     {
 610       /* Must be a reference.  Either the symbol has already been defined,
 611          or this is a forward reference to it.  */
 612       *string = p;
 613       return -1;
 614     }
 615 }
 616
 617 static int
 618 stab_reg_to_regnum (struct symbol *sym, struct gdbarch *gdbarch)
 619 {
 620   int regno = gdbarch_stab_reg_to_regnum (gdbarch, SYMBOL_VALUE (sym));
 621
 622   if (regno < 0
 623       || regno >= (gdbarch_num_regs (gdbarch)
 624                    + gdbarch_num_pseudo_regs (gdbarch)))
 625     {
 626       reg_value_complaint (regno,
 627                            gdbarch_num_regs (gdbarch)
 628                              + gdbarch_num_pseudo_regs (gdbarch),
 629                            SYMBOL_PRINT_NAME (sym));
 630
 631       regno = gdbarch_sp_regnum (gdbarch); /* Known safe, though useless.  */
 632     }
 633
 634   return regno;
 635 }
 636
 637 static const struct symbol_register_ops stab_register_funcs = {
 638   stab_reg_to_regnum
 639 };
 640
 641 /* The "aclass" indices for computed symbols.  */
 642
 643 static int stab_register_index;
 644 static int stab_regparm_index;
 645
 646 struct symbol *
 647 define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
 648                struct objfile *objfile)
 649 {
 650   struct gdbarch *gdbarch = get_objfile_arch (objfile);
 651   struct symbol *sym;
 652   const char *p = find_name_end (string);
 653   int deftype;
 654   int synonym = 0;
 655   int i;
 656
 657   /* We would like to eliminate nameless symbols, but keep their types.
 658      E.g. stab entry ":t10=*2" should produce a type 10, which is a pointer
 659      to type 2, but, should not create a symbol to address that type.  Since
 660      the symbol will be nameless, there is no way any user can refer to it.  */
 661
 662   int nameless;
 663
 664   /* Ignore syms with empty names.  */
 665   if (string[0] == 0)
 666     return 0;
 667
 668   /* Ignore old-style symbols from cc -go.  */
 669   if (p == 0)
 670     return 0;
 671
 672   while (p[1] == ':')
 673     {
 674       p += 2;
 675       p = strchr (p, ':');
 676       if (p == NULL)
 677         {
 678           complaint (&symfile_complaints,
 679                      _("Bad stabs string '%s'"), string);
 680           return NULL;
 681         }
 682     }
 683
 684   /* If a nameless stab entry, all we need is the type, not the symbol.
 685      e.g. ":t10=*2" or a nameless enum like " :T16=ered:0,green:1,blue:2,;" */
 686   nameless = (p == string || ((string[0] == ' ') && (string[1] == ':')));
 687
 688   current_symbol = sym = allocate_symbol (objfile);
 689
 690   if (processing_gcc_compilation)
 691     {
 692       /* GCC 2.x puts the line number in desc.  SunOS apparently puts in the
 693          number of bytes occupied by a type or object, which we ignore.  */
 694       SYMBOL_LINE (sym) = desc;
 695     }
 696   else
 697     {
 698       SYMBOL_LINE (sym) = 0;    /* unknown */
 699     }
 700
 701   SYMBOL_SET_LANGUAGE (sym, current_subfile->language,
 702                        &objfile->objfile_obstack);
 703
 704   if (is_cplus_marker (string[0]))
 705     {
 706       /* Special GNU C++ names.  */
 707       switch (string[1])
 708         {
 709         case 't':
 710           SYMBOL_SET_LINKAGE_NAME (sym, "this");
 711           break;
 712
 713         case 'v':               /* $vtbl_ptr_type */
 714           goto normal;
 715
 716         case 'e':
 717           SYMBOL_SET_LINKAGE_NAME (sym, "eh_throw");
 718           break;
 719
 720         case '_':
 721           /* This was an anonymous type that was never fixed up.  */
 722           goto normal;
 723
 724         case 'X':
 725           /* SunPRO (3.0 at least) static variable encoding.  */
 726           if (gdbarch_static_transform_name_p (gdbarch))
 727             goto normal;
 728           /* ... fall through ...  */
 729
 730         default:
 731           complaint (&symfile_complaints, _("Unknown C++ symbol name `%s'"),
 732                      string);
 733           goto normal;          /* Do *something* with it.  */
 734         }
 735     }
 736   else
 737     {
 738     normal:
 739       std::string new_name;
 740
 741       if (SYMBOL_LANGUAGE (sym) == language_cplus)
 742         {
 743           char *name = (char *) alloca (p - string + 1);
 744
 745           memcpy (name, string, p - string);
 746           name[p - string] = '\0';
 747           new_name = cp_canonicalize_string (name);
 748         }
 749       if (!new_name.empty ())
 750         {
 751           SYMBOL_SET_NAMES (sym,
 752                             new_name.c_str (), new_name.length (),
 753                             1, objfile);
 754         }
 755       else
 756         SYMBOL_SET_NAMES (sym, string, p - string, 1, objfile);
 757
 758       if (SYMBOL_LANGUAGE (sym) == language_cplus)
 759         cp_scan_for_anonymous_namespaces (sym, objfile);
 760
 761     }
 762   p++;
 763
 764   /* Determine the type of name being defined.  */
 765 #if 0
 766   /* Getting GDB to correctly skip the symbol on an undefined symbol
 767      descriptor and not ever dump core is a very dodgy proposition if
 768      we do things this way.  I say the acorn RISC machine can just
 769      fix their compiler.  */
 770   /* The Acorn RISC machine's compiler can put out locals that don't
 771      start with "234=" or "(3,4)=", so assume anything other than the
 772      deftypes we know how to handle is a local.  */
 773   if (!strchr ("cfFGpPrStTvVXCR", *p))
 774 #else
 775   if (isdigit (*p) || *p == '(' || *p == '-')
 776 #endif
 777     deftype = 'l';
 778   else
 779     deftype = *p++;
 780
 781   switch (deftype)
 782     {
 783     case 'c':
 784       /* c is a special case, not followed by a type-number.
 785          SYMBOL:c=iVALUE for an integer constant symbol.
 786          SYMBOL:c=rVALUE for a floating constant symbol.
 787          SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
 788          e.g. "b:c=e6,0" for "const b = blob1"
 789          (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;").  */
 790       if (*p != '=')
 791         {
 792           SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
 793           SYMBOL_TYPE (sym) = error_type (&p, objfile);
 794           SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
 795           add_symbol_to_list (sym, &file_symbols);
 796           return sym;
 797         }
 798       ++p;
 799       switch (*p++)
 800         {
 801         case 'r':
 802           {
 803             double d = atof (p);
 804             gdb_byte *dbl_valu;
 805             struct type *dbl_type;
 806
 807             /* FIXME-if-picky-about-floating-accuracy: Should be using
 808                target arithmetic to get the value.  real.c in GCC
 809                probably has the necessary code.  */
 810
 811             dbl_type = objfile_type (objfile)->builtin_double;
 812             dbl_valu
 813               = (gdb_byte *) obstack_alloc (&objfile->objfile_obstack,
 814                                             TYPE_LENGTH (dbl_type));
 815             store_typed_floating (dbl_valu, dbl_type, d);
 816
 817             SYMBOL_TYPE (sym) = dbl_type;
 818             SYMBOL_VALUE_BYTES (sym) = dbl_valu;
 819             SYMBOL_ACLASS_INDEX (sym) = LOC_CONST_BYTES;
 820           }
 821           break;
 822         case 'i':
 823           {
 824             /* Defining integer constants this way is kind of silly,
 825                since 'e' constants allows the compiler to give not
 826                only the value, but the type as well.  C has at least
 827                int, long, unsigned int, and long long as constant
 828                types; other languages probably should have at least
 829                unsigned as well as signed constants.  */
 830
 831             SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_long;
 832             SYMBOL_VALUE (sym) = atoi (p);
 833             SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
 834           }
 835           break;
 836
 837         case 'c':
 838           {
 839             SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_char;
 840             SYMBOL_VALUE (sym) = atoi (p);
 841             SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
 842           }
 843           break;
 844
 845         case 's':
 846           {
 847             struct type *range_type;
 848             int ind = 0;
 849             char quote = *p++;
 850             gdb_byte *string_local = (gdb_byte *) alloca (strlen (p));
 851             gdb_byte *string_value;
 852
 853             if (quote != '\'' && quote != '"')
 854               {
 855                 SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
 856                 SYMBOL_TYPE (sym) = error_type (&p, objfile);
 857                 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
 858                 add_symbol_to_list (sym, &file_symbols);
 859                 return sym;
 860               }
 861
 862             /* Find matching quote, rejecting escaped quotes.  */
 863             while (*p && *p != quote)
 864               {
 865                 if (*p == '\\' && p[1] == quote)
 866                   {
 867                     string_local[ind] = (gdb_byte) quote;
 868                     ind++;
 869                     p += 2;
 870                   }
 871                 else if (*p)
 872                   {
 873                     string_local[ind] = (gdb_byte) (*p);
 874                     ind++;
 875                     p++;
 876                   }
 877               }
 878             if (*p != quote)
 879               {
 880                 SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
 881                 SYMBOL_TYPE (sym) = error_type (&p, objfile);
 882                 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
 883                 add_symbol_to_list (sym, &file_symbols);
 884                 return sym;
 885               }
 886
 887             /* NULL terminate the string.  */
 888             string_local[ind] = 0;
 889             range_type
 890               = create_static_range_type (NULL,
 891                                           objfile_type (objfile)->builtin_int,
 892                                           0, ind);
 893             SYMBOL_TYPE (sym) = create_array_type (NULL,
 894                                   objfile_type (objfile)->builtin_char,
 895                                   range_type);
 896             string_value
 897               = (gdb_byte *) obstack_alloc (&objfile->objfile_obstack, ind + 1);
 898             memcpy (string_value, string_local, ind + 1);
 899             p++;
 900
 901             SYMBOL_VALUE_BYTES (sym) = string_value;
 902             SYMBOL_ACLASS_INDEX (sym) = LOC_CONST_BYTES;
 903           }
 904           break;
 905
 906         case 'e':
 907           /* SYMBOL:c=eTYPE,INTVALUE for a constant symbol whose value
 908              can be represented as integral.
 909              e.g. "b:c=e6,0" for "const b = blob1"
 910              (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;").  */
 911           {
 912             SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
 913             SYMBOL_TYPE (sym) = read_type (&p, objfile);
 914
 915             if (*p != ',')
 916               {
 917                 SYMBOL_TYPE (sym) = error_type (&p, objfile);
 918                 break;
 919               }
 920             ++p;
 921
 922             /* If the value is too big to fit in an int (perhaps because
 923                it is unsigned), or something like that, we silently get
 924                a bogus value.  The type and everything else about it is
 925                correct.  Ideally, we should be using whatever we have
 926                available for parsing unsigned and long long values,
 927                however.  */
 928             SYMBOL_VALUE (sym) = atoi (p);
 929           }
 930           break;
 931         default:
 932           {
 933             SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
 934             SYMBOL_TYPE (sym) = error_type (&p, objfile);
 935           }
 936         }
 937       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
 938       add_symbol_to_list (sym, &file_symbols);
 939       return sym;
 940
 941     case 'C':
 942       /* The name of a caught exception.  */
 943       SYMBOL_TYPE (sym) = read_type (&p, objfile);
 944       SYMBOL_ACLASS_INDEX (sym) = LOC_LABEL;
 945       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
 946       SYMBOL_VALUE_ADDRESS (sym) = valu;
 947       add_symbol_to_list (sym, &local_symbols);
 948       break;
 949
 950     case 'f':
 951       /* A static function definition.  */
 952       SYMBOL_TYPE (sym) = read_type (&p, objfile);
 953       SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
 954       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
 955       add_symbol_to_list (sym, &file_symbols);
 956       /* fall into process_function_types.  */
 957
 958     process_function_types:
 959       /* Function result types are described as the result type in stabs.
 960          We need to convert this to the function-returning-type-X type
 961          in GDB.  E.g. "int" is converted to "function returning int".  */
 962       if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_FUNC)
 963         SYMBOL_TYPE (sym) = lookup_function_type (SYMBOL_TYPE (sym));
 964
 965       /* All functions in C++ have prototypes.  Stabs does not offer an
 966          explicit way to identify prototyped or unprototyped functions,
 967          but both GCC and Sun CC emit stabs for the "call-as" type rather
 968          than the "declared-as" type for unprototyped functions, so
 969          we treat all functions as if they were prototyped.  This is used
 970          primarily for promotion when calling the function from GDB.  */
 971       TYPE_PROTOTYPED (SYMBOL_TYPE (sym)) = 1;
 972
 973       /* fall into process_prototype_types.  */
 974
 975     process_prototype_types:
 976       /* Sun acc puts declared types of arguments here.  */
 977       if (*p == ';')
 978         {
 979           struct type *ftype = SYMBOL_TYPE (sym);
 980           int nsemi = 0;
 981           int nparams = 0;
 982           const char *p1 = p;
 983
 984           /* Obtain a worst case guess for the number of arguments
 985              by counting the semicolons.  */
 986           while (*p1)
 987             {
 988               if (*p1++ == ';')
 989                 nsemi++;
 990             }
 991
 992           /* Allocate parameter information fields and fill them in.  */
 993           TYPE_FIELDS (ftype) = (struct field *)
 994             TYPE_ALLOC (ftype, nsemi * sizeof (struct field));
 995           while (*p++ == ';')
 996             {
 997               struct type *ptype;
 998
 999               /* A type number of zero indicates the start of varargs.
1000                  FIXME: GDB currently ignores vararg functions.  */
1001               if (p[0] == '0' && p[1] == '\0')
1002                 break;
1003               ptype = read_type (&p, objfile);
1004
1005               /* The Sun compilers mark integer arguments, which should
1006                  be promoted to the width of the calling conventions, with
1007                  a type which references itself.  This type is turned into
1008                  a TYPE_CODE_VOID type by read_type, and we have to turn
1009                  it back into builtin_int here.
1010                  FIXME: Do we need a new builtin_promoted_int_arg ?  */
1011               if (TYPE_CODE (ptype) == TYPE_CODE_VOID)
1012                 ptype = objfile_type (objfile)->builtin_int;
1013               TYPE_FIELD_TYPE (ftype, nparams) = ptype;
1014               TYPE_FIELD_ARTIFICIAL (ftype, nparams++) = 0;
1015             }
1016           TYPE_NFIELDS (ftype) = nparams;
1017           TYPE_PROTOTYPED (ftype) = 1;
1018         }
1019       break;
1020
1021     case 'F':
1022       /* A global function definition.  */
1023       SYMBOL_TYPE (sym) = read_type (&p, objfile);
1024       SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
1025       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1026       add_symbol_to_list (sym, &global_symbols);
1027       goto process_function_types;
1028
1029     case 'G':
1030       /* For a class G (global) symbol, it appears that the
1031          value is not correct.  It is necessary to search for the
1032          corresponding linker definition to find the value.
1033          These definitions appear at the end of the namelist.  */
1034       SYMBOL_TYPE (sym) = read_type (&p, objfile);
1035       SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
1036       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1037       /* Don't add symbol references to global_sym_chain.
1038          Symbol references don't have valid names and wont't match up with
1039          minimal symbols when the global_sym_chain is relocated.
1040          We'll fixup symbol references when we fixup the defining symbol.  */
1041       if (SYMBOL_LINKAGE_NAME (sym) && SYMBOL_LINKAGE_NAME (sym)[0] != '#')
1042         {
1043           i = hashname (SYMBOL_LINKAGE_NAME (sym));
1044           SYMBOL_VALUE_CHAIN (sym) = global_sym_chain[i];
1045           global_sym_chain[i] = sym;
1046         }
1047       add_symbol_to_list (sym, &global_symbols);
1048       break;
1049
1050       /* This case is faked by a conditional above,
1051          when there is no code letter in the dbx data.
1052          Dbx data never actually contains 'l'.  */
1053     case 's':
1054     case 'l':
1055       SYMBOL_TYPE (sym) = read_type (&p, objfile);
1056       SYMBOL_ACLASS_INDEX (sym) = LOC_LOCAL;
1057       SYMBOL_VALUE (sym) = valu;
1058       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1059       add_symbol_to_list (sym, &local_symbols);
1060       break;
1061
1062     case 'p':
1063       if (*p == 'F')
1064         /* pF is a two-letter code that means a function parameter in Fortran.
1065            The type-number specifies the type of the return value.
1066            Translate it into a pointer-to-function type.  */
1067         {
1068           p++;
1069           SYMBOL_TYPE (sym)
1070             = lookup_pointer_type
1071             (lookup_function_type (read_type (&p, objfile)));
1072         }
1073       else
1074         SYMBOL_TYPE (sym) = read_type (&p, objfile);
1075
1076       SYMBOL_ACLASS_INDEX (sym) = LOC_ARG;
1077       SYMBOL_VALUE (sym) = valu;
1078       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1079       SYMBOL_IS_ARGUMENT (sym) = 1;
1080       add_symbol_to_list (sym, &local_symbols);
1081
1082       if (gdbarch_byte_order (gdbarch) != BFD_ENDIAN_BIG)
1083         {
1084           /* On little-endian machines, this crud is never necessary,
1085              and, if the extra bytes contain garbage, is harmful.  */
1086           break;
1087         }
1088
1089       /* If it's gcc-compiled, if it says `short', believe it.  */
1090       if (processing_gcc_compilation
1091           || gdbarch_believe_pcc_promotion (gdbarch))
1092         break;
1093
1094       if (!gdbarch_believe_pcc_promotion (gdbarch))
1095         {
1096           /* If PCC says a parameter is a short or a char, it is
1097              really an int.  */
1098           if (TYPE_LENGTH (SYMBOL_TYPE (sym))
1099               < gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT
1100               && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT)
1101             {
1102               SYMBOL_TYPE (sym) =
1103                 TYPE_UNSIGNED (SYMBOL_TYPE (sym))
1104                 ? objfile_type (objfile)->builtin_unsigned_int
1105                 : objfile_type (objfile)->builtin_int;
1106             }
1107           break;
1108         }
1109
1110     case 'P':
1111       /* acc seems to use P to declare the prototypes of functions that
1112          are referenced by this file.  gdb is not prepared to deal
1113          with this extra information.  FIXME, it ought to.  */
1114       if (type == N_FUN)
1115         {
1116           SYMBOL_TYPE (sym) = read_type (&p, objfile);
1117           goto process_prototype_types;
1118         }
1119       /*FALLTHROUGH */
1120
1121     case 'R':
1122       /* Parameter which is in a register.  */
1123       SYMBOL_TYPE (sym) = read_type (&p, objfile);
1124       SYMBOL_ACLASS_INDEX (sym) = stab_register_index;
1125       SYMBOL_IS_ARGUMENT (sym) = 1;
1126       SYMBOL_VALUE (sym) = valu;
1127       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1128       add_symbol_to_list (sym, &local_symbols);
1129       break;
1130
1131     case 'r':
1132       /* Register variable (either global or local).  */
1133       SYMBOL_TYPE (sym) = read_type (&p, objfile);
1134       SYMBOL_ACLASS_INDEX (sym) = stab_register_index;
1135       SYMBOL_VALUE (sym) = valu;
1136       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1137       if (within_function)
1138         {
1139           /* Sun cc uses a pair of symbols, one 'p' and one 'r', with
1140              the same name to represent an argument passed in a
1141              register.  GCC uses 'P' for the same case.  So if we find
1142              such a symbol pair we combine it into one 'P' symbol.
1143              For Sun cc we need to do this regardless of
1144              stabs_argument_has_addr, because the compiler puts out
1145              the 'p' symbol even if it never saves the argument onto
1146              the stack.
1147
1148              On most machines, we want to preserve both symbols, so
1149              that we can still get information about what is going on
1150              with the stack (VAX for computing args_printed, using
1151              stack slots instead of saved registers in backtraces,
1152              etc.).
1153
1154              Note that this code illegally combines
1155              main(argc) struct foo argc; { register struct foo argc; }
1156              but this case is considered pathological and causes a warning
1157              from a decent compiler.  */
1158
1159           if (local_symbols
1160               && local_symbols->nsyms > 0
1161               && gdbarch_stabs_argument_has_addr (gdbarch, SYMBOL_TYPE (sym)))
1162             {
1163               struct symbol *prev_sym;
1164
1165               prev_sym = local_symbols->symbol[local_symbols->nsyms - 1];
1166               if ((SYMBOL_CLASS (prev_sym) == LOC_REF_ARG
1167                    || SYMBOL_CLASS (prev_sym) == LOC_ARG)
1168                   && strcmp (SYMBOL_LINKAGE_NAME (prev_sym),
1169                              SYMBOL_LINKAGE_NAME (sym)) == 0)
1170                 {
1171                   SYMBOL_ACLASS_INDEX (prev_sym) = stab_register_index;
1172                   /* Use the type from the LOC_REGISTER; that is the type
1173                      that is actually in that register.  */
1174                   SYMBOL_TYPE (prev_sym) = SYMBOL_TYPE (sym);
1175                   SYMBOL_VALUE (prev_sym) = SYMBOL_VALUE (sym);
1176                   sym = prev_sym;
1177                   break;
1178                 }
1179             }
1180           add_symbol_to_list (sym, &local_symbols);
1181         }
1182       else
1183         add_symbol_to_list (sym, &file_symbols);
1184       break;
1185
1186     case 'S':
1187       /* Static symbol at top level of file.  */
1188       SYMBOL_TYPE (sym) = read_type (&p, objfile);
1189       SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
1190       SYMBOL_VALUE_ADDRESS (sym) = valu;
1191       if (gdbarch_static_transform_name_p (gdbarch)
1192           && gdbarch_static_transform_name (gdbarch,
1193                                             SYMBOL_LINKAGE_NAME (sym))
1194              != SYMBOL_LINKAGE_NAME (sym))
1195         {
1196           struct bound_minimal_symbol msym;
1197
1198           msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
1199                                         NULL, objfile);
1200           if (msym.minsym != NULL)
1201             {
1202               const char *new_name = gdbarch_static_transform_name
1203                 (gdbarch, SYMBOL_LINKAGE_NAME (sym));
1204
1205               SYMBOL_SET_LINKAGE_NAME (sym, new_name);
1206               SYMBOL_VALUE_ADDRESS (sym) = BMSYMBOL_VALUE_ADDRESS (msym);
1207             }
1208         }
1209       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1210       add_symbol_to_list (sym, &file_symbols);
1211       break;
1212
1213     case 't':
1214       /* In Ada, there is no distinction between typedef and non-typedef;
1215          any type declaration implicitly has the equivalent of a typedef,
1216          and thus 't' is in fact equivalent to 'Tt'.
1217
1218          Therefore, for Ada units, we check the character immediately
1219          before the 't', and if we do not find a 'T', then make sure to
1220          create the associated symbol in the STRUCT_DOMAIN ('t' definitions
1221          will be stored in the VAR_DOMAIN).  If the symbol was indeed
1222          defined as 'Tt' then the STRUCT_DOMAIN symbol will be created
1223          elsewhere, so we don't need to take care of that.
1224
1225          This is important to do, because of forward references:
1226          The cleanup of undefined types stored in undef_types only uses
1227          STRUCT_DOMAIN symbols to perform the replacement.  */
1228       synonym = (SYMBOL_LANGUAGE (sym) == language_ada && p[-2] != 'T');
1229
1230       /* Typedef */
1231       SYMBOL_TYPE (sym) = read_type (&p, objfile);
1232
1233       /* For a nameless type, we don't want a create a symbol, thus we
1234          did not use `sym'.  Return without further processing.  */
1235       if (nameless)
1236         return NULL;
1237
1238       SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
1239       SYMBOL_VALUE (sym) = valu;
1240       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1241       /* C++ vagaries: we may have a type which is derived from
1242          a base type which did not have its name defined when the
1243          derived class was output.  We fill in the derived class's
1244          base part member's name here in that case.  */
1245       if (TYPE_NAME (SYMBOL_TYPE (sym)) != NULL)
1246         if ((TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT
1247              || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_UNION)
1248             && TYPE_N_BASECLASSES (SYMBOL_TYPE (sym)))
1249           {
1250             int j;
1251
1252             for (j = TYPE_N_BASECLASSES (SYMBOL_TYPE (sym)) - 1; j >= 0; j--)
1253               if (TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym), j) == 0)
1254                 TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym), j) =
1255                   type_name_no_tag (TYPE_BASECLASS (SYMBOL_TYPE (sym), j));
1256           }
1257
1258       if (TYPE_NAME (SYMBOL_TYPE (sym)) == NULL)
1259         {
1260           /* gcc-2.6 or later (when using -fvtable-thunks)
1261              emits a unique named type for a vtable entry.
1262              Some gdb code depends on that specific name.  */
1263           extern const char vtbl_ptr_name[];
1264
1265           if ((TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR
1266                && strcmp (SYMBOL_LINKAGE_NAME (sym), vtbl_ptr_name))
1267               || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FUNC)
1268             {
1269               /* If we are giving a name to a type such as "pointer to
1270                  foo" or "function returning foo", we better not set
1271                  the TYPE_NAME.  If the program contains "typedef char
1272                  *caddr_t;", we don't want all variables of type char
1273                  * to print as caddr_t.  This is not just a
1274                  consequence of GDB's type management; PCC and GCC (at
1275                  least through version 2.4) both output variables of
1276                  either type char * or caddr_t with the type number
1277                  defined in the 't' symbol for caddr_t.  If a future
1278                  compiler cleans this up it GDB is not ready for it
1279                  yet, but if it becomes ready we somehow need to
1280                  disable this check (without breaking the PCC/GCC2.4
1281                  case).
1282
1283                  Sigh.
1284
1285                  Fortunately, this check seems not to be necessary
1286                  for anything except pointers or functions.  */
1287               /* ezannoni: 2000-10-26.  This seems to apply for
1288                  versions of gcc older than 2.8.  This was the original
1289                  problem: with the following code gdb would tell that
1290                  the type for name1 is caddr_t, and func is char().
1291
1292                  typedef char *caddr_t;
1293                  char *name2;
1294                  struct x
1295                  {
1296                    char *name1;
1297                  } xx;
1298                  char *func()
1299                  {
1300                  }
1301                  main () {}
1302                  */
1303
1304               /* Pascal accepts names for pointer types.  */
1305               if (current_subfile->language == language_pascal)
1306                 {
1307                   TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_LINKAGE_NAME (sym);
1308                 }
1309             }
1310           else
1311             TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_LINKAGE_NAME (sym);
1312         }
1313
1314       add_symbol_to_list (sym, &file_symbols);
1315
1316       if (synonym)
1317         {
1318           /* Create the STRUCT_DOMAIN clone.  */
1319           struct symbol *struct_sym = allocate_symbol (objfile);
1320
1321           *struct_sym = *sym;
1322           SYMBOL_ACLASS_INDEX (struct_sym) = LOC_TYPEDEF;
1323           SYMBOL_VALUE (struct_sym) = valu;
1324           SYMBOL_DOMAIN (struct_sym) = STRUCT_DOMAIN;
1325           if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
1326             TYPE_NAME (SYMBOL_TYPE (sym))
1327               = obconcat (&objfile->objfile_obstack,
1328                           SYMBOL_LINKAGE_NAME (sym),
1329                           (char *) NULL);
1330           add_symbol_to_list (struct_sym, &file_symbols);
1331         }
1332
1333       break;
1334
1335     case 'T':
1336       /* Struct, union, or enum tag.  For GNU C++, this can be be followed
1337          by 't' which means we are typedef'ing it as well.  */
1338       synonym = *p == 't';
1339
1340       if (synonym)
1341         p++;
1342
1343       SYMBOL_TYPE (sym) = read_type (&p, objfile);
1344
1345       /* For a nameless type, we don't want a create a symbol, thus we
1346          did not use `sym'.  Return without further processing.  */
1347       if (nameless)
1348         return NULL;
1349
1350       SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
1351       SYMBOL_VALUE (sym) = valu;
1352       SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
1353       if (TYPE_TAG_NAME (SYMBOL_TYPE (sym)) == 0)
1354         TYPE_TAG_NAME (SYMBOL_TYPE (sym))
1355           = obconcat (&objfile->objfile_obstack,
1356                       SYMBOL_LINKAGE_NAME (sym),
1357                       (char *) NULL);
1358       add_symbol_to_list (sym, &file_symbols);
1359
1360       if (synonym)
1361         {
1362           /* Clone the sym and then modify it.  */
1363           struct symbol *typedef_sym = allocate_symbol (objfile);
1364
1365           *typedef_sym = *sym;
1366           SYMBOL_ACLASS_INDEX (typedef_sym) = LOC_TYPEDEF;
1367           SYMBOL_VALUE (typedef_sym) = valu;
1368           SYMBOL_DOMAIN (typedef_sym) = VAR_DOMAIN;
1369           if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
1370             TYPE_NAME (SYMBOL_TYPE (sym))
1371               = obconcat (&objfile->objfile_obstack,
1372                           SYMBOL_LINKAGE_NAME (sym),
1373                           (char *) NULL);
1374           add_symbol_to_list (typedef_sym, &file_symbols);
1375         }
1376       break;
1377
1378     case 'V':
1379       /* Static symbol of local scope.  */
1380       SYMBOL_TYPE (sym) = read_type (&p, objfile);
1381       SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
1382       SYMBOL_VALUE_ADDRESS (sym) = valu;
1383       if (gdbarch_static_transform_name_p (gdbarch)
1384           && gdbarch_static_transform_name (gdbarch,
1385                                             SYMBOL_LINKAGE_NAME (sym))
1386              != SYMBOL_LINKAGE_NAME (sym))
1387         {
1388           struct bound_minimal_symbol msym;
1389
1390           msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
1391                                         NULL, objfile);
1392           if (msym.minsym != NULL)
1393             {
1394               const char *new_name = gdbarch_static_transform_name
1395                 (gdbarch, SYMBOL_LINKAGE_NAME (sym));
1396
1397               SYMBOL_SET_LINKAGE_NAME (sym, new_name);
1398               SYMBOL_VALUE_ADDRESS (sym) = BMSYMBOL_VALUE_ADDRESS (msym);
1399             }
1400         }
1401       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1402         add_symbol_to_list (sym, &local_symbols);
1403       break;
1404
1405     case 'v':
1406       /* Reference parameter */
1407       SYMBOL_TYPE (sym) = read_type (&p, objfile);
1408       SYMBOL_ACLASS_INDEX (sym) = LOC_REF_ARG;
1409       SYMBOL_IS_ARGUMENT (sym) = 1;
1410       SYMBOL_VALUE (sym) = valu;
1411       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1412       add_symbol_to_list (sym, &local_symbols);
1413       break;
1414
1415     case 'a':
1416       /* Reference parameter which is in a register.  */
1417       SYMBOL_TYPE (sym) = read_type (&p, objfile);
1418       SYMBOL_ACLASS_INDEX (sym) = stab_regparm_index;
1419       SYMBOL_IS_ARGUMENT (sym) = 1;
1420       SYMBOL_VALUE (sym) = valu;
1421       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1422       add_symbol_to_list (sym, &local_symbols);
1423       break;
1424
1425     case 'X':
1426       /* This is used by Sun FORTRAN for "function result value".
1427          Sun claims ("dbx and dbxtool interfaces", 2nd ed)
1428          that Pascal uses it too, but when I tried it Pascal used
1429          "x:3" (local symbol) instead.  */
1430       SYMBOL_TYPE (sym) = read_type (&p, objfile);
1431       SYMBOL_ACLASS_INDEX (sym) = LOC_LOCAL;
1432       SYMBOL_VALUE (sym) = valu;
1433       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1434       add_symbol_to_list (sym, &local_symbols);
1435       break;
1436
1437     default:
1438       SYMBOL_TYPE (sym) = error_type (&p, objfile);
1439       SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
1440       SYMBOL_VALUE (sym) = 0;
1441       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1442       add_symbol_to_list (sym, &file_symbols);
1443       break;
1444     }
1445
1446   /* Some systems pass variables of certain types by reference instead
1447      of by value, i.e. they will pass the address of a structure (in a
1448      register or on the stack) instead of the structure itself.  */
1449
1450   if (gdbarch_stabs_argument_has_addr (gdbarch, SYMBOL_TYPE (sym))
1451       && SYMBOL_IS_ARGUMENT (sym))
1452     {
1453       /* We have to convert LOC_REGISTER to LOC_REGPARM_ADDR (for
1454          variables passed in a register).  */
1455       if (SYMBOL_CLASS (sym) == LOC_REGISTER)
1456         SYMBOL_ACLASS_INDEX (sym) = LOC_REGPARM_ADDR;
1457       /* Likewise for converting LOC_ARG to LOC_REF_ARG (for the 7th
1458          and subsequent arguments on SPARC, for example).  */
1459       else if (SYMBOL_CLASS (sym) == LOC_ARG)
1460         SYMBOL_ACLASS_INDEX (sym) = LOC_REF_ARG;
1461     }
1462
1463   return sym;
1464 }
1465
1466 /* Skip rest of this symbol and return an error type.
1467
1468    General notes on error recovery:  error_type always skips to the
1469    end of the symbol (modulo cretinous dbx symbol name continuation).
1470    Thus code like this:
1471
1472    if (*(*pp)++ != ';')
1473    return error_type (pp, objfile);
1474
1475    is wrong because if *pp starts out pointing at '\0' (typically as the
1476    result of an earlier error), it will be incremented to point to the
1477    start of the next symbol, which might produce strange results, at least
1478    if you run off the end of the string table.  Instead use
1479
1480    if (**pp != ';')
1481    return error_type (pp, objfile);
1482    ++*pp;
1483
1484    or
1485
1486    if (**pp != ';')
1487    foo = error_type (pp, objfile);
1488    else
1489    ++*pp;
1490
1491    And in case it isn't obvious, the point of all this hair is so the compiler
1492    can define new types and new syntaxes, and old versions of the
1493    debugger will be able to read the new symbol tables.  */
1494
1495 static struct type *
1496 error_type (const char **pp, struct objfile *objfile)
1497 {
1498   complaint (&symfile_complaints,
1499              _("couldn't parse type; debugger out of date?"));
1500   while (1)
1501     {
1502       /* Skip to end of symbol.  */
1503       while (**pp != '\0')
1504         {
1505           (*pp)++;
1506         }
1507
1508       /* Check for and handle cretinous dbx symbol name continuation!  */
1509       if ((*pp)[-1] == '\\' || (*pp)[-1] == '?')
1510         {
1511           *pp = next_symbol_text (objfile);
1512         }
1513       else
1514         {
1515           break;
1516         }
1517     }
1518   return objfile_type (objfile)->builtin_error;
1519 }
1520 \f
1521
1522 /* Read type information or a type definition; return the type.  Even
1523    though this routine accepts either type information or a type
1524    definition, the distinction is relevant--some parts of stabsread.c
1525    assume that type information starts with a digit, '-', or '(' in
1526    deciding whether to call read_type.  */
1527
1528 static struct type *
1529 read_type (const char **pp, struct objfile *objfile)
1530 {
1531   struct type *type = 0;
1532   struct type *type1;
1533   int typenums[2];
1534   char type_descriptor;
1535
1536   /* Size in bits of type if specified by a type attribute, or -1 if
1537      there is no size attribute.  */
1538   int type_size = -1;
1539
1540   /* Used to distinguish string and bitstring from char-array and set.  */
1541   int is_string = 0;
1542
1543   /* Used to distinguish vector from array.  */
1544   int is_vector = 0;
1545
1546   /* Read type number if present.  The type number may be omitted.
1547      for instance in a two-dimensional array declared with type
1548      "ar1;1;10;ar1;1;10;4".  */
1549   if ((**pp >= '0' && **pp <= '9')
1550       || **pp == '('
1551       || **pp == '-')
1552     {
1553       if (read_type_number (pp, typenums) != 0)
1554         return error_type (pp, objfile);
1555
1556       if (**pp != '=')
1557         {
1558           /* Type is not being defined here.  Either it already
1559              exists, or this is a forward reference to it.
1560              dbx_alloc_type handles both cases.  */
1561           type = dbx_alloc_type (typenums, objfile);
1562
1563           /* If this is a forward reference, arrange to complain if it
1564              doesn't get patched up by the time we're done
1565              reading.  */
1566           if (TYPE_CODE (type) == TYPE_CODE_UNDEF)
1567             add_undefined_type (type, typenums);
1568
1569           return type;
1570         }
1571
1572       /* Type is being defined here.  */
1573       /* Skip the '='.
1574          Also skip the type descriptor - we get it below with (*pp)[-1].  */
1575       (*pp) += 2;
1576     }
1577   else
1578     {
1579       /* 'typenums=' not present, type is anonymous.  Read and return
1580          the definition, but don't put it in the type vector.  */
1581       typenums[0] = typenums[1] = -1;
1582       (*pp)++;
1583     }
1584
1585 again:
1586   type_descriptor = (*pp)[-1];
1587   switch (type_descriptor)
1588     {
1589     case 'x':
1590       {
1591         enum type_code code;
1592
1593         /* Used to index through file_symbols.  */
1594         struct pending *ppt;
1595         int i;
1596
1597         /* Name including "struct", etc.  */
1598         char *type_name;
1599
1600         {
1601           const char *from, *p, *q1, *q2;
1602
1603           /* Set the type code according to the following letter.  */
1604           switch ((*pp)[0])
1605             {
1606             case 's':
1607               code = TYPE_CODE_STRUCT;
1608               break;
1609             case 'u':
1610               code = TYPE_CODE_UNION;
1611               break;
1612             case 'e':
1613               code = TYPE_CODE_ENUM;
1614               break;
1615             default:
1616               {
1617                 /* Complain and keep going, so compilers can invent new
1618                    cross-reference types.  */
1619                 complaint (&symfile_complaints,
1620                            _("Unrecognized cross-reference type `%c'"),
1621                            (*pp)[0]);
1622                 code = TYPE_CODE_STRUCT;
1623                 break;
1624               }
1625             }
1626
1627           q1 = strchr (*pp, '<');
1628           p = strchr (*pp, ':');
1629           if (p == NULL)
1630             return error_type (pp, objfile);
1631           if (q1 && p > q1 && p[1] == ':')
1632             {
1633               int nesting_level = 0;
1634
1635               for (q2 = q1; *q2; q2++)
1636                 {
1637                   if (*q2 == '<')
1638                     nesting_level++;
1639                   else if (*q2 == '>')
1640                     nesting_level--;
1641                   else if (*q2 == ':' && nesting_level == 0)
1642                     break;
1643                 }
1644               p = q2;
1645               if (*p != ':')
1646                 return error_type (pp, objfile);
1647             }
1648           type_name = NULL;
1649           if (current_subfile->language == language_cplus)
1650             {
1651               char *name = (char *) alloca (p - *pp + 1);
1652
1653               memcpy (name, *pp, p - *pp);
1654               name[p - *pp] = '\0';
1655
1656               std::string new_name = cp_canonicalize_string (name);
1657               if (!new_name.empty ())
1658                 {
1659                   type_name
1660                     = (char *) obstack_copy0 (&objfile->objfile_obstack,
1661                                               new_name.c_str (),
1662                                               new_name.length ());
1663                 }
1664             }
1665           if (type_name == NULL)
1666             {
1667               char *to = type_name = (char *)
1668                 obstack_alloc (&objfile->objfile_obstack, p - *pp + 1);
1669
1670               /* Copy the name.  */
1671               from = *pp + 1;
1672               while (from < p)
1673                 *to++ = *from++;
1674               *to = '\0';
1675             }
1676
1677           /* Set the pointer ahead of the name which we just read, and
1678              the colon.  */
1679           *pp = p + 1;
1680         }
1681
1682         /* If this type has already been declared, then reuse the same
1683            type, rather than allocating a new one.  This saves some
1684            memory.  */
1685
1686         for (ppt = file_symbols; ppt; ppt = ppt->next)
1687           for (i = 0; i < ppt->nsyms; i++)
1688             {
1689               struct symbol *sym = ppt->symbol[i];
1690
1691               if (SYMBOL_CLASS (sym) == LOC_TYPEDEF
1692                   && SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
1693                   && (TYPE_CODE (SYMBOL_TYPE (sym)) == code)
1694                   && strcmp (SYMBOL_LINKAGE_NAME (sym), type_name) == 0)
1695                 {
1696                   obstack_free (&objfile->objfile_obstack, type_name);
1697                   type = SYMBOL_TYPE (sym);
1698                   if (typenums[0] != -1)
1699                     *dbx_lookup_type (typenums, objfile) = type;
1700                   return type;
1701                 }
1702             }
1703
1704         /* Didn't find the type to which this refers, so we must
1705            be dealing with a forward reference.  Allocate a type
1706            structure for it, and keep track of it so we can
1707            fill in the rest of the fields when we get the full
1708            type.  */
1709         type = dbx_alloc_type (typenums, objfile);
1710         TYPE_CODE (type) = code;
1711         TYPE_TAG_NAME (type) = type_name;
1712         INIT_CPLUS_SPECIFIC (type);
1713         TYPE_STUB (type) = 1;
1714
1715         add_undefined_type (type, typenums);
1716         return type;
1717       }
1718
1719     case '-':                   /* RS/6000 built-in type */
1720     case '0':
1721     case '1':
1722     case '2':
1723     case '3':
1724     case '4':
1725     case '5':
1726     case '6':
1727     case '7':
1728     case '8':
1729     case '9':
1730     case '(':
1731       (*pp)--;
1732
1733       /* We deal with something like t(1,2)=(3,4)=... which
1734          the Lucid compiler and recent gcc versions (post 2.7.3) use.  */
1735
1736       /* Allocate and enter the typedef type first.
1737          This handles recursive types.  */
1738       type = dbx_alloc_type (typenums, objfile);
1739       TYPE_CODE (type) = TYPE_CODE_TYPEDEF;
1740       {
1741         struct type *xtype = read_type (pp, objfile);
1742
1743         if (type == xtype)
1744           {
1745             /* It's being defined as itself.  That means it is "void".  */
1746             TYPE_CODE (type) = TYPE_CODE_VOID;
1747             TYPE_LENGTH (type) = 1;
1748           }
1749         else if (type_size >= 0 || is_string)
1750           {
1751             /* This is the absolute wrong way to construct types.  Every
1752                other debug format has found a way around this problem and
1753                the related problems with unnecessarily stubbed types;
1754                someone motivated should attempt to clean up the issue
1755                here as well.  Once a type pointed to has been created it
1756                should not be modified.
1757
1758                Well, it's not *absolutely* wrong.  Constructing recursive
1759                types (trees, linked lists) necessarily entails modifying
1760                types after creating them.  Constructing any loop structure
1761                entails side effects.  The Dwarf 2 reader does handle this
1762                more gracefully (it never constructs more than once
1763                instance of a type object, so it doesn't have to copy type
1764                objects wholesale), but it still mutates type objects after
1765                other folks have references to them.
1766
1767                Keep in mind that this circularity/mutation issue shows up
1768                at the source language level, too: C's "incomplete types",
1769                for example.  So the proper cleanup, I think, would be to
1770                limit GDB's type smashing to match exactly those required
1771                by the source language.  So GDB could have a
1772                "complete_this_type" function, but never create unnecessary
1773                copies of a type otherwise.  */
1774             replace_type (type, xtype);
1775             TYPE_NAME (type) = NULL;
1776             TYPE_TAG_NAME (type) = NULL;
1777           }
1778         else
1779           {
1780             TYPE_TARGET_STUB (type) = 1;
1781             TYPE_TARGET_TYPE (type) = xtype;
1782           }
1783       }
1784       break;
1785
1786       /* In the following types, we must be sure to overwrite any existing
1787          type that the typenums refer to, rather than allocating a new one
1788          and making the typenums point to the new one.  This is because there
1789          may already be pointers to the existing type (if it had been
1790          forward-referenced), and we must change it to a pointer, function,
1791          reference, or whatever, *in-place*.  */
1792
1793     case '*':                   /* Pointer to another type */
1794       type1 = read_type (pp, objfile);
1795       type = make_pointer_type (type1, dbx_lookup_type (typenums, objfile));
1796       break;
1797
1798     case '&':                   /* Reference to another type */
1799       type1 = read_type (pp, objfile);
1800       type = make_reference_type (type1, dbx_lookup_type (typenums, objfile),
1801                                   TYPE_CODE_REF);
1802       break;
1803
1804     case 'f':                   /* Function returning another type */
1805       type1 = read_type (pp, objfile);
1806       type = make_function_type (type1, dbx_lookup_type (typenums, objfile));
1807       break;
1808
1809     case 'g':                   /* Prototyped function.  (Sun)  */
1810       {
1811         /* Unresolved questions:
1812
1813            - According to Sun's ``STABS Interface Manual'', for 'f'
1814            and 'F' symbol descriptors, a `0' in the argument type list
1815            indicates a varargs function.  But it doesn't say how 'g'
1816            type descriptors represent that info.  Someone with access
1817            to Sun's toolchain should try it out.
1818
1819            - According to the comment in define_symbol (search for
1820            `process_prototype_types:'), Sun emits integer arguments as
1821            types which ref themselves --- like `void' types.  Do we
1822            have to deal with that here, too?  Again, someone with
1823            access to Sun's toolchain should try it out and let us
1824            know.  */
1825
1826         const char *type_start = (*pp) - 1;
1827         struct type *return_type = read_type (pp, objfile);
1828         struct type *func_type
1829           = make_function_type (return_type,
1830                                 dbx_lookup_type (typenums, objfile));
1831         struct type_list {
1832           struct type *type;
1833           struct type_list *next;
1834         } *arg_types = 0;
1835         int num_args = 0;
1836
1837         while (**pp && **pp != '#')
1838           {
1839             struct type *arg_type = read_type (pp, objfile);
1840             struct type_list *newobj = XALLOCA (struct type_list);
1841             newobj->type = arg_type;
1842             newobj->next = arg_types;
1843             arg_types = newobj;
1844             num_args++;
1845           }
1846         if (**pp == '#')
1847           ++*pp;
1848         else
1849           {
1850             complaint (&symfile_complaints,
1851                        _("Prototyped function type didn't "
1852                          "end arguments with `#':\n%s"),
1853                        type_start);
1854           }
1855
1856         /* If there is just one argument whose type is `void', then
1857            that's just an empty argument list.  */
1858         if (arg_types
1859             && ! arg_types->next
1860             && TYPE_CODE (arg_types->type) == TYPE_CODE_VOID)
1861           num_args = 0;
1862
1863         TYPE_FIELDS (func_type)
1864           = (struct field *) TYPE_ALLOC (func_type,
1865                                          num_args * sizeof (struct field));
1866         memset (TYPE_FIELDS (func_type), 0, num_args * sizeof (struct field));
1867         {
1868           int i;
1869           struct type_list *t;
1870
1871           /* We stuck each argument type onto the front of the list
1872              when we read it, so the list is reversed.  Build the
1873              fields array right-to-left.  */
1874           for (t = arg_types, i = num_args - 1; t; t = t->next, i--)
1875             TYPE_FIELD_TYPE (func_type, i) = t->type;
1876         }
1877         TYPE_NFIELDS (func_type) = num_args;
1878         TYPE_PROTOTYPED (func_type) = 1;
1879
1880         type = func_type;
1881         break;
1882       }
1883
1884     case 'k':                   /* Const qualifier on some type (Sun) */
1885       type = read_type (pp, objfile);
1886       type = make_cv_type (1, TYPE_VOLATILE (type), type,
1887                            dbx_lookup_type (typenums, objfile));
1888       break;
1889
1890     case 'B':                   /* Volatile qual on some type (Sun) */
1891       type = read_type (pp, objfile);
1892       type = make_cv_type (TYPE_CONST (type), 1, type,
1893                            dbx_lookup_type (typenums, objfile));
1894       break;
1895
1896     case '@':
1897       if (isdigit (**pp) || **pp == '(' || **pp == '-')
1898         {                       /* Member (class & variable) type */
1899           /* FIXME -- we should be doing smash_to_XXX types here.  */
1900
1901           struct type *domain = read_type (pp, objfile);
1902           struct type *memtype;
1903
1904           if (**pp != ',')
1905             /* Invalid member type data format.  */
1906             return error_type (pp, objfile);
1907           ++*pp;
1908
1909           memtype = read_type (pp, objfile);
1910           type = dbx_alloc_type (typenums, objfile);
1911           smash_to_memberptr_type (type, domain, memtype);
1912         }
1913       else
1914         /* type attribute */
1915         {
1916           const char *attr = *pp;
1917
1918           /* Skip to the semicolon.  */
1919           while (**pp != ';' && **pp != '\0')
1920             ++(*pp);
1921           if (**pp == '\0')
1922             return error_type (pp, objfile);
1923           else
1924             ++ * pp;            /* Skip the semicolon.  */
1925
1926           switch (*attr)
1927             {
1928             case 's':           /* Size attribute */
1929               type_size = atoi (attr + 1);
1930               if (type_size <= 0)
1931                 type_size = -1;
1932               break;
1933
1934             case 'S':           /* String attribute */
1935               /* FIXME: check to see if following type is array?  */
1936               is_string = 1;
1937               break;
1938
1939             case 'V':           /* Vector attribute */
1940               /* FIXME: check to see if following type is array?  */
1941               is_vector = 1;
1942               break;
1943
1944             default:
1945               /* Ignore unrecognized type attributes, so future compilers
1946                  can invent new ones.  */
1947               break;
1948             }
1949           ++*pp;
1950           goto again;
1951         }
1952       break;
1953
1954     case '#':                   /* Method (class & fn) type */
1955       if ((*pp)[0] == '#')
1956         {
1957           /* We'll get the parameter types from the name.  */
1958           struct type *return_type;
1959
1960           (*pp)++;
1961           return_type = read_type (pp, objfile);
1962           if (*(*pp)++ != ';')
1963             complaint (&symfile_complaints,
1964                        _("invalid (minimal) member type "
1965                          "data format at symtab pos %d."),
1966                        symnum);
1967           type = allocate_stub_method (return_type);
1968           if (typenums[0] != -1)
1969             *dbx_lookup_type (typenums, objfile) = type;
1970         }
1971       else
1972         {
1973           struct type *domain = read_type (pp, objfile);
1974           struct type *return_type;
1975           struct field *args;
1976           int nargs, varargs;
1977
1978           if (**pp != ',')
1979             /* Invalid member type data format.  */
1980             return error_type (pp, objfile);
1981           else
1982             ++(*pp);
1983
1984           return_type = read_type (pp, objfile);
1985           args = read_args (pp, ';', objfile, &nargs, &varargs);
1986           if (args == NULL)
1987             return error_type (pp, objfile);
1988           type = dbx_alloc_type (typenums, objfile);
1989           smash_to_method_type (type, domain, return_type, args,
1990                                 nargs, varargs);
1991         }
1992       break;
1993
1994     case 'r':                   /* Range type */
1995       type = read_range_type (pp, typenums, type_size, objfile);
1996       if (typenums[0] != -1)
1997         *dbx_lookup_type (typenums, objfile) = type;
1998       break;
1999
2000     case 'b':
2001         {
2002           /* Sun ACC builtin int type */
2003           type = read_sun_builtin_type (pp, typenums, objfile);
2004           if (typenums[0] != -1)
2005             *dbx_lookup_type (typenums, objfile) = type;
2006         }
2007       break;
2008
2009     case 'R':                   /* Sun ACC builtin float type */
2010       type = read_sun_floating_type (pp, typenums, objfile);
2011       if (typenums[0] != -1)
2012         *dbx_lookup_type (typenums, objfile) = type;
2013       break;
2014
2015     case 'e':                   /* Enumeration type */
2016       type = dbx_alloc_type (typenums, objfile);
2017       type = read_enum_type (pp, type, objfile);
2018       if (typenums[0] != -1)
2019         *dbx_lookup_type (typenums, objfile) = type;
2020       break;
2021
2022     case 's':                   /* Struct type */
2023     case 'u':                   /* Union type */
2024       {
2025         enum type_code type_code = TYPE_CODE_UNDEF;
2026         type = dbx_alloc_type (typenums, objfile);
2027         switch (type_descriptor)
2028           {
2029           case 's':
2030             type_code = TYPE_CODE_STRUCT;
2031             break;
2032           case 'u':
2033             type_code = TYPE_CODE_UNION;
2034             break;
2035           }
2036         type = read_struct_type (pp, type, type_code, objfile);
2037         break;
2038       }
2039
2040     case 'a':                   /* Array type */
2041       if (**pp != 'r')
2042         return error_type (pp, objfile);
2043       ++*pp;
2044
2045       type = dbx_alloc_type (typenums, objfile);
2046       type = read_array_type (pp, type, objfile);
2047       if (is_string)
2048         TYPE_CODE (type) = TYPE_CODE_STRING;
2049       if (is_vector)
2050         make_vector_type (type);
2051       break;
2052
2053     case 'S':                   /* Set type */
2054       type1 = read_type (pp, objfile);
2055       type = create_set_type ((struct type *) NULL, type1);
2056       if (typenums[0] != -1)
2057         *dbx_lookup_type (typenums, objfile) = type;
2058       break;
2059
2060     default:
2061       --*pp;                    /* Go back to the symbol in error.  */
2062       /* Particularly important if it was \0!  */
2063       return error_type (pp, objfile);
2064     }
2065
2066   if (type == 0)
2067     {
2068       warning (_("GDB internal error, type is NULL in stabsread.c."));
2069       return error_type (pp, objfile);
2070     }
2071
2072   /* Size specified in a type attribute overrides any other size.  */
2073   if (type_size != -1)
2074     TYPE_LENGTH (type) = (type_size + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT;
2075
2076   return type;
2077 }
2078 \f
2079 /* RS/6000 xlc/dbx combination uses a set of builtin types, starting from -1.
2080    Return the proper type node for a given builtin type number.  */
2081
2082 static const struct objfile_data *rs6000_builtin_type_data;
2083
2084 static struct type *
2085 rs6000_builtin_type (int typenum, struct objfile *objfile)
2086 {
2087   struct type **negative_types
2088     = (struct type **) objfile_data (objfile, rs6000_builtin_type_data);
2089
2090   /* We recognize types numbered from -NUMBER_RECOGNIZED to -1.  */
2091 #define NUMBER_RECOGNIZED 34
2092   struct type *rettype = NULL;
2093
2094   if (typenum >= 0 || typenum < -NUMBER_RECOGNIZED)
2095     {
2096       complaint (&symfile_complaints, _("Unknown builtin type %d"), typenum);
2097       return objfile_type (objfile)->builtin_error;
2098     }
2099
2100   if (!negative_types)
2101     {
2102       /* This includes an empty slot for type number -0.  */
2103       negative_types = OBSTACK_CALLOC (&objfile->objfile_obstack,
2104                                        NUMBER_RECOGNIZED + 1, struct type *);
2105       set_objfile_data (objfile, rs6000_builtin_type_data, negative_types);
2106     }
2107
2108   if (negative_types[-typenum] != NULL)
2109     return negative_types[-typenum];
2110
2111 #if TARGET_CHAR_BIT != 8
2112 #error This code wrong for TARGET_CHAR_BIT not 8
2113   /* These definitions all assume that TARGET_CHAR_BIT is 8.  I think
2114      that if that ever becomes not true, the correct fix will be to
2115      make the size in the struct type to be in bits, not in units of
2116      TARGET_CHAR_BIT.  */
2117 #endif
2118
2119   switch (-typenum)
2120     {
2121     case 1:
2122       /* The size of this and all the other types are fixed, defined
2123          by the debugging format.  If there is a type called "int" which
2124          is other than 32 bits, then it should use a new negative type
2125          number (or avoid negative type numbers for that case).
2126          See stabs.texinfo.  */
2127       rettype = init_integer_type (objfile, 32, 0, "int");
2128       break;
2129     case 2:
2130       rettype = init_integer_type (objfile, 8, 0, "char");
2131       TYPE_NOSIGN (rettype) = 1;
2132       break;
2133     case 3:
2134       rettype = init_integer_type (objfile, 16, 0, "short");
2135       break;
2136     case 4:
2137       rettype = init_integer_type (objfile, 32, 0, "long");
2138       break;
2139     case 5:
2140       rettype = init_integer_type (objfile, 8, 1, "unsigned char");
2141       break;
2142     case 6:
2143       rettype = init_integer_type (objfile, 8, 0, "signed char");
2144       break;
2145     case 7:
2146       rettype = init_integer_type (objfile, 16, 1, "unsigned short");
2147       break;
2148     case 8:
2149       rettype = init_integer_type (objfile, 32, 1, "unsigned int");
2150       break;
2151     case 9:
2152       rettype = init_integer_type (objfile, 32, 1, "unsigned");
2153       break;
2154     case 10:
2155       rettype = init_integer_type (objfile, 32, 1, "unsigned long");
2156       break;
2157     case 11:
2158       rettype = init_type (objfile, TYPE_CODE_VOID, 1, "void");
2159       break;
2160     case 12:
2161       /* IEEE single precision (32 bit).  */
2162       rettype = init_float_type (objfile, 32, "float",
2163                                  floatformats_ieee_single);
2164       break;
2165     case 13:
2166       /* IEEE double precision (64 bit).  */
2167       rettype = init_float_type (objfile, 64, "double",
2168                                  floatformats_ieee_double);
2169       break;
2170     case 14:
2171       /* This is an IEEE double on the RS/6000, and different machines with
2172          different sizes for "long double" should use different negative
2173          type numbers.  See stabs.texinfo.  */
2174       rettype = init_float_type (objfile, 64, "long double",
2175                                  floatformats_ieee_double);
2176       break;
2177     case 15:
2178       rettype = init_integer_type (objfile, 32, 0, "integer");
2179       break;
2180     case 16:
2181       rettype = init_boolean_type (objfile, 32, 1, "boolean");
2182       break;
2183     case 17:
2184       rettype = init_float_type (objfile, 32, "short real",
2185                                  floatformats_ieee_single);
2186       break;
2187     case 18:
2188       rettype = init_float_type (objfile, 64, "real",
2189                                  floatformats_ieee_double);
2190       break;
2191     case 19:
2192       rettype = init_type (objfile, TYPE_CODE_ERROR, 0, "stringptr");
2193       break;
2194     case 20:
2195       rettype = init_character_type (objfile, 8, 1, "character");
2196       break;
2197     case 21:
2198       rettype = init_boolean_type (objfile, 8, 1, "logical*1");
2199       break;
2200     case 22:
2201       rettype = init_boolean_type (objfile, 16, 1, "logical*2");
2202       break;
2203     case 23:
2204       rettype = init_boolean_type (objfile, 32, 1, "logical*4");
2205       break;
2206     case 24:
2207       rettype = init_boolean_type (objfile, 32, 1, "logical");
2208       break;
2209     case 25:
2210       /* Complex type consisting of two IEEE single precision values.  */
2211       rettype = init_complex_type (objfile, "complex",
2212                                    rs6000_builtin_type (12, objfile));
2213       break;
2214     case 26:
2215       /* Complex type consisting of two IEEE double precision values.  */
2216       rettype = init_complex_type (objfile, "double complex",
2217                                    rs6000_builtin_type (13, objfile));
2218       break;
2219     case 27:
2220       rettype = init_integer_type (objfile, 8, 0, "integer*1");
2221       break;
2222     case 28:
2223       rettype = init_integer_type (objfile, 16, 0, "integer*2");
2224       break;
2225     case 29:
2226       rettype = init_integer_type (objfile, 32, 0, "integer*4");
2227       break;
2228     case 30:
2229       rettype = init_character_type (objfile, 16, 0, "wchar");
2230       break;
2231     case 31:
2232       rettype = init_integer_type (objfile, 64, 0, "long long");
2233       break;
2234     case 32:
2235       rettype = init_integer_type (objfile, 64, 1, "unsigned long long");
2236       break;
2237     case 33:
2238       rettype = init_integer_type (objfile, 64, 1, "logical*8");
2239       break;
2240     case 34:
2241       rettype = init_integer_type (objfile, 64, 0, "integer*8");
2242       break;
2243     }
2244   negative_types[-typenum] = rettype;
2245   return rettype;
2246 }
2247 \f
2248 /* This page contains subroutines of read_type.  */
2249
2250 /* Wrapper around method_name_from_physname to flag a complaint
2251    if there is an error.  */
2252
2253 static char *
2254 stabs_method_name_from_physname (const char *physname)
2255 {
2256   char *method_name;
2257
2258   method_name = method_name_from_physname (physname);
2259
2260   if (method_name == NULL)
2261     {
2262       complaint (&symfile_complaints,
2263                  _("Method has bad physname %s\n"), physname);
2264       return NULL;
2265     }
2266
2267   return method_name;
2268 }
2269
2270 /* Read member function stabs info for C++ classes.  The form of each member
2271    function data is:
2272
2273    NAME :: TYPENUM[=type definition] ARGS : PHYSNAME ;
2274
2275    An example with two member functions is:
2276
2277    afunc1::20=##15;:i;2A.;afunc2::20:i;2A.;
2278
2279    For the case of overloaded operators, the format is op$::*.funcs, where
2280    $ is the CPLUS_MARKER (usually '$'), `*' holds the place for an operator
2281    name (such as `+=') and `.' marks the end of the operator name.
2282
2283    Returns 1 for success, 0 for failure.  */
2284
2285 static int
2286 read_member_functions (struct field_info *fip, const char **pp,
2287                        struct type *type, struct objfile *objfile)
2288 {
2289   int nfn_fields = 0;
2290   int length = 0;
2291   int i;
2292   struct next_fnfield
2293     {
2294       struct next_fnfield *next;
2295       struct fn_field fn_field;
2296     }
2297    *sublist;
2298   struct type *look_ahead_type;
2299   struct next_fnfieldlist *new_fnlist;
2300   struct next_fnfield *new_sublist;
2301   char *main_fn_name;
2302   const char *p;
2303
2304   /* Process each list until we find something that is not a member function
2305      or find the end of the functions.  */
2306
2307   while (**pp != ';')
2308     {
2309       /* We should be positioned at the start of the function name.
2310          Scan forward to find the first ':' and if it is not the
2311          first of a "::" delimiter, then this is not a member function.  */
2312       p = *pp;
2313       while (*p != ':')
2314         {
2315           p++;
2316         }
2317       if (p[1] != ':')
2318         {
2319           break;
2320         }
2321
2322       sublist = NULL;
2323       look_ahead_type = NULL;
2324       length = 0;
2325
2326       new_fnlist = XCNEW (struct next_fnfieldlist);
2327       make_cleanup (xfree, new_fnlist);
2328
2329       if ((*pp)[0] == 'o' && (*pp)[1] == 'p' && is_cplus_marker ((*pp)[2]))
2330         {
2331           /* This is a completely wierd case.  In order to stuff in the
2332              names that might contain colons (the usual name delimiter),
2333              Mike Tiemann defined a different name format which is
2334              signalled if the identifier is "op$".  In that case, the
2335              format is "op$::XXXX." where XXXX is the name.  This is
2336              used for names like "+" or "=".  YUUUUUUUK!  FIXME!  */
2337           /* This lets the user type "break operator+".
2338              We could just put in "+" as the name, but that wouldn't
2339              work for "*".  */
2340           static char opname[32] = "op$";
2341           char *o = opname + 3;
2342
2343           /* Skip past '::'.  */
2344           *pp = p + 2;
2345
2346           STABS_CONTINUE (pp, objfile);
2347           p = *pp;
2348           while (*p != '.')
2349             {
2350               *o++ = *p++;
2351             }
2352           main_fn_name = savestring (opname, o - opname);
2353           /* Skip past '.'  */
2354           *pp = p + 1;
2355         }
2356       else
2357         {
2358           main_fn_name = savestring (*pp, p - *pp);
2359           /* Skip past '::'.  */
2360           *pp = p + 2;
2361         }
2362       new_fnlist->fn_fieldlist.name = main_fn_name;
2363
2364       do
2365         {
2366           new_sublist = XCNEW (struct next_fnfield);
2367           make_cleanup (xfree, new_sublist);
2368
2369           /* Check for and handle cretinous dbx symbol name continuation!  */
2370           if (look_ahead_type == NULL)
2371             {
2372               /* Normal case.  */
2373               STABS_CONTINUE (pp, objfile);
2374
2375               new_sublist->fn_field.type = read_type (pp, objfile);
2376               if (**pp != ':')
2377                 {
2378                   /* Invalid symtab info for member function.  */
2379                   return 0;
2380                 }
2381             }
2382           else
2383             {
2384               /* g++ version 1 kludge */
2385               new_sublist->fn_field.type = look_ahead_type;
2386               look_ahead_type = NULL;
2387             }
2388
2389           (*pp)++;
2390           p = *pp;
2391           while (*p != ';')
2392             {
2393               p++;
2394             }
2395
2396           /* These are methods, not functions.  */
2397           if (TYPE_CODE (new_sublist->fn_field.type) == TYPE_CODE_FUNC)
2398             TYPE_CODE (new_sublist->fn_field.type) = TYPE_CODE_METHOD;
2399           else
2400             gdb_assert (TYPE_CODE (new_sublist->fn_field.type)
2401                         == TYPE_CODE_METHOD);
2402
2403           /* If this is just a stub, then we don't have the real name here.  */
2404           if (TYPE_STUB (new_sublist->fn_field.type))
2405             {
2406               if (!TYPE_SELF_TYPE (new_sublist->fn_field.type))
2407                 set_type_self_type (new_sublist->fn_field.type, type);
2408               new_sublist->fn_field.is_stub = 1;
2409             }
2410
2411           new_sublist->fn_field.physname = savestring (*pp, p - *pp);
2412           *pp = p + 1;
2413
2414           /* Set this member function's visibility fields.  */
2415           switch (*(*pp)++)
2416             {
2417             case VISIBILITY_PRIVATE:
2418               new_sublist->fn_field.is_private = 1;
2419               break;
2420             case VISIBILITY_PROTECTED:
2421               new_sublist->fn_field.is_protected = 1;
2422               break;
2423             }
2424
2425           STABS_CONTINUE (pp, objfile);
2426           switch (**pp)
2427             {
2428             case 'A':           /* Normal functions.  */
2429               new_sublist->fn_field.is_const = 0;
2430               new_sublist->fn_field.is_volatile = 0;
2431               (*pp)++;
2432               break;
2433             case 'B':           /* `const' member functions.  */
2434               new_sublist->fn_field.is_const = 1;
2435               new_sublist->fn_field.is_volatile = 0;
2436               (*pp)++;
2437               break;
2438             case 'C':           /* `volatile' member function.  */
2439               new_sublist->fn_field.is_const = 0;
2440               new_sublist->fn_field.is_volatile = 1;
2441               (*pp)++;
2442               break;
2443             case 'D':           /* `const volatile' member function.  */
2444               new_sublist->fn_field.is_const = 1;
2445               new_sublist->fn_field.is_volatile = 1;
2446               (*pp)++;
2447               break;
2448             case '*':           /* File compiled with g++ version 1 --
2449                                    no info.  */
2450             case '?':
2451             case '.':
2452               break;
2453             default:
2454               complaint (&symfile_complaints,
2455                          _("const/volatile indicator missing, got '%c'"),
2456                          **pp);
2457               break;
2458             }
2459
2460           switch (*(*pp)++)
2461             {
2462             case '*':
2463               {
2464                 int nbits;
2465                 /* virtual member function, followed by index.
2466                    The sign bit is set to distinguish pointers-to-methods
2467                    from virtual function indicies.  Since the array is
2468                    in words, the quantity must be shifted left by 1
2469                    on 16 bit machine, and by 2 on 32 bit machine, forcing
2470                    the sign bit out, and usable as a valid index into
2471                    the array.  Remove the sign bit here.  */
2472                 new_sublist->fn_field.voffset =
2473                   (0x7fffffff & read_huge_number (pp, ';', &nbits, 0)) + 2;
2474                 if (nbits != 0)
2475                   return 0;
2476
2477                 STABS_CONTINUE (pp, objfile);
2478                 if (**pp == ';' || **pp == '\0')
2479                   {
2480                     /* Must be g++ version 1.  */
2481                     new_sublist->fn_field.fcontext = 0;
2482                   }
2483                 else
2484                   {
2485                     /* Figure out from whence this virtual function came.
2486                        It may belong to virtual function table of
2487                        one of its baseclasses.  */
2488                     look_ahead_type = read_type (pp, objfile);
2489                     if (**pp == ':')
2490                       {
2491                         /* g++ version 1 overloaded methods.  */
2492                       }
2493                     else
2494                       {
2495                         new_sublist->fn_field.fcontext = look_ahead_type;
2496                         if (**pp != ';')
2497                           {
2498                             return 0;
2499                           }
2500                         else
2501                           {
2502                             ++*pp;
2503                           }
2504                         look_ahead_type = NULL;
2505                       }
2506                   }
2507                 break;
2508               }
2509             case '?':
2510               /* static member function.  */
2511               {
2512                 int slen = strlen (main_fn_name);
2513
2514                 new_sublist->fn_field.voffset = VOFFSET_STATIC;
2515
2516                 /* For static member functions, we can't tell if they
2517                    are stubbed, as they are put out as functions, and not as
2518                    methods.
2519                    GCC v2 emits the fully mangled name if
2520                    dbxout.c:flag_minimal_debug is not set, so we have to
2521                    detect a fully mangled physname here and set is_stub
2522                    accordingly.  Fully mangled physnames in v2 start with
2523                    the member function name, followed by two underscores.
2524                    GCC v3 currently always emits stubbed member functions,
2525                    but with fully mangled physnames, which start with _Z.  */
2526                 if (!(strncmp (new_sublist->fn_field.physname,
2527                                main_fn_name, slen) == 0
2528                       && new_sublist->fn_field.physname[slen] == '_'
2529                       && new_sublist->fn_field.physname[slen + 1] == '_'))
2530                   {
2531                     new_sublist->fn_field.is_stub = 1;
2532                   }
2533                 break;
2534               }
2535
2536             default:
2537               /* error */
2538               complaint (&symfile_complaints,
2539                          _("member function type missing, got '%c'"),
2540                          (*pp)[-1]);
2541               /* Fall through into normal member function.  */
2542
2543             case '.':
2544               /* normal member function.  */
2545               new_sublist->fn_field.voffset = 0;
2546               new_sublist->fn_field.fcontext = 0;
2547               break;
2548             }
2549
2550           new_sublist->next = sublist;
2551           sublist = new_sublist;
2552           length++;
2553           STABS_CONTINUE (pp, objfile);
2554         }
2555       while (**pp != ';' && **pp != '\0');
2556
2557       (*pp)++;
2558       STABS_CONTINUE (pp, objfile);
2559
2560       /* Skip GCC 3.X member functions which are duplicates of the callable
2561          constructor/destructor.  */
2562       if (strcmp_iw (main_fn_name, "__base_ctor ") == 0
2563           || strcmp_iw (main_fn_name, "__base_dtor ") == 0
2564           || strcmp (main_fn_name, "__deleting_dtor") == 0)
2565         {
2566           xfree (main_fn_name);
2567         }
2568       else
2569         {
2570           int has_stub = 0;
2571           int has_destructor = 0, has_other = 0;
2572           int is_v3 = 0;
2573           struct next_fnfield *tmp_sublist;
2574
2575           /* Various versions of GCC emit various mostly-useless
2576              strings in the name field for special member functions.
2577
2578              For stub methods, we need to defer correcting the name
2579              until we are ready to unstub the method, because the current
2580              name string is used by gdb_mangle_name.  The only stub methods
2581              of concern here are GNU v2 operators; other methods have their
2582              names correct (see caveat below).
2583
2584              For non-stub methods, in GNU v3, we have a complete physname.
2585              Therefore we can safely correct the name now.  This primarily
2586              affects constructors and destructors, whose name will be
2587              __comp_ctor or __comp_dtor instead of Foo or ~Foo.  Cast
2588              operators will also have incorrect names; for instance,
2589              "operator int" will be named "operator i" (i.e. the type is
2590              mangled).
2591
2592              For non-stub methods in GNU v2, we have no easy way to
2593              know if we have a complete physname or not.  For most
2594              methods the result depends on the platform (if CPLUS_MARKER
2595              can be `$' or `.', it will use minimal debug information, or
2596              otherwise the full physname will be included).
2597
2598              Rather than dealing with this, we take a different approach.
2599              For v3 mangled names, we can use the full physname; for v2,
2600              we use cplus_demangle_opname (which is actually v2 specific),
2601              because the only interesting names are all operators - once again
2602              barring the caveat below.  Skip this process if any method in the
2603              group is a stub, to prevent our fouling up the workings of
2604              gdb_mangle_name.
2605
2606              The caveat: GCC 2.95.x (and earlier?) put constructors and
2607              destructors in the same method group.  We need to split this
2608              into two groups, because they should have different names.
2609              So for each method group we check whether it contains both
2610              routines whose physname appears to be a destructor (the physnames
2611              for and destructors are always provided, due to quirks in v2
2612              mangling) and routines whose physname does not appear to be a
2613              destructor.  If so then we break up the list into two halves.
2614              Even if the constructors and destructors aren't in the same group
2615              the destructor will still lack the leading tilde, so that also
2616              needs to be fixed.
2617
2618              So, to summarize what we expect and handle here:
2619
2620                 Given         Given          Real         Real       Action
2621              method name     physname      physname   method name
2622
2623              __opi            [none]     __opi__3Foo  operator int    opname
2624                                                                  [now or later]
2625              Foo              _._3Foo       _._3Foo      ~Foo      separate and
2626                                                                        rename
2627              operator i     _ZN3FoocviEv _ZN3FoocviEv operator int    demangle
2628              __comp_ctor  _ZN3FooC1ERKS_ _ZN3FooC1ERKS_   Foo         demangle
2629           */
2630
2631           tmp_sublist = sublist;
2632           while (tmp_sublist != NULL)
2633             {
2634               if (tmp_sublist->fn_field.is_stub)
2635                 has_stub = 1;
2636               if (tmp_sublist->fn_field.physname[0] == '_'
2637                   && tmp_sublist->fn_field.physname[1] == 'Z')
2638                 is_v3 = 1;
2639
2640               if (is_destructor_name (tmp_sublist->fn_field.physname))
2641                 has_destructor++;
2642               else
2643                 has_other++;
2644
2645               tmp_sublist = tmp_sublist->next;
2646             }
2647
2648           if (has_destructor && has_other)
2649             {
2650               struct next_fnfieldlist *destr_fnlist;
2651               struct next_fnfield *last_sublist;
2652
2653               /* Create a new fn_fieldlist for the destructors.  */
2654
2655               destr_fnlist = XCNEW (struct next_fnfieldlist);
2656               make_cleanup (xfree, destr_fnlist);
2657
2658               destr_fnlist->fn_fieldlist.name
2659                 = obconcat (&objfile->objfile_obstack, "~",
2660                             new_fnlist->fn_fieldlist.name, (char *) NULL);
2661
2662               destr_fnlist->fn_fieldlist.fn_fields =
2663                 XOBNEWVEC (&objfile->objfile_obstack,
2664                            struct fn_field, has_destructor);
2665               memset (destr_fnlist->fn_fieldlist.fn_fields, 0,
2666                   sizeof (struct fn_field) * has_destructor);
2667               tmp_sublist = sublist;
2668               last_sublist = NULL;
2669               i = 0;
2670               while (tmp_sublist != NULL)
2671                 {
2672                   if (!is_destructor_name (tmp_sublist->fn_field.physname))
2673                     {
2674                       tmp_sublist = tmp_sublist->next;
2675                       continue;
2676                     }
2677
2678                   destr_fnlist->fn_fieldlist.fn_fields[i++]
2679                     = tmp_sublist->fn_field;
2680                   if (last_sublist)
2681                     last_sublist->next = tmp_sublist->next;
2682                   else
2683                     sublist = tmp_sublist->next;
2684                   last_sublist = tmp_sublist;
2685                   tmp_sublist = tmp_sublist->next;
2686                 }
2687
2688               destr_fnlist->fn_fieldlist.length = has_destructor;
2689               destr_fnlist->next = fip->fnlist;
2690               fip->fnlist = destr_fnlist;
2691               nfn_fields++;
2692               length -= has_destructor;
2693             }
2694           else if (is_v3)
2695             {
2696               /* v3 mangling prevents the use of abbreviated physnames,
2697                  so we can do this here.  There are stubbed methods in v3
2698                  only:
2699                  - in -gstabs instead of -gstabs+
2700                  - or for static methods, which are output as a function type
2701                    instead of a method type.  */
2702               char *new_method_name =
2703                 stabs_method_name_from_physname (sublist->fn_field.physname);
2704
2705               if (new_method_name != NULL
2706                   && strcmp (new_method_name,
2707                              new_fnlist->fn_fieldlist.name) != 0)
2708                 {
2709                   new_fnlist->fn_fieldlist.name = new_method_name;
2710                   xfree (main_fn_name);
2711                 }
2712               else
2713                 xfree (new_method_name);
2714             }
2715           else if (has_destructor && new_fnlist->fn_fieldlist.name[0] != '~')
2716             {
2717               new_fnlist->fn_fieldlist.name =
2718                 obconcat (&objfile->objfile_obstack,
2719                           "~", main_fn_name, (char *)NULL);
2720               xfree (main_fn_name);
2721             }
2722           else if (!has_stub)
2723             {
2724               char dem_opname[256];
2725               int ret;
2726
2727               ret = cplus_demangle_opname (new_fnlist->fn_fieldlist.name,
2728                                               dem_opname, DMGL_ANSI);
2729               if (!ret)
2730                 ret = cplus_demangle_opname (new_fnlist->fn_fieldlist.name,
2731                                              dem_opname, 0);
2732               if (ret)
2733                 new_fnlist->fn_fieldlist.name
2734                   = ((const char *)
2735                      obstack_copy0 (&objfile->objfile_obstack, dem_opname,
2736                                     strlen (dem_opname)));
2737               xfree (main_fn_name);
2738             }
2739
2740           new_fnlist->fn_fieldlist.fn_fields = (struct fn_field *)
2741             obstack_alloc (&objfile->objfile_obstack,
2742                            sizeof (struct fn_field) * length);
2743           memset (new_fnlist->fn_fieldlist.fn_fields, 0,
2744                   sizeof (struct fn_field) * length);
2745           for (i = length; (i--, sublist); sublist = sublist->next)
2746             {
2747               new_fnlist->fn_fieldlist.fn_fields[i] = sublist->fn_field;
2748             }
2749
2750           new_fnlist->fn_fieldlist.length = length;
2751           new_fnlist->next = fip->fnlist;
2752           fip->fnlist = new_fnlist;
2753           nfn_fields++;
2754         }
2755     }
2756
2757   if (nfn_fields)
2758     {
2759       ALLOCATE_CPLUS_STRUCT_TYPE (type);
2760       TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
2761         TYPE_ALLOC (type, sizeof (struct fn_fieldlist) * nfn_fields);
2762       memset (TYPE_FN_FIELDLISTS (type), 0,
2763               sizeof (struct fn_fieldlist) * nfn_fields);
2764       TYPE_NFN_FIELDS (type) = nfn_fields;
2765     }
2766
2767   return 1;
2768 }
2769
2770 /* Special GNU C++ name.
2771
2772    Returns 1 for success, 0 for failure.  "failure" means that we can't
2773    keep parsing and it's time for error_type().  */
2774
2775 static int
2776 read_cpp_abbrev (struct field_info *fip, const char **pp, struct type *type,
2777                  struct objfile *objfile)
2778 {
2779   const char *p;
2780   const char *name;
2781   char cpp_abbrev;
2782   struct type *context;
2783
2784   p = *pp;
2785   if (*++p == 'v')
2786     {
2787       name = NULL;
2788       cpp_abbrev = *++p;
2789
2790       *pp = p + 1;
2791
2792       /* At this point, *pp points to something like "22:23=*22...",
2793          where the type number before the ':' is the "context" and
2794          everything after is a regular type definition.  Lookup the
2795          type, find it's name, and construct the field name.  */
2796
2797       context = read_type (pp, objfile);
2798
2799       switch (cpp_abbrev)
2800         {
2801         case 'f':               /* $vf -- a virtual function table pointer */
2802           name = type_name_no_tag (context);
2803           if (name == NULL)
2804             {
2805               name = "";
2806             }
2807           fip->list->field.name = obconcat (&objfile->objfile_obstack,
2808                                             vptr_name, name, (char *) NULL);
2809           break;
2810
2811         case 'b':               /* $vb -- a virtual bsomethingorother */
2812           name = type_name_no_tag (context);
2813           if (name == NULL)
2814             {
2815               complaint (&symfile_complaints,
2816                          _("C++ abbreviated type name "
2817                            "unknown at symtab pos %d"),
2818                          symnum);
2819               name = "FOO";
2820             }
2821           fip->list->field.name = obconcat (&objfile->objfile_obstack, vb_name,
2822                                             name, (char *) NULL);
2823           break;
2824
2825         default:
2826           invalid_cpp_abbrev_complaint (*pp);
2827           fip->list->field.name = obconcat (&objfile->objfile_obstack,
2828                                             "INVALID_CPLUSPLUS_ABBREV",
2829                                             (char *) NULL);
2830           break;
2831         }
2832
2833       /* At this point, *pp points to the ':'.  Skip it and read the
2834          field type.  */
2835
2836       p = ++(*pp);
2837       if (p[-1] != ':')
2838         {
2839           invalid_cpp_abbrev_complaint (*pp);
2840           return 0;
2841         }
2842       fip->list->field.type = read_type (pp, objfile);
2843       if (**pp == ',')
2844         (*pp)++;                /* Skip the comma.  */
2845       else
2846         return 0;
2847
2848       {
2849         int nbits;
2850
2851         SET_FIELD_BITPOS (fip->list->field,
2852                           read_huge_number (pp, ';', &nbits, 0));
2853         if (nbits != 0)
2854           return 0;
2855       }
2856       /* This field is unpacked.  */
2857       FIELD_BITSIZE (fip->list->field) = 0;
2858       fip->list->visibility = VISIBILITY_PRIVATE;
2859     }
2860   else
2861     {
2862       invalid_cpp_abbrev_complaint (*pp);
2863       /* We have no idea what syntax an unrecognized abbrev would have, so
2864          better return 0.  If we returned 1, we would need to at least advance
2865          *pp to avoid an infinite loop.  */
2866       return 0;
2867     }
2868   return 1;
2869 }
2870
2871 static void
2872 read_one_struct_field (struct field_info *fip, const char **pp, const char *p,
2873                        struct type *type, struct objfile *objfile)
2874 {
2875   struct gdbarch *gdbarch = get_objfile_arch (objfile);
2876
2877   fip->list->field.name
2878     = (const char *) obstack_copy0 (&objfile->objfile_obstack, *pp, p - *pp);
2879   *pp = p + 1;
2880
2881   /* This means we have a visibility for a field coming.  */
2882   if (**pp == '/')
2883     {
2884       (*pp)++;
2885       fip->list->visibility = *(*pp)++;
2886     }
2887   else
2888     {
2889       /* normal dbx-style format, no explicit visibility */
2890       fip->list->visibility = VISIBILITY_PUBLIC;
2891     }
2892
2893   fip->list->field.type = read_type (pp, objfile);
2894   if (**pp == ':')
2895     {
2896       p = ++(*pp);
2897 #if 0
2898       /* Possible future hook for nested types.  */
2899       if (**pp == '!')
2900         {
2901           fip->list->field.bitpos = (long) -2;  /* nested type */
2902           p = ++(*pp);
2903         }
2904       else
2905         ...;
2906 #endif
2907       while (*p != ';')
2908         {
2909           p++;
2910         }
2911       /* Static class member.  */
2912       SET_FIELD_PHYSNAME (fip->list->field, savestring (*pp, p - *pp));
2913       *pp = p + 1;
2914       return;
2915     }
2916   else if (**pp != ',')
2917     {
2918       /* Bad structure-type format.  */
2919       stabs_general_complaint ("bad structure-type format");
2920       return;
2921     }
2922
2923   (*pp)++;                      /* Skip the comma.  */
2924
2925   {
2926     int nbits;
2927
2928     SET_FIELD_BITPOS (fip->list->field,
2929                       read_huge_number (pp, ',', &nbits, 0));
2930     if (nbits != 0)
2931       {
2932         stabs_general_complaint ("bad structure-type format");
2933         return;
2934       }
2935     FIELD_BITSIZE (fip->list->field) = read_huge_number (pp, ';', &nbits, 0);
2936     if (nbits != 0)
2937       {
2938         stabs_general_complaint ("bad structure-type format");
2939         return;
2940       }
2941   }
2942
2943   if (FIELD_BITPOS (fip->list->field) == 0
2944       && FIELD_BITSIZE (fip->list->field) == 0)
2945     {
2946       /* This can happen in two cases: (1) at least for gcc 2.4.5 or so,
2947          it is a field which has been optimized out.  The correct stab for
2948          this case is to use VISIBILITY_IGNORE, but that is a recent
2949          invention.  (2) It is a 0-size array.  For example
2950          union { int num; char str[0]; } foo.  Printing _("<no value>" for
2951          str in "p foo" is OK, since foo.str (and thus foo.str[3])
2952          will continue to work, and a 0-size array as a whole doesn't
2953          have any contents to print.
2954
2955          I suspect this probably could also happen with gcc -gstabs (not
2956          -gstabs+) for static fields, and perhaps other C++ extensions.
2957          Hopefully few people use -gstabs with gdb, since it is intended
2958          for dbx compatibility.  */
2959
2960       /* Ignore this field.  */
2961       fip->list->visibility = VISIBILITY_IGNORE;
2962     }
2963   else
2964     {
2965       /* Detect an unpacked field and mark it as such.
2966          dbx gives a bit size for all fields.
2967          Note that forward refs cannot be packed,
2968          and treat enums as if they had the width of ints.  */
2969
2970       struct type *field_type = check_typedef (FIELD_TYPE (fip->list->field));
2971
2972       if (TYPE_CODE (field_type) != TYPE_CODE_INT
2973           && TYPE_CODE (field_type) != TYPE_CODE_RANGE
2974           && TYPE_CODE (field_type) != TYPE_CODE_BOOL
2975           && TYPE_CODE (field_type) != TYPE_CODE_ENUM)
2976         {
2977           FIELD_BITSIZE (fip->list->field) = 0;
2978         }
2979       if ((FIELD_BITSIZE (fip->list->field)
2980            == TARGET_CHAR_BIT * TYPE_LENGTH (field_type)
2981            || (TYPE_CODE (field_type) == TYPE_CODE_ENUM
2982                && FIELD_BITSIZE (fip->list->field)
2983                   == gdbarch_int_bit (gdbarch))
2984           )
2985           &&
2986           FIELD_BITPOS (fip->list->field) % 8 == 0)
2987         {
2988           FIELD_BITSIZE (fip->list->field) = 0;
2989         }
2990     }
2991 }
2992
2993
2994 /* Read struct or class data fields.  They have the form:
2995
2996    NAME : [VISIBILITY] TYPENUM , BITPOS , BITSIZE ;
2997
2998    At the end, we see a semicolon instead of a field.
2999
3000    In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
3001    a static field.
3002
3003    The optional VISIBILITY is one of:
3004
3005    '/0' (VISIBILITY_PRIVATE)
3006    '/1' (VISIBILITY_PROTECTED)
3007    '/2' (VISIBILITY_PUBLIC)
3008    '/9' (VISIBILITY_IGNORE)
3009
3010    or nothing, for C style fields with public visibility.
3011
3012    Returns 1 for success, 0 for failure.  */
3013
3014 static int
3015 read_struct_fields (struct field_info *fip, const char **pp, struct type *type,
3016                     struct objfile *objfile)
3017 {
3018   const char *p;
3019   struct nextfield *newobj;
3020
3021   /* We better set p right now, in case there are no fields at all...    */
3022
3023   p = *pp;
3024
3025   /* Read each data member type until we find the terminating ';' at the end of
3026      the data member list, or break for some other reason such as finding the
3027      start of the member function list.  */
3028   /* Stab string for structure/union does not end with two ';' in
3029      SUN C compiler 5.3 i.e. F6U2, hence check for end of string.  */
3030
3031   while (**pp != ';' && **pp != '\0')
3032     {
3033       STABS_CONTINUE (pp, objfile);
3034       /* Get space to record the next field's data.  */
3035       newobj = XCNEW (struct nextfield);
3036       make_cleanup (xfree, newobj);
3037
3038       newobj->next = fip->list;
3039       fip->list = newobj;
3040
3041       /* Get the field name.  */
3042       p = *pp;
3043
3044       /* If is starts with CPLUS_MARKER it is a special abbreviation,
3045          unless the CPLUS_MARKER is followed by an underscore, in
3046          which case it is just the name of an anonymous type, which we
3047          should handle like any other type name.  */
3048
3049       if (is_cplus_marker (p[0]) && p[1] != '_')
3050         {
3051           if (!read_cpp_abbrev (fip, pp, type, objfile))
3052             return 0;
3053           continue;
3054         }
3055
3056       /* Look for the ':' that separates the field name from the field
3057          values.  Data members are delimited by a single ':', while member
3058          functions are delimited by a pair of ':'s.  When we hit the member
3059          functions (if any), terminate scan loop and return.  */
3060
3061       while (*p != ':' && *p != '\0')
3062         {
3063           p++;
3064         }
3065       if (*p == '\0')
3066         return 0;
3067
3068       /* Check to see if we have hit the member functions yet.  */
3069       if (p[1] == ':')
3070         {
3071           break;
3072         }
3073       read_one_struct_field (fip, pp, p, type, objfile);
3074     }
3075   if (p[0] == ':' && p[1] == ':')
3076     {
3077       /* (the deleted) chill the list of fields: the last entry (at
3078          the head) is a partially constructed entry which we now
3079          scrub.  */
3080       fip->list = fip->list->next;
3081     }
3082   return 1;
3083 }
3084 /* *INDENT-OFF* */
3085 /* The stabs for C++ derived classes contain baseclass information which
3086    is marked by a '!' character after the total size.  This function is
3087    called when we encounter the baseclass marker, and slurps up all the
3088    baseclass information.
3089
3090    Immediately following the '!' marker is the number of base classes that
3091    the class is derived from, followed by information for each base class.
3092    For each base class, there are two visibility specifiers, a bit offset
3093    to the base class information within the derived class, a reference to
3094    the type for the base class, and a terminating semicolon.
3095
3096    A typical example, with two base classes, would be "!2,020,19;0264,21;".
3097                                                        ^^ ^ ^ ^  ^ ^  ^
3098         Baseclass information marker __________________|| | | |  | |  |
3099         Number of baseclasses __________________________| | | |  | |  |
3100         Visibility specifiers (2) ________________________| | |  | |  |
3101         Offset in bits from start of class _________________| |  | |  |
3102         Type number for base class ___________________________|  | |  |
3103         Visibility specifiers (2) _______________________________| |  |
3104         Offset in bits from start of class ________________________|  |
3105         Type number of base class ____________________________________|
3106
3107   Return 1 for success, 0 for (error-type-inducing) failure.  */
3108 /* *INDENT-ON* */
3109
3110
3111
3112 static int
3113 read_baseclasses (struct field_info *fip, const char **pp, struct type *type,
3114                   struct objfile *objfile)
3115 {
3116   int i;
3117   struct nextfield *newobj;
3118
3119   if (**pp != '!')
3120     {
3121       return 1;
3122     }
3123   else
3124     {
3125       /* Skip the '!' baseclass information marker.  */
3126       (*pp)++;
3127     }
3128
3129   ALLOCATE_CPLUS_STRUCT_TYPE (type);
3130   {
3131     int nbits;
3132
3133     TYPE_N_BASECLASSES (type) = read_huge_number (pp, ',', &nbits, 0);
3134     if (nbits != 0)
3135       return 0;
3136   }
3137
3138 #if 0
3139   /* Some stupid compilers have trouble with the following, so break
3140      it up into simpler expressions.  */
3141   TYPE_FIELD_VIRTUAL_BITS (type) = (B_TYPE *)
3142     TYPE_ALLOC (type, B_BYTES (TYPE_N_BASECLASSES (type)));
3143 #else
3144   {
3145     int num_bytes = B_BYTES (TYPE_N_BASECLASSES (type));
3146     char *pointer;
3147
3148     pointer = (char *) TYPE_ALLOC (type, num_bytes);
3149     TYPE_FIELD_VIRTUAL_BITS (type) = (B_TYPE *) pointer;
3150   }
3151 #endif /* 0 */
3152
3153   B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), TYPE_N_BASECLASSES (type));
3154
3155   for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
3156     {
3157       newobj = XCNEW (struct nextfield);
3158       make_cleanup (xfree, newobj);
3159
3160       newobj->next = fip->list;
3161       fip->list = newobj;
3162       FIELD_BITSIZE (newobj->field) = 0;        /* This should be an unpacked
3163                                            field!  */
3164
3165       STABS_CONTINUE (pp, objfile);
3166       switch (**pp)
3167         {
3168         case '0':
3169           /* Nothing to do.  */
3170           break;
3171         case '1':
3172           SET_TYPE_FIELD_VIRTUAL (type, i);
3173           break;
3174         default:
3175           /* Unknown character.  Complain and treat it as non-virtual.  */
3176           {
3177             complaint (&symfile_complaints,
3178                        _("Unknown virtual character `%c' for baseclass"),
3179                        **pp);
3180           }
3181         }
3182       ++(*pp);
3183
3184       newobj->visibility = *(*pp)++;
3185       switch (newobj->visibility)
3186         {
3187         case VISIBILITY_PRIVATE:
3188         case VISIBILITY_PROTECTED:
3189         case VISIBILITY_PUBLIC:
3190           break;
3191         default:
3192           /* Bad visibility format.  Complain and treat it as
3193              public.  */
3194           {
3195             complaint (&symfile_complaints,
3196                        _("Unknown visibility `%c' for baseclass"),
3197                        newobj->visibility);
3198             newobj->visibility = VISIBILITY_PUBLIC;
3199           }
3200         }
3201
3202       {
3203         int nbits;
3204
3205         /* The remaining value is the bit offset of the portion of the object
3206            corresponding to this baseclass.  Always zero in the absence of
3207            multiple inheritance.  */
3208
3209         SET_FIELD_BITPOS (newobj->field, read_huge_number (pp, ',', &nbits, 0));
3210         if (nbits != 0)
3211           return 0;
3212       }
3213
3214       /* The last piece of baseclass information is the type of the
3215          base class.  Read it, and remember it's type name as this
3216          field's name.  */
3217
3218       newobj->field.type = read_type (pp, objfile);
3219       newobj->field.name = type_name_no_tag (newobj->field.type);
3220
3221       /* Skip trailing ';' and bump count of number of fields seen.  */
3222       if (**pp == ';')
3223         (*pp)++;
3224       else
3225         return 0;
3226     }
3227   return 1;
3228 }
3229
3230 /* The tail end of stabs for C++ classes that contain a virtual function
3231    pointer contains a tilde, a %, and a type number.
3232    The type number refers to the base class (possibly this class itself) which
3233    contains the vtable pointer for the current class.
3234
3235    This function is called when we have parsed all the method declarations,
3236    so we can look for the vptr base class info.  */
3237
3238 static int
3239 read_tilde_fields (struct field_info *fip, const char **pp, struct type *type,
3240                    struct objfile *objfile)
3241 {
3242   const char *p;
3243
3244   STABS_CONTINUE (pp, objfile);
3245
3246   /* If we are positioned at a ';', then skip it.  */
3247   if (**pp == ';')
3248     {
3249       (*pp)++;
3250     }
3251
3252   if (**pp == '~')
3253     {
3254       (*pp)++;
3255
3256       if (**pp == '=' || **pp == '+' || **pp == '-')
3257         {
3258           /* Obsolete flags that used to indicate the presence
3259              of constructors and/or destructors.  */
3260           (*pp)++;
3261         }
3262
3263       /* Read either a '%' or the final ';'.  */
3264       if (*(*pp)++ == '%')
3265         {
3266           /* The next number is the type number of the base class
3267              (possibly our own class) which supplies the vtable for
3268              this class.  Parse it out, and search that class to find
3269              its vtable pointer, and install those into TYPE_VPTR_BASETYPE
3270              and TYPE_VPTR_FIELDNO.  */
3271
3272           struct type *t;
3273           int i;
3274
3275           t = read_type (pp, objfile);
3276           p = (*pp)++;
3277           while (*p != '\0' && *p != ';')
3278             {
3279               p++;
3280             }
3281           if (*p == '\0')
3282             {
3283               /* Premature end of symbol.  */
3284               return 0;
3285             }
3286
3287           set_type_vptr_basetype (type, t);
3288           if (type == t)        /* Our own class provides vtbl ptr.  */
3289             {
3290               for (i = TYPE_NFIELDS (t) - 1;
3291                    i >= TYPE_N_BASECLASSES (t);
3292                    --i)
3293                 {
3294                   const char *name = TYPE_FIELD_NAME (t, i);
3295
3296                   if (!strncmp (name, vptr_name, sizeof (vptr_name) - 2)
3297                       && is_cplus_marker (name[sizeof (vptr_name) - 2]))
3298                     {
3299                       set_type_vptr_fieldno (type, i);
3300                       goto gotit;
3301                     }
3302                 }
3303               /* Virtual function table field not found.  */
3304               complaint (&symfile_complaints,
3305                          _("virtual function table pointer "
3306                            "not found when defining class `%s'"),
3307                          TYPE_NAME (type));
3308               return 0;
3309             }
3310           else
3311             {
3312               set_type_vptr_fieldno (type, TYPE_VPTR_FIELDNO (t));
3313             }
3314
3315         gotit:
3316           *pp = p + 1;
3317         }
3318     }
3319   return 1;
3320 }
3321
3322 static int
3323 attach_fn_fields_to_type (struct field_info *fip, struct type *type)
3324 {
3325   int n;
3326
3327   for (n = TYPE_NFN_FIELDS (type);
3328        fip->fnlist != NULL;
3329        fip->fnlist = fip->fnlist->next)
3330     {
3331       --n;                      /* Circumvent Sun3 compiler bug.  */
3332       TYPE_FN_FIELDLISTS (type)[n] = fip->fnlist->fn_fieldlist;
3333     }
3334   return 1;
3335 }
3336
3337 /* Create the vector of fields, and record how big it is.
3338    We need this info to record proper virtual function table information
3339    for this class's virtual functions.  */
3340
3341 static int
3342 attach_fields_to_type (struct field_info *fip, struct type *type,
3343                        struct objfile *objfile)
3344 {
3345   int nfields = 0;
3346   int non_public_fields = 0;
3347   struct nextfield *scan;
3348
3349   /* Count up the number of fields that we have, as well as taking note of
3350      whether or not there are any non-public fields, which requires us to
3351      allocate and build the private_field_bits and protected_field_bits
3352      bitfields.  */
3353
3354   for (scan = fip->list; scan != NULL; scan = scan->next)
3355     {
3356       nfields++;
3357       if (scan->visibility != VISIBILITY_PUBLIC)
3358         {
3359           non_public_fields++;
3360         }
3361     }
3362
3363   /* Now we know how many fields there are, and whether or not there are any
3364      non-public fields.  Record the field count, allocate space for the
3365      array of fields, and create blank visibility bitfields if necessary.  */
3366
3367   TYPE_NFIELDS (type) = nfields;
3368   TYPE_FIELDS (type) = (struct field *)
3369     TYPE_ALLOC (type, sizeof (struct field) * nfields);
3370   memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nfields);
3371
3372   if (non_public_fields)
3373     {
3374       ALLOCATE_CPLUS_STRUCT_TYPE (type);
3375
3376       TYPE_FIELD_PRIVATE_BITS (type) =
3377         (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
3378       B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
3379
3380       TYPE_FIELD_PROTECTED_BITS (type) =
3381         (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
3382       B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
3383
3384       TYPE_FIELD_IGNORE_BITS (type) =
3385         (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
3386       B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
3387     }
3388
3389   /* Copy the saved-up fields into the field vector.  Start from the
3390      head of the list, adding to the tail of the field array, so that
3391      they end up in the same order in the array in which they were
3392      added to the list.  */
3393
3394   while (nfields-- > 0)
3395     {
3396       TYPE_FIELD (type, nfields) = fip->list->field;
3397       switch (fip->list->visibility)
3398         {
3399         case VISIBILITY_PRIVATE:
3400           SET_TYPE_FIELD_PRIVATE (type, nfields);
3401           break;
3402
3403         case VISIBILITY_PROTECTED:
3404           SET_TYPE_FIELD_PROTECTED (type, nfields);
3405           break;
3406
3407         case VISIBILITY_IGNORE:
3408           SET_TYPE_FIELD_IGNORE (type, nfields);
3409           break;
3410
3411         case VISIBILITY_PUBLIC:
3412           break;
3413
3414         default:
3415           /* Unknown visibility.  Complain and treat it as public.  */
3416           {
3417             complaint (&symfile_complaints,
3418                        _("Unknown visibility `%c' for field"),
3419                        fip->list->visibility);
3420           }
3421           break;
3422         }
3423       fip->list = fip->list->next;
3424     }
3425   return 1;
3426 }
3427
3428
3429 /* Complain that the compiler has emitted more than one definition for the
3430    structure type TYPE.  */
3431 static void
3432 complain_about_struct_wipeout (struct type *type)
3433 {
3434   const char *name = "";
3435   const char *kind = "";
3436
3437   if (TYPE_TAG_NAME (type))
3438     {
3439       name = TYPE_TAG_NAME (type);
3440       switch (TYPE_CODE (type))
3441         {
3442         case TYPE_CODE_STRUCT: kind = "struct "; break;
3443         case TYPE_CODE_UNION:  kind = "union ";  break;
3444         case TYPE_CODE_ENUM:   kind = "enum ";   break;
3445         default: kind = "";
3446         }
3447     }
3448   else if (TYPE_NAME (type))
3449     {
3450       name = TYPE_NAME (type);
3451       kind = "";
3452     }
3453   else
3454     {
3455       name = "<unknown>";
3456       kind = "";
3457     }
3458
3459   complaint (&symfile_complaints,
3460              _("struct/union type gets multiply defined: %s%s"), kind, name);
3461 }
3462
3463 /* Set the length for all variants of a same main_type, which are
3464    connected in the closed chain.
3465
3466    This is something that needs to be done when a type is defined *after*
3467    some cross references to this type have already been read.  Consider
3468    for instance the following scenario where we have the following two
3469    stabs entries:
3470
3471         .stabs  "t:p(0,21)=*(0,22)=k(0,23)=xsdummy:",160,0,28,-24
3472         .stabs  "dummy:T(0,23)=s16x:(0,1),0,3[...]"
3473
3474    A stubbed version of type dummy is created while processing the first
3475    stabs entry.  The length of that type is initially set to zero, since
3476    it is unknown at this point.  Also, a "constant" variation of type
3477    "dummy" is created as well (this is the "(0,22)=k(0,23)" section of
3478    the stabs line).
3479
3480    The second stabs entry allows us to replace the stubbed definition
3481    with the real definition.  However, we still need to adjust the length
3482    of the "constant" variation of that type, as its length was left
3483    untouched during the main type replacement...  */
3484
3485 static void
3486 set_length_in_type_chain (struct type *type)
3487 {
3488   struct type *ntype = TYPE_CHAIN (type);
3489
3490   while (ntype != type)
3491     {
3492       if (TYPE_LENGTH(ntype) == 0)
3493         TYPE_LENGTH (ntype) = TYPE_LENGTH (type);
3494       else
3495         complain_about_struct_wipeout (ntype);
3496       ntype = TYPE_CHAIN (ntype);
3497     }
3498 }
3499
3500 /* Read the description of a structure (or union type) and return an object
3501    describing the type.
3502
3503    PP points to a character pointer that points to the next unconsumed token
3504    in the stabs string.  For example, given stabs "A:T4=s4a:1,0,32;;",
3505    *PP will point to "4a:1,0,32;;".
3506
3507    TYPE points to an incomplete type that needs to be filled in.
3508
3509    OBJFILE points to the current objfile from which the stabs information is
3510    being read.  (Note that it is redundant in that TYPE also contains a pointer
3511    to this same objfile, so it might be a good idea to eliminate it.  FIXME).
3512  */
3513
3514 static struct type *
3515 read_struct_type (const char **pp, struct type *type, enum type_code type_code,
3516                   struct objfile *objfile)
3517 {
3518   struct cleanup *back_to;
3519   struct field_info fi;
3520
3521   fi.list = NULL;
3522   fi.fnlist = NULL;
3523
3524   /* When describing struct/union/class types in stabs, G++ always drops
3525      all qualifications from the name.  So if you've got:
3526        struct A { ... struct B { ... }; ... };
3527      then G++ will emit stabs for `struct A::B' that call it simply
3528      `struct B'.  Obviously, if you've got a real top-level definition for
3529      `struct B', or other nested definitions, this is going to cause
3530      problems.
3531
3532      Obviously, GDB can't fix this by itself, but it can at least avoid
3533      scribbling on existing structure type objects when new definitions
3534      appear.  */
3535   if (! (TYPE_CODE (type) == TYPE_CODE_UNDEF
3536          || TYPE_STUB (type)))
3537     {
3538       complain_about_struct_wipeout (type);
3539
3540       /* It's probably best to return the type unchanged.  */
3541       return type;
3542     }
3543
3544   back_to = make_cleanup (null_cleanup, 0);
3545
3546   INIT_CPLUS_SPECIFIC (type);
3547   TYPE_CODE (type) = type_code;
3548   TYPE_STUB (type) = 0;
3549
3550   /* First comes the total size in bytes.  */
3551
3552   {
3553     int nbits;
3554
3555     TYPE_LENGTH (type) = read_huge_number (pp, 0, &nbits, 0);
3556     if (nbits != 0)
3557       {
3558         do_cleanups (back_to);
3559         return error_type (pp, objfile);
3560       }
3561     set_length_in_type_chain (type);
3562   }
3563
3564   /* Now read the baseclasses, if any, read the regular C struct or C++
3565      class member fields, attach the fields to the type, read the C++
3566      member functions, attach them to the type, and then read any tilde
3567      field (baseclass specifier for the class holding the main vtable).  */
3568
3569   if (!read_baseclasses (&fi, pp, type, objfile)
3570       || !read_struct_fields (&fi, pp, type, objfile)
3571       || !attach_fields_to_type (&fi, type, objfile)
3572       || !read_member_functions (&fi, pp, type, objfile)
3573       || !attach_fn_fields_to_type (&fi, type)
3574       || !read_tilde_fields (&fi, pp, type, objfile))
3575     {
3576       type = error_type (pp, objfile);
3577     }
3578
3579   do_cleanups (back_to);
3580   return (type);
3581 }
3582
3583 /* Read a definition of an array type,
3584    and create and return a suitable type object.
3585    Also creates a range type which represents the bounds of that
3586    array.  */
3587
3588 static struct type *
3589 read_array_type (const char **pp, struct type *type,
3590                  struct objfile *objfile)
3591 {
3592   struct type *index_type, *element_type, *range_type;
3593   int lower, upper;
3594   int adjustable = 0;
3595   int nbits;
3596
3597   /* Format of an array type:
3598      "ar<index type>;lower;upper;<array_contents_type>".
3599      OS9000: "arlower,upper;<array_contents_type>".
3600
3601      Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
3602      for these, produce a type like float[][].  */
3603
3604     {
3605       index_type = read_type (pp, objfile);
3606       if (**pp != ';')
3607         /* Improper format of array type decl.  */
3608         return error_type (pp, objfile);
3609       ++*pp;
3610     }
3611
3612   if (!(**pp >= '0' && **pp <= '9') && **pp != '-')
3613     {
3614       (*pp)++;
3615       adjustable = 1;
3616     }
3617   lower = read_huge_number (pp, ';', &nbits, 0);
3618
3619   if (nbits != 0)
3620     return error_type (pp, objfile);
3621
3622   if (!(**pp >= '0' && **pp <= '9') && **pp != '-')
3623     {
3624       (*pp)++;
3625       adjustable = 1;
3626     }
3627   upper = read_huge_number (pp, ';', &nbits, 0);
3628   if (nbits != 0)
3629     return error_type (pp, objfile);
3630
3631   element_type = read_type (pp, objfile);
3632
3633   if (adjustable)
3634     {
3635       lower = 0;
3636       upper = -1;
3637     }
3638
3639   range_type =
3640     create_static_range_type ((struct type *) NULL, index_type, lower, upper);
3641   type = create_array_type (type, element_type, range_type);
3642
3643   return type;
3644 }
3645
3646
3647 /* Read a definition of an enumeration type,
3648    and create and return a suitable type object.
3649    Also defines the symbols that represent the values of the type.  */
3650
3651 static struct type *
3652 read_enum_type (const char **pp, struct type *type,
3653                 struct objfile *objfile)
3654 {
3655   struct gdbarch *gdbarch = get_objfile_arch (objfile);
3656   const char *p;
3657   char *name;
3658   long n;
3659   struct symbol *sym;
3660   int nsyms = 0;
3661   struct pending **symlist;
3662   struct pending *osyms, *syms;
3663   int o_nsyms;
3664   int nbits;
3665   int unsigned_enum = 1;
3666
3667 #if 0
3668   /* FIXME!  The stabs produced by Sun CC merrily define things that ought
3669      to be file-scope, between N_FN entries, using N_LSYM.  What's a mother
3670      to do?  For now, force all enum values to file scope.  */
3671   if (within_function)
3672     symlist = &local_symbols;
3673   else
3674 #endif
3675     symlist = &file_symbols;
3676   osyms = *symlist;
3677   o_nsyms = osyms ? osyms->nsyms : 0;
3678
3679   /* The aix4 compiler emits an extra field before the enum members;
3680      my guess is it's a type of some sort.  Just ignore it.  */
3681   if (**pp == '-')
3682     {
3683       /* Skip over the type.  */
3684       while (**pp != ':')
3685         (*pp)++;
3686
3687       /* Skip over the colon.  */
3688       (*pp)++;
3689     }
3690
3691   /* Read the value-names and their values.
3692      The input syntax is NAME:VALUE,NAME:VALUE, and so on.
3693      A semicolon or comma instead of a NAME means the end.  */
3694   while (**pp && **pp != ';' && **pp != ',')
3695     {
3696       STABS_CONTINUE (pp, objfile);
3697       p = *pp;
3698       while (*p != ':')
3699         p++;
3700       name = (char *) obstack_copy0 (&objfile->objfile_obstack, *pp, p - *pp);
3701       *pp = p + 1;
3702       n = read_huge_number (pp, ',', &nbits, 0);
3703       if (nbits != 0)
3704         return error_type (pp, objfile);
3705
3706       sym = allocate_symbol (objfile);
3707       SYMBOL_SET_LINKAGE_NAME (sym, name);
3708       SYMBOL_SET_LANGUAGE (sym, current_subfile->language,
3709                            &objfile->objfile_obstack);
3710       SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
3711       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
3712       SYMBOL_VALUE (sym) = n;
3713       if (n < 0)
3714         unsigned_enum = 0;
3715       add_symbol_to_list (sym, symlist);
3716       nsyms++;
3717     }
3718
3719   if (**pp == ';')
3720     (*pp)++;                    /* Skip the semicolon.  */
3721
3722   /* Now fill in the fields of the type-structure.  */
3723
3724   TYPE_LENGTH (type) = gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT;
3725   set_length_in_type_chain (type);
3726   TYPE_CODE (type) = TYPE_CODE_ENUM;
3727   TYPE_STUB (type) = 0;
3728   if (unsigned_enum)
3729     TYPE_UNSIGNED (type) = 1;
3730   TYPE_NFIELDS (type) = nsyms;
3731   TYPE_FIELDS (type) = (struct field *)
3732     TYPE_ALLOC (type, sizeof (struct field) * nsyms);
3733   memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nsyms);
3734
3735   /* Find the symbols for the values and put them into the type.
3736      The symbols can be found in the symlist that we put them on
3737      to cause them to be defined.  osyms contains the old value
3738      of that symlist; everything up to there was defined by us.  */
3739   /* Note that we preserve the order of the enum constants, so
3740      that in something like "enum {FOO, LAST_THING=FOO}" we print
3741      FOO, not LAST_THING.  */
3742
3743   for (syms = *symlist, n = nsyms - 1; syms; syms = syms->next)
3744     {
3745       int last = syms == osyms ? o_nsyms : 0;
3746       int j = syms->nsyms;
3747
3748       for (; --j >= last; --n)
3749         {
3750           struct symbol *xsym = syms->symbol[j];
3751
3752           SYMBOL_TYPE (xsym) = type;
3753           TYPE_FIELD_NAME (type, n) = SYMBOL_LINKAGE_NAME (xsym);
3754           SET_FIELD_ENUMVAL (TYPE_FIELD (type, n), SYMBOL_VALUE (xsym));
3755           TYPE_FIELD_BITSIZE (type, n) = 0;
3756         }
3757       if (syms == osyms)
3758         break;
3759     }
3760
3761   return type;
3762 }
3763
3764 /* Sun's ACC uses a somewhat saner method for specifying the builtin
3765    typedefs in every file (for int, long, etc):
3766
3767    type = b <signed> <width> <format type>; <offset>; <nbits>
3768    signed = u or s.
3769    optional format type = c or b for char or boolean.
3770    offset = offset from high order bit to start bit of type.
3771    width is # bytes in object of this type, nbits is # bits in type.
3772
3773    The width/offset stuff appears to be for small objects stored in
3774    larger ones (e.g. `shorts' in `int' registers).  We ignore it for now,
3775    FIXME.  */
3776
3777 static struct type *
3778 read_sun_builtin_type (const char **pp, int typenums[2], struct objfile *objfile)
3779 {
3780   int type_bits;
3781   int nbits;
3782   int unsigned_type;
3783   int boolean_type = 0;
3784
3785   switch (**pp)
3786     {
3787     case 's':
3788       unsigned_type = 0;
3789       break;
3790     case 'u':
3791       unsigned_type = 1;
3792       break;
3793     default:
3794       return error_type (pp, objfile);
3795     }
3796   (*pp)++;
3797
3798   /* For some odd reason, all forms of char put a c here.  This is strange
3799      because no other type has this honor.  We can safely ignore this because
3800      we actually determine 'char'acterness by the number of bits specified in
3801      the descriptor.
3802      Boolean forms, e.g Fortran logical*X, put a b here.  */
3803
3804   if (**pp == 'c')
3805     (*pp)++;
3806   else if (**pp == 'b')
3807     {
3808       boolean_type = 1;
3809       (*pp)++;
3810     }
3811
3812   /* The first number appears to be the number of bytes occupied
3813      by this type, except that unsigned short is 4 instead of 2.
3814      Since this information is redundant with the third number,
3815      we will ignore it.  */
3816   read_huge_number (pp, ';', &nbits, 0);
3817   if (nbits != 0)
3818     return error_type (pp, objfile);
3819
3820   /* The second number is always 0, so ignore it too.  */
3821   read_huge_number (pp, ';', &nbits, 0);
3822   if (nbits != 0)
3823     return error_type (pp, objfile);
3824
3825   /* The third number is the number of bits for this type.  */
3826   type_bits = read_huge_number (pp, 0, &nbits, 0);
3827   if (nbits != 0)
3828     return error_type (pp, objfile);
3829   /* The type *should* end with a semicolon.  If it are embedded
3830      in a larger type the semicolon may be the only way to know where
3831      the type ends.  If this type is at the end of the stabstring we
3832      can deal with the omitted semicolon (but we don't have to like
3833      it).  Don't bother to complain(), Sun's compiler omits the semicolon
3834      for "void".  */
3835   if (**pp == ';')
3836     ++(*pp);
3837
3838   if (type_bits == 0)
3839     {
3840       struct type *type = init_type (objfile, TYPE_CODE_VOID, 1, NULL);
3841       if (unsigned_type)
3842         TYPE_UNSIGNED (type) = 1;
3843       return type;
3844     }
3845
3846   if (boolean_type)
3847     return init_boolean_type (objfile, type_bits, unsigned_type, NULL);
3848   else
3849     return init_integer_type (objfile, type_bits, unsigned_type, NULL);
3850 }
3851
3852 static struct type *
3853 read_sun_floating_type (const char **pp, int typenums[2],
3854                         struct objfile *objfile)
3855 {
3856   int nbits;
3857   int details;
3858   int nbytes;
3859   struct type *rettype;
3860
3861   /* The first number has more details about the type, for example
3862      FN_COMPLEX.  */
3863   details = read_huge_number (pp, ';', &nbits, 0);
3864   if (nbits != 0)
3865     return error_type (pp, objfile);
3866
3867   /* The second number is the number of bytes occupied by this type.  */
3868   nbytes = read_huge_number (pp, ';', &nbits, 0);
3869   if (nbits != 0)
3870     return error_type (pp, objfile);
3871
3872   nbits = nbytes * TARGET_CHAR_BIT;
3873
3874   if (details == NF_COMPLEX || details == NF_COMPLEX16
3875       || details == NF_COMPLEX32)
3876     {
3877       rettype = dbx_init_float_type (objfile, nbits / 2);
3878       return init_complex_type (objfile, NULL, rettype);
3879     }
3880
3881   return dbx_init_float_type (objfile, nbits);
3882 }
3883
3884 /* Read a number from the string pointed to by *PP.
3885    The value of *PP is advanced over the number.
3886    If END is nonzero, the character that ends the
3887    number must match END, or an error happens;
3888    and that character is skipped if it does match.
3889    If END is zero, *PP is left pointing to that character.
3890
3891    If TWOS_COMPLEMENT_BITS is set to a strictly positive value and if
3892    the number is represented in an octal representation, assume that
3893    it is represented in a 2's complement representation with a size of
3894    TWOS_COMPLEMENT_BITS.
3895
3896    If the number fits in a long, set *BITS to 0 and return the value.
3897    If not, set *BITS to be the number of bits in the number and return 0.
3898
3899    If encounter garbage, set *BITS to -1 and return 0.  */
3900
3901 static long
3902 read_huge_number (const char **pp, int end, int *bits,
3903                   int twos_complement_bits)
3904 {
3905   const char *p = *pp;
3906   int sign = 1;
3907   int sign_bit = 0;
3908   long n = 0;
3909   int radix = 10;
3910   char overflow = 0;
3911   int nbits = 0;
3912   int c;
3913   long upper_limit;
3914   int twos_complement_representation = 0;
3915
3916   if (*p == '-')
3917     {
3918       sign = -1;
3919       p++;
3920     }
3921
3922   /* Leading zero means octal.  GCC uses this to output values larger
3923      than an int (because that would be hard in decimal).  */
3924   if (*p == '0')
3925     {
3926       radix = 8;
3927       p++;
3928     }
3929
3930   /* Skip extra zeros.  */
3931   while (*p == '0')
3932     p++;
3933
3934   if (sign > 0 && radix == 8 && twos_complement_bits > 0)
3935     {
3936       /* Octal, possibly signed.  Check if we have enough chars for a
3937          negative number.  */
3938
3939       size_t len;
3940       const char *p1 = p;
3941
3942       while ((c = *p1) >= '0' && c < '8')
3943         p1++;
3944
3945       len = p1 - p;
3946       if (len > twos_complement_bits / 3
3947           || (twos_complement_bits % 3 == 0
3948               && len == twos_complement_bits / 3))
3949         {
3950           /* Ok, we have enough characters for a signed value, check
3951              for signness by testing if the sign bit is set.  */
3952           sign_bit = (twos_complement_bits % 3 + 2) % 3;
3953           c = *p - '0';
3954           if (c & (1 << sign_bit))
3955             {
3956               /* Definitely signed.  */
3957               twos_complement_representation = 1;
3958               sign = -1;
3959             }
3960         }
3961     }
3962
3963   upper_limit = LONG_MAX / radix;
3964
3965   while ((c = *p++) >= '0' && c < ('0' + radix))
3966     {
3967       if (n <= upper_limit)
3968         {
3969           if (twos_complement_representation)
3970             {
3971               /* Octal, signed, twos complement representation.  In
3972                  this case, n is the corresponding absolute value.  */
3973               if (n == 0)
3974                 {
3975                   long sn = c - '0' - ((2 * (c - '0')) | (2 << sign_bit));
3976
3977                   n = -sn;
3978                 }
3979               else
3980                 {
3981                   n *= radix;
3982                   n -= c - '0';
3983                 }
3984             }
3985           else
3986             {
3987               /* unsigned representation */
3988               n *= radix;
3989               n += c - '0';             /* FIXME this overflows anyway.  */
3990             }
3991         }
3992       else
3993         overflow = 1;
3994
3995       /* This depends on large values being output in octal, which is
3996          what GCC does.  */
3997       if (radix == 8)
3998         {
3999           if (nbits == 0)
4000             {
4001               if (c == '0')
4002                 /* Ignore leading zeroes.  */
4003                 ;
4004               else if (c == '1')
4005                 nbits = 1;
4006               else if (c == '2' || c == '3')
4007                 nbits = 2;
4008               else
4009                 nbits = 3;
4010             }
4011           else
4012             nbits += 3;
4013         }
4014     }
4015   if (end)
4016     {
4017       if (c && c != end)
4018         {
4019           if (bits != NULL)
4020             *bits = -1;
4021           return 0;
4022         }
4023     }
4024   else
4025     --p;
4026
4027   if (radix == 8 && twos_complement_bits > 0 && nbits > twos_complement_bits)
4028     {
4029       /* We were supposed to parse a number with maximum
4030          TWOS_COMPLEMENT_BITS bits, but something went wrong.  */
4031       if (bits != NULL)
4032         *bits = -1;
4033       return 0;
4034     }
4035
4036   *pp = p;
4037   if (overflow)
4038     {
4039       if (nbits == 0)
4040         {
4041           /* Large decimal constants are an error (because it is hard to
4042              count how many bits are in them).  */
4043           if (bits != NULL)
4044             *bits = -1;
4045           return 0;
4046         }
4047
4048       /* -0x7f is the same as 0x80.  So deal with it by adding one to
4049          the number of bits.  Two's complement represention octals
4050          can't have a '-' in front.  */
4051       if (sign == -1 && !twos_complement_representation)
4052         ++nbits;
4053       if (bits)
4054         *bits = nbits;
4055     }
4056   else
4057     {
4058       if (bits)
4059         *bits = 0;
4060       return n * sign;
4061     }
4062   /* It's *BITS which has the interesting information.  */
4063   return 0;
4064 }
4065
4066 static struct type *
4067 read_range_type (const char **pp, int typenums[2], int type_size,
4068                  struct objfile *objfile)
4069 {
4070   struct gdbarch *gdbarch = get_objfile_arch (objfile);
4071   const char *orig_pp = *pp;
4072   int rangenums[2];
4073   long n2, n3;
4074   int n2bits, n3bits;
4075   int self_subrange;
4076   struct type *result_type;
4077   struct type *index_type = NULL;
4078
4079   /* First comes a type we are a subrange of.
4080      In C it is usually 0, 1 or the type being defined.  */
4081   if (read_type_number (pp, rangenums) != 0)
4082     return error_type (pp, objfile);
4083   self_subrange = (rangenums[0] == typenums[0] &&
4084                    rangenums[1] == typenums[1]);
4085
4086   if (**pp == '=')
4087     {
4088       *pp = orig_pp;
4089       index_type = read_type (pp, objfile);
4090     }
4091
4092   /* A semicolon should now follow; skip it.  */
4093   if (**pp == ';')
4094     (*pp)++;
4095
4096   /* The remaining two operands are usually lower and upper bounds
4097      of the range.  But in some special cases they mean something else.  */
4098   n2 = read_huge_number (pp, ';', &n2bits, type_size);
4099   n3 = read_huge_number (pp, ';', &n3bits, type_size);
4100
4101   if (n2bits == -1 || n3bits == -1)
4102     return error_type (pp, objfile);
4103
4104   if (index_type)
4105     goto handle_true_range;
4106
4107   /* If limits are huge, must be large integral type.  */
4108   if (n2bits != 0 || n3bits != 0)
4109     {
4110       char got_signed = 0;
4111       char got_unsigned = 0;
4112       /* Number of bits in the type.  */
4113       int nbits = 0;
4114
4115       /* If a type size attribute has been specified, the bounds of
4116          the range should fit in this size.  If the lower bounds needs
4117          more bits than the upper bound, then the type is signed.  */
4118       if (n2bits <= type_size && n3bits <= type_size)
4119         {
4120           if (n2bits == type_size && n2bits > n3bits)
4121             got_signed = 1;
4122           else
4123             got_unsigned = 1;
4124           nbits = type_size;
4125         }
4126       /* Range from 0 to <large number> is an unsigned large integral type.  */
4127       else if ((n2bits == 0 && n2 == 0) && n3bits != 0)
4128         {
4129           got_unsigned = 1;
4130           nbits = n3bits;
4131         }
4132       /* Range from <large number> to <large number>-1 is a large signed
4133          integral type.  Take care of the case where <large number> doesn't
4134          fit in a long but <large number>-1 does.  */
4135       else if ((n2bits != 0 && n3bits != 0 && n2bits == n3bits + 1)
4136                || (n2bits != 0 && n3bits == 0
4137                    && (n2bits == sizeof (long) * HOST_CHAR_BIT)
4138                    && n3 == LONG_MAX))
4139         {
4140           got_signed = 1;
4141           nbits = n2bits;
4142         }
4143
4144       if (got_signed || got_unsigned)
4145         return init_integer_type (objfile, nbits, got_unsigned, NULL);
4146       else
4147         return error_type (pp, objfile);
4148     }
4149
4150   /* A type defined as a subrange of itself, with bounds both 0, is void.  */
4151   if (self_subrange && n2 == 0 && n3 == 0)
4152     return init_type (objfile, TYPE_CODE_VOID, 1, NULL);
4153
4154   /* If n3 is zero and n2 is positive, we want a floating type, and n2
4155      is the width in bytes.
4156
4157      Fortran programs appear to use this for complex types also.  To
4158      distinguish between floats and complex, g77 (and others?)  seem
4159      to use self-subranges for the complexes, and subranges of int for
4160      the floats.
4161
4162      Also note that for complexes, g77 sets n2 to the size of one of
4163      the member floats, not the whole complex beast.  My guess is that
4164      this was to work well with pre-COMPLEX versions of gdb.  */
4165
4166   if (n3 == 0 && n2 > 0)
4167     {
4168       struct type *float_type
4169         = dbx_init_float_type (objfile, n2 * TARGET_CHAR_BIT);
4170
4171       if (self_subrange)
4172         return init_complex_type (objfile, NULL, float_type);
4173       else
4174         return float_type;
4175     }
4176
4177   /* If the upper bound is -1, it must really be an unsigned integral.  */
4178
4179   else if (n2 == 0 && n3 == -1)
4180     {
4181       int bits = type_size;
4182
4183       if (bits <= 0)
4184         {
4185           /* We don't know its size.  It is unsigned int or unsigned
4186              long.  GCC 2.3.3 uses this for long long too, but that is
4187              just a GDB 3.5 compatibility hack.  */
4188           bits = gdbarch_int_bit (gdbarch);
4189         }
4190
4191       return init_integer_type (objfile, bits, 1, NULL);
4192     }
4193
4194   /* Special case: char is defined (Who knows why) as a subrange of
4195      itself with range 0-127.  */
4196   else if (self_subrange && n2 == 0 && n3 == 127)
4197     {
4198       struct type *type = init_integer_type (objfile, 1, 0, NULL);
4199       TYPE_NOSIGN (type) = 1;
4200       return type;
4201     }
4202   /* We used to do this only for subrange of self or subrange of int.  */
4203   else if (n2 == 0)
4204     {
4205       /* -1 is used for the upper bound of (4 byte) "unsigned int" and
4206          "unsigned long", and we already checked for that,
4207          so don't need to test for it here.  */
4208
4209       if (n3 < 0)
4210         /* n3 actually gives the size.  */
4211         return init_integer_type (objfile, -n3 * TARGET_CHAR_BIT, 1, NULL);
4212
4213       /* Is n3 == 2**(8n)-1 for some integer n?  Then it's an
4214          unsigned n-byte integer.  But do require n to be a power of
4215          two; we don't want 3- and 5-byte integers flying around.  */
4216       {
4217         int bytes;
4218         unsigned long bits;
4219
4220         bits = n3;
4221         for (bytes = 0; (bits & 0xff) == 0xff; bytes++)
4222           bits >>= 8;
4223         if (bits == 0
4224             && ((bytes - 1) & bytes) == 0) /* "bytes is a power of two" */
4225           return init_integer_type (objfile, bytes * TARGET_CHAR_BIT, 1, NULL);
4226       }
4227     }
4228   /* I think this is for Convex "long long".  Since I don't know whether
4229      Convex sets self_subrange, I also accept that particular size regardless
4230      of self_subrange.  */
4231   else if (n3 == 0 && n2 < 0
4232            && (self_subrange
4233                || n2 == -gdbarch_long_long_bit
4234                           (gdbarch) / TARGET_CHAR_BIT))
4235     return init_integer_type (objfile, -n2 * TARGET_CHAR_BIT, 0, NULL);
4236   else if (n2 == -n3 - 1)
4237     {
4238       if (n3 == 0x7f)
4239         return init_integer_type (objfile, 8, 0, NULL);
4240       if (n3 == 0x7fff)
4241         return init_integer_type (objfile, 16, 0, NULL);
4242       if (n3 == 0x7fffffff)
4243         return init_integer_type (objfile, 32, 0, NULL);
4244     }
4245
4246   /* We have a real range type on our hands.  Allocate space and
4247      return a real pointer.  */
4248 handle_true_range:
4249
4250   if (self_subrange)
4251     index_type = objfile_type (objfile)->builtin_int;
4252   else
4253     index_type = *dbx_lookup_type (rangenums, objfile);
4254   if (index_type == NULL)
4255     {
4256       /* Does this actually ever happen?  Is that why we are worrying
4257          about dealing with it rather than just calling error_type?  */
4258
4259       complaint (&symfile_complaints,
4260                  _("base type %d of range type is not defined"), rangenums[1]);
4261
4262       index_type = objfile_type (objfile)->builtin_int;
4263     }
4264
4265   result_type
4266     = create_static_range_type ((struct type *) NULL, index_type, n2, n3);
4267   return (result_type);
4268 }
4269
4270 /* Read in an argument list.  This is a list of types, separated by commas
4271    and terminated with END.  Return the list of types read in, or NULL
4272    if there is an error.  */
4273
4274 static struct field *
4275 read_args (const char **pp, int end, struct objfile *objfile, int *nargsp,
4276            int *varargsp)
4277 {
4278   /* FIXME!  Remove this arbitrary limit!  */
4279   struct type *types[1024];     /* Allow for fns of 1023 parameters.  */
4280   int n = 0, i;
4281   struct field *rval;
4282
4283   while (**pp != end)
4284     {
4285       if (**pp != ',')
4286         /* Invalid argument list: no ','.  */
4287         return NULL;
4288       (*pp)++;
4289       STABS_CONTINUE (pp, objfile);
4290       types[n++] = read_type (pp, objfile);
4291     }
4292   (*pp)++;                      /* get past `end' (the ':' character).  */
4293
4294   if (n == 0)
4295     {
4296       /* We should read at least the THIS parameter here.  Some broken stabs
4297          output contained `(0,41),(0,42)=@s8;-16;,(0,43),(0,1);' where should
4298          have been present ";-16,(0,43)" reference instead.  This way the
4299          excessive ";" marker prematurely stops the parameters parsing.  */
4300
4301       complaint (&symfile_complaints, _("Invalid (empty) method arguments"));
4302       *varargsp = 0;
4303     }
4304   else if (TYPE_CODE (types[n - 1]) != TYPE_CODE_VOID)
4305     *varargsp = 1;
4306   else
4307     {
4308       n--;
4309       *varargsp = 0;
4310     }
4311
4312   rval = XCNEWVEC (struct field, n);
4313   for (i = 0; i < n; i++)
4314     rval[i].type = types[i];
4315   *nargsp = n;
4316   return rval;
4317 }
4318 \f
4319 /* Common block handling.  */
4320
4321 /* List of symbols declared since the last BCOMM.  This list is a tail
4322    of local_symbols.  When ECOMM is seen, the symbols on the list
4323    are noted so their proper addresses can be filled in later,
4324    using the common block base address gotten from the assembler
4325    stabs.  */
4326
4327 static struct pending *common_block;
4328 static int common_block_i;
4329
4330 /* Name of the current common block.  We get it from the BCOMM instead of the
4331    ECOMM to match IBM documentation (even though IBM puts the name both places
4332    like everyone else).  */
4333 static char *common_block_name;
4334
4335 /* Process a N_BCOMM symbol.  The storage for NAME is not guaranteed
4336    to remain after this function returns.  */
4337
4338 void
4339 common_block_start (const char *name, struct objfile *objfile)
4340 {
4341   if (common_block_name != NULL)
4342     {
4343       complaint (&symfile_complaints,
4344                  _("Invalid symbol data: common block within common block"));
4345     }
4346   common_block = local_symbols;
4347   common_block_i = local_symbols ? local_symbols->nsyms : 0;
4348   common_block_name = (char *) obstack_copy0 (&objfile->objfile_obstack, name,
4349                                               strlen (name));
4350 }
4351
4352 /* Process a N_ECOMM symbol.  */
4353
4354 void
4355 common_block_end (struct objfile *objfile)
4356 {
4357   /* Symbols declared since the BCOMM are to have the common block
4358      start address added in when we know it.  common_block and
4359      common_block_i point to the first symbol after the BCOMM in
4360      the local_symbols list; copy the list and hang it off the
4361      symbol for the common block name for later fixup.  */
4362   int i;
4363   struct symbol *sym;
4364   struct pending *newobj = 0;
4365   struct pending *next;
4366   int j;
4367
4368   if (common_block_name == NULL)
4369     {
4370       complaint (&symfile_complaints, _("ECOMM symbol unmatched by BCOMM"));
4371       return;
4372     }
4373
4374   sym = allocate_symbol (objfile);
4375   /* Note: common_block_name already saved on objfile_obstack.  */
4376   SYMBOL_SET_LINKAGE_NAME (sym, common_block_name);
4377   SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
4378
4379   /* Now we copy all the symbols which have been defined since the BCOMM.  */
4380
4381   /* Copy all the struct pendings before common_block.  */
4382   for (next = local_symbols;
4383        next != NULL && next != common_block;
4384        next = next->next)
4385     {
4386       for (j = 0; j < next->nsyms; j++)
4387         add_symbol_to_list (next->symbol[j], &newobj);
4388     }
4389
4390   /* Copy however much of COMMON_BLOCK we need.  If COMMON_BLOCK is
4391      NULL, it means copy all the local symbols (which we already did
4392      above).  */
4393
4394   if (common_block != NULL)
4395     for (j = common_block_i; j < common_block->nsyms; j++)
4396       add_symbol_to_list (common_block->symbol[j], &newobj);
4397
4398   SYMBOL_TYPE (sym) = (struct type *) newobj;
4399
4400   /* Should we be putting local_symbols back to what it was?
4401      Does it matter?  */
4402
4403   i = hashname (SYMBOL_LINKAGE_NAME (sym));
4404   SYMBOL_VALUE_CHAIN (sym) = global_sym_chain[i];
4405   global_sym_chain[i] = sym;
4406   common_block_name = NULL;
4407 }
4408
4409 /* Add a common block's start address to the offset of each symbol
4410    declared to be in it (by being between a BCOMM/ECOMM pair that uses
4411    the common block name).  */
4412
4413 static void
4414 fix_common_block (struct symbol *sym, CORE_ADDR valu)
4415 {
4416   struct pending *next = (struct pending *) SYMBOL_TYPE (sym);
4417
4418   for (; next; next = next->next)
4419     {
4420       int j;
4421
4422       for (j = next->nsyms - 1; j >= 0; j--)
4423         SYMBOL_VALUE_ADDRESS (next->symbol[j]) += valu;
4424     }
4425 }
4426 \f
4427
4428
4429 /* Add {TYPE, TYPENUMS} to the NONAME_UNDEFS vector.
4430    See add_undefined_type for more details.  */
4431
4432 static void
4433 add_undefined_type_noname (struct type *type, int typenums[2])
4434 {
4435   struct nat nat;
4436
4437   nat.typenums[0] = typenums [0];
4438   nat.typenums[1] = typenums [1];
4439   nat.type = type;
4440
4441   if (noname_undefs_length == noname_undefs_allocated)
4442     {
4443       noname_undefs_allocated *= 2;
4444       noname_undefs = (struct nat *)
4445         xrealloc ((char *) noname_undefs,
4446                   noname_undefs_allocated * sizeof (struct nat));
4447     }
4448   noname_undefs[noname_undefs_length++] = nat;
4449 }
4450
4451 /* Add TYPE to the UNDEF_TYPES vector.
4452    See add_undefined_type for more details.  */
4453
4454 static void
4455 add_undefined_type_1 (struct type *type)
4456 {
4457   if (undef_types_length == undef_types_allocated)
4458     {
4459       undef_types_allocated *= 2;
4460       undef_types = (struct type **)
4461         xrealloc ((char *) undef_types,
4462                   undef_types_allocated * sizeof (struct type *));
4463     }
4464   undef_types[undef_types_length++] = type;
4465 }
4466
4467 /* What about types defined as forward references inside of a small lexical
4468    scope?  */
4469 /* Add a type to the list of undefined types to be checked through
4470    once this file has been read in.
4471
4472    In practice, we actually maintain two such lists: The first list
4473    (UNDEF_TYPES) is used for types whose name has been provided, and
4474    concerns forward references (eg 'xs' or 'xu' forward references);
4475    the second list (NONAME_UNDEFS) is used for types whose name is
4476    unknown at creation time, because they were referenced through
4477    their type number before the actual type was declared.
4478    This function actually adds the given type to the proper list.  */
4479
4480 static void
4481 add_undefined_type (struct type *type, int typenums[2])
4482 {
4483   if (TYPE_TAG_NAME (type) == NULL)
4484     add_undefined_type_noname (type, typenums);
4485   else
4486     add_undefined_type_1 (type);
4487 }
4488
4489 /* Try to fix all undefined types pushed on the UNDEF_TYPES vector.  */
4490
4491 static void
4492 cleanup_undefined_types_noname (struct objfile *objfile)
4493 {
4494   int i;
4495
4496   for (i = 0; i < noname_undefs_length; i++)
4497     {
4498       struct nat nat = noname_undefs[i];
4499       struct type **type;
4500
4501       type = dbx_lookup_type (nat.typenums, objfile);
4502       if (nat.type != *type && TYPE_CODE (*type) != TYPE_CODE_UNDEF)
4503         {
4504           /* The instance flags of the undefined type are still unset,
4505              and needs to be copied over from the reference type.
4506              Since replace_type expects them to be identical, we need
4507              to set these flags manually before hand.  */
4508           TYPE_INSTANCE_FLAGS (nat.type) = TYPE_INSTANCE_FLAGS (*type);
4509           replace_type (nat.type, *type);
4510         }
4511     }
4512
4513   noname_undefs_length = 0;
4514 }
4515
4516 /* Go through each undefined type, see if it's still undefined, and fix it
4517    up if possible.  We have two kinds of undefined types:
4518
4519    TYPE_CODE_ARRAY:  Array whose target type wasn't defined yet.
4520    Fix:  update array length using the element bounds
4521    and the target type's length.
4522    TYPE_CODE_STRUCT, TYPE_CODE_UNION:  Structure whose fields were not
4523    yet defined at the time a pointer to it was made.
4524    Fix:  Do a full lookup on the struct/union tag.  */
4525
4526 static void
4527 cleanup_undefined_types_1 (void)
4528 {
4529   struct type **type;
4530
4531   /* Iterate over every undefined type, and look for a symbol whose type
4532      matches our undefined type.  The symbol matches if:
4533        1. It is a typedef in the STRUCT domain;
4534        2. It has the same name, and same type code;
4535        3. The instance flags are identical.
4536
4537      It is important to check the instance flags, because we have seen
4538      examples where the debug info contained definitions such as:
4539
4540          "foo_t:t30=B31=xefoo_t:"
4541
4542      In this case, we have created an undefined type named "foo_t" whose
4543      instance flags is null (when processing "xefoo_t"), and then created
4544      another type with the same name, but with different instance flags
4545      ('B' means volatile).  I think that the definition above is wrong,
4546      since the same type cannot be volatile and non-volatile at the same
4547      time, but we need to be able to cope with it when it happens.  The
4548      approach taken here is to treat these two types as different.  */
4549
4550   for (type = undef_types; type < undef_types + undef_types_length; type++)
4551     {
4552       switch (TYPE_CODE (*type))
4553         {
4554
4555         case TYPE_CODE_STRUCT:
4556         case TYPE_CODE_UNION:
4557         case TYPE_CODE_ENUM:
4558           {
4559             /* Check if it has been defined since.  Need to do this here
4560                as well as in check_typedef to deal with the (legitimate in
4561                C though not C++) case of several types with the same name
4562                in different source files.  */
4563             if (TYPE_STUB (*type))
4564               {
4565                 struct pending *ppt;
4566                 int i;
4567                 /* Name of the type, without "struct" or "union".  */
4568                 const char *type_name = TYPE_TAG_NAME (*type);
4569
4570                 if (type_name == NULL)
4571                   {
4572                     complaint (&symfile_complaints, _("need a type name"));
4573                     break;
4574                   }
4575                 for (ppt = file_symbols; ppt; ppt = ppt->next)
4576                   {
4577                     for (i = 0; i < ppt->nsyms; i++)
4578                       {
4579                         struct symbol *sym = ppt->symbol[i];
4580
4581                         if (SYMBOL_CLASS (sym) == LOC_TYPEDEF
4582                             && SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
4583                             && (TYPE_CODE (SYMBOL_TYPE (sym)) ==
4584                                 TYPE_CODE (*type))
4585                             && (TYPE_INSTANCE_FLAGS (*type) ==
4586                                 TYPE_INSTANCE_FLAGS (SYMBOL_TYPE (sym)))
4587                             && strcmp (SYMBOL_LINKAGE_NAME (sym),
4588                                        type_name) == 0)
4589                           replace_type (*type, SYMBOL_TYPE (sym));
4590                       }
4591                   }
4592               }
4593           }
4594           break;
4595
4596         default:
4597           {
4598             complaint (&symfile_complaints,
4599                        _("forward-referenced types left unresolved, "
4600                        "type code %d."),
4601                        TYPE_CODE (*type));
4602           }
4603           break;
4604         }
4605     }
4606
4607   undef_types_length = 0;
4608 }
4609
4610 /* Try to fix all the undefined types we ecountered while processing
4611    this unit.  */
4612
4613 void
4614 cleanup_undefined_stabs_types (struct objfile *objfile)
4615 {
4616   cleanup_undefined_types_1 ();
4617   cleanup_undefined_types_noname (objfile);
4618 }
4619
4620 /* Scan through all of the global symbols defined in the object file,
4621    assigning values to the debugging symbols that need to be assigned
4622    to.  Get these symbols from the minimal symbol table.  */
4623
4624 void
4625 scan_file_globals (struct objfile *objfile)
4626 {
4627   int hash;
4628   struct minimal_symbol *msymbol;
4629   struct symbol *sym, *prev;
4630   struct objfile *resolve_objfile;
4631
4632   /* SVR4 based linkers copy referenced global symbols from shared
4633      libraries to the main executable.
4634      If we are scanning the symbols for a shared library, try to resolve
4635      them from the minimal symbols of the main executable first.  */
4636
4637   if (symfile_objfile && objfile != symfile_objfile)
4638     resolve_objfile = symfile_objfile;
4639   else
4640     resolve_objfile = objfile;
4641
4642   while (1)
4643     {
4644       /* Avoid expensive loop through all minimal symbols if there are
4645          no unresolved symbols.  */
4646       for (hash = 0; hash < HASHSIZE; hash++)
4647         {
4648           if (global_sym_chain[hash])
4649             break;
4650         }
4651       if (hash >= HASHSIZE)
4652         return;
4653
4654       ALL_OBJFILE_MSYMBOLS (resolve_objfile, msymbol)
4655         {
4656           QUIT;
4657
4658           /* Skip static symbols.  */
4659           switch (MSYMBOL_TYPE (msymbol))
4660             {
4661             case mst_file_text:
4662             case mst_file_data:
4663             case mst_file_bss:
4664               continue;
4665             default:
4666               break;
4667             }
4668
4669           prev = NULL;
4670
4671           /* Get the hash index and check all the symbols
4672              under that hash index.  */
4673
4674           hash = hashname (MSYMBOL_LINKAGE_NAME (msymbol));
4675
4676           for (sym = global_sym_chain[hash]; sym;)
4677             {
4678               if (strcmp (MSYMBOL_LINKAGE_NAME (msymbol),
4679                           SYMBOL_LINKAGE_NAME (sym)) == 0)
4680                 {
4681                   /* Splice this symbol out of the hash chain and
4682                      assign the value we have to it.  */
4683                   if (prev)
4684                     {
4685                       SYMBOL_VALUE_CHAIN (prev) = SYMBOL_VALUE_CHAIN (sym);
4686                     }
4687                   else
4688                     {
4689                       global_sym_chain[hash] = SYMBOL_VALUE_CHAIN (sym);
4690                     }
4691
4692                   /* Check to see whether we need to fix up a common block.  */
4693                   /* Note: this code might be executed several times for
4694                      the same symbol if there are multiple references.  */
4695                   if (sym)
4696                     {
4697                       if (SYMBOL_CLASS (sym) == LOC_BLOCK)
4698                         {
4699                           fix_common_block (sym,
4700                                             MSYMBOL_VALUE_ADDRESS (resolve_objfile,
4701                                                                    msymbol));
4702                         }
4703                       else
4704                         {
4705                           SYMBOL_VALUE_ADDRESS (sym)
4706                             = MSYMBOL_VALUE_ADDRESS (resolve_objfile, msymbol);
4707                         }
4708                       SYMBOL_SECTION (sym) = MSYMBOL_SECTION (msymbol);
4709                     }
4710
4711                   if (prev)
4712                     {
4713                       sym = SYMBOL_VALUE_CHAIN (prev);
4714                     }
4715                   else
4716                     {
4717                       sym = global_sym_chain[hash];
4718                     }
4719                 }
4720               else
4721                 {
4722                   prev = sym;
4723                   sym = SYMBOL_VALUE_CHAIN (sym);
4724                 }
4725             }
4726         }
4727       if (resolve_objfile == objfile)
4728         break;
4729       resolve_objfile = objfile;
4730     }
4731
4732   /* Change the storage class of any remaining unresolved globals to
4733      LOC_UNRESOLVED and remove them from the chain.  */
4734   for (hash = 0; hash < HASHSIZE; hash++)
4735     {
4736       sym = global_sym_chain[hash];
4737       while (sym)
4738         {
4739           prev = sym;
4740           sym = SYMBOL_VALUE_CHAIN (sym);
4741
4742           /* Change the symbol address from the misleading chain value
4743              to address zero.  */
4744           SYMBOL_VALUE_ADDRESS (prev) = 0;
4745
4746           /* Complain about unresolved common block symbols.  */
4747           if (SYMBOL_CLASS (prev) == LOC_STATIC)
4748             SYMBOL_ACLASS_INDEX (prev) = LOC_UNRESOLVED;
4749           else
4750             complaint (&symfile_complaints,
4751                        _("%s: common block `%s' from "
4752                          "global_sym_chain unresolved"),
4753                        objfile_name (objfile), SYMBOL_PRINT_NAME (prev));
4754         }
4755     }
4756   memset (global_sym_chain, 0, sizeof (global_sym_chain));
4757 }
4758
4759 /* Initialize anything that needs initializing when starting to read
4760    a fresh piece of a symbol file, e.g. reading in the stuff corresponding
4761    to a psymtab.  */
4762
4763 void
4764 stabsread_init (void)
4765 {
4766 }
4767
4768 /* Initialize anything that needs initializing when a completely new
4769    symbol file is specified (not just adding some symbols from another
4770    file, e.g. a shared library).  */
4771
4772 void
4773 stabsread_new_init (void)
4774 {
4775   /* Empty the hash table of global syms looking for values.  */
4776   memset (global_sym_chain, 0, sizeof (global_sym_chain));
4777 }
4778
4779 /* Initialize anything that needs initializing at the same time as
4780    start_symtab() is called.  */
4781
4782 void
4783 start_stabs (void)
4784 {
4785   global_stabs = NULL;          /* AIX COFF */
4786   /* Leave FILENUM of 0 free for builtin types and this file's types.  */
4787   n_this_object_header_files = 1;
4788   type_vector_length = 0;
4789   type_vector = (struct type **) 0;
4790
4791   /* FIXME: If common_block_name is not already NULL, we should complain().  */
4792   common_block_name = NULL;
4793 }
4794
4795 /* Call after end_symtab().  */
4796
4797 void
4798 end_stabs (void)
4799 {
4800   if (type_vector)
4801     {
4802       xfree (type_vector);
4803     }
4804   type_vector = 0;
4805   type_vector_length = 0;
4806   previous_stab_code = 0;
4807 }
4808
4809 void
4810 finish_global_stabs (struct objfile *objfile)
4811 {
4812   if (global_stabs)
4813     {
4814       patch_block_stabs (global_symbols, global_stabs, objfile);
4815       xfree (global_stabs);
4816       global_stabs = NULL;
4817     }
4818 }
4819
4820 /* Find the end of the name, delimited by a ':', but don't match
4821    ObjC symbols which look like -[Foo bar::]:bla.  */
4822 static const char *
4823 find_name_end (const char *name)
4824 {
4825   const char *s = name;
4826
4827   if (s[0] == '-' || *s == '+')
4828     {
4829       /* Must be an ObjC method symbol.  */
4830       if (s[1] != '[')
4831         {
4832           error (_("invalid symbol name \"%s\""), name);
4833         }
4834       s = strchr (s, ']');
4835       if (s == NULL)
4836         {
4837           error (_("invalid symbol name \"%s\""), name);
4838         }
4839       return strchr (s, ':');
4840     }
4841   else
4842     {
4843       return strchr (s, ':');
4844     }
4845 }
4846
4847 /* Initializer for this module.  */
4848
4849 void
4850 _initialize_stabsread (void)
4851 {
4852   rs6000_builtin_type_data = register_objfile_data ();
4853
4854   undef_types_allocated = 20;
4855   undef_types_length = 0;
4856   undef_types = XNEWVEC (struct type *, undef_types_allocated);
4857
4858   noname_undefs_allocated = 20;
4859   noname_undefs_length = 0;
4860   noname_undefs = XNEWVEC (struct nat, noname_undefs_allocated);
4861
4862   stab_register_index = register_symbol_register_impl (LOC_REGISTER,
4863                                                        &stab_register_funcs);
4864   stab_regparm_index = register_symbol_register_impl (LOC_REGPARM_ADDR,
4865                                                       &stab_register_funcs);
4866 }