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