1 /* Support routines for decoding "stabs" debugging information format.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
5 2008, 2009, 2010 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 /* Support routines for reading and decoding debugging information in
23 the "stabs" format. This format is used with many systems that use
24 the a.out object file format, as well as some systems that use
25 COFF or ELF where the stabs data is placed in a special section.
26 Avoid placing any object file format specific code in this file. */
29 #include "gdb_string.h"
31 #include "gdb_obstack.h"
34 #include "expression.h"
37 #include "aout/stab_gnu.h" /* We always use GNU stabs, not native */
39 #include "aout/aout64.h"
40 #include "gdb-stabs.h"
42 #include "complaints.h"
47 #include "cp-support.h"
48 #include "gdb_assert.h"
52 /* Ask stabsread.h to define the vars it normally declares `extern'. */
55 #include "stabsread.h" /* Our own declarations */
58 extern void _initialize_stabsread (void);
60 /* The routines that read and process a complete stabs for a C struct or
61 C++ class pass lists of data member fields and lists of member function
62 fields in an instance of a field_info structure, as defined below.
63 This is part of some reorganization of low level C++ support and is
64 expected to eventually go away... (FIXME) */
70 struct nextfield
*next
;
72 /* This is the raw visibility from the stab. It is not checked
73 for being one of the visibilities we recognize, so code which
74 examines this field better be able to deal. */
80 struct next_fnfieldlist
82 struct next_fnfieldlist
*next
;
83 struct fn_fieldlist fn_fieldlist
;
89 read_one_struct_field (struct field_info
*, char **, char *,
90 struct type
*, struct objfile
*);
92 static struct type
*dbx_alloc_type (int[2], struct objfile
*);
94 static long read_huge_number (char **, int, int *, int);
96 static struct type
*error_type (char **, struct objfile
*);
99 patch_block_stabs (struct pending
*, struct pending_stabs
*,
102 static void fix_common_block (struct symbol
*, int);
104 static int read_type_number (char **, int *);
106 static struct type
*read_type (char **, struct objfile
*);
108 static struct type
*read_range_type (char **, int[2], int, struct objfile
*);
110 static struct type
*read_sun_builtin_type (char **, int[2], struct objfile
*);
112 static struct type
*read_sun_floating_type (char **, int[2],
115 static struct type
*read_enum_type (char **, struct type
*, struct objfile
*);
117 static struct type
*rs6000_builtin_type (int, struct objfile
*);
120 read_member_functions (struct field_info
*, char **, struct type
*,
124 read_struct_fields (struct field_info
*, char **, struct type
*,
128 read_baseclasses (struct field_info
*, char **, struct type
*,
132 read_tilde_fields (struct field_info
*, char **, struct type
*,
135 static int attach_fn_fields_to_type (struct field_info
*, struct type
*);
137 static int attach_fields_to_type (struct field_info
*, struct type
*,
140 static struct type
*read_struct_type (char **, struct type
*,
144 static struct type
*read_array_type (char **, struct type
*,
147 static struct field
*read_args (char **, int, struct objfile
*, int *, int *);
149 static void add_undefined_type (struct type
*, int[2]);
152 read_cpp_abbrev (struct field_info
*, char **, struct type
*,
155 static char *find_name_end (char *name
);
157 static int process_reference (char **string
);
159 void stabsread_clear_cache (void);
161 static const char vptr_name
[] = "_vptr$";
162 static const char vb_name
[] = "_vb$";
165 invalid_cpp_abbrev_complaint (const char *arg1
)
167 complaint (&symfile_complaints
, _("invalid C++ abbreviation `%s'"), arg1
);
171 reg_value_complaint (int regnum
, int num_regs
, const char *sym
)
173 complaint (&symfile_complaints
,
174 _("register number %d too large (max %d) in symbol %s"),
175 regnum
, num_regs
- 1, sym
);
179 stabs_general_complaint (const char *arg1
)
181 complaint (&symfile_complaints
, "%s", arg1
);
184 /* Make a list of forward references which haven't been defined. */
186 static struct type
**undef_types
;
187 static int undef_types_allocated
;
188 static int undef_types_length
;
189 static struct symbol
*current_symbol
= NULL
;
191 /* Make a list of nameless types that are undefined.
192 This happens when another type is referenced by its number
193 before this type is actually defined. For instance "t(0,1)=k(0,2)"
194 and type (0,2) is defined only later. */
201 static struct nat
*noname_undefs
;
202 static int noname_undefs_allocated
;
203 static int noname_undefs_length
;
205 /* Check for and handle cretinous stabs symbol name continuation! */
206 #define STABS_CONTINUE(pp,objfile) \
208 if (**(pp) == '\\' || (**(pp) == '?' && (*(pp))[1] == '\0')) \
209 *(pp) = next_symbol_text (objfile); \
213 /* Look up a dbx type-number pair. Return the address of the slot
214 where the type for that number-pair is stored.
215 The number-pair is in TYPENUMS.
217 This can be used for finding the type associated with that pair
218 or for associating a new type with the pair. */
220 static struct type
**
221 dbx_lookup_type (int typenums
[2], struct objfile
*objfile
)
223 int filenum
= typenums
[0];
224 int index
= typenums
[1];
227 struct header_file
*f
;
230 if (filenum
== -1) /* -1,-1 is for temporary types. */
233 if (filenum
< 0 || filenum
>= n_this_object_header_files
)
235 complaint (&symfile_complaints
,
236 _("Invalid symbol data: type number (%d,%d) out of range at symtab pos %d."),
237 filenum
, index
, symnum
);
245 /* Caller wants address of address of type. We think
246 that negative (rs6k builtin) types will never appear as
247 "lvalues", (nor should they), so we stuff the real type
248 pointer into a temp, and return its address. If referenced,
249 this will do the right thing. */
250 static struct type
*temp_type
;
252 temp_type
= rs6000_builtin_type (index
, objfile
);
256 /* Type is defined outside of header files.
257 Find it in this object file's type vector. */
258 if (index
>= type_vector_length
)
260 old_len
= type_vector_length
;
263 type_vector_length
= INITIAL_TYPE_VECTOR_LENGTH
;
264 type_vector
= (struct type
**)
265 xmalloc (type_vector_length
* sizeof (struct type
*));
267 while (index
>= type_vector_length
)
269 type_vector_length
*= 2;
271 type_vector
= (struct type
**)
272 xrealloc ((char *) type_vector
,
273 (type_vector_length
* sizeof (struct type
*)));
274 memset (&type_vector
[old_len
], 0,
275 (type_vector_length
- old_len
) * sizeof (struct type
*));
277 return (&type_vector
[index
]);
281 real_filenum
= this_object_header_files
[filenum
];
283 if (real_filenum
>= N_HEADER_FILES (objfile
))
285 static struct type
*temp_type
;
287 warning (_("GDB internal error: bad real_filenum"));
290 temp_type
= objfile_type (objfile
)->builtin_error
;
294 f
= HEADER_FILES (objfile
) + real_filenum
;
296 f_orig_length
= f
->length
;
297 if (index
>= f_orig_length
)
299 while (index
>= f
->length
)
303 f
->vector
= (struct type
**)
304 xrealloc ((char *) f
->vector
, f
->length
* sizeof (struct type
*));
305 memset (&f
->vector
[f_orig_length
], 0,
306 (f
->length
- f_orig_length
) * sizeof (struct type
*));
308 return (&f
->vector
[index
]);
312 /* Make sure there is a type allocated for type numbers TYPENUMS
313 and return the type object.
314 This can create an empty (zeroed) type object.
315 TYPENUMS may be (-1, -1) to return a new type object that is not
316 put into the type vector, and so may not be referred to by number. */
319 dbx_alloc_type (int typenums
[2], struct objfile
*objfile
)
321 struct type
**type_addr
;
323 if (typenums
[0] == -1)
325 return (alloc_type (objfile
));
328 type_addr
= dbx_lookup_type (typenums
, objfile
);
330 /* If we are referring to a type not known at all yet,
331 allocate an empty type for it.
332 We will fill it in later if we find out how. */
335 *type_addr
= alloc_type (objfile
);
341 /* for all the stabs in a given stab vector, build appropriate types
342 and fix their symbols in given symbol vector. */
345 patch_block_stabs (struct pending
*symbols
, struct pending_stabs
*stabs
,
346 struct objfile
*objfile
)
356 /* for all the stab entries, find their corresponding symbols and
357 patch their types! */
359 for (ii
= 0; ii
< stabs
->count
; ++ii
)
361 name
= stabs
->stab
[ii
];
362 pp
= (char *) strchr (name
, ':');
363 gdb_assert (pp
); /* Must find a ':' or game's over. */
367 pp
= (char *) strchr (pp
, ':');
369 sym
= find_symbol_in_list (symbols
, name
, pp
- name
);
372 /* FIXME-maybe: it would be nice if we noticed whether
373 the variable was defined *anywhere*, not just whether
374 it is defined in this compilation unit. But neither
375 xlc or GCC seem to need such a definition, and until
376 we do psymtabs (so that the minimal symbols from all
377 compilation units are available now), I'm not sure
378 how to get the information. */
380 /* On xcoff, if a global is defined and never referenced,
381 ld will remove it from the executable. There is then
382 a N_GSYM stab for it, but no regular (C_EXT) symbol. */
383 sym
= (struct symbol
*)
384 obstack_alloc (&objfile
->objfile_obstack
,
385 sizeof (struct symbol
));
387 memset (sym
, 0, sizeof (struct symbol
));
388 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
389 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
390 SYMBOL_SET_LINKAGE_NAME
391 (sym
, obsavestring (name
, pp
- name
,
392 &objfile
->objfile_obstack
));
394 if (*(pp
- 1) == 'F' || *(pp
- 1) == 'f')
396 /* I don't think the linker does this with functions,
397 so as far as I know this is never executed.
398 But it doesn't hurt to check. */
400 lookup_function_type (read_type (&pp
, objfile
));
404 SYMBOL_TYPE (sym
) = read_type (&pp
, objfile
);
406 add_symbol_to_list (sym
, &global_symbols
);
411 if (*(pp
- 1) == 'F' || *(pp
- 1) == 'f')
414 lookup_function_type (read_type (&pp
, objfile
));
418 SYMBOL_TYPE (sym
) = read_type (&pp
, objfile
);
426 /* Read a number by which a type is referred to in dbx data,
427 or perhaps read a pair (FILENUM, TYPENUM) in parentheses.
428 Just a single number N is equivalent to (0,N).
429 Return the two numbers by storing them in the vector TYPENUMS.
430 TYPENUMS will then be used as an argument to dbx_lookup_type.
432 Returns 0 for success, -1 for error. */
435 read_type_number (char **pp
, int *typenums
)
441 typenums
[0] = read_huge_number (pp
, ',', &nbits
, 0);
444 typenums
[1] = read_huge_number (pp
, ')', &nbits
, 0);
451 typenums
[1] = read_huge_number (pp
, 0, &nbits
, 0);
459 #define VISIBILITY_PRIVATE '0' /* Stabs character for private field */
460 #define VISIBILITY_PROTECTED '1' /* Stabs character for protected fld */
461 #define VISIBILITY_PUBLIC '2' /* Stabs character for public field */
462 #define VISIBILITY_IGNORE '9' /* Optimized out or zero length */
464 /* Structure for storing pointers to reference definitions for fast lookup
465 during "process_later". */
474 #define MAX_CHUNK_REFS 100
475 #define REF_CHUNK_SIZE (MAX_CHUNK_REFS * sizeof (struct ref_map))
476 #define REF_MAP_SIZE(ref_chunk) ((ref_chunk) * REF_CHUNK_SIZE)
478 static struct ref_map
*ref_map
;
480 /* Ptr to free cell in chunk's linked list. */
481 static int ref_count
= 0;
483 /* Number of chunks malloced. */
484 static int ref_chunk
= 0;
486 /* This file maintains a cache of stabs aliases found in the symbol
487 table. If the symbol table changes, this cache must be cleared
488 or we are left holding onto data in invalid obstacks. */
490 stabsread_clear_cache (void)
496 /* Create array of pointers mapping refids to symbols and stab strings.
497 Add pointers to reference definition symbols and/or their values as we
498 find them, using their reference numbers as our index.
499 These will be used later when we resolve references. */
501 ref_add (int refnum
, struct symbol
*sym
, char *stabs
, CORE_ADDR value
)
505 if (refnum
>= ref_count
)
506 ref_count
= refnum
+ 1;
507 if (ref_count
> ref_chunk
* MAX_CHUNK_REFS
)
509 int new_slots
= ref_count
- ref_chunk
* MAX_CHUNK_REFS
;
510 int new_chunks
= new_slots
/ MAX_CHUNK_REFS
+ 1;
511 ref_map
= (struct ref_map
*)
512 xrealloc (ref_map
, REF_MAP_SIZE (ref_chunk
+ new_chunks
));
513 memset (ref_map
+ ref_chunk
* MAX_CHUNK_REFS
, 0, new_chunks
* REF_CHUNK_SIZE
);
514 ref_chunk
+= new_chunks
;
516 ref_map
[refnum
].stabs
= stabs
;
517 ref_map
[refnum
].sym
= sym
;
518 ref_map
[refnum
].value
= value
;
521 /* Return defined sym for the reference REFNUM. */
523 ref_search (int refnum
)
525 if (refnum
< 0 || refnum
> ref_count
)
527 return ref_map
[refnum
].sym
;
530 /* Parse a reference id in STRING and return the resulting
531 reference number. Move STRING beyond the reference id. */
534 process_reference (char **string
)
542 /* Advance beyond the initial '#'. */
545 /* Read number as reference id. */
546 while (*p
&& isdigit (*p
))
548 refnum
= refnum
* 10 + *p
- '0';
555 /* If STRING defines a reference, store away a pointer to the reference
556 definition for later use. Return the reference number. */
559 symbol_reference_defined (char **string
)
564 refnum
= process_reference (&p
);
566 /* Defining symbols end in '=' */
569 /* Symbol is being defined here. */
575 /* Must be a reference. Either the symbol has already been defined,
576 or this is a forward reference to it. */
583 stab_reg_to_regnum (struct symbol
*sym
, struct gdbarch
*gdbarch
)
585 int regno
= gdbarch_stab_reg_to_regnum (gdbarch
, SYMBOL_VALUE (sym
));
587 if (regno
>= gdbarch_num_regs (gdbarch
)
588 + gdbarch_num_pseudo_regs (gdbarch
))
590 reg_value_complaint (regno
,
591 gdbarch_num_regs (gdbarch
)
592 + gdbarch_num_pseudo_regs (gdbarch
),
593 SYMBOL_PRINT_NAME (sym
));
595 regno
= gdbarch_sp_regnum (gdbarch
); /* Known safe, though useless */
601 static const struct symbol_register_ops stab_register_funcs
= {
606 define_symbol (CORE_ADDR valu
, char *string
, int desc
, int type
,
607 struct objfile
*objfile
)
609 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
611 char *p
= (char *) find_name_end (string
);
615 char *new_name
= NULL
;
617 /* We would like to eliminate nameless symbols, but keep their types.
618 E.g. stab entry ":t10=*2" should produce a type 10, which is a pointer
619 to type 2, but, should not create a symbol to address that type. Since
620 the symbol will be nameless, there is no way any user can refer to it. */
624 /* Ignore syms with empty names. */
628 /* Ignore old-style symbols from cc -go */
638 /* If a nameless stab entry, all we need is the type, not the symbol.
639 e.g. ":t10=*2" or a nameless enum like " :T16=ered:0,green:1,blue:2,;" */
640 nameless
= (p
== string
|| ((string
[0] == ' ') && (string
[1] == ':')));
642 current_symbol
= sym
= (struct symbol
*)
643 obstack_alloc (&objfile
->objfile_obstack
, sizeof (struct symbol
));
644 memset (sym
, 0, sizeof (struct symbol
));
646 switch (type
& N_TYPE
)
649 SYMBOL_SECTION (sym
) = SECT_OFF_TEXT (objfile
);
652 SYMBOL_SECTION (sym
) = SECT_OFF_DATA (objfile
);
655 SYMBOL_SECTION (sym
) = SECT_OFF_BSS (objfile
);
659 if (processing_gcc_compilation
)
661 /* GCC 2.x puts the line number in desc. SunOS apparently puts in the
662 number of bytes occupied by a type or object, which we ignore. */
663 SYMBOL_LINE (sym
) = desc
;
667 SYMBOL_LINE (sym
) = 0; /* unknown */
670 if (is_cplus_marker (string
[0]))
672 /* Special GNU C++ names. */
676 SYMBOL_SET_LINKAGE_NAME (sym
, "this");
679 case 'v': /* $vtbl_ptr_type */
683 SYMBOL_SET_LINKAGE_NAME (sym
, "eh_throw");
687 /* This was an anonymous type that was never fixed up. */
691 /* SunPRO (3.0 at least) static variable encoding. */
692 if (gdbarch_static_transform_name_p (gdbarch
))
694 /* ... fall through ... */
697 complaint (&symfile_complaints
, _("Unknown C++ symbol name `%s'"),
699 goto normal
; /* Do *something* with it */
705 SYMBOL_LANGUAGE (sym
) = current_subfile
->language
;
706 if (SYMBOL_LANGUAGE (sym
) == language_cplus
)
708 char *name
= alloca (p
- string
+ 1);
709 memcpy (name
, string
, p
- string
);
710 name
[p
- string
] = '\0';
711 new_name
= cp_canonicalize_string (name
);
712 cp_scan_for_anonymous_namespaces (sym
);
714 if (new_name
!= NULL
)
716 SYMBOL_SET_NAMES (sym
, new_name
, strlen (new_name
), 1, objfile
);
720 SYMBOL_SET_NAMES (sym
, string
, p
- string
, 1, objfile
);
724 /* Determine the type of name being defined. */
726 /* Getting GDB to correctly skip the symbol on an undefined symbol
727 descriptor and not ever dump core is a very dodgy proposition if
728 we do things this way. I say the acorn RISC machine can just
729 fix their compiler. */
730 /* The Acorn RISC machine's compiler can put out locals that don't
731 start with "234=" or "(3,4)=", so assume anything other than the
732 deftypes we know how to handle is a local. */
733 if (!strchr ("cfFGpPrStTvVXCR", *p
))
735 if (isdigit (*p
) || *p
== '(' || *p
== '-')
744 /* c is a special case, not followed by a type-number.
745 SYMBOL:c=iVALUE for an integer constant symbol.
746 SYMBOL:c=rVALUE for a floating constant symbol.
747 SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
748 e.g. "b:c=e6,0" for "const b = blob1"
749 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
752 SYMBOL_CLASS (sym
) = LOC_CONST
;
753 SYMBOL_TYPE (sym
) = error_type (&p
, objfile
);
754 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
755 add_symbol_to_list (sym
, &file_symbols
);
765 struct type
*dbl_type
;
767 /* FIXME-if-picky-about-floating-accuracy: Should be using
768 target arithmetic to get the value. real.c in GCC
769 probably has the necessary code. */
771 dbl_type
= objfile_type (objfile
)->builtin_double
;
773 obstack_alloc (&objfile
->objfile_obstack
,
774 TYPE_LENGTH (dbl_type
));
775 store_typed_floating (dbl_valu
, dbl_type
, d
);
777 SYMBOL_TYPE (sym
) = dbl_type
;
778 SYMBOL_VALUE_BYTES (sym
) = dbl_valu
;
779 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
784 /* Defining integer constants this way is kind of silly,
785 since 'e' constants allows the compiler to give not
786 only the value, but the type as well. C has at least
787 int, long, unsigned int, and long long as constant
788 types; other languages probably should have at least
789 unsigned as well as signed constants. */
791 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_long
;
792 SYMBOL_VALUE (sym
) = atoi (p
);
793 SYMBOL_CLASS (sym
) = LOC_CONST
;
797 /* SYMBOL:c=eTYPE,INTVALUE for a constant symbol whose value
798 can be represented as integral.
799 e.g. "b:c=e6,0" for "const b = blob1"
800 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
802 SYMBOL_CLASS (sym
) = LOC_CONST
;
803 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
807 SYMBOL_TYPE (sym
) = error_type (&p
, objfile
);
812 /* If the value is too big to fit in an int (perhaps because
813 it is unsigned), or something like that, we silently get
814 a bogus value. The type and everything else about it is
815 correct. Ideally, we should be using whatever we have
816 available for parsing unsigned and long long values,
818 SYMBOL_VALUE (sym
) = atoi (p
);
823 SYMBOL_CLASS (sym
) = LOC_CONST
;
824 SYMBOL_TYPE (sym
) = error_type (&p
, objfile
);
827 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
828 add_symbol_to_list (sym
, &file_symbols
);
832 /* The name of a caught exception. */
833 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
834 SYMBOL_CLASS (sym
) = LOC_LABEL
;
835 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
836 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
837 add_symbol_to_list (sym
, &local_symbols
);
841 /* A static function definition. */
842 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
843 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
844 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
845 add_symbol_to_list (sym
, &file_symbols
);
846 /* fall into process_function_types. */
848 process_function_types
:
849 /* Function result types are described as the result type in stabs.
850 We need to convert this to the function-returning-type-X type
851 in GDB. E.g. "int" is converted to "function returning int". */
852 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_FUNC
)
853 SYMBOL_TYPE (sym
) = lookup_function_type (SYMBOL_TYPE (sym
));
855 /* All functions in C++ have prototypes. Stabs does not offer an
856 explicit way to identify prototyped or unprototyped functions,
857 but both GCC and Sun CC emit stabs for the "call-as" type rather
858 than the "declared-as" type for unprototyped functions, so
859 we treat all functions as if they were prototyped. This is used
860 primarily for promotion when calling the function from GDB. */
861 TYPE_PROTOTYPED (SYMBOL_TYPE (sym
)) = 1;
863 /* fall into process_prototype_types */
865 process_prototype_types
:
866 /* Sun acc puts declared types of arguments here. */
869 struct type
*ftype
= SYMBOL_TYPE (sym
);
874 /* Obtain a worst case guess for the number of arguments
875 by counting the semicolons. */
882 /* Allocate parameter information fields and fill them in. */
883 TYPE_FIELDS (ftype
) = (struct field
*)
884 TYPE_ALLOC (ftype
, nsemi
* sizeof (struct field
));
889 /* A type number of zero indicates the start of varargs.
890 FIXME: GDB currently ignores vararg functions. */
891 if (p
[0] == '0' && p
[1] == '\0')
893 ptype
= read_type (&p
, objfile
);
895 /* The Sun compilers mark integer arguments, which should
896 be promoted to the width of the calling conventions, with
897 a type which references itself. This type is turned into
898 a TYPE_CODE_VOID type by read_type, and we have to turn
899 it back into builtin_int here.
900 FIXME: Do we need a new builtin_promoted_int_arg ? */
901 if (TYPE_CODE (ptype
) == TYPE_CODE_VOID
)
902 ptype
= objfile_type (objfile
)->builtin_int
;
903 TYPE_FIELD_TYPE (ftype
, nparams
) = ptype
;
904 TYPE_FIELD_ARTIFICIAL (ftype
, nparams
++) = 0;
906 TYPE_NFIELDS (ftype
) = nparams
;
907 TYPE_PROTOTYPED (ftype
) = 1;
912 /* A global function definition. */
913 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
914 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
915 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
916 add_symbol_to_list (sym
, &global_symbols
);
917 goto process_function_types
;
920 /* For a class G (global) symbol, it appears that the
921 value is not correct. It is necessary to search for the
922 corresponding linker definition to find the value.
923 These definitions appear at the end of the namelist. */
924 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
925 SYMBOL_CLASS (sym
) = LOC_STATIC
;
926 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
927 /* Don't add symbol references to global_sym_chain.
928 Symbol references don't have valid names and wont't match up with
929 minimal symbols when the global_sym_chain is relocated.
930 We'll fixup symbol references when we fixup the defining symbol. */
931 if (SYMBOL_LINKAGE_NAME (sym
) && SYMBOL_LINKAGE_NAME (sym
)[0] != '#')
933 i
= hashname (SYMBOL_LINKAGE_NAME (sym
));
934 SYMBOL_VALUE_CHAIN (sym
) = global_sym_chain
[i
];
935 global_sym_chain
[i
] = sym
;
937 add_symbol_to_list (sym
, &global_symbols
);
940 /* This case is faked by a conditional above,
941 when there is no code letter in the dbx data.
942 Dbx data never actually contains 'l'. */
945 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
946 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
947 SYMBOL_VALUE (sym
) = valu
;
948 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
949 add_symbol_to_list (sym
, &local_symbols
);
954 /* pF is a two-letter code that means a function parameter in Fortran.
955 The type-number specifies the type of the return value.
956 Translate it into a pointer-to-function type. */
960 = lookup_pointer_type
961 (lookup_function_type (read_type (&p
, objfile
)));
964 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
966 SYMBOL_CLASS (sym
) = LOC_ARG
;
967 SYMBOL_VALUE (sym
) = valu
;
968 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
969 SYMBOL_IS_ARGUMENT (sym
) = 1;
970 add_symbol_to_list (sym
, &local_symbols
);
972 if (gdbarch_byte_order (gdbarch
) != BFD_ENDIAN_BIG
)
974 /* On little-endian machines, this crud is never necessary,
975 and, if the extra bytes contain garbage, is harmful. */
979 /* If it's gcc-compiled, if it says `short', believe it. */
980 if (processing_gcc_compilation
981 || gdbarch_believe_pcc_promotion (gdbarch
))
984 if (!gdbarch_believe_pcc_promotion (gdbarch
))
986 /* If PCC says a parameter is a short or a char, it is
988 if (TYPE_LENGTH (SYMBOL_TYPE (sym
))
989 < gdbarch_int_bit (gdbarch
) / TARGET_CHAR_BIT
990 && TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_INT
)
993 TYPE_UNSIGNED (SYMBOL_TYPE (sym
))
994 ? objfile_type (objfile
)->builtin_unsigned_int
995 : objfile_type (objfile
)->builtin_int
;
1001 /* acc seems to use P to declare the prototypes of functions that
1002 are referenced by this file. gdb is not prepared to deal
1003 with this extra information. FIXME, it ought to. */
1006 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1007 goto process_prototype_types
;
1012 /* Parameter which is in a register. */
1013 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1014 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
1015 SYMBOL_REGISTER_OPS (sym
) = &stab_register_funcs
;
1016 SYMBOL_IS_ARGUMENT (sym
) = 1;
1017 SYMBOL_VALUE (sym
) = valu
;
1018 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
1019 add_symbol_to_list (sym
, &local_symbols
);
1023 /* Register variable (either global or local). */
1024 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1025 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
1026 SYMBOL_REGISTER_OPS (sym
) = &stab_register_funcs
;
1027 SYMBOL_VALUE (sym
) = valu
;
1028 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
1029 if (within_function
)
1031 /* Sun cc uses a pair of symbols, one 'p' and one 'r', with
1032 the same name to represent an argument passed in a
1033 register. GCC uses 'P' for the same case. So if we find
1034 such a symbol pair we combine it into one 'P' symbol.
1035 For Sun cc we need to do this regardless of
1036 stabs_argument_has_addr, because the compiler puts out
1037 the 'p' symbol even if it never saves the argument onto
1040 On most machines, we want to preserve both symbols, so
1041 that we can still get information about what is going on
1042 with the stack (VAX for computing args_printed, using
1043 stack slots instead of saved registers in backtraces,
1046 Note that this code illegally combines
1047 main(argc) struct foo argc; { register struct foo argc; }
1048 but this case is considered pathological and causes a warning
1049 from a decent compiler. */
1052 && local_symbols
->nsyms
> 0
1053 && gdbarch_stabs_argument_has_addr (gdbarch
, SYMBOL_TYPE (sym
)))
1055 struct symbol
*prev_sym
;
1056 prev_sym
= local_symbols
->symbol
[local_symbols
->nsyms
- 1];
1057 if ((SYMBOL_CLASS (prev_sym
) == LOC_REF_ARG
1058 || SYMBOL_CLASS (prev_sym
) == LOC_ARG
)
1059 && strcmp (SYMBOL_LINKAGE_NAME (prev_sym
),
1060 SYMBOL_LINKAGE_NAME (sym
)) == 0)
1062 SYMBOL_CLASS (prev_sym
) = LOC_REGISTER
;
1063 SYMBOL_REGISTER_OPS (prev_sym
) = &stab_register_funcs
;
1064 /* Use the type from the LOC_REGISTER; that is the type
1065 that is actually in that register. */
1066 SYMBOL_TYPE (prev_sym
) = SYMBOL_TYPE (sym
);
1067 SYMBOL_VALUE (prev_sym
) = SYMBOL_VALUE (sym
);
1072 add_symbol_to_list (sym
, &local_symbols
);
1075 add_symbol_to_list (sym
, &file_symbols
);
1079 /* Static symbol at top level of file */
1080 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1081 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1082 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
1083 if (gdbarch_static_transform_name_p (gdbarch
)
1084 && gdbarch_static_transform_name (gdbarch
,
1085 SYMBOL_LINKAGE_NAME (sym
))
1086 != SYMBOL_LINKAGE_NAME (sym
))
1088 struct minimal_symbol
*msym
;
1089 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
), NULL
, objfile
);
1092 char *new_name
= gdbarch_static_transform_name
1093 (gdbarch
, SYMBOL_LINKAGE_NAME (sym
));
1094 SYMBOL_SET_LINKAGE_NAME (sym
, new_name
);
1095 SYMBOL_VALUE_ADDRESS (sym
) = SYMBOL_VALUE_ADDRESS (msym
);
1098 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
1099 add_symbol_to_list (sym
, &file_symbols
);
1103 /* In Ada, there is no distinction between typedef and non-typedef;
1104 any type declaration implicitly has the equivalent of a typedef,
1105 and thus 't' is in fact equivalent to 'Tt'.
1107 Therefore, for Ada units, we check the character immediately
1108 before the 't', and if we do not find a 'T', then make sure to
1109 create the associated symbol in the STRUCT_DOMAIN ('t' definitions
1110 will be stored in the VAR_DOMAIN). If the symbol was indeed
1111 defined as 'Tt' then the STRUCT_DOMAIN symbol will be created
1112 elsewhere, so we don't need to take care of that.
1114 This is important to do, because of forward references:
1115 The cleanup of undefined types stored in undef_types only uses
1116 STRUCT_DOMAIN symbols to perform the replacement. */
1117 synonym
= (SYMBOL_LANGUAGE (sym
) == language_ada
&& p
[-2] != 'T');
1120 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1122 /* For a nameless type, we don't want a create a symbol, thus we
1123 did not use `sym'. Return without further processing. */
1127 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1128 SYMBOL_VALUE (sym
) = valu
;
1129 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
1130 /* C++ vagaries: we may have a type which is derived from
1131 a base type which did not have its name defined when the
1132 derived class was output. We fill in the derived class's
1133 base part member's name here in that case. */
1134 if (TYPE_NAME (SYMBOL_TYPE (sym
)) != NULL
)
1135 if ((TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
1136 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_UNION
)
1137 && TYPE_N_BASECLASSES (SYMBOL_TYPE (sym
)))
1140 for (j
= TYPE_N_BASECLASSES (SYMBOL_TYPE (sym
)) - 1; j
>= 0; j
--)
1141 if (TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym
), j
) == 0)
1142 TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym
), j
) =
1143 type_name_no_tag (TYPE_BASECLASS (SYMBOL_TYPE (sym
), j
));
1146 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == NULL
)
1148 /* gcc-2.6 or later (when using -fvtable-thunks)
1149 emits a unique named type for a vtable entry.
1150 Some gdb code depends on that specific name. */
1151 extern const char vtbl_ptr_name
[];
1153 if ((TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_PTR
1154 && strcmp (SYMBOL_LINKAGE_NAME (sym
), vtbl_ptr_name
))
1155 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FUNC
)
1157 /* If we are giving a name to a type such as "pointer to
1158 foo" or "function returning foo", we better not set
1159 the TYPE_NAME. If the program contains "typedef char
1160 *caddr_t;", we don't want all variables of type char
1161 * to print as caddr_t. This is not just a
1162 consequence of GDB's type management; PCC and GCC (at
1163 least through version 2.4) both output variables of
1164 either type char * or caddr_t with the type number
1165 defined in the 't' symbol for caddr_t. If a future
1166 compiler cleans this up it GDB is not ready for it
1167 yet, but if it becomes ready we somehow need to
1168 disable this check (without breaking the PCC/GCC2.4
1173 Fortunately, this check seems not to be necessary
1174 for anything except pointers or functions. */
1175 /* ezannoni: 2000-10-26. This seems to apply for
1176 versions of gcc older than 2.8. This was the original
1177 problem: with the following code gdb would tell that
1178 the type for name1 is caddr_t, and func is char()
1179 typedef char *caddr_t;
1191 /* Pascal accepts names for pointer types. */
1192 if (current_subfile
->language
== language_pascal
)
1194 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_LINKAGE_NAME (sym
);
1198 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_LINKAGE_NAME (sym
);
1201 add_symbol_to_list (sym
, &file_symbols
);
1205 /* Create the STRUCT_DOMAIN clone. */
1206 struct symbol
*struct_sym
= (struct symbol
*)
1207 obstack_alloc (&objfile
->objfile_obstack
, sizeof (struct symbol
));
1210 SYMBOL_CLASS (struct_sym
) = LOC_TYPEDEF
;
1211 SYMBOL_VALUE (struct_sym
) = valu
;
1212 SYMBOL_DOMAIN (struct_sym
) = STRUCT_DOMAIN
;
1213 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
1214 TYPE_NAME (SYMBOL_TYPE (sym
))
1215 = obconcat (&objfile
->objfile_obstack
, "", "",
1216 SYMBOL_LINKAGE_NAME (sym
));
1217 add_symbol_to_list (struct_sym
, &file_symbols
);
1223 /* Struct, union, or enum tag. For GNU C++, this can be be followed
1224 by 't' which means we are typedef'ing it as well. */
1225 synonym
= *p
== 't';
1230 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1232 /* For a nameless type, we don't want a create a symbol, thus we
1233 did not use `sym'. Return without further processing. */
1237 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1238 SYMBOL_VALUE (sym
) = valu
;
1239 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
1240 if (TYPE_TAG_NAME (SYMBOL_TYPE (sym
)) == 0)
1241 TYPE_TAG_NAME (SYMBOL_TYPE (sym
))
1242 = obconcat (&objfile
->objfile_obstack
, "", "",
1243 SYMBOL_LINKAGE_NAME (sym
));
1244 add_symbol_to_list (sym
, &file_symbols
);
1248 /* Clone the sym and then modify it. */
1249 struct symbol
*typedef_sym
= (struct symbol
*)
1250 obstack_alloc (&objfile
->objfile_obstack
, sizeof (struct symbol
));
1251 *typedef_sym
= *sym
;
1252 SYMBOL_CLASS (typedef_sym
) = LOC_TYPEDEF
;
1253 SYMBOL_VALUE (typedef_sym
) = valu
;
1254 SYMBOL_DOMAIN (typedef_sym
) = VAR_DOMAIN
;
1255 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
1256 TYPE_NAME (SYMBOL_TYPE (sym
))
1257 = obconcat (&objfile
->objfile_obstack
, "", "",
1258 SYMBOL_LINKAGE_NAME (sym
));
1259 add_symbol_to_list (typedef_sym
, &file_symbols
);
1264 /* Static symbol of local scope */
1265 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1266 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1267 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
1268 if (gdbarch_static_transform_name_p (gdbarch
)
1269 && gdbarch_static_transform_name (gdbarch
,
1270 SYMBOL_LINKAGE_NAME (sym
))
1271 != SYMBOL_LINKAGE_NAME (sym
))
1273 struct minimal_symbol
*msym
;
1274 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
), NULL
, objfile
);
1277 char *new_name
= gdbarch_static_transform_name
1278 (gdbarch
, SYMBOL_LINKAGE_NAME (sym
));
1279 SYMBOL_SET_LINKAGE_NAME (sym
, new_name
);
1280 SYMBOL_VALUE_ADDRESS (sym
) = SYMBOL_VALUE_ADDRESS (msym
);
1283 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
1284 add_symbol_to_list (sym
, &local_symbols
);
1288 /* Reference parameter */
1289 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1290 SYMBOL_CLASS (sym
) = LOC_REF_ARG
;
1291 SYMBOL_IS_ARGUMENT (sym
) = 1;
1292 SYMBOL_VALUE (sym
) = valu
;
1293 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
1294 add_symbol_to_list (sym
, &local_symbols
);
1298 /* Reference parameter which is in a register. */
1299 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1300 SYMBOL_CLASS (sym
) = LOC_REGPARM_ADDR
;
1301 SYMBOL_REGISTER_OPS (sym
) = &stab_register_funcs
;
1302 SYMBOL_IS_ARGUMENT (sym
) = 1;
1303 SYMBOL_VALUE (sym
) = valu
;
1304 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
1305 add_symbol_to_list (sym
, &local_symbols
);
1309 /* This is used by Sun FORTRAN for "function result value".
1310 Sun claims ("dbx and dbxtool interfaces", 2nd ed)
1311 that Pascal uses it too, but when I tried it Pascal used
1312 "x:3" (local symbol) instead. */
1313 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1314 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
1315 SYMBOL_VALUE (sym
) = valu
;
1316 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
1317 add_symbol_to_list (sym
, &local_symbols
);
1321 SYMBOL_TYPE (sym
) = error_type (&p
, objfile
);
1322 SYMBOL_CLASS (sym
) = LOC_CONST
;
1323 SYMBOL_VALUE (sym
) = 0;
1324 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
1325 add_symbol_to_list (sym
, &file_symbols
);
1329 /* Some systems pass variables of certain types by reference instead
1330 of by value, i.e. they will pass the address of a structure (in a
1331 register or on the stack) instead of the structure itself. */
1333 if (gdbarch_stabs_argument_has_addr (gdbarch
, SYMBOL_TYPE (sym
))
1334 && SYMBOL_IS_ARGUMENT (sym
))
1336 /* We have to convert LOC_REGISTER to LOC_REGPARM_ADDR (for
1337 variables passed in a register). */
1338 if (SYMBOL_CLASS (sym
) == LOC_REGISTER
)
1339 SYMBOL_CLASS (sym
) = LOC_REGPARM_ADDR
;
1340 /* Likewise for converting LOC_ARG to LOC_REF_ARG (for the 7th
1341 and subsequent arguments on SPARC, for example). */
1342 else if (SYMBOL_CLASS (sym
) == LOC_ARG
)
1343 SYMBOL_CLASS (sym
) = LOC_REF_ARG
;
1349 /* Skip rest of this symbol and return an error type.
1351 General notes on error recovery: error_type always skips to the
1352 end of the symbol (modulo cretinous dbx symbol name continuation).
1353 Thus code like this:
1355 if (*(*pp)++ != ';')
1356 return error_type (pp, objfile);
1358 is wrong because if *pp starts out pointing at '\0' (typically as the
1359 result of an earlier error), it will be incremented to point to the
1360 start of the next symbol, which might produce strange results, at least
1361 if you run off the end of the string table. Instead use
1364 return error_type (pp, objfile);
1370 foo = error_type (pp, objfile);
1374 And in case it isn't obvious, the point of all this hair is so the compiler
1375 can define new types and new syntaxes, and old versions of the
1376 debugger will be able to read the new symbol tables. */
1378 static struct type
*
1379 error_type (char **pp
, struct objfile
*objfile
)
1381 complaint (&symfile_complaints
, _("couldn't parse type; debugger out of date?"));
1384 /* Skip to end of symbol. */
1385 while (**pp
!= '\0')
1390 /* Check for and handle cretinous dbx symbol name continuation! */
1391 if ((*pp
)[-1] == '\\' || (*pp
)[-1] == '?')
1393 *pp
= next_symbol_text (objfile
);
1400 return objfile_type (objfile
)->builtin_error
;
1404 /* Read type information or a type definition; return the type. Even
1405 though this routine accepts either type information or a type
1406 definition, the distinction is relevant--some parts of stabsread.c
1407 assume that type information starts with a digit, '-', or '(' in
1408 deciding whether to call read_type. */
1410 static struct type
*
1411 read_type (char **pp
, struct objfile
*objfile
)
1413 struct type
*type
= 0;
1416 char type_descriptor
;
1418 /* Size in bits of type if specified by a type attribute, or -1 if
1419 there is no size attribute. */
1422 /* Used to distinguish string and bitstring from char-array and set. */
1425 /* Used to distinguish vector from array. */
1428 /* Read type number if present. The type number may be omitted.
1429 for instance in a two-dimensional array declared with type
1430 "ar1;1;10;ar1;1;10;4". */
1431 if ((**pp
>= '0' && **pp
<= '9')
1435 if (read_type_number (pp
, typenums
) != 0)
1436 return error_type (pp
, objfile
);
1440 /* Type is not being defined here. Either it already
1441 exists, or this is a forward reference to it.
1442 dbx_alloc_type handles both cases. */
1443 type
= dbx_alloc_type (typenums
, objfile
);
1445 /* If this is a forward reference, arrange to complain if it
1446 doesn't get patched up by the time we're done
1448 if (TYPE_CODE (type
) == TYPE_CODE_UNDEF
)
1449 add_undefined_type (type
, typenums
);
1454 /* Type is being defined here. */
1456 Also skip the type descriptor - we get it below with (*pp)[-1]. */
1461 /* 'typenums=' not present, type is anonymous. Read and return
1462 the definition, but don't put it in the type vector. */
1463 typenums
[0] = typenums
[1] = -1;
1468 type_descriptor
= (*pp
)[-1];
1469 switch (type_descriptor
)
1473 enum type_code code
;
1475 /* Used to index through file_symbols. */
1476 struct pending
*ppt
;
1479 /* Name including "struct", etc. */
1483 char *from
, *to
, *p
, *q1
, *q2
;
1485 /* Set the type code according to the following letter. */
1489 code
= TYPE_CODE_STRUCT
;
1492 code
= TYPE_CODE_UNION
;
1495 code
= TYPE_CODE_ENUM
;
1499 /* Complain and keep going, so compilers can invent new
1500 cross-reference types. */
1501 complaint (&symfile_complaints
,
1502 _("Unrecognized cross-reference type `%c'"), (*pp
)[0]);
1503 code
= TYPE_CODE_STRUCT
;
1508 q1
= strchr (*pp
, '<');
1509 p
= strchr (*pp
, ':');
1511 return error_type (pp
, objfile
);
1512 if (q1
&& p
> q1
&& p
[1] == ':')
1514 int nesting_level
= 0;
1515 for (q2
= q1
; *q2
; q2
++)
1519 else if (*q2
== '>')
1521 else if (*q2
== ':' && nesting_level
== 0)
1526 return error_type (pp
, objfile
);
1529 if (current_subfile
->language
== language_cplus
)
1531 char *new_name
, *name
= alloca (p
- *pp
+ 1);
1532 memcpy (name
, *pp
, p
- *pp
);
1533 name
[p
- *pp
] = '\0';
1534 new_name
= cp_canonicalize_string (name
);
1535 if (new_name
!= NULL
)
1537 type_name
= obsavestring (new_name
, strlen (new_name
),
1538 &objfile
->objfile_obstack
);
1542 if (type_name
== NULL
)
1545 (char *) obstack_alloc (&objfile
->objfile_obstack
, p
- *pp
+ 1);
1547 /* Copy the name. */
1554 /* Set the pointer ahead of the name which we just read, and
1559 /* If this type has already been declared, then reuse the same
1560 type, rather than allocating a new one. This saves some
1563 for (ppt
= file_symbols
; ppt
; ppt
= ppt
->next
)
1564 for (i
= 0; i
< ppt
->nsyms
; i
++)
1566 struct symbol
*sym
= ppt
->symbol
[i
];
1568 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
1569 && SYMBOL_DOMAIN (sym
) == STRUCT_DOMAIN
1570 && (TYPE_CODE (SYMBOL_TYPE (sym
)) == code
)
1571 && strcmp (SYMBOL_LINKAGE_NAME (sym
), type_name
) == 0)
1573 obstack_free (&objfile
->objfile_obstack
, type_name
);
1574 type
= SYMBOL_TYPE (sym
);
1575 if (typenums
[0] != -1)
1576 *dbx_lookup_type (typenums
, objfile
) = type
;
1581 /* Didn't find the type to which this refers, so we must
1582 be dealing with a forward reference. Allocate a type
1583 structure for it, and keep track of it so we can
1584 fill in the rest of the fields when we get the full
1586 type
= dbx_alloc_type (typenums
, objfile
);
1587 TYPE_CODE (type
) = code
;
1588 TYPE_TAG_NAME (type
) = type_name
;
1589 INIT_CPLUS_SPECIFIC (type
);
1590 TYPE_STUB (type
) = 1;
1592 add_undefined_type (type
, typenums
);
1596 case '-': /* RS/6000 built-in type */
1610 /* We deal with something like t(1,2)=(3,4)=... which
1611 the Lucid compiler and recent gcc versions (post 2.7.3) use. */
1613 /* Allocate and enter the typedef type first.
1614 This handles recursive types. */
1615 type
= dbx_alloc_type (typenums
, objfile
);
1616 TYPE_CODE (type
) = TYPE_CODE_TYPEDEF
;
1618 struct type
*xtype
= read_type (pp
, objfile
);
1621 /* It's being defined as itself. That means it is "void". */
1622 TYPE_CODE (type
) = TYPE_CODE_VOID
;
1623 TYPE_LENGTH (type
) = 1;
1625 else if (type_size
>= 0 || is_string
)
1627 /* This is the absolute wrong way to construct types. Every
1628 other debug format has found a way around this problem and
1629 the related problems with unnecessarily stubbed types;
1630 someone motivated should attempt to clean up the issue
1631 here as well. Once a type pointed to has been created it
1632 should not be modified.
1634 Well, it's not *absolutely* wrong. Constructing recursive
1635 types (trees, linked lists) necessarily entails modifying
1636 types after creating them. Constructing any loop structure
1637 entails side effects. The Dwarf 2 reader does handle this
1638 more gracefully (it never constructs more than once
1639 instance of a type object, so it doesn't have to copy type
1640 objects wholesale), but it still mutates type objects after
1641 other folks have references to them.
1643 Keep in mind that this circularity/mutation issue shows up
1644 at the source language level, too: C's "incomplete types",
1645 for example. So the proper cleanup, I think, would be to
1646 limit GDB's type smashing to match exactly those required
1647 by the source language. So GDB could have a
1648 "complete_this_type" function, but never create unnecessary
1649 copies of a type otherwise. */
1650 replace_type (type
, xtype
);
1651 TYPE_NAME (type
) = NULL
;
1652 TYPE_TAG_NAME (type
) = NULL
;
1656 TYPE_TARGET_STUB (type
) = 1;
1657 TYPE_TARGET_TYPE (type
) = xtype
;
1662 /* In the following types, we must be sure to overwrite any existing
1663 type that the typenums refer to, rather than allocating a new one
1664 and making the typenums point to the new one. This is because there
1665 may already be pointers to the existing type (if it had been
1666 forward-referenced), and we must change it to a pointer, function,
1667 reference, or whatever, *in-place*. */
1669 case '*': /* Pointer to another type */
1670 type1
= read_type (pp
, objfile
);
1671 type
= make_pointer_type (type1
, dbx_lookup_type (typenums
, objfile
));
1674 case '&': /* Reference to another type */
1675 type1
= read_type (pp
, objfile
);
1676 type
= make_reference_type (type1
, dbx_lookup_type (typenums
, objfile
));
1679 case 'f': /* Function returning another type */
1680 type1
= read_type (pp
, objfile
);
1681 type
= make_function_type (type1
, dbx_lookup_type (typenums
, objfile
));
1684 case 'g': /* Prototyped function. (Sun) */
1686 /* Unresolved questions:
1688 - According to Sun's ``STABS Interface Manual'', for 'f'
1689 and 'F' symbol descriptors, a `0' in the argument type list
1690 indicates a varargs function. But it doesn't say how 'g'
1691 type descriptors represent that info. Someone with access
1692 to Sun's toolchain should try it out.
1694 - According to the comment in define_symbol (search for
1695 `process_prototype_types:'), Sun emits integer arguments as
1696 types which ref themselves --- like `void' types. Do we
1697 have to deal with that here, too? Again, someone with
1698 access to Sun's toolchain should try it out and let us
1701 const char *type_start
= (*pp
) - 1;
1702 struct type
*return_type
= read_type (pp
, objfile
);
1703 struct type
*func_type
1704 = make_function_type (return_type
,
1705 dbx_lookup_type (typenums
, objfile
));
1708 struct type_list
*next
;
1712 while (**pp
&& **pp
!= '#')
1714 struct type
*arg_type
= read_type (pp
, objfile
);
1715 struct type_list
*new = alloca (sizeof (*new));
1716 new->type
= arg_type
;
1717 new->next
= arg_types
;
1725 complaint (&symfile_complaints
,
1726 _("Prototyped function type didn't end arguments with `#':\n%s"),
1730 /* If there is just one argument whose type is `void', then
1731 that's just an empty argument list. */
1733 && ! arg_types
->next
1734 && TYPE_CODE (arg_types
->type
) == TYPE_CODE_VOID
)
1737 TYPE_FIELDS (func_type
)
1738 = (struct field
*) TYPE_ALLOC (func_type
,
1739 num_args
* sizeof (struct field
));
1740 memset (TYPE_FIELDS (func_type
), 0, num_args
* sizeof (struct field
));
1743 struct type_list
*t
;
1745 /* We stuck each argument type onto the front of the list
1746 when we read it, so the list is reversed. Build the
1747 fields array right-to-left. */
1748 for (t
= arg_types
, i
= num_args
- 1; t
; t
= t
->next
, i
--)
1749 TYPE_FIELD_TYPE (func_type
, i
) = t
->type
;
1751 TYPE_NFIELDS (func_type
) = num_args
;
1752 TYPE_PROTOTYPED (func_type
) = 1;
1758 case 'k': /* Const qualifier on some type (Sun) */
1759 type
= read_type (pp
, objfile
);
1760 type
= make_cv_type (1, TYPE_VOLATILE (type
), type
,
1761 dbx_lookup_type (typenums
, objfile
));
1764 case 'B': /* Volatile qual on some type (Sun) */
1765 type
= read_type (pp
, objfile
);
1766 type
= make_cv_type (TYPE_CONST (type
), 1, type
,
1767 dbx_lookup_type (typenums
, objfile
));
1771 if (isdigit (**pp
) || **pp
== '(' || **pp
== '-')
1772 { /* Member (class & variable) type */
1773 /* FIXME -- we should be doing smash_to_XXX types here. */
1775 struct type
*domain
= read_type (pp
, objfile
);
1776 struct type
*memtype
;
1779 /* Invalid member type data format. */
1780 return error_type (pp
, objfile
);
1783 memtype
= read_type (pp
, objfile
);
1784 type
= dbx_alloc_type (typenums
, objfile
);
1785 smash_to_memberptr_type (type
, domain
, memtype
);
1788 /* type attribute */
1791 /* Skip to the semicolon. */
1792 while (**pp
!= ';' && **pp
!= '\0')
1795 return error_type (pp
, objfile
);
1797 ++ * pp
; /* Skip the semicolon. */
1801 case 's': /* Size attribute */
1802 type_size
= atoi (attr
+ 1);
1807 case 'S': /* String attribute */
1808 /* FIXME: check to see if following type is array? */
1812 case 'V': /* Vector attribute */
1813 /* FIXME: check to see if following type is array? */
1818 /* Ignore unrecognized type attributes, so future compilers
1819 can invent new ones. */
1827 case '#': /* Method (class & fn) type */
1828 if ((*pp
)[0] == '#')
1830 /* We'll get the parameter types from the name. */
1831 struct type
*return_type
;
1834 return_type
= read_type (pp
, objfile
);
1835 if (*(*pp
)++ != ';')
1836 complaint (&symfile_complaints
,
1837 _("invalid (minimal) member type data format at symtab pos %d."),
1839 type
= allocate_stub_method (return_type
);
1840 if (typenums
[0] != -1)
1841 *dbx_lookup_type (typenums
, objfile
) = type
;
1845 struct type
*domain
= read_type (pp
, objfile
);
1846 struct type
*return_type
;
1851 /* Invalid member type data format. */
1852 return error_type (pp
, objfile
);
1856 return_type
= read_type (pp
, objfile
);
1857 args
= read_args (pp
, ';', objfile
, &nargs
, &varargs
);
1859 return error_type (pp
, objfile
);
1860 type
= dbx_alloc_type (typenums
, objfile
);
1861 smash_to_method_type (type
, domain
, return_type
, args
,
1866 case 'r': /* Range type */
1867 type
= read_range_type (pp
, typenums
, type_size
, objfile
);
1868 if (typenums
[0] != -1)
1869 *dbx_lookup_type (typenums
, objfile
) = type
;
1874 /* Sun ACC builtin int type */
1875 type
= read_sun_builtin_type (pp
, typenums
, objfile
);
1876 if (typenums
[0] != -1)
1877 *dbx_lookup_type (typenums
, objfile
) = type
;
1881 case 'R': /* Sun ACC builtin float type */
1882 type
= read_sun_floating_type (pp
, typenums
, objfile
);
1883 if (typenums
[0] != -1)
1884 *dbx_lookup_type (typenums
, objfile
) = type
;
1887 case 'e': /* Enumeration type */
1888 type
= dbx_alloc_type (typenums
, objfile
);
1889 type
= read_enum_type (pp
, type
, objfile
);
1890 if (typenums
[0] != -1)
1891 *dbx_lookup_type (typenums
, objfile
) = type
;
1894 case 's': /* Struct type */
1895 case 'u': /* Union type */
1897 enum type_code type_code
= TYPE_CODE_UNDEF
;
1898 type
= dbx_alloc_type (typenums
, objfile
);
1899 switch (type_descriptor
)
1902 type_code
= TYPE_CODE_STRUCT
;
1905 type_code
= TYPE_CODE_UNION
;
1908 type
= read_struct_type (pp
, type
, type_code
, objfile
);
1912 case 'a': /* Array type */
1914 return error_type (pp
, objfile
);
1917 type
= dbx_alloc_type (typenums
, objfile
);
1918 type
= read_array_type (pp
, type
, objfile
);
1920 TYPE_CODE (type
) = TYPE_CODE_STRING
;
1922 make_vector_type (type
);
1925 case 'S': /* Set or bitstring type */
1926 type1
= read_type (pp
, objfile
);
1927 type
= create_set_type ((struct type
*) NULL
, type1
);
1929 TYPE_CODE (type
) = TYPE_CODE_BITSTRING
;
1930 if (typenums
[0] != -1)
1931 *dbx_lookup_type (typenums
, objfile
) = type
;
1935 --*pp
; /* Go back to the symbol in error */
1936 /* Particularly important if it was \0! */
1937 return error_type (pp
, objfile
);
1942 warning (_("GDB internal error, type is NULL in stabsread.c."));
1943 return error_type (pp
, objfile
);
1946 /* Size specified in a type attribute overrides any other size. */
1947 if (type_size
!= -1)
1948 TYPE_LENGTH (type
) = (type_size
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
1953 /* RS/6000 xlc/dbx combination uses a set of builtin types, starting from -1.
1954 Return the proper type node for a given builtin type number. */
1956 static const struct objfile_data
*rs6000_builtin_type_data
;
1958 static struct type
*
1959 rs6000_builtin_type (int typenum
, struct objfile
*objfile
)
1961 struct type
**negative_types
= objfile_data (objfile
, rs6000_builtin_type_data
);
1963 /* We recognize types numbered from -NUMBER_RECOGNIZED to -1. */
1964 #define NUMBER_RECOGNIZED 34
1965 struct type
*rettype
= NULL
;
1967 if (typenum
>= 0 || typenum
< -NUMBER_RECOGNIZED
)
1969 complaint (&symfile_complaints
, _("Unknown builtin type %d"), typenum
);
1970 return objfile_type (objfile
)->builtin_error
;
1973 if (!negative_types
)
1975 /* This includes an empty slot for type number -0. */
1976 negative_types
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
1977 NUMBER_RECOGNIZED
+ 1, struct type
*);
1978 set_objfile_data (objfile
, rs6000_builtin_type_data
, negative_types
);
1981 if (negative_types
[-typenum
] != NULL
)
1982 return negative_types
[-typenum
];
1984 #if TARGET_CHAR_BIT != 8
1985 #error This code wrong for TARGET_CHAR_BIT not 8
1986 /* These definitions all assume that TARGET_CHAR_BIT is 8. I think
1987 that if that ever becomes not true, the correct fix will be to
1988 make the size in the struct type to be in bits, not in units of
1995 /* The size of this and all the other types are fixed, defined
1996 by the debugging format. If there is a type called "int" which
1997 is other than 32 bits, then it should use a new negative type
1998 number (or avoid negative type numbers for that case).
1999 See stabs.texinfo. */
2000 rettype
= init_type (TYPE_CODE_INT
, 4, 0, "int", objfile
);
2003 rettype
= init_type (TYPE_CODE_INT
, 1, 0, "char", objfile
);
2006 rettype
= init_type (TYPE_CODE_INT
, 2, 0, "short", objfile
);
2009 rettype
= init_type (TYPE_CODE_INT
, 4, 0, "long", objfile
);
2012 rettype
= init_type (TYPE_CODE_INT
, 1, TYPE_FLAG_UNSIGNED
,
2013 "unsigned char", objfile
);
2016 rettype
= init_type (TYPE_CODE_INT
, 1, 0, "signed char", objfile
);
2019 rettype
= init_type (TYPE_CODE_INT
, 2, TYPE_FLAG_UNSIGNED
,
2020 "unsigned short", objfile
);
2023 rettype
= init_type (TYPE_CODE_INT
, 4, TYPE_FLAG_UNSIGNED
,
2024 "unsigned int", objfile
);
2027 rettype
= init_type (TYPE_CODE_INT
, 4, TYPE_FLAG_UNSIGNED
,
2028 "unsigned", objfile
);
2030 rettype
= init_type (TYPE_CODE_INT
, 4, TYPE_FLAG_UNSIGNED
,
2031 "unsigned long", objfile
);
2034 rettype
= init_type (TYPE_CODE_VOID
, 1, 0, "void", objfile
);
2037 /* IEEE single precision (32 bit). */
2038 rettype
= init_type (TYPE_CODE_FLT
, 4, 0, "float", objfile
);
2041 /* IEEE double precision (64 bit). */
2042 rettype
= init_type (TYPE_CODE_FLT
, 8, 0, "double", objfile
);
2045 /* This is an IEEE double on the RS/6000, and different machines with
2046 different sizes for "long double" should use different negative
2047 type numbers. See stabs.texinfo. */
2048 rettype
= init_type (TYPE_CODE_FLT
, 8, 0, "long double", objfile
);
2051 rettype
= init_type (TYPE_CODE_INT
, 4, 0, "integer", objfile
);
2054 rettype
= init_type (TYPE_CODE_BOOL
, 4, TYPE_FLAG_UNSIGNED
,
2055 "boolean", objfile
);
2058 rettype
= init_type (TYPE_CODE_FLT
, 4, 0, "short real", objfile
);
2061 rettype
= init_type (TYPE_CODE_FLT
, 8, 0, "real", objfile
);
2064 rettype
= init_type (TYPE_CODE_ERROR
, 0, 0, "stringptr", objfile
);
2067 rettype
= init_type (TYPE_CODE_CHAR
, 1, TYPE_FLAG_UNSIGNED
,
2068 "character", objfile
);
2071 rettype
= init_type (TYPE_CODE_BOOL
, 1, TYPE_FLAG_UNSIGNED
,
2072 "logical*1", objfile
);
2075 rettype
= init_type (TYPE_CODE_BOOL
, 2, TYPE_FLAG_UNSIGNED
,
2076 "logical*2", objfile
);
2079 rettype
= init_type (TYPE_CODE_BOOL
, 4, TYPE_FLAG_UNSIGNED
,
2080 "logical*4", objfile
);
2083 rettype
= init_type (TYPE_CODE_BOOL
, 4, TYPE_FLAG_UNSIGNED
,
2084 "logical", objfile
);
2087 /* Complex type consisting of two IEEE single precision values. */
2088 rettype
= init_type (TYPE_CODE_COMPLEX
, 8, 0, "complex", objfile
);
2089 TYPE_TARGET_TYPE (rettype
) = init_type (TYPE_CODE_FLT
, 4, 0, "float",
2093 /* Complex type consisting of two IEEE double precision values. */
2094 rettype
= init_type (TYPE_CODE_COMPLEX
, 16, 0, "double complex", NULL
);
2095 TYPE_TARGET_TYPE (rettype
) = init_type (TYPE_CODE_FLT
, 8, 0, "double",
2099 rettype
= init_type (TYPE_CODE_INT
, 1, 0, "integer*1", objfile
);
2102 rettype
= init_type (TYPE_CODE_INT
, 2, 0, "integer*2", objfile
);
2105 rettype
= init_type (TYPE_CODE_INT
, 4, 0, "integer*4", objfile
);
2108 rettype
= init_type (TYPE_CODE_CHAR
, 2, 0, "wchar", objfile
);
2111 rettype
= init_type (TYPE_CODE_INT
, 8, 0, "long long", objfile
);
2114 rettype
= init_type (TYPE_CODE_INT
, 8, TYPE_FLAG_UNSIGNED
,
2115 "unsigned long long", objfile
);
2118 rettype
= init_type (TYPE_CODE_INT
, 8, TYPE_FLAG_UNSIGNED
,
2119 "logical*8", objfile
);
2122 rettype
= init_type (TYPE_CODE_INT
, 8, 0, "integer*8", objfile
);
2125 negative_types
[-typenum
] = rettype
;
2129 /* This page contains subroutines of read_type. */
2131 /* Replace *OLD_NAME with the method name portion of PHYSNAME. */
2134 update_method_name_from_physname (char **old_name
, char *physname
)
2138 method_name
= method_name_from_physname (physname
);
2140 if (method_name
== NULL
)
2142 complaint (&symfile_complaints
,
2143 _("Method has bad physname %s\n"), physname
);
2147 if (strcmp (*old_name
, method_name
) != 0)
2150 *old_name
= method_name
;
2153 xfree (method_name
);
2156 /* Read member function stabs info for C++ classes. The form of each member
2159 NAME :: TYPENUM[=type definition] ARGS : PHYSNAME ;
2161 An example with two member functions is:
2163 afunc1::20=##15;:i;2A.;afunc2::20:i;2A.;
2165 For the case of overloaded operators, the format is op$::*.funcs, where
2166 $ is the CPLUS_MARKER (usually '$'), `*' holds the place for an operator
2167 name (such as `+=') and `.' marks the end of the operator name.
2169 Returns 1 for success, 0 for failure. */
2172 read_member_functions (struct field_info
*fip
, char **pp
, struct type
*type
,
2173 struct objfile
*objfile
)
2177 /* Total number of member functions defined in this class. If the class
2178 defines two `f' functions, and one `g' function, then this will have
2180 int total_length
= 0;
2184 struct next_fnfield
*next
;
2185 struct fn_field fn_field
;
2188 struct type
*look_ahead_type
;
2189 struct next_fnfieldlist
*new_fnlist
;
2190 struct next_fnfield
*new_sublist
;
2194 /* Process each list until we find something that is not a member function
2195 or find the end of the functions. */
2199 /* We should be positioned at the start of the function name.
2200 Scan forward to find the first ':' and if it is not the
2201 first of a "::" delimiter, then this is not a member function. */
2213 look_ahead_type
= NULL
;
2216 new_fnlist
= (struct next_fnfieldlist
*)
2217 xmalloc (sizeof (struct next_fnfieldlist
));
2218 make_cleanup (xfree
, new_fnlist
);
2219 memset (new_fnlist
, 0, sizeof (struct next_fnfieldlist
));
2221 if ((*pp
)[0] == 'o' && (*pp
)[1] == 'p' && is_cplus_marker ((*pp
)[2]))
2223 /* This is a completely wierd case. In order to stuff in the
2224 names that might contain colons (the usual name delimiter),
2225 Mike Tiemann defined a different name format which is
2226 signalled if the identifier is "op$". In that case, the
2227 format is "op$::XXXX." where XXXX is the name. This is
2228 used for names like "+" or "=". YUUUUUUUK! FIXME! */
2229 /* This lets the user type "break operator+".
2230 We could just put in "+" as the name, but that wouldn't
2232 static char opname
[32] = "op$";
2233 char *o
= opname
+ 3;
2235 /* Skip past '::'. */
2238 STABS_CONTINUE (pp
, objfile
);
2244 main_fn_name
= savestring (opname
, o
- opname
);
2250 main_fn_name
= savestring (*pp
, p
- *pp
);
2251 /* Skip past '::'. */
2254 new_fnlist
->fn_fieldlist
.name
= main_fn_name
;
2259 (struct next_fnfield
*) xmalloc (sizeof (struct next_fnfield
));
2260 make_cleanup (xfree
, new_sublist
);
2261 memset (new_sublist
, 0, sizeof (struct next_fnfield
));
2263 /* Check for and handle cretinous dbx symbol name continuation! */
2264 if (look_ahead_type
== NULL
)
2267 STABS_CONTINUE (pp
, objfile
);
2269 new_sublist
->fn_field
.type
= read_type (pp
, objfile
);
2272 /* Invalid symtab info for member function. */
2278 /* g++ version 1 kludge */
2279 new_sublist
->fn_field
.type
= look_ahead_type
;
2280 look_ahead_type
= NULL
;
2290 /* If this is just a stub, then we don't have the real name here. */
2292 if (TYPE_STUB (new_sublist
->fn_field
.type
))
2294 if (!TYPE_DOMAIN_TYPE (new_sublist
->fn_field
.type
))
2295 TYPE_DOMAIN_TYPE (new_sublist
->fn_field
.type
) = type
;
2296 new_sublist
->fn_field
.is_stub
= 1;
2298 new_sublist
->fn_field
.physname
= savestring (*pp
, p
- *pp
);
2301 /* Set this member function's visibility fields. */
2304 case VISIBILITY_PRIVATE
:
2305 new_sublist
->fn_field
.is_private
= 1;
2307 case VISIBILITY_PROTECTED
:
2308 new_sublist
->fn_field
.is_protected
= 1;
2312 STABS_CONTINUE (pp
, objfile
);
2315 case 'A': /* Normal functions. */
2316 new_sublist
->fn_field
.is_const
= 0;
2317 new_sublist
->fn_field
.is_volatile
= 0;
2320 case 'B': /* `const' member functions. */
2321 new_sublist
->fn_field
.is_const
= 1;
2322 new_sublist
->fn_field
.is_volatile
= 0;
2325 case 'C': /* `volatile' member function. */
2326 new_sublist
->fn_field
.is_const
= 0;
2327 new_sublist
->fn_field
.is_volatile
= 1;
2330 case 'D': /* `const volatile' member function. */
2331 new_sublist
->fn_field
.is_const
= 1;
2332 new_sublist
->fn_field
.is_volatile
= 1;
2335 case '*': /* File compiled with g++ version 1 -- no info */
2340 complaint (&symfile_complaints
,
2341 _("const/volatile indicator missing, got '%c'"), **pp
);
2350 /* virtual member function, followed by index.
2351 The sign bit is set to distinguish pointers-to-methods
2352 from virtual function indicies. Since the array is
2353 in words, the quantity must be shifted left by 1
2354 on 16 bit machine, and by 2 on 32 bit machine, forcing
2355 the sign bit out, and usable as a valid index into
2356 the array. Remove the sign bit here. */
2357 new_sublist
->fn_field
.voffset
=
2358 (0x7fffffff & read_huge_number (pp
, ';', &nbits
, 0)) + 2;
2362 STABS_CONTINUE (pp
, objfile
);
2363 if (**pp
== ';' || **pp
== '\0')
2365 /* Must be g++ version 1. */
2366 new_sublist
->fn_field
.fcontext
= 0;
2370 /* Figure out from whence this virtual function came.
2371 It may belong to virtual function table of
2372 one of its baseclasses. */
2373 look_ahead_type
= read_type (pp
, objfile
);
2376 /* g++ version 1 overloaded methods. */
2380 new_sublist
->fn_field
.fcontext
= look_ahead_type
;
2389 look_ahead_type
= NULL
;
2395 /* static member function. */
2397 int slen
= strlen (main_fn_name
);
2399 new_sublist
->fn_field
.voffset
= VOFFSET_STATIC
;
2401 /* For static member functions, we can't tell if they
2402 are stubbed, as they are put out as functions, and not as
2404 GCC v2 emits the fully mangled name if
2405 dbxout.c:flag_minimal_debug is not set, so we have to
2406 detect a fully mangled physname here and set is_stub
2407 accordingly. Fully mangled physnames in v2 start with
2408 the member function name, followed by two underscores.
2409 GCC v3 currently always emits stubbed member functions,
2410 but with fully mangled physnames, which start with _Z. */
2411 if (!(strncmp (new_sublist
->fn_field
.physname
,
2412 main_fn_name
, slen
) == 0
2413 && new_sublist
->fn_field
.physname
[slen
] == '_'
2414 && new_sublist
->fn_field
.physname
[slen
+ 1] == '_'))
2416 new_sublist
->fn_field
.is_stub
= 1;
2423 complaint (&symfile_complaints
,
2424 _("member function type missing, got '%c'"), (*pp
)[-1]);
2425 /* Fall through into normal member function. */
2428 /* normal member function. */
2429 new_sublist
->fn_field
.voffset
= 0;
2430 new_sublist
->fn_field
.fcontext
= 0;
2434 new_sublist
->next
= sublist
;
2435 sublist
= new_sublist
;
2437 STABS_CONTINUE (pp
, objfile
);
2439 while (**pp
!= ';' && **pp
!= '\0');
2442 STABS_CONTINUE (pp
, objfile
);
2444 /* Skip GCC 3.X member functions which are duplicates of the callable
2445 constructor/destructor. */
2446 if (strcmp_iw (main_fn_name
, "__base_ctor ") == 0
2447 || strcmp_iw (main_fn_name
, "__base_dtor ") == 0
2448 || strcmp (main_fn_name
, "__deleting_dtor") == 0)
2450 xfree (main_fn_name
);
2455 int has_destructor
= 0, has_other
= 0;
2457 struct next_fnfield
*tmp_sublist
;
2459 /* Various versions of GCC emit various mostly-useless
2460 strings in the name field for special member functions.
2462 For stub methods, we need to defer correcting the name
2463 until we are ready to unstub the method, because the current
2464 name string is used by gdb_mangle_name. The only stub methods
2465 of concern here are GNU v2 operators; other methods have their
2466 names correct (see caveat below).
2468 For non-stub methods, in GNU v3, we have a complete physname.
2469 Therefore we can safely correct the name now. This primarily
2470 affects constructors and destructors, whose name will be
2471 __comp_ctor or __comp_dtor instead of Foo or ~Foo. Cast
2472 operators will also have incorrect names; for instance,
2473 "operator int" will be named "operator i" (i.e. the type is
2476 For non-stub methods in GNU v2, we have no easy way to
2477 know if we have a complete physname or not. For most
2478 methods the result depends on the platform (if CPLUS_MARKER
2479 can be `$' or `.', it will use minimal debug information, or
2480 otherwise the full physname will be included).
2482 Rather than dealing with this, we take a different approach.
2483 For v3 mangled names, we can use the full physname; for v2,
2484 we use cplus_demangle_opname (which is actually v2 specific),
2485 because the only interesting names are all operators - once again
2486 barring the caveat below. Skip this process if any method in the
2487 group is a stub, to prevent our fouling up the workings of
2490 The caveat: GCC 2.95.x (and earlier?) put constructors and
2491 destructors in the same method group. We need to split this
2492 into two groups, because they should have different names.
2493 So for each method group we check whether it contains both
2494 routines whose physname appears to be a destructor (the physnames
2495 for and destructors are always provided, due to quirks in v2
2496 mangling) and routines whose physname does not appear to be a
2497 destructor. If so then we break up the list into two halves.
2498 Even if the constructors and destructors aren't in the same group
2499 the destructor will still lack the leading tilde, so that also
2502 So, to summarize what we expect and handle here:
2504 Given Given Real Real Action
2505 method name physname physname method name
2507 __opi [none] __opi__3Foo operator int opname
2509 Foo _._3Foo _._3Foo ~Foo separate and
2511 operator i _ZN3FoocviEv _ZN3FoocviEv operator int demangle
2512 __comp_ctor _ZN3FooC1ERKS_ _ZN3FooC1ERKS_ Foo demangle
2515 tmp_sublist
= sublist
;
2516 while (tmp_sublist
!= NULL
)
2518 if (tmp_sublist
->fn_field
.is_stub
)
2520 if (tmp_sublist
->fn_field
.physname
[0] == '_'
2521 && tmp_sublist
->fn_field
.physname
[1] == 'Z')
2524 if (is_destructor_name (tmp_sublist
->fn_field
.physname
))
2529 tmp_sublist
= tmp_sublist
->next
;
2532 if (has_destructor
&& has_other
)
2534 struct next_fnfieldlist
*destr_fnlist
;
2535 struct next_fnfield
*last_sublist
;
2537 /* Create a new fn_fieldlist for the destructors. */
2539 destr_fnlist
= (struct next_fnfieldlist
*)
2540 xmalloc (sizeof (struct next_fnfieldlist
));
2541 make_cleanup (xfree
, destr_fnlist
);
2542 memset (destr_fnlist
, 0, sizeof (struct next_fnfieldlist
));
2543 destr_fnlist
->fn_fieldlist
.name
2544 = obconcat (&objfile
->objfile_obstack
, "", "~",
2545 new_fnlist
->fn_fieldlist
.name
);
2547 destr_fnlist
->fn_fieldlist
.fn_fields
= (struct fn_field
*)
2548 obstack_alloc (&objfile
->objfile_obstack
,
2549 sizeof (struct fn_field
) * has_destructor
);
2550 memset (destr_fnlist
->fn_fieldlist
.fn_fields
, 0,
2551 sizeof (struct fn_field
) * has_destructor
);
2552 tmp_sublist
= sublist
;
2553 last_sublist
= NULL
;
2555 while (tmp_sublist
!= NULL
)
2557 if (!is_destructor_name (tmp_sublist
->fn_field
.physname
))
2559 tmp_sublist
= tmp_sublist
->next
;
2563 destr_fnlist
->fn_fieldlist
.fn_fields
[i
++]
2564 = tmp_sublist
->fn_field
;
2566 last_sublist
->next
= tmp_sublist
->next
;
2568 sublist
= tmp_sublist
->next
;
2569 last_sublist
= tmp_sublist
;
2570 tmp_sublist
= tmp_sublist
->next
;
2573 destr_fnlist
->fn_fieldlist
.length
= has_destructor
;
2574 destr_fnlist
->next
= fip
->fnlist
;
2575 fip
->fnlist
= destr_fnlist
;
2577 total_length
+= has_destructor
;
2578 length
-= has_destructor
;
2582 /* v3 mangling prevents the use of abbreviated physnames,
2583 so we can do this here. There are stubbed methods in v3
2585 - in -gstabs instead of -gstabs+
2586 - or for static methods, which are output as a function type
2587 instead of a method type. */
2589 update_method_name_from_physname (&new_fnlist
->fn_fieldlist
.name
,
2590 sublist
->fn_field
.physname
);
2592 else if (has_destructor
&& new_fnlist
->fn_fieldlist
.name
[0] != '~')
2594 new_fnlist
->fn_fieldlist
.name
=
2595 concat ("~", main_fn_name
, (char *)NULL
);
2596 xfree (main_fn_name
);
2600 char dem_opname
[256];
2602 ret
= cplus_demangle_opname (new_fnlist
->fn_fieldlist
.name
,
2603 dem_opname
, DMGL_ANSI
);
2605 ret
= cplus_demangle_opname (new_fnlist
->fn_fieldlist
.name
,
2608 new_fnlist
->fn_fieldlist
.name
2609 = obsavestring (dem_opname
, strlen (dem_opname
),
2610 &objfile
->objfile_obstack
);
2613 new_fnlist
->fn_fieldlist
.fn_fields
= (struct fn_field
*)
2614 obstack_alloc (&objfile
->objfile_obstack
,
2615 sizeof (struct fn_field
) * length
);
2616 memset (new_fnlist
->fn_fieldlist
.fn_fields
, 0,
2617 sizeof (struct fn_field
) * length
);
2618 for (i
= length
; (i
--, sublist
); sublist
= sublist
->next
)
2620 new_fnlist
->fn_fieldlist
.fn_fields
[i
] = sublist
->fn_field
;
2623 new_fnlist
->fn_fieldlist
.length
= length
;
2624 new_fnlist
->next
= fip
->fnlist
;
2625 fip
->fnlist
= new_fnlist
;
2627 total_length
+= length
;
2633 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2634 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
2635 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * nfn_fields
);
2636 memset (TYPE_FN_FIELDLISTS (type
), 0,
2637 sizeof (struct fn_fieldlist
) * nfn_fields
);
2638 TYPE_NFN_FIELDS (type
) = nfn_fields
;
2639 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
2645 /* Special GNU C++ name.
2647 Returns 1 for success, 0 for failure. "failure" means that we can't
2648 keep parsing and it's time for error_type(). */
2651 read_cpp_abbrev (struct field_info
*fip
, char **pp
, struct type
*type
,
2652 struct objfile
*objfile
)
2657 struct type
*context
;
2667 /* At this point, *pp points to something like "22:23=*22...",
2668 where the type number before the ':' is the "context" and
2669 everything after is a regular type definition. Lookup the
2670 type, find it's name, and construct the field name. */
2672 context
= read_type (pp
, objfile
);
2676 case 'f': /* $vf -- a virtual function table pointer */
2677 name
= type_name_no_tag (context
);
2682 fip
->list
->field
.name
=
2683 obconcat (&objfile
->objfile_obstack
, vptr_name
, name
, "");
2686 case 'b': /* $vb -- a virtual bsomethingorother */
2687 name
= type_name_no_tag (context
);
2690 complaint (&symfile_complaints
,
2691 _("C++ abbreviated type name unknown at symtab pos %d"),
2695 fip
->list
->field
.name
=
2696 obconcat (&objfile
->objfile_obstack
, vb_name
, name
, "");
2700 invalid_cpp_abbrev_complaint (*pp
);
2701 fip
->list
->field
.name
=
2702 obconcat (&objfile
->objfile_obstack
,
2703 "INVALID_CPLUSPLUS_ABBREV", "", "");
2707 /* At this point, *pp points to the ':'. Skip it and read the
2713 invalid_cpp_abbrev_complaint (*pp
);
2716 fip
->list
->field
.type
= read_type (pp
, objfile
);
2718 (*pp
)++; /* Skip the comma. */
2724 FIELD_BITPOS (fip
->list
->field
) = read_huge_number (pp
, ';', &nbits
,
2729 /* This field is unpacked. */
2730 FIELD_BITSIZE (fip
->list
->field
) = 0;
2731 fip
->list
->visibility
= VISIBILITY_PRIVATE
;
2735 invalid_cpp_abbrev_complaint (*pp
);
2736 /* We have no idea what syntax an unrecognized abbrev would have, so
2737 better return 0. If we returned 1, we would need to at least advance
2738 *pp to avoid an infinite loop. */
2745 read_one_struct_field (struct field_info
*fip
, char **pp
, char *p
,
2746 struct type
*type
, struct objfile
*objfile
)
2748 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2750 fip
->list
->field
.name
=
2751 obsavestring (*pp
, p
- *pp
, &objfile
->objfile_obstack
);
2754 /* This means we have a visibility for a field coming. */
2758 fip
->list
->visibility
= *(*pp
)++;
2762 /* normal dbx-style format, no explicit visibility */
2763 fip
->list
->visibility
= VISIBILITY_PUBLIC
;
2766 fip
->list
->field
.type
= read_type (pp
, objfile
);
2771 /* Possible future hook for nested types. */
2774 fip
->list
->field
.bitpos
= (long) -2; /* nested type */
2784 /* Static class member. */
2785 SET_FIELD_PHYSNAME (fip
->list
->field
, savestring (*pp
, p
- *pp
));
2789 else if (**pp
!= ',')
2791 /* Bad structure-type format. */
2792 stabs_general_complaint ("bad structure-type format");
2796 (*pp
)++; /* Skip the comma. */
2800 FIELD_BITPOS (fip
->list
->field
) = read_huge_number (pp
, ',', &nbits
, 0);
2803 stabs_general_complaint ("bad structure-type format");
2806 FIELD_BITSIZE (fip
->list
->field
) = read_huge_number (pp
, ';', &nbits
, 0);
2809 stabs_general_complaint ("bad structure-type format");
2814 if (FIELD_BITPOS (fip
->list
->field
) == 0
2815 && FIELD_BITSIZE (fip
->list
->field
) == 0)
2817 /* This can happen in two cases: (1) at least for gcc 2.4.5 or so,
2818 it is a field which has been optimized out. The correct stab for
2819 this case is to use VISIBILITY_IGNORE, but that is a recent
2820 invention. (2) It is a 0-size array. For example
2821 union { int num; char str[0]; } foo. Printing _("<no value>" for
2822 str in "p foo" is OK, since foo.str (and thus foo.str[3])
2823 will continue to work, and a 0-size array as a whole doesn't
2824 have any contents to print.
2826 I suspect this probably could also happen with gcc -gstabs (not
2827 -gstabs+) for static fields, and perhaps other C++ extensions.
2828 Hopefully few people use -gstabs with gdb, since it is intended
2829 for dbx compatibility. */
2831 /* Ignore this field. */
2832 fip
->list
->visibility
= VISIBILITY_IGNORE
;
2836 /* Detect an unpacked field and mark it as such.
2837 dbx gives a bit size for all fields.
2838 Note that forward refs cannot be packed,
2839 and treat enums as if they had the width of ints. */
2841 struct type
*field_type
= check_typedef (FIELD_TYPE (fip
->list
->field
));
2843 if (TYPE_CODE (field_type
) != TYPE_CODE_INT
2844 && TYPE_CODE (field_type
) != TYPE_CODE_RANGE
2845 && TYPE_CODE (field_type
) != TYPE_CODE_BOOL
2846 && TYPE_CODE (field_type
) != TYPE_CODE_ENUM
)
2848 FIELD_BITSIZE (fip
->list
->field
) = 0;
2850 if ((FIELD_BITSIZE (fip
->list
->field
)
2851 == TARGET_CHAR_BIT
* TYPE_LENGTH (field_type
)
2852 || (TYPE_CODE (field_type
) == TYPE_CODE_ENUM
2853 && FIELD_BITSIZE (fip
->list
->field
)
2854 == gdbarch_int_bit (gdbarch
))
2857 FIELD_BITPOS (fip
->list
->field
) % 8 == 0)
2859 FIELD_BITSIZE (fip
->list
->field
) = 0;
2865 /* Read struct or class data fields. They have the form:
2867 NAME : [VISIBILITY] TYPENUM , BITPOS , BITSIZE ;
2869 At the end, we see a semicolon instead of a field.
2871 In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
2874 The optional VISIBILITY is one of:
2876 '/0' (VISIBILITY_PRIVATE)
2877 '/1' (VISIBILITY_PROTECTED)
2878 '/2' (VISIBILITY_PUBLIC)
2879 '/9' (VISIBILITY_IGNORE)
2881 or nothing, for C style fields with public visibility.
2883 Returns 1 for success, 0 for failure. */
2886 read_struct_fields (struct field_info
*fip
, char **pp
, struct type
*type
,
2887 struct objfile
*objfile
)
2890 struct nextfield
*new;
2892 /* We better set p right now, in case there are no fields at all... */
2896 /* Read each data member type until we find the terminating ';' at the end of
2897 the data member list, or break for some other reason such as finding the
2898 start of the member function list. */
2899 /* Stab string for structure/union does not end with two ';' in
2900 SUN C compiler 5.3 i.e. F6U2, hence check for end of string. */
2902 while (**pp
!= ';' && **pp
!= '\0')
2904 STABS_CONTINUE (pp
, objfile
);
2905 /* Get space to record the next field's data. */
2906 new = (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
2907 make_cleanup (xfree
, new);
2908 memset (new, 0, sizeof (struct nextfield
));
2909 new->next
= fip
->list
;
2912 /* Get the field name. */
2915 /* If is starts with CPLUS_MARKER it is a special abbreviation,
2916 unless the CPLUS_MARKER is followed by an underscore, in
2917 which case it is just the name of an anonymous type, which we
2918 should handle like any other type name. */
2920 if (is_cplus_marker (p
[0]) && p
[1] != '_')
2922 if (!read_cpp_abbrev (fip
, pp
, type
, objfile
))
2927 /* Look for the ':' that separates the field name from the field
2928 values. Data members are delimited by a single ':', while member
2929 functions are delimited by a pair of ':'s. When we hit the member
2930 functions (if any), terminate scan loop and return. */
2932 while (*p
!= ':' && *p
!= '\0')
2939 /* Check to see if we have hit the member functions yet. */
2944 read_one_struct_field (fip
, pp
, p
, type
, objfile
);
2946 if (p
[0] == ':' && p
[1] == ':')
2948 /* (the deleted) chill the list of fields: the last entry (at
2949 the head) is a partially constructed entry which we now
2951 fip
->list
= fip
->list
->next
;
2956 /* The stabs for C++ derived classes contain baseclass information which
2957 is marked by a '!' character after the total size. This function is
2958 called when we encounter the baseclass marker, and slurps up all the
2959 baseclass information.
2961 Immediately following the '!' marker is the number of base classes that
2962 the class is derived from, followed by information for each base class.
2963 For each base class, there are two visibility specifiers, a bit offset
2964 to the base class information within the derived class, a reference to
2965 the type for the base class, and a terminating semicolon.
2967 A typical example, with two base classes, would be "!2,020,19;0264,21;".
2969 Baseclass information marker __________________|| | | | | | |
2970 Number of baseclasses __________________________| | | | | | |
2971 Visibility specifiers (2) ________________________| | | | | |
2972 Offset in bits from start of class _________________| | | | |
2973 Type number for base class ___________________________| | | |
2974 Visibility specifiers (2) _______________________________| | |
2975 Offset in bits from start of class ________________________| |
2976 Type number of base class ____________________________________|
2978 Return 1 for success, 0 for (error-type-inducing) failure. */
2984 read_baseclasses (struct field_info
*fip
, char **pp
, struct type
*type
,
2985 struct objfile
*objfile
)
2988 struct nextfield
*new;
2996 /* Skip the '!' baseclass information marker. */
3000 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3003 TYPE_N_BASECLASSES (type
) = read_huge_number (pp
, ',', &nbits
, 0);
3009 /* Some stupid compilers have trouble with the following, so break
3010 it up into simpler expressions. */
3011 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*)
3012 TYPE_ALLOC (type
, B_BYTES (TYPE_N_BASECLASSES (type
)));
3015 int num_bytes
= B_BYTES (TYPE_N_BASECLASSES (type
));
3018 pointer
= (char *) TYPE_ALLOC (type
, num_bytes
);
3019 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*) pointer
;
3023 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), TYPE_N_BASECLASSES (type
));
3025 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
3027 new = (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
3028 make_cleanup (xfree
, new);
3029 memset (new, 0, sizeof (struct nextfield
));
3030 new->next
= fip
->list
;
3032 FIELD_BITSIZE (new->field
) = 0; /* this should be an unpacked field! */
3034 STABS_CONTINUE (pp
, objfile
);
3038 /* Nothing to do. */
3041 SET_TYPE_FIELD_VIRTUAL (type
, i
);
3044 /* Unknown character. Complain and treat it as non-virtual. */
3046 complaint (&symfile_complaints
,
3047 _("Unknown virtual character `%c' for baseclass"), **pp
);
3052 new->visibility
= *(*pp
)++;
3053 switch (new->visibility
)
3055 case VISIBILITY_PRIVATE
:
3056 case VISIBILITY_PROTECTED
:
3057 case VISIBILITY_PUBLIC
:
3060 /* Bad visibility format. Complain and treat it as
3063 complaint (&symfile_complaints
,
3064 _("Unknown visibility `%c' for baseclass"),
3066 new->visibility
= VISIBILITY_PUBLIC
;
3073 /* The remaining value is the bit offset of the portion of the object
3074 corresponding to this baseclass. Always zero in the absence of
3075 multiple inheritance. */
3077 FIELD_BITPOS (new->field
) = read_huge_number (pp
, ',', &nbits
, 0);
3082 /* The last piece of baseclass information is the type of the
3083 base class. Read it, and remember it's type name as this
3086 new->field
.type
= read_type (pp
, objfile
);
3087 new->field
.name
= type_name_no_tag (new->field
.type
);
3089 /* skip trailing ';' and bump count of number of fields seen */
3098 /* The tail end of stabs for C++ classes that contain a virtual function
3099 pointer contains a tilde, a %, and a type number.
3100 The type number refers to the base class (possibly this class itself) which
3101 contains the vtable pointer for the current class.
3103 This function is called when we have parsed all the method declarations,
3104 so we can look for the vptr base class info. */
3107 read_tilde_fields (struct field_info
*fip
, char **pp
, struct type
*type
,
3108 struct objfile
*objfile
)
3112 STABS_CONTINUE (pp
, objfile
);
3114 /* If we are positioned at a ';', then skip it. */
3124 if (**pp
== '=' || **pp
== '+' || **pp
== '-')
3126 /* Obsolete flags that used to indicate the presence
3127 of constructors and/or destructors. */
3131 /* Read either a '%' or the final ';'. */
3132 if (*(*pp
)++ == '%')
3134 /* The next number is the type number of the base class
3135 (possibly our own class) which supplies the vtable for
3136 this class. Parse it out, and search that class to find
3137 its vtable pointer, and install those into TYPE_VPTR_BASETYPE
3138 and TYPE_VPTR_FIELDNO. */
3143 t
= read_type (pp
, objfile
);
3145 while (*p
!= '\0' && *p
!= ';')
3151 /* Premature end of symbol. */
3155 TYPE_VPTR_BASETYPE (type
) = t
;
3156 if (type
== t
) /* Our own class provides vtbl ptr */
3158 for (i
= TYPE_NFIELDS (t
) - 1;
3159 i
>= TYPE_N_BASECLASSES (t
);
3162 char *name
= TYPE_FIELD_NAME (t
, i
);
3163 if (!strncmp (name
, vptr_name
, sizeof (vptr_name
) - 2)
3164 && is_cplus_marker (name
[sizeof (vptr_name
) - 2]))
3166 TYPE_VPTR_FIELDNO (type
) = i
;
3170 /* Virtual function table field not found. */
3171 complaint (&symfile_complaints
,
3172 _("virtual function table pointer not found when defining class `%s'"),
3178 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
3189 attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
)
3193 for (n
= TYPE_NFN_FIELDS (type
);
3194 fip
->fnlist
!= NULL
;
3195 fip
->fnlist
= fip
->fnlist
->next
)
3197 --n
; /* Circumvent Sun3 compiler bug */
3198 TYPE_FN_FIELDLISTS (type
)[n
] = fip
->fnlist
->fn_fieldlist
;
3203 /* Create the vector of fields, and record how big it is.
3204 We need this info to record proper virtual function table information
3205 for this class's virtual functions. */
3208 attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
3209 struct objfile
*objfile
)
3212 int non_public_fields
= 0;
3213 struct nextfield
*scan
;
3215 /* Count up the number of fields that we have, as well as taking note of
3216 whether or not there are any non-public fields, which requires us to
3217 allocate and build the private_field_bits and protected_field_bits
3220 for (scan
= fip
->list
; scan
!= NULL
; scan
= scan
->next
)
3223 if (scan
->visibility
!= VISIBILITY_PUBLIC
)
3225 non_public_fields
++;
3229 /* Now we know how many fields there are, and whether or not there are any
3230 non-public fields. Record the field count, allocate space for the
3231 array of fields, and create blank visibility bitfields if necessary. */
3233 TYPE_NFIELDS (type
) = nfields
;
3234 TYPE_FIELDS (type
) = (struct field
*)
3235 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
3236 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
3238 if (non_public_fields
)
3240 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3242 TYPE_FIELD_PRIVATE_BITS (type
) =
3243 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3244 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
3246 TYPE_FIELD_PROTECTED_BITS (type
) =
3247 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3248 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
3250 TYPE_FIELD_IGNORE_BITS (type
) =
3251 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3252 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
3255 /* Copy the saved-up fields into the field vector. Start from the head
3256 of the list, adding to the tail of the field array, so that they end
3257 up in the same order in the array in which they were added to the list. */
3259 while (nfields
-- > 0)
3261 TYPE_FIELD (type
, nfields
) = fip
->list
->field
;
3262 switch (fip
->list
->visibility
)
3264 case VISIBILITY_PRIVATE
:
3265 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
3268 case VISIBILITY_PROTECTED
:
3269 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
3272 case VISIBILITY_IGNORE
:
3273 SET_TYPE_FIELD_IGNORE (type
, nfields
);
3276 case VISIBILITY_PUBLIC
:
3280 /* Unknown visibility. Complain and treat it as public. */
3282 complaint (&symfile_complaints
, _("Unknown visibility `%c' for field"),
3283 fip
->list
->visibility
);
3287 fip
->list
= fip
->list
->next
;
3293 /* Complain that the compiler has emitted more than one definition for the
3294 structure type TYPE. */
3296 complain_about_struct_wipeout (struct type
*type
)
3301 if (TYPE_TAG_NAME (type
))
3303 name
= TYPE_TAG_NAME (type
);
3304 switch (TYPE_CODE (type
))
3306 case TYPE_CODE_STRUCT
: kind
= "struct "; break;
3307 case TYPE_CODE_UNION
: kind
= "union "; break;
3308 case TYPE_CODE_ENUM
: kind
= "enum "; break;
3312 else if (TYPE_NAME (type
))
3314 name
= TYPE_NAME (type
);
3323 complaint (&symfile_complaints
,
3324 _("struct/union type gets multiply defined: %s%s"), kind
, name
);
3328 /* Read the description of a structure (or union type) and return an object
3329 describing the type.
3331 PP points to a character pointer that points to the next unconsumed token
3332 in the the stabs string. For example, given stabs "A:T4=s4a:1,0,32;;",
3333 *PP will point to "4a:1,0,32;;".
3335 TYPE points to an incomplete type that needs to be filled in.
3337 OBJFILE points to the current objfile from which the stabs information is
3338 being read. (Note that it is redundant in that TYPE also contains a pointer
3339 to this same objfile, so it might be a good idea to eliminate it. FIXME).
3342 static struct type
*
3343 read_struct_type (char **pp
, struct type
*type
, enum type_code type_code
,
3344 struct objfile
*objfile
)
3346 struct cleanup
*back_to
;
3347 struct field_info fi
;
3352 /* When describing struct/union/class types in stabs, G++ always drops
3353 all qualifications from the name. So if you've got:
3354 struct A { ... struct B { ... }; ... };
3355 then G++ will emit stabs for `struct A::B' that call it simply
3356 `struct B'. Obviously, if you've got a real top-level definition for
3357 `struct B', or other nested definitions, this is going to cause
3360 Obviously, GDB can't fix this by itself, but it can at least avoid
3361 scribbling on existing structure type objects when new definitions
3363 if (! (TYPE_CODE (type
) == TYPE_CODE_UNDEF
3364 || TYPE_STUB (type
)))
3366 complain_about_struct_wipeout (type
);
3368 /* It's probably best to return the type unchanged. */
3372 back_to
= make_cleanup (null_cleanup
, 0);
3374 INIT_CPLUS_SPECIFIC (type
);
3375 TYPE_CODE (type
) = type_code
;
3376 TYPE_STUB (type
) = 0;
3378 /* First comes the total size in bytes. */
3382 TYPE_LENGTH (type
) = read_huge_number (pp
, 0, &nbits
, 0);
3384 return error_type (pp
, objfile
);
3387 /* Now read the baseclasses, if any, read the regular C struct or C++
3388 class member fields, attach the fields to the type, read the C++
3389 member functions, attach them to the type, and then read any tilde
3390 field (baseclass specifier for the class holding the main vtable). */
3392 if (!read_baseclasses (&fi
, pp
, type
, objfile
)
3393 || !read_struct_fields (&fi
, pp
, type
, objfile
)
3394 || !attach_fields_to_type (&fi
, type
, objfile
)
3395 || !read_member_functions (&fi
, pp
, type
, objfile
)
3396 || !attach_fn_fields_to_type (&fi
, type
)
3397 || !read_tilde_fields (&fi
, pp
, type
, objfile
))
3399 type
= error_type (pp
, objfile
);
3402 do_cleanups (back_to
);
3406 /* Read a definition of an array type,
3407 and create and return a suitable type object.
3408 Also creates a range type which represents the bounds of that
3411 static struct type
*
3412 read_array_type (char **pp
, struct type
*type
,
3413 struct objfile
*objfile
)
3415 struct type
*index_type
, *element_type
, *range_type
;
3420 /* Format of an array type:
3421 "ar<index type>;lower;upper;<array_contents_type>".
3422 OS9000: "arlower,upper;<array_contents_type>".
3424 Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
3425 for these, produce a type like float[][]. */
3428 index_type
= read_type (pp
, objfile
);
3430 /* Improper format of array type decl. */
3431 return error_type (pp
, objfile
);
3435 if (!(**pp
>= '0' && **pp
<= '9') && **pp
!= '-')
3440 lower
= read_huge_number (pp
, ';', &nbits
, 0);
3443 return error_type (pp
, objfile
);
3445 if (!(**pp
>= '0' && **pp
<= '9') && **pp
!= '-')
3450 upper
= read_huge_number (pp
, ';', &nbits
, 0);
3452 return error_type (pp
, objfile
);
3454 element_type
= read_type (pp
, objfile
);
3463 create_range_type ((struct type
*) NULL
, index_type
, lower
, upper
);
3464 type
= create_array_type (type
, element_type
, range_type
);
3470 /* Read a definition of an enumeration type,
3471 and create and return a suitable type object.
3472 Also defines the symbols that represent the values of the type. */
3474 static struct type
*
3475 read_enum_type (char **pp
, struct type
*type
,
3476 struct objfile
*objfile
)
3478 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3484 struct pending
**symlist
;
3485 struct pending
*osyms
, *syms
;
3488 int unsigned_enum
= 1;
3491 /* FIXME! The stabs produced by Sun CC merrily define things that ought
3492 to be file-scope, between N_FN entries, using N_LSYM. What's a mother
3493 to do? For now, force all enum values to file scope. */
3494 if (within_function
)
3495 symlist
= &local_symbols
;
3498 symlist
= &file_symbols
;
3500 o_nsyms
= osyms
? osyms
->nsyms
: 0;
3502 /* The aix4 compiler emits an extra field before the enum members;
3503 my guess is it's a type of some sort. Just ignore it. */
3506 /* Skip over the type. */
3510 /* Skip over the colon. */
3514 /* Read the value-names and their values.
3515 The input syntax is NAME:VALUE,NAME:VALUE, and so on.
3516 A semicolon or comma instead of a NAME means the end. */
3517 while (**pp
&& **pp
!= ';' && **pp
!= ',')
3519 STABS_CONTINUE (pp
, objfile
);
3523 name
= obsavestring (*pp
, p
- *pp
, &objfile
->objfile_obstack
);
3525 n
= read_huge_number (pp
, ',', &nbits
, 0);
3527 return error_type (pp
, objfile
);
3529 sym
= (struct symbol
*)
3530 obstack_alloc (&objfile
->objfile_obstack
, sizeof (struct symbol
));
3531 memset (sym
, 0, sizeof (struct symbol
));
3532 SYMBOL_SET_LINKAGE_NAME (sym
, name
);
3533 SYMBOL_LANGUAGE (sym
) = current_subfile
->language
;
3534 SYMBOL_CLASS (sym
) = LOC_CONST
;
3535 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
3536 SYMBOL_VALUE (sym
) = n
;
3539 add_symbol_to_list (sym
, symlist
);
3544 (*pp
)++; /* Skip the semicolon. */
3546 /* Now fill in the fields of the type-structure. */
3548 TYPE_LENGTH (type
) = gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
;
3549 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
3550 TYPE_STUB (type
) = 0;
3552 TYPE_UNSIGNED (type
) = 1;
3553 TYPE_NFIELDS (type
) = nsyms
;
3554 TYPE_FIELDS (type
) = (struct field
*)
3555 TYPE_ALLOC (type
, sizeof (struct field
) * nsyms
);
3556 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nsyms
);
3558 /* Find the symbols for the values and put them into the type.
3559 The symbols can be found in the symlist that we put them on
3560 to cause them to be defined. osyms contains the old value
3561 of that symlist; everything up to there was defined by us. */
3562 /* Note that we preserve the order of the enum constants, so
3563 that in something like "enum {FOO, LAST_THING=FOO}" we print
3564 FOO, not LAST_THING. */
3566 for (syms
= *symlist
, n
= nsyms
- 1; syms
; syms
= syms
->next
)
3568 int last
= syms
== osyms
? o_nsyms
: 0;
3569 int j
= syms
->nsyms
;
3570 for (; --j
>= last
; --n
)
3572 struct symbol
*xsym
= syms
->symbol
[j
];
3573 SYMBOL_TYPE (xsym
) = type
;
3574 TYPE_FIELD_NAME (type
, n
) = SYMBOL_LINKAGE_NAME (xsym
);
3575 TYPE_FIELD_BITPOS (type
, n
) = SYMBOL_VALUE (xsym
);
3576 TYPE_FIELD_BITSIZE (type
, n
) = 0;
3585 /* Sun's ACC uses a somewhat saner method for specifying the builtin
3586 typedefs in every file (for int, long, etc):
3588 type = b <signed> <width> <format type>; <offset>; <nbits>
3590 optional format type = c or b for char or boolean.
3591 offset = offset from high order bit to start bit of type.
3592 width is # bytes in object of this type, nbits is # bits in type.
3594 The width/offset stuff appears to be for small objects stored in
3595 larger ones (e.g. `shorts' in `int' registers). We ignore it for now,
3598 static struct type
*
3599 read_sun_builtin_type (char **pp
, int typenums
[2], struct objfile
*objfile
)
3604 enum type_code code
= TYPE_CODE_INT
;
3615 return error_type (pp
, objfile
);
3619 /* For some odd reason, all forms of char put a c here. This is strange
3620 because no other type has this honor. We can safely ignore this because
3621 we actually determine 'char'acterness by the number of bits specified in
3623 Boolean forms, e.g Fortran logical*X, put a b here. */
3627 else if (**pp
== 'b')
3629 code
= TYPE_CODE_BOOL
;
3633 /* The first number appears to be the number of bytes occupied
3634 by this type, except that unsigned short is 4 instead of 2.
3635 Since this information is redundant with the third number,
3636 we will ignore it. */
3637 read_huge_number (pp
, ';', &nbits
, 0);
3639 return error_type (pp
, objfile
);
3641 /* The second number is always 0, so ignore it too. */
3642 read_huge_number (pp
, ';', &nbits
, 0);
3644 return error_type (pp
, objfile
);
3646 /* The third number is the number of bits for this type. */
3647 type_bits
= read_huge_number (pp
, 0, &nbits
, 0);
3649 return error_type (pp
, objfile
);
3650 /* The type *should* end with a semicolon. If it are embedded
3651 in a larger type the semicolon may be the only way to know where
3652 the type ends. If this type is at the end of the stabstring we
3653 can deal with the omitted semicolon (but we don't have to like
3654 it). Don't bother to complain(), Sun's compiler omits the semicolon
3660 return init_type (TYPE_CODE_VOID
, 1,
3661 signed_type
? 0 : TYPE_FLAG_UNSIGNED
, (char *) NULL
,
3664 return init_type (code
,
3665 type_bits
/ TARGET_CHAR_BIT
,
3666 signed_type
? 0 : TYPE_FLAG_UNSIGNED
, (char *) NULL
,
3670 static struct type
*
3671 read_sun_floating_type (char **pp
, int typenums
[2], struct objfile
*objfile
)
3676 struct type
*rettype
;
3678 /* The first number has more details about the type, for example
3680 details
= read_huge_number (pp
, ';', &nbits
, 0);
3682 return error_type (pp
, objfile
);
3684 /* The second number is the number of bytes occupied by this type */
3685 nbytes
= read_huge_number (pp
, ';', &nbits
, 0);
3687 return error_type (pp
, objfile
);
3689 if (details
== NF_COMPLEX
|| details
== NF_COMPLEX16
3690 || details
== NF_COMPLEX32
)
3692 rettype
= init_type (TYPE_CODE_COMPLEX
, nbytes
, 0, NULL
, objfile
);
3693 TYPE_TARGET_TYPE (rettype
)
3694 = init_type (TYPE_CODE_FLT
, nbytes
/ 2, 0, NULL
, objfile
);
3698 return init_type (TYPE_CODE_FLT
, nbytes
, 0, NULL
, objfile
);
3701 /* Read a number from the string pointed to by *PP.
3702 The value of *PP is advanced over the number.
3703 If END is nonzero, the character that ends the
3704 number must match END, or an error happens;
3705 and that character is skipped if it does match.
3706 If END is zero, *PP is left pointing to that character.
3708 If TWOS_COMPLEMENT_BITS is set to a strictly positive value and if
3709 the number is represented in an octal representation, assume that
3710 it is represented in a 2's complement representation with a size of
3711 TWOS_COMPLEMENT_BITS.
3713 If the number fits in a long, set *BITS to 0 and return the value.
3714 If not, set *BITS to be the number of bits in the number and return 0.
3716 If encounter garbage, set *BITS to -1 and return 0. */
3719 read_huge_number (char **pp
, int end
, int *bits
, int twos_complement_bits
)
3730 int twos_complement_representation
= 0;
3738 /* Leading zero means octal. GCC uses this to output values larger
3739 than an int (because that would be hard in decimal). */
3746 /* Skip extra zeros. */
3750 if (sign
> 0 && radix
== 8 && twos_complement_bits
> 0)
3752 /* Octal, possibly signed. Check if we have enough chars for a
3757 while ((c
= *p1
) >= '0' && c
< '8')
3761 if (len
> twos_complement_bits
/ 3
3762 || (twos_complement_bits
% 3 == 0 && len
== twos_complement_bits
/ 3))
3764 /* Ok, we have enough characters for a signed value, check
3765 for signness by testing if the sign bit is set. */
3766 sign_bit
= (twos_complement_bits
% 3 + 2) % 3;
3768 if (c
& (1 << sign_bit
))
3770 /* Definitely signed. */
3771 twos_complement_representation
= 1;
3777 upper_limit
= LONG_MAX
/ radix
;
3779 while ((c
= *p
++) >= '0' && c
< ('0' + radix
))
3781 if (n
<= upper_limit
)
3783 if (twos_complement_representation
)
3785 /* Octal, signed, twos complement representation. In
3786 this case, n is the corresponding absolute value. */
3789 long sn
= c
- '0' - ((2 * (c
- '0')) | (2 << sign_bit
));
3800 /* unsigned representation */
3802 n
+= c
- '0'; /* FIXME this overflows anyway */
3808 /* This depends on large values being output in octal, which is
3815 /* Ignore leading zeroes. */
3819 else if (c
== '2' || c
== '3')
3840 if (radix
== 8 && twos_complement_bits
> 0 && nbits
> twos_complement_bits
)
3842 /* We were supposed to parse a number with maximum
3843 TWOS_COMPLEMENT_BITS bits, but something went wrong. */
3854 /* Large decimal constants are an error (because it is hard to
3855 count how many bits are in them). */
3861 /* -0x7f is the same as 0x80. So deal with it by adding one to
3862 the number of bits. Two's complement represention octals
3863 can't have a '-' in front. */
3864 if (sign
== -1 && !twos_complement_representation
)
3875 /* It's *BITS which has the interesting information. */
3879 static struct type
*
3880 read_range_type (char **pp
, int typenums
[2], int type_size
,
3881 struct objfile
*objfile
)
3883 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3884 char *orig_pp
= *pp
;
3889 struct type
*result_type
;
3890 struct type
*index_type
= NULL
;
3892 /* First comes a type we are a subrange of.
3893 In C it is usually 0, 1 or the type being defined. */
3894 if (read_type_number (pp
, rangenums
) != 0)
3895 return error_type (pp
, objfile
);
3896 self_subrange
= (rangenums
[0] == typenums
[0] &&
3897 rangenums
[1] == typenums
[1]);
3902 index_type
= read_type (pp
, objfile
);
3905 /* A semicolon should now follow; skip it. */
3909 /* The remaining two operands are usually lower and upper bounds
3910 of the range. But in some special cases they mean something else. */
3911 n2
= read_huge_number (pp
, ';', &n2bits
, type_size
);
3912 n3
= read_huge_number (pp
, ';', &n3bits
, type_size
);
3914 if (n2bits
== -1 || n3bits
== -1)
3915 return error_type (pp
, objfile
);
3918 goto handle_true_range
;
3920 /* If limits are huge, must be large integral type. */
3921 if (n2bits
!= 0 || n3bits
!= 0)
3923 char got_signed
= 0;
3924 char got_unsigned
= 0;
3925 /* Number of bits in the type. */
3928 /* If a type size attribute has been specified, the bounds of
3929 the range should fit in this size. If the lower bounds needs
3930 more bits than the upper bound, then the type is signed. */
3931 if (n2bits
<= type_size
&& n3bits
<= type_size
)
3933 if (n2bits
== type_size
&& n2bits
> n3bits
)
3939 /* Range from 0 to <large number> is an unsigned large integral type. */
3940 else if ((n2bits
== 0 && n2
== 0) && n3bits
!= 0)
3945 /* Range from <large number> to <large number>-1 is a large signed
3946 integral type. Take care of the case where <large number> doesn't
3947 fit in a long but <large number>-1 does. */
3948 else if ((n2bits
!= 0 && n3bits
!= 0 && n2bits
== n3bits
+ 1)
3949 || (n2bits
!= 0 && n3bits
== 0
3950 && (n2bits
== sizeof (long) * HOST_CHAR_BIT
)
3957 if (got_signed
|| got_unsigned
)
3959 return init_type (TYPE_CODE_INT
, nbits
/ TARGET_CHAR_BIT
,
3960 got_unsigned
? TYPE_FLAG_UNSIGNED
: 0, NULL
,
3964 return error_type (pp
, objfile
);
3967 /* A type defined as a subrange of itself, with bounds both 0, is void. */
3968 if (self_subrange
&& n2
== 0 && n3
== 0)
3969 return init_type (TYPE_CODE_VOID
, 1, 0, NULL
, objfile
);
3971 /* If n3 is zero and n2 is positive, we want a floating type, and n2
3972 is the width in bytes.
3974 Fortran programs appear to use this for complex types also. To
3975 distinguish between floats and complex, g77 (and others?) seem
3976 to use self-subranges for the complexes, and subranges of int for
3979 Also note that for complexes, g77 sets n2 to the size of one of
3980 the member floats, not the whole complex beast. My guess is that
3981 this was to work well with pre-COMPLEX versions of gdb. */
3983 if (n3
== 0 && n2
> 0)
3985 struct type
*float_type
3986 = init_type (TYPE_CODE_FLT
, n2
, 0, NULL
, objfile
);
3990 struct type
*complex_type
=
3991 init_type (TYPE_CODE_COMPLEX
, 2 * n2
, 0, NULL
, objfile
);
3992 TYPE_TARGET_TYPE (complex_type
) = float_type
;
3993 return complex_type
;
3999 /* If the upper bound is -1, it must really be an unsigned integral. */
4001 else if (n2
== 0 && n3
== -1)
4003 int bits
= type_size
;
4006 /* We don't know its size. It is unsigned int or unsigned
4007 long. GCC 2.3.3 uses this for long long too, but that is
4008 just a GDB 3.5 compatibility hack. */
4009 bits
= gdbarch_int_bit (gdbarch
);
4012 return init_type (TYPE_CODE_INT
, bits
/ TARGET_CHAR_BIT
,
4013 TYPE_FLAG_UNSIGNED
, NULL
, objfile
);
4016 /* Special case: char is defined (Who knows why) as a subrange of
4017 itself with range 0-127. */
4018 else if (self_subrange
&& n2
== 0 && n3
== 127)
4019 return init_type (TYPE_CODE_INT
, 1, TYPE_FLAG_NOSIGN
, NULL
, objfile
);
4021 /* We used to do this only for subrange of self or subrange of int. */
4024 /* -1 is used for the upper bound of (4 byte) "unsigned int" and
4025 "unsigned long", and we already checked for that,
4026 so don't need to test for it here. */
4029 /* n3 actually gives the size. */
4030 return init_type (TYPE_CODE_INT
, -n3
, TYPE_FLAG_UNSIGNED
,
4033 /* Is n3 == 2**(8n)-1 for some integer n? Then it's an
4034 unsigned n-byte integer. But do require n to be a power of
4035 two; we don't want 3- and 5-byte integers flying around. */
4041 for (bytes
= 0; (bits
& 0xff) == 0xff; bytes
++)
4044 && ((bytes
- 1) & bytes
) == 0) /* "bytes is a power of two" */
4045 return init_type (TYPE_CODE_INT
, bytes
, TYPE_FLAG_UNSIGNED
, NULL
,
4049 /* I think this is for Convex "long long". Since I don't know whether
4050 Convex sets self_subrange, I also accept that particular size regardless
4051 of self_subrange. */
4052 else if (n3
== 0 && n2
< 0
4054 || n2
== -gdbarch_long_long_bit
4055 (gdbarch
) / TARGET_CHAR_BIT
))
4056 return init_type (TYPE_CODE_INT
, -n2
, 0, NULL
, objfile
);
4057 else if (n2
== -n3
- 1)
4060 return init_type (TYPE_CODE_INT
, 1, 0, NULL
, objfile
);
4062 return init_type (TYPE_CODE_INT
, 2, 0, NULL
, objfile
);
4063 if (n3
== 0x7fffffff)
4064 return init_type (TYPE_CODE_INT
, 4, 0, NULL
, objfile
);
4067 /* We have a real range type on our hands. Allocate space and
4068 return a real pointer. */
4072 index_type
= objfile_type (objfile
)->builtin_int
;
4074 index_type
= *dbx_lookup_type (rangenums
, objfile
);
4075 if (index_type
== NULL
)
4077 /* Does this actually ever happen? Is that why we are worrying
4078 about dealing with it rather than just calling error_type? */
4080 complaint (&symfile_complaints
,
4081 _("base type %d of range type is not defined"), rangenums
[1]);
4083 index_type
= objfile_type (objfile
)->builtin_int
;
4086 result_type
= create_range_type ((struct type
*) NULL
, index_type
, n2
, n3
);
4087 return (result_type
);
4090 /* Read in an argument list. This is a list of types, separated by commas
4091 and terminated with END. Return the list of types read in, or NULL
4092 if there is an error. */
4094 static struct field
*
4095 read_args (char **pp
, int end
, struct objfile
*objfile
, int *nargsp
,
4098 /* FIXME! Remove this arbitrary limit! */
4099 struct type
*types
[1024]; /* allow for fns of 1023 parameters */
4106 /* Invalid argument list: no ','. */
4109 STABS_CONTINUE (pp
, objfile
);
4110 types
[n
++] = read_type (pp
, objfile
);
4112 (*pp
)++; /* get past `end' (the ':' character) */
4116 /* We should read at least the THIS parameter here. Some broken stabs
4117 output contained `(0,41),(0,42)=@s8;-16;,(0,43),(0,1);' where should
4118 have been present ";-16,(0,43)" reference instead. This way the
4119 excessive ";" marker prematurely stops the parameters parsing. */
4121 complaint (&symfile_complaints
, _("Invalid (empty) method arguments"));
4124 else if (TYPE_CODE (types
[n
- 1]) != TYPE_CODE_VOID
)
4132 rval
= (struct field
*) xmalloc (n
* sizeof (struct field
));
4133 memset (rval
, 0, n
* sizeof (struct field
));
4134 for (i
= 0; i
< n
; i
++)
4135 rval
[i
].type
= types
[i
];
4140 /* Common block handling. */
4142 /* List of symbols declared since the last BCOMM. This list is a tail
4143 of local_symbols. When ECOMM is seen, the symbols on the list
4144 are noted so their proper addresses can be filled in later,
4145 using the common block base address gotten from the assembler
4148 static struct pending
*common_block
;
4149 static int common_block_i
;
4151 /* Name of the current common block. We get it from the BCOMM instead of the
4152 ECOMM to match IBM documentation (even though IBM puts the name both places
4153 like everyone else). */
4154 static char *common_block_name
;
4156 /* Process a N_BCOMM symbol. The storage for NAME is not guaranteed
4157 to remain after this function returns. */
4160 common_block_start (char *name
, struct objfile
*objfile
)
4162 if (common_block_name
!= NULL
)
4164 complaint (&symfile_complaints
,
4165 _("Invalid symbol data: common block within common block"));
4167 common_block
= local_symbols
;
4168 common_block_i
= local_symbols
? local_symbols
->nsyms
: 0;
4169 common_block_name
= obsavestring (name
, strlen (name
),
4170 &objfile
->objfile_obstack
);
4173 /* Process a N_ECOMM symbol. */
4176 common_block_end (struct objfile
*objfile
)
4178 /* Symbols declared since the BCOMM are to have the common block
4179 start address added in when we know it. common_block and
4180 common_block_i point to the first symbol after the BCOMM in
4181 the local_symbols list; copy the list and hang it off the
4182 symbol for the common block name for later fixup. */
4185 struct pending
*new = 0;
4186 struct pending
*next
;
4189 if (common_block_name
== NULL
)
4191 complaint (&symfile_complaints
, _("ECOMM symbol unmatched by BCOMM"));
4195 sym
= (struct symbol
*)
4196 obstack_alloc (&objfile
->objfile_obstack
, sizeof (struct symbol
));
4197 memset (sym
, 0, sizeof (struct symbol
));
4198 /* Note: common_block_name already saved on objfile_obstack */
4199 SYMBOL_SET_LINKAGE_NAME (sym
, common_block_name
);
4200 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
4202 /* Now we copy all the symbols which have been defined since the BCOMM. */
4204 /* Copy all the struct pendings before common_block. */
4205 for (next
= local_symbols
;
4206 next
!= NULL
&& next
!= common_block
;
4209 for (j
= 0; j
< next
->nsyms
; j
++)
4210 add_symbol_to_list (next
->symbol
[j
], &new);
4213 /* Copy however much of COMMON_BLOCK we need. If COMMON_BLOCK is
4214 NULL, it means copy all the local symbols (which we already did
4217 if (common_block
!= NULL
)
4218 for (j
= common_block_i
; j
< common_block
->nsyms
; j
++)
4219 add_symbol_to_list (common_block
->symbol
[j
], &new);
4221 SYMBOL_TYPE (sym
) = (struct type
*) new;
4223 /* Should we be putting local_symbols back to what it was?
4226 i
= hashname (SYMBOL_LINKAGE_NAME (sym
));
4227 SYMBOL_VALUE_CHAIN (sym
) = global_sym_chain
[i
];
4228 global_sym_chain
[i
] = sym
;
4229 common_block_name
= NULL
;
4232 /* Add a common block's start address to the offset of each symbol
4233 declared to be in it (by being between a BCOMM/ECOMM pair that uses
4234 the common block name). */
4237 fix_common_block (struct symbol
*sym
, int valu
)
4239 struct pending
*next
= (struct pending
*) SYMBOL_TYPE (sym
);
4240 for (; next
; next
= next
->next
)
4243 for (j
= next
->nsyms
- 1; j
>= 0; j
--)
4244 SYMBOL_VALUE_ADDRESS (next
->symbol
[j
]) += valu
;
4250 /* Add {TYPE, TYPENUMS} to the NONAME_UNDEFS vector.
4251 See add_undefined_type for more details. */
4254 add_undefined_type_noname (struct type
*type
, int typenums
[2])
4258 nat
.typenums
[0] = typenums
[0];
4259 nat
.typenums
[1] = typenums
[1];
4262 if (noname_undefs_length
== noname_undefs_allocated
)
4264 noname_undefs_allocated
*= 2;
4265 noname_undefs
= (struct nat
*)
4266 xrealloc ((char *) noname_undefs
,
4267 noname_undefs_allocated
* sizeof (struct nat
));
4269 noname_undefs
[noname_undefs_length
++] = nat
;
4272 /* Add TYPE to the UNDEF_TYPES vector.
4273 See add_undefined_type for more details. */
4276 add_undefined_type_1 (struct type
*type
)
4278 if (undef_types_length
== undef_types_allocated
)
4280 undef_types_allocated
*= 2;
4281 undef_types
= (struct type
**)
4282 xrealloc ((char *) undef_types
,
4283 undef_types_allocated
* sizeof (struct type
*));
4285 undef_types
[undef_types_length
++] = type
;
4288 /* What about types defined as forward references inside of a small lexical
4290 /* Add a type to the list of undefined types to be checked through
4291 once this file has been read in.
4293 In practice, we actually maintain two such lists: The first list
4294 (UNDEF_TYPES) is used for types whose name has been provided, and
4295 concerns forward references (eg 'xs' or 'xu' forward references);
4296 the second list (NONAME_UNDEFS) is used for types whose name is
4297 unknown at creation time, because they were referenced through
4298 their type number before the actual type was declared.
4299 This function actually adds the given type to the proper list. */
4302 add_undefined_type (struct type
*type
, int typenums
[2])
4304 if (TYPE_TAG_NAME (type
) == NULL
)
4305 add_undefined_type_noname (type
, typenums
);
4307 add_undefined_type_1 (type
);
4310 /* Try to fix all undefined types pushed on the UNDEF_TYPES vector. */
4313 cleanup_undefined_types_noname (struct objfile
*objfile
)
4317 for (i
= 0; i
< noname_undefs_length
; i
++)
4319 struct nat nat
= noname_undefs
[i
];
4322 type
= dbx_lookup_type (nat
.typenums
, objfile
);
4323 if (nat
.type
!= *type
&& TYPE_CODE (*type
) != TYPE_CODE_UNDEF
)
4325 /* The instance flags of the undefined type are still unset,
4326 and needs to be copied over from the reference type.
4327 Since replace_type expects them to be identical, we need
4328 to set these flags manually before hand. */
4329 TYPE_INSTANCE_FLAGS (nat
.type
) = TYPE_INSTANCE_FLAGS (*type
);
4330 replace_type (nat
.type
, *type
);
4334 noname_undefs_length
= 0;
4337 /* Go through each undefined type, see if it's still undefined, and fix it
4338 up if possible. We have two kinds of undefined types:
4340 TYPE_CODE_ARRAY: Array whose target type wasn't defined yet.
4341 Fix: update array length using the element bounds
4342 and the target type's length.
4343 TYPE_CODE_STRUCT, TYPE_CODE_UNION: Structure whose fields were not
4344 yet defined at the time a pointer to it was made.
4345 Fix: Do a full lookup on the struct/union tag. */
4348 cleanup_undefined_types_1 (void)
4352 /* Iterate over every undefined type, and look for a symbol whose type
4353 matches our undefined type. The symbol matches if:
4354 1. It is a typedef in the STRUCT domain;
4355 2. It has the same name, and same type code;
4356 3. The instance flags are identical.
4358 It is important to check the instance flags, because we have seen
4359 examples where the debug info contained definitions such as:
4361 "foo_t:t30=B31=xefoo_t:"
4363 In this case, we have created an undefined type named "foo_t" whose
4364 instance flags is null (when processing "xefoo_t"), and then created
4365 another type with the same name, but with different instance flags
4366 ('B' means volatile). I think that the definition above is wrong,
4367 since the same type cannot be volatile and non-volatile at the same
4368 time, but we need to be able to cope with it when it happens. The
4369 approach taken here is to treat these two types as different. */
4371 for (type
= undef_types
; type
< undef_types
+ undef_types_length
; type
++)
4373 switch (TYPE_CODE (*type
))
4376 case TYPE_CODE_STRUCT
:
4377 case TYPE_CODE_UNION
:
4378 case TYPE_CODE_ENUM
:
4380 /* Check if it has been defined since. Need to do this here
4381 as well as in check_typedef to deal with the (legitimate in
4382 C though not C++) case of several types with the same name
4383 in different source files. */
4384 if (TYPE_STUB (*type
))
4386 struct pending
*ppt
;
4388 /* Name of the type, without "struct" or "union" */
4389 char *typename
= TYPE_TAG_NAME (*type
);
4391 if (typename
== NULL
)
4393 complaint (&symfile_complaints
, _("need a type name"));
4396 for (ppt
= file_symbols
; ppt
; ppt
= ppt
->next
)
4398 for (i
= 0; i
< ppt
->nsyms
; i
++)
4400 struct symbol
*sym
= ppt
->symbol
[i
];
4402 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
4403 && SYMBOL_DOMAIN (sym
) == STRUCT_DOMAIN
4404 && (TYPE_CODE (SYMBOL_TYPE (sym
)) ==
4406 && (TYPE_INSTANCE_FLAGS (*type
) ==
4407 TYPE_INSTANCE_FLAGS (SYMBOL_TYPE (sym
)))
4408 && strcmp (SYMBOL_LINKAGE_NAME (sym
),
4410 replace_type (*type
, SYMBOL_TYPE (sym
));
4419 complaint (&symfile_complaints
,
4420 _("forward-referenced types left unresolved, "
4428 undef_types_length
= 0;
4431 /* Try to fix all the undefined types we ecountered while processing
4435 cleanup_undefined_types (struct objfile
*objfile
)
4437 cleanup_undefined_types_1 ();
4438 cleanup_undefined_types_noname (objfile
);
4441 /* Scan through all of the global symbols defined in the object file,
4442 assigning values to the debugging symbols that need to be assigned
4443 to. Get these symbols from the minimal symbol table. */
4446 scan_file_globals (struct objfile
*objfile
)
4449 struct minimal_symbol
*msymbol
;
4450 struct symbol
*sym
, *prev
;
4451 struct objfile
*resolve_objfile
;
4453 /* SVR4 based linkers copy referenced global symbols from shared
4454 libraries to the main executable.
4455 If we are scanning the symbols for a shared library, try to resolve
4456 them from the minimal symbols of the main executable first. */
4458 if (symfile_objfile
&& objfile
!= symfile_objfile
)
4459 resolve_objfile
= symfile_objfile
;
4461 resolve_objfile
= objfile
;
4465 /* Avoid expensive loop through all minimal symbols if there are
4466 no unresolved symbols. */
4467 for (hash
= 0; hash
< HASHSIZE
; hash
++)
4469 if (global_sym_chain
[hash
])
4472 if (hash
>= HASHSIZE
)
4475 ALL_OBJFILE_MSYMBOLS (resolve_objfile
, msymbol
)
4479 /* Skip static symbols. */
4480 switch (MSYMBOL_TYPE (msymbol
))
4492 /* Get the hash index and check all the symbols
4493 under that hash index. */
4495 hash
= hashname (SYMBOL_LINKAGE_NAME (msymbol
));
4497 for (sym
= global_sym_chain
[hash
]; sym
;)
4499 if (strcmp (SYMBOL_LINKAGE_NAME (msymbol
),
4500 SYMBOL_LINKAGE_NAME (sym
)) == 0)
4502 /* Splice this symbol out of the hash chain and
4503 assign the value we have to it. */
4506 SYMBOL_VALUE_CHAIN (prev
) = SYMBOL_VALUE_CHAIN (sym
);
4510 global_sym_chain
[hash
] = SYMBOL_VALUE_CHAIN (sym
);
4513 /* Check to see whether we need to fix up a common block. */
4514 /* Note: this code might be executed several times for
4515 the same symbol if there are multiple references. */
4518 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
4520 fix_common_block (sym
,
4521 SYMBOL_VALUE_ADDRESS (msymbol
));
4525 SYMBOL_VALUE_ADDRESS (sym
)
4526 = SYMBOL_VALUE_ADDRESS (msymbol
);
4528 SYMBOL_SECTION (sym
) = SYMBOL_SECTION (msymbol
);
4533 sym
= SYMBOL_VALUE_CHAIN (prev
);
4537 sym
= global_sym_chain
[hash
];
4543 sym
= SYMBOL_VALUE_CHAIN (sym
);
4547 if (resolve_objfile
== objfile
)
4549 resolve_objfile
= objfile
;
4552 /* Change the storage class of any remaining unresolved globals to
4553 LOC_UNRESOLVED and remove them from the chain. */
4554 for (hash
= 0; hash
< HASHSIZE
; hash
++)
4556 sym
= global_sym_chain
[hash
];
4560 sym
= SYMBOL_VALUE_CHAIN (sym
);
4562 /* Change the symbol address from the misleading chain value
4564 SYMBOL_VALUE_ADDRESS (prev
) = 0;
4566 /* Complain about unresolved common block symbols. */
4567 if (SYMBOL_CLASS (prev
) == LOC_STATIC
)
4568 SYMBOL_CLASS (prev
) = LOC_UNRESOLVED
;
4570 complaint (&symfile_complaints
,
4571 _("%s: common block `%s' from global_sym_chain unresolved"),
4572 objfile
->name
, SYMBOL_PRINT_NAME (prev
));
4575 memset (global_sym_chain
, 0, sizeof (global_sym_chain
));
4578 /* Initialize anything that needs initializing when starting to read
4579 a fresh piece of a symbol file, e.g. reading in the stuff corresponding
4583 stabsread_init (void)
4587 /* Initialize anything that needs initializing when a completely new
4588 symbol file is specified (not just adding some symbols from another
4589 file, e.g. a shared library). */
4592 stabsread_new_init (void)
4594 /* Empty the hash table of global syms looking for values. */
4595 memset (global_sym_chain
, 0, sizeof (global_sym_chain
));
4598 /* Initialize anything that needs initializing at the same time as
4599 start_symtab() is called. */
4604 global_stabs
= NULL
; /* AIX COFF */
4605 /* Leave FILENUM of 0 free for builtin types and this file's types. */
4606 n_this_object_header_files
= 1;
4607 type_vector_length
= 0;
4608 type_vector
= (struct type
**) 0;
4610 /* FIXME: If common_block_name is not already NULL, we should complain(). */
4611 common_block_name
= NULL
;
4614 /* Call after end_symtab() */
4621 xfree (type_vector
);
4624 type_vector_length
= 0;
4625 previous_stab_code
= 0;
4629 finish_global_stabs (struct objfile
*objfile
)
4633 patch_block_stabs (global_symbols
, global_stabs
, objfile
);
4634 xfree (global_stabs
);
4635 global_stabs
= NULL
;
4639 /* Find the end of the name, delimited by a ':', but don't match
4640 ObjC symbols which look like -[Foo bar::]:bla. */
4642 find_name_end (char *name
)
4645 if (s
[0] == '-' || *s
== '+')
4647 /* Must be an ObjC method symbol. */
4650 error (_("invalid symbol name \"%s\""), name
);
4652 s
= strchr (s
, ']');
4655 error (_("invalid symbol name \"%s\""), name
);
4657 return strchr (s
, ':');
4661 return strchr (s
, ':');
4665 /* Initializer for this module */
4668 _initialize_stabsread (void)
4670 rs6000_builtin_type_data
= register_objfile_data ();
4672 undef_types_allocated
= 20;
4673 undef_types_length
= 0;
4674 undef_types
= (struct type
**)
4675 xmalloc (undef_types_allocated
* sizeof (struct type
*));
4677 noname_undefs_allocated
= 20;
4678 noname_undefs_length
= 0;
4679 noname_undefs
= (struct nat
*)
4680 xmalloc (noname_undefs_allocated
* sizeof (struct nat
));