1 /* DWARF debugging format support for GDB.
2 Copyright (C) 1991, 1992 Free Software Foundation, Inc.
3 Written by Fred Fish at Cygnus Support. Portions based on dbxread.c,
4 mipsread.c, coffread.c, and dwarfread.c from a Data General SVR4 gdb port.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
24 FIXME: Figure out how to get the frame pointer register number in the
25 execution environment of the target. Remove R_FP kludge
27 FIXME: Add generation of dependencies list to partial symtab code.
29 FIXME: Resolve minor differences between what information we put in the
30 partial symbol table and what dbxread puts in. For example, we don't yet
31 put enum constants there. And dbxread seems to invent a lot of typedefs
32 we never see. Use the new printpsym command to see the partial symbol table
35 FIXME: Figure out a better way to tell gdb about the name of the function
36 contain the user's entry point (I.E. main())
38 FIXME: See other FIXME's and "ifdef 0" scattered throughout the code for
39 other things to work on, if you get bored. :-)
49 #include "libbfd.h" /* FIXME Secret Internal BFD stuff (bfd_read) */
50 #include "elf/dwarf.h"
57 #include <sys/types.h>
62 /* FIXME -- convert this to SEEK_SET a la POSIX, move to config files. */
67 #ifdef MAINTENANCE /* Define to 1 to compile in some maintenance stuff */
68 #define SQUAWK(stuff) dwarfwarn stuff
73 #ifndef R_FP /* FIXME */
74 #define R_FP 14 /* Kludge to get frame pointer register number */
77 typedef unsigned int DIE_REF
; /* Reference to a DIE */
80 #define GCC_PRODUCER "GNU C "
83 #ifndef GPLUS_PRODUCER
84 #define GPLUS_PRODUCER "GNU C++ "
88 #define LCC_PRODUCER "NCR C/C++"
91 #ifndef CFRONT_PRODUCER
92 #define CFRONT_PRODUCER "CFRONT " /* A wild a** guess... */
95 #define STREQ(a,b) (strcmp(a,b)==0)
96 #define STREQN(a,b,n) (strncmp(a,b,n)==0)
98 /* Flags to target_to_host() that tell whether or not the data object is
99 expected to be signed. Used, for example, when fetching a signed
100 integer in the target environment which is used as a signed integer
101 in the host environment, and the two environments have different sized
102 ints. In this case, *somebody* has to sign extend the smaller sized
105 #define GET_UNSIGNED 0 /* No sign extension required */
106 #define GET_SIGNED 1 /* Sign extension required */
108 /* Defines for things which are specified in the document "DWARF Debugging
109 Information Format" published by UNIX International, Programming Languages
110 SIG. These defines are based on revision 1.0.0, Jan 20, 1992. */
112 #define SIZEOF_DIE_LENGTH 4
113 #define SIZEOF_DIE_TAG 2
114 #define SIZEOF_ATTRIBUTE 2
115 #define SIZEOF_FORMAT_SPECIFIER 1
116 #define SIZEOF_FMT_FT 2
117 #define SIZEOF_LINETBL_LENGTH 4
118 #define SIZEOF_LINETBL_LINENO 4
119 #define SIZEOF_LINETBL_STMT 2
120 #define SIZEOF_LINETBL_DELTA 4
121 #define SIZEOF_LOC_ATOM_CODE 1
123 #define FORM_FROM_ATTR(attr) ((attr) & 0xF) /* Implicitly specified */
125 /* Macros that return the sizes of various types of data in the target
128 FIXME: Currently these are just compile time constants (as they are in
129 other parts of gdb as well). They need to be able to get the right size
130 either from the bfd or possibly from the DWARF info. It would be nice if
131 the DWARF producer inserted DIES that describe the fundamental types in
132 the target environment into the DWARF info, similar to the way dbx stabs
133 producers produce information about their fundamental types. */
135 #define TARGET_FT_POINTER_SIZE(objfile) (TARGET_PTR_BIT / TARGET_CHAR_BIT)
136 #define TARGET_FT_LONG_SIZE(objfile) (TARGET_LONG_BIT / TARGET_CHAR_BIT)
138 /* The Amiga SVR4 header file <dwarf.h> defines AT_element_list as a
139 FORM_BLOCK2, and this is the value emitted by the AT&T compiler.
140 However, the Issue 2 DWARF specification from AT&T defines it as
141 a FORM_BLOCK4, as does the latest specification from UI/PLSIG.
142 For backwards compatibility with the AT&T compiler produced executables
143 we define AT_short_element_list for this variant. */
145 #define AT_short_element_list (0x00f0|FORM_BLOCK2)
147 /* External variables referenced. */
149 extern int info_verbose
; /* From main.c; nonzero => verbose */
150 extern char *warning_pre_print
; /* From utils.c */
152 /* The DWARF debugging information consists of two major pieces,
153 one is a block of DWARF Information Entries (DIE's) and the other
154 is a line number table. The "struct dieinfo" structure contains
155 the information for a single DIE, the one currently being processed.
157 In order to make it easier to randomly access the attribute fields
158 of the current DIE, which are specifically unordered within the DIE,
159 each DIE is scanned and an instance of the "struct dieinfo"
160 structure is initialized.
162 Initialization is done in two levels. The first, done by basicdieinfo(),
163 just initializes those fields that are vital to deciding whether or not
164 to use this DIE, how to skip past it, etc. The second, done by the
165 function completedieinfo(), fills in the rest of the information.
167 Attributes which have block forms are not interpreted at the time
168 the DIE is scanned, instead we just save pointers to the start
169 of their value fields.
171 Some fields have a flag <name>_p that is set when the value of the
172 field is valid (I.E. we found a matching attribute in the DIE). Since
173 we may want to test for the presence of some attributes in the DIE,
174 such as AT_low_pc, without restricting the values of the field,
175 we need someway to note that we found such an attribute.
182 char * die
; /* Pointer to the raw DIE data */
183 unsigned long die_length
; /* Length of the raw DIE data */
184 DIE_REF die_ref
; /* Offset of this DIE */
185 unsigned short die_tag
; /* Tag for this DIE */
186 unsigned long at_padding
;
187 unsigned long at_sibling
;
190 unsigned short at_fund_type
;
191 BLOCK
* at_mod_fund_type
;
192 unsigned long at_user_def_type
;
193 BLOCK
* at_mod_u_d_type
;
194 unsigned short at_ordering
;
195 BLOCK
* at_subscr_data
;
196 unsigned long at_byte_size
;
197 unsigned short at_bit_offset
;
198 unsigned long at_bit_size
;
199 BLOCK
* at_element_list
;
200 unsigned long at_stmt_list
;
201 unsigned long at_low_pc
;
202 unsigned long at_high_pc
;
203 unsigned long at_language
;
204 unsigned long at_member
;
205 unsigned long at_discr
;
206 BLOCK
* at_discr_value
;
207 BLOCK
* at_string_length
;
210 unsigned long at_start_scope
;
211 unsigned long at_stride_size
;
212 unsigned long at_src_info
;
213 char * at_prototyped
;
214 unsigned int has_at_low_pc
:1;
215 unsigned int has_at_stmt_list
:1;
216 unsigned int has_at_byte_size
:1;
217 unsigned int short_element_list
:1;
220 static int diecount
; /* Approximate count of dies for compilation unit */
221 static struct dieinfo
*curdie
; /* For warnings and such */
223 static char *dbbase
; /* Base pointer to dwarf info */
224 static int dbsize
; /* Size of dwarf info in bytes */
225 static int dbroff
; /* Relative offset from start of .debug section */
226 static char *lnbase
; /* Base pointer to line section */
227 static int isreg
; /* Kludge to identify register variables */
228 static int offreg
; /* Kludge to identify basereg references */
230 /* This value is added to each symbol value. FIXME: Generalize to
231 the section_offsets structure used by dbxread. */
232 static CORE_ADDR baseaddr
; /* Add to each symbol value */
234 /* The section offsets used in the current psymtab or symtab. FIXME,
235 only used to pass one value (baseaddr) at the moment. */
236 static struct section_offsets
*base_section_offsets
;
238 /* Each partial symbol table entry contains a pointer to private data for the
239 read_symtab() function to use when expanding a partial symbol table entry
240 to a full symbol table entry. For DWARF debugging info, this data is
241 contained in the following structure and macros are provided for easy
242 access to the members given a pointer to a partial symbol table entry.
244 dbfoff Always the absolute file offset to the start of the ".debug"
245 section for the file containing the DIE's being accessed.
247 dbroff Relative offset from the start of the ".debug" access to the
248 first DIE to be accessed. When building the partial symbol
249 table, this value will be zero since we are accessing the
250 entire ".debug" section. When expanding a partial symbol
251 table entry, this value will be the offset to the first
252 DIE for the compilation unit containing the symbol that
253 triggers the expansion.
255 dblength The size of the chunk of DIE's being examined, in bytes.
257 lnfoff The absolute file offset to the line table fragment. Ignored
258 when building partial symbol tables, but used when expanding
259 them, and contains the absolute file offset to the fragment
260 of the ".line" section containing the line numbers for the
261 current compilation unit.
265 file_ptr dbfoff
; /* Absolute file offset to start of .debug section */
266 int dbroff
; /* Relative offset from start of .debug section */
267 int dblength
; /* Size of the chunk of DIE's being examined */
268 file_ptr lnfoff
; /* Absolute file offset to line table fragment */
271 #define DBFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbfoff)
272 #define DBROFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbroff)
273 #define DBLENGTH(p) (((struct dwfinfo *)((p)->read_symtab_private))->dblength)
274 #define LNFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->lnfoff)
276 /* The generic symbol table building routines have separate lists for
277 file scope symbols and all all other scopes (local scopes). So
278 we need to select the right one to pass to add_symbol_to_list().
279 We do it by keeping a pointer to the correct list in list_in_scope.
281 FIXME: The original dwarf code just treated the file scope as the first
282 local scope, and all other local scopes as nested local scopes, and worked
283 fine. Check to see if we really need to distinguish these in buildsym.c */
285 struct pending
**list_in_scope
= &file_symbols
;
287 /* DIES which have user defined types or modified user defined types refer to
288 other DIES for the type information. Thus we need to associate the offset
289 of a DIE for a user defined type with a pointer to the type information.
291 Originally this was done using a simple but expensive algorithm, with an
292 array of unsorted structures, each containing an offset/type-pointer pair.
293 This array was scanned linearly each time a lookup was done. The result
294 was that gdb was spending over half it's startup time munging through this
295 array of pointers looking for a structure that had the right offset member.
297 The second attempt used the same array of structures, but the array was
298 sorted using qsort each time a new offset/type was recorded, and a binary
299 search was used to find the type pointer for a given DIE offset. This was
300 even slower, due to the overhead of sorting the array each time a new
301 offset/type pair was entered.
303 The third attempt uses a fixed size array of type pointers, indexed by a
304 value derived from the DIE offset. Since the minimum DIE size is 4 bytes,
305 we can divide any DIE offset by 4 to obtain a unique index into this fixed
306 size array. Since each element is a 4 byte pointer, it takes exactly as
307 much memory to hold this array as to hold the DWARF info for a given
308 compilation unit. But it gets freed as soon as we are done with it. */
310 static struct type
**utypes
; /* Pointer to array of user type pointers */
311 static int numutypes
; /* Max number of user type pointers */
313 /* Record the language for the compilation unit which is currently being
314 processed. We know it once we have seen the TAG_compile_unit DIE,
315 and we need it while processing the DIE's for that compilation unit.
316 It is eventually saved in the symtab structure, but we don't finalize
317 the symtab struct until we have processed all the DIE's for the
320 static enum language cu_language
;
322 /* Forward declarations of static functions so we don't have to worry
323 about ordering within this file. */
326 attribute_size
PARAMS ((unsigned int));
329 target_to_host
PARAMS ((char *, int, int, struct objfile
*));
332 add_enum_psymbol
PARAMS ((struct dieinfo
*, struct objfile
*));
335 handle_producer
PARAMS ((char *));
338 read_file_scope
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
341 read_func_scope
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
344 read_lexical_block_scope
PARAMS ((struct dieinfo
*, char *, char *,
351 scan_partial_symbols
PARAMS ((char *, char *, struct objfile
*));
354 scan_compilation_units
PARAMS ((char *, char *, file_ptr
,
355 file_ptr
, struct objfile
*));
358 add_partial_symbol
PARAMS ((struct dieinfo
*, struct objfile
*));
361 init_psymbol_list
PARAMS ((struct objfile
*, int));
364 basicdieinfo
PARAMS ((struct dieinfo
*, char *, struct objfile
*));
367 completedieinfo
PARAMS ((struct dieinfo
*, struct objfile
*));
370 dwarf_psymtab_to_symtab
PARAMS ((struct partial_symtab
*));
373 psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*));
375 static struct symtab
*
376 read_ofile_symtab
PARAMS ((struct partial_symtab
*));
379 process_dies
PARAMS ((char *, char *, struct objfile
*));
382 read_structure_scope
PARAMS ((struct dieinfo
*, char *, char *,
386 decode_array_element_type
PARAMS ((char *));
389 decode_subscr_data
PARAMS ((char *, char *));
392 dwarf_read_array_type
PARAMS ((struct dieinfo
*));
395 read_tag_pointer_type
PARAMS ((struct dieinfo
*dip
));
398 read_subroutine_type
PARAMS ((struct dieinfo
*, char *, char *));
401 read_enumeration
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
404 struct_type
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
407 enum_type
PARAMS ((struct dieinfo
*, struct objfile
*));
410 decode_line_numbers
PARAMS ((char *));
413 decode_die_type
PARAMS ((struct dieinfo
*));
416 decode_mod_fund_type
PARAMS ((char *));
419 decode_mod_u_d_type
PARAMS ((char *));
422 decode_modified_type
PARAMS ((char *, unsigned int, int));
425 decode_fund_type
PARAMS ((unsigned int));
428 create_name
PARAMS ((char *, struct obstack
*));
431 lookup_utype
PARAMS ((DIE_REF
));
434 alloc_utype
PARAMS ((DIE_REF
, struct type
*));
436 static struct symbol
*
437 new_symbol
PARAMS ((struct dieinfo
*, struct objfile
*));
440 synthesize_typedef
PARAMS ((struct dieinfo
*, struct objfile
*,
444 locval
PARAMS ((char *));
447 record_minimal_symbol
PARAMS ((char *, CORE_ADDR
, enum minimal_symbol_type
,
451 set_cu_language
PARAMS ((struct dieinfo
*));
457 set_cu_language -- set local copy of language for compilation unit
462 set_cu_language (struct dieinfo *dip)
466 Decode the language attribute for a compilation unit DIE and
467 remember what the language was. We use this at various times
468 when processing DIE's for a given compilation unit.
477 set_cu_language (dip
)
480 switch (dip
-> at_language
)
484 cu_language
= language_c
;
486 case LANG_C_PLUS_PLUS
:
487 cu_language
= language_cplus
;
497 cu_language
= language_unknown
;
506 dwarf_build_psymtabs -- build partial symtabs from DWARF debug info
510 void dwarf_build_psymtabs (struct objfile *objfile,
511 struct section_offsets *section_offsets,
512 int mainline, file_ptr dbfoff, unsigned int dbfsize,
513 file_ptr lnoffset, unsigned int lnsize)
517 This function is called upon to build partial symtabs from files
518 containing DIE's (Dwarf Information Entries) and DWARF line numbers.
520 It is passed a bfd* containing the DIES
521 and line number information, the corresponding filename for that
522 file, a base address for relocating the symbols, a flag indicating
523 whether or not this debugging information is from a "main symbol
524 table" rather than a shared library or dynamically linked file,
525 and file offset/size pairs for the DIE information and line number
535 dwarf_build_psymtabs (objfile
, section_offsets
, mainline
, dbfoff
, dbfsize
,
537 struct objfile
*objfile
;
538 struct section_offsets
*section_offsets
;
541 unsigned int dbfsize
;
545 bfd
*abfd
= objfile
->obfd
;
546 struct cleanup
*back_to
;
548 current_objfile
= objfile
;
550 dbbase
= xmalloc (dbsize
);
552 if ((bfd_seek (abfd
, dbfoff
, L_SET
) != 0) ||
553 (bfd_read (dbbase
, dbsize
, 1, abfd
) != dbsize
))
556 error ("can't read DWARF data from '%s'", bfd_get_filename (abfd
));
558 back_to
= make_cleanup (free
, dbbase
);
560 /* If we are reinitializing, or if we have never loaded syms yet, init.
561 Since we have no idea how many DIES we are looking at, we just guess
562 some arbitrary value. */
564 if (mainline
|| objfile
-> global_psymbols
.size
== 0 ||
565 objfile
-> static_psymbols
.size
== 0)
567 init_psymbol_list (objfile
, 1024);
570 /* Save the relocation factor where everybody can see it. */
572 base_section_offsets
= section_offsets
;
573 baseaddr
= ANOFFSET (section_offsets
, 0);
575 /* Follow the compilation unit sibling chain, building a partial symbol
576 table entry for each one. Save enough information about each compilation
577 unit to locate the full DWARF information later. */
579 scan_compilation_units (dbbase
, dbbase
+ dbsize
, dbfoff
, lnoffset
, objfile
);
581 do_cleanups (back_to
);
582 current_objfile
= NULL
;
590 record_minimal_symbol -- add entry to gdb's minimal symbol table
594 static void record_minimal_symbol (char *name, CORE_ADDR address,
595 enum minimal_symbol_type ms_type,
596 struct objfile *objfile)
600 Given a pointer to the name of a symbol that should be added to the
601 minimal symbol table, and the address associated with that
602 symbol, records this information for later use in building the
603 minimal symbol table.
608 record_minimal_symbol (name
, address
, ms_type
, objfile
)
611 enum minimal_symbol_type ms_type
;
612 struct objfile
*objfile
;
614 name
= obsavestring (name
, strlen (name
), &objfile
-> symbol_obstack
);
615 prim_record_minimal_symbol (name
, address
, ms_type
);
622 dwarfwarn -- issue a DWARF related warning
626 Issue warnings about DWARF related things that aren't serious enough
627 to warrant aborting with an error, but should not be ignored either.
628 This includes things like detectable corruption in DIE's, missing
629 DIE's, unimplemented features, etc.
631 In general, running across tags or attributes that we don't recognize
632 is not considered to be a problem and we should not issue warnings
637 We mostly follow the example of the error() routine, but without
638 returning to command level. It is arguable about whether warnings
639 should be issued at all, and if so, where they should go (stdout or
642 We assume that curdie is valid and contains at least the basic
643 information for the DIE where the problem was noticed.
654 fmt
= va_arg (ap
, char *);
656 fprintf (stderr
, "warning: DWARF ref 0x%x: ", curdie
-> die_ref
);
657 if (curdie
-> at_name
)
659 fprintf (stderr
, "'%s': ", curdie
-> at_name
);
661 vfprintf (stderr
, fmt
, ap
);
662 fprintf (stderr
, "\n");
671 read_lexical_block_scope -- process all dies in a lexical block
675 static void read_lexical_block_scope (struct dieinfo *dip,
676 char *thisdie, char *enddie)
680 Process all the DIES contained within a lexical block scope.
681 Start a new scope, process the dies, and then close the scope.
686 read_lexical_block_scope (dip
, thisdie
, enddie
, objfile
)
690 struct objfile
*objfile
;
692 register struct context_stack
*new;
694 push_context (0, dip
-> at_low_pc
);
695 process_dies (thisdie
+ dip
-> die_length
, enddie
, objfile
);
696 new = pop_context ();
697 if (local_symbols
!= NULL
)
699 finish_block (0, &local_symbols
, new -> old_blocks
, new -> start_addr
,
700 dip
-> at_high_pc
, objfile
);
702 local_symbols
= new -> locals
;
709 lookup_utype -- look up a user defined type from die reference
713 static type *lookup_utype (DIE_REF die_ref)
717 Given a DIE reference, lookup the user defined type associated with
718 that DIE, if it has been registered already. If not registered, then
719 return NULL. Alloc_utype() can be called to register an empty
720 type for this reference, which will be filled in later when the
721 actual referenced DIE is processed.
725 lookup_utype (die_ref
)
728 struct type
*type
= NULL
;
731 utypeidx
= (die_ref
- dbroff
) / 4;
732 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
734 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", die_ref
);
738 type
= *(utypes
+ utypeidx
);
748 alloc_utype -- add a user defined type for die reference
752 static type *alloc_utype (DIE_REF die_ref, struct type *utypep)
756 Given a die reference DIE_REF, and a possible pointer to a user
757 defined type UTYPEP, register that this reference has a user
758 defined type and either use the specified type in UTYPEP or
759 make a new empty type that will be filled in later.
761 We should only be called after calling lookup_utype() to verify that
762 there is not currently a type registered for DIE_REF.
766 alloc_utype (die_ref
, utypep
)
773 utypeidx
= (die_ref
- dbroff
) / 4;
774 typep
= utypes
+ utypeidx
;
775 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
777 utypep
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
778 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", die_ref
);
780 else if (*typep
!= NULL
)
783 SQUAWK (("internal error: dup user type allocation"));
789 utypep
= alloc_type (current_objfile
);
800 decode_die_type -- return a type for a specified die
804 static struct type *decode_die_type (struct dieinfo *dip)
808 Given a pointer to a die information structure DIP, decode the
809 type of the die and return a pointer to the decoded type. All
810 dies without specific types default to type int.
814 decode_die_type (dip
)
817 struct type
*type
= NULL
;
819 if (dip
-> at_fund_type
!= 0)
821 type
= decode_fund_type (dip
-> at_fund_type
);
823 else if (dip
-> at_mod_fund_type
!= NULL
)
825 type
= decode_mod_fund_type (dip
-> at_mod_fund_type
);
827 else if (dip
-> at_user_def_type
)
829 if ((type
= lookup_utype (dip
-> at_user_def_type
)) == NULL
)
831 type
= alloc_utype (dip
-> at_user_def_type
, NULL
);
834 else if (dip
-> at_mod_u_d_type
)
836 type
= decode_mod_u_d_type (dip
-> at_mod_u_d_type
);
840 type
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
849 struct_type -- compute and return the type for a struct or union
853 static struct type *struct_type (struct dieinfo *dip, char *thisdie,
854 char *enddie, struct objfile *objfile)
858 Given pointer to a die information structure for a die which
859 defines a union or structure (and MUST define one or the other),
860 and pointers to the raw die data that define the range of dies which
861 define the members, compute and return the user defined type for the
866 struct_type (dip
, thisdie
, enddie
, objfile
)
870 struct objfile
*objfile
;
874 struct nextfield
*next
;
877 struct nextfield
*list
= NULL
;
878 struct nextfield
*new;
886 if ((type
= lookup_utype (dip
-> die_ref
)) == NULL
)
888 /* No forward references created an empty type, so install one now */
889 type
= alloc_utype (dip
-> die_ref
, NULL
);
891 INIT_CPLUS_SPECIFIC(type
);
892 switch (dip
-> die_tag
)
895 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
898 case TAG_structure_type
:
899 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
903 TYPE_CODE (type
) = TYPE_CODE_UNION
;
907 /* Should never happen */
908 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
910 SQUAWK (("missing class, structure, or union tag"));
913 /* Some compilers try to be helpful by inventing "fake" names for
914 anonymous enums, structures, and unions, like "~0fake" or ".0fake".
915 Thanks, but no thanks... */
916 if (dip
-> at_name
!= NULL
917 && *dip
-> at_name
!= '~'
918 && *dip
-> at_name
!= '.')
920 TYPE_NAME (type
) = obconcat (&objfile
-> type_obstack
,
921 tpart1
, " ", dip
-> at_name
);
923 /* Use whatever size is known. Zero is a valid size. We might however
924 wish to check has_at_byte_size to make sure that some byte size was
925 given explicitly, but DWARF doesn't specify that explicit sizes of
926 zero have to present, so complaining about missing sizes should
927 probably not be the default. */
928 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
929 thisdie
+= dip
-> die_length
;
930 while (thisdie
< enddie
)
932 basicdieinfo (&mbr
, thisdie
, objfile
);
933 completedieinfo (&mbr
, objfile
);
934 if (mbr
.die_length
<= SIZEOF_DIE_LENGTH
)
938 else if (mbr
.at_sibling
!= 0)
940 nextdie
= dbbase
+ mbr
.at_sibling
- dbroff
;
944 nextdie
= thisdie
+ mbr
.die_length
;
949 /* Get space to record the next field's data. */
950 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
955 obsavestring (mbr
.at_name
, strlen (mbr
.at_name
),
956 &objfile
-> type_obstack
);
957 list
-> field
.type
= decode_die_type (&mbr
);
958 list
-> field
.bitpos
= 8 * locval (mbr
.at_location
);
959 /* Handle bit fields. */
960 list
-> field
.bitsize
= mbr
.at_bit_size
;
962 /* For big endian bits, the at_bit_offset gives the additional
963 bit offset from the MSB of the containing anonymous object to
964 the MSB of the field. We don't have to do anything special
965 since we don't need to know the size of the anonymous object. */
966 list
-> field
.bitpos
+= mbr
.at_bit_offset
;
968 /* For little endian bits, we need to have a non-zero at_bit_size,
969 so that we know we are in fact dealing with a bitfield. Compute
970 the bit offset to the MSB of the anonymous object, subtract off
971 the number of bits from the MSB of the field to the MSB of the
972 object, and then subtract off the number of bits of the field
973 itself. The result is the bit offset of the LSB of the field. */
974 if (mbr
.at_bit_size
> 0)
976 if (mbr
.has_at_byte_size
)
978 /* The size of the anonymous object containing the bit field
979 is explicit, so use the indicated size (in bytes). */
980 anonymous_size
= mbr
.at_byte_size
;
984 /* The size of the anonymous object containing the bit field
985 matches the size of an object of the bit field's type.
986 DWARF allows at_byte_size to be left out in such cases,
987 as a debug information size optimization. */
988 anonymous_size
= TYPE_LENGTH (list
-> field
.type
);
990 list
-> field
.bitpos
+=
991 anonymous_size
* 8 - mbr
.at_bit_offset
- mbr
.at_bit_size
;
997 process_dies (thisdie
, nextdie
, objfile
);
1002 /* Now create the vector of fields, and record how big it is. We may
1003 not even have any fields, if this DIE was generated due to a reference
1004 to an anonymous structure or union. In this case, TYPE_FLAG_STUB is
1005 set, which clues gdb in to the fact that it needs to search elsewhere
1006 for the full structure definition. */
1009 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
1013 TYPE_NFIELDS (type
) = nfields
;
1014 TYPE_FIELDS (type
) = (struct field
*)
1015 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
1016 /* Copy the saved-up fields into the field vector. */
1017 for (n
= nfields
; list
; list
= list
-> next
)
1019 TYPE_FIELD (type
, --n
) = list
-> field
;
1029 read_structure_scope -- process all dies within struct or union
1033 static void read_structure_scope (struct dieinfo *dip,
1034 char *thisdie, char *enddie, struct objfile *objfile)
1038 Called when we find the DIE that starts a structure or union
1039 scope (definition) to process all dies that define the members
1040 of the structure or union. DIP is a pointer to the die info
1041 struct for the DIE that names the structure or union.
1045 Note that we need to call struct_type regardless of whether or not
1046 the DIE has an at_name attribute, since it might be an anonymous
1047 structure or union. This gets the type entered into our set of
1050 However, if the structure is incomplete (an opaque struct/union)
1051 then suppress creating a symbol table entry for it since gdb only
1052 wants to find the one with the complete definition. Note that if
1053 it is complete, we just call new_symbol, which does it's own
1054 checking about whether the struct/union is anonymous or not (and
1055 suppresses creating a symbol table entry itself).
1060 read_structure_scope (dip
, thisdie
, enddie
, objfile
)
1061 struct dieinfo
*dip
;
1064 struct objfile
*objfile
;
1069 type
= struct_type (dip
, thisdie
, enddie
, objfile
);
1070 if (!(TYPE_FLAGS (type
) & TYPE_FLAG_STUB
))
1072 sym
= new_symbol (dip
, objfile
);
1075 SYMBOL_TYPE (sym
) = type
;
1076 if (cu_language
== language_cplus
)
1078 synthesize_typedef (dip
, objfile
, type
);
1088 decode_array_element_type -- decode type of the array elements
1092 static struct type *decode_array_element_type (char *scan, char *end)
1096 As the last step in decoding the array subscript information for an
1097 array DIE, we need to decode the type of the array elements. We are
1098 passed a pointer to this last part of the subscript information and
1099 must return the appropriate type. If the type attribute is not
1100 recognized, just warn about the problem and return type int.
1103 static struct type
*
1104 decode_array_element_type (scan
)
1109 unsigned short attribute
;
1110 unsigned short fundtype
;
1113 attribute
= target_to_host (scan
, SIZEOF_ATTRIBUTE
, GET_UNSIGNED
,
1115 scan
+= SIZEOF_ATTRIBUTE
;
1116 if ((nbytes
= attribute_size (attribute
)) == -1)
1118 SQUAWK (("bad array element type attribute 0x%x", attribute
));
1119 typep
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1126 fundtype
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1128 typep
= decode_fund_type (fundtype
);
1130 case AT_mod_fund_type
:
1131 typep
= decode_mod_fund_type (scan
);
1133 case AT_user_def_type
:
1134 die_ref
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1136 if ((typep
= lookup_utype (die_ref
)) == NULL
)
1138 typep
= alloc_utype (die_ref
, NULL
);
1141 case AT_mod_u_d_type
:
1142 typep
= decode_mod_u_d_type (scan
);
1145 SQUAWK (("bad array element type attribute 0x%x", attribute
));
1146 typep
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1157 decode_subscr_data -- decode array subscript and element type data
1161 static struct type *decode_subscr_data (char *scan, char *end)
1165 The array subscripts and the data type of the elements of an
1166 array are described by a list of data items, stored as a block
1167 of contiguous bytes. There is a data item describing each array
1168 dimension, and a final data item describing the element type.
1169 The data items are ordered the same as their appearance in the
1170 source (I.E. leftmost dimension first, next to leftmost second,
1173 We are passed a pointer to the start of the block of bytes
1174 containing the data items, and a pointer to the first byte past
1175 the data. This function decodes the data and returns a type.
1178 FIXME: This code only implements the forms currently used
1179 by the AT&T and GNU C compilers.
1181 The end pointer is supplied for error checking, maybe we should
1185 static struct type
*
1186 decode_subscr_data (scan
, end
)
1190 struct type
*typep
= NULL
;
1191 struct type
*nexttype
;
1192 unsigned int format
;
1193 unsigned short fundtype
;
1194 unsigned long lowbound
;
1195 unsigned long highbound
;
1198 format
= target_to_host (scan
, SIZEOF_FORMAT_SPECIFIER
, GET_UNSIGNED
,
1200 scan
+= SIZEOF_FORMAT_SPECIFIER
;
1204 typep
= decode_array_element_type (scan
);
1207 fundtype
= target_to_host (scan
, SIZEOF_FMT_FT
, GET_UNSIGNED
,
1209 scan
+= SIZEOF_FMT_FT
;
1210 if (fundtype
!= FT_integer
&& fundtype
!= FT_signed_integer
1211 && fundtype
!= FT_unsigned_integer
)
1213 SQUAWK (("array subscripts must be integral types, not type 0x%x",
1218 nbytes
= TARGET_FT_LONG_SIZE (current_objfile
);
1219 lowbound
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1222 highbound
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1225 nexttype
= decode_subscr_data (scan
, end
);
1226 if (nexttype
!= NULL
)
1228 typep
= alloc_type (current_objfile
);
1229 TYPE_CODE (typep
) = TYPE_CODE_ARRAY
;
1230 TYPE_LENGTH (typep
) = TYPE_LENGTH (nexttype
);
1231 TYPE_LENGTH (typep
) *= (highbound
- lowbound
) + 1;
1232 TYPE_TARGET_TYPE (typep
) = nexttype
;
1243 SQUAWK (("array subscript format 0x%x not handled yet", format
));
1246 SQUAWK (("unknown array subscript format %x", format
));
1256 dwarf_read_array_type -- read TAG_array_type DIE
1260 static void dwarf_read_array_type (struct dieinfo *dip)
1264 Extract all information from a TAG_array_type DIE and add to
1265 the user defined type vector.
1269 dwarf_read_array_type (dip
)
1270 struct dieinfo
*dip
;
1276 unsigned short blocksz
;
1279 if (dip
-> at_ordering
!= ORD_row_major
)
1281 /* FIXME: Can gdb even handle column major arrays? */
1282 SQUAWK (("array not row major; not handled correctly"));
1284 if ((sub
= dip
-> at_subscr_data
) != NULL
)
1286 nbytes
= attribute_size (AT_subscr_data
);
1287 blocksz
= target_to_host (sub
, nbytes
, GET_UNSIGNED
, current_objfile
);
1288 subend
= sub
+ nbytes
+ blocksz
;
1290 type
= decode_subscr_data (sub
, subend
);
1293 if ((utype
= lookup_utype (dip
-> die_ref
)) == NULL
)
1295 utype
= alloc_utype (dip
-> die_ref
, NULL
);
1297 TYPE_CODE (utype
) = TYPE_CODE_ARRAY
;
1298 TYPE_TARGET_TYPE (utype
) =
1299 lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1300 TYPE_LENGTH (utype
) = 1 * TYPE_LENGTH (TYPE_TARGET_TYPE (utype
));
1304 if ((utype
= lookup_utype (dip
-> die_ref
)) == NULL
)
1306 alloc_utype (dip
-> die_ref
, type
);
1310 TYPE_CODE (utype
) = TYPE_CODE_ARRAY
;
1311 TYPE_LENGTH (utype
) = TYPE_LENGTH (type
);
1312 TYPE_TARGET_TYPE (utype
) = TYPE_TARGET_TYPE (type
);
1322 read_tag_pointer_type -- read TAG_pointer_type DIE
1326 static void read_tag_pointer_type (struct dieinfo *dip)
1330 Extract all information from a TAG_pointer_type DIE and add to
1331 the user defined type vector.
1335 read_tag_pointer_type (dip
)
1336 struct dieinfo
*dip
;
1341 type
= decode_die_type (dip
);
1342 if ((utype
= lookup_utype (dip
-> die_ref
)) == NULL
)
1344 utype
= lookup_pointer_type (type
);
1345 alloc_utype (dip
-> die_ref
, utype
);
1349 TYPE_TARGET_TYPE (utype
) = type
;
1350 TYPE_POINTER_TYPE (type
) = utype
;
1352 /* We assume the machine has only one representation for pointers! */
1353 /* FIXME: This confuses host<->target data representations, and is a
1354 poor assumption besides. */
1356 TYPE_LENGTH (utype
) = sizeof (char *);
1357 TYPE_CODE (utype
) = TYPE_CODE_PTR
;
1365 read_subroutine_type -- process TAG_subroutine_type dies
1369 static void read_subroutine_type (struct dieinfo *dip, char thisdie,
1374 Handle DIES due to C code like:
1377 int (*funcp)(int a, long l); (Generates TAG_subroutine_type DIE)
1383 The parameter DIES are currently ignored. See if gdb has a way to
1384 include this info in it's type system, and decode them if so. Is
1385 this what the type structure's "arg_types" field is for? (FIXME)
1389 read_subroutine_type (dip
, thisdie
, enddie
)
1390 struct dieinfo
*dip
;
1394 struct type
*type
; /* Type that this function returns */
1395 struct type
*ftype
; /* Function that returns above type */
1397 /* Decode the type that this subroutine returns */
1399 type
= decode_die_type (dip
);
1401 /* Check to see if we already have a partially constructed user
1402 defined type for this DIE, from a forward reference. */
1404 if ((ftype
= lookup_utype (dip
-> die_ref
)) == NULL
)
1406 /* This is the first reference to one of these types. Make
1407 a new one and place it in the user defined types. */
1408 ftype
= lookup_function_type (type
);
1409 alloc_utype (dip
-> die_ref
, ftype
);
1413 /* We have an existing partially constructed type, so bash it
1414 into the correct type. */
1415 TYPE_TARGET_TYPE (ftype
) = type
;
1416 TYPE_FUNCTION_TYPE (type
) = ftype
;
1417 TYPE_LENGTH (ftype
) = 1;
1418 TYPE_CODE (ftype
) = TYPE_CODE_FUNC
;
1426 read_enumeration -- process dies which define an enumeration
1430 static void read_enumeration (struct dieinfo *dip, char *thisdie,
1431 char *enddie, struct objfile *objfile)
1435 Given a pointer to a die which begins an enumeration, process all
1436 the dies that define the members of the enumeration.
1440 Note that we need to call enum_type regardless of whether or not we
1441 have a symbol, since we might have an enum without a tag name (thus
1442 no symbol for the tagname).
1446 read_enumeration (dip
, thisdie
, enddie
, objfile
)
1447 struct dieinfo
*dip
;
1450 struct objfile
*objfile
;
1455 type
= enum_type (dip
, objfile
);
1456 sym
= new_symbol (dip
, objfile
);
1459 SYMBOL_TYPE (sym
) = type
;
1460 if (cu_language
== language_cplus
)
1462 synthesize_typedef (dip
, objfile
, type
);
1471 enum_type -- decode and return a type for an enumeration
1475 static type *enum_type (struct dieinfo *dip, struct objfile *objfile)
1479 Given a pointer to a die information structure for the die which
1480 starts an enumeration, process all the dies that define the members
1481 of the enumeration and return a type pointer for the enumeration.
1483 At the same time, for each member of the enumeration, create a
1484 symbol for it with namespace VAR_NAMESPACE and class LOC_CONST,
1485 and give it the type of the enumeration itself.
1489 Note that the DWARF specification explicitly mandates that enum
1490 constants occur in reverse order from the source program order,
1491 for "consistency" and because this ordering is easier for many
1492 compilers to generate. (Draft 6, sec 3.8.5, Enumeration type
1493 Entries). Because gdb wants to see the enum members in program
1494 source order, we have to ensure that the order gets reversed while
1495 we are processing them.
1498 static struct type
*
1499 enum_type (dip
, objfile
)
1500 struct dieinfo
*dip
;
1501 struct objfile
*objfile
;
1505 struct nextfield
*next
;
1508 struct nextfield
*list
= NULL
;
1509 struct nextfield
*new;
1514 unsigned short blocksz
;
1518 if ((type
= lookup_utype (dip
-> die_ref
)) == NULL
)
1520 /* No forward references created an empty type, so install one now */
1521 type
= alloc_utype (dip
-> die_ref
, NULL
);
1523 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1524 /* Some compilers try to be helpful by inventing "fake" names for
1525 anonymous enums, structures, and unions, like "~0fake" or ".0fake".
1526 Thanks, but no thanks... */
1527 if (dip
-> at_name
!= NULL
1528 && *dip
-> at_name
!= '~'
1529 && *dip
-> at_name
!= '.')
1531 TYPE_NAME (type
) = obconcat (&objfile
-> type_obstack
, "enum",
1532 " ", dip
-> at_name
);
1534 if (dip
-> at_byte_size
!= 0)
1536 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
1538 if ((scan
= dip
-> at_element_list
) != NULL
)
1540 if (dip
-> short_element_list
)
1542 nbytes
= attribute_size (AT_short_element_list
);
1546 nbytes
= attribute_size (AT_element_list
);
1548 blocksz
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, objfile
);
1549 listend
= scan
+ nbytes
+ blocksz
;
1551 while (scan
< listend
)
1553 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1556 list
-> field
.type
= NULL
;
1557 list
-> field
.bitsize
= 0;
1558 list
-> field
.bitpos
=
1559 target_to_host (scan
, TARGET_FT_LONG_SIZE (objfile
), GET_SIGNED
,
1561 scan
+= TARGET_FT_LONG_SIZE (objfile
);
1562 list
-> field
.name
= obsavestring (scan
, strlen (scan
),
1563 &objfile
-> type_obstack
);
1564 scan
+= strlen (scan
) + 1;
1566 /* Handcraft a new symbol for this enum member. */
1567 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
1568 sizeof (struct symbol
));
1569 memset (sym
, 0, sizeof (struct symbol
));
1570 SYMBOL_NAME (sym
) = create_name (list
-> field
.name
,
1571 &objfile
->symbol_obstack
);
1572 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1573 SYMBOL_CLASS (sym
) = LOC_CONST
;
1574 SYMBOL_TYPE (sym
) = type
;
1575 SYMBOL_VALUE (sym
) = list
-> field
.bitpos
;
1576 add_symbol_to_list (sym
, list_in_scope
);
1578 /* Now create the vector of fields, and record how big it is. This is
1579 where we reverse the order, by pulling the members off the list in
1580 reverse order from how they were inserted. If we have no fields
1581 (this is apparently possible in C++) then skip building a field
1585 TYPE_NFIELDS (type
) = nfields
;
1586 TYPE_FIELDS (type
) = (struct field
*)
1587 obstack_alloc (&objfile
->symbol_obstack
, sizeof (struct field
) * nfields
);
1588 /* Copy the saved-up fields into the field vector. */
1589 for (n
= 0; (n
< nfields
) && (list
!= NULL
); list
= list
-> next
)
1591 TYPE_FIELD (type
, n
++) = list
-> field
;
1602 read_func_scope -- process all dies within a function scope
1606 Process all dies within a given function scope. We are passed
1607 a die information structure pointer DIP for the die which
1608 starts the function scope, and pointers into the raw die data
1609 that define the dies within the function scope.
1611 For now, we ignore lexical block scopes within the function.
1612 The problem is that AT&T cc does not define a DWARF lexical
1613 block scope for the function itself, while gcc defines a
1614 lexical block scope for the function. We need to think about
1615 how to handle this difference, or if it is even a problem.
1620 read_func_scope (dip
, thisdie
, enddie
, objfile
)
1621 struct dieinfo
*dip
;
1624 struct objfile
*objfile
;
1626 register struct context_stack
*new;
1628 if (objfile
-> ei
.entry_point
>= dip
-> at_low_pc
&&
1629 objfile
-> ei
.entry_point
< dip
-> at_high_pc
)
1631 objfile
-> ei
.entry_func_lowpc
= dip
-> at_low_pc
;
1632 objfile
-> ei
.entry_func_highpc
= dip
-> at_high_pc
;
1634 if (STREQ (dip
-> at_name
, "main")) /* FIXME: hardwired name */
1636 objfile
-> ei
.main_func_lowpc
= dip
-> at_low_pc
;
1637 objfile
-> ei
.main_func_highpc
= dip
-> at_high_pc
;
1639 new = push_context (0, dip
-> at_low_pc
);
1640 new -> name
= new_symbol (dip
, objfile
);
1641 list_in_scope
= &local_symbols
;
1642 process_dies (thisdie
+ dip
-> die_length
, enddie
, objfile
);
1643 new = pop_context ();
1644 /* Make a block for the local symbols within. */
1645 finish_block (new -> name
, &local_symbols
, new -> old_blocks
,
1646 new -> start_addr
, dip
-> at_high_pc
, objfile
);
1647 list_in_scope
= &file_symbols
;
1655 handle_producer -- process the AT_producer attribute
1659 Perform any operations that depend on finding a particular
1660 AT_producer attribute.
1665 handle_producer (producer
)
1669 /* If this compilation unit was compiled with g++ or gcc, then set the
1670 processing_gcc_compilation flag. */
1672 processing_gcc_compilation
=
1673 STREQN (producer
, GPLUS_PRODUCER
, strlen (GPLUS_PRODUCER
))
1674 || STREQN (producer
, GCC_PRODUCER
, strlen (GCC_PRODUCER
));
1676 /* Select a demangling style if we can identify the producer and if
1677 the current style is auto. We leave the current style alone if it
1678 is not auto. We also leave the demangling style alone if we find a
1679 gcc (cc1) producer, as opposed to a g++ (cc1plus) producer. */
1681 #if 1 /* Works, but is experimental. -fnf */
1682 if (AUTO_DEMANGLING
)
1684 if (STREQN (producer
, GPLUS_PRODUCER
, strlen (GPLUS_PRODUCER
)))
1686 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1688 else if (STREQN (producer
, LCC_PRODUCER
, strlen (LCC_PRODUCER
)))
1690 set_demangling_style (LUCID_DEMANGLING_STYLE_STRING
);
1692 else if (STREQN (producer
, CFRONT_PRODUCER
, strlen (CFRONT_PRODUCER
)))
1694 set_demangling_style (CFRONT_DEMANGLING_STYLE_STRING
);
1705 read_file_scope -- process all dies within a file scope
1709 Process all dies within a given file scope. We are passed a
1710 pointer to the die information structure for the die which
1711 starts the file scope, and pointers into the raw die data which
1712 mark the range of dies within the file scope.
1714 When the partial symbol table is built, the file offset for the line
1715 number table for each compilation unit is saved in the partial symbol
1716 table entry for that compilation unit. As the symbols for each
1717 compilation unit are read, the line number table is read into memory
1718 and the variable lnbase is set to point to it. Thus all we have to
1719 do is use lnbase to access the line number table for the current
1724 read_file_scope (dip
, thisdie
, enddie
, objfile
)
1725 struct dieinfo
*dip
;
1728 struct objfile
*objfile
;
1730 struct cleanup
*back_to
;
1731 struct symtab
*symtab
;
1733 if (objfile
-> ei
.entry_point
>= dip
-> at_low_pc
&&
1734 objfile
-> ei
.entry_point
< dip
-> at_high_pc
)
1736 objfile
-> ei
.entry_file_lowpc
= dip
-> at_low_pc
;
1737 objfile
-> ei
.entry_file_highpc
= dip
-> at_high_pc
;
1739 set_cu_language (dip
);
1740 if (dip
-> at_producer
!= NULL
)
1742 handle_producer (dip
-> at_producer
);
1744 numutypes
= (enddie
- thisdie
) / 4;
1745 utypes
= (struct type
**) xmalloc (numutypes
* sizeof (struct type
*));
1746 back_to
= make_cleanup (free
, utypes
);
1747 memset (utypes
, 0, numutypes
* sizeof (struct type
*));
1748 start_symtab (dip
-> at_name
, dip
-> at_comp_dir
, dip
-> at_low_pc
);
1749 decode_line_numbers (lnbase
);
1750 process_dies (thisdie
+ dip
-> die_length
, enddie
, objfile
);
1751 symtab
= end_symtab (dip
-> at_high_pc
, 0, 0, objfile
);
1754 symtab
-> language
= cu_language
;
1756 do_cleanups (back_to
);
1765 process_dies -- process a range of DWARF Information Entries
1769 static void process_dies (char *thisdie, char *enddie,
1770 struct objfile *objfile)
1774 Process all DIE's in a specified range. May be (and almost
1775 certainly will be) called recursively.
1779 process_dies (thisdie
, enddie
, objfile
)
1782 struct objfile
*objfile
;
1787 while (thisdie
< enddie
)
1789 basicdieinfo (&di
, thisdie
, objfile
);
1790 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
1794 else if (di
.die_tag
== TAG_padding
)
1796 nextdie
= thisdie
+ di
.die_length
;
1800 completedieinfo (&di
, objfile
);
1801 if (di
.at_sibling
!= 0)
1803 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
1807 nextdie
= thisdie
+ di
.die_length
;
1811 case TAG_compile_unit
:
1812 read_file_scope (&di
, thisdie
, nextdie
, objfile
);
1814 case TAG_global_subroutine
:
1815 case TAG_subroutine
:
1816 if (di
.has_at_low_pc
)
1818 read_func_scope (&di
, thisdie
, nextdie
, objfile
);
1821 case TAG_lexical_block
:
1822 read_lexical_block_scope (&di
, thisdie
, nextdie
, objfile
);
1824 case TAG_class_type
:
1825 case TAG_structure_type
:
1826 case TAG_union_type
:
1827 read_structure_scope (&di
, thisdie
, nextdie
, objfile
);
1829 case TAG_enumeration_type
:
1830 read_enumeration (&di
, thisdie
, nextdie
, objfile
);
1832 case TAG_subroutine_type
:
1833 read_subroutine_type (&di
, thisdie
, nextdie
);
1835 case TAG_array_type
:
1836 dwarf_read_array_type (&di
);
1838 case TAG_pointer_type
:
1839 read_tag_pointer_type (&di
);
1842 new_symbol (&di
, objfile
);
1854 decode_line_numbers -- decode a line number table fragment
1858 static void decode_line_numbers (char *tblscan, char *tblend,
1859 long length, long base, long line, long pc)
1863 Translate the DWARF line number information to gdb form.
1865 The ".line" section contains one or more line number tables, one for
1866 each ".line" section from the objects that were linked.
1868 The AT_stmt_list attribute for each TAG_source_file entry in the
1869 ".debug" section contains the offset into the ".line" section for the
1870 start of the table for that file.
1872 The table itself has the following structure:
1874 <table length><base address><source statement entry>
1875 4 bytes 4 bytes 10 bytes
1877 The table length is the total size of the table, including the 4 bytes
1878 for the length information.
1880 The base address is the address of the first instruction generated
1881 for the source file.
1883 Each source statement entry has the following structure:
1885 <line number><statement position><address delta>
1886 4 bytes 2 bytes 4 bytes
1888 The line number is relative to the start of the file, starting with
1891 The statement position either -1 (0xFFFF) or the number of characters
1892 from the beginning of the line to the beginning of the statement.
1894 The address delta is the difference between the base address and
1895 the address of the first instruction for the statement.
1897 Note that we must copy the bytes from the packed table to our local
1898 variables before attempting to use them, to avoid alignment problems
1899 on some machines, particularly RISC processors.
1903 Does gdb expect the line numbers to be sorted? They are now by
1904 chance/luck, but are not required to be. (FIXME)
1906 The line with number 0 is unused, gdb apparently can discover the
1907 span of the last line some other way. How? (FIXME)
1911 decode_line_numbers (linetable
)
1916 unsigned long length
;
1921 if (linetable
!= NULL
)
1923 tblscan
= tblend
= linetable
;
1924 length
= target_to_host (tblscan
, SIZEOF_LINETBL_LENGTH
, GET_UNSIGNED
,
1926 tblscan
+= SIZEOF_LINETBL_LENGTH
;
1928 base
= target_to_host (tblscan
, TARGET_FT_POINTER_SIZE (objfile
),
1929 GET_UNSIGNED
, current_objfile
);
1930 tblscan
+= TARGET_FT_POINTER_SIZE (objfile
);
1932 while (tblscan
< tblend
)
1934 line
= target_to_host (tblscan
, SIZEOF_LINETBL_LINENO
, GET_UNSIGNED
,
1936 tblscan
+= SIZEOF_LINETBL_LINENO
+ SIZEOF_LINETBL_STMT
;
1937 pc
= target_to_host (tblscan
, SIZEOF_LINETBL_DELTA
, GET_UNSIGNED
,
1939 tblscan
+= SIZEOF_LINETBL_DELTA
;
1943 record_line (current_subfile
, line
, pc
);
1953 locval -- compute the value of a location attribute
1957 static int locval (char *loc)
1961 Given pointer to a string of bytes that define a location, compute
1962 the location and return the value.
1964 When computing values involving the current value of the frame pointer,
1965 the value zero is used, which results in a value relative to the frame
1966 pointer, rather than the absolute value. This is what GDB wants
1969 When the result is a register number, the global isreg flag is set,
1970 otherwise it is cleared. This is a kludge until we figure out a better
1971 way to handle the problem. Gdb's design does not mesh well with the
1972 DWARF notion of a location computing interpreter, which is a shame
1973 because the flexibility goes unused.
1977 Note that stack[0] is unused except as a default error return.
1978 Note that stack overflow is not yet handled.
1985 unsigned short nbytes
;
1986 unsigned short locsize
;
1987 auto long stack
[64];
1994 nbytes
= attribute_size (AT_location
);
1995 locsize
= target_to_host (loc
, nbytes
, GET_UNSIGNED
, current_objfile
);
1997 end
= loc
+ locsize
;
2002 loc_value_size
= TARGET_FT_LONG_SIZE (current_objfile
);
2005 loc_atom_code
= target_to_host (loc
, SIZEOF_LOC_ATOM_CODE
, GET_UNSIGNED
,
2007 loc
+= SIZEOF_LOC_ATOM_CODE
;
2008 switch (loc_atom_code
)
2015 /* push register (number) */
2016 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
2017 GET_UNSIGNED
, current_objfile
);
2018 loc
+= loc_value_size
;
2022 /* push value of register (number) */
2023 /* Actually, we compute the value as if register has 0 */
2025 regno
= target_to_host (loc
, loc_value_size
, GET_UNSIGNED
,
2027 loc
+= loc_value_size
;
2030 stack
[++stacki
] = 0;
2034 stack
[++stacki
] = 0;
2035 SQUAWK (("BASEREG %d not handled!", regno
));
2039 /* push address (relocated address) */
2040 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
2041 GET_UNSIGNED
, current_objfile
);
2042 loc
+= loc_value_size
;
2045 /* push constant (number) FIXME: signed or unsigned! */
2046 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
2047 GET_SIGNED
, current_objfile
);
2048 loc
+= loc_value_size
;
2051 /* pop, deref and push 2 bytes (as a long) */
2052 SQUAWK (("OP_DEREF2 address 0x%x not handled", stack
[stacki
]));
2054 case OP_DEREF4
: /* pop, deref and push 4 bytes (as a long) */
2055 SQUAWK (("OP_DEREF4 address 0x%x not handled", stack
[stacki
]));
2057 case OP_ADD
: /* pop top 2 items, add, push result */
2058 stack
[stacki
- 1] += stack
[stacki
];
2063 return (stack
[stacki
]);
2070 read_ofile_symtab -- build a full symtab entry from chunk of DIE's
2074 static struct symtab *read_ofile_symtab (struct partial_symtab *pst)
2078 When expanding a partial symbol table entry to a full symbol table
2079 entry, this is the function that gets called to read in the symbols
2080 for the compilation unit.
2082 Returns a pointer to the newly constructed symtab (which is now
2083 the new first one on the objfile's symtab list).
2086 static struct symtab
*
2087 read_ofile_symtab (pst
)
2088 struct partial_symtab
*pst
;
2090 struct cleanup
*back_to
;
2091 unsigned long lnsize
;
2094 char lnsizedata
[SIZEOF_LINETBL_LENGTH
];
2096 abfd
= pst
-> objfile
-> obfd
;
2097 current_objfile
= pst
-> objfile
;
2099 /* Allocate a buffer for the entire chunk of DIE's for this compilation
2100 unit, seek to the location in the file, and read in all the DIE's. */
2103 dbsize
= DBLENGTH (pst
);
2104 dbbase
= xmalloc (dbsize
);
2105 dbroff
= DBROFF(pst
);
2106 foffset
= DBFOFF(pst
) + dbroff
;
2107 base_section_offsets
= pst
->section_offsets
;
2108 baseaddr
= ANOFFSET (pst
->section_offsets
, 0);
2109 if (bfd_seek (abfd
, foffset
, L_SET
) ||
2110 (bfd_read (dbbase
, dbsize
, 1, abfd
) != dbsize
))
2113 error ("can't read DWARF data");
2115 back_to
= make_cleanup (free
, dbbase
);
2117 /* If there is a line number table associated with this compilation unit
2118 then read the size of this fragment in bytes, from the fragment itself.
2119 Allocate a buffer for the fragment and read it in for future
2125 if (bfd_seek (abfd
, LNFOFF (pst
), L_SET
) ||
2126 (bfd_read ((PTR
) lnsizedata
, sizeof (lnsizedata
), 1, abfd
) !=
2127 sizeof (lnsizedata
)))
2129 error ("can't read DWARF line number table size");
2131 lnsize
= target_to_host (lnsizedata
, SIZEOF_LINETBL_LENGTH
,
2132 GET_UNSIGNED
, pst
-> objfile
);
2133 lnbase
= xmalloc (lnsize
);
2134 if (bfd_seek (abfd
, LNFOFF (pst
), L_SET
) ||
2135 (bfd_read (lnbase
, lnsize
, 1, abfd
) != lnsize
))
2138 error ("can't read DWARF line numbers");
2140 make_cleanup (free
, lnbase
);
2143 process_dies (dbbase
, dbbase
+ dbsize
, pst
-> objfile
);
2144 do_cleanups (back_to
);
2145 current_objfile
= NULL
;
2146 return (pst
-> objfile
-> symtabs
);
2153 psymtab_to_symtab_1 -- do grunt work for building a full symtab entry
2157 static void psymtab_to_symtab_1 (struct partial_symtab *pst)
2161 Called once for each partial symbol table entry that needs to be
2162 expanded into a full symbol table entry.
2167 psymtab_to_symtab_1 (pst
)
2168 struct partial_symtab
*pst
;
2171 struct cleanup
*old_chain
;
2177 warning ("psymtab for %s already read in. Shouldn't happen.",
2182 /* Read in all partial symtabs on which this one is dependent */
2183 for (i
= 0; i
< pst
-> number_of_dependencies
; i
++)
2185 if (!pst
-> dependencies
[i
] -> readin
)
2187 /* Inform about additional files that need to be read in. */
2190 fputs_filtered (" ", stdout
);
2192 fputs_filtered ("and ", stdout
);
2194 printf_filtered ("%s...",
2195 pst
-> dependencies
[i
] -> filename
);
2197 fflush (stdout
); /* Flush output */
2199 psymtab_to_symtab_1 (pst
-> dependencies
[i
]);
2202 if (DBLENGTH (pst
)) /* Otherwise it's a dummy */
2205 old_chain
= make_cleanup (really_free_pendings
, 0);
2206 pst
-> symtab
= read_ofile_symtab (pst
);
2209 printf_filtered ("%d DIE's, sorting...", diecount
);
2213 sort_symtab_syms (pst
-> symtab
);
2214 do_cleanups (old_chain
);
2225 dwarf_psymtab_to_symtab -- build a full symtab entry from partial one
2229 static void dwarf_psymtab_to_symtab (struct partial_symtab *pst)
2233 This is the DWARF support entry point for building a full symbol
2234 table entry from a partial symbol table entry. We are passed a
2235 pointer to the partial symbol table entry that needs to be expanded.
2240 dwarf_psymtab_to_symtab (pst
)
2241 struct partial_symtab
*pst
;
2248 warning ("psymtab for %s already read in. Shouldn't happen.",
2253 if (DBLENGTH (pst
) || pst
-> number_of_dependencies
)
2255 /* Print the message now, before starting serious work, to avoid
2256 disconcerting pauses. */
2259 printf_filtered ("Reading in symbols for %s...",
2264 psymtab_to_symtab_1 (pst
);
2266 #if 0 /* FIXME: Check to see what dbxread is doing here and see if
2267 we need to do an equivalent or is this something peculiar to
2269 Match with global symbols. This only needs to be done once,
2270 after all of the symtabs and dependencies have been read in.
2272 scan_file_globals (pst
-> objfile
);
2275 /* Finish up the verbose info message. */
2278 printf_filtered ("done.\n");
2290 init_psymbol_list -- initialize storage for partial symbols
2294 static void init_psymbol_list (struct objfile *objfile, int total_symbols)
2298 Initializes storage for all of the partial symbols that will be
2299 created by dwarf_build_psymtabs and subsidiaries.
2303 init_psymbol_list (objfile
, total_symbols
)
2304 struct objfile
*objfile
;
2307 /* Free any previously allocated psymbol lists. */
2309 if (objfile
-> global_psymbols
.list
)
2311 mfree (objfile
-> md
, (PTR
)objfile
-> global_psymbols
.list
);
2313 if (objfile
-> static_psymbols
.list
)
2315 mfree (objfile
-> md
, (PTR
)objfile
-> static_psymbols
.list
);
2318 /* Current best guess is that there are approximately a twentieth
2319 of the total symbols (in a debugging file) are global or static
2322 objfile
-> global_psymbols
.size
= total_symbols
/ 10;
2323 objfile
-> static_psymbols
.size
= total_symbols
/ 10;
2324 objfile
-> global_psymbols
.next
=
2325 objfile
-> global_psymbols
.list
= (struct partial_symbol
*)
2326 xmmalloc (objfile
-> md
, objfile
-> global_psymbols
.size
2327 * sizeof (struct partial_symbol
));
2328 objfile
-> static_psymbols
.next
=
2329 objfile
-> static_psymbols
.list
= (struct partial_symbol
*)
2330 xmmalloc (objfile
-> md
, objfile
-> static_psymbols
.size
2331 * sizeof (struct partial_symbol
));
2338 add_enum_psymbol -- add enumeration members to partial symbol table
2342 Given pointer to a DIE that is known to be for an enumeration,
2343 extract the symbolic names of the enumeration members and add
2344 partial symbols for them.
2348 add_enum_psymbol (dip
, objfile
)
2349 struct dieinfo
*dip
;
2350 struct objfile
*objfile
;
2354 unsigned short blocksz
;
2357 if ((scan
= dip
-> at_element_list
) != NULL
)
2359 if (dip
-> short_element_list
)
2361 nbytes
= attribute_size (AT_short_element_list
);
2365 nbytes
= attribute_size (AT_element_list
);
2367 blocksz
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, objfile
);
2369 listend
= scan
+ blocksz
;
2370 while (scan
< listend
)
2372 scan
+= TARGET_FT_LONG_SIZE (objfile
);
2373 ADD_PSYMBOL_TO_LIST (scan
, strlen (scan
), VAR_NAMESPACE
, LOC_CONST
,
2374 objfile
-> static_psymbols
, 0);
2375 scan
+= strlen (scan
) + 1;
2384 add_partial_symbol -- add symbol to partial symbol table
2388 Given a DIE, if it is one of the types that we want to
2389 add to a partial symbol table, finish filling in the die info
2390 and then add a partial symbol table entry for it.
2394 The caller must ensure that the DIE has a valid name attribute.
2398 add_partial_symbol (dip
, objfile
)
2399 struct dieinfo
*dip
;
2400 struct objfile
*objfile
;
2402 switch (dip
-> die_tag
)
2404 case TAG_global_subroutine
:
2405 record_minimal_symbol (dip
-> at_name
, dip
-> at_low_pc
, mst_text
,
2407 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2408 VAR_NAMESPACE
, LOC_BLOCK
,
2409 objfile
-> global_psymbols
,
2412 case TAG_global_variable
:
2413 record_minimal_symbol (dip
-> at_name
, locval (dip
-> at_location
),
2415 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2416 VAR_NAMESPACE
, LOC_STATIC
,
2417 objfile
-> global_psymbols
,
2420 case TAG_subroutine
:
2421 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2422 VAR_NAMESPACE
, LOC_BLOCK
,
2423 objfile
-> static_psymbols
,
2426 case TAG_local_variable
:
2427 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2428 VAR_NAMESPACE
, LOC_STATIC
,
2429 objfile
-> static_psymbols
,
2433 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2434 VAR_NAMESPACE
, LOC_TYPEDEF
,
2435 objfile
-> static_psymbols
,
2438 case TAG_class_type
:
2439 case TAG_structure_type
:
2440 case TAG_union_type
:
2441 case TAG_enumeration_type
:
2442 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2443 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2444 objfile
-> static_psymbols
,
2446 if (cu_language
== language_cplus
)
2448 /* For C++, these implicitly act as typedefs as well. */
2449 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2450 VAR_NAMESPACE
, LOC_TYPEDEF
,
2451 objfile
-> static_psymbols
,
2462 scan_partial_symbols -- scan DIE's within a single compilation unit
2466 Process the DIE's within a single compilation unit, looking for
2467 interesting DIE's that contribute to the partial symbol table entry
2468 for this compilation unit.
2472 There are some DIE's that may appear both at file scope and within
2473 the scope of a function. We are only interested in the ones at file
2474 scope, and the only way to tell them apart is to keep track of the
2475 scope. For example, consider the test case:
2480 for which the relevant DWARF segment has the structure:
2483 0x23 global subrtn sibling 0x9b
2485 fund_type FT_integer
2490 0x23 local var sibling 0x97
2492 fund_type FT_integer
2493 location OP_BASEREG 0xe
2500 0x1d local var sibling 0xb8
2502 fund_type FT_integer
2503 location OP_ADDR 0x800025dc
2508 We want to include the symbol 'i' in the partial symbol table, but
2509 not the symbol 'j'. In essence, we want to skip all the dies within
2510 the scope of a TAG_global_subroutine DIE.
2512 Don't attempt to add anonymous structures or unions since they have
2513 no name. Anonymous enumerations however are processed, because we
2514 want to extract their member names (the check for a tag name is
2517 Also, for variables and subroutines, check that this is the place
2518 where the actual definition occurs, rather than just a reference
2523 scan_partial_symbols (thisdie
, enddie
, objfile
)
2526 struct objfile
*objfile
;
2532 while (thisdie
< enddie
)
2534 basicdieinfo (&di
, thisdie
, objfile
);
2535 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
2541 nextdie
= thisdie
+ di
.die_length
;
2542 /* To avoid getting complete die information for every die, we
2543 only do it (below) for the cases we are interested in. */
2546 case TAG_global_subroutine
:
2547 case TAG_subroutine
:
2548 completedieinfo (&di
, objfile
);
2549 if (di
.at_name
&& (di
.has_at_low_pc
|| di
.at_location
))
2551 add_partial_symbol (&di
, objfile
);
2552 /* If there is a sibling attribute, adjust the nextdie
2553 pointer to skip the entire scope of the subroutine.
2554 Apply some sanity checking to make sure we don't
2555 overrun or underrun the range of remaining DIE's */
2556 if (di
.at_sibling
!= 0)
2558 temp
= dbbase
+ di
.at_sibling
- dbroff
;
2559 if ((temp
< thisdie
) || (temp
>= enddie
))
2561 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", di
.at_sibling
);
2570 case TAG_global_variable
:
2571 case TAG_local_variable
:
2572 completedieinfo (&di
, objfile
);
2573 if (di
.at_name
&& (di
.has_at_low_pc
|| di
.at_location
))
2575 add_partial_symbol (&di
, objfile
);
2579 case TAG_class_type
:
2580 case TAG_structure_type
:
2581 case TAG_union_type
:
2582 completedieinfo (&di
, objfile
);
2585 add_partial_symbol (&di
, objfile
);
2588 case TAG_enumeration_type
:
2589 completedieinfo (&di
, objfile
);
2592 add_partial_symbol (&di
, objfile
);
2594 add_enum_psymbol (&di
, objfile
);
2606 scan_compilation_units -- build a psymtab entry for each compilation
2610 This is the top level dwarf parsing routine for building partial
2613 It scans from the beginning of the DWARF table looking for the first
2614 TAG_compile_unit DIE, and then follows the sibling chain to locate
2615 each additional TAG_compile_unit DIE.
2617 For each TAG_compile_unit DIE it creates a partial symtab structure,
2618 calls a subordinate routine to collect all the compilation unit's
2619 global DIE's, file scope DIEs, typedef DIEs, etc, and then links the
2620 new partial symtab structure into the partial symbol table. It also
2621 records the appropriate information in the partial symbol table entry
2622 to allow the chunk of DIE's and line number table for this compilation
2623 unit to be located and re-read later, to generate a complete symbol
2624 table entry for the compilation unit.
2626 Thus it effectively partitions up a chunk of DIE's for multiple
2627 compilation units into smaller DIE chunks and line number tables,
2628 and associates them with a partial symbol table entry.
2632 If any compilation unit has no line number table associated with
2633 it for some reason (a missing at_stmt_list attribute, rather than
2634 just one with a value of zero, which is valid) then we ensure that
2635 the recorded file offset is zero so that the routine which later
2636 reads line number table fragments knows that there is no fragment
2646 scan_compilation_units (thisdie
, enddie
, dbfoff
, lnoffset
, objfile
)
2651 struct objfile
*objfile
;
2655 struct partial_symtab
*pst
;
2658 file_ptr curlnoffset
;
2660 while (thisdie
< enddie
)
2662 basicdieinfo (&di
, thisdie
, objfile
);
2663 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
2667 else if (di
.die_tag
!= TAG_compile_unit
)
2669 nextdie
= thisdie
+ di
.die_length
;
2673 completedieinfo (&di
, objfile
);
2674 set_cu_language (&di
);
2675 if (di
.at_sibling
!= 0)
2677 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
2681 nextdie
= thisdie
+ di
.die_length
;
2683 curoff
= thisdie
- dbbase
;
2684 culength
= nextdie
- thisdie
;
2685 curlnoffset
= di
.has_at_stmt_list
? lnoffset
+ di
.at_stmt_list
: 0;
2687 /* First allocate a new partial symbol table structure */
2689 pst
= start_psymtab_common (objfile
, base_section_offsets
,
2690 di
.at_name
, di
.at_low_pc
,
2691 objfile
-> global_psymbols
.next
,
2692 objfile
-> static_psymbols
.next
);
2694 pst
-> texthigh
= di
.at_high_pc
;
2695 pst
-> read_symtab_private
= (char *)
2696 obstack_alloc (&objfile
-> psymbol_obstack
,
2697 sizeof (struct dwfinfo
));
2698 DBFOFF (pst
) = dbfoff
;
2699 DBROFF (pst
) = curoff
;
2700 DBLENGTH (pst
) = culength
;
2701 LNFOFF (pst
) = curlnoffset
;
2702 pst
-> read_symtab
= dwarf_psymtab_to_symtab
;
2704 /* Now look for partial symbols */
2706 scan_partial_symbols (thisdie
+ di
.die_length
, nextdie
, objfile
);
2708 pst
-> n_global_syms
= objfile
-> global_psymbols
.next
-
2709 (objfile
-> global_psymbols
.list
+ pst
-> globals_offset
);
2710 pst
-> n_static_syms
= objfile
-> static_psymbols
.next
-
2711 (objfile
-> static_psymbols
.list
+ pst
-> statics_offset
);
2712 sort_pst_symbols (pst
);
2713 /* If there is already a psymtab or symtab for a file of this name,
2714 remove it. (If there is a symtab, more drastic things also
2715 happen.) This happens in VxWorks. */
2716 free_named_symtabs (pst
-> filename
);
2726 new_symbol -- make a symbol table entry for a new symbol
2730 static struct symbol *new_symbol (struct dieinfo *dip,
2731 struct objfile *objfile)
2735 Given a pointer to a DWARF information entry, figure out if we need
2736 to make a symbol table entry for it, and if so, create a new entry
2737 and return a pointer to it.
2740 static struct symbol
*
2741 new_symbol (dip
, objfile
)
2742 struct dieinfo
*dip
;
2743 struct objfile
*objfile
;
2745 struct symbol
*sym
= NULL
;
2747 if (dip
-> at_name
!= NULL
)
2749 sym
= (struct symbol
*) obstack_alloc (&objfile
-> symbol_obstack
,
2750 sizeof (struct symbol
));
2751 memset (sym
, 0, sizeof (struct symbol
));
2752 SYMBOL_NAME (sym
) = create_name (dip
-> at_name
,
2753 &objfile
->symbol_obstack
);
2754 /* default assumptions */
2755 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2756 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2757 SYMBOL_TYPE (sym
) = decode_die_type (dip
);
2758 switch (dip
-> die_tag
)
2761 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
;
2762 SYMBOL_CLASS (sym
) = LOC_LABEL
;
2764 case TAG_global_subroutine
:
2765 case TAG_subroutine
:
2766 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
;
2767 SYMBOL_TYPE (sym
) = lookup_function_type (SYMBOL_TYPE (sym
));
2768 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
2769 if (dip
-> die_tag
== TAG_global_subroutine
)
2771 add_symbol_to_list (sym
, &global_symbols
);
2775 add_symbol_to_list (sym
, list_in_scope
);
2778 case TAG_global_variable
:
2779 if (dip
-> at_location
!= NULL
)
2781 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2782 add_symbol_to_list (sym
, &global_symbols
);
2783 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2784 SYMBOL_VALUE (sym
) += baseaddr
;
2787 case TAG_local_variable
:
2788 if (dip
-> at_location
!= NULL
)
2790 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2791 add_symbol_to_list (sym
, list_in_scope
);
2794 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
2798 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
2802 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2803 SYMBOL_VALUE (sym
) += baseaddr
;
2807 case TAG_formal_parameter
:
2808 if (dip
-> at_location
!= NULL
)
2810 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2812 add_symbol_to_list (sym
, list_in_scope
);
2815 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
2819 SYMBOL_CLASS (sym
) = LOC_ARG
;
2822 case TAG_unspecified_parameters
:
2823 /* From varargs functions; gdb doesn't seem to have any interest in
2824 this information, so just ignore it for now. (FIXME?) */
2826 case TAG_class_type
:
2827 case TAG_structure_type
:
2828 case TAG_union_type
:
2829 case TAG_enumeration_type
:
2830 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2831 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
2832 add_symbol_to_list (sym
, list_in_scope
);
2835 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2836 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2837 add_symbol_to_list (sym
, list_in_scope
);
2840 /* Not a tag we recognize. Hopefully we aren't processing trash
2841 data, but since we must specifically ignore things we don't
2842 recognize, there is nothing else we should do at this point. */
2853 synthesize_typedef -- make a symbol table entry for a "fake" typedef
2857 static void synthesize_typedef (struct dieinfo *dip,
2858 struct objfile *objfile,
2863 Given a pointer to a DWARF information entry, synthesize a typedef
2864 for the name in the DIE, using the specified type.
2866 This is used for C++ class, structs, unions, and enumerations to
2867 set up the tag name as a type.
2872 synthesize_typedef (dip
, objfile
, type
)
2873 struct dieinfo
*dip
;
2874 struct objfile
*objfile
;
2877 struct symbol
*sym
= NULL
;
2879 if (dip
-> at_name
!= NULL
)
2881 sym
= (struct symbol
*)
2882 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
2883 memset (sym
, 0, sizeof (struct symbol
));
2884 SYMBOL_NAME (sym
) = create_name (dip
-> at_name
,
2885 &objfile
->symbol_obstack
);
2886 SYMBOL_TYPE (sym
) = type
;
2887 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2888 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2889 add_symbol_to_list (sym
, list_in_scope
);
2897 decode_mod_fund_type -- decode a modified fundamental type
2901 static struct type *decode_mod_fund_type (char *typedata)
2905 Decode a block of data containing a modified fundamental
2906 type specification. TYPEDATA is a pointer to the block,
2907 which starts with a length containing the size of the rest
2908 of the block. At the end of the block is a fundmental type
2909 code value that gives the fundamental type. Everything
2910 in between are type modifiers.
2912 We simply compute the number of modifiers and call the general
2913 function decode_modified_type to do the actual work.
2916 static struct type
*
2917 decode_mod_fund_type (typedata
)
2920 struct type
*typep
= NULL
;
2921 unsigned short modcount
;
2924 /* Get the total size of the block, exclusive of the size itself */
2926 nbytes
= attribute_size (AT_mod_fund_type
);
2927 modcount
= target_to_host (typedata
, nbytes
, GET_UNSIGNED
, current_objfile
);
2930 /* Deduct the size of the fundamental type bytes at the end of the block. */
2932 modcount
-= attribute_size (AT_fund_type
);
2934 /* Now do the actual decoding */
2936 typep
= decode_modified_type (typedata
, modcount
, AT_mod_fund_type
);
2944 decode_mod_u_d_type -- decode a modified user defined type
2948 static struct type *decode_mod_u_d_type (char *typedata)
2952 Decode a block of data containing a modified user defined
2953 type specification. TYPEDATA is a pointer to the block,
2954 which consists of a two byte length, containing the size
2955 of the rest of the block. At the end of the block is a
2956 four byte value that gives a reference to a user defined type.
2957 Everything in between are type modifiers.
2959 We simply compute the number of modifiers and call the general
2960 function decode_modified_type to do the actual work.
2963 static struct type
*
2964 decode_mod_u_d_type (typedata
)
2967 struct type
*typep
= NULL
;
2968 unsigned short modcount
;
2971 /* Get the total size of the block, exclusive of the size itself */
2973 nbytes
= attribute_size (AT_mod_u_d_type
);
2974 modcount
= target_to_host (typedata
, nbytes
, GET_UNSIGNED
, current_objfile
);
2977 /* Deduct the size of the reference type bytes at the end of the block. */
2979 modcount
-= attribute_size (AT_user_def_type
);
2981 /* Now do the actual decoding */
2983 typep
= decode_modified_type (typedata
, modcount
, AT_mod_u_d_type
);
2991 decode_modified_type -- decode modified user or fundamental type
2995 static struct type *decode_modified_type (char *modifiers,
2996 unsigned short modcount, int mtype)
3000 Decode a modified type, either a modified fundamental type or
3001 a modified user defined type. MODIFIERS is a pointer to the
3002 block of bytes that define MODCOUNT modifiers. Immediately
3003 following the last modifier is a short containing the fundamental
3004 type or a long containing the reference to the user defined
3005 type. Which one is determined by MTYPE, which is either
3006 AT_mod_fund_type or AT_mod_u_d_type to indicate what modified
3007 type we are generating.
3009 We call ourself recursively to generate each modified type,`
3010 until MODCOUNT reaches zero, at which point we have consumed
3011 all the modifiers and generate either the fundamental type or
3012 user defined type. When the recursion unwinds, each modifier
3013 is applied in turn to generate the full modified type.
3017 If we find a modifier that we don't recognize, and it is not one
3018 of those reserved for application specific use, then we issue a
3019 warning and simply ignore the modifier.
3023 We currently ignore MOD_const and MOD_volatile. (FIXME)
3027 static struct type
*
3028 decode_modified_type (modifiers
, modcount
, mtype
)
3030 unsigned int modcount
;
3033 struct type
*typep
= NULL
;
3034 unsigned short fundtype
;
3043 case AT_mod_fund_type
:
3044 nbytes
= attribute_size (AT_fund_type
);
3045 fundtype
= target_to_host (modifiers
, nbytes
, GET_UNSIGNED
,
3047 typep
= decode_fund_type (fundtype
);
3049 case AT_mod_u_d_type
:
3050 nbytes
= attribute_size (AT_user_def_type
);
3051 die_ref
= target_to_host (modifiers
, nbytes
, GET_UNSIGNED
,
3053 if ((typep
= lookup_utype (die_ref
)) == NULL
)
3055 typep
= alloc_utype (die_ref
, NULL
);
3059 SQUAWK (("botched modified type decoding (mtype 0x%x)", mtype
));
3060 typep
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
3066 modifier
= *modifiers
++;
3067 typep
= decode_modified_type (modifiers
, --modcount
, mtype
);
3070 case MOD_pointer_to
:
3071 typep
= lookup_pointer_type (typep
);
3073 case MOD_reference_to
:
3074 typep
= lookup_reference_type (typep
);
3077 SQUAWK (("type modifier 'const' ignored")); /* FIXME */
3080 SQUAWK (("type modifier 'volatile' ignored")); /* FIXME */
3083 if (!(MOD_lo_user
<= (unsigned char) modifier
3084 && (unsigned char) modifier
<= MOD_hi_user
))
3086 SQUAWK (("unknown type modifier %u",
3087 (unsigned char) modifier
));
3099 decode_fund_type -- translate basic DWARF type to gdb base type
3103 Given an integer that is one of the fundamental DWARF types,
3104 translate it to one of the basic internal gdb types and return
3105 a pointer to the appropriate gdb type (a "struct type *").
3109 If we encounter a fundamental type that we are unprepared to
3110 deal with, and it is not in the range of those types defined
3111 as application specific types, then we issue a warning and
3112 treat the type as an "int".
3115 static struct type
*
3116 decode_fund_type (fundtype
)
3117 unsigned int fundtype
;
3119 struct type
*typep
= NULL
;
3125 typep
= lookup_fundamental_type (current_objfile
, FT_VOID
);
3128 case FT_boolean
: /* Was FT_set in AT&T version */
3129 typep
= lookup_fundamental_type (current_objfile
, FT_BOOLEAN
);
3132 case FT_pointer
: /* (void *) */
3133 typep
= lookup_fundamental_type (current_objfile
, FT_VOID
);
3134 typep
= lookup_pointer_type (typep
);
3138 typep
= lookup_fundamental_type (current_objfile
, FT_CHAR
);
3141 case FT_signed_char
:
3142 typep
= lookup_fundamental_type (current_objfile
, FT_SIGNED_CHAR
);
3145 case FT_unsigned_char
:
3146 typep
= lookup_fundamental_type (current_objfile
, FT_UNSIGNED_CHAR
);
3150 typep
= lookup_fundamental_type (current_objfile
, FT_SHORT
);
3153 case FT_signed_short
:
3154 typep
= lookup_fundamental_type (current_objfile
, FT_SIGNED_SHORT
);
3157 case FT_unsigned_short
:
3158 typep
= lookup_fundamental_type (current_objfile
, FT_UNSIGNED_SHORT
);
3162 typep
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
3165 case FT_signed_integer
:
3166 typep
= lookup_fundamental_type (current_objfile
, FT_SIGNED_INTEGER
);
3169 case FT_unsigned_integer
:
3170 typep
= lookup_fundamental_type (current_objfile
, FT_UNSIGNED_INTEGER
);
3174 typep
= lookup_fundamental_type (current_objfile
, FT_LONG
);
3177 case FT_signed_long
:
3178 typep
= lookup_fundamental_type (current_objfile
, FT_SIGNED_LONG
);
3181 case FT_unsigned_long
:
3182 typep
= lookup_fundamental_type (current_objfile
, FT_UNSIGNED_LONG
);
3186 typep
= lookup_fundamental_type (current_objfile
, FT_LONG_LONG
);
3189 case FT_signed_long_long
:
3190 typep
= lookup_fundamental_type (current_objfile
, FT_SIGNED_LONG_LONG
);
3193 case FT_unsigned_long_long
:
3194 typep
= lookup_fundamental_type (current_objfile
, FT_UNSIGNED_LONG_LONG
);
3198 typep
= lookup_fundamental_type (current_objfile
, FT_FLOAT
);
3201 case FT_dbl_prec_float
:
3202 typep
= lookup_fundamental_type (current_objfile
, FT_DBL_PREC_FLOAT
);
3205 case FT_ext_prec_float
:
3206 typep
= lookup_fundamental_type (current_objfile
, FT_EXT_PREC_FLOAT
);
3210 typep
= lookup_fundamental_type (current_objfile
, FT_COMPLEX
);
3213 case FT_dbl_prec_complex
:
3214 typep
= lookup_fundamental_type (current_objfile
, FT_DBL_PREC_COMPLEX
);
3217 case FT_ext_prec_complex
:
3218 typep
= lookup_fundamental_type (current_objfile
, FT_EXT_PREC_COMPLEX
);
3223 if ((typep
== NULL
) && !(FT_lo_user
<= fundtype
&& fundtype
<= FT_hi_user
))
3225 SQUAWK (("unexpected fundamental type 0x%x", fundtype
));
3226 typep
= lookup_fundamental_type (current_objfile
, FT_VOID
);
3236 create_name -- allocate a fresh copy of a string on an obstack
3240 Given a pointer to a string and a pointer to an obstack, allocates
3241 a fresh copy of the string on the specified obstack.
3246 create_name (name
, obstackp
)
3248 struct obstack
*obstackp
;
3253 length
= strlen (name
) + 1;
3254 newname
= (char *) obstack_alloc (obstackp
, length
);
3255 strcpy (newname
, name
);
3263 basicdieinfo -- extract the minimal die info from raw die data
3267 void basicdieinfo (char *diep, struct dieinfo *dip,
3268 struct objfile *objfile)
3272 Given a pointer to raw DIE data, and a pointer to an instance of a
3273 die info structure, this function extracts the basic information
3274 from the DIE data required to continue processing this DIE, along
3275 with some bookkeeping information about the DIE.
3277 The information we absolutely must have includes the DIE tag,
3278 and the DIE length. If we need the sibling reference, then we
3279 will have to call completedieinfo() to process all the remaining
3282 Note that since there is no guarantee that the data is properly
3283 aligned in memory for the type of access required (indirection
3284 through anything other than a char pointer), and there is no
3285 guarantee that it is in the same byte order as the gdb host,
3286 we call a function which deals with both alignment and byte
3287 swapping issues. Possibly inefficient, but quite portable.
3289 We also take care of some other basic things at this point, such
3290 as ensuring that the instance of the die info structure starts
3291 out completely zero'd and that curdie is initialized for use
3292 in error reporting if we have a problem with the current die.
3296 All DIE's must have at least a valid length, thus the minimum
3297 DIE size is SIZEOF_DIE_LENGTH. In order to have a valid tag, the
3298 DIE size must be at least SIZEOF_DIE_TAG larger, otherwise they
3299 are forced to be TAG_padding DIES.
3301 Padding DIES must be at least SIZEOF_DIE_LENGTH in length, implying
3302 that if a padding DIE is used for alignment and the amount needed is
3303 less than SIZEOF_DIE_LENGTH, then the padding DIE has to be big
3304 enough to align to the next alignment boundry.
3306 We do some basic sanity checking here, such as verifying that the
3307 length of the die would not cause it to overrun the recorded end of
3308 the buffer holding the DIE info. If we find a DIE that is either
3309 too small or too large, we force it's length to zero which should
3310 cause the caller to take appropriate action.
3314 basicdieinfo (dip
, diep
, objfile
)
3315 struct dieinfo
*dip
;
3317 struct objfile
*objfile
;
3320 memset (dip
, 0, sizeof (struct dieinfo
));
3322 dip
-> die_ref
= dbroff
+ (diep
- dbbase
);
3323 dip
-> die_length
= target_to_host (diep
, SIZEOF_DIE_LENGTH
, GET_UNSIGNED
,
3325 if ((dip
-> die_length
< SIZEOF_DIE_LENGTH
) ||
3326 ((diep
+ dip
-> die_length
) > (dbbase
+ dbsize
)))
3328 dwarfwarn ("malformed DIE, bad length (%d bytes)", dip
-> die_length
);
3329 dip
-> die_length
= 0;
3331 else if (dip
-> die_length
< (SIZEOF_DIE_LENGTH
+ SIZEOF_DIE_TAG
))
3333 dip
-> die_tag
= TAG_padding
;
3337 diep
+= SIZEOF_DIE_LENGTH
;
3338 dip
-> die_tag
= target_to_host (diep
, SIZEOF_DIE_TAG
, GET_UNSIGNED
,
3347 completedieinfo -- finish reading the information for a given DIE
3351 void completedieinfo (struct dieinfo *dip, struct objfile *objfile)
3355 Given a pointer to an already partially initialized die info structure,
3356 scan the raw DIE data and finish filling in the die info structure
3357 from the various attributes found.
3359 Note that since there is no guarantee that the data is properly
3360 aligned in memory for the type of access required (indirection
3361 through anything other than a char pointer), and there is no
3362 guarantee that it is in the same byte order as the gdb host,
3363 we call a function which deals with both alignment and byte
3364 swapping issues. Possibly inefficient, but quite portable.
3368 Each time we are called, we increment the diecount variable, which
3369 keeps an approximate count of the number of dies processed for
3370 each compilation unit. This information is presented to the user
3371 if the info_verbose flag is set.
3376 completedieinfo (dip
, objfile
)
3377 struct dieinfo
*dip
;
3378 struct objfile
*objfile
;
3380 char *diep
; /* Current pointer into raw DIE data */
3381 char *end
; /* Terminate DIE scan here */
3382 unsigned short attr
; /* Current attribute being scanned */
3383 unsigned short form
; /* Form of the attribute */
3384 int nbytes
; /* Size of next field to read */
3388 end
= diep
+ dip
-> die_length
;
3389 diep
+= SIZEOF_DIE_LENGTH
+ SIZEOF_DIE_TAG
;
3392 attr
= target_to_host (diep
, SIZEOF_ATTRIBUTE
, GET_UNSIGNED
, objfile
);
3393 diep
+= SIZEOF_ATTRIBUTE
;
3394 if ((nbytes
= attribute_size (attr
)) == -1)
3396 SQUAWK (("unknown attribute length, skipped remaining attributes"));;
3403 dip
-> at_fund_type
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3407 dip
-> at_ordering
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3411 dip
-> at_bit_offset
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3415 dip
-> at_sibling
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3419 dip
-> at_stmt_list
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3421 dip
-> has_at_stmt_list
= 1;
3424 dip
-> at_low_pc
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3426 dip
-> at_low_pc
+= baseaddr
;
3427 dip
-> has_at_low_pc
= 1;
3430 dip
-> at_high_pc
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3432 dip
-> at_high_pc
+= baseaddr
;
3435 dip
-> at_language
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3438 case AT_user_def_type
:
3439 dip
-> at_user_def_type
= target_to_host (diep
, nbytes
,
3440 GET_UNSIGNED
, objfile
);
3443 dip
-> at_byte_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3445 dip
-> has_at_byte_size
= 1;
3448 dip
-> at_bit_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3452 dip
-> at_member
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3456 dip
-> at_discr
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3460 dip
-> at_location
= diep
;
3462 case AT_mod_fund_type
:
3463 dip
-> at_mod_fund_type
= diep
;
3465 case AT_subscr_data
:
3466 dip
-> at_subscr_data
= diep
;
3468 case AT_mod_u_d_type
:
3469 dip
-> at_mod_u_d_type
= diep
;
3471 case AT_element_list
:
3472 dip
-> at_element_list
= diep
;
3473 dip
-> short_element_list
= 0;
3475 case AT_short_element_list
:
3476 dip
-> at_element_list
= diep
;
3477 dip
-> short_element_list
= 1;
3479 case AT_discr_value
:
3480 dip
-> at_discr_value
= diep
;
3482 case AT_string_length
:
3483 dip
-> at_string_length
= diep
;
3486 dip
-> at_name
= diep
;
3489 /* For now, ignore any "hostname:" portion, since gdb doesn't
3490 know how to deal with it. (FIXME). */
3491 dip
-> at_comp_dir
= strrchr (diep
, ':');
3492 if (dip
-> at_comp_dir
!= NULL
)
3494 dip
-> at_comp_dir
++;
3498 dip
-> at_comp_dir
= diep
;
3502 dip
-> at_producer
= diep
;
3504 case AT_start_scope
:
3505 dip
-> at_start_scope
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3508 case AT_stride_size
:
3509 dip
-> at_stride_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3513 dip
-> at_src_info
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3517 dip
-> at_prototyped
= diep
;
3520 /* Found an attribute that we are unprepared to handle. However
3521 it is specifically one of the design goals of DWARF that
3522 consumers should ignore unknown attributes. As long as the
3523 form is one that we recognize (so we know how to skip it),
3524 we can just ignore the unknown attribute. */
3527 form
= FORM_FROM_ATTR (attr
);
3541 diep
+= TARGET_FT_POINTER_SIZE (objfile
);
3544 diep
+= 2 + target_to_host (diep
, nbytes
, GET_UNSIGNED
, objfile
);
3547 diep
+= 4 + target_to_host (diep
, nbytes
, GET_UNSIGNED
, objfile
);
3550 diep
+= strlen (diep
) + 1;
3553 SQUAWK (("unknown attribute form (0x%x)", form
));
3554 SQUAWK (("unknown attribute length, skipped remaining attributes"));;
3565 target_to_host -- swap in target data to host
3569 target_to_host (char *from, int nbytes, int signextend,
3570 struct objfile *objfile)
3574 Given pointer to data in target format in FROM, a byte count for
3575 the size of the data in NBYTES, a flag indicating whether or not
3576 the data is signed in SIGNEXTEND, and a pointer to the current
3577 objfile in OBJFILE, convert the data to host format and return
3578 the converted value.
3582 FIXME: If we read data that is known to be signed, and expect to
3583 use it as signed data, then we need to explicitly sign extend the
3584 result until the bfd library is able to do this for us.
3588 static unsigned long
3589 target_to_host (from
, nbytes
, signextend
, objfile
)
3592 int signextend
; /* FIXME: Unused */
3593 struct objfile
*objfile
;
3595 unsigned long rtnval
;
3600 rtnval
= bfd_get_64 (objfile
-> obfd
, (bfd_byte
*) from
);
3603 rtnval
= bfd_get_32 (objfile
-> obfd
, (bfd_byte
*) from
);
3606 rtnval
= bfd_get_16 (objfile
-> obfd
, (bfd_byte
*) from
);
3609 rtnval
= bfd_get_8 (objfile
-> obfd
, (bfd_byte
*) from
);
3612 dwarfwarn ("no bfd support for %d byte data object", nbytes
);
3623 attribute_size -- compute size of data for a DWARF attribute
3627 static int attribute_size (unsigned int attr)
3631 Given a DWARF attribute in ATTR, compute the size of the first
3632 piece of data associated with this attribute and return that
3635 Returns -1 for unrecognized attributes.
3640 attribute_size (attr
)
3643 int nbytes
; /* Size of next data for this attribute */
3644 unsigned short form
; /* Form of the attribute */
3646 form
= FORM_FROM_ATTR (attr
);
3649 case FORM_STRING
: /* A variable length field is next */
3652 case FORM_DATA2
: /* Next 2 byte field is the data itself */
3653 case FORM_BLOCK2
: /* Next 2 byte field is a block length */
3656 case FORM_DATA4
: /* Next 4 byte field is the data itself */
3657 case FORM_BLOCK4
: /* Next 4 byte field is a block length */
3658 case FORM_REF
: /* Next 4 byte field is a DIE offset */
3661 case FORM_DATA8
: /* Next 8 byte field is the data itself */
3664 case FORM_ADDR
: /* Next field size is target sizeof(void *) */
3665 nbytes
= TARGET_FT_POINTER_SIZE (objfile
);
3668 SQUAWK (("unknown attribute form (0x%x)", form
));