gdb/stabsread.c

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