gdb/stabsread.c

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