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