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