contrib/gdb-7/gdb/stabsread.c

   1 /* Support routines for decoding "stabs" debugging information format.
   2
   3    Copyright (C) 1986-2015 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 "bfd.h"
  28 #include "gdb_obstack.h"
  29 #include "symtab.h"
  30 #include "gdbtypes.h"
  31 #include "expression.h"
  32 #include "symfile.h"
  33 #include "objfiles.h"
  34 #include "aout/stab_gnu.h"      /* We always use GNU stabs, not native.  */
  35 #include "libaout.h"
  36 #include "aout/aout64.h"
  37 #include "gdb-stabs.h"
  38 #include "buildsym.h"
  39 #include "complaints.h"
  40 #include "demangle.h"
  41 #include "gdb-demangle.h"
  42 #include "language.h"
  43 #include "doublest.h"
  44 #include "cp-abi.h"
  45 #include "cp-support.h"
  46 #include <ctype.h>
  47
  48 /* Ask stabsread.h to define the vars it normally declares `extern'.  */
  49 #define EXTERN
  50 /**/
  51 #include "stabsread.h"          /* Our own declarations */
  52 #undef  EXTERN
  53
  54 extern void _initialize_stabsread (void);
  55
  56 struct nextfield
  57 {
  58   struct nextfield *next;
  59
  60   /* This is the raw visibility from the stab.  It is not checked
  61      for being one of the visibilities we recognize, so code which
  62      examines this field better be able to deal.  */
  63   int visibility;
  64
  65   struct field field;
  66 };
  67
  68 struct next_fnfieldlist
  69 {
  70   struct next_fnfieldlist *next;
  71   struct fn_fieldlist fn_fieldlist;
  72 };
  73
  74 /* The routines that read and process a complete stabs for a C struct or
  75    C++ class pass lists of data member fields and lists of member function
  76    fields in an instance of a field_info structure, as defined below.
  77    This is part of some reorganization of low level C++ support and is
  78    expected to eventually go away...  (FIXME) */
  79
  80 struct field_info
  81   {
  82     struct nextfield *list;
  83     struct next_fnfieldlist *fnlist;
  84   };
  85
  86 static void
  87 read_one_struct_field (struct field_info *, char **, char *,
  88                        struct type *, struct objfile *);
  89
  90 static struct type *dbx_alloc_type (int[2], struct objfile *);
  91
  92 static long read_huge_number (char **, int, int *, int);
  93
  94 static struct type *error_type (char **, struct objfile *);
  95
  96 static void
  97 patch_block_stabs (struct pending *, struct pending_stabs *,
  98                    struct objfile *);
  99
 100 static void fix_common_block (struct symbol *, CORE_ADDR);
 101
 102 static int read_type_number (char **, int *);
 103
 104 static struct type *read_type (char **, struct objfile *);
 105
 106 static struct type *read_range_type (char **, int[2], int, struct objfile *);
 107
 108 static struct type *read_sun_builtin_type (char **, int[2], struct objfile *);
 109
 110 static struct type *read_sun_floating_type (char **, int[2],
 111                                             struct objfile *);
 112
 113 static struct type *read_enum_type (char **, struct type *, struct objfile *);
 114
 115 static struct type *rs6000_builtin_type (int, struct objfile *);
 116
 117 static int
 118 read_member_functions (struct field_info *, char **, struct type *,
 119                        struct objfile *);
 120
 121 static int
 122 read_struct_fields (struct field_info *, char **, struct type *,
 123                     struct objfile *);
 124
 125 static int
 126 read_baseclasses (struct field_info *, char **, struct type *,
 127                   struct objfile *);
 128
 129 static int
 130 read_tilde_fields (struct field_info *, char **, struct type *,
 131                    struct objfile *);
 132
 133 static int attach_fn_fields_to_type (struct field_info *, struct type *);
 134
 135 static int attach_fields_to_type (struct field_info *, struct type *,
 136                                   struct objfile *);
 137
 138 static struct type *read_struct_type (char **, struct type *,
 139                                       enum type_code,
 140                                       struct objfile *);
 141
 142 static struct type *read_array_type (char **, struct type *,
 143                                      struct objfile *);
 144
 145 static struct field *read_args (char **, int, struct objfile *, int *, int *);
 146
 147 static void add_undefined_type (struct type *, int[2]);
 148
 149 static int
 150 read_cpp_abbrev (struct field_info *, char **, struct type *,
 151                  struct objfile *);
 152
 153 static char *find_name_end (char *name);
 154
 155 static int process_reference (char **string);
 156
 157 void stabsread_clear_cache (void);
 158
 159 static const char vptr_name[] = "_vptr$";
 160 static const char vb_name[] = "_vb$";
 161
 162 static void
 163 invalid_cpp_abbrev_complaint (const char *arg1)
 164 {
 165   complaint (&symfile_complaints, _("invalid C++ abbreviation `%s'"), arg1);
 166 }
 167
 168 static void
 169 reg_value_complaint (int regnum, int num_regs, const char *sym)
 170 {
 171   complaint (&symfile_complaints,
 172              _("register number %d too large (max %d) in symbol %s"),
 173              regnum, num_regs - 1, sym);
 174 }
 175
 176 static void
 177 stabs_general_complaint (const char *arg1)
 178 {
 179   complaint (&symfile_complaints, "%s", arg1);
 180 }
 181
 182 /* Make a list of forward references which haven't been defined.  */
 183
 184 static struct type **undef_types;
 185 static int undef_types_allocated;
 186 static int undef_types_length;
 187 static struct symbol *current_symbol = NULL;
 188
 189 /* Make a list of nameless types that are undefined.
 190    This happens when another type is referenced by its number
 191    before this type is actually defined.  For instance "t(0,1)=k(0,2)"
 192    and type (0,2) is defined only later.  */
 193
 194 struct nat
 195 {
 196   int typenums[2];
 197   struct type *type;
 198 };
 199 static struct nat *noname_undefs;
 200 static int noname_undefs_allocated;
 201 static int noname_undefs_length;
 202
 203 /* Check for and handle cretinous stabs symbol name continuation!  */
 204 #define STABS_CONTINUE(pp,objfile)                              \
 205   do {                                                  \
 206     if (**(pp) == '\\' || (**(pp) == '?' && (*(pp))[1] == '\0')) \
 207       *(pp) = next_symbol_text (objfile);       \
 208   } while (0)
 209
 210 /* Vector of types defined so far, indexed by their type numbers.
 211    (In newer sun systems, dbx uses a pair of numbers in parens,
 212    as in "(SUBFILENUM,NUMWITHINSUBFILE)".
 213    Then these numbers must be translated through the type_translations
 214    hash table to get the index into the type vector.)  */
 215
 216 static struct type **type_vector;
 217
 218 /* Number of elements allocated for type_vector currently.  */
 219
 220 static int type_vector_length;
 221
 222 /* Initial size of type vector.  Is realloc'd larger if needed, and
 223    realloc'd down to the size actually used, when completed.  */
 224
 225 #define INITIAL_TYPE_VECTOR_LENGTH 160
 226 \f
 227
 228 /* Look up a dbx type-number pair.  Return the address of the slot
 229    where the type for that number-pair is stored.
 230    The number-pair is in TYPENUMS.
 231
 232    This can be used for finding the type associated with that pair
 233    or for associating a new type with the pair.  */
 234
 235 static struct type **
 236 dbx_lookup_type (int typenums[2], struct objfile *objfile)
 237 {
 238   int filenum = typenums[0];
 239   int index = typenums[1];
 240   unsigned old_len;
 241   int real_filenum;
 242   struct header_file *f;
 243   int f_orig_length;
 244
 245   if (filenum == -1)            /* -1,-1 is for temporary types.  */
 246     return 0;
 247
 248   if (filenum < 0 || filenum >= n_this_object_header_files)
 249     {
 250       complaint (&symfile_complaints,
 251                  _("Invalid symbol data: type number "
 252                    "(%d,%d) out of range at symtab pos %d."),
 253                  filenum, index, symnum);
 254       goto error_return;
 255     }
 256
 257   if (filenum == 0)
 258     {
 259       if (index < 0)
 260         {
 261           /* Caller wants address of address of type.  We think
 262              that negative (rs6k builtin) types will never appear as
 263              "lvalues", (nor should they), so we stuff the real type
 264              pointer into a temp, and return its address.  If referenced,
 265              this will do the right thing.  */
 266           static struct type *temp_type;
 267
 268           temp_type = rs6000_builtin_type (index, objfile);
 269           return &temp_type;
 270         }
 271
 272       /* Type is defined outside of header files.
 273          Find it in this object file's type vector.  */
 274       if (index >= type_vector_length)
 275         {
 276           old_len = type_vector_length;
 277           if (old_len == 0)
 278             {
 279               type_vector_length = INITIAL_TYPE_VECTOR_LENGTH;
 280               type_vector = (struct type **)
 281                 xmalloc (type_vector_length * sizeof (struct type *));
 282             }
 283           while (index >= type_vector_length)
 284             {
 285               type_vector_length *= 2;
 286             }
 287           type_vector = (struct type **)
 288             xrealloc ((char *) type_vector,
 289                       (type_vector_length * sizeof (struct type *)));
 290           memset (&type_vector[old_len], 0,
 291                   (type_vector_length - old_len) * sizeof (struct type *));
 292         }
 293       return (&type_vector[index]);
 294     }
 295   else
 296     {
 297       real_filenum = this_object_header_files[filenum];
 298
 299       if (real_filenum >= N_HEADER_FILES (objfile))
 300         {
 301           static struct type *temp_type;
 302
 303           warning (_("GDB internal error: bad real_filenum"));
 304
 305         error_return:
 306           temp_type = objfile_type (objfile)->builtin_error;
 307           return &temp_type;
 308         }
 309
 310       f = HEADER_FILES (objfile) + real_filenum;
 311
 312       f_orig_length = f->length;
 313       if (index >= f_orig_length)
 314         {
 315           while (index >= f->length)
 316             {
 317               f->length *= 2;
 318             }
 319           f->vector = (struct type **)
 320             xrealloc ((char *) f->vector, f->length * sizeof (struct type *));
 321           memset (&f->vector[f_orig_length], 0,
 322                   (f->length - f_orig_length) * sizeof (struct type *));
 323         }
 324       return (&f->vector[index]);
 325     }
 326 }
 327
 328 /* Make sure there is a type allocated for type numbers TYPENUMS
 329    and return the type object.
 330    This can create an empty (zeroed) type object.
 331    TYPENUMS may be (-1, -1) to return a new type object that is not
 332    put into the type vector, and so may not be referred to by number.  */
 333
 334 static struct type *
 335 dbx_alloc_type (int typenums[2], struct objfile *objfile)
 336 {
 337   struct type **type_addr;
 338
 339   if (typenums[0] == -1)
 340     {
 341       return (alloc_type (objfile));
 342     }
 343
 344   type_addr = dbx_lookup_type (typenums, objfile);
 345
 346   /* If we are referring to a type not known at all yet,
 347      allocate an empty type for it.
 348      We will fill it in later if we find out how.  */
 349   if (*type_addr == 0)
 350     {
 351       *type_addr = alloc_type (objfile);
 352     }
 353
 354   return (*type_addr);
 355 }
 356
 357 /* for all the stabs in a given stab vector, build appropriate types
 358    and fix their symbols in given symbol vector.  */
 359
 360 static void
 361 patch_block_stabs (struct pending *symbols, struct pending_stabs *stabs,
 362                    struct objfile *objfile)
 363 {
 364   int ii;
 365   char *name;
 366   char *pp;
 367   struct symbol *sym;
 368
 369   if (stabs)
 370     {
 371       /* for all the stab entries, find their corresponding symbols and
 372          patch their types!  */
 373
 374       for (ii = 0; ii < stabs->count; ++ii)
 375         {
 376           name = stabs->stab[ii];
 377           pp = (char *) strchr (name, ':');
 378           gdb_assert (pp);      /* Must find a ':' or game's over.  */
 379           while (pp[1] == ':')
 380             {
 381               pp += 2;
 382               pp = (char *) strchr (pp, ':');
 383             }
 384           sym = find_symbol_in_list (symbols, name, pp - name);
 385           if (!sym)
 386             {
 387               /* FIXME-maybe: it would be nice if we noticed whether
 388                  the variable was defined *anywhere*, not just whether
 389                  it is defined in this compilation unit.  But neither
 390                  xlc or GCC seem to need such a definition, and until
 391                  we do psymtabs (so that the minimal symbols from all
 392                  compilation units are available now), I'm not sure
 393                  how to get the information.  */
 394
 395               /* On xcoff, if a global is defined and never referenced,
 396                  ld will remove it from the executable.  There is then
 397                  a N_GSYM stab for it, but no regular (C_EXT) symbol.  */
 398               sym = allocate_symbol (objfile);
 399               SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
 400               SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
 401               SYMBOL_SET_LINKAGE_NAME
 402                 (sym, obstack_copy0 (&objfile->objfile_obstack,
 403                                      name, pp - name));
 404               pp += 2;
 405               if (*(pp - 1) == 'F' || *(pp - 1) == 'f')
 406                 {
 407                   /* I don't think the linker does this with functions,
 408                      so as far as I know this is never executed.
 409                      But it doesn't hurt to check.  */
 410                   SYMBOL_TYPE (sym) =
 411                     lookup_function_type (read_type (&pp, objfile));
 412                 }
 413               else
 414                 {
 415                   SYMBOL_TYPE (sym) = read_type (&pp, objfile);
 416                 }
 417               add_symbol_to_list (sym, &global_symbols);
 418             }
 419           else
 420             {
 421               pp += 2;
 422               if (*(pp - 1) == 'F' || *(pp - 1) == 'f')
 423                 {
 424                   SYMBOL_TYPE (sym) =
 425                     lookup_function_type (read_type (&pp, objfile));
 426                 }
 427               else
 428                 {
 429                   SYMBOL_TYPE (sym) = read_type (&pp, objfile);
 430                 }
 431             }
 432         }
 433     }
 434 }
 435 \f
 436
 437 /* Read a number by which a type is referred to in dbx data,
 438    or perhaps read a pair (FILENUM, TYPENUM) in parentheses.
 439    Just a single number N is equivalent to (0,N).
 440    Return the two numbers by storing them in the vector TYPENUMS.
 441    TYPENUMS will then be used as an argument to dbx_lookup_type.
 442
 443    Returns 0 for success, -1 for error.  */
 444
 445 static int
 446 read_type_number (char **pp, int *typenums)
 447 {
 448   int nbits;
 449
 450   if (**pp == '(')
 451     {
 452       (*pp)++;
 453       typenums[0] = read_huge_number (pp, ',', &nbits, 0);
 454       if (nbits != 0)
 455         return -1;
 456       typenums[1] = read_huge_number (pp, ')', &nbits, 0);
 457       if (nbits != 0)
 458         return -1;
 459     }
 460   else
 461     {
 462       typenums[0] = 0;
 463       typenums[1] = read_huge_number (pp, 0, &nbits, 0);
 464       if (nbits != 0)
 465         return -1;
 466     }
 467   return 0;
 468 }
 469 \f
 470
 471 #define VISIBILITY_PRIVATE      '0'     /* Stabs character for private field */
 472 #define VISIBILITY_PROTECTED    '1'     /* Stabs character for protected fld */
 473 #define VISIBILITY_PUBLIC       '2'     /* Stabs character for public field */
 474 #define VISIBILITY_IGNORE       '9'     /* Optimized out or zero length */
 475
 476 /* Structure for storing pointers to reference definitions for fast lookup
 477    during "process_later".  */
 478
 479 struct ref_map
 480 {
 481   char *stabs;
 482   CORE_ADDR value;
 483   struct symbol *sym;
 484 };
 485
 486 #define MAX_CHUNK_REFS 100
 487 #define REF_CHUNK_SIZE (MAX_CHUNK_REFS * sizeof (struct ref_map))
 488 #define REF_MAP_SIZE(ref_chunk) ((ref_chunk) * REF_CHUNK_SIZE)
 489
 490 static struct ref_map *ref_map;
 491
 492 /* Ptr to free cell in chunk's linked list.  */
 493 static int ref_count = 0;
 494
 495 /* Number of chunks malloced.  */
 496 static int ref_chunk = 0;
 497
 498 /* This file maintains a cache of stabs aliases found in the symbol
 499    table.  If the symbol table changes, this cache must be cleared
 500    or we are left holding onto data in invalid obstacks.  */
 501 void
 502 stabsread_clear_cache (void)
 503 {
 504   ref_count = 0;
 505   ref_chunk = 0;
 506 }
 507
 508 /* Create array of pointers mapping refids to symbols and stab strings.
 509    Add pointers to reference definition symbols and/or their values as we
 510    find them, using their reference numbers as our index.
 511    These will be used later when we resolve references.  */
 512 void
 513 ref_add (int refnum, struct symbol *sym, char *stabs, CORE_ADDR value)
 514 {
 515   if (ref_count == 0)
 516     ref_chunk = 0;
 517   if (refnum >= ref_count)
 518     ref_count = refnum + 1;
 519   if (ref_count > ref_chunk * MAX_CHUNK_REFS)
 520     {
 521       int new_slots = ref_count - ref_chunk * MAX_CHUNK_REFS;
 522       int new_chunks = new_slots / MAX_CHUNK_REFS + 1;
 523
 524       ref_map = (struct ref_map *)
 525         xrealloc (ref_map, REF_MAP_SIZE (ref_chunk + new_chunks));
 526       memset (ref_map + ref_chunk * MAX_CHUNK_REFS, 0,
 527               new_chunks * REF_CHUNK_SIZE);
 528       ref_chunk += new_chunks;
 529     }
 530   ref_map[refnum].stabs = stabs;
 531   ref_map[refnum].sym = sym;
 532   ref_map[refnum].value = value;
 533 }
 534
 535 /* Return defined sym for the reference REFNUM.  */
 536 struct symbol *
 537 ref_search (int refnum)
 538 {
 539   if (refnum < 0 || refnum > ref_count)
 540     return 0;
 541   return ref_map[refnum].sym;
 542 }
 543
 544 /* Parse a reference id in STRING and return the resulting
 545    reference number.  Move STRING beyond the reference id.  */
 546
 547 static int
 548 process_reference (char **string)
 549 {
 550   char *p;
 551   int refnum = 0;
 552
 553   if (**string != '#')
 554     return 0;
 555
 556   /* Advance beyond the initial '#'.  */
 557   p = *string + 1;
 558
 559   /* Read number as reference id.  */
 560   while (*p && isdigit (*p))
 561     {
 562       refnum = refnum * 10 + *p - '0';
 563       p++;
 564     }
 565   *string = p;
 566   return refnum;
 567 }
 568
 569 /* If STRING defines a reference, store away a pointer to the reference
 570    definition for later use.  Return the reference number.  */
 571
 572 int
 573 symbol_reference_defined (char **string)
 574 {
 575   char *p = *string;
 576   int refnum = 0;
 577
 578   refnum = process_reference (&p);
 579
 580   /* Defining symbols end in '='.  */
 581   if (*p == '=')
 582     {
 583       /* Symbol is being defined here.  */
 584       *string = p + 1;
 585       return refnum;
 586     }
 587   else
 588     {
 589       /* Must be a reference.  Either the symbol has already been defined,
 590          or this is a forward reference to it.  */
 591       *string = p;
 592       return -1;
 593     }
 594 }
 595
 596 static int
 597 stab_reg_to_regnum (struct symbol *sym, struct gdbarch *gdbarch)
 598 {
 599   int regno = gdbarch_stab_reg_to_regnum (gdbarch, SYMBOL_VALUE (sym));
 600
 601   if (regno >= gdbarch_num_regs (gdbarch)
 602                 + gdbarch_num_pseudo_regs (gdbarch))
 603     {
 604       reg_value_complaint (regno,
 605                            gdbarch_num_regs (gdbarch)
 606                              + gdbarch_num_pseudo_regs (gdbarch),
 607                            SYMBOL_PRINT_NAME (sym));
 608
 609       regno = gdbarch_sp_regnum (gdbarch); /* Known safe, though useless.  */
 610     }
 611
 612   return regno;
 613 }
 614
 615 static const struct symbol_register_ops stab_register_funcs = {
 616   stab_reg_to_regnum
 617 };
 618
 619 /* The "aclass" indices for computed symbols.  */
 620
 621 static int stab_register_index;
 622 static int stab_regparm_index;
 623
 624 struct symbol *
 625 define_symbol (CORE_ADDR valu, char *string, int desc, int type,
 626                struct objfile *objfile)
 627 {
 628   struct gdbarch *gdbarch = get_objfile_arch (objfile);
 629   struct symbol *sym;
 630   char *p = (char *) find_name_end (string);
 631   int deftype;
 632   int synonym = 0;
 633   int i;
 634   char *new_name = NULL;
 635
 636   /* We would like to eliminate nameless symbols, but keep their types.
 637      E.g. stab entry ":t10=*2" should produce a type 10, which is a pointer
 638      to type 2, but, should not create a symbol to address that type.  Since
 639      the symbol will be nameless, there is no way any user can refer to it.  */
 640
 641   int nameless;
 642
 643   /* Ignore syms with empty names.  */
 644   if (string[0] == 0)
 645     return 0;
 646
 647   /* Ignore old-style symbols from cc -go.  */
 648   if (p == 0)
 649     return 0;
 650
 651   while (p[1] == ':')
 652     {
 653       p += 2;
 654       p = strchr (p, ':');
 655       if (p == NULL)
 656         {
 657           complaint (&symfile_complaints,
 658                      _("Bad stabs string '%s'"), string);
 659           return NULL;
 660         }
 661     }
 662
 663   /* If a nameless stab entry, all we need is the type, not the symbol.
 664      e.g. ":t10=*2" or a nameless enum like " :T16=ered:0,green:1,blue:2,;" */
 665   nameless = (p == string || ((string[0] == ' ') && (string[1] == ':')));
 666
 667   current_symbol = sym = allocate_symbol (objfile);
 668
 669   if (processing_gcc_compilation)
 670     {
 671       /* GCC 2.x puts the line number in desc.  SunOS apparently puts in the
 672          number of bytes occupied by a type or object, which we ignore.  */
 673       SYMBOL_LINE (sym) = desc;
 674     }
 675   else
 676     {
 677       SYMBOL_LINE (sym) = 0;    /* unknown */
 678     }
 679
 680   SYMBOL_SET_LANGUAGE (sym, current_subfile->language,
 681                        &objfile->objfile_obstack);
 682
 683   if (is_cplus_marker (string[0]))
 684     {
 685       /* Special GNU C++ names.  */
 686       switch (string[1])
 687         {
 688         case 't':
 689           SYMBOL_SET_LINKAGE_NAME (sym, "this");
 690           break;
 691
 692         case 'v':               /* $vtbl_ptr_type */
 693           goto normal;
 694
 695         case 'e':
 696           SYMBOL_SET_LINKAGE_NAME (sym, "eh_throw");
 697           break;
 698
 699         case '_':
 700           /* This was an anonymous type that was never fixed up.  */
 701           goto normal;
 702
 703         case 'X':
 704           /* SunPRO (3.0 at least) static variable encoding.  */
 705           if (gdbarch_static_transform_name_p (gdbarch))
 706             goto normal;
 707           /* ... fall through ...  */
 708
 709         default:
 710           complaint (&symfile_complaints, _("Unknown C++ symbol name `%s'"),
 711                      string);
 712           goto normal;          /* Do *something* with it.  */
 713         }
 714     }
 715   else
 716     {
 717     normal:
 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_static_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) = BMSYMBOL_VALUE_ADDRESS (msym);
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) = BMSYMBOL_VALUE_ADDRESS (msym);
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 *newobj = alloca (sizeof (*newobj));
1813             newobj->type = arg_type;
1814             newobj->next = arg_types;
1815             arg_types = newobj;
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           /* These are methods, not functions.  */
2382           if (TYPE_CODE (new_sublist->fn_field.type) == TYPE_CODE_FUNC)
2383             TYPE_CODE (new_sublist->fn_field.type) = TYPE_CODE_METHOD;
2384           else
2385             gdb_assert (TYPE_CODE (new_sublist->fn_field.type)
2386                         == TYPE_CODE_METHOD);
2387
2388           /* If this is just a stub, then we don't have the real name here.  */
2389           if (TYPE_STUB (new_sublist->fn_field.type))
2390             {
2391               if (!TYPE_SELF_TYPE (new_sublist->fn_field.type))
2392                 set_type_self_type (new_sublist->fn_field.type, type);
2393               new_sublist->fn_field.is_stub = 1;
2394             }
2395
2396           new_sublist->fn_field.physname = savestring (*pp, p - *pp);
2397           *pp = p + 1;
2398
2399           /* Set this member function's visibility fields.  */
2400           switch (*(*pp)++)
2401             {
2402             case VISIBILITY_PRIVATE:
2403               new_sublist->fn_field.is_private = 1;
2404               break;
2405             case VISIBILITY_PROTECTED:
2406               new_sublist->fn_field.is_protected = 1;
2407               break;
2408             }
2409
2410           STABS_CONTINUE (pp, objfile);
2411           switch (**pp)
2412             {
2413             case 'A':           /* Normal functions.  */
2414               new_sublist->fn_field.is_const = 0;
2415               new_sublist->fn_field.is_volatile = 0;
2416               (*pp)++;
2417               break;
2418             case 'B':           /* `const' member functions.  */
2419               new_sublist->fn_field.is_const = 1;
2420               new_sublist->fn_field.is_volatile = 0;
2421               (*pp)++;
2422               break;
2423             case 'C':           /* `volatile' member function.  */
2424               new_sublist->fn_field.is_const = 0;
2425               new_sublist->fn_field.is_volatile = 1;
2426               (*pp)++;
2427               break;
2428             case 'D':           /* `const volatile' member function.  */
2429               new_sublist->fn_field.is_const = 1;
2430               new_sublist->fn_field.is_volatile = 1;
2431               (*pp)++;
2432               break;
2433             case '*':           /* File compiled with g++ version 1 --
2434                                    no info.  */
2435             case '?':
2436             case '.':
2437               break;
2438             default:
2439               complaint (&symfile_complaints,
2440                          _("const/volatile indicator missing, got '%c'"),
2441                          **pp);
2442               break;
2443             }
2444
2445           switch (*(*pp)++)
2446             {
2447             case '*':
2448               {
2449                 int nbits;
2450                 /* virtual member function, followed by index.
2451                    The sign bit is set to distinguish pointers-to-methods
2452                    from virtual function indicies.  Since the array is
2453                    in words, the quantity must be shifted left by 1
2454                    on 16 bit machine, and by 2 on 32 bit machine, forcing
2455                    the sign bit out, and usable as a valid index into
2456                    the array.  Remove the sign bit here.  */
2457                 new_sublist->fn_field.voffset =
2458                   (0x7fffffff & read_huge_number (pp, ';', &nbits, 0)) + 2;
2459                 if (nbits != 0)
2460                   return 0;
2461
2462                 STABS_CONTINUE (pp, objfile);
2463                 if (**pp == ';' || **pp == '\0')
2464                   {
2465                     /* Must be g++ version 1.  */
2466                     new_sublist->fn_field.fcontext = 0;
2467                   }
2468                 else
2469                   {
2470                     /* Figure out from whence this virtual function came.
2471                        It may belong to virtual function table of
2472                        one of its baseclasses.  */
2473                     look_ahead_type = read_type (pp, objfile);
2474                     if (**pp == ':')
2475                       {
2476                         /* g++ version 1 overloaded methods.  */
2477                       }
2478                     else
2479                       {
2480                         new_sublist->fn_field.fcontext = look_ahead_type;
2481                         if (**pp != ';')
2482                           {
2483                             return 0;
2484                           }
2485                         else
2486                           {
2487                             ++*pp;
2488                           }
2489                         look_ahead_type = NULL;
2490                       }
2491                   }
2492                 break;
2493               }
2494             case '?':
2495               /* static member function.  */
2496               {
2497                 int slen = strlen (main_fn_name);
2498
2499                 new_sublist->fn_field.voffset = VOFFSET_STATIC;
2500
2501                 /* For static member functions, we can't tell if they
2502                    are stubbed, as they are put out as functions, and not as
2503                    methods.
2504                    GCC v2 emits the fully mangled name if
2505                    dbxout.c:flag_minimal_debug is not set, so we have to
2506                    detect a fully mangled physname here and set is_stub
2507                    accordingly.  Fully mangled physnames in v2 start with
2508                    the member function name, followed by two underscores.
2509                    GCC v3 currently always emits stubbed member functions,
2510                    but with fully mangled physnames, which start with _Z.  */
2511                 if (!(strncmp (new_sublist->fn_field.physname,
2512                                main_fn_name, slen) == 0
2513                       && new_sublist->fn_field.physname[slen] == '_'
2514                       && new_sublist->fn_field.physname[slen + 1] == '_'))
2515                   {
2516                     new_sublist->fn_field.is_stub = 1;
2517                   }
2518                 break;
2519               }
2520
2521             default:
2522               /* error */
2523               complaint (&symfile_complaints,
2524                          _("member function type missing, got '%c'"),
2525                          (*pp)[-1]);
2526               /* Fall through into normal member function.  */
2527
2528             case '.':
2529               /* normal member function.  */
2530               new_sublist->fn_field.voffset = 0;
2531               new_sublist->fn_field.fcontext = 0;
2532               break;
2533             }
2534
2535           new_sublist->next = sublist;
2536           sublist = new_sublist;
2537           length++;
2538           STABS_CONTINUE (pp, objfile);
2539         }
2540       while (**pp != ';' && **pp != '\0');
2541
2542       (*pp)++;
2543       STABS_CONTINUE (pp, objfile);
2544
2545       /* Skip GCC 3.X member functions which are duplicates of the callable
2546          constructor/destructor.  */
2547       if (strcmp_iw (main_fn_name, "__base_ctor ") == 0
2548           || strcmp_iw (main_fn_name, "__base_dtor ") == 0
2549           || strcmp (main_fn_name, "__deleting_dtor") == 0)
2550         {
2551           xfree (main_fn_name);
2552         }
2553       else
2554         {
2555           int has_stub = 0;
2556           int has_destructor = 0, has_other = 0;
2557           int is_v3 = 0;
2558           struct next_fnfield *tmp_sublist;
2559
2560           /* Various versions of GCC emit various mostly-useless
2561              strings in the name field for special member functions.
2562
2563              For stub methods, we need to defer correcting the name
2564              until we are ready to unstub the method, because the current
2565              name string is used by gdb_mangle_name.  The only stub methods
2566              of concern here are GNU v2 operators; other methods have their
2567              names correct (see caveat below).
2568
2569              For non-stub methods, in GNU v3, we have a complete physname.
2570              Therefore we can safely correct the name now.  This primarily
2571              affects constructors and destructors, whose name will be
2572              __comp_ctor or __comp_dtor instead of Foo or ~Foo.  Cast
2573              operators will also have incorrect names; for instance,
2574              "operator int" will be named "operator i" (i.e. the type is
2575              mangled).
2576
2577              For non-stub methods in GNU v2, we have no easy way to
2578              know if we have a complete physname or not.  For most
2579              methods the result depends on the platform (if CPLUS_MARKER
2580              can be `$' or `.', it will use minimal debug information, or
2581              otherwise the full physname will be included).
2582
2583              Rather than dealing with this, we take a different approach.
2584              For v3 mangled names, we can use the full physname; for v2,
2585              we use cplus_demangle_opname (which is actually v2 specific),
2586              because the only interesting names are all operators - once again
2587              barring the caveat below.  Skip this process if any method in the
2588              group is a stub, to prevent our fouling up the workings of
2589              gdb_mangle_name.
2590
2591              The caveat: GCC 2.95.x (and earlier?) put constructors and
2592              destructors in the same method group.  We need to split this
2593              into two groups, because they should have different names.
2594              So for each method group we check whether it contains both
2595              routines whose physname appears to be a destructor (the physnames
2596              for and destructors are always provided, due to quirks in v2
2597              mangling) and routines whose physname does not appear to be a
2598              destructor.  If so then we break up the list into two halves.
2599              Even if the constructors and destructors aren't in the same group
2600              the destructor will still lack the leading tilde, so that also
2601              needs to be fixed.
2602
2603              So, to summarize what we expect and handle here:
2604
2605                 Given         Given          Real         Real       Action
2606              method name     physname      physname   method name
2607
2608              __opi            [none]     __opi__3Foo  operator int    opname
2609                                                                  [now or later]
2610              Foo              _._3Foo       _._3Foo      ~Foo      separate and
2611                                                                        rename
2612              operator i     _ZN3FoocviEv _ZN3FoocviEv operator int    demangle
2613              __comp_ctor  _ZN3FooC1ERKS_ _ZN3FooC1ERKS_   Foo         demangle
2614           */
2615
2616           tmp_sublist = sublist;
2617           while (tmp_sublist != NULL)
2618             {
2619               if (tmp_sublist->fn_field.is_stub)
2620                 has_stub = 1;
2621               if (tmp_sublist->fn_field.physname[0] == '_'
2622                   && tmp_sublist->fn_field.physname[1] == 'Z')
2623                 is_v3 = 1;
2624
2625               if (is_destructor_name (tmp_sublist->fn_field.physname))
2626                 has_destructor++;
2627               else
2628                 has_other++;
2629
2630               tmp_sublist = tmp_sublist->next;
2631             }
2632
2633           if (has_destructor && has_other)
2634             {
2635               struct next_fnfieldlist *destr_fnlist;
2636               struct next_fnfield *last_sublist;
2637
2638               /* Create a new fn_fieldlist for the destructors.  */
2639
2640               destr_fnlist = (struct next_fnfieldlist *)
2641                 xmalloc (sizeof (struct next_fnfieldlist));
2642               make_cleanup (xfree, destr_fnlist);
2643               memset (destr_fnlist, 0, sizeof (struct next_fnfieldlist));
2644               destr_fnlist->fn_fieldlist.name
2645                 = obconcat (&objfile->objfile_obstack, "~",
2646                             new_fnlist->fn_fieldlist.name, (char *) NULL);
2647
2648               destr_fnlist->fn_fieldlist.fn_fields = (struct fn_field *)
2649                 obstack_alloc (&objfile->objfile_obstack,
2650                                sizeof (struct fn_field) * has_destructor);
2651               memset (destr_fnlist->fn_fieldlist.fn_fields, 0,
2652                   sizeof (struct fn_field) * has_destructor);
2653               tmp_sublist = sublist;
2654               last_sublist = NULL;
2655               i = 0;
2656               while (tmp_sublist != NULL)
2657                 {
2658                   if (!is_destructor_name (tmp_sublist->fn_field.physname))
2659                     {
2660                       tmp_sublist = tmp_sublist->next;
2661                       continue;
2662                     }
2663
2664                   destr_fnlist->fn_fieldlist.fn_fields[i++]
2665                     = tmp_sublist->fn_field;
2666                   if (last_sublist)
2667                     last_sublist->next = tmp_sublist->next;
2668                   else
2669                     sublist = tmp_sublist->next;
2670                   last_sublist = tmp_sublist;
2671                   tmp_sublist = tmp_sublist->next;
2672                 }
2673
2674               destr_fnlist->fn_fieldlist.length = has_destructor;
2675               destr_fnlist->next = fip->fnlist;
2676               fip->fnlist = destr_fnlist;
2677               nfn_fields++;
2678               length -= has_destructor;
2679             }
2680           else if (is_v3)
2681             {
2682               /* v3 mangling prevents the use of abbreviated physnames,
2683                  so we can do this here.  There are stubbed methods in v3
2684                  only:
2685                  - in -gstabs instead of -gstabs+
2686                  - or for static methods, which are output as a function type
2687                    instead of a method type.  */
2688               char *new_method_name =
2689                 stabs_method_name_from_physname (sublist->fn_field.physname);
2690
2691               if (new_method_name != NULL
2692                   && strcmp (new_method_name,
2693                              new_fnlist->fn_fieldlist.name) != 0)
2694                 {
2695                   new_fnlist->fn_fieldlist.name = new_method_name;
2696                   xfree (main_fn_name);
2697                 }
2698               else
2699                 xfree (new_method_name);
2700             }
2701           else if (has_destructor && new_fnlist->fn_fieldlist.name[0] != '~')
2702             {
2703               new_fnlist->fn_fieldlist.name =
2704                 obconcat (&objfile->objfile_obstack,
2705                           "~", main_fn_name, (char *)NULL);
2706               xfree (main_fn_name);
2707             }
2708           else if (!has_stub)
2709             {
2710               char dem_opname[256];
2711               int ret;
2712
2713               ret = cplus_demangle_opname (new_fnlist->fn_fieldlist.name,
2714                                               dem_opname, DMGL_ANSI);
2715               if (!ret)
2716                 ret = cplus_demangle_opname (new_fnlist->fn_fieldlist.name,
2717                                              dem_opname, 0);
2718               if (ret)
2719                 new_fnlist->fn_fieldlist.name
2720                   = obstack_copy0 (&objfile->objfile_obstack,
2721                                    dem_opname, strlen (dem_opname));
2722               xfree (main_fn_name);
2723             }
2724
2725           new_fnlist->fn_fieldlist.fn_fields = (struct fn_field *)
2726             obstack_alloc (&objfile->objfile_obstack,
2727                            sizeof (struct fn_field) * length);
2728           memset (new_fnlist->fn_fieldlist.fn_fields, 0,
2729                   sizeof (struct fn_field) * length);
2730           for (i = length; (i--, sublist); sublist = sublist->next)
2731             {
2732               new_fnlist->fn_fieldlist.fn_fields[i] = sublist->fn_field;
2733             }
2734
2735           new_fnlist->fn_fieldlist.length = length;
2736           new_fnlist->next = fip->fnlist;
2737           fip->fnlist = new_fnlist;
2738           nfn_fields++;
2739         }
2740     }
2741
2742   if (nfn_fields)
2743     {
2744       ALLOCATE_CPLUS_STRUCT_TYPE (type);
2745       TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
2746         TYPE_ALLOC (type, sizeof (struct fn_fieldlist) * nfn_fields);
2747       memset (TYPE_FN_FIELDLISTS (type), 0,
2748               sizeof (struct fn_fieldlist) * nfn_fields);
2749       TYPE_NFN_FIELDS (type) = nfn_fields;
2750     }
2751
2752   return 1;
2753 }
2754
2755 /* Special GNU C++ name.
2756
2757    Returns 1 for success, 0 for failure.  "failure" means that we can't
2758    keep parsing and it's time for error_type().  */
2759
2760 static int
2761 read_cpp_abbrev (struct field_info *fip, char **pp, struct type *type,
2762                  struct objfile *objfile)
2763 {
2764   char *p;
2765   const char *name;
2766   char cpp_abbrev;
2767   struct type *context;
2768
2769   p = *pp;
2770   if (*++p == 'v')
2771     {
2772       name = NULL;
2773       cpp_abbrev = *++p;
2774
2775       *pp = p + 1;
2776
2777       /* At this point, *pp points to something like "22:23=*22...",
2778          where the type number before the ':' is the "context" and
2779          everything after is a regular type definition.  Lookup the
2780          type, find it's name, and construct the field name.  */
2781
2782       context = read_type (pp, objfile);
2783
2784       switch (cpp_abbrev)
2785         {
2786         case 'f':               /* $vf -- a virtual function table pointer */
2787           name = type_name_no_tag (context);
2788           if (name == NULL)
2789             {
2790               name = "";
2791             }
2792           fip->list->field.name = obconcat (&objfile->objfile_obstack,
2793                                             vptr_name, name, (char *) NULL);
2794           break;
2795
2796         case 'b':               /* $vb -- a virtual bsomethingorother */
2797           name = type_name_no_tag (context);
2798           if (name == NULL)
2799             {
2800               complaint (&symfile_complaints,
2801                          _("C++ abbreviated type name "
2802                            "unknown at symtab pos %d"),
2803                          symnum);
2804               name = "FOO";
2805             }
2806           fip->list->field.name = obconcat (&objfile->objfile_obstack, vb_name,
2807                                             name, (char *) NULL);
2808           break;
2809
2810         default:
2811           invalid_cpp_abbrev_complaint (*pp);
2812           fip->list->field.name = obconcat (&objfile->objfile_obstack,
2813                                             "INVALID_CPLUSPLUS_ABBREV",
2814                                             (char *) NULL);
2815           break;
2816         }
2817
2818       /* At this point, *pp points to the ':'.  Skip it and read the
2819          field type.  */
2820
2821       p = ++(*pp);
2822       if (p[-1] != ':')
2823         {
2824           invalid_cpp_abbrev_complaint (*pp);
2825           return 0;
2826         }
2827       fip->list->field.type = read_type (pp, objfile);
2828       if (**pp == ',')
2829         (*pp)++;                /* Skip the comma.  */
2830       else
2831         return 0;
2832
2833       {
2834         int nbits;
2835
2836         SET_FIELD_BITPOS (fip->list->field,
2837                           read_huge_number (pp, ';', &nbits, 0));
2838         if (nbits != 0)
2839           return 0;
2840       }
2841       /* This field is unpacked.  */
2842       FIELD_BITSIZE (fip->list->field) = 0;
2843       fip->list->visibility = VISIBILITY_PRIVATE;
2844     }
2845   else
2846     {
2847       invalid_cpp_abbrev_complaint (*pp);
2848       /* We have no idea what syntax an unrecognized abbrev would have, so
2849          better return 0.  If we returned 1, we would need to at least advance
2850          *pp to avoid an infinite loop.  */
2851       return 0;
2852     }
2853   return 1;
2854 }
2855
2856 static void
2857 read_one_struct_field (struct field_info *fip, char **pp, char *p,
2858                        struct type *type, struct objfile *objfile)
2859 {
2860   struct gdbarch *gdbarch = get_objfile_arch (objfile);
2861
2862   fip->list->field.name =
2863     obstack_copy0 (&objfile->objfile_obstack, *pp, p - *pp);
2864   *pp = p + 1;
2865
2866   /* This means we have a visibility for a field coming.  */
2867   if (**pp == '/')
2868     {
2869       (*pp)++;
2870       fip->list->visibility = *(*pp)++;
2871     }
2872   else
2873     {
2874       /* normal dbx-style format, no explicit visibility */
2875       fip->list->visibility = VISIBILITY_PUBLIC;
2876     }
2877
2878   fip->list->field.type = read_type (pp, objfile);
2879   if (**pp == ':')
2880     {
2881       p = ++(*pp);
2882 #if 0
2883       /* Possible future hook for nested types.  */
2884       if (**pp == '!')
2885         {
2886           fip->list->field.bitpos = (long) -2;  /* nested type */
2887           p = ++(*pp);
2888         }
2889       else
2890         ...;
2891 #endif
2892       while (*p != ';')
2893         {
2894           p++;
2895         }
2896       /* Static class member.  */
2897       SET_FIELD_PHYSNAME (fip->list->field, savestring (*pp, p - *pp));
2898       *pp = p + 1;
2899       return;
2900     }
2901   else if (**pp != ',')
2902     {
2903       /* Bad structure-type format.  */
2904       stabs_general_complaint ("bad structure-type format");
2905       return;
2906     }
2907
2908   (*pp)++;                      /* Skip the comma.  */
2909
2910   {
2911     int nbits;
2912
2913     SET_FIELD_BITPOS (fip->list->field,
2914                       read_huge_number (pp, ',', &nbits, 0));
2915     if (nbits != 0)
2916       {
2917         stabs_general_complaint ("bad structure-type format");
2918         return;
2919       }
2920     FIELD_BITSIZE (fip->list->field) = read_huge_number (pp, ';', &nbits, 0);
2921     if (nbits != 0)
2922       {
2923         stabs_general_complaint ("bad structure-type format");
2924         return;
2925       }
2926   }
2927
2928   if (FIELD_BITPOS (fip->list->field) == 0
2929       && FIELD_BITSIZE (fip->list->field) == 0)
2930     {
2931       /* This can happen in two cases: (1) at least for gcc 2.4.5 or so,
2932          it is a field which has been optimized out.  The correct stab for
2933          this case is to use VISIBILITY_IGNORE, but that is a recent
2934          invention.  (2) It is a 0-size array.  For example
2935          union { int num; char str[0]; } foo.  Printing _("<no value>" for
2936          str in "p foo" is OK, since foo.str (and thus foo.str[3])
2937          will continue to work, and a 0-size array as a whole doesn't
2938          have any contents to print.
2939
2940          I suspect this probably could also happen with gcc -gstabs (not
2941          -gstabs+) for static fields, and perhaps other C++ extensions.
2942          Hopefully few people use -gstabs with gdb, since it is intended
2943          for dbx compatibility.  */
2944
2945       /* Ignore this field.  */
2946       fip->list->visibility = VISIBILITY_IGNORE;
2947     }
2948   else
2949     {
2950       /* Detect an unpacked field and mark it as such.
2951          dbx gives a bit size for all fields.
2952          Note that forward refs cannot be packed,
2953          and treat enums as if they had the width of ints.  */
2954
2955       struct type *field_type = check_typedef (FIELD_TYPE (fip->list->field));
2956
2957       if (TYPE_CODE (field_type) != TYPE_CODE_INT
2958           && TYPE_CODE (field_type) != TYPE_CODE_RANGE
2959           && TYPE_CODE (field_type) != TYPE_CODE_BOOL
2960           && TYPE_CODE (field_type) != TYPE_CODE_ENUM)
2961         {
2962           FIELD_BITSIZE (fip->list->field) = 0;
2963         }
2964       if ((FIELD_BITSIZE (fip->list->field)
2965            == TARGET_CHAR_BIT * TYPE_LENGTH (field_type)
2966            || (TYPE_CODE (field_type) == TYPE_CODE_ENUM
2967                && FIELD_BITSIZE (fip->list->field)
2968                   == gdbarch_int_bit (gdbarch))
2969           )
2970           &&
2971           FIELD_BITPOS (fip->list->field) % 8 == 0)
2972         {
2973           FIELD_BITSIZE (fip->list->field) = 0;
2974         }
2975     }
2976 }
2977
2978
2979 /* Read struct or class data fields.  They have the form:
2980
2981    NAME : [VISIBILITY] TYPENUM , BITPOS , BITSIZE ;
2982
2983    At the end, we see a semicolon instead of a field.
2984
2985    In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
2986    a static field.
2987
2988    The optional VISIBILITY is one of:
2989
2990    '/0' (VISIBILITY_PRIVATE)
2991    '/1' (VISIBILITY_PROTECTED)
2992    '/2' (VISIBILITY_PUBLIC)
2993    '/9' (VISIBILITY_IGNORE)
2994
2995    or nothing, for C style fields with public visibility.
2996
2997    Returns 1 for success, 0 for failure.  */
2998
2999 static int
3000 read_struct_fields (struct field_info *fip, char **pp, struct type *type,
3001                     struct objfile *objfile)
3002 {
3003   char *p;
3004   struct nextfield *newobj;
3005
3006   /* We better set p right now, in case there are no fields at all...    */
3007
3008   p = *pp;
3009
3010   /* Read each data member type until we find the terminating ';' at the end of
3011      the data member list, or break for some other reason such as finding the
3012      start of the member function list.  */
3013   /* Stab string for structure/union does not end with two ';' in
3014      SUN C compiler 5.3 i.e. F6U2, hence check for end of string.  */
3015
3016   while (**pp != ';' && **pp != '\0')
3017     {
3018       STABS_CONTINUE (pp, objfile);
3019       /* Get space to record the next field's data.  */
3020       newobj = (struct nextfield *) xmalloc (sizeof (struct nextfield));
3021       make_cleanup (xfree, newobj);
3022       memset (newobj, 0, sizeof (struct nextfield));
3023       newobj->next = fip->list;
3024       fip->list = newobj;
3025
3026       /* Get the field name.  */
3027       p = *pp;
3028
3029       /* If is starts with CPLUS_MARKER it is a special abbreviation,
3030          unless the CPLUS_MARKER is followed by an underscore, in
3031          which case it is just the name of an anonymous type, which we
3032          should handle like any other type name.  */
3033
3034       if (is_cplus_marker (p[0]) && p[1] != '_')
3035         {
3036           if (!read_cpp_abbrev (fip, pp, type, objfile))
3037             return 0;
3038           continue;
3039         }
3040
3041       /* Look for the ':' that separates the field name from the field
3042          values.  Data members are delimited by a single ':', while member
3043          functions are delimited by a pair of ':'s.  When we hit the member
3044          functions (if any), terminate scan loop and return.  */
3045
3046       while (*p != ':' && *p != '\0')
3047         {
3048           p++;
3049         }
3050       if (*p == '\0')
3051         return 0;
3052
3053       /* Check to see if we have hit the member functions yet.  */
3054       if (p[1] == ':')
3055         {
3056           break;
3057         }
3058       read_one_struct_field (fip, pp, p, type, objfile);
3059     }
3060   if (p[0] == ':' && p[1] == ':')
3061     {
3062       /* (the deleted) chill the list of fields: the last entry (at
3063          the head) is a partially constructed entry which we now
3064          scrub.  */
3065       fip->list = fip->list->next;
3066     }
3067   return 1;
3068 }
3069 /* *INDENT-OFF* */
3070 /* The stabs for C++ derived classes contain baseclass information which
3071    is marked by a '!' character after the total size.  This function is
3072    called when we encounter the baseclass marker, and slurps up all the
3073    baseclass information.
3074
3075    Immediately following the '!' marker is the number of base classes that
3076    the class is derived from, followed by information for each base class.
3077    For each base class, there are two visibility specifiers, a bit offset
3078    to the base class information within the derived class, a reference to
3079    the type for the base class, and a terminating semicolon.
3080
3081    A typical example, with two base classes, would be "!2,020,19;0264,21;".
3082                                                        ^^ ^ ^ ^  ^ ^  ^
3083         Baseclass information marker __________________|| | | |  | |  |
3084         Number of baseclasses __________________________| | | |  | |  |
3085         Visibility specifiers (2) ________________________| | |  | |  |
3086         Offset in bits from start of class _________________| |  | |  |
3087         Type number for base class ___________________________|  | |  |
3088         Visibility specifiers (2) _______________________________| |  |
3089         Offset in bits from start of class ________________________|  |
3090         Type number of base class ____________________________________|
3091
3092   Return 1 for success, 0 for (error-type-inducing) failure.  */
3093 /* *INDENT-ON* */
3094
3095
3096
3097 static int
3098 read_baseclasses (struct field_info *fip, char **pp, struct type *type,
3099                   struct objfile *objfile)
3100 {
3101   int i;
3102   struct nextfield *newobj;
3103
3104   if (**pp != '!')
3105     {
3106       return 1;
3107     }
3108   else
3109     {
3110       /* Skip the '!' baseclass information marker.  */
3111       (*pp)++;
3112     }
3113
3114   ALLOCATE_CPLUS_STRUCT_TYPE (type);
3115   {
3116     int nbits;
3117
3118     TYPE_N_BASECLASSES (type) = read_huge_number (pp, ',', &nbits, 0);
3119     if (nbits != 0)
3120       return 0;
3121   }
3122
3123 #if 0
3124   /* Some stupid compilers have trouble with the following, so break
3125      it up into simpler expressions.  */
3126   TYPE_FIELD_VIRTUAL_BITS (type) = (B_TYPE *)
3127     TYPE_ALLOC (type, B_BYTES (TYPE_N_BASECLASSES (type)));
3128 #else
3129   {
3130     int num_bytes = B_BYTES (TYPE_N_BASECLASSES (type));
3131     char *pointer;
3132
3133     pointer = (char *) TYPE_ALLOC (type, num_bytes);
3134     TYPE_FIELD_VIRTUAL_BITS (type) = (B_TYPE *) pointer;
3135   }
3136 #endif /* 0 */
3137
3138   B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), TYPE_N_BASECLASSES (type));
3139
3140   for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
3141     {
3142       newobj = (struct nextfield *) xmalloc (sizeof (struct nextfield));
3143       make_cleanup (xfree, newobj);
3144       memset (newobj, 0, sizeof (struct nextfield));
3145       newobj->next = fip->list;
3146       fip->list = newobj;
3147       FIELD_BITSIZE (newobj->field) = 0;        /* This should be an unpacked
3148                                            field!  */
3149
3150       STABS_CONTINUE (pp, objfile);
3151       switch (**pp)
3152         {
3153         case '0':
3154           /* Nothing to do.  */
3155           break;
3156         case '1':
3157           SET_TYPE_FIELD_VIRTUAL (type, i);
3158           break;
3159         default:
3160           /* Unknown character.  Complain and treat it as non-virtual.  */
3161           {
3162             complaint (&symfile_complaints,
3163                        _("Unknown virtual character `%c' for baseclass"),
3164                        **pp);
3165           }
3166         }
3167       ++(*pp);
3168
3169       newobj->visibility = *(*pp)++;
3170       switch (newobj->visibility)
3171         {
3172         case VISIBILITY_PRIVATE:
3173         case VISIBILITY_PROTECTED:
3174         case VISIBILITY_PUBLIC:
3175           break;
3176         default:
3177           /* Bad visibility format.  Complain and treat it as
3178              public.  */
3179           {
3180             complaint (&symfile_complaints,
3181                        _("Unknown visibility `%c' for baseclass"),
3182                        newobj->visibility);
3183             newobj->visibility = VISIBILITY_PUBLIC;
3184           }
3185         }
3186
3187       {
3188         int nbits;
3189
3190         /* The remaining value is the bit offset of the portion of the object
3191            corresponding to this baseclass.  Always zero in the absence of
3192            multiple inheritance.  */
3193
3194         SET_FIELD_BITPOS (newobj->field, read_huge_number (pp, ',', &nbits, 0));
3195         if (nbits != 0)
3196           return 0;
3197       }
3198
3199       /* The last piece of baseclass information is the type of the
3200          base class.  Read it, and remember it's type name as this
3201          field's name.  */
3202
3203       newobj->field.type = read_type (pp, objfile);
3204       newobj->field.name = type_name_no_tag (newobj->field.type);
3205
3206       /* Skip trailing ';' and bump count of number of fields seen.  */
3207       if (**pp == ';')
3208         (*pp)++;
3209       else
3210         return 0;
3211     }
3212   return 1;
3213 }
3214
3215 /* The tail end of stabs for C++ classes that contain a virtual function
3216    pointer contains a tilde, a %, and a type number.
3217    The type number refers to the base class (possibly this class itself) which
3218    contains the vtable pointer for the current class.
3219
3220    This function is called when we have parsed all the method declarations,
3221    so we can look for the vptr base class info.  */
3222
3223 static int
3224 read_tilde_fields (struct field_info *fip, char **pp, struct type *type,
3225                    struct objfile *objfile)
3226 {
3227   char *p;
3228
3229   STABS_CONTINUE (pp, objfile);
3230
3231   /* If we are positioned at a ';', then skip it.  */
3232   if (**pp == ';')
3233     {
3234       (*pp)++;
3235     }
3236
3237   if (**pp == '~')
3238     {
3239       (*pp)++;
3240
3241       if (**pp == '=' || **pp == '+' || **pp == '-')
3242         {
3243           /* Obsolete flags that used to indicate the presence
3244              of constructors and/or destructors.  */
3245           (*pp)++;
3246         }
3247
3248       /* Read either a '%' or the final ';'.  */
3249       if (*(*pp)++ == '%')
3250         {
3251           /* The next number is the type number of the base class
3252              (possibly our own class) which supplies the vtable for
3253              this class.  Parse it out, and search that class to find
3254              its vtable pointer, and install those into TYPE_VPTR_BASETYPE
3255              and TYPE_VPTR_FIELDNO.  */
3256
3257           struct type *t;
3258           int i;
3259
3260           t = read_type (pp, objfile);
3261           p = (*pp)++;
3262           while (*p != '\0' && *p != ';')
3263             {
3264               p++;
3265             }
3266           if (*p == '\0')
3267             {
3268               /* Premature end of symbol.  */
3269               return 0;
3270             }
3271
3272           set_type_vptr_basetype (type, t);
3273           if (type == t)        /* Our own class provides vtbl ptr.  */
3274             {
3275               for (i = TYPE_NFIELDS (t) - 1;
3276                    i >= TYPE_N_BASECLASSES (t);
3277                    --i)
3278                 {
3279                   const char *name = TYPE_FIELD_NAME (t, i);
3280
3281                   if (!strncmp (name, vptr_name, sizeof (vptr_name) - 2)
3282                       && is_cplus_marker (name[sizeof (vptr_name) - 2]))
3283                     {
3284                       set_type_vptr_fieldno (type, i);
3285                       goto gotit;
3286                     }
3287                 }
3288               /* Virtual function table field not found.  */
3289               complaint (&symfile_complaints,
3290                          _("virtual function table pointer "
3291                            "not found when defining class `%s'"),
3292                          TYPE_NAME (type));
3293               return 0;
3294             }
3295           else
3296             {
3297               set_type_vptr_fieldno (type, TYPE_VPTR_FIELDNO (t));
3298             }
3299
3300         gotit:
3301           *pp = p + 1;
3302         }
3303     }
3304   return 1;
3305 }
3306
3307 static int
3308 attach_fn_fields_to_type (struct field_info *fip, struct type *type)
3309 {
3310   int n;
3311
3312   for (n = TYPE_NFN_FIELDS (type);
3313        fip->fnlist != NULL;
3314        fip->fnlist = fip->fnlist->next)
3315     {
3316       --n;                      /* Circumvent Sun3 compiler bug.  */
3317       TYPE_FN_FIELDLISTS (type)[n] = fip->fnlist->fn_fieldlist;
3318     }
3319   return 1;
3320 }
3321
3322 /* Create the vector of fields, and record how big it is.
3323    We need this info to record proper virtual function table information
3324    for this class's virtual functions.  */
3325
3326 static int
3327 attach_fields_to_type (struct field_info *fip, struct type *type,
3328                        struct objfile *objfile)
3329 {
3330   int nfields = 0;
3331   int non_public_fields = 0;
3332   struct nextfield *scan;
3333
3334   /* Count up the number of fields that we have, as well as taking note of
3335      whether or not there are any non-public fields, which requires us to
3336      allocate and build the private_field_bits and protected_field_bits
3337      bitfields.  */
3338
3339   for (scan = fip->list; scan != NULL; scan = scan->next)
3340     {
3341       nfields++;
3342       if (scan->visibility != VISIBILITY_PUBLIC)
3343         {
3344           non_public_fields++;
3345         }
3346     }
3347
3348   /* Now we know how many fields there are, and whether or not there are any
3349      non-public fields.  Record the field count, allocate space for the
3350      array of fields, and create blank visibility bitfields if necessary.  */
3351
3352   TYPE_NFIELDS (type) = nfields;
3353   TYPE_FIELDS (type) = (struct field *)
3354     TYPE_ALLOC (type, sizeof (struct field) * nfields);
3355   memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nfields);
3356
3357   if (non_public_fields)
3358     {
3359       ALLOCATE_CPLUS_STRUCT_TYPE (type);
3360
3361       TYPE_FIELD_PRIVATE_BITS (type) =
3362         (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
3363       B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
3364
3365       TYPE_FIELD_PROTECTED_BITS (type) =
3366         (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
3367       B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
3368
3369       TYPE_FIELD_IGNORE_BITS (type) =
3370         (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
3371       B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
3372     }
3373
3374   /* Copy the saved-up fields into the field vector.  Start from the
3375      head of the list, adding to the tail of the field array, so that
3376      they end up in the same order in the array in which they were
3377      added to the list.  */
3378
3379   while (nfields-- > 0)
3380     {
3381       TYPE_FIELD (type, nfields) = fip->list->field;
3382       switch (fip->list->visibility)
3383         {
3384         case VISIBILITY_PRIVATE:
3385           SET_TYPE_FIELD_PRIVATE (type, nfields);
3386           break;
3387
3388         case VISIBILITY_PROTECTED:
3389           SET_TYPE_FIELD_PROTECTED (type, nfields);
3390           break;
3391
3392         case VISIBILITY_IGNORE:
3393           SET_TYPE_FIELD_IGNORE (type, nfields);
3394           break;
3395
3396         case VISIBILITY_PUBLIC:
3397           break;
3398
3399         default:
3400           /* Unknown visibility.  Complain and treat it as public.  */
3401           {
3402             complaint (&symfile_complaints,
3403                        _("Unknown visibility `%c' for field"),
3404                        fip->list->visibility);
3405           }
3406           break;
3407         }
3408       fip->list = fip->list->next;
3409     }
3410   return 1;
3411 }
3412
3413
3414 /* Complain that the compiler has emitted more than one definition for the
3415    structure type TYPE.  */
3416 static void
3417 complain_about_struct_wipeout (struct type *type)
3418 {
3419   const char *name = "";
3420   const char *kind = "";
3421
3422   if (TYPE_TAG_NAME (type))
3423     {
3424       name = TYPE_TAG_NAME (type);
3425       switch (TYPE_CODE (type))
3426         {
3427         case TYPE_CODE_STRUCT: kind = "struct "; break;
3428         case TYPE_CODE_UNION:  kind = "union ";  break;
3429         case TYPE_CODE_ENUM:   kind = "enum ";   break;
3430         default: kind = "";
3431         }
3432     }
3433   else if (TYPE_NAME (type))
3434     {
3435       name = TYPE_NAME (type);
3436       kind = "";
3437     }
3438   else
3439     {
3440       name = "<unknown>";
3441       kind = "";
3442     }
3443
3444   complaint (&symfile_complaints,
3445              _("struct/union type gets multiply defined: %s%s"), kind, name);
3446 }
3447
3448 /* Set the length for all variants of a same main_type, which are
3449    connected in the closed chain.
3450
3451    This is something that needs to be done when a type is defined *after*
3452    some cross references to this type have already been read.  Consider
3453    for instance the following scenario where we have the following two
3454    stabs entries:
3455
3456         .stabs  "t:p(0,21)=*(0,22)=k(0,23)=xsdummy:",160,0,28,-24
3457         .stabs  "dummy:T(0,23)=s16x:(0,1),0,3[...]"
3458
3459    A stubbed version of type dummy is created while processing the first
3460    stabs entry.  The length of that type is initially set to zero, since
3461    it is unknown at this point.  Also, a "constant" variation of type
3462    "dummy" is created as well (this is the "(0,22)=k(0,23)" section of
3463    the stabs line).
3464
3465    The second stabs entry allows us to replace the stubbed definition
3466    with the real definition.  However, we still need to adjust the length
3467    of the "constant" variation of that type, as its length was left
3468    untouched during the main type replacement...  */
3469
3470 static void
3471 set_length_in_type_chain (struct type *type)
3472 {
3473   struct type *ntype = TYPE_CHAIN (type);
3474
3475   while (ntype != type)
3476     {
3477       if (TYPE_LENGTH(ntype) == 0)
3478         TYPE_LENGTH (ntype) = TYPE_LENGTH (type);
3479       else
3480         complain_about_struct_wipeout (ntype);
3481       ntype = TYPE_CHAIN (ntype);
3482     }
3483 }
3484
3485 /* Read the description of a structure (or union type) and return an object
3486    describing the type.
3487
3488    PP points to a character pointer that points to the next unconsumed token
3489    in the stabs string.  For example, given stabs "A:T4=s4a:1,0,32;;",
3490    *PP will point to "4a:1,0,32;;".
3491
3492    TYPE points to an incomplete type that needs to be filled in.
3493
3494    OBJFILE points to the current objfile from which the stabs information is
3495    being read.  (Note that it is redundant in that TYPE also contains a pointer
3496    to this same objfile, so it might be a good idea to eliminate it.  FIXME).
3497  */
3498
3499 static struct type *
3500 read_struct_type (char **pp, struct type *type, enum type_code type_code,
3501                   struct objfile *objfile)
3502 {
3503   struct cleanup *back_to;
3504   struct field_info fi;
3505
3506   fi.list = NULL;
3507   fi.fnlist = NULL;
3508
3509   /* When describing struct/union/class types in stabs, G++ always drops
3510      all qualifications from the name.  So if you've got:
3511        struct A { ... struct B { ... }; ... };
3512      then G++ will emit stabs for `struct A::B' that call it simply
3513      `struct B'.  Obviously, if you've got a real top-level definition for
3514      `struct B', or other nested definitions, this is going to cause
3515      problems.
3516
3517      Obviously, GDB can't fix this by itself, but it can at least avoid
3518      scribbling on existing structure type objects when new definitions
3519      appear.  */
3520   if (! (TYPE_CODE (type) == TYPE_CODE_UNDEF
3521          || TYPE_STUB (type)))
3522     {
3523       complain_about_struct_wipeout (type);
3524
3525       /* It's probably best to return the type unchanged.  */
3526       return type;
3527     }
3528
3529   back_to = make_cleanup (null_cleanup, 0);
3530
3531   INIT_CPLUS_SPECIFIC (type);
3532   TYPE_CODE (type) = type_code;
3533   TYPE_STUB (type) = 0;
3534
3535   /* First comes the total size in bytes.  */
3536
3537   {
3538     int nbits;
3539
3540     TYPE_LENGTH (type) = read_huge_number (pp, 0, &nbits, 0);
3541     if (nbits != 0)
3542       {
3543         do_cleanups (back_to);
3544         return error_type (pp, objfile);
3545       }
3546     set_length_in_type_chain (type);
3547   }
3548
3549   /* Now read the baseclasses, if any, read the regular C struct or C++
3550      class member fields, attach the fields to the type, read the C++
3551      member functions, attach them to the type, and then read any tilde
3552      field (baseclass specifier for the class holding the main vtable).  */
3553
3554   if (!read_baseclasses (&fi, pp, type, objfile)
3555       || !read_struct_fields (&fi, pp, type, objfile)
3556       || !attach_fields_to_type (&fi, type, objfile)
3557       || !read_member_functions (&fi, pp, type, objfile)
3558       || !attach_fn_fields_to_type (&fi, type)
3559       || !read_tilde_fields (&fi, pp, type, objfile))
3560     {
3561       type = error_type (pp, objfile);
3562     }
3563
3564   do_cleanups (back_to);
3565   return (type);
3566 }
3567
3568 /* Read a definition of an array type,
3569    and create and return a suitable type object.
3570    Also creates a range type which represents the bounds of that
3571    array.  */
3572
3573 static struct type *
3574 read_array_type (char **pp, struct type *type,
3575                  struct objfile *objfile)
3576 {
3577   struct type *index_type, *element_type, *range_type;
3578   int lower, upper;
3579   int adjustable = 0;
3580   int nbits;
3581
3582   /* Format of an array type:
3583      "ar<index type>;lower;upper;<array_contents_type>".
3584      OS9000: "arlower,upper;<array_contents_type>".
3585
3586      Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
3587      for these, produce a type like float[][].  */
3588
3589     {
3590       index_type = read_type (pp, objfile);
3591       if (**pp != ';')
3592         /* Improper format of array type decl.  */
3593         return error_type (pp, objfile);
3594       ++*pp;
3595     }
3596
3597   if (!(**pp >= '0' && **pp <= '9') && **pp != '-')
3598     {
3599       (*pp)++;
3600       adjustable = 1;
3601     }
3602   lower = read_huge_number (pp, ';', &nbits, 0);
3603
3604   if (nbits != 0)
3605     return error_type (pp, objfile);
3606
3607   if (!(**pp >= '0' && **pp <= '9') && **pp != '-')
3608     {
3609       (*pp)++;
3610       adjustable = 1;
3611     }
3612   upper = read_huge_number (pp, ';', &nbits, 0);
3613   if (nbits != 0)
3614     return error_type (pp, objfile);
3615
3616   element_type = read_type (pp, objfile);
3617
3618   if (adjustable)
3619     {
3620       lower = 0;
3621       upper = -1;
3622     }
3623
3624   range_type =
3625     create_static_range_type ((struct type *) NULL, index_type, lower, upper);
3626   type = create_array_type (type, element_type, range_type);
3627
3628   return type;
3629 }
3630
3631
3632 /* Read a definition of an enumeration type,
3633    and create and return a suitable type object.
3634    Also defines the symbols that represent the values of the type.  */
3635
3636 static struct type *
3637 read_enum_type (char **pp, struct type *type,
3638                 struct objfile *objfile)
3639 {
3640   struct gdbarch *gdbarch = get_objfile_arch (objfile);
3641   char *p;
3642   char *name;
3643   long n;
3644   struct symbol *sym;
3645   int nsyms = 0;
3646   struct pending **symlist;
3647   struct pending *osyms, *syms;
3648   int o_nsyms;
3649   int nbits;
3650   int unsigned_enum = 1;
3651
3652 #if 0
3653   /* FIXME!  The stabs produced by Sun CC merrily define things that ought
3654      to be file-scope, between N_FN entries, using N_LSYM.  What's a mother
3655      to do?  For now, force all enum values to file scope.  */
3656   if (within_function)
3657     symlist = &local_symbols;
3658   else
3659 #endif
3660     symlist = &file_symbols;
3661   osyms = *symlist;
3662   o_nsyms = osyms ? osyms->nsyms : 0;
3663
3664   /* The aix4 compiler emits an extra field before the enum members;
3665      my guess is it's a type of some sort.  Just ignore it.  */
3666   if (**pp == '-')
3667     {
3668       /* Skip over the type.  */
3669       while (**pp != ':')
3670         (*pp)++;
3671
3672       /* Skip over the colon.  */
3673       (*pp)++;
3674     }
3675
3676   /* Read the value-names and their values.
3677      The input syntax is NAME:VALUE,NAME:VALUE, and so on.
3678      A semicolon or comma instead of a NAME means the end.  */
3679   while (**pp && **pp != ';' && **pp != ',')
3680     {
3681       STABS_CONTINUE (pp, objfile);
3682       p = *pp;
3683       while (*p != ':')
3684         p++;
3685       name = obstack_copy0 (&objfile->objfile_obstack, *pp, p - *pp);
3686       *pp = p + 1;
3687       n = read_huge_number (pp, ',', &nbits, 0);
3688       if (nbits != 0)
3689         return error_type (pp, objfile);
3690
3691       sym = allocate_symbol (objfile);
3692       SYMBOL_SET_LINKAGE_NAME (sym, name);
3693       SYMBOL_SET_LANGUAGE (sym, current_subfile->language,
3694                            &objfile->objfile_obstack);
3695       SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
3696       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
3697       SYMBOL_VALUE (sym) = n;
3698       if (n < 0)
3699         unsigned_enum = 0;
3700       add_symbol_to_list (sym, symlist);
3701       nsyms++;
3702     }
3703
3704   if (**pp == ';')
3705     (*pp)++;                    /* Skip the semicolon.  */
3706
3707   /* Now fill in the fields of the type-structure.  */
3708
3709   TYPE_LENGTH (type) = gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT;
3710   set_length_in_type_chain (type);
3711   TYPE_CODE (type) = TYPE_CODE_ENUM;
3712   TYPE_STUB (type) = 0;
3713   if (unsigned_enum)
3714     TYPE_UNSIGNED (type) = 1;
3715   TYPE_NFIELDS (type) = nsyms;
3716   TYPE_FIELDS (type) = (struct field *)
3717     TYPE_ALLOC (type, sizeof (struct field) * nsyms);
3718   memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nsyms);
3719
3720   /* Find the symbols for the values and put them into the type.
3721      The symbols can be found in the symlist that we put them on
3722      to cause them to be defined.  osyms contains the old value
3723      of that symlist; everything up to there was defined by us.  */
3724   /* Note that we preserve the order of the enum constants, so
3725      that in something like "enum {FOO, LAST_THING=FOO}" we print
3726      FOO, not LAST_THING.  */
3727
3728   for (syms = *symlist, n = nsyms - 1; syms; syms = syms->next)
3729     {
3730       int last = syms == osyms ? o_nsyms : 0;
3731       int j = syms->nsyms;
3732
3733       for (; --j >= last; --n)
3734         {
3735           struct symbol *xsym = syms->symbol[j];
3736
3737           SYMBOL_TYPE (xsym) = type;
3738           TYPE_FIELD_NAME (type, n) = SYMBOL_LINKAGE_NAME (xsym);
3739           SET_FIELD_ENUMVAL (TYPE_FIELD (type, n), SYMBOL_VALUE (xsym));
3740           TYPE_FIELD_BITSIZE (type, n) = 0;
3741         }
3742       if (syms == osyms)
3743         break;
3744     }
3745
3746   return type;
3747 }
3748
3749 /* Sun's ACC uses a somewhat saner method for specifying the builtin
3750    typedefs in every file (for int, long, etc):
3751
3752    type = b <signed> <width> <format type>; <offset>; <nbits>
3753    signed = u or s.
3754    optional format type = c or b for char or boolean.
3755    offset = offset from high order bit to start bit of type.
3756    width is # bytes in object of this type, nbits is # bits in type.
3757
3758    The width/offset stuff appears to be for small objects stored in
3759    larger ones (e.g. `shorts' in `int' registers).  We ignore it for now,
3760    FIXME.  */
3761
3762 static struct type *
3763 read_sun_builtin_type (char **pp, int typenums[2], struct objfile *objfile)
3764 {
3765   int type_bits;
3766   int nbits;
3767   int signed_type;
3768   enum type_code code = TYPE_CODE_INT;
3769
3770   switch (**pp)
3771     {
3772     case 's':
3773       signed_type = 1;
3774       break;
3775     case 'u':
3776       signed_type = 0;
3777       break;
3778     default:
3779       return error_type (pp, objfile);
3780     }
3781   (*pp)++;
3782
3783   /* For some odd reason, all forms of char put a c here.  This is strange
3784      because no other type has this honor.  We can safely ignore this because
3785      we actually determine 'char'acterness by the number of bits specified in
3786      the descriptor.
3787      Boolean forms, e.g Fortran logical*X, put a b here.  */
3788
3789   if (**pp == 'c')
3790     (*pp)++;
3791   else if (**pp == 'b')
3792     {
3793       code = TYPE_CODE_BOOL;
3794       (*pp)++;
3795     }
3796
3797   /* The first number appears to be the number of bytes occupied
3798      by this type, except that unsigned short is 4 instead of 2.
3799      Since this information is redundant with the third number,
3800      we will ignore it.  */
3801   read_huge_number (pp, ';', &nbits, 0);
3802   if (nbits != 0)
3803     return error_type (pp, objfile);
3804
3805   /* The second number is always 0, so ignore it too.  */
3806   read_huge_number (pp, ';', &nbits, 0);
3807   if (nbits != 0)
3808     return error_type (pp, objfile);
3809
3810   /* The third number is the number of bits for this type.  */
3811   type_bits = read_huge_number (pp, 0, &nbits, 0);
3812   if (nbits != 0)
3813     return error_type (pp, objfile);
3814   /* The type *should* end with a semicolon.  If it are embedded
3815      in a larger type the semicolon may be the only way to know where
3816      the type ends.  If this type is at the end of the stabstring we
3817      can deal with the omitted semicolon (but we don't have to like
3818      it).  Don't bother to complain(), Sun's compiler omits the semicolon
3819      for "void".  */
3820   if (**pp == ';')
3821     ++(*pp);
3822
3823   if (type_bits == 0)
3824     return init_type (TYPE_CODE_VOID, 1,
3825                       signed_type ? 0 : TYPE_FLAG_UNSIGNED, (char *) NULL,
3826                       objfile);
3827   else
3828     return init_type (code,
3829                       type_bits / TARGET_CHAR_BIT,
3830                       signed_type ? 0 : TYPE_FLAG_UNSIGNED, (char *) NULL,
3831                       objfile);
3832 }
3833
3834 static struct type *
3835 read_sun_floating_type (char **pp, int typenums[2], struct objfile *objfile)
3836 {
3837   int nbits;
3838   int details;
3839   int nbytes;
3840   struct type *rettype;
3841
3842   /* The first number has more details about the type, for example
3843      FN_COMPLEX.  */
3844   details = read_huge_number (pp, ';', &nbits, 0);
3845   if (nbits != 0)
3846     return error_type (pp, objfile);
3847
3848   /* The second number is the number of bytes occupied by this type.  */
3849   nbytes = read_huge_number (pp, ';', &nbits, 0);
3850   if (nbits != 0)
3851     return error_type (pp, objfile);
3852
3853   if (details == NF_COMPLEX || details == NF_COMPLEX16
3854       || details == NF_COMPLEX32)
3855     {
3856       rettype = init_type (TYPE_CODE_COMPLEX, nbytes, 0, NULL, objfile);
3857       TYPE_TARGET_TYPE (rettype)
3858         = init_type (TYPE_CODE_FLT, nbytes / 2, 0, NULL, objfile);
3859       return rettype;
3860     }
3861
3862   return init_type (TYPE_CODE_FLT, nbytes, 0, NULL, objfile);
3863 }
3864
3865 /* Read a number from the string pointed to by *PP.
3866    The value of *PP is advanced over the number.
3867    If END is nonzero, the character that ends the
3868    number must match END, or an error happens;
3869    and that character is skipped if it does match.
3870    If END is zero, *PP is left pointing to that character.
3871
3872    If TWOS_COMPLEMENT_BITS is set to a strictly positive value and if
3873    the number is represented in an octal representation, assume that
3874    it is represented in a 2's complement representation with a size of
3875    TWOS_COMPLEMENT_BITS.
3876
3877    If the number fits in a long, set *BITS to 0 and return the value.
3878    If not, set *BITS to be the number of bits in the number and return 0.
3879
3880    If encounter garbage, set *BITS to -1 and return 0.  */
3881
3882 static long
3883 read_huge_number (char **pp, int end, int *bits, int twos_complement_bits)
3884 {
3885   char *p = *pp;
3886   int sign = 1;
3887   int sign_bit = 0;
3888   long n = 0;
3889   int radix = 10;
3890   char overflow = 0;
3891   int nbits = 0;
3892   int c;
3893   long upper_limit;
3894   int twos_complement_representation = 0;
3895
3896   if (*p == '-')
3897     {
3898       sign = -1;
3899       p++;
3900     }
3901
3902   /* Leading zero means octal.  GCC uses this to output values larger
3903      than an int (because that would be hard in decimal).  */
3904   if (*p == '0')
3905     {
3906       radix = 8;
3907       p++;
3908     }
3909
3910   /* Skip extra zeros.  */
3911   while (*p == '0')
3912     p++;
3913
3914   if (sign > 0 && radix == 8 && twos_complement_bits > 0)
3915     {
3916       /* Octal, possibly signed.  Check if we have enough chars for a
3917          negative number.  */
3918
3919       size_t len;
3920       char *p1 = p;
3921
3922       while ((c = *p1) >= '0' && c < '8')
3923         p1++;
3924
3925       len = p1 - p;
3926       if (len > twos_complement_bits / 3
3927           || (twos_complement_bits % 3 == 0
3928               && len == twos_complement_bits / 3))
3929         {
3930           /* Ok, we have enough characters for a signed value, check
3931              for signness by testing if the sign bit is set.  */
3932           sign_bit = (twos_complement_bits % 3 + 2) % 3;
3933           c = *p - '0';
3934           if (c & (1 << sign_bit))
3935             {
3936               /* Definitely signed.  */
3937               twos_complement_representation = 1;
3938               sign = -1;
3939             }
3940         }
3941     }
3942
3943   upper_limit = LONG_MAX / radix;
3944
3945   while ((c = *p++) >= '0' && c < ('0' + radix))
3946     {
3947       if (n <= upper_limit)
3948         {
3949           if (twos_complement_representation)
3950             {
3951               /* Octal, signed, twos complement representation.  In
3952                  this case, n is the corresponding absolute value.  */
3953               if (n == 0)
3954                 {
3955                   long sn = c - '0' - ((2 * (c - '0')) | (2 << sign_bit));
3956
3957                   n = -sn;
3958                 }
3959               else
3960                 {
3961                   n *= radix;
3962                   n -= c - '0';
3963                 }
3964             }
3965           else
3966             {
3967               /* unsigned representation */
3968               n *= radix;
3969               n += c - '0';             /* FIXME this overflows anyway.  */
3970             }
3971         }
3972       else
3973         overflow = 1;
3974
3975       /* This depends on large values being output in octal, which is
3976          what GCC does.  */
3977       if (radix == 8)
3978         {
3979           if (nbits == 0)
3980             {
3981               if (c == '0')
3982                 /* Ignore leading zeroes.  */
3983                 ;
3984               else if (c == '1')
3985                 nbits = 1;
3986               else if (c == '2' || c == '3')
3987                 nbits = 2;
3988               else
3989                 nbits = 3;
3990             }
3991           else
3992             nbits += 3;
3993         }
3994     }
3995   if (end)
3996     {
3997       if (c && c != end)
3998         {
3999           if (bits != NULL)
4000             *bits = -1;
4001           return 0;
4002         }
4003     }
4004   else
4005     --p;
4006
4007   if (radix == 8 && twos_complement_bits > 0 && nbits > twos_complement_bits)
4008     {
4009       /* We were supposed to parse a number with maximum
4010          TWOS_COMPLEMENT_BITS bits, but something went wrong.  */
4011       if (bits != NULL)
4012         *bits = -1;
4013       return 0;
4014     }
4015
4016   *pp = p;
4017   if (overflow)
4018     {
4019       if (nbits == 0)
4020         {
4021           /* Large decimal constants are an error (because it is hard to
4022              count how many bits are in them).  */
4023           if (bits != NULL)
4024             *bits = -1;
4025           return 0;
4026         }
4027
4028       /* -0x7f is the same as 0x80.  So deal with it by adding one to
4029          the number of bits.  Two's complement represention octals
4030          can't have a '-' in front.  */
4031       if (sign == -1 && !twos_complement_representation)
4032         ++nbits;
4033       if (bits)
4034         *bits = nbits;
4035     }
4036   else
4037     {
4038       if (bits)
4039         *bits = 0;
4040       return n * sign;
4041     }
4042   /* It's *BITS which has the interesting information.  */
4043   return 0;
4044 }
4045
4046 static struct type *
4047 read_range_type (char **pp, int typenums[2], int type_size,
4048                  struct objfile *objfile)
4049 {
4050   struct gdbarch *gdbarch = get_objfile_arch (objfile);
4051   char *orig_pp = *pp;
4052   int rangenums[2];
4053   long n2, n3;
4054   int n2bits, n3bits;
4055   int self_subrange;
4056   struct type *result_type;
4057   struct type *index_type = NULL;
4058
4059   /* First comes a type we are a subrange of.
4060      In C it is usually 0, 1 or the type being defined.  */
4061   if (read_type_number (pp, rangenums) != 0)
4062     return error_type (pp, objfile);
4063   self_subrange = (rangenums[0] == typenums[0] &&
4064                    rangenums[1] == typenums[1]);
4065
4066   if (**pp == '=')
4067     {
4068       *pp = orig_pp;
4069       index_type = read_type (pp, objfile);
4070     }
4071
4072   /* A semicolon should now follow; skip it.  */
4073   if (**pp == ';')
4074     (*pp)++;
4075
4076   /* The remaining two operands are usually lower and upper bounds
4077      of the range.  But in some special cases they mean something else.  */
4078   n2 = read_huge_number (pp, ';', &n2bits, type_size);
4079   n3 = read_huge_number (pp, ';', &n3bits, type_size);
4080
4081   if (n2bits == -1 || n3bits == -1)
4082     return error_type (pp, objfile);
4083
4084   if (index_type)
4085     goto handle_true_range;
4086
4087   /* If limits are huge, must be large integral type.  */
4088   if (n2bits != 0 || n3bits != 0)
4089     {
4090       char got_signed = 0;
4091       char got_unsigned = 0;
4092       /* Number of bits in the type.  */
4093       int nbits = 0;
4094
4095       /* If a type size attribute has been specified, the bounds of
4096          the range should fit in this size.  If the lower bounds needs
4097          more bits than the upper bound, then the type is signed.  */
4098       if (n2bits <= type_size && n3bits <= type_size)
4099         {
4100           if (n2bits == type_size && n2bits > n3bits)
4101             got_signed = 1;
4102           else
4103             got_unsigned = 1;
4104           nbits = type_size;
4105         }
4106       /* Range from 0 to <large number> is an unsigned large integral type.  */
4107       else if ((n2bits == 0 && n2 == 0) && n3bits != 0)
4108         {
4109           got_unsigned = 1;
4110           nbits = n3bits;
4111         }
4112       /* Range from <large number> to <large number>-1 is a large signed
4113          integral type.  Take care of the case where <large number> doesn't
4114          fit in a long but <large number>-1 does.  */
4115       else if ((n2bits != 0 && n3bits != 0 && n2bits == n3bits + 1)
4116                || (n2bits != 0 && n3bits == 0
4117                    && (n2bits == sizeof (long) * HOST_CHAR_BIT)
4118                    && n3 == LONG_MAX))
4119         {
4120           got_signed = 1;
4121           nbits = n2bits;
4122         }
4123
4124       if (got_signed || got_unsigned)
4125         {
4126           return init_type (TYPE_CODE_INT, nbits / TARGET_CHAR_BIT,
4127                             got_unsigned ? TYPE_FLAG_UNSIGNED : 0, NULL,
4128                             objfile);
4129         }
4130       else
4131         return error_type (pp, objfile);
4132     }
4133
4134   /* A type defined as a subrange of itself, with bounds both 0, is void.  */
4135   if (self_subrange && n2 == 0 && n3 == 0)
4136     return init_type (TYPE_CODE_VOID, 1, 0, NULL, objfile);
4137
4138   /* If n3 is zero and n2 is positive, we want a floating type, and n2
4139      is the width in bytes.
4140
4141      Fortran programs appear to use this for complex types also.  To
4142      distinguish between floats and complex, g77 (and others?)  seem
4143      to use self-subranges for the complexes, and subranges of int for
4144      the floats.
4145
4146      Also note that for complexes, g77 sets n2 to the size of one of
4147      the member floats, not the whole complex beast.  My guess is that
4148      this was to work well with pre-COMPLEX versions of gdb.  */
4149
4150   if (n3 == 0 && n2 > 0)
4151     {
4152       struct type *float_type
4153         = init_type (TYPE_CODE_FLT, n2, 0, NULL, objfile);
4154
4155       if (self_subrange)
4156         {
4157           struct type *complex_type =
4158             init_type (TYPE_CODE_COMPLEX, 2 * n2, 0, NULL, objfile);
4159
4160           TYPE_TARGET_TYPE (complex_type) = float_type;
4161           return complex_type;
4162         }
4163       else
4164         return float_type;
4165     }
4166
4167   /* If the upper bound is -1, it must really be an unsigned integral.  */
4168
4169   else if (n2 == 0 && n3 == -1)
4170     {
4171       int bits = type_size;
4172
4173       if (bits <= 0)
4174         {
4175           /* We don't know its size.  It is unsigned int or unsigned
4176              long.  GCC 2.3.3 uses this for long long too, but that is
4177              just a GDB 3.5 compatibility hack.  */
4178           bits = gdbarch_int_bit (gdbarch);
4179         }
4180
4181       return init_type (TYPE_CODE_INT, bits / TARGET_CHAR_BIT,
4182                         TYPE_FLAG_UNSIGNED, NULL, objfile);
4183     }
4184
4185   /* Special case: char is defined (Who knows why) as a subrange of
4186      itself with range 0-127.  */
4187   else if (self_subrange && n2 == 0 && n3 == 127)
4188     return init_type (TYPE_CODE_INT, 1, TYPE_FLAG_NOSIGN, NULL, objfile);
4189
4190   /* We used to do this only for subrange of self or subrange of int.  */
4191   else if (n2 == 0)
4192     {
4193       /* -1 is used for the upper bound of (4 byte) "unsigned int" and
4194          "unsigned long", and we already checked for that,
4195          so don't need to test for it here.  */
4196
4197       if (n3 < 0)
4198         /* n3 actually gives the size.  */
4199         return init_type (TYPE_CODE_INT, -n3, TYPE_FLAG_UNSIGNED,
4200                           NULL, objfile);
4201
4202       /* Is n3 == 2**(8n)-1 for some integer n?  Then it's an
4203          unsigned n-byte integer.  But do require n to be a power of
4204          two; we don't want 3- and 5-byte integers flying around.  */
4205       {
4206         int bytes;
4207         unsigned long bits;
4208
4209         bits = n3;
4210         for (bytes = 0; (bits & 0xff) == 0xff; bytes++)
4211           bits >>= 8;
4212         if (bits == 0
4213             && ((bytes - 1) & bytes) == 0) /* "bytes is a power of two" */
4214           return init_type (TYPE_CODE_INT, bytes, TYPE_FLAG_UNSIGNED, NULL,
4215                             objfile);
4216       }
4217     }
4218   /* I think this is for Convex "long long".  Since I don't know whether
4219      Convex sets self_subrange, I also accept that particular size regardless
4220      of self_subrange.  */
4221   else if (n3 == 0 && n2 < 0
4222            && (self_subrange
4223                || n2 == -gdbarch_long_long_bit
4224                           (gdbarch) / TARGET_CHAR_BIT))
4225     return init_type (TYPE_CODE_INT, -n2, 0, NULL, objfile);
4226   else if (n2 == -n3 - 1)
4227     {
4228       if (n3 == 0x7f)
4229         return init_type (TYPE_CODE_INT, 1, 0, NULL, objfile);
4230       if (n3 == 0x7fff)
4231         return init_type (TYPE_CODE_INT, 2, 0, NULL, objfile);
4232       if (n3 == 0x7fffffff)
4233         return init_type (TYPE_CODE_INT, 4, 0, NULL, objfile);
4234     }
4235
4236   /* We have a real range type on our hands.  Allocate space and
4237      return a real pointer.  */
4238 handle_true_range:
4239
4240   if (self_subrange)
4241     index_type = objfile_type (objfile)->builtin_int;
4242   else
4243     index_type = *dbx_lookup_type (rangenums, objfile);
4244   if (index_type == NULL)
4245     {
4246       /* Does this actually ever happen?  Is that why we are worrying
4247          about dealing with it rather than just calling error_type?  */
4248
4249       complaint (&symfile_complaints,
4250                  _("base type %d of range type is not defined"), rangenums[1]);
4251
4252       index_type = objfile_type (objfile)->builtin_int;
4253     }
4254
4255   result_type
4256     = create_static_range_type ((struct type *) NULL, index_type, n2, n3);
4257   return (result_type);
4258 }
4259
4260 /* Read in an argument list.  This is a list of types, separated by commas
4261    and terminated with END.  Return the list of types read in, or NULL
4262    if there is an error.  */
4263
4264 static struct field *
4265 read_args (char **pp, int end, struct objfile *objfile, int *nargsp,
4266            int *varargsp)
4267 {
4268   /* FIXME!  Remove this arbitrary limit!  */
4269   struct type *types[1024];     /* Allow for fns of 1023 parameters.  */
4270   int n = 0, i;
4271   struct field *rval;
4272
4273   while (**pp != end)
4274     {
4275       if (**pp != ',')
4276         /* Invalid argument list: no ','.  */
4277         return NULL;
4278       (*pp)++;
4279       STABS_CONTINUE (pp, objfile);
4280       types[n++] = read_type (pp, objfile);
4281     }
4282   (*pp)++;                      /* get past `end' (the ':' character).  */
4283
4284   if (n == 0)
4285     {
4286       /* We should read at least the THIS parameter here.  Some broken stabs
4287          output contained `(0,41),(0,42)=@s8;-16;,(0,43),(0,1);' where should
4288          have been present ";-16,(0,43)" reference instead.  This way the
4289          excessive ";" marker prematurely stops the parameters parsing.  */
4290
4291       complaint (&symfile_complaints, _("Invalid (empty) method arguments"));
4292       *varargsp = 0;
4293     }
4294   else if (TYPE_CODE (types[n - 1]) != TYPE_CODE_VOID)
4295     *varargsp = 1;
4296   else
4297     {
4298       n--;
4299       *varargsp = 0;
4300     }
4301
4302   rval = (struct field *) xmalloc (n * sizeof (struct field));
4303   memset (rval, 0, n * sizeof (struct field));
4304   for (i = 0; i < n; i++)
4305     rval[i].type = types[i];
4306   *nargsp = n;
4307   return rval;
4308 }
4309 \f
4310 /* Common block handling.  */
4311
4312 /* List of symbols declared since the last BCOMM.  This list is a tail
4313    of local_symbols.  When ECOMM is seen, the symbols on the list
4314    are noted so their proper addresses can be filled in later,
4315    using the common block base address gotten from the assembler
4316    stabs.  */
4317
4318 static struct pending *common_block;
4319 static int common_block_i;
4320
4321 /* Name of the current common block.  We get it from the BCOMM instead of the
4322    ECOMM to match IBM documentation (even though IBM puts the name both places
4323    like everyone else).  */
4324 static char *common_block_name;
4325
4326 /* Process a N_BCOMM symbol.  The storage for NAME is not guaranteed
4327    to remain after this function returns.  */
4328
4329 void
4330 common_block_start (char *name, struct objfile *objfile)
4331 {
4332   if (common_block_name != NULL)
4333     {
4334       complaint (&symfile_complaints,
4335                  _("Invalid symbol data: common block within common block"));
4336     }
4337   common_block = local_symbols;
4338   common_block_i = local_symbols ? local_symbols->nsyms : 0;
4339   common_block_name = obstack_copy0 (&objfile->objfile_obstack,
4340                                      name, strlen (name));
4341 }
4342
4343 /* Process a N_ECOMM symbol.  */
4344
4345 void
4346 common_block_end (struct objfile *objfile)
4347 {
4348   /* Symbols declared since the BCOMM are to have the common block
4349      start address added in when we know it.  common_block and
4350      common_block_i point to the first symbol after the BCOMM in
4351      the local_symbols list; copy the list and hang it off the
4352      symbol for the common block name for later fixup.  */
4353   int i;
4354   struct symbol *sym;
4355   struct pending *newobj = 0;
4356   struct pending *next;
4357   int j;
4358
4359   if (common_block_name == NULL)
4360     {
4361       complaint (&symfile_complaints, _("ECOMM symbol unmatched by BCOMM"));
4362       return;
4363     }
4364
4365   sym = allocate_symbol (objfile);
4366   /* Note: common_block_name already saved on objfile_obstack.  */
4367   SYMBOL_SET_LINKAGE_NAME (sym, common_block_name);
4368   SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
4369
4370   /* Now we copy all the symbols which have been defined since the BCOMM.  */
4371
4372   /* Copy all the struct pendings before common_block.  */
4373   for (next = local_symbols;
4374        next != NULL && next != common_block;
4375        next = next->next)
4376     {
4377       for (j = 0; j < next->nsyms; j++)
4378         add_symbol_to_list (next->symbol[j], &newobj);
4379     }
4380
4381   /* Copy however much of COMMON_BLOCK we need.  If COMMON_BLOCK is
4382      NULL, it means copy all the local symbols (which we already did
4383      above).  */
4384
4385   if (common_block != NULL)
4386     for (j = common_block_i; j < common_block->nsyms; j++)
4387       add_symbol_to_list (common_block->symbol[j], &newobj);
4388
4389   SYMBOL_TYPE (sym) = (struct type *) newobj;
4390
4391   /* Should we be putting local_symbols back to what it was?
4392      Does it matter?  */
4393
4394   i = hashname (SYMBOL_LINKAGE_NAME (sym));
4395   SYMBOL_VALUE_CHAIN (sym) = global_sym_chain[i];
4396   global_sym_chain[i] = sym;
4397   common_block_name = NULL;
4398 }
4399
4400 /* Add a common block's start address to the offset of each symbol
4401    declared to be in it (by being between a BCOMM/ECOMM pair that uses
4402    the common block name).  */
4403
4404 static void
4405 fix_common_block (struct symbol *sym, CORE_ADDR valu)
4406 {
4407   struct pending *next = (struct pending *) SYMBOL_TYPE (sym);
4408
4409   for (; next; next = next->next)
4410     {
4411       int j;
4412
4413       for (j = next->nsyms - 1; j >= 0; j--)
4414         SYMBOL_VALUE_ADDRESS (next->symbol[j]) += valu;
4415     }
4416 }
4417 \f
4418
4419
4420 /* Add {TYPE, TYPENUMS} to the NONAME_UNDEFS vector.
4421    See add_undefined_type for more details.  */
4422
4423 static void
4424 add_undefined_type_noname (struct type *type, int typenums[2])
4425 {
4426   struct nat nat;
4427
4428   nat.typenums[0] = typenums [0];
4429   nat.typenums[1] = typenums [1];
4430   nat.type = type;
4431
4432   if (noname_undefs_length == noname_undefs_allocated)
4433     {
4434       noname_undefs_allocated *= 2;
4435       noname_undefs = (struct nat *)
4436         xrealloc ((char *) noname_undefs,
4437                   noname_undefs_allocated * sizeof (struct nat));
4438     }
4439   noname_undefs[noname_undefs_length++] = nat;
4440 }
4441
4442 /* Add TYPE to the UNDEF_TYPES vector.
4443    See add_undefined_type for more details.  */
4444
4445 static void
4446 add_undefined_type_1 (struct type *type)
4447 {
4448   if (undef_types_length == undef_types_allocated)
4449     {
4450       undef_types_allocated *= 2;
4451       undef_types = (struct type **)
4452         xrealloc ((char *) undef_types,
4453                   undef_types_allocated * sizeof (struct type *));
4454     }
4455   undef_types[undef_types_length++] = type;
4456 }
4457
4458 /* What about types defined as forward references inside of a small lexical
4459    scope?  */
4460 /* Add a type to the list of undefined types to be checked through
4461    once this file has been read in.
4462
4463    In practice, we actually maintain two such lists: The first list
4464    (UNDEF_TYPES) is used for types whose name has been provided, and
4465    concerns forward references (eg 'xs' or 'xu' forward references);
4466    the second list (NONAME_UNDEFS) is used for types whose name is
4467    unknown at creation time, because they were referenced through
4468    their type number before the actual type was declared.
4469    This function actually adds the given type to the proper list.  */
4470
4471 static void
4472 add_undefined_type (struct type *type, int typenums[2])
4473 {
4474   if (TYPE_TAG_NAME (type) == NULL)
4475     add_undefined_type_noname (type, typenums);
4476   else
4477     add_undefined_type_1 (type);
4478 }
4479
4480 /* Try to fix all undefined types pushed on the UNDEF_TYPES vector.  */
4481
4482 static void
4483 cleanup_undefined_types_noname (struct objfile *objfile)
4484 {
4485   int i;
4486
4487   for (i = 0; i < noname_undefs_length; i++)
4488     {
4489       struct nat nat = noname_undefs[i];
4490       struct type **type;
4491
4492       type = dbx_lookup_type (nat.typenums, objfile);
4493       if (nat.type != *type && TYPE_CODE (*type) != TYPE_CODE_UNDEF)
4494         {
4495           /* The instance flags of the undefined type are still unset,
4496              and needs to be copied over from the reference type.
4497              Since replace_type expects them to be identical, we need
4498              to set these flags manually before hand.  */
4499           TYPE_INSTANCE_FLAGS (nat.type) = TYPE_INSTANCE_FLAGS (*type);
4500           replace_type (nat.type, *type);
4501         }
4502     }
4503
4504   noname_undefs_length = 0;
4505 }
4506
4507 /* Go through each undefined type, see if it's still undefined, and fix it
4508    up if possible.  We have two kinds of undefined types:
4509
4510    TYPE_CODE_ARRAY:  Array whose target type wasn't defined yet.
4511    Fix:  update array length using the element bounds
4512    and the target type's length.
4513    TYPE_CODE_STRUCT, TYPE_CODE_UNION:  Structure whose fields were not
4514    yet defined at the time a pointer to it was made.
4515    Fix:  Do a full lookup on the struct/union tag.  */
4516
4517 static void
4518 cleanup_undefined_types_1 (void)
4519 {
4520   struct type **type;
4521
4522   /* Iterate over every undefined type, and look for a symbol whose type
4523      matches our undefined type.  The symbol matches if:
4524        1. It is a typedef in the STRUCT domain;
4525        2. It has the same name, and same type code;
4526        3. The instance flags are identical.
4527
4528      It is important to check the instance flags, because we have seen
4529      examples where the debug info contained definitions such as:
4530
4531          "foo_t:t30=B31=xefoo_t:"
4532
4533      In this case, we have created an undefined type named "foo_t" whose
4534      instance flags is null (when processing "xefoo_t"), and then created
4535      another type with the same name, but with different instance flags
4536      ('B' means volatile).  I think that the definition above is wrong,
4537      since the same type cannot be volatile and non-volatile at the same
4538      time, but we need to be able to cope with it when it happens.  The
4539      approach taken here is to treat these two types as different.  */
4540
4541   for (type = undef_types; type < undef_types + undef_types_length; type++)
4542     {
4543       switch (TYPE_CODE (*type))
4544         {
4545
4546         case TYPE_CODE_STRUCT:
4547         case TYPE_CODE_UNION:
4548         case TYPE_CODE_ENUM:
4549           {
4550             /* Check if it has been defined since.  Need to do this here
4551                as well as in check_typedef to deal with the (legitimate in
4552                C though not C++) case of several types with the same name
4553                in different source files.  */
4554             if (TYPE_STUB (*type))
4555               {
4556                 struct pending *ppt;
4557                 int i;
4558                 /* Name of the type, without "struct" or "union".  */
4559                 const char *type_name = TYPE_TAG_NAME (*type);
4560
4561                 if (type_name == NULL)
4562                   {
4563                     complaint (&symfile_complaints, _("need a type name"));
4564                     break;
4565                   }
4566                 for (ppt = file_symbols; ppt; ppt = ppt->next)
4567                   {
4568                     for (i = 0; i < ppt->nsyms; i++)
4569                       {
4570                         struct symbol *sym = ppt->symbol[i];
4571
4572                         if (SYMBOL_CLASS (sym) == LOC_TYPEDEF
4573                             && SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
4574                             && (TYPE_CODE (SYMBOL_TYPE (sym)) ==
4575                                 TYPE_CODE (*type))
4576                             && (TYPE_INSTANCE_FLAGS (*type) ==
4577                                 TYPE_INSTANCE_FLAGS (SYMBOL_TYPE (sym)))
4578                             && strcmp (SYMBOL_LINKAGE_NAME (sym),
4579                                        type_name) == 0)
4580                           replace_type (*type, SYMBOL_TYPE (sym));
4581                       }
4582                   }
4583               }
4584           }
4585           break;
4586
4587         default:
4588           {
4589             complaint (&symfile_complaints,
4590                        _("forward-referenced types left unresolved, "
4591                        "type code %d."),
4592                        TYPE_CODE (*type));
4593           }
4594           break;
4595         }
4596     }
4597
4598   undef_types_length = 0;
4599 }
4600
4601 /* Try to fix all the undefined types we ecountered while processing
4602    this unit.  */
4603
4604 void
4605 cleanup_undefined_stabs_types (struct objfile *objfile)
4606 {
4607   cleanup_undefined_types_1 ();
4608   cleanup_undefined_types_noname (objfile);
4609 }
4610
4611 /* Scan through all of the global symbols defined in the object file,
4612    assigning values to the debugging symbols that need to be assigned
4613    to.  Get these symbols from the minimal symbol table.  */
4614
4615 void
4616 scan_file_globals (struct objfile *objfile)
4617 {
4618   int hash;
4619   struct minimal_symbol *msymbol;
4620   struct symbol *sym, *prev;
4621   struct objfile *resolve_objfile;
4622
4623   /* SVR4 based linkers copy referenced global symbols from shared
4624      libraries to the main executable.
4625      If we are scanning the symbols for a shared library, try to resolve
4626      them from the minimal symbols of the main executable first.  */
4627
4628   if (symfile_objfile && objfile != symfile_objfile)
4629     resolve_objfile = symfile_objfile;
4630   else
4631     resolve_objfile = objfile;
4632
4633   while (1)
4634     {
4635       /* Avoid expensive loop through all minimal symbols if there are
4636          no unresolved symbols.  */
4637       for (hash = 0; hash < HASHSIZE; hash++)
4638         {
4639           if (global_sym_chain[hash])
4640             break;
4641         }
4642       if (hash >= HASHSIZE)
4643         return;
4644
4645       ALL_OBJFILE_MSYMBOLS (resolve_objfile, msymbol)
4646         {
4647           QUIT;
4648
4649           /* Skip static symbols.  */
4650           switch (MSYMBOL_TYPE (msymbol))
4651             {
4652             case mst_file_text:
4653             case mst_file_data:
4654             case mst_file_bss:
4655               continue;
4656             default:
4657               break;
4658             }
4659
4660           prev = NULL;
4661
4662           /* Get the hash index and check all the symbols
4663              under that hash index.  */
4664
4665           hash = hashname (MSYMBOL_LINKAGE_NAME (msymbol));
4666
4667           for (sym = global_sym_chain[hash]; sym;)
4668             {
4669               if (strcmp (MSYMBOL_LINKAGE_NAME (msymbol),
4670                           SYMBOL_LINKAGE_NAME (sym)) == 0)
4671                 {
4672                   /* Splice this symbol out of the hash chain and
4673                      assign the value we have to it.  */
4674                   if (prev)
4675                     {
4676                       SYMBOL_VALUE_CHAIN (prev) = SYMBOL_VALUE_CHAIN (sym);
4677                     }
4678                   else
4679                     {
4680                       global_sym_chain[hash] = SYMBOL_VALUE_CHAIN (sym);
4681                     }
4682
4683                   /* Check to see whether we need to fix up a common block.  */
4684                   /* Note: this code might be executed several times for
4685                      the same symbol if there are multiple references.  */
4686                   if (sym)
4687                     {
4688                       if (SYMBOL_CLASS (sym) == LOC_BLOCK)
4689                         {
4690                           fix_common_block (sym,
4691                                             MSYMBOL_VALUE_ADDRESS (resolve_objfile,
4692                                                                    msymbol));
4693                         }
4694                       else
4695                         {
4696                           SYMBOL_VALUE_ADDRESS (sym)
4697                             = MSYMBOL_VALUE_ADDRESS (resolve_objfile, msymbol);
4698                         }
4699                       SYMBOL_SECTION (sym) = MSYMBOL_SECTION (msymbol);
4700                     }
4701
4702                   if (prev)
4703                     {
4704                       sym = SYMBOL_VALUE_CHAIN (prev);
4705                     }
4706                   else
4707                     {
4708                       sym = global_sym_chain[hash];
4709                     }
4710                 }
4711               else
4712                 {
4713                   prev = sym;
4714                   sym = SYMBOL_VALUE_CHAIN (sym);
4715                 }
4716             }
4717         }
4718       if (resolve_objfile == objfile)
4719         break;
4720       resolve_objfile = objfile;
4721     }
4722
4723   /* Change the storage class of any remaining unresolved globals to
4724      LOC_UNRESOLVED and remove them from the chain.  */
4725   for (hash = 0; hash < HASHSIZE; hash++)
4726     {
4727       sym = global_sym_chain[hash];
4728       while (sym)
4729         {
4730           prev = sym;
4731           sym = SYMBOL_VALUE_CHAIN (sym);
4732
4733           /* Change the symbol address from the misleading chain value
4734              to address zero.  */
4735           SYMBOL_VALUE_ADDRESS (prev) = 0;
4736
4737           /* Complain about unresolved common block symbols.  */
4738           if (SYMBOL_CLASS (prev) == LOC_STATIC)
4739             SYMBOL_ACLASS_INDEX (prev) = LOC_UNRESOLVED;
4740           else
4741             complaint (&symfile_complaints,
4742                        _("%s: common block `%s' from "
4743                          "global_sym_chain unresolved"),
4744                        objfile_name (objfile), SYMBOL_PRINT_NAME (prev));
4745         }
4746     }
4747   memset (global_sym_chain, 0, sizeof (global_sym_chain));
4748 }
4749
4750 /* Initialize anything that needs initializing when starting to read
4751    a fresh piece of a symbol file, e.g. reading in the stuff corresponding
4752    to a psymtab.  */
4753
4754 void
4755 stabsread_init (void)
4756 {
4757 }
4758
4759 /* Initialize anything that needs initializing when a completely new
4760    symbol file is specified (not just adding some symbols from another
4761    file, e.g. a shared library).  */
4762
4763 void
4764 stabsread_new_init (void)
4765 {
4766   /* Empty the hash table of global syms looking for values.  */
4767   memset (global_sym_chain, 0, sizeof (global_sym_chain));
4768 }
4769
4770 /* Initialize anything that needs initializing at the same time as
4771    start_symtab() is called.  */
4772
4773 void
4774 start_stabs (void)
4775 {
4776   global_stabs = NULL;          /* AIX COFF */
4777   /* Leave FILENUM of 0 free for builtin types and this file's types.  */
4778   n_this_object_header_files = 1;
4779   type_vector_length = 0;
4780   type_vector = (struct type **) 0;
4781
4782   /* FIXME: If common_block_name is not already NULL, we should complain().  */
4783   common_block_name = NULL;
4784 }
4785
4786 /* Call after end_symtab().  */
4787
4788 void
4789 end_stabs (void)
4790 {
4791   if (type_vector)
4792     {
4793       xfree (type_vector);
4794     }
4795   type_vector = 0;
4796   type_vector_length = 0;
4797   previous_stab_code = 0;
4798 }
4799
4800 void
4801 finish_global_stabs (struct objfile *objfile)
4802 {
4803   if (global_stabs)
4804     {
4805       patch_block_stabs (global_symbols, global_stabs, objfile);
4806       xfree (global_stabs);
4807       global_stabs = NULL;
4808     }
4809 }
4810
4811 /* Find the end of the name, delimited by a ':', but don't match
4812    ObjC symbols which look like -[Foo bar::]:bla.  */
4813 static char *
4814 find_name_end (char *name)
4815 {
4816   char *s = name;
4817
4818   if (s[0] == '-' || *s == '+')
4819     {
4820       /* Must be an ObjC method symbol.  */
4821       if (s[1] != '[')
4822         {
4823           error (_("invalid symbol name \"%s\""), name);
4824         }
4825       s = strchr (s, ']');
4826       if (s == NULL)
4827         {
4828           error (_("invalid symbol name \"%s\""), name);
4829         }
4830       return strchr (s, ':');
4831     }
4832   else
4833     {
4834       return strchr (s, ':');
4835     }
4836 }
4837
4838 /* Initializer for this module.  */
4839
4840 void
4841 _initialize_stabsread (void)
4842 {
4843   rs6000_builtin_type_data = register_objfile_data ();
4844
4845   undef_types_allocated = 20;
4846   undef_types_length = 0;
4847   undef_types = (struct type **)
4848     xmalloc (undef_types_allocated * sizeof (struct type *));
4849
4850   noname_undefs_allocated = 20;
4851   noname_undefs_length = 0;
4852   noname_undefs = (struct nat *)
4853     xmalloc (noname_undefs_allocated * sizeof (struct nat));
4854
4855   stab_register_index = register_symbol_register_impl (LOC_REGISTER,
4856                                                        &stab_register_funcs);
4857   stab_regparm_index = register_symbol_register_impl (LOC_REGPARM_ADDR,
4858                                                       &stab_register_funcs);
4859 }