gdb/stabsread.c

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