gdb/stabsread.c

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