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