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 /* start-sanitize-chill */
96 #ifndef CHILL_PRODUCER
97 #define CHILL_PRODUCER "GNU Chill "
99 /* end-sanitize-chill */
101 #define STREQ(a,b) (strcmp(a,b)==0)
102 #define STREQN(a,b,n) (strncmp(a,b,n)==0)
104 /* Flags to target_to_host() that tell whether or not the data object is
105 expected to be signed. Used, for example, when fetching a signed
106 integer in the target environment which is used as a signed integer
107 in the host environment, and the two environments have different sized
108 ints. In this case, *somebody* has to sign extend the smaller sized
111 #define GET_UNSIGNED 0 /* No sign extension required */
112 #define GET_SIGNED 1 /* Sign extension required */
114 /* Defines for things which are specified in the document "DWARF Debugging
115 Information Format" published by UNIX International, Programming Languages
116 SIG. These defines are based on revision 1.0.0, Jan 20, 1992. */
118 #define SIZEOF_DIE_LENGTH 4
119 #define SIZEOF_DIE_TAG 2
120 #define SIZEOF_ATTRIBUTE 2
121 #define SIZEOF_FORMAT_SPECIFIER 1
122 #define SIZEOF_FMT_FT 2
123 #define SIZEOF_LINETBL_LENGTH 4
124 #define SIZEOF_LINETBL_LINENO 4
125 #define SIZEOF_LINETBL_STMT 2
126 #define SIZEOF_LINETBL_DELTA 4
127 #define SIZEOF_LOC_ATOM_CODE 1
129 #define FORM_FROM_ATTR(attr) ((attr) & 0xF) /* Implicitly specified */
131 /* Macros that return the sizes of various types of data in the target
134 FIXME: Currently these are just compile time constants (as they are in
135 other parts of gdb as well). They need to be able to get the right size
136 either from the bfd or possibly from the DWARF info. It would be nice if
137 the DWARF producer inserted DIES that describe the fundamental types in
138 the target environment into the DWARF info, similar to the way dbx stabs
139 producers produce information about their fundamental types. */
141 #define TARGET_FT_POINTER_SIZE(objfile) (TARGET_PTR_BIT / TARGET_CHAR_BIT)
142 #define TARGET_FT_LONG_SIZE(objfile) (TARGET_LONG_BIT / TARGET_CHAR_BIT)
144 /* The Amiga SVR4 header file <dwarf.h> defines AT_element_list as a
145 FORM_BLOCK2, and this is the value emitted by the AT&T compiler.
146 However, the Issue 2 DWARF specification from AT&T defines it as
147 a FORM_BLOCK4, as does the latest specification from UI/PLSIG.
148 For backwards compatibility with the AT&T compiler produced executables
149 we define AT_short_element_list for this variant. */
151 #define AT_short_element_list (0x00f0|FORM_BLOCK2)
153 /* External variables referenced. */
155 extern int info_verbose
; /* From main.c; nonzero => verbose */
156 extern char *warning_pre_print
; /* From utils.c */
158 /* The DWARF debugging information consists of two major pieces,
159 one is a block of DWARF Information Entries (DIE's) and the other
160 is a line number table. The "struct dieinfo" structure contains
161 the information for a single DIE, the one currently being processed.
163 In order to make it easier to randomly access the attribute fields
164 of the current DIE, which are specifically unordered within the DIE,
165 each DIE is scanned and an instance of the "struct dieinfo"
166 structure is initialized.
168 Initialization is done in two levels. The first, done by basicdieinfo(),
169 just initializes those fields that are vital to deciding whether or not
170 to use this DIE, how to skip past it, etc. The second, done by the
171 function completedieinfo(), fills in the rest of the information.
173 Attributes which have block forms are not interpreted at the time
174 the DIE is scanned, instead we just save pointers to the start
175 of their value fields.
177 Some fields have a flag <name>_p that is set when the value of the
178 field is valid (I.E. we found a matching attribute in the DIE). Since
179 we may want to test for the presence of some attributes in the DIE,
180 such as AT_low_pc, without restricting the values of the field,
181 we need someway to note that we found such an attribute.
188 char * die
; /* Pointer to the raw DIE data */
189 unsigned long die_length
; /* Length of the raw DIE data */
190 DIE_REF die_ref
; /* Offset of this DIE */
191 unsigned short die_tag
; /* Tag for this DIE */
192 unsigned long at_padding
;
193 unsigned long at_sibling
;
196 unsigned short at_fund_type
;
197 BLOCK
* at_mod_fund_type
;
198 unsigned long at_user_def_type
;
199 BLOCK
* at_mod_u_d_type
;
200 unsigned short at_ordering
;
201 BLOCK
* at_subscr_data
;
202 unsigned long at_byte_size
;
203 unsigned short at_bit_offset
;
204 unsigned long at_bit_size
;
205 BLOCK
* at_element_list
;
206 unsigned long at_stmt_list
;
207 unsigned long at_low_pc
;
208 unsigned long at_high_pc
;
209 unsigned long at_language
;
210 unsigned long at_member
;
211 unsigned long at_discr
;
212 BLOCK
* at_discr_value
;
213 BLOCK
* at_string_length
;
216 unsigned long at_start_scope
;
217 unsigned long at_stride_size
;
218 unsigned long at_src_info
;
219 char * at_prototyped
;
220 unsigned int has_at_low_pc
:1;
221 unsigned int has_at_stmt_list
:1;
222 unsigned int has_at_byte_size
:1;
223 unsigned int short_element_list
:1;
226 static int diecount
; /* Approximate count of dies for compilation unit */
227 static struct dieinfo
*curdie
; /* For warnings and such */
229 static char *dbbase
; /* Base pointer to dwarf info */
230 static int dbsize
; /* Size of dwarf info in bytes */
231 static int dbroff
; /* Relative offset from start of .debug section */
232 static char *lnbase
; /* Base pointer to line section */
233 static int isreg
; /* Kludge to identify register variables */
234 static int offreg
; /* Kludge to identify basereg references */
236 /* This value is added to each symbol value. FIXME: Generalize to
237 the section_offsets structure used by dbxread. */
238 static CORE_ADDR baseaddr
; /* Add to each symbol value */
240 /* The section offsets used in the current psymtab or symtab. FIXME,
241 only used to pass one value (baseaddr) at the moment. */
242 static struct section_offsets
*base_section_offsets
;
244 /* Each partial symbol table entry contains a pointer to private data for the
245 read_symtab() function to use when expanding a partial symbol table entry
246 to a full symbol table entry. For DWARF debugging info, this data is
247 contained in the following structure and macros are provided for easy
248 access to the members given a pointer to a partial symbol table entry.
250 dbfoff Always the absolute file offset to the start of the ".debug"
251 section for the file containing the DIE's being accessed.
253 dbroff Relative offset from the start of the ".debug" access to the
254 first DIE to be accessed. When building the partial symbol
255 table, this value will be zero since we are accessing the
256 entire ".debug" section. When expanding a partial symbol
257 table entry, this value will be the offset to the first
258 DIE for the compilation unit containing the symbol that
259 triggers the expansion.
261 dblength The size of the chunk of DIE's being examined, in bytes.
263 lnfoff The absolute file offset to the line table fragment. Ignored
264 when building partial symbol tables, but used when expanding
265 them, and contains the absolute file offset to the fragment
266 of the ".line" section containing the line numbers for the
267 current compilation unit.
271 file_ptr dbfoff
; /* Absolute file offset to start of .debug section */
272 int dbroff
; /* Relative offset from start of .debug section */
273 int dblength
; /* Size of the chunk of DIE's being examined */
274 file_ptr lnfoff
; /* Absolute file offset to line table fragment */
277 #define DBFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbfoff)
278 #define DBROFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbroff)
279 #define DBLENGTH(p) (((struct dwfinfo *)((p)->read_symtab_private))->dblength)
280 #define LNFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->lnfoff)
282 /* The generic symbol table building routines have separate lists for
283 file scope symbols and all all other scopes (local scopes). So
284 we need to select the right one to pass to add_symbol_to_list().
285 We do it by keeping a pointer to the correct list in list_in_scope.
287 FIXME: The original dwarf code just treated the file scope as the first
288 local scope, and all other local scopes as nested local scopes, and worked
289 fine. Check to see if we really need to distinguish these in buildsym.c */
291 struct pending
**list_in_scope
= &file_symbols
;
293 /* DIES which have user defined types or modified user defined types refer to
294 other DIES for the type information. Thus we need to associate the offset
295 of a DIE for a user defined type with a pointer to the type information.
297 Originally this was done using a simple but expensive algorithm, with an
298 array of unsorted structures, each containing an offset/type-pointer pair.
299 This array was scanned linearly each time a lookup was done. The result
300 was that gdb was spending over half it's startup time munging through this
301 array of pointers looking for a structure that had the right offset member.
303 The second attempt used the same array of structures, but the array was
304 sorted using qsort each time a new offset/type was recorded, and a binary
305 search was used to find the type pointer for a given DIE offset. This was
306 even slower, due to the overhead of sorting the array each time a new
307 offset/type pair was entered.
309 The third attempt uses a fixed size array of type pointers, indexed by a
310 value derived from the DIE offset. Since the minimum DIE size is 4 bytes,
311 we can divide any DIE offset by 4 to obtain a unique index into this fixed
312 size array. Since each element is a 4 byte pointer, it takes exactly as
313 much memory to hold this array as to hold the DWARF info for a given
314 compilation unit. But it gets freed as soon as we are done with it. */
316 static struct type
**utypes
; /* Pointer to array of user type pointers */
317 static int numutypes
; /* Max number of user type pointers */
319 /* Record the language for the compilation unit which is currently being
320 processed. We know it once we have seen the TAG_compile_unit DIE,
321 and we need it while processing the DIE's for that compilation unit.
322 It is eventually saved in the symtab structure, but we don't finalize
323 the symtab struct until we have processed all the DIE's for the
326 static enum language cu_language
;
328 /* Forward declarations of static functions so we don't have to worry
329 about ordering within this file. */
332 attribute_size
PARAMS ((unsigned int));
335 target_to_host
PARAMS ((char *, int, int, struct objfile
*));
338 add_enum_psymbol
PARAMS ((struct dieinfo
*, struct objfile
*));
341 handle_producer
PARAMS ((char *));
344 read_file_scope
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
347 read_func_scope
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
350 read_lexical_block_scope
PARAMS ((struct dieinfo
*, char *, char *,
357 scan_partial_symbols
PARAMS ((char *, char *, struct objfile
*));
360 scan_compilation_units
PARAMS ((char *, char *, file_ptr
,
361 file_ptr
, struct objfile
*));
364 add_partial_symbol
PARAMS ((struct dieinfo
*, struct objfile
*));
367 init_psymbol_list
PARAMS ((struct objfile
*, int));
370 basicdieinfo
PARAMS ((struct dieinfo
*, char *, struct objfile
*));
373 completedieinfo
PARAMS ((struct dieinfo
*, struct objfile
*));
376 dwarf_psymtab_to_symtab
PARAMS ((struct partial_symtab
*));
379 psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*));
381 static struct symtab
*
382 read_ofile_symtab
PARAMS ((struct partial_symtab
*));
385 process_dies
PARAMS ((char *, char *, struct objfile
*));
388 read_structure_scope
PARAMS ((struct dieinfo
*, char *, char *,
392 decode_array_element_type
PARAMS ((char *));
395 decode_subscr_data
PARAMS ((char *, char *));
398 dwarf_read_array_type
PARAMS ((struct dieinfo
*));
401 read_tag_pointer_type
PARAMS ((struct dieinfo
*dip
));
404 read_subroutine_type
PARAMS ((struct dieinfo
*, char *, char *));
407 read_enumeration
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
410 struct_type
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
413 enum_type
PARAMS ((struct dieinfo
*, struct objfile
*));
416 decode_line_numbers
PARAMS ((char *));
419 decode_die_type
PARAMS ((struct dieinfo
*));
422 decode_mod_fund_type
PARAMS ((char *));
425 decode_mod_u_d_type
PARAMS ((char *));
428 decode_modified_type
PARAMS ((char *, unsigned int, int));
431 decode_fund_type
PARAMS ((unsigned int));
434 create_name
PARAMS ((char *, struct obstack
*));
437 lookup_utype
PARAMS ((DIE_REF
));
440 alloc_utype
PARAMS ((DIE_REF
, struct type
*));
442 static struct symbol
*
443 new_symbol
PARAMS ((struct dieinfo
*, struct objfile
*));
446 synthesize_typedef
PARAMS ((struct dieinfo
*, struct objfile
*,
450 locval
PARAMS ((char *));
453 record_minimal_symbol
PARAMS ((char *, CORE_ADDR
, enum minimal_symbol_type
,
457 set_cu_language
PARAMS ((struct dieinfo
*));
463 set_cu_language -- set local copy of language for compilation unit
468 set_cu_language (struct dieinfo *dip)
472 Decode the language attribute for a compilation unit DIE and
473 remember what the language was. We use this at various times
474 when processing DIE's for a given compilation unit.
483 set_cu_language (dip
)
486 switch (dip
-> at_language
)
490 cu_language
= language_c
;
492 case LANG_C_PLUS_PLUS
:
493 cu_language
= language_cplus
;
495 /* start-sanitize-chill */
497 cu_language
= language_chill
;
499 /* end-sanitize-chill */
501 cu_language
= language_m2
;
510 cu_language
= language_unknown
;
519 dwarf_build_psymtabs -- build partial symtabs from DWARF debug info
523 void dwarf_build_psymtabs (struct objfile *objfile,
524 struct section_offsets *section_offsets,
525 int mainline, file_ptr dbfoff, unsigned int dbfsize,
526 file_ptr lnoffset, unsigned int lnsize)
530 This function is called upon to build partial symtabs from files
531 containing DIE's (Dwarf Information Entries) and DWARF line numbers.
533 It is passed a bfd* containing the DIES
534 and line number information, the corresponding filename for that
535 file, a base address for relocating the symbols, a flag indicating
536 whether or not this debugging information is from a "main symbol
537 table" rather than a shared library or dynamically linked file,
538 and file offset/size pairs for the DIE information and line number
548 dwarf_build_psymtabs (objfile
, section_offsets
, mainline
, dbfoff
, dbfsize
,
550 struct objfile
*objfile
;
551 struct section_offsets
*section_offsets
;
554 unsigned int dbfsize
;
558 bfd
*abfd
= objfile
->obfd
;
559 struct cleanup
*back_to
;
561 current_objfile
= objfile
;
563 dbbase
= xmalloc (dbsize
);
565 if ((bfd_seek (abfd
, dbfoff
, L_SET
) != 0) ||
566 (bfd_read (dbbase
, dbsize
, 1, abfd
) != dbsize
))
569 error ("can't read DWARF data from '%s'", bfd_get_filename (abfd
));
571 back_to
= make_cleanup (free
, dbbase
);
573 /* If we are reinitializing, or if we have never loaded syms yet, init.
574 Since we have no idea how many DIES we are looking at, we just guess
575 some arbitrary value. */
577 if (mainline
|| objfile
-> global_psymbols
.size
== 0 ||
578 objfile
-> static_psymbols
.size
== 0)
580 init_psymbol_list (objfile
, 1024);
583 /* Save the relocation factor where everybody can see it. */
585 base_section_offsets
= section_offsets
;
586 baseaddr
= ANOFFSET (section_offsets
, 0);
588 /* Follow the compilation unit sibling chain, building a partial symbol
589 table entry for each one. Save enough information about each compilation
590 unit to locate the full DWARF information later. */
592 scan_compilation_units (dbbase
, dbbase
+ dbsize
, dbfoff
, lnoffset
, objfile
);
594 do_cleanups (back_to
);
595 current_objfile
= NULL
;
603 record_minimal_symbol -- add entry to gdb's minimal symbol table
607 static void record_minimal_symbol (char *name, CORE_ADDR address,
608 enum minimal_symbol_type ms_type,
609 struct objfile *objfile)
613 Given a pointer to the name of a symbol that should be added to the
614 minimal symbol table, and the address associated with that
615 symbol, records this information for later use in building the
616 minimal symbol table.
621 record_minimal_symbol (name
, address
, ms_type
, objfile
)
624 enum minimal_symbol_type ms_type
;
625 struct objfile
*objfile
;
627 name
= obsavestring (name
, strlen (name
), &objfile
-> symbol_obstack
);
628 prim_record_minimal_symbol (name
, address
, ms_type
);
635 dwarfwarn -- issue a DWARF related warning
639 Issue warnings about DWARF related things that aren't serious enough
640 to warrant aborting with an error, but should not be ignored either.
641 This includes things like detectable corruption in DIE's, missing
642 DIE's, unimplemented features, etc.
644 In general, running across tags or attributes that we don't recognize
645 is not considered to be a problem and we should not issue warnings
650 We mostly follow the example of the error() routine, but without
651 returning to command level. It is arguable about whether warnings
652 should be issued at all, and if so, where they should go (stdout or
655 We assume that curdie is valid and contains at least the basic
656 information for the DIE where the problem was noticed.
667 fmt
= va_arg (ap
, char *);
669 fprintf (stderr
, "warning: DWARF ref 0x%x: ", curdie
-> die_ref
);
670 if (curdie
-> at_name
)
672 fprintf (stderr
, "'%s': ", curdie
-> at_name
);
674 vfprintf (stderr
, fmt
, ap
);
675 fprintf (stderr
, "\n");
684 read_lexical_block_scope -- process all dies in a lexical block
688 static void read_lexical_block_scope (struct dieinfo *dip,
689 char *thisdie, char *enddie)
693 Process all the DIES contained within a lexical block scope.
694 Start a new scope, process the dies, and then close the scope.
699 read_lexical_block_scope (dip
, thisdie
, enddie
, objfile
)
703 struct objfile
*objfile
;
705 register struct context_stack
*new;
707 push_context (0, dip
-> at_low_pc
);
708 process_dies (thisdie
+ dip
-> die_length
, enddie
, objfile
);
709 new = pop_context ();
710 if (local_symbols
!= NULL
)
712 finish_block (0, &local_symbols
, new -> old_blocks
, new -> start_addr
,
713 dip
-> at_high_pc
, objfile
);
715 local_symbols
= new -> locals
;
722 lookup_utype -- look up a user defined type from die reference
726 static type *lookup_utype (DIE_REF die_ref)
730 Given a DIE reference, lookup the user defined type associated with
731 that DIE, if it has been registered already. If not registered, then
732 return NULL. Alloc_utype() can be called to register an empty
733 type for this reference, which will be filled in later when the
734 actual referenced DIE is processed.
738 lookup_utype (die_ref
)
741 struct type
*type
= NULL
;
744 utypeidx
= (die_ref
- dbroff
) / 4;
745 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
747 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", die_ref
);
751 type
= *(utypes
+ utypeidx
);
761 alloc_utype -- add a user defined type for die reference
765 static type *alloc_utype (DIE_REF die_ref, struct type *utypep)
769 Given a die reference DIE_REF, and a possible pointer to a user
770 defined type UTYPEP, register that this reference has a user
771 defined type and either use the specified type in UTYPEP or
772 make a new empty type that will be filled in later.
774 We should only be called after calling lookup_utype() to verify that
775 there is not currently a type registered for DIE_REF.
779 alloc_utype (die_ref
, utypep
)
786 utypeidx
= (die_ref
- dbroff
) / 4;
787 typep
= utypes
+ utypeidx
;
788 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
790 utypep
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
791 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", die_ref
);
793 else if (*typep
!= NULL
)
796 SQUAWK (("internal error: dup user type allocation"));
802 utypep
= alloc_type (current_objfile
);
813 decode_die_type -- return a type for a specified die
817 static struct type *decode_die_type (struct dieinfo *dip)
821 Given a pointer to a die information structure DIP, decode the
822 type of the die and return a pointer to the decoded type. All
823 dies without specific types default to type int.
827 decode_die_type (dip
)
830 struct type
*type
= NULL
;
832 if (dip
-> at_fund_type
!= 0)
834 type
= decode_fund_type (dip
-> at_fund_type
);
836 else if (dip
-> at_mod_fund_type
!= NULL
)
838 type
= decode_mod_fund_type (dip
-> at_mod_fund_type
);
840 else if (dip
-> at_user_def_type
)
842 if ((type
= lookup_utype (dip
-> at_user_def_type
)) == NULL
)
844 type
= alloc_utype (dip
-> at_user_def_type
, NULL
);
847 else if (dip
-> at_mod_u_d_type
)
849 type
= decode_mod_u_d_type (dip
-> at_mod_u_d_type
);
853 type
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
862 struct_type -- compute and return the type for a struct or union
866 static struct type *struct_type (struct dieinfo *dip, char *thisdie,
867 char *enddie, struct objfile *objfile)
871 Given pointer to a die information structure for a die which
872 defines a union or structure (and MUST define one or the other),
873 and pointers to the raw die data that define the range of dies which
874 define the members, compute and return the user defined type for the
879 struct_type (dip
, thisdie
, enddie
, objfile
)
883 struct objfile
*objfile
;
887 struct nextfield
*next
;
890 struct nextfield
*list
= NULL
;
891 struct nextfield
*new;
899 if ((type
= lookup_utype (dip
-> die_ref
)) == NULL
)
901 /* No forward references created an empty type, so install one now */
902 type
= alloc_utype (dip
-> die_ref
, NULL
);
904 INIT_CPLUS_SPECIFIC(type
);
905 switch (dip
-> die_tag
)
908 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
911 case TAG_structure_type
:
912 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
916 TYPE_CODE (type
) = TYPE_CODE_UNION
;
920 /* Should never happen */
921 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
923 SQUAWK (("missing class, structure, or union tag"));
926 /* Some compilers try to be helpful by inventing "fake" names for
927 anonymous enums, structures, and unions, like "~0fake" or ".0fake".
928 Thanks, but no thanks... */
929 if (dip
-> at_name
!= NULL
930 && *dip
-> at_name
!= '~'
931 && *dip
-> at_name
!= '.')
933 TYPE_NAME (type
) = obconcat (&objfile
-> type_obstack
,
934 tpart1
, " ", dip
-> at_name
);
936 /* Use whatever size is known. Zero is a valid size. We might however
937 wish to check has_at_byte_size to make sure that some byte size was
938 given explicitly, but DWARF doesn't specify that explicit sizes of
939 zero have to present, so complaining about missing sizes should
940 probably not be the default. */
941 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
942 thisdie
+= dip
-> die_length
;
943 while (thisdie
< enddie
)
945 basicdieinfo (&mbr
, thisdie
, objfile
);
946 completedieinfo (&mbr
, objfile
);
947 if (mbr
.die_length
<= SIZEOF_DIE_LENGTH
)
951 else if (mbr
.at_sibling
!= 0)
953 nextdie
= dbbase
+ mbr
.at_sibling
- dbroff
;
957 nextdie
= thisdie
+ mbr
.die_length
;
962 /* Get space to record the next field's data. */
963 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
968 obsavestring (mbr
.at_name
, strlen (mbr
.at_name
),
969 &objfile
-> type_obstack
);
970 list
-> field
.type
= decode_die_type (&mbr
);
971 list
-> field
.bitpos
= 8 * locval (mbr
.at_location
);
972 /* Handle bit fields. */
973 list
-> field
.bitsize
= mbr
.at_bit_size
;
975 /* For big endian bits, the at_bit_offset gives the additional
976 bit offset from the MSB of the containing anonymous object to
977 the MSB of the field. We don't have to do anything special
978 since we don't need to know the size of the anonymous object. */
979 list
-> field
.bitpos
+= mbr
.at_bit_offset
;
981 /* For little endian bits, we need to have a non-zero at_bit_size,
982 so that we know we are in fact dealing with a bitfield. Compute
983 the bit offset to the MSB of the anonymous object, subtract off
984 the number of bits from the MSB of the field to the MSB of the
985 object, and then subtract off the number of bits of the field
986 itself. The result is the bit offset of the LSB of the field. */
987 if (mbr
.at_bit_size
> 0)
989 if (mbr
.has_at_byte_size
)
991 /* The size of the anonymous object containing the bit field
992 is explicit, so use the indicated size (in bytes). */
993 anonymous_size
= mbr
.at_byte_size
;
997 /* The size of the anonymous object containing the bit field
998 matches the size of an object of the bit field's type.
999 DWARF allows at_byte_size to be left out in such cases,
1000 as a debug information size optimization. */
1001 anonymous_size
= TYPE_LENGTH (list
-> field
.type
);
1003 list
-> field
.bitpos
+=
1004 anonymous_size
* 8 - mbr
.at_bit_offset
- mbr
.at_bit_size
;
1010 process_dies (thisdie
, nextdie
, objfile
);
1015 /* Now create the vector of fields, and record how big it is. We may
1016 not even have any fields, if this DIE was generated due to a reference
1017 to an anonymous structure or union. In this case, TYPE_FLAG_STUB is
1018 set, which clues gdb in to the fact that it needs to search elsewhere
1019 for the full structure definition. */
1022 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
1026 TYPE_NFIELDS (type
) = nfields
;
1027 TYPE_FIELDS (type
) = (struct field
*)
1028 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
1029 /* Copy the saved-up fields into the field vector. */
1030 for (n
= nfields
; list
; list
= list
-> next
)
1032 TYPE_FIELD (type
, --n
) = list
-> field
;
1042 read_structure_scope -- process all dies within struct or union
1046 static void read_structure_scope (struct dieinfo *dip,
1047 char *thisdie, char *enddie, struct objfile *objfile)
1051 Called when we find the DIE that starts a structure or union
1052 scope (definition) to process all dies that define the members
1053 of the structure or union. DIP is a pointer to the die info
1054 struct for the DIE that names the structure or union.
1058 Note that we need to call struct_type regardless of whether or not
1059 the DIE has an at_name attribute, since it might be an anonymous
1060 structure or union. This gets the type entered into our set of
1063 However, if the structure is incomplete (an opaque struct/union)
1064 then suppress creating a symbol table entry for it since gdb only
1065 wants to find the one with the complete definition. Note that if
1066 it is complete, we just call new_symbol, which does it's own
1067 checking about whether the struct/union is anonymous or not (and
1068 suppresses creating a symbol table entry itself).
1073 read_structure_scope (dip
, thisdie
, enddie
, objfile
)
1074 struct dieinfo
*dip
;
1077 struct objfile
*objfile
;
1082 type
= struct_type (dip
, thisdie
, enddie
, objfile
);
1083 if (!(TYPE_FLAGS (type
) & TYPE_FLAG_STUB
))
1085 sym
= new_symbol (dip
, objfile
);
1088 SYMBOL_TYPE (sym
) = type
;
1089 if (cu_language
== language_cplus
)
1091 synthesize_typedef (dip
, objfile
, type
);
1101 decode_array_element_type -- decode type of the array elements
1105 static struct type *decode_array_element_type (char *scan, char *end)
1109 As the last step in decoding the array subscript information for an
1110 array DIE, we need to decode the type of the array elements. We are
1111 passed a pointer to this last part of the subscript information and
1112 must return the appropriate type. If the type attribute is not
1113 recognized, just warn about the problem and return type int.
1116 static struct type
*
1117 decode_array_element_type (scan
)
1122 unsigned short attribute
;
1123 unsigned short fundtype
;
1126 attribute
= target_to_host (scan
, SIZEOF_ATTRIBUTE
, GET_UNSIGNED
,
1128 scan
+= SIZEOF_ATTRIBUTE
;
1129 if ((nbytes
= attribute_size (attribute
)) == -1)
1131 SQUAWK (("bad array element type attribute 0x%x", attribute
));
1132 typep
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1139 fundtype
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1141 typep
= decode_fund_type (fundtype
);
1143 case AT_mod_fund_type
:
1144 typep
= decode_mod_fund_type (scan
);
1146 case AT_user_def_type
:
1147 die_ref
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1149 if ((typep
= lookup_utype (die_ref
)) == NULL
)
1151 typep
= alloc_utype (die_ref
, NULL
);
1154 case AT_mod_u_d_type
:
1155 typep
= decode_mod_u_d_type (scan
);
1158 SQUAWK (("bad array element type attribute 0x%x", attribute
));
1159 typep
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1170 decode_subscr_data -- decode array subscript and element type data
1174 static struct type *decode_subscr_data (char *scan, char *end)
1178 The array subscripts and the data type of the elements of an
1179 array are described by a list of data items, stored as a block
1180 of contiguous bytes. There is a data item describing each array
1181 dimension, and a final data item describing the element type.
1182 The data items are ordered the same as their appearance in the
1183 source (I.E. leftmost dimension first, next to leftmost second,
1186 We are passed a pointer to the start of the block of bytes
1187 containing the data items, and a pointer to the first byte past
1188 the data. This function decodes the data and returns a type.
1191 FIXME: This code only implements the forms currently used
1192 by the AT&T and GNU C compilers.
1194 The end pointer is supplied for error checking, maybe we should
1198 static struct type
*
1199 decode_subscr_data (scan
, end
)
1203 struct type
*typep
= NULL
;
1204 struct type
*nexttype
;
1205 unsigned int format
;
1206 unsigned short fundtype
;
1207 unsigned long lowbound
;
1208 unsigned long highbound
;
1211 format
= target_to_host (scan
, SIZEOF_FORMAT_SPECIFIER
, GET_UNSIGNED
,
1213 scan
+= SIZEOF_FORMAT_SPECIFIER
;
1217 typep
= decode_array_element_type (scan
);
1220 fundtype
= target_to_host (scan
, SIZEOF_FMT_FT
, GET_UNSIGNED
,
1222 scan
+= SIZEOF_FMT_FT
;
1223 if (fundtype
!= FT_integer
&& fundtype
!= FT_signed_integer
1224 && fundtype
!= FT_unsigned_integer
)
1226 SQUAWK (("array subscripts must be integral types, not type 0x%x",
1231 nbytes
= TARGET_FT_LONG_SIZE (current_objfile
);
1232 lowbound
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1235 highbound
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1238 nexttype
= decode_subscr_data (scan
, end
);
1239 if (nexttype
!= NULL
)
1241 typep
= alloc_type (current_objfile
);
1242 TYPE_CODE (typep
) = TYPE_CODE_ARRAY
;
1243 TYPE_LENGTH (typep
) = TYPE_LENGTH (nexttype
);
1244 TYPE_LENGTH (typep
) *= (highbound
- lowbound
) + 1;
1245 TYPE_TARGET_TYPE (typep
) = nexttype
;
1256 SQUAWK (("array subscript format 0x%x not handled yet", format
));
1259 SQUAWK (("unknown array subscript format %x", format
));
1269 dwarf_read_array_type -- read TAG_array_type DIE
1273 static void dwarf_read_array_type (struct dieinfo *dip)
1277 Extract all information from a TAG_array_type DIE and add to
1278 the user defined type vector.
1282 dwarf_read_array_type (dip
)
1283 struct dieinfo
*dip
;
1289 unsigned short blocksz
;
1292 if (dip
-> at_ordering
!= ORD_row_major
)
1294 /* FIXME: Can gdb even handle column major arrays? */
1295 SQUAWK (("array not row major; not handled correctly"));
1297 if ((sub
= dip
-> at_subscr_data
) != NULL
)
1299 nbytes
= attribute_size (AT_subscr_data
);
1300 blocksz
= target_to_host (sub
, nbytes
, GET_UNSIGNED
, current_objfile
);
1301 subend
= sub
+ nbytes
+ blocksz
;
1303 type
= decode_subscr_data (sub
, subend
);
1306 if ((utype
= lookup_utype (dip
-> die_ref
)) == NULL
)
1308 utype
= alloc_utype (dip
-> die_ref
, NULL
);
1310 TYPE_CODE (utype
) = TYPE_CODE_ARRAY
;
1311 TYPE_TARGET_TYPE (utype
) =
1312 lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1313 TYPE_LENGTH (utype
) = 1 * TYPE_LENGTH (TYPE_TARGET_TYPE (utype
));
1317 if ((utype
= lookup_utype (dip
-> die_ref
)) == NULL
)
1319 alloc_utype (dip
-> die_ref
, type
);
1323 TYPE_CODE (utype
) = TYPE_CODE_ARRAY
;
1324 TYPE_LENGTH (utype
) = TYPE_LENGTH (type
);
1325 TYPE_TARGET_TYPE (utype
) = TYPE_TARGET_TYPE (type
);
1335 read_tag_pointer_type -- read TAG_pointer_type DIE
1339 static void read_tag_pointer_type (struct dieinfo *dip)
1343 Extract all information from a TAG_pointer_type DIE and add to
1344 the user defined type vector.
1348 read_tag_pointer_type (dip
)
1349 struct dieinfo
*dip
;
1354 type
= decode_die_type (dip
);
1355 if ((utype
= lookup_utype (dip
-> die_ref
)) == NULL
)
1357 utype
= lookup_pointer_type (type
);
1358 alloc_utype (dip
-> die_ref
, utype
);
1362 TYPE_TARGET_TYPE (utype
) = type
;
1363 TYPE_POINTER_TYPE (type
) = utype
;
1365 /* We assume the machine has only one representation for pointers! */
1366 /* FIXME: This confuses host<->target data representations, and is a
1367 poor assumption besides. */
1369 TYPE_LENGTH (utype
) = sizeof (char *);
1370 TYPE_CODE (utype
) = TYPE_CODE_PTR
;
1378 read_subroutine_type -- process TAG_subroutine_type dies
1382 static void read_subroutine_type (struct dieinfo *dip, char thisdie,
1387 Handle DIES due to C code like:
1390 int (*funcp)(int a, long l); (Generates TAG_subroutine_type DIE)
1396 The parameter DIES are currently ignored. See if gdb has a way to
1397 include this info in it's type system, and decode them if so. Is
1398 this what the type structure's "arg_types" field is for? (FIXME)
1402 read_subroutine_type (dip
, thisdie
, enddie
)
1403 struct dieinfo
*dip
;
1407 struct type
*type
; /* Type that this function returns */
1408 struct type
*ftype
; /* Function that returns above type */
1410 /* Decode the type that this subroutine returns */
1412 type
= decode_die_type (dip
);
1414 /* Check to see if we already have a partially constructed user
1415 defined type for this DIE, from a forward reference. */
1417 if ((ftype
= lookup_utype (dip
-> die_ref
)) == NULL
)
1419 /* This is the first reference to one of these types. Make
1420 a new one and place it in the user defined types. */
1421 ftype
= lookup_function_type (type
);
1422 alloc_utype (dip
-> die_ref
, ftype
);
1426 /* We have an existing partially constructed type, so bash it
1427 into the correct type. */
1428 TYPE_TARGET_TYPE (ftype
) = type
;
1429 TYPE_FUNCTION_TYPE (type
) = ftype
;
1430 TYPE_LENGTH (ftype
) = 1;
1431 TYPE_CODE (ftype
) = TYPE_CODE_FUNC
;
1439 read_enumeration -- process dies which define an enumeration
1443 static void read_enumeration (struct dieinfo *dip, char *thisdie,
1444 char *enddie, struct objfile *objfile)
1448 Given a pointer to a die which begins an enumeration, process all
1449 the dies that define the members of the enumeration.
1453 Note that we need to call enum_type regardless of whether or not we
1454 have a symbol, since we might have an enum without a tag name (thus
1455 no symbol for the tagname).
1459 read_enumeration (dip
, thisdie
, enddie
, objfile
)
1460 struct dieinfo
*dip
;
1463 struct objfile
*objfile
;
1468 type
= enum_type (dip
, objfile
);
1469 sym
= new_symbol (dip
, objfile
);
1472 SYMBOL_TYPE (sym
) = type
;
1473 if (cu_language
== language_cplus
)
1475 synthesize_typedef (dip
, objfile
, type
);
1484 enum_type -- decode and return a type for an enumeration
1488 static type *enum_type (struct dieinfo *dip, struct objfile *objfile)
1492 Given a pointer to a die information structure for the die which
1493 starts an enumeration, process all the dies that define the members
1494 of the enumeration and return a type pointer for the enumeration.
1496 At the same time, for each member of the enumeration, create a
1497 symbol for it with namespace VAR_NAMESPACE and class LOC_CONST,
1498 and give it the type of the enumeration itself.
1502 Note that the DWARF specification explicitly mandates that enum
1503 constants occur in reverse order from the source program order,
1504 for "consistency" and because this ordering is easier for many
1505 compilers to generate. (Draft 6, sec 3.8.5, Enumeration type
1506 Entries). Because gdb wants to see the enum members in program
1507 source order, we have to ensure that the order gets reversed while
1508 we are processing them.
1511 static struct type
*
1512 enum_type (dip
, objfile
)
1513 struct dieinfo
*dip
;
1514 struct objfile
*objfile
;
1518 struct nextfield
*next
;
1521 struct nextfield
*list
= NULL
;
1522 struct nextfield
*new;
1527 unsigned short blocksz
;
1531 if ((type
= lookup_utype (dip
-> die_ref
)) == NULL
)
1533 /* No forward references created an empty type, so install one now */
1534 type
= alloc_utype (dip
-> die_ref
, NULL
);
1536 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1537 /* Some compilers try to be helpful by inventing "fake" names for
1538 anonymous enums, structures, and unions, like "~0fake" or ".0fake".
1539 Thanks, but no thanks... */
1540 if (dip
-> at_name
!= NULL
1541 && *dip
-> at_name
!= '~'
1542 && *dip
-> at_name
!= '.')
1544 TYPE_NAME (type
) = obconcat (&objfile
-> type_obstack
, "enum",
1545 " ", dip
-> at_name
);
1547 if (dip
-> at_byte_size
!= 0)
1549 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
1551 if ((scan
= dip
-> at_element_list
) != NULL
)
1553 if (dip
-> short_element_list
)
1555 nbytes
= attribute_size (AT_short_element_list
);
1559 nbytes
= attribute_size (AT_element_list
);
1561 blocksz
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, objfile
);
1562 listend
= scan
+ nbytes
+ blocksz
;
1564 while (scan
< listend
)
1566 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1569 list
-> field
.type
= NULL
;
1570 list
-> field
.bitsize
= 0;
1571 list
-> field
.bitpos
=
1572 target_to_host (scan
, TARGET_FT_LONG_SIZE (objfile
), GET_SIGNED
,
1574 scan
+= TARGET_FT_LONG_SIZE (objfile
);
1575 list
-> field
.name
= obsavestring (scan
, strlen (scan
),
1576 &objfile
-> type_obstack
);
1577 scan
+= strlen (scan
) + 1;
1579 /* Handcraft a new symbol for this enum member. */
1580 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
1581 sizeof (struct symbol
));
1582 memset (sym
, 0, sizeof (struct symbol
));
1583 SYMBOL_NAME (sym
) = create_name (list
-> field
.name
,
1584 &objfile
->symbol_obstack
);
1585 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1586 SYMBOL_CLASS (sym
) = LOC_CONST
;
1587 SYMBOL_TYPE (sym
) = type
;
1588 SYMBOL_VALUE (sym
) = list
-> field
.bitpos
;
1589 add_symbol_to_list (sym
, list_in_scope
);
1591 /* Now create the vector of fields, and record how big it is. This is
1592 where we reverse the order, by pulling the members off the list in
1593 reverse order from how they were inserted. If we have no fields
1594 (this is apparently possible in C++) then skip building a field
1598 TYPE_NFIELDS (type
) = nfields
;
1599 TYPE_FIELDS (type
) = (struct field
*)
1600 obstack_alloc (&objfile
->symbol_obstack
, sizeof (struct field
) * nfields
);
1601 /* Copy the saved-up fields into the field vector. */
1602 for (n
= 0; (n
< nfields
) && (list
!= NULL
); list
= list
-> next
)
1604 TYPE_FIELD (type
, n
++) = list
-> field
;
1615 read_func_scope -- process all dies within a function scope
1619 Process all dies within a given function scope. We are passed
1620 a die information structure pointer DIP for the die which
1621 starts the function scope, and pointers into the raw die data
1622 that define the dies within the function scope.
1624 For now, we ignore lexical block scopes within the function.
1625 The problem is that AT&T cc does not define a DWARF lexical
1626 block scope for the function itself, while gcc defines a
1627 lexical block scope for the function. We need to think about
1628 how to handle this difference, or if it is even a problem.
1633 read_func_scope (dip
, thisdie
, enddie
, objfile
)
1634 struct dieinfo
*dip
;
1637 struct objfile
*objfile
;
1639 register struct context_stack
*new;
1641 if (objfile
-> ei
.entry_point
>= dip
-> at_low_pc
&&
1642 objfile
-> ei
.entry_point
< dip
-> at_high_pc
)
1644 objfile
-> ei
.entry_func_lowpc
= dip
-> at_low_pc
;
1645 objfile
-> ei
.entry_func_highpc
= dip
-> at_high_pc
;
1647 if (STREQ (dip
-> at_name
, "main")) /* FIXME: hardwired name */
1649 objfile
-> ei
.main_func_lowpc
= dip
-> at_low_pc
;
1650 objfile
-> ei
.main_func_highpc
= dip
-> at_high_pc
;
1652 new = push_context (0, dip
-> at_low_pc
);
1653 new -> name
= new_symbol (dip
, objfile
);
1654 list_in_scope
= &local_symbols
;
1655 process_dies (thisdie
+ dip
-> die_length
, enddie
, objfile
);
1656 new = pop_context ();
1657 /* Make a block for the local symbols within. */
1658 finish_block (new -> name
, &local_symbols
, new -> old_blocks
,
1659 new -> start_addr
, dip
-> at_high_pc
, objfile
);
1660 list_in_scope
= &file_symbols
;
1668 handle_producer -- process the AT_producer attribute
1672 Perform any operations that depend on finding a particular
1673 AT_producer attribute.
1678 handle_producer (producer
)
1682 /* If this compilation unit was compiled with g++ or gcc, then set the
1683 processing_gcc_compilation flag. */
1685 processing_gcc_compilation
=
1686 STREQN (producer
, GPLUS_PRODUCER
, strlen (GPLUS_PRODUCER
))
1687 /* start-sanitize-chill */
1688 || STREQN (producer
, CHILL_PRODUCER
, strlen (CHILL_PRODUCER
))
1689 /* end-sanitize-chill */
1690 || STREQN (producer
, GCC_PRODUCER
, strlen (GCC_PRODUCER
));
1692 /* Select a demangling style if we can identify the producer and if
1693 the current style is auto. We leave the current style alone if it
1694 is not auto. We also leave the demangling style alone if we find a
1695 gcc (cc1) producer, as opposed to a g++ (cc1plus) producer. */
1697 #if 1 /* Works, but is experimental. -fnf */
1698 if (AUTO_DEMANGLING
)
1700 if (STREQN (producer
, GPLUS_PRODUCER
, strlen (GPLUS_PRODUCER
)))
1702 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1704 else if (STREQN (producer
, LCC_PRODUCER
, strlen (LCC_PRODUCER
)))
1706 set_demangling_style (LUCID_DEMANGLING_STYLE_STRING
);
1708 else if (STREQN (producer
, CFRONT_PRODUCER
, strlen (CFRONT_PRODUCER
)))
1710 set_demangling_style (CFRONT_DEMANGLING_STYLE_STRING
);
1721 read_file_scope -- process all dies within a file scope
1725 Process all dies within a given file scope. We are passed a
1726 pointer to the die information structure for the die which
1727 starts the file scope, and pointers into the raw die data which
1728 mark the range of dies within the file scope.
1730 When the partial symbol table is built, the file offset for the line
1731 number table for each compilation unit is saved in the partial symbol
1732 table entry for that compilation unit. As the symbols for each
1733 compilation unit are read, the line number table is read into memory
1734 and the variable lnbase is set to point to it. Thus all we have to
1735 do is use lnbase to access the line number table for the current
1740 read_file_scope (dip
, thisdie
, enddie
, objfile
)
1741 struct dieinfo
*dip
;
1744 struct objfile
*objfile
;
1746 struct cleanup
*back_to
;
1747 struct symtab
*symtab
;
1749 if (objfile
-> ei
.entry_point
>= dip
-> at_low_pc
&&
1750 objfile
-> ei
.entry_point
< dip
-> at_high_pc
)
1752 objfile
-> ei
.entry_file_lowpc
= dip
-> at_low_pc
;
1753 objfile
-> ei
.entry_file_highpc
= dip
-> at_high_pc
;
1755 set_cu_language (dip
);
1756 if (dip
-> at_producer
!= NULL
)
1758 handle_producer (dip
-> at_producer
);
1760 numutypes
= (enddie
- thisdie
) / 4;
1761 utypes
= (struct type
**) xmalloc (numutypes
* sizeof (struct type
*));
1762 back_to
= make_cleanup (free
, utypes
);
1763 memset (utypes
, 0, numutypes
* sizeof (struct type
*));
1764 start_symtab (dip
-> at_name
, dip
-> at_comp_dir
, dip
-> at_low_pc
);
1765 decode_line_numbers (lnbase
);
1766 process_dies (thisdie
+ dip
-> die_length
, enddie
, objfile
);
1767 symtab
= end_symtab (dip
-> at_high_pc
, 0, 0, objfile
);
1770 symtab
-> language
= cu_language
;
1772 do_cleanups (back_to
);
1781 process_dies -- process a range of DWARF Information Entries
1785 static void process_dies (char *thisdie, char *enddie,
1786 struct objfile *objfile)
1790 Process all DIE's in a specified range. May be (and almost
1791 certainly will be) called recursively.
1795 process_dies (thisdie
, enddie
, objfile
)
1798 struct objfile
*objfile
;
1803 while (thisdie
< enddie
)
1805 basicdieinfo (&di
, thisdie
, objfile
);
1806 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
1810 else if (di
.die_tag
== TAG_padding
)
1812 nextdie
= thisdie
+ di
.die_length
;
1816 completedieinfo (&di
, objfile
);
1817 if (di
.at_sibling
!= 0)
1819 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
1823 nextdie
= thisdie
+ di
.die_length
;
1827 case TAG_compile_unit
:
1828 read_file_scope (&di
, thisdie
, nextdie
, objfile
);
1830 case TAG_global_subroutine
:
1831 case TAG_subroutine
:
1832 if (di
.has_at_low_pc
)
1834 read_func_scope (&di
, thisdie
, nextdie
, objfile
);
1837 case TAG_lexical_block
:
1838 read_lexical_block_scope (&di
, thisdie
, nextdie
, objfile
);
1840 case TAG_class_type
:
1841 case TAG_structure_type
:
1842 case TAG_union_type
:
1843 read_structure_scope (&di
, thisdie
, nextdie
, objfile
);
1845 case TAG_enumeration_type
:
1846 read_enumeration (&di
, thisdie
, nextdie
, objfile
);
1848 case TAG_subroutine_type
:
1849 read_subroutine_type (&di
, thisdie
, nextdie
);
1851 case TAG_array_type
:
1852 dwarf_read_array_type (&di
);
1854 case TAG_pointer_type
:
1855 read_tag_pointer_type (&di
);
1858 new_symbol (&di
, objfile
);
1870 decode_line_numbers -- decode a line number table fragment
1874 static void decode_line_numbers (char *tblscan, char *tblend,
1875 long length, long base, long line, long pc)
1879 Translate the DWARF line number information to gdb form.
1881 The ".line" section contains one or more line number tables, one for
1882 each ".line" section from the objects that were linked.
1884 The AT_stmt_list attribute for each TAG_source_file entry in the
1885 ".debug" section contains the offset into the ".line" section for the
1886 start of the table for that file.
1888 The table itself has the following structure:
1890 <table length><base address><source statement entry>
1891 4 bytes 4 bytes 10 bytes
1893 The table length is the total size of the table, including the 4 bytes
1894 for the length information.
1896 The base address is the address of the first instruction generated
1897 for the source file.
1899 Each source statement entry has the following structure:
1901 <line number><statement position><address delta>
1902 4 bytes 2 bytes 4 bytes
1904 The line number is relative to the start of the file, starting with
1907 The statement position either -1 (0xFFFF) or the number of characters
1908 from the beginning of the line to the beginning of the statement.
1910 The address delta is the difference between the base address and
1911 the address of the first instruction for the statement.
1913 Note that we must copy the bytes from the packed table to our local
1914 variables before attempting to use them, to avoid alignment problems
1915 on some machines, particularly RISC processors.
1919 Does gdb expect the line numbers to be sorted? They are now by
1920 chance/luck, but are not required to be. (FIXME)
1922 The line with number 0 is unused, gdb apparently can discover the
1923 span of the last line some other way. How? (FIXME)
1927 decode_line_numbers (linetable
)
1932 unsigned long length
;
1937 if (linetable
!= NULL
)
1939 tblscan
= tblend
= linetable
;
1940 length
= target_to_host (tblscan
, SIZEOF_LINETBL_LENGTH
, GET_UNSIGNED
,
1942 tblscan
+= SIZEOF_LINETBL_LENGTH
;
1944 base
= target_to_host (tblscan
, TARGET_FT_POINTER_SIZE (objfile
),
1945 GET_UNSIGNED
, current_objfile
);
1946 tblscan
+= TARGET_FT_POINTER_SIZE (objfile
);
1948 while (tblscan
< tblend
)
1950 line
= target_to_host (tblscan
, SIZEOF_LINETBL_LINENO
, GET_UNSIGNED
,
1952 tblscan
+= SIZEOF_LINETBL_LINENO
+ SIZEOF_LINETBL_STMT
;
1953 pc
= target_to_host (tblscan
, SIZEOF_LINETBL_DELTA
, GET_UNSIGNED
,
1955 tblscan
+= SIZEOF_LINETBL_DELTA
;
1959 record_line (current_subfile
, line
, pc
);
1969 locval -- compute the value of a location attribute
1973 static int locval (char *loc)
1977 Given pointer to a string of bytes that define a location, compute
1978 the location and return the value.
1980 When computing values involving the current value of the frame pointer,
1981 the value zero is used, which results in a value relative to the frame
1982 pointer, rather than the absolute value. This is what GDB wants
1985 When the result is a register number, the global isreg flag is set,
1986 otherwise it is cleared. This is a kludge until we figure out a better
1987 way to handle the problem. Gdb's design does not mesh well with the
1988 DWARF notion of a location computing interpreter, which is a shame
1989 because the flexibility goes unused.
1993 Note that stack[0] is unused except as a default error return.
1994 Note that stack overflow is not yet handled.
2001 unsigned short nbytes
;
2002 unsigned short locsize
;
2003 auto long stack
[64];
2010 nbytes
= attribute_size (AT_location
);
2011 locsize
= target_to_host (loc
, nbytes
, GET_UNSIGNED
, current_objfile
);
2013 end
= loc
+ locsize
;
2018 loc_value_size
= TARGET_FT_LONG_SIZE (current_objfile
);
2021 loc_atom_code
= target_to_host (loc
, SIZEOF_LOC_ATOM_CODE
, GET_UNSIGNED
,
2023 loc
+= SIZEOF_LOC_ATOM_CODE
;
2024 switch (loc_atom_code
)
2031 /* push register (number) */
2032 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
2033 GET_UNSIGNED
, current_objfile
);
2034 loc
+= loc_value_size
;
2038 /* push value of register (number) */
2039 /* Actually, we compute the value as if register has 0 */
2041 regno
= target_to_host (loc
, loc_value_size
, GET_UNSIGNED
,
2043 loc
+= loc_value_size
;
2046 stack
[++stacki
] = 0;
2050 stack
[++stacki
] = 0;
2051 SQUAWK (("BASEREG %d not handled!", regno
));
2055 /* push address (relocated address) */
2056 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
2057 GET_UNSIGNED
, current_objfile
);
2058 loc
+= loc_value_size
;
2061 /* push constant (number) FIXME: signed or unsigned! */
2062 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
2063 GET_SIGNED
, current_objfile
);
2064 loc
+= loc_value_size
;
2067 /* pop, deref and push 2 bytes (as a long) */
2068 SQUAWK (("OP_DEREF2 address 0x%x not handled", stack
[stacki
]));
2070 case OP_DEREF4
: /* pop, deref and push 4 bytes (as a long) */
2071 SQUAWK (("OP_DEREF4 address 0x%x not handled", stack
[stacki
]));
2073 case OP_ADD
: /* pop top 2 items, add, push result */
2074 stack
[stacki
- 1] += stack
[stacki
];
2079 return (stack
[stacki
]);
2086 read_ofile_symtab -- build a full symtab entry from chunk of DIE's
2090 static struct symtab *read_ofile_symtab (struct partial_symtab *pst)
2094 When expanding a partial symbol table entry to a full symbol table
2095 entry, this is the function that gets called to read in the symbols
2096 for the compilation unit.
2098 Returns a pointer to the newly constructed symtab (which is now
2099 the new first one on the objfile's symtab list).
2102 static struct symtab
*
2103 read_ofile_symtab (pst
)
2104 struct partial_symtab
*pst
;
2106 struct cleanup
*back_to
;
2107 unsigned long lnsize
;
2110 char lnsizedata
[SIZEOF_LINETBL_LENGTH
];
2112 abfd
= pst
-> objfile
-> obfd
;
2113 current_objfile
= pst
-> objfile
;
2115 /* Allocate a buffer for the entire chunk of DIE's for this compilation
2116 unit, seek to the location in the file, and read in all the DIE's. */
2119 dbsize
= DBLENGTH (pst
);
2120 dbbase
= xmalloc (dbsize
);
2121 dbroff
= DBROFF(pst
);
2122 foffset
= DBFOFF(pst
) + dbroff
;
2123 base_section_offsets
= pst
->section_offsets
;
2124 baseaddr
= ANOFFSET (pst
->section_offsets
, 0);
2125 if (bfd_seek (abfd
, foffset
, L_SET
) ||
2126 (bfd_read (dbbase
, dbsize
, 1, abfd
) != dbsize
))
2129 error ("can't read DWARF data");
2131 back_to
= make_cleanup (free
, dbbase
);
2133 /* If there is a line number table associated with this compilation unit
2134 then read the size of this fragment in bytes, from the fragment itself.
2135 Allocate a buffer for the fragment and read it in for future
2141 if (bfd_seek (abfd
, LNFOFF (pst
), L_SET
) ||
2142 (bfd_read ((PTR
) lnsizedata
, sizeof (lnsizedata
), 1, abfd
) !=
2143 sizeof (lnsizedata
)))
2145 error ("can't read DWARF line number table size");
2147 lnsize
= target_to_host (lnsizedata
, SIZEOF_LINETBL_LENGTH
,
2148 GET_UNSIGNED
, pst
-> objfile
);
2149 lnbase
= xmalloc (lnsize
);
2150 if (bfd_seek (abfd
, LNFOFF (pst
), L_SET
) ||
2151 (bfd_read (lnbase
, lnsize
, 1, abfd
) != lnsize
))
2154 error ("can't read DWARF line numbers");
2156 make_cleanup (free
, lnbase
);
2159 process_dies (dbbase
, dbbase
+ dbsize
, pst
-> objfile
);
2160 do_cleanups (back_to
);
2161 current_objfile
= NULL
;
2162 return (pst
-> objfile
-> symtabs
);
2169 psymtab_to_symtab_1 -- do grunt work for building a full symtab entry
2173 static void psymtab_to_symtab_1 (struct partial_symtab *pst)
2177 Called once for each partial symbol table entry that needs to be
2178 expanded into a full symbol table entry.
2183 psymtab_to_symtab_1 (pst
)
2184 struct partial_symtab
*pst
;
2187 struct cleanup
*old_chain
;
2193 warning ("psymtab for %s already read in. Shouldn't happen.",
2198 /* Read in all partial symtabs on which this one is dependent */
2199 for (i
= 0; i
< pst
-> number_of_dependencies
; i
++)
2201 if (!pst
-> dependencies
[i
] -> readin
)
2203 /* Inform about additional files that need to be read in. */
2206 fputs_filtered (" ", stdout
);
2208 fputs_filtered ("and ", stdout
);
2210 printf_filtered ("%s...",
2211 pst
-> dependencies
[i
] -> filename
);
2213 fflush (stdout
); /* Flush output */
2215 psymtab_to_symtab_1 (pst
-> dependencies
[i
]);
2218 if (DBLENGTH (pst
)) /* Otherwise it's a dummy */
2221 old_chain
= make_cleanup (really_free_pendings
, 0);
2222 pst
-> symtab
= read_ofile_symtab (pst
);
2225 printf_filtered ("%d DIE's, sorting...", diecount
);
2229 sort_symtab_syms (pst
-> symtab
);
2230 do_cleanups (old_chain
);
2241 dwarf_psymtab_to_symtab -- build a full symtab entry from partial one
2245 static void dwarf_psymtab_to_symtab (struct partial_symtab *pst)
2249 This is the DWARF support entry point for building a full symbol
2250 table entry from a partial symbol table entry. We are passed a
2251 pointer to the partial symbol table entry that needs to be expanded.
2256 dwarf_psymtab_to_symtab (pst
)
2257 struct partial_symtab
*pst
;
2264 warning ("psymtab for %s already read in. Shouldn't happen.",
2269 if (DBLENGTH (pst
) || pst
-> number_of_dependencies
)
2271 /* Print the message now, before starting serious work, to avoid
2272 disconcerting pauses. */
2275 printf_filtered ("Reading in symbols for %s...",
2280 psymtab_to_symtab_1 (pst
);
2282 #if 0 /* FIXME: Check to see what dbxread is doing here and see if
2283 we need to do an equivalent or is this something peculiar to
2285 Match with global symbols. This only needs to be done once,
2286 after all of the symtabs and dependencies have been read in.
2288 scan_file_globals (pst
-> objfile
);
2291 /* Finish up the verbose info message. */
2294 printf_filtered ("done.\n");
2306 init_psymbol_list -- initialize storage for partial symbols
2310 static void init_psymbol_list (struct objfile *objfile, int total_symbols)
2314 Initializes storage for all of the partial symbols that will be
2315 created by dwarf_build_psymtabs and subsidiaries.
2319 init_psymbol_list (objfile
, total_symbols
)
2320 struct objfile
*objfile
;
2323 /* Free any previously allocated psymbol lists. */
2325 if (objfile
-> global_psymbols
.list
)
2327 mfree (objfile
-> md
, (PTR
)objfile
-> global_psymbols
.list
);
2329 if (objfile
-> static_psymbols
.list
)
2331 mfree (objfile
-> md
, (PTR
)objfile
-> static_psymbols
.list
);
2334 /* Current best guess is that there are approximately a twentieth
2335 of the total symbols (in a debugging file) are global or static
2338 objfile
-> global_psymbols
.size
= total_symbols
/ 10;
2339 objfile
-> static_psymbols
.size
= total_symbols
/ 10;
2340 objfile
-> global_psymbols
.next
=
2341 objfile
-> global_psymbols
.list
= (struct partial_symbol
*)
2342 xmmalloc (objfile
-> md
, objfile
-> global_psymbols
.size
2343 * sizeof (struct partial_symbol
));
2344 objfile
-> static_psymbols
.next
=
2345 objfile
-> static_psymbols
.list
= (struct partial_symbol
*)
2346 xmmalloc (objfile
-> md
, objfile
-> static_psymbols
.size
2347 * sizeof (struct partial_symbol
));
2354 add_enum_psymbol -- add enumeration members to partial symbol table
2358 Given pointer to a DIE that is known to be for an enumeration,
2359 extract the symbolic names of the enumeration members and add
2360 partial symbols for them.
2364 add_enum_psymbol (dip
, objfile
)
2365 struct dieinfo
*dip
;
2366 struct objfile
*objfile
;
2370 unsigned short blocksz
;
2373 if ((scan
= dip
-> at_element_list
) != NULL
)
2375 if (dip
-> short_element_list
)
2377 nbytes
= attribute_size (AT_short_element_list
);
2381 nbytes
= attribute_size (AT_element_list
);
2383 blocksz
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, objfile
);
2385 listend
= scan
+ blocksz
;
2386 while (scan
< listend
)
2388 scan
+= TARGET_FT_LONG_SIZE (objfile
);
2389 ADD_PSYMBOL_TO_LIST (scan
, strlen (scan
), VAR_NAMESPACE
, LOC_CONST
,
2390 objfile
-> static_psymbols
, 0);
2391 scan
+= strlen (scan
) + 1;
2400 add_partial_symbol -- add symbol to partial symbol table
2404 Given a DIE, if it is one of the types that we want to
2405 add to a partial symbol table, finish filling in the die info
2406 and then add a partial symbol table entry for it.
2410 The caller must ensure that the DIE has a valid name attribute.
2414 add_partial_symbol (dip
, objfile
)
2415 struct dieinfo
*dip
;
2416 struct objfile
*objfile
;
2418 switch (dip
-> die_tag
)
2420 case TAG_global_subroutine
:
2421 record_minimal_symbol (dip
-> at_name
, dip
-> at_low_pc
, mst_text
,
2423 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2424 VAR_NAMESPACE
, LOC_BLOCK
,
2425 objfile
-> global_psymbols
,
2428 case TAG_global_variable
:
2429 record_minimal_symbol (dip
-> at_name
, locval (dip
-> at_location
),
2431 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2432 VAR_NAMESPACE
, LOC_STATIC
,
2433 objfile
-> global_psymbols
,
2436 case TAG_subroutine
:
2437 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2438 VAR_NAMESPACE
, LOC_BLOCK
,
2439 objfile
-> static_psymbols
,
2442 case TAG_local_variable
:
2443 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2444 VAR_NAMESPACE
, LOC_STATIC
,
2445 objfile
-> static_psymbols
,
2449 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2450 VAR_NAMESPACE
, LOC_TYPEDEF
,
2451 objfile
-> static_psymbols
,
2454 case TAG_class_type
:
2455 case TAG_structure_type
:
2456 case TAG_union_type
:
2457 case TAG_enumeration_type
:
2458 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2459 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2460 objfile
-> static_psymbols
,
2462 if (cu_language
== language_cplus
)
2464 /* For C++, these implicitly act as typedefs as well. */
2465 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2466 VAR_NAMESPACE
, LOC_TYPEDEF
,
2467 objfile
-> static_psymbols
,
2478 scan_partial_symbols -- scan DIE's within a single compilation unit
2482 Process the DIE's within a single compilation unit, looking for
2483 interesting DIE's that contribute to the partial symbol table entry
2484 for this compilation unit.
2488 There are some DIE's that may appear both at file scope and within
2489 the scope of a function. We are only interested in the ones at file
2490 scope, and the only way to tell them apart is to keep track of the
2491 scope. For example, consider the test case:
2496 for which the relevant DWARF segment has the structure:
2499 0x23 global subrtn sibling 0x9b
2501 fund_type FT_integer
2506 0x23 local var sibling 0x97
2508 fund_type FT_integer
2509 location OP_BASEREG 0xe
2516 0x1d local var sibling 0xb8
2518 fund_type FT_integer
2519 location OP_ADDR 0x800025dc
2524 We want to include the symbol 'i' in the partial symbol table, but
2525 not the symbol 'j'. In essence, we want to skip all the dies within
2526 the scope of a TAG_global_subroutine DIE.
2528 Don't attempt to add anonymous structures or unions since they have
2529 no name. Anonymous enumerations however are processed, because we
2530 want to extract their member names (the check for a tag name is
2533 Also, for variables and subroutines, check that this is the place
2534 where the actual definition occurs, rather than just a reference
2539 scan_partial_symbols (thisdie
, enddie
, objfile
)
2542 struct objfile
*objfile
;
2548 while (thisdie
< enddie
)
2550 basicdieinfo (&di
, thisdie
, objfile
);
2551 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
2557 nextdie
= thisdie
+ di
.die_length
;
2558 /* To avoid getting complete die information for every die, we
2559 only do it (below) for the cases we are interested in. */
2562 case TAG_global_subroutine
:
2563 case TAG_subroutine
:
2564 completedieinfo (&di
, objfile
);
2565 if (di
.at_name
&& (di
.has_at_low_pc
|| di
.at_location
))
2567 add_partial_symbol (&di
, objfile
);
2568 /* If there is a sibling attribute, adjust the nextdie
2569 pointer to skip the entire scope of the subroutine.
2570 Apply some sanity checking to make sure we don't
2571 overrun or underrun the range of remaining DIE's */
2572 if (di
.at_sibling
!= 0)
2574 temp
= dbbase
+ di
.at_sibling
- dbroff
;
2575 if ((temp
< thisdie
) || (temp
>= enddie
))
2577 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", di
.at_sibling
);
2586 case TAG_global_variable
:
2587 case TAG_local_variable
:
2588 completedieinfo (&di
, objfile
);
2589 if (di
.at_name
&& (di
.has_at_low_pc
|| di
.at_location
))
2591 add_partial_symbol (&di
, objfile
);
2595 case TAG_class_type
:
2596 case TAG_structure_type
:
2597 case TAG_union_type
:
2598 completedieinfo (&di
, objfile
);
2601 add_partial_symbol (&di
, objfile
);
2604 case TAG_enumeration_type
:
2605 completedieinfo (&di
, objfile
);
2608 add_partial_symbol (&di
, objfile
);
2610 add_enum_psymbol (&di
, objfile
);
2622 scan_compilation_units -- build a psymtab entry for each compilation
2626 This is the top level dwarf parsing routine for building partial
2629 It scans from the beginning of the DWARF table looking for the first
2630 TAG_compile_unit DIE, and then follows the sibling chain to locate
2631 each additional TAG_compile_unit DIE.
2633 For each TAG_compile_unit DIE it creates a partial symtab structure,
2634 calls a subordinate routine to collect all the compilation unit's
2635 global DIE's, file scope DIEs, typedef DIEs, etc, and then links the
2636 new partial symtab structure into the partial symbol table. It also
2637 records the appropriate information in the partial symbol table entry
2638 to allow the chunk of DIE's and line number table for this compilation
2639 unit to be located and re-read later, to generate a complete symbol
2640 table entry for the compilation unit.
2642 Thus it effectively partitions up a chunk of DIE's for multiple
2643 compilation units into smaller DIE chunks and line number tables,
2644 and associates them with a partial symbol table entry.
2648 If any compilation unit has no line number table associated with
2649 it for some reason (a missing at_stmt_list attribute, rather than
2650 just one with a value of zero, which is valid) then we ensure that
2651 the recorded file offset is zero so that the routine which later
2652 reads line number table fragments knows that there is no fragment
2662 scan_compilation_units (thisdie
, enddie
, dbfoff
, lnoffset
, objfile
)
2667 struct objfile
*objfile
;
2671 struct partial_symtab
*pst
;
2674 file_ptr curlnoffset
;
2676 while (thisdie
< enddie
)
2678 basicdieinfo (&di
, thisdie
, objfile
);
2679 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
2683 else if (di
.die_tag
!= TAG_compile_unit
)
2685 nextdie
= thisdie
+ di
.die_length
;
2689 completedieinfo (&di
, objfile
);
2690 set_cu_language (&di
);
2691 if (di
.at_sibling
!= 0)
2693 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
2697 nextdie
= thisdie
+ di
.die_length
;
2699 curoff
= thisdie
- dbbase
;
2700 culength
= nextdie
- thisdie
;
2701 curlnoffset
= di
.has_at_stmt_list
? lnoffset
+ di
.at_stmt_list
: 0;
2703 /* First allocate a new partial symbol table structure */
2705 pst
= start_psymtab_common (objfile
, base_section_offsets
,
2706 di
.at_name
, di
.at_low_pc
,
2707 objfile
-> global_psymbols
.next
,
2708 objfile
-> static_psymbols
.next
);
2710 pst
-> texthigh
= di
.at_high_pc
;
2711 pst
-> read_symtab_private
= (char *)
2712 obstack_alloc (&objfile
-> psymbol_obstack
,
2713 sizeof (struct dwfinfo
));
2714 DBFOFF (pst
) = dbfoff
;
2715 DBROFF (pst
) = curoff
;
2716 DBLENGTH (pst
) = culength
;
2717 LNFOFF (pst
) = curlnoffset
;
2718 pst
-> read_symtab
= dwarf_psymtab_to_symtab
;
2720 /* Now look for partial symbols */
2722 scan_partial_symbols (thisdie
+ di
.die_length
, nextdie
, objfile
);
2724 pst
-> n_global_syms
= objfile
-> global_psymbols
.next
-
2725 (objfile
-> global_psymbols
.list
+ pst
-> globals_offset
);
2726 pst
-> n_static_syms
= objfile
-> static_psymbols
.next
-
2727 (objfile
-> static_psymbols
.list
+ pst
-> statics_offset
);
2728 sort_pst_symbols (pst
);
2729 /* If there is already a psymtab or symtab for a file of this name,
2730 remove it. (If there is a symtab, more drastic things also
2731 happen.) This happens in VxWorks. */
2732 free_named_symtabs (pst
-> filename
);
2742 new_symbol -- make a symbol table entry for a new symbol
2746 static struct symbol *new_symbol (struct dieinfo *dip,
2747 struct objfile *objfile)
2751 Given a pointer to a DWARF information entry, figure out if we need
2752 to make a symbol table entry for it, and if so, create a new entry
2753 and return a pointer to it.
2756 static struct symbol
*
2757 new_symbol (dip
, objfile
)
2758 struct dieinfo
*dip
;
2759 struct objfile
*objfile
;
2761 struct symbol
*sym
= NULL
;
2763 if (dip
-> at_name
!= NULL
)
2765 sym
= (struct symbol
*) obstack_alloc (&objfile
-> symbol_obstack
,
2766 sizeof (struct symbol
));
2767 memset (sym
, 0, sizeof (struct symbol
));
2768 SYMBOL_NAME (sym
) = create_name (dip
-> at_name
,
2769 &objfile
->symbol_obstack
);
2770 /* default assumptions */
2771 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2772 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2773 SYMBOL_TYPE (sym
) = decode_die_type (dip
);
2774 switch (dip
-> die_tag
)
2777 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
;
2778 SYMBOL_CLASS (sym
) = LOC_LABEL
;
2780 case TAG_global_subroutine
:
2781 case TAG_subroutine
:
2782 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
;
2783 SYMBOL_TYPE (sym
) = lookup_function_type (SYMBOL_TYPE (sym
));
2784 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
2785 if (dip
-> die_tag
== TAG_global_subroutine
)
2787 add_symbol_to_list (sym
, &global_symbols
);
2791 add_symbol_to_list (sym
, list_in_scope
);
2794 case TAG_global_variable
:
2795 if (dip
-> at_location
!= NULL
)
2797 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2798 add_symbol_to_list (sym
, &global_symbols
);
2799 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2800 SYMBOL_VALUE (sym
) += baseaddr
;
2803 case TAG_local_variable
:
2804 if (dip
-> at_location
!= NULL
)
2806 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2807 add_symbol_to_list (sym
, list_in_scope
);
2810 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
2814 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
2818 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2819 SYMBOL_VALUE (sym
) += baseaddr
;
2823 case TAG_formal_parameter
:
2824 if (dip
-> at_location
!= NULL
)
2826 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2828 add_symbol_to_list (sym
, list_in_scope
);
2831 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
2835 SYMBOL_CLASS (sym
) = LOC_ARG
;
2838 case TAG_unspecified_parameters
:
2839 /* From varargs functions; gdb doesn't seem to have any interest in
2840 this information, so just ignore it for now. (FIXME?) */
2842 case TAG_class_type
:
2843 case TAG_structure_type
:
2844 case TAG_union_type
:
2845 case TAG_enumeration_type
:
2846 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2847 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
2848 add_symbol_to_list (sym
, list_in_scope
);
2851 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2852 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2853 add_symbol_to_list (sym
, list_in_scope
);
2856 /* Not a tag we recognize. Hopefully we aren't processing trash
2857 data, but since we must specifically ignore things we don't
2858 recognize, there is nothing else we should do at this point. */
2869 synthesize_typedef -- make a symbol table entry for a "fake" typedef
2873 static void synthesize_typedef (struct dieinfo *dip,
2874 struct objfile *objfile,
2879 Given a pointer to a DWARF information entry, synthesize a typedef
2880 for the name in the DIE, using the specified type.
2882 This is used for C++ class, structs, unions, and enumerations to
2883 set up the tag name as a type.
2888 synthesize_typedef (dip
, objfile
, type
)
2889 struct dieinfo
*dip
;
2890 struct objfile
*objfile
;
2893 struct symbol
*sym
= NULL
;
2895 if (dip
-> at_name
!= NULL
)
2897 sym
= (struct symbol
*)
2898 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
2899 memset (sym
, 0, sizeof (struct symbol
));
2900 SYMBOL_NAME (sym
) = create_name (dip
-> at_name
,
2901 &objfile
->symbol_obstack
);
2902 SYMBOL_TYPE (sym
) = type
;
2903 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2904 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2905 add_symbol_to_list (sym
, list_in_scope
);
2913 decode_mod_fund_type -- decode a modified fundamental type
2917 static struct type *decode_mod_fund_type (char *typedata)
2921 Decode a block of data containing a modified fundamental
2922 type specification. TYPEDATA is a pointer to the block,
2923 which starts with a length containing the size of the rest
2924 of the block. At the end of the block is a fundmental type
2925 code value that gives the fundamental type. Everything
2926 in between are type modifiers.
2928 We simply compute the number of modifiers and call the general
2929 function decode_modified_type to do the actual work.
2932 static struct type
*
2933 decode_mod_fund_type (typedata
)
2936 struct type
*typep
= NULL
;
2937 unsigned short modcount
;
2940 /* Get the total size of the block, exclusive of the size itself */
2942 nbytes
= attribute_size (AT_mod_fund_type
);
2943 modcount
= target_to_host (typedata
, nbytes
, GET_UNSIGNED
, current_objfile
);
2946 /* Deduct the size of the fundamental type bytes at the end of the block. */
2948 modcount
-= attribute_size (AT_fund_type
);
2950 /* Now do the actual decoding */
2952 typep
= decode_modified_type (typedata
, modcount
, AT_mod_fund_type
);
2960 decode_mod_u_d_type -- decode a modified user defined type
2964 static struct type *decode_mod_u_d_type (char *typedata)
2968 Decode a block of data containing a modified user defined
2969 type specification. TYPEDATA is a pointer to the block,
2970 which consists of a two byte length, containing the size
2971 of the rest of the block. At the end of the block is a
2972 four byte value that gives a reference to a user defined type.
2973 Everything in between are type modifiers.
2975 We simply compute the number of modifiers and call the general
2976 function decode_modified_type to do the actual work.
2979 static struct type
*
2980 decode_mod_u_d_type (typedata
)
2983 struct type
*typep
= NULL
;
2984 unsigned short modcount
;
2987 /* Get the total size of the block, exclusive of the size itself */
2989 nbytes
= attribute_size (AT_mod_u_d_type
);
2990 modcount
= target_to_host (typedata
, nbytes
, GET_UNSIGNED
, current_objfile
);
2993 /* Deduct the size of the reference type bytes at the end of the block. */
2995 modcount
-= attribute_size (AT_user_def_type
);
2997 /* Now do the actual decoding */
2999 typep
= decode_modified_type (typedata
, modcount
, AT_mod_u_d_type
);
3007 decode_modified_type -- decode modified user or fundamental type
3011 static struct type *decode_modified_type (char *modifiers,
3012 unsigned short modcount, int mtype)
3016 Decode a modified type, either a modified fundamental type or
3017 a modified user defined type. MODIFIERS is a pointer to the
3018 block of bytes that define MODCOUNT modifiers. Immediately
3019 following the last modifier is a short containing the fundamental
3020 type or a long containing the reference to the user defined
3021 type. Which one is determined by MTYPE, which is either
3022 AT_mod_fund_type or AT_mod_u_d_type to indicate what modified
3023 type we are generating.
3025 We call ourself recursively to generate each modified type,`
3026 until MODCOUNT reaches zero, at which point we have consumed
3027 all the modifiers and generate either the fundamental type or
3028 user defined type. When the recursion unwinds, each modifier
3029 is applied in turn to generate the full modified type.
3033 If we find a modifier that we don't recognize, and it is not one
3034 of those reserved for application specific use, then we issue a
3035 warning and simply ignore the modifier.
3039 We currently ignore MOD_const and MOD_volatile. (FIXME)
3043 static struct type
*
3044 decode_modified_type (modifiers
, modcount
, mtype
)
3046 unsigned int modcount
;
3049 struct type
*typep
= NULL
;
3050 unsigned short fundtype
;
3059 case AT_mod_fund_type
:
3060 nbytes
= attribute_size (AT_fund_type
);
3061 fundtype
= target_to_host (modifiers
, nbytes
, GET_UNSIGNED
,
3063 typep
= decode_fund_type (fundtype
);
3065 case AT_mod_u_d_type
:
3066 nbytes
= attribute_size (AT_user_def_type
);
3067 die_ref
= target_to_host (modifiers
, nbytes
, GET_UNSIGNED
,
3069 if ((typep
= lookup_utype (die_ref
)) == NULL
)
3071 typep
= alloc_utype (die_ref
, NULL
);
3075 SQUAWK (("botched modified type decoding (mtype 0x%x)", mtype
));
3076 typep
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
3082 modifier
= *modifiers
++;
3083 typep
= decode_modified_type (modifiers
, --modcount
, mtype
);
3086 case MOD_pointer_to
:
3087 typep
= lookup_pointer_type (typep
);
3089 case MOD_reference_to
:
3090 typep
= lookup_reference_type (typep
);
3093 SQUAWK (("type modifier 'const' ignored")); /* FIXME */
3096 SQUAWK (("type modifier 'volatile' ignored")); /* FIXME */
3099 if (!(MOD_lo_user
<= (unsigned char) modifier
3100 && (unsigned char) modifier
<= MOD_hi_user
))
3102 SQUAWK (("unknown type modifier %u",
3103 (unsigned char) modifier
));
3115 decode_fund_type -- translate basic DWARF type to gdb base type
3119 Given an integer that is one of the fundamental DWARF types,
3120 translate it to one of the basic internal gdb types and return
3121 a pointer to the appropriate gdb type (a "struct type *").
3125 If we encounter a fundamental type that we are unprepared to
3126 deal with, and it is not in the range of those types defined
3127 as application specific types, then we issue a warning and
3128 treat the type as an "int".
3131 static struct type
*
3132 decode_fund_type (fundtype
)
3133 unsigned int fundtype
;
3135 struct type
*typep
= NULL
;
3141 typep
= lookup_fundamental_type (current_objfile
, FT_VOID
);
3144 case FT_boolean
: /* Was FT_set in AT&T version */
3145 typep
= lookup_fundamental_type (current_objfile
, FT_BOOLEAN
);
3148 case FT_pointer
: /* (void *) */
3149 typep
= lookup_fundamental_type (current_objfile
, FT_VOID
);
3150 typep
= lookup_pointer_type (typep
);
3154 typep
= lookup_fundamental_type (current_objfile
, FT_CHAR
);
3157 case FT_signed_char
:
3158 typep
= lookup_fundamental_type (current_objfile
, FT_SIGNED_CHAR
);
3161 case FT_unsigned_char
:
3162 typep
= lookup_fundamental_type (current_objfile
, FT_UNSIGNED_CHAR
);
3166 typep
= lookup_fundamental_type (current_objfile
, FT_SHORT
);
3169 case FT_signed_short
:
3170 typep
= lookup_fundamental_type (current_objfile
, FT_SIGNED_SHORT
);
3173 case FT_unsigned_short
:
3174 typep
= lookup_fundamental_type (current_objfile
, FT_UNSIGNED_SHORT
);
3178 typep
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
3181 case FT_signed_integer
:
3182 typep
= lookup_fundamental_type (current_objfile
, FT_SIGNED_INTEGER
);
3185 case FT_unsigned_integer
:
3186 typep
= lookup_fundamental_type (current_objfile
, FT_UNSIGNED_INTEGER
);
3190 typep
= lookup_fundamental_type (current_objfile
, FT_LONG
);
3193 case FT_signed_long
:
3194 typep
= lookup_fundamental_type (current_objfile
, FT_SIGNED_LONG
);
3197 case FT_unsigned_long
:
3198 typep
= lookup_fundamental_type (current_objfile
, FT_UNSIGNED_LONG
);
3202 typep
= lookup_fundamental_type (current_objfile
, FT_LONG_LONG
);
3205 case FT_signed_long_long
:
3206 typep
= lookup_fundamental_type (current_objfile
, FT_SIGNED_LONG_LONG
);
3209 case FT_unsigned_long_long
:
3210 typep
= lookup_fundamental_type (current_objfile
, FT_UNSIGNED_LONG_LONG
);
3214 typep
= lookup_fundamental_type (current_objfile
, FT_FLOAT
);
3217 case FT_dbl_prec_float
:
3218 typep
= lookup_fundamental_type (current_objfile
, FT_DBL_PREC_FLOAT
);
3221 case FT_ext_prec_float
:
3222 typep
= lookup_fundamental_type (current_objfile
, FT_EXT_PREC_FLOAT
);
3226 typep
= lookup_fundamental_type (current_objfile
, FT_COMPLEX
);
3229 case FT_dbl_prec_complex
:
3230 typep
= lookup_fundamental_type (current_objfile
, FT_DBL_PREC_COMPLEX
);
3233 case FT_ext_prec_complex
:
3234 typep
= lookup_fundamental_type (current_objfile
, FT_EXT_PREC_COMPLEX
);
3239 if ((typep
== NULL
) && !(FT_lo_user
<= fundtype
&& fundtype
<= FT_hi_user
))
3241 SQUAWK (("unexpected fundamental type 0x%x", fundtype
));
3242 typep
= lookup_fundamental_type (current_objfile
, FT_VOID
);
3252 create_name -- allocate a fresh copy of a string on an obstack
3256 Given a pointer to a string and a pointer to an obstack, allocates
3257 a fresh copy of the string on the specified obstack.
3262 create_name (name
, obstackp
)
3264 struct obstack
*obstackp
;
3269 length
= strlen (name
) + 1;
3270 newname
= (char *) obstack_alloc (obstackp
, length
);
3271 strcpy (newname
, name
);
3279 basicdieinfo -- extract the minimal die info from raw die data
3283 void basicdieinfo (char *diep, struct dieinfo *dip,
3284 struct objfile *objfile)
3288 Given a pointer to raw DIE data, and a pointer to an instance of a
3289 die info structure, this function extracts the basic information
3290 from the DIE data required to continue processing this DIE, along
3291 with some bookkeeping information about the DIE.
3293 The information we absolutely must have includes the DIE tag,
3294 and the DIE length. If we need the sibling reference, then we
3295 will have to call completedieinfo() to process all the remaining
3298 Note that since there is no guarantee that the data is properly
3299 aligned in memory for the type of access required (indirection
3300 through anything other than a char pointer), and there is no
3301 guarantee that it is in the same byte order as the gdb host,
3302 we call a function which deals with both alignment and byte
3303 swapping issues. Possibly inefficient, but quite portable.
3305 We also take care of some other basic things at this point, such
3306 as ensuring that the instance of the die info structure starts
3307 out completely zero'd and that curdie is initialized for use
3308 in error reporting if we have a problem with the current die.
3312 All DIE's must have at least a valid length, thus the minimum
3313 DIE size is SIZEOF_DIE_LENGTH. In order to have a valid tag, the
3314 DIE size must be at least SIZEOF_DIE_TAG larger, otherwise they
3315 are forced to be TAG_padding DIES.
3317 Padding DIES must be at least SIZEOF_DIE_LENGTH in length, implying
3318 that if a padding DIE is used for alignment and the amount needed is
3319 less than SIZEOF_DIE_LENGTH, then the padding DIE has to be big
3320 enough to align to the next alignment boundry.
3322 We do some basic sanity checking here, such as verifying that the
3323 length of the die would not cause it to overrun the recorded end of
3324 the buffer holding the DIE info. If we find a DIE that is either
3325 too small or too large, we force it's length to zero which should
3326 cause the caller to take appropriate action.
3330 basicdieinfo (dip
, diep
, objfile
)
3331 struct dieinfo
*dip
;
3333 struct objfile
*objfile
;
3336 memset (dip
, 0, sizeof (struct dieinfo
));
3338 dip
-> die_ref
= dbroff
+ (diep
- dbbase
);
3339 dip
-> die_length
= target_to_host (diep
, SIZEOF_DIE_LENGTH
, GET_UNSIGNED
,
3341 if ((dip
-> die_length
< SIZEOF_DIE_LENGTH
) ||
3342 ((diep
+ dip
-> die_length
) > (dbbase
+ dbsize
)))
3344 dwarfwarn ("malformed DIE, bad length (%d bytes)", dip
-> die_length
);
3345 dip
-> die_length
= 0;
3347 else if (dip
-> die_length
< (SIZEOF_DIE_LENGTH
+ SIZEOF_DIE_TAG
))
3349 dip
-> die_tag
= TAG_padding
;
3353 diep
+= SIZEOF_DIE_LENGTH
;
3354 dip
-> die_tag
= target_to_host (diep
, SIZEOF_DIE_TAG
, GET_UNSIGNED
,
3363 completedieinfo -- finish reading the information for a given DIE
3367 void completedieinfo (struct dieinfo *dip, struct objfile *objfile)
3371 Given a pointer to an already partially initialized die info structure,
3372 scan the raw DIE data and finish filling in the die info structure
3373 from the various attributes found.
3375 Note that since there is no guarantee that the data is properly
3376 aligned in memory for the type of access required (indirection
3377 through anything other than a char pointer), and there is no
3378 guarantee that it is in the same byte order as the gdb host,
3379 we call a function which deals with both alignment and byte
3380 swapping issues. Possibly inefficient, but quite portable.
3384 Each time we are called, we increment the diecount variable, which
3385 keeps an approximate count of the number of dies processed for
3386 each compilation unit. This information is presented to the user
3387 if the info_verbose flag is set.
3392 completedieinfo (dip
, objfile
)
3393 struct dieinfo
*dip
;
3394 struct objfile
*objfile
;
3396 char *diep
; /* Current pointer into raw DIE data */
3397 char *end
; /* Terminate DIE scan here */
3398 unsigned short attr
; /* Current attribute being scanned */
3399 unsigned short form
; /* Form of the attribute */
3400 int nbytes
; /* Size of next field to read */
3404 end
= diep
+ dip
-> die_length
;
3405 diep
+= SIZEOF_DIE_LENGTH
+ SIZEOF_DIE_TAG
;
3408 attr
= target_to_host (diep
, SIZEOF_ATTRIBUTE
, GET_UNSIGNED
, objfile
);
3409 diep
+= SIZEOF_ATTRIBUTE
;
3410 if ((nbytes
= attribute_size (attr
)) == -1)
3412 SQUAWK (("unknown attribute length, skipped remaining attributes"));;
3419 dip
-> at_fund_type
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3423 dip
-> at_ordering
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3427 dip
-> at_bit_offset
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3431 dip
-> at_sibling
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3435 dip
-> at_stmt_list
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3437 dip
-> has_at_stmt_list
= 1;
3440 dip
-> at_low_pc
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3442 dip
-> at_low_pc
+= baseaddr
;
3443 dip
-> has_at_low_pc
= 1;
3446 dip
-> at_high_pc
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3448 dip
-> at_high_pc
+= baseaddr
;
3451 dip
-> at_language
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3454 case AT_user_def_type
:
3455 dip
-> at_user_def_type
= target_to_host (diep
, nbytes
,
3456 GET_UNSIGNED
, objfile
);
3459 dip
-> at_byte_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3461 dip
-> has_at_byte_size
= 1;
3464 dip
-> at_bit_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3468 dip
-> at_member
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3472 dip
-> at_discr
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3476 dip
-> at_location
= diep
;
3478 case AT_mod_fund_type
:
3479 dip
-> at_mod_fund_type
= diep
;
3481 case AT_subscr_data
:
3482 dip
-> at_subscr_data
= diep
;
3484 case AT_mod_u_d_type
:
3485 dip
-> at_mod_u_d_type
= diep
;
3487 case AT_element_list
:
3488 dip
-> at_element_list
= diep
;
3489 dip
-> short_element_list
= 0;
3491 case AT_short_element_list
:
3492 dip
-> at_element_list
= diep
;
3493 dip
-> short_element_list
= 1;
3495 case AT_discr_value
:
3496 dip
-> at_discr_value
= diep
;
3498 case AT_string_length
:
3499 dip
-> at_string_length
= diep
;
3502 dip
-> at_name
= diep
;
3505 /* For now, ignore any "hostname:" portion, since gdb doesn't
3506 know how to deal with it. (FIXME). */
3507 dip
-> at_comp_dir
= strrchr (diep
, ':');
3508 if (dip
-> at_comp_dir
!= NULL
)
3510 dip
-> at_comp_dir
++;
3514 dip
-> at_comp_dir
= diep
;
3518 dip
-> at_producer
= diep
;
3520 case AT_start_scope
:
3521 dip
-> at_start_scope
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3524 case AT_stride_size
:
3525 dip
-> at_stride_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3529 dip
-> at_src_info
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3533 dip
-> at_prototyped
= diep
;
3536 /* Found an attribute that we are unprepared to handle. However
3537 it is specifically one of the design goals of DWARF that
3538 consumers should ignore unknown attributes. As long as the
3539 form is one that we recognize (so we know how to skip it),
3540 we can just ignore the unknown attribute. */
3543 form
= FORM_FROM_ATTR (attr
);
3557 diep
+= TARGET_FT_POINTER_SIZE (objfile
);
3560 diep
+= 2 + target_to_host (diep
, nbytes
, GET_UNSIGNED
, objfile
);
3563 diep
+= 4 + target_to_host (diep
, nbytes
, GET_UNSIGNED
, objfile
);
3566 diep
+= strlen (diep
) + 1;
3569 SQUAWK (("unknown attribute form (0x%x)", form
));
3570 SQUAWK (("unknown attribute length, skipped remaining attributes"));;
3581 target_to_host -- swap in target data to host
3585 target_to_host (char *from, int nbytes, int signextend,
3586 struct objfile *objfile)
3590 Given pointer to data in target format in FROM, a byte count for
3591 the size of the data in NBYTES, a flag indicating whether or not
3592 the data is signed in SIGNEXTEND, and a pointer to the current
3593 objfile in OBJFILE, convert the data to host format and return
3594 the converted value.
3598 FIXME: If we read data that is known to be signed, and expect to
3599 use it as signed data, then we need to explicitly sign extend the
3600 result until the bfd library is able to do this for us.
3604 static unsigned long
3605 target_to_host (from
, nbytes
, signextend
, objfile
)
3608 int signextend
; /* FIXME: Unused */
3609 struct objfile
*objfile
;
3611 unsigned long rtnval
;
3616 rtnval
= bfd_get_64 (objfile
-> obfd
, (bfd_byte
*) from
);
3619 rtnval
= bfd_get_32 (objfile
-> obfd
, (bfd_byte
*) from
);
3622 rtnval
= bfd_get_16 (objfile
-> obfd
, (bfd_byte
*) from
);
3625 rtnval
= bfd_get_8 (objfile
-> obfd
, (bfd_byte
*) from
);
3628 dwarfwarn ("no bfd support for %d byte data object", nbytes
);
3639 attribute_size -- compute size of data for a DWARF attribute
3643 static int attribute_size (unsigned int attr)
3647 Given a DWARF attribute in ATTR, compute the size of the first
3648 piece of data associated with this attribute and return that
3651 Returns -1 for unrecognized attributes.
3656 attribute_size (attr
)
3659 int nbytes
; /* Size of next data for this attribute */
3660 unsigned short form
; /* Form of the attribute */
3662 form
= FORM_FROM_ATTR (attr
);
3665 case FORM_STRING
: /* A variable length field is next */
3668 case FORM_DATA2
: /* Next 2 byte field is the data itself */
3669 case FORM_BLOCK2
: /* Next 2 byte field is a block length */
3672 case FORM_DATA4
: /* Next 4 byte field is the data itself */
3673 case FORM_BLOCK4
: /* Next 4 byte field is a block length */
3674 case FORM_REF
: /* Next 4 byte field is a DIE offset */
3677 case FORM_DATA8
: /* Next 8 byte field is the data itself */
3680 case FORM_ADDR
: /* Next field size is target sizeof(void *) */
3681 nbytes
= TARGET_FT_POINTER_SIZE (objfile
);
3684 SQUAWK (("unknown attribute form (0x%x)", form
));