gdb/stabsread.c

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