1 /* DWARF debugging format support for GDB.
2 Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996
3 Free Software Foundation, Inc.
4 Written by Fred Fish at Cygnus Support. Portions based on dbxread.c,
5 mipsread.c, coffread.c, and dwarfread.c from a Data General SVR4 gdb port.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
25 FIXME: Do we need to generate dependencies in partial symtabs?
26 (Perhaps we don't need to).
28 FIXME: Resolve minor differences between what information we put in the
29 partial symbol table and what dbxread puts in. For example, we don't yet
30 put enum constants there. And dbxread seems to invent a lot of typedefs
31 we never see. Use the new printpsym command to see the partial symbol table
34 FIXME: Figure out a better way to tell gdb about the name of the function
35 contain the user's entry point (I.E. main())
37 FIXME: See other FIXME's and "ifdef 0" scattered throughout the code for
38 other things to work on, if you get bored. :-)
47 #include "elf/dwarf.h"
50 #include "expression.h" /* Needed for enum exp_opcode in language.h, sigh... */
52 #include "complaints.h"
55 #include "gdb_string.h"
61 /* Some macros to provide DIE info for complaints. */
63 #define DIE_ID (curdie!=NULL ? curdie->die_ref : 0)
64 #define DIE_NAME (curdie!=NULL && curdie->at_name!=NULL) ? curdie->at_name : ""
66 /* Complaints that can be issued during DWARF debug info reading. */
68 struct complaint no_bfd_get_N
=
70 "DIE @ 0x%x \"%s\", no bfd support for %d byte data object", 0, 0
73 struct complaint malformed_die
=
75 "DIE @ 0x%x \"%s\", malformed DIE, bad length (%d bytes)", 0, 0
78 struct complaint bad_die_ref
=
80 "DIE @ 0x%x \"%s\", reference to DIE (0x%x) outside compilation unit", 0, 0
83 struct complaint unknown_attribute_form
=
85 "DIE @ 0x%x \"%s\", unknown attribute form (0x%x)", 0, 0
88 struct complaint unknown_attribute_length
=
90 "DIE @ 0x%x \"%s\", unknown attribute length, skipped remaining attributes", 0, 0
93 struct complaint unexpected_fund_type
=
95 "DIE @ 0x%x \"%s\", unexpected fundamental type 0x%x", 0, 0
98 struct complaint unknown_type_modifier
=
100 "DIE @ 0x%x \"%s\", unknown type modifier %u", 0, 0
103 struct complaint volatile_ignored
=
105 "DIE @ 0x%x \"%s\", type modifier 'volatile' ignored", 0, 0
108 struct complaint const_ignored
=
110 "DIE @ 0x%x \"%s\", type modifier 'const' ignored", 0, 0
113 struct complaint botched_modified_type
=
115 "DIE @ 0x%x \"%s\", botched modified type decoding (mtype 0x%x)", 0, 0
118 struct complaint op_deref2
=
120 "DIE @ 0x%x \"%s\", OP_DEREF2 address 0x%x not handled", 0, 0
123 struct complaint op_deref4
=
125 "DIE @ 0x%x \"%s\", OP_DEREF4 address 0x%x not handled", 0, 0
128 struct complaint basereg_not_handled
=
130 "DIE @ 0x%x \"%s\", BASEREG %d not handled", 0, 0
133 struct complaint dup_user_type_allocation
=
135 "DIE @ 0x%x \"%s\", internal error: duplicate user type allocation", 0, 0
138 struct complaint dup_user_type_definition
=
140 "DIE @ 0x%x \"%s\", internal error: duplicate user type definition", 0, 0
143 struct complaint missing_tag
=
145 "DIE @ 0x%x \"%s\", missing class, structure, or union tag", 0, 0
148 struct complaint bad_array_element_type
=
150 "DIE @ 0x%x \"%s\", bad array element type attribute 0x%x", 0, 0
153 struct complaint subscript_data_items
=
155 "DIE @ 0x%x \"%s\", can't decode subscript data items", 0, 0
158 struct complaint unhandled_array_subscript_format
=
160 "DIE @ 0x%x \"%s\", array subscript format 0x%x not handled yet", 0, 0
163 struct complaint unknown_array_subscript_format
=
165 "DIE @ 0x%x \"%s\", unknown array subscript format %x", 0, 0
168 struct complaint not_row_major
=
170 "DIE @ 0x%x \"%s\", array not row major; not handled correctly", 0, 0
173 struct complaint missing_at_name
=
175 "DIE @ 0x%x, AT_name tag missing", 0, 0
178 typedef unsigned int DIE_REF
; /* Reference to a DIE */
181 #define GCC_PRODUCER "GNU C "
184 #ifndef GPLUS_PRODUCER
185 #define GPLUS_PRODUCER "GNU C++ "
189 #define LCC_PRODUCER "NCR C/C++"
192 #ifndef CHILL_PRODUCER
193 #define CHILL_PRODUCER "GNU Chill "
196 /* Provide a default mapping from a DWARF register number to a gdb REGNUM. */
197 #ifndef DWARF_REG_TO_REGNUM
198 #define DWARF_REG_TO_REGNUM(num) (num)
201 /* Flags to target_to_host() that tell whether or not the data object is
202 expected to be signed. Used, for example, when fetching a signed
203 integer in the target environment which is used as a signed integer
204 in the host environment, and the two environments have different sized
205 ints. In this case, *somebody* has to sign extend the smaller sized
208 #define GET_UNSIGNED 0 /* No sign extension required */
209 #define GET_SIGNED 1 /* Sign extension required */
211 /* Defines for things which are specified in the document "DWARF Debugging
212 Information Format" published by UNIX International, Programming Languages
213 SIG. These defines are based on revision 1.0.0, Jan 20, 1992. */
215 #define SIZEOF_DIE_LENGTH 4
216 #define SIZEOF_DIE_TAG 2
217 #define SIZEOF_ATTRIBUTE 2
218 #define SIZEOF_FORMAT_SPECIFIER 1
219 #define SIZEOF_FMT_FT 2
220 #define SIZEOF_LINETBL_LENGTH 4
221 #define SIZEOF_LINETBL_LINENO 4
222 #define SIZEOF_LINETBL_STMT 2
223 #define SIZEOF_LINETBL_DELTA 4
224 #define SIZEOF_LOC_ATOM_CODE 1
226 #define FORM_FROM_ATTR(attr) ((attr) & 0xF) /* Implicitly specified */
228 /* Macros that return the sizes of various types of data in the target
231 FIXME: Currently these are just compile time constants (as they are in
232 other parts of gdb as well). They need to be able to get the right size
233 either from the bfd or possibly from the DWARF info. It would be nice if
234 the DWARF producer inserted DIES that describe the fundamental types in
235 the target environment into the DWARF info, similar to the way dbx stabs
236 producers produce information about their fundamental types. */
238 #define TARGET_FT_POINTER_SIZE(objfile) (TARGET_PTR_BIT / TARGET_CHAR_BIT)
239 #define TARGET_FT_LONG_SIZE(objfile) (TARGET_LONG_BIT / TARGET_CHAR_BIT)
241 /* The Amiga SVR4 header file <dwarf.h> defines AT_element_list as a
242 FORM_BLOCK2, and this is the value emitted by the AT&T compiler.
243 However, the Issue 2 DWARF specification from AT&T defines it as
244 a FORM_BLOCK4, as does the latest specification from UI/PLSIG.
245 For backwards compatibility with the AT&T compiler produced executables
246 we define AT_short_element_list for this variant. */
248 #define AT_short_element_list (0x00f0|FORM_BLOCK2)
250 /* External variables referenced. */
252 extern int info_verbose
; /* From main.c; nonzero => verbose */
253 extern char *warning_pre_print
; /* From utils.c */
255 /* The DWARF debugging information consists of two major pieces,
256 one is a block of DWARF Information Entries (DIE's) and the other
257 is a line number table. The "struct dieinfo" structure contains
258 the information for a single DIE, the one currently being processed.
260 In order to make it easier to randomly access the attribute fields
261 of the current DIE, which are specifically unordered within the DIE,
262 each DIE is scanned and an instance of the "struct dieinfo"
263 structure is initialized.
265 Initialization is done in two levels. The first, done by basicdieinfo(),
266 just initializes those fields that are vital to deciding whether or not
267 to use this DIE, how to skip past it, etc. The second, done by the
268 function completedieinfo(), fills in the rest of the information.
270 Attributes which have block forms are not interpreted at the time
271 the DIE is scanned, instead we just save pointers to the start
272 of their value fields.
274 Some fields have a flag <name>_p that is set when the value of the
275 field is valid (I.E. we found a matching attribute in the DIE). Since
276 we may want to test for the presence of some attributes in the DIE,
277 such as AT_low_pc, without restricting the values of the field,
278 we need someway to note that we found such an attribute.
285 char * die
; /* Pointer to the raw DIE data */
286 unsigned long die_length
; /* Length of the raw DIE data */
287 DIE_REF die_ref
; /* Offset of this DIE */
288 unsigned short die_tag
; /* Tag for this DIE */
289 unsigned long at_padding
;
290 unsigned long at_sibling
;
293 unsigned short at_fund_type
;
294 BLOCK
* at_mod_fund_type
;
295 unsigned long at_user_def_type
;
296 BLOCK
* at_mod_u_d_type
;
297 unsigned short at_ordering
;
298 BLOCK
* at_subscr_data
;
299 unsigned long at_byte_size
;
300 unsigned short at_bit_offset
;
301 unsigned long at_bit_size
;
302 BLOCK
* at_element_list
;
303 unsigned long at_stmt_list
;
305 CORE_ADDR at_high_pc
;
306 unsigned long at_language
;
307 unsigned long at_member
;
308 unsigned long at_discr
;
309 BLOCK
* at_discr_value
;
310 BLOCK
* at_string_length
;
313 unsigned long at_start_scope
;
314 unsigned long at_stride_size
;
315 unsigned long at_src_info
;
316 char * at_prototyped
;
317 unsigned int has_at_low_pc
:1;
318 unsigned int has_at_stmt_list
:1;
319 unsigned int has_at_byte_size
:1;
320 unsigned int short_element_list
:1;
323 static int diecount
; /* Approximate count of dies for compilation unit */
324 static struct dieinfo
*curdie
; /* For warnings and such */
326 static char *dbbase
; /* Base pointer to dwarf info */
327 static int dbsize
; /* Size of dwarf info in bytes */
328 static int dbroff
; /* Relative offset from start of .debug section */
329 static char *lnbase
; /* Base pointer to line section */
330 static int isreg
; /* Kludge to identify register variables */
331 static int optimized_out
; /* Kludge to identify optimized out variables */
332 /* Kludge to identify basereg references. Nonzero if we have an offset
333 relative to a basereg. */
335 /* Which base register is it relative to? */
338 /* This value is added to each symbol value. FIXME: Generalize to
339 the section_offsets structure used by dbxread (once this is done,
340 pass the appropriate section number to end_symtab). */
341 static CORE_ADDR baseaddr
; /* Add to each symbol value */
343 /* The section offsets used in the current psymtab or symtab. FIXME,
344 only used to pass one value (baseaddr) at the moment. */
345 static struct section_offsets
*base_section_offsets
;
347 /* We put a pointer to this structure in the read_symtab_private field
351 /* Always the absolute file offset to the start of the ".debug"
352 section for the file containing the DIE's being accessed. */
354 /* Relative offset from the start of the ".debug" section to the
355 first DIE to be accessed. When building the partial symbol
356 table, this value will be zero since we are accessing the
357 entire ".debug" section. When expanding a partial symbol
358 table entry, this value will be the offset to the first
359 DIE for the compilation unit containing the symbol that
360 triggers the expansion. */
362 /* The size of the chunk of DIE's being examined, in bytes. */
364 /* The absolute file offset to the line table fragment. Ignored
365 when building partial symbol tables, but used when expanding
366 them, and contains the absolute file offset to the fragment
367 of the ".line" section containing the line numbers for the
368 current compilation unit. */
372 #define DBFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbfoff)
373 #define DBROFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbroff)
374 #define DBLENGTH(p) (((struct dwfinfo *)((p)->read_symtab_private))->dblength)
375 #define LNFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->lnfoff)
377 /* The generic symbol table building routines have separate lists for
378 file scope symbols and all all other scopes (local scopes). So
379 we need to select the right one to pass to add_symbol_to_list().
380 We do it by keeping a pointer to the correct list in list_in_scope.
382 FIXME: The original dwarf code just treated the file scope as the first
383 local scope, and all other local scopes as nested local scopes, and worked
384 fine. Check to see if we really need to distinguish these in buildsym.c */
386 struct pending
**list_in_scope
= &file_symbols
;
388 /* DIES which have user defined types or modified user defined types refer to
389 other DIES for the type information. Thus we need to associate the offset
390 of a DIE for a user defined type with a pointer to the type information.
392 Originally this was done using a simple but expensive algorithm, with an
393 array of unsorted structures, each containing an offset/type-pointer pair.
394 This array was scanned linearly each time a lookup was done. The result
395 was that gdb was spending over half it's startup time munging through this
396 array of pointers looking for a structure that had the right offset member.
398 The second attempt used the same array of structures, but the array was
399 sorted using qsort each time a new offset/type was recorded, and a binary
400 search was used to find the type pointer for a given DIE offset. This was
401 even slower, due to the overhead of sorting the array each time a new
402 offset/type pair was entered.
404 The third attempt uses a fixed size array of type pointers, indexed by a
405 value derived from the DIE offset. Since the minimum DIE size is 4 bytes,
406 we can divide any DIE offset by 4 to obtain a unique index into this fixed
407 size array. Since each element is a 4 byte pointer, it takes exactly as
408 much memory to hold this array as to hold the DWARF info for a given
409 compilation unit. But it gets freed as soon as we are done with it.
410 This has worked well in practice, as a reasonable tradeoff between memory
411 consumption and speed, without having to resort to much more complicated
414 static struct type
**utypes
; /* Pointer to array of user type pointers */
415 static int numutypes
; /* Max number of user type pointers */
417 /* Maintain an array of referenced fundamental types for the current
418 compilation unit being read. For DWARF version 1, we have to construct
419 the fundamental types on the fly, since no information about the
420 fundamental types is supplied. Each such fundamental type is created by
421 calling a language dependent routine to create the type, and then a
422 pointer to that type is then placed in the array at the index specified
423 by it's FT_<TYPENAME> value. The array has a fixed size set by the
424 FT_NUM_MEMBERS compile time constant, which is the number of predefined
425 fundamental types gdb knows how to construct. */
427 static struct type
*ftypes
[FT_NUM_MEMBERS
]; /* Fundamental types */
429 /* Record the language for the compilation unit which is currently being
430 processed. We know it once we have seen the TAG_compile_unit DIE,
431 and we need it while processing the DIE's for that compilation unit.
432 It is eventually saved in the symtab structure, but we don't finalize
433 the symtab struct until we have processed all the DIE's for the
434 compilation unit. We also need to get and save a pointer to the
435 language struct for this language, so we can call the language
436 dependent routines for doing things such as creating fundamental
439 static enum language cu_language
;
440 static const struct language_defn
*cu_language_defn
;
442 /* Forward declarations of static functions so we don't have to worry
443 about ordering within this file. */
446 attribute_size
PARAMS ((unsigned int));
449 target_to_host
PARAMS ((char *, int, int, struct objfile
*));
452 add_enum_psymbol
PARAMS ((struct dieinfo
*, struct objfile
*));
455 handle_producer
PARAMS ((char *));
458 read_file_scope
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
461 read_func_scope
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
464 read_lexical_block_scope
PARAMS ((struct dieinfo
*, char *, char *,
468 scan_partial_symbols
PARAMS ((char *, char *, struct objfile
*));
471 scan_compilation_units
PARAMS ((char *, char *, file_ptr
,
472 file_ptr
, struct objfile
*));
475 add_partial_symbol
PARAMS ((struct dieinfo
*, struct objfile
*));
478 basicdieinfo
PARAMS ((struct dieinfo
*, char *, struct objfile
*));
481 completedieinfo
PARAMS ((struct dieinfo
*, struct objfile
*));
484 dwarf_psymtab_to_symtab
PARAMS ((struct partial_symtab
*));
487 psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*));
490 read_ofile_symtab
PARAMS ((struct partial_symtab
*));
493 process_dies
PARAMS ((char *, char *, struct objfile
*));
496 read_structure_scope
PARAMS ((struct dieinfo
*, char *, char *,
500 decode_array_element_type
PARAMS ((char *));
503 decode_subscript_data_item
PARAMS ((char *, char *));
506 dwarf_read_array_type
PARAMS ((struct dieinfo
*));
509 read_tag_pointer_type
PARAMS ((struct dieinfo
*dip
));
512 read_tag_string_type
PARAMS ((struct dieinfo
*dip
));
515 read_subroutine_type
PARAMS ((struct dieinfo
*, char *, char *));
518 read_enumeration
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
521 struct_type
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
524 enum_type
PARAMS ((struct dieinfo
*, struct objfile
*));
527 decode_line_numbers
PARAMS ((char *));
530 decode_die_type
PARAMS ((struct dieinfo
*));
533 decode_mod_fund_type
PARAMS ((char *));
536 decode_mod_u_d_type
PARAMS ((char *));
539 decode_modified_type
PARAMS ((char *, unsigned int, int));
542 decode_fund_type
PARAMS ((unsigned int));
545 create_name
PARAMS ((char *, struct obstack
*));
548 lookup_utype
PARAMS ((DIE_REF
));
551 alloc_utype
PARAMS ((DIE_REF
, struct type
*));
553 static struct symbol
*
554 new_symbol
PARAMS ((struct dieinfo
*, struct objfile
*));
557 synthesize_typedef
PARAMS ((struct dieinfo
*, struct objfile
*,
561 locval
PARAMS ((char *));
564 set_cu_language
PARAMS ((struct dieinfo
*));
567 dwarf_fundamental_type
PARAMS ((struct objfile
*, int));
574 dwarf_fundamental_type -- lookup or create a fundamental type
579 dwarf_fundamental_type (struct objfile *objfile, int typeid)
583 DWARF version 1 doesn't supply any fundamental type information,
584 so gdb has to construct such types. It has a fixed number of
585 fundamental types that it knows how to construct, which is the
586 union of all types that it knows how to construct for all languages
587 that it knows about. These are enumerated in gdbtypes.h.
589 As an example, assume we find a DIE that references a DWARF
590 fundamental type of FT_integer. We first look in the ftypes
591 array to see if we already have such a type, indexed by the
592 gdb internal value of FT_INTEGER. If so, we simply return a
593 pointer to that type. If not, then we ask an appropriate
594 language dependent routine to create a type FT_INTEGER, using
595 defaults reasonable for the current target machine, and install
596 that type in ftypes for future reference.
600 Pointer to a fundamental type.
605 dwarf_fundamental_type (objfile
, typeid)
606 struct objfile
*objfile
;
609 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
611 error ("internal error - invalid fundamental type id %d", typeid);
614 /* Look for this particular type in the fundamental type vector. If one is
615 not found, create and install one appropriate for the current language
616 and the current target machine. */
618 if (ftypes
[typeid] == NULL
)
620 ftypes
[typeid] = cu_language_defn
-> la_fund_type(objfile
, typeid);
623 return (ftypes
[typeid]);
630 set_cu_language -- set local copy of language for compilation unit
635 set_cu_language (struct dieinfo *dip)
639 Decode the language attribute for a compilation unit DIE and
640 remember what the language was. We use this at various times
641 when processing DIE's for a given compilation unit.
650 set_cu_language (dip
)
653 switch (dip
-> at_language
)
657 cu_language
= language_c
;
659 case LANG_C_PLUS_PLUS
:
660 cu_language
= language_cplus
;
663 cu_language
= language_chill
;
666 cu_language
= language_m2
;
674 /* We don't know anything special about these yet. */
675 cu_language
= language_unknown
;
678 /* If no at_language, try to deduce one from the filename */
679 cu_language
= deduce_language_from_filename (dip
-> at_name
);
682 cu_language_defn
= language_def (cu_language
);
689 dwarf_build_psymtabs -- build partial symtabs from DWARF debug info
693 void dwarf_build_psymtabs (struct objfile *objfile,
694 struct section_offsets *section_offsets,
695 int mainline, file_ptr dbfoff, unsigned int dbfsize,
696 file_ptr lnoffset, unsigned int lnsize)
700 This function is called upon to build partial symtabs from files
701 containing DIE's (Dwarf Information Entries) and DWARF line numbers.
703 It is passed a bfd* containing the DIES
704 and line number information, the corresponding filename for that
705 file, a base address for relocating the symbols, a flag indicating
706 whether or not this debugging information is from a "main symbol
707 table" rather than a shared library or dynamically linked file,
708 and file offset/size pairs for the DIE information and line number
718 dwarf_build_psymtabs (objfile
, section_offsets
, mainline
, dbfoff
, dbfsize
,
720 struct objfile
*objfile
;
721 struct section_offsets
*section_offsets
;
724 unsigned int dbfsize
;
728 bfd
*abfd
= objfile
->obfd
;
729 struct cleanup
*back_to
;
731 current_objfile
= objfile
;
733 dbbase
= xmalloc (dbsize
);
735 if ((bfd_seek (abfd
, dbfoff
, SEEK_SET
) != 0) ||
736 (bfd_read (dbbase
, dbsize
, 1, abfd
) != dbsize
))
739 error ("can't read DWARF data from '%s'", bfd_get_filename (abfd
));
741 back_to
= make_cleanup (free
, dbbase
);
743 /* If we are reinitializing, or if we have never loaded syms yet, init.
744 Since we have no idea how many DIES we are looking at, we just guess
745 some arbitrary value. */
747 if (mainline
|| objfile
-> global_psymbols
.size
== 0 ||
748 objfile
-> static_psymbols
.size
== 0)
750 init_psymbol_list (objfile
, 1024);
753 /* Save the relocation factor where everybody can see it. */
755 base_section_offsets
= section_offsets
;
756 baseaddr
= ANOFFSET (section_offsets
, 0);
758 /* Follow the compilation unit sibling chain, building a partial symbol
759 table entry for each one. Save enough information about each compilation
760 unit to locate the full DWARF information later. */
762 scan_compilation_units (dbbase
, dbbase
+ dbsize
, dbfoff
, lnoffset
, objfile
);
764 do_cleanups (back_to
);
765 current_objfile
= NULL
;
772 read_lexical_block_scope -- process all dies in a lexical block
776 static void read_lexical_block_scope (struct dieinfo *dip,
777 char *thisdie, char *enddie)
781 Process all the DIES contained within a lexical block scope.
782 Start a new scope, process the dies, and then close the scope.
787 read_lexical_block_scope (dip
, thisdie
, enddie
, objfile
)
791 struct objfile
*objfile
;
793 register struct context_stack
*new;
795 push_context (0, dip
-> at_low_pc
);
796 process_dies (thisdie
+ dip
-> die_length
, enddie
, objfile
);
797 new = pop_context ();
798 if (local_symbols
!= NULL
)
800 finish_block (0, &local_symbols
, new -> old_blocks
, new -> start_addr
,
801 dip
-> at_high_pc
, objfile
);
803 local_symbols
= new -> locals
;
810 lookup_utype -- look up a user defined type from die reference
814 static type *lookup_utype (DIE_REF die_ref)
818 Given a DIE reference, lookup the user defined type associated with
819 that DIE, if it has been registered already. If not registered, then
820 return NULL. Alloc_utype() can be called to register an empty
821 type for this reference, which will be filled in later when the
822 actual referenced DIE is processed.
826 lookup_utype (die_ref
)
829 struct type
*type
= NULL
;
832 utypeidx
= (die_ref
- dbroff
) / 4;
833 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
835 complain (&bad_die_ref
, DIE_ID
, DIE_NAME
);
839 type
= *(utypes
+ utypeidx
);
849 alloc_utype -- add a user defined type for die reference
853 static type *alloc_utype (DIE_REF die_ref, struct type *utypep)
857 Given a die reference DIE_REF, and a possible pointer to a user
858 defined type UTYPEP, register that this reference has a user
859 defined type and either use the specified type in UTYPEP or
860 make a new empty type that will be filled in later.
862 We should only be called after calling lookup_utype() to verify that
863 there is not currently a type registered for DIE_REF.
867 alloc_utype (die_ref
, utypep
)
874 utypeidx
= (die_ref
- dbroff
) / 4;
875 typep
= utypes
+ utypeidx
;
876 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
878 utypep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
879 complain (&bad_die_ref
, DIE_ID
, DIE_NAME
);
881 else if (*typep
!= NULL
)
884 complain (&dup_user_type_allocation
, DIE_ID
, DIE_NAME
);
890 utypep
= alloc_type (current_objfile
);
901 free_utypes -- free the utypes array and reset pointer & count
905 static void free_utypes (PTR dummy)
909 Called via do_cleanups to free the utypes array, reset the pointer to NULL,
910 and set numutypes back to zero. This ensures that the utypes does not get
911 referenced after being freed.
928 decode_die_type -- return a type for a specified die
932 static struct type *decode_die_type (struct dieinfo *dip)
936 Given a pointer to a die information structure DIP, decode the
937 type of the die and return a pointer to the decoded type. All
938 dies without specific types default to type int.
942 decode_die_type (dip
)
945 struct type
*type
= NULL
;
947 if (dip
-> at_fund_type
!= 0)
949 type
= decode_fund_type (dip
-> at_fund_type
);
951 else if (dip
-> at_mod_fund_type
!= NULL
)
953 type
= decode_mod_fund_type (dip
-> at_mod_fund_type
);
955 else if (dip
-> at_user_def_type
)
957 if ((type
= lookup_utype (dip
-> at_user_def_type
)) == NULL
)
959 type
= alloc_utype (dip
-> at_user_def_type
, NULL
);
962 else if (dip
-> at_mod_u_d_type
)
964 type
= decode_mod_u_d_type (dip
-> at_mod_u_d_type
);
968 type
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
977 struct_type -- compute and return the type for a struct or union
981 static struct type *struct_type (struct dieinfo *dip, char *thisdie,
982 char *enddie, struct objfile *objfile)
986 Given pointer to a die information structure for a die which
987 defines a union or structure (and MUST define one or the other),
988 and pointers to the raw die data that define the range of dies which
989 define the members, compute and return the user defined type for the
994 struct_type (dip
, thisdie
, enddie
, objfile
)
998 struct objfile
*objfile
;
1002 struct nextfield
*next
;
1005 struct nextfield
*list
= NULL
;
1006 struct nextfield
*new;
1013 if ((type
= lookup_utype (dip
-> die_ref
)) == NULL
)
1015 /* No forward references created an empty type, so install one now */
1016 type
= alloc_utype (dip
-> die_ref
, NULL
);
1018 INIT_CPLUS_SPECIFIC(type
);
1019 switch (dip
-> die_tag
)
1021 case TAG_class_type
:
1022 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
1024 case TAG_structure_type
:
1025 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
1027 case TAG_union_type
:
1028 TYPE_CODE (type
) = TYPE_CODE_UNION
;
1031 /* Should never happen */
1032 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
1033 complain (&missing_tag
, DIE_ID
, DIE_NAME
);
1036 /* Some compilers try to be helpful by inventing "fake" names for
1037 anonymous enums, structures, and unions, like "~0fake" or ".0fake".
1038 Thanks, but no thanks... */
1039 if (dip
-> at_name
!= NULL
1040 && *dip
-> at_name
!= '~'
1041 && *dip
-> at_name
!= '.')
1043 TYPE_TAG_NAME (type
) = obconcat (&objfile
-> type_obstack
,
1044 "", "", dip
-> at_name
);
1046 /* Use whatever size is known. Zero is a valid size. We might however
1047 wish to check has_at_byte_size to make sure that some byte size was
1048 given explicitly, but DWARF doesn't specify that explicit sizes of
1049 zero have to present, so complaining about missing sizes should
1050 probably not be the default. */
1051 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
1052 thisdie
+= dip
-> die_length
;
1053 while (thisdie
< enddie
)
1055 basicdieinfo (&mbr
, thisdie
, objfile
);
1056 completedieinfo (&mbr
, objfile
);
1057 if (mbr
.die_length
<= SIZEOF_DIE_LENGTH
)
1061 else if (mbr
.at_sibling
!= 0)
1063 nextdie
= dbbase
+ mbr
.at_sibling
- dbroff
;
1067 nextdie
= thisdie
+ mbr
.die_length
;
1069 switch (mbr
.die_tag
)
1072 /* Get space to record the next field's data. */
1073 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1076 /* Save the data. */
1077 list
-> field
.name
=
1078 obsavestring (mbr
.at_name
, strlen (mbr
.at_name
),
1079 &objfile
-> type_obstack
);
1080 list
-> field
.type
= decode_die_type (&mbr
);
1081 list
-> field
.bitpos
= 8 * locval (mbr
.at_location
);
1082 /* Handle bit fields. */
1083 list
-> field
.bitsize
= mbr
.at_bit_size
;
1084 if (BITS_BIG_ENDIAN
)
1086 /* For big endian bits, the at_bit_offset gives the
1087 additional bit offset from the MSB of the containing
1088 anonymous object to the MSB of the field. We don't
1089 have to do anything special since we don't need to
1090 know the size of the anonymous object. */
1091 list
-> field
.bitpos
+= mbr
.at_bit_offset
;
1095 /* For little endian bits, we need to have a non-zero
1096 at_bit_size, so that we know we are in fact dealing
1097 with a bitfield. Compute the bit offset to the MSB
1098 of the anonymous object, subtract off the number of
1099 bits from the MSB of the field to the MSB of the
1100 object, and then subtract off the number of bits of
1101 the field itself. The result is the bit offset of
1102 the LSB of the field. */
1103 if (mbr
.at_bit_size
> 0)
1105 if (mbr
.has_at_byte_size
)
1107 /* The size of the anonymous object containing
1108 the bit field is explicit, so use the
1109 indicated size (in bytes). */
1110 anonymous_size
= mbr
.at_byte_size
;
1114 /* The size of the anonymous object containing
1115 the bit field matches the size of an object
1116 of the bit field's type. DWARF allows
1117 at_byte_size to be left out in such cases, as
1118 a debug information size optimization. */
1119 anonymous_size
= TYPE_LENGTH (list
-> field
.type
);
1121 list
-> field
.bitpos
+=
1122 anonymous_size
* 8 - mbr
.at_bit_offset
- mbr
.at_bit_size
;
1128 process_dies (thisdie
, nextdie
, objfile
);
1133 /* Now create the vector of fields, and record how big it is. We may
1134 not even have any fields, if this DIE was generated due to a reference
1135 to an anonymous structure or union. In this case, TYPE_FLAG_STUB is
1136 set, which clues gdb in to the fact that it needs to search elsewhere
1137 for the full structure definition. */
1140 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
1144 TYPE_NFIELDS (type
) = nfields
;
1145 TYPE_FIELDS (type
) = (struct field
*)
1146 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
1147 /* Copy the saved-up fields into the field vector. */
1148 for (n
= nfields
; list
; list
= list
-> next
)
1150 TYPE_FIELD (type
, --n
) = list
-> field
;
1160 read_structure_scope -- process all dies within struct or union
1164 static void read_structure_scope (struct dieinfo *dip,
1165 char *thisdie, char *enddie, struct objfile *objfile)
1169 Called when we find the DIE that starts a structure or union
1170 scope (definition) to process all dies that define the members
1171 of the structure or union. DIP is a pointer to the die info
1172 struct for the DIE that names the structure or union.
1176 Note that we need to call struct_type regardless of whether or not
1177 the DIE has an at_name attribute, since it might be an anonymous
1178 structure or union. This gets the type entered into our set of
1181 However, if the structure is incomplete (an opaque struct/union)
1182 then suppress creating a symbol table entry for it since gdb only
1183 wants to find the one with the complete definition. Note that if
1184 it is complete, we just call new_symbol, which does it's own
1185 checking about whether the struct/union is anonymous or not (and
1186 suppresses creating a symbol table entry itself).
1191 read_structure_scope (dip
, thisdie
, enddie
, objfile
)
1192 struct dieinfo
*dip
;
1195 struct objfile
*objfile
;
1200 type
= struct_type (dip
, thisdie
, enddie
, objfile
);
1201 if (!(TYPE_FLAGS (type
) & TYPE_FLAG_STUB
))
1203 sym
= new_symbol (dip
, objfile
);
1206 SYMBOL_TYPE (sym
) = type
;
1207 if (cu_language
== language_cplus
)
1209 synthesize_typedef (dip
, objfile
, type
);
1219 decode_array_element_type -- decode type of the array elements
1223 static struct type *decode_array_element_type (char *scan, char *end)
1227 As the last step in decoding the array subscript information for an
1228 array DIE, we need to decode the type of the array elements. We are
1229 passed a pointer to this last part of the subscript information and
1230 must return the appropriate type. If the type attribute is not
1231 recognized, just warn about the problem and return type int.
1234 static struct type
*
1235 decode_array_element_type (scan
)
1240 unsigned short attribute
;
1241 unsigned short fundtype
;
1244 attribute
= target_to_host (scan
, SIZEOF_ATTRIBUTE
, GET_UNSIGNED
,
1246 scan
+= SIZEOF_ATTRIBUTE
;
1247 if ((nbytes
= attribute_size (attribute
)) == -1)
1249 complain (&bad_array_element_type
, DIE_ID
, DIE_NAME
, attribute
);
1250 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1257 fundtype
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1259 typep
= decode_fund_type (fundtype
);
1261 case AT_mod_fund_type
:
1262 typep
= decode_mod_fund_type (scan
);
1264 case AT_user_def_type
:
1265 die_ref
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1267 if ((typep
= lookup_utype (die_ref
)) == NULL
)
1269 typep
= alloc_utype (die_ref
, NULL
);
1272 case AT_mod_u_d_type
:
1273 typep
= decode_mod_u_d_type (scan
);
1276 complain (&bad_array_element_type
, DIE_ID
, DIE_NAME
, attribute
);
1277 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1288 decode_subscript_data_item -- decode array subscript item
1292 static struct type *
1293 decode_subscript_data_item (char *scan, char *end)
1297 The array subscripts and the data type of the elements of an
1298 array are described by a list of data items, stored as a block
1299 of contiguous bytes. There is a data item describing each array
1300 dimension, and a final data item describing the element type.
1301 The data items are ordered the same as their appearance in the
1302 source (I.E. leftmost dimension first, next to leftmost second,
1305 The data items describing each array dimension consist of four
1306 parts: (1) a format specifier, (2) type type of the subscript
1307 index, (3) a description of the low bound of the array dimension,
1308 and (4) a description of the high bound of the array dimension.
1310 The last data item is the description of the type of each of
1313 We are passed a pointer to the start of the block of bytes
1314 containing the remaining data items, and a pointer to the first
1315 byte past the data. This function recursively decodes the
1316 remaining data items and returns a type.
1318 If we somehow fail to decode some data, we complain about it
1319 and return a type "array of int".
1322 FIXME: This code only implements the forms currently used
1323 by the AT&T and GNU C compilers.
1325 The end pointer is supplied for error checking, maybe we should
1329 static struct type
*
1330 decode_subscript_data_item (scan
, end
)
1334 struct type
*typep
= NULL
; /* Array type we are building */
1335 struct type
*nexttype
; /* Type of each element (may be array) */
1336 struct type
*indextype
; /* Type of this index */
1337 struct type
*rangetype
;
1338 unsigned int format
;
1339 unsigned short fundtype
;
1340 unsigned long lowbound
;
1341 unsigned long highbound
;
1344 format
= target_to_host (scan
, SIZEOF_FORMAT_SPECIFIER
, GET_UNSIGNED
,
1346 scan
+= SIZEOF_FORMAT_SPECIFIER
;
1350 typep
= decode_array_element_type (scan
);
1353 fundtype
= target_to_host (scan
, SIZEOF_FMT_FT
, GET_UNSIGNED
,
1355 indextype
= decode_fund_type (fundtype
);
1356 scan
+= SIZEOF_FMT_FT
;
1357 nbytes
= TARGET_FT_LONG_SIZE (current_objfile
);
1358 lowbound
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, current_objfile
);
1360 highbound
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, current_objfile
);
1362 nexttype
= decode_subscript_data_item (scan
, end
);
1363 if (nexttype
== NULL
)
1365 /* Munged subscript data or other problem, fake it. */
1366 complain (&subscript_data_items
, DIE_ID
, DIE_NAME
);
1367 nexttype
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1369 rangetype
= create_range_type ((struct type
*) NULL
, indextype
,
1370 lowbound
, highbound
);
1371 typep
= create_array_type ((struct type
*) NULL
, nexttype
, rangetype
);
1380 complain (&unhandled_array_subscript_format
, DIE_ID
, DIE_NAME
, format
);
1381 nexttype
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1382 rangetype
= create_range_type ((struct type
*) NULL
, nexttype
, 0, 0);
1383 typep
= create_array_type ((struct type
*) NULL
, nexttype
, rangetype
);
1386 complain (&unknown_array_subscript_format
, DIE_ID
, DIE_NAME
, format
);
1387 nexttype
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1388 rangetype
= create_range_type ((struct type
*) NULL
, nexttype
, 0, 0);
1389 typep
= create_array_type ((struct type
*) NULL
, nexttype
, rangetype
);
1399 dwarf_read_array_type -- read TAG_array_type DIE
1403 static void dwarf_read_array_type (struct dieinfo *dip)
1407 Extract all information from a TAG_array_type DIE and add to
1408 the user defined type vector.
1412 dwarf_read_array_type (dip
)
1413 struct dieinfo
*dip
;
1419 unsigned short blocksz
;
1422 if (dip
-> at_ordering
!= ORD_row_major
)
1424 /* FIXME: Can gdb even handle column major arrays? */
1425 complain (¬_row_major
, DIE_ID
, DIE_NAME
);
1427 if ((sub
= dip
-> at_subscr_data
) != NULL
)
1429 nbytes
= attribute_size (AT_subscr_data
);
1430 blocksz
= target_to_host (sub
, nbytes
, GET_UNSIGNED
, current_objfile
);
1431 subend
= sub
+ nbytes
+ blocksz
;
1433 type
= decode_subscript_data_item (sub
, subend
);
1434 if ((utype
= lookup_utype (dip
-> die_ref
)) == NULL
)
1436 /* Install user defined type that has not been referenced yet. */
1437 alloc_utype (dip
-> die_ref
, type
);
1439 else if (TYPE_CODE (utype
) == TYPE_CODE_UNDEF
)
1441 /* Ick! A forward ref has already generated a blank type in our
1442 slot, and this type probably already has things pointing to it
1443 (which is what caused it to be created in the first place).
1444 If it's just a place holder we can plop our fully defined type
1445 on top of it. We can't recover the space allocated for our
1446 new type since it might be on an obstack, but we could reuse
1447 it if we kept a list of them, but it might not be worth it
1453 /* Double ick! Not only is a type already in our slot, but
1454 someone has decorated it. Complain and leave it alone. */
1455 complain (&dup_user_type_definition
, DIE_ID
, DIE_NAME
);
1464 read_tag_pointer_type -- read TAG_pointer_type DIE
1468 static void read_tag_pointer_type (struct dieinfo *dip)
1472 Extract all information from a TAG_pointer_type DIE and add to
1473 the user defined type vector.
1477 read_tag_pointer_type (dip
)
1478 struct dieinfo
*dip
;
1483 type
= decode_die_type (dip
);
1484 if ((utype
= lookup_utype (dip
-> die_ref
)) == NULL
)
1486 utype
= lookup_pointer_type (type
);
1487 alloc_utype (dip
-> die_ref
, utype
);
1491 TYPE_TARGET_TYPE (utype
) = type
;
1492 TYPE_POINTER_TYPE (type
) = utype
;
1494 /* We assume the machine has only one representation for pointers! */
1495 /* FIXME: This confuses host<->target data representations, and is a
1496 poor assumption besides. */
1498 TYPE_LENGTH (utype
) = sizeof (char *);
1499 TYPE_CODE (utype
) = TYPE_CODE_PTR
;
1507 read_tag_string_type -- read TAG_string_type DIE
1511 static void read_tag_string_type (struct dieinfo *dip)
1515 Extract all information from a TAG_string_type DIE and add to
1516 the user defined type vector. It isn't really a user defined
1517 type, but it behaves like one, with other DIE's using an
1518 AT_user_def_type attribute to reference it.
1522 read_tag_string_type (dip
)
1523 struct dieinfo
*dip
;
1526 struct type
*indextype
;
1527 struct type
*rangetype
;
1528 unsigned long lowbound
= 0;
1529 unsigned long highbound
;
1531 if (dip
-> has_at_byte_size
)
1533 /* A fixed bounds string */
1534 highbound
= dip
-> at_byte_size
- 1;
1538 /* A varying length string. Stub for now. (FIXME) */
1541 indextype
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1542 rangetype
= create_range_type ((struct type
*) NULL
, indextype
, lowbound
,
1545 utype
= lookup_utype (dip
-> die_ref
);
1548 /* No type defined, go ahead and create a blank one to use. */
1549 utype
= alloc_utype (dip
-> die_ref
, (struct type
*) NULL
);
1553 /* Already a type in our slot due to a forward reference. Make sure it
1554 is a blank one. If not, complain and leave it alone. */
1555 if (TYPE_CODE (utype
) != TYPE_CODE_UNDEF
)
1557 complain (&dup_user_type_definition
, DIE_ID
, DIE_NAME
);
1562 /* Create the string type using the blank type we either found or created. */
1563 utype
= create_string_type (utype
, rangetype
);
1570 read_subroutine_type -- process TAG_subroutine_type dies
1574 static void read_subroutine_type (struct dieinfo *dip, char thisdie,
1579 Handle DIES due to C code like:
1582 int (*funcp)(int a, long l); (Generates TAG_subroutine_type DIE)
1588 The parameter DIES are currently ignored. See if gdb has a way to
1589 include this info in it's type system, and decode them if so. Is
1590 this what the type structure's "arg_types" field is for? (FIXME)
1594 read_subroutine_type (dip
, thisdie
, enddie
)
1595 struct dieinfo
*dip
;
1599 struct type
*type
; /* Type that this function returns */
1600 struct type
*ftype
; /* Function that returns above type */
1602 /* Decode the type that this subroutine returns */
1604 type
= decode_die_type (dip
);
1606 /* Check to see if we already have a partially constructed user
1607 defined type for this DIE, from a forward reference. */
1609 if ((ftype
= lookup_utype (dip
-> die_ref
)) == NULL
)
1611 /* This is the first reference to one of these types. Make
1612 a new one and place it in the user defined types. */
1613 ftype
= lookup_function_type (type
);
1614 alloc_utype (dip
-> die_ref
, ftype
);
1616 else if (TYPE_CODE (ftype
) == TYPE_CODE_UNDEF
)
1618 /* We have an existing partially constructed type, so bash it
1619 into the correct type. */
1620 TYPE_TARGET_TYPE (ftype
) = type
;
1621 TYPE_LENGTH (ftype
) = 1;
1622 TYPE_CODE (ftype
) = TYPE_CODE_FUNC
;
1626 complain (&dup_user_type_definition
, DIE_ID
, DIE_NAME
);
1634 read_enumeration -- process dies which define an enumeration
1638 static void read_enumeration (struct dieinfo *dip, char *thisdie,
1639 char *enddie, struct objfile *objfile)
1643 Given a pointer to a die which begins an enumeration, process all
1644 the dies that define the members of the enumeration.
1648 Note that we need to call enum_type regardless of whether or not we
1649 have a symbol, since we might have an enum without a tag name (thus
1650 no symbol for the tagname).
1654 read_enumeration (dip
, thisdie
, enddie
, objfile
)
1655 struct dieinfo
*dip
;
1658 struct objfile
*objfile
;
1663 type
= enum_type (dip
, objfile
);
1664 sym
= new_symbol (dip
, objfile
);
1667 SYMBOL_TYPE (sym
) = type
;
1668 if (cu_language
== language_cplus
)
1670 synthesize_typedef (dip
, objfile
, type
);
1679 enum_type -- decode and return a type for an enumeration
1683 static type *enum_type (struct dieinfo *dip, struct objfile *objfile)
1687 Given a pointer to a die information structure for the die which
1688 starts an enumeration, process all the dies that define the members
1689 of the enumeration and return a type pointer for the enumeration.
1691 At the same time, for each member of the enumeration, create a
1692 symbol for it with namespace VAR_NAMESPACE and class LOC_CONST,
1693 and give it the type of the enumeration itself.
1697 Note that the DWARF specification explicitly mandates that enum
1698 constants occur in reverse order from the source program order,
1699 for "consistency" and because this ordering is easier for many
1700 compilers to generate. (Draft 6, sec 3.8.5, Enumeration type
1701 Entries). Because gdb wants to see the enum members in program
1702 source order, we have to ensure that the order gets reversed while
1703 we are processing them.
1706 static struct type
*
1707 enum_type (dip
, objfile
)
1708 struct dieinfo
*dip
;
1709 struct objfile
*objfile
;
1713 struct nextfield
*next
;
1716 struct nextfield
*list
= NULL
;
1717 struct nextfield
*new;
1722 unsigned short blocksz
;
1725 int unsigned_enum
= 1;
1727 if ((type
= lookup_utype (dip
-> die_ref
)) == NULL
)
1729 /* No forward references created an empty type, so install one now */
1730 type
= alloc_utype (dip
-> die_ref
, NULL
);
1732 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1733 /* Some compilers try to be helpful by inventing "fake" names for
1734 anonymous enums, structures, and unions, like "~0fake" or ".0fake".
1735 Thanks, but no thanks... */
1736 if (dip
-> at_name
!= NULL
1737 && *dip
-> at_name
!= '~'
1738 && *dip
-> at_name
!= '.')
1740 TYPE_TAG_NAME (type
) = obconcat (&objfile
-> type_obstack
,
1741 "", "", dip
-> at_name
);
1743 if (dip
-> at_byte_size
!= 0)
1745 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
1747 if ((scan
= dip
-> at_element_list
) != NULL
)
1749 if (dip
-> short_element_list
)
1751 nbytes
= attribute_size (AT_short_element_list
);
1755 nbytes
= attribute_size (AT_element_list
);
1757 blocksz
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, objfile
);
1758 listend
= scan
+ nbytes
+ blocksz
;
1760 while (scan
< listend
)
1762 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1765 list
-> field
.type
= NULL
;
1766 list
-> field
.bitsize
= 0;
1767 list
-> field
.bitpos
=
1768 target_to_host (scan
, TARGET_FT_LONG_SIZE (objfile
), GET_SIGNED
,
1770 scan
+= TARGET_FT_LONG_SIZE (objfile
);
1771 list
-> field
.name
= obsavestring (scan
, strlen (scan
),
1772 &objfile
-> type_obstack
);
1773 scan
+= strlen (scan
) + 1;
1775 /* Handcraft a new symbol for this enum member. */
1776 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
1777 sizeof (struct symbol
));
1778 memset (sym
, 0, sizeof (struct symbol
));
1779 SYMBOL_NAME (sym
) = create_name (list
-> field
.name
,
1780 &objfile
->symbol_obstack
);
1781 SYMBOL_INIT_LANGUAGE_SPECIFIC (sym
, cu_language
);
1782 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1783 SYMBOL_CLASS (sym
) = LOC_CONST
;
1784 SYMBOL_TYPE (sym
) = type
;
1785 SYMBOL_VALUE (sym
) = list
-> field
.bitpos
;
1786 if (SYMBOL_VALUE (sym
) < 0)
1788 add_symbol_to_list (sym
, list_in_scope
);
1790 /* Now create the vector of fields, and record how big it is. This is
1791 where we reverse the order, by pulling the members off the list in
1792 reverse order from how they were inserted. If we have no fields
1793 (this is apparently possible in C++) then skip building a field
1798 TYPE_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
1799 TYPE_NFIELDS (type
) = nfields
;
1800 TYPE_FIELDS (type
) = (struct field
*)
1801 obstack_alloc (&objfile
->symbol_obstack
, sizeof (struct field
) * nfields
);
1802 /* Copy the saved-up fields into the field vector. */
1803 for (n
= 0; (n
< nfields
) && (list
!= NULL
); list
= list
-> next
)
1805 TYPE_FIELD (type
, n
++) = list
-> field
;
1816 read_func_scope -- process all dies within a function scope
1820 Process all dies within a given function scope. We are passed
1821 a die information structure pointer DIP for the die which
1822 starts the function scope, and pointers into the raw die data
1823 that define the dies within the function scope.
1825 For now, we ignore lexical block scopes within the function.
1826 The problem is that AT&T cc does not define a DWARF lexical
1827 block scope for the function itself, while gcc defines a
1828 lexical block scope for the function. We need to think about
1829 how to handle this difference, or if it is even a problem.
1834 read_func_scope (dip
, thisdie
, enddie
, objfile
)
1835 struct dieinfo
*dip
;
1838 struct objfile
*objfile
;
1840 register struct context_stack
*new;
1842 /* AT_name is absent if the function is described with an
1843 AT_abstract_origin tag.
1844 Ignore the function description for now to avoid GDB core dumps.
1845 FIXME: Add code to handle AT_abstract_origin tags properly. */
1846 if (dip
-> at_name
== NULL
)
1848 complain (&missing_at_name
, DIE_ID
);
1852 if (objfile
-> ei
.entry_point
>= dip
-> at_low_pc
&&
1853 objfile
-> ei
.entry_point
< dip
-> at_high_pc
)
1855 objfile
-> ei
.entry_func_lowpc
= dip
-> at_low_pc
;
1856 objfile
-> ei
.entry_func_highpc
= dip
-> at_high_pc
;
1858 if (STREQ (dip
-> at_name
, "main")) /* FIXME: hardwired name */
1860 objfile
-> ei
.main_func_lowpc
= dip
-> at_low_pc
;
1861 objfile
-> ei
.main_func_highpc
= dip
-> at_high_pc
;
1863 new = push_context (0, dip
-> at_low_pc
);
1864 new -> name
= new_symbol (dip
, objfile
);
1865 list_in_scope
= &local_symbols
;
1866 process_dies (thisdie
+ dip
-> die_length
, enddie
, objfile
);
1867 new = pop_context ();
1868 /* Make a block for the local symbols within. */
1869 finish_block (new -> name
, &local_symbols
, new -> old_blocks
,
1870 new -> start_addr
, dip
-> at_high_pc
, objfile
);
1871 list_in_scope
= &file_symbols
;
1879 handle_producer -- process the AT_producer attribute
1883 Perform any operations that depend on finding a particular
1884 AT_producer attribute.
1889 handle_producer (producer
)
1893 /* If this compilation unit was compiled with g++ or gcc, then set the
1894 processing_gcc_compilation flag. */
1896 processing_gcc_compilation
=
1897 STREQN (producer
, GPLUS_PRODUCER
, strlen (GPLUS_PRODUCER
))
1898 || STREQN (producer
, CHILL_PRODUCER
, strlen (CHILL_PRODUCER
))
1899 || STREQN (producer
, GCC_PRODUCER
, strlen (GCC_PRODUCER
));
1901 /* Select a demangling style if we can identify the producer and if
1902 the current style is auto. We leave the current style alone if it
1903 is not auto. We also leave the demangling style alone if we find a
1904 gcc (cc1) producer, as opposed to a g++ (cc1plus) producer. */
1906 if (AUTO_DEMANGLING
)
1908 if (STREQN (producer
, GPLUS_PRODUCER
, strlen (GPLUS_PRODUCER
)))
1910 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1912 else if (STREQN (producer
, LCC_PRODUCER
, strlen (LCC_PRODUCER
)))
1914 set_demangling_style (LUCID_DEMANGLING_STYLE_STRING
);
1924 read_file_scope -- process all dies within a file scope
1928 Process all dies within a given file scope. We are passed a
1929 pointer to the die information structure for the die which
1930 starts the file scope, and pointers into the raw die data which
1931 mark the range of dies within the file scope.
1933 When the partial symbol table is built, the file offset for the line
1934 number table for each compilation unit is saved in the partial symbol
1935 table entry for that compilation unit. As the symbols for each
1936 compilation unit are read, the line number table is read into memory
1937 and the variable lnbase is set to point to it. Thus all we have to
1938 do is use lnbase to access the line number table for the current
1943 read_file_scope (dip
, thisdie
, enddie
, objfile
)
1944 struct dieinfo
*dip
;
1947 struct objfile
*objfile
;
1949 struct cleanup
*back_to
;
1950 struct symtab
*symtab
;
1952 if (objfile
-> ei
.entry_point
>= dip
-> at_low_pc
&&
1953 objfile
-> ei
.entry_point
< dip
-> at_high_pc
)
1955 objfile
-> ei
.entry_file_lowpc
= dip
-> at_low_pc
;
1956 objfile
-> ei
.entry_file_highpc
= dip
-> at_high_pc
;
1958 set_cu_language (dip
);
1959 if (dip
-> at_producer
!= NULL
)
1961 handle_producer (dip
-> at_producer
);
1963 numutypes
= (enddie
- thisdie
) / 4;
1964 utypes
= (struct type
**) xmalloc (numutypes
* sizeof (struct type
*));
1965 back_to
= make_cleanup (free_utypes
, NULL
);
1966 memset (utypes
, 0, numutypes
* sizeof (struct type
*));
1967 memset (ftypes
, 0, FT_NUM_MEMBERS
* sizeof (struct type
*));
1968 start_symtab (dip
-> at_name
, dip
-> at_comp_dir
, dip
-> at_low_pc
);
1969 decode_line_numbers (lnbase
);
1970 process_dies (thisdie
+ dip
-> die_length
, enddie
, objfile
);
1972 symtab
= end_symtab (dip
-> at_high_pc
, objfile
, 0);
1975 symtab
-> language
= cu_language
;
1977 do_cleanups (back_to
);
1984 process_dies -- process a range of DWARF Information Entries
1988 static void process_dies (char *thisdie, char *enddie,
1989 struct objfile *objfile)
1993 Process all DIE's in a specified range. May be (and almost
1994 certainly will be) called recursively.
1998 process_dies (thisdie
, enddie
, objfile
)
2001 struct objfile
*objfile
;
2006 while (thisdie
< enddie
)
2008 basicdieinfo (&di
, thisdie
, objfile
);
2009 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
2013 else if (di
.die_tag
== TAG_padding
)
2015 nextdie
= thisdie
+ di
.die_length
;
2019 completedieinfo (&di
, objfile
);
2020 if (di
.at_sibling
!= 0)
2022 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
2026 nextdie
= thisdie
+ di
.die_length
;
2028 #ifdef SMASH_TEXT_ADDRESS
2029 /* I think that these are always text, not data, addresses. */
2030 SMASH_TEXT_ADDRESS (di
.at_low_pc
);
2031 SMASH_TEXT_ADDRESS (di
.at_high_pc
);
2035 case TAG_compile_unit
:
2036 /* Skip Tag_compile_unit if we are already inside a compilation
2037 unit, we are unable to handle nested compilation units
2038 properly (FIXME). */
2039 if (current_subfile
== NULL
)
2040 read_file_scope (&di
, thisdie
, nextdie
, objfile
);
2042 nextdie
= thisdie
+ di
.die_length
;
2044 case TAG_global_subroutine
:
2045 case TAG_subroutine
:
2046 if (di
.has_at_low_pc
)
2048 read_func_scope (&di
, thisdie
, nextdie
, objfile
);
2051 case TAG_lexical_block
:
2052 read_lexical_block_scope (&di
, thisdie
, nextdie
, objfile
);
2054 case TAG_class_type
:
2055 case TAG_structure_type
:
2056 case TAG_union_type
:
2057 read_structure_scope (&di
, thisdie
, nextdie
, objfile
);
2059 case TAG_enumeration_type
:
2060 read_enumeration (&di
, thisdie
, nextdie
, objfile
);
2062 case TAG_subroutine_type
:
2063 read_subroutine_type (&di
, thisdie
, nextdie
);
2065 case TAG_array_type
:
2066 dwarf_read_array_type (&di
);
2068 case TAG_pointer_type
:
2069 read_tag_pointer_type (&di
);
2071 case TAG_string_type
:
2072 read_tag_string_type (&di
);
2075 new_symbol (&di
, objfile
);
2087 decode_line_numbers -- decode a line number table fragment
2091 static void decode_line_numbers (char *tblscan, char *tblend,
2092 long length, long base, long line, long pc)
2096 Translate the DWARF line number information to gdb form.
2098 The ".line" section contains one or more line number tables, one for
2099 each ".line" section from the objects that were linked.
2101 The AT_stmt_list attribute for each TAG_source_file entry in the
2102 ".debug" section contains the offset into the ".line" section for the
2103 start of the table for that file.
2105 The table itself has the following structure:
2107 <table length><base address><source statement entry>
2108 4 bytes 4 bytes 10 bytes
2110 The table length is the total size of the table, including the 4 bytes
2111 for the length information.
2113 The base address is the address of the first instruction generated
2114 for the source file.
2116 Each source statement entry has the following structure:
2118 <line number><statement position><address delta>
2119 4 bytes 2 bytes 4 bytes
2121 The line number is relative to the start of the file, starting with
2124 The statement position either -1 (0xFFFF) or the number of characters
2125 from the beginning of the line to the beginning of the statement.
2127 The address delta is the difference between the base address and
2128 the address of the first instruction for the statement.
2130 Note that we must copy the bytes from the packed table to our local
2131 variables before attempting to use them, to avoid alignment problems
2132 on some machines, particularly RISC processors.
2136 Does gdb expect the line numbers to be sorted? They are now by
2137 chance/luck, but are not required to be. (FIXME)
2139 The line with number 0 is unused, gdb apparently can discover the
2140 span of the last line some other way. How? (FIXME)
2144 decode_line_numbers (linetable
)
2149 unsigned long length
;
2154 if (linetable
!= NULL
)
2156 tblscan
= tblend
= linetable
;
2157 length
= target_to_host (tblscan
, SIZEOF_LINETBL_LENGTH
, GET_UNSIGNED
,
2159 tblscan
+= SIZEOF_LINETBL_LENGTH
;
2161 base
= target_to_host (tblscan
, TARGET_FT_POINTER_SIZE (objfile
),
2162 GET_UNSIGNED
, current_objfile
);
2163 tblscan
+= TARGET_FT_POINTER_SIZE (objfile
);
2165 while (tblscan
< tblend
)
2167 line
= target_to_host (tblscan
, SIZEOF_LINETBL_LINENO
, GET_UNSIGNED
,
2169 tblscan
+= SIZEOF_LINETBL_LINENO
+ SIZEOF_LINETBL_STMT
;
2170 pc
= target_to_host (tblscan
, SIZEOF_LINETBL_DELTA
, GET_UNSIGNED
,
2172 tblscan
+= SIZEOF_LINETBL_DELTA
;
2176 record_line (current_subfile
, line
, pc
);
2186 locval -- compute the value of a location attribute
2190 static int locval (char *loc)
2194 Given pointer to a string of bytes that define a location, compute
2195 the location and return the value.
2196 A location description containing no atoms indicates that the
2197 object is optimized out. The global optimized_out flag is set for
2198 those, the return value is meaningless.
2200 When computing values involving the current value of the frame pointer,
2201 the value zero is used, which results in a value relative to the frame
2202 pointer, rather than the absolute value. This is what GDB wants
2205 When the result is a register number, the global isreg flag is set,
2206 otherwise it is cleared. This is a kludge until we figure out a better
2207 way to handle the problem. Gdb's design does not mesh well with the
2208 DWARF notion of a location computing interpreter, which is a shame
2209 because the flexibility goes unused.
2213 Note that stack[0] is unused except as a default error return.
2214 Note that stack overflow is not yet handled.
2221 unsigned short nbytes
;
2222 unsigned short locsize
;
2223 auto long stack
[64];
2229 nbytes
= attribute_size (AT_location
);
2230 locsize
= target_to_host (loc
, nbytes
, GET_UNSIGNED
, current_objfile
);
2232 end
= loc
+ locsize
;
2238 loc_value_size
= TARGET_FT_LONG_SIZE (current_objfile
);
2242 loc_atom_code
= target_to_host (loc
, SIZEOF_LOC_ATOM_CODE
, GET_UNSIGNED
,
2244 loc
+= SIZEOF_LOC_ATOM_CODE
;
2245 switch (loc_atom_code
)
2252 /* push register (number) */
2254 = DWARF_REG_TO_REGNUM (target_to_host (loc
, loc_value_size
,
2257 loc
+= loc_value_size
;
2261 /* push value of register (number) */
2262 /* Actually, we compute the value as if register has 0, so the
2263 value ends up being the offset from that register. */
2265 basereg
= target_to_host (loc
, loc_value_size
, GET_UNSIGNED
,
2267 loc
+= loc_value_size
;
2268 stack
[++stacki
] = 0;
2271 /* push address (relocated address) */
2272 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
2273 GET_UNSIGNED
, current_objfile
);
2274 loc
+= loc_value_size
;
2277 /* push constant (number) FIXME: signed or unsigned! */
2278 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
2279 GET_SIGNED
, current_objfile
);
2280 loc
+= loc_value_size
;
2283 /* pop, deref and push 2 bytes (as a long) */
2284 complain (&op_deref2
, DIE_ID
, DIE_NAME
, stack
[stacki
]);
2286 case OP_DEREF4
: /* pop, deref and push 4 bytes (as a long) */
2287 complain (&op_deref4
, DIE_ID
, DIE_NAME
, stack
[stacki
]);
2289 case OP_ADD
: /* pop top 2 items, add, push result */
2290 stack
[stacki
- 1] += stack
[stacki
];
2295 return (stack
[stacki
]);
2302 read_ofile_symtab -- build a full symtab entry from chunk of DIE's
2306 static void read_ofile_symtab (struct partial_symtab *pst)
2310 When expanding a partial symbol table entry to a full symbol table
2311 entry, this is the function that gets called to read in the symbols
2312 for the compilation unit. A pointer to the newly constructed symtab,
2313 which is now the new first one on the objfile's symtab list, is
2314 stashed in the partial symbol table entry.
2318 read_ofile_symtab (pst
)
2319 struct partial_symtab
*pst
;
2321 struct cleanup
*back_to
;
2322 unsigned long lnsize
;
2325 char lnsizedata
[SIZEOF_LINETBL_LENGTH
];
2327 abfd
= pst
-> objfile
-> obfd
;
2328 current_objfile
= pst
-> objfile
;
2330 /* Allocate a buffer for the entire chunk of DIE's for this compilation
2331 unit, seek to the location in the file, and read in all the DIE's. */
2334 dbsize
= DBLENGTH (pst
);
2335 dbbase
= xmalloc (dbsize
);
2336 dbroff
= DBROFF(pst
);
2337 foffset
= DBFOFF(pst
) + dbroff
;
2338 base_section_offsets
= pst
->section_offsets
;
2339 baseaddr
= ANOFFSET (pst
->section_offsets
, 0);
2340 if (bfd_seek (abfd
, foffset
, SEEK_SET
) ||
2341 (bfd_read (dbbase
, dbsize
, 1, abfd
) != dbsize
))
2344 error ("can't read DWARF data");
2346 back_to
= make_cleanup (free
, dbbase
);
2348 /* If there is a line number table associated with this compilation unit
2349 then read the size of this fragment in bytes, from the fragment itself.
2350 Allocate a buffer for the fragment and read it in for future
2356 if (bfd_seek (abfd
, LNFOFF (pst
), SEEK_SET
) ||
2357 (bfd_read ((PTR
) lnsizedata
, sizeof (lnsizedata
), 1, abfd
) !=
2358 sizeof (lnsizedata
)))
2360 error ("can't read DWARF line number table size");
2362 lnsize
= target_to_host (lnsizedata
, SIZEOF_LINETBL_LENGTH
,
2363 GET_UNSIGNED
, pst
-> objfile
);
2364 lnbase
= xmalloc (lnsize
);
2365 if (bfd_seek (abfd
, LNFOFF (pst
), SEEK_SET
) ||
2366 (bfd_read (lnbase
, lnsize
, 1, abfd
) != lnsize
))
2369 error ("can't read DWARF line numbers");
2371 make_cleanup (free
, lnbase
);
2374 process_dies (dbbase
, dbbase
+ dbsize
, pst
-> objfile
);
2375 do_cleanups (back_to
);
2376 current_objfile
= NULL
;
2377 pst
-> symtab
= pst
-> objfile
-> symtabs
;
2384 psymtab_to_symtab_1 -- do grunt work for building a full symtab entry
2388 static void psymtab_to_symtab_1 (struct partial_symtab *pst)
2392 Called once for each partial symbol table entry that needs to be
2393 expanded into a full symbol table entry.
2398 psymtab_to_symtab_1 (pst
)
2399 struct partial_symtab
*pst
;
2402 struct cleanup
*old_chain
;
2408 warning ("psymtab for %s already read in. Shouldn't happen.",
2413 /* Read in all partial symtabs on which this one is dependent */
2414 for (i
= 0; i
< pst
-> number_of_dependencies
; i
++)
2416 if (!pst
-> dependencies
[i
] -> readin
)
2418 /* Inform about additional files that need to be read in. */
2421 fputs_filtered (" ", gdb_stdout
);
2423 fputs_filtered ("and ", gdb_stdout
);
2425 printf_filtered ("%s...",
2426 pst
-> dependencies
[i
] -> filename
);
2428 gdb_flush (gdb_stdout
); /* Flush output */
2430 psymtab_to_symtab_1 (pst
-> dependencies
[i
]);
2433 if (DBLENGTH (pst
)) /* Otherwise it's a dummy */
2436 old_chain
= make_cleanup (really_free_pendings
, 0);
2437 read_ofile_symtab (pst
);
2440 printf_filtered ("%d DIE's, sorting...", diecount
);
2442 gdb_flush (gdb_stdout
);
2444 sort_symtab_syms (pst
-> symtab
);
2445 do_cleanups (old_chain
);
2456 dwarf_psymtab_to_symtab -- build a full symtab entry from partial one
2460 static void dwarf_psymtab_to_symtab (struct partial_symtab *pst)
2464 This is the DWARF support entry point for building a full symbol
2465 table entry from a partial symbol table entry. We are passed a
2466 pointer to the partial symbol table entry that needs to be expanded.
2471 dwarf_psymtab_to_symtab (pst
)
2472 struct partial_symtab
*pst
;
2479 warning ("psymtab for %s already read in. Shouldn't happen.",
2484 if (DBLENGTH (pst
) || pst
-> number_of_dependencies
)
2486 /* Print the message now, before starting serious work, to avoid
2487 disconcerting pauses. */
2490 printf_filtered ("Reading in symbols for %s...",
2492 gdb_flush (gdb_stdout
);
2495 psymtab_to_symtab_1 (pst
);
2497 #if 0 /* FIXME: Check to see what dbxread is doing here and see if
2498 we need to do an equivalent or is this something peculiar to
2500 Match with global symbols. This only needs to be done once,
2501 after all of the symtabs and dependencies have been read in.
2503 scan_file_globals (pst
-> objfile
);
2506 /* Finish up the verbose info message. */
2509 printf_filtered ("done.\n");
2510 gdb_flush (gdb_stdout
);
2521 add_enum_psymbol -- add enumeration members to partial symbol table
2525 Given pointer to a DIE that is known to be for an enumeration,
2526 extract the symbolic names of the enumeration members and add
2527 partial symbols for them.
2531 add_enum_psymbol (dip
, objfile
)
2532 struct dieinfo
*dip
;
2533 struct objfile
*objfile
;
2537 unsigned short blocksz
;
2540 if ((scan
= dip
-> at_element_list
) != NULL
)
2542 if (dip
-> short_element_list
)
2544 nbytes
= attribute_size (AT_short_element_list
);
2548 nbytes
= attribute_size (AT_element_list
);
2550 blocksz
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, objfile
);
2552 listend
= scan
+ blocksz
;
2553 while (scan
< listend
)
2555 scan
+= TARGET_FT_LONG_SIZE (objfile
);
2556 ADD_PSYMBOL_TO_LIST (scan
, strlen (scan
), VAR_NAMESPACE
, LOC_CONST
,
2557 objfile
-> static_psymbols
, 0, cu_language
,
2559 scan
+= strlen (scan
) + 1;
2568 add_partial_symbol -- add symbol to partial symbol table
2572 Given a DIE, if it is one of the types that we want to
2573 add to a partial symbol table, finish filling in the die info
2574 and then add a partial symbol table entry for it.
2578 The caller must ensure that the DIE has a valid name attribute.
2582 add_partial_symbol (dip
, objfile
)
2583 struct dieinfo
*dip
;
2584 struct objfile
*objfile
;
2586 switch (dip
-> die_tag
)
2588 case TAG_global_subroutine
:
2589 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2590 VAR_NAMESPACE
, LOC_BLOCK
,
2591 objfile
-> global_psymbols
,
2592 dip
-> at_low_pc
, cu_language
, objfile
);
2594 case TAG_global_variable
:
2595 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2596 VAR_NAMESPACE
, LOC_STATIC
,
2597 objfile
-> global_psymbols
,
2598 0, cu_language
, objfile
);
2600 case TAG_subroutine
:
2601 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2602 VAR_NAMESPACE
, LOC_BLOCK
,
2603 objfile
-> static_psymbols
,
2604 dip
-> at_low_pc
, cu_language
, objfile
);
2606 case TAG_local_variable
:
2607 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2608 VAR_NAMESPACE
, LOC_STATIC
,
2609 objfile
-> static_psymbols
,
2610 0, cu_language
, objfile
);
2613 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2614 VAR_NAMESPACE
, LOC_TYPEDEF
,
2615 objfile
-> static_psymbols
,
2616 0, cu_language
, objfile
);
2618 case TAG_class_type
:
2619 case TAG_structure_type
:
2620 case TAG_union_type
:
2621 case TAG_enumeration_type
:
2622 /* Do not add opaque aggregate definitions to the psymtab. */
2623 if (!dip
-> has_at_byte_size
)
2625 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2626 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2627 objfile
-> static_psymbols
,
2628 0, cu_language
, objfile
);
2629 if (cu_language
== language_cplus
)
2631 /* For C++, these implicitly act as typedefs as well. */
2632 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2633 VAR_NAMESPACE
, LOC_TYPEDEF
,
2634 objfile
-> static_psymbols
,
2635 0, cu_language
, objfile
);
2645 scan_partial_symbols -- scan DIE's within a single compilation unit
2649 Process the DIE's within a single compilation unit, looking for
2650 interesting DIE's that contribute to the partial symbol table entry
2651 for this compilation unit.
2655 There are some DIE's that may appear both at file scope and within
2656 the scope of a function. We are only interested in the ones at file
2657 scope, and the only way to tell them apart is to keep track of the
2658 scope. For example, consider the test case:
2663 for which the relevant DWARF segment has the structure:
2666 0x23 global subrtn sibling 0x9b
2668 fund_type FT_integer
2673 0x23 local var sibling 0x97
2675 fund_type FT_integer
2676 location OP_BASEREG 0xe
2683 0x1d local var sibling 0xb8
2685 fund_type FT_integer
2686 location OP_ADDR 0x800025dc
2691 We want to include the symbol 'i' in the partial symbol table, but
2692 not the symbol 'j'. In essence, we want to skip all the dies within
2693 the scope of a TAG_global_subroutine DIE.
2695 Don't attempt to add anonymous structures or unions since they have
2696 no name. Anonymous enumerations however are processed, because we
2697 want to extract their member names (the check for a tag name is
2700 Also, for variables and subroutines, check that this is the place
2701 where the actual definition occurs, rather than just a reference
2706 scan_partial_symbols (thisdie
, enddie
, objfile
)
2709 struct objfile
*objfile
;
2715 while (thisdie
< enddie
)
2717 basicdieinfo (&di
, thisdie
, objfile
);
2718 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
2724 nextdie
= thisdie
+ di
.die_length
;
2725 /* To avoid getting complete die information for every die, we
2726 only do it (below) for the cases we are interested in. */
2729 case TAG_global_subroutine
:
2730 case TAG_subroutine
:
2731 completedieinfo (&di
, objfile
);
2732 if (di
.at_name
&& (di
.has_at_low_pc
|| di
.at_location
))
2734 add_partial_symbol (&di
, objfile
);
2735 /* If there is a sibling attribute, adjust the nextdie
2736 pointer to skip the entire scope of the subroutine.
2737 Apply some sanity checking to make sure we don't
2738 overrun or underrun the range of remaining DIE's */
2739 if (di
.at_sibling
!= 0)
2741 temp
= dbbase
+ di
.at_sibling
- dbroff
;
2742 if ((temp
< thisdie
) || (temp
>= enddie
))
2744 complain (&bad_die_ref
, DIE_ID
, DIE_NAME
,
2754 case TAG_global_variable
:
2755 case TAG_local_variable
:
2756 completedieinfo (&di
, objfile
);
2757 if (di
.at_name
&& (di
.has_at_low_pc
|| di
.at_location
))
2759 add_partial_symbol (&di
, objfile
);
2763 case TAG_class_type
:
2764 case TAG_structure_type
:
2765 case TAG_union_type
:
2766 completedieinfo (&di
, objfile
);
2769 add_partial_symbol (&di
, objfile
);
2772 case TAG_enumeration_type
:
2773 completedieinfo (&di
, objfile
);
2776 add_partial_symbol (&di
, objfile
);
2778 add_enum_psymbol (&di
, objfile
);
2790 scan_compilation_units -- build a psymtab entry for each compilation
2794 This is the top level dwarf parsing routine for building partial
2797 It scans from the beginning of the DWARF table looking for the first
2798 TAG_compile_unit DIE, and then follows the sibling chain to locate
2799 each additional TAG_compile_unit DIE.
2801 For each TAG_compile_unit DIE it creates a partial symtab structure,
2802 calls a subordinate routine to collect all the compilation unit's
2803 global DIE's, file scope DIEs, typedef DIEs, etc, and then links the
2804 new partial symtab structure into the partial symbol table. It also
2805 records the appropriate information in the partial symbol table entry
2806 to allow the chunk of DIE's and line number table for this compilation
2807 unit to be located and re-read later, to generate a complete symbol
2808 table entry for the compilation unit.
2810 Thus it effectively partitions up a chunk of DIE's for multiple
2811 compilation units into smaller DIE chunks and line number tables,
2812 and associates them with a partial symbol table entry.
2816 If any compilation unit has no line number table associated with
2817 it for some reason (a missing at_stmt_list attribute, rather than
2818 just one with a value of zero, which is valid) then we ensure that
2819 the recorded file offset is zero so that the routine which later
2820 reads line number table fragments knows that there is no fragment
2830 scan_compilation_units (thisdie
, enddie
, dbfoff
, lnoffset
, objfile
)
2835 struct objfile
*objfile
;
2839 struct partial_symtab
*pst
;
2842 file_ptr curlnoffset
;
2844 while (thisdie
< enddie
)
2846 basicdieinfo (&di
, thisdie
, objfile
);
2847 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
2851 else if (di
.die_tag
!= TAG_compile_unit
)
2853 nextdie
= thisdie
+ di
.die_length
;
2857 completedieinfo (&di
, objfile
);
2858 set_cu_language (&di
);
2859 if (di
.at_sibling
!= 0)
2861 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
2865 nextdie
= thisdie
+ di
.die_length
;
2867 curoff
= thisdie
- dbbase
;
2868 culength
= nextdie
- thisdie
;
2869 curlnoffset
= di
.has_at_stmt_list
? lnoffset
+ di
.at_stmt_list
: 0;
2871 /* First allocate a new partial symbol table structure */
2873 pst
= start_psymtab_common (objfile
, base_section_offsets
,
2874 di
.at_name
, di
.at_low_pc
,
2875 objfile
-> global_psymbols
.next
,
2876 objfile
-> static_psymbols
.next
);
2878 pst
-> texthigh
= di
.at_high_pc
;
2879 pst
-> read_symtab_private
= (char *)
2880 obstack_alloc (&objfile
-> psymbol_obstack
,
2881 sizeof (struct dwfinfo
));
2882 DBFOFF (pst
) = dbfoff
;
2883 DBROFF (pst
) = curoff
;
2884 DBLENGTH (pst
) = culength
;
2885 LNFOFF (pst
) = curlnoffset
;
2886 pst
-> read_symtab
= dwarf_psymtab_to_symtab
;
2888 /* Now look for partial symbols */
2890 scan_partial_symbols (thisdie
+ di
.die_length
, nextdie
, objfile
);
2892 pst
-> n_global_syms
= objfile
-> global_psymbols
.next
-
2893 (objfile
-> global_psymbols
.list
+ pst
-> globals_offset
);
2894 pst
-> n_static_syms
= objfile
-> static_psymbols
.next
-
2895 (objfile
-> static_psymbols
.list
+ pst
-> statics_offset
);
2896 sort_pst_symbols (pst
);
2897 /* If there is already a psymtab or symtab for a file of this name,
2898 remove it. (If there is a symtab, more drastic things also
2899 happen.) This happens in VxWorks. */
2900 free_named_symtabs (pst
-> filename
);
2910 new_symbol -- make a symbol table entry for a new symbol
2914 static struct symbol *new_symbol (struct dieinfo *dip,
2915 struct objfile *objfile)
2919 Given a pointer to a DWARF information entry, figure out if we need
2920 to make a symbol table entry for it, and if so, create a new entry
2921 and return a pointer to it.
2924 static struct symbol
*
2925 new_symbol (dip
, objfile
)
2926 struct dieinfo
*dip
;
2927 struct objfile
*objfile
;
2929 struct symbol
*sym
= NULL
;
2931 if (dip
-> at_name
!= NULL
)
2933 sym
= (struct symbol
*) obstack_alloc (&objfile
-> symbol_obstack
,
2934 sizeof (struct symbol
));
2935 OBJSTAT (objfile
, n_syms
++);
2936 memset (sym
, 0, sizeof (struct symbol
));
2937 SYMBOL_NAME (sym
) = create_name (dip
-> at_name
,
2938 &objfile
->symbol_obstack
);
2939 /* default assumptions */
2940 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2941 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2942 SYMBOL_TYPE (sym
) = decode_die_type (dip
);
2944 /* If this symbol is from a C++ compilation, then attempt to cache the
2945 demangled form for future reference. This is a typical time versus
2946 space tradeoff, that was decided in favor of time because it sped up
2947 C++ symbol lookups by a factor of about 20. */
2949 SYMBOL_LANGUAGE (sym
) = cu_language
;
2950 SYMBOL_INIT_DEMANGLED_NAME (sym
, &objfile
-> symbol_obstack
);
2951 switch (dip
-> die_tag
)
2954 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
;
2955 SYMBOL_CLASS (sym
) = LOC_LABEL
;
2957 case TAG_global_subroutine
:
2958 case TAG_subroutine
:
2959 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
;
2960 SYMBOL_TYPE (sym
) = lookup_function_type (SYMBOL_TYPE (sym
));
2961 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
2962 if (dip
-> die_tag
== TAG_global_subroutine
)
2964 add_symbol_to_list (sym
, &global_symbols
);
2968 add_symbol_to_list (sym
, list_in_scope
);
2971 case TAG_global_variable
:
2972 if (dip
-> at_location
!= NULL
)
2974 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2975 add_symbol_to_list (sym
, &global_symbols
);
2976 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2977 SYMBOL_VALUE (sym
) += baseaddr
;
2980 case TAG_local_variable
:
2981 if (dip
-> at_location
!= NULL
)
2983 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2984 add_symbol_to_list (sym
, list_in_scope
);
2987 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
2991 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
2995 SYMBOL_CLASS (sym
) = LOC_BASEREG
;
2996 SYMBOL_BASEREG (sym
) = basereg
;
3000 SYMBOL_CLASS (sym
) = LOC_STATIC
;
3001 SYMBOL_VALUE (sym
) += baseaddr
;
3005 case TAG_formal_parameter
:
3006 if (dip
-> at_location
!= NULL
)
3008 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
3010 add_symbol_to_list (sym
, list_in_scope
);
3013 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
3017 SYMBOL_CLASS (sym
) = LOC_BASEREG_ARG
;
3018 SYMBOL_BASEREG (sym
) = basereg
;
3022 SYMBOL_CLASS (sym
) = LOC_ARG
;
3025 case TAG_unspecified_parameters
:
3026 /* From varargs functions; gdb doesn't seem to have any interest in
3027 this information, so just ignore it for now. (FIXME?) */
3029 case TAG_class_type
:
3030 case TAG_structure_type
:
3031 case TAG_union_type
:
3032 case TAG_enumeration_type
:
3033 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
3034 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
3035 add_symbol_to_list (sym
, list_in_scope
);
3038 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
3039 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3040 add_symbol_to_list (sym
, list_in_scope
);
3043 /* Not a tag we recognize. Hopefully we aren't processing trash
3044 data, but since we must specifically ignore things we don't
3045 recognize, there is nothing else we should do at this point. */
3056 synthesize_typedef -- make a symbol table entry for a "fake" typedef
3060 static void synthesize_typedef (struct dieinfo *dip,
3061 struct objfile *objfile,
3066 Given a pointer to a DWARF information entry, synthesize a typedef
3067 for the name in the DIE, using the specified type.
3069 This is used for C++ class, structs, unions, and enumerations to
3070 set up the tag name as a type.
3075 synthesize_typedef (dip
, objfile
, type
)
3076 struct dieinfo
*dip
;
3077 struct objfile
*objfile
;
3080 struct symbol
*sym
= NULL
;
3082 if (dip
-> at_name
!= NULL
)
3084 sym
= (struct symbol
*)
3085 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
3086 OBJSTAT (objfile
, n_syms
++);
3087 memset (sym
, 0, sizeof (struct symbol
));
3088 SYMBOL_NAME (sym
) = create_name (dip
-> at_name
,
3089 &objfile
->symbol_obstack
);
3090 SYMBOL_INIT_LANGUAGE_SPECIFIC (sym
, cu_language
);
3091 SYMBOL_TYPE (sym
) = type
;
3092 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
3093 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3094 add_symbol_to_list (sym
, list_in_scope
);
3102 decode_mod_fund_type -- decode a modified fundamental type
3106 static struct type *decode_mod_fund_type (char *typedata)
3110 Decode a block of data containing a modified fundamental
3111 type specification. TYPEDATA is a pointer to the block,
3112 which starts with a length containing the size of the rest
3113 of the block. At the end of the block is a fundmental type
3114 code value that gives the fundamental type. Everything
3115 in between are type modifiers.
3117 We simply compute the number of modifiers and call the general
3118 function decode_modified_type to do the actual work.
3121 static struct type
*
3122 decode_mod_fund_type (typedata
)
3125 struct type
*typep
= NULL
;
3126 unsigned short modcount
;
3129 /* Get the total size of the block, exclusive of the size itself */
3131 nbytes
= attribute_size (AT_mod_fund_type
);
3132 modcount
= target_to_host (typedata
, nbytes
, GET_UNSIGNED
, current_objfile
);
3135 /* Deduct the size of the fundamental type bytes at the end of the block. */
3137 modcount
-= attribute_size (AT_fund_type
);
3139 /* Now do the actual decoding */
3141 typep
= decode_modified_type (typedata
, modcount
, AT_mod_fund_type
);
3149 decode_mod_u_d_type -- decode a modified user defined type
3153 static struct type *decode_mod_u_d_type (char *typedata)
3157 Decode a block of data containing a modified user defined
3158 type specification. TYPEDATA is a pointer to the block,
3159 which consists of a two byte length, containing the size
3160 of the rest of the block. At the end of the block is a
3161 four byte value that gives a reference to a user defined type.
3162 Everything in between are type modifiers.
3164 We simply compute the number of modifiers and call the general
3165 function decode_modified_type to do the actual work.
3168 static struct type
*
3169 decode_mod_u_d_type (typedata
)
3172 struct type
*typep
= NULL
;
3173 unsigned short modcount
;
3176 /* Get the total size of the block, exclusive of the size itself */
3178 nbytes
= attribute_size (AT_mod_u_d_type
);
3179 modcount
= target_to_host (typedata
, nbytes
, GET_UNSIGNED
, current_objfile
);
3182 /* Deduct the size of the reference type bytes at the end of the block. */
3184 modcount
-= attribute_size (AT_user_def_type
);
3186 /* Now do the actual decoding */
3188 typep
= decode_modified_type (typedata
, modcount
, AT_mod_u_d_type
);
3196 decode_modified_type -- decode modified user or fundamental type
3200 static struct type *decode_modified_type (char *modifiers,
3201 unsigned short modcount, int mtype)
3205 Decode a modified type, either a modified fundamental type or
3206 a modified user defined type. MODIFIERS is a pointer to the
3207 block of bytes that define MODCOUNT modifiers. Immediately
3208 following the last modifier is a short containing the fundamental
3209 type or a long containing the reference to the user defined
3210 type. Which one is determined by MTYPE, which is either
3211 AT_mod_fund_type or AT_mod_u_d_type to indicate what modified
3212 type we are generating.
3214 We call ourself recursively to generate each modified type,`
3215 until MODCOUNT reaches zero, at which point we have consumed
3216 all the modifiers and generate either the fundamental type or
3217 user defined type. When the recursion unwinds, each modifier
3218 is applied in turn to generate the full modified type.
3222 If we find a modifier that we don't recognize, and it is not one
3223 of those reserved for application specific use, then we issue a
3224 warning and simply ignore the modifier.
3228 We currently ignore MOD_const and MOD_volatile. (FIXME)
3232 static struct type
*
3233 decode_modified_type (modifiers
, modcount
, mtype
)
3235 unsigned int modcount
;
3238 struct type
*typep
= NULL
;
3239 unsigned short fundtype
;
3248 case AT_mod_fund_type
:
3249 nbytes
= attribute_size (AT_fund_type
);
3250 fundtype
= target_to_host (modifiers
, nbytes
, GET_UNSIGNED
,
3252 typep
= decode_fund_type (fundtype
);
3254 case AT_mod_u_d_type
:
3255 nbytes
= attribute_size (AT_user_def_type
);
3256 die_ref
= target_to_host (modifiers
, nbytes
, GET_UNSIGNED
,
3258 if ((typep
= lookup_utype (die_ref
)) == NULL
)
3260 typep
= alloc_utype (die_ref
, NULL
);
3264 complain (&botched_modified_type
, DIE_ID
, DIE_NAME
, mtype
);
3265 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
3271 modifier
= *modifiers
++;
3272 typep
= decode_modified_type (modifiers
, --modcount
, mtype
);
3275 case MOD_pointer_to
:
3276 typep
= lookup_pointer_type (typep
);
3278 case MOD_reference_to
:
3279 typep
= lookup_reference_type (typep
);
3282 complain (&const_ignored
, DIE_ID
, DIE_NAME
); /* FIXME */
3285 complain (&volatile_ignored
, DIE_ID
, DIE_NAME
); /* FIXME */
3288 if (!(MOD_lo_user
<= (unsigned char) modifier
3289 && (unsigned char) modifier
<= MOD_hi_user
))
3291 complain (&unknown_type_modifier
, DIE_ID
, DIE_NAME
, modifier
);
3303 decode_fund_type -- translate basic DWARF type to gdb base type
3307 Given an integer that is one of the fundamental DWARF types,
3308 translate it to one of the basic internal gdb types and return
3309 a pointer to the appropriate gdb type (a "struct type *").
3313 For robustness, if we are asked to translate a fundamental
3314 type that we are unprepared to deal with, we return int so
3315 callers can always depend upon a valid type being returned,
3316 and so gdb may at least do something reasonable by default.
3317 If the type is not in the range of those types defined as
3318 application specific types, we also issue a warning.
3321 static struct type
*
3322 decode_fund_type (fundtype
)
3323 unsigned int fundtype
;
3325 struct type
*typep
= NULL
;
3331 typep
= dwarf_fundamental_type (current_objfile
, FT_VOID
);
3334 case FT_boolean
: /* Was FT_set in AT&T version */
3335 typep
= dwarf_fundamental_type (current_objfile
, FT_BOOLEAN
);
3338 case FT_pointer
: /* (void *) */
3339 typep
= dwarf_fundamental_type (current_objfile
, FT_VOID
);
3340 typep
= lookup_pointer_type (typep
);
3344 typep
= dwarf_fundamental_type (current_objfile
, FT_CHAR
);
3347 case FT_signed_char
:
3348 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_CHAR
);
3351 case FT_unsigned_char
:
3352 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_CHAR
);
3356 typep
= dwarf_fundamental_type (current_objfile
, FT_SHORT
);
3359 case FT_signed_short
:
3360 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_SHORT
);
3363 case FT_unsigned_short
:
3364 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_SHORT
);
3368 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
3371 case FT_signed_integer
:
3372 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_INTEGER
);
3375 case FT_unsigned_integer
:
3376 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_INTEGER
);
3380 typep
= dwarf_fundamental_type (current_objfile
, FT_LONG
);
3383 case FT_signed_long
:
3384 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_LONG
);
3387 case FT_unsigned_long
:
3388 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_LONG
);
3392 typep
= dwarf_fundamental_type (current_objfile
, FT_LONG_LONG
);
3395 case FT_signed_long_long
:
3396 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_LONG_LONG
);
3399 case FT_unsigned_long_long
:
3400 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_LONG_LONG
);
3404 typep
= dwarf_fundamental_type (current_objfile
, FT_FLOAT
);
3407 case FT_dbl_prec_float
:
3408 typep
= dwarf_fundamental_type (current_objfile
, FT_DBL_PREC_FLOAT
);
3411 case FT_ext_prec_float
:
3412 typep
= dwarf_fundamental_type (current_objfile
, FT_EXT_PREC_FLOAT
);
3416 typep
= dwarf_fundamental_type (current_objfile
, FT_COMPLEX
);
3419 case FT_dbl_prec_complex
:
3420 typep
= dwarf_fundamental_type (current_objfile
, FT_DBL_PREC_COMPLEX
);
3423 case FT_ext_prec_complex
:
3424 typep
= dwarf_fundamental_type (current_objfile
, FT_EXT_PREC_COMPLEX
);
3431 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
3432 if (!(FT_lo_user
<= fundtype
&& fundtype
<= FT_hi_user
))
3434 complain (&unexpected_fund_type
, DIE_ID
, DIE_NAME
, fundtype
);
3445 create_name -- allocate a fresh copy of a string on an obstack
3449 Given a pointer to a string and a pointer to an obstack, allocates
3450 a fresh copy of the string on the specified obstack.
3455 create_name (name
, obstackp
)
3457 struct obstack
*obstackp
;
3462 length
= strlen (name
) + 1;
3463 newname
= (char *) obstack_alloc (obstackp
, length
);
3464 strcpy (newname
, name
);
3472 basicdieinfo -- extract the minimal die info from raw die data
3476 void basicdieinfo (char *diep, struct dieinfo *dip,
3477 struct objfile *objfile)
3481 Given a pointer to raw DIE data, and a pointer to an instance of a
3482 die info structure, this function extracts the basic information
3483 from the DIE data required to continue processing this DIE, along
3484 with some bookkeeping information about the DIE.
3486 The information we absolutely must have includes the DIE tag,
3487 and the DIE length. If we need the sibling reference, then we
3488 will have to call completedieinfo() to process all the remaining
3491 Note that since there is no guarantee that the data is properly
3492 aligned in memory for the type of access required (indirection
3493 through anything other than a char pointer), and there is no
3494 guarantee that it is in the same byte order as the gdb host,
3495 we call a function which deals with both alignment and byte
3496 swapping issues. Possibly inefficient, but quite portable.
3498 We also take care of some other basic things at this point, such
3499 as ensuring that the instance of the die info structure starts
3500 out completely zero'd and that curdie is initialized for use
3501 in error reporting if we have a problem with the current die.
3505 All DIE's must have at least a valid length, thus the minimum
3506 DIE size is SIZEOF_DIE_LENGTH. In order to have a valid tag, the
3507 DIE size must be at least SIZEOF_DIE_TAG larger, otherwise they
3508 are forced to be TAG_padding DIES.
3510 Padding DIES must be at least SIZEOF_DIE_LENGTH in length, implying
3511 that if a padding DIE is used for alignment and the amount needed is
3512 less than SIZEOF_DIE_LENGTH, then the padding DIE has to be big
3513 enough to align to the next alignment boundry.
3515 We do some basic sanity checking here, such as verifying that the
3516 length of the die would not cause it to overrun the recorded end of
3517 the buffer holding the DIE info. If we find a DIE that is either
3518 too small or too large, we force it's length to zero which should
3519 cause the caller to take appropriate action.
3523 basicdieinfo (dip
, diep
, objfile
)
3524 struct dieinfo
*dip
;
3526 struct objfile
*objfile
;
3529 memset (dip
, 0, sizeof (struct dieinfo
));
3531 dip
-> die_ref
= dbroff
+ (diep
- dbbase
);
3532 dip
-> die_length
= target_to_host (diep
, SIZEOF_DIE_LENGTH
, GET_UNSIGNED
,
3534 if ((dip
-> die_length
< SIZEOF_DIE_LENGTH
) ||
3535 ((diep
+ dip
-> die_length
) > (dbbase
+ dbsize
)))
3537 complain (&malformed_die
, DIE_ID
, DIE_NAME
, dip
-> die_length
);
3538 dip
-> die_length
= 0;
3540 else if (dip
-> die_length
< (SIZEOF_DIE_LENGTH
+ SIZEOF_DIE_TAG
))
3542 dip
-> die_tag
= TAG_padding
;
3546 diep
+= SIZEOF_DIE_LENGTH
;
3547 dip
-> die_tag
= target_to_host (diep
, SIZEOF_DIE_TAG
, GET_UNSIGNED
,
3556 completedieinfo -- finish reading the information for a given DIE
3560 void completedieinfo (struct dieinfo *dip, struct objfile *objfile)
3564 Given a pointer to an already partially initialized die info structure,
3565 scan the raw DIE data and finish filling in the die info structure
3566 from the various attributes found.
3568 Note that since there is no guarantee that the data is properly
3569 aligned in memory for the type of access required (indirection
3570 through anything other than a char pointer), and there is no
3571 guarantee that it is in the same byte order as the gdb host,
3572 we call a function which deals with both alignment and byte
3573 swapping issues. Possibly inefficient, but quite portable.
3577 Each time we are called, we increment the diecount variable, which
3578 keeps an approximate count of the number of dies processed for
3579 each compilation unit. This information is presented to the user
3580 if the info_verbose flag is set.
3585 completedieinfo (dip
, objfile
)
3586 struct dieinfo
*dip
;
3587 struct objfile
*objfile
;
3589 char *diep
; /* Current pointer into raw DIE data */
3590 char *end
; /* Terminate DIE scan here */
3591 unsigned short attr
; /* Current attribute being scanned */
3592 unsigned short form
; /* Form of the attribute */
3593 int nbytes
; /* Size of next field to read */
3597 end
= diep
+ dip
-> die_length
;
3598 diep
+= SIZEOF_DIE_LENGTH
+ SIZEOF_DIE_TAG
;
3601 attr
= target_to_host (diep
, SIZEOF_ATTRIBUTE
, GET_UNSIGNED
, objfile
);
3602 diep
+= SIZEOF_ATTRIBUTE
;
3603 if ((nbytes
= attribute_size (attr
)) == -1)
3605 complain (&unknown_attribute_length
, DIE_ID
, DIE_NAME
);
3612 dip
-> at_fund_type
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3616 dip
-> at_ordering
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3620 dip
-> at_bit_offset
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3624 dip
-> at_sibling
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3628 dip
-> at_stmt_list
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3630 dip
-> has_at_stmt_list
= 1;
3633 dip
-> at_low_pc
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3635 dip
-> at_low_pc
+= baseaddr
;
3636 dip
-> has_at_low_pc
= 1;
3639 dip
-> at_high_pc
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3641 dip
-> at_high_pc
+= baseaddr
;
3644 dip
-> at_language
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3647 case AT_user_def_type
:
3648 dip
-> at_user_def_type
= target_to_host (diep
, nbytes
,
3649 GET_UNSIGNED
, objfile
);
3652 dip
-> at_byte_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3654 dip
-> has_at_byte_size
= 1;
3657 dip
-> at_bit_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3661 dip
-> at_member
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3665 dip
-> at_discr
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3669 dip
-> at_location
= diep
;
3671 case AT_mod_fund_type
:
3672 dip
-> at_mod_fund_type
= diep
;
3674 case AT_subscr_data
:
3675 dip
-> at_subscr_data
= diep
;
3677 case AT_mod_u_d_type
:
3678 dip
-> at_mod_u_d_type
= diep
;
3680 case AT_element_list
:
3681 dip
-> at_element_list
= diep
;
3682 dip
-> short_element_list
= 0;
3684 case AT_short_element_list
:
3685 dip
-> at_element_list
= diep
;
3686 dip
-> short_element_list
= 1;
3688 case AT_discr_value
:
3689 dip
-> at_discr_value
= diep
;
3691 case AT_string_length
:
3692 dip
-> at_string_length
= diep
;
3695 dip
-> at_name
= diep
;
3698 /* For now, ignore any "hostname:" portion, since gdb doesn't
3699 know how to deal with it. (FIXME). */
3700 dip
-> at_comp_dir
= strrchr (diep
, ':');
3701 if (dip
-> at_comp_dir
!= NULL
)
3703 dip
-> at_comp_dir
++;
3707 dip
-> at_comp_dir
= diep
;
3711 dip
-> at_producer
= diep
;
3713 case AT_start_scope
:
3714 dip
-> at_start_scope
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3717 case AT_stride_size
:
3718 dip
-> at_stride_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3722 dip
-> at_src_info
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3726 dip
-> at_prototyped
= diep
;
3729 /* Found an attribute that we are unprepared to handle. However
3730 it is specifically one of the design goals of DWARF that
3731 consumers should ignore unknown attributes. As long as the
3732 form is one that we recognize (so we know how to skip it),
3733 we can just ignore the unknown attribute. */
3736 form
= FORM_FROM_ATTR (attr
);
3750 diep
+= TARGET_FT_POINTER_SIZE (objfile
);
3753 diep
+= 2 + target_to_host (diep
, nbytes
, GET_UNSIGNED
, objfile
);
3756 diep
+= 4 + target_to_host (diep
, nbytes
, GET_UNSIGNED
, objfile
);
3759 diep
+= strlen (diep
) + 1;
3762 complain (&unknown_attribute_form
, DIE_ID
, DIE_NAME
, form
);
3773 target_to_host -- swap in target data to host
3777 target_to_host (char *from, int nbytes, int signextend,
3778 struct objfile *objfile)
3782 Given pointer to data in target format in FROM, a byte count for
3783 the size of the data in NBYTES, a flag indicating whether or not
3784 the data is signed in SIGNEXTEND, and a pointer to the current
3785 objfile in OBJFILE, convert the data to host format and return
3786 the converted value.
3790 FIXME: If we read data that is known to be signed, and expect to
3791 use it as signed data, then we need to explicitly sign extend the
3792 result until the bfd library is able to do this for us.
3794 FIXME: Would a 32 bit target ever need an 8 byte result?
3799 target_to_host (from
, nbytes
, signextend
, objfile
)
3802 int signextend
; /* FIXME: Unused */
3803 struct objfile
*objfile
;
3810 rtnval
= bfd_get_64 (objfile
-> obfd
, (bfd_byte
*) from
);
3813 rtnval
= bfd_get_32 (objfile
-> obfd
, (bfd_byte
*) from
);
3816 rtnval
= bfd_get_16 (objfile
-> obfd
, (bfd_byte
*) from
);
3819 rtnval
= bfd_get_8 (objfile
-> obfd
, (bfd_byte
*) from
);
3822 complain (&no_bfd_get_N
, DIE_ID
, DIE_NAME
, nbytes
);
3833 attribute_size -- compute size of data for a DWARF attribute
3837 static int attribute_size (unsigned int attr)
3841 Given a DWARF attribute in ATTR, compute the size of the first
3842 piece of data associated with this attribute and return that
3845 Returns -1 for unrecognized attributes.
3850 attribute_size (attr
)
3853 int nbytes
; /* Size of next data for this attribute */
3854 unsigned short form
; /* Form of the attribute */
3856 form
= FORM_FROM_ATTR (attr
);
3859 case FORM_STRING
: /* A variable length field is next */
3862 case FORM_DATA2
: /* Next 2 byte field is the data itself */
3863 case FORM_BLOCK2
: /* Next 2 byte field is a block length */
3866 case FORM_DATA4
: /* Next 4 byte field is the data itself */
3867 case FORM_BLOCK4
: /* Next 4 byte field is a block length */
3868 case FORM_REF
: /* Next 4 byte field is a DIE offset */
3871 case FORM_DATA8
: /* Next 8 byte field is the data itself */
3874 case FORM_ADDR
: /* Next field size is target sizeof(void *) */
3875 nbytes
= TARGET_FT_POINTER_SIZE (objfile
);
3878 complain (&unknown_attribute_form
, DIE_ID
, DIE_NAME
, form
);