1 /* Support routines for decoding "stabs" debugging information format.
3 Copyright (C) 1986-2015 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 /* Support routines for reading and decoding debugging information in
21 the "stabs" format. This format is used with many systems that use
22 the a.out object file format, as well as some systems that use
23 COFF or ELF where the stabs data is placed in a special section.
24 Avoid placing any object file format specific code in this file. */
28 #include "gdb_obstack.h"
31 #include "expression.h"
34 #include "aout/stab_gnu.h" /* We always use GNU stabs, not native. */
36 #include "aout/aout64.h"
37 #include "gdb-stabs.h"
39 #include "complaints.h"
41 #include "gdb-demangle.h"
45 #include "cp-support.h"
48 /* Ask stabsread.h to define the vars it normally declares `extern'. */
51 #include "stabsread.h" /* Our own declarations */
54 extern void _initialize_stabsread (void);
58 struct nextfield *next;
60 /* This is the raw visibility from the stab. It is not checked
61 for being one of the visibilities we recognize, so code which
62 examines this field better be able to deal. */
68 struct next_fnfieldlist
70 struct next_fnfieldlist *next;
71 struct fn_fieldlist fn_fieldlist;
74 /* The routines that read and process a complete stabs for a C struct or
75 C++ class pass lists of data member fields and lists of member function
76 fields in an instance of a field_info structure, as defined below.
77 This is part of some reorganization of low level C++ support and is
78 expected to eventually go away... (FIXME) */
82 struct nextfield *list;
83 struct next_fnfieldlist *fnlist;
87 read_one_struct_field (struct field_info *, char **, char *,
88 struct type *, struct objfile *);
90 static struct type *dbx_alloc_type (int[2], struct objfile *);
92 static long read_huge_number (char **, int, int *, int);
94 static struct type *error_type (char **, struct objfile *);
97 patch_block_stabs (struct pending *, struct pending_stabs *,
100 static void fix_common_block (struct symbol *, CORE_ADDR);
102 static int read_type_number (char **, int *);
104 static struct type *read_type (char **, struct objfile *);
106 static struct type *read_range_type (char **, int[2], int, struct objfile *);
108 static struct type *read_sun_builtin_type (char **, int[2], struct objfile *);
110 static struct type *read_sun_floating_type (char **, int[2],
113 static struct type *read_enum_type (char **, struct type *, struct objfile *);
115 static struct type *rs6000_builtin_type (int, struct objfile *);
118 read_member_functions (struct field_info *, char **, struct type *,
122 read_struct_fields (struct field_info *, char **, struct type *,
126 read_baseclasses (struct field_info *, char **, struct type *,
130 read_tilde_fields (struct field_info *, char **, struct type *,
133 static int attach_fn_fields_to_type (struct field_info *, struct type *);
135 static int attach_fields_to_type (struct field_info *, struct type *,
138 static struct type *read_struct_type (char **, struct type *,
142 static struct type *read_array_type (char **, struct type *,
145 static struct field *read_args (char **, int, struct objfile *, int *, int *);
147 static void add_undefined_type (struct type *, int[2]);
150 read_cpp_abbrev (struct field_info *, char **, struct type *,
153 static char *find_name_end (char *name);
155 static int process_reference (char **string);
157 void stabsread_clear_cache (void);
159 static const char vptr_name[] = "_vptr$";
160 static const char vb_name[] = "_vb$";
163 invalid_cpp_abbrev_complaint (const char *arg1)
165 complaint (&symfile_complaints, _("invalid C++ abbreviation `%s'"), arg1);
169 reg_value_complaint (int regnum, int num_regs, const char *sym)
171 complaint (&symfile_complaints,
172 _("register number %d too large (max %d) in symbol %s"),
173 regnum, num_regs - 1, sym);
177 stabs_general_complaint (const char *arg1)
179 complaint (&symfile_complaints, "%s", arg1);
182 /* Make a list of forward references which haven't been defined. */
184 static struct type **undef_types;
185 static int undef_types_allocated;
186 static int undef_types_length;
187 static struct symbol *current_symbol = NULL;
189 /* Make a list of nameless types that are undefined.
190 This happens when another type is referenced by its number
191 before this type is actually defined. For instance "t(0,1)=k(0,2)"
192 and type (0,2) is defined only later. */
199 static struct nat *noname_undefs;
200 static int noname_undefs_allocated;
201 static int noname_undefs_length;
203 /* Check for and handle cretinous stabs symbol name continuation! */
204 #define STABS_CONTINUE(pp,objfile) \
206 if (**(pp) == '\\' || (**(pp) == '?' && (*(pp))[1] == '\0')) \
207 *(pp) = next_symbol_text (objfile); \
210 /* Vector of types defined so far, indexed by their type numbers.
211 (In newer sun systems, dbx uses a pair of numbers in parens,
212 as in "(SUBFILENUM,NUMWITHINSUBFILE)".
213 Then these numbers must be translated through the type_translations
214 hash table to get the index into the type vector.) */
216 static struct type **type_vector;
218 /* Number of elements allocated for type_vector currently. */
220 static int type_vector_length;
222 /* Initial size of type vector. Is realloc'd larger if needed, and
223 realloc'd down to the size actually used, when completed. */
225 #define INITIAL_TYPE_VECTOR_LENGTH 160
228 /* Look up a dbx type-number pair. Return the address of the slot
229 where the type for that number-pair is stored.
230 The number-pair is in TYPENUMS.
232 This can be used for finding the type associated with that pair
233 or for associating a new type with the pair. */
235 static struct type **
236 dbx_lookup_type (int typenums[2], struct objfile *objfile)
238 int filenum = typenums[0];
239 int index = typenums[1];
242 struct header_file *f;
245 if (filenum == -1) /* -1,-1 is for temporary types. */
248 if (filenum < 0 || filenum >= n_this_object_header_files)
250 complaint (&symfile_complaints,
251 _("Invalid symbol data: type number "
252 "(%d,%d) out of range at symtab pos %d."),
253 filenum, index, symnum);
261 /* Caller wants address of address of type. We think
262 that negative (rs6k builtin) types will never appear as
263 "lvalues", (nor should they), so we stuff the real type
264 pointer into a temp, and return its address. If referenced,
265 this will do the right thing. */
266 static struct type *temp_type;
268 temp_type = rs6000_builtin_type (index, objfile);
272 /* Type is defined outside of header files.
273 Find it in this object file's type vector. */
274 if (index >= type_vector_length)
276 old_len = type_vector_length;
279 type_vector_length = INITIAL_TYPE_VECTOR_LENGTH;
280 type_vector = XNEWVEC (struct type *, type_vector_length);
282 while (index >= type_vector_length)
284 type_vector_length *= 2;
286 type_vector = (struct type **)
287 xrealloc ((char *) type_vector,
288 (type_vector_length * sizeof (struct type *)));
289 memset (&type_vector[old_len], 0,
290 (type_vector_length - old_len) * sizeof (struct type *));
292 return (&type_vector[index]);
296 real_filenum = this_object_header_files[filenum];
298 if (real_filenum >= N_HEADER_FILES (objfile))
300 static struct type *temp_type;
302 warning (_("GDB internal error: bad real_filenum"));
305 temp_type = objfile_type (objfile)->builtin_error;
309 f = HEADER_FILES (objfile) + real_filenum;
311 f_orig_length = f->length;
312 if (index >= f_orig_length)
314 while (index >= f->length)
318 f->vector = (struct type **)
319 xrealloc ((char *) f->vector, f->length * sizeof (struct type *));
320 memset (&f->vector[f_orig_length], 0,
321 (f->length - f_orig_length) * sizeof (struct type *));
323 return (&f->vector[index]);
327 /* Make sure there is a type allocated for type numbers TYPENUMS
328 and return the type object.
329 This can create an empty (zeroed) type object.
330 TYPENUMS may be (-1, -1) to return a new type object that is not
331 put into the type vector, and so may not be referred to by number. */
334 dbx_alloc_type (int typenums[2], struct objfile *objfile)
336 struct type **type_addr;
338 if (typenums[0] == -1)
340 return (alloc_type (objfile));
343 type_addr = dbx_lookup_type (typenums, objfile);
345 /* If we are referring to a type not known at all yet,
346 allocate an empty type for it.
347 We will fill it in later if we find out how. */
350 *type_addr = alloc_type (objfile);
356 /* for all the stabs in a given stab vector, build appropriate types
357 and fix their symbols in given symbol vector. */
360 patch_block_stabs (struct pending *symbols, struct pending_stabs *stabs,
361 struct objfile *objfile)
370 /* for all the stab entries, find their corresponding symbols and
371 patch their types! */
373 for (ii = 0; ii < stabs->count; ++ii)
375 name = stabs->stab[ii];
376 pp = (char *) strchr (name, ':');
377 gdb_assert (pp); /* Must find a ':' or game's over. */
381 pp = (char *) strchr (pp, ':');
383 sym = find_symbol_in_list (symbols, name, pp - name);
386 /* FIXME-maybe: it would be nice if we noticed whether
387 the variable was defined *anywhere*, not just whether
388 it is defined in this compilation unit. But neither
389 xlc or GCC seem to need such a definition, and until
390 we do psymtabs (so that the minimal symbols from all
391 compilation units are available now), I'm not sure
392 how to get the information. */
394 /* On xcoff, if a global is defined and never referenced,
395 ld will remove it from the executable. There is then
396 a N_GSYM stab for it, but no regular (C_EXT) symbol. */
397 sym = allocate_symbol (objfile);
398 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
399 SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
400 SYMBOL_SET_LINKAGE_NAME
401 (sym, (char *) obstack_copy0 (&objfile->objfile_obstack,
404 if (*(pp - 1) == 'F' || *(pp - 1) == 'f')
406 /* I don't think the linker does this with functions,
407 so as far as I know this is never executed.
408 But it doesn't hurt to check. */
410 lookup_function_type (read_type (&pp, objfile));
414 SYMBOL_TYPE (sym) = read_type (&pp, objfile);
416 add_symbol_to_list (sym, &global_symbols);
421 if (*(pp - 1) == 'F' || *(pp - 1) == 'f')
424 lookup_function_type (read_type (&pp, objfile));
428 SYMBOL_TYPE (sym) = read_type (&pp, objfile);
436 /* Read a number by which a type is referred to in dbx data,
437 or perhaps read a pair (FILENUM, TYPENUM) in parentheses.
438 Just a single number N is equivalent to (0,N).
439 Return the two numbers by storing them in the vector TYPENUMS.
440 TYPENUMS will then be used as an argument to dbx_lookup_type.
442 Returns 0 for success, -1 for error. */
445 read_type_number (char **pp, int *typenums)
452 typenums[0] = read_huge_number (pp, ',', &nbits, 0);
455 typenums[1] = read_huge_number (pp, ')', &nbits, 0);
462 typenums[1] = read_huge_number (pp, 0, &nbits, 0);
470 #define VISIBILITY_PRIVATE '0' /* Stabs character for private field */
471 #define VISIBILITY_PROTECTED '1' /* Stabs character for protected fld */
472 #define VISIBILITY_PUBLIC '2' /* Stabs character for public field */
473 #define VISIBILITY_IGNORE '9' /* Optimized out or zero length */
475 /* Structure for storing pointers to reference definitions for fast lookup
476 during "process_later". */
485 #define MAX_CHUNK_REFS 100
486 #define REF_CHUNK_SIZE (MAX_CHUNK_REFS * sizeof (struct ref_map))
487 #define REF_MAP_SIZE(ref_chunk) ((ref_chunk) * REF_CHUNK_SIZE)
489 static struct ref_map *ref_map;
491 /* Ptr to free cell in chunk's linked list. */
492 static int ref_count = 0;
494 /* Number of chunks malloced. */
495 static int ref_chunk = 0;
497 /* This file maintains a cache of stabs aliases found in the symbol
498 table. If the symbol table changes, this cache must be cleared
499 or we are left holding onto data in invalid obstacks. */
501 stabsread_clear_cache (void)
507 /* Create array of pointers mapping refids to symbols and stab strings.
508 Add pointers to reference definition symbols and/or their values as we
509 find them, using their reference numbers as our index.
510 These will be used later when we resolve references. */
512 ref_add (int refnum, struct symbol *sym, char *stabs, CORE_ADDR value)
516 if (refnum >= ref_count)
517 ref_count = refnum + 1;
518 if (ref_count > ref_chunk * MAX_CHUNK_REFS)
520 int new_slots = ref_count - ref_chunk * MAX_CHUNK_REFS;
521 int new_chunks = new_slots / MAX_CHUNK_REFS + 1;
523 ref_map = (struct ref_map *)
524 xrealloc (ref_map, REF_MAP_SIZE (ref_chunk + new_chunks));
525 memset (ref_map + ref_chunk * MAX_CHUNK_REFS, 0,
526 new_chunks * REF_CHUNK_SIZE);
527 ref_chunk += new_chunks;
529 ref_map[refnum].stabs = stabs;
530 ref_map[refnum].sym = sym;
531 ref_map[refnum].value = value;
534 /* Return defined sym for the reference REFNUM. */
536 ref_search (int refnum)
538 if (refnum < 0 || refnum > ref_count)
540 return ref_map[refnum].sym;
543 /* Parse a reference id in STRING and return the resulting
544 reference number. Move STRING beyond the reference id. */
547 process_reference (char **string)
555 /* Advance beyond the initial '#'. */
558 /* Read number as reference id. */
559 while (*p && isdigit (*p))
561 refnum = refnum * 10 + *p - '0';
568 /* If STRING defines a reference, store away a pointer to the reference
569 definition for later use. Return the reference number. */
572 symbol_reference_defined (char **string)
577 refnum = process_reference (&p);
579 /* Defining symbols end in '='. */
582 /* Symbol is being defined here. */
588 /* Must be a reference. Either the symbol has already been defined,
589 or this is a forward reference to it. */
596 stab_reg_to_regnum (struct symbol *sym, struct gdbarch *gdbarch)
598 int regno = gdbarch_stab_reg_to_regnum (gdbarch, SYMBOL_VALUE (sym));
600 if (regno >= gdbarch_num_regs (gdbarch)
601 + gdbarch_num_pseudo_regs (gdbarch))
603 reg_value_complaint (regno,
604 gdbarch_num_regs (gdbarch)
605 + gdbarch_num_pseudo_regs (gdbarch),
606 SYMBOL_PRINT_NAME (sym));
608 regno = gdbarch_sp_regnum (gdbarch); /* Known safe, though useless. */
614 static const struct symbol_register_ops stab_register_funcs = {
618 /* The "aclass" indices for computed symbols. */
620 static int stab_register_index;
621 static int stab_regparm_index;
624 define_symbol (CORE_ADDR valu, char *string, int desc, int type,
625 struct objfile *objfile)
627 struct gdbarch *gdbarch = get_objfile_arch (objfile);
629 char *p = (char *) find_name_end (string);
633 char *new_name = NULL;
635 /* We would like to eliminate nameless symbols, but keep their types.
636 E.g. stab entry ":t10=*2" should produce a type 10, which is a pointer
637 to type 2, but, should not create a symbol to address that type. Since
638 the symbol will be nameless, there is no way any user can refer to it. */
642 /* Ignore syms with empty names. */
646 /* Ignore old-style symbols from cc -go. */
656 complaint (&symfile_complaints,
657 _("Bad stabs string '%s'"), string);
662 /* If a nameless stab entry, all we need is the type, not the symbol.
663 e.g. ":t10=*2" or a nameless enum like " :T16=ered:0,green:1,blue:2,;" */
664 nameless = (p == string || ((string[0] == ' ') && (string[1] == ':')));
666 current_symbol = sym = allocate_symbol (objfile);
668 if (processing_gcc_compilation)
670 /* GCC 2.x puts the line number in desc. SunOS apparently puts in the
671 number of bytes occupied by a type or object, which we ignore. */
672 SYMBOL_LINE (sym) = desc;
676 SYMBOL_LINE (sym) = 0; /* unknown */
679 SYMBOL_SET_LANGUAGE (sym, current_subfile->language,
680 &objfile->objfile_obstack);
682 if (is_cplus_marker (string[0]))
684 /* Special GNU C++ names. */
688 SYMBOL_SET_LINKAGE_NAME (sym, "this");
691 case 'v': /* $vtbl_ptr_type */
695 SYMBOL_SET_LINKAGE_NAME (sym, "eh_throw");
699 /* This was an anonymous type that was never fixed up. */
703 /* SunPRO (3.0 at least) static variable encoding. */
704 if (gdbarch_static_transform_name_p (gdbarch))
706 /* ... fall through ... */
709 complaint (&symfile_complaints, _("Unknown C++ symbol name `%s'"),
711 goto normal; /* Do *something* with it. */
717 if (SYMBOL_LANGUAGE (sym) == language_cplus)
719 char *name = (char *) alloca (p - string + 1);
721 memcpy (name, string, p - string);
722 name[p - string] = '\0';
723 new_name = cp_canonicalize_string (name);
725 if (new_name != NULL)
727 SYMBOL_SET_NAMES (sym, new_name, strlen (new_name), 1, objfile);
731 SYMBOL_SET_NAMES (sym, string, p - string, 1, objfile);
733 if (SYMBOL_LANGUAGE (sym) == language_cplus)
734 cp_scan_for_anonymous_namespaces (sym, objfile);
739 /* Determine the type of name being defined. */
741 /* Getting GDB to correctly skip the symbol on an undefined symbol
742 descriptor and not ever dump core is a very dodgy proposition if
743 we do things this way. I say the acorn RISC machine can just
744 fix their compiler. */
745 /* The Acorn RISC machine's compiler can put out locals that don't
746 start with "234=" or "(3,4)=", so assume anything other than the
747 deftypes we know how to handle is a local. */
748 if (!strchr ("cfFGpPrStTvVXCR", *p))
750 if (isdigit (*p) || *p == '(' || *p == '-')
759 /* c is a special case, not followed by a type-number.
760 SYMBOL:c=iVALUE for an integer constant symbol.
761 SYMBOL:c=rVALUE for a floating constant symbol.
762 SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
763 e.g. "b:c=e6,0" for "const b = blob1"
764 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
767 SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
768 SYMBOL_TYPE (sym) = error_type (&p, objfile);
769 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
770 add_symbol_to_list (sym, &file_symbols);
780 struct type *dbl_type;
782 /* FIXME-if-picky-about-floating-accuracy: Should be using
783 target arithmetic to get the value. real.c in GCC
784 probably has the necessary code. */
786 dbl_type = objfile_type (objfile)->builtin_double;
788 = (gdb_byte *) obstack_alloc (&objfile->objfile_obstack,
789 TYPE_LENGTH (dbl_type));
790 store_typed_floating (dbl_valu, dbl_type, d);
792 SYMBOL_TYPE (sym) = dbl_type;
793 SYMBOL_VALUE_BYTES (sym) = dbl_valu;
794 SYMBOL_ACLASS_INDEX (sym) = LOC_CONST_BYTES;
799 /* Defining integer constants this way is kind of silly,
800 since 'e' constants allows the compiler to give not
801 only the value, but the type as well. C has at least
802 int, long, unsigned int, and long long as constant
803 types; other languages probably should have at least
804 unsigned as well as signed constants. */
806 SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_long;
807 SYMBOL_VALUE (sym) = atoi (p);
808 SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
814 SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_char;
815 SYMBOL_VALUE (sym) = atoi (p);
816 SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
822 struct type *range_type;
825 gdb_byte *string_local = (gdb_byte *) alloca (strlen (p));
826 gdb_byte *string_value;
828 if (quote != '\'' && quote != '"')
830 SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
831 SYMBOL_TYPE (sym) = error_type (&p, objfile);
832 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
833 add_symbol_to_list (sym, &file_symbols);
837 /* Find matching quote, rejecting escaped quotes. */
838 while (*p && *p != quote)
840 if (*p == '\\' && p[1] == quote)
842 string_local[ind] = (gdb_byte) quote;
848 string_local[ind] = (gdb_byte) (*p);
855 SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
856 SYMBOL_TYPE (sym) = error_type (&p, objfile);
857 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
858 add_symbol_to_list (sym, &file_symbols);
862 /* NULL terminate the string. */
863 string_local[ind] = 0;
865 = create_static_range_type (NULL,
866 objfile_type (objfile)->builtin_int,
868 SYMBOL_TYPE (sym) = create_array_type (NULL,
869 objfile_type (objfile)->builtin_char,
872 = (gdb_byte *) obstack_alloc (&objfile->objfile_obstack, ind + 1);
873 memcpy (string_value, string_local, ind + 1);
876 SYMBOL_VALUE_BYTES (sym) = string_value;
877 SYMBOL_ACLASS_INDEX (sym) = LOC_CONST_BYTES;
882 /* SYMBOL:c=eTYPE,INTVALUE for a constant symbol whose value
883 can be represented as integral.
884 e.g. "b:c=e6,0" for "const b = blob1"
885 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
887 SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
888 SYMBOL_TYPE (sym) = read_type (&p, objfile);
892 SYMBOL_TYPE (sym) = error_type (&p, objfile);
897 /* If the value is too big to fit in an int (perhaps because
898 it is unsigned), or something like that, we silently get
899 a bogus value. The type and everything else about it is
900 correct. Ideally, we should be using whatever we have
901 available for parsing unsigned and long long values,
903 SYMBOL_VALUE (sym) = atoi (p);
908 SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
909 SYMBOL_TYPE (sym) = error_type (&p, objfile);
912 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
913 add_symbol_to_list (sym, &file_symbols);
917 /* The name of a caught exception. */
918 SYMBOL_TYPE (sym) = read_type (&p, objfile);
919 SYMBOL_ACLASS_INDEX (sym) = LOC_LABEL;
920 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
921 SYMBOL_VALUE_ADDRESS (sym) = valu;
922 add_symbol_to_list (sym, &local_symbols);
926 /* A static function definition. */
927 SYMBOL_TYPE (sym) = read_type (&p, objfile);
928 SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
929 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
930 add_symbol_to_list (sym, &file_symbols);
931 /* fall into process_function_types. */
933 process_function_types:
934 /* Function result types are described as the result type in stabs.
935 We need to convert this to the function-returning-type-X type
936 in GDB. E.g. "int" is converted to "function returning int". */
937 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_FUNC)
938 SYMBOL_TYPE (sym) = lookup_function_type (SYMBOL_TYPE (sym));
940 /* All functions in C++ have prototypes. Stabs does not offer an
941 explicit way to identify prototyped or unprototyped functions,
942 but both GCC and Sun CC emit stabs for the "call-as" type rather
943 than the "declared-as" type for unprototyped functions, so
944 we treat all functions as if they were prototyped. This is used
945 primarily for promotion when calling the function from GDB. */
946 TYPE_PROTOTYPED (SYMBOL_TYPE (sym)) = 1;
948 /* fall into process_prototype_types. */
950 process_prototype_types:
951 /* Sun acc puts declared types of arguments here. */
954 struct type *ftype = SYMBOL_TYPE (sym);
959 /* Obtain a worst case guess for the number of arguments
960 by counting the semicolons. */
967 /* Allocate parameter information fields and fill them in. */
968 TYPE_FIELDS (ftype) = (struct field *)
969 TYPE_ALLOC (ftype, nsemi * sizeof (struct field));
974 /* A type number of zero indicates the start of varargs.
975 FIXME: GDB currently ignores vararg functions. */
976 if (p[0] == '0' && p[1] == '\0')
978 ptype = read_type (&p, objfile);
980 /* The Sun compilers mark integer arguments, which should
981 be promoted to the width of the calling conventions, with
982 a type which references itself. This type is turned into
983 a TYPE_CODE_VOID type by read_type, and we have to turn
984 it back into builtin_int here.
985 FIXME: Do we need a new builtin_promoted_int_arg ? */
986 if (TYPE_CODE (ptype) == TYPE_CODE_VOID)
987 ptype = objfile_type (objfile)->builtin_int;
988 TYPE_FIELD_TYPE (ftype, nparams) = ptype;
989 TYPE_FIELD_ARTIFICIAL (ftype, nparams++) = 0;
991 TYPE_NFIELDS (ftype) = nparams;
992 TYPE_PROTOTYPED (ftype) = 1;
997 /* A global function definition. */
998 SYMBOL_TYPE (sym) = read_type (&p, objfile);
999 SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
1000 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1001 add_symbol_to_list (sym, &global_symbols);
1002 goto process_function_types;
1005 /* For a class G (global) symbol, it appears that the
1006 value is not correct. It is necessary to search for the
1007 corresponding linker definition to find the value.
1008 These definitions appear at the end of the namelist. */
1009 SYMBOL_TYPE (sym) = read_type (&p, objfile);
1010 SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
1011 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1012 /* Don't add symbol references to global_sym_chain.
1013 Symbol references don't have valid names and wont't match up with
1014 minimal symbols when the global_sym_chain is relocated.
1015 We'll fixup symbol references when we fixup the defining symbol. */
1016 if (SYMBOL_LINKAGE_NAME (sym) && SYMBOL_LINKAGE_NAME (sym)[0] != '#')
1018 i = hashname (SYMBOL_LINKAGE_NAME (sym));
1019 SYMBOL_VALUE_CHAIN (sym) = global_sym_chain[i];
1020 global_sym_chain[i] = sym;
1022 add_symbol_to_list (sym, &global_symbols);
1025 /* This case is faked by a conditional above,
1026 when there is no code letter in the dbx data.
1027 Dbx data never actually contains 'l'. */
1030 SYMBOL_TYPE (sym) = read_type (&p, objfile);
1031 SYMBOL_ACLASS_INDEX (sym) = LOC_LOCAL;
1032 SYMBOL_VALUE (sym) = valu;
1033 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1034 add_symbol_to_list (sym, &local_symbols);
1039 /* pF is a two-letter code that means a function parameter in Fortran.
1040 The type-number specifies the type of the return value.
1041 Translate it into a pointer-to-function type. */
1045 = lookup_pointer_type
1046 (lookup_function_type (read_type (&p, objfile)));
1049 SYMBOL_TYPE (sym) = read_type (&p, objfile);
1051 SYMBOL_ACLASS_INDEX (sym) = LOC_ARG;
1052 SYMBOL_VALUE (sym) = valu;
1053 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1054 SYMBOL_IS_ARGUMENT (sym) = 1;
1055 add_symbol_to_list (sym, &local_symbols);
1057 if (gdbarch_byte_order (gdbarch) != BFD_ENDIAN_BIG)
1059 /* On little-endian machines, this crud is never necessary,
1060 and, if the extra bytes contain garbage, is harmful. */
1064 /* If it's gcc-compiled, if it says `short', believe it. */
1065 if (processing_gcc_compilation
1066 || gdbarch_believe_pcc_promotion (gdbarch))
1069 if (!gdbarch_believe_pcc_promotion (gdbarch))
1071 /* If PCC says a parameter is a short or a char, it is
1073 if (TYPE_LENGTH (SYMBOL_TYPE (sym))
1074 < gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT
1075 && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT)
1078 TYPE_UNSIGNED (SYMBOL_TYPE (sym))
1079 ? objfile_type (objfile)->builtin_unsigned_int
1080 : objfile_type (objfile)->builtin_int;
1086 /* acc seems to use P to declare the prototypes of functions that
1087 are referenced by this file. gdb is not prepared to deal
1088 with this extra information. FIXME, it ought to. */
1091 SYMBOL_TYPE (sym) = read_type (&p, objfile);
1092 goto process_prototype_types;
1097 /* Parameter which is in a register. */
1098 SYMBOL_TYPE (sym) = read_type (&p, objfile);
1099 SYMBOL_ACLASS_INDEX (sym) = stab_register_index;
1100 SYMBOL_IS_ARGUMENT (sym) = 1;
1101 SYMBOL_VALUE (sym) = valu;
1102 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1103 add_symbol_to_list (sym, &local_symbols);
1107 /* Register variable (either global or local). */
1108 SYMBOL_TYPE (sym) = read_type (&p, objfile);
1109 SYMBOL_ACLASS_INDEX (sym) = stab_register_index;
1110 SYMBOL_VALUE (sym) = valu;
1111 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1112 if (within_function)
1114 /* Sun cc uses a pair of symbols, one 'p' and one 'r', with
1115 the same name to represent an argument passed in a
1116 register. GCC uses 'P' for the same case. So if we find
1117 such a symbol pair we combine it into one 'P' symbol.
1118 For Sun cc we need to do this regardless of
1119 stabs_argument_has_addr, because the compiler puts out
1120 the 'p' symbol even if it never saves the argument onto
1123 On most machines, we want to preserve both symbols, so
1124 that we can still get information about what is going on
1125 with the stack (VAX for computing args_printed, using
1126 stack slots instead of saved registers in backtraces,
1129 Note that this code illegally combines
1130 main(argc) struct foo argc; { register struct foo argc; }
1131 but this case is considered pathological and causes a warning
1132 from a decent compiler. */
1135 && local_symbols->nsyms > 0
1136 && gdbarch_stabs_argument_has_addr (gdbarch, SYMBOL_TYPE (sym)))
1138 struct symbol *prev_sym;
1140 prev_sym = local_symbols->symbol[local_symbols->nsyms - 1];
1141 if ((SYMBOL_CLASS (prev_sym) == LOC_REF_ARG
1142 || SYMBOL_CLASS (prev_sym) == LOC_ARG)
1143 && strcmp (SYMBOL_LINKAGE_NAME (prev_sym),
1144 SYMBOL_LINKAGE_NAME (sym)) == 0)
1146 SYMBOL_ACLASS_INDEX (prev_sym) = stab_register_index;
1147 /* Use the type from the LOC_REGISTER; that is the type
1148 that is actually in that register. */
1149 SYMBOL_TYPE (prev_sym) = SYMBOL_TYPE (sym);
1150 SYMBOL_VALUE (prev_sym) = SYMBOL_VALUE (sym);
1155 add_symbol_to_list (sym, &local_symbols);
1158 add_symbol_to_list (sym, &file_symbols);
1162 /* Static symbol at top level of file. */
1163 SYMBOL_TYPE (sym) = read_type (&p, objfile);
1164 SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
1165 SYMBOL_VALUE_ADDRESS (sym) = valu;
1166 if (gdbarch_static_transform_name_p (gdbarch)
1167 && gdbarch_static_transform_name (gdbarch,
1168 SYMBOL_LINKAGE_NAME (sym))
1169 != SYMBOL_LINKAGE_NAME (sym))
1171 struct bound_minimal_symbol msym;
1173 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
1175 if (msym.minsym != NULL)
1177 const char *new_name = gdbarch_static_transform_name
1178 (gdbarch, SYMBOL_LINKAGE_NAME (sym));
1180 SYMBOL_SET_LINKAGE_NAME (sym, new_name);
1181 SYMBOL_VALUE_ADDRESS (sym) = BMSYMBOL_VALUE_ADDRESS (msym);
1184 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1185 add_symbol_to_list (sym, &file_symbols);
1189 /* In Ada, there is no distinction between typedef and non-typedef;
1190 any type declaration implicitly has the equivalent of a typedef,
1191 and thus 't' is in fact equivalent to 'Tt'.
1193 Therefore, for Ada units, we check the character immediately
1194 before the 't', and if we do not find a 'T', then make sure to
1195 create the associated symbol in the STRUCT_DOMAIN ('t' definitions
1196 will be stored in the VAR_DOMAIN). If the symbol was indeed
1197 defined as 'Tt' then the STRUCT_DOMAIN symbol will be created
1198 elsewhere, so we don't need to take care of that.
1200 This is important to do, because of forward references:
1201 The cleanup of undefined types stored in undef_types only uses
1202 STRUCT_DOMAIN symbols to perform the replacement. */
1203 synonym = (SYMBOL_LANGUAGE (sym) == language_ada && p[-2] != 'T');
1206 SYMBOL_TYPE (sym) = read_type (&p, objfile);
1208 /* For a nameless type, we don't want a create a symbol, thus we
1209 did not use `sym'. Return without further processing. */
1213 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
1214 SYMBOL_VALUE (sym) = valu;
1215 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1216 /* C++ vagaries: we may have a type which is derived from
1217 a base type which did not have its name defined when the
1218 derived class was output. We fill in the derived class's
1219 base part member's name here in that case. */
1220 if (TYPE_NAME (SYMBOL_TYPE (sym)) != NULL)
1221 if ((TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT
1222 || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_UNION)
1223 && TYPE_N_BASECLASSES (SYMBOL_TYPE (sym)))
1227 for (j = TYPE_N_BASECLASSES (SYMBOL_TYPE (sym)) - 1; j >= 0; j--)
1228 if (TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym), j) == 0)
1229 TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym), j) =
1230 type_name_no_tag (TYPE_BASECLASS (SYMBOL_TYPE (sym), j));
1233 if (TYPE_NAME (SYMBOL_TYPE (sym)) == NULL)
1235 /* gcc-2.6 or later (when using -fvtable-thunks)
1236 emits a unique named type for a vtable entry.
1237 Some gdb code depends on that specific name. */
1238 extern const char vtbl_ptr_name[];
1240 if ((TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR
1241 && strcmp (SYMBOL_LINKAGE_NAME (sym), vtbl_ptr_name))
1242 || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FUNC)
1244 /* If we are giving a name to a type such as "pointer to
1245 foo" or "function returning foo", we better not set
1246 the TYPE_NAME. If the program contains "typedef char
1247 *caddr_t;", we don't want all variables of type char
1248 * to print as caddr_t. This is not just a
1249 consequence of GDB's type management; PCC and GCC (at
1250 least through version 2.4) both output variables of
1251 either type char * or caddr_t with the type number
1252 defined in the 't' symbol for caddr_t. If a future
1253 compiler cleans this up it GDB is not ready for it
1254 yet, but if it becomes ready we somehow need to
1255 disable this check (without breaking the PCC/GCC2.4
1260 Fortunately, this check seems not to be necessary
1261 for anything except pointers or functions. */
1262 /* ezannoni: 2000-10-26. This seems to apply for
1263 versions of gcc older than 2.8. This was the original
1264 problem: with the following code gdb would tell that
1265 the type for name1 is caddr_t, and func is char().
1267 typedef char *caddr_t;
1279 /* Pascal accepts names for pointer types. */
1280 if (current_subfile->language == language_pascal)
1282 TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_LINKAGE_NAME (sym);
1286 TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_LINKAGE_NAME (sym);
1289 add_symbol_to_list (sym, &file_symbols);
1293 /* Create the STRUCT_DOMAIN clone. */
1294 struct symbol *struct_sym = allocate_symbol (objfile);
1297 SYMBOL_ACLASS_INDEX (struct_sym) = LOC_TYPEDEF;
1298 SYMBOL_VALUE (struct_sym) = valu;
1299 SYMBOL_DOMAIN (struct_sym) = STRUCT_DOMAIN;
1300 if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
1301 TYPE_NAME (SYMBOL_TYPE (sym))
1302 = obconcat (&objfile->objfile_obstack,
1303 SYMBOL_LINKAGE_NAME (sym),
1305 add_symbol_to_list (struct_sym, &file_symbols);
1311 /* Struct, union, or enum tag. For GNU C++, this can be be followed
1312 by 't' which means we are typedef'ing it as well. */
1313 synonym = *p == 't';
1318 SYMBOL_TYPE (sym) = read_type (&p, objfile);
1320 /* For a nameless type, we don't want a create a symbol, thus we
1321 did not use `sym'. Return without further processing. */
1325 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
1326 SYMBOL_VALUE (sym) = valu;
1327 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
1328 if (TYPE_TAG_NAME (SYMBOL_TYPE (sym)) == 0)
1329 TYPE_TAG_NAME (SYMBOL_TYPE (sym))
1330 = obconcat (&objfile->objfile_obstack,
1331 SYMBOL_LINKAGE_NAME (sym),
1333 add_symbol_to_list (sym, &file_symbols);
1337 /* Clone the sym and then modify it. */
1338 struct symbol *typedef_sym = allocate_symbol (objfile);
1340 *typedef_sym = *sym;
1341 SYMBOL_ACLASS_INDEX (typedef_sym) = LOC_TYPEDEF;
1342 SYMBOL_VALUE (typedef_sym) = valu;
1343 SYMBOL_DOMAIN (typedef_sym) = VAR_DOMAIN;
1344 if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
1345 TYPE_NAME (SYMBOL_TYPE (sym))
1346 = obconcat (&objfile->objfile_obstack,
1347 SYMBOL_LINKAGE_NAME (sym),
1349 add_symbol_to_list (typedef_sym, &file_symbols);
1354 /* Static symbol of local scope. */
1355 SYMBOL_TYPE (sym) = read_type (&p, objfile);
1356 SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
1357 SYMBOL_VALUE_ADDRESS (sym) = valu;
1358 if (gdbarch_static_transform_name_p (gdbarch)
1359 && gdbarch_static_transform_name (gdbarch,
1360 SYMBOL_LINKAGE_NAME (sym))
1361 != SYMBOL_LINKAGE_NAME (sym))
1363 struct bound_minimal_symbol msym;
1365 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
1367 if (msym.minsym != NULL)
1369 const char *new_name = gdbarch_static_transform_name
1370 (gdbarch, SYMBOL_LINKAGE_NAME (sym));
1372 SYMBOL_SET_LINKAGE_NAME (sym, new_name);
1373 SYMBOL_VALUE_ADDRESS (sym) = BMSYMBOL_VALUE_ADDRESS (msym);
1376 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1377 add_symbol_to_list (sym, &local_symbols);
1381 /* Reference parameter */
1382 SYMBOL_TYPE (sym) = read_type (&p, objfile);
1383 SYMBOL_ACLASS_INDEX (sym) = LOC_REF_ARG;
1384 SYMBOL_IS_ARGUMENT (sym) = 1;
1385 SYMBOL_VALUE (sym) = valu;
1386 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1387 add_symbol_to_list (sym, &local_symbols);
1391 /* Reference parameter which is in a register. */
1392 SYMBOL_TYPE (sym) = read_type (&p, objfile);
1393 SYMBOL_ACLASS_INDEX (sym) = stab_regparm_index;
1394 SYMBOL_IS_ARGUMENT (sym) = 1;
1395 SYMBOL_VALUE (sym) = valu;
1396 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1397 add_symbol_to_list (sym, &local_symbols);
1401 /* This is used by Sun FORTRAN for "function result value".
1402 Sun claims ("dbx and dbxtool interfaces", 2nd ed)
1403 that Pascal uses it too, but when I tried it Pascal used
1404 "x:3" (local symbol) instead. */
1405 SYMBOL_TYPE (sym) = read_type (&p, objfile);
1406 SYMBOL_ACLASS_INDEX (sym) = LOC_LOCAL;
1407 SYMBOL_VALUE (sym) = valu;
1408 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1409 add_symbol_to_list (sym, &local_symbols);
1413 SYMBOL_TYPE (sym) = error_type (&p, objfile);
1414 SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
1415 SYMBOL_VALUE (sym) = 0;
1416 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1417 add_symbol_to_list (sym, &file_symbols);
1421 /* Some systems pass variables of certain types by reference instead
1422 of by value, i.e. they will pass the address of a structure (in a
1423 register or on the stack) instead of the structure itself. */
1425 if (gdbarch_stabs_argument_has_addr (gdbarch, SYMBOL_TYPE (sym))
1426 && SYMBOL_IS_ARGUMENT (sym))
1428 /* We have to convert LOC_REGISTER to LOC_REGPARM_ADDR (for
1429 variables passed in a register). */
1430 if (SYMBOL_CLASS (sym) == LOC_REGISTER)
1431 SYMBOL_ACLASS_INDEX (sym) = LOC_REGPARM_ADDR;
1432 /* Likewise for converting LOC_ARG to LOC_REF_ARG (for the 7th
1433 and subsequent arguments on SPARC, for example). */
1434 else if (SYMBOL_CLASS (sym) == LOC_ARG)
1435 SYMBOL_ACLASS_INDEX (sym) = LOC_REF_ARG;
1441 /* Skip rest of this symbol and return an error type.
1443 General notes on error recovery: error_type always skips to the
1444 end of the symbol (modulo cretinous dbx symbol name continuation).
1445 Thus code like this:
1447 if (*(*pp)++ != ';')
1448 return error_type (pp, objfile);
1450 is wrong because if *pp starts out pointing at '\0' (typically as the
1451 result of an earlier error), it will be incremented to point to the
1452 start of the next symbol, which might produce strange results, at least
1453 if you run off the end of the string table. Instead use
1456 return error_type (pp, objfile);
1462 foo = error_type (pp, objfile);
1466 And in case it isn't obvious, the point of all this hair is so the compiler
1467 can define new types and new syntaxes, and old versions of the
1468 debugger will be able to read the new symbol tables. */
1470 static struct type *
1471 error_type (char **pp, struct objfile *objfile)
1473 complaint (&symfile_complaints,
1474 _("couldn't parse type; debugger out of date?"));
1477 /* Skip to end of symbol. */
1478 while (**pp != '\0')
1483 /* Check for and handle cretinous dbx symbol name continuation! */
1484 if ((*pp)[-1] == '\\' || (*pp)[-1] == '?')
1486 *pp = next_symbol_text (objfile);
1493 return objfile_type (objfile)->builtin_error;
1497 /* Read type information or a type definition; return the type. Even
1498 though this routine accepts either type information or a type
1499 definition, the distinction is relevant--some parts of stabsread.c
1500 assume that type information starts with a digit, '-', or '(' in
1501 deciding whether to call read_type. */
1503 static struct type *
1504 read_type (char **pp, struct objfile *objfile)
1506 struct type *type = 0;
1509 char type_descriptor;
1511 /* Size in bits of type if specified by a type attribute, or -1 if
1512 there is no size attribute. */
1515 /* Used to distinguish string and bitstring from char-array and set. */
1518 /* Used to distinguish vector from array. */
1521 /* Read type number if present. The type number may be omitted.
1522 for instance in a two-dimensional array declared with type
1523 "ar1;1;10;ar1;1;10;4". */
1524 if ((**pp >= '0' && **pp <= '9')
1528 if (read_type_number (pp, typenums) != 0)
1529 return error_type (pp, objfile);
1533 /* Type is not being defined here. Either it already
1534 exists, or this is a forward reference to it.
1535 dbx_alloc_type handles both cases. */
1536 type = dbx_alloc_type (typenums, objfile);
1538 /* If this is a forward reference, arrange to complain if it
1539 doesn't get patched up by the time we're done
1541 if (TYPE_CODE (type) == TYPE_CODE_UNDEF)
1542 add_undefined_type (type, typenums);
1547 /* Type is being defined here. */
1549 Also skip the type descriptor - we get it below with (*pp)[-1]. */
1554 /* 'typenums=' not present, type is anonymous. Read and return
1555 the definition, but don't put it in the type vector. */
1556 typenums[0] = typenums[1] = -1;
1561 type_descriptor = (*pp)[-1];
1562 switch (type_descriptor)
1566 enum type_code code;
1568 /* Used to index through file_symbols. */
1569 struct pending *ppt;
1572 /* Name including "struct", etc. */
1576 char *from, *to, *p, *q1, *q2;
1578 /* Set the type code according to the following letter. */
1582 code = TYPE_CODE_STRUCT;
1585 code = TYPE_CODE_UNION;
1588 code = TYPE_CODE_ENUM;
1592 /* Complain and keep going, so compilers can invent new
1593 cross-reference types. */
1594 complaint (&symfile_complaints,
1595 _("Unrecognized cross-reference type `%c'"),
1597 code = TYPE_CODE_STRUCT;
1602 q1 = strchr (*pp, '<');
1603 p = strchr (*pp, ':');
1605 return error_type (pp, objfile);
1606 if (q1 && p > q1 && p[1] == ':')
1608 int nesting_level = 0;
1610 for (q2 = q1; *q2; q2++)
1614 else if (*q2 == '>')
1616 else if (*q2 == ':' && nesting_level == 0)
1621 return error_type (pp, objfile);
1624 if (current_subfile->language == language_cplus)
1626 char *new_name, *name = (char *) alloca (p - *pp + 1);
1628 memcpy (name, *pp, p - *pp);
1629 name[p - *pp] = '\0';
1630 new_name = cp_canonicalize_string (name);
1631 if (new_name != NULL)
1634 = (char *) obstack_copy0 (&objfile->objfile_obstack,
1635 new_name, strlen (new_name));
1639 if (type_name == NULL)
1641 to = type_name = (char *)
1642 obstack_alloc (&objfile->objfile_obstack, p - *pp + 1);
1644 /* Copy the name. */
1651 /* Set the pointer ahead of the name which we just read, and
1656 /* If this type has already been declared, then reuse the same
1657 type, rather than allocating a new one. This saves some
1660 for (ppt = file_symbols; ppt; ppt = ppt->next)
1661 for (i = 0; i < ppt->nsyms; i++)
1663 struct symbol *sym = ppt->symbol[i];
1665 if (SYMBOL_CLASS (sym) == LOC_TYPEDEF
1666 && SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
1667 && (TYPE_CODE (SYMBOL_TYPE (sym)) == code)
1668 && strcmp (SYMBOL_LINKAGE_NAME (sym), type_name) == 0)
1670 obstack_free (&objfile->objfile_obstack, type_name);
1671 type = SYMBOL_TYPE (sym);
1672 if (typenums[0] != -1)
1673 *dbx_lookup_type (typenums, objfile) = type;
1678 /* Didn't find the type to which this refers, so we must
1679 be dealing with a forward reference. Allocate a type
1680 structure for it, and keep track of it so we can
1681 fill in the rest of the fields when we get the full
1683 type = dbx_alloc_type (typenums, objfile);
1684 TYPE_CODE (type) = code;
1685 TYPE_TAG_NAME (type) = type_name;
1686 INIT_CPLUS_SPECIFIC (type);
1687 TYPE_STUB (type) = 1;
1689 add_undefined_type (type, typenums);
1693 case '-': /* RS/6000 built-in type */
1707 /* We deal with something like t(1,2)=(3,4)=... which
1708 the Lucid compiler and recent gcc versions (post 2.7.3) use. */
1710 /* Allocate and enter the typedef type first.
1711 This handles recursive types. */
1712 type = dbx_alloc_type (typenums, objfile);
1713 TYPE_CODE (type) = TYPE_CODE_TYPEDEF;
1715 struct type *xtype = read_type (pp, objfile);
1719 /* It's being defined as itself. That means it is "void". */
1720 TYPE_CODE (type) = TYPE_CODE_VOID;
1721 TYPE_LENGTH (type) = 1;
1723 else if (type_size >= 0 || is_string)
1725 /* This is the absolute wrong way to construct types. Every
1726 other debug format has found a way around this problem and
1727 the related problems with unnecessarily stubbed types;
1728 someone motivated should attempt to clean up the issue
1729 here as well. Once a type pointed to has been created it
1730 should not be modified.
1732 Well, it's not *absolutely* wrong. Constructing recursive
1733 types (trees, linked lists) necessarily entails modifying
1734 types after creating them. Constructing any loop structure
1735 entails side effects. The Dwarf 2 reader does handle this
1736 more gracefully (it never constructs more than once
1737 instance of a type object, so it doesn't have to copy type
1738 objects wholesale), but it still mutates type objects after
1739 other folks have references to them.
1741 Keep in mind that this circularity/mutation issue shows up
1742 at the source language level, too: C's "incomplete types",
1743 for example. So the proper cleanup, I think, would be to
1744 limit GDB's type smashing to match exactly those required
1745 by the source language. So GDB could have a
1746 "complete_this_type" function, but never create unnecessary
1747 copies of a type otherwise. */
1748 replace_type (type, xtype);
1749 TYPE_NAME (type) = NULL;
1750 TYPE_TAG_NAME (type) = NULL;
1754 TYPE_TARGET_STUB (type) = 1;
1755 TYPE_TARGET_TYPE (type) = xtype;
1760 /* In the following types, we must be sure to overwrite any existing
1761 type that the typenums refer to, rather than allocating a new one
1762 and making the typenums point to the new one. This is because there
1763 may already be pointers to the existing type (if it had been
1764 forward-referenced), and we must change it to a pointer, function,
1765 reference, or whatever, *in-place*. */
1767 case '*': /* Pointer to another type */
1768 type1 = read_type (pp, objfile);
1769 type = make_pointer_type (type1, dbx_lookup_type (typenums, objfile));
1772 case '&': /* Reference to another type */
1773 type1 = read_type (pp, objfile);
1774 type = make_reference_type (type1, dbx_lookup_type (typenums, objfile));
1777 case 'f': /* Function returning another type */
1778 type1 = read_type (pp, objfile);
1779 type = make_function_type (type1, dbx_lookup_type (typenums, objfile));
1782 case 'g': /* Prototyped function. (Sun) */
1784 /* Unresolved questions:
1786 - According to Sun's ``STABS Interface Manual'', for 'f'
1787 and 'F' symbol descriptors, a `0' in the argument type list
1788 indicates a varargs function. But it doesn't say how 'g'
1789 type descriptors represent that info. Someone with access
1790 to Sun's toolchain should try it out.
1792 - According to the comment in define_symbol (search for
1793 `process_prototype_types:'), Sun emits integer arguments as
1794 types which ref themselves --- like `void' types. Do we
1795 have to deal with that here, too? Again, someone with
1796 access to Sun's toolchain should try it out and let us
1799 const char *type_start = (*pp) - 1;
1800 struct type *return_type = read_type (pp, objfile);
1801 struct type *func_type
1802 = make_function_type (return_type,
1803 dbx_lookup_type (typenums, objfile));
1806 struct type_list *next;
1810 while (**pp && **pp != '#')
1812 struct type *arg_type = read_type (pp, objfile);
1813 struct type_list *newobj = XALLOCA (struct type_list);
1814 newobj->type = arg_type;
1815 newobj->next = arg_types;
1823 complaint (&symfile_complaints,
1824 _("Prototyped function type didn't "
1825 "end arguments with `#':\n%s"),
1829 /* If there is just one argument whose type is `void', then
1830 that's just an empty argument list. */
1832 && ! arg_types->next
1833 && TYPE_CODE (arg_types->type) == TYPE_CODE_VOID)
1836 TYPE_FIELDS (func_type)
1837 = (struct field *) TYPE_ALLOC (func_type,
1838 num_args * sizeof (struct field));
1839 memset (TYPE_FIELDS (func_type), 0, num_args * sizeof (struct field));
1842 struct type_list *t;
1844 /* We stuck each argument type onto the front of the list
1845 when we read it, so the list is reversed. Build the
1846 fields array right-to-left. */
1847 for (t = arg_types, i = num_args - 1; t; t = t->next, i--)
1848 TYPE_FIELD_TYPE (func_type, i) = t->type;
1850 TYPE_NFIELDS (func_type) = num_args;
1851 TYPE_PROTOTYPED (func_type) = 1;
1857 case 'k': /* Const qualifier on some type (Sun) */
1858 type = read_type (pp, objfile);
1859 type = make_cv_type (1, TYPE_VOLATILE (type), type,
1860 dbx_lookup_type (typenums, objfile));
1863 case 'B': /* Volatile qual on some type (Sun) */
1864 type = read_type (pp, objfile);
1865 type = make_cv_type (TYPE_CONST (type), 1, type,
1866 dbx_lookup_type (typenums, objfile));
1870 if (isdigit (**pp) || **pp == '(' || **pp == '-')
1871 { /* Member (class & variable) type */
1872 /* FIXME -- we should be doing smash_to_XXX types here. */
1874 struct type *domain = read_type (pp, objfile);
1875 struct type *memtype;
1878 /* Invalid member type data format. */
1879 return error_type (pp, objfile);
1882 memtype = read_type (pp, objfile);
1883 type = dbx_alloc_type (typenums, objfile);
1884 smash_to_memberptr_type (type, domain, memtype);
1887 /* type attribute */
1891 /* Skip to the semicolon. */
1892 while (**pp != ';' && **pp != '\0')
1895 return error_type (pp, objfile);
1897 ++ * pp; /* Skip the semicolon. */
1901 case 's': /* Size attribute */
1902 type_size = atoi (attr + 1);
1907 case 'S': /* String attribute */
1908 /* FIXME: check to see if following type is array? */
1912 case 'V': /* Vector attribute */
1913 /* FIXME: check to see if following type is array? */
1918 /* Ignore unrecognized type attributes, so future compilers
1919 can invent new ones. */
1927 case '#': /* Method (class & fn) type */
1928 if ((*pp)[0] == '#')
1930 /* We'll get the parameter types from the name. */
1931 struct type *return_type;
1934 return_type = read_type (pp, objfile);
1935 if (*(*pp)++ != ';')
1936 complaint (&symfile_complaints,
1937 _("invalid (minimal) member type "
1938 "data format at symtab pos %d."),
1940 type = allocate_stub_method (return_type);
1941 if (typenums[0] != -1)
1942 *dbx_lookup_type (typenums, objfile) = type;
1946 struct type *domain = read_type (pp, objfile);
1947 struct type *return_type;
1952 /* Invalid member type data format. */
1953 return error_type (pp, objfile);
1957 return_type = read_type (pp, objfile);
1958 args = read_args (pp, ';', objfile, &nargs, &varargs);
1960 return error_type (pp, objfile);
1961 type = dbx_alloc_type (typenums, objfile);
1962 smash_to_method_type (type, domain, return_type, args,
1967 case 'r': /* Range type */
1968 type = read_range_type (pp, typenums, type_size, objfile);
1969 if (typenums[0] != -1)
1970 *dbx_lookup_type (typenums, objfile) = type;
1975 /* Sun ACC builtin int type */
1976 type = read_sun_builtin_type (pp, typenums, objfile);
1977 if (typenums[0] != -1)
1978 *dbx_lookup_type (typenums, objfile) = type;
1982 case 'R': /* Sun ACC builtin float type */
1983 type = read_sun_floating_type (pp, typenums, objfile);
1984 if (typenums[0] != -1)
1985 *dbx_lookup_type (typenums, objfile) = type;
1988 case 'e': /* Enumeration type */
1989 type = dbx_alloc_type (typenums, objfile);
1990 type = read_enum_type (pp, type, objfile);
1991 if (typenums[0] != -1)
1992 *dbx_lookup_type (typenums, objfile) = type;
1995 case 's': /* Struct type */
1996 case 'u': /* Union type */
1998 enum type_code type_code = TYPE_CODE_UNDEF;
1999 type = dbx_alloc_type (typenums, objfile);
2000 switch (type_descriptor)
2003 type_code = TYPE_CODE_STRUCT;
2006 type_code = TYPE_CODE_UNION;
2009 type = read_struct_type (pp, type, type_code, objfile);
2013 case 'a': /* Array type */
2015 return error_type (pp, objfile);
2018 type = dbx_alloc_type (typenums, objfile);
2019 type = read_array_type (pp, type, objfile);
2021 TYPE_CODE (type) = TYPE_CODE_STRING;
2023 make_vector_type (type);
2026 case 'S': /* Set type */
2027 type1 = read_type (pp, objfile);
2028 type = create_set_type ((struct type *) NULL, type1);
2029 if (typenums[0] != -1)
2030 *dbx_lookup_type (typenums, objfile) = type;
2034 --*pp; /* Go back to the symbol in error. */
2035 /* Particularly important if it was \0! */
2036 return error_type (pp, objfile);
2041 warning (_("GDB internal error, type is NULL in stabsread.c."));
2042 return error_type (pp, objfile);
2045 /* Size specified in a type attribute overrides any other size. */
2046 if (type_size != -1)
2047 TYPE_LENGTH (type) = (type_size + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT;
2052 /* RS/6000 xlc/dbx combination uses a set of builtin types, starting from -1.
2053 Return the proper type node for a given builtin type number. */
2055 static const struct objfile_data *rs6000_builtin_type_data;
2057 static struct type *
2058 rs6000_builtin_type (int typenum, struct objfile *objfile)
2060 struct type **negative_types
2061 = (struct type **) objfile_data (objfile, rs6000_builtin_type_data);
2063 /* We recognize types numbered from -NUMBER_RECOGNIZED to -1. */
2064 #define NUMBER_RECOGNIZED 34
2065 struct type *rettype = NULL;
2067 if (typenum >= 0 || typenum < -NUMBER_RECOGNIZED)
2069 complaint (&symfile_complaints, _("Unknown builtin type %d"), typenum);
2070 return objfile_type (objfile)->builtin_error;
2073 if (!negative_types)
2075 /* This includes an empty slot for type number -0. */
2076 negative_types = OBSTACK_CALLOC (&objfile->objfile_obstack,
2077 NUMBER_RECOGNIZED + 1, struct type *);
2078 set_objfile_data (objfile, rs6000_builtin_type_data, negative_types);
2081 if (negative_types[-typenum] != NULL)
2082 return negative_types[-typenum];
2084 #if TARGET_CHAR_BIT != 8
2085 #error This code wrong for TARGET_CHAR_BIT not 8
2086 /* These definitions all assume that TARGET_CHAR_BIT is 8. I think
2087 that if that ever becomes not true, the correct fix will be to
2088 make the size in the struct type to be in bits, not in units of
2095 /* The size of this and all the other types are fixed, defined
2096 by the debugging format. If there is a type called "int" which
2097 is other than 32 bits, then it should use a new negative type
2098 number (or avoid negative type numbers for that case).
2099 See stabs.texinfo. */
2100 rettype = init_type (TYPE_CODE_INT, 4, 0, "int", objfile);
2103 rettype = init_type (TYPE_CODE_INT, 1, 0, "char", objfile);
2106 rettype = init_type (TYPE_CODE_INT, 2, 0, "short", objfile);
2109 rettype = init_type (TYPE_CODE_INT, 4, 0, "long", objfile);
2112 rettype = init_type (TYPE_CODE_INT, 1, TYPE_FLAG_UNSIGNED,
2113 "unsigned char", objfile);
2116 rettype = init_type (TYPE_CODE_INT, 1, 0, "signed char", objfile);
2119 rettype = init_type (TYPE_CODE_INT, 2, TYPE_FLAG_UNSIGNED,
2120 "unsigned short", objfile);
2123 rettype = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
2124 "unsigned int", objfile);
2127 rettype = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
2128 "unsigned", objfile);
2131 rettype = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
2132 "unsigned long", objfile);
2135 rettype = init_type (TYPE_CODE_VOID, 1, 0, "void", objfile);
2138 /* IEEE single precision (32 bit). */
2139 rettype = init_type (TYPE_CODE_FLT, 4, 0, "float", objfile);
2142 /* IEEE double precision (64 bit). */
2143 rettype = init_type (TYPE_CODE_FLT, 8, 0, "double", objfile);
2146 /* This is an IEEE double on the RS/6000, and different machines with
2147 different sizes for "long double" should use different negative
2148 type numbers. See stabs.texinfo. */
2149 rettype = init_type (TYPE_CODE_FLT, 8, 0, "long double", objfile);
2152 rettype = init_type (TYPE_CODE_INT, 4, 0, "integer", objfile);
2155 rettype = init_type (TYPE_CODE_BOOL, 4, TYPE_FLAG_UNSIGNED,
2156 "boolean", objfile);
2159 rettype = init_type (TYPE_CODE_FLT, 4, 0, "short real", objfile);
2162 rettype = init_type (TYPE_CODE_FLT, 8, 0, "real", objfile);
2165 rettype = init_type (TYPE_CODE_ERROR, 0, 0, "stringptr", objfile);
2168 rettype = init_type (TYPE_CODE_CHAR, 1, TYPE_FLAG_UNSIGNED,
2169 "character", objfile);
2172 rettype = init_type (TYPE_CODE_BOOL, 1, TYPE_FLAG_UNSIGNED,
2173 "logical*1", objfile);
2176 rettype = init_type (TYPE_CODE_BOOL, 2, TYPE_FLAG_UNSIGNED,
2177 "logical*2", objfile);
2180 rettype = init_type (TYPE_CODE_BOOL, 4, TYPE_FLAG_UNSIGNED,
2181 "logical*4", objfile);
2184 rettype = init_type (TYPE_CODE_BOOL, 4, TYPE_FLAG_UNSIGNED,
2185 "logical", objfile);
2188 /* Complex type consisting of two IEEE single precision values. */
2189 rettype = init_type (TYPE_CODE_COMPLEX, 8, 0, "complex", objfile);
2190 TYPE_TARGET_TYPE (rettype) = init_type (TYPE_CODE_FLT, 4, 0, "float",
2194 /* Complex type consisting of two IEEE double precision values. */
2195 rettype = init_type (TYPE_CODE_COMPLEX, 16, 0, "double complex", NULL);
2196 TYPE_TARGET_TYPE (rettype) = init_type (TYPE_CODE_FLT, 8, 0, "double",
2200 rettype = init_type (TYPE_CODE_INT, 1, 0, "integer*1", objfile);
2203 rettype = init_type (TYPE_CODE_INT, 2, 0, "integer*2", objfile);
2206 rettype = init_type (TYPE_CODE_INT, 4, 0, "integer*4", objfile);
2209 rettype = init_type (TYPE_CODE_CHAR, 2, 0, "wchar", objfile);
2212 rettype = init_type (TYPE_CODE_INT, 8, 0, "long long", objfile);
2215 rettype = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED,
2216 "unsigned long long", objfile);
2219 rettype = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED,
2220 "logical*8", objfile);
2223 rettype = init_type (TYPE_CODE_INT, 8, 0, "integer*8", objfile);
2226 negative_types[-typenum] = rettype;
2230 /* This page contains subroutines of read_type. */
2232 /* Wrapper around method_name_from_physname to flag a complaint
2233 if there is an error. */
2236 stabs_method_name_from_physname (const char *physname)
2240 method_name = method_name_from_physname (physname);
2242 if (method_name == NULL)
2244 complaint (&symfile_complaints,
2245 _("Method has bad physname %s\n"), physname);
2252 /* Read member function stabs info for C++ classes. The form of each member
2255 NAME :: TYPENUM[=type definition] ARGS : PHYSNAME ;
2257 An example with two member functions is:
2259 afunc1::20=##15;:i;2A.;afunc2::20:i;2A.;
2261 For the case of overloaded operators, the format is op$::*.funcs, where
2262 $ is the CPLUS_MARKER (usually '$'), `*' holds the place for an operator
2263 name (such as `+=') and `.' marks the end of the operator name.
2265 Returns 1 for success, 0 for failure. */
2268 read_member_functions (struct field_info *fip, char **pp, struct type *type,
2269 struct objfile *objfile)
2276 struct next_fnfield *next;
2277 struct fn_field fn_field;
2280 struct type *look_ahead_type;
2281 struct next_fnfieldlist *new_fnlist;
2282 struct next_fnfield *new_sublist;
2286 /* Process each list until we find something that is not a member function
2287 or find the end of the functions. */
2291 /* We should be positioned at the start of the function name.
2292 Scan forward to find the first ':' and if it is not the
2293 first of a "::" delimiter, then this is not a member function. */
2305 look_ahead_type = NULL;
2308 new_fnlist = XCNEW (struct next_fnfieldlist);
2309 make_cleanup (xfree, new_fnlist);
2311 if ((*pp)[0] == 'o' && (*pp)[1] == 'p' && is_cplus_marker ((*pp)[2]))
2313 /* This is a completely wierd case. In order to stuff in the
2314 names that might contain colons (the usual name delimiter),
2315 Mike Tiemann defined a different name format which is
2316 signalled if the identifier is "op$". In that case, the
2317 format is "op$::XXXX." where XXXX is the name. This is
2318 used for names like "+" or "=". YUUUUUUUK! FIXME! */
2319 /* This lets the user type "break operator+".
2320 We could just put in "+" as the name, but that wouldn't
2322 static char opname[32] = "op$";
2323 char *o = opname + 3;
2325 /* Skip past '::'. */
2328 STABS_CONTINUE (pp, objfile);
2334 main_fn_name = savestring (opname, o - opname);
2340 main_fn_name = savestring (*pp, p - *pp);
2341 /* Skip past '::'. */
2344 new_fnlist->fn_fieldlist.name = main_fn_name;
2348 new_sublist = XCNEW (struct next_fnfield);
2349 make_cleanup (xfree, new_sublist);
2351 /* Check for and handle cretinous dbx symbol name continuation! */
2352 if (look_ahead_type == NULL)
2355 STABS_CONTINUE (pp, objfile);
2357 new_sublist->fn_field.type = read_type (pp, objfile);
2360 /* Invalid symtab info for member function. */
2366 /* g++ version 1 kludge */
2367 new_sublist->fn_field.type = look_ahead_type;
2368 look_ahead_type = NULL;
2378 /* These are methods, not functions. */
2379 if (TYPE_CODE (new_sublist->fn_field.type) == TYPE_CODE_FUNC)
2380 TYPE_CODE (new_sublist->fn_field.type) = TYPE_CODE_METHOD;
2382 gdb_assert (TYPE_CODE (new_sublist->fn_field.type)
2383 == TYPE_CODE_METHOD);
2385 /* If this is just a stub, then we don't have the real name here. */
2386 if (TYPE_STUB (new_sublist->fn_field.type))
2388 if (!TYPE_SELF_TYPE (new_sublist->fn_field.type))
2389 set_type_self_type (new_sublist->fn_field.type, type);
2390 new_sublist->fn_field.is_stub = 1;
2393 new_sublist->fn_field.physname = savestring (*pp, p - *pp);
2396 /* Set this member function's visibility fields. */
2399 case VISIBILITY_PRIVATE:
2400 new_sublist->fn_field.is_private = 1;
2402 case VISIBILITY_PROTECTED:
2403 new_sublist->fn_field.is_protected = 1;
2407 STABS_CONTINUE (pp, objfile);
2410 case 'A': /* Normal functions. */
2411 new_sublist->fn_field.is_const = 0;
2412 new_sublist->fn_field.is_volatile = 0;
2415 case 'B': /* `const' member functions. */
2416 new_sublist->fn_field.is_const = 1;
2417 new_sublist->fn_field.is_volatile = 0;
2420 case 'C': /* `volatile' member function. */
2421 new_sublist->fn_field.is_const = 0;
2422 new_sublist->fn_field.is_volatile = 1;
2425 case 'D': /* `const volatile' member function. */
2426 new_sublist->fn_field.is_const = 1;
2427 new_sublist->fn_field.is_volatile = 1;
2430 case '*': /* File compiled with g++ version 1 --
2436 complaint (&symfile_complaints,
2437 _("const/volatile indicator missing, got '%c'"),
2447 /* virtual member function, followed by index.
2448 The sign bit is set to distinguish pointers-to-methods
2449 from virtual function indicies. Since the array is
2450 in words, the quantity must be shifted left by 1
2451 on 16 bit machine, and by 2 on 32 bit machine, forcing
2452 the sign bit out, and usable as a valid index into
2453 the array. Remove the sign bit here. */
2454 new_sublist->fn_field.voffset =
2455 (0x7fffffff & read_huge_number (pp, ';', &nbits, 0)) + 2;
2459 STABS_CONTINUE (pp, objfile);
2460 if (**pp == ';' || **pp == '\0')
2462 /* Must be g++ version 1. */
2463 new_sublist->fn_field.fcontext = 0;
2467 /* Figure out from whence this virtual function came.
2468 It may belong to virtual function table of
2469 one of its baseclasses. */
2470 look_ahead_type = read_type (pp, objfile);
2473 /* g++ version 1 overloaded methods. */
2477 new_sublist->fn_field.fcontext = look_ahead_type;
2486 look_ahead_type = NULL;
2492 /* static member function. */
2494 int slen = strlen (main_fn_name);
2496 new_sublist->fn_field.voffset = VOFFSET_STATIC;
2498 /* For static member functions, we can't tell if they
2499 are stubbed, as they are put out as functions, and not as
2501 GCC v2 emits the fully mangled name if
2502 dbxout.c:flag_minimal_debug is not set, so we have to
2503 detect a fully mangled physname here and set is_stub
2504 accordingly. Fully mangled physnames in v2 start with
2505 the member function name, followed by two underscores.
2506 GCC v3 currently always emits stubbed member functions,
2507 but with fully mangled physnames, which start with _Z. */
2508 if (!(strncmp (new_sublist->fn_field.physname,
2509 main_fn_name, slen) == 0
2510 && new_sublist->fn_field.physname[slen] == '_'
2511 && new_sublist->fn_field.physname[slen + 1] == '_'))
2513 new_sublist->fn_field.is_stub = 1;
2520 complaint (&symfile_complaints,
2521 _("member function type missing, got '%c'"),
2523 /* Fall through into normal member function. */
2526 /* normal member function. */
2527 new_sublist->fn_field.voffset = 0;
2528 new_sublist->fn_field.fcontext = 0;
2532 new_sublist->next = sublist;
2533 sublist = new_sublist;
2535 STABS_CONTINUE (pp, objfile);
2537 while (**pp != ';' && **pp != '\0');
2540 STABS_CONTINUE (pp, objfile);
2542 /* Skip GCC 3.X member functions which are duplicates of the callable
2543 constructor/destructor. */
2544 if (strcmp_iw (main_fn_name, "__base_ctor ") == 0
2545 || strcmp_iw (main_fn_name, "__base_dtor ") == 0
2546 || strcmp (main_fn_name, "__deleting_dtor") == 0)
2548 xfree (main_fn_name);
2553 int has_destructor = 0, has_other = 0;
2555 struct next_fnfield *tmp_sublist;
2557 /* Various versions of GCC emit various mostly-useless
2558 strings in the name field for special member functions.
2560 For stub methods, we need to defer correcting the name
2561 until we are ready to unstub the method, because the current
2562 name string is used by gdb_mangle_name. The only stub methods
2563 of concern here are GNU v2 operators; other methods have their
2564 names correct (see caveat below).
2566 For non-stub methods, in GNU v3, we have a complete physname.
2567 Therefore we can safely correct the name now. This primarily
2568 affects constructors and destructors, whose name will be
2569 __comp_ctor or __comp_dtor instead of Foo or ~Foo. Cast
2570 operators will also have incorrect names; for instance,
2571 "operator int" will be named "operator i" (i.e. the type is
2574 For non-stub methods in GNU v2, we have no easy way to
2575 know if we have a complete physname or not. For most
2576 methods the result depends on the platform (if CPLUS_MARKER
2577 can be `$' or `.', it will use minimal debug information, or
2578 otherwise the full physname will be included).
2580 Rather than dealing with this, we take a different approach.
2581 For v3 mangled names, we can use the full physname; for v2,
2582 we use cplus_demangle_opname (which is actually v2 specific),
2583 because the only interesting names are all operators - once again
2584 barring the caveat below. Skip this process if any method in the
2585 group is a stub, to prevent our fouling up the workings of
2588 The caveat: GCC 2.95.x (and earlier?) put constructors and
2589 destructors in the same method group. We need to split this
2590 into two groups, because they should have different names.
2591 So for each method group we check whether it contains both
2592 routines whose physname appears to be a destructor (the physnames
2593 for and destructors are always provided, due to quirks in v2
2594 mangling) and routines whose physname does not appear to be a
2595 destructor. If so then we break up the list into two halves.
2596 Even if the constructors and destructors aren't in the same group
2597 the destructor will still lack the leading tilde, so that also
2600 So, to summarize what we expect and handle here:
2602 Given Given Real Real Action
2603 method name physname physname method name
2605 __opi [none] __opi__3Foo operator int opname
2607 Foo _._3Foo _._3Foo ~Foo separate and
2609 operator i _ZN3FoocviEv _ZN3FoocviEv operator int demangle
2610 __comp_ctor _ZN3FooC1ERKS_ _ZN3FooC1ERKS_ Foo demangle
2613 tmp_sublist = sublist;
2614 while (tmp_sublist != NULL)
2616 if (tmp_sublist->fn_field.is_stub)
2618 if (tmp_sublist->fn_field.physname[0] == '_'
2619 && tmp_sublist->fn_field.physname[1] == 'Z')
2622 if (is_destructor_name (tmp_sublist->fn_field.physname))
2627 tmp_sublist = tmp_sublist->next;
2630 if (has_destructor && has_other)
2632 struct next_fnfieldlist *destr_fnlist;
2633 struct next_fnfield *last_sublist;
2635 /* Create a new fn_fieldlist for the destructors. */
2637 destr_fnlist = XCNEW (struct next_fnfieldlist);
2638 make_cleanup (xfree, destr_fnlist);
2640 destr_fnlist->fn_fieldlist.name
2641 = obconcat (&objfile->objfile_obstack, "~",
2642 new_fnlist->fn_fieldlist.name, (char *) NULL);
2644 destr_fnlist->fn_fieldlist.fn_fields =
2645 XOBNEWVEC (&objfile->objfile_obstack,
2646 struct fn_field, has_destructor);
2647 memset (destr_fnlist->fn_fieldlist.fn_fields, 0,
2648 sizeof (struct fn_field) * has_destructor);
2649 tmp_sublist = sublist;
2650 last_sublist = NULL;
2652 while (tmp_sublist != NULL)
2654 if (!is_destructor_name (tmp_sublist->fn_field.physname))
2656 tmp_sublist = tmp_sublist->next;
2660 destr_fnlist->fn_fieldlist.fn_fields[i++]
2661 = tmp_sublist->fn_field;
2663 last_sublist->next = tmp_sublist->next;
2665 sublist = tmp_sublist->next;
2666 last_sublist = tmp_sublist;
2667 tmp_sublist = tmp_sublist->next;
2670 destr_fnlist->fn_fieldlist.length = has_destructor;
2671 destr_fnlist->next = fip->fnlist;
2672 fip->fnlist = destr_fnlist;
2674 length -= has_destructor;
2678 /* v3 mangling prevents the use of abbreviated physnames,
2679 so we can do this here. There are stubbed methods in v3
2681 - in -gstabs instead of -gstabs+
2682 - or for static methods, which are output as a function type
2683 instead of a method type. */
2684 char *new_method_name =
2685 stabs_method_name_from_physname (sublist->fn_field.physname);
2687 if (new_method_name != NULL
2688 && strcmp (new_method_name,
2689 new_fnlist->fn_fieldlist.name) != 0)
2691 new_fnlist->fn_fieldlist.name = new_method_name;
2692 xfree (main_fn_name);
2695 xfree (new_method_name);
2697 else if (has_destructor && new_fnlist->fn_fieldlist.name[0] != '~')
2699 new_fnlist->fn_fieldlist.name =
2700 obconcat (&objfile->objfile_obstack,
2701 "~", main_fn_name, (char *)NULL);
2702 xfree (main_fn_name);
2706 char dem_opname[256];
2709 ret = cplus_demangle_opname (new_fnlist->fn_fieldlist.name,
2710 dem_opname, DMGL_ANSI);
2712 ret = cplus_demangle_opname (new_fnlist->fn_fieldlist.name,
2715 new_fnlist->fn_fieldlist.name
2717 obstack_copy0 (&objfile->objfile_obstack, dem_opname,
2718 strlen (dem_opname)));
2719 xfree (main_fn_name);
2722 new_fnlist->fn_fieldlist.fn_fields = (struct fn_field *)
2723 obstack_alloc (&objfile->objfile_obstack,
2724 sizeof (struct fn_field) * length);
2725 memset (new_fnlist->fn_fieldlist.fn_fields, 0,
2726 sizeof (struct fn_field) * length);
2727 for (i = length; (i--, sublist); sublist = sublist->next)
2729 new_fnlist->fn_fieldlist.fn_fields[i] = sublist->fn_field;
2732 new_fnlist->fn_fieldlist.length = length;
2733 new_fnlist->next = fip->fnlist;
2734 fip->fnlist = new_fnlist;
2741 ALLOCATE_CPLUS_STRUCT_TYPE (type);
2742 TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
2743 TYPE_ALLOC (type, sizeof (struct fn_fieldlist) * nfn_fields);
2744 memset (TYPE_FN_FIELDLISTS (type), 0,
2745 sizeof (struct fn_fieldlist) * nfn_fields);
2746 TYPE_NFN_FIELDS (type) = nfn_fields;
2752 /* Special GNU C++ name.
2754 Returns 1 for success, 0 for failure. "failure" means that we can't
2755 keep parsing and it's time for error_type(). */
2758 read_cpp_abbrev (struct field_info *fip, char **pp, struct type *type,
2759 struct objfile *objfile)
2764 struct type *context;
2774 /* At this point, *pp points to something like "22:23=*22...",
2775 where the type number before the ':' is the "context" and
2776 everything after is a regular type definition. Lookup the
2777 type, find it's name, and construct the field name. */
2779 context = read_type (pp, objfile);
2783 case 'f': /* $vf -- a virtual function table pointer */
2784 name = type_name_no_tag (context);
2789 fip->list->field.name = obconcat (&objfile->objfile_obstack,
2790 vptr_name, name, (char *) NULL);
2793 case 'b': /* $vb -- a virtual bsomethingorother */
2794 name = type_name_no_tag (context);
2797 complaint (&symfile_complaints,
2798 _("C++ abbreviated type name "
2799 "unknown at symtab pos %d"),
2803 fip->list->field.name = obconcat (&objfile->objfile_obstack, vb_name,
2804 name, (char *) NULL);
2808 invalid_cpp_abbrev_complaint (*pp);
2809 fip->list->field.name = obconcat (&objfile->objfile_obstack,
2810 "INVALID_CPLUSPLUS_ABBREV",
2815 /* At this point, *pp points to the ':'. Skip it and read the
2821 invalid_cpp_abbrev_complaint (*pp);
2824 fip->list->field.type = read_type (pp, objfile);
2826 (*pp)++; /* Skip the comma. */
2833 SET_FIELD_BITPOS (fip->list->field,
2834 read_huge_number (pp, ';', &nbits, 0));
2838 /* This field is unpacked. */
2839 FIELD_BITSIZE (fip->list->field) = 0;
2840 fip->list->visibility = VISIBILITY_PRIVATE;
2844 invalid_cpp_abbrev_complaint (*pp);
2845 /* We have no idea what syntax an unrecognized abbrev would have, so
2846 better return 0. If we returned 1, we would need to at least advance
2847 *pp to avoid an infinite loop. */
2854 read_one_struct_field (struct field_info *fip, char **pp, char *p,
2855 struct type *type, struct objfile *objfile)
2857 struct gdbarch *gdbarch = get_objfile_arch (objfile);
2859 fip->list->field.name
2860 = (const char *) obstack_copy0 (&objfile->objfile_obstack, *pp, p - *pp);
2863 /* This means we have a visibility for a field coming. */
2867 fip->list->visibility = *(*pp)++;
2871 /* normal dbx-style format, no explicit visibility */
2872 fip->list->visibility = VISIBILITY_PUBLIC;
2875 fip->list->field.type = read_type (pp, objfile);
2880 /* Possible future hook for nested types. */
2883 fip->list->field.bitpos = (long) -2; /* nested type */
2893 /* Static class member. */
2894 SET_FIELD_PHYSNAME (fip->list->field, savestring (*pp, p - *pp));
2898 else if (**pp != ',')
2900 /* Bad structure-type format. */
2901 stabs_general_complaint ("bad structure-type format");
2905 (*pp)++; /* Skip the comma. */
2910 SET_FIELD_BITPOS (fip->list->field,
2911 read_huge_number (pp, ',', &nbits, 0));
2914 stabs_general_complaint ("bad structure-type format");
2917 FIELD_BITSIZE (fip->list->field) = read_huge_number (pp, ';', &nbits, 0);
2920 stabs_general_complaint ("bad structure-type format");
2925 if (FIELD_BITPOS (fip->list->field) == 0
2926 && FIELD_BITSIZE (fip->list->field) == 0)
2928 /* This can happen in two cases: (1) at least for gcc 2.4.5 or so,
2929 it is a field which has been optimized out. The correct stab for
2930 this case is to use VISIBILITY_IGNORE, but that is a recent
2931 invention. (2) It is a 0-size array. For example
2932 union { int num; char str[0]; } foo. Printing _("<no value>" for
2933 str in "p foo" is OK, since foo.str (and thus foo.str[3])
2934 will continue to work, and a 0-size array as a whole doesn't
2935 have any contents to print.
2937 I suspect this probably could also happen with gcc -gstabs (not
2938 -gstabs+) for static fields, and perhaps other C++ extensions.
2939 Hopefully few people use -gstabs with gdb, since it is intended
2940 for dbx compatibility. */
2942 /* Ignore this field. */
2943 fip->list->visibility = VISIBILITY_IGNORE;
2947 /* Detect an unpacked field and mark it as such.
2948 dbx gives a bit size for all fields.
2949 Note that forward refs cannot be packed,
2950 and treat enums as if they had the width of ints. */
2952 struct type *field_type = check_typedef (FIELD_TYPE (fip->list->field));
2954 if (TYPE_CODE (field_type) != TYPE_CODE_INT
2955 && TYPE_CODE (field_type) != TYPE_CODE_RANGE
2956 && TYPE_CODE (field_type) != TYPE_CODE_BOOL
2957 && TYPE_CODE (field_type) != TYPE_CODE_ENUM)
2959 FIELD_BITSIZE (fip->list->field) = 0;
2961 if ((FIELD_BITSIZE (fip->list->field)
2962 == TARGET_CHAR_BIT * TYPE_LENGTH (field_type)
2963 || (TYPE_CODE (field_type) == TYPE_CODE_ENUM
2964 && FIELD_BITSIZE (fip->list->field)
2965 == gdbarch_int_bit (gdbarch))
2968 FIELD_BITPOS (fip->list->field) % 8 == 0)
2970 FIELD_BITSIZE (fip->list->field) = 0;
2976 /* Read struct or class data fields. They have the form:
2978 NAME : [VISIBILITY] TYPENUM , BITPOS , BITSIZE ;
2980 At the end, we see a semicolon instead of a field.
2982 In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
2985 The optional VISIBILITY is one of:
2987 '/0' (VISIBILITY_PRIVATE)
2988 '/1' (VISIBILITY_PROTECTED)
2989 '/2' (VISIBILITY_PUBLIC)
2990 '/9' (VISIBILITY_IGNORE)
2992 or nothing, for C style fields with public visibility.
2994 Returns 1 for success, 0 for failure. */
2997 read_struct_fields (struct field_info *fip, char **pp, struct type *type,
2998 struct objfile *objfile)
3001 struct nextfield *newobj;
3003 /* We better set p right now, in case there are no fields at all... */
3007 /* Read each data member type until we find the terminating ';' at the end of
3008 the data member list, or break for some other reason such as finding the
3009 start of the member function list. */
3010 /* Stab string for structure/union does not end with two ';' in
3011 SUN C compiler 5.3 i.e. F6U2, hence check for end of string. */
3013 while (**pp != ';' && **pp != '\0')
3015 STABS_CONTINUE (pp, objfile);
3016 /* Get space to record the next field's data. */
3017 newobj = XCNEW (struct nextfield);
3018 make_cleanup (xfree, newobj);
3020 newobj->next = fip->list;
3023 /* Get the field name. */
3026 /* If is starts with CPLUS_MARKER it is a special abbreviation,
3027 unless the CPLUS_MARKER is followed by an underscore, in
3028 which case it is just the name of an anonymous type, which we
3029 should handle like any other type name. */
3031 if (is_cplus_marker (p[0]) && p[1] != '_')
3033 if (!read_cpp_abbrev (fip, pp, type, objfile))
3038 /* Look for the ':' that separates the field name from the field
3039 values. Data members are delimited by a single ':', while member
3040 functions are delimited by a pair of ':'s. When we hit the member
3041 functions (if any), terminate scan loop and return. */
3043 while (*p != ':' && *p != '\0')
3050 /* Check to see if we have hit the member functions yet. */
3055 read_one_struct_field (fip, pp, p, type, objfile);
3057 if (p[0] == ':' && p[1] == ':')
3059 /* (the deleted) chill the list of fields: the last entry (at
3060 the head) is a partially constructed entry which we now
3062 fip->list = fip->list->next;
3067 /* The stabs for C++ derived classes contain baseclass information which
3068 is marked by a '!' character after the total size. This function is
3069 called when we encounter the baseclass marker, and slurps up all the
3070 baseclass information.
3072 Immediately following the '!' marker is the number of base classes that
3073 the class is derived from, followed by information for each base class.
3074 For each base class, there are two visibility specifiers, a bit offset
3075 to the base class information within the derived class, a reference to
3076 the type for the base class, and a terminating semicolon.
3078 A typical example, with two base classes, would be "!2,020,19;0264,21;".
3080 Baseclass information marker __________________|| | | | | | |
3081 Number of baseclasses __________________________| | | | | | |
3082 Visibility specifiers (2) ________________________| | | | | |
3083 Offset in bits from start of class _________________| | | | |
3084 Type number for base class ___________________________| | | |
3085 Visibility specifiers (2) _______________________________| | |
3086 Offset in bits from start of class ________________________| |
3087 Type number of base class ____________________________________|
3089 Return 1 for success, 0 for (error-type-inducing) failure. */
3095 read_baseclasses (struct field_info *fip, char **pp, struct type *type,
3096 struct objfile *objfile)
3099 struct nextfield *newobj;
3107 /* Skip the '!' baseclass information marker. */
3111 ALLOCATE_CPLUS_STRUCT_TYPE (type);
3115 TYPE_N_BASECLASSES (type) = read_huge_number (pp, ',', &nbits, 0);
3121 /* Some stupid compilers have trouble with the following, so break
3122 it up into simpler expressions. */
3123 TYPE_FIELD_VIRTUAL_BITS (type) = (B_TYPE *)
3124 TYPE_ALLOC (type, B_BYTES (TYPE_N_BASECLASSES (type)));
3127 int num_bytes = B_BYTES (TYPE_N_BASECLASSES (type));
3130 pointer = (char *) TYPE_ALLOC (type, num_bytes);
3131 TYPE_FIELD_VIRTUAL_BITS (type) = (B_TYPE *) pointer;
3135 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), TYPE_N_BASECLASSES (type));
3137 for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
3139 newobj = XCNEW (struct nextfield);
3140 make_cleanup (xfree, newobj);
3142 newobj->next = fip->list;
3144 FIELD_BITSIZE (newobj->field) = 0; /* This should be an unpacked
3147 STABS_CONTINUE (pp, objfile);
3151 /* Nothing to do. */
3154 SET_TYPE_FIELD_VIRTUAL (type, i);
3157 /* Unknown character. Complain and treat it as non-virtual. */
3159 complaint (&symfile_complaints,
3160 _("Unknown virtual character `%c' for baseclass"),
3166 newobj->visibility = *(*pp)++;
3167 switch (newobj->visibility)
3169 case VISIBILITY_PRIVATE:
3170 case VISIBILITY_PROTECTED:
3171 case VISIBILITY_PUBLIC:
3174 /* Bad visibility format. Complain and treat it as
3177 complaint (&symfile_complaints,
3178 _("Unknown visibility `%c' for baseclass"),
3179 newobj->visibility);
3180 newobj->visibility = VISIBILITY_PUBLIC;
3187 /* The remaining value is the bit offset of the portion of the object
3188 corresponding to this baseclass. Always zero in the absence of
3189 multiple inheritance. */
3191 SET_FIELD_BITPOS (newobj->field, read_huge_number (pp, ',', &nbits, 0));
3196 /* The last piece of baseclass information is the type of the
3197 base class. Read it, and remember it's type name as this
3200 newobj->field.type = read_type (pp, objfile);
3201 newobj->field.name = type_name_no_tag (newobj->field.type);
3203 /* Skip trailing ';' and bump count of number of fields seen. */
3212 /* The tail end of stabs for C++ classes that contain a virtual function
3213 pointer contains a tilde, a %, and a type number.
3214 The type number refers to the base class (possibly this class itself) which
3215 contains the vtable pointer for the current class.
3217 This function is called when we have parsed all the method declarations,
3218 so we can look for the vptr base class info. */
3221 read_tilde_fields (struct field_info *fip, char **pp, struct type *type,
3222 struct objfile *objfile)
3226 STABS_CONTINUE (pp, objfile);
3228 /* If we are positioned at a ';', then skip it. */
3238 if (**pp == '=' || **pp == '+' || **pp == '-')
3240 /* Obsolete flags that used to indicate the presence
3241 of constructors and/or destructors. */
3245 /* Read either a '%' or the final ';'. */
3246 if (*(*pp)++ == '%')
3248 /* The next number is the type number of the base class
3249 (possibly our own class) which supplies the vtable for
3250 this class. Parse it out, and search that class to find
3251 its vtable pointer, and install those into TYPE_VPTR_BASETYPE
3252 and TYPE_VPTR_FIELDNO. */
3257 t = read_type (pp, objfile);
3259 while (*p != '\0' && *p != ';')
3265 /* Premature end of symbol. */
3269 set_type_vptr_basetype (type, t);
3270 if (type == t) /* Our own class provides vtbl ptr. */
3272 for (i = TYPE_NFIELDS (t) - 1;
3273 i >= TYPE_N_BASECLASSES (t);
3276 const char *name = TYPE_FIELD_NAME (t, i);
3278 if (!strncmp (name, vptr_name, sizeof (vptr_name) - 2)
3279 && is_cplus_marker (name[sizeof (vptr_name) - 2]))
3281 set_type_vptr_fieldno (type, i);
3285 /* Virtual function table field not found. */
3286 complaint (&symfile_complaints,
3287 _("virtual function table pointer "
3288 "not found when defining class `%s'"),
3294 set_type_vptr_fieldno (type, TYPE_VPTR_FIELDNO (t));
3305 attach_fn_fields_to_type (struct field_info *fip, struct type *type)
3309 for (n = TYPE_NFN_FIELDS (type);
3310 fip->fnlist != NULL;
3311 fip->fnlist = fip->fnlist->next)
3313 --n; /* Circumvent Sun3 compiler bug. */
3314 TYPE_FN_FIELDLISTS (type)[n] = fip->fnlist->fn_fieldlist;
3319 /* Create the vector of fields, and record how big it is.
3320 We need this info to record proper virtual function table information
3321 for this class's virtual functions. */
3324 attach_fields_to_type (struct field_info *fip, struct type *type,
3325 struct objfile *objfile)
3328 int non_public_fields = 0;
3329 struct nextfield *scan;
3331 /* Count up the number of fields that we have, as well as taking note of
3332 whether or not there are any non-public fields, which requires us to
3333 allocate and build the private_field_bits and protected_field_bits
3336 for (scan = fip->list; scan != NULL; scan = scan->next)
3339 if (scan->visibility != VISIBILITY_PUBLIC)
3341 non_public_fields++;
3345 /* Now we know how many fields there are, and whether or not there are any
3346 non-public fields. Record the field count, allocate space for the
3347 array of fields, and create blank visibility bitfields if necessary. */
3349 TYPE_NFIELDS (type) = nfields;
3350 TYPE_FIELDS (type) = (struct field *)
3351 TYPE_ALLOC (type, sizeof (struct field) * nfields);
3352 memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nfields);
3354 if (non_public_fields)
3356 ALLOCATE_CPLUS_STRUCT_TYPE (type);
3358 TYPE_FIELD_PRIVATE_BITS (type) =
3359 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
3360 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
3362 TYPE_FIELD_PROTECTED_BITS (type) =
3363 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
3364 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
3366 TYPE_FIELD_IGNORE_BITS (type) =
3367 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
3368 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
3371 /* Copy the saved-up fields into the field vector. Start from the
3372 head of the list, adding to the tail of the field array, so that
3373 they end up in the same order in the array in which they were
3374 added to the list. */
3376 while (nfields-- > 0)
3378 TYPE_FIELD (type, nfields) = fip->list->field;
3379 switch (fip->list->visibility)
3381 case VISIBILITY_PRIVATE:
3382 SET_TYPE_FIELD_PRIVATE (type, nfields);
3385 case VISIBILITY_PROTECTED:
3386 SET_TYPE_FIELD_PROTECTED (type, nfields);
3389 case VISIBILITY_IGNORE:
3390 SET_TYPE_FIELD_IGNORE (type, nfields);
3393 case VISIBILITY_PUBLIC:
3397 /* Unknown visibility. Complain and treat it as public. */
3399 complaint (&symfile_complaints,
3400 _("Unknown visibility `%c' for field"),
3401 fip->list->visibility);
3405 fip->list = fip->list->next;
3411 /* Complain that the compiler has emitted more than one definition for the
3412 structure type TYPE. */
3414 complain_about_struct_wipeout (struct type *type)
3416 const char *name = "";
3417 const char *kind = "";
3419 if (TYPE_TAG_NAME (type))
3421 name = TYPE_TAG_NAME (type);
3422 switch (TYPE_CODE (type))
3424 case TYPE_CODE_STRUCT: kind = "struct "; break;
3425 case TYPE_CODE_UNION: kind = "union "; break;
3426 case TYPE_CODE_ENUM: kind = "enum "; break;
3430 else if (TYPE_NAME (type))
3432 name = TYPE_NAME (type);
3441 complaint (&symfile_complaints,
3442 _("struct/union type gets multiply defined: %s%s"), kind, name);
3445 /* Set the length for all variants of a same main_type, which are
3446 connected in the closed chain.
3448 This is something that needs to be done when a type is defined *after*
3449 some cross references to this type have already been read. Consider
3450 for instance the following scenario where we have the following two
3453 .stabs "t:p(0,21)=*(0,22)=k(0,23)=xsdummy:",160,0,28,-24
3454 .stabs "dummy:T(0,23)=s16x:(0,1),0,3[...]"
3456 A stubbed version of type dummy is created while processing the first
3457 stabs entry. The length of that type is initially set to zero, since
3458 it is unknown at this point. Also, a "constant" variation of type
3459 "dummy" is created as well (this is the "(0,22)=k(0,23)" section of
3462 The second stabs entry allows us to replace the stubbed definition
3463 with the real definition. However, we still need to adjust the length
3464 of the "constant" variation of that type, as its length was left
3465 untouched during the main type replacement... */
3468 set_length_in_type_chain (struct type *type)
3470 struct type *ntype = TYPE_CHAIN (type);
3472 while (ntype != type)
3474 if (TYPE_LENGTH(ntype) == 0)
3475 TYPE_LENGTH (ntype) = TYPE_LENGTH (type);
3477 complain_about_struct_wipeout (ntype);
3478 ntype = TYPE_CHAIN (ntype);
3482 /* Read the description of a structure (or union type) and return an object
3483 describing the type.
3485 PP points to a character pointer that points to the next unconsumed token
3486 in the stabs string. For example, given stabs "A:T4=s4a:1,0,32;;",
3487 *PP will point to "4a:1,0,32;;".
3489 TYPE points to an incomplete type that needs to be filled in.
3491 OBJFILE points to the current objfile from which the stabs information is
3492 being read. (Note that it is redundant in that TYPE also contains a pointer
3493 to this same objfile, so it might be a good idea to eliminate it. FIXME).
3496 static struct type *
3497 read_struct_type (char **pp, struct type *type, enum type_code type_code,
3498 struct objfile *objfile)
3500 struct cleanup *back_to;
3501 struct field_info fi;
3506 /* When describing struct/union/class types in stabs, G++ always drops
3507 all qualifications from the name. So if you've got:
3508 struct A { ... struct B { ... }; ... };
3509 then G++ will emit stabs for `struct A::B' that call it simply
3510 `struct B'. Obviously, if you've got a real top-level definition for
3511 `struct B', or other nested definitions, this is going to cause
3514 Obviously, GDB can't fix this by itself, but it can at least avoid
3515 scribbling on existing structure type objects when new definitions
3517 if (! (TYPE_CODE (type) == TYPE_CODE_UNDEF
3518 || TYPE_STUB (type)))
3520 complain_about_struct_wipeout (type);
3522 /* It's probably best to return the type unchanged. */
3526 back_to = make_cleanup (null_cleanup, 0);
3528 INIT_CPLUS_SPECIFIC (type);
3529 TYPE_CODE (type) = type_code;
3530 TYPE_STUB (type) = 0;
3532 /* First comes the total size in bytes. */
3537 TYPE_LENGTH (type) = read_huge_number (pp, 0, &nbits, 0);
3540 do_cleanups (back_to);
3541 return error_type (pp, objfile);
3543 set_length_in_type_chain (type);
3546 /* Now read the baseclasses, if any, read the regular C struct or C++
3547 class member fields, attach the fields to the type, read the C++
3548 member functions, attach them to the type, and then read any tilde
3549 field (baseclass specifier for the class holding the main vtable). */
3551 if (!read_baseclasses (&fi, pp, type, objfile)
3552 || !read_struct_fields (&fi, pp, type, objfile)
3553 || !attach_fields_to_type (&fi, type, objfile)
3554 || !read_member_functions (&fi, pp, type, objfile)
3555 || !attach_fn_fields_to_type (&fi, type)
3556 || !read_tilde_fields (&fi, pp, type, objfile))
3558 type = error_type (pp, objfile);
3561 do_cleanups (back_to);
3565 /* Read a definition of an array type,
3566 and create and return a suitable type object.
3567 Also creates a range type which represents the bounds of that
3570 static struct type *
3571 read_array_type (char **pp, struct type *type,
3572 struct objfile *objfile)
3574 struct type *index_type, *element_type, *range_type;
3579 /* Format of an array type:
3580 "ar<index type>;lower;upper;<array_contents_type>".
3581 OS9000: "arlower,upper;<array_contents_type>".
3583 Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
3584 for these, produce a type like float[][]. */
3587 index_type = read_type (pp, objfile);
3589 /* Improper format of array type decl. */
3590 return error_type (pp, objfile);
3594 if (!(**pp >= '0' && **pp <= '9') && **pp != '-')
3599 lower = read_huge_number (pp, ';', &nbits, 0);
3602 return error_type (pp, objfile);
3604 if (!(**pp >= '0' && **pp <= '9') && **pp != '-')
3609 upper = read_huge_number (pp, ';', &nbits, 0);
3611 return error_type (pp, objfile);
3613 element_type = read_type (pp, objfile);
3622 create_static_range_type ((struct type *) NULL, index_type, lower, upper);
3623 type = create_array_type (type, element_type, range_type);
3629 /* Read a definition of an enumeration type,
3630 and create and return a suitable type object.
3631 Also defines the symbols that represent the values of the type. */
3633 static struct type *
3634 read_enum_type (char **pp, struct type *type,
3635 struct objfile *objfile)
3637 struct gdbarch *gdbarch = get_objfile_arch (objfile);
3643 struct pending **symlist;
3644 struct pending *osyms, *syms;
3647 int unsigned_enum = 1;
3650 /* FIXME! The stabs produced by Sun CC merrily define things that ought
3651 to be file-scope, between N_FN entries, using N_LSYM. What's a mother
3652 to do? For now, force all enum values to file scope. */
3653 if (within_function)
3654 symlist = &local_symbols;
3657 symlist = &file_symbols;
3659 o_nsyms = osyms ? osyms->nsyms : 0;
3661 /* The aix4 compiler emits an extra field before the enum members;
3662 my guess is it's a type of some sort. Just ignore it. */
3665 /* Skip over the type. */
3669 /* Skip over the colon. */
3673 /* Read the value-names and their values.
3674 The input syntax is NAME:VALUE,NAME:VALUE, and so on.
3675 A semicolon or comma instead of a NAME means the end. */
3676 while (**pp && **pp != ';' && **pp != ',')
3678 STABS_CONTINUE (pp, objfile);
3682 name = (char *) obstack_copy0 (&objfile->objfile_obstack, *pp, p - *pp);
3684 n = read_huge_number (pp, ',', &nbits, 0);
3686 return error_type (pp, objfile);
3688 sym = allocate_symbol (objfile);
3689 SYMBOL_SET_LINKAGE_NAME (sym, name);
3690 SYMBOL_SET_LANGUAGE (sym, current_subfile->language,
3691 &objfile->objfile_obstack);
3692 SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
3693 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
3694 SYMBOL_VALUE (sym) = n;
3697 add_symbol_to_list (sym, symlist);
3702 (*pp)++; /* Skip the semicolon. */
3704 /* Now fill in the fields of the type-structure. */
3706 TYPE_LENGTH (type) = gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT;
3707 set_length_in_type_chain (type);
3708 TYPE_CODE (type) = TYPE_CODE_ENUM;
3709 TYPE_STUB (type) = 0;
3711 TYPE_UNSIGNED (type) = 1;
3712 TYPE_NFIELDS (type) = nsyms;
3713 TYPE_FIELDS (type) = (struct field *)
3714 TYPE_ALLOC (type, sizeof (struct field) * nsyms);
3715 memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nsyms);
3717 /* Find the symbols for the values and put them into the type.
3718 The symbols can be found in the symlist that we put them on
3719 to cause them to be defined. osyms contains the old value
3720 of that symlist; everything up to there was defined by us. */
3721 /* Note that we preserve the order of the enum constants, so
3722 that in something like "enum {FOO, LAST_THING=FOO}" we print
3723 FOO, not LAST_THING. */
3725 for (syms = *symlist, n = nsyms - 1; syms; syms = syms->next)
3727 int last = syms == osyms ? o_nsyms : 0;
3728 int j = syms->nsyms;
3730 for (; --j >= last; --n)
3732 struct symbol *xsym = syms->symbol[j];
3734 SYMBOL_TYPE (xsym) = type;
3735 TYPE_FIELD_NAME (type, n) = SYMBOL_LINKAGE_NAME (xsym);
3736 SET_FIELD_ENUMVAL (TYPE_FIELD (type, n), SYMBOL_VALUE (xsym));
3737 TYPE_FIELD_BITSIZE (type, n) = 0;
3746 /* Sun's ACC uses a somewhat saner method for specifying the builtin
3747 typedefs in every file (for int, long, etc):
3749 type = b <signed> <width> <format type>; <offset>; <nbits>
3751 optional format type = c or b for char or boolean.
3752 offset = offset from high order bit to start bit of type.
3753 width is # bytes in object of this type, nbits is # bits in type.
3755 The width/offset stuff appears to be for small objects stored in
3756 larger ones (e.g. `shorts' in `int' registers). We ignore it for now,
3759 static struct type *
3760 read_sun_builtin_type (char **pp, int typenums[2], struct objfile *objfile)
3765 enum type_code code = TYPE_CODE_INT;
3776 return error_type (pp, objfile);
3780 /* For some odd reason, all forms of char put a c here. This is strange
3781 because no other type has this honor. We can safely ignore this because
3782 we actually determine 'char'acterness by the number of bits specified in
3784 Boolean forms, e.g Fortran logical*X, put a b here. */
3788 else if (**pp == 'b')
3790 code = TYPE_CODE_BOOL;
3794 /* The first number appears to be the number of bytes occupied
3795 by this type, except that unsigned short is 4 instead of 2.
3796 Since this information is redundant with the third number,
3797 we will ignore it. */
3798 read_huge_number (pp, ';', &nbits, 0);
3800 return error_type (pp, objfile);
3802 /* The second number is always 0, so ignore it too. */
3803 read_huge_number (pp, ';', &nbits, 0);
3805 return error_type (pp, objfile);
3807 /* The third number is the number of bits for this type. */
3808 type_bits = read_huge_number (pp, 0, &nbits, 0);
3810 return error_type (pp, objfile);
3811 /* The type *should* end with a semicolon. If it are embedded
3812 in a larger type the semicolon may be the only way to know where
3813 the type ends. If this type is at the end of the stabstring we
3814 can deal with the omitted semicolon (but we don't have to like
3815 it). Don't bother to complain(), Sun's compiler omits the semicolon
3821 return init_type (TYPE_CODE_VOID, 1,
3822 signed_type ? 0 : TYPE_FLAG_UNSIGNED, (char *) NULL,
3825 return init_type (code,
3826 type_bits / TARGET_CHAR_BIT,
3827 signed_type ? 0 : TYPE_FLAG_UNSIGNED, (char *) NULL,
3831 static struct type *
3832 read_sun_floating_type (char **pp, int typenums[2], struct objfile *objfile)
3837 struct type *rettype;
3839 /* The first number has more details about the type, for example
3841 details = read_huge_number (pp, ';', &nbits, 0);
3843 return error_type (pp, objfile);
3845 /* The second number is the number of bytes occupied by this type. */
3846 nbytes = read_huge_number (pp, ';', &nbits, 0);
3848 return error_type (pp, objfile);
3850 if (details == NF_COMPLEX || details == NF_COMPLEX16
3851 || details == NF_COMPLEX32)
3853 rettype = init_type (TYPE_CODE_COMPLEX, nbytes, 0, NULL, objfile);
3854 TYPE_TARGET_TYPE (rettype)
3855 = init_type (TYPE_CODE_FLT, nbytes / 2, 0, NULL, objfile);
3859 return init_type (TYPE_CODE_FLT, nbytes, 0, NULL, objfile);
3862 /* Read a number from the string pointed to by *PP.
3863 The value of *PP is advanced over the number.
3864 If END is nonzero, the character that ends the
3865 number must match END, or an error happens;
3866 and that character is skipped if it does match.
3867 If END is zero, *PP is left pointing to that character.
3869 If TWOS_COMPLEMENT_BITS is set to a strictly positive value and if
3870 the number is represented in an octal representation, assume that
3871 it is represented in a 2's complement representation with a size of
3872 TWOS_COMPLEMENT_BITS.
3874 If the number fits in a long, set *BITS to 0 and return the value.
3875 If not, set *BITS to be the number of bits in the number and return 0.
3877 If encounter garbage, set *BITS to -1 and return 0. */
3880 read_huge_number (char **pp, int end, int *bits, int twos_complement_bits)
3891 int twos_complement_representation = 0;
3899 /* Leading zero means octal. GCC uses this to output values larger
3900 than an int (because that would be hard in decimal). */
3907 /* Skip extra zeros. */
3911 if (sign > 0 && radix == 8 && twos_complement_bits > 0)
3913 /* Octal, possibly signed. Check if we have enough chars for a
3919 while ((c = *p1) >= '0' && c < '8')
3923 if (len > twos_complement_bits / 3
3924 || (twos_complement_bits % 3 == 0
3925 && len == twos_complement_bits / 3))
3927 /* Ok, we have enough characters for a signed value, check
3928 for signness by testing if the sign bit is set. */
3929 sign_bit = (twos_complement_bits % 3 + 2) % 3;
3931 if (c & (1 << sign_bit))
3933 /* Definitely signed. */
3934 twos_complement_representation = 1;
3940 upper_limit = LONG_MAX / radix;
3942 while ((c = *p++) >= '0' && c < ('0' + radix))
3944 if (n <= upper_limit)
3946 if (twos_complement_representation)
3948 /* Octal, signed, twos complement representation. In
3949 this case, n is the corresponding absolute value. */
3952 long sn = c - '0' - ((2 * (c - '0')) | (2 << sign_bit));
3964 /* unsigned representation */
3966 n += c - '0'; /* FIXME this overflows anyway. */
3972 /* This depends on large values being output in octal, which is
3979 /* Ignore leading zeroes. */
3983 else if (c == '2' || c == '3')
4004 if (radix == 8 && twos_complement_bits > 0 && nbits > twos_complement_bits)
4006 /* We were supposed to parse a number with maximum
4007 TWOS_COMPLEMENT_BITS bits, but something went wrong. */
4018 /* Large decimal constants are an error (because it is hard to
4019 count how many bits are in them). */
4025 /* -0x7f is the same as 0x80. So deal with it by adding one to
4026 the number of bits. Two's complement represention octals
4027 can't have a '-' in front. */
4028 if (sign == -1 && !twos_complement_representation)
4039 /* It's *BITS which has the interesting information. */
4043 static struct type *
4044 read_range_type (char **pp, int typenums[2], int type_size,
4045 struct objfile *objfile)
4047 struct gdbarch *gdbarch = get_objfile_arch (objfile);
4048 char *orig_pp = *pp;
4053 struct type *result_type;
4054 struct type *index_type = NULL;
4056 /* First comes a type we are a subrange of.
4057 In C it is usually 0, 1 or the type being defined. */
4058 if (read_type_number (pp, rangenums) != 0)
4059 return error_type (pp, objfile);
4060 self_subrange = (rangenums[0] == typenums[0] &&
4061 rangenums[1] == typenums[1]);
4066 index_type = read_type (pp, objfile);
4069 /* A semicolon should now follow; skip it. */
4073 /* The remaining two operands are usually lower and upper bounds
4074 of the range. But in some special cases they mean something else. */
4075 n2 = read_huge_number (pp, ';', &n2bits, type_size);
4076 n3 = read_huge_number (pp, ';', &n3bits, type_size);
4078 if (n2bits == -1 || n3bits == -1)
4079 return error_type (pp, objfile);
4082 goto handle_true_range;
4084 /* If limits are huge, must be large integral type. */
4085 if (n2bits != 0 || n3bits != 0)
4087 char got_signed = 0;
4088 char got_unsigned = 0;
4089 /* Number of bits in the type. */
4092 /* If a type size attribute has been specified, the bounds of
4093 the range should fit in this size. If the lower bounds needs
4094 more bits than the upper bound, then the type is signed. */
4095 if (n2bits <= type_size && n3bits <= type_size)
4097 if (n2bits == type_size && n2bits > n3bits)
4103 /* Range from 0 to <large number> is an unsigned large integral type. */
4104 else if ((n2bits == 0 && n2 == 0) && n3bits != 0)
4109 /* Range from <large number> to <large number>-1 is a large signed
4110 integral type. Take care of the case where <large number> doesn't
4111 fit in a long but <large number>-1 does. */
4112 else if ((n2bits != 0 && n3bits != 0 && n2bits == n3bits + 1)
4113 || (n2bits != 0 && n3bits == 0
4114 && (n2bits == sizeof (long) * HOST_CHAR_BIT)
4121 if (got_signed || got_unsigned)
4123 return init_type (TYPE_CODE_INT, nbits / TARGET_CHAR_BIT,
4124 got_unsigned ? TYPE_FLAG_UNSIGNED : 0, NULL,
4128 return error_type (pp, objfile);
4131 /* A type defined as a subrange of itself, with bounds both 0, is void. */
4132 if (self_subrange && n2 == 0 && n3 == 0)
4133 return init_type (TYPE_CODE_VOID, 1, 0, NULL, objfile);
4135 /* If n3 is zero and n2 is positive, we want a floating type, and n2
4136 is the width in bytes.
4138 Fortran programs appear to use this for complex types also. To
4139 distinguish between floats and complex, g77 (and others?) seem
4140 to use self-subranges for the complexes, and subranges of int for
4143 Also note that for complexes, g77 sets n2 to the size of one of
4144 the member floats, not the whole complex beast. My guess is that
4145 this was to work well with pre-COMPLEX versions of gdb. */
4147 if (n3 == 0 && n2 > 0)
4149 struct type *float_type
4150 = init_type (TYPE_CODE_FLT, n2, 0, NULL, objfile);
4154 struct type *complex_type =
4155 init_type (TYPE_CODE_COMPLEX, 2 * n2, 0, NULL, objfile);
4157 TYPE_TARGET_TYPE (complex_type) = float_type;
4158 return complex_type;
4164 /* If the upper bound is -1, it must really be an unsigned integral. */
4166 else if (n2 == 0 && n3 == -1)
4168 int bits = type_size;
4172 /* We don't know its size. It is unsigned int or unsigned
4173 long. GCC 2.3.3 uses this for long long too, but that is
4174 just a GDB 3.5 compatibility hack. */
4175 bits = gdbarch_int_bit (gdbarch);
4178 return init_type (TYPE_CODE_INT, bits / TARGET_CHAR_BIT,
4179 TYPE_FLAG_UNSIGNED, NULL, objfile);
4182 /* Special case: char is defined (Who knows why) as a subrange of
4183 itself with range 0-127. */
4184 else if (self_subrange && n2 == 0 && n3 == 127)
4185 return init_type (TYPE_CODE_INT, 1, TYPE_FLAG_NOSIGN, NULL, objfile);
4187 /* We used to do this only for subrange of self or subrange of int. */
4190 /* -1 is used for the upper bound of (4 byte) "unsigned int" and
4191 "unsigned long", and we already checked for that,
4192 so don't need to test for it here. */
4195 /* n3 actually gives the size. */
4196 return init_type (TYPE_CODE_INT, -n3, TYPE_FLAG_UNSIGNED,
4199 /* Is n3 == 2**(8n)-1 for some integer n? Then it's an
4200 unsigned n-byte integer. But do require n to be a power of
4201 two; we don't want 3- and 5-byte integers flying around. */
4207 for (bytes = 0; (bits & 0xff) == 0xff; bytes++)
4210 && ((bytes - 1) & bytes) == 0) /* "bytes is a power of two" */
4211 return init_type (TYPE_CODE_INT, bytes, TYPE_FLAG_UNSIGNED, NULL,
4215 /* I think this is for Convex "long long". Since I don't know whether
4216 Convex sets self_subrange, I also accept that particular size regardless
4217 of self_subrange. */
4218 else if (n3 == 0 && n2 < 0
4220 || n2 == -gdbarch_long_long_bit
4221 (gdbarch) / TARGET_CHAR_BIT))
4222 return init_type (TYPE_CODE_INT, -n2, 0, NULL, objfile);
4223 else if (n2 == -n3 - 1)
4226 return init_type (TYPE_CODE_INT, 1, 0, NULL, objfile);
4228 return init_type (TYPE_CODE_INT, 2, 0, NULL, objfile);
4229 if (n3 == 0x7fffffff)
4230 return init_type (TYPE_CODE_INT, 4, 0, NULL, objfile);
4233 /* We have a real range type on our hands. Allocate space and
4234 return a real pointer. */
4238 index_type = objfile_type (objfile)->builtin_int;
4240 index_type = *dbx_lookup_type (rangenums, objfile);
4241 if (index_type == NULL)
4243 /* Does this actually ever happen? Is that why we are worrying
4244 about dealing with it rather than just calling error_type? */
4246 complaint (&symfile_complaints,
4247 _("base type %d of range type is not defined"), rangenums[1]);
4249 index_type = objfile_type (objfile)->builtin_int;
4253 = create_static_range_type ((struct type *) NULL, index_type, n2, n3);
4254 return (result_type);
4257 /* Read in an argument list. This is a list of types, separated by commas
4258 and terminated with END. Return the list of types read in, or NULL
4259 if there is an error. */
4261 static struct field *
4262 read_args (char **pp, int end, struct objfile *objfile, int *nargsp,
4265 /* FIXME! Remove this arbitrary limit! */
4266 struct type *types[1024]; /* Allow for fns of 1023 parameters. */
4273 /* Invalid argument list: no ','. */
4276 STABS_CONTINUE (pp, objfile);
4277 types[n++] = read_type (pp, objfile);
4279 (*pp)++; /* get past `end' (the ':' character). */
4283 /* We should read at least the THIS parameter here. Some broken stabs
4284 output contained `(0,41),(0,42)=@s8;-16;,(0,43),(0,1);' where should
4285 have been present ";-16,(0,43)" reference instead. This way the
4286 excessive ";" marker prematurely stops the parameters parsing. */
4288 complaint (&symfile_complaints, _("Invalid (empty) method arguments"));
4291 else if (TYPE_CODE (types[n - 1]) != TYPE_CODE_VOID)
4299 rval = XCNEWVEC (struct field, n);
4300 for (i = 0; i < n; i++)
4301 rval[i].type = types[i];
4306 /* Common block handling. */
4308 /* List of symbols declared since the last BCOMM. This list is a tail
4309 of local_symbols. When ECOMM is seen, the symbols on the list
4310 are noted so their proper addresses can be filled in later,
4311 using the common block base address gotten from the assembler
4314 static struct pending *common_block;
4315 static int common_block_i;
4317 /* Name of the current common block. We get it from the BCOMM instead of the
4318 ECOMM to match IBM documentation (even though IBM puts the name both places
4319 like everyone else). */
4320 static char *common_block_name;
4322 /* Process a N_BCOMM symbol. The storage for NAME is not guaranteed
4323 to remain after this function returns. */
4326 common_block_start (char *name, struct objfile *objfile)
4328 if (common_block_name != NULL)
4330 complaint (&symfile_complaints,
4331 _("Invalid symbol data: common block within common block"));
4333 common_block = local_symbols;
4334 common_block_i = local_symbols ? local_symbols->nsyms : 0;
4335 common_block_name = (char *) obstack_copy0 (&objfile->objfile_obstack, name,
4339 /* Process a N_ECOMM symbol. */
4342 common_block_end (struct objfile *objfile)
4344 /* Symbols declared since the BCOMM are to have the common block
4345 start address added in when we know it. common_block and
4346 common_block_i point to the first symbol after the BCOMM in
4347 the local_symbols list; copy the list and hang it off the
4348 symbol for the common block name for later fixup. */
4351 struct pending *newobj = 0;
4352 struct pending *next;
4355 if (common_block_name == NULL)
4357 complaint (&symfile_complaints, _("ECOMM symbol unmatched by BCOMM"));
4361 sym = allocate_symbol (objfile);
4362 /* Note: common_block_name already saved on objfile_obstack. */
4363 SYMBOL_SET_LINKAGE_NAME (sym, common_block_name);
4364 SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
4366 /* Now we copy all the symbols which have been defined since the BCOMM. */
4368 /* Copy all the struct pendings before common_block. */
4369 for (next = local_symbols;
4370 next != NULL && next != common_block;
4373 for (j = 0; j < next->nsyms; j++)
4374 add_symbol_to_list (next->symbol[j], &newobj);
4377 /* Copy however much of COMMON_BLOCK we need. If COMMON_BLOCK is
4378 NULL, it means copy all the local symbols (which we already did
4381 if (common_block != NULL)
4382 for (j = common_block_i; j < common_block->nsyms; j++)
4383 add_symbol_to_list (common_block->symbol[j], &newobj);
4385 SYMBOL_TYPE (sym) = (struct type *) newobj;
4387 /* Should we be putting local_symbols back to what it was?
4390 i = hashname (SYMBOL_LINKAGE_NAME (sym));
4391 SYMBOL_VALUE_CHAIN (sym) = global_sym_chain[i];
4392 global_sym_chain[i] = sym;
4393 common_block_name = NULL;
4396 /* Add a common block's start address to the offset of each symbol
4397 declared to be in it (by being between a BCOMM/ECOMM pair that uses
4398 the common block name). */
4401 fix_common_block (struct symbol *sym, CORE_ADDR valu)
4403 struct pending *next = (struct pending *) SYMBOL_TYPE (sym);
4405 for (; next; next = next->next)
4409 for (j = next->nsyms - 1; j >= 0; j--)
4410 SYMBOL_VALUE_ADDRESS (next->symbol[j]) += valu;
4416 /* Add {TYPE, TYPENUMS} to the NONAME_UNDEFS vector.
4417 See add_undefined_type for more details. */
4420 add_undefined_type_noname (struct type *type, int typenums[2])
4424 nat.typenums[0] = typenums [0];
4425 nat.typenums[1] = typenums [1];
4428 if (noname_undefs_length == noname_undefs_allocated)
4430 noname_undefs_allocated *= 2;
4431 noname_undefs = (struct nat *)
4432 xrealloc ((char *) noname_undefs,
4433 noname_undefs_allocated * sizeof (struct nat));
4435 noname_undefs[noname_undefs_length++] = nat;
4438 /* Add TYPE to the UNDEF_TYPES vector.
4439 See add_undefined_type for more details. */
4442 add_undefined_type_1 (struct type *type)
4444 if (undef_types_length == undef_types_allocated)
4446 undef_types_allocated *= 2;
4447 undef_types = (struct type **)
4448 xrealloc ((char *) undef_types,
4449 undef_types_allocated * sizeof (struct type *));
4451 undef_types[undef_types_length++] = type;
4454 /* What about types defined as forward references inside of a small lexical
4456 /* Add a type to the list of undefined types to be checked through
4457 once this file has been read in.
4459 In practice, we actually maintain two such lists: The first list
4460 (UNDEF_TYPES) is used for types whose name has been provided, and
4461 concerns forward references (eg 'xs' or 'xu' forward references);
4462 the second list (NONAME_UNDEFS) is used for types whose name is
4463 unknown at creation time, because they were referenced through
4464 their type number before the actual type was declared.
4465 This function actually adds the given type to the proper list. */
4468 add_undefined_type (struct type *type, int typenums[2])
4470 if (TYPE_TAG_NAME (type) == NULL)
4471 add_undefined_type_noname (type, typenums);
4473 add_undefined_type_1 (type);
4476 /* Try to fix all undefined types pushed on the UNDEF_TYPES vector. */
4479 cleanup_undefined_types_noname (struct objfile *objfile)
4483 for (i = 0; i < noname_undefs_length; i++)
4485 struct nat nat = noname_undefs[i];
4488 type = dbx_lookup_type (nat.typenums, objfile);
4489 if (nat.type != *type && TYPE_CODE (*type) != TYPE_CODE_UNDEF)
4491 /* The instance flags of the undefined type are still unset,
4492 and needs to be copied over from the reference type.
4493 Since replace_type expects them to be identical, we need
4494 to set these flags manually before hand. */
4495 TYPE_INSTANCE_FLAGS (nat.type) = TYPE_INSTANCE_FLAGS (*type);
4496 replace_type (nat.type, *type);
4500 noname_undefs_length = 0;
4503 /* Go through each undefined type, see if it's still undefined, and fix it
4504 up if possible. We have two kinds of undefined types:
4506 TYPE_CODE_ARRAY: Array whose target type wasn't defined yet.
4507 Fix: update array length using the element bounds
4508 and the target type's length.
4509 TYPE_CODE_STRUCT, TYPE_CODE_UNION: Structure whose fields were not
4510 yet defined at the time a pointer to it was made.
4511 Fix: Do a full lookup on the struct/union tag. */
4514 cleanup_undefined_types_1 (void)
4518 /* Iterate over every undefined type, and look for a symbol whose type
4519 matches our undefined type. The symbol matches if:
4520 1. It is a typedef in the STRUCT domain;
4521 2. It has the same name, and same type code;
4522 3. The instance flags are identical.
4524 It is important to check the instance flags, because we have seen
4525 examples where the debug info contained definitions such as:
4527 "foo_t:t30=B31=xefoo_t:"
4529 In this case, we have created an undefined type named "foo_t" whose
4530 instance flags is null (when processing "xefoo_t"), and then created
4531 another type with the same name, but with different instance flags
4532 ('B' means volatile). I think that the definition above is wrong,
4533 since the same type cannot be volatile and non-volatile at the same
4534 time, but we need to be able to cope with it when it happens. The
4535 approach taken here is to treat these two types as different. */
4537 for (type = undef_types; type < undef_types + undef_types_length; type++)
4539 switch (TYPE_CODE (*type))
4542 case TYPE_CODE_STRUCT:
4543 case TYPE_CODE_UNION:
4544 case TYPE_CODE_ENUM:
4546 /* Check if it has been defined since. Need to do this here
4547 as well as in check_typedef to deal with the (legitimate in
4548 C though not C++) case of several types with the same name
4549 in different source files. */
4550 if (TYPE_STUB (*type))
4552 struct pending *ppt;
4554 /* Name of the type, without "struct" or "union". */
4555 const char *type_name = TYPE_TAG_NAME (*type);
4557 if (type_name == NULL)
4559 complaint (&symfile_complaints, _("need a type name"));
4562 for (ppt = file_symbols; ppt; ppt = ppt->next)
4564 for (i = 0; i < ppt->nsyms; i++)
4566 struct symbol *sym = ppt->symbol[i];
4568 if (SYMBOL_CLASS (sym) == LOC_TYPEDEF
4569 && SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
4570 && (TYPE_CODE (SYMBOL_TYPE (sym)) ==
4572 && (TYPE_INSTANCE_FLAGS (*type) ==
4573 TYPE_INSTANCE_FLAGS (SYMBOL_TYPE (sym)))
4574 && strcmp (SYMBOL_LINKAGE_NAME (sym),
4576 replace_type (*type, SYMBOL_TYPE (sym));
4585 complaint (&symfile_complaints,
4586 _("forward-referenced types left unresolved, "
4594 undef_types_length = 0;
4597 /* Try to fix all the undefined types we ecountered while processing
4601 cleanup_undefined_stabs_types (struct objfile *objfile)
4603 cleanup_undefined_types_1 ();
4604 cleanup_undefined_types_noname (objfile);
4607 /* Scan through all of the global symbols defined in the object file,
4608 assigning values to the debugging symbols that need to be assigned
4609 to. Get these symbols from the minimal symbol table. */
4612 scan_file_globals (struct objfile *objfile)
4615 struct minimal_symbol *msymbol;
4616 struct symbol *sym, *prev;
4617 struct objfile *resolve_objfile;
4619 /* SVR4 based linkers copy referenced global symbols from shared
4620 libraries to the main executable.
4621 If we are scanning the symbols for a shared library, try to resolve
4622 them from the minimal symbols of the main executable first. */
4624 if (symfile_objfile && objfile != symfile_objfile)
4625 resolve_objfile = symfile_objfile;
4627 resolve_objfile = objfile;
4631 /* Avoid expensive loop through all minimal symbols if there are
4632 no unresolved symbols. */
4633 for (hash = 0; hash < HASHSIZE; hash++)
4635 if (global_sym_chain[hash])
4638 if (hash >= HASHSIZE)
4641 ALL_OBJFILE_MSYMBOLS (resolve_objfile, msymbol)
4645 /* Skip static symbols. */
4646 switch (MSYMBOL_TYPE (msymbol))
4658 /* Get the hash index and check all the symbols
4659 under that hash index. */
4661 hash = hashname (MSYMBOL_LINKAGE_NAME (msymbol));
4663 for (sym = global_sym_chain[hash]; sym;)
4665 if (strcmp (MSYMBOL_LINKAGE_NAME (msymbol),
4666 SYMBOL_LINKAGE_NAME (sym)) == 0)
4668 /* Splice this symbol out of the hash chain and
4669 assign the value we have to it. */
4672 SYMBOL_VALUE_CHAIN (prev) = SYMBOL_VALUE_CHAIN (sym);
4676 global_sym_chain[hash] = SYMBOL_VALUE_CHAIN (sym);
4679 /* Check to see whether we need to fix up a common block. */
4680 /* Note: this code might be executed several times for
4681 the same symbol if there are multiple references. */
4684 if (SYMBOL_CLASS (sym) == LOC_BLOCK)
4686 fix_common_block (sym,
4687 MSYMBOL_VALUE_ADDRESS (resolve_objfile,
4692 SYMBOL_VALUE_ADDRESS (sym)
4693 = MSYMBOL_VALUE_ADDRESS (resolve_objfile, msymbol);
4695 SYMBOL_SECTION (sym) = MSYMBOL_SECTION (msymbol);
4700 sym = SYMBOL_VALUE_CHAIN (prev);
4704 sym = global_sym_chain[hash];
4710 sym = SYMBOL_VALUE_CHAIN (sym);
4714 if (resolve_objfile == objfile)
4716 resolve_objfile = objfile;
4719 /* Change the storage class of any remaining unresolved globals to
4720 LOC_UNRESOLVED and remove them from the chain. */
4721 for (hash = 0; hash < HASHSIZE; hash++)
4723 sym = global_sym_chain[hash];
4727 sym = SYMBOL_VALUE_CHAIN (sym);
4729 /* Change the symbol address from the misleading chain value
4731 SYMBOL_VALUE_ADDRESS (prev) = 0;
4733 /* Complain about unresolved common block symbols. */
4734 if (SYMBOL_CLASS (prev) == LOC_STATIC)
4735 SYMBOL_ACLASS_INDEX (prev) = LOC_UNRESOLVED;
4737 complaint (&symfile_complaints,
4738 _("%s: common block `%s' from "
4739 "global_sym_chain unresolved"),
4740 objfile_name (objfile), SYMBOL_PRINT_NAME (prev));
4743 memset (global_sym_chain, 0, sizeof (global_sym_chain));
4746 /* Initialize anything that needs initializing when starting to read
4747 a fresh piece of a symbol file, e.g. reading in the stuff corresponding
4751 stabsread_init (void)
4755 /* Initialize anything that needs initializing when a completely new
4756 symbol file is specified (not just adding some symbols from another
4757 file, e.g. a shared library). */
4760 stabsread_new_init (void)
4762 /* Empty the hash table of global syms looking for values. */
4763 memset (global_sym_chain, 0, sizeof (global_sym_chain));
4766 /* Initialize anything that needs initializing at the same time as
4767 start_symtab() is called. */
4772 global_stabs = NULL; /* AIX COFF */
4773 /* Leave FILENUM of 0 free for builtin types and this file's types. */
4774 n_this_object_header_files = 1;
4775 type_vector_length = 0;
4776 type_vector = (struct type **) 0;
4778 /* FIXME: If common_block_name is not already NULL, we should complain(). */
4779 common_block_name = NULL;
4782 /* Call after end_symtab(). */
4789 xfree (type_vector);
4792 type_vector_length = 0;
4793 previous_stab_code = 0;
4797 finish_global_stabs (struct objfile *objfile)
4801 patch_block_stabs (global_symbols, global_stabs, objfile);
4802 xfree (global_stabs);
4803 global_stabs = NULL;
4807 /* Find the end of the name, delimited by a ':', but don't match
4808 ObjC symbols which look like -[Foo bar::]:bla. */
4810 find_name_end (char *name)
4814 if (s[0] == '-' || *s == '+')
4816 /* Must be an ObjC method symbol. */
4819 error (_("invalid symbol name \"%s\""), name);
4821 s = strchr (s, ']');
4824 error (_("invalid symbol name \"%s\""), name);
4826 return strchr (s, ':');
4830 return strchr (s, ':');
4834 /* Initializer for this module. */
4837 _initialize_stabsread (void)
4839 rs6000_builtin_type_data = register_objfile_data ();
4841 undef_types_allocated = 20;
4842 undef_types_length = 0;
4843 undef_types = XNEWVEC (struct type *, undef_types_allocated);
4845 noname_undefs_allocated = 20;
4846 noname_undefs_length = 0;
4847 noname_undefs = XNEWVEC (struct nat, noname_undefs_allocated);
4849 stab_register_index = register_symbol_register_impl (LOC_REGISTER,
4850 &stab_register_funcs);
4851 stab_regparm_index = register_symbol_register_impl (LOC_REGPARM_ADDR,
4852 &stab_register_funcs);