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