gdb/stabsread.c

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