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