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