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