gdb/stabsread.c

   1 /* Support routines for decoding "stabs" debugging information format.
   2    Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995
   3              Free Software Foundation, Inc.
   4
   5 This file is part of GDB.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 /* Support routines for reading and decoding debugging information in
  22    the "stabs" format.  This format is used with many systems that use
  23    the a.out object file format, as well as some systems that use
  24    COFF or ELF where the stabs data is placed in a special section.
  25    Avoid placing any object file format specific code in this file. */
  26
  27 #include "defs.h"
  28 #include "gdb_string.h"
  29 #include "bfd.h"
  30 #include "obstack.h"
  31 #include "symtab.h"
  32 #include "gdbtypes.h"
  33 #include "expression.h"
  34 #include "symfile.h"
  35 #include "objfiles.h"
  36 #include "aout/stab_gnu.h"      /* We always use GNU stabs, not native */
  37 #include "libaout.h"
  38 #include "aout/aout64.h"
  39 #include "gdb-stabs.h"
  40 #include "buildsym.h"
  41 #include "complaints.h"
  42 #include "demangle.h"
  43 #include "language.h"
  44
  45 #include <ctype.h>
  46
  47 /* Ask stabsread.h to define the vars it normally declares `extern'.  */
  48 #define EXTERN  /**/
  49 #include "stabsread.h"          /* Our own declarations */
  50 #undef  EXTERN
  51
  52 /* The routines that read and process a complete stabs for a C struct or
  53    C++ class pass lists of data member fields and lists of member function
  54    fields in an instance of a field_info structure, as defined below.
  55    This is part of some reorganization of low level C++ support and is
  56    expected to eventually go away... (FIXME) */
  57
  58 struct field_info
  59 {
  60   struct nextfield
  61     {
  62       struct nextfield *next;
  63
  64       /* This is the raw visibility from the stab.  It is not checked
  65          for being one of the visibilities we recognize, so code which
  66          examines this field better be able to deal.  */
  67       int visibility;
  68
  69       struct field field;
  70     } *list;
  71   struct next_fnfieldlist
  72     {
  73       struct next_fnfieldlist *next;
  74       struct fn_fieldlist fn_fieldlist;
  75     } *fnlist;
  76 };
  77
  78 static struct type *
  79 dbx_alloc_type PARAMS ((int [2], struct objfile *));
  80
  81 static long read_huge_number PARAMS ((char **, int, int *));
  82
  83 static struct type *error_type PARAMS ((char **, struct objfile *));
  84
  85 static void
  86 patch_block_stabs PARAMS ((struct pending *, struct pending_stabs *,
  87                            struct objfile *));
  88
  89 static void
  90 fix_common_block PARAMS ((struct symbol *, int));
  91
  92 static int
  93 read_type_number PARAMS ((char **, int *));
  94
  95 static struct type *
  96 read_range_type PARAMS ((char **, int [2], struct objfile *));
  97
  98 static struct type *
  99 read_sun_builtin_type PARAMS ((char **, int [2], struct objfile *));
 100
 101 static struct type *
 102 read_sun_floating_type PARAMS ((char **, int [2], struct objfile *));
 103
 104 static struct type *
 105 read_enum_type PARAMS ((char **, struct type *, struct objfile *));
 106
 107 static struct type *
 108 rs6000_builtin_type PARAMS ((int));
 109
 110 static int
 111 read_member_functions PARAMS ((struct field_info *, char **, struct type *,
 112                                struct objfile *));
 113
 114 static int
 115 read_struct_fields PARAMS ((struct field_info *, char **, struct type *,
 116                             struct objfile *));
 117
 118 static int
 119 read_baseclasses PARAMS ((struct field_info *, char **, struct type *,
 120                           struct objfile *));
 121
 122 static int
 123 read_tilde_fields PARAMS ((struct field_info *, char **, struct type *,
 124                            struct objfile *));
 125
 126 static int
 127 attach_fn_fields_to_type PARAMS ((struct field_info *, struct type *));
 128
 129 static int
 130 attach_fields_to_type PARAMS ((struct field_info *, struct type *,
 131                                struct objfile *));
 132
 133 static struct type *
 134 read_struct_type PARAMS ((char **, struct type *, struct objfile *));
 135
 136 static struct type *
 137 read_array_type PARAMS ((char **, struct type *, struct objfile *));
 138
 139 static struct type **
 140 read_args PARAMS ((char **, int, struct objfile *));
 141
 142 static int
 143 read_cpp_abbrev PARAMS ((struct field_info *, char **, struct type *,
 144                          struct objfile *));
 145
 146 static const char vptr_name[] = { '_','v','p','t','r',CPLUS_MARKER,'\0' };
 147 static const char vb_name[] =   { '_','v','b',CPLUS_MARKER,'\0' };
 148
 149 /* Define this as 1 if a pcc declaration of a char or short argument
 150    gives the correct address.  Otherwise assume pcc gives the
 151    address of the corresponding int, which is not the same on a
 152    big-endian machine.  */
 153
 154 #ifndef BELIEVE_PCC_PROMOTION
 155 #define BELIEVE_PCC_PROMOTION 0
 156 #endif
 157
 158 struct complaint invalid_cpp_abbrev_complaint =
 159   {"invalid C++ abbreviation `%s'", 0, 0};
 160
 161 struct complaint invalid_cpp_type_complaint =
 162   {"C++ abbreviated type name unknown at symtab pos %d", 0, 0};
 163
 164 struct complaint member_fn_complaint =
 165   {"member function type missing, got '%c'", 0, 0};
 166
 167 struct complaint const_vol_complaint =
 168   {"const/volatile indicator missing, got '%c'", 0, 0};
 169
 170 struct complaint error_type_complaint =
 171   {"debug info mismatch between compiler and debugger", 0, 0};
 172
 173 struct complaint invalid_member_complaint =
 174   {"invalid (minimal) member type data format at symtab pos %d.", 0, 0};
 175
 176 struct complaint range_type_base_complaint =
 177   {"base type %d of range type is not defined", 0, 0};
 178
 179 struct complaint reg_value_complaint =
 180   {"register number %d too large (max %d) in symbol %s", 0, 0};
 181
 182 struct complaint vtbl_notfound_complaint =
 183   {"virtual function table pointer not found when defining class `%s'", 0, 0};
 184
 185 struct complaint unrecognized_cplus_name_complaint =
 186   {"Unknown C++ symbol name `%s'", 0, 0};
 187
 188 struct complaint rs6000_builtin_complaint =
 189   {"Unknown builtin type %d", 0, 0};
 190
 191 struct complaint unresolved_sym_chain_complaint =
 192   {"%s: common block `%s' from global_sym_chain unresolved", 0, 0};
 193
 194 struct complaint stabs_general_complaint =
 195   {"%s", 0, 0};
 196
 197 /* Make a list of forward references which haven't been defined.  */
 198
 199 static struct type **undef_types;
 200 static int undef_types_allocated;
 201 static int undef_types_length;
 202 static struct symbol *current_symbol = NULL;
 203
 204 /* Check for and handle cretinous stabs symbol name continuation!  */
 205 #define STABS_CONTINUE(pp,objfile)                              \
 206   do {                                                  \
 207     if (**(pp) == '\\' || (**(pp) == '?' && (*(pp))[1] == '\0')) \
 208       *(pp) = next_symbol_text (objfile);       \
 209   } while (0)
 210 \f
 211 /* FIXME: These probably should be our own types (like rs6000_builtin_type
 212    has its own types) rather than builtin_type_*.  */
 213 static struct type **os9k_type_vector[] = {
 214         0,
 215         &builtin_type_int,
 216         &builtin_type_char,
 217         &builtin_type_long,
 218         &builtin_type_short,
 219         &builtin_type_unsigned_char,
 220         &builtin_type_unsigned_short,
 221         &builtin_type_unsigned_long,
 222         &builtin_type_unsigned_int,
 223         &builtin_type_float,
 224         &builtin_type_double,
 225         &builtin_type_void,
 226         &builtin_type_long_double
 227 };
 228
 229 static void os9k_init_type_vector PARAMS ((struct type **));
 230
 231 static void
 232 os9k_init_type_vector(tv)
 233     struct type **tv;
 234 {
 235   int i;
 236   for (i=0; i<sizeof(os9k_type_vector)/sizeof(struct type **); i++)
 237     tv[i] = (os9k_type_vector[i] == 0 ? 0 : *(os9k_type_vector[i]));
 238 }
 239
 240 /* Look up a dbx type-number pair.  Return the address of the slot
 241    where the type for that number-pair is stored.
 242    The number-pair is in TYPENUMS.
 243
 244    This can be used for finding the type associated with that pair
 245    or for associating a new type with the pair.  */
 246
 247 struct type **
 248 dbx_lookup_type (typenums)
 249      int typenums[2];
 250 {
 251   register int filenum = typenums[0];
 252   register int index = typenums[1];
 253   unsigned old_len;
 254   register int real_filenum;
 255   register struct header_file *f;
 256   int f_orig_length;
 257
 258   if (filenum == -1)            /* -1,-1 is for temporary types.  */
 259     return 0;
 260
 261   if (filenum < 0 || filenum >= n_this_object_header_files)
 262     {
 263       static struct complaint msg = {"\
 264 Invalid symbol data: type number (%d,%d) out of range at symtab pos %d.",
 265                                 0, 0};
 266       complain (&msg, filenum, index, symnum);
 267       goto error_return;
 268     }
 269
 270   if (filenum == 0)
 271     {
 272       if (index < 0)
 273         {
 274           /* Caller wants address of address of type.  We think
 275              that negative (rs6k builtin) types will never appear as
 276              "lvalues", (nor should they), so we stuff the real type
 277              pointer into a temp, and return its address.  If referenced,
 278              this will do the right thing.  */
 279           static struct type *temp_type;
 280
 281           temp_type = rs6000_builtin_type(index);
 282           return &temp_type;
 283         }
 284
 285       /* Type is defined outside of header files.
 286          Find it in this object file's type vector.  */
 287       if (index >= type_vector_length)
 288         {
 289           old_len = type_vector_length;
 290           if (old_len == 0)
 291             {
 292               type_vector_length = INITIAL_TYPE_VECTOR_LENGTH;
 293               type_vector = (struct type **)
 294                 malloc (type_vector_length * sizeof (struct type *));
 295             }
 296           while (index >= type_vector_length)
 297             {
 298               type_vector_length *= 2;
 299             }
 300           type_vector = (struct type **)
 301             xrealloc ((char *) type_vector,
 302                       (type_vector_length * sizeof (struct type *)));
 303           memset (&type_vector[old_len], 0,
 304                   (type_vector_length - old_len) * sizeof (struct type *));
 305
 306           if (os9k_stabs)
 307             /* Deal with OS9000 fundamental types.  */
 308             os9k_init_type_vector (type_vector);
 309         }
 310       return (&type_vector[index]);
 311     }
 312   else
 313     {
 314       real_filenum = this_object_header_files[filenum];
 315
 316       if (real_filenum >= n_header_files)
 317         {
 318           struct type *temp_type;
 319           struct type **temp_type_p;
 320
 321           warning ("GDB internal error: bad real_filenum");
 322
 323         error_return:
 324           temp_type = init_type (TYPE_CODE_ERROR, 0, 0, NULL, NULL);
 325           temp_type_p = (struct type **) xmalloc (sizeof (struct type *));
 326           *temp_type_p = temp_type;
 327           return temp_type_p;
 328         }
 329
 330       f = &header_files[real_filenum];
 331
 332       f_orig_length = f->length;
 333       if (index >= f_orig_length)
 334         {
 335           while (index >= f->length)
 336             {
 337               f->length *= 2;
 338             }
 339           f->vector = (struct type **)
 340             xrealloc ((char *) f->vector, f->length * sizeof (struct type *));
 341           memset (&f->vector[f_orig_length], 0,
 342                   (f->length - f_orig_length) * sizeof (struct type *));
 343         }
 344       return (&f->vector[index]);
 345     }
 346 }
 347
 348 /* Make sure there is a type allocated for type numbers TYPENUMS
 349    and return the type object.
 350    This can create an empty (zeroed) type object.
 351    TYPENUMS may be (-1, -1) to return a new type object that is not
 352    put into the type vector, and so may not be referred to by number. */
 353
 354 static struct type *
 355 dbx_alloc_type (typenums, objfile)
 356      int typenums[2];
 357      struct objfile *objfile;
 358 {
 359   register struct type **type_addr;
 360
 361   if (typenums[0] == -1)
 362     {
 363       return (alloc_type (objfile));
 364     }
 365
 366   type_addr = dbx_lookup_type (typenums);
 367
 368   /* If we are referring to a type not known at all yet,
 369      allocate an empty type for it.
 370      We will fill it in later if we find out how.  */
 371   if (*type_addr == 0)
 372     {
 373       *type_addr = alloc_type (objfile);
 374     }
 375
 376   return (*type_addr);
 377 }
 378
 379 /* for all the stabs in a given stab vector, build appropriate types
 380    and fix their symbols in given symbol vector. */
 381
 382 static void
 383 patch_block_stabs (symbols, stabs, objfile)
 384      struct pending *symbols;
 385      struct pending_stabs *stabs;
 386      struct objfile *objfile;
 387 {
 388   int ii;
 389   char *name;
 390   char *pp;
 391   struct symbol *sym;
 392
 393   if (stabs)
 394     {
 395
 396       /* for all the stab entries, find their corresponding symbols and
 397          patch their types! */
 398
 399       for (ii = 0; ii < stabs->count; ++ii)
 400         {
 401           name = stabs->stab[ii];
 402           pp = (char*) strchr (name, ':');
 403           while (pp[1] == ':')
 404             {
 405                pp += 2;
 406                pp = (char *)strchr(pp, ':');
 407             }
 408           sym = find_symbol_in_list (symbols, name, pp-name);
 409           if (!sym)
 410             {
 411               /* FIXME-maybe: it would be nice if we noticed whether
 412                  the variable was defined *anywhere*, not just whether
 413                  it is defined in this compilation unit.  But neither
 414                  xlc or GCC seem to need such a definition, and until
 415                  we do psymtabs (so that the minimal symbols from all
 416                  compilation units are available now), I'm not sure
 417                  how to get the information.  */
 418
 419               /* On xcoff, if a global is defined and never referenced,
 420                  ld will remove it from the executable.  There is then
 421                  a N_GSYM stab for it, but no regular (C_EXT) symbol.  */
 422               sym = (struct symbol *)
 423                 obstack_alloc (&objfile->symbol_obstack,
 424                                sizeof (struct symbol));
 425
 426               memset (sym, 0, sizeof (struct symbol));
 427               SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
 428               SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT;
 429               SYMBOL_NAME (sym) =
 430                 obstack_copy0 (&objfile->symbol_obstack, name, pp - name);
 431               pp += 2;
 432               if (*(pp-1) == 'F' || *(pp-1) == 'f')
 433                 {
 434                   /* I don't think the linker does this with functions,
 435                      so as far as I know this is never executed.
 436                      But it doesn't hurt to check.  */
 437                   SYMBOL_TYPE (sym) =
 438                     lookup_function_type (read_type (&pp, objfile));
 439                 }
 440               else
 441                 {
 442                   SYMBOL_TYPE (sym) = read_type (&pp, objfile);
 443                 }
 444               add_symbol_to_list (sym, &global_symbols);
 445             }
 446           else
 447             {
 448               pp += 2;
 449               if (*(pp-1) == 'F' || *(pp-1) == 'f')
 450                 {
 451                   SYMBOL_TYPE (sym) =
 452                     lookup_function_type (read_type (&pp, objfile));
 453                 }
 454               else
 455                 {
 456                   SYMBOL_TYPE (sym) = read_type (&pp, objfile);
 457                 }
 458             }
 459         }
 460     }
 461 }
 462
 463 \f
 464 /* Read a number by which a type is referred to in dbx data,
 465    or perhaps read a pair (FILENUM, TYPENUM) in parentheses.
 466    Just a single number N is equivalent to (0,N).
 467    Return the two numbers by storing them in the vector TYPENUMS.
 468    TYPENUMS will then be used as an argument to dbx_lookup_type.
 469
 470    Returns 0 for success, -1 for error.  */
 471
 472 static int
 473 read_type_number (pp, typenums)
 474      register char **pp;
 475      register int *typenums;
 476 {
 477   int nbits;
 478   if (**pp == '(')
 479     {
 480       (*pp)++;
 481       typenums[0] = read_huge_number (pp, ',', &nbits);
 482       if (nbits != 0) return -1;
 483       typenums[1] = read_huge_number (pp, ')', &nbits);
 484       if (nbits != 0) return -1;
 485     }
 486   else
 487     {
 488       typenums[0] = 0;
 489       typenums[1] = read_huge_number (pp, 0, &nbits);
 490       if (nbits != 0) return -1;
 491     }
 492   return 0;
 493 }
 494
 495 \f
 496 #if !defined (REG_STRUCT_HAS_ADDR)
 497 #define REG_STRUCT_HAS_ADDR(gcc_p,type) 0
 498 #endif
 499
 500 /* ARGSUSED */
 501 struct symbol *
 502 define_symbol (valu, string, desc, type, objfile)
 503      CORE_ADDR valu;
 504      char *string;
 505      int desc;
 506      int type;
 507      struct objfile *objfile;
 508 {
 509   register struct symbol *sym;
 510   char *p = (char *) strchr (string, ':');
 511   int deftype;
 512   int synonym = 0;
 513   register int i;
 514
 515   /* We would like to eliminate nameless symbols, but keep their types.
 516      E.g. stab entry ":t10=*2" should produce a type 10, which is a pointer
 517      to type 2, but, should not create a symbol to address that type. Since
 518      the symbol will be nameless, there is no way any user can refer to it. */
 519
 520   int nameless;
 521
 522   /* Ignore syms with empty names.  */
 523   if (string[0] == 0)
 524     return 0;
 525
 526   /* Ignore old-style symbols from cc -go  */
 527   if (p == 0)
 528     return 0;
 529
 530   while (p[1] == ':')
 531     {
 532        p += 2;
 533        p = strchr(p, ':');
 534     }
 535
 536   /* If a nameless stab entry, all we need is the type, not the symbol.
 537      e.g. ":t10=*2" or a nameless enum like " :T16=ered:0,green:1,blue:2,;" */
 538   nameless = (p == string || ((string[0] == ' ') && (string[1] == ':')));
 539
 540   current_symbol = sym = (struct symbol *)
 541     obstack_alloc (&objfile -> symbol_obstack, sizeof (struct symbol));
 542   memset (sym, 0, sizeof (struct symbol));
 543
 544   switch (type & N_TYPE)
 545     {
 546     case N_TEXT:
 547       SYMBOL_SECTION(sym) = SECT_OFF_TEXT;
 548       break;
 549     case N_DATA:
 550       SYMBOL_SECTION(sym) = SECT_OFF_DATA;
 551       break;
 552     case N_BSS:
 553       SYMBOL_SECTION(sym) = SECT_OFF_BSS;
 554       break;
 555     }
 556
 557   if (processing_gcc_compilation)
 558     {
 559       /* GCC 2.x puts the line number in desc.  SunOS apparently puts in the
 560          number of bytes occupied by a type or object, which we ignore.  */
 561       SYMBOL_LINE(sym) = desc;
 562     }
 563   else
 564     {
 565       SYMBOL_LINE(sym) = 0;                     /* unknown */
 566     }
 567
 568   if (string[0] == CPLUS_MARKER)
 569     {
 570       /* Special GNU C++ names.  */
 571       switch (string[1])
 572         {
 573           case 't':
 574             SYMBOL_NAME (sym) = obsavestring ("this", strlen ("this"),
 575                                               &objfile -> symbol_obstack);
 576             break;
 577
 578           case 'v': /* $vtbl_ptr_type */
 579             /* Was: SYMBOL_NAME (sym) = "vptr"; */
 580             goto normal;
 581
 582           case 'e':
 583             SYMBOL_NAME (sym) = obsavestring ("eh_throw", strlen ("eh_throw"),
 584                                               &objfile -> symbol_obstack);
 585             break;
 586
 587           case '_':
 588             /* This was an anonymous type that was never fixed up.  */
 589             goto normal;
 590
 591 #ifdef STATIC_TRANSFORM_NAME
 592           case 'X':
 593             /* SunPRO (3.0 at least) static variable encoding.  */
 594             goto normal;
 595 #endif
 596
 597           default:
 598             complain (&unrecognized_cplus_name_complaint, string);
 599             goto normal;                /* Do *something* with it */
 600         }
 601     }
 602   else
 603     {
 604     normal:
 605       SYMBOL_LANGUAGE (sym) = current_subfile -> language;
 606       SYMBOL_NAME (sym) = (char *)
 607         obstack_alloc (&objfile -> symbol_obstack, ((p - string) + 1));
 608       /* Open-coded memcpy--saves function call time.  */
 609       /* FIXME:  Does it really?  Try replacing with simple strcpy and
 610          try it on an executable with a large symbol table. */
 611       /* FIXME: considering that gcc can open code memcpy anyway, I
 612          doubt it.  xoxorich. */
 613       {
 614         register char *p1 = string;
 615         register char *p2 = SYMBOL_NAME (sym);
 616         while (p1 != p)
 617           {
 618             *p2++ = *p1++;
 619           }
 620         *p2++ = '\0';
 621       }
 622
 623       /* If this symbol is from a C++ compilation, then attempt to cache the
 624          demangled form for future reference.  This is a typical time versus
 625          space tradeoff, that was decided in favor of time because it sped up
 626          C++ symbol lookups by a factor of about 20. */
 627
 628       SYMBOL_INIT_DEMANGLED_NAME (sym, &objfile->symbol_obstack);
 629     }
 630   p++;
 631
 632   /* Determine the type of name being defined.  */
 633 #if 0
 634   /* Getting GDB to correctly skip the symbol on an undefined symbol
 635      descriptor and not ever dump core is a very dodgy proposition if
 636      we do things this way.  I say the acorn RISC machine can just
 637      fix their compiler.  */
 638   /* The Acorn RISC machine's compiler can put out locals that don't
 639      start with "234=" or "(3,4)=", so assume anything other than the
 640      deftypes we know how to handle is a local.  */
 641   if (!strchr ("cfFGpPrStTvVXCR", *p))
 642 #else
 643   if (isdigit (*p) || *p == '(' || *p == '-')
 644 #endif
 645     deftype = 'l';
 646   else
 647     deftype = *p++;
 648
 649   switch (deftype)
 650     {
 651     case 'c':
 652       /* c is a special case, not followed by a type-number.
 653          SYMBOL:c=iVALUE for an integer constant symbol.
 654          SYMBOL:c=rVALUE for a floating constant symbol.
 655          SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
 656          e.g. "b:c=e6,0" for "const b = blob1"
 657          (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;").  */
 658       if (*p != '=')
 659         {
 660           SYMBOL_CLASS (sym) = LOC_CONST;
 661           SYMBOL_TYPE (sym) = error_type (&p, objfile);
 662           SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
 663           add_symbol_to_list (sym, &file_symbols);
 664           return sym;
 665         }
 666       ++p;
 667       switch (*p++)
 668         {
 669         case 'r':
 670           {
 671             double d = atof (p);
 672             char *dbl_valu;
 673
 674             /* FIXME-if-picky-about-floating-accuracy: Should be using
 675                target arithmetic to get the value.  real.c in GCC
 676                probably has the necessary code.  */
 677
 678             /* FIXME: lookup_fundamental_type is a hack.  We should be
 679                creating a type especially for the type of float constants.
 680                Problem is, what type should it be?
 681
 682                Also, what should the name of this type be?  Should we
 683                be using 'S' constants (see stabs.texinfo) instead?  */
 684
 685             SYMBOL_TYPE (sym) = lookup_fundamental_type (objfile,
 686                                                          FT_DBL_PREC_FLOAT);
 687             dbl_valu = (char *)
 688               obstack_alloc (&objfile -> symbol_obstack,
 689                              TYPE_LENGTH (SYMBOL_TYPE (sym)));
 690             store_floating (dbl_valu, TYPE_LENGTH (SYMBOL_TYPE (sym)), d);
 691             SYMBOL_VALUE_BYTES (sym) = dbl_valu;
 692             SYMBOL_CLASS (sym) = LOC_CONST_BYTES;
 693           }
 694           break;
 695         case 'i':
 696           {
 697             /* Defining integer constants this way is kind of silly,
 698                since 'e' constants allows the compiler to give not
 699                only the value, but the type as well.  C has at least
 700                int, long, unsigned int, and long long as constant
 701                types; other languages probably should have at least
 702                unsigned as well as signed constants.  */
 703
 704             /* We just need one int constant type for all objfiles.
 705                It doesn't depend on languages or anything (arguably its
 706                name should be a language-specific name for a type of
 707                that size, but I'm inclined to say that if the compiler
 708                wants a nice name for the type, it can use 'e').  */
 709             static struct type *int_const_type;
 710
 711             /* Yes, this is as long as a *host* int.  That is because we
 712                use atoi.  */
 713             if (int_const_type == NULL)
 714               int_const_type =
 715                 init_type (TYPE_CODE_INT,
 716                            sizeof (int) * HOST_CHAR_BIT / TARGET_CHAR_BIT, 0,
 717                            "integer constant",
 718                            (struct objfile *)NULL);
 719             SYMBOL_TYPE (sym) = int_const_type;
 720             SYMBOL_VALUE (sym) = atoi (p);
 721             SYMBOL_CLASS (sym) = LOC_CONST;
 722           }
 723           break;
 724         case 'e':
 725           /* SYMBOL:c=eTYPE,INTVALUE for a constant symbol whose value
 726              can be represented as integral.
 727              e.g. "b:c=e6,0" for "const b = blob1"
 728              (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;").  */
 729           {
 730             SYMBOL_CLASS (sym) = LOC_CONST;
 731             SYMBOL_TYPE (sym) = read_type (&p, objfile);
 732
 733             if (*p != ',')
 734               {
 735                 SYMBOL_TYPE (sym) = error_type (&p, objfile);
 736                 break;
 737               }
 738             ++p;
 739
 740             /* If the value is too big to fit in an int (perhaps because
 741                it is unsigned), or something like that, we silently get
 742                a bogus value.  The type and everything else about it is
 743                correct.  Ideally, we should be using whatever we have
 744                available for parsing unsigned and long long values,
 745                however.  */
 746             SYMBOL_VALUE (sym) = atoi (p);
 747           }
 748           break;
 749         default:
 750           {
 751             SYMBOL_CLASS (sym) = LOC_CONST;
 752             SYMBOL_TYPE (sym) = error_type (&p, objfile);
 753           }
 754         }
 755       SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
 756       add_symbol_to_list (sym, &file_symbols);
 757       return sym;
 758
 759     case 'C':
 760       /* The name of a caught exception.  */
 761       SYMBOL_TYPE (sym) = read_type (&p, objfile);
 762       SYMBOL_CLASS (sym) = LOC_LABEL;
 763       SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
 764       SYMBOL_VALUE_ADDRESS (sym) = valu;
 765       add_symbol_to_list (sym, &local_symbols);
 766       break;
 767
 768     case 'f':
 769       /* A static function definition.  */
 770       SYMBOL_TYPE (sym) = read_type (&p, objfile);
 771       SYMBOL_CLASS (sym) = LOC_BLOCK;
 772       SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
 773       add_symbol_to_list (sym, &file_symbols);
 774       /* fall into process_function_types.  */
 775
 776     process_function_types:
 777       /* Function result types are described as the result type in stabs.
 778          We need to convert this to the function-returning-type-X type
 779          in GDB.  E.g. "int" is converted to "function returning int".  */
 780       if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_FUNC)
 781         SYMBOL_TYPE (sym) = lookup_function_type (SYMBOL_TYPE (sym));
 782       /* fall into process_prototype_types */
 783
 784     process_prototype_types:
 785       /* Sun acc puts declared types of arguments here.  We don't care
 786          about their actual types (FIXME -- we should remember the whole
 787          function prototype), but the list may define some new types
 788          that we have to remember, so we must scan it now.  */
 789       while (*p == ';') {
 790         p++;
 791         read_type (&p, objfile);
 792       }
 793       break;
 794
 795     case 'F':
 796       /* A global function definition.  */
 797       SYMBOL_TYPE (sym) = read_type (&p, objfile);
 798       SYMBOL_CLASS (sym) = LOC_BLOCK;
 799       SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
 800       add_symbol_to_list (sym, &global_symbols);
 801       goto process_function_types;
 802
 803     case 'G':
 804       /* For a class G (global) symbol, it appears that the
 805          value is not correct.  It is necessary to search for the
 806          corresponding linker definition to find the value.
 807          These definitions appear at the end of the namelist.  */
 808       SYMBOL_TYPE (sym) = read_type (&p, objfile);
 809       i = hashname (SYMBOL_NAME (sym));
 810       SYMBOL_VALUE_CHAIN (sym) = global_sym_chain[i];
 811       global_sym_chain[i] = sym;
 812       SYMBOL_CLASS (sym) = LOC_STATIC;
 813       SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
 814       add_symbol_to_list (sym, &global_symbols);
 815       break;
 816
 817       /* This case is faked by a conditional above,
 818          when there is no code letter in the dbx data.
 819          Dbx data never actually contains 'l'.  */
 820     case 's':
 821     case 'l':
 822       SYMBOL_TYPE (sym) = read_type (&p, objfile);
 823       SYMBOL_CLASS (sym) = LOC_LOCAL;
 824       SYMBOL_VALUE (sym) = valu;
 825       SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
 826       add_symbol_to_list (sym, &local_symbols);
 827       break;
 828
 829     case 'p':
 830       if (*p == 'F')
 831         /* pF is a two-letter code that means a function parameter in Fortran.
 832            The type-number specifies the type of the return value.
 833            Translate it into a pointer-to-function type.  */
 834         {
 835           p++;
 836           SYMBOL_TYPE (sym)
 837             = lookup_pointer_type
 838               (lookup_function_type (read_type (&p, objfile)));
 839         }
 840       else
 841         SYMBOL_TYPE (sym) = read_type (&p, objfile);
 842
 843       /* Normally this is a parameter, a LOC_ARG.  On the i960, it
 844          can also be a LOC_LOCAL_ARG depending on symbol type.  */
 845 #ifndef DBX_PARM_SYMBOL_CLASS
 846 #define DBX_PARM_SYMBOL_CLASS(type)     LOC_ARG
 847 #endif
 848
 849       SYMBOL_CLASS (sym) = DBX_PARM_SYMBOL_CLASS (type);
 850       SYMBOL_VALUE (sym) = valu;
 851       SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
 852       add_symbol_to_list (sym, &local_symbols);
 853
 854       if (TARGET_BYTE_ORDER != BIG_ENDIAN)
 855         {
 856           /* On little-endian machines, this crud is never necessary,
 857              and, if the extra bytes contain garbage, is harmful.  */
 858           break;
 859         }
 860
 861       /* If it's gcc-compiled, if it says `short', believe it.  */
 862       if (processing_gcc_compilation || BELIEVE_PCC_PROMOTION)
 863         break;
 864
 865 #if !BELIEVE_PCC_PROMOTION
 866       {
 867         /* This is the signed type which arguments get promoted to.  */
 868         static struct type *pcc_promotion_type;
 869         /* This is the unsigned type which arguments get promoted to.  */
 870         static struct type *pcc_unsigned_promotion_type;
 871
 872         /* Call it "int" because this is mainly C lossage.  */
 873         if (pcc_promotion_type == NULL)
 874           pcc_promotion_type =
 875             init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
 876                        0, "int", NULL);
 877
 878         if (pcc_unsigned_promotion_type == NULL)
 879           pcc_unsigned_promotion_type =
 880             init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
 881                        TYPE_FLAG_UNSIGNED, "unsigned int", NULL);
 882
 883 #if defined(BELIEVE_PCC_PROMOTION_TYPE)
 884         /* This macro is defined on machines (e.g. sparc) where
 885            we should believe the type of a PCC 'short' argument,
 886            but shouldn't believe the address (the address is
 887            the address of the corresponding int).
 888
 889            My guess is that this correction, as opposed to changing
 890            the parameter to an 'int' (as done below, for PCC
 891            on most machines), is the right thing to do
 892            on all machines, but I don't want to risk breaking
 893            something that already works.  On most PCC machines,
 894            the sparc problem doesn't come up because the calling
 895            function has to zero the top bytes (not knowing whether
 896            the called function wants an int or a short), so there
 897            is little practical difference between an int and a short
 898            (except perhaps what happens when the GDB user types
 899            "print short_arg = 0x10000;").
 900
 901            Hacked for SunOS 4.1 by gnu@cygnus.com.  In 4.1, the compiler
 902            actually produces the correct address (we don't need to fix it
 903            up).  I made this code adapt so that it will offset the symbol
 904            if it was pointing at an int-aligned location and not
 905            otherwise.  This way you can use the same gdb for 4.0.x and
 906            4.1 systems.
 907
 908            If the parameter is shorter than an int, and is integral
 909            (e.g. char, short, or unsigned equivalent), and is claimed to
 910            be passed on an integer boundary, don't believe it!  Offset the
 911            parameter's address to the tail-end of that integer.  */
 912
 913         if (TYPE_LENGTH (SYMBOL_TYPE (sym)) < TYPE_LENGTH (pcc_promotion_type)
 914             && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT
 915             && 0 == SYMBOL_VALUE (sym) % TYPE_LENGTH (pcc_promotion_type))
 916           {
 917             SYMBOL_VALUE (sym) += TYPE_LENGTH (pcc_promotion_type)
 918               - TYPE_LENGTH (SYMBOL_TYPE (sym));
 919           }
 920         break;
 921
 922 #else /* no BELIEVE_PCC_PROMOTION_TYPE.  */
 923
 924         /* If PCC says a parameter is a short or a char,
 925            it is really an int.  */
 926         if (TYPE_LENGTH (SYMBOL_TYPE (sym)) < TYPE_LENGTH (pcc_promotion_type)
 927             && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT)
 928           {
 929             SYMBOL_TYPE (sym) =
 930               TYPE_UNSIGNED (SYMBOL_TYPE (sym))
 931                 ? pcc_unsigned_promotion_type
 932                 : pcc_promotion_type;
 933           }
 934         break;
 935
 936 #endif /* no BELIEVE_PCC_PROMOTION_TYPE.  */
 937       }
 938 #endif /* !BELIEVE_PCC_PROMOTION.  */
 939
 940     case 'P':
 941       /* acc seems to use P to delare the prototypes of functions that
 942          are referenced by this file.  gdb is not prepared to deal
 943          with this extra information.  FIXME, it ought to.  */
 944       if (type == N_FUN)
 945         {
 946           read_type (&p, objfile);
 947           goto process_prototype_types;
 948         }
 949       /*FALLTHROUGH*/
 950
 951     case 'R':
 952       /* Parameter which is in a register.  */
 953       SYMBOL_TYPE (sym) = read_type (&p, objfile);
 954       SYMBOL_CLASS (sym) = LOC_REGPARM;
 955       SYMBOL_VALUE (sym) = STAB_REG_TO_REGNUM (valu);
 956       if (SYMBOL_VALUE (sym) >= NUM_REGS)
 957         {
 958           complain (&reg_value_complaint, SYMBOL_VALUE (sym), NUM_REGS,
 959                     SYMBOL_SOURCE_NAME (sym));
 960           SYMBOL_VALUE (sym) = SP_REGNUM;  /* Known safe, though useless */
 961         }
 962       SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
 963       add_symbol_to_list (sym, &local_symbols);
 964       break;
 965
 966     case 'r':
 967       /* Register variable (either global or local).  */
 968       SYMBOL_TYPE (sym) = read_type (&p, objfile);
 969       SYMBOL_CLASS (sym) = LOC_REGISTER;
 970       SYMBOL_VALUE (sym) = STAB_REG_TO_REGNUM (valu);
 971       if (SYMBOL_VALUE (sym) >= NUM_REGS)
 972         {
 973           complain (&reg_value_complaint, SYMBOL_VALUE (sym), NUM_REGS,
 974                     SYMBOL_SOURCE_NAME (sym));
 975           SYMBOL_VALUE (sym) = SP_REGNUM;  /* Known safe, though useless */
 976         }
 977       SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
 978       if (within_function)
 979         {
 980           /* Sun cc uses a pair of symbols, one 'p' and one 'r' with the same
 981              name to represent an argument passed in a register.
 982              GCC uses 'P' for the same case.  So if we find such a symbol pair
 983              we combine it into one 'P' symbol.  For Sun cc we need to do this
 984              regardless of REG_STRUCT_HAS_ADDR, because the compiler puts out
 985              the 'p' symbol even if it never saves the argument onto the stack.
 986
 987              On most machines, we want to preserve both symbols, so that
 988              we can still get information about what is going on with the
 989              stack (VAX for computing args_printed, using stack slots instead
 990              of saved registers in backtraces, etc.).
 991
 992              Note that this code illegally combines
 993                main(argc) struct foo argc; { register struct foo argc; }
 994              but this case is considered pathological and causes a warning
 995              from a decent compiler.  */
 996
 997           if (local_symbols
 998               && local_symbols->nsyms > 0
 999 #ifndef USE_REGISTER_NOT_ARG
1000               && REG_STRUCT_HAS_ADDR (processing_gcc_compilation,
1001                                       SYMBOL_TYPE (sym))
1002               && (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT
1003                   || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_UNION
1004                   || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_SET
1005                   || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_BITSTRING)
1006 #endif
1007               )
1008             {
1009               struct symbol *prev_sym;
1010               prev_sym = local_symbols->symbol[local_symbols->nsyms - 1];
1011               if ((SYMBOL_CLASS (prev_sym) == LOC_REF_ARG
1012                    || SYMBOL_CLASS (prev_sym) == LOC_ARG)
1013                   && STREQ (SYMBOL_NAME (prev_sym), SYMBOL_NAME(sym)))
1014                 {
1015                   SYMBOL_CLASS (prev_sym) = LOC_REGPARM;
1016                   /* Use the type from the LOC_REGISTER; that is the type
1017                      that is actually in that register.  */
1018                   SYMBOL_TYPE (prev_sym) = SYMBOL_TYPE (sym);
1019                   SYMBOL_VALUE (prev_sym) = SYMBOL_VALUE (sym);
1020                   sym = prev_sym;
1021                   break;
1022                 }
1023             }
1024           add_symbol_to_list (sym, &local_symbols);
1025         }
1026       else
1027         add_symbol_to_list (sym, &file_symbols);
1028       break;
1029
1030     case 'S':
1031       /* Static symbol at top level of file */
1032       SYMBOL_TYPE (sym) = read_type (&p, objfile);
1033       SYMBOL_CLASS (sym) = LOC_STATIC;
1034       SYMBOL_VALUE_ADDRESS (sym) = valu;
1035 #ifdef STATIC_TRANSFORM_NAME
1036       if (SYMBOL_NAME (sym)[0] == '$')
1037       {
1038         struct minimal_symbol *msym;
1039         msym = lookup_minimal_symbol (SYMBOL_NAME (sym), NULL, objfile);
1040         if (msym != NULL)
1041           {
1042             SYMBOL_NAME (sym) = STATIC_TRANSFORM_NAME (SYMBOL_NAME (sym));
1043             SYMBOL_VALUE_ADDRESS (sym) = SYMBOL_VALUE_ADDRESS (msym);
1044           }
1045       }
1046 #endif
1047       SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
1048       add_symbol_to_list (sym, &file_symbols);
1049       break;
1050
1051     case 't':
1052       SYMBOL_TYPE (sym) = read_type (&p, objfile);
1053
1054       /* For a nameless type, we don't want a create a symbol, thus we
1055          did not use `sym'. Return without further processing. */
1056       if (nameless) return NULL;
1057
1058       SYMBOL_CLASS (sym) = LOC_TYPEDEF;
1059       SYMBOL_VALUE (sym) = valu;
1060       SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
1061       /* C++ vagaries: we may have a type which is derived from
1062          a base type which did not have its name defined when the
1063          derived class was output.  We fill in the derived class's
1064          base part member's name here in that case.  */
1065       if (TYPE_NAME (SYMBOL_TYPE (sym)) != NULL)
1066         if ((TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT
1067              || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_UNION)
1068             && TYPE_N_BASECLASSES (SYMBOL_TYPE (sym)))
1069           {
1070             int j;
1071             for (j = TYPE_N_BASECLASSES (SYMBOL_TYPE (sym)) - 1; j >= 0; j--)
1072               if (TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym), j) == 0)
1073                 TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym), j) =
1074                   type_name_no_tag (TYPE_BASECLASS (SYMBOL_TYPE (sym), j));
1075           }
1076
1077       if (TYPE_NAME (SYMBOL_TYPE (sym)) == NULL)
1078         {
1079           /* gcc-2.6 or later (when using -fvtable-thunks)
1080              emits a unique named type for a vtable entry.
1081              Some gdb code depends on that specific name. */
1082           extern const char vtbl_ptr_name[];
1083
1084           if ((TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR
1085                && strcmp (SYMBOL_NAME (sym), vtbl_ptr_name))
1086               || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FUNC)
1087             {
1088               /* If we are giving a name to a type such as "pointer to
1089                  foo" or "function returning foo", we better not set
1090                  the TYPE_NAME.  If the program contains "typedef char
1091                  *caddr_t;", we don't want all variables of type char
1092                  * to print as caddr_t.  This is not just a
1093                  consequence of GDB's type management; PCC and GCC (at
1094                  least through version 2.4) both output variables of
1095                  either type char * or caddr_t with the type number
1096                  defined in the 't' symbol for caddr_t.  If a future
1097                  compiler cleans this up it GDB is not ready for it
1098                  yet, but if it becomes ready we somehow need to
1099                  disable this check (without breaking the PCC/GCC2.4
1100                  case).
1101
1102                  Sigh.
1103
1104                  Fortunately, this check seems not to be necessary
1105                  for anything except pointers or functions.  */
1106             }
1107           else
1108             TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_NAME (sym);
1109         }
1110
1111       add_symbol_to_list (sym, &file_symbols);
1112       break;
1113
1114     case 'T':
1115       /* Struct, union, or enum tag.  For GNU C++, this can be be followed
1116          by 't' which means we are typedef'ing it as well.  */
1117       synonym = *p == 't';
1118
1119       if (synonym)
1120         p++;
1121       /* The semantics of C++ state that "struct foo { ... }" also defines
1122          a typedef for "foo".  Unfortunately, cfront never makes the typedef
1123          when translating C++ into C.  We make the typedef here so that
1124          "ptype foo" works as expected for cfront translated code.  */
1125       else if (current_subfile->language == language_cplus)
1126         synonym = 1;
1127
1128       SYMBOL_TYPE (sym) = read_type (&p, objfile);
1129
1130       /* For a nameless type, we don't want a create a symbol, thus we
1131          did not use `sym'. Return without further processing. */
1132       if (nameless) return NULL;
1133
1134       SYMBOL_CLASS (sym) = LOC_TYPEDEF;
1135       SYMBOL_VALUE (sym) = valu;
1136       SYMBOL_NAMESPACE (sym) = STRUCT_NAMESPACE;
1137       if (TYPE_TAG_NAME (SYMBOL_TYPE (sym)) == 0)
1138         TYPE_TAG_NAME (SYMBOL_TYPE (sym))
1139           = obconcat (&objfile -> type_obstack, "", "", SYMBOL_NAME (sym));
1140       add_symbol_to_list (sym, &file_symbols);
1141
1142       if (synonym)
1143         {
1144           /* Clone the sym and then modify it. */
1145           register struct symbol *typedef_sym = (struct symbol *)
1146             obstack_alloc (&objfile -> symbol_obstack, sizeof (struct symbol));
1147           *typedef_sym = *sym;
1148           SYMBOL_CLASS (typedef_sym) = LOC_TYPEDEF;
1149           SYMBOL_VALUE (typedef_sym) = valu;
1150           SYMBOL_NAMESPACE (typedef_sym) = VAR_NAMESPACE;
1151           if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
1152             TYPE_NAME (SYMBOL_TYPE (sym))
1153               = obconcat (&objfile -> type_obstack, "", "", SYMBOL_NAME (sym));
1154           add_symbol_to_list (typedef_sym, &file_symbols);
1155         }
1156       break;
1157
1158     case 'V':
1159       /* Static symbol of local scope */
1160       SYMBOL_TYPE (sym) = read_type (&p, objfile);
1161       SYMBOL_CLASS (sym) = LOC_STATIC;
1162       SYMBOL_VALUE_ADDRESS (sym) = valu;
1163 #ifdef STATIC_TRANSFORM_NAME
1164       if (SYMBOL_NAME (sym)[0] == '$')
1165       {
1166         struct minimal_symbol *msym;
1167         msym = lookup_minimal_symbol (SYMBOL_NAME (sym), NULL, objfile);
1168         if (msym != NULL)
1169           {
1170             SYMBOL_NAME (sym) = STATIC_TRANSFORM_NAME (SYMBOL_NAME (sym));
1171             SYMBOL_VALUE_ADDRESS (sym) = SYMBOL_VALUE_ADDRESS (msym);
1172           }
1173       }
1174 #endif
1175       SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
1176       if (os9k_stabs)
1177         add_symbol_to_list (sym, &global_symbols);
1178       else
1179         add_symbol_to_list (sym, &local_symbols);
1180       break;
1181
1182     case 'v':
1183       /* Reference parameter */
1184       SYMBOL_TYPE (sym) = read_type (&p, objfile);
1185       SYMBOL_CLASS (sym) = LOC_REF_ARG;
1186       SYMBOL_VALUE (sym) = valu;
1187       SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
1188       add_symbol_to_list (sym, &local_symbols);
1189       break;
1190
1191     case 'a':
1192       /* Reference parameter which is in a register.  */
1193       SYMBOL_TYPE (sym) = read_type (&p, objfile);
1194       SYMBOL_CLASS (sym) = LOC_REGPARM_ADDR;
1195       SYMBOL_VALUE (sym) = STAB_REG_TO_REGNUM (valu);
1196       if (SYMBOL_VALUE (sym) >= NUM_REGS)
1197         {
1198           complain (&reg_value_complaint, SYMBOL_VALUE (sym), NUM_REGS,
1199                     SYMBOL_SOURCE_NAME (sym));
1200           SYMBOL_VALUE (sym) = SP_REGNUM;  /* Known safe, though useless */
1201         }
1202       SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
1203       add_symbol_to_list (sym, &local_symbols);
1204       break;
1205
1206     case 'X':
1207       /* This is used by Sun FORTRAN for "function result value".
1208          Sun claims ("dbx and dbxtool interfaces", 2nd ed)
1209          that Pascal uses it too, but when I tried it Pascal used
1210          "x:3" (local symbol) instead.  */
1211       SYMBOL_TYPE (sym) = read_type (&p, objfile);
1212       SYMBOL_CLASS (sym) = LOC_LOCAL;
1213       SYMBOL_VALUE (sym) = valu;
1214       SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
1215       add_symbol_to_list (sym, &local_symbols);
1216       break;
1217
1218     default:
1219       SYMBOL_TYPE (sym) = error_type (&p, objfile);
1220       SYMBOL_CLASS (sym) = LOC_CONST;
1221       SYMBOL_VALUE (sym) = 0;
1222       SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
1223       add_symbol_to_list (sym, &file_symbols);
1224       break;
1225     }
1226
1227   /* When passing structures to a function, some systems sometimes pass
1228      the address in a register, not the structure itself. */
1229
1230   if (REG_STRUCT_HAS_ADDR (processing_gcc_compilation,
1231                               SYMBOL_TYPE (sym))
1232       && ((TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT)
1233           || (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_UNION)
1234           || (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_BITSTRING)
1235           || (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_SET)))
1236     {
1237       /* If REG_STRUCT_HAS_ADDR yields non-zero we have to
1238         convert LOC_REGPARM to LOC_REGPARM_ADDR for structures and unions. */
1239       if (SYMBOL_CLASS (sym) == LOC_REGPARM)
1240         SYMBOL_CLASS (sym) = LOC_REGPARM_ADDR;
1241       /* Likewise for converting LOC_ARG to LOC_REF_ARG (for the 7th and
1242          subsequent arguments on the sparc, for example).  */
1243       else if (SYMBOL_CLASS (sym) == LOC_ARG)
1244         SYMBOL_CLASS (sym) = LOC_REF_ARG;
1245     }
1246
1247   return sym;
1248 }
1249
1250 \f
1251 /* Skip rest of this symbol and return an error type.
1252
1253    General notes on error recovery:  error_type always skips to the
1254    end of the symbol (modulo cretinous dbx symbol name continuation).
1255    Thus code like this:
1256
1257    if (*(*pp)++ != ';')
1258      return error_type (pp, objfile);
1259
1260    is wrong because if *pp starts out pointing at '\0' (typically as the
1261    result of an earlier error), it will be incremented to point to the
1262    start of the next symbol, which might produce strange results, at least
1263    if you run off the end of the string table.  Instead use
1264
1265    if (**pp != ';')
1266      return error_type (pp, objfile);
1267    ++*pp;
1268
1269    or
1270
1271    if (**pp != ';')
1272      foo = error_type (pp, objfile);
1273    else
1274      ++*pp;
1275
1276    And in case it isn't obvious, the point of all this hair is so the compiler
1277    can define new types and new syntaxes, and old versions of the
1278    debugger will be able to read the new symbol tables.  */
1279
1280 static struct type *
1281 error_type (pp, objfile)
1282      char **pp;
1283      struct objfile *objfile;
1284 {
1285   complain (&error_type_complaint);
1286   while (1)
1287     {
1288       /* Skip to end of symbol.  */
1289       while (**pp != '\0')
1290         {
1291           (*pp)++;
1292         }
1293
1294       /* Check for and handle cretinous dbx symbol name continuation!  */
1295       if ((*pp)[-1] == '\\' || (*pp)[-1] == '?')
1296         {
1297           *pp = next_symbol_text (objfile);
1298         }
1299       else
1300         {
1301           break;
1302         }
1303     }
1304   return (builtin_type_error);
1305 }
1306
1307 \f
1308 /* Read type information or a type definition; return the type.  Even
1309    though this routine accepts either type information or a type
1310    definition, the distinction is relevant--some parts of stabsread.c
1311    assume that type information starts with a digit, '-', or '(' in
1312    deciding whether to call read_type.  */
1313
1314 struct type *
1315 read_type (pp, objfile)
1316      register char **pp;
1317      struct objfile *objfile;
1318 {
1319   register struct type *type = 0;
1320   struct type *type1;
1321   int typenums[2];
1322   int xtypenums[2];
1323   char type_descriptor;
1324
1325   /* Size in bits of type if specified by a type attribute, or -1 if
1326      there is no size attribute.  */
1327   int type_size = -1;
1328
1329   /* Used to distinguish string and bitstring from char-array and set. */
1330   int is_string = 0;
1331
1332   /* Read type number if present.  The type number may be omitted.
1333      for instance in a two-dimensional array declared with type
1334      "ar1;1;10;ar1;1;10;4".  */
1335   if ((**pp >= '0' && **pp <= '9')
1336       || **pp == '('
1337       || **pp == '-')
1338     {
1339       if (read_type_number (pp, typenums) != 0)
1340         return error_type (pp, objfile);
1341
1342       /* Type is not being defined here.  Either it already exists,
1343          or this is a forward reference to it.  dbx_alloc_type handles
1344          both cases.  */
1345       if (**pp != '=')
1346         return dbx_alloc_type (typenums, objfile);
1347
1348       /* Type is being defined here.  */
1349       /* Skip the '='.  */
1350       ++(*pp);
1351
1352       while (**pp == '@')
1353         {
1354           char *p = *pp + 1;
1355           /* It might be a type attribute or a member type.  */
1356           if (isdigit (*p) || *p ==  '(' || *p == '-')
1357             /* Member type.  */
1358             break;
1359           else
1360             {
1361               /* Type attributes.  */
1362               char *attr = p;
1363
1364               /* Skip to the semicolon.  */
1365               while (*p != ';' && *p != '\0')
1366                 ++p;
1367               *pp = p;
1368               if (*p == '\0')
1369                 return error_type (pp, objfile);
1370               else
1371                 /* Skip the semicolon.  */
1372                 ++*pp;
1373
1374               switch (*attr)
1375                 {
1376                 case 's':
1377                   type_size = atoi (attr + 1);
1378                   if (type_size <= 0)
1379                     type_size = -1;
1380                   break;
1381
1382                 case 'S':
1383                   is_string = 1;
1384                   break;
1385
1386                 default:
1387                   /* Ignore unrecognized type attributes, so future compilers
1388                      can invent new ones.  */
1389                   break;
1390                 }
1391             }
1392         }
1393       /* Skip the type descriptor, we get it below with (*pp)[-1].  */
1394       ++(*pp);
1395     }
1396   else
1397     {
1398       /* 'typenums=' not present, type is anonymous.  Read and return
1399          the definition, but don't put it in the type vector.  */
1400       typenums[0] = typenums[1] = -1;
1401       (*pp)++;
1402     }
1403
1404   type_descriptor = (*pp)[-1];
1405   switch (type_descriptor)
1406     {
1407     case 'x':
1408       {
1409         enum type_code code;
1410
1411         /* Used to index through file_symbols.  */
1412         struct pending *ppt;
1413         int i;
1414
1415         /* Name including "struct", etc.  */
1416         char *type_name;
1417
1418         {
1419           char *from, *to, *p, *q1, *q2;
1420
1421           /* Set the type code according to the following letter.  */
1422           switch ((*pp)[0])
1423             {
1424             case 's':
1425               code = TYPE_CODE_STRUCT;
1426               break;
1427             case 'u':
1428               code = TYPE_CODE_UNION;
1429               break;
1430             case 'e':
1431               code = TYPE_CODE_ENUM;
1432               break;
1433             default:
1434               {
1435                 /* Complain and keep going, so compilers can invent new
1436                    cross-reference types.  */
1437                 static struct complaint msg =
1438                   {"Unrecognized cross-reference type `%c'", 0, 0};
1439                 complain (&msg, (*pp)[0]);
1440                 code = TYPE_CODE_STRUCT;
1441                 break;
1442               }
1443             }
1444
1445           q1 = strchr(*pp, '<');
1446           p = strchr(*pp, ':');
1447           if (p == NULL)
1448             return error_type (pp, objfile);
1449           while (q1 && p > q1 && p[1] == ':')
1450             {
1451                q2 = strchr(q1, '>');
1452                if (!q2 || q2 < p)
1453                  break;
1454                p += 2;
1455                p = strchr(p, ':');
1456                if (p == NULL)
1457                  return error_type (pp, objfile);
1458             }
1459           to = type_name =
1460                 (char *)obstack_alloc (&objfile->type_obstack, p - *pp + 1);
1461
1462           /* Copy the name.  */
1463           from = *pp + 1;
1464           while (from < p)
1465             *to++ = *from++;
1466           *to = '\0';
1467
1468           /* Set the pointer ahead of the name which we just read, and
1469              the colon.  */
1470           *pp = from + 1;
1471         }
1472
1473         /* Now check to see whether the type has already been
1474            declared.  This was written for arrays of cross-referenced
1475            types before we had TYPE_CODE_TARGET_STUBBED, so I'm pretty
1476            sure it is not necessary anymore.  But it might be a good
1477            idea, to save a little memory.  */
1478
1479         for (ppt = file_symbols; ppt; ppt = ppt->next)
1480           for (i = 0; i < ppt->nsyms; i++)
1481             {
1482               struct symbol *sym = ppt->symbol[i];
1483
1484               if (SYMBOL_CLASS (sym) == LOC_TYPEDEF
1485                   && SYMBOL_NAMESPACE (sym) == STRUCT_NAMESPACE
1486                   && (TYPE_CODE (SYMBOL_TYPE (sym)) == code)
1487                   && STREQ (SYMBOL_NAME (sym), type_name))
1488                 {
1489                   obstack_free (&objfile -> type_obstack, type_name);
1490                   type = SYMBOL_TYPE (sym);
1491                   return type;
1492                 }
1493             }
1494
1495         /* Didn't find the type to which this refers, so we must
1496            be dealing with a forward reference.  Allocate a type
1497            structure for it, and keep track of it so we can
1498            fill in the rest of the fields when we get the full
1499            type.  */
1500         type = dbx_alloc_type (typenums, objfile);
1501         TYPE_CODE (type) = code;
1502         TYPE_TAG_NAME (type) = type_name;
1503         INIT_CPLUS_SPECIFIC(type);
1504         TYPE_FLAGS (type) |= TYPE_FLAG_STUB;
1505
1506         add_undefined_type (type);
1507         return type;
1508       }
1509
1510     case '-':                           /* RS/6000 built-in type */
1511     case '0':
1512     case '1':
1513     case '2':
1514     case '3':
1515     case '4':
1516     case '5':
1517     case '6':
1518     case '7':
1519     case '8':
1520     case '9':
1521     case '(':
1522
1523       {
1524         char *pp_saved;
1525
1526         (*pp)--;
1527         pp_saved = *pp;
1528
1529         /* Peek ahead at the number to detect void.  */
1530         if (read_type_number (pp, xtypenums) != 0)
1531           return error_type (pp, objfile);
1532
1533         if (typenums[0] == xtypenums[0] && typenums[1] == xtypenums[1])
1534           /* It's being defined as itself.  That means it is "void".  */
1535           type = init_type (TYPE_CODE_VOID, 1, 0, NULL, objfile);
1536         else
1537           {
1538             struct type *xtype;
1539
1540             /* Go back to the number and have read_type get it.  This means
1541                that we can deal with something like t(1,2)=(3,4)=... which
1542                the Lucid compiler uses.  */
1543             *pp = pp_saved;
1544             xtype = read_type (pp, objfile);
1545
1546             /* The type is being defined to another type.  So we copy the type.
1547                This loses if we copy a C++ class and so we lose track of how
1548                the names are mangled (but g++ doesn't output stabs like this
1549                now anyway).  */
1550
1551             type = alloc_type (objfile);
1552             if (SYMBOL_LINE (current_symbol) == 0)
1553               {
1554                 *type = *xtype;
1555                 /* The idea behind clearing the names is that the only purpose
1556                    for defining a type to another type is so that the name of
1557                    one can be different.  So we probably don't need to worry
1558                    much about the case where the compiler doesn't give a name
1559                    to the new type.  */
1560                 TYPE_NAME (type) = NULL;
1561                 TYPE_TAG_NAME (type) = NULL;
1562               }
1563             else
1564               {
1565                 TYPE_CODE (type) = TYPE_CODE_TYPEDEF;
1566                 TYPE_FLAGS (type) |= TYPE_FLAG_TARGET_STUB;
1567                 TYPE_TARGET_TYPE (type) = xtype;
1568               }
1569           }
1570         if (typenums[0] != -1)
1571           *dbx_lookup_type (typenums) = type;
1572         break;
1573       }
1574
1575     /* In the following types, we must be sure to overwrite any existing
1576        type that the typenums refer to, rather than allocating a new one
1577        and making the typenums point to the new one.  This is because there
1578        may already be pointers to the existing type (if it had been
1579        forward-referenced), and we must change it to a pointer, function,
1580        reference, or whatever, *in-place*.  */
1581
1582     case '*':
1583       type1 = read_type (pp, objfile);
1584       type = make_pointer_type (type1, dbx_lookup_type (typenums));
1585       break;
1586
1587     case '&':                           /* Reference to another type */
1588       type1 = read_type (pp, objfile);
1589       type = make_reference_type (type1, dbx_lookup_type (typenums));
1590       break;
1591
1592     case 'f':                           /* Function returning another type */
1593       if (os9k_stabs && **pp == '(')
1594         {
1595           /* Function prototype; parse it.
1596              We must conditionalize this on os9k_stabs because otherwise
1597              it could be confused with a Sun-style (1,3) typenumber
1598              (I think).  */
1599           struct type *t;
1600           ++*pp;
1601           while (**pp != ')')
1602             {
1603               t = read_type(pp, objfile);
1604               if (**pp == ',') ++*pp;
1605             }
1606         }
1607       type1 = read_type (pp, objfile);
1608       type = make_function_type (type1, dbx_lookup_type (typenums));
1609       break;
1610
1611     case 'k':                      /* Const qualifier on some type (Sun) */
1612     case 'c':                      /* Const qualifier on some type (OS9000) */
1613       /* Because 'c' means other things to AIX and 'k' is perfectly good,
1614          only accept 'c' in the os9k_stabs case.  */
1615       if (type_descriptor == 'c' && !os9k_stabs)
1616         return error_type (pp, objfile);
1617       type = read_type (pp, objfile);
1618       /* FIXME! For now, we ignore const and volatile qualifiers.  */
1619       break;
1620
1621     case 'B':                        /* Volatile qual on some type (Sun) */
1622     case 'i':                        /* Volatile qual on some type (OS9000) */
1623       /* Because 'i' means other things to AIX and 'B' is perfectly good,
1624          only accept 'i' in the os9k_stabs case.  */
1625       if (type_descriptor == 'i' && !os9k_stabs)
1626         return error_type (pp, objfile);
1627       type = read_type (pp, objfile);
1628       /* FIXME! For now, we ignore const and volatile qualifiers.  */
1629       break;
1630
1631 /* FIXME -- we should be doing smash_to_XXX types here.  */
1632     case '@':                           /* Member (class & variable) type */
1633       {
1634         struct type *domain = read_type (pp, objfile);
1635         struct type *memtype;
1636
1637         if (**pp != ',')
1638           /* Invalid member type data format.  */
1639           return error_type (pp, objfile);
1640         ++*pp;
1641
1642         memtype = read_type (pp, objfile);
1643         type = dbx_alloc_type (typenums, objfile);
1644         smash_to_member_type (type, domain, memtype);
1645       }
1646       break;
1647
1648     case '#':                           /* Method (class & fn) type */
1649       if ((*pp)[0] == '#')
1650         {
1651           /* We'll get the parameter types from the name.  */
1652           struct type *return_type;
1653
1654           (*pp)++;
1655           return_type = read_type (pp, objfile);
1656           if (*(*pp)++ != ';')
1657             complain (&invalid_member_complaint, symnum);
1658           type = allocate_stub_method (return_type);
1659           if (typenums[0] != -1)
1660             *dbx_lookup_type (typenums) = type;
1661         }
1662       else
1663         {
1664           struct type *domain = read_type (pp, objfile);
1665           struct type *return_type;
1666           struct type **args;
1667
1668           if (**pp != ',')
1669             /* Invalid member type data format.  */
1670             return error_type (pp, objfile);
1671           else
1672             ++(*pp);
1673
1674           return_type = read_type (pp, objfile);
1675           args = read_args (pp, ';', objfile);
1676           type = dbx_alloc_type (typenums, objfile);
1677           smash_to_method_type (type, domain, return_type, args);
1678         }
1679       break;
1680
1681     case 'r':                           /* Range type */
1682       type = read_range_type (pp, typenums, objfile);
1683       if (typenums[0] != -1)
1684         *dbx_lookup_type (typenums) = type;
1685       break;
1686
1687     case 'b':
1688       if (os9k_stabs)
1689         /* Const and volatile qualified type.  */
1690         type = read_type (pp, objfile);
1691       else
1692         {
1693           /* Sun ACC builtin int type */
1694           type = read_sun_builtin_type (pp, typenums, objfile);
1695           if (typenums[0] != -1)
1696             *dbx_lookup_type (typenums) = type;
1697         }
1698       break;
1699
1700     case 'R':                           /* Sun ACC builtin float type */
1701       type = read_sun_floating_type (pp, typenums, objfile);
1702       if (typenums[0] != -1)
1703         *dbx_lookup_type (typenums) = type;
1704       break;
1705
1706     case 'e':                           /* Enumeration type */
1707       type = dbx_alloc_type (typenums, objfile);
1708       type = read_enum_type (pp, type, objfile);
1709       if (typenums[0] != -1)
1710         *dbx_lookup_type (typenums) = type;
1711       break;
1712
1713     case 's':                           /* Struct type */
1714     case 'u':                           /* Union type */
1715       type = dbx_alloc_type (typenums, objfile);
1716       switch (type_descriptor)
1717         {
1718           case 's':
1719             TYPE_CODE (type) = TYPE_CODE_STRUCT;
1720             break;
1721           case 'u':
1722             TYPE_CODE (type) = TYPE_CODE_UNION;
1723             break;
1724         }
1725       type = read_struct_type (pp, type, objfile);
1726       break;
1727
1728     case 'a':                           /* Array type */
1729       if (**pp != 'r')
1730         return error_type (pp, objfile);
1731       ++*pp;
1732
1733       type = dbx_alloc_type (typenums, objfile);
1734       type = read_array_type (pp, type, objfile);
1735       if (is_string)
1736         TYPE_CODE (type) = TYPE_CODE_STRING;
1737       break;
1738
1739     case 'S':
1740       type1 = read_type (pp, objfile);
1741       type = create_set_type ((struct type*) NULL, type1);
1742       if (is_string)
1743         TYPE_CODE (type) = TYPE_CODE_BITSTRING;
1744       if (typenums[0] != -1)
1745         *dbx_lookup_type (typenums) = type;
1746       break;
1747
1748     default:
1749       --*pp;                    /* Go back to the symbol in error */
1750                                 /* Particularly important if it was \0! */
1751       return error_type (pp, objfile);
1752     }
1753
1754   if (type == 0)
1755     {
1756       warning ("GDB internal error, type is NULL in stabsread.c\n");
1757       return error_type (pp, objfile);
1758     }
1759
1760   /* Size specified in a type attribute overrides any other size.  */
1761   if (type_size != -1)
1762     TYPE_LENGTH (type) = (type_size + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT;
1763
1764   return type;
1765 }
1766 \f
1767 /* RS/6000 xlc/dbx combination uses a set of builtin types, starting from -1.
1768    Return the proper type node for a given builtin type number. */
1769
1770 static struct type *
1771 rs6000_builtin_type (typenum)
1772      int typenum;
1773 {
1774   /* We recognize types numbered from -NUMBER_RECOGNIZED to -1.  */
1775 #define NUMBER_RECOGNIZED 34
1776   /* This includes an empty slot for type number -0.  */
1777   static struct type *negative_types[NUMBER_RECOGNIZED + 1];
1778   struct type *rettype = NULL;
1779
1780   if (typenum >= 0 || typenum < -NUMBER_RECOGNIZED)
1781     {
1782       complain (&rs6000_builtin_complaint, typenum);
1783       return builtin_type_error;
1784     }
1785   if (negative_types[-typenum] != NULL)
1786     return negative_types[-typenum];
1787
1788 #if TARGET_CHAR_BIT != 8
1789   #error This code wrong for TARGET_CHAR_BIT not 8
1790   /* These definitions all assume that TARGET_CHAR_BIT is 8.  I think
1791      that if that ever becomes not true, the correct fix will be to
1792      make the size in the struct type to be in bits, not in units of
1793      TARGET_CHAR_BIT.  */
1794 #endif
1795
1796   switch (-typenum)
1797     {
1798     case 1:
1799       /* The size of this and all the other types are fixed, defined
1800          by the debugging format.  If there is a type called "int" which
1801          is other than 32 bits, then it should use a new negative type
1802          number (or avoid negative type numbers for that case).
1803          See stabs.texinfo.  */
1804       rettype = init_type (TYPE_CODE_INT, 4, 0, "int", NULL);
1805       break;
1806     case 2:
1807       rettype = init_type (TYPE_CODE_INT, 1, 0, "char", NULL);
1808       break;
1809     case 3:
1810       rettype = init_type (TYPE_CODE_INT, 2, 0, "short", NULL);
1811       break;
1812     case 4:
1813       rettype = init_type (TYPE_CODE_INT, 4, 0, "long", NULL);
1814       break;
1815     case 5:
1816       rettype = init_type (TYPE_CODE_INT, 1, TYPE_FLAG_UNSIGNED,
1817                            "unsigned char", NULL);
1818       break;
1819     case 6:
1820       rettype = init_type (TYPE_CODE_INT, 1, 0, "signed char", NULL);
1821       break;
1822     case 7:
1823       rettype = init_type (TYPE_CODE_INT, 2, TYPE_FLAG_UNSIGNED,
1824                            "unsigned short", NULL);
1825       break;
1826     case 8:
1827       rettype = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
1828                            "unsigned int", NULL);
1829       break;
1830     case 9:
1831       rettype = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
1832                            "unsigned", NULL);
1833     case 10:
1834       rettype = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
1835                            "unsigned long", NULL);
1836       break;
1837     case 11:
1838       rettype = init_type (TYPE_CODE_VOID, 1, 0, "void", NULL);
1839       break;
1840     case 12:
1841       /* IEEE single precision (32 bit).  */
1842       rettype = init_type (TYPE_CODE_FLT, 4, 0, "float", NULL);
1843       break;
1844     case 13:
1845       /* IEEE double precision (64 bit).  */
1846       rettype = init_type (TYPE_CODE_FLT, 8, 0, "double", NULL);
1847       break;
1848     case 14:
1849       /* This is an IEEE double on the RS/6000, and different machines with
1850          different sizes for "long double" should use different negative
1851          type numbers.  See stabs.texinfo.  */
1852       rettype = init_type (TYPE_CODE_FLT, 8, 0, "long double", NULL);
1853       break;
1854     case 15:
1855       rettype = init_type (TYPE_CODE_INT, 4, 0, "integer", NULL);
1856       break;
1857     case 16:
1858       rettype = init_type (TYPE_CODE_BOOL, 4, TYPE_FLAG_UNSIGNED,
1859                            "boolean", NULL);
1860       break;
1861     case 17:
1862       rettype = init_type (TYPE_CODE_FLT, 4, 0, "short real", NULL);
1863       break;
1864     case 18:
1865       rettype = init_type (TYPE_CODE_FLT, 8, 0, "real", NULL);
1866       break;
1867     case 19:
1868       rettype = init_type (TYPE_CODE_ERROR, 0, 0, "stringptr", NULL);
1869       break;
1870     case 20:
1871       rettype = init_type (TYPE_CODE_CHAR, 1, TYPE_FLAG_UNSIGNED,
1872                            "character", NULL);
1873       break;
1874     case 21:
1875       rettype = init_type (TYPE_CODE_BOOL, 1, TYPE_FLAG_UNSIGNED,
1876                            "logical*1", NULL);
1877       break;
1878     case 22:
1879       rettype = init_type (TYPE_CODE_BOOL, 2, TYPE_FLAG_UNSIGNED,
1880                            "logical*2", NULL);
1881       break;
1882     case 23:
1883       rettype = init_type (TYPE_CODE_BOOL, 4, TYPE_FLAG_UNSIGNED,
1884                            "logical*4", NULL);
1885       break;
1886     case 24:
1887       rettype = init_type (TYPE_CODE_BOOL, 4, TYPE_FLAG_UNSIGNED,
1888                            "logical", NULL);
1889       break;
1890     case 25:
1891       /* Complex type consisting of two IEEE single precision values.  */
1892       rettype = init_type (TYPE_CODE_ERROR, 8, 0, "complex", NULL);
1893       break;
1894     case 26:
1895       /* Complex type consisting of two IEEE double precision values.  */
1896       rettype = init_type (TYPE_CODE_ERROR, 16, 0, "double complex", NULL);
1897       break;
1898     case 27:
1899       rettype = init_type (TYPE_CODE_INT, 1, 0, "integer*1", NULL);
1900       break;
1901     case 28:
1902       rettype = init_type (TYPE_CODE_INT, 2, 0, "integer*2", NULL);
1903       break;
1904     case 29:
1905       rettype = init_type (TYPE_CODE_INT, 4, 0, "integer*4", NULL);
1906       break;
1907     case 30:
1908       rettype = init_type (TYPE_CODE_CHAR, 2, 0, "wchar", NULL);
1909       break;
1910     case 31:
1911       rettype = init_type (TYPE_CODE_INT, 8, 0, "long long", NULL);
1912       break;
1913     case 32:
1914       rettype = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED,
1915                            "unsigned long long", NULL);
1916       break;
1917     case 33:
1918       rettype = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED,
1919                            "logical*8", NULL);
1920       break;
1921     case 34:
1922       rettype = init_type (TYPE_CODE_INT, 8, 0, "integer*8", NULL);
1923       break;
1924     }
1925   negative_types[-typenum] = rettype;
1926   return rettype;
1927 }
1928 \f
1929 /* This page contains subroutines of read_type.  */
1930
1931 #define VISIBILITY_PRIVATE      '0'     /* Stabs character for private field */
1932 #define VISIBILITY_PROTECTED    '1'     /* Stabs character for protected fld */
1933 #define VISIBILITY_PUBLIC       '2'     /* Stabs character for public field */
1934 #define VISIBILITY_IGNORE       '9'     /* Optimized out or zero length */
1935
1936 /* Read member function stabs info for C++ classes.  The form of each member
1937    function data is:
1938
1939         NAME :: TYPENUM[=type definition] ARGS : PHYSNAME ;
1940
1941    An example with two member functions is:
1942
1943         afunc1::20=##15;:i;2A.;afunc2::20:i;2A.;
1944
1945    For the case of overloaded operators, the format is op$::*.funcs, where
1946    $ is the CPLUS_MARKER (usually '$'), `*' holds the place for an operator
1947    name (such as `+=') and `.' marks the end of the operator name.
1948
1949    Returns 1 for success, 0 for failure.  */
1950
1951 static int
1952 read_member_functions (fip, pp, type, objfile)
1953      struct field_info *fip;
1954      char **pp;
1955      struct type *type;
1956      struct objfile *objfile;
1957 {
1958   int nfn_fields = 0;
1959   int length = 0;
1960   /* Total number of member functions defined in this class.  If the class
1961      defines two `f' functions, and one `g' function, then this will have
1962      the value 3.  */
1963   int total_length = 0;
1964   int i;
1965   struct next_fnfield
1966     {
1967       struct next_fnfield *next;
1968       struct fn_field fn_field;
1969     } *sublist;
1970   struct type *look_ahead_type;
1971   struct next_fnfieldlist *new_fnlist;
1972   struct next_fnfield *new_sublist;
1973   char *main_fn_name;
1974   register char *p;
1975
1976   /* Process each list until we find something that is not a member function
1977      or find the end of the functions. */
1978
1979   while (**pp != ';')
1980     {
1981       /* We should be positioned at the start of the function name.
1982          Scan forward to find the first ':' and if it is not the
1983          first of a "::" delimiter, then this is not a member function. */
1984       p = *pp;
1985       while (*p != ':')
1986         {
1987           p++;
1988         }
1989       if (p[1] != ':')
1990         {
1991           break;
1992         }
1993
1994       sublist = NULL;
1995       look_ahead_type = NULL;
1996       length = 0;
1997
1998       new_fnlist = (struct next_fnfieldlist *)
1999         xmalloc (sizeof (struct next_fnfieldlist));
2000       make_cleanup (free, new_fnlist);
2001       memset (new_fnlist, 0, sizeof (struct next_fnfieldlist));
2002
2003       if ((*pp)[0] == 'o' && (*pp)[1] == 'p' && (*pp)[2] == CPLUS_MARKER)
2004         {
2005           /* This is a completely wierd case.  In order to stuff in the
2006              names that might contain colons (the usual name delimiter),
2007              Mike Tiemann defined a different name format which is
2008              signalled if the identifier is "op$".  In that case, the
2009              format is "op$::XXXX." where XXXX is the name.  This is
2010              used for names like "+" or "=".  YUUUUUUUK!  FIXME!  */
2011           /* This lets the user type "break operator+".
2012              We could just put in "+" as the name, but that wouldn't
2013              work for "*".  */
2014           static char opname[32] = {'o', 'p', CPLUS_MARKER};
2015           char *o = opname + 3;
2016
2017           /* Skip past '::'.  */
2018           *pp = p + 2;
2019
2020           STABS_CONTINUE (pp, objfile);
2021           p = *pp;
2022           while (*p != '.')
2023             {
2024               *o++ = *p++;
2025             }
2026           main_fn_name = savestring (opname, o - opname);
2027           /* Skip past '.'  */
2028           *pp = p + 1;
2029         }
2030       else
2031         {
2032           main_fn_name = savestring (*pp, p - *pp);
2033           /* Skip past '::'.  */
2034           *pp = p + 2;
2035         }
2036       new_fnlist -> fn_fieldlist.name = main_fn_name;
2037
2038       do
2039         {
2040           new_sublist =
2041             (struct next_fnfield *) xmalloc (sizeof (struct next_fnfield));
2042           make_cleanup (free, new_sublist);
2043           memset (new_sublist, 0, sizeof (struct next_fnfield));
2044
2045           /* Check for and handle cretinous dbx symbol name continuation!  */
2046           if (look_ahead_type == NULL)
2047             {
2048               /* Normal case. */
2049               STABS_CONTINUE (pp, objfile);
2050
2051               new_sublist -> fn_field.type = read_type (pp, objfile);
2052               if (**pp != ':')
2053                 {
2054                   /* Invalid symtab info for member function.  */
2055                   return 0;
2056                 }
2057             }
2058           else
2059             {
2060               /* g++ version 1 kludge */
2061               new_sublist -> fn_field.type = look_ahead_type;
2062               look_ahead_type = NULL;
2063             }
2064
2065           (*pp)++;
2066           p = *pp;
2067           while (*p != ';')
2068             {
2069               p++;
2070             }
2071
2072           /* If this is just a stub, then we don't have the real name here. */
2073
2074           if (TYPE_FLAGS (new_sublist -> fn_field.type) & TYPE_FLAG_STUB)
2075             {
2076               if (!TYPE_DOMAIN_TYPE (new_sublist -> fn_field.type))
2077                 TYPE_DOMAIN_TYPE (new_sublist -> fn_field.type) = type;
2078               new_sublist -> fn_field.is_stub = 1;
2079             }
2080           new_sublist -> fn_field.physname = savestring (*pp, p - *pp);
2081           *pp = p + 1;
2082
2083           /* Set this member function's visibility fields.  */
2084           switch (*(*pp)++)
2085             {
2086               case VISIBILITY_PRIVATE:
2087                 new_sublist -> fn_field.is_private = 1;
2088                 break;
2089               case VISIBILITY_PROTECTED:
2090                 new_sublist -> fn_field.is_protected = 1;
2091                 break;
2092             }
2093
2094           STABS_CONTINUE (pp, objfile);
2095           switch (**pp)
2096             {
2097               case 'A': /* Normal functions. */
2098                 new_sublist -> fn_field.is_const = 0;
2099                 new_sublist -> fn_field.is_volatile = 0;
2100                 (*pp)++;
2101                 break;
2102               case 'B': /* `const' member functions. */
2103                 new_sublist -> fn_field.is_const = 1;
2104                 new_sublist -> fn_field.is_volatile = 0;
2105                 (*pp)++;
2106                 break;
2107               case 'C': /* `volatile' member function. */
2108                 new_sublist -> fn_field.is_const = 0;
2109                 new_sublist -> fn_field.is_volatile = 1;
2110                 (*pp)++;
2111                 break;
2112               case 'D': /* `const volatile' member function. */
2113                 new_sublist -> fn_field.is_const = 1;
2114                 new_sublist -> fn_field.is_volatile = 1;
2115                 (*pp)++;
2116                 break;
2117               case '*': /* File compiled with g++ version 1 -- no info */
2118               case '?':
2119               case '.':
2120                 break;
2121               default:
2122                 complain (&const_vol_complaint, **pp);
2123                 break;
2124             }
2125
2126           switch (*(*pp)++)
2127             {
2128               case '*':
2129               {
2130                 int nbits;
2131                 /* virtual member function, followed by index.
2132                    The sign bit is set to distinguish pointers-to-methods
2133                    from virtual function indicies.  Since the array is
2134                    in words, the quantity must be shifted left by 1
2135                    on 16 bit machine, and by 2 on 32 bit machine, forcing
2136                    the sign bit out, and usable as a valid index into
2137                    the array.  Remove the sign bit here.  */
2138                 new_sublist -> fn_field.voffset =
2139                   (0x7fffffff & read_huge_number (pp, ';', &nbits)) + 2;
2140                 if (nbits != 0)
2141                   return 0;
2142
2143                 STABS_CONTINUE (pp, objfile);
2144                 if (**pp == ';' || **pp == '\0')
2145                   {
2146                     /* Must be g++ version 1.  */
2147                     new_sublist -> fn_field.fcontext = 0;
2148                   }
2149                 else
2150                   {
2151                     /* Figure out from whence this virtual function came.
2152                        It may belong to virtual function table of
2153                        one of its baseclasses.  */
2154                     look_ahead_type = read_type (pp, objfile);
2155                     if (**pp == ':')
2156                       {
2157                         /* g++ version 1 overloaded methods. */
2158                       }
2159                     else
2160                       {
2161                         new_sublist -> fn_field.fcontext = look_ahead_type;
2162                         if (**pp != ';')
2163                           {
2164                             return 0;
2165                           }
2166                         else
2167                           {
2168                             ++*pp;
2169                           }
2170                         look_ahead_type = NULL;
2171                       }
2172                   }
2173                 break;
2174               }
2175               case '?':
2176                 /* static member function.  */
2177                 new_sublist -> fn_field.voffset = VOFFSET_STATIC;
2178                 if (strncmp (new_sublist -> fn_field.physname,
2179                              main_fn_name, strlen (main_fn_name)))
2180                   {
2181                     new_sublist -> fn_field.is_stub = 1;
2182                   }
2183                 break;
2184
2185               default:
2186                 /* error */
2187                 complain (&member_fn_complaint, (*pp)[-1]);
2188                 /* Fall through into normal member function.  */
2189
2190               case '.':
2191                 /* normal member function.  */
2192                 new_sublist -> fn_field.voffset = 0;
2193                 new_sublist -> fn_field.fcontext = 0;
2194                 break;
2195             }
2196
2197           new_sublist -> next = sublist;
2198           sublist = new_sublist;
2199           length++;
2200           STABS_CONTINUE (pp, objfile);
2201         }
2202       while (**pp != ';' && **pp != '\0');
2203
2204       (*pp)++;
2205
2206       new_fnlist -> fn_fieldlist.fn_fields = (struct fn_field *)
2207         obstack_alloc (&objfile -> type_obstack,
2208                        sizeof (struct fn_field) * length);
2209       memset (new_fnlist -> fn_fieldlist.fn_fields, 0,
2210               sizeof (struct fn_field) * length);
2211       for (i = length; (i--, sublist); sublist = sublist -> next)
2212         {
2213           new_fnlist -> fn_fieldlist.fn_fields[i] = sublist -> fn_field;
2214         }
2215
2216       new_fnlist -> fn_fieldlist.length = length;
2217       new_fnlist -> next = fip -> fnlist;
2218       fip -> fnlist = new_fnlist;
2219       nfn_fields++;
2220       total_length += length;
2221       STABS_CONTINUE (pp, objfile);
2222     }
2223
2224   if (nfn_fields)
2225     {
2226       ALLOCATE_CPLUS_STRUCT_TYPE (type);
2227       TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
2228         TYPE_ALLOC (type, sizeof (struct fn_fieldlist) * nfn_fields);
2229       memset (TYPE_FN_FIELDLISTS (type), 0,
2230               sizeof (struct fn_fieldlist) * nfn_fields);
2231       TYPE_NFN_FIELDS (type) = nfn_fields;
2232       TYPE_NFN_FIELDS_TOTAL (type) = total_length;
2233     }
2234
2235   return 1;
2236 }
2237
2238 /* Special GNU C++ name.
2239
2240    Returns 1 for success, 0 for failure.  "failure" means that we can't
2241    keep parsing and it's time for error_type().  */
2242
2243 static int
2244 read_cpp_abbrev (fip, pp, type, objfile)
2245      struct field_info *fip;
2246      char **pp;
2247      struct type *type;
2248      struct objfile *objfile;
2249 {
2250   register char *p;
2251   char *name;
2252   char cpp_abbrev;
2253   struct type *context;
2254
2255   p = *pp;
2256   if (*++p == 'v')
2257     {
2258       name = NULL;
2259       cpp_abbrev = *++p;
2260
2261       *pp = p + 1;
2262
2263       /* At this point, *pp points to something like "22:23=*22...",
2264          where the type number before the ':' is the "context" and
2265          everything after is a regular type definition.  Lookup the
2266          type, find it's name, and construct the field name. */
2267
2268       context = read_type (pp, objfile);
2269
2270       switch (cpp_abbrev)
2271         {
2272           case 'f':             /* $vf -- a virtual function table pointer */
2273             fip->list->field.name =
2274               obconcat (&objfile->type_obstack, vptr_name, "", "");
2275             break;
2276
2277           case 'b':             /* $vb -- a virtual bsomethingorother */
2278             name = type_name_no_tag (context);
2279             if (name == NULL)
2280               {
2281                 complain (&invalid_cpp_type_complaint, symnum);
2282                 name = "FOO";
2283               }
2284             fip->list->field.name =
2285               obconcat (&objfile->type_obstack, vb_name, name, "");
2286             break;
2287
2288           default:
2289             complain (&invalid_cpp_abbrev_complaint, *pp);
2290             fip->list->field.name =
2291               obconcat (&objfile->type_obstack,
2292                         "INVALID_CPLUSPLUS_ABBREV", "", "");
2293             break;
2294         }
2295
2296       /* At this point, *pp points to the ':'.  Skip it and read the
2297          field type. */
2298
2299       p = ++(*pp);
2300       if (p[-1] != ':')
2301         {
2302           complain (&invalid_cpp_abbrev_complaint, *pp);
2303           return 0;
2304         }
2305       fip->list->field.type = read_type (pp, objfile);
2306       if (**pp == ',')
2307         (*pp)++;                        /* Skip the comma.  */
2308       else
2309         return 0;
2310
2311       {
2312         int nbits;
2313         fip->list->field.bitpos = read_huge_number (pp, ';', &nbits);
2314         if (nbits != 0)
2315           return 0;
2316       }
2317       /* This field is unpacked.  */
2318       fip->list->field.bitsize = 0;
2319       fip->list->visibility = VISIBILITY_PRIVATE;
2320     }
2321   else
2322     {
2323       complain (&invalid_cpp_abbrev_complaint, *pp);
2324       /* We have no idea what syntax an unrecognized abbrev would have, so
2325          better return 0.  If we returned 1, we would need to at least advance
2326          *pp to avoid an infinite loop.  */
2327       return 0;
2328     }
2329   return 1;
2330 }
2331
2332 static void
2333 read_one_struct_field (fip, pp, p, type, objfile)
2334      struct field_info *fip;
2335      char **pp;
2336      char *p;
2337      struct type *type;
2338      struct objfile *objfile;
2339 {
2340   /* The following is code to work around cfront generated stabs.
2341      The stabs contains full mangled name for each field.
2342      We try to demangle the name and extract the field name out of it.
2343   */
2344   if (ARM_DEMANGLING && current_subfile->language == language_cplus)
2345     {
2346       char save_p;
2347       char *dem, *dem_p;
2348       save_p = *p;
2349       *p = '\0';
2350       dem = cplus_demangle (*pp, DMGL_ANSI | DMGL_PARAMS);
2351       if (dem != NULL)
2352         {
2353           dem_p = strrchr (dem, ':');
2354           if (dem_p != 0 && *(dem_p-1)==':')
2355             dem_p++;
2356           fip->list->field.name =
2357             obsavestring (dem_p, strlen(dem_p), &objfile -> type_obstack);
2358         }
2359       else
2360         {
2361           fip->list->field.name =
2362             obsavestring (*pp, p - *pp, &objfile -> type_obstack);
2363         }
2364       *p = save_p;
2365     }
2366   /* end of code for cfront work around */
2367
2368   else
2369     fip -> list -> field.name =
2370     obsavestring (*pp, p - *pp, &objfile -> type_obstack);
2371   *pp = p + 1;
2372
2373   /* This means we have a visibility for a field coming. */
2374   if (**pp == '/')
2375     {
2376       (*pp)++;
2377       fip -> list -> visibility = *(*pp)++;
2378     }
2379   else
2380     {
2381       /* normal dbx-style format, no explicit visibility */
2382       fip -> list -> visibility = VISIBILITY_PUBLIC;
2383     }
2384
2385   fip -> list -> field.type = read_type (pp, objfile);
2386   if (**pp == ':')
2387     {
2388       p = ++(*pp);
2389 #if 0
2390       /* Possible future hook for nested types. */
2391       if (**pp == '!')
2392         {
2393           fip -> list -> field.bitpos = (long)-2; /* nested type */
2394           p = ++(*pp);
2395         }
2396       else
2397 #endif
2398         {
2399           /* Static class member.  */
2400           fip -> list -> field.bitpos = (long) -1;
2401         }
2402       while (*p != ';')
2403         {
2404           p++;
2405         }
2406       fip -> list -> field.bitsize = (long) savestring (*pp, p - *pp);
2407       *pp = p + 1;
2408       return;
2409     }
2410   else if (**pp != ',')
2411     {
2412       /* Bad structure-type format.  */
2413       complain (&stabs_general_complaint, "bad structure-type format");
2414       return;
2415     }
2416
2417   (*pp)++;                      /* Skip the comma.  */
2418
2419   {
2420     int nbits;
2421     fip -> list -> field.bitpos = read_huge_number (pp, ',', &nbits);
2422     if (nbits != 0)
2423       {
2424         complain (&stabs_general_complaint, "bad structure-type format");
2425         return;
2426       }
2427     fip -> list -> field.bitsize = read_huge_number (pp, ';', &nbits);
2428     if (nbits != 0)
2429       {
2430         complain (&stabs_general_complaint, "bad structure-type format");
2431         return;
2432       }
2433   }
2434
2435   if (fip -> list -> field.bitpos == 0 && fip -> list -> field.bitsize == 0)
2436     {
2437       /* This can happen in two cases: (1) at least for gcc 2.4.5 or so,
2438          it is a field which has been optimized out.  The correct stab for
2439          this case is to use VISIBILITY_IGNORE, but that is a recent
2440          invention.  (2) It is a 0-size array.  For example
2441          union { int num; char str[0]; } foo.  Printing "<no value>" for
2442          str in "p foo" is OK, since foo.str (and thus foo.str[3])
2443          will continue to work, and a 0-size array as a whole doesn't
2444          have any contents to print.
2445
2446          I suspect this probably could also happen with gcc -gstabs (not
2447          -gstabs+) for static fields, and perhaps other C++ extensions.
2448          Hopefully few people use -gstabs with gdb, since it is intended
2449          for dbx compatibility.  */
2450
2451       /* Ignore this field.  */
2452       fip -> list-> visibility = VISIBILITY_IGNORE;
2453     }
2454   else
2455     {
2456       /* Detect an unpacked field and mark it as such.
2457          dbx gives a bit size for all fields.
2458          Note that forward refs cannot be packed,
2459          and treat enums as if they had the width of ints.  */
2460
2461       if (TYPE_CODE (fip -> list -> field.type) != TYPE_CODE_INT
2462           && TYPE_CODE (fip -> list -> field.type) != TYPE_CODE_BOOL
2463           && TYPE_CODE (fip -> list -> field.type) != TYPE_CODE_ENUM)
2464         {
2465           fip -> list -> field.bitsize = 0;
2466         }
2467       if ((fip -> list -> field.bitsize
2468            == TARGET_CHAR_BIT * TYPE_LENGTH (fip -> list -> field.type)
2469            || (TYPE_CODE (fip -> list -> field.type) == TYPE_CODE_ENUM
2470                && (fip -> list -> field.bitsize
2471                    == TARGET_INT_BIT)
2472                )
2473            )
2474           &&
2475           fip -> list -> field.bitpos % 8 == 0)
2476         {
2477           fip -> list -> field.bitsize = 0;
2478         }
2479     }
2480 }
2481
2482
2483 /* Read struct or class data fields.  They have the form:
2484
2485         NAME : [VISIBILITY] TYPENUM , BITPOS , BITSIZE ;
2486
2487    At the end, we see a semicolon instead of a field.
2488
2489    In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
2490    a static field.
2491
2492    The optional VISIBILITY is one of:
2493
2494         '/0'    (VISIBILITY_PRIVATE)
2495         '/1'    (VISIBILITY_PROTECTED)
2496         '/2'    (VISIBILITY_PUBLIC)
2497         '/9'    (VISIBILITY_IGNORE)
2498
2499    or nothing, for C style fields with public visibility.
2500
2501    Returns 1 for success, 0 for failure.  */
2502
2503 static int
2504 read_struct_fields (fip, pp, type, objfile)
2505      struct field_info *fip;
2506      char **pp;
2507      struct type *type;
2508      struct objfile *objfile;
2509 {
2510   register char *p;
2511   struct nextfield *new;
2512
2513   /* We better set p right now, in case there are no fields at all...    */
2514
2515   p = *pp;
2516
2517   /* Read each data member type until we find the terminating ';' at the end of
2518      the data member list, or break for some other reason such as finding the
2519      start of the member function list. */
2520
2521   while (**pp != ';')
2522     {
2523       if (os9k_stabs && **pp == ',') break;
2524       STABS_CONTINUE (pp, objfile);
2525       /* Get space to record the next field's data.  */
2526       new = (struct nextfield *) xmalloc (sizeof (struct nextfield));
2527       make_cleanup (free, new);
2528       memset (new, 0, sizeof (struct nextfield));
2529       new -> next = fip -> list;
2530       fip -> list = new;
2531
2532       /* Get the field name.  */
2533       p = *pp;
2534
2535       /* If is starts with CPLUS_MARKER it is a special abbreviation,
2536          unless the CPLUS_MARKER is followed by an underscore, in
2537          which case it is just the name of an anonymous type, which we
2538          should handle like any other type name.  We accept either '$'
2539          or '.', because a field name can never contain one of these
2540          characters except as a CPLUS_MARKER (we probably should be
2541          doing that in most parts of GDB).  */
2542
2543       if ((*p == '$' || *p == '.') && p[1] != '_')
2544         {
2545           if (!read_cpp_abbrev (fip, pp, type, objfile))
2546             return 0;
2547           continue;
2548         }
2549
2550       /* Look for the ':' that separates the field name from the field
2551          values.  Data members are delimited by a single ':', while member
2552          functions are delimited by a pair of ':'s.  When we hit the member
2553          functions (if any), terminate scan loop and return. */
2554
2555       while (*p != ':' && *p != '\0')
2556         {
2557           p++;
2558         }
2559       if (*p == '\0')
2560         return 0;
2561
2562       /* Check to see if we have hit the member functions yet.  */
2563       if (p[1] == ':')
2564         {
2565           break;
2566         }
2567       read_one_struct_field (fip, pp, p, type, objfile);
2568     }
2569   if (p[0] == ':' && p[1] == ':')
2570     {
2571       /* chill the list of fields: the last entry (at the head) is a
2572          partially constructed entry which we now scrub. */
2573       fip -> list = fip -> list -> next;
2574     }
2575   return 1;
2576 }
2577
2578 /* The stabs for C++ derived classes contain baseclass information which
2579    is marked by a '!' character after the total size.  This function is
2580    called when we encounter the baseclass marker, and slurps up all the
2581    baseclass information.
2582
2583    Immediately following the '!' marker is the number of base classes that
2584    the class is derived from, followed by information for each base class.
2585    For each base class, there are two visibility specifiers, a bit offset
2586    to the base class information within the derived class, a reference to
2587    the type for the base class, and a terminating semicolon.
2588
2589    A typical example, with two base classes, would be "!2,020,19;0264,21;".
2590                                                        ^^ ^ ^ ^  ^ ^  ^
2591         Baseclass information marker __________________|| | | |  | |  |
2592         Number of baseclasses __________________________| | | |  | |  |
2593         Visibility specifiers (2) ________________________| | |  | |  |
2594         Offset in bits from start of class _________________| |  | |  |
2595         Type number for base class ___________________________|  | |  |
2596         Visibility specifiers (2) _______________________________| |  |
2597         Offset in bits from start of class ________________________|  |
2598         Type number of base class ____________________________________|
2599
2600   Return 1 for success, 0 for (error-type-inducing) failure.  */
2601
2602 static int
2603 read_baseclasses (fip, pp, type, objfile)
2604      struct field_info *fip;
2605      char **pp;
2606      struct type *type;
2607      struct objfile *objfile;
2608 {
2609   int i;
2610   struct nextfield *new;
2611
2612   if (**pp != '!')
2613     {
2614       return 1;
2615     }
2616   else
2617     {
2618       /* Skip the '!' baseclass information marker. */
2619       (*pp)++;
2620     }
2621
2622   ALLOCATE_CPLUS_STRUCT_TYPE (type);
2623   {
2624     int nbits;
2625     TYPE_N_BASECLASSES (type) = read_huge_number (pp, ',', &nbits);
2626     if (nbits != 0)
2627       return 0;
2628   }
2629
2630 #if 0
2631   /* Some stupid compilers have trouble with the following, so break
2632      it up into simpler expressions.  */
2633   TYPE_FIELD_VIRTUAL_BITS (type) = (B_TYPE *)
2634     TYPE_ALLOC (type, B_BYTES (TYPE_N_BASECLASSES (type)));
2635 #else
2636   {
2637     int num_bytes = B_BYTES (TYPE_N_BASECLASSES (type));
2638     char *pointer;
2639
2640     pointer = (char *) TYPE_ALLOC (type, num_bytes);
2641     TYPE_FIELD_VIRTUAL_BITS (type) = (B_TYPE *) pointer;
2642   }
2643 #endif /* 0 */
2644
2645   B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), TYPE_N_BASECLASSES (type));
2646
2647   for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
2648     {
2649       new = (struct nextfield *) xmalloc (sizeof (struct nextfield));
2650       make_cleanup (free, new);
2651       memset (new, 0, sizeof (struct nextfield));
2652       new -> next = fip -> list;
2653       fip -> list = new;
2654       new -> field.bitsize = 0; /* this should be an unpacked field! */
2655
2656       STABS_CONTINUE (pp, objfile);
2657       switch (**pp)
2658         {
2659           case '0':
2660             /* Nothing to do. */
2661             break;
2662           case '1':
2663             SET_TYPE_FIELD_VIRTUAL (type, i);
2664             break;
2665           default:
2666             /* Unknown character.  Complain and treat it as non-virtual.  */
2667             {
2668               static struct complaint msg = {
2669                 "Unknown virtual character `%c' for baseclass", 0, 0};
2670               complain (&msg, **pp);
2671             }
2672         }
2673       ++(*pp);
2674
2675       new -> visibility = *(*pp)++;
2676       switch (new -> visibility)
2677         {
2678           case VISIBILITY_PRIVATE:
2679           case VISIBILITY_PROTECTED:
2680           case VISIBILITY_PUBLIC:
2681             break;
2682           default:
2683             /* Bad visibility format.  Complain and treat it as
2684                public.  */
2685             {
2686               static struct complaint msg = {
2687                 "Unknown visibility `%c' for baseclass", 0, 0};
2688               complain (&msg, new -> visibility);
2689               new -> visibility = VISIBILITY_PUBLIC;
2690             }
2691         }
2692
2693       {
2694         int nbits;
2695
2696         /* The remaining value is the bit offset of the portion of the object
2697            corresponding to this baseclass.  Always zero in the absence of
2698            multiple inheritance.  */
2699
2700         new -> field.bitpos = read_huge_number (pp, ',', &nbits);
2701         if (nbits != 0)
2702           return 0;
2703       }
2704
2705       /* The last piece of baseclass information is the type of the
2706          base class.  Read it, and remember it's type name as this
2707          field's name. */
2708
2709       new -> field.type = read_type (pp, objfile);
2710       new -> field.name = type_name_no_tag (new -> field.type);
2711
2712       /* skip trailing ';' and bump count of number of fields seen */
2713       if (**pp == ';')
2714         (*pp)++;
2715       else
2716         return 0;
2717     }
2718   return 1;
2719 }
2720
2721 /* The tail end of stabs for C++ classes that contain a virtual function
2722    pointer contains a tilde, a %, and a type number.
2723    The type number refers to the base class (possibly this class itself) which
2724    contains the vtable pointer for the current class.
2725
2726    This function is called when we have parsed all the method declarations,
2727    so we can look for the vptr base class info.  */
2728
2729 static int
2730 read_tilde_fields (fip, pp, type, objfile)
2731      struct field_info *fip;
2732      char **pp;
2733      struct type *type;
2734      struct objfile *objfile;
2735 {
2736   register char *p;
2737
2738   STABS_CONTINUE (pp, objfile);
2739
2740   /* If we are positioned at a ';', then skip it. */
2741   if (**pp == ';')
2742     {
2743       (*pp)++;
2744     }
2745
2746   if (**pp == '~')
2747     {
2748       (*pp)++;
2749
2750       if (**pp == '=' || **pp == '+' || **pp == '-')
2751         {
2752           /* Obsolete flags that used to indicate the presence
2753              of constructors and/or destructors. */
2754           (*pp)++;
2755         }
2756
2757       /* Read either a '%' or the final ';'.  */
2758       if (*(*pp)++ == '%')
2759         {
2760           /* The next number is the type number of the base class
2761              (possibly our own class) which supplies the vtable for
2762              this class.  Parse it out, and search that class to find
2763              its vtable pointer, and install those into TYPE_VPTR_BASETYPE
2764              and TYPE_VPTR_FIELDNO.  */
2765
2766           struct type *t;
2767           int i;
2768
2769           t = read_type (pp, objfile);
2770           p = (*pp)++;
2771           while (*p != '\0' && *p != ';')
2772             {
2773               p++;
2774             }
2775           if (*p == '\0')
2776             {
2777               /* Premature end of symbol.  */
2778               return 0;
2779             }
2780
2781           TYPE_VPTR_BASETYPE (type) = t;
2782           if (type == t)                /* Our own class provides vtbl ptr */
2783             {
2784               for (i = TYPE_NFIELDS (t) - 1;
2785                    i >= TYPE_N_BASECLASSES (t);
2786                    --i)
2787                 {
2788                   if (! strncmp (TYPE_FIELD_NAME (t, i), vptr_name,
2789                                  sizeof (vptr_name) - 1))
2790                     {
2791                       TYPE_VPTR_FIELDNO (type) = i;
2792                       goto gotit;
2793                     }
2794                 }
2795               /* Virtual function table field not found.  */
2796               complain (&vtbl_notfound_complaint, TYPE_NAME (type));
2797               return 0;
2798             }
2799           else
2800             {
2801               TYPE_VPTR_FIELDNO (type) = TYPE_VPTR_FIELDNO (t);
2802             }
2803
2804     gotit:
2805           *pp = p + 1;
2806         }
2807     }
2808   return 1;
2809 }
2810
2811 static int
2812 attach_fn_fields_to_type (fip, type)
2813      struct field_info *fip;
2814      register struct type *type;
2815 {
2816   register int n;
2817
2818   for (n = TYPE_NFN_FIELDS (type);
2819        fip -> fnlist != NULL;
2820        fip -> fnlist = fip -> fnlist -> next)
2821     {
2822       --n;                      /* Circumvent Sun3 compiler bug */
2823       TYPE_FN_FIELDLISTS (type)[n] = fip -> fnlist -> fn_fieldlist;
2824     }
2825   return 1;
2826 }
2827
2828 /* Create the vector of fields, and record how big it is.
2829    We need this info to record proper virtual function table information
2830    for this class's virtual functions.  */
2831
2832 static int
2833 attach_fields_to_type (fip, type, objfile)
2834      struct field_info *fip;
2835      register struct type *type;
2836      struct objfile *objfile;
2837 {
2838   register int nfields = 0;
2839   register int non_public_fields = 0;
2840   register struct nextfield *scan;
2841
2842   /* Count up the number of fields that we have, as well as taking note of
2843      whether or not there are any non-public fields, which requires us to
2844      allocate and build the private_field_bits and protected_field_bits
2845      bitfields. */
2846
2847   for (scan = fip -> list; scan != NULL; scan = scan -> next)
2848     {
2849       nfields++;
2850       if (scan -> visibility != VISIBILITY_PUBLIC)
2851         {
2852           non_public_fields++;
2853         }
2854     }
2855
2856   /* Now we know how many fields there are, and whether or not there are any
2857      non-public fields.  Record the field count, allocate space for the
2858      array of fields, and create blank visibility bitfields if necessary. */
2859
2860   TYPE_NFIELDS (type) = nfields;
2861   TYPE_FIELDS (type) = (struct field *)
2862     TYPE_ALLOC (type, sizeof (struct field) * nfields);
2863   memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nfields);
2864
2865   if (non_public_fields)
2866     {
2867       ALLOCATE_CPLUS_STRUCT_TYPE (type);
2868
2869       TYPE_FIELD_PRIVATE_BITS (type) =
2870         (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
2871       B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
2872
2873       TYPE_FIELD_PROTECTED_BITS (type) =
2874         (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
2875       B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
2876
2877       TYPE_FIELD_IGNORE_BITS (type) =
2878         (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
2879       B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
2880     }
2881
2882   /* Copy the saved-up fields into the field vector.  Start from the head
2883      of the list, adding to the tail of the field array, so that they end
2884      up in the same order in the array in which they were added to the list. */
2885
2886   while (nfields-- > 0)
2887     {
2888       TYPE_FIELD (type, nfields) = fip -> list -> field;
2889       switch (fip -> list -> visibility)
2890         {
2891           case VISIBILITY_PRIVATE:
2892             SET_TYPE_FIELD_PRIVATE (type, nfields);
2893             break;
2894
2895           case VISIBILITY_PROTECTED:
2896             SET_TYPE_FIELD_PROTECTED (type, nfields);
2897             break;
2898
2899           case VISIBILITY_IGNORE:
2900             SET_TYPE_FIELD_IGNORE (type, nfields);
2901             break;
2902
2903           case VISIBILITY_PUBLIC:
2904             break;
2905
2906           default:
2907             /* Unknown visibility.  Complain and treat it as public.  */
2908             {
2909               static struct complaint msg = {
2910                 "Unknown visibility `%c' for field", 0, 0};
2911               complain (&msg, fip -> list -> visibility);
2912             }
2913             break;
2914         }
2915       fip -> list = fip -> list -> next;
2916     }
2917   return 1;
2918 }
2919
2920 /* Read the description of a structure (or union type) and return an object
2921    describing the type.
2922
2923    PP points to a character pointer that points to the next unconsumed token
2924    in the the stabs string.  For example, given stabs "A:T4=s4a:1,0,32;;",
2925    *PP will point to "4a:1,0,32;;".
2926
2927    TYPE points to an incomplete type that needs to be filled in.
2928
2929    OBJFILE points to the current objfile from which the stabs information is
2930    being read.  (Note that it is redundant in that TYPE also contains a pointer
2931    to this same objfile, so it might be a good idea to eliminate it.  FIXME).
2932    */
2933
2934 static struct type *
2935 read_struct_type (pp, type, objfile)
2936      char **pp;
2937      struct type *type;
2938      struct objfile *objfile;
2939 {
2940   struct cleanup *back_to;
2941   struct field_info fi;
2942
2943   fi.list = NULL;
2944   fi.fnlist = NULL;
2945
2946   back_to = make_cleanup (null_cleanup, 0);
2947
2948   INIT_CPLUS_SPECIFIC (type);
2949   TYPE_FLAGS (type) &= ~TYPE_FLAG_STUB;
2950
2951   /* First comes the total size in bytes.  */
2952
2953   {
2954     int nbits;
2955     TYPE_LENGTH (type) = read_huge_number (pp, 0, &nbits);
2956     if (nbits != 0)
2957       return error_type (pp, objfile);
2958   }
2959
2960   /* Now read the baseclasses, if any, read the regular C struct or C++
2961      class member fields, attach the fields to the type, read the C++
2962      member functions, attach them to the type, and then read any tilde
2963      field (baseclass specifier for the class holding the main vtable). */
2964
2965   if (!read_baseclasses (&fi, pp, type, objfile)
2966       || !read_struct_fields (&fi, pp, type, objfile)
2967       || !attach_fields_to_type (&fi, type, objfile)
2968       || !read_member_functions (&fi, pp, type, objfile)
2969       || !attach_fn_fields_to_type (&fi, type)
2970       || !read_tilde_fields (&fi, pp, type, objfile))
2971     {
2972       type = error_type (pp, objfile);
2973     }
2974
2975   do_cleanups (back_to);
2976   return (type);
2977 }
2978
2979 /* Read a definition of an array type,
2980    and create and return a suitable type object.
2981    Also creates a range type which represents the bounds of that
2982    array.  */
2983
2984 static struct type *
2985 read_array_type (pp, type, objfile)
2986      register char **pp;
2987      register struct type *type;
2988      struct objfile *objfile;
2989 {
2990   struct type *index_type, *element_type, *range_type;
2991   int lower, upper;
2992   int adjustable = 0;
2993   int nbits;
2994
2995   /* Format of an array type:
2996      "ar<index type>;lower;upper;<array_contents_type>".
2997      OS9000: "arlower,upper;<array_contents_type>".
2998
2999      Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
3000      for these, produce a type like float[][].  */
3001
3002   if (os9k_stabs)
3003     index_type = builtin_type_int;
3004   else
3005     {
3006       index_type = read_type (pp, objfile);
3007       if (**pp != ';')
3008         /* Improper format of array type decl.  */
3009         return error_type (pp, objfile);
3010       ++*pp;
3011     }
3012
3013   if (!(**pp >= '0' && **pp <= '9') && **pp != '-')
3014     {
3015       (*pp)++;
3016       adjustable = 1;
3017     }
3018   lower = read_huge_number (pp, os9k_stabs ? ',' : ';', &nbits);
3019   if (nbits != 0)
3020     return error_type (pp, objfile);
3021
3022   if (!(**pp >= '0' && **pp <= '9') && **pp != '-')
3023     {
3024       (*pp)++;
3025       adjustable = 1;
3026     }
3027   upper = read_huge_number (pp, ';', &nbits);
3028   if (nbits != 0)
3029     return error_type (pp, objfile);
3030
3031   element_type = read_type (pp, objfile);
3032
3033   if (adjustable)
3034     {
3035       lower = 0;
3036       upper = -1;
3037     }
3038
3039   range_type =
3040     create_range_type ((struct type *) NULL, index_type, lower, upper);
3041   type = create_array_type (type, element_type, range_type);
3042
3043   return type;
3044 }
3045
3046
3047 /* Read a definition of an enumeration type,
3048    and create and return a suitable type object.
3049    Also defines the symbols that represent the values of the type.  */
3050
3051 static struct type *
3052 read_enum_type (pp, type, objfile)
3053      register char **pp;
3054      register struct type *type;
3055      struct objfile *objfile;
3056 {
3057   register char *p;
3058   char *name;
3059   register long n;
3060   register struct symbol *sym;
3061   int nsyms = 0;
3062   struct pending **symlist;
3063   struct pending *osyms, *syms;
3064   int o_nsyms;
3065   int nbits;
3066   int unsigned_enum = 1;
3067
3068 #if 0
3069   /* FIXME!  The stabs produced by Sun CC merrily define things that ought
3070      to be file-scope, between N_FN entries, using N_LSYM.  What's a mother
3071      to do?  For now, force all enum values to file scope.  */
3072   if (within_function)
3073     symlist = &local_symbols;
3074   else
3075 #endif
3076     symlist = &file_symbols;
3077   osyms = *symlist;
3078   o_nsyms = osyms ? osyms->nsyms : 0;
3079
3080   if (os9k_stabs)
3081     {
3082       /* Size.  Perhaps this does not have to be conditionalized on
3083          os9k_stabs (assuming the name of an enum constant can't start
3084          with a digit).  */
3085       read_huge_number (pp, 0, &nbits);
3086       if (nbits != 0)
3087         return error_type (pp, objfile);
3088     }
3089
3090   /* The aix4 compiler emits an extra field before the enum members;
3091      my guess is it's a type of some sort.  Just ignore it.  */
3092   if (**pp == '-')
3093     {
3094       /* Skip over the type.  */
3095       while (**pp != ':')
3096         (*pp)++;
3097
3098       /* Skip over the colon.  */
3099       (*pp)++;
3100     }
3101
3102   /* Read the value-names and their values.
3103      The input syntax is NAME:VALUE,NAME:VALUE, and so on.
3104      A semicolon or comma instead of a NAME means the end.  */
3105   while (**pp && **pp != ';' && **pp != ',')
3106     {
3107       STABS_CONTINUE (pp, objfile);
3108       p = *pp;
3109       while (*p != ':') p++;
3110       name = obsavestring (*pp, p - *pp, &objfile -> symbol_obstack);
3111       *pp = p + 1;
3112       n = read_huge_number (pp, ',', &nbits);
3113       if (nbits != 0)
3114         return error_type (pp, objfile);
3115
3116       sym = (struct symbol *)
3117         obstack_alloc (&objfile -> symbol_obstack, sizeof (struct symbol));
3118       memset (sym, 0, sizeof (struct symbol));
3119       SYMBOL_NAME (sym) = name;
3120       SYMBOL_LANGUAGE (sym) = current_subfile -> language;
3121       SYMBOL_CLASS (sym) = LOC_CONST;
3122       SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
3123       SYMBOL_VALUE (sym) = n;
3124       if (n < 0)
3125         unsigned_enum = 0;
3126       add_symbol_to_list (sym, symlist);
3127       nsyms++;
3128     }
3129
3130   if (**pp == ';')
3131     (*pp)++;                    /* Skip the semicolon.  */
3132
3133   /* Now fill in the fields of the type-structure.  */
3134
3135   TYPE_LENGTH (type) = TARGET_INT_BIT / HOST_CHAR_BIT;
3136   TYPE_CODE (type) = TYPE_CODE_ENUM;
3137   TYPE_FLAGS (type) &= ~TYPE_FLAG_STUB;
3138   if (unsigned_enum)
3139     TYPE_FLAGS (type) |= TYPE_FLAG_UNSIGNED;
3140   TYPE_NFIELDS (type) = nsyms;
3141   TYPE_FIELDS (type) = (struct field *)
3142     TYPE_ALLOC (type, sizeof (struct field) * nsyms);
3143   memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nsyms);
3144
3145   /* Find the symbols for the values and put them into the type.
3146      The symbols can be found in the symlist that we put them on
3147      to cause them to be defined.  osyms contains the old value
3148      of that symlist; everything up to there was defined by us.  */
3149   /* Note that we preserve the order of the enum constants, so
3150      that in something like "enum {FOO, LAST_THING=FOO}" we print
3151      FOO, not LAST_THING.  */
3152
3153   for (syms = *symlist, n = nsyms - 1; syms; syms = syms->next)
3154     {
3155       int last = syms == osyms ? o_nsyms : 0;
3156       int j = syms->nsyms;
3157       for (; --j >= last; --n)
3158         {
3159           struct symbol *xsym = syms->symbol[j];
3160           SYMBOL_TYPE (xsym) = type;
3161           TYPE_FIELD_NAME (type, n) = SYMBOL_NAME (xsym);
3162           TYPE_FIELD_VALUE (type, n) = 0;
3163           TYPE_FIELD_BITPOS (type, n) = SYMBOL_VALUE (xsym);
3164           TYPE_FIELD_BITSIZE (type, n) = 0;
3165         }
3166       if (syms == osyms)
3167         break;
3168     }
3169
3170   return type;
3171 }
3172
3173 /* Sun's ACC uses a somewhat saner method for specifying the builtin
3174    typedefs in every file (for int, long, etc):
3175
3176         type = b <signed> <width>; <offset>; <nbits>
3177         signed = u or s.  Possible c in addition to u or s (for char?).
3178         offset = offset from high order bit to start bit of type.
3179         width is # bytes in object of this type, nbits is # bits in type.
3180
3181    The width/offset stuff appears to be for small objects stored in
3182    larger ones (e.g. `shorts' in `int' registers).  We ignore it for now,
3183    FIXME.  */
3184
3185 static struct type *
3186 read_sun_builtin_type (pp, typenums, objfile)
3187      char **pp;
3188      int typenums[2];
3189      struct objfile *objfile;
3190 {
3191   int type_bits;
3192   int nbits;
3193   int signed_type;
3194
3195   switch (**pp)
3196     {
3197       case 's':
3198         signed_type = 1;
3199         break;
3200       case 'u':
3201         signed_type = 0;
3202         break;
3203       default:
3204         return error_type (pp, objfile);
3205     }
3206   (*pp)++;
3207
3208   /* For some odd reason, all forms of char put a c here.  This is strange
3209      because no other type has this honor.  We can safely ignore this because
3210      we actually determine 'char'acterness by the number of bits specified in
3211      the descriptor.  */
3212
3213   if (**pp == 'c')
3214     (*pp)++;
3215
3216   /* The first number appears to be the number of bytes occupied
3217      by this type, except that unsigned short is 4 instead of 2.
3218      Since this information is redundant with the third number,
3219      we will ignore it.  */
3220   read_huge_number (pp, ';', &nbits);
3221   if (nbits != 0)
3222     return error_type (pp, objfile);
3223
3224   /* The second number is always 0, so ignore it too. */
3225   read_huge_number (pp, ';', &nbits);
3226   if (nbits != 0)
3227     return error_type (pp, objfile);
3228
3229   /* The third number is the number of bits for this type. */
3230   type_bits = read_huge_number (pp, 0, &nbits);
3231   if (nbits != 0)
3232     return error_type (pp, objfile);
3233   /* The type *should* end with a semicolon.  If it are embedded
3234      in a larger type the semicolon may be the only way to know where
3235      the type ends.  If this type is at the end of the stabstring we
3236      can deal with the omitted semicolon (but we don't have to like
3237      it).  Don't bother to complain(), Sun's compiler omits the semicolon
3238      for "void".  */
3239   if (**pp == ';')
3240     ++(*pp);
3241
3242   if (type_bits == 0)
3243     return init_type (TYPE_CODE_VOID, 1,
3244                       signed_type ? 0 : TYPE_FLAG_UNSIGNED, (char *)NULL,
3245                       objfile);
3246   else
3247     return init_type (TYPE_CODE_INT,
3248                       type_bits / TARGET_CHAR_BIT,
3249                       signed_type ? 0 : TYPE_FLAG_UNSIGNED, (char *)NULL,
3250                       objfile);
3251 }
3252
3253 static struct type *
3254 read_sun_floating_type (pp, typenums, objfile)
3255      char **pp;
3256      int typenums[2];
3257      struct objfile *objfile;
3258 {
3259   int nbits;
3260   int details;
3261   int nbytes;
3262
3263   /* The first number has more details about the type, for example
3264      FN_COMPLEX.  */
3265   details = read_huge_number (pp, ';', &nbits);
3266   if (nbits != 0)
3267     return error_type (pp, objfile);
3268
3269   /* The second number is the number of bytes occupied by this type */
3270   nbytes = read_huge_number (pp, ';', &nbits);
3271   if (nbits != 0)
3272     return error_type (pp, objfile);
3273
3274   if (details == NF_COMPLEX || details == NF_COMPLEX16
3275       || details == NF_COMPLEX32)
3276     /* This is a type we can't handle, but we do know the size.
3277        We also will be able to give it a name.  */
3278     return init_type (TYPE_CODE_ERROR, nbytes, 0, NULL, objfile);
3279
3280   return init_type (TYPE_CODE_FLT, nbytes, 0, NULL, objfile);
3281 }
3282
3283 /* Read a number from the string pointed to by *PP.
3284    The value of *PP is advanced over the number.
3285    If END is nonzero, the character that ends the
3286    number must match END, or an error happens;
3287    and that character is skipped if it does match.
3288    If END is zero, *PP is left pointing to that character.
3289
3290    If the number fits in a long, set *BITS to 0 and return the value.
3291    If not, set *BITS to be the number of bits in the number and return 0.
3292
3293    If encounter garbage, set *BITS to -1 and return 0.  */
3294
3295 static long
3296 read_huge_number (pp, end, bits)
3297      char **pp;
3298      int end;
3299      int *bits;
3300 {
3301   char *p = *pp;
3302   int sign = 1;
3303   long n = 0;
3304   int radix = 10;
3305   char overflow = 0;
3306   int nbits = 0;
3307   int c;
3308   long upper_limit;
3309
3310   if (*p == '-')
3311     {
3312       sign = -1;
3313       p++;
3314     }
3315
3316   /* Leading zero means octal.  GCC uses this to output values larger
3317      than an int (because that would be hard in decimal).  */
3318   if (*p == '0')
3319     {
3320       radix = 8;
3321       p++;
3322     }
3323
3324   if (os9k_stabs)
3325     upper_limit = ULONG_MAX / radix;
3326   else
3327     upper_limit = LONG_MAX / radix;
3328
3329   while ((c = *p++) >= '0' && c < ('0' + radix))
3330     {
3331       if (n <= upper_limit)
3332         {
3333           n *= radix;
3334           n += c - '0';         /* FIXME this overflows anyway */
3335         }
3336       else
3337         overflow = 1;
3338
3339       /* This depends on large values being output in octal, which is
3340          what GCC does. */
3341       if (radix == 8)
3342         {
3343           if (nbits == 0)
3344             {
3345               if (c == '0')
3346                 /* Ignore leading zeroes.  */
3347                 ;
3348               else if (c == '1')
3349                 nbits = 1;
3350               else if (c == '2' || c == '3')
3351                 nbits = 2;
3352               else
3353                 nbits = 3;
3354             }
3355           else
3356             nbits += 3;
3357         }
3358     }
3359   if (end)
3360     {
3361       if (c && c != end)
3362         {
3363           if (bits != NULL)
3364             *bits = -1;
3365           return 0;
3366         }
3367     }
3368   else
3369     --p;
3370
3371   *pp = p;
3372   if (overflow)
3373     {
3374       if (nbits == 0)
3375         {
3376           /* Large decimal constants are an error (because it is hard to
3377              count how many bits are in them).  */
3378           if (bits != NULL)
3379             *bits = -1;
3380           return 0;
3381         }
3382
3383       /* -0x7f is the same as 0x80.  So deal with it by adding one to
3384          the number of bits.  */
3385       if (sign == -1)
3386         ++nbits;
3387       if (bits)
3388         *bits = nbits;
3389     }
3390   else
3391     {
3392       if (bits)
3393         *bits = 0;
3394       return n * sign;
3395     }
3396   /* It's *BITS which has the interesting information.  */
3397   return 0;
3398 }
3399
3400 static struct type *
3401 read_range_type (pp, typenums, objfile)
3402      char **pp;
3403      int typenums[2];
3404      struct objfile *objfile;
3405 {
3406   char *orig_pp = *pp;
3407   int rangenums[2];
3408   long n2, n3;
3409   int n2bits, n3bits;
3410   int self_subrange;
3411   struct type *result_type;
3412   struct type *index_type = NULL;
3413
3414   /* First comes a type we are a subrange of.
3415      In C it is usually 0, 1 or the type being defined.  */
3416   if (read_type_number (pp, rangenums) != 0)
3417     return error_type (pp, objfile);
3418   self_subrange = (rangenums[0] == typenums[0] &&
3419                    rangenums[1] == typenums[1]);
3420
3421   if (**pp == '=')
3422     {
3423       *pp = orig_pp;
3424       index_type = read_type (pp, objfile);
3425     }
3426
3427   /* A semicolon should now follow; skip it.  */
3428   if (**pp == ';')
3429     (*pp)++;
3430
3431   /* The remaining two operands are usually lower and upper bounds
3432      of the range.  But in some special cases they mean something else.  */
3433   n2 = read_huge_number (pp, ';', &n2bits);
3434   n3 = read_huge_number (pp, ';', &n3bits);
3435
3436   if (n2bits == -1 || n3bits == -1)
3437     return error_type (pp, objfile);
3438
3439   if (index_type)
3440     goto handle_true_range;
3441
3442   /* If limits are huge, must be large integral type.  */
3443   if (n2bits != 0 || n3bits != 0)
3444     {
3445       char got_signed = 0;
3446       char got_unsigned = 0;
3447       /* Number of bits in the type.  */
3448       int nbits = 0;
3449
3450       /* Range from 0 to <large number> is an unsigned large integral type.  */
3451       if ((n2bits == 0 && n2 == 0) && n3bits != 0)
3452         {
3453           got_unsigned = 1;
3454           nbits = n3bits;
3455         }
3456       /* Range from <large number> to <large number>-1 is a large signed
3457          integral type.  Take care of the case where <large number> doesn't
3458          fit in a long but <large number>-1 does.  */
3459       else if ((n2bits != 0 && n3bits != 0 && n2bits == n3bits + 1)
3460                || (n2bits != 0 && n3bits == 0
3461                    && (n2bits == sizeof (long) * HOST_CHAR_BIT)
3462                    && n3 == LONG_MAX))
3463         {
3464           got_signed = 1;
3465           nbits = n2bits;
3466         }
3467
3468       if (got_signed || got_unsigned)
3469         {
3470           return init_type (TYPE_CODE_INT, nbits / TARGET_CHAR_BIT,
3471                             got_unsigned ? TYPE_FLAG_UNSIGNED : 0, NULL,
3472                             objfile);
3473         }
3474       else
3475         return error_type (pp, objfile);
3476     }
3477
3478   /* A type defined as a subrange of itself, with bounds both 0, is void.  */
3479   if (self_subrange && n2 == 0 && n3 == 0)
3480     return init_type (TYPE_CODE_VOID, 1, 0, NULL, objfile);
3481
3482   /* If n3 is zero and n2 is positive, we want a floating type,
3483      and n2 is the width in bytes.
3484
3485      Fortran programs appear to use this for complex types also,
3486      and they give no way to distinguish between double and single-complex!
3487
3488      GDB does not have complex types.
3489
3490      Just return the complex as a float of that size.  It won't work right
3491      for the complex values, but at least it makes the file loadable.  */
3492
3493   if (n3 == 0 && n2 > 0)
3494     {
3495       return init_type (TYPE_CODE_FLT, n2, 0, NULL, objfile);
3496     }
3497
3498   /* If the upper bound is -1, it must really be an unsigned int.  */
3499
3500   else if (n2 == 0 && n3 == -1)
3501     {
3502       /* It is unsigned int or unsigned long.  */
3503       /* GCC 2.3.3 uses this for long long too, but that is just a GDB 3.5
3504          compatibility hack.  */
3505       return init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
3506                         TYPE_FLAG_UNSIGNED, NULL, objfile);
3507     }
3508
3509   /* Special case: char is defined (Who knows why) as a subrange of
3510      itself with range 0-127.  */
3511   else if (self_subrange && n2 == 0 && n3 == 127)
3512     return init_type (TYPE_CODE_INT, 1, 0, NULL, objfile);
3513
3514   else if (current_symbol && SYMBOL_LANGUAGE (current_symbol) == language_chill
3515       && SYMBOL_LINE (current_symbol) > 0)
3516     goto handle_true_range;
3517
3518   /* We used to do this only for subrange of self or subrange of int.  */
3519   else if (n2 == 0)
3520     {
3521       if (n3 < 0)
3522         /* n3 actually gives the size.  */
3523         return init_type (TYPE_CODE_INT, - n3, TYPE_FLAG_UNSIGNED,
3524                           NULL, objfile);
3525       if (n3 == 0xff)
3526         return init_type (TYPE_CODE_INT, 1, TYPE_FLAG_UNSIGNED, NULL, objfile);
3527       if (n3 == 0xffff)
3528         return init_type (TYPE_CODE_INT, 2, TYPE_FLAG_UNSIGNED, NULL, objfile);
3529
3530       /* -1 is used for the upper bound of (4 byte) "unsigned int" and
3531          "unsigned long", and we already checked for that,
3532          so don't need to test for it here.  */
3533     }
3534   /* I think this is for Convex "long long".  Since I don't know whether
3535      Convex sets self_subrange, I also accept that particular size regardless
3536      of self_subrange.  */
3537   else if (n3 == 0 && n2 < 0
3538            && (self_subrange
3539                || n2 == - TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT))
3540     return init_type (TYPE_CODE_INT, - n2, 0, NULL, objfile);
3541   else if (n2 == -n3 -1)
3542     {
3543       if (n3 == 0x7f)
3544         return init_type (TYPE_CODE_INT, 1, 0, NULL, objfile);
3545       if (n3 == 0x7fff)
3546         return init_type (TYPE_CODE_INT, 2, 0, NULL, objfile);
3547       if (n3 == 0x7fffffff)
3548         return init_type (TYPE_CODE_INT, 4, 0, NULL, objfile);
3549     }
3550
3551   /* We have a real range type on our hands.  Allocate space and
3552      return a real pointer.  */
3553  handle_true_range:
3554
3555   /* At this point I don't have the faintest idea how to deal with
3556      a self_subrange type; I'm going to assume that this is used
3557      as an idiom, and that all of them are special cases.  So . . .  */
3558   if (self_subrange)
3559     return error_type (pp, objfile);
3560
3561   index_type = *dbx_lookup_type (rangenums);
3562   if (index_type == NULL)
3563     {
3564       /* Does this actually ever happen?  Is that why we are worrying
3565          about dealing with it rather than just calling error_type?  */
3566
3567       static struct type *range_type_index;
3568
3569       complain (&range_type_base_complaint, rangenums[1]);
3570       if (range_type_index == NULL)
3571         range_type_index =
3572           init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
3573                      0, "range type index type", NULL);
3574       index_type = range_type_index;
3575     }
3576
3577   result_type = create_range_type ((struct type *) NULL, index_type, n2, n3);
3578   return (result_type);
3579 }
3580
3581 /* Read in an argument list.  This is a list of types, separated by commas
3582    and terminated with END.  Return the list of types read in, or (struct type
3583    **)-1 if there is an error.  */
3584
3585 static struct type **
3586 read_args (pp, end, objfile)
3587      char **pp;
3588      int end;
3589      struct objfile *objfile;
3590 {
3591   /* FIXME!  Remove this arbitrary limit!  */
3592   struct type *types[1024], **rval; /* allow for fns of 1023 parameters */
3593   int n = 0;
3594
3595   while (**pp != end)
3596     {
3597       if (**pp != ',')
3598         /* Invalid argument list: no ','.  */
3599         return (struct type **)-1;
3600       (*pp)++;
3601       STABS_CONTINUE (pp, objfile);
3602       types[n++] = read_type (pp, objfile);
3603     }
3604   (*pp)++;                      /* get past `end' (the ':' character) */
3605
3606   if (n == 1)
3607     {
3608       rval = (struct type **) xmalloc (2 * sizeof (struct type *));
3609     }
3610   else if (TYPE_CODE (types[n-1]) != TYPE_CODE_VOID)
3611     {
3612       rval = (struct type **) xmalloc ((n + 1) * sizeof (struct type *));
3613       memset (rval + n, 0, sizeof (struct type *));
3614     }
3615   else
3616     {
3617       rval = (struct type **) xmalloc (n * sizeof (struct type *));
3618     }
3619   memcpy (rval, types, n * sizeof (struct type *));
3620   return rval;
3621 }
3622 \f
3623 /* Common block handling.  */
3624
3625 /* List of symbols declared since the last BCOMM.  This list is a tail
3626    of local_symbols.  When ECOMM is seen, the symbols on the list
3627    are noted so their proper addresses can be filled in later,
3628    using the common block base address gotten from the assembler
3629    stabs.  */
3630
3631 static struct pending *common_block;
3632 static int common_block_i;
3633
3634 /* Name of the current common block.  We get it from the BCOMM instead of the
3635    ECOMM to match IBM documentation (even though IBM puts the name both places
3636    like everyone else).  */
3637 static char *common_block_name;
3638
3639 /* Process a N_BCOMM symbol.  The storage for NAME is not guaranteed
3640    to remain after this function returns.  */
3641
3642 void
3643 common_block_start (name, objfile)
3644      char *name;
3645      struct objfile *objfile;
3646 {
3647   if (common_block_name != NULL)
3648     {
3649       static struct complaint msg = {
3650         "Invalid symbol data: common block within common block",
3651         0, 0};
3652       complain (&msg);
3653     }
3654   common_block = local_symbols;
3655   common_block_i = local_symbols ? local_symbols->nsyms : 0;
3656   common_block_name = obsavestring (name, strlen (name),
3657                                     &objfile -> symbol_obstack);
3658 }
3659
3660 /* Process a N_ECOMM symbol.  */
3661
3662 void
3663 common_block_end (objfile)
3664      struct objfile *objfile;
3665 {
3666   /* Symbols declared since the BCOMM are to have the common block
3667      start address added in when we know it.  common_block and
3668      common_block_i point to the first symbol after the BCOMM in
3669      the local_symbols list; copy the list and hang it off the
3670      symbol for the common block name for later fixup.  */
3671   int i;
3672   struct symbol *sym;
3673   struct pending *new = 0;
3674   struct pending *next;
3675   int j;
3676
3677   if (common_block_name == NULL)
3678     {
3679       static struct complaint msg = {"ECOMM symbol unmatched by BCOMM", 0, 0};
3680       complain (&msg);
3681       return;
3682     }
3683
3684   sym = (struct symbol *)
3685     obstack_alloc (&objfile -> symbol_obstack, sizeof (struct symbol));
3686   memset (sym, 0, sizeof (struct symbol));
3687   SYMBOL_NAME (sym) = common_block_name;
3688   SYMBOL_CLASS (sym) = LOC_BLOCK;
3689
3690   /* Now we copy all the symbols which have been defined since the BCOMM.  */
3691
3692   /* Copy all the struct pendings before common_block.  */
3693   for (next = local_symbols;
3694        next != NULL && next != common_block;
3695        next = next->next)
3696     {
3697       for (j = 0; j < next->nsyms; j++)
3698         add_symbol_to_list (next->symbol[j], &new);
3699     }
3700
3701   /* Copy however much of COMMON_BLOCK we need.  If COMMON_BLOCK is
3702      NULL, it means copy all the local symbols (which we already did
3703      above).  */
3704
3705   if (common_block != NULL)
3706     for (j = common_block_i; j < common_block->nsyms; j++)
3707       add_symbol_to_list (common_block->symbol[j], &new);
3708
3709   SYMBOL_TYPE (sym) = (struct type *) new;
3710
3711   /* Should we be putting local_symbols back to what it was?
3712      Does it matter?  */
3713
3714   i = hashname (SYMBOL_NAME (sym));
3715   SYMBOL_VALUE_CHAIN (sym) = global_sym_chain[i];
3716   global_sym_chain[i] = sym;
3717   common_block_name = NULL;
3718 }
3719
3720 /* Add a common block's start address to the offset of each symbol
3721    declared to be in it (by being between a BCOMM/ECOMM pair that uses
3722    the common block name).  */
3723
3724 static void
3725 fix_common_block (sym, valu)
3726     struct symbol *sym;
3727     int valu;
3728 {
3729   struct pending *next = (struct pending *) SYMBOL_TYPE (sym);
3730   for ( ; next; next = next->next)
3731     {
3732       register int j;
3733       for (j = next->nsyms - 1; j >= 0; j--)
3734         SYMBOL_VALUE_ADDRESS (next->symbol[j]) += valu;
3735     }
3736 }
3737
3738
3739 \f
3740 /* What about types defined as forward references inside of a small lexical
3741    scope?  */
3742 /* Add a type to the list of undefined types to be checked through
3743    once this file has been read in.  */
3744
3745 void
3746 add_undefined_type (type)
3747      struct type *type;
3748 {
3749   if (undef_types_length == undef_types_allocated)
3750     {
3751       undef_types_allocated *= 2;
3752       undef_types = (struct type **)
3753         xrealloc ((char *) undef_types,
3754                   undef_types_allocated * sizeof (struct type *));
3755     }
3756   undef_types[undef_types_length++] = type;
3757 }
3758
3759 /* Go through each undefined type, see if it's still undefined, and fix it
3760    up if possible.  We have two kinds of undefined types:
3761
3762    TYPE_CODE_ARRAY:  Array whose target type wasn't defined yet.
3763                         Fix:  update array length using the element bounds
3764                         and the target type's length.
3765    TYPE_CODE_STRUCT, TYPE_CODE_UNION:  Structure whose fields were not
3766                         yet defined at the time a pointer to it was made.
3767                         Fix:  Do a full lookup on the struct/union tag.  */
3768 void
3769 cleanup_undefined_types ()
3770 {
3771   struct type **type;
3772
3773   for (type = undef_types; type < undef_types + undef_types_length; type++)
3774     {
3775       switch (TYPE_CODE (*type))
3776         {
3777
3778           case TYPE_CODE_STRUCT:
3779           case TYPE_CODE_UNION:
3780           case TYPE_CODE_ENUM:
3781           {
3782             /* Check if it has been defined since.  Need to do this here
3783                as well as in check_typedef to deal with the (legitimate in
3784                C though not C++) case of several types with the same name
3785                in different source files.  */
3786             if (TYPE_FLAGS (*type) & TYPE_FLAG_STUB)
3787               {
3788                 struct pending *ppt;
3789                 int i;
3790                 /* Name of the type, without "struct" or "union" */
3791                 char *typename = TYPE_TAG_NAME (*type);
3792
3793                 if (typename == NULL)
3794                   {
3795                     static struct complaint msg = {"need a type name", 0, 0};
3796                     complain (&msg);
3797                     break;
3798                   }
3799                 for (ppt = file_symbols; ppt; ppt = ppt->next)
3800                   {
3801                     for (i = 0; i < ppt->nsyms; i++)
3802                       {
3803                         struct symbol *sym = ppt->symbol[i];
3804
3805                         if (SYMBOL_CLASS (sym) == LOC_TYPEDEF
3806                             && SYMBOL_NAMESPACE (sym) == STRUCT_NAMESPACE
3807                             && (TYPE_CODE (SYMBOL_TYPE (sym)) ==
3808                                 TYPE_CODE (*type))
3809                             && STREQ (SYMBOL_NAME (sym), typename))
3810                           {
3811                             memcpy (*type, SYMBOL_TYPE (sym),
3812                                     sizeof (struct type));
3813                           }
3814                       }
3815                   }
3816               }
3817           }
3818           break;
3819
3820         default:
3821         badtype:
3822           {
3823             static struct complaint msg = {"\
3824 GDB internal error.  cleanup_undefined_types with bad type %d.", 0, 0};
3825             complain (&msg, TYPE_CODE (*type));
3826           }
3827           break;
3828         }
3829     }
3830
3831   undef_types_length = 0;
3832 }
3833
3834 /* Scan through all of the global symbols defined in the object file,
3835    assigning values to the debugging symbols that need to be assigned
3836    to.  Get these symbols from the minimal symbol table.  */
3837
3838 void
3839 scan_file_globals (objfile)
3840      struct objfile *objfile;
3841 {
3842   int hash;
3843   struct minimal_symbol *msymbol;
3844   struct symbol *sym, *prev;
3845
3846   /* Avoid expensive loop through all minimal symbols if there are
3847      no unresolved symbols.  */
3848   for (hash = 0; hash < HASHSIZE; hash++)
3849     {
3850       if (global_sym_chain[hash])
3851         break;
3852     }
3853   if (hash >= HASHSIZE)
3854     return;
3855
3856   for (msymbol = objfile -> msymbols;
3857        msymbol && SYMBOL_NAME (msymbol) != NULL;
3858        msymbol++)
3859     {
3860       QUIT;
3861
3862       /* Skip static symbols.  */
3863       switch (MSYMBOL_TYPE (msymbol))
3864         {
3865         case mst_file_text:
3866         case mst_file_data:
3867         case mst_file_bss:
3868           continue;
3869         default:
3870           break;
3871         }
3872
3873       prev = NULL;
3874
3875       /* Get the hash index and check all the symbols
3876          under that hash index. */
3877
3878       hash = hashname (SYMBOL_NAME (msymbol));
3879
3880       for (sym = global_sym_chain[hash]; sym;)
3881         {
3882           if (SYMBOL_NAME (msymbol)[0] == SYMBOL_NAME (sym)[0] &&
3883               STREQ(SYMBOL_NAME (msymbol) + 1, SYMBOL_NAME (sym) + 1))
3884             {
3885               /* Splice this symbol out of the hash chain and
3886                  assign the value we have to it. */
3887               if (prev)
3888                 {
3889                   SYMBOL_VALUE_CHAIN (prev) = SYMBOL_VALUE_CHAIN (sym);
3890                 }
3891               else
3892                 {
3893                   global_sym_chain[hash] = SYMBOL_VALUE_CHAIN (sym);
3894                 }
3895
3896               /* Check to see whether we need to fix up a common block.  */
3897               /* Note: this code might be executed several times for
3898                  the same symbol if there are multiple references.  */
3899
3900               if (SYMBOL_CLASS (sym) == LOC_BLOCK)
3901                 {
3902                   fix_common_block (sym, SYMBOL_VALUE_ADDRESS (msymbol));
3903                 }
3904               else
3905                 {
3906                   SYMBOL_VALUE_ADDRESS (sym) = SYMBOL_VALUE_ADDRESS (msymbol);
3907                 }
3908
3909               SYMBOL_SECTION (sym) = SYMBOL_SECTION (msymbol);
3910
3911               if (prev)
3912                 {
3913                   sym = SYMBOL_VALUE_CHAIN (prev);
3914                 }
3915               else
3916                 {
3917                   sym = global_sym_chain[hash];
3918                 }
3919             }
3920           else
3921             {
3922               prev = sym;
3923               sym = SYMBOL_VALUE_CHAIN (sym);
3924             }
3925         }
3926     }
3927
3928   /* Change the storage class of any remaining unresolved globals to
3929      LOC_UNRESOLVED and remove them from the chain.  */
3930   for (hash = 0; hash < HASHSIZE; hash++)
3931     {
3932       sym = global_sym_chain[hash];
3933       while (sym)
3934         {
3935           prev = sym;
3936           sym = SYMBOL_VALUE_CHAIN (sym);
3937
3938           /* Change the symbol address from the misleading chain value
3939              to address zero.  */
3940           SYMBOL_VALUE_ADDRESS (prev) = 0;
3941
3942           /* Complain about unresolved common block symbols.  */
3943           if (SYMBOL_CLASS (prev) == LOC_STATIC)
3944             SYMBOL_CLASS (prev) = LOC_UNRESOLVED;
3945           else
3946             complain (&unresolved_sym_chain_complaint,
3947                       objfile->name, SYMBOL_NAME (prev));
3948         }
3949     }
3950   memset (global_sym_chain, 0, sizeof (global_sym_chain));
3951 }
3952
3953 /* Initialize anything that needs initializing when starting to read
3954    a fresh piece of a symbol file, e.g. reading in the stuff corresponding
3955    to a psymtab.  */
3956
3957 void
3958 stabsread_init ()
3959 {
3960 }
3961
3962 /* Initialize anything that needs initializing when a completely new
3963    symbol file is specified (not just adding some symbols from another
3964    file, e.g. a shared library).  */
3965
3966 void
3967 stabsread_new_init ()
3968 {
3969   /* Empty the hash table of global syms looking for values.  */
3970   memset (global_sym_chain, 0, sizeof (global_sym_chain));
3971 }
3972
3973 /* Initialize anything that needs initializing at the same time as
3974    start_symtab() is called. */
3975
3976 void start_stabs ()
3977 {
3978   global_stabs = NULL;          /* AIX COFF */
3979   /* Leave FILENUM of 0 free for builtin types and this file's types.  */
3980   n_this_object_header_files = 1;
3981   type_vector_length = 0;
3982   type_vector = (struct type **) 0;
3983
3984   /* FIXME: If common_block_name is not already NULL, we should complain().  */
3985   common_block_name = NULL;
3986
3987   os9k_stabs = 0;
3988 }
3989
3990 /* Call after end_symtab() */
3991
3992 void end_stabs ()
3993 {
3994   if (type_vector)
3995     {
3996       free ((char *) type_vector);
3997     }
3998   type_vector = 0;
3999   type_vector_length = 0;
4000   previous_stab_code = 0;
4001 }
4002
4003 void
4004 finish_global_stabs (objfile)
4005      struct objfile *objfile;
4006 {
4007   if (global_stabs)
4008     {
4009       patch_block_stabs (global_symbols, global_stabs, objfile);
4010       free ((PTR) global_stabs);
4011       global_stabs = NULL;
4012     }
4013 }
4014
4015 /* Initializer for this module */
4016
4017 void
4018 _initialize_stabsread ()
4019 {
4020   undef_types_allocated = 20;
4021   undef_types_length = 0;
4022   undef_types = (struct type **)
4023     xmalloc (undef_types_allocated * sizeof (struct type *));
4024 }