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
;
490 cu_language
= language_chill
;
493 cu_language
= language_m2
;
502 cu_language
= language_unknown
;
511 dwarf_build_psymtabs -- build partial symtabs from DWARF debug info
515 void dwarf_build_psymtabs (struct objfile *objfile,
516 struct section_offsets *section_offsets,
517 int mainline, file_ptr dbfoff, unsigned int dbfsize,
518 file_ptr lnoffset, unsigned int lnsize)
522 This function is called upon to build partial symtabs from files
523 containing DIE's (Dwarf Information Entries) and DWARF line numbers.
525 It is passed a bfd* containing the DIES
526 and line number information, the corresponding filename for that
527 file, a base address for relocating the symbols, a flag indicating
528 whether or not this debugging information is from a "main symbol
529 table" rather than a shared library or dynamically linked file,
530 and file offset/size pairs for the DIE information and line number
540 dwarf_build_psymtabs (objfile
, section_offsets
, mainline
, dbfoff
, dbfsize
,
542 struct objfile
*objfile
;
543 struct section_offsets
*section_offsets
;
546 unsigned int dbfsize
;
550 bfd
*abfd
= objfile
->obfd
;
551 struct cleanup
*back_to
;
553 current_objfile
= objfile
;
555 dbbase
= xmalloc (dbsize
);
557 if ((bfd_seek (abfd
, dbfoff
, L_SET
) != 0) ||
558 (bfd_read (dbbase
, dbsize
, 1, abfd
) != dbsize
))
561 error ("can't read DWARF data from '%s'", bfd_get_filename (abfd
));
563 back_to
= make_cleanup (free
, dbbase
);
565 /* If we are reinitializing, or if we have never loaded syms yet, init.
566 Since we have no idea how many DIES we are looking at, we just guess
567 some arbitrary value. */
569 if (mainline
|| objfile
-> global_psymbols
.size
== 0 ||
570 objfile
-> static_psymbols
.size
== 0)
572 init_psymbol_list (objfile
, 1024);
575 /* Save the relocation factor where everybody can see it. */
577 base_section_offsets
= section_offsets
;
578 baseaddr
= ANOFFSET (section_offsets
, 0);
580 /* Follow the compilation unit sibling chain, building a partial symbol
581 table entry for each one. Save enough information about each compilation
582 unit to locate the full DWARF information later. */
584 scan_compilation_units (dbbase
, dbbase
+ dbsize
, dbfoff
, lnoffset
, objfile
);
586 do_cleanups (back_to
);
587 current_objfile
= NULL
;
595 record_minimal_symbol -- add entry to gdb's minimal symbol table
599 static void record_minimal_symbol (char *name, CORE_ADDR address,
600 enum minimal_symbol_type ms_type,
601 struct objfile *objfile)
605 Given a pointer to the name of a symbol that should be added to the
606 minimal symbol table, and the address associated with that
607 symbol, records this information for later use in building the
608 minimal symbol table.
613 record_minimal_symbol (name
, address
, ms_type
, objfile
)
616 enum minimal_symbol_type ms_type
;
617 struct objfile
*objfile
;
619 name
= obsavestring (name
, strlen (name
), &objfile
-> symbol_obstack
);
620 prim_record_minimal_symbol (name
, address
, ms_type
);
627 dwarfwarn -- issue a DWARF related warning
631 Issue warnings about DWARF related things that aren't serious enough
632 to warrant aborting with an error, but should not be ignored either.
633 This includes things like detectable corruption in DIE's, missing
634 DIE's, unimplemented features, etc.
636 In general, running across tags or attributes that we don't recognize
637 is not considered to be a problem and we should not issue warnings
642 We mostly follow the example of the error() routine, but without
643 returning to command level. It is arguable about whether warnings
644 should be issued at all, and if so, where they should go (stdout or
647 We assume that curdie is valid and contains at least the basic
648 information for the DIE where the problem was noticed.
659 fmt
= va_arg (ap
, char *);
661 fprintf (stderr
, "warning: DWARF ref 0x%x: ", curdie
-> die_ref
);
662 if (curdie
-> at_name
)
664 fprintf (stderr
, "'%s': ", curdie
-> at_name
);
666 vfprintf (stderr
, fmt
, ap
);
667 fprintf (stderr
, "\n");
676 read_lexical_block_scope -- process all dies in a lexical block
680 static void read_lexical_block_scope (struct dieinfo *dip,
681 char *thisdie, char *enddie)
685 Process all the DIES contained within a lexical block scope.
686 Start a new scope, process the dies, and then close the scope.
691 read_lexical_block_scope (dip
, thisdie
, enddie
, objfile
)
695 struct objfile
*objfile
;
697 register struct context_stack
*new;
699 push_context (0, dip
-> at_low_pc
);
700 process_dies (thisdie
+ dip
-> die_length
, enddie
, objfile
);
701 new = pop_context ();
702 if (local_symbols
!= NULL
)
704 finish_block (0, &local_symbols
, new -> old_blocks
, new -> start_addr
,
705 dip
-> at_high_pc
, objfile
);
707 local_symbols
= new -> locals
;
714 lookup_utype -- look up a user defined type from die reference
718 static type *lookup_utype (DIE_REF die_ref)
722 Given a DIE reference, lookup the user defined type associated with
723 that DIE, if it has been registered already. If not registered, then
724 return NULL. Alloc_utype() can be called to register an empty
725 type for this reference, which will be filled in later when the
726 actual referenced DIE is processed.
730 lookup_utype (die_ref
)
733 struct type
*type
= NULL
;
736 utypeidx
= (die_ref
- dbroff
) / 4;
737 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
739 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", die_ref
);
743 type
= *(utypes
+ utypeidx
);
753 alloc_utype -- add a user defined type for die reference
757 static type *alloc_utype (DIE_REF die_ref, struct type *utypep)
761 Given a die reference DIE_REF, and a possible pointer to a user
762 defined type UTYPEP, register that this reference has a user
763 defined type and either use the specified type in UTYPEP or
764 make a new empty type that will be filled in later.
766 We should only be called after calling lookup_utype() to verify that
767 there is not currently a type registered for DIE_REF.
771 alloc_utype (die_ref
, utypep
)
778 utypeidx
= (die_ref
- dbroff
) / 4;
779 typep
= utypes
+ utypeidx
;
780 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
782 utypep
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
783 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", die_ref
);
785 else if (*typep
!= NULL
)
788 SQUAWK (("internal error: dup user type allocation"));
794 utypep
= alloc_type (current_objfile
);
805 decode_die_type -- return a type for a specified die
809 static struct type *decode_die_type (struct dieinfo *dip)
813 Given a pointer to a die information structure DIP, decode the
814 type of the die and return a pointer to the decoded type. All
815 dies without specific types default to type int.
819 decode_die_type (dip
)
822 struct type
*type
= NULL
;
824 if (dip
-> at_fund_type
!= 0)
826 type
= decode_fund_type (dip
-> at_fund_type
);
828 else if (dip
-> at_mod_fund_type
!= NULL
)
830 type
= decode_mod_fund_type (dip
-> at_mod_fund_type
);
832 else if (dip
-> at_user_def_type
)
834 if ((type
= lookup_utype (dip
-> at_user_def_type
)) == NULL
)
836 type
= alloc_utype (dip
-> at_user_def_type
, NULL
);
839 else if (dip
-> at_mod_u_d_type
)
841 type
= decode_mod_u_d_type (dip
-> at_mod_u_d_type
);
845 type
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
854 struct_type -- compute and return the type for a struct or union
858 static struct type *struct_type (struct dieinfo *dip, char *thisdie,
859 char *enddie, struct objfile *objfile)
863 Given pointer to a die information structure for a die which
864 defines a union or structure (and MUST define one or the other),
865 and pointers to the raw die data that define the range of dies which
866 define the members, compute and return the user defined type for the
871 struct_type (dip
, thisdie
, enddie
, objfile
)
875 struct objfile
*objfile
;
879 struct nextfield
*next
;
882 struct nextfield
*list
= NULL
;
883 struct nextfield
*new;
891 if ((type
= lookup_utype (dip
-> die_ref
)) == NULL
)
893 /* No forward references created an empty type, so install one now */
894 type
= alloc_utype (dip
-> die_ref
, NULL
);
896 INIT_CPLUS_SPECIFIC(type
);
897 switch (dip
-> die_tag
)
900 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
903 case TAG_structure_type
:
904 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
908 TYPE_CODE (type
) = TYPE_CODE_UNION
;
912 /* Should never happen */
913 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
915 SQUAWK (("missing class, structure, or union tag"));
918 /* Some compilers try to be helpful by inventing "fake" names for
919 anonymous enums, structures, and unions, like "~0fake" or ".0fake".
920 Thanks, but no thanks... */
921 if (dip
-> at_name
!= NULL
922 && *dip
-> at_name
!= '~'
923 && *dip
-> at_name
!= '.')
925 TYPE_NAME (type
) = obconcat (&objfile
-> type_obstack
,
926 tpart1
, " ", dip
-> at_name
);
928 /* Use whatever size is known. Zero is a valid size. We might however
929 wish to check has_at_byte_size to make sure that some byte size was
930 given explicitly, but DWARF doesn't specify that explicit sizes of
931 zero have to present, so complaining about missing sizes should
932 probably not be the default. */
933 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
934 thisdie
+= dip
-> die_length
;
935 while (thisdie
< enddie
)
937 basicdieinfo (&mbr
, thisdie
, objfile
);
938 completedieinfo (&mbr
, objfile
);
939 if (mbr
.die_length
<= SIZEOF_DIE_LENGTH
)
943 else if (mbr
.at_sibling
!= 0)
945 nextdie
= dbbase
+ mbr
.at_sibling
- dbroff
;
949 nextdie
= thisdie
+ mbr
.die_length
;
954 /* Get space to record the next field's data. */
955 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
960 obsavestring (mbr
.at_name
, strlen (mbr
.at_name
),
961 &objfile
-> type_obstack
);
962 list
-> field
.type
= decode_die_type (&mbr
);
963 list
-> field
.bitpos
= 8 * locval (mbr
.at_location
);
964 /* Handle bit fields. */
965 list
-> field
.bitsize
= mbr
.at_bit_size
;
967 /* For big endian bits, the at_bit_offset gives the additional
968 bit offset from the MSB of the containing anonymous object to
969 the MSB of the field. We don't have to do anything special
970 since we don't need to know the size of the anonymous object. */
971 list
-> field
.bitpos
+= mbr
.at_bit_offset
;
973 /* For little endian bits, we need to have a non-zero at_bit_size,
974 so that we know we are in fact dealing with a bitfield. Compute
975 the bit offset to the MSB of the anonymous object, subtract off
976 the number of bits from the MSB of the field to the MSB of the
977 object, and then subtract off the number of bits of the field
978 itself. The result is the bit offset of the LSB of the field. */
979 if (mbr
.at_bit_size
> 0)
981 if (mbr
.has_at_byte_size
)
983 /* The size of the anonymous object containing the bit field
984 is explicit, so use the indicated size (in bytes). */
985 anonymous_size
= mbr
.at_byte_size
;
989 /* The size of the anonymous object containing the bit field
990 matches the size of an object of the bit field's type.
991 DWARF allows at_byte_size to be left out in such cases,
992 as a debug information size optimization. */
993 anonymous_size
= TYPE_LENGTH (list
-> field
.type
);
995 list
-> field
.bitpos
+=
996 anonymous_size
* 8 - mbr
.at_bit_offset
- mbr
.at_bit_size
;
1002 process_dies (thisdie
, nextdie
, objfile
);
1007 /* Now create the vector of fields, and record how big it is. We may
1008 not even have any fields, if this DIE was generated due to a reference
1009 to an anonymous structure or union. In this case, TYPE_FLAG_STUB is
1010 set, which clues gdb in to the fact that it needs to search elsewhere
1011 for the full structure definition. */
1014 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
1018 TYPE_NFIELDS (type
) = nfields
;
1019 TYPE_FIELDS (type
) = (struct field
*)
1020 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
1021 /* Copy the saved-up fields into the field vector. */
1022 for (n
= nfields
; list
; list
= list
-> next
)
1024 TYPE_FIELD (type
, --n
) = list
-> field
;
1034 read_structure_scope -- process all dies within struct or union
1038 static void read_structure_scope (struct dieinfo *dip,
1039 char *thisdie, char *enddie, struct objfile *objfile)
1043 Called when we find the DIE that starts a structure or union
1044 scope (definition) to process all dies that define the members
1045 of the structure or union. DIP is a pointer to the die info
1046 struct for the DIE that names the structure or union.
1050 Note that we need to call struct_type regardless of whether or not
1051 the DIE has an at_name attribute, since it might be an anonymous
1052 structure or union. This gets the type entered into our set of
1055 However, if the structure is incomplete (an opaque struct/union)
1056 then suppress creating a symbol table entry for it since gdb only
1057 wants to find the one with the complete definition. Note that if
1058 it is complete, we just call new_symbol, which does it's own
1059 checking about whether the struct/union is anonymous or not (and
1060 suppresses creating a symbol table entry itself).
1065 read_structure_scope (dip
, thisdie
, enddie
, objfile
)
1066 struct dieinfo
*dip
;
1069 struct objfile
*objfile
;
1074 type
= struct_type (dip
, thisdie
, enddie
, objfile
);
1075 if (!(TYPE_FLAGS (type
) & TYPE_FLAG_STUB
))
1077 sym
= new_symbol (dip
, objfile
);
1080 SYMBOL_TYPE (sym
) = type
;
1081 if (cu_language
== language_cplus
)
1083 synthesize_typedef (dip
, objfile
, type
);
1093 decode_array_element_type -- decode type of the array elements
1097 static struct type *decode_array_element_type (char *scan, char *end)
1101 As the last step in decoding the array subscript information for an
1102 array DIE, we need to decode the type of the array elements. We are
1103 passed a pointer to this last part of the subscript information and
1104 must return the appropriate type. If the type attribute is not
1105 recognized, just warn about the problem and return type int.
1108 static struct type
*
1109 decode_array_element_type (scan
)
1114 unsigned short attribute
;
1115 unsigned short fundtype
;
1118 attribute
= target_to_host (scan
, SIZEOF_ATTRIBUTE
, GET_UNSIGNED
,
1120 scan
+= SIZEOF_ATTRIBUTE
;
1121 if ((nbytes
= attribute_size (attribute
)) == -1)
1123 SQUAWK (("bad array element type attribute 0x%x", attribute
));
1124 typep
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1131 fundtype
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1133 typep
= decode_fund_type (fundtype
);
1135 case AT_mod_fund_type
:
1136 typep
= decode_mod_fund_type (scan
);
1138 case AT_user_def_type
:
1139 die_ref
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1141 if ((typep
= lookup_utype (die_ref
)) == NULL
)
1143 typep
= alloc_utype (die_ref
, NULL
);
1146 case AT_mod_u_d_type
:
1147 typep
= decode_mod_u_d_type (scan
);
1150 SQUAWK (("bad array element type attribute 0x%x", attribute
));
1151 typep
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1162 decode_subscr_data -- decode array subscript and element type data
1166 static struct type *decode_subscr_data (char *scan, char *end)
1170 The array subscripts and the data type of the elements of an
1171 array are described by a list of data items, stored as a block
1172 of contiguous bytes. There is a data item describing each array
1173 dimension, and a final data item describing the element type.
1174 The data items are ordered the same as their appearance in the
1175 source (I.E. leftmost dimension first, next to leftmost second,
1178 We are passed a pointer to the start of the block of bytes
1179 containing the data items, and a pointer to the first byte past
1180 the data. This function decodes the data and returns a type.
1183 FIXME: This code only implements the forms currently used
1184 by the AT&T and GNU C compilers.
1186 The end pointer is supplied for error checking, maybe we should
1190 static struct type
*
1191 decode_subscr_data (scan
, end
)
1195 struct type
*typep
= NULL
;
1196 struct type
*nexttype
;
1197 unsigned int format
;
1198 unsigned short fundtype
;
1199 unsigned long lowbound
;
1200 unsigned long highbound
;
1203 format
= target_to_host (scan
, SIZEOF_FORMAT_SPECIFIER
, GET_UNSIGNED
,
1205 scan
+= SIZEOF_FORMAT_SPECIFIER
;
1209 typep
= decode_array_element_type (scan
);
1212 fundtype
= target_to_host (scan
, SIZEOF_FMT_FT
, GET_UNSIGNED
,
1214 scan
+= SIZEOF_FMT_FT
;
1215 if (fundtype
!= FT_integer
&& fundtype
!= FT_signed_integer
1216 && fundtype
!= FT_unsigned_integer
)
1218 SQUAWK (("array subscripts must be integral types, not type 0x%x",
1223 nbytes
= TARGET_FT_LONG_SIZE (current_objfile
);
1224 lowbound
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1227 highbound
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1230 nexttype
= decode_subscr_data (scan
, end
);
1231 if (nexttype
!= NULL
)
1233 typep
= alloc_type (current_objfile
);
1234 TYPE_CODE (typep
) = TYPE_CODE_ARRAY
;
1235 TYPE_LENGTH (typep
) = TYPE_LENGTH (nexttype
);
1236 TYPE_LENGTH (typep
) *= (highbound
- lowbound
) + 1;
1237 TYPE_TARGET_TYPE (typep
) = nexttype
;
1248 SQUAWK (("array subscript format 0x%x not handled yet", format
));
1251 SQUAWK (("unknown array subscript format %x", format
));
1261 dwarf_read_array_type -- read TAG_array_type DIE
1265 static void dwarf_read_array_type (struct dieinfo *dip)
1269 Extract all information from a TAG_array_type DIE and add to
1270 the user defined type vector.
1274 dwarf_read_array_type (dip
)
1275 struct dieinfo
*dip
;
1281 unsigned short blocksz
;
1284 if (dip
-> at_ordering
!= ORD_row_major
)
1286 /* FIXME: Can gdb even handle column major arrays? */
1287 SQUAWK (("array not row major; not handled correctly"));
1289 if ((sub
= dip
-> at_subscr_data
) != NULL
)
1291 nbytes
= attribute_size (AT_subscr_data
);
1292 blocksz
= target_to_host (sub
, nbytes
, GET_UNSIGNED
, current_objfile
);
1293 subend
= sub
+ nbytes
+ blocksz
;
1295 type
= decode_subscr_data (sub
, subend
);
1298 if ((utype
= lookup_utype (dip
-> die_ref
)) == NULL
)
1300 utype
= alloc_utype (dip
-> die_ref
, NULL
);
1302 TYPE_CODE (utype
) = TYPE_CODE_ARRAY
;
1303 TYPE_TARGET_TYPE (utype
) =
1304 lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1305 TYPE_LENGTH (utype
) = 1 * TYPE_LENGTH (TYPE_TARGET_TYPE (utype
));
1309 if ((utype
= lookup_utype (dip
-> die_ref
)) == NULL
)
1311 alloc_utype (dip
-> die_ref
, type
);
1315 TYPE_CODE (utype
) = TYPE_CODE_ARRAY
;
1316 TYPE_LENGTH (utype
) = TYPE_LENGTH (type
);
1317 TYPE_TARGET_TYPE (utype
) = TYPE_TARGET_TYPE (type
);
1327 read_tag_pointer_type -- read TAG_pointer_type DIE
1331 static void read_tag_pointer_type (struct dieinfo *dip)
1335 Extract all information from a TAG_pointer_type DIE and add to
1336 the user defined type vector.
1340 read_tag_pointer_type (dip
)
1341 struct dieinfo
*dip
;
1346 type
= decode_die_type (dip
);
1347 if ((utype
= lookup_utype (dip
-> die_ref
)) == NULL
)
1349 utype
= lookup_pointer_type (type
);
1350 alloc_utype (dip
-> die_ref
, utype
);
1354 TYPE_TARGET_TYPE (utype
) = type
;
1355 TYPE_POINTER_TYPE (type
) = utype
;
1357 /* We assume the machine has only one representation for pointers! */
1358 /* FIXME: This confuses host<->target data representations, and is a
1359 poor assumption besides. */
1361 TYPE_LENGTH (utype
) = sizeof (char *);
1362 TYPE_CODE (utype
) = TYPE_CODE_PTR
;
1370 read_subroutine_type -- process TAG_subroutine_type dies
1374 static void read_subroutine_type (struct dieinfo *dip, char thisdie,
1379 Handle DIES due to C code like:
1382 int (*funcp)(int a, long l); (Generates TAG_subroutine_type DIE)
1388 The parameter DIES are currently ignored. See if gdb has a way to
1389 include this info in it's type system, and decode them if so. Is
1390 this what the type structure's "arg_types" field is for? (FIXME)
1394 read_subroutine_type (dip
, thisdie
, enddie
)
1395 struct dieinfo
*dip
;
1399 struct type
*type
; /* Type that this function returns */
1400 struct type
*ftype
; /* Function that returns above type */
1402 /* Decode the type that this subroutine returns */
1404 type
= decode_die_type (dip
);
1406 /* Check to see if we already have a partially constructed user
1407 defined type for this DIE, from a forward reference. */
1409 if ((ftype
= lookup_utype (dip
-> die_ref
)) == NULL
)
1411 /* This is the first reference to one of these types. Make
1412 a new one and place it in the user defined types. */
1413 ftype
= lookup_function_type (type
);
1414 alloc_utype (dip
-> die_ref
, ftype
);
1418 /* We have an existing partially constructed type, so bash it
1419 into the correct type. */
1420 TYPE_TARGET_TYPE (ftype
) = type
;
1421 TYPE_FUNCTION_TYPE (type
) = ftype
;
1422 TYPE_LENGTH (ftype
) = 1;
1423 TYPE_CODE (ftype
) = TYPE_CODE_FUNC
;
1431 read_enumeration -- process dies which define an enumeration
1435 static void read_enumeration (struct dieinfo *dip, char *thisdie,
1436 char *enddie, struct objfile *objfile)
1440 Given a pointer to a die which begins an enumeration, process all
1441 the dies that define the members of the enumeration.
1445 Note that we need to call enum_type regardless of whether or not we
1446 have a symbol, since we might have an enum without a tag name (thus
1447 no symbol for the tagname).
1451 read_enumeration (dip
, thisdie
, enddie
, objfile
)
1452 struct dieinfo
*dip
;
1455 struct objfile
*objfile
;
1460 type
= enum_type (dip
, objfile
);
1461 sym
= new_symbol (dip
, objfile
);
1464 SYMBOL_TYPE (sym
) = type
;
1465 if (cu_language
== language_cplus
)
1467 synthesize_typedef (dip
, objfile
, type
);
1476 enum_type -- decode and return a type for an enumeration
1480 static type *enum_type (struct dieinfo *dip, struct objfile *objfile)
1484 Given a pointer to a die information structure for the die which
1485 starts an enumeration, process all the dies that define the members
1486 of the enumeration and return a type pointer for the enumeration.
1488 At the same time, for each member of the enumeration, create a
1489 symbol for it with namespace VAR_NAMESPACE and class LOC_CONST,
1490 and give it the type of the enumeration itself.
1494 Note that the DWARF specification explicitly mandates that enum
1495 constants occur in reverse order from the source program order,
1496 for "consistency" and because this ordering is easier for many
1497 compilers to generate. (Draft 6, sec 3.8.5, Enumeration type
1498 Entries). Because gdb wants to see the enum members in program
1499 source order, we have to ensure that the order gets reversed while
1500 we are processing them.
1503 static struct type
*
1504 enum_type (dip
, objfile
)
1505 struct dieinfo
*dip
;
1506 struct objfile
*objfile
;
1510 struct nextfield
*next
;
1513 struct nextfield
*list
= NULL
;
1514 struct nextfield
*new;
1519 unsigned short blocksz
;
1523 if ((type
= lookup_utype (dip
-> die_ref
)) == NULL
)
1525 /* No forward references created an empty type, so install one now */
1526 type
= alloc_utype (dip
-> die_ref
, NULL
);
1528 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1529 /* Some compilers try to be helpful by inventing "fake" names for
1530 anonymous enums, structures, and unions, like "~0fake" or ".0fake".
1531 Thanks, but no thanks... */
1532 if (dip
-> at_name
!= NULL
1533 && *dip
-> at_name
!= '~'
1534 && *dip
-> at_name
!= '.')
1536 TYPE_NAME (type
) = obconcat (&objfile
-> type_obstack
, "enum",
1537 " ", dip
-> at_name
);
1539 if (dip
-> at_byte_size
!= 0)
1541 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
1543 if ((scan
= dip
-> at_element_list
) != NULL
)
1545 if (dip
-> short_element_list
)
1547 nbytes
= attribute_size (AT_short_element_list
);
1551 nbytes
= attribute_size (AT_element_list
);
1553 blocksz
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, objfile
);
1554 listend
= scan
+ nbytes
+ blocksz
;
1556 while (scan
< listend
)
1558 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1561 list
-> field
.type
= NULL
;
1562 list
-> field
.bitsize
= 0;
1563 list
-> field
.bitpos
=
1564 target_to_host (scan
, TARGET_FT_LONG_SIZE (objfile
), GET_SIGNED
,
1566 scan
+= TARGET_FT_LONG_SIZE (objfile
);
1567 list
-> field
.name
= obsavestring (scan
, strlen (scan
),
1568 &objfile
-> type_obstack
);
1569 scan
+= strlen (scan
) + 1;
1571 /* Handcraft a new symbol for this enum member. */
1572 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
1573 sizeof (struct symbol
));
1574 memset (sym
, 0, sizeof (struct symbol
));
1575 SYMBOL_NAME (sym
) = create_name (list
-> field
.name
,
1576 &objfile
->symbol_obstack
);
1577 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1578 SYMBOL_CLASS (sym
) = LOC_CONST
;
1579 SYMBOL_TYPE (sym
) = type
;
1580 SYMBOL_VALUE (sym
) = list
-> field
.bitpos
;
1581 add_symbol_to_list (sym
, list_in_scope
);
1583 /* Now create the vector of fields, and record how big it is. This is
1584 where we reverse the order, by pulling the members off the list in
1585 reverse order from how they were inserted. If we have no fields
1586 (this is apparently possible in C++) then skip building a field
1590 TYPE_NFIELDS (type
) = nfields
;
1591 TYPE_FIELDS (type
) = (struct field
*)
1592 obstack_alloc (&objfile
->symbol_obstack
, sizeof (struct field
) * nfields
);
1593 /* Copy the saved-up fields into the field vector. */
1594 for (n
= 0; (n
< nfields
) && (list
!= NULL
); list
= list
-> next
)
1596 TYPE_FIELD (type
, n
++) = list
-> field
;
1607 read_func_scope -- process all dies within a function scope
1611 Process all dies within a given function scope. We are passed
1612 a die information structure pointer DIP for the die which
1613 starts the function scope, and pointers into the raw die data
1614 that define the dies within the function scope.
1616 For now, we ignore lexical block scopes within the function.
1617 The problem is that AT&T cc does not define a DWARF lexical
1618 block scope for the function itself, while gcc defines a
1619 lexical block scope for the function. We need to think about
1620 how to handle this difference, or if it is even a problem.
1625 read_func_scope (dip
, thisdie
, enddie
, objfile
)
1626 struct dieinfo
*dip
;
1629 struct objfile
*objfile
;
1631 register struct context_stack
*new;
1633 if (objfile
-> ei
.entry_point
>= dip
-> at_low_pc
&&
1634 objfile
-> ei
.entry_point
< dip
-> at_high_pc
)
1636 objfile
-> ei
.entry_func_lowpc
= dip
-> at_low_pc
;
1637 objfile
-> ei
.entry_func_highpc
= dip
-> at_high_pc
;
1639 if (STREQ (dip
-> at_name
, "main")) /* FIXME: hardwired name */
1641 objfile
-> ei
.main_func_lowpc
= dip
-> at_low_pc
;
1642 objfile
-> ei
.main_func_highpc
= dip
-> at_high_pc
;
1644 new = push_context (0, dip
-> at_low_pc
);
1645 new -> name
= new_symbol (dip
, objfile
);
1646 list_in_scope
= &local_symbols
;
1647 process_dies (thisdie
+ dip
-> die_length
, enddie
, objfile
);
1648 new = pop_context ();
1649 /* Make a block for the local symbols within. */
1650 finish_block (new -> name
, &local_symbols
, new -> old_blocks
,
1651 new -> start_addr
, dip
-> at_high_pc
, objfile
);
1652 list_in_scope
= &file_symbols
;
1660 handle_producer -- process the AT_producer attribute
1664 Perform any operations that depend on finding a particular
1665 AT_producer attribute.
1670 handle_producer (producer
)
1674 /* If this compilation unit was compiled with g++ or gcc, then set the
1675 processing_gcc_compilation flag. */
1677 processing_gcc_compilation
=
1678 STREQN (producer
, GPLUS_PRODUCER
, strlen (GPLUS_PRODUCER
))
1679 || STREQN (producer
, GCC_PRODUCER
, strlen (GCC_PRODUCER
));
1681 /* Select a demangling style if we can identify the producer and if
1682 the current style is auto. We leave the current style alone if it
1683 is not auto. We also leave the demangling style alone if we find a
1684 gcc (cc1) producer, as opposed to a g++ (cc1plus) producer. */
1686 #if 1 /* Works, but is experimental. -fnf */
1687 if (AUTO_DEMANGLING
)
1689 if (STREQN (producer
, GPLUS_PRODUCER
, strlen (GPLUS_PRODUCER
)))
1691 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1693 else if (STREQN (producer
, LCC_PRODUCER
, strlen (LCC_PRODUCER
)))
1695 set_demangling_style (LUCID_DEMANGLING_STYLE_STRING
);
1697 else if (STREQN (producer
, CFRONT_PRODUCER
, strlen (CFRONT_PRODUCER
)))
1699 set_demangling_style (CFRONT_DEMANGLING_STYLE_STRING
);
1710 read_file_scope -- process all dies within a file scope
1714 Process all dies within a given file scope. We are passed a
1715 pointer to the die information structure for the die which
1716 starts the file scope, and pointers into the raw die data which
1717 mark the range of dies within the file scope.
1719 When the partial symbol table is built, the file offset for the line
1720 number table for each compilation unit is saved in the partial symbol
1721 table entry for that compilation unit. As the symbols for each
1722 compilation unit are read, the line number table is read into memory
1723 and the variable lnbase is set to point to it. Thus all we have to
1724 do is use lnbase to access the line number table for the current
1729 read_file_scope (dip
, thisdie
, enddie
, objfile
)
1730 struct dieinfo
*dip
;
1733 struct objfile
*objfile
;
1735 struct cleanup
*back_to
;
1736 struct symtab
*symtab
;
1738 if (objfile
-> ei
.entry_point
>= dip
-> at_low_pc
&&
1739 objfile
-> ei
.entry_point
< dip
-> at_high_pc
)
1741 objfile
-> ei
.entry_file_lowpc
= dip
-> at_low_pc
;
1742 objfile
-> ei
.entry_file_highpc
= dip
-> at_high_pc
;
1744 set_cu_language (dip
);
1745 if (dip
-> at_producer
!= NULL
)
1747 handle_producer (dip
-> at_producer
);
1749 numutypes
= (enddie
- thisdie
) / 4;
1750 utypes
= (struct type
**) xmalloc (numutypes
* sizeof (struct type
*));
1751 back_to
= make_cleanup (free
, utypes
);
1752 memset (utypes
, 0, numutypes
* sizeof (struct type
*));
1753 start_symtab (dip
-> at_name
, dip
-> at_comp_dir
, dip
-> at_low_pc
);
1754 decode_line_numbers (lnbase
);
1755 process_dies (thisdie
+ dip
-> die_length
, enddie
, objfile
);
1756 symtab
= end_symtab (dip
-> at_high_pc
, 0, 0, objfile
);
1759 symtab
-> language
= cu_language
;
1761 do_cleanups (back_to
);
1770 process_dies -- process a range of DWARF Information Entries
1774 static void process_dies (char *thisdie, char *enddie,
1775 struct objfile *objfile)
1779 Process all DIE's in a specified range. May be (and almost
1780 certainly will be) called recursively.
1784 process_dies (thisdie
, enddie
, objfile
)
1787 struct objfile
*objfile
;
1792 while (thisdie
< enddie
)
1794 basicdieinfo (&di
, thisdie
, objfile
);
1795 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
1799 else if (di
.die_tag
== TAG_padding
)
1801 nextdie
= thisdie
+ di
.die_length
;
1805 completedieinfo (&di
, objfile
);
1806 if (di
.at_sibling
!= 0)
1808 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
1812 nextdie
= thisdie
+ di
.die_length
;
1816 case TAG_compile_unit
:
1817 read_file_scope (&di
, thisdie
, nextdie
, objfile
);
1819 case TAG_global_subroutine
:
1820 case TAG_subroutine
:
1821 if (di
.has_at_low_pc
)
1823 read_func_scope (&di
, thisdie
, nextdie
, objfile
);
1826 case TAG_lexical_block
:
1827 read_lexical_block_scope (&di
, thisdie
, nextdie
, objfile
);
1829 case TAG_class_type
:
1830 case TAG_structure_type
:
1831 case TAG_union_type
:
1832 read_structure_scope (&di
, thisdie
, nextdie
, objfile
);
1834 case TAG_enumeration_type
:
1835 read_enumeration (&di
, thisdie
, nextdie
, objfile
);
1837 case TAG_subroutine_type
:
1838 read_subroutine_type (&di
, thisdie
, nextdie
);
1840 case TAG_array_type
:
1841 dwarf_read_array_type (&di
);
1843 case TAG_pointer_type
:
1844 read_tag_pointer_type (&di
);
1847 new_symbol (&di
, objfile
);
1859 decode_line_numbers -- decode a line number table fragment
1863 static void decode_line_numbers (char *tblscan, char *tblend,
1864 long length, long base, long line, long pc)
1868 Translate the DWARF line number information to gdb form.
1870 The ".line" section contains one or more line number tables, one for
1871 each ".line" section from the objects that were linked.
1873 The AT_stmt_list attribute for each TAG_source_file entry in the
1874 ".debug" section contains the offset into the ".line" section for the
1875 start of the table for that file.
1877 The table itself has the following structure:
1879 <table length><base address><source statement entry>
1880 4 bytes 4 bytes 10 bytes
1882 The table length is the total size of the table, including the 4 bytes
1883 for the length information.
1885 The base address is the address of the first instruction generated
1886 for the source file.
1888 Each source statement entry has the following structure:
1890 <line number><statement position><address delta>
1891 4 bytes 2 bytes 4 bytes
1893 The line number is relative to the start of the file, starting with
1896 The statement position either -1 (0xFFFF) or the number of characters
1897 from the beginning of the line to the beginning of the statement.
1899 The address delta is the difference between the base address and
1900 the address of the first instruction for the statement.
1902 Note that we must copy the bytes from the packed table to our local
1903 variables before attempting to use them, to avoid alignment problems
1904 on some machines, particularly RISC processors.
1908 Does gdb expect the line numbers to be sorted? They are now by
1909 chance/luck, but are not required to be. (FIXME)
1911 The line with number 0 is unused, gdb apparently can discover the
1912 span of the last line some other way. How? (FIXME)
1916 decode_line_numbers (linetable
)
1921 unsigned long length
;
1926 if (linetable
!= NULL
)
1928 tblscan
= tblend
= linetable
;
1929 length
= target_to_host (tblscan
, SIZEOF_LINETBL_LENGTH
, GET_UNSIGNED
,
1931 tblscan
+= SIZEOF_LINETBL_LENGTH
;
1933 base
= target_to_host (tblscan
, TARGET_FT_POINTER_SIZE (objfile
),
1934 GET_UNSIGNED
, current_objfile
);
1935 tblscan
+= TARGET_FT_POINTER_SIZE (objfile
);
1937 while (tblscan
< tblend
)
1939 line
= target_to_host (tblscan
, SIZEOF_LINETBL_LINENO
, GET_UNSIGNED
,
1941 tblscan
+= SIZEOF_LINETBL_LINENO
+ SIZEOF_LINETBL_STMT
;
1942 pc
= target_to_host (tblscan
, SIZEOF_LINETBL_DELTA
, GET_UNSIGNED
,
1944 tblscan
+= SIZEOF_LINETBL_DELTA
;
1948 record_line (current_subfile
, line
, pc
);
1958 locval -- compute the value of a location attribute
1962 static int locval (char *loc)
1966 Given pointer to a string of bytes that define a location, compute
1967 the location and return the value.
1969 When computing values involving the current value of the frame pointer,
1970 the value zero is used, which results in a value relative to the frame
1971 pointer, rather than the absolute value. This is what GDB wants
1974 When the result is a register number, the global isreg flag is set,
1975 otherwise it is cleared. This is a kludge until we figure out a better
1976 way to handle the problem. Gdb's design does not mesh well with the
1977 DWARF notion of a location computing interpreter, which is a shame
1978 because the flexibility goes unused.
1982 Note that stack[0] is unused except as a default error return.
1983 Note that stack overflow is not yet handled.
1990 unsigned short nbytes
;
1991 unsigned short locsize
;
1992 auto long stack
[64];
1999 nbytes
= attribute_size (AT_location
);
2000 locsize
= target_to_host (loc
, nbytes
, GET_UNSIGNED
, current_objfile
);
2002 end
= loc
+ locsize
;
2007 loc_value_size
= TARGET_FT_LONG_SIZE (current_objfile
);
2010 loc_atom_code
= target_to_host (loc
, SIZEOF_LOC_ATOM_CODE
, GET_UNSIGNED
,
2012 loc
+= SIZEOF_LOC_ATOM_CODE
;
2013 switch (loc_atom_code
)
2020 /* push register (number) */
2021 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
2022 GET_UNSIGNED
, current_objfile
);
2023 loc
+= loc_value_size
;
2027 /* push value of register (number) */
2028 /* Actually, we compute the value as if register has 0 */
2030 regno
= target_to_host (loc
, loc_value_size
, GET_UNSIGNED
,
2032 loc
+= loc_value_size
;
2035 stack
[++stacki
] = 0;
2039 stack
[++stacki
] = 0;
2040 SQUAWK (("BASEREG %d not handled!", regno
));
2044 /* push address (relocated address) */
2045 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
2046 GET_UNSIGNED
, current_objfile
);
2047 loc
+= loc_value_size
;
2050 /* push constant (number) FIXME: signed or unsigned! */
2051 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
2052 GET_SIGNED
, current_objfile
);
2053 loc
+= loc_value_size
;
2056 /* pop, deref and push 2 bytes (as a long) */
2057 SQUAWK (("OP_DEREF2 address 0x%x not handled", stack
[stacki
]));
2059 case OP_DEREF4
: /* pop, deref and push 4 bytes (as a long) */
2060 SQUAWK (("OP_DEREF4 address 0x%x not handled", stack
[stacki
]));
2062 case OP_ADD
: /* pop top 2 items, add, push result */
2063 stack
[stacki
- 1] += stack
[stacki
];
2068 return (stack
[stacki
]);
2075 read_ofile_symtab -- build a full symtab entry from chunk of DIE's
2079 static struct symtab *read_ofile_symtab (struct partial_symtab *pst)
2083 When expanding a partial symbol table entry to a full symbol table
2084 entry, this is the function that gets called to read in the symbols
2085 for the compilation unit.
2087 Returns a pointer to the newly constructed symtab (which is now
2088 the new first one on the objfile's symtab list).
2091 static struct symtab
*
2092 read_ofile_symtab (pst
)
2093 struct partial_symtab
*pst
;
2095 struct cleanup
*back_to
;
2096 unsigned long lnsize
;
2099 char lnsizedata
[SIZEOF_LINETBL_LENGTH
];
2101 abfd
= pst
-> objfile
-> obfd
;
2102 current_objfile
= pst
-> objfile
;
2104 /* Allocate a buffer for the entire chunk of DIE's for this compilation
2105 unit, seek to the location in the file, and read in all the DIE's. */
2108 dbsize
= DBLENGTH (pst
);
2109 dbbase
= xmalloc (dbsize
);
2110 dbroff
= DBROFF(pst
);
2111 foffset
= DBFOFF(pst
) + dbroff
;
2112 base_section_offsets
= pst
->section_offsets
;
2113 baseaddr
= ANOFFSET (pst
->section_offsets
, 0);
2114 if (bfd_seek (abfd
, foffset
, L_SET
) ||
2115 (bfd_read (dbbase
, dbsize
, 1, abfd
) != dbsize
))
2118 error ("can't read DWARF data");
2120 back_to
= make_cleanup (free
, dbbase
);
2122 /* If there is a line number table associated with this compilation unit
2123 then read the size of this fragment in bytes, from the fragment itself.
2124 Allocate a buffer for the fragment and read it in for future
2130 if (bfd_seek (abfd
, LNFOFF (pst
), L_SET
) ||
2131 (bfd_read ((PTR
) lnsizedata
, sizeof (lnsizedata
), 1, abfd
) !=
2132 sizeof (lnsizedata
)))
2134 error ("can't read DWARF line number table size");
2136 lnsize
= target_to_host (lnsizedata
, SIZEOF_LINETBL_LENGTH
,
2137 GET_UNSIGNED
, pst
-> objfile
);
2138 lnbase
= xmalloc (lnsize
);
2139 if (bfd_seek (abfd
, LNFOFF (pst
), L_SET
) ||
2140 (bfd_read (lnbase
, lnsize
, 1, abfd
) != lnsize
))
2143 error ("can't read DWARF line numbers");
2145 make_cleanup (free
, lnbase
);
2148 process_dies (dbbase
, dbbase
+ dbsize
, pst
-> objfile
);
2149 do_cleanups (back_to
);
2150 current_objfile
= NULL
;
2151 return (pst
-> objfile
-> symtabs
);
2158 psymtab_to_symtab_1 -- do grunt work for building a full symtab entry
2162 static void psymtab_to_symtab_1 (struct partial_symtab *pst)
2166 Called once for each partial symbol table entry that needs to be
2167 expanded into a full symbol table entry.
2172 psymtab_to_symtab_1 (pst
)
2173 struct partial_symtab
*pst
;
2176 struct cleanup
*old_chain
;
2182 warning ("psymtab for %s already read in. Shouldn't happen.",
2187 /* Read in all partial symtabs on which this one is dependent */
2188 for (i
= 0; i
< pst
-> number_of_dependencies
; i
++)
2190 if (!pst
-> dependencies
[i
] -> readin
)
2192 /* Inform about additional files that need to be read in. */
2195 fputs_filtered (" ", stdout
);
2197 fputs_filtered ("and ", stdout
);
2199 printf_filtered ("%s...",
2200 pst
-> dependencies
[i
] -> filename
);
2202 fflush (stdout
); /* Flush output */
2204 psymtab_to_symtab_1 (pst
-> dependencies
[i
]);
2207 if (DBLENGTH (pst
)) /* Otherwise it's a dummy */
2210 old_chain
= make_cleanup (really_free_pendings
, 0);
2211 pst
-> symtab
= read_ofile_symtab (pst
);
2214 printf_filtered ("%d DIE's, sorting...", diecount
);
2218 sort_symtab_syms (pst
-> symtab
);
2219 do_cleanups (old_chain
);
2230 dwarf_psymtab_to_symtab -- build a full symtab entry from partial one
2234 static void dwarf_psymtab_to_symtab (struct partial_symtab *pst)
2238 This is the DWARF support entry point for building a full symbol
2239 table entry from a partial symbol table entry. We are passed a
2240 pointer to the partial symbol table entry that needs to be expanded.
2245 dwarf_psymtab_to_symtab (pst
)
2246 struct partial_symtab
*pst
;
2253 warning ("psymtab for %s already read in. Shouldn't happen.",
2258 if (DBLENGTH (pst
) || pst
-> number_of_dependencies
)
2260 /* Print the message now, before starting serious work, to avoid
2261 disconcerting pauses. */
2264 printf_filtered ("Reading in symbols for %s...",
2269 psymtab_to_symtab_1 (pst
);
2271 #if 0 /* FIXME: Check to see what dbxread is doing here and see if
2272 we need to do an equivalent or is this something peculiar to
2274 Match with global symbols. This only needs to be done once,
2275 after all of the symtabs and dependencies have been read in.
2277 scan_file_globals (pst
-> objfile
);
2280 /* Finish up the verbose info message. */
2283 printf_filtered ("done.\n");
2295 init_psymbol_list -- initialize storage for partial symbols
2299 static void init_psymbol_list (struct objfile *objfile, int total_symbols)
2303 Initializes storage for all of the partial symbols that will be
2304 created by dwarf_build_psymtabs and subsidiaries.
2308 init_psymbol_list (objfile
, total_symbols
)
2309 struct objfile
*objfile
;
2312 /* Free any previously allocated psymbol lists. */
2314 if (objfile
-> global_psymbols
.list
)
2316 mfree (objfile
-> md
, (PTR
)objfile
-> global_psymbols
.list
);
2318 if (objfile
-> static_psymbols
.list
)
2320 mfree (objfile
-> md
, (PTR
)objfile
-> static_psymbols
.list
);
2323 /* Current best guess is that there are approximately a twentieth
2324 of the total symbols (in a debugging file) are global or static
2327 objfile
-> global_psymbols
.size
= total_symbols
/ 10;
2328 objfile
-> static_psymbols
.size
= total_symbols
/ 10;
2329 objfile
-> global_psymbols
.next
=
2330 objfile
-> global_psymbols
.list
= (struct partial_symbol
*)
2331 xmmalloc (objfile
-> md
, objfile
-> global_psymbols
.size
2332 * sizeof (struct partial_symbol
));
2333 objfile
-> static_psymbols
.next
=
2334 objfile
-> static_psymbols
.list
= (struct partial_symbol
*)
2335 xmmalloc (objfile
-> md
, objfile
-> static_psymbols
.size
2336 * sizeof (struct partial_symbol
));
2343 add_enum_psymbol -- add enumeration members to partial symbol table
2347 Given pointer to a DIE that is known to be for an enumeration,
2348 extract the symbolic names of the enumeration members and add
2349 partial symbols for them.
2353 add_enum_psymbol (dip
, objfile
)
2354 struct dieinfo
*dip
;
2355 struct objfile
*objfile
;
2359 unsigned short blocksz
;
2362 if ((scan
= dip
-> at_element_list
) != NULL
)
2364 if (dip
-> short_element_list
)
2366 nbytes
= attribute_size (AT_short_element_list
);
2370 nbytes
= attribute_size (AT_element_list
);
2372 blocksz
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, objfile
);
2374 listend
= scan
+ blocksz
;
2375 while (scan
< listend
)
2377 scan
+= TARGET_FT_LONG_SIZE (objfile
);
2378 ADD_PSYMBOL_TO_LIST (scan
, strlen (scan
), VAR_NAMESPACE
, LOC_CONST
,
2379 objfile
-> static_psymbols
, 0);
2380 scan
+= strlen (scan
) + 1;
2389 add_partial_symbol -- add symbol to partial symbol table
2393 Given a DIE, if it is one of the types that we want to
2394 add to a partial symbol table, finish filling in the die info
2395 and then add a partial symbol table entry for it.
2399 The caller must ensure that the DIE has a valid name attribute.
2403 add_partial_symbol (dip
, objfile
)
2404 struct dieinfo
*dip
;
2405 struct objfile
*objfile
;
2407 switch (dip
-> die_tag
)
2409 case TAG_global_subroutine
:
2410 record_minimal_symbol (dip
-> at_name
, dip
-> at_low_pc
, mst_text
,
2412 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2413 VAR_NAMESPACE
, LOC_BLOCK
,
2414 objfile
-> global_psymbols
,
2417 case TAG_global_variable
:
2418 record_minimal_symbol (dip
-> at_name
, locval (dip
-> at_location
),
2420 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2421 VAR_NAMESPACE
, LOC_STATIC
,
2422 objfile
-> global_psymbols
,
2425 case TAG_subroutine
:
2426 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2427 VAR_NAMESPACE
, LOC_BLOCK
,
2428 objfile
-> static_psymbols
,
2431 case TAG_local_variable
:
2432 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2433 VAR_NAMESPACE
, LOC_STATIC
,
2434 objfile
-> static_psymbols
,
2438 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2439 VAR_NAMESPACE
, LOC_TYPEDEF
,
2440 objfile
-> static_psymbols
,
2443 case TAG_class_type
:
2444 case TAG_structure_type
:
2445 case TAG_union_type
:
2446 case TAG_enumeration_type
:
2447 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2448 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2449 objfile
-> static_psymbols
,
2451 if (cu_language
== language_cplus
)
2453 /* For C++, these implicitly act as typedefs as well. */
2454 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2455 VAR_NAMESPACE
, LOC_TYPEDEF
,
2456 objfile
-> static_psymbols
,
2467 scan_partial_symbols -- scan DIE's within a single compilation unit
2471 Process the DIE's within a single compilation unit, looking for
2472 interesting DIE's that contribute to the partial symbol table entry
2473 for this compilation unit.
2477 There are some DIE's that may appear both at file scope and within
2478 the scope of a function. We are only interested in the ones at file
2479 scope, and the only way to tell them apart is to keep track of the
2480 scope. For example, consider the test case:
2485 for which the relevant DWARF segment has the structure:
2488 0x23 global subrtn sibling 0x9b
2490 fund_type FT_integer
2495 0x23 local var sibling 0x97
2497 fund_type FT_integer
2498 location OP_BASEREG 0xe
2505 0x1d local var sibling 0xb8
2507 fund_type FT_integer
2508 location OP_ADDR 0x800025dc
2513 We want to include the symbol 'i' in the partial symbol table, but
2514 not the symbol 'j'. In essence, we want to skip all the dies within
2515 the scope of a TAG_global_subroutine DIE.
2517 Don't attempt to add anonymous structures or unions since they have
2518 no name. Anonymous enumerations however are processed, because we
2519 want to extract their member names (the check for a tag name is
2522 Also, for variables and subroutines, check that this is the place
2523 where the actual definition occurs, rather than just a reference
2528 scan_partial_symbols (thisdie
, enddie
, objfile
)
2531 struct objfile
*objfile
;
2537 while (thisdie
< enddie
)
2539 basicdieinfo (&di
, thisdie
, objfile
);
2540 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
2546 nextdie
= thisdie
+ di
.die_length
;
2547 /* To avoid getting complete die information for every die, we
2548 only do it (below) for the cases we are interested in. */
2551 case TAG_global_subroutine
:
2552 case TAG_subroutine
:
2553 completedieinfo (&di
, objfile
);
2554 if (di
.at_name
&& (di
.has_at_low_pc
|| di
.at_location
))
2556 add_partial_symbol (&di
, objfile
);
2557 /* If there is a sibling attribute, adjust the nextdie
2558 pointer to skip the entire scope of the subroutine.
2559 Apply some sanity checking to make sure we don't
2560 overrun or underrun the range of remaining DIE's */
2561 if (di
.at_sibling
!= 0)
2563 temp
= dbbase
+ di
.at_sibling
- dbroff
;
2564 if ((temp
< thisdie
) || (temp
>= enddie
))
2566 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", di
.at_sibling
);
2575 case TAG_global_variable
:
2576 case TAG_local_variable
:
2577 completedieinfo (&di
, objfile
);
2578 if (di
.at_name
&& (di
.has_at_low_pc
|| di
.at_location
))
2580 add_partial_symbol (&di
, objfile
);
2584 case TAG_class_type
:
2585 case TAG_structure_type
:
2586 case TAG_union_type
:
2587 completedieinfo (&di
, objfile
);
2590 add_partial_symbol (&di
, objfile
);
2593 case TAG_enumeration_type
:
2594 completedieinfo (&di
, objfile
);
2597 add_partial_symbol (&di
, objfile
);
2599 add_enum_psymbol (&di
, objfile
);
2611 scan_compilation_units -- build a psymtab entry for each compilation
2615 This is the top level dwarf parsing routine for building partial
2618 It scans from the beginning of the DWARF table looking for the first
2619 TAG_compile_unit DIE, and then follows the sibling chain to locate
2620 each additional TAG_compile_unit DIE.
2622 For each TAG_compile_unit DIE it creates a partial symtab structure,
2623 calls a subordinate routine to collect all the compilation unit's
2624 global DIE's, file scope DIEs, typedef DIEs, etc, and then links the
2625 new partial symtab structure into the partial symbol table. It also
2626 records the appropriate information in the partial symbol table entry
2627 to allow the chunk of DIE's and line number table for this compilation
2628 unit to be located and re-read later, to generate a complete symbol
2629 table entry for the compilation unit.
2631 Thus it effectively partitions up a chunk of DIE's for multiple
2632 compilation units into smaller DIE chunks and line number tables,
2633 and associates them with a partial symbol table entry.
2637 If any compilation unit has no line number table associated with
2638 it for some reason (a missing at_stmt_list attribute, rather than
2639 just one with a value of zero, which is valid) then we ensure that
2640 the recorded file offset is zero so that the routine which later
2641 reads line number table fragments knows that there is no fragment
2651 scan_compilation_units (thisdie
, enddie
, dbfoff
, lnoffset
, objfile
)
2656 struct objfile
*objfile
;
2660 struct partial_symtab
*pst
;
2663 file_ptr curlnoffset
;
2665 while (thisdie
< enddie
)
2667 basicdieinfo (&di
, thisdie
, objfile
);
2668 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
2672 else if (di
.die_tag
!= TAG_compile_unit
)
2674 nextdie
= thisdie
+ di
.die_length
;
2678 completedieinfo (&di
, objfile
);
2679 set_cu_language (&di
);
2680 if (di
.at_sibling
!= 0)
2682 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
2686 nextdie
= thisdie
+ di
.die_length
;
2688 curoff
= thisdie
- dbbase
;
2689 culength
= nextdie
- thisdie
;
2690 curlnoffset
= di
.has_at_stmt_list
? lnoffset
+ di
.at_stmt_list
: 0;
2692 /* First allocate a new partial symbol table structure */
2694 pst
= start_psymtab_common (objfile
, base_section_offsets
,
2695 di
.at_name
, di
.at_low_pc
,
2696 objfile
-> global_psymbols
.next
,
2697 objfile
-> static_psymbols
.next
);
2699 pst
-> texthigh
= di
.at_high_pc
;
2700 pst
-> read_symtab_private
= (char *)
2701 obstack_alloc (&objfile
-> psymbol_obstack
,
2702 sizeof (struct dwfinfo
));
2703 DBFOFF (pst
) = dbfoff
;
2704 DBROFF (pst
) = curoff
;
2705 DBLENGTH (pst
) = culength
;
2706 LNFOFF (pst
) = curlnoffset
;
2707 pst
-> read_symtab
= dwarf_psymtab_to_symtab
;
2709 /* Now look for partial symbols */
2711 scan_partial_symbols (thisdie
+ di
.die_length
, nextdie
, objfile
);
2713 pst
-> n_global_syms
= objfile
-> global_psymbols
.next
-
2714 (objfile
-> global_psymbols
.list
+ pst
-> globals_offset
);
2715 pst
-> n_static_syms
= objfile
-> static_psymbols
.next
-
2716 (objfile
-> static_psymbols
.list
+ pst
-> statics_offset
);
2717 sort_pst_symbols (pst
);
2718 /* If there is already a psymtab or symtab for a file of this name,
2719 remove it. (If there is a symtab, more drastic things also
2720 happen.) This happens in VxWorks. */
2721 free_named_symtabs (pst
-> filename
);
2731 new_symbol -- make a symbol table entry for a new symbol
2735 static struct symbol *new_symbol (struct dieinfo *dip,
2736 struct objfile *objfile)
2740 Given a pointer to a DWARF information entry, figure out if we need
2741 to make a symbol table entry for it, and if so, create a new entry
2742 and return a pointer to it.
2745 static struct symbol
*
2746 new_symbol (dip
, objfile
)
2747 struct dieinfo
*dip
;
2748 struct objfile
*objfile
;
2750 struct symbol
*sym
= NULL
;
2752 if (dip
-> at_name
!= NULL
)
2754 sym
= (struct symbol
*) obstack_alloc (&objfile
-> symbol_obstack
,
2755 sizeof (struct symbol
));
2756 memset (sym
, 0, sizeof (struct symbol
));
2757 SYMBOL_NAME (sym
) = create_name (dip
-> at_name
,
2758 &objfile
->symbol_obstack
);
2759 /* default assumptions */
2760 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2761 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2762 SYMBOL_TYPE (sym
) = decode_die_type (dip
);
2763 switch (dip
-> die_tag
)
2766 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
;
2767 SYMBOL_CLASS (sym
) = LOC_LABEL
;
2769 case TAG_global_subroutine
:
2770 case TAG_subroutine
:
2771 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
;
2772 SYMBOL_TYPE (sym
) = lookup_function_type (SYMBOL_TYPE (sym
));
2773 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
2774 if (dip
-> die_tag
== TAG_global_subroutine
)
2776 add_symbol_to_list (sym
, &global_symbols
);
2780 add_symbol_to_list (sym
, list_in_scope
);
2783 case TAG_global_variable
:
2784 if (dip
-> at_location
!= NULL
)
2786 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2787 add_symbol_to_list (sym
, &global_symbols
);
2788 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2789 SYMBOL_VALUE (sym
) += baseaddr
;
2792 case TAG_local_variable
:
2793 if (dip
-> at_location
!= NULL
)
2795 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2796 add_symbol_to_list (sym
, list_in_scope
);
2799 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
2803 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
2807 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2808 SYMBOL_VALUE (sym
) += baseaddr
;
2812 case TAG_formal_parameter
:
2813 if (dip
-> at_location
!= NULL
)
2815 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2817 add_symbol_to_list (sym
, list_in_scope
);
2820 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
2824 SYMBOL_CLASS (sym
) = LOC_ARG
;
2827 case TAG_unspecified_parameters
:
2828 /* From varargs functions; gdb doesn't seem to have any interest in
2829 this information, so just ignore it for now. (FIXME?) */
2831 case TAG_class_type
:
2832 case TAG_structure_type
:
2833 case TAG_union_type
:
2834 case TAG_enumeration_type
:
2835 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2836 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
2837 add_symbol_to_list (sym
, list_in_scope
);
2840 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2841 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2842 add_symbol_to_list (sym
, list_in_scope
);
2845 /* Not a tag we recognize. Hopefully we aren't processing trash
2846 data, but since we must specifically ignore things we don't
2847 recognize, there is nothing else we should do at this point. */
2858 synthesize_typedef -- make a symbol table entry for a "fake" typedef
2862 static void synthesize_typedef (struct dieinfo *dip,
2863 struct objfile *objfile,
2868 Given a pointer to a DWARF information entry, synthesize a typedef
2869 for the name in the DIE, using the specified type.
2871 This is used for C++ class, structs, unions, and enumerations to
2872 set up the tag name as a type.
2877 synthesize_typedef (dip
, objfile
, type
)
2878 struct dieinfo
*dip
;
2879 struct objfile
*objfile
;
2882 struct symbol
*sym
= NULL
;
2884 if (dip
-> at_name
!= NULL
)
2886 sym
= (struct symbol
*)
2887 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
2888 memset (sym
, 0, sizeof (struct symbol
));
2889 SYMBOL_NAME (sym
) = create_name (dip
-> at_name
,
2890 &objfile
->symbol_obstack
);
2891 SYMBOL_TYPE (sym
) = type
;
2892 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2893 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2894 add_symbol_to_list (sym
, list_in_scope
);
2902 decode_mod_fund_type -- decode a modified fundamental type
2906 static struct type *decode_mod_fund_type (char *typedata)
2910 Decode a block of data containing a modified fundamental
2911 type specification. TYPEDATA is a pointer to the block,
2912 which starts with a length containing the size of the rest
2913 of the block. At the end of the block is a fundmental type
2914 code value that gives the fundamental type. Everything
2915 in between are type modifiers.
2917 We simply compute the number of modifiers and call the general
2918 function decode_modified_type to do the actual work.
2921 static struct type
*
2922 decode_mod_fund_type (typedata
)
2925 struct type
*typep
= NULL
;
2926 unsigned short modcount
;
2929 /* Get the total size of the block, exclusive of the size itself */
2931 nbytes
= attribute_size (AT_mod_fund_type
);
2932 modcount
= target_to_host (typedata
, nbytes
, GET_UNSIGNED
, current_objfile
);
2935 /* Deduct the size of the fundamental type bytes at the end of the block. */
2937 modcount
-= attribute_size (AT_fund_type
);
2939 /* Now do the actual decoding */
2941 typep
= decode_modified_type (typedata
, modcount
, AT_mod_fund_type
);
2949 decode_mod_u_d_type -- decode a modified user defined type
2953 static struct type *decode_mod_u_d_type (char *typedata)
2957 Decode a block of data containing a modified user defined
2958 type specification. TYPEDATA is a pointer to the block,
2959 which consists of a two byte length, containing the size
2960 of the rest of the block. At the end of the block is a
2961 four byte value that gives a reference to a user defined type.
2962 Everything in between are type modifiers.
2964 We simply compute the number of modifiers and call the general
2965 function decode_modified_type to do the actual work.
2968 static struct type
*
2969 decode_mod_u_d_type (typedata
)
2972 struct type
*typep
= NULL
;
2973 unsigned short modcount
;
2976 /* Get the total size of the block, exclusive of the size itself */
2978 nbytes
= attribute_size (AT_mod_u_d_type
);
2979 modcount
= target_to_host (typedata
, nbytes
, GET_UNSIGNED
, current_objfile
);
2982 /* Deduct the size of the reference type bytes at the end of the block. */
2984 modcount
-= attribute_size (AT_user_def_type
);
2986 /* Now do the actual decoding */
2988 typep
= decode_modified_type (typedata
, modcount
, AT_mod_u_d_type
);
2996 decode_modified_type -- decode modified user or fundamental type
3000 static struct type *decode_modified_type (char *modifiers,
3001 unsigned short modcount, int mtype)
3005 Decode a modified type, either a modified fundamental type or
3006 a modified user defined type. MODIFIERS is a pointer to the
3007 block of bytes that define MODCOUNT modifiers. Immediately
3008 following the last modifier is a short containing the fundamental
3009 type or a long containing the reference to the user defined
3010 type. Which one is determined by MTYPE, which is either
3011 AT_mod_fund_type or AT_mod_u_d_type to indicate what modified
3012 type we are generating.
3014 We call ourself recursively to generate each modified type,`
3015 until MODCOUNT reaches zero, at which point we have consumed
3016 all the modifiers and generate either the fundamental type or
3017 user defined type. When the recursion unwinds, each modifier
3018 is applied in turn to generate the full modified type.
3022 If we find a modifier that we don't recognize, and it is not one
3023 of those reserved for application specific use, then we issue a
3024 warning and simply ignore the modifier.
3028 We currently ignore MOD_const and MOD_volatile. (FIXME)
3032 static struct type
*
3033 decode_modified_type (modifiers
, modcount
, mtype
)
3035 unsigned int modcount
;
3038 struct type
*typep
= NULL
;
3039 unsigned short fundtype
;
3048 case AT_mod_fund_type
:
3049 nbytes
= attribute_size (AT_fund_type
);
3050 fundtype
= target_to_host (modifiers
, nbytes
, GET_UNSIGNED
,
3052 typep
= decode_fund_type (fundtype
);
3054 case AT_mod_u_d_type
:
3055 nbytes
= attribute_size (AT_user_def_type
);
3056 die_ref
= target_to_host (modifiers
, nbytes
, GET_UNSIGNED
,
3058 if ((typep
= lookup_utype (die_ref
)) == NULL
)
3060 typep
= alloc_utype (die_ref
, NULL
);
3064 SQUAWK (("botched modified type decoding (mtype 0x%x)", mtype
));
3065 typep
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
3071 modifier
= *modifiers
++;
3072 typep
= decode_modified_type (modifiers
, --modcount
, mtype
);
3075 case MOD_pointer_to
:
3076 typep
= lookup_pointer_type (typep
);
3078 case MOD_reference_to
:
3079 typep
= lookup_reference_type (typep
);
3082 SQUAWK (("type modifier 'const' ignored")); /* FIXME */
3085 SQUAWK (("type modifier 'volatile' ignored")); /* FIXME */
3088 if (!(MOD_lo_user
<= (unsigned char) modifier
3089 && (unsigned char) modifier
<= MOD_hi_user
))
3091 SQUAWK (("unknown type modifier %u",
3092 (unsigned char) modifier
));
3104 decode_fund_type -- translate basic DWARF type to gdb base type
3108 Given an integer that is one of the fundamental DWARF types,
3109 translate it to one of the basic internal gdb types and return
3110 a pointer to the appropriate gdb type (a "struct type *").
3114 If we encounter a fundamental type that we are unprepared to
3115 deal with, and it is not in the range of those types defined
3116 as application specific types, then we issue a warning and
3117 treat the type as an "int".
3120 static struct type
*
3121 decode_fund_type (fundtype
)
3122 unsigned int fundtype
;
3124 struct type
*typep
= NULL
;
3130 typep
= lookup_fundamental_type (current_objfile
, FT_VOID
);
3133 case FT_boolean
: /* Was FT_set in AT&T version */
3134 typep
= lookup_fundamental_type (current_objfile
, FT_BOOLEAN
);
3137 case FT_pointer
: /* (void *) */
3138 typep
= lookup_fundamental_type (current_objfile
, FT_VOID
);
3139 typep
= lookup_pointer_type (typep
);
3143 typep
= lookup_fundamental_type (current_objfile
, FT_CHAR
);
3146 case FT_signed_char
:
3147 typep
= lookup_fundamental_type (current_objfile
, FT_SIGNED_CHAR
);
3150 case FT_unsigned_char
:
3151 typep
= lookup_fundamental_type (current_objfile
, FT_UNSIGNED_CHAR
);
3155 typep
= lookup_fundamental_type (current_objfile
, FT_SHORT
);
3158 case FT_signed_short
:
3159 typep
= lookup_fundamental_type (current_objfile
, FT_SIGNED_SHORT
);
3162 case FT_unsigned_short
:
3163 typep
= lookup_fundamental_type (current_objfile
, FT_UNSIGNED_SHORT
);
3167 typep
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
3170 case FT_signed_integer
:
3171 typep
= lookup_fundamental_type (current_objfile
, FT_SIGNED_INTEGER
);
3174 case FT_unsigned_integer
:
3175 typep
= lookup_fundamental_type (current_objfile
, FT_UNSIGNED_INTEGER
);
3179 typep
= lookup_fundamental_type (current_objfile
, FT_LONG
);
3182 case FT_signed_long
:
3183 typep
= lookup_fundamental_type (current_objfile
, FT_SIGNED_LONG
);
3186 case FT_unsigned_long
:
3187 typep
= lookup_fundamental_type (current_objfile
, FT_UNSIGNED_LONG
);
3191 typep
= lookup_fundamental_type (current_objfile
, FT_LONG_LONG
);
3194 case FT_signed_long_long
:
3195 typep
= lookup_fundamental_type (current_objfile
, FT_SIGNED_LONG_LONG
);
3198 case FT_unsigned_long_long
:
3199 typep
= lookup_fundamental_type (current_objfile
, FT_UNSIGNED_LONG_LONG
);
3203 typep
= lookup_fundamental_type (current_objfile
, FT_FLOAT
);
3206 case FT_dbl_prec_float
:
3207 typep
= lookup_fundamental_type (current_objfile
, FT_DBL_PREC_FLOAT
);
3210 case FT_ext_prec_float
:
3211 typep
= lookup_fundamental_type (current_objfile
, FT_EXT_PREC_FLOAT
);
3215 typep
= lookup_fundamental_type (current_objfile
, FT_COMPLEX
);
3218 case FT_dbl_prec_complex
:
3219 typep
= lookup_fundamental_type (current_objfile
, FT_DBL_PREC_COMPLEX
);
3222 case FT_ext_prec_complex
:
3223 typep
= lookup_fundamental_type (current_objfile
, FT_EXT_PREC_COMPLEX
);
3228 if ((typep
== NULL
) && !(FT_lo_user
<= fundtype
&& fundtype
<= FT_hi_user
))
3230 SQUAWK (("unexpected fundamental type 0x%x", fundtype
));
3231 typep
= lookup_fundamental_type (current_objfile
, FT_VOID
);
3241 create_name -- allocate a fresh copy of a string on an obstack
3245 Given a pointer to a string and a pointer to an obstack, allocates
3246 a fresh copy of the string on the specified obstack.
3251 create_name (name
, obstackp
)
3253 struct obstack
*obstackp
;
3258 length
= strlen (name
) + 1;
3259 newname
= (char *) obstack_alloc (obstackp
, length
);
3260 strcpy (newname
, name
);
3268 basicdieinfo -- extract the minimal die info from raw die data
3272 void basicdieinfo (char *diep, struct dieinfo *dip,
3273 struct objfile *objfile)
3277 Given a pointer to raw DIE data, and a pointer to an instance of a
3278 die info structure, this function extracts the basic information
3279 from the DIE data required to continue processing this DIE, along
3280 with some bookkeeping information about the DIE.
3282 The information we absolutely must have includes the DIE tag,
3283 and the DIE length. If we need the sibling reference, then we
3284 will have to call completedieinfo() to process all the remaining
3287 Note that since there is no guarantee that the data is properly
3288 aligned in memory for the type of access required (indirection
3289 through anything other than a char pointer), and there is no
3290 guarantee that it is in the same byte order as the gdb host,
3291 we call a function which deals with both alignment and byte
3292 swapping issues. Possibly inefficient, but quite portable.
3294 We also take care of some other basic things at this point, such
3295 as ensuring that the instance of the die info structure starts
3296 out completely zero'd and that curdie is initialized for use
3297 in error reporting if we have a problem with the current die.
3301 All DIE's must have at least a valid length, thus the minimum
3302 DIE size is SIZEOF_DIE_LENGTH. In order to have a valid tag, the
3303 DIE size must be at least SIZEOF_DIE_TAG larger, otherwise they
3304 are forced to be TAG_padding DIES.
3306 Padding DIES must be at least SIZEOF_DIE_LENGTH in length, implying
3307 that if a padding DIE is used for alignment and the amount needed is
3308 less than SIZEOF_DIE_LENGTH, then the padding DIE has to be big
3309 enough to align to the next alignment boundry.
3311 We do some basic sanity checking here, such as verifying that the
3312 length of the die would not cause it to overrun the recorded end of
3313 the buffer holding the DIE info. If we find a DIE that is either
3314 too small or too large, we force it's length to zero which should
3315 cause the caller to take appropriate action.
3319 basicdieinfo (dip
, diep
, objfile
)
3320 struct dieinfo
*dip
;
3322 struct objfile
*objfile
;
3325 memset (dip
, 0, sizeof (struct dieinfo
));
3327 dip
-> die_ref
= dbroff
+ (diep
- dbbase
);
3328 dip
-> die_length
= target_to_host (diep
, SIZEOF_DIE_LENGTH
, GET_UNSIGNED
,
3330 if ((dip
-> die_length
< SIZEOF_DIE_LENGTH
) ||
3331 ((diep
+ dip
-> die_length
) > (dbbase
+ dbsize
)))
3333 dwarfwarn ("malformed DIE, bad length (%d bytes)", dip
-> die_length
);
3334 dip
-> die_length
= 0;
3336 else if (dip
-> die_length
< (SIZEOF_DIE_LENGTH
+ SIZEOF_DIE_TAG
))
3338 dip
-> die_tag
= TAG_padding
;
3342 diep
+= SIZEOF_DIE_LENGTH
;
3343 dip
-> die_tag
= target_to_host (diep
, SIZEOF_DIE_TAG
, GET_UNSIGNED
,
3352 completedieinfo -- finish reading the information for a given DIE
3356 void completedieinfo (struct dieinfo *dip, struct objfile *objfile)
3360 Given a pointer to an already partially initialized die info structure,
3361 scan the raw DIE data and finish filling in the die info structure
3362 from the various attributes found.
3364 Note that since there is no guarantee that the data is properly
3365 aligned in memory for the type of access required (indirection
3366 through anything other than a char pointer), and there is no
3367 guarantee that it is in the same byte order as the gdb host,
3368 we call a function which deals with both alignment and byte
3369 swapping issues. Possibly inefficient, but quite portable.
3373 Each time we are called, we increment the diecount variable, which
3374 keeps an approximate count of the number of dies processed for
3375 each compilation unit. This information is presented to the user
3376 if the info_verbose flag is set.
3381 completedieinfo (dip
, objfile
)
3382 struct dieinfo
*dip
;
3383 struct objfile
*objfile
;
3385 char *diep
; /* Current pointer into raw DIE data */
3386 char *end
; /* Terminate DIE scan here */
3387 unsigned short attr
; /* Current attribute being scanned */
3388 unsigned short form
; /* Form of the attribute */
3389 int nbytes
; /* Size of next field to read */
3393 end
= diep
+ dip
-> die_length
;
3394 diep
+= SIZEOF_DIE_LENGTH
+ SIZEOF_DIE_TAG
;
3397 attr
= target_to_host (diep
, SIZEOF_ATTRIBUTE
, GET_UNSIGNED
, objfile
);
3398 diep
+= SIZEOF_ATTRIBUTE
;
3399 if ((nbytes
= attribute_size (attr
)) == -1)
3401 SQUAWK (("unknown attribute length, skipped remaining attributes"));;
3408 dip
-> at_fund_type
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3412 dip
-> at_ordering
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3416 dip
-> at_bit_offset
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3420 dip
-> at_sibling
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3424 dip
-> at_stmt_list
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3426 dip
-> has_at_stmt_list
= 1;
3429 dip
-> at_low_pc
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3431 dip
-> at_low_pc
+= baseaddr
;
3432 dip
-> has_at_low_pc
= 1;
3435 dip
-> at_high_pc
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3437 dip
-> at_high_pc
+= baseaddr
;
3440 dip
-> at_language
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3443 case AT_user_def_type
:
3444 dip
-> at_user_def_type
= target_to_host (diep
, nbytes
,
3445 GET_UNSIGNED
, objfile
);
3448 dip
-> at_byte_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3450 dip
-> has_at_byte_size
= 1;
3453 dip
-> at_bit_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3457 dip
-> at_member
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3461 dip
-> at_discr
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3465 dip
-> at_location
= diep
;
3467 case AT_mod_fund_type
:
3468 dip
-> at_mod_fund_type
= diep
;
3470 case AT_subscr_data
:
3471 dip
-> at_subscr_data
= diep
;
3473 case AT_mod_u_d_type
:
3474 dip
-> at_mod_u_d_type
= diep
;
3476 case AT_element_list
:
3477 dip
-> at_element_list
= diep
;
3478 dip
-> short_element_list
= 0;
3480 case AT_short_element_list
:
3481 dip
-> at_element_list
= diep
;
3482 dip
-> short_element_list
= 1;
3484 case AT_discr_value
:
3485 dip
-> at_discr_value
= diep
;
3487 case AT_string_length
:
3488 dip
-> at_string_length
= diep
;
3491 dip
-> at_name
= diep
;
3494 /* For now, ignore any "hostname:" portion, since gdb doesn't
3495 know how to deal with it. (FIXME). */
3496 dip
-> at_comp_dir
= strrchr (diep
, ':');
3497 if (dip
-> at_comp_dir
!= NULL
)
3499 dip
-> at_comp_dir
++;
3503 dip
-> at_comp_dir
= diep
;
3507 dip
-> at_producer
= diep
;
3509 case AT_start_scope
:
3510 dip
-> at_start_scope
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3513 case AT_stride_size
:
3514 dip
-> at_stride_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3518 dip
-> at_src_info
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3522 dip
-> at_prototyped
= diep
;
3525 /* Found an attribute that we are unprepared to handle. However
3526 it is specifically one of the design goals of DWARF that
3527 consumers should ignore unknown attributes. As long as the
3528 form is one that we recognize (so we know how to skip it),
3529 we can just ignore the unknown attribute. */
3532 form
= FORM_FROM_ATTR (attr
);
3546 diep
+= TARGET_FT_POINTER_SIZE (objfile
);
3549 diep
+= 2 + target_to_host (diep
, nbytes
, GET_UNSIGNED
, objfile
);
3552 diep
+= 4 + target_to_host (diep
, nbytes
, GET_UNSIGNED
, objfile
);
3555 diep
+= strlen (diep
) + 1;
3558 SQUAWK (("unknown attribute form (0x%x)", form
));
3559 SQUAWK (("unknown attribute length, skipped remaining attributes"));;
3570 target_to_host -- swap in target data to host
3574 target_to_host (char *from, int nbytes, int signextend,
3575 struct objfile *objfile)
3579 Given pointer to data in target format in FROM, a byte count for
3580 the size of the data in NBYTES, a flag indicating whether or not
3581 the data is signed in SIGNEXTEND, and a pointer to the current
3582 objfile in OBJFILE, convert the data to host format and return
3583 the converted value.
3587 FIXME: If we read data that is known to be signed, and expect to
3588 use it as signed data, then we need to explicitly sign extend the
3589 result until the bfd library is able to do this for us.
3593 static unsigned long
3594 target_to_host (from
, nbytes
, signextend
, objfile
)
3597 int signextend
; /* FIXME: Unused */
3598 struct objfile
*objfile
;
3600 unsigned long rtnval
;
3605 rtnval
= bfd_get_64 (objfile
-> obfd
, (bfd_byte
*) from
);
3608 rtnval
= bfd_get_32 (objfile
-> obfd
, (bfd_byte
*) from
);
3611 rtnval
= bfd_get_16 (objfile
-> obfd
, (bfd_byte
*) from
);
3614 rtnval
= bfd_get_8 (objfile
-> obfd
, (bfd_byte
*) from
);
3617 dwarfwarn ("no bfd support for %d byte data object", nbytes
);
3628 attribute_size -- compute size of data for a DWARF attribute
3632 static int attribute_size (unsigned int attr)
3636 Given a DWARF attribute in ATTR, compute the size of the first
3637 piece of data associated with this attribute and return that
3640 Returns -1 for unrecognized attributes.
3645 attribute_size (attr
)
3648 int nbytes
; /* Size of next data for this attribute */
3649 unsigned short form
; /* Form of the attribute */
3651 form
= FORM_FROM_ATTR (attr
);
3654 case FORM_STRING
: /* A variable length field is next */
3657 case FORM_DATA2
: /* Next 2 byte field is the data itself */
3658 case FORM_BLOCK2
: /* Next 2 byte field is a block length */
3661 case FORM_DATA4
: /* Next 4 byte field is the data itself */
3662 case FORM_BLOCK4
: /* Next 4 byte field is a block length */
3663 case FORM_REF
: /* Next 4 byte field is a DIE offset */
3666 case FORM_DATA8
: /* Next 8 byte field is the data itself */
3669 case FORM_ADDR
: /* Next field size is target sizeof(void *) */
3670 nbytes
= TARGET_FT_POINTER_SIZE (objfile
);
3673 SQUAWK (("unknown attribute form (0x%x)", form
));