gdb/stabsread.c

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