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