gdb/stabsread.c

   1 /* Support routines for decoding "stabs" debugging information format.
   2
   3    Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
   4    1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free
   5    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., 59 Temple Place - Suite 330,
  22    Boston, MA 02111-1307, 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             char *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 = (char *)
 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           type = dbx_alloc_type (typenums, objfile);
1808           smash_to_method_type (type, domain, return_type, args,
1809                                 nargs, varargs);
1810         }
1811       break;
1812
1813     case 'r':                   /* Range type */
1814       type = read_range_type (pp, typenums, type_size, objfile);
1815       if (typenums[0] != -1)
1816         *dbx_lookup_type (typenums) = type;
1817       break;
1818
1819     case 'b':
1820         {
1821           /* Sun ACC builtin int type */
1822           type = read_sun_builtin_type (pp, typenums, objfile);
1823           if (typenums[0] != -1)
1824             *dbx_lookup_type (typenums) = type;
1825         }
1826       break;
1827
1828     case 'R':                   /* Sun ACC builtin float type */
1829       type = read_sun_floating_type (pp, typenums, objfile);
1830       if (typenums[0] != -1)
1831         *dbx_lookup_type (typenums) = type;
1832       break;
1833
1834     case 'e':                   /* Enumeration type */
1835       type = dbx_alloc_type (typenums, objfile);
1836       type = read_enum_type (pp, type, objfile);
1837       if (typenums[0] != -1)
1838         *dbx_lookup_type (typenums) = type;
1839       break;
1840
1841     case 's':                   /* Struct type */
1842     case 'u':                   /* Union type */
1843       {
1844         enum type_code type_code = TYPE_CODE_UNDEF;
1845         type = dbx_alloc_type (typenums, objfile);
1846         switch (type_descriptor)
1847           {
1848           case 's':
1849             type_code = TYPE_CODE_STRUCT;
1850             break;
1851           case 'u':
1852             type_code = TYPE_CODE_UNION;
1853             break;
1854           }
1855         type = read_struct_type (pp, type, type_code, objfile);
1856         break;
1857       }
1858
1859     case 'a':                   /* Array type */
1860       if (**pp != 'r')
1861         return error_type (pp, objfile);
1862       ++*pp;
1863
1864       type = dbx_alloc_type (typenums, objfile);
1865       type = read_array_type (pp, type, objfile);
1866       if (is_string)
1867         TYPE_CODE (type) = TYPE_CODE_STRING;
1868       if (is_vector)
1869         TYPE_FLAGS (type) |= TYPE_FLAG_VECTOR;
1870       break;
1871
1872     case 'S':                   /* Set or bitstring  type */
1873       type1 = read_type (pp, objfile);
1874       type = create_set_type ((struct type *) NULL, type1);
1875       if (is_string)
1876         TYPE_CODE (type) = TYPE_CODE_BITSTRING;
1877       if (typenums[0] != -1)
1878         *dbx_lookup_type (typenums) = type;
1879       break;
1880
1881     default:
1882       --*pp;                    /* Go back to the symbol in error */
1883       /* Particularly important if it was \0! */
1884       return error_type (pp, objfile);
1885     }
1886
1887   if (type == 0)
1888     {
1889       warning (_("GDB internal error, type is NULL in stabsread.c."));
1890       return error_type (pp, objfile);
1891     }
1892
1893   /* Size specified in a type attribute overrides any other size.  */
1894   if (type_size != -1)
1895     TYPE_LENGTH (type) = (type_size + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT;
1896
1897   return type;
1898 }
1899 \f
1900 /* RS/6000 xlc/dbx combination uses a set of builtin types, starting from -1.
1901    Return the proper type node for a given builtin type number. */
1902
1903 static struct type *
1904 rs6000_builtin_type (int typenum)
1905 {
1906   /* We recognize types numbered from -NUMBER_RECOGNIZED to -1.  */
1907 #define NUMBER_RECOGNIZED 34
1908   /* This includes an empty slot for type number -0.  */
1909   static struct type *negative_types[NUMBER_RECOGNIZED + 1];
1910   struct type *rettype = NULL;
1911
1912   if (typenum >= 0 || typenum < -NUMBER_RECOGNIZED)
1913     {
1914       complaint (&symfile_complaints, _("Unknown builtin type %d"), typenum);
1915       return builtin_type_error;
1916     }
1917   if (negative_types[-typenum] != NULL)
1918     return negative_types[-typenum];
1919
1920 #if TARGET_CHAR_BIT != 8
1921 #error This code wrong for TARGET_CHAR_BIT not 8
1922   /* These definitions all assume that TARGET_CHAR_BIT is 8.  I think
1923      that if that ever becomes not true, the correct fix will be to
1924      make the size in the struct type to be in bits, not in units of
1925      TARGET_CHAR_BIT.  */
1926 #endif
1927
1928   switch (-typenum)
1929     {
1930     case 1:
1931       /* The size of this and all the other types are fixed, defined
1932          by the debugging format.  If there is a type called "int" which
1933          is other than 32 bits, then it should use a new negative type
1934          number (or avoid negative type numbers for that case).
1935          See stabs.texinfo.  */
1936       rettype = init_type (TYPE_CODE_INT, 4, 0, "int", NULL);
1937       break;
1938     case 2:
1939       rettype = init_type (TYPE_CODE_INT, 1, 0, "char", NULL);
1940       break;
1941     case 3:
1942       rettype = init_type (TYPE_CODE_INT, 2, 0, "short", NULL);
1943       break;
1944     case 4:
1945       rettype = init_type (TYPE_CODE_INT, 4, 0, "long", NULL);
1946       break;
1947     case 5:
1948       rettype = init_type (TYPE_CODE_INT, 1, TYPE_FLAG_UNSIGNED,
1949                            "unsigned char", NULL);
1950       break;
1951     case 6:
1952       rettype = init_type (TYPE_CODE_INT, 1, 0, "signed char", NULL);
1953       break;
1954     case 7:
1955       rettype = init_type (TYPE_CODE_INT, 2, TYPE_FLAG_UNSIGNED,
1956                            "unsigned short", NULL);
1957       break;
1958     case 8:
1959       rettype = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
1960                            "unsigned int", NULL);
1961       break;
1962     case 9:
1963       rettype = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
1964                            "unsigned", NULL);
1965     case 10:
1966       rettype = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
1967                            "unsigned long", NULL);
1968       break;
1969     case 11:
1970       rettype = init_type (TYPE_CODE_VOID, 1, 0, "void", NULL);
1971       break;
1972     case 12:
1973       /* IEEE single precision (32 bit).  */
1974       rettype = init_type (TYPE_CODE_FLT, 4, 0, "float", NULL);
1975       break;
1976     case 13:
1977       /* IEEE double precision (64 bit).  */
1978       rettype = init_type (TYPE_CODE_FLT, 8, 0, "double", NULL);
1979       break;
1980     case 14:
1981       /* This is an IEEE double on the RS/6000, and different machines with
1982          different sizes for "long double" should use different negative
1983          type numbers.  See stabs.texinfo.  */
1984       rettype = init_type (TYPE_CODE_FLT, 8, 0, "long double", NULL);
1985       break;
1986     case 15:
1987       rettype = init_type (TYPE_CODE_INT, 4, 0, "integer", NULL);
1988       break;
1989     case 16:
1990       rettype = init_type (TYPE_CODE_BOOL, 4, TYPE_FLAG_UNSIGNED,
1991                            "boolean", NULL);
1992       break;
1993     case 17:
1994       rettype = init_type (TYPE_CODE_FLT, 4, 0, "short real", NULL);
1995       break;
1996     case 18:
1997       rettype = init_type (TYPE_CODE_FLT, 8, 0, "real", NULL);
1998       break;
1999     case 19:
2000       rettype = init_type (TYPE_CODE_ERROR, 0, 0, "stringptr", NULL);
2001       break;
2002     case 20:
2003       rettype = init_type (TYPE_CODE_CHAR, 1, TYPE_FLAG_UNSIGNED,
2004                            "character", NULL);
2005       break;
2006     case 21:
2007       rettype = init_type (TYPE_CODE_BOOL, 1, TYPE_FLAG_UNSIGNED,
2008                            "logical*1", NULL);
2009       break;
2010     case 22:
2011       rettype = init_type (TYPE_CODE_BOOL, 2, TYPE_FLAG_UNSIGNED,
2012                            "logical*2", NULL);
2013       break;
2014     case 23:
2015       rettype = init_type (TYPE_CODE_BOOL, 4, TYPE_FLAG_UNSIGNED,
2016                            "logical*4", NULL);
2017       break;
2018     case 24:
2019       rettype = init_type (TYPE_CODE_BOOL, 4, TYPE_FLAG_UNSIGNED,
2020                            "logical", NULL);
2021       break;
2022     case 25:
2023       /* Complex type consisting of two IEEE single precision values.  */
2024       rettype = init_type (TYPE_CODE_COMPLEX, 8, 0, "complex", NULL);
2025       TYPE_TARGET_TYPE (rettype) = init_type (TYPE_CODE_FLT, 4, 0, "float",
2026                                               NULL);
2027       break;
2028     case 26:
2029       /* Complex type consisting of two IEEE double precision values.  */
2030       rettype = init_type (TYPE_CODE_COMPLEX, 16, 0, "double complex", NULL);
2031       TYPE_TARGET_TYPE (rettype) = init_type (TYPE_CODE_FLT, 8, 0, "double",
2032                                               NULL);
2033       break;
2034     case 27:
2035       rettype = init_type (TYPE_CODE_INT, 1, 0, "integer*1", NULL);
2036       break;
2037     case 28:
2038       rettype = init_type (TYPE_CODE_INT, 2, 0, "integer*2", NULL);
2039       break;
2040     case 29:
2041       rettype = init_type (TYPE_CODE_INT, 4, 0, "integer*4", NULL);
2042       break;
2043     case 30:
2044       rettype = init_type (TYPE_CODE_CHAR, 2, 0, "wchar", NULL);
2045       break;
2046     case 31:
2047       rettype = init_type (TYPE_CODE_INT, 8, 0, "long long", NULL);
2048       break;
2049     case 32:
2050       rettype = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED,
2051                            "unsigned long long", NULL);
2052       break;
2053     case 33:
2054       rettype = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED,
2055                            "logical*8", NULL);
2056       break;
2057     case 34:
2058       rettype = init_type (TYPE_CODE_INT, 8, 0, "integer*8", NULL);
2059       break;
2060     }
2061   negative_types[-typenum] = rettype;
2062   return rettype;
2063 }
2064 \f
2065 /* This page contains subroutines of read_type.  */
2066
2067 /* Replace *OLD_NAME with the method name portion of PHYSNAME.  */
2068
2069 static void
2070 update_method_name_from_physname (char **old_name, char *physname)
2071 {
2072   char *method_name;
2073
2074   method_name = method_name_from_physname (physname);
2075
2076   if (method_name == NULL)
2077     {
2078       complaint (&symfile_complaints,
2079                  _("Method has bad physname %s\n"), physname);
2080       return;
2081     }
2082
2083   if (strcmp (*old_name, method_name) != 0)
2084     {
2085       xfree (*old_name);
2086       *old_name = method_name;
2087     }
2088   else
2089     xfree (method_name);
2090 }
2091
2092 /* Read member function stabs info for C++ classes.  The form of each member
2093    function data is:
2094
2095    NAME :: TYPENUM[=type definition] ARGS : PHYSNAME ;
2096
2097    An example with two member functions is:
2098
2099    afunc1::20=##15;:i;2A.;afunc2::20:i;2A.;
2100
2101    For the case of overloaded operators, the format is op$::*.funcs, where
2102    $ is the CPLUS_MARKER (usually '$'), `*' holds the place for an operator
2103    name (such as `+=') and `.' marks the end of the operator name.
2104
2105    Returns 1 for success, 0 for failure.  */
2106
2107 static int
2108 read_member_functions (struct field_info *fip, char **pp, struct type *type,
2109                        struct objfile *objfile)
2110 {
2111   int nfn_fields = 0;
2112   int length = 0;
2113   /* Total number of member functions defined in this class.  If the class
2114      defines two `f' functions, and one `g' function, then this will have
2115      the value 3.  */
2116   int total_length = 0;
2117   int i;
2118   struct next_fnfield
2119     {
2120       struct next_fnfield *next;
2121       struct fn_field fn_field;
2122     }
2123    *sublist;
2124   struct type *look_ahead_type;
2125   struct next_fnfieldlist *new_fnlist;
2126   struct next_fnfield *new_sublist;
2127   char *main_fn_name;
2128   char *p;
2129
2130   /* Process each list until we find something that is not a member function
2131      or find the end of the functions. */
2132
2133   while (**pp != ';')
2134     {
2135       /* We should be positioned at the start of the function name.
2136          Scan forward to find the first ':' and if it is not the
2137          first of a "::" delimiter, then this is not a member function. */
2138       p = *pp;
2139       while (*p != ':')
2140         {
2141           p++;
2142         }
2143       if (p[1] != ':')
2144         {
2145           break;
2146         }
2147
2148       sublist = NULL;
2149       look_ahead_type = NULL;
2150       length = 0;
2151
2152       new_fnlist = (struct next_fnfieldlist *)
2153         xmalloc (sizeof (struct next_fnfieldlist));
2154       make_cleanup (xfree, new_fnlist);
2155       memset (new_fnlist, 0, sizeof (struct next_fnfieldlist));
2156
2157       if ((*pp)[0] == 'o' && (*pp)[1] == 'p' && is_cplus_marker ((*pp)[2]))
2158         {
2159           /* This is a completely wierd case.  In order to stuff in the
2160              names that might contain colons (the usual name delimiter),
2161              Mike Tiemann defined a different name format which is
2162              signalled if the identifier is "op$".  In that case, the
2163              format is "op$::XXXX." where XXXX is the name.  This is
2164              used for names like "+" or "=".  YUUUUUUUK!  FIXME!  */
2165           /* This lets the user type "break operator+".
2166              We could just put in "+" as the name, but that wouldn't
2167              work for "*".  */
2168           static char opname[32] = "op$";
2169           char *o = opname + 3;
2170
2171           /* Skip past '::'.  */
2172           *pp = p + 2;
2173
2174           STABS_CONTINUE (pp, objfile);
2175           p = *pp;
2176           while (*p != '.')
2177             {
2178               *o++ = *p++;
2179             }
2180           main_fn_name = savestring (opname, o - opname);
2181           /* Skip past '.'  */
2182           *pp = p + 1;
2183         }
2184       else
2185         {
2186           main_fn_name = savestring (*pp, p - *pp);
2187           /* Skip past '::'.  */
2188           *pp = p + 2;
2189         }
2190       new_fnlist->fn_fieldlist.name = main_fn_name;
2191
2192       do
2193         {
2194           new_sublist =
2195             (struct next_fnfield *) xmalloc (sizeof (struct next_fnfield));
2196           make_cleanup (xfree, new_sublist);
2197           memset (new_sublist, 0, sizeof (struct next_fnfield));
2198
2199           /* Check for and handle cretinous dbx symbol name continuation!  */
2200           if (look_ahead_type == NULL)
2201             {
2202               /* Normal case. */
2203               STABS_CONTINUE (pp, objfile);
2204
2205               new_sublist->fn_field.type = read_type (pp, objfile);
2206               if (**pp != ':')
2207                 {
2208                   /* Invalid symtab info for member function.  */
2209                   return 0;
2210                 }
2211             }
2212           else
2213             {
2214               /* g++ version 1 kludge */
2215               new_sublist->fn_field.type = look_ahead_type;
2216               look_ahead_type = NULL;
2217             }
2218
2219           (*pp)++;
2220           p = *pp;
2221           while (*p != ';')
2222             {
2223               p++;
2224             }
2225
2226           /* If this is just a stub, then we don't have the real name here. */
2227
2228           if (TYPE_STUB (new_sublist->fn_field.type))
2229             {
2230               if (!TYPE_DOMAIN_TYPE (new_sublist->fn_field.type))
2231                 TYPE_DOMAIN_TYPE (new_sublist->fn_field.type) = type;
2232               new_sublist->fn_field.is_stub = 1;
2233             }
2234           new_sublist->fn_field.physname = savestring (*pp, p - *pp);
2235           *pp = p + 1;
2236
2237           /* Set this member function's visibility fields.  */
2238           switch (*(*pp)++)
2239             {
2240             case VISIBILITY_PRIVATE:
2241               new_sublist->fn_field.is_private = 1;
2242               break;
2243             case VISIBILITY_PROTECTED:
2244               new_sublist->fn_field.is_protected = 1;
2245               break;
2246             }
2247
2248           STABS_CONTINUE (pp, objfile);
2249           switch (**pp)
2250             {
2251             case 'A':           /* Normal functions. */
2252               new_sublist->fn_field.is_const = 0;
2253               new_sublist->fn_field.is_volatile = 0;
2254               (*pp)++;
2255               break;
2256             case 'B':           /* `const' member functions. */
2257               new_sublist->fn_field.is_const = 1;
2258               new_sublist->fn_field.is_volatile = 0;
2259               (*pp)++;
2260               break;
2261             case 'C':           /* `volatile' member function. */
2262               new_sublist->fn_field.is_const = 0;
2263               new_sublist->fn_field.is_volatile = 1;
2264               (*pp)++;
2265               break;
2266             case 'D':           /* `const volatile' member function. */
2267               new_sublist->fn_field.is_const = 1;
2268               new_sublist->fn_field.is_volatile = 1;
2269               (*pp)++;
2270               break;
2271             case '*':           /* File compiled with g++ version 1 -- no info */
2272             case '?':
2273             case '.':
2274               break;
2275             default:
2276               complaint (&symfile_complaints,
2277                          _("const/volatile indicator missing, got '%c'"), **pp);
2278               break;
2279             }
2280
2281           switch (*(*pp)++)
2282             {
2283             case '*':
2284               {
2285                 int nbits;
2286                 /* virtual member function, followed by index.
2287                    The sign bit is set to distinguish pointers-to-methods
2288                    from virtual function indicies.  Since the array is
2289                    in words, the quantity must be shifted left by 1
2290                    on 16 bit machine, and by 2 on 32 bit machine, forcing
2291                    the sign bit out, and usable as a valid index into
2292                    the array.  Remove the sign bit here.  */
2293                 new_sublist->fn_field.voffset =
2294                   (0x7fffffff & read_huge_number (pp, ';', &nbits, 0)) + 2;
2295                 if (nbits != 0)
2296                   return 0;
2297
2298                 STABS_CONTINUE (pp, objfile);
2299                 if (**pp == ';' || **pp == '\0')
2300                   {
2301                     /* Must be g++ version 1.  */
2302                     new_sublist->fn_field.fcontext = 0;
2303                   }
2304                 else
2305                   {
2306                     /* Figure out from whence this virtual function came.
2307                        It may belong to virtual function table of
2308                        one of its baseclasses.  */
2309                     look_ahead_type = read_type (pp, objfile);
2310                     if (**pp == ':')
2311                       {
2312                         /* g++ version 1 overloaded methods. */
2313                       }
2314                     else
2315                       {
2316                         new_sublist->fn_field.fcontext = look_ahead_type;
2317                         if (**pp != ';')
2318                           {
2319                             return 0;
2320                           }
2321                         else
2322                           {
2323                             ++*pp;
2324                           }
2325                         look_ahead_type = NULL;
2326                       }
2327                   }
2328                 break;
2329               }
2330             case '?':
2331               /* static member function.  */
2332               {
2333                 int slen = strlen (main_fn_name);
2334
2335                 new_sublist->fn_field.voffset = VOFFSET_STATIC;
2336
2337                 /* For static member functions, we can't tell if they
2338                    are stubbed, as they are put out as functions, and not as
2339                    methods.
2340                    GCC v2 emits the fully mangled name if
2341                    dbxout.c:flag_minimal_debug is not set, so we have to
2342                    detect a fully mangled physname here and set is_stub
2343                    accordingly.  Fully mangled physnames in v2 start with
2344                    the member function name, followed by two underscores.
2345                    GCC v3 currently always emits stubbed member functions,
2346                    but with fully mangled physnames, which start with _Z.  */
2347                 if (!(strncmp (new_sublist->fn_field.physname,
2348                                main_fn_name, slen) == 0
2349                       && new_sublist->fn_field.physname[slen] == '_'
2350                       && new_sublist->fn_field.physname[slen + 1] == '_'))
2351                   {
2352                     new_sublist->fn_field.is_stub = 1;
2353                   }
2354                 break;
2355               }
2356
2357             default:
2358               /* error */
2359               complaint (&symfile_complaints,
2360                          _("member function type missing, got '%c'"), (*pp)[-1]);
2361               /* Fall through into normal member function.  */
2362
2363             case '.':
2364               /* normal member function.  */
2365               new_sublist->fn_field.voffset = 0;
2366               new_sublist->fn_field.fcontext = 0;
2367               break;
2368             }
2369
2370           new_sublist->next = sublist;
2371           sublist = new_sublist;
2372           length++;
2373           STABS_CONTINUE (pp, objfile);
2374         }
2375       while (**pp != ';' && **pp != '\0');
2376
2377       (*pp)++;
2378       STABS_CONTINUE (pp, objfile);
2379
2380       /* Skip GCC 3.X member functions which are duplicates of the callable
2381          constructor/destructor.  */
2382       if (strcmp (main_fn_name, "__base_ctor") == 0
2383           || strcmp (main_fn_name, "__base_dtor") == 0
2384           || strcmp (main_fn_name, "__deleting_dtor") == 0)
2385         {
2386           xfree (main_fn_name);
2387         }
2388       else
2389         {
2390           int has_stub = 0;
2391           int has_destructor = 0, has_other = 0;
2392           int is_v3 = 0;
2393           struct next_fnfield *tmp_sublist;
2394
2395           /* Various versions of GCC emit various mostly-useless
2396              strings in the name field for special member functions.
2397
2398              For stub methods, we need to defer correcting the name
2399              until we are ready to unstub the method, because the current
2400              name string is used by gdb_mangle_name.  The only stub methods
2401              of concern here are GNU v2 operators; other methods have their
2402              names correct (see caveat below).
2403
2404              For non-stub methods, in GNU v3, we have a complete physname.
2405              Therefore we can safely correct the name now.  This primarily
2406              affects constructors and destructors, whose name will be
2407              __comp_ctor or __comp_dtor instead of Foo or ~Foo.  Cast
2408              operators will also have incorrect names; for instance,
2409              "operator int" will be named "operator i" (i.e. the type is
2410              mangled).
2411
2412              For non-stub methods in GNU v2, we have no easy way to
2413              know if we have a complete physname or not.  For most
2414              methods the result depends on the platform (if CPLUS_MARKER
2415              can be `$' or `.', it will use minimal debug information, or
2416              otherwise the full physname will be included).
2417
2418              Rather than dealing with this, we take a different approach.
2419              For v3 mangled names, we can use the full physname; for v2,
2420              we use cplus_demangle_opname (which is actually v2 specific),
2421              because the only interesting names are all operators - once again
2422              barring the caveat below.  Skip this process if any method in the
2423              group is a stub, to prevent our fouling up the workings of
2424              gdb_mangle_name.
2425
2426              The caveat: GCC 2.95.x (and earlier?) put constructors and
2427              destructors in the same method group.  We need to split this
2428              into two groups, because they should have different names.
2429              So for each method group we check whether it contains both
2430              routines whose physname appears to be a destructor (the physnames
2431              for and destructors are always provided, due to quirks in v2
2432              mangling) and routines whose physname does not appear to be a
2433              destructor.  If so then we break up the list into two halves.
2434              Even if the constructors and destructors aren't in the same group
2435              the destructor will still lack the leading tilde, so that also
2436              needs to be fixed.
2437
2438              So, to summarize what we expect and handle here:
2439
2440                 Given         Given          Real         Real       Action
2441              method name     physname      physname   method name
2442
2443              __opi            [none]     __opi__3Foo  operator int    opname
2444                                                                    [now or later]
2445              Foo              _._3Foo       _._3Foo      ~Foo       separate and
2446                                                                        rename
2447              operator i     _ZN3FoocviEv _ZN3FoocviEv operator int    demangle
2448              __comp_ctor  _ZN3FooC1ERKS_ _ZN3FooC1ERKS_   Foo         demangle
2449           */
2450
2451           tmp_sublist = sublist;
2452           while (tmp_sublist != NULL)
2453             {
2454               if (tmp_sublist->fn_field.is_stub)
2455                 has_stub = 1;
2456               if (tmp_sublist->fn_field.physname[0] == '_'
2457                   && tmp_sublist->fn_field.physname[1] == 'Z')
2458                 is_v3 = 1;
2459
2460               if (is_destructor_name (tmp_sublist->fn_field.physname))
2461                 has_destructor++;
2462               else
2463                 has_other++;
2464
2465               tmp_sublist = tmp_sublist->next;
2466             }
2467
2468           if (has_destructor && has_other)
2469             {
2470               struct next_fnfieldlist *destr_fnlist;
2471               struct next_fnfield *last_sublist;
2472
2473               /* Create a new fn_fieldlist for the destructors.  */
2474
2475               destr_fnlist = (struct next_fnfieldlist *)
2476                 xmalloc (sizeof (struct next_fnfieldlist));
2477               make_cleanup (xfree, destr_fnlist);
2478               memset (destr_fnlist, 0, sizeof (struct next_fnfieldlist));
2479               destr_fnlist->fn_fieldlist.name
2480                 = obconcat (&objfile->objfile_obstack, "", "~",
2481                             new_fnlist->fn_fieldlist.name);
2482
2483               destr_fnlist->fn_fieldlist.fn_fields = (struct fn_field *)
2484                 obstack_alloc (&objfile->objfile_obstack,
2485                                sizeof (struct fn_field) * has_destructor);
2486               memset (destr_fnlist->fn_fieldlist.fn_fields, 0,
2487                   sizeof (struct fn_field) * has_destructor);
2488               tmp_sublist = sublist;
2489               last_sublist = NULL;
2490               i = 0;
2491               while (tmp_sublist != NULL)
2492                 {
2493                   if (!is_destructor_name (tmp_sublist->fn_field.physname))
2494                     {
2495                       tmp_sublist = tmp_sublist->next;
2496                       continue;
2497                     }
2498
2499                   destr_fnlist->fn_fieldlist.fn_fields[i++]
2500                     = tmp_sublist->fn_field;
2501                   if (last_sublist)
2502                     last_sublist->next = tmp_sublist->next;
2503                   else
2504                     sublist = tmp_sublist->next;
2505                   last_sublist = tmp_sublist;
2506                   tmp_sublist = tmp_sublist->next;
2507                 }
2508
2509               destr_fnlist->fn_fieldlist.length = has_destructor;
2510               destr_fnlist->next = fip->fnlist;
2511               fip->fnlist = destr_fnlist;
2512               nfn_fields++;
2513               total_length += has_destructor;
2514               length -= has_destructor;
2515             }
2516           else if (is_v3)
2517             {
2518               /* v3 mangling prevents the use of abbreviated physnames,
2519                  so we can do this here.  There are stubbed methods in v3
2520                  only:
2521                  - in -gstabs instead of -gstabs+
2522                  - or for static methods, which are output as a function type
2523                    instead of a method type.  */
2524
2525               update_method_name_from_physname (&new_fnlist->fn_fieldlist.name,
2526                                                 sublist->fn_field.physname);
2527             }
2528           else if (has_destructor && new_fnlist->fn_fieldlist.name[0] != '~')
2529             {
2530               new_fnlist->fn_fieldlist.name = concat ("~", main_fn_name, NULL);
2531               xfree (main_fn_name);
2532             }
2533           else if (!has_stub)
2534             {
2535               char dem_opname[256];
2536               int ret;
2537               ret = cplus_demangle_opname (new_fnlist->fn_fieldlist.name,
2538                                               dem_opname, DMGL_ANSI);
2539               if (!ret)
2540                 ret = cplus_demangle_opname (new_fnlist->fn_fieldlist.name,
2541                                              dem_opname, 0);
2542               if (ret)
2543                 new_fnlist->fn_fieldlist.name
2544                   = obsavestring (dem_opname, strlen (dem_opname),
2545                                   &objfile->objfile_obstack);
2546             }
2547
2548           new_fnlist->fn_fieldlist.fn_fields = (struct fn_field *)
2549             obstack_alloc (&objfile->objfile_obstack,
2550                            sizeof (struct fn_field) * length);
2551           memset (new_fnlist->fn_fieldlist.fn_fields, 0,
2552                   sizeof (struct fn_field) * length);
2553           for (i = length; (i--, sublist); sublist = sublist->next)
2554             {
2555               new_fnlist->fn_fieldlist.fn_fields[i] = sublist->fn_field;
2556             }
2557
2558           new_fnlist->fn_fieldlist.length = length;
2559           new_fnlist->next = fip->fnlist;
2560           fip->fnlist = new_fnlist;
2561           nfn_fields++;
2562           total_length += length;
2563         }
2564     }
2565
2566   if (nfn_fields)
2567     {
2568       ALLOCATE_CPLUS_STRUCT_TYPE (type);
2569       TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
2570         TYPE_ALLOC (type, sizeof (struct fn_fieldlist) * nfn_fields);
2571       memset (TYPE_FN_FIELDLISTS (type), 0,
2572               sizeof (struct fn_fieldlist) * nfn_fields);
2573       TYPE_NFN_FIELDS (type) = nfn_fields;
2574       TYPE_NFN_FIELDS_TOTAL (type) = total_length;
2575     }
2576
2577   return 1;
2578 }
2579
2580 /* Special GNU C++ name.
2581
2582    Returns 1 for success, 0 for failure.  "failure" means that we can't
2583    keep parsing and it's time for error_type().  */
2584
2585 static int
2586 read_cpp_abbrev (struct field_info *fip, char **pp, struct type *type,
2587                  struct objfile *objfile)
2588 {
2589   char *p;
2590   char *name;
2591   char cpp_abbrev;
2592   struct type *context;
2593
2594   p = *pp;
2595   if (*++p == 'v')
2596     {
2597       name = NULL;
2598       cpp_abbrev = *++p;
2599
2600       *pp = p + 1;
2601
2602       /* At this point, *pp points to something like "22:23=*22...",
2603          where the type number before the ':' is the "context" and
2604          everything after is a regular type definition.  Lookup the
2605          type, find it's name, and construct the field name. */
2606
2607       context = read_type (pp, objfile);
2608
2609       switch (cpp_abbrev)
2610         {
2611         case 'f':               /* $vf -- a virtual function table pointer */
2612           name = type_name_no_tag (context);
2613           if (name == NULL)
2614           {
2615                   name = "";
2616           }
2617           fip->list->field.name =
2618             obconcat (&objfile->objfile_obstack, vptr_name, name, "");
2619           break;
2620
2621         case 'b':               /* $vb -- a virtual bsomethingorother */
2622           name = type_name_no_tag (context);
2623           if (name == NULL)
2624             {
2625               complaint (&symfile_complaints,
2626                          _("C++ abbreviated type name unknown at symtab pos %d"),
2627                          symnum);
2628               name = "FOO";
2629             }
2630           fip->list->field.name =
2631             obconcat (&objfile->objfile_obstack, vb_name, name, "");
2632           break;
2633
2634         default:
2635           invalid_cpp_abbrev_complaint (*pp);
2636           fip->list->field.name =
2637             obconcat (&objfile->objfile_obstack,
2638                       "INVALID_CPLUSPLUS_ABBREV", "", "");
2639           break;
2640         }
2641
2642       /* At this point, *pp points to the ':'.  Skip it and read the
2643          field type. */
2644
2645       p = ++(*pp);
2646       if (p[-1] != ':')
2647         {
2648           invalid_cpp_abbrev_complaint (*pp);
2649           return 0;
2650         }
2651       fip->list->field.type = read_type (pp, objfile);
2652       if (**pp == ',')
2653         (*pp)++;                /* Skip the comma.  */
2654       else
2655         return 0;
2656
2657       {
2658         int nbits;
2659         FIELD_BITPOS (fip->list->field) = read_huge_number (pp, ';', &nbits,
2660                                                             0);
2661         if (nbits != 0)
2662           return 0;
2663       }
2664       /* This field is unpacked.  */
2665       FIELD_BITSIZE (fip->list->field) = 0;
2666       fip->list->visibility = VISIBILITY_PRIVATE;
2667     }
2668   else
2669     {
2670       invalid_cpp_abbrev_complaint (*pp);
2671       /* We have no idea what syntax an unrecognized abbrev would have, so
2672          better return 0.  If we returned 1, we would need to at least advance
2673          *pp to avoid an infinite loop.  */
2674       return 0;
2675     }
2676   return 1;
2677 }
2678
2679 static void
2680 read_one_struct_field (struct field_info *fip, char **pp, char *p,
2681                        struct type *type, struct objfile *objfile)
2682 {
2683   fip->list->field.name =
2684     obsavestring (*pp, p - *pp, &objfile->objfile_obstack);
2685   *pp = p + 1;
2686
2687   /* This means we have a visibility for a field coming. */
2688   if (**pp == '/')
2689     {
2690       (*pp)++;
2691       fip->list->visibility = *(*pp)++;
2692     }
2693   else
2694     {
2695       /* normal dbx-style format, no explicit visibility */
2696       fip->list->visibility = VISIBILITY_PUBLIC;
2697     }
2698
2699   fip->list->field.type = read_type (pp, objfile);
2700   if (**pp == ':')
2701     {
2702       p = ++(*pp);
2703 #if 0
2704       /* Possible future hook for nested types. */
2705       if (**pp == '!')
2706         {
2707           fip->list->field.bitpos = (long) -2;  /* nested type */
2708           p = ++(*pp);
2709         }
2710       else
2711         ...;
2712 #endif
2713       while (*p != ';')
2714         {
2715           p++;
2716         }
2717       /* Static class member.  */
2718       SET_FIELD_PHYSNAME (fip->list->field, savestring (*pp, p - *pp));
2719       *pp = p + 1;
2720       return;
2721     }
2722   else if (**pp != ',')
2723     {
2724       /* Bad structure-type format.  */
2725       stabs_general_complaint ("bad structure-type format");
2726       return;
2727     }
2728
2729   (*pp)++;                      /* Skip the comma.  */
2730
2731   {
2732     int nbits;
2733     FIELD_BITPOS (fip->list->field) = read_huge_number (pp, ',', &nbits, 0);
2734     if (nbits != 0)
2735       {
2736         stabs_general_complaint ("bad structure-type format");
2737         return;
2738       }
2739     FIELD_BITSIZE (fip->list->field) = read_huge_number (pp, ';', &nbits, 0);
2740     if (nbits != 0)
2741       {
2742         stabs_general_complaint ("bad structure-type format");
2743         return;
2744       }
2745   }
2746
2747   if (FIELD_BITPOS (fip->list->field) == 0
2748       && FIELD_BITSIZE (fip->list->field) == 0)
2749     {
2750       /* This can happen in two cases: (1) at least for gcc 2.4.5 or so,
2751          it is a field which has been optimized out.  The correct stab for
2752          this case is to use VISIBILITY_IGNORE, but that is a recent
2753          invention.  (2) It is a 0-size array.  For example
2754          union { int num; char str[0]; } foo.  Printing _("<no value>" for
2755          str in "p foo" is OK, since foo.str (and thus foo.str[3])
2756          will continue to work, and a 0-size array as a whole doesn't
2757          have any contents to print.
2758
2759          I suspect this probably could also happen with gcc -gstabs (not
2760          -gstabs+) for static fields, and perhaps other C++ extensions.
2761          Hopefully few people use -gstabs with gdb, since it is intended
2762          for dbx compatibility.  */
2763
2764       /* Ignore this field.  */
2765       fip->list->visibility = VISIBILITY_IGNORE;
2766     }
2767   else
2768     {
2769       /* Detect an unpacked field and mark it as such.
2770          dbx gives a bit size for all fields.
2771          Note that forward refs cannot be packed,
2772          and treat enums as if they had the width of ints.  */
2773
2774       struct type *field_type = check_typedef (FIELD_TYPE (fip->list->field));
2775
2776       if (TYPE_CODE (field_type) != TYPE_CODE_INT
2777           && TYPE_CODE (field_type) != TYPE_CODE_RANGE
2778           && TYPE_CODE (field_type) != TYPE_CODE_BOOL
2779           && TYPE_CODE (field_type) != TYPE_CODE_ENUM)
2780         {
2781           FIELD_BITSIZE (fip->list->field) = 0;
2782         }
2783       if ((FIELD_BITSIZE (fip->list->field)
2784            == TARGET_CHAR_BIT * TYPE_LENGTH (field_type)
2785            || (TYPE_CODE (field_type) == TYPE_CODE_ENUM
2786                && FIELD_BITSIZE (fip->list->field) == TARGET_INT_BIT)
2787           )
2788           &&
2789           FIELD_BITPOS (fip->list->field) % 8 == 0)
2790         {
2791           FIELD_BITSIZE (fip->list->field) = 0;
2792         }
2793     }
2794 }
2795
2796
2797 /* Read struct or class data fields.  They have the form:
2798
2799    NAME : [VISIBILITY] TYPENUM , BITPOS , BITSIZE ;
2800
2801    At the end, we see a semicolon instead of a field.
2802
2803    In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
2804    a static field.
2805
2806    The optional VISIBILITY is one of:
2807
2808    '/0' (VISIBILITY_PRIVATE)
2809    '/1' (VISIBILITY_PROTECTED)
2810    '/2' (VISIBILITY_PUBLIC)
2811    '/9' (VISIBILITY_IGNORE)
2812
2813    or nothing, for C style fields with public visibility.
2814
2815    Returns 1 for success, 0 for failure.  */
2816
2817 static int
2818 read_struct_fields (struct field_info *fip, char **pp, struct type *type,
2819                     struct objfile *objfile)
2820 {
2821   char *p;
2822   struct nextfield *new;
2823
2824   /* We better set p right now, in case there are no fields at all...    */
2825
2826   p = *pp;
2827
2828   /* Read each data member type until we find the terminating ';' at the end of
2829      the data member list, or break for some other reason such as finding the
2830      start of the member function list. */
2831   /* Stab string for structure/union does not end with two ';' in
2832      SUN C compiler 5.3 i.e. F6U2, hence check for end of string. */
2833
2834   while (**pp != ';' && **pp != '\0')
2835     {
2836       STABS_CONTINUE (pp, objfile);
2837       /* Get space to record the next field's data.  */
2838       new = (struct nextfield *) xmalloc (sizeof (struct nextfield));
2839       make_cleanup (xfree, new);
2840       memset (new, 0, sizeof (struct nextfield));
2841       new->next = fip->list;
2842       fip->list = new;
2843
2844       /* Get the field name.  */
2845       p = *pp;
2846
2847       /* If is starts with CPLUS_MARKER it is a special abbreviation,
2848          unless the CPLUS_MARKER is followed by an underscore, in
2849          which case it is just the name of an anonymous type, which we
2850          should handle like any other type name.  */
2851
2852       if (is_cplus_marker (p[0]) && p[1] != '_')
2853         {
2854           if (!read_cpp_abbrev (fip, pp, type, objfile))
2855             return 0;
2856           continue;
2857         }
2858
2859       /* Look for the ':' that separates the field name from the field
2860          values.  Data members are delimited by a single ':', while member
2861          functions are delimited by a pair of ':'s.  When we hit the member
2862          functions (if any), terminate scan loop and return. */
2863
2864       while (*p != ':' && *p != '\0')
2865         {
2866           p++;
2867         }
2868       if (*p == '\0')
2869         return 0;
2870
2871       /* Check to see if we have hit the member functions yet.  */
2872       if (p[1] == ':')
2873         {
2874           break;
2875         }
2876       read_one_struct_field (fip, pp, p, type, objfile);
2877     }
2878   if (p[0] == ':' && p[1] == ':')
2879     {
2880       /* (the deleted) chill the list of fields: the last entry (at
2881          the head) is a partially constructed entry which we now
2882          scrub. */
2883       fip->list = fip->list->next;
2884     }
2885   return 1;
2886 }
2887 /* *INDENT-OFF* */
2888 /* The stabs for C++ derived classes contain baseclass information which
2889    is marked by a '!' character after the total size.  This function is
2890    called when we encounter the baseclass marker, and slurps up all the
2891    baseclass information.
2892
2893    Immediately following the '!' marker is the number of base classes that
2894    the class is derived from, followed by information for each base class.
2895    For each base class, there are two visibility specifiers, a bit offset
2896    to the base class information within the derived class, a reference to
2897    the type for the base class, and a terminating semicolon.
2898
2899    A typical example, with two base classes, would be "!2,020,19;0264,21;".
2900                                                        ^^ ^ ^ ^  ^ ^  ^
2901         Baseclass information marker __________________|| | | |  | |  |
2902         Number of baseclasses __________________________| | | |  | |  |
2903         Visibility specifiers (2) ________________________| | |  | |  |
2904         Offset in bits from start of class _________________| |  | |  |
2905         Type number for base class ___________________________|  | |  |
2906         Visibility specifiers (2) _______________________________| |  |
2907         Offset in bits from start of class ________________________|  |
2908         Type number of base class ____________________________________|
2909
2910   Return 1 for success, 0 for (error-type-inducing) failure.  */
2911 /* *INDENT-ON* */
2912
2913
2914
2915 static int
2916 read_baseclasses (struct field_info *fip, char **pp, struct type *type,
2917                   struct objfile *objfile)
2918 {
2919   int i;
2920   struct nextfield *new;
2921
2922   if (**pp != '!')
2923     {
2924       return 1;
2925     }
2926   else
2927     {
2928       /* Skip the '!' baseclass information marker. */
2929       (*pp)++;
2930     }
2931
2932   ALLOCATE_CPLUS_STRUCT_TYPE (type);
2933   {
2934     int nbits;
2935     TYPE_N_BASECLASSES (type) = read_huge_number (pp, ',', &nbits, 0);
2936     if (nbits != 0)
2937       return 0;
2938   }
2939
2940 #if 0
2941   /* Some stupid compilers have trouble with the following, so break
2942      it up into simpler expressions.  */
2943   TYPE_FIELD_VIRTUAL_BITS (type) = (B_TYPE *)
2944     TYPE_ALLOC (type, B_BYTES (TYPE_N_BASECLASSES (type)));
2945 #else
2946   {
2947     int num_bytes = B_BYTES (TYPE_N_BASECLASSES (type));
2948     char *pointer;
2949
2950     pointer = (char *) TYPE_ALLOC (type, num_bytes);
2951     TYPE_FIELD_VIRTUAL_BITS (type) = (B_TYPE *) pointer;
2952   }
2953 #endif /* 0 */
2954
2955   B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), TYPE_N_BASECLASSES (type));
2956
2957   for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
2958     {
2959       new = (struct nextfield *) xmalloc (sizeof (struct nextfield));
2960       make_cleanup (xfree, new);
2961       memset (new, 0, sizeof (struct nextfield));
2962       new->next = fip->list;
2963       fip->list = new;
2964       FIELD_BITSIZE (new->field) = 0;   /* this should be an unpacked field! */
2965
2966       STABS_CONTINUE (pp, objfile);
2967       switch (**pp)
2968         {
2969         case '0':
2970           /* Nothing to do. */
2971           break;
2972         case '1':
2973           SET_TYPE_FIELD_VIRTUAL (type, i);
2974           break;
2975         default:
2976           /* Unknown character.  Complain and treat it as non-virtual.  */
2977           {
2978             complaint (&symfile_complaints,
2979                        _("Unknown virtual character `%c' for baseclass"), **pp);
2980           }
2981         }
2982       ++(*pp);
2983
2984       new->visibility = *(*pp)++;
2985       switch (new->visibility)
2986         {
2987         case VISIBILITY_PRIVATE:
2988         case VISIBILITY_PROTECTED:
2989         case VISIBILITY_PUBLIC:
2990           break;
2991         default:
2992           /* Bad visibility format.  Complain and treat it as
2993              public.  */
2994           {
2995             complaint (&symfile_complaints,
2996                        _("Unknown visibility `%c' for baseclass"),
2997                        new->visibility);
2998             new->visibility = VISIBILITY_PUBLIC;
2999           }
3000         }
3001
3002       {
3003         int nbits;
3004
3005         /* The remaining value is the bit offset of the portion of the object
3006            corresponding to this baseclass.  Always zero in the absence of
3007            multiple inheritance.  */
3008
3009         FIELD_BITPOS (new->field) = read_huge_number (pp, ',', &nbits, 0);
3010         if (nbits != 0)
3011           return 0;
3012       }
3013
3014       /* The last piece of baseclass information is the type of the
3015          base class.  Read it, and remember it's type name as this
3016          field's name. */
3017
3018       new->field.type = read_type (pp, objfile);
3019       new->field.name = type_name_no_tag (new->field.type);
3020
3021       /* skip trailing ';' and bump count of number of fields seen */
3022       if (**pp == ';')
3023         (*pp)++;
3024       else
3025         return 0;
3026     }
3027   return 1;
3028 }
3029
3030 /* The tail end of stabs for C++ classes that contain a virtual function
3031    pointer contains a tilde, a %, and a type number.
3032    The type number refers to the base class (possibly this class itself) which
3033    contains the vtable pointer for the current class.
3034
3035    This function is called when we have parsed all the method declarations,
3036    so we can look for the vptr base class info.  */
3037
3038 static int
3039 read_tilde_fields (struct field_info *fip, char **pp, struct type *type,
3040                    struct objfile *objfile)
3041 {
3042   char *p;
3043
3044   STABS_CONTINUE (pp, objfile);
3045
3046   /* If we are positioned at a ';', then skip it. */
3047   if (**pp == ';')
3048     {
3049       (*pp)++;
3050     }
3051
3052   if (**pp == '~')
3053     {
3054       (*pp)++;
3055
3056       if (**pp == '=' || **pp == '+' || **pp == '-')
3057         {
3058           /* Obsolete flags that used to indicate the presence
3059              of constructors and/or destructors. */
3060           (*pp)++;
3061         }
3062
3063       /* Read either a '%' or the final ';'.  */
3064       if (*(*pp)++ == '%')
3065         {
3066           /* The next number is the type number of the base class
3067              (possibly our own class) which supplies the vtable for
3068              this class.  Parse it out, and search that class to find
3069              its vtable pointer, and install those into TYPE_VPTR_BASETYPE
3070              and TYPE_VPTR_FIELDNO.  */
3071
3072           struct type *t;
3073           int i;
3074
3075           t = read_type (pp, objfile);
3076           p = (*pp)++;
3077           while (*p != '\0' && *p != ';')
3078             {
3079               p++;
3080             }
3081           if (*p == '\0')
3082             {
3083               /* Premature end of symbol.  */
3084               return 0;
3085             }
3086
3087           TYPE_VPTR_BASETYPE (type) = t;
3088           if (type == t)        /* Our own class provides vtbl ptr */
3089             {
3090               for (i = TYPE_NFIELDS (t) - 1;
3091                    i >= TYPE_N_BASECLASSES (t);
3092                    --i)
3093                 {
3094                   char *name = TYPE_FIELD_NAME (t, i);
3095                   if (!strncmp (name, vptr_name, sizeof (vptr_name) - 2)
3096                       && is_cplus_marker (name[sizeof (vptr_name) - 2]))
3097                     {
3098                       TYPE_VPTR_FIELDNO (type) = i;
3099                       goto gotit;
3100                     }
3101                 }
3102               /* Virtual function table field not found.  */
3103               complaint (&symfile_complaints,
3104                          _("virtual function table pointer not found when defining class `%s'"),
3105                          TYPE_NAME (type));
3106               return 0;
3107             }
3108           else
3109             {
3110               TYPE_VPTR_FIELDNO (type) = TYPE_VPTR_FIELDNO (t);
3111             }
3112
3113         gotit:
3114           *pp = p + 1;
3115         }
3116     }
3117   return 1;
3118 }
3119
3120 static int
3121 attach_fn_fields_to_type (struct field_info *fip, struct type *type)
3122 {
3123   int n;
3124
3125   for (n = TYPE_NFN_FIELDS (type);
3126        fip->fnlist != NULL;
3127        fip->fnlist = fip->fnlist->next)
3128     {
3129       --n;                      /* Circumvent Sun3 compiler bug */
3130       TYPE_FN_FIELDLISTS (type)[n] = fip->fnlist->fn_fieldlist;
3131     }
3132   return 1;
3133 }
3134
3135 /* Create the vector of fields, and record how big it is.
3136    We need this info to record proper virtual function table information
3137    for this class's virtual functions.  */
3138
3139 static int
3140 attach_fields_to_type (struct field_info *fip, struct type *type,
3141                        struct objfile *objfile)
3142 {
3143   int nfields = 0;
3144   int non_public_fields = 0;
3145   struct nextfield *scan;
3146
3147   /* Count up the number of fields that we have, as well as taking note of
3148      whether or not there are any non-public fields, which requires us to
3149      allocate and build the private_field_bits and protected_field_bits
3150      bitfields. */
3151
3152   for (scan = fip->list; scan != NULL; scan = scan->next)
3153     {
3154       nfields++;
3155       if (scan->visibility != VISIBILITY_PUBLIC)
3156         {
3157           non_public_fields++;
3158         }
3159     }
3160
3161   /* Now we know how many fields there are, and whether or not there are any
3162      non-public fields.  Record the field count, allocate space for the
3163      array of fields, and create blank visibility bitfields if necessary. */
3164
3165   TYPE_NFIELDS (type) = nfields;
3166   TYPE_FIELDS (type) = (struct field *)
3167     TYPE_ALLOC (type, sizeof (struct field) * nfields);
3168   memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nfields);
3169
3170   if (non_public_fields)
3171     {
3172       ALLOCATE_CPLUS_STRUCT_TYPE (type);
3173
3174       TYPE_FIELD_PRIVATE_BITS (type) =
3175         (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
3176       B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
3177
3178       TYPE_FIELD_PROTECTED_BITS (type) =
3179         (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
3180       B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
3181
3182       TYPE_FIELD_IGNORE_BITS (type) =
3183         (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
3184       B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
3185     }
3186
3187   /* Copy the saved-up fields into the field vector.  Start from the head
3188      of the list, adding to the tail of the field array, so that they end
3189      up in the same order in the array in which they were added to the list. */
3190
3191   while (nfields-- > 0)
3192     {
3193       TYPE_FIELD (type, nfields) = fip->list->field;
3194       switch (fip->list->visibility)
3195         {
3196         case VISIBILITY_PRIVATE:
3197           SET_TYPE_FIELD_PRIVATE (type, nfields);
3198           break;
3199
3200         case VISIBILITY_PROTECTED:
3201           SET_TYPE_FIELD_PROTECTED (type, nfields);
3202           break;
3203
3204         case VISIBILITY_IGNORE:
3205           SET_TYPE_FIELD_IGNORE (type, nfields);
3206           break;
3207
3208         case VISIBILITY_PUBLIC:
3209           break;
3210
3211         default:
3212           /* Unknown visibility.  Complain and treat it as public.  */
3213           {
3214             complaint (&symfile_complaints, _("Unknown visibility `%c' for field"),
3215                        fip->list->visibility);
3216           }
3217           break;
3218         }
3219       fip->list = fip->list->next;
3220     }
3221   return 1;
3222 }
3223
3224
3225 /* Complain that the compiler has emitted more than one definition for the
3226    structure type TYPE.  */
3227 static void
3228 complain_about_struct_wipeout (struct type *type)
3229 {
3230   char *name = "";
3231   char *kind = "";
3232
3233   if (TYPE_TAG_NAME (type))
3234     {
3235       name = TYPE_TAG_NAME (type);
3236       switch (TYPE_CODE (type))
3237         {
3238         case TYPE_CODE_STRUCT: kind = "struct "; break;
3239         case TYPE_CODE_UNION:  kind = "union ";  break;
3240         case TYPE_CODE_ENUM:   kind = "enum ";   break;
3241         default: kind = "";
3242         }
3243     }
3244   else if (TYPE_NAME (type))
3245     {
3246       name = TYPE_NAME (type);
3247       kind = "";
3248     }
3249   else
3250     {
3251       name = "<unknown>";
3252       kind = "";
3253     }
3254
3255   complaint (&symfile_complaints,
3256              _("struct/union type gets multiply defined: %s%s"), kind, name);
3257 }
3258
3259
3260 /* Read the description of a structure (or union type) and return an object
3261    describing the type.
3262
3263    PP points to a character pointer that points to the next unconsumed token
3264    in the the stabs string.  For example, given stabs "A:T4=s4a:1,0,32;;",
3265    *PP will point to "4a:1,0,32;;".
3266
3267    TYPE points to an incomplete type that needs to be filled in.
3268
3269    OBJFILE points to the current objfile from which the stabs information is
3270    being read.  (Note that it is redundant in that TYPE also contains a pointer
3271    to this same objfile, so it might be a good idea to eliminate it.  FIXME).
3272  */
3273
3274 static struct type *
3275 read_struct_type (char **pp, struct type *type, enum type_code type_code,
3276                   struct objfile *objfile)
3277 {
3278   struct cleanup *back_to;
3279   struct field_info fi;
3280
3281   fi.list = NULL;
3282   fi.fnlist = NULL;
3283
3284   /* When describing struct/union/class types in stabs, G++ always drops
3285      all qualifications from the name.  So if you've got:
3286        struct A { ... struct B { ... }; ... };
3287      then G++ will emit stabs for `struct A::B' that call it simply
3288      `struct B'.  Obviously, if you've got a real top-level definition for
3289      `struct B', or other nested definitions, this is going to cause
3290      problems.
3291
3292      Obviously, GDB can't fix this by itself, but it can at least avoid
3293      scribbling on existing structure type objects when new definitions
3294      appear.  */
3295   if (! (TYPE_CODE (type) == TYPE_CODE_UNDEF
3296          || TYPE_STUB (type)))
3297     {
3298       complain_about_struct_wipeout (type);
3299
3300       /* It's probably best to return the type unchanged.  */
3301       return type;
3302     }
3303
3304   back_to = make_cleanup (null_cleanup, 0);
3305
3306   INIT_CPLUS_SPECIFIC (type);
3307   TYPE_CODE (type) = type_code;
3308   TYPE_FLAGS (type) &= ~TYPE_FLAG_STUB;
3309
3310   /* First comes the total size in bytes.  */
3311
3312   {
3313     int nbits;
3314     TYPE_LENGTH (type) = read_huge_number (pp, 0, &nbits, 0);
3315     if (nbits != 0)
3316       return error_type (pp, objfile);
3317   }
3318
3319   /* Now read the baseclasses, if any, read the regular C struct or C++
3320      class member fields, attach the fields to the type, read the C++
3321      member functions, attach them to the type, and then read any tilde
3322      field (baseclass specifier for the class holding the main vtable). */
3323
3324   if (!read_baseclasses (&fi, pp, type, objfile)
3325       || !read_struct_fields (&fi, pp, type, objfile)
3326       || !attach_fields_to_type (&fi, type, objfile)
3327       || !read_member_functions (&fi, pp, type, objfile)
3328       || !attach_fn_fields_to_type (&fi, type)
3329       || !read_tilde_fields (&fi, pp, type, objfile))
3330     {
3331       type = error_type (pp, objfile);
3332     }
3333
3334   do_cleanups (back_to);
3335   return (type);
3336 }
3337
3338 /* Read a definition of an array type,
3339    and create and return a suitable type object.
3340    Also creates a range type which represents the bounds of that
3341    array.  */
3342
3343 static struct type *
3344 read_array_type (char **pp, struct type *type,
3345                  struct objfile *objfile)
3346 {
3347   struct type *index_type, *element_type, *range_type;
3348   int lower, upper;
3349   int adjustable = 0;
3350   int nbits;
3351
3352   /* Format of an array type:
3353      "ar<index type>;lower;upper;<array_contents_type>".
3354      OS9000: "arlower,upper;<array_contents_type>".
3355
3356      Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
3357      for these, produce a type like float[][].  */
3358
3359     {
3360       index_type = read_type (pp, objfile);
3361       if (**pp != ';')
3362         /* Improper format of array type decl.  */
3363         return error_type (pp, objfile);
3364       ++*pp;
3365     }
3366
3367   if (!(**pp >= '0' && **pp <= '9') && **pp != '-')
3368     {
3369       (*pp)++;
3370       adjustable = 1;
3371     }
3372   lower = read_huge_number (pp, ';', &nbits, 0);
3373
3374   if (nbits != 0)
3375     return error_type (pp, objfile);
3376
3377   if (!(**pp >= '0' && **pp <= '9') && **pp != '-')
3378     {
3379       (*pp)++;
3380       adjustable = 1;
3381     }
3382   upper = read_huge_number (pp, ';', &nbits, 0);
3383   if (nbits != 0)
3384     return error_type (pp, objfile);
3385
3386   element_type = read_type (pp, objfile);
3387
3388   if (adjustable)
3389     {
3390       lower = 0;
3391       upper = -1;
3392     }
3393
3394   range_type =
3395     create_range_type ((struct type *) NULL, index_type, lower, upper);
3396   type = create_array_type (type, element_type, range_type);
3397
3398   return type;
3399 }
3400
3401
3402 /* Read a definition of an enumeration type,
3403    and create and return a suitable type object.
3404    Also defines the symbols that represent the values of the type.  */
3405
3406 static struct type *
3407 read_enum_type (char **pp, struct type *type,
3408                 struct objfile *objfile)
3409 {
3410   char *p;
3411   char *name;
3412   long n;
3413   struct symbol *sym;
3414   int nsyms = 0;
3415   struct pending **symlist;
3416   struct pending *osyms, *syms;
3417   int o_nsyms;
3418   int nbits;
3419   int unsigned_enum = 1;
3420
3421 #if 0
3422   /* FIXME!  The stabs produced by Sun CC merrily define things that ought
3423      to be file-scope, between N_FN entries, using N_LSYM.  What's a mother
3424      to do?  For now, force all enum values to file scope.  */
3425   if (within_function)
3426     symlist = &local_symbols;
3427   else
3428 #endif
3429     symlist = &file_symbols;
3430   osyms = *symlist;
3431   o_nsyms = osyms ? osyms->nsyms : 0;
3432
3433   /* The aix4 compiler emits an extra field before the enum members;
3434      my guess is it's a type of some sort.  Just ignore it.  */
3435   if (**pp == '-')
3436     {
3437       /* Skip over the type.  */
3438       while (**pp != ':')
3439         (*pp)++;
3440
3441       /* Skip over the colon.  */
3442       (*pp)++;
3443     }
3444
3445   /* Read the value-names and their values.
3446      The input syntax is NAME:VALUE,NAME:VALUE, and so on.
3447      A semicolon or comma instead of a NAME means the end.  */
3448   while (**pp && **pp != ';' && **pp != ',')
3449     {
3450       STABS_CONTINUE (pp, objfile);
3451       p = *pp;
3452       while (*p != ':')
3453         p++;
3454       name = obsavestring (*pp, p - *pp, &objfile->objfile_obstack);
3455       *pp = p + 1;
3456       n = read_huge_number (pp, ',', &nbits, 0);
3457       if (nbits != 0)
3458         return error_type (pp, objfile);
3459
3460       sym = (struct symbol *)
3461         obstack_alloc (&objfile->objfile_obstack, sizeof (struct symbol));
3462       memset (sym, 0, sizeof (struct symbol));
3463       DEPRECATED_SYMBOL_NAME (sym) = name;
3464       SYMBOL_LANGUAGE (sym) = current_subfile->language;
3465       SYMBOL_CLASS (sym) = LOC_CONST;
3466       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
3467       SYMBOL_VALUE (sym) = n;
3468       if (n < 0)
3469         unsigned_enum = 0;
3470       add_symbol_to_list (sym, symlist);
3471       nsyms++;
3472     }
3473
3474   if (**pp == ';')
3475     (*pp)++;                    /* Skip the semicolon.  */
3476
3477   /* Now fill in the fields of the type-structure.  */
3478
3479   TYPE_LENGTH (type) = TARGET_INT_BIT / HOST_CHAR_BIT;
3480   TYPE_CODE (type) = TYPE_CODE_ENUM;
3481   TYPE_FLAGS (type) &= ~TYPE_FLAG_STUB;
3482   if (unsigned_enum)
3483     TYPE_FLAGS (type) |= TYPE_FLAG_UNSIGNED;
3484   TYPE_NFIELDS (type) = nsyms;
3485   TYPE_FIELDS (type) = (struct field *)
3486     TYPE_ALLOC (type, sizeof (struct field) * nsyms);
3487   memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nsyms);
3488
3489   /* Find the symbols for the values and put them into the type.
3490      The symbols can be found in the symlist that we put them on
3491      to cause them to be defined.  osyms contains the old value
3492      of that symlist; everything up to there was defined by us.  */
3493   /* Note that we preserve the order of the enum constants, so
3494      that in something like "enum {FOO, LAST_THING=FOO}" we print
3495      FOO, not LAST_THING.  */
3496
3497   for (syms = *symlist, n = nsyms - 1; syms; syms = syms->next)
3498     {
3499       int last = syms == osyms ? o_nsyms : 0;
3500       int j = syms->nsyms;
3501       for (; --j >= last; --n)
3502         {
3503           struct symbol *xsym = syms->symbol[j];
3504           SYMBOL_TYPE (xsym) = type;
3505           TYPE_FIELD_NAME (type, n) = DEPRECATED_SYMBOL_NAME (xsym);
3506           TYPE_FIELD_BITPOS (type, n) = SYMBOL_VALUE (xsym);
3507           TYPE_FIELD_BITSIZE (type, n) = 0;
3508         }
3509       if (syms == osyms)
3510         break;
3511     }
3512
3513   return type;
3514 }
3515
3516 /* Sun's ACC uses a somewhat saner method for specifying the builtin
3517    typedefs in every file (for int, long, etc):
3518
3519    type = b <signed> <width> <format type>; <offset>; <nbits>
3520    signed = u or s.
3521    optional format type = c or b for char or boolean.
3522    offset = offset from high order bit to start bit of type.
3523    width is # bytes in object of this type, nbits is # bits in type.
3524
3525    The width/offset stuff appears to be for small objects stored in
3526    larger ones (e.g. `shorts' in `int' registers).  We ignore it for now,
3527    FIXME.  */
3528
3529 static struct type *
3530 read_sun_builtin_type (char **pp, int typenums[2], struct objfile *objfile)
3531 {
3532   int type_bits;
3533   int nbits;
3534   int signed_type;
3535   enum type_code code = TYPE_CODE_INT;
3536
3537   switch (**pp)
3538     {
3539     case 's':
3540       signed_type = 1;
3541       break;
3542     case 'u':
3543       signed_type = 0;
3544       break;
3545     default:
3546       return error_type (pp, objfile);
3547     }
3548   (*pp)++;
3549
3550   /* For some odd reason, all forms of char put a c here.  This is strange
3551      because no other type has this honor.  We can safely ignore this because
3552      we actually determine 'char'acterness by the number of bits specified in
3553      the descriptor.
3554      Boolean forms, e.g Fortran logical*X, put a b here.  */
3555
3556   if (**pp == 'c')
3557     (*pp)++;
3558   else if (**pp == 'b')
3559     {
3560       code = TYPE_CODE_BOOL;
3561       (*pp)++;
3562     }
3563
3564   /* The first number appears to be the number of bytes occupied
3565      by this type, except that unsigned short is 4 instead of 2.
3566      Since this information is redundant with the third number,
3567      we will ignore it.  */
3568   read_huge_number (pp, ';', &nbits, 0);
3569   if (nbits != 0)
3570     return error_type (pp, objfile);
3571
3572   /* The second number is always 0, so ignore it too. */
3573   read_huge_number (pp, ';', &nbits, 0);
3574   if (nbits != 0)
3575     return error_type (pp, objfile);
3576
3577   /* The third number is the number of bits for this type. */
3578   type_bits = read_huge_number (pp, 0, &nbits, 0);
3579   if (nbits != 0)
3580     return error_type (pp, objfile);
3581   /* The type *should* end with a semicolon.  If it are embedded
3582      in a larger type the semicolon may be the only way to know where
3583      the type ends.  If this type is at the end of the stabstring we
3584      can deal with the omitted semicolon (but we don't have to like
3585      it).  Don't bother to complain(), Sun's compiler omits the semicolon
3586      for "void".  */
3587   if (**pp == ';')
3588     ++(*pp);
3589
3590   if (type_bits == 0)
3591     return init_type (TYPE_CODE_VOID, 1,
3592                       signed_type ? 0 : TYPE_FLAG_UNSIGNED, (char *) NULL,
3593                       objfile);
3594   else
3595     return init_type (code,
3596                       type_bits / TARGET_CHAR_BIT,
3597                       signed_type ? 0 : TYPE_FLAG_UNSIGNED, (char *) NULL,
3598                       objfile);
3599 }
3600
3601 static struct type *
3602 read_sun_floating_type (char **pp, int typenums[2], struct objfile *objfile)
3603 {
3604   int nbits;
3605   int details;
3606   int nbytes;
3607   struct type *rettype;
3608
3609   /* The first number has more details about the type, for example
3610      FN_COMPLEX.  */
3611   details = read_huge_number (pp, ';', &nbits, 0);
3612   if (nbits != 0)
3613     return error_type (pp, objfile);
3614
3615   /* The second number is the number of bytes occupied by this type */
3616   nbytes = read_huge_number (pp, ';', &nbits, 0);
3617   if (nbits != 0)
3618     return error_type (pp, objfile);
3619
3620   if (details == NF_COMPLEX || details == NF_COMPLEX16
3621       || details == NF_COMPLEX32)
3622     {
3623       rettype = init_type (TYPE_CODE_COMPLEX, nbytes, 0, NULL, objfile);
3624       TYPE_TARGET_TYPE (rettype)
3625         = init_type (TYPE_CODE_FLT, nbytes / 2, 0, NULL, objfile);
3626       return rettype;
3627     }
3628
3629   return init_type (TYPE_CODE_FLT, nbytes, 0, NULL, objfile);
3630 }
3631
3632 /* Read a number from the string pointed to by *PP.
3633    The value of *PP is advanced over the number.
3634    If END is nonzero, the character that ends the
3635    number must match END, or an error happens;
3636    and that character is skipped if it does match.
3637    If END is zero, *PP is left pointing to that character.
3638
3639    If TWOS_COMPLEMENT_BITS is set to a strictly positive value and if
3640    the number is represented in an octal representation, assume that
3641    it is represented in a 2's complement representation with a size of
3642    TWOS_COMPLEMENT_BITS.
3643
3644    If the number fits in a long, set *BITS to 0 and return the value.
3645    If not, set *BITS to be the number of bits in the number and return 0.
3646
3647    If encounter garbage, set *BITS to -1 and return 0.  */
3648
3649 static long
3650 read_huge_number (char **pp, int end, int *bits, int twos_complement_bits)
3651 {
3652   char *p = *pp;
3653   int sign = 1;
3654   int sign_bit;
3655   long n = 0;
3656   long sn = 0;
3657   int radix = 10;
3658   char overflow = 0;
3659   int nbits = 0;
3660   int c;
3661   long upper_limit;
3662   int twos_complement_representation = radix == 8 && twos_complement_bits > 0;
3663
3664   if (*p == '-')
3665     {
3666       sign = -1;
3667       p++;
3668     }
3669
3670   /* Leading zero means octal.  GCC uses this to output values larger
3671      than an int (because that would be hard in decimal).  */
3672   if (*p == '0')
3673     {
3674       radix = 8;
3675       p++;
3676     }
3677
3678   upper_limit = LONG_MAX / radix;
3679
3680   while ((c = *p++) >= '0' && c < ('0' + radix))
3681     {
3682       if (n <= upper_limit)
3683         {
3684           if (twos_complement_representation)
3685             {
3686               /* Octal, signed, twos complement representation. In this case,
3687                  sn is the signed value, n is the corresponding absolute
3688                  value. signed_bit is the position of the sign bit in the
3689                  first three bits.  */
3690               if (sn == 0)
3691                 {
3692                   sign_bit = (twos_complement_bits % 3 + 2) % 3;
3693                   sn = c - '0' - ((2 * (c - '0')) | (2 << sign_bit));
3694                 }
3695               else
3696                 {
3697                   sn *= radix;
3698                   sn += c - '0';
3699                 }
3700
3701               if (sn < 0)
3702                 n = -sn;
3703             }
3704           else
3705             {
3706               /* unsigned representation */
3707               n *= radix;
3708               n += c - '0';             /* FIXME this overflows anyway */
3709             }
3710         }
3711       else
3712         overflow = 1;
3713
3714       /* This depends on large values being output in octal, which is
3715          what GCC does. */
3716       if (radix == 8)
3717         {
3718           if (nbits == 0)
3719             {
3720               if (c == '0')
3721                 /* Ignore leading zeroes.  */
3722                 ;
3723               else if (c == '1')
3724                 nbits = 1;
3725               else if (c == '2' || c == '3')
3726                 nbits = 2;
3727               else
3728                 nbits = 3;
3729             }
3730           else
3731             nbits += 3;
3732         }
3733     }
3734   if (end)
3735     {
3736       if (c && c != end)
3737         {
3738           if (bits != NULL)
3739             *bits = -1;
3740           return 0;
3741         }
3742     }
3743   else
3744     --p;
3745
3746   *pp = p;
3747   if (overflow)
3748     {
3749       if (nbits == 0)
3750         {
3751           /* Large decimal constants are an error (because it is hard to
3752              count how many bits are in them).  */
3753           if (bits != NULL)
3754             *bits = -1;
3755           return 0;
3756         }
3757
3758       /* -0x7f is the same as 0x80.  So deal with it by adding one to
3759          the number of bits.  */
3760       if (sign == -1)
3761         ++nbits;
3762       if (bits)
3763         *bits = nbits;
3764     }
3765   else
3766     {
3767       if (bits)
3768         *bits = 0;
3769       if (twos_complement_representation)
3770         return sn;
3771       else
3772         return n * sign;
3773     }
3774   /* It's *BITS which has the interesting information.  */
3775   return 0;
3776 }
3777
3778 static struct type *
3779 read_range_type (char **pp, int typenums[2], int type_size,
3780                  struct objfile *objfile)
3781 {
3782   char *orig_pp = *pp;
3783   int rangenums[2];
3784   long n2, n3;
3785   int n2bits, n3bits;
3786   int self_subrange;
3787   struct type *result_type;
3788   struct type *index_type = NULL;
3789
3790   /* First comes a type we are a subrange of.
3791      In C it is usually 0, 1 or the type being defined.  */
3792   if (read_type_number (pp, rangenums) != 0)
3793     return error_type (pp, objfile);
3794   self_subrange = (rangenums[0] == typenums[0] &&
3795                    rangenums[1] == typenums[1]);
3796
3797   if (**pp == '=')
3798     {
3799       *pp = orig_pp;
3800       index_type = read_type (pp, objfile);
3801     }
3802
3803   /* A semicolon should now follow; skip it.  */
3804   if (**pp == ';')
3805     (*pp)++;
3806
3807   /* The remaining two operands are usually lower and upper bounds
3808      of the range.  But in some special cases they mean something else.  */
3809   n2 = read_huge_number (pp, ';', &n2bits, type_size);
3810   n3 = read_huge_number (pp, ';', &n3bits, type_size);
3811
3812   if (n2bits == -1 || n3bits == -1)
3813     return error_type (pp, objfile);
3814
3815   if (index_type)
3816     goto handle_true_range;
3817
3818   /* If limits are huge, must be large integral type.  */
3819   if (n2bits != 0 || n3bits != 0)
3820     {
3821       char got_signed = 0;
3822       char got_unsigned = 0;
3823       /* Number of bits in the type.  */
3824       int nbits = 0;
3825
3826       /* If a type size attribute has been specified, the bounds of
3827          the range should fit in this size. If the lower bounds needs
3828          more bits than the upper bound, then the type is signed.  */
3829       if (n2bits <= type_size && n3bits <= type_size)
3830         {
3831           if (n2bits == type_size && n2bits > n3bits)
3832             got_signed = 1;
3833           else
3834             got_unsigned = 1;
3835           nbits = type_size;
3836         }
3837       /* Range from 0 to <large number> is an unsigned large integral type.  */
3838       else if ((n2bits == 0 && n2 == 0) && n3bits != 0)
3839         {
3840           got_unsigned = 1;
3841           nbits = n3bits;
3842         }
3843       /* Range from <large number> to <large number>-1 is a large signed
3844          integral type.  Take care of the case where <large number> doesn't
3845          fit in a long but <large number>-1 does.  */
3846       else if ((n2bits != 0 && n3bits != 0 && n2bits == n3bits + 1)
3847                || (n2bits != 0 && n3bits == 0
3848                    && (n2bits == sizeof (long) * HOST_CHAR_BIT)
3849                    && n3 == LONG_MAX))
3850         {
3851           got_signed = 1;
3852           nbits = n2bits;
3853         }
3854
3855       if (got_signed || got_unsigned)
3856         {
3857           return init_type (TYPE_CODE_INT, nbits / TARGET_CHAR_BIT,
3858                             got_unsigned ? TYPE_FLAG_UNSIGNED : 0, NULL,
3859                             objfile);
3860         }
3861       else
3862         return error_type (pp, objfile);
3863     }
3864
3865   /* A type defined as a subrange of itself, with bounds both 0, is void.  */
3866   if (self_subrange && n2 == 0 && n3 == 0)
3867     return init_type (TYPE_CODE_VOID, 1, 0, NULL, objfile);
3868
3869   /* If n3 is zero and n2 is positive, we want a floating type, and n2
3870      is the width in bytes.
3871
3872      Fortran programs appear to use this for complex types also.  To
3873      distinguish between floats and complex, g77 (and others?)  seem
3874      to use self-subranges for the complexes, and subranges of int for
3875      the floats.
3876
3877      Also note that for complexes, g77 sets n2 to the size of one of
3878      the member floats, not the whole complex beast.  My guess is that
3879      this was to work well with pre-COMPLEX versions of gdb. */
3880
3881   if (n3 == 0 && n2 > 0)
3882     {
3883       struct type *float_type
3884         = init_type (TYPE_CODE_FLT, n2, 0, NULL, objfile);
3885
3886       if (self_subrange)
3887         {
3888           struct type *complex_type =
3889             init_type (TYPE_CODE_COMPLEX, 2 * n2, 0, NULL, objfile);
3890           TYPE_TARGET_TYPE (complex_type) = float_type;
3891           return complex_type;
3892         }
3893       else
3894         return float_type;
3895     }
3896
3897   /* If the upper bound is -1, it must really be an unsigned int.  */
3898
3899   else if (n2 == 0 && n3 == -1)
3900     {
3901       /* It is unsigned int or unsigned long.  */
3902       /* GCC 2.3.3 uses this for long long too, but that is just a GDB 3.5
3903          compatibility hack.  */
3904       return init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
3905                         TYPE_FLAG_UNSIGNED, NULL, objfile);
3906     }
3907
3908   /* Special case: char is defined (Who knows why) as a subrange of
3909      itself with range 0-127.  */
3910   else if (self_subrange && n2 == 0 && n3 == 127)
3911     return init_type (TYPE_CODE_INT, 1, TYPE_FLAG_NOSIGN, NULL, objfile);
3912
3913   /* We used to do this only for subrange of self or subrange of int.  */
3914   else if (n2 == 0)
3915     {
3916       /* -1 is used for the upper bound of (4 byte) "unsigned int" and
3917          "unsigned long", and we already checked for that,
3918          so don't need to test for it here.  */
3919
3920       if (n3 < 0)
3921         /* n3 actually gives the size.  */
3922         return init_type (TYPE_CODE_INT, -n3, TYPE_FLAG_UNSIGNED,
3923                           NULL, objfile);
3924
3925       /* Is n3 == 2**(8n)-1 for some integer n?  Then it's an
3926          unsigned n-byte integer.  But do require n to be a power of
3927          two; we don't want 3- and 5-byte integers flying around.  */
3928       {
3929         int bytes;
3930         unsigned long bits;
3931
3932         bits = n3;
3933         for (bytes = 0; (bits & 0xff) == 0xff; bytes++)
3934           bits >>= 8;
3935         if (bits == 0
3936             && ((bytes - 1) & bytes) == 0) /* "bytes is a power of two" */
3937           return init_type (TYPE_CODE_INT, bytes, TYPE_FLAG_UNSIGNED, NULL,
3938                             objfile);
3939       }
3940     }
3941   /* I think this is for Convex "long long".  Since I don't know whether
3942      Convex sets self_subrange, I also accept that particular size regardless
3943      of self_subrange.  */
3944   else if (n3 == 0 && n2 < 0
3945            && (self_subrange
3946                || n2 == -TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT))
3947     return init_type (TYPE_CODE_INT, -n2, 0, NULL, objfile);
3948   else if (n2 == -n3 - 1)
3949     {
3950       if (n3 == 0x7f)
3951         return init_type (TYPE_CODE_INT, 1, 0, NULL, objfile);
3952       if (n3 == 0x7fff)
3953         return init_type (TYPE_CODE_INT, 2, 0, NULL, objfile);
3954       if (n3 == 0x7fffffff)
3955         return init_type (TYPE_CODE_INT, 4, 0, NULL, objfile);
3956     }
3957
3958   /* We have a real range type on our hands.  Allocate space and
3959      return a real pointer.  */
3960 handle_true_range:
3961
3962   if (self_subrange)
3963     index_type = builtin_type_int;
3964   else
3965     index_type = *dbx_lookup_type (rangenums);
3966   if (index_type == NULL)
3967     {
3968       /* Does this actually ever happen?  Is that why we are worrying
3969          about dealing with it rather than just calling error_type?  */
3970
3971       static struct type *range_type_index;
3972
3973       complaint (&symfile_complaints,
3974                  _("base type %d of range type is not defined"), rangenums[1]);
3975       if (range_type_index == NULL)
3976         range_type_index =
3977           init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
3978                      0, "range type index type", NULL);
3979       index_type = range_type_index;
3980     }
3981
3982   result_type = create_range_type ((struct type *) NULL, index_type, n2, n3);
3983   return (result_type);
3984 }
3985
3986 /* Read in an argument list.  This is a list of types, separated by commas
3987    and terminated with END.  Return the list of types read in, or (struct type
3988    **)-1 if there is an error.  */
3989
3990 static struct field *
3991 read_args (char **pp, int end, struct objfile *objfile, int *nargsp,
3992            int *varargsp)
3993 {
3994   /* FIXME!  Remove this arbitrary limit!  */
3995   struct type *types[1024];     /* allow for fns of 1023 parameters */
3996   int n = 0, i;
3997   struct field *rval;
3998
3999   while (**pp != end)
4000     {
4001       if (**pp != ',')
4002         /* Invalid argument list: no ','.  */
4003         return (struct field *) -1;
4004       (*pp)++;
4005       STABS_CONTINUE (pp, objfile);
4006       types[n++] = read_type (pp, objfile);
4007     }
4008   (*pp)++;                      /* get past `end' (the ':' character) */
4009
4010   if (TYPE_CODE (types[n - 1]) != TYPE_CODE_VOID)
4011     *varargsp = 1;
4012   else
4013     {
4014       n--;
4015       *varargsp = 0;
4016     }
4017
4018   rval = (struct field *) xmalloc (n * sizeof (struct field));
4019   memset (rval, 0, n * sizeof (struct field));
4020   for (i = 0; i < n; i++)
4021     rval[i].type = types[i];
4022   *nargsp = n;
4023   return rval;
4024 }
4025 \f
4026 /* Common block handling.  */
4027
4028 /* List of symbols declared since the last BCOMM.  This list is a tail
4029    of local_symbols.  When ECOMM is seen, the symbols on the list
4030    are noted so their proper addresses can be filled in later,
4031    using the common block base address gotten from the assembler
4032    stabs.  */
4033
4034 static struct pending *common_block;
4035 static int common_block_i;
4036
4037 /* Name of the current common block.  We get it from the BCOMM instead of the
4038    ECOMM to match IBM documentation (even though IBM puts the name both places
4039    like everyone else).  */
4040 static char *common_block_name;
4041
4042 /* Process a N_BCOMM symbol.  The storage for NAME is not guaranteed
4043    to remain after this function returns.  */
4044
4045 void
4046 common_block_start (char *name, struct objfile *objfile)
4047 {
4048   if (common_block_name != NULL)
4049     {
4050       complaint (&symfile_complaints,
4051                  _("Invalid symbol data: common block within common block"));
4052     }
4053   common_block = local_symbols;
4054   common_block_i = local_symbols ? local_symbols->nsyms : 0;
4055   common_block_name = obsavestring (name, strlen (name),
4056                                     &objfile->objfile_obstack);
4057 }
4058
4059 /* Process a N_ECOMM symbol.  */
4060
4061 void
4062 common_block_end (struct objfile *objfile)
4063 {
4064   /* Symbols declared since the BCOMM are to have the common block
4065      start address added in when we know it.  common_block and
4066      common_block_i point to the first symbol after the BCOMM in
4067      the local_symbols list; copy the list and hang it off the
4068      symbol for the common block name for later fixup.  */
4069   int i;
4070   struct symbol *sym;
4071   struct pending *new = 0;
4072   struct pending *next;
4073   int j;
4074
4075   if (common_block_name == NULL)
4076     {
4077       complaint (&symfile_complaints, _("ECOMM symbol unmatched by BCOMM"));
4078       return;
4079     }
4080
4081   sym = (struct symbol *)
4082     obstack_alloc (&objfile->objfile_obstack, sizeof (struct symbol));
4083   memset (sym, 0, sizeof (struct symbol));
4084   /* Note: common_block_name already saved on objfile_obstack */
4085   DEPRECATED_SYMBOL_NAME (sym) = common_block_name;
4086   SYMBOL_CLASS (sym) = LOC_BLOCK;
4087
4088   /* Now we copy all the symbols which have been defined since the BCOMM.  */
4089
4090   /* Copy all the struct pendings before common_block.  */
4091   for (next = local_symbols;
4092        next != NULL && next != common_block;
4093        next = next->next)
4094     {
4095       for (j = 0; j < next->nsyms; j++)
4096         add_symbol_to_list (next->symbol[j], &new);
4097     }
4098
4099   /* Copy however much of COMMON_BLOCK we need.  If COMMON_BLOCK is
4100      NULL, it means copy all the local symbols (which we already did
4101      above).  */
4102
4103   if (common_block != NULL)
4104     for (j = common_block_i; j < common_block->nsyms; j++)
4105       add_symbol_to_list (common_block->symbol[j], &new);
4106
4107   SYMBOL_TYPE (sym) = (struct type *) new;
4108
4109   /* Should we be putting local_symbols back to what it was?
4110      Does it matter?  */
4111
4112   i = hashname (DEPRECATED_SYMBOL_NAME (sym));
4113   SYMBOL_VALUE_CHAIN (sym) = global_sym_chain[i];
4114   global_sym_chain[i] = sym;
4115   common_block_name = NULL;
4116 }
4117
4118 /* Add a common block's start address to the offset of each symbol
4119    declared to be in it (by being between a BCOMM/ECOMM pair that uses
4120    the common block name).  */
4121
4122 static void
4123 fix_common_block (struct symbol *sym, int valu)
4124 {
4125   struct pending *next = (struct pending *) SYMBOL_TYPE (sym);
4126   for (; next; next = next->next)
4127     {
4128       int j;
4129       for (j = next->nsyms - 1; j >= 0; j--)
4130         SYMBOL_VALUE_ADDRESS (next->symbol[j]) += valu;
4131     }
4132 }
4133 \f
4134
4135
4136 /* What about types defined as forward references inside of a small lexical
4137    scope?  */
4138 /* Add a type to the list of undefined types to be checked through
4139    once this file has been read in.  */
4140
4141 static void
4142 add_undefined_type (struct type *type)
4143 {
4144   if (undef_types_length == undef_types_allocated)
4145     {
4146       undef_types_allocated *= 2;
4147       undef_types = (struct type **)
4148         xrealloc ((char *) undef_types,
4149                   undef_types_allocated * sizeof (struct type *));
4150     }
4151   undef_types[undef_types_length++] = type;
4152 }
4153
4154 /* Go through each undefined type, see if it's still undefined, and fix it
4155    up if possible.  We have two kinds of undefined types:
4156
4157    TYPE_CODE_ARRAY:  Array whose target type wasn't defined yet.
4158    Fix:  update array length using the element bounds
4159    and the target type's length.
4160    TYPE_CODE_STRUCT, TYPE_CODE_UNION:  Structure whose fields were not
4161    yet defined at the time a pointer to it was made.
4162    Fix:  Do a full lookup on the struct/union tag.  */
4163 void
4164 cleanup_undefined_types (void)
4165 {
4166   struct type **type;
4167
4168   for (type = undef_types; type < undef_types + undef_types_length; type++)
4169     {
4170       switch (TYPE_CODE (*type))
4171         {
4172
4173         case TYPE_CODE_STRUCT:
4174         case TYPE_CODE_UNION:
4175         case TYPE_CODE_ENUM:
4176           {
4177             /* Check if it has been defined since.  Need to do this here
4178                as well as in check_typedef to deal with the (legitimate in
4179                C though not C++) case of several types with the same name
4180                in different source files.  */
4181             if (TYPE_STUB (*type))
4182               {
4183                 struct pending *ppt;
4184                 int i;
4185                 /* Name of the type, without "struct" or "union" */
4186                 char *typename = TYPE_TAG_NAME (*type);
4187
4188                 if (typename == NULL)
4189                   {
4190                     complaint (&symfile_complaints, _("need a type name"));
4191                     break;
4192                   }
4193                 for (ppt = file_symbols; ppt; ppt = ppt->next)
4194                   {
4195                     for (i = 0; i < ppt->nsyms; i++)
4196                       {
4197                         struct symbol *sym = ppt->symbol[i];
4198
4199                         if (SYMBOL_CLASS (sym) == LOC_TYPEDEF
4200                             && SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
4201                             && (TYPE_CODE (SYMBOL_TYPE (sym)) ==
4202                                 TYPE_CODE (*type))
4203                             && strcmp (DEPRECATED_SYMBOL_NAME (sym), typename) == 0)
4204                           replace_type (*type, SYMBOL_TYPE (sym));
4205                       }
4206                   }
4207               }
4208           }
4209           break;
4210
4211         default:
4212           {
4213             complaint (&symfile_complaints,
4214                        _("forward-referenced types left unresolved, "
4215                        "type code %d."),
4216                        TYPE_CODE (*type));
4217           }
4218           break;
4219         }
4220     }
4221
4222   undef_types_length = 0;
4223 }
4224
4225 /* Scan through all of the global symbols defined in the object file,
4226    assigning values to the debugging symbols that need to be assigned
4227    to.  Get these symbols from the minimal symbol table.  */
4228
4229 void
4230 scan_file_globals (struct objfile *objfile)
4231 {
4232   int hash;
4233   struct minimal_symbol *msymbol;
4234   struct symbol *sym, *prev;
4235   struct objfile *resolve_objfile;
4236
4237   /* SVR4 based linkers copy referenced global symbols from shared
4238      libraries to the main executable.
4239      If we are scanning the symbols for a shared library, try to resolve
4240      them from the minimal symbols of the main executable first.  */
4241
4242   if (symfile_objfile && objfile != symfile_objfile)
4243     resolve_objfile = symfile_objfile;
4244   else
4245     resolve_objfile = objfile;
4246
4247   while (1)
4248     {
4249       /* Avoid expensive loop through all minimal symbols if there are
4250          no unresolved symbols.  */
4251       for (hash = 0; hash < HASHSIZE; hash++)
4252         {
4253           if (global_sym_chain[hash])
4254             break;
4255         }
4256       if (hash >= HASHSIZE)
4257         return;
4258
4259       for (msymbol = resolve_objfile->msymbols;
4260            msymbol && DEPRECATED_SYMBOL_NAME (msymbol) != NULL;
4261            msymbol++)
4262         {
4263           QUIT;
4264
4265           /* Skip static symbols.  */
4266           switch (MSYMBOL_TYPE (msymbol))
4267             {
4268             case mst_file_text:
4269             case mst_file_data:
4270             case mst_file_bss:
4271               continue;
4272             default:
4273               break;
4274             }
4275
4276           prev = NULL;
4277
4278           /* Get the hash index and check all the symbols
4279              under that hash index. */
4280
4281           hash = hashname (DEPRECATED_SYMBOL_NAME (msymbol));
4282
4283           for (sym = global_sym_chain[hash]; sym;)
4284             {
4285               if (DEPRECATED_SYMBOL_NAME (msymbol)[0] == DEPRECATED_SYMBOL_NAME (sym)[0] &&
4286                   strcmp (DEPRECATED_SYMBOL_NAME (msymbol) + 1, DEPRECATED_SYMBOL_NAME (sym) + 1) == 0)
4287                 {
4288                   /* Splice this symbol out of the hash chain and
4289                      assign the value we have to it. */
4290                   if (prev)
4291                     {
4292                       SYMBOL_VALUE_CHAIN (prev) = SYMBOL_VALUE_CHAIN (sym);
4293                     }
4294                   else
4295                     {
4296                       global_sym_chain[hash] = SYMBOL_VALUE_CHAIN (sym);
4297                     }
4298
4299                   /* Check to see whether we need to fix up a common block.  */
4300                   /* Note: this code might be executed several times for
4301                      the same symbol if there are multiple references.  */
4302                   if (sym)
4303                     {
4304                       if (SYMBOL_CLASS (sym) == LOC_BLOCK)
4305                         {
4306                           fix_common_block (sym,
4307                                             SYMBOL_VALUE_ADDRESS (msymbol));
4308                         }
4309                       else
4310                         {
4311                           SYMBOL_VALUE_ADDRESS (sym)
4312                             = SYMBOL_VALUE_ADDRESS (msymbol);
4313                         }
4314                       SYMBOL_SECTION (sym) = SYMBOL_SECTION (msymbol);
4315                     }
4316
4317                   if (prev)
4318                     {
4319                       sym = SYMBOL_VALUE_CHAIN (prev);
4320                     }
4321                   else
4322                     {
4323                       sym = global_sym_chain[hash];
4324                     }
4325                 }
4326               else
4327                 {
4328                   prev = sym;
4329                   sym = SYMBOL_VALUE_CHAIN (sym);
4330                 }
4331             }
4332         }
4333       if (resolve_objfile == objfile)
4334         break;
4335       resolve_objfile = objfile;
4336     }
4337
4338   /* Change the storage class of any remaining unresolved globals to
4339      LOC_UNRESOLVED and remove them from the chain.  */
4340   for (hash = 0; hash < HASHSIZE; hash++)
4341     {
4342       sym = global_sym_chain[hash];
4343       while (sym)
4344         {
4345           prev = sym;
4346           sym = SYMBOL_VALUE_CHAIN (sym);
4347
4348           /* Change the symbol address from the misleading chain value
4349              to address zero.  */
4350           SYMBOL_VALUE_ADDRESS (prev) = 0;
4351
4352           /* Complain about unresolved common block symbols.  */
4353           if (SYMBOL_CLASS (prev) == LOC_STATIC)
4354             SYMBOL_CLASS (prev) = LOC_UNRESOLVED;
4355           else
4356             complaint (&symfile_complaints,
4357                        _("%s: common block `%s' from global_sym_chain unresolved"),
4358                        objfile->name, DEPRECATED_SYMBOL_NAME (prev));
4359         }
4360     }
4361   memset (global_sym_chain, 0, sizeof (global_sym_chain));
4362 }
4363
4364 /* Initialize anything that needs initializing when starting to read
4365    a fresh piece of a symbol file, e.g. reading in the stuff corresponding
4366    to a psymtab.  */
4367
4368 void
4369 stabsread_init (void)
4370 {
4371 }
4372
4373 /* Initialize anything that needs initializing when a completely new
4374    symbol file is specified (not just adding some symbols from another
4375    file, e.g. a shared library).  */
4376
4377 void
4378 stabsread_new_init (void)
4379 {
4380   /* Empty the hash table of global syms looking for values.  */
4381   memset (global_sym_chain, 0, sizeof (global_sym_chain));
4382 }
4383
4384 /* Initialize anything that needs initializing at the same time as
4385    start_symtab() is called. */
4386
4387 void
4388 start_stabs (void)
4389 {
4390   global_stabs = NULL;          /* AIX COFF */
4391   /* Leave FILENUM of 0 free for builtin types and this file's types.  */
4392   n_this_object_header_files = 1;
4393   type_vector_length = 0;
4394   type_vector = (struct type **) 0;
4395
4396   /* FIXME: If common_block_name is not already NULL, we should complain().  */
4397   common_block_name = NULL;
4398 }
4399
4400 /* Call after end_symtab() */
4401
4402 void
4403 end_stabs (void)
4404 {
4405   if (type_vector)
4406     {
4407       xfree (type_vector);
4408     }
4409   type_vector = 0;
4410   type_vector_length = 0;
4411   previous_stab_code = 0;
4412 }
4413
4414 void
4415 finish_global_stabs (struct objfile *objfile)
4416 {
4417   if (global_stabs)
4418     {
4419       patch_block_stabs (global_symbols, global_stabs, objfile);
4420       xfree (global_stabs);
4421       global_stabs = NULL;
4422     }
4423 }
4424
4425 /* Find the end of the name, delimited by a ':', but don't match
4426    ObjC symbols which look like -[Foo bar::]:bla.  */
4427 static char *
4428 find_name_end (char *name)
4429 {
4430   char *s = name;
4431   if (s[0] == '-' || *s == '+')
4432     {
4433       /* Must be an ObjC method symbol.  */
4434       if (s[1] != '[')
4435         {
4436           error (_("invalid symbol name \"%s\""), name);
4437         }
4438       s = strchr (s, ']');
4439       if (s == NULL)
4440         {
4441           error (_("invalid symbol name \"%s\""), name);
4442         }
4443       return strchr (s, ':');
4444     }
4445   else
4446     {
4447       return strchr (s, ':');
4448     }
4449 }
4450
4451 /* Initializer for this module */
4452
4453 void
4454 _initialize_stabsread (void)
4455 {
4456   undef_types_allocated = 20;
4457   undef_types_length = 0;
4458   undef_types = (struct type **)
4459     xmalloc (undef_types_allocated * sizeof (struct type *));
4460 }