gdb/stabsread.c

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