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