gdb/stabsread.c

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