1 /* Support routines for decoding "stabs" debugging information format.
3 Copyright (C) 1986-2023 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 by some systems that use
22 COFF or ELF where the stabs data is placed in a special section (as
23 well as with many old systems that used the a.out object file
24 format). Avoid placing any object file format specific code in
29 #include "gdbsupport/gdb_obstack.h"
32 #include "expression.h"
35 #include "aout/stab_gnu.h" /* We always use GNU stabs, not native. */
37 #include "aout/aout64.h"
38 #include "gdb-stabs.h"
39 #include "buildsym-legacy.h"
40 #include "complaints.h"
42 #include "gdb-demangle.h"
44 #include "target-float.h"
47 #include "cp-support.h"
50 #include "stabsread.h"
52 /* See stabsread.h for these globals. */
54 const char *(*next_symbol_text_func
) (struct objfile
*);
55 unsigned char processing_gcc_compilation
;
57 struct symbol
*global_sym_chain
[HASHSIZE
];
58 struct pending_stabs
*global_stabs
;
59 int previous_stab_code
;
60 int *this_object_header_files
;
61 int n_this_object_header_files
;
62 int n_allocated_this_object_header_files
;
64 struct stabs_nextfield
66 struct stabs_nextfield
*next
;
68 /* This is the raw visibility from the stab. It is not checked
69 for being one of the visibilities we recognize, so code which
70 examines this field better be able to deal. */
76 struct next_fnfieldlist
78 struct next_fnfieldlist
*next
;
79 struct fn_fieldlist fn_fieldlist
;
82 /* The routines that read and process a complete stabs for a C struct or
83 C++ class pass lists of data member fields and lists of member function
84 fields in an instance of a field_info structure, as defined below.
85 This is part of some reorganization of low level C++ support and is
86 expected to eventually go away... (FIXME) */
88 struct stab_field_info
90 struct stabs_nextfield
*list
= nullptr;
91 struct next_fnfieldlist
*fnlist
= nullptr;
97 read_one_struct_field (struct stab_field_info
*, const char **, const char *,
98 struct type
*, struct objfile
*);
100 static struct type
*dbx_alloc_type (int[2], struct objfile
*);
102 static long read_huge_number (const char **, int, int *, int);
104 static struct type
*error_type (const char **, struct objfile
*);
107 patch_block_stabs (struct pending
*, struct pending_stabs
*,
110 static int read_type_number (const char **, int *);
112 static struct type
*read_type (const char **, struct objfile
*);
114 static struct type
*read_range_type (const char **, int[2],
115 int, struct objfile
*);
117 static struct type
*read_sun_builtin_type (const char **,
118 int[2], struct objfile
*);
120 static struct type
*read_sun_floating_type (const char **, int[2],
123 static struct type
*read_enum_type (const char **, struct type
*, struct objfile
*);
125 static struct type
*rs6000_builtin_type (int, struct objfile
*);
128 read_member_functions (struct stab_field_info
*, const char **, struct type
*,
132 read_struct_fields (struct stab_field_info
*, const char **, struct type
*,
136 read_baseclasses (struct stab_field_info
*, const char **, struct type
*,
140 read_tilde_fields (struct stab_field_info
*, const char **, struct type
*,
143 static int attach_fn_fields_to_type (struct stab_field_info
*, struct type
*);
145 static int attach_fields_to_type (struct stab_field_info
*, struct type
*,
148 static struct type
*read_struct_type (const char **, struct type
*,
152 static struct type
*read_array_type (const char **, struct type
*,
155 static struct field
*read_args (const char **, int, struct objfile
*,
158 static void add_undefined_type (struct type
*, int[2]);
161 read_cpp_abbrev (struct stab_field_info
*, const char **, struct type
*,
164 static const char *find_name_end (const char *name
);
166 static int process_reference (const char **string
);
168 void stabsread_clear_cache (void);
170 static const char vptr_name
[] = "_vptr$";
171 static const char vb_name
[] = "_vb$";
174 invalid_cpp_abbrev_complaint (const char *arg1
)
176 complaint (_("invalid C++ abbreviation `%s'"), arg1
);
180 reg_value_complaint (int regnum
, int num_regs
, const char *sym
)
182 complaint (_("bad register number %d (max %d) in symbol %s"),
183 regnum
, num_regs
- 1, sym
);
187 stabs_general_complaint (const char *arg1
)
189 complaint ("%s", arg1
);
192 /* Make a list of forward references which haven't been defined. */
194 static struct type
**undef_types
;
195 static int undef_types_allocated
;
196 static int undef_types_length
;
197 static struct symbol
*current_symbol
= NULL
;
199 /* Make a list of nameless types that are undefined.
200 This happens when another type is referenced by its number
201 before this type is actually defined. For instance "t(0,1)=k(0,2)"
202 and type (0,2) is defined only later. */
209 static struct nat
*noname_undefs
;
210 static int noname_undefs_allocated
;
211 static int noname_undefs_length
;
213 /* Check for and handle cretinous stabs symbol name continuation! */
214 #define STABS_CONTINUE(pp,objfile) \
216 if (**(pp) == '\\' || (**(pp) == '?' && (*(pp))[1] == '\0')) \
217 *(pp) = next_symbol_text (objfile); \
220 /* Vector of types defined so far, indexed by their type numbers.
221 (In newer sun systems, dbx uses a pair of numbers in parens,
222 as in "(SUBFILENUM,NUMWITHINSUBFILE)".
223 Then these numbers must be translated through the type_translations
224 hash table to get the index into the type vector.) */
226 static struct type
**type_vector
;
228 /* Number of elements allocated for type_vector currently. */
230 static int type_vector_length
;
232 /* Initial size of type vector. Is realloc'd larger if needed, and
233 realloc'd down to the size actually used, when completed. */
235 #define INITIAL_TYPE_VECTOR_LENGTH 160
238 /* Look up a dbx type-number pair. Return the address of the slot
239 where the type for that number-pair is stored.
240 The number-pair is in TYPENUMS.
242 This can be used for finding the type associated with that pair
243 or for associating a new type with the pair. */
245 static struct type
**
246 dbx_lookup_type (int typenums
[2], struct objfile
*objfile
)
248 int filenum
= typenums
[0];
249 int index
= typenums
[1];
252 struct header_file
*f
;
255 if (filenum
== -1) /* -1,-1 is for temporary types. */
258 if (filenum
< 0 || filenum
>= n_this_object_header_files
)
260 complaint (_("Invalid symbol data: type number "
261 "(%d,%d) out of range at symtab pos %d."),
262 filenum
, index
, symnum
);
270 /* Caller wants address of address of type. We think
271 that negative (rs6k builtin) types will never appear as
272 "lvalues", (nor should they), so we stuff the real type
273 pointer into a temp, and return its address. If referenced,
274 this will do the right thing. */
275 static struct type
*temp_type
;
277 temp_type
= rs6000_builtin_type (index
, objfile
);
281 /* Type is defined outside of header files.
282 Find it in this object file's type vector. */
283 if (index
>= type_vector_length
)
285 old_len
= type_vector_length
;
288 type_vector_length
= INITIAL_TYPE_VECTOR_LENGTH
;
289 type_vector
= XNEWVEC (struct type
*, type_vector_length
);
291 while (index
>= type_vector_length
)
293 type_vector_length
*= 2;
295 type_vector
= (struct type
**)
296 xrealloc ((char *) type_vector
,
297 (type_vector_length
* sizeof (struct type
*)));
298 memset (&type_vector
[old_len
], 0,
299 (type_vector_length
- old_len
) * sizeof (struct type
*));
301 return (&type_vector
[index
]);
305 real_filenum
= this_object_header_files
[filenum
];
307 if (real_filenum
>= N_HEADER_FILES (objfile
))
309 static struct type
*temp_type
;
311 warning (_("GDB internal error: bad real_filenum"));
314 temp_type
= objfile_type (objfile
)->builtin_error
;
318 f
= HEADER_FILES (objfile
) + real_filenum
;
320 f_orig_length
= f
->length
;
321 if (index
>= f_orig_length
)
323 while (index
>= f
->length
)
327 f
->vector
= (struct type
**)
328 xrealloc ((char *) f
->vector
, f
->length
* sizeof (struct type
*));
329 memset (&f
->vector
[f_orig_length
], 0,
330 (f
->length
- f_orig_length
) * sizeof (struct type
*));
332 return (&f
->vector
[index
]);
336 /* Make sure there is a type allocated for type numbers TYPENUMS
337 and return the type object.
338 This can create an empty (zeroed) type object.
339 TYPENUMS may be (-1, -1) to return a new type object that is not
340 put into the type vector, and so may not be referred to by number. */
343 dbx_alloc_type (int typenums
[2], struct objfile
*objfile
)
345 struct type
**type_addr
;
347 if (typenums
[0] == -1)
349 return type_allocator (objfile
).new_type ();
352 type_addr
= dbx_lookup_type (typenums
, objfile
);
354 /* If we are referring to a type not known at all yet,
355 allocate an empty type for it.
356 We will fill it in later if we find out how. */
359 *type_addr
= type_allocator (objfile
).new_type ();
365 /* Allocate a floating-point type of size BITS. */
368 dbx_init_float_type (struct objfile
*objfile
, int bits
)
370 struct gdbarch
*gdbarch
= objfile
->arch ();
371 const struct floatformat
**format
;
374 format
= gdbarch_floatformat_for_type (gdbarch
, NULL
, bits
);
375 type_allocator
alloc (objfile
);
377 type
= init_float_type (alloc
, bits
, NULL
, format
);
379 type
= alloc
.new_type (TYPE_CODE_ERROR
, bits
, NULL
);
384 /* for all the stabs in a given stab vector, build appropriate types
385 and fix their symbols in given symbol vector. */
388 patch_block_stabs (struct pending
*symbols
, struct pending_stabs
*stabs
,
389 struct objfile
*objfile
)
398 /* for all the stab entries, find their corresponding symbols and
399 patch their types! */
401 for (ii
= 0; ii
< stabs
->count
; ++ii
)
403 name
= stabs
->stab
[ii
];
404 pp
= (char *) strchr (name
, ':');
405 gdb_assert (pp
); /* Must find a ':' or game's over. */
409 pp
= (char *) strchr (pp
, ':');
411 sym
= find_symbol_in_list (symbols
, name
, pp
- name
);
414 /* FIXME-maybe: it would be nice if we noticed whether
415 the variable was defined *anywhere*, not just whether
416 it is defined in this compilation unit. But neither
417 xlc or GCC seem to need such a definition, and until
418 we do psymtabs (so that the minimal symbols from all
419 compilation units are available now), I'm not sure
420 how to get the information. */
422 /* On xcoff, if a global is defined and never referenced,
423 ld will remove it from the executable. There is then
424 a N_GSYM stab for it, but no regular (C_EXT) symbol. */
425 sym
= new (&objfile
->objfile_obstack
) symbol
;
426 sym
->set_domain (VAR_DOMAIN
);
427 sym
->set_aclass_index (LOC_OPTIMIZED_OUT
);
428 sym
->set_linkage_name
429 (obstack_strndup (&objfile
->objfile_obstack
, name
, pp
- name
));
431 if (*(pp
- 1) == 'F' || *(pp
- 1) == 'f')
433 /* I don't think the linker does this with functions,
434 so as far as I know this is never executed.
435 But it doesn't hurt to check. */
437 (lookup_function_type (read_type (&pp
, objfile
)));
441 sym
->set_type (read_type (&pp
, objfile
));
443 add_symbol_to_list (sym
, get_global_symbols ());
448 if (*(pp
- 1) == 'F' || *(pp
- 1) == 'f')
451 (lookup_function_type (read_type (&pp
, objfile
)));
455 sym
->set_type (read_type (&pp
, objfile
));
463 /* Read a number by which a type is referred to in dbx data,
464 or perhaps read a pair (FILENUM, TYPENUM) in parentheses.
465 Just a single number N is equivalent to (0,N).
466 Return the two numbers by storing them in the vector TYPENUMS.
467 TYPENUMS will then be used as an argument to dbx_lookup_type.
469 Returns 0 for success, -1 for error. */
472 read_type_number (const char **pp
, int *typenums
)
479 typenums
[0] = read_huge_number (pp
, ',', &nbits
, 0);
482 typenums
[1] = read_huge_number (pp
, ')', &nbits
, 0);
489 typenums
[1] = read_huge_number (pp
, 0, &nbits
, 0);
497 #define VISIBILITY_PRIVATE '0' /* Stabs character for private field */
498 #define VISIBILITY_PROTECTED '1' /* Stabs character for protected fld */
499 #define VISIBILITY_PUBLIC '2' /* Stabs character for public field */
500 #define VISIBILITY_IGNORE '9' /* Optimized out or zero length */
502 /* Structure for storing pointers to reference definitions for fast lookup
503 during "process_later". */
512 #define MAX_CHUNK_REFS 100
513 #define REF_CHUNK_SIZE (MAX_CHUNK_REFS * sizeof (struct ref_map))
514 #define REF_MAP_SIZE(ref_chunk) ((ref_chunk) * REF_CHUNK_SIZE)
516 static struct ref_map
*ref_map
;
518 /* Ptr to free cell in chunk's linked list. */
519 static int ref_count
= 0;
521 /* Number of chunks malloced. */
522 static int ref_chunk
= 0;
524 /* This file maintains a cache of stabs aliases found in the symbol
525 table. If the symbol table changes, this cache must be cleared
526 or we are left holding onto data in invalid obstacks. */
528 stabsread_clear_cache (void)
534 /* Create array of pointers mapping refids to symbols and stab strings.
535 Add pointers to reference definition symbols and/or their values as we
536 find them, using their reference numbers as our index.
537 These will be used later when we resolve references. */
539 ref_add (int refnum
, struct symbol
*sym
, const char *stabs
, CORE_ADDR value
)
543 if (refnum
>= ref_count
)
544 ref_count
= refnum
+ 1;
545 if (ref_count
> ref_chunk
* MAX_CHUNK_REFS
)
547 int new_slots
= ref_count
- ref_chunk
* MAX_CHUNK_REFS
;
548 int new_chunks
= new_slots
/ MAX_CHUNK_REFS
+ 1;
550 ref_map
= (struct ref_map
*)
551 xrealloc (ref_map
, REF_MAP_SIZE (ref_chunk
+ new_chunks
));
552 memset (ref_map
+ ref_chunk
* MAX_CHUNK_REFS
, 0,
553 new_chunks
* REF_CHUNK_SIZE
);
554 ref_chunk
+= new_chunks
;
556 ref_map
[refnum
].stabs
= stabs
;
557 ref_map
[refnum
].sym
= sym
;
558 ref_map
[refnum
].value
= value
;
561 /* Return defined sym for the reference REFNUM. */
563 ref_search (int refnum
)
565 if (refnum
< 0 || refnum
> ref_count
)
567 return ref_map
[refnum
].sym
;
570 /* Parse a reference id in STRING and return the resulting
571 reference number. Move STRING beyond the reference id. */
574 process_reference (const char **string
)
582 /* Advance beyond the initial '#'. */
585 /* Read number as reference id. */
586 while (*p
&& isdigit (*p
))
588 refnum
= refnum
* 10 + *p
- '0';
595 /* If STRING defines a reference, store away a pointer to the reference
596 definition for later use. Return the reference number. */
599 symbol_reference_defined (const char **string
)
601 const char *p
= *string
;
604 refnum
= process_reference (&p
);
606 /* Defining symbols end in '='. */
609 /* Symbol is being defined here. */
615 /* Must be a reference. Either the symbol has already been defined,
616 or this is a forward reference to it. */
623 stab_reg_to_regnum (struct symbol
*sym
, struct gdbarch
*gdbarch
)
625 int regno
= gdbarch_stab_reg_to_regnum (gdbarch
, sym
->value_longest ());
627 if (regno
< 0 || regno
>= gdbarch_num_cooked_regs (gdbarch
))
629 reg_value_complaint (regno
, gdbarch_num_cooked_regs (gdbarch
),
632 regno
= gdbarch_sp_regnum (gdbarch
); /* Known safe, though useless. */
638 static const struct symbol_register_ops stab_register_funcs
= {
642 /* The "aclass" indices for computed symbols. */
644 static int stab_register_index
;
645 static int stab_regparm_index
;
648 define_symbol (CORE_ADDR valu
, const char *string
, int desc
, int type
,
649 struct objfile
*objfile
)
651 struct gdbarch
*gdbarch
= objfile
->arch ();
653 const char *p
= find_name_end (string
);
658 /* We would like to eliminate nameless symbols, but keep their types.
659 E.g. stab entry ":t10=*2" should produce a type 10, which is a pointer
660 to type 2, but, should not create a symbol to address that type. Since
661 the symbol will be nameless, there is no way any user can refer to it. */
665 /* Ignore syms with empty names. */
669 /* Ignore old-style symbols from cc -go. */
680 _("Bad stabs string '%s'"), string
);
685 /* If a nameless stab entry, all we need is the type, not the symbol.
686 e.g. ":t10=*2" or a nameless enum like " :T16=ered:0,green:1,blue:2,;" */
687 nameless
= (p
== string
|| ((string
[0] == ' ') && (string
[1] == ':')));
689 current_symbol
= sym
= new (&objfile
->objfile_obstack
) symbol
;
691 if (processing_gcc_compilation
)
693 /* GCC 2.x puts the line number in desc. SunOS apparently puts in the
694 number of bytes occupied by a type or object, which we ignore. */
695 sym
->set_line (desc
);
699 sym
->set_line (0); /* unknown */
702 sym
->set_language (get_current_subfile ()->language
,
703 &objfile
->objfile_obstack
);
705 if (is_cplus_marker (string
[0]))
707 /* Special GNU C++ names. */
711 sym
->set_linkage_name ("this");
714 case 'v': /* $vtbl_ptr_type */
718 sym
->set_linkage_name ("eh_throw");
722 /* This was an anonymous type that was never fixed up. */
726 complaint (_("Unknown C++ symbol name `%s'"),
728 goto normal
; /* Do *something* with it. */
734 gdb::unique_xmalloc_ptr
<char> new_name
;
736 if (sym
->language () == language_cplus
)
738 std::string
name (string
, p
- string
);
739 new_name
= cp_canonicalize_string (name
.c_str ());
741 else if (sym
->language () == language_c
)
743 std::string
name (string
, p
- string
);
744 new_name
= c_canonicalize_name (name
.c_str ());
746 if (new_name
!= nullptr)
747 sym
->compute_and_set_names (new_name
.get (), true, objfile
->per_bfd
);
749 sym
->compute_and_set_names (gdb::string_view (string
, p
- string
), true,
752 if (sym
->language () == language_cplus
)
753 cp_scan_for_anonymous_namespaces (get_buildsym_compunit (), sym
,
759 /* Determine the type of name being defined. */
761 /* Getting GDB to correctly skip the symbol on an undefined symbol
762 descriptor and not ever dump core is a very dodgy proposition if
763 we do things this way. I say the acorn RISC machine can just
764 fix their compiler. */
765 /* The Acorn RISC machine's compiler can put out locals that don't
766 start with "234=" or "(3,4)=", so assume anything other than the
767 deftypes we know how to handle is a local. */
768 if (!strchr ("cfFGpPrStTvVXCR", *p
))
770 if (isdigit (*p
) || *p
== '(' || *p
== '-')
779 /* c is a special case, not followed by a type-number.
780 SYMBOL:c=iVALUE for an integer constant symbol.
781 SYMBOL:c=rVALUE for a floating constant symbol.
782 SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
783 e.g. "b:c=e6,0" for "const b = blob1"
784 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
787 sym
->set_aclass_index (LOC_CONST
);
788 sym
->set_type (error_type (&p
, objfile
));
789 sym
->set_domain (VAR_DOMAIN
);
790 add_symbol_to_list (sym
, get_file_symbols ());
799 struct type
*dbl_type
;
801 dbl_type
= objfile_type (objfile
)->builtin_double
;
803 = (gdb_byte
*) obstack_alloc (&objfile
->objfile_obstack
,
804 dbl_type
->length ());
806 target_float_from_string (dbl_valu
, dbl_type
, std::string (p
));
808 sym
->set_type (dbl_type
);
809 sym
->set_value_bytes (dbl_valu
);
810 sym
->set_aclass_index (LOC_CONST_BYTES
);
815 /* Defining integer constants this way is kind of silly,
816 since 'e' constants allows the compiler to give not
817 only the value, but the type as well. C has at least
818 int, long, unsigned int, and long long as constant
819 types; other languages probably should have at least
820 unsigned as well as signed constants. */
822 sym
->set_type (objfile_type (objfile
)->builtin_long
);
823 sym
->set_value_longest (atoi (p
));
824 sym
->set_aclass_index (LOC_CONST
);
830 sym
->set_type (objfile_type (objfile
)->builtin_char
);
831 sym
->set_value_longest (atoi (p
));
832 sym
->set_aclass_index (LOC_CONST
);
838 struct type
*range_type
;
841 gdb_byte
*string_local
= (gdb_byte
*) alloca (strlen (p
));
842 gdb_byte
*string_value
;
844 if (quote
!= '\'' && quote
!= '"')
846 sym
->set_aclass_index (LOC_CONST
);
847 sym
->set_type (error_type (&p
, objfile
));
848 sym
->set_domain (VAR_DOMAIN
);
849 add_symbol_to_list (sym
, get_file_symbols ());
853 /* Find matching quote, rejecting escaped quotes. */
854 while (*p
&& *p
!= quote
)
856 if (*p
== '\\' && p
[1] == quote
)
858 string_local
[ind
] = (gdb_byte
) quote
;
864 string_local
[ind
] = (gdb_byte
) (*p
);
871 sym
->set_aclass_index (LOC_CONST
);
872 sym
->set_type (error_type (&p
, objfile
));
873 sym
->set_domain (VAR_DOMAIN
);
874 add_symbol_to_list (sym
, get_file_symbols ());
878 /* NULL terminate the string. */
879 string_local
[ind
] = 0;
881 = create_static_range_type (NULL
,
882 objfile_type (objfile
)->builtin_int
,
885 (create_array_type (NULL
, objfile_type (objfile
)->builtin_char
,
888 = (gdb_byte
*) obstack_alloc (&objfile
->objfile_obstack
, ind
+ 1);
889 memcpy (string_value
, string_local
, ind
+ 1);
892 sym
->set_value_bytes (string_value
);
893 sym
->set_aclass_index (LOC_CONST_BYTES
);
898 /* SYMBOL:c=eTYPE,INTVALUE for a constant symbol whose value
899 can be represented as integral.
900 e.g. "b:c=e6,0" for "const b = blob1"
901 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
903 sym
->set_aclass_index (LOC_CONST
);
904 sym
->set_type (read_type (&p
, objfile
));
908 sym
->set_type (error_type (&p
, objfile
));
913 /* If the value is too big to fit in an int (perhaps because
914 it is unsigned), or something like that, we silently get
915 a bogus value. The type and everything else about it is
916 correct. Ideally, we should be using whatever we have
917 available for parsing unsigned and long long values,
919 sym
->set_value_longest (atoi (p
));
924 sym
->set_aclass_index (LOC_CONST
);
925 sym
->set_type (error_type (&p
, objfile
));
928 sym
->set_domain (VAR_DOMAIN
);
929 add_symbol_to_list (sym
, get_file_symbols ());
933 /* The name of a caught exception. */
934 sym
->set_type (read_type (&p
, objfile
));
935 sym
->set_aclass_index (LOC_LABEL
);
936 sym
->set_domain (VAR_DOMAIN
);
937 sym
->set_value_address (valu
);
938 add_symbol_to_list (sym
, get_local_symbols ());
942 /* A static function definition. */
943 sym
->set_type (read_type (&p
, objfile
));
944 sym
->set_aclass_index (LOC_BLOCK
);
945 sym
->set_domain (VAR_DOMAIN
);
946 add_symbol_to_list (sym
, get_file_symbols ());
947 /* fall into process_function_types. */
949 process_function_types
:
950 /* Function result types are described as the result type in stabs.
951 We need to convert this to the function-returning-type-X type
952 in GDB. E.g. "int" is converted to "function returning int". */
953 if (sym
->type ()->code () != TYPE_CODE_FUNC
)
954 sym
->set_type (lookup_function_type (sym
->type ()));
956 /* All functions in C++ have prototypes. Stabs does not offer an
957 explicit way to identify prototyped or unprototyped functions,
958 but both GCC and Sun CC emit stabs for the "call-as" type rather
959 than the "declared-as" type for unprototyped functions, so
960 we treat all functions as if they were prototyped. This is used
961 primarily for promotion when calling the function from GDB. */
962 sym
->type ()->set_is_prototyped (true);
964 /* fall into process_prototype_types. */
966 process_prototype_types
:
967 /* Sun acc puts declared types of arguments here. */
970 struct type
*ftype
= sym
->type ();
975 /* Obtain a worst case guess for the number of arguments
976 by counting the semicolons. */
983 /* Allocate parameter information fields and fill them in. */
986 TYPE_ALLOC (ftype
, nsemi
* sizeof (struct field
)));
991 /* A type number of zero indicates the start of varargs.
992 FIXME: GDB currently ignores vararg functions. */
993 if (p
[0] == '0' && p
[1] == '\0')
995 ptype
= read_type (&p
, objfile
);
997 /* The Sun compilers mark integer arguments, which should
998 be promoted to the width of the calling conventions, with
999 a type which references itself. This type is turned into
1000 a TYPE_CODE_VOID type by read_type, and we have to turn
1001 it back into builtin_int here.
1002 FIXME: Do we need a new builtin_promoted_int_arg ? */
1003 if (ptype
->code () == TYPE_CODE_VOID
)
1004 ptype
= objfile_type (objfile
)->builtin_int
;
1005 ftype
->field (nparams
).set_type (ptype
);
1006 TYPE_FIELD_ARTIFICIAL (ftype
, nparams
++) = 0;
1008 ftype
->set_num_fields (nparams
);
1009 ftype
->set_is_prototyped (true);
1014 /* A global function definition. */
1015 sym
->set_type (read_type (&p
, objfile
));
1016 sym
->set_aclass_index (LOC_BLOCK
);
1017 sym
->set_domain (VAR_DOMAIN
);
1018 add_symbol_to_list (sym
, get_global_symbols ());
1019 goto process_function_types
;
1022 /* For a class G (global) symbol, it appears that the
1023 value is not correct. It is necessary to search for the
1024 corresponding linker definition to find the value.
1025 These definitions appear at the end of the namelist. */
1026 sym
->set_type (read_type (&p
, objfile
));
1027 sym
->set_aclass_index (LOC_STATIC
);
1028 sym
->set_domain (VAR_DOMAIN
);
1029 /* Don't add symbol references to global_sym_chain.
1030 Symbol references don't have valid names and wont't match up with
1031 minimal symbols when the global_sym_chain is relocated.
1032 We'll fixup symbol references when we fixup the defining symbol. */
1033 if (sym
->linkage_name () && sym
->linkage_name ()[0] != '#')
1035 i
= hashname (sym
->linkage_name ());
1036 sym
->set_value_chain (global_sym_chain
[i
]);
1037 global_sym_chain
[i
] = sym
;
1039 add_symbol_to_list (sym
, get_global_symbols ());
1042 /* This case is faked by a conditional above,
1043 when there is no code letter in the dbx data.
1044 Dbx data never actually contains 'l'. */
1047 sym
->set_type (read_type (&p
, objfile
));
1048 sym
->set_aclass_index (LOC_LOCAL
);
1049 sym
->set_value_longest (valu
);
1050 sym
->set_domain (VAR_DOMAIN
);
1051 add_symbol_to_list (sym
, get_local_symbols ());
1056 /* pF is a two-letter code that means a function parameter in Fortran.
1057 The type-number specifies the type of the return value.
1058 Translate it into a pointer-to-function type. */
1062 (lookup_pointer_type
1063 (lookup_function_type (read_type (&p
, objfile
))));
1066 sym
->set_type (read_type (&p
, objfile
));
1068 sym
->set_aclass_index (LOC_ARG
);
1069 sym
->set_value_longest (valu
);
1070 sym
->set_domain (VAR_DOMAIN
);
1071 sym
->set_is_argument (1);
1072 add_symbol_to_list (sym
, get_local_symbols ());
1074 if (gdbarch_byte_order (gdbarch
) != BFD_ENDIAN_BIG
)
1076 /* On little-endian machines, this crud is never necessary,
1077 and, if the extra bytes contain garbage, is harmful. */
1081 /* If it's gcc-compiled, if it says `short', believe it. */
1082 if (processing_gcc_compilation
1083 || gdbarch_believe_pcc_promotion (gdbarch
))
1086 if (!gdbarch_believe_pcc_promotion (gdbarch
))
1088 /* If PCC says a parameter is a short or a char, it is
1090 if (sym
->type ()->length ()
1091 < gdbarch_int_bit (gdbarch
) / TARGET_CHAR_BIT
1092 && sym
->type ()->code () == TYPE_CODE_INT
)
1095 (sym
->type ()->is_unsigned ()
1096 ? objfile_type (objfile
)->builtin_unsigned_int
1097 : objfile_type (objfile
)->builtin_int
);
1104 /* acc seems to use P to declare the prototypes of functions that
1105 are referenced by this file. gdb is not prepared to deal
1106 with this extra information. FIXME, it ought to. */
1109 sym
->set_type (read_type (&p
, objfile
));
1110 goto process_prototype_types
;
1115 /* Parameter which is in a register. */
1116 sym
->set_type (read_type (&p
, objfile
));
1117 sym
->set_aclass_index (stab_register_index
);
1118 sym
->set_is_argument (1);
1119 sym
->set_value_longest (valu
);
1120 sym
->set_domain (VAR_DOMAIN
);
1121 add_symbol_to_list (sym
, get_local_symbols ());
1125 /* Register variable (either global or local). */
1126 sym
->set_type (read_type (&p
, objfile
));
1127 sym
->set_aclass_index (stab_register_index
);
1128 sym
->set_value_longest (valu
);
1129 sym
->set_domain (VAR_DOMAIN
);
1130 if (within_function
)
1132 /* Sun cc uses a pair of symbols, one 'p' and one 'r', with
1133 the same name to represent an argument passed in a
1134 register. GCC uses 'P' for the same case. So if we find
1135 such a symbol pair we combine it into one 'P' symbol.
1136 For Sun cc we need to do this regardless of stabs_argument_has_addr, because the compiler puts out
1137 the 'p' symbol even if it never saves the argument onto
1140 On most machines, we want to preserve both symbols, so
1141 that we can still get information about what is going on
1142 with the stack (VAX for computing args_printed, using
1143 stack slots instead of saved registers in backtraces,
1146 Note that this code illegally combines
1147 main(argc) struct foo argc; { register struct foo argc; }
1148 but this case is considered pathological and causes a warning
1149 from a decent compiler. */
1151 struct pending
*local_symbols
= *get_local_symbols ();
1153 && local_symbols
->nsyms
> 0
1154 && gdbarch_stabs_argument_has_addr (gdbarch
, sym
->type ()))
1156 struct symbol
*prev_sym
;
1158 prev_sym
= local_symbols
->symbol
[local_symbols
->nsyms
- 1];
1159 if ((prev_sym
->aclass () == LOC_REF_ARG
1160 || prev_sym
->aclass () == LOC_ARG
)
1161 && strcmp (prev_sym
->linkage_name (),
1162 sym
->linkage_name ()) == 0)
1164 prev_sym
->set_aclass_index (stab_register_index
);
1165 /* Use the type from the LOC_REGISTER; that is the type
1166 that is actually in that register. */
1167 prev_sym
->set_type (sym
->type ());
1168 prev_sym
->set_value_longest (sym
->value_longest ());
1173 add_symbol_to_list (sym
, get_local_symbols ());
1176 add_symbol_to_list (sym
, get_file_symbols ());
1180 /* Static symbol at top level of file. */
1181 sym
->set_type (read_type (&p
, objfile
));
1182 sym
->set_aclass_index (LOC_STATIC
);
1183 sym
->set_value_address (valu
);
1184 sym
->set_domain (VAR_DOMAIN
);
1185 add_symbol_to_list (sym
, get_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
= (sym
->language () == language_ada
&& p
[-2] != 'T');
1206 sym
->set_type (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 sym
->set_aclass_index (LOC_TYPEDEF
);
1214 sym
->set_value_longest (valu
);
1215 sym
->set_domain (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 (sym
->type ()->name () != NULL
)
1221 if ((sym
->type ()->code () == TYPE_CODE_STRUCT
1222 || sym
->type ()->code () == TYPE_CODE_UNION
)
1223 && TYPE_N_BASECLASSES (sym
->type ()))
1227 for (j
= TYPE_N_BASECLASSES (sym
->type ()) - 1; j
>= 0; j
--)
1228 if (TYPE_BASECLASS_NAME (sym
->type (), j
) == 0)
1229 sym
->type ()->field (j
).set_name
1230 (TYPE_BASECLASS (sym
->type (), j
)->name ());
1233 if (sym
->type ()->name () == NULL
)
1235 if ((sym
->type ()->code () == TYPE_CODE_PTR
1236 && strcmp (sym
->linkage_name (), vtbl_ptr_name
))
1237 || sym
->type ()->code () == TYPE_CODE_FUNC
)
1239 /* If we are giving a name to a type such as "pointer to
1240 foo" or "function returning foo", we better not set
1241 the TYPE_NAME. If the program contains "typedef char
1242 *caddr_t;", we don't want all variables of type char
1243 * to print as caddr_t. This is not just a
1244 consequence of GDB's type management; PCC and GCC (at
1245 least through version 2.4) both output variables of
1246 either type char * or caddr_t with the type number
1247 defined in the 't' symbol for caddr_t. If a future
1248 compiler cleans this up it GDB is not ready for it
1249 yet, but if it becomes ready we somehow need to
1250 disable this check (without breaking the PCC/GCC2.4
1255 Fortunately, this check seems not to be necessary
1256 for anything except pointers or functions. */
1257 /* ezannoni: 2000-10-26. This seems to apply for
1258 versions of gcc older than 2.8. This was the original
1259 problem: with the following code gdb would tell that
1260 the type for name1 is caddr_t, and func is char().
1262 typedef char *caddr_t;
1274 /* Pascal accepts names for pointer types. */
1275 if (get_current_subfile ()->language
== language_pascal
)
1276 sym
->type ()->set_name (sym
->linkage_name ());
1279 sym
->type ()->set_name (sym
->linkage_name ());
1282 add_symbol_to_list (sym
, get_file_symbols ());
1286 /* Create the STRUCT_DOMAIN clone. */
1287 struct symbol
*struct_sym
= new (&objfile
->objfile_obstack
) symbol
;
1290 struct_sym
->set_aclass_index (LOC_TYPEDEF
);
1291 struct_sym
->set_value_longest (valu
);
1292 struct_sym
->set_domain (STRUCT_DOMAIN
);
1293 if (sym
->type ()->name () == 0)
1294 sym
->type ()->set_name
1295 (obconcat (&objfile
->objfile_obstack
, sym
->linkage_name (),
1297 add_symbol_to_list (struct_sym
, get_file_symbols ());
1303 /* Struct, union, or enum tag. For GNU C++, this can be be followed
1304 by 't' which means we are typedef'ing it as well. */
1305 synonym
= *p
== 't';
1310 sym
->set_type (read_type (&p
, objfile
));
1312 /* For a nameless type, we don't want a create a symbol, thus we
1313 did not use `sym'. Return without further processing. */
1317 sym
->set_aclass_index (LOC_TYPEDEF
);
1318 sym
->set_value_longest (valu
);
1319 sym
->set_domain (STRUCT_DOMAIN
);
1320 if (sym
->type ()->name () == 0)
1321 sym
->type ()->set_name
1322 (obconcat (&objfile
->objfile_obstack
, sym
->linkage_name (),
1324 add_symbol_to_list (sym
, get_file_symbols ());
1328 /* Clone the sym and then modify it. */
1329 struct symbol
*typedef_sym
= new (&objfile
->objfile_obstack
) symbol
;
1331 *typedef_sym
= *sym
;
1332 typedef_sym
->set_aclass_index (LOC_TYPEDEF
);
1333 typedef_sym
->set_value_longest (valu
);
1334 typedef_sym
->set_domain (VAR_DOMAIN
);
1335 if (sym
->type ()->name () == 0)
1336 sym
->type ()->set_name
1337 (obconcat (&objfile
->objfile_obstack
, sym
->linkage_name (),
1339 add_symbol_to_list (typedef_sym
, get_file_symbols ());
1344 /* Static symbol of local scope. */
1345 sym
->set_type (read_type (&p
, objfile
));
1346 sym
->set_aclass_index (LOC_STATIC
);
1347 sym
->set_value_address (valu
);
1348 sym
->set_domain (VAR_DOMAIN
);
1349 add_symbol_to_list (sym
, get_local_symbols ());
1353 /* Reference parameter */
1354 sym
->set_type (read_type (&p
, objfile
));
1355 sym
->set_aclass_index (LOC_REF_ARG
);
1356 sym
->set_is_argument (1);
1357 sym
->set_value_longest (valu
);
1358 sym
->set_domain (VAR_DOMAIN
);
1359 add_symbol_to_list (sym
, get_local_symbols ());
1363 /* Reference parameter which is in a register. */
1364 sym
->set_type (read_type (&p
, objfile
));
1365 sym
->set_aclass_index (stab_regparm_index
);
1366 sym
->set_is_argument (1);
1367 sym
->set_value_longest (valu
);
1368 sym
->set_domain (VAR_DOMAIN
);
1369 add_symbol_to_list (sym
, get_local_symbols ());
1373 /* This is used by Sun FORTRAN for "function result value".
1374 Sun claims ("dbx and dbxtool interfaces", 2nd ed)
1375 that Pascal uses it too, but when I tried it Pascal used
1376 "x:3" (local symbol) instead. */
1377 sym
->set_type (read_type (&p
, objfile
));
1378 sym
->set_aclass_index (LOC_LOCAL
);
1379 sym
->set_value_longest (valu
);
1380 sym
->set_domain (VAR_DOMAIN
);
1381 add_symbol_to_list (sym
, get_local_symbols ());
1385 sym
->set_type (error_type (&p
, objfile
));
1386 sym
->set_aclass_index (LOC_CONST
);
1387 sym
->set_value_longest (0);
1388 sym
->set_domain (VAR_DOMAIN
);
1389 add_symbol_to_list (sym
, get_file_symbols ());
1393 /* Some systems pass variables of certain types by reference instead
1394 of by value, i.e. they will pass the address of a structure (in a
1395 register or on the stack) instead of the structure itself. */
1397 if (gdbarch_stabs_argument_has_addr (gdbarch
, sym
->type ())
1398 && sym
->is_argument ())
1400 /* We have to convert LOC_REGISTER to LOC_REGPARM_ADDR (for
1401 variables passed in a register). */
1402 if (sym
->aclass () == LOC_REGISTER
)
1403 sym
->set_aclass_index (LOC_REGPARM_ADDR
);
1404 /* Likewise for converting LOC_ARG to LOC_REF_ARG (for the 7th
1405 and subsequent arguments on SPARC, for example). */
1406 else if (sym
->aclass () == LOC_ARG
)
1407 sym
->set_aclass_index (LOC_REF_ARG
);
1413 /* Skip rest of this symbol and return an error type.
1415 General notes on error recovery: error_type always skips to the
1416 end of the symbol (modulo cretinous dbx symbol name continuation).
1417 Thus code like this:
1419 if (*(*pp)++ != ';')
1420 return error_type (pp, objfile);
1422 is wrong because if *pp starts out pointing at '\0' (typically as the
1423 result of an earlier error), it will be incremented to point to the
1424 start of the next symbol, which might produce strange results, at least
1425 if you run off the end of the string table. Instead use
1428 return error_type (pp, objfile);
1434 foo = error_type (pp, objfile);
1438 And in case it isn't obvious, the point of all this hair is so the compiler
1439 can define new types and new syntaxes, and old versions of the
1440 debugger will be able to read the new symbol tables. */
1442 static struct type
*
1443 error_type (const char **pp
, struct objfile
*objfile
)
1445 complaint (_("couldn't parse type; debugger out of date?"));
1448 /* Skip to end of symbol. */
1449 while (**pp
!= '\0')
1454 /* Check for and handle cretinous dbx symbol name continuation! */
1455 if ((*pp
)[-1] == '\\' || (*pp
)[-1] == '?')
1457 *pp
= next_symbol_text (objfile
);
1464 return objfile_type (objfile
)->builtin_error
;
1468 /* Allocate a stub method whose return type is TYPE. This apparently
1469 happens for speed of symbol reading, since parsing out the
1470 arguments to the method is cpu-intensive, the way we are doing it.
1471 So, we will fill in arguments later. This always returns a fresh
1474 static struct type
*
1475 allocate_stub_method (struct type
*type
)
1479 mtype
= type_allocator (type
).new_type ();
1480 mtype
->set_code (TYPE_CODE_METHOD
);
1481 mtype
->set_length (1);
1482 mtype
->set_is_stub (true);
1483 mtype
->set_target_type (type
);
1484 /* TYPE_SELF_TYPE (mtype) = unknown yet */
1488 /* Read type information or a type definition; return the type. Even
1489 though this routine accepts either type information or a type
1490 definition, the distinction is relevant--some parts of stabsread.c
1491 assume that type information starts with a digit, '-', or '(' in
1492 deciding whether to call read_type. */
1494 static struct type
*
1495 read_type (const char **pp
, struct objfile
*objfile
)
1497 struct type
*type
= 0;
1500 char type_descriptor
;
1502 /* Size in bits of type if specified by a type attribute, or -1 if
1503 there is no size attribute. */
1506 /* Used to distinguish string and bitstring from char-array and set. */
1509 /* Used to distinguish vector from array. */
1512 /* Read type number if present. The type number may be omitted.
1513 for instance in a two-dimensional array declared with type
1514 "ar1;1;10;ar1;1;10;4". */
1515 if ((**pp
>= '0' && **pp
<= '9')
1519 if (read_type_number (pp
, typenums
) != 0)
1520 return error_type (pp
, objfile
);
1524 /* Type is not being defined here. Either it already
1525 exists, or this is a forward reference to it.
1526 dbx_alloc_type handles both cases. */
1527 type
= dbx_alloc_type (typenums
, objfile
);
1529 /* If this is a forward reference, arrange to complain if it
1530 doesn't get patched up by the time we're done
1532 if (type
->code () == TYPE_CODE_UNDEF
)
1533 add_undefined_type (type
, typenums
);
1538 /* Type is being defined here. */
1540 Also skip the type descriptor - we get it below with (*pp)[-1]. */
1545 /* 'typenums=' not present, type is anonymous. Read and return
1546 the definition, but don't put it in the type vector. */
1547 typenums
[0] = typenums
[1] = -1;
1552 type_descriptor
= (*pp
)[-1];
1553 switch (type_descriptor
)
1557 enum type_code code
;
1559 /* Used to index through file_symbols. */
1560 struct pending
*ppt
;
1563 /* Name including "struct", etc. */
1567 const char *from
, *p
, *q1
, *q2
;
1569 /* Set the type code according to the following letter. */
1573 code
= TYPE_CODE_STRUCT
;
1576 code
= TYPE_CODE_UNION
;
1579 code
= TYPE_CODE_ENUM
;
1583 /* Complain and keep going, so compilers can invent new
1584 cross-reference types. */
1585 complaint (_("Unrecognized cross-reference type `%c'"),
1587 code
= TYPE_CODE_STRUCT
;
1592 q1
= strchr (*pp
, '<');
1593 p
= strchr (*pp
, ':');
1595 return error_type (pp
, objfile
);
1596 if (q1
&& p
> q1
&& p
[1] == ':')
1598 int nesting_level
= 0;
1600 for (q2
= q1
; *q2
; q2
++)
1604 else if (*q2
== '>')
1606 else if (*q2
== ':' && nesting_level
== 0)
1611 return error_type (pp
, objfile
);
1614 if (get_current_subfile ()->language
== language_cplus
)
1616 std::string
name (*pp
, p
- *pp
);
1617 gdb::unique_xmalloc_ptr
<char> new_name
1618 = cp_canonicalize_string (name
.c_str ());
1619 if (new_name
!= nullptr)
1620 type_name
= obstack_strdup (&objfile
->objfile_obstack
,
1623 else if (get_current_subfile ()->language
== language_c
)
1625 std::string
name (*pp
, p
- *pp
);
1626 gdb::unique_xmalloc_ptr
<char> new_name
1627 = c_canonicalize_name (name
.c_str ());
1628 if (new_name
!= nullptr)
1629 type_name
= obstack_strdup (&objfile
->objfile_obstack
,
1632 if (type_name
== NULL
)
1634 char *to
= type_name
= (char *)
1635 obstack_alloc (&objfile
->objfile_obstack
, p
- *pp
+ 1);
1637 /* Copy the name. */
1644 /* Set the pointer ahead of the name which we just read, and
1649 /* If this type has already been declared, then reuse the same
1650 type, rather than allocating a new one. This saves some
1653 for (ppt
= *get_file_symbols (); ppt
; ppt
= ppt
->next
)
1654 for (i
= 0; i
< ppt
->nsyms
; i
++)
1656 struct symbol
*sym
= ppt
->symbol
[i
];
1658 if (sym
->aclass () == LOC_TYPEDEF
1659 && sym
->domain () == STRUCT_DOMAIN
1660 && (sym
->type ()->code () == code
)
1661 && strcmp (sym
->linkage_name (), type_name
) == 0)
1663 obstack_free (&objfile
->objfile_obstack
, type_name
);
1664 type
= sym
->type ();
1665 if (typenums
[0] != -1)
1666 *dbx_lookup_type (typenums
, objfile
) = type
;
1671 /* Didn't find the type to which this refers, so we must
1672 be dealing with a forward reference. Allocate a type
1673 structure for it, and keep track of it so we can
1674 fill in the rest of the fields when we get the full
1676 type
= dbx_alloc_type (typenums
, objfile
);
1677 type
->set_code (code
);
1678 type
->set_name (type_name
);
1679 INIT_CPLUS_SPECIFIC (type
);
1680 type
->set_is_stub (true);
1682 add_undefined_type (type
, typenums
);
1686 case '-': /* RS/6000 built-in type */
1700 /* We deal with something like t(1,2)=(3,4)=... which
1701 the Lucid compiler and recent gcc versions (post 2.7.3) use. */
1703 /* Allocate and enter the typedef type first.
1704 This handles recursive types. */
1705 type
= dbx_alloc_type (typenums
, objfile
);
1706 type
->set_code (TYPE_CODE_TYPEDEF
);
1708 struct type
*xtype
= read_type (pp
, objfile
);
1712 /* It's being defined as itself. That means it is "void". */
1713 type
->set_code (TYPE_CODE_VOID
);
1714 type
->set_length (1);
1716 else if (type_size
>= 0 || is_string
)
1718 /* This is the absolute wrong way to construct types. Every
1719 other debug format has found a way around this problem and
1720 the related problems with unnecessarily stubbed types;
1721 someone motivated should attempt to clean up the issue
1722 here as well. Once a type pointed to has been created it
1723 should not be modified.
1725 Well, it's not *absolutely* wrong. Constructing recursive
1726 types (trees, linked lists) necessarily entails modifying
1727 types after creating them. Constructing any loop structure
1728 entails side effects. The Dwarf 2 reader does handle this
1729 more gracefully (it never constructs more than once
1730 instance of a type object, so it doesn't have to copy type
1731 objects wholesale), but it still mutates type objects after
1732 other folks have references to them.
1734 Keep in mind that this circularity/mutation issue shows up
1735 at the source language level, too: C's "incomplete types",
1736 for example. So the proper cleanup, I think, would be to
1737 limit GDB's type smashing to match exactly those required
1738 by the source language. So GDB could have a
1739 "complete_this_type" function, but never create unnecessary
1740 copies of a type otherwise. */
1741 replace_type (type
, xtype
);
1742 type
->set_name (NULL
);
1746 type
->set_target_is_stub (true);
1747 type
->set_target_type (xtype
);
1752 /* In the following types, we must be sure to overwrite any existing
1753 type that the typenums refer to, rather than allocating a new one
1754 and making the typenums point to the new one. This is because there
1755 may already be pointers to the existing type (if it had been
1756 forward-referenced), and we must change it to a pointer, function,
1757 reference, or whatever, *in-place*. */
1759 case '*': /* Pointer to another type */
1760 type1
= read_type (pp
, objfile
);
1761 type
= make_pointer_type (type1
, dbx_lookup_type (typenums
, objfile
));
1764 case '&': /* Reference to another type */
1765 type1
= read_type (pp
, objfile
);
1766 type
= make_reference_type (type1
, dbx_lookup_type (typenums
, objfile
),
1770 case 'f': /* Function returning another type */
1771 type1
= read_type (pp
, objfile
);
1772 type
= make_function_type (type1
, dbx_lookup_type (typenums
, objfile
));
1775 case 'g': /* Prototyped function. (Sun) */
1777 /* Unresolved questions:
1779 - According to Sun's ``STABS Interface Manual'', for 'f'
1780 and 'F' symbol descriptors, a `0' in the argument type list
1781 indicates a varargs function. But it doesn't say how 'g'
1782 type descriptors represent that info. Someone with access
1783 to Sun's toolchain should try it out.
1785 - According to the comment in define_symbol (search for
1786 `process_prototype_types:'), Sun emits integer arguments as
1787 types which ref themselves --- like `void' types. Do we
1788 have to deal with that here, too? Again, someone with
1789 access to Sun's toolchain should try it out and let us
1792 const char *type_start
= (*pp
) - 1;
1793 struct type
*return_type
= read_type (pp
, objfile
);
1794 struct type
*func_type
1795 = make_function_type (return_type
,
1796 dbx_lookup_type (typenums
, objfile
));
1799 struct type_list
*next
;
1803 while (**pp
&& **pp
!= '#')
1805 struct type
*arg_type
= read_type (pp
, objfile
);
1806 struct type_list
*newobj
= XALLOCA (struct type_list
);
1807 newobj
->type
= arg_type
;
1808 newobj
->next
= arg_types
;
1816 complaint (_("Prototyped function type didn't "
1817 "end arguments with `#':\n%s"),
1821 /* If there is just one argument whose type is `void', then
1822 that's just an empty argument list. */
1824 && ! arg_types
->next
1825 && arg_types
->type
->code () == TYPE_CODE_VOID
)
1828 func_type
->set_fields
1829 ((struct field
*) TYPE_ALLOC (func_type
,
1830 num_args
* sizeof (struct field
)));
1831 memset (func_type
->fields (), 0, num_args
* sizeof (struct field
));
1834 struct type_list
*t
;
1836 /* We stuck each argument type onto the front of the list
1837 when we read it, so the list is reversed. Build the
1838 fields array right-to-left. */
1839 for (t
= arg_types
, i
= num_args
- 1; t
; t
= t
->next
, i
--)
1840 func_type
->field (i
).set_type (t
->type
);
1842 func_type
->set_num_fields (num_args
);
1843 func_type
->set_is_prototyped (true);
1849 case 'k': /* Const qualifier on some type (Sun) */
1850 type
= read_type (pp
, objfile
);
1851 type
= make_cv_type (1, TYPE_VOLATILE (type
), type
,
1852 dbx_lookup_type (typenums
, objfile
));
1855 case 'B': /* Volatile qual on some type (Sun) */
1856 type
= read_type (pp
, objfile
);
1857 type
= make_cv_type (TYPE_CONST (type
), 1, type
,
1858 dbx_lookup_type (typenums
, objfile
));
1862 if (isdigit (**pp
) || **pp
== '(' || **pp
== '-')
1863 { /* Member (class & variable) type */
1864 /* FIXME -- we should be doing smash_to_XXX types here. */
1866 struct type
*domain
= read_type (pp
, objfile
);
1867 struct type
*memtype
;
1870 /* Invalid member type data format. */
1871 return error_type (pp
, objfile
);
1874 memtype
= read_type (pp
, objfile
);
1875 type
= dbx_alloc_type (typenums
, objfile
);
1876 smash_to_memberptr_type (type
, domain
, memtype
);
1879 /* type attribute */
1881 const char *attr
= *pp
;
1883 /* Skip to the semicolon. */
1884 while (**pp
!= ';' && **pp
!= '\0')
1887 return error_type (pp
, objfile
);
1889 ++ * pp
; /* Skip the semicolon. */
1893 case 's': /* Size attribute */
1894 type_size
= atoi (attr
+ 1);
1899 case 'S': /* String attribute */
1900 /* FIXME: check to see if following type is array? */
1904 case 'V': /* Vector attribute */
1905 /* FIXME: check to see if following type is array? */
1910 /* Ignore unrecognized type attributes, so future compilers
1911 can invent new ones. */
1919 case '#': /* Method (class & fn) type */
1920 if ((*pp
)[0] == '#')
1922 /* We'll get the parameter types from the name. */
1923 struct type
*return_type
;
1926 return_type
= read_type (pp
, objfile
);
1927 if (*(*pp
)++ != ';')
1928 complaint (_("invalid (minimal) member type "
1929 "data format at symtab pos %d."),
1931 type
= allocate_stub_method (return_type
);
1932 if (typenums
[0] != -1)
1933 *dbx_lookup_type (typenums
, objfile
) = type
;
1937 struct type
*domain
= read_type (pp
, objfile
);
1938 struct type
*return_type
;
1943 /* Invalid member type data format. */
1944 return error_type (pp
, objfile
);
1948 return_type
= read_type (pp
, objfile
);
1949 args
= read_args (pp
, ';', objfile
, &nargs
, &varargs
);
1951 return error_type (pp
, objfile
);
1952 type
= dbx_alloc_type (typenums
, objfile
);
1953 smash_to_method_type (type
, domain
, return_type
, args
,
1958 case 'r': /* Range type */
1959 type
= read_range_type (pp
, typenums
, type_size
, objfile
);
1960 if (typenums
[0] != -1)
1961 *dbx_lookup_type (typenums
, objfile
) = type
;
1966 /* Sun ACC builtin int type */
1967 type
= read_sun_builtin_type (pp
, typenums
, objfile
);
1968 if (typenums
[0] != -1)
1969 *dbx_lookup_type (typenums
, objfile
) = type
;
1973 case 'R': /* Sun ACC builtin float type */
1974 type
= read_sun_floating_type (pp
, typenums
, objfile
);
1975 if (typenums
[0] != -1)
1976 *dbx_lookup_type (typenums
, objfile
) = type
;
1979 case 'e': /* Enumeration type */
1980 type
= dbx_alloc_type (typenums
, objfile
);
1981 type
= read_enum_type (pp
, type
, objfile
);
1982 if (typenums
[0] != -1)
1983 *dbx_lookup_type (typenums
, objfile
) = type
;
1986 case 's': /* Struct type */
1987 case 'u': /* Union type */
1989 enum type_code type_code
= TYPE_CODE_UNDEF
;
1990 type
= dbx_alloc_type (typenums
, objfile
);
1991 switch (type_descriptor
)
1994 type_code
= TYPE_CODE_STRUCT
;
1997 type_code
= TYPE_CODE_UNION
;
2000 type
= read_struct_type (pp
, type
, type_code
, objfile
);
2004 case 'a': /* Array type */
2006 return error_type (pp
, objfile
);
2009 type
= dbx_alloc_type (typenums
, objfile
);
2010 type
= read_array_type (pp
, type
, objfile
);
2012 type
->set_code (TYPE_CODE_STRING
);
2014 make_vector_type (type
);
2017 case 'S': /* Set type */
2018 type1
= read_type (pp
, objfile
);
2019 type
= create_set_type (NULL
, type1
);
2020 if (typenums
[0] != -1)
2021 *dbx_lookup_type (typenums
, objfile
) = type
;
2025 --*pp
; /* Go back to the symbol in error. */
2026 /* Particularly important if it was \0! */
2027 return error_type (pp
, objfile
);
2032 warning (_("GDB internal error, type is NULL in stabsread.c."));
2033 return error_type (pp
, objfile
);
2036 /* Size specified in a type attribute overrides any other size. */
2037 if (type_size
!= -1)
2038 type
->set_length ((type_size
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
);
2043 /* RS/6000 xlc/dbx combination uses a set of builtin types, starting from -1.
2044 Return the proper type node for a given builtin type number. */
2046 static const registry
<objfile
>::key
<struct type
*,
2047 gdb::noop_deleter
<struct type
*>>
2048 rs6000_builtin_type_data
;
2050 static struct type
*
2051 rs6000_builtin_type (int typenum
, struct objfile
*objfile
)
2053 struct type
**negative_types
= rs6000_builtin_type_data
.get (objfile
);
2055 /* We recognize types numbered from -NUMBER_RECOGNIZED to -1. */
2056 #define NUMBER_RECOGNIZED 34
2057 struct type
*rettype
= NULL
;
2059 if (typenum
>= 0 || typenum
< -NUMBER_RECOGNIZED
)
2061 complaint (_("Unknown builtin type %d"), typenum
);
2062 return objfile_type (objfile
)->builtin_error
;
2065 if (!negative_types
)
2067 /* This includes an empty slot for type number -0. */
2068 negative_types
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
2069 NUMBER_RECOGNIZED
+ 1, struct type
*);
2070 rs6000_builtin_type_data
.set (objfile
, negative_types
);
2073 if (negative_types
[-typenum
] != NULL
)
2074 return negative_types
[-typenum
];
2076 #if TARGET_CHAR_BIT != 8
2077 #error This code wrong for TARGET_CHAR_BIT not 8
2078 /* These definitions all assume that TARGET_CHAR_BIT is 8. I think
2079 that if that ever becomes not true, the correct fix will be to
2080 make the size in the struct type to be in bits, not in units of
2084 type_allocator
alloc (objfile
);
2088 /* The size of this and all the other types are fixed, defined
2089 by the debugging format. If there is a type called "int" which
2090 is other than 32 bits, then it should use a new negative type
2091 number (or avoid negative type numbers for that case).
2092 See stabs.texinfo. */
2093 rettype
= init_integer_type (alloc
, 32, 0, "int");
2096 rettype
= init_integer_type (alloc
, 8, 0, "char");
2097 rettype
->set_has_no_signedness (true);
2100 rettype
= init_integer_type (alloc
, 16, 0, "short");
2103 rettype
= init_integer_type (alloc
, 32, 0, "long");
2106 rettype
= init_integer_type (alloc
, 8, 1, "unsigned char");
2109 rettype
= init_integer_type (alloc
, 8, 0, "signed char");
2112 rettype
= init_integer_type (alloc
, 16, 1, "unsigned short");
2115 rettype
= init_integer_type (alloc
, 32, 1, "unsigned int");
2118 rettype
= init_integer_type (alloc
, 32, 1, "unsigned");
2121 rettype
= init_integer_type (alloc
, 32, 1, "unsigned long");
2124 rettype
= alloc
.new_type (TYPE_CODE_VOID
, TARGET_CHAR_BIT
, "void");
2127 /* IEEE single precision (32 bit). */
2128 rettype
= init_float_type (alloc
, 32, "float",
2129 floatformats_ieee_single
);
2132 /* IEEE double precision (64 bit). */
2133 rettype
= init_float_type (alloc
, 64, "double",
2134 floatformats_ieee_double
);
2137 /* This is an IEEE double on the RS/6000, and different machines with
2138 different sizes for "long double" should use different negative
2139 type numbers. See stabs.texinfo. */
2140 rettype
= init_float_type (alloc
, 64, "long double",
2141 floatformats_ieee_double
);
2144 rettype
= init_integer_type (alloc
, 32, 0, "integer");
2147 rettype
= init_boolean_type (alloc
, 32, 1, "boolean");
2150 rettype
= init_float_type (alloc
, 32, "short real",
2151 floatformats_ieee_single
);
2154 rettype
= init_float_type (alloc
, 64, "real",
2155 floatformats_ieee_double
);
2158 rettype
= alloc
.new_type (TYPE_CODE_ERROR
, 0, "stringptr");
2161 rettype
= init_character_type (alloc
, 8, 1, "character");
2164 rettype
= init_boolean_type (alloc
, 8, 1, "logical*1");
2167 rettype
= init_boolean_type (alloc
, 16, 1, "logical*2");
2170 rettype
= init_boolean_type (alloc
, 32, 1, "logical*4");
2173 rettype
= init_boolean_type (alloc
, 32, 1, "logical");
2176 /* Complex type consisting of two IEEE single precision values. */
2177 rettype
= init_complex_type ("complex",
2178 rs6000_builtin_type (12, objfile
));
2181 /* Complex type consisting of two IEEE double precision values. */
2182 rettype
= init_complex_type ("double complex",
2183 rs6000_builtin_type (13, objfile
));
2186 rettype
= init_integer_type (alloc
, 8, 0, "integer*1");
2189 rettype
= init_integer_type (alloc
, 16, 0, "integer*2");
2192 rettype
= init_integer_type (alloc
, 32, 0, "integer*4");
2195 rettype
= init_character_type (alloc
, 16, 0, "wchar");
2198 rettype
= init_integer_type (alloc
, 64, 0, "long long");
2201 rettype
= init_integer_type (alloc
, 64, 1, "unsigned long long");
2204 rettype
= init_integer_type (alloc
, 64, 1, "logical*8");
2207 rettype
= init_integer_type (alloc
, 64, 0, "integer*8");
2210 negative_types
[-typenum
] = rettype
;
2214 /* This page contains subroutines of read_type. */
2216 /* Wrapper around method_name_from_physname to flag a complaint
2217 if there is an error. */
2220 stabs_method_name_from_physname (const char *physname
)
2224 method_name
= method_name_from_physname (physname
);
2226 if (method_name
== NULL
)
2228 complaint (_("Method has bad physname %s\n"), physname
);
2235 /* Read member function stabs info for C++ classes. The form of each member
2238 NAME :: TYPENUM[=type definition] ARGS : PHYSNAME ;
2240 An example with two member functions is:
2242 afunc1::20=##15;:i;2A.;afunc2::20:i;2A.;
2244 For the case of overloaded operators, the format is op$::*.funcs, where
2245 $ is the CPLUS_MARKER (usually '$'), `*' holds the place for an operator
2246 name (such as `+=') and `.' marks the end of the operator name.
2248 Returns 1 for success, 0 for failure. */
2251 read_member_functions (struct stab_field_info
*fip
, const char **pp
,
2252 struct type
*type
, struct objfile
*objfile
)
2259 struct next_fnfield
*next
;
2260 struct fn_field fn_field
;
2263 struct type
*look_ahead_type
;
2264 struct next_fnfieldlist
*new_fnlist
;
2265 struct next_fnfield
*new_sublist
;
2269 /* Process each list until we find something that is not a member function
2270 or find the end of the functions. */
2274 /* We should be positioned at the start of the function name.
2275 Scan forward to find the first ':' and if it is not the
2276 first of a "::" delimiter, then this is not a member function. */
2288 look_ahead_type
= NULL
;
2291 new_fnlist
= OBSTACK_ZALLOC (&fip
->obstack
, struct next_fnfieldlist
);
2293 if ((*pp
)[0] == 'o' && (*pp
)[1] == 'p' && is_cplus_marker ((*pp
)[2]))
2295 /* This is a completely wierd case. In order to stuff in the
2296 names that might contain colons (the usual name delimiter),
2297 Mike Tiemann defined a different name format which is
2298 signalled if the identifier is "op$". In that case, the
2299 format is "op$::XXXX." where XXXX is the name. This is
2300 used for names like "+" or "=". YUUUUUUUK! FIXME! */
2301 /* This lets the user type "break operator+".
2302 We could just put in "+" as the name, but that wouldn't
2304 static char opname
[32] = "op$";
2305 char *o
= opname
+ 3;
2307 /* Skip past '::'. */
2310 STABS_CONTINUE (pp
, objfile
);
2316 main_fn_name
= savestring (opname
, o
- opname
);
2322 main_fn_name
= savestring (*pp
, p
- *pp
);
2323 /* Skip past '::'. */
2326 new_fnlist
->fn_fieldlist
.name
= main_fn_name
;
2330 new_sublist
= OBSTACK_ZALLOC (&fip
->obstack
, struct next_fnfield
);
2332 /* Check for and handle cretinous dbx symbol name continuation! */
2333 if (look_ahead_type
== NULL
)
2336 STABS_CONTINUE (pp
, objfile
);
2338 new_sublist
->fn_field
.type
= read_type (pp
, objfile
);
2341 /* Invalid symtab info for member function. */
2347 /* g++ version 1 kludge */
2348 new_sublist
->fn_field
.type
= look_ahead_type
;
2349 look_ahead_type
= NULL
;
2359 /* These are methods, not functions. */
2360 if (new_sublist
->fn_field
.type
->code () == TYPE_CODE_FUNC
)
2361 new_sublist
->fn_field
.type
->set_code (TYPE_CODE_METHOD
);
2363 /* If this is just a stub, then we don't have the real name here. */
2364 if (new_sublist
->fn_field
.type
->is_stub ())
2366 if (!TYPE_SELF_TYPE (new_sublist
->fn_field
.type
))
2367 set_type_self_type (new_sublist
->fn_field
.type
, type
);
2368 new_sublist
->fn_field
.is_stub
= 1;
2371 new_sublist
->fn_field
.physname
= savestring (*pp
, p
- *pp
);
2374 /* Set this member function's visibility fields. */
2377 case VISIBILITY_PRIVATE
:
2378 new_sublist
->fn_field
.is_private
= 1;
2380 case VISIBILITY_PROTECTED
:
2381 new_sublist
->fn_field
.is_protected
= 1;
2385 STABS_CONTINUE (pp
, objfile
);
2388 case 'A': /* Normal functions. */
2389 new_sublist
->fn_field
.is_const
= 0;
2390 new_sublist
->fn_field
.is_volatile
= 0;
2393 case 'B': /* `const' member functions. */
2394 new_sublist
->fn_field
.is_const
= 1;
2395 new_sublist
->fn_field
.is_volatile
= 0;
2398 case 'C': /* `volatile' member function. */
2399 new_sublist
->fn_field
.is_const
= 0;
2400 new_sublist
->fn_field
.is_volatile
= 1;
2403 case 'D': /* `const volatile' member function. */
2404 new_sublist
->fn_field
.is_const
= 1;
2405 new_sublist
->fn_field
.is_volatile
= 1;
2408 case '*': /* File compiled with g++ version 1 --
2414 complaint (_("const/volatile indicator missing, got '%c'"),
2424 /* virtual member function, followed by index.
2425 The sign bit is set to distinguish pointers-to-methods
2426 from virtual function indicies. Since the array is
2427 in words, the quantity must be shifted left by 1
2428 on 16 bit machine, and by 2 on 32 bit machine, forcing
2429 the sign bit out, and usable as a valid index into
2430 the array. Remove the sign bit here. */
2431 new_sublist
->fn_field
.voffset
=
2432 (0x7fffffff & read_huge_number (pp
, ';', &nbits
, 0)) + 2;
2436 STABS_CONTINUE (pp
, objfile
);
2437 if (**pp
== ';' || **pp
== '\0')
2439 /* Must be g++ version 1. */
2440 new_sublist
->fn_field
.fcontext
= 0;
2444 /* Figure out from whence this virtual function came.
2445 It may belong to virtual function table of
2446 one of its baseclasses. */
2447 look_ahead_type
= read_type (pp
, objfile
);
2450 /* g++ version 1 overloaded methods. */
2454 new_sublist
->fn_field
.fcontext
= look_ahead_type
;
2463 look_ahead_type
= NULL
;
2469 /* static member function. */
2471 int slen
= strlen (main_fn_name
);
2473 new_sublist
->fn_field
.voffset
= VOFFSET_STATIC
;
2475 /* For static member functions, we can't tell if they
2476 are stubbed, as they are put out as functions, and not as
2478 GCC v2 emits the fully mangled name if
2479 dbxout.c:flag_minimal_debug is not set, so we have to
2480 detect a fully mangled physname here and set is_stub
2481 accordingly. Fully mangled physnames in v2 start with
2482 the member function name, followed by two underscores.
2483 GCC v3 currently always emits stubbed member functions,
2484 but with fully mangled physnames, which start with _Z. */
2485 if (!(strncmp (new_sublist
->fn_field
.physname
,
2486 main_fn_name
, slen
) == 0
2487 && new_sublist
->fn_field
.physname
[slen
] == '_'
2488 && new_sublist
->fn_field
.physname
[slen
+ 1] == '_'))
2490 new_sublist
->fn_field
.is_stub
= 1;
2497 complaint (_("member function type missing, got '%c'"),
2499 /* Normal member function. */
2503 /* normal member function. */
2504 new_sublist
->fn_field
.voffset
= 0;
2505 new_sublist
->fn_field
.fcontext
= 0;
2509 new_sublist
->next
= sublist
;
2510 sublist
= new_sublist
;
2512 STABS_CONTINUE (pp
, objfile
);
2514 while (**pp
!= ';' && **pp
!= '\0');
2517 STABS_CONTINUE (pp
, objfile
);
2519 /* Skip GCC 3.X member functions which are duplicates of the callable
2520 constructor/destructor. */
2521 if (strcmp_iw (main_fn_name
, "__base_ctor ") == 0
2522 || strcmp_iw (main_fn_name
, "__base_dtor ") == 0
2523 || strcmp (main_fn_name
, "__deleting_dtor") == 0)
2525 xfree (main_fn_name
);
2529 int has_destructor
= 0, has_other
= 0;
2531 struct next_fnfield
*tmp_sublist
;
2533 /* Various versions of GCC emit various mostly-useless
2534 strings in the name field for special member functions.
2536 For stub methods, we need to defer correcting the name
2537 until we are ready to unstub the method, because the current
2538 name string is used by gdb_mangle_name. The only stub methods
2539 of concern here are GNU v2 operators; other methods have their
2540 names correct (see caveat below).
2542 For non-stub methods, in GNU v3, we have a complete physname.
2543 Therefore we can safely correct the name now. This primarily
2544 affects constructors and destructors, whose name will be
2545 __comp_ctor or __comp_dtor instead of Foo or ~Foo. Cast
2546 operators will also have incorrect names; for instance,
2547 "operator int" will be named "operator i" (i.e. the type is
2550 For non-stub methods in GNU v2, we have no easy way to
2551 know if we have a complete physname or not. For most
2552 methods the result depends on the platform (if CPLUS_MARKER
2553 can be `$' or `.', it will use minimal debug information, or
2554 otherwise the full physname will be included).
2556 Rather than dealing with this, we take a different approach.
2557 For v3 mangled names, we can use the full physname; for v2,
2558 we use cplus_demangle_opname (which is actually v2 specific),
2559 because the only interesting names are all operators - once again
2560 barring the caveat below. Skip this process if any method in the
2561 group is a stub, to prevent our fouling up the workings of
2564 The caveat: GCC 2.95.x (and earlier?) put constructors and
2565 destructors in the same method group. We need to split this
2566 into two groups, because they should have different names.
2567 So for each method group we check whether it contains both
2568 routines whose physname appears to be a destructor (the physnames
2569 for and destructors are always provided, due to quirks in v2
2570 mangling) and routines whose physname does not appear to be a
2571 destructor. If so then we break up the list into two halves.
2572 Even if the constructors and destructors aren't in the same group
2573 the destructor will still lack the leading tilde, so that also
2576 So, to summarize what we expect and handle here:
2578 Given Given Real Real Action
2579 method name physname physname method name
2581 __opi [none] __opi__3Foo operator int opname
2583 Foo _._3Foo _._3Foo ~Foo separate and
2585 operator i _ZN3FoocviEv _ZN3FoocviEv operator int demangle
2586 __comp_ctor _ZN3FooC1ERKS_ _ZN3FooC1ERKS_ Foo demangle
2589 tmp_sublist
= sublist
;
2590 while (tmp_sublist
!= NULL
)
2592 if (tmp_sublist
->fn_field
.physname
[0] == '_'
2593 && tmp_sublist
->fn_field
.physname
[1] == 'Z')
2596 if (is_destructor_name (tmp_sublist
->fn_field
.physname
))
2601 tmp_sublist
= tmp_sublist
->next
;
2604 if (has_destructor
&& has_other
)
2606 struct next_fnfieldlist
*destr_fnlist
;
2607 struct next_fnfield
*last_sublist
;
2609 /* Create a new fn_fieldlist for the destructors. */
2611 destr_fnlist
= OBSTACK_ZALLOC (&fip
->obstack
,
2612 struct next_fnfieldlist
);
2614 destr_fnlist
->fn_fieldlist
.name
2615 = obconcat (&objfile
->objfile_obstack
, "~",
2616 new_fnlist
->fn_fieldlist
.name
, (char *) NULL
);
2618 destr_fnlist
->fn_fieldlist
.fn_fields
=
2619 XOBNEWVEC (&objfile
->objfile_obstack
,
2620 struct fn_field
, has_destructor
);
2621 memset (destr_fnlist
->fn_fieldlist
.fn_fields
, 0,
2622 sizeof (struct fn_field
) * has_destructor
);
2623 tmp_sublist
= sublist
;
2624 last_sublist
= NULL
;
2626 while (tmp_sublist
!= NULL
)
2628 if (!is_destructor_name (tmp_sublist
->fn_field
.physname
))
2630 tmp_sublist
= tmp_sublist
->next
;
2634 destr_fnlist
->fn_fieldlist
.fn_fields
[i
++]
2635 = tmp_sublist
->fn_field
;
2637 last_sublist
->next
= tmp_sublist
->next
;
2639 sublist
= tmp_sublist
->next
;
2640 last_sublist
= tmp_sublist
;
2641 tmp_sublist
= tmp_sublist
->next
;
2644 destr_fnlist
->fn_fieldlist
.length
= has_destructor
;
2645 destr_fnlist
->next
= fip
->fnlist
;
2646 fip
->fnlist
= destr_fnlist
;
2648 length
-= has_destructor
;
2652 /* v3 mangling prevents the use of abbreviated physnames,
2653 so we can do this here. There are stubbed methods in v3
2655 - in -gstabs instead of -gstabs+
2656 - or for static methods, which are output as a function type
2657 instead of a method type. */
2658 char *new_method_name
=
2659 stabs_method_name_from_physname (sublist
->fn_field
.physname
);
2661 if (new_method_name
!= NULL
2662 && strcmp (new_method_name
,
2663 new_fnlist
->fn_fieldlist
.name
) != 0)
2665 new_fnlist
->fn_fieldlist
.name
= new_method_name
;
2666 xfree (main_fn_name
);
2669 xfree (new_method_name
);
2671 else if (has_destructor
&& new_fnlist
->fn_fieldlist
.name
[0] != '~')
2673 new_fnlist
->fn_fieldlist
.name
=
2674 obconcat (&objfile
->objfile_obstack
,
2675 "~", main_fn_name
, (char *)NULL
);
2676 xfree (main_fn_name
);
2679 new_fnlist
->fn_fieldlist
.fn_fields
2680 = OBSTACK_CALLOC (&objfile
->objfile_obstack
, length
, fn_field
);
2681 for (i
= length
; (i
--, sublist
); sublist
= sublist
->next
)
2683 new_fnlist
->fn_fieldlist
.fn_fields
[i
] = sublist
->fn_field
;
2686 new_fnlist
->fn_fieldlist
.length
= length
;
2687 new_fnlist
->next
= fip
->fnlist
;
2688 fip
->fnlist
= new_fnlist
;
2695 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2696 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
2697 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * nfn_fields
);
2698 memset (TYPE_FN_FIELDLISTS (type
), 0,
2699 sizeof (struct fn_fieldlist
) * nfn_fields
);
2700 TYPE_NFN_FIELDS (type
) = nfn_fields
;
2706 /* Special GNU C++ name.
2708 Returns 1 for success, 0 for failure. "failure" means that we can't
2709 keep parsing and it's time for error_type(). */
2712 read_cpp_abbrev (struct stab_field_info
*fip
, const char **pp
,
2713 struct type
*type
, struct objfile
*objfile
)
2718 struct type
*context
;
2728 /* At this point, *pp points to something like "22:23=*22...",
2729 where the type number before the ':' is the "context" and
2730 everything after is a regular type definition. Lookup the
2731 type, find it's name, and construct the field name. */
2733 context
= read_type (pp
, objfile
);
2737 case 'f': /* $vf -- a virtual function table pointer */
2738 name
= context
->name ();
2743 fip
->list
->field
.set_name (obconcat (&objfile
->objfile_obstack
,
2744 vptr_name
, name
, (char *) NULL
));
2747 case 'b': /* $vb -- a virtual bsomethingorother */
2748 name
= context
->name ();
2751 complaint (_("C++ abbreviated type name "
2752 "unknown at symtab pos %d"),
2756 fip
->list
->field
.set_name (obconcat (&objfile
->objfile_obstack
,
2757 vb_name
, name
, (char *) NULL
));
2761 invalid_cpp_abbrev_complaint (*pp
);
2762 fip
->list
->field
.set_name (obconcat (&objfile
->objfile_obstack
,
2763 "INVALID_CPLUSPLUS_ABBREV",
2768 /* At this point, *pp points to the ':'. Skip it and read the
2774 invalid_cpp_abbrev_complaint (*pp
);
2777 fip
->list
->field
.set_type (read_type (pp
, objfile
));
2779 (*pp
)++; /* Skip the comma. */
2786 fip
->list
->field
.set_loc_bitpos (read_huge_number (pp
, ';', &nbits
, 0));
2790 /* This field is unpacked. */
2791 FIELD_BITSIZE (fip
->list
->field
) = 0;
2792 fip
->list
->visibility
= VISIBILITY_PRIVATE
;
2796 invalid_cpp_abbrev_complaint (*pp
);
2797 /* We have no idea what syntax an unrecognized abbrev would have, so
2798 better return 0. If we returned 1, we would need to at least advance
2799 *pp to avoid an infinite loop. */
2806 read_one_struct_field (struct stab_field_info
*fip
, const char **pp
,
2807 const char *p
, struct type
*type
,
2808 struct objfile
*objfile
)
2810 struct gdbarch
*gdbarch
= objfile
->arch ();
2812 fip
->list
->field
.set_name
2813 (obstack_strndup (&objfile
->objfile_obstack
, *pp
, p
- *pp
));
2816 /* This means we have a visibility for a field coming. */
2820 fip
->list
->visibility
= *(*pp
)++;
2824 /* normal dbx-style format, no explicit visibility */
2825 fip
->list
->visibility
= VISIBILITY_PUBLIC
;
2828 fip
->list
->field
.set_type (read_type (pp
, objfile
));
2833 /* Possible future hook for nested types. */
2836 fip
->list
->field
.bitpos
= (long) -2; /* nested type */
2846 /* Static class member. */
2847 fip
->list
->field
.set_loc_physname (savestring (*pp
, p
- *pp
));
2851 else if (**pp
!= ',')
2853 /* Bad structure-type format. */
2854 stabs_general_complaint ("bad structure-type format");
2858 (*pp
)++; /* Skip the comma. */
2863 fip
->list
->field
.set_loc_bitpos (read_huge_number (pp
, ',', &nbits
, 0));
2866 stabs_general_complaint ("bad structure-type format");
2869 FIELD_BITSIZE (fip
->list
->field
) = read_huge_number (pp
, ';', &nbits
, 0);
2872 stabs_general_complaint ("bad structure-type format");
2877 if (fip
->list
->field
.loc_bitpos () == 0
2878 && FIELD_BITSIZE (fip
->list
->field
) == 0)
2880 /* This can happen in two cases: (1) at least for gcc 2.4.5 or so,
2881 it is a field which has been optimized out. The correct stab for
2882 this case is to use VISIBILITY_IGNORE, but that is a recent
2883 invention. (2) It is a 0-size array. For example
2884 union { int num; char str[0]; } foo. Printing _("<no value>" for
2885 str in "p foo" is OK, since foo.str (and thus foo.str[3])
2886 will continue to work, and a 0-size array as a whole doesn't
2887 have any contents to print.
2889 I suspect this probably could also happen with gcc -gstabs (not
2890 -gstabs+) for static fields, and perhaps other C++ extensions.
2891 Hopefully few people use -gstabs with gdb, since it is intended
2892 for dbx compatibility. */
2894 /* Ignore this field. */
2895 fip
->list
->visibility
= VISIBILITY_IGNORE
;
2899 /* Detect an unpacked field and mark it as such.
2900 dbx gives a bit size for all fields.
2901 Note that forward refs cannot be packed,
2902 and treat enums as if they had the width of ints. */
2904 struct type
*field_type
= check_typedef (fip
->list
->field
.type ());
2906 if (field_type
->code () != TYPE_CODE_INT
2907 && field_type
->code () != TYPE_CODE_RANGE
2908 && field_type
->code () != TYPE_CODE_BOOL
2909 && field_type
->code () != TYPE_CODE_ENUM
)
2911 FIELD_BITSIZE (fip
->list
->field
) = 0;
2913 if ((FIELD_BITSIZE (fip
->list
->field
)
2914 == TARGET_CHAR_BIT
* field_type
->length ()
2915 || (field_type
->code () == TYPE_CODE_ENUM
2916 && FIELD_BITSIZE (fip
->list
->field
)
2917 == gdbarch_int_bit (gdbarch
))
2920 fip
->list
->field
.loc_bitpos () % 8 == 0)
2922 FIELD_BITSIZE (fip
->list
->field
) = 0;
2928 /* Read struct or class data fields. They have the form:
2930 NAME : [VISIBILITY] TYPENUM , BITPOS , BITSIZE ;
2932 At the end, we see a semicolon instead of a field.
2934 In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
2937 The optional VISIBILITY is one of:
2939 '/0' (VISIBILITY_PRIVATE)
2940 '/1' (VISIBILITY_PROTECTED)
2941 '/2' (VISIBILITY_PUBLIC)
2942 '/9' (VISIBILITY_IGNORE)
2944 or nothing, for C style fields with public visibility.
2946 Returns 1 for success, 0 for failure. */
2949 read_struct_fields (struct stab_field_info
*fip
, const char **pp
,
2950 struct type
*type
, struct objfile
*objfile
)
2953 struct stabs_nextfield
*newobj
;
2955 /* We better set p right now, in case there are no fields at all... */
2959 /* Read each data member type until we find the terminating ';' at the end of
2960 the data member list, or break for some other reason such as finding the
2961 start of the member function list. */
2962 /* Stab string for structure/union does not end with two ';' in
2963 SUN C compiler 5.3 i.e. F6U2, hence check for end of string. */
2965 while (**pp
!= ';' && **pp
!= '\0')
2967 STABS_CONTINUE (pp
, objfile
);
2968 /* Get space to record the next field's data. */
2969 newobj
= OBSTACK_ZALLOC (&fip
->obstack
, struct stabs_nextfield
);
2971 newobj
->next
= fip
->list
;
2974 /* Get the field name. */
2977 /* If is starts with CPLUS_MARKER it is a special abbreviation,
2978 unless the CPLUS_MARKER is followed by an underscore, in
2979 which case it is just the name of an anonymous type, which we
2980 should handle like any other type name. */
2982 if (is_cplus_marker (p
[0]) && p
[1] != '_')
2984 if (!read_cpp_abbrev (fip
, pp
, type
, objfile
))
2989 /* Look for the ':' that separates the field name from the field
2990 values. Data members are delimited by a single ':', while member
2991 functions are delimited by a pair of ':'s. When we hit the member
2992 functions (if any), terminate scan loop and return. */
2994 while (*p
!= ':' && *p
!= '\0')
3001 /* Check to see if we have hit the member functions yet. */
3006 read_one_struct_field (fip
, pp
, p
, type
, objfile
);
3008 if (p
[0] == ':' && p
[1] == ':')
3010 /* (the deleted) chill the list of fields: the last entry (at
3011 the head) is a partially constructed entry which we now
3013 fip
->list
= fip
->list
->next
;
3017 /* The stabs for C++ derived classes contain baseclass information which
3018 is marked by a '!' character after the total size. This function is
3019 called when we encounter the baseclass marker, and slurps up all the
3020 baseclass information.
3022 Immediately following the '!' marker is the number of base classes that
3023 the class is derived from, followed by information for each base class.
3024 For each base class, there are two visibility specifiers, a bit offset
3025 to the base class information within the derived class, a reference to
3026 the type for the base class, and a terminating semicolon.
3028 A typical example, with two base classes, would be "!2,020,19;0264,21;".
3030 Baseclass information marker __________________|| | | | | | |
3031 Number of baseclasses __________________________| | | | | | |
3032 Visibility specifiers (2) ________________________| | | | | |
3033 Offset in bits from start of class _________________| | | | |
3034 Type number for base class ___________________________| | | |
3035 Visibility specifiers (2) _______________________________| | |
3036 Offset in bits from start of class ________________________| |
3037 Type number of base class ____________________________________|
3039 Return 1 for success, 0 for (error-type-inducing) failure. */
3044 read_baseclasses (struct stab_field_info
*fip
, const char **pp
,
3045 struct type
*type
, struct objfile
*objfile
)
3048 struct stabs_nextfield
*newobj
;
3056 /* Skip the '!' baseclass information marker. */
3060 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3064 TYPE_N_BASECLASSES (type
) = read_huge_number (pp
, ',', &nbits
, 0);
3070 /* Some stupid compilers have trouble with the following, so break
3071 it up into simpler expressions. */
3072 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*)
3073 TYPE_ALLOC (type
, B_BYTES (TYPE_N_BASECLASSES (type
)));
3076 int num_bytes
= B_BYTES (TYPE_N_BASECLASSES (type
));
3079 pointer
= (char *) TYPE_ALLOC (type
, num_bytes
);
3080 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*) pointer
;
3084 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), TYPE_N_BASECLASSES (type
));
3086 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
3088 newobj
= OBSTACK_ZALLOC (&fip
->obstack
, struct stabs_nextfield
);
3090 newobj
->next
= fip
->list
;
3092 FIELD_BITSIZE (newobj
->field
) = 0; /* This should be an unpacked
3095 STABS_CONTINUE (pp
, objfile
);
3099 /* Nothing to do. */
3102 SET_TYPE_FIELD_VIRTUAL (type
, i
);
3105 /* Unknown character. Complain and treat it as non-virtual. */
3107 complaint (_("Unknown virtual character `%c' for baseclass"),
3113 newobj
->visibility
= *(*pp
)++;
3114 switch (newobj
->visibility
)
3116 case VISIBILITY_PRIVATE
:
3117 case VISIBILITY_PROTECTED
:
3118 case VISIBILITY_PUBLIC
:
3121 /* Bad visibility format. Complain and treat it as
3124 complaint (_("Unknown visibility `%c' for baseclass"),
3125 newobj
->visibility
);
3126 newobj
->visibility
= VISIBILITY_PUBLIC
;
3133 /* The remaining value is the bit offset of the portion of the object
3134 corresponding to this baseclass. Always zero in the absence of
3135 multiple inheritance. */
3137 newobj
->field
.set_loc_bitpos (read_huge_number (pp
, ',', &nbits
, 0));
3142 /* The last piece of baseclass information is the type of the
3143 base class. Read it, and remember it's type name as this
3146 newobj
->field
.set_type (read_type (pp
, objfile
));
3147 newobj
->field
.set_name (newobj
->field
.type ()->name ());
3149 /* Skip trailing ';' and bump count of number of fields seen. */
3158 /* The tail end of stabs for C++ classes that contain a virtual function
3159 pointer contains a tilde, a %, and a type number.
3160 The type number refers to the base class (possibly this class itself) which
3161 contains the vtable pointer for the current class.
3163 This function is called when we have parsed all the method declarations,
3164 so we can look for the vptr base class info. */
3167 read_tilde_fields (struct stab_field_info
*fip
, const char **pp
,
3168 struct type
*type
, struct objfile
*objfile
)
3172 STABS_CONTINUE (pp
, objfile
);
3174 /* If we are positioned at a ';', then skip it. */
3184 if (**pp
== '=' || **pp
== '+' || **pp
== '-')
3186 /* Obsolete flags that used to indicate the presence
3187 of constructors and/or destructors. */
3191 /* Read either a '%' or the final ';'. */
3192 if (*(*pp
)++ == '%')
3194 /* The next number is the type number of the base class
3195 (possibly our own class) which supplies the vtable for
3196 this class. Parse it out, and search that class to find
3197 its vtable pointer, and install those into TYPE_VPTR_BASETYPE
3198 and TYPE_VPTR_FIELDNO. */
3203 t
= read_type (pp
, objfile
);
3205 while (*p
!= '\0' && *p
!= ';')
3211 /* Premature end of symbol. */
3215 set_type_vptr_basetype (type
, t
);
3216 if (type
== t
) /* Our own class provides vtbl ptr. */
3218 for (i
= t
->num_fields () - 1;
3219 i
>= TYPE_N_BASECLASSES (t
);
3222 const char *name
= t
->field (i
).name ();
3224 if (!strncmp (name
, vptr_name
, sizeof (vptr_name
) - 2)
3225 && is_cplus_marker (name
[sizeof (vptr_name
) - 2]))
3227 set_type_vptr_fieldno (type
, i
);
3231 /* Virtual function table field not found. */
3232 complaint (_("virtual function table pointer "
3233 "not found when defining class `%s'"),
3239 set_type_vptr_fieldno (type
, TYPE_VPTR_FIELDNO (t
));
3250 attach_fn_fields_to_type (struct stab_field_info
*fip
, struct type
*type
)
3254 for (n
= TYPE_NFN_FIELDS (type
);
3255 fip
->fnlist
!= NULL
;
3256 fip
->fnlist
= fip
->fnlist
->next
)
3258 --n
; /* Circumvent Sun3 compiler bug. */
3259 TYPE_FN_FIELDLISTS (type
)[n
] = fip
->fnlist
->fn_fieldlist
;
3264 /* Create the vector of fields, and record how big it is.
3265 We need this info to record proper virtual function table information
3266 for this class's virtual functions. */
3269 attach_fields_to_type (struct stab_field_info
*fip
, struct type
*type
,
3270 struct objfile
*objfile
)
3273 int non_public_fields
= 0;
3274 struct stabs_nextfield
*scan
;
3276 /* Count up the number of fields that we have, as well as taking note of
3277 whether or not there are any non-public fields, which requires us to
3278 allocate and build the private_field_bits and protected_field_bits
3281 for (scan
= fip
->list
; scan
!= NULL
; scan
= scan
->next
)
3284 if (scan
->visibility
!= VISIBILITY_PUBLIC
)
3286 non_public_fields
++;
3290 /* Now we know how many fields there are, and whether or not there are any
3291 non-public fields. Record the field count, allocate space for the
3292 array of fields, and create blank visibility bitfields if necessary. */
3294 type
->set_num_fields (nfields
);
3297 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
));
3298 memset (type
->fields (), 0, sizeof (struct field
) * nfields
);
3300 if (non_public_fields
)
3302 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3304 TYPE_FIELD_PRIVATE_BITS (type
) =
3305 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3306 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
3308 TYPE_FIELD_PROTECTED_BITS (type
) =
3309 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3310 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
3312 TYPE_FIELD_IGNORE_BITS (type
) =
3313 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3314 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
3317 /* Copy the saved-up fields into the field vector. Start from the
3318 head of the list, adding to the tail of the field array, so that
3319 they end up in the same order in the array in which they were
3320 added to the list. */
3322 while (nfields
-- > 0)
3324 type
->field (nfields
) = fip
->list
->field
;
3325 switch (fip
->list
->visibility
)
3327 case VISIBILITY_PRIVATE
:
3328 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
3331 case VISIBILITY_PROTECTED
:
3332 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
3335 case VISIBILITY_IGNORE
:
3336 SET_TYPE_FIELD_IGNORE (type
, nfields
);
3339 case VISIBILITY_PUBLIC
:
3343 /* Unknown visibility. Complain and treat it as public. */
3345 complaint (_("Unknown visibility `%c' for field"),
3346 fip
->list
->visibility
);
3350 fip
->list
= fip
->list
->next
;
3356 /* Complain that the compiler has emitted more than one definition for the
3357 structure type TYPE. */
3359 complain_about_struct_wipeout (struct type
*type
)
3361 const char *name
= "";
3362 const char *kind
= "";
3366 name
= type
->name ();
3367 switch (type
->code ())
3369 case TYPE_CODE_STRUCT
: kind
= "struct "; break;
3370 case TYPE_CODE_UNION
: kind
= "union "; break;
3371 case TYPE_CODE_ENUM
: kind
= "enum "; break;
3381 complaint (_("struct/union type gets multiply defined: %s%s"), kind
, name
);
3384 /* Set the length for all variants of a same main_type, which are
3385 connected in the closed chain.
3387 This is something that needs to be done when a type is defined *after*
3388 some cross references to this type have already been read. Consider
3389 for instance the following scenario where we have the following two
3392 .stabs "t:p(0,21)=*(0,22)=k(0,23)=xsdummy:",160,0,28,-24
3393 .stabs "dummy:T(0,23)=s16x:(0,1),0,3[...]"
3395 A stubbed version of type dummy is created while processing the first
3396 stabs entry. The length of that type is initially set to zero, since
3397 it is unknown at this point. Also, a "constant" variation of type
3398 "dummy" is created as well (this is the "(0,22)=k(0,23)" section of
3401 The second stabs entry allows us to replace the stubbed definition
3402 with the real definition. However, we still need to adjust the length
3403 of the "constant" variation of that type, as its length was left
3404 untouched during the main type replacement... */
3407 set_length_in_type_chain (struct type
*type
)
3409 struct type
*ntype
= TYPE_CHAIN (type
);
3411 while (ntype
!= type
)
3413 if (ntype
->length () == 0)
3414 ntype
->set_length (type
->length ());
3416 complain_about_struct_wipeout (ntype
);
3417 ntype
= TYPE_CHAIN (ntype
);
3421 /* Read the description of a structure (or union type) and return an object
3422 describing the type.
3424 PP points to a character pointer that points to the next unconsumed token
3425 in the stabs string. For example, given stabs "A:T4=s4a:1,0,32;;",
3426 *PP will point to "4a:1,0,32;;".
3428 TYPE points to an incomplete type that needs to be filled in.
3430 OBJFILE points to the current objfile from which the stabs information is
3431 being read. (Note that it is redundant in that TYPE also contains a pointer
3432 to this same objfile, so it might be a good idea to eliminate it. FIXME).
3435 static struct type
*
3436 read_struct_type (const char **pp
, struct type
*type
, enum type_code type_code
,
3437 struct objfile
*objfile
)
3439 struct stab_field_info fi
;
3441 /* When describing struct/union/class types in stabs, G++ always drops
3442 all qualifications from the name. So if you've got:
3443 struct A { ... struct B { ... }; ... };
3444 then G++ will emit stabs for `struct A::B' that call it simply
3445 `struct B'. Obviously, if you've got a real top-level definition for
3446 `struct B', or other nested definitions, this is going to cause
3449 Obviously, GDB can't fix this by itself, but it can at least avoid
3450 scribbling on existing structure type objects when new definitions
3452 if (! (type
->code () == TYPE_CODE_UNDEF
3453 || type
->is_stub ()))
3455 complain_about_struct_wipeout (type
);
3457 /* It's probably best to return the type unchanged. */
3461 INIT_CPLUS_SPECIFIC (type
);
3462 type
->set_code (type_code
);
3463 type
->set_is_stub (false);
3465 /* First comes the total size in bytes. */
3470 type
->set_length (read_huge_number (pp
, 0, &nbits
, 0));
3472 return error_type (pp
, objfile
);
3473 set_length_in_type_chain (type
);
3476 /* Now read the baseclasses, if any, read the regular C struct or C++
3477 class member fields, attach the fields to the type, read the C++
3478 member functions, attach them to the type, and then read any tilde
3479 field (baseclass specifier for the class holding the main vtable). */
3481 if (!read_baseclasses (&fi
, pp
, type
, objfile
)
3482 || !read_struct_fields (&fi
, pp
, type
, objfile
)
3483 || !attach_fields_to_type (&fi
, type
, objfile
)
3484 || !read_member_functions (&fi
, pp
, type
, objfile
)
3485 || !attach_fn_fields_to_type (&fi
, type
)
3486 || !read_tilde_fields (&fi
, pp
, type
, objfile
))
3488 type
= error_type (pp
, objfile
);
3494 /* Read a definition of an array type,
3495 and create and return a suitable type object.
3496 Also creates a range type which represents the bounds of that
3499 static struct type
*
3500 read_array_type (const char **pp
, struct type
*type
,
3501 struct objfile
*objfile
)
3503 struct type
*index_type
, *element_type
, *range_type
;
3508 /* Format of an array type:
3509 "ar<index type>;lower;upper;<array_contents_type>".
3510 OS9000: "arlower,upper;<array_contents_type>".
3512 Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
3513 for these, produce a type like float[][]. */
3516 index_type
= read_type (pp
, objfile
);
3518 /* Improper format of array type decl. */
3519 return error_type (pp
, objfile
);
3523 if (!(**pp
>= '0' && **pp
<= '9') && **pp
!= '-')
3528 lower
= read_huge_number (pp
, ';', &nbits
, 0);
3531 return error_type (pp
, objfile
);
3533 if (!(**pp
>= '0' && **pp
<= '9') && **pp
!= '-')
3538 upper
= read_huge_number (pp
, ';', &nbits
, 0);
3540 return error_type (pp
, objfile
);
3542 element_type
= read_type (pp
, objfile
);
3551 create_static_range_type (NULL
, index_type
, lower
, upper
);
3552 type
= create_array_type (type
, element_type
, range_type
);
3558 /* Read a definition of an enumeration type,
3559 and create and return a suitable type object.
3560 Also defines the symbols that represent the values of the type. */
3562 static struct type
*
3563 read_enum_type (const char **pp
, struct type
*type
,
3564 struct objfile
*objfile
)
3566 struct gdbarch
*gdbarch
= objfile
->arch ();
3572 struct pending
**symlist
;
3573 struct pending
*osyms
, *syms
;
3576 int unsigned_enum
= 1;
3579 /* FIXME! The stabs produced by Sun CC merrily define things that ought
3580 to be file-scope, between N_FN entries, using N_LSYM. What's a mother
3581 to do? For now, force all enum values to file scope. */
3582 if (within_function
)
3583 symlist
= get_local_symbols ();
3586 symlist
= get_file_symbols ();
3588 o_nsyms
= osyms
? osyms
->nsyms
: 0;
3590 /* The aix4 compiler emits an extra field before the enum members;
3591 my guess is it's a type of some sort. Just ignore it. */
3594 /* Skip over the type. */
3598 /* Skip over the colon. */
3602 /* Read the value-names and their values.
3603 The input syntax is NAME:VALUE,NAME:VALUE, and so on.
3604 A semicolon or comma instead of a NAME means the end. */
3605 while (**pp
&& **pp
!= ';' && **pp
!= ',')
3607 STABS_CONTINUE (pp
, objfile
);
3611 name
= obstack_strndup (&objfile
->objfile_obstack
, *pp
, p
- *pp
);
3613 n
= read_huge_number (pp
, ',', &nbits
, 0);
3615 return error_type (pp
, objfile
);
3617 sym
= new (&objfile
->objfile_obstack
) symbol
;
3618 sym
->set_linkage_name (name
);
3619 sym
->set_language (get_current_subfile ()->language
,
3620 &objfile
->objfile_obstack
);
3621 sym
->set_aclass_index (LOC_CONST
);
3622 sym
->set_domain (VAR_DOMAIN
);
3623 sym
->set_value_longest (n
);
3626 add_symbol_to_list (sym
, symlist
);
3631 (*pp
)++; /* Skip the semicolon. */
3633 /* Now fill in the fields of the type-structure. */
3635 type
->set_length (gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
);
3636 set_length_in_type_chain (type
);
3637 type
->set_code (TYPE_CODE_ENUM
);
3638 type
->set_is_stub (false);
3640 type
->set_is_unsigned (true);
3641 type
->set_num_fields (nsyms
);
3644 TYPE_ALLOC (type
, sizeof (struct field
) * nsyms
));
3645 memset (type
->fields (), 0, sizeof (struct field
) * nsyms
);
3647 /* Find the symbols for the values and put them into the type.
3648 The symbols can be found in the symlist that we put them on
3649 to cause them to be defined. osyms contains the old value
3650 of that symlist; everything up to there was defined by us. */
3651 /* Note that we preserve the order of the enum constants, so
3652 that in something like "enum {FOO, LAST_THING=FOO}" we print
3653 FOO, not LAST_THING. */
3655 for (syms
= *symlist
, n
= nsyms
- 1; syms
; syms
= syms
->next
)
3657 int last
= syms
== osyms
? o_nsyms
: 0;
3658 int j
= syms
->nsyms
;
3660 for (; --j
>= last
; --n
)
3662 struct symbol
*xsym
= syms
->symbol
[j
];
3664 xsym
->set_type (type
);
3665 type
->field (n
).set_name (xsym
->linkage_name ());
3666 type
->field (n
).set_loc_enumval (xsym
->value_longest ());
3667 TYPE_FIELD_BITSIZE (type
, n
) = 0;
3676 /* Sun's ACC uses a somewhat saner method for specifying the builtin
3677 typedefs in every file (for int, long, etc):
3679 type = b <signed> <width> <format type>; <offset>; <nbits>
3681 optional format type = c or b for char or boolean.
3682 offset = offset from high order bit to start bit of type.
3683 width is # bytes in object of this type, nbits is # bits in type.
3685 The width/offset stuff appears to be for small objects stored in
3686 larger ones (e.g. `shorts' in `int' registers). We ignore it for now,
3689 static struct type
*
3690 read_sun_builtin_type (const char **pp
, int typenums
[2], struct objfile
*objfile
)
3695 int boolean_type
= 0;
3706 return error_type (pp
, objfile
);
3710 /* For some odd reason, all forms of char put a c here. This is strange
3711 because no other type has this honor. We can safely ignore this because
3712 we actually determine 'char'acterness by the number of bits specified in
3714 Boolean forms, e.g Fortran logical*X, put a b here. */
3718 else if (**pp
== 'b')
3724 /* The first number appears to be the number of bytes occupied
3725 by this type, except that unsigned short is 4 instead of 2.
3726 Since this information is redundant with the third number,
3727 we will ignore it. */
3728 read_huge_number (pp
, ';', &nbits
, 0);
3730 return error_type (pp
, objfile
);
3732 /* The second number is always 0, so ignore it too. */
3733 read_huge_number (pp
, ';', &nbits
, 0);
3735 return error_type (pp
, objfile
);
3737 /* The third number is the number of bits for this type. */
3738 type_bits
= read_huge_number (pp
, 0, &nbits
, 0);
3740 return error_type (pp
, objfile
);
3741 /* The type *should* end with a semicolon. If it are embedded
3742 in a larger type the semicolon may be the only way to know where
3743 the type ends. If this type is at the end of the stabstring we
3744 can deal with the omitted semicolon (but we don't have to like
3745 it). Don't bother to complain(), Sun's compiler omits the semicolon
3750 type_allocator
alloc (objfile
);
3753 struct type
*type
= alloc
.new_type (TYPE_CODE_VOID
,
3754 TARGET_CHAR_BIT
, nullptr);
3756 type
->set_is_unsigned (true);
3762 return init_boolean_type (alloc
, type_bits
, unsigned_type
, NULL
);
3764 return init_integer_type (alloc
, type_bits
, unsigned_type
, NULL
);
3767 static struct type
*
3768 read_sun_floating_type (const char **pp
, int typenums
[2],
3769 struct objfile
*objfile
)
3774 struct type
*rettype
;
3776 /* The first number has more details about the type, for example
3778 details
= read_huge_number (pp
, ';', &nbits
, 0);
3780 return error_type (pp
, objfile
);
3782 /* The second number is the number of bytes occupied by this type. */
3783 nbytes
= read_huge_number (pp
, ';', &nbits
, 0);
3785 return error_type (pp
, objfile
);
3787 nbits
= nbytes
* TARGET_CHAR_BIT
;
3789 if (details
== NF_COMPLEX
|| details
== NF_COMPLEX16
3790 || details
== NF_COMPLEX32
)
3792 rettype
= dbx_init_float_type (objfile
, nbits
/ 2);
3793 return init_complex_type (NULL
, rettype
);
3796 return dbx_init_float_type (objfile
, nbits
);
3799 /* Read a number from the string pointed to by *PP.
3800 The value of *PP is advanced over the number.
3801 If END is nonzero, the character that ends the
3802 number must match END, or an error happens;
3803 and that character is skipped if it does match.
3804 If END is zero, *PP is left pointing to that character.
3806 If TWOS_COMPLEMENT_BITS is set to a strictly positive value and if
3807 the number is represented in an octal representation, assume that
3808 it is represented in a 2's complement representation with a size of
3809 TWOS_COMPLEMENT_BITS.
3811 If the number fits in a long, set *BITS to 0 and return the value.
3812 If not, set *BITS to be the number of bits in the number and return 0.
3814 If encounter garbage, set *BITS to -1 and return 0. */
3817 read_huge_number (const char **pp
, int end
, int *bits
,
3818 int twos_complement_bits
)
3820 const char *p
= *pp
;
3829 int twos_complement_representation
= 0;
3837 /* Leading zero means octal. GCC uses this to output values larger
3838 than an int (because that would be hard in decimal). */
3845 /* Skip extra zeros. */
3849 if (sign
> 0 && radix
== 8 && twos_complement_bits
> 0)
3851 /* Octal, possibly signed. Check if we have enough chars for a
3857 while ((c
= *p1
) >= '0' && c
< '8')
3861 if (len
> twos_complement_bits
/ 3
3862 || (twos_complement_bits
% 3 == 0
3863 && len
== twos_complement_bits
/ 3))
3865 /* Ok, we have enough characters for a signed value, check
3866 for signedness by testing if the sign bit is set. */
3867 sign_bit
= (twos_complement_bits
% 3 + 2) % 3;
3869 if (c
& (1 << sign_bit
))
3871 /* Definitely signed. */
3872 twos_complement_representation
= 1;
3878 upper_limit
= LONG_MAX
/ radix
;
3880 while ((c
= *p
++) >= '0' && c
< ('0' + radix
))
3882 if (n
<= upper_limit
)
3884 if (twos_complement_representation
)
3886 /* Octal, signed, twos complement representation. In
3887 this case, n is the corresponding absolute value. */
3890 long sn
= c
- '0' - ((2 * (c
- '0')) | (2 << sign_bit
));
3902 /* unsigned representation */
3904 n
+= c
- '0'; /* FIXME this overflows anyway. */
3910 /* This depends on large values being output in octal, which is
3917 /* Ignore leading zeroes. */
3921 else if (c
== '2' || c
== '3')
3942 if (radix
== 8 && twos_complement_bits
> 0 && nbits
> twos_complement_bits
)
3944 /* We were supposed to parse a number with maximum
3945 TWOS_COMPLEMENT_BITS bits, but something went wrong. */
3956 /* Large decimal constants are an error (because it is hard to
3957 count how many bits are in them). */
3963 /* -0x7f is the same as 0x80. So deal with it by adding one to
3964 the number of bits. Two's complement represention octals
3965 can't have a '-' in front. */
3966 if (sign
== -1 && !twos_complement_representation
)
3977 /* It's *BITS which has the interesting information. */
3981 static struct type
*
3982 read_range_type (const char **pp
, int typenums
[2], int type_size
,
3983 struct objfile
*objfile
)
3985 struct gdbarch
*gdbarch
= objfile
->arch ();
3986 const char *orig_pp
= *pp
;
3991 struct type
*result_type
;
3992 struct type
*index_type
= NULL
;
3994 /* First comes a type we are a subrange of.
3995 In C it is usually 0, 1 or the type being defined. */
3996 if (read_type_number (pp
, rangenums
) != 0)
3997 return error_type (pp
, objfile
);
3998 self_subrange
= (rangenums
[0] == typenums
[0] &&
3999 rangenums
[1] == typenums
[1]);
4004 index_type
= read_type (pp
, objfile
);
4007 /* A semicolon should now follow; skip it. */
4011 /* The remaining two operands are usually lower and upper bounds
4012 of the range. But in some special cases they mean something else. */
4013 n2
= read_huge_number (pp
, ';', &n2bits
, type_size
);
4014 n3
= read_huge_number (pp
, ';', &n3bits
, type_size
);
4016 if (n2bits
== -1 || n3bits
== -1)
4017 return error_type (pp
, objfile
);
4019 type_allocator
alloc (objfile
);
4022 goto handle_true_range
;
4024 /* If limits are huge, must be large integral type. */
4025 if (n2bits
!= 0 || n3bits
!= 0)
4027 char got_signed
= 0;
4028 char got_unsigned
= 0;
4029 /* Number of bits in the type. */
4032 /* If a type size attribute has been specified, the bounds of
4033 the range should fit in this size. If the lower bounds needs
4034 more bits than the upper bound, then the type is signed. */
4035 if (n2bits
<= type_size
&& n3bits
<= type_size
)
4037 if (n2bits
== type_size
&& n2bits
> n3bits
)
4043 /* Range from 0 to <large number> is an unsigned large integral type. */
4044 else if ((n2bits
== 0 && n2
== 0) && n3bits
!= 0)
4049 /* Range from <large number> to <large number>-1 is a large signed
4050 integral type. Take care of the case where <large number> doesn't
4051 fit in a long but <large number>-1 does. */
4052 else if ((n2bits
!= 0 && n3bits
!= 0 && n2bits
== n3bits
+ 1)
4053 || (n2bits
!= 0 && n3bits
== 0
4054 && (n2bits
== sizeof (long) * HOST_CHAR_BIT
)
4061 if (got_signed
|| got_unsigned
)
4062 return init_integer_type (alloc
, nbits
, got_unsigned
, NULL
);
4064 return error_type (pp
, objfile
);
4067 /* A type defined as a subrange of itself, with bounds both 0, is void. */
4068 if (self_subrange
&& n2
== 0 && n3
== 0)
4069 return alloc
.new_type (TYPE_CODE_VOID
, TARGET_CHAR_BIT
, nullptr);
4071 /* If n3 is zero and n2 is positive, we want a floating type, and n2
4072 is the width in bytes.
4074 Fortran programs appear to use this for complex types also. To
4075 distinguish between floats and complex, g77 (and others?) seem
4076 to use self-subranges for the complexes, and subranges of int for
4079 Also note that for complexes, g77 sets n2 to the size of one of
4080 the member floats, not the whole complex beast. My guess is that
4081 this was to work well with pre-COMPLEX versions of gdb. */
4083 if (n3
== 0 && n2
> 0)
4085 struct type
*float_type
4086 = dbx_init_float_type (objfile
, n2
* TARGET_CHAR_BIT
);
4089 return init_complex_type (NULL
, float_type
);
4094 /* If the upper bound is -1, it must really be an unsigned integral. */
4096 else if (n2
== 0 && n3
== -1)
4098 int bits
= type_size
;
4102 /* We don't know its size. It is unsigned int or unsigned
4103 long. GCC 2.3.3 uses this for long long too, but that is
4104 just a GDB 3.5 compatibility hack. */
4105 bits
= gdbarch_int_bit (gdbarch
);
4108 return init_integer_type (alloc
, bits
, 1, NULL
);
4111 /* Special case: char is defined (Who knows why) as a subrange of
4112 itself with range 0-127. */
4113 else if (self_subrange
&& n2
== 0 && n3
== 127)
4115 struct type
*type
= init_integer_type (alloc
, TARGET_CHAR_BIT
,
4117 type
->set_has_no_signedness (true);
4120 /* We used to do this only for subrange of self or subrange of int. */
4123 /* -1 is used for the upper bound of (4 byte) "unsigned int" and
4124 "unsigned long", and we already checked for that,
4125 so don't need to test for it here. */
4128 /* n3 actually gives the size. */
4129 return init_integer_type (alloc
, -n3
* TARGET_CHAR_BIT
, 1, NULL
);
4131 /* Is n3 == 2**(8n)-1 for some integer n? Then it's an
4132 unsigned n-byte integer. But do require n to be a power of
4133 two; we don't want 3- and 5-byte integers flying around. */
4139 for (bytes
= 0; (bits
& 0xff) == 0xff; bytes
++)
4142 && ((bytes
- 1) & bytes
) == 0) /* "bytes is a power of two" */
4143 return init_integer_type (alloc
, bytes
* TARGET_CHAR_BIT
, 1, NULL
);
4146 /* I think this is for Convex "long long". Since I don't know whether
4147 Convex sets self_subrange, I also accept that particular size regardless
4148 of self_subrange. */
4149 else if (n3
== 0 && n2
< 0
4151 || n2
== -gdbarch_long_long_bit
4152 (gdbarch
) / TARGET_CHAR_BIT
))
4153 return init_integer_type (alloc
, -n2
* TARGET_CHAR_BIT
, 0, NULL
);
4154 else if (n2
== -n3
- 1)
4157 return init_integer_type (alloc
, 8, 0, NULL
);
4159 return init_integer_type (alloc
, 16, 0, NULL
);
4160 if (n3
== 0x7fffffff)
4161 return init_integer_type (alloc
, 32, 0, NULL
);
4164 /* We have a real range type on our hands. Allocate space and
4165 return a real pointer. */
4169 index_type
= objfile_type (objfile
)->builtin_int
;
4171 index_type
= *dbx_lookup_type (rangenums
, objfile
);
4172 if (index_type
== NULL
)
4174 /* Does this actually ever happen? Is that why we are worrying
4175 about dealing with it rather than just calling error_type? */
4177 complaint (_("base type %d of range type is not defined"), rangenums
[1]);
4179 index_type
= objfile_type (objfile
)->builtin_int
;
4183 = create_static_range_type (NULL
, index_type
, n2
, n3
);
4184 return (result_type
);
4187 /* Read in an argument list. This is a list of types, separated by commas
4188 and terminated with END. Return the list of types read in, or NULL
4189 if there is an error. */
4191 static struct field
*
4192 read_args (const char **pp
, int end
, struct objfile
*objfile
, int *nargsp
,
4195 /* FIXME! Remove this arbitrary limit! */
4196 struct type
*types
[1024]; /* Allow for fns of 1023 parameters. */
4203 /* Invalid argument list: no ','. */
4206 STABS_CONTINUE (pp
, objfile
);
4207 types
[n
++] = read_type (pp
, objfile
);
4209 (*pp
)++; /* get past `end' (the ':' character). */
4213 /* We should read at least the THIS parameter here. Some broken stabs
4214 output contained `(0,41),(0,42)=@s8;-16;,(0,43),(0,1);' where should
4215 have been present ";-16,(0,43)" reference instead. This way the
4216 excessive ";" marker prematurely stops the parameters parsing. */
4218 complaint (_("Invalid (empty) method arguments"));
4221 else if (types
[n
- 1]->code () != TYPE_CODE_VOID
)
4229 rval
= XCNEWVEC (struct field
, n
);
4230 for (i
= 0; i
< n
; i
++)
4231 rval
[i
].set_type (types
[i
]);
4236 /* Common block handling. */
4238 /* List of symbols declared since the last BCOMM. This list is a tail
4239 of local_symbols. When ECOMM is seen, the symbols on the list
4240 are noted so their proper addresses can be filled in later,
4241 using the common block base address gotten from the assembler
4244 static struct pending
*common_block
;
4245 static int common_block_i
;
4247 /* Name of the current common block. We get it from the BCOMM instead of the
4248 ECOMM to match IBM documentation (even though IBM puts the name both places
4249 like everyone else). */
4250 static char *common_block_name
;
4252 /* Process a N_BCOMM symbol. The storage for NAME is not guaranteed
4253 to remain after this function returns. */
4256 common_block_start (const char *name
, struct objfile
*objfile
)
4258 if (common_block_name
!= NULL
)
4260 complaint (_("Invalid symbol data: common block within common block"));
4262 common_block
= *get_local_symbols ();
4263 common_block_i
= common_block
? common_block
->nsyms
: 0;
4264 common_block_name
= obstack_strdup (&objfile
->objfile_obstack
, name
);
4267 /* Process a N_ECOMM symbol. */
4270 common_block_end (struct objfile
*objfile
)
4272 /* Symbols declared since the BCOMM are to have the common block
4273 start address added in when we know it. common_block and
4274 common_block_i point to the first symbol after the BCOMM in
4275 the local_symbols list; copy the list and hang it off the
4276 symbol for the common block name for later fixup. */
4279 struct pending
*newobj
= 0;
4280 struct pending
*next
;
4283 if (common_block_name
== NULL
)
4285 complaint (_("ECOMM symbol unmatched by BCOMM"));
4289 sym
= new (&objfile
->objfile_obstack
) symbol
;
4290 /* Note: common_block_name already saved on objfile_obstack. */
4291 sym
->set_linkage_name (common_block_name
);
4292 sym
->set_aclass_index (LOC_BLOCK
);
4294 /* Now we copy all the symbols which have been defined since the BCOMM. */
4296 /* Copy all the struct pendings before common_block. */
4297 for (next
= *get_local_symbols ();
4298 next
!= NULL
&& next
!= common_block
;
4301 for (j
= 0; j
< next
->nsyms
; j
++)
4302 add_symbol_to_list (next
->symbol
[j
], &newobj
);
4305 /* Copy however much of COMMON_BLOCK we need. If COMMON_BLOCK is
4306 NULL, it means copy all the local symbols (which we already did
4309 if (common_block
!= NULL
)
4310 for (j
= common_block_i
; j
< common_block
->nsyms
; j
++)
4311 add_symbol_to_list (common_block
->symbol
[j
], &newobj
);
4313 sym
->set_type ((struct type
*) newobj
);
4315 /* Should we be putting local_symbols back to what it was?
4318 i
= hashname (sym
->linkage_name ());
4319 sym
->set_value_chain (global_sym_chain
[i
]);
4320 global_sym_chain
[i
] = sym
;
4321 common_block_name
= NULL
;
4324 /* Add a common block's start address to the offset of each symbol
4325 declared to be in it (by being between a BCOMM/ECOMM pair that uses
4326 the common block name). */
4329 fix_common_block (struct symbol
*sym
, CORE_ADDR valu
, int section_index
)
4331 struct pending
*next
= (struct pending
*) sym
->type ();
4333 for (; next
; next
= next
->next
)
4337 for (j
= next
->nsyms
- 1; j
>= 0; j
--)
4339 next
->symbol
[j
]->set_value_address
4340 (next
->symbol
[j
]->value_address () + valu
);
4341 next
->symbol
[j
]->set_section_index (section_index
);
4348 /* Add {TYPE, TYPENUMS} to the NONAME_UNDEFS vector.
4349 See add_undefined_type for more details. */
4352 add_undefined_type_noname (struct type
*type
, int typenums
[2])
4356 nat
.typenums
[0] = typenums
[0];
4357 nat
.typenums
[1] = typenums
[1];
4360 if (noname_undefs_length
== noname_undefs_allocated
)
4362 noname_undefs_allocated
*= 2;
4363 noname_undefs
= (struct nat
*)
4364 xrealloc ((char *) noname_undefs
,
4365 noname_undefs_allocated
* sizeof (struct nat
));
4367 noname_undefs
[noname_undefs_length
++] = nat
;
4370 /* Add TYPE to the UNDEF_TYPES vector.
4371 See add_undefined_type for more details. */
4374 add_undefined_type_1 (struct type
*type
)
4376 if (undef_types_length
== undef_types_allocated
)
4378 undef_types_allocated
*= 2;
4379 undef_types
= (struct type
**)
4380 xrealloc ((char *) undef_types
,
4381 undef_types_allocated
* sizeof (struct type
*));
4383 undef_types
[undef_types_length
++] = type
;
4386 /* What about types defined as forward references inside of a small lexical
4388 /* Add a type to the list of undefined types to be checked through
4389 once this file has been read in.
4391 In practice, we actually maintain two such lists: The first list
4392 (UNDEF_TYPES) is used for types whose name has been provided, and
4393 concerns forward references (eg 'xs' or 'xu' forward references);
4394 the second list (NONAME_UNDEFS) is used for types whose name is
4395 unknown at creation time, because they were referenced through
4396 their type number before the actual type was declared.
4397 This function actually adds the given type to the proper list. */
4400 add_undefined_type (struct type
*type
, int typenums
[2])
4402 if (type
->name () == NULL
)
4403 add_undefined_type_noname (type
, typenums
);
4405 add_undefined_type_1 (type
);
4408 /* Try to fix all undefined types pushed on the UNDEF_TYPES vector. */
4411 cleanup_undefined_types_noname (struct objfile
*objfile
)
4415 for (i
= 0; i
< noname_undefs_length
; i
++)
4417 struct nat nat
= noname_undefs
[i
];
4420 type
= dbx_lookup_type (nat
.typenums
, objfile
);
4421 if (nat
.type
!= *type
&& (*type
)->code () != TYPE_CODE_UNDEF
)
4423 /* The instance flags of the undefined type are still unset,
4424 and needs to be copied over from the reference type.
4425 Since replace_type expects them to be identical, we need
4426 to set these flags manually before hand. */
4427 nat
.type
->set_instance_flags ((*type
)->instance_flags ());
4428 replace_type (nat
.type
, *type
);
4432 noname_undefs_length
= 0;
4435 /* Go through each undefined type, see if it's still undefined, and fix it
4436 up if possible. We have two kinds of undefined types:
4438 TYPE_CODE_ARRAY: Array whose target type wasn't defined yet.
4439 Fix: update array length using the element bounds
4440 and the target type's length.
4441 TYPE_CODE_STRUCT, TYPE_CODE_UNION: Structure whose fields were not
4442 yet defined at the time a pointer to it was made.
4443 Fix: Do a full lookup on the struct/union tag. */
4446 cleanup_undefined_types_1 (void)
4450 /* Iterate over every undefined type, and look for a symbol whose type
4451 matches our undefined type. The symbol matches if:
4452 1. It is a typedef in the STRUCT domain;
4453 2. It has the same name, and same type code;
4454 3. The instance flags are identical.
4456 It is important to check the instance flags, because we have seen
4457 examples where the debug info contained definitions such as:
4459 "foo_t:t30=B31=xefoo_t:"
4461 In this case, we have created an undefined type named "foo_t" whose
4462 instance flags is null (when processing "xefoo_t"), and then created
4463 another type with the same name, but with different instance flags
4464 ('B' means volatile). I think that the definition above is wrong,
4465 since the same type cannot be volatile and non-volatile at the same
4466 time, but we need to be able to cope with it when it happens. The
4467 approach taken here is to treat these two types as different. */
4469 for (type
= undef_types
; type
< undef_types
+ undef_types_length
; type
++)
4471 switch ((*type
)->code ())
4474 case TYPE_CODE_STRUCT
:
4475 case TYPE_CODE_UNION
:
4476 case TYPE_CODE_ENUM
:
4478 /* Check if it has been defined since. Need to do this here
4479 as well as in check_typedef to deal with the (legitimate in
4480 C though not C++) case of several types with the same name
4481 in different source files. */
4482 if ((*type
)->is_stub ())
4484 struct pending
*ppt
;
4486 /* Name of the type, without "struct" or "union". */
4487 const char *type_name
= (*type
)->name ();
4489 if (type_name
== NULL
)
4491 complaint (_("need a type name"));
4494 for (ppt
= *get_file_symbols (); ppt
; ppt
= ppt
->next
)
4496 for (i
= 0; i
< ppt
->nsyms
; i
++)
4498 struct symbol
*sym
= ppt
->symbol
[i
];
4500 if (sym
->aclass () == LOC_TYPEDEF
4501 && sym
->domain () == STRUCT_DOMAIN
4502 && (sym
->type ()->code () == (*type
)->code ())
4503 && ((*type
)->instance_flags ()
4504 == sym
->type ()->instance_flags ())
4505 && strcmp (sym
->linkage_name (), type_name
) == 0)
4506 replace_type (*type
, sym
->type ());
4515 complaint (_("forward-referenced types left unresolved, "
4523 undef_types_length
= 0;
4526 /* Try to fix all the undefined types we encountered while processing
4530 cleanup_undefined_stabs_types (struct objfile
*objfile
)
4532 cleanup_undefined_types_1 ();
4533 cleanup_undefined_types_noname (objfile
);
4536 /* See stabsread.h. */
4539 scan_file_globals (struct objfile
*objfile
)
4542 struct symbol
*sym
, *prev
;
4543 struct objfile
*resolve_objfile
;
4545 /* SVR4 based linkers copy referenced global symbols from shared
4546 libraries to the main executable.
4547 If we are scanning the symbols for a shared library, try to resolve
4548 them from the minimal symbols of the main executable first. */
4550 if (current_program_space
->symfile_object_file
4551 && objfile
!= current_program_space
->symfile_object_file
)
4552 resolve_objfile
= current_program_space
->symfile_object_file
;
4554 resolve_objfile
= objfile
;
4558 /* Avoid expensive loop through all minimal symbols if there are
4559 no unresolved symbols. */
4560 for (hash
= 0; hash
< HASHSIZE
; hash
++)
4562 if (global_sym_chain
[hash
])
4565 if (hash
>= HASHSIZE
)
4568 for (minimal_symbol
*msymbol
: resolve_objfile
->msymbols ())
4572 /* Skip static symbols. */
4573 switch (msymbol
->type ())
4585 /* Get the hash index and check all the symbols
4586 under that hash index. */
4588 hash
= hashname (msymbol
->linkage_name ());
4590 for (sym
= global_sym_chain
[hash
]; sym
;)
4592 if (strcmp (msymbol
->linkage_name (), sym
->linkage_name ()) == 0)
4594 /* Splice this symbol out of the hash chain and
4595 assign the value we have to it. */
4598 prev
->set_value_chain (sym
->value_chain ());
4602 global_sym_chain
[hash
] = sym
->value_chain ();
4605 /* Check to see whether we need to fix up a common block. */
4606 /* Note: this code might be executed several times for
4607 the same symbol if there are multiple references. */
4610 if (sym
->aclass () == LOC_BLOCK
)
4612 (sym
, msymbol
->value_address (resolve_objfile
),
4613 msymbol
->section_index ());
4615 sym
->set_value_address
4616 (msymbol
->value_address (resolve_objfile
));
4617 sym
->set_section_index (msymbol
->section_index ());
4622 sym
= prev
->value_chain ();
4626 sym
= global_sym_chain
[hash
];
4632 sym
= sym
->value_chain ();
4636 if (resolve_objfile
== objfile
)
4638 resolve_objfile
= objfile
;
4641 /* Change the storage class of any remaining unresolved globals to
4642 LOC_UNRESOLVED and remove them from the chain. */
4643 for (hash
= 0; hash
< HASHSIZE
; hash
++)
4645 sym
= global_sym_chain
[hash
];
4649 sym
= sym
->value_chain ();
4651 /* Change the symbol address from the misleading chain value
4653 prev
->set_value_address (0);
4655 /* Complain about unresolved common block symbols. */
4656 if (prev
->aclass () == LOC_STATIC
)
4657 prev
->set_aclass_index (LOC_UNRESOLVED
);
4659 complaint (_("%s: common block `%s' from "
4660 "global_sym_chain unresolved"),
4661 objfile_name (objfile
), prev
->print_name ());
4664 memset (global_sym_chain
, 0, sizeof (global_sym_chain
));
4667 /* Initialize anything that needs initializing when starting to read
4668 a fresh piece of a symbol file, e.g. reading in the stuff corresponding
4672 stabsread_init (void)
4676 /* Initialize anything that needs initializing when a completely new
4677 symbol file is specified (not just adding some symbols from another
4678 file, e.g. a shared library). */
4681 stabsread_new_init (void)
4683 /* Empty the hash table of global syms looking for values. */
4684 memset (global_sym_chain
, 0, sizeof (global_sym_chain
));
4687 /* Initialize anything that needs initializing at the same time as
4688 start_compunit_symtab() is called. */
4693 global_stabs
= NULL
; /* AIX COFF */
4694 /* Leave FILENUM of 0 free for builtin types and this file's types. */
4695 n_this_object_header_files
= 1;
4696 type_vector_length
= 0;
4697 type_vector
= (struct type
**) 0;
4698 within_function
= 0;
4700 /* FIXME: If common_block_name is not already NULL, we should complain(). */
4701 common_block_name
= NULL
;
4704 /* Call after end_compunit_symtab(). */
4711 xfree (type_vector
);
4714 type_vector_length
= 0;
4715 previous_stab_code
= 0;
4719 finish_global_stabs (struct objfile
*objfile
)
4723 patch_block_stabs (*get_global_symbols (), global_stabs
, objfile
);
4724 xfree (global_stabs
);
4725 global_stabs
= NULL
;
4729 /* Find the end of the name, delimited by a ':', but don't match
4730 ObjC symbols which look like -[Foo bar::]:bla. */
4732 find_name_end (const char *name
)
4734 const char *s
= name
;
4736 if (s
[0] == '-' || *s
== '+')
4738 /* Must be an ObjC method symbol. */
4741 error (_("invalid symbol name \"%s\""), name
);
4743 s
= strchr (s
, ']');
4746 error (_("invalid symbol name \"%s\""), name
);
4748 return strchr (s
, ':');
4752 return strchr (s
, ':');
4756 /* See stabsread.h. */
4759 hashname (const char *name
)
4761 return fast_hash (name
, strlen (name
)) % HASHSIZE
;
4764 /* Initializer for this module. */
4766 void _initialize_stabsread ();
4768 _initialize_stabsread ()
4770 undef_types_allocated
= 20;
4771 undef_types_length
= 0;
4772 undef_types
= XNEWVEC (struct type
*, undef_types_allocated
);
4774 noname_undefs_allocated
= 20;
4775 noname_undefs_length
= 0;
4776 noname_undefs
= XNEWVEC (struct nat
, noname_undefs_allocated
);
4778 stab_register_index
= register_symbol_register_impl (LOC_REGISTER
,
4779 &stab_register_funcs
);
4780 stab_regparm_index
= register_symbol_register_impl (LOC_REGPARM_ADDR
,
4781 &stab_register_funcs
);