gdb/stabsread.c

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