gdb/stabsread.c

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