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