1 /* DWARF debugging format support for GDB.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
4 Free Software Foundation, Inc.
5 Written by Fred Fish at Cygnus Support. Portions based on dbxread.c,
6 mipsread.c, coffread.c, and dwarfread.c from a Data General SVR4 gdb port.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
26 FIXME: Do we need to generate dependencies in partial symtabs?
27 (Perhaps we don't need to).
29 FIXME: Resolve minor differences between what information we put in the
30 partial symbol table and what dbxread puts in. For example, we don't yet
31 put enum constants there. And dbxread seems to invent a lot of typedefs
32 we never see. Use the new printpsym command to see the partial symbol table
35 FIXME: Figure out a better way to tell gdb about the name of the function
36 contain the user's entry point (I.E. main())
38 FIXME: See other FIXME's and "ifdef 0" scattered throughout the code for
39 other things to work on, if you get bored. :-)
48 #include "elf/dwarf.h"
51 #include "expression.h" /* Needed for enum exp_opcode in language.h, sigh... */
53 #include "complaints.h"
56 #include "gdb_string.h"
58 /* Some macros to provide DIE info for complaints. */
60 #define DIE_ID (curdie!=NULL ? curdie->die_ref : 0)
61 #define DIE_NAME (curdie!=NULL && curdie->at_name!=NULL) ? curdie->at_name : ""
63 /* Complaints that can be issued during DWARF debug info reading. */
65 struct complaint no_bfd_get_N
=
67 "DIE @ 0x%x \"%s\", no bfd support for %d byte data object", 0, 0
70 struct complaint malformed_die
=
72 "DIE @ 0x%x \"%s\", malformed DIE, bad length (%d bytes)", 0, 0
75 struct complaint bad_die_ref
=
77 "DIE @ 0x%x \"%s\", reference to DIE (0x%x) outside compilation unit", 0, 0
80 struct complaint unknown_attribute_form
=
82 "DIE @ 0x%x \"%s\", unknown attribute form (0x%x)", 0, 0
85 struct complaint unknown_attribute_length
=
87 "DIE @ 0x%x \"%s\", unknown attribute length, skipped remaining attributes", 0, 0
90 struct complaint unexpected_fund_type
=
92 "DIE @ 0x%x \"%s\", unexpected fundamental type 0x%x", 0, 0
95 struct complaint unknown_type_modifier
=
97 "DIE @ 0x%x \"%s\", unknown type modifier %u", 0, 0
100 struct complaint volatile_ignored
=
102 "DIE @ 0x%x \"%s\", type modifier 'volatile' ignored", 0, 0
105 struct complaint const_ignored
=
107 "DIE @ 0x%x \"%s\", type modifier 'const' ignored", 0, 0
110 struct complaint botched_modified_type
=
112 "DIE @ 0x%x \"%s\", botched modified type decoding (mtype 0x%x)", 0, 0
115 struct complaint op_deref2
=
117 "DIE @ 0x%x \"%s\", OP_DEREF2 address 0x%x not handled", 0, 0
120 struct complaint op_deref4
=
122 "DIE @ 0x%x \"%s\", OP_DEREF4 address 0x%x not handled", 0, 0
125 struct complaint basereg_not_handled
=
127 "DIE @ 0x%x \"%s\", BASEREG %d not handled", 0, 0
130 struct complaint dup_user_type_allocation
=
132 "DIE @ 0x%x \"%s\", internal error: duplicate user type allocation", 0, 0
135 struct complaint dup_user_type_definition
=
137 "DIE @ 0x%x \"%s\", internal error: duplicate user type definition", 0, 0
140 struct complaint missing_tag
=
142 "DIE @ 0x%x \"%s\", missing class, structure, or union tag", 0, 0
145 struct complaint bad_array_element_type
=
147 "DIE @ 0x%x \"%s\", bad array element type attribute 0x%x", 0, 0
150 struct complaint subscript_data_items
=
152 "DIE @ 0x%x \"%s\", can't decode subscript data items", 0, 0
155 struct complaint unhandled_array_subscript_format
=
157 "DIE @ 0x%x \"%s\", array subscript format 0x%x not handled yet", 0, 0
160 struct complaint unknown_array_subscript_format
=
162 "DIE @ 0x%x \"%s\", unknown array subscript format %x", 0, 0
165 struct complaint not_row_major
=
167 "DIE @ 0x%x \"%s\", array not row major; not handled correctly", 0, 0
170 struct complaint missing_at_name
=
172 "DIE @ 0x%x, AT_name tag missing", 0, 0
175 typedef unsigned int DIE_REF
; /* Reference to a DIE */
178 #define GCC_PRODUCER "GNU C "
181 #ifndef GPLUS_PRODUCER
182 #define GPLUS_PRODUCER "GNU C++ "
186 #define LCC_PRODUCER "NCR C/C++"
189 #ifndef CHILL_PRODUCER
190 #define CHILL_PRODUCER "GNU Chill "
193 /* Flags to target_to_host() that tell whether or not the data object is
194 expected to be signed. Used, for example, when fetching a signed
195 integer in the target environment which is used as a signed integer
196 in the host environment, and the two environments have different sized
197 ints. In this case, *somebody* has to sign extend the smaller sized
200 #define GET_UNSIGNED 0 /* No sign extension required */
201 #define GET_SIGNED 1 /* Sign extension required */
203 /* Defines for things which are specified in the document "DWARF Debugging
204 Information Format" published by UNIX International, Programming Languages
205 SIG. These defines are based on revision 1.0.0, Jan 20, 1992. */
207 #define SIZEOF_DIE_LENGTH 4
208 #define SIZEOF_DIE_TAG 2
209 #define SIZEOF_ATTRIBUTE 2
210 #define SIZEOF_FORMAT_SPECIFIER 1
211 #define SIZEOF_FMT_FT 2
212 #define SIZEOF_LINETBL_LENGTH 4
213 #define SIZEOF_LINETBL_LINENO 4
214 #define SIZEOF_LINETBL_STMT 2
215 #define SIZEOF_LINETBL_DELTA 4
216 #define SIZEOF_LOC_ATOM_CODE 1
218 #define FORM_FROM_ATTR(attr) ((attr) & 0xF) /* Implicitly specified */
220 /* Macros that return the sizes of various types of data in the target
223 FIXME: Currently these are just compile time constants (as they are in
224 other parts of gdb as well). They need to be able to get the right size
225 either from the bfd or possibly from the DWARF info. It would be nice if
226 the DWARF producer inserted DIES that describe the fundamental types in
227 the target environment into the DWARF info, similar to the way dbx stabs
228 producers produce information about their fundamental types. */
230 #define TARGET_FT_POINTER_SIZE(objfile) (TARGET_PTR_BIT / TARGET_CHAR_BIT)
231 #define TARGET_FT_LONG_SIZE(objfile) (TARGET_LONG_BIT / TARGET_CHAR_BIT)
233 /* The Amiga SVR4 header file <dwarf.h> defines AT_element_list as a
234 FORM_BLOCK2, and this is the value emitted by the AT&T compiler.
235 However, the Issue 2 DWARF specification from AT&T defines it as
236 a FORM_BLOCK4, as does the latest specification from UI/PLSIG.
237 For backwards compatibility with the AT&T compiler produced executables
238 we define AT_short_element_list for this variant. */
240 #define AT_short_element_list (0x00f0|FORM_BLOCK2)
242 /* External variables referenced. */
244 extern int info_verbose
; /* From main.c; nonzero => verbose */
245 extern char *warning_pre_print
; /* From utils.c */
247 /* The DWARF debugging information consists of two major pieces,
248 one is a block of DWARF Information Entries (DIE's) and the other
249 is a line number table. The "struct dieinfo" structure contains
250 the information for a single DIE, the one currently being processed.
252 In order to make it easier to randomly access the attribute fields
253 of the current DIE, which are specifically unordered within the DIE,
254 each DIE is scanned and an instance of the "struct dieinfo"
255 structure is initialized.
257 Initialization is done in two levels. The first, done by basicdieinfo(),
258 just initializes those fields that are vital to deciding whether or not
259 to use this DIE, how to skip past it, etc. The second, done by the
260 function completedieinfo(), fills in the rest of the information.
262 Attributes which have block forms are not interpreted at the time
263 the DIE is scanned, instead we just save pointers to the start
264 of their value fields.
266 Some fields have a flag <name>_p that is set when the value of the
267 field is valid (I.E. we found a matching attribute in the DIE). Since
268 we may want to test for the presence of some attributes in the DIE,
269 such as AT_low_pc, without restricting the values of the field,
270 we need someway to note that we found such an attribute.
278 char *die
; /* Pointer to the raw DIE data */
279 unsigned long die_length
; /* Length of the raw DIE data */
280 DIE_REF die_ref
; /* Offset of this DIE */
281 unsigned short die_tag
; /* Tag for this DIE */
282 unsigned long at_padding
;
283 unsigned long at_sibling
;
286 unsigned short at_fund_type
;
287 BLOCK
*at_mod_fund_type
;
288 unsigned long at_user_def_type
;
289 BLOCK
*at_mod_u_d_type
;
290 unsigned short at_ordering
;
291 BLOCK
*at_subscr_data
;
292 unsigned long at_byte_size
;
293 unsigned short at_bit_offset
;
294 unsigned long at_bit_size
;
295 BLOCK
*at_element_list
;
296 unsigned long at_stmt_list
;
298 CORE_ADDR at_high_pc
;
299 unsigned long at_language
;
300 unsigned long at_member
;
301 unsigned long at_discr
;
302 BLOCK
*at_discr_value
;
303 BLOCK
*at_string_length
;
306 unsigned long at_start_scope
;
307 unsigned long at_stride_size
;
308 unsigned long at_src_info
;
310 unsigned int has_at_low_pc
:1;
311 unsigned int has_at_stmt_list
:1;
312 unsigned int has_at_byte_size
:1;
313 unsigned int short_element_list
:1;
315 /* Kludge to identify register variables */
319 /* Kludge to identify optimized out variables */
321 unsigned int optimized_out
;
323 /* Kludge to identify basereg references.
324 Nonzero if we have an offset relative to a basereg. */
328 /* Kludge to identify which base register is it relative to. */
330 unsigned int basereg
;
333 static int diecount
; /* Approximate count of dies for compilation unit */
334 static struct dieinfo
*curdie
; /* For warnings and such */
336 static char *dbbase
; /* Base pointer to dwarf info */
337 static int dbsize
; /* Size of dwarf info in bytes */
338 static int dbroff
; /* Relative offset from start of .debug section */
339 static char *lnbase
; /* Base pointer to line section */
341 /* This value is added to each symbol value. FIXME: Generalize to
342 the section_offsets structure used by dbxread (once this is done,
343 pass the appropriate section number to end_symtab). */
344 static CORE_ADDR baseaddr
; /* Add to each symbol value */
346 /* The section offsets used in the current psymtab or symtab. FIXME,
347 only used to pass one value (baseaddr) at the moment. */
348 static struct section_offsets
*base_section_offsets
;
350 /* We put a pointer to this structure in the read_symtab_private field
355 /* Always the absolute file offset to the start of the ".debug"
356 section for the file containing the DIE's being accessed. */
358 /* Relative offset from the start of the ".debug" section to the
359 first DIE to be accessed. When building the partial symbol
360 table, this value will be zero since we are accessing the
361 entire ".debug" section. When expanding a partial symbol
362 table entry, this value will be the offset to the first
363 DIE for the compilation unit containing the symbol that
364 triggers the expansion. */
366 /* The size of the chunk of DIE's being examined, in bytes. */
368 /* The absolute file offset to the line table fragment. Ignored
369 when building partial symbol tables, but used when expanding
370 them, and contains the absolute file offset to the fragment
371 of the ".line" section containing the line numbers for the
372 current compilation unit. */
376 #define DBFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbfoff)
377 #define DBROFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbroff)
378 #define DBLENGTH(p) (((struct dwfinfo *)((p)->read_symtab_private))->dblength)
379 #define LNFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->lnfoff)
381 /* The generic symbol table building routines have separate lists for
382 file scope symbols and all all other scopes (local scopes). So
383 we need to select the right one to pass to add_symbol_to_list().
384 We do it by keeping a pointer to the correct list in list_in_scope.
386 FIXME: The original dwarf code just treated the file scope as the first
387 local scope, and all other local scopes as nested local scopes, and worked
388 fine. Check to see if we really need to distinguish these in buildsym.c */
390 struct pending
**list_in_scope
= &file_symbols
;
392 /* DIES which have user defined types or modified user defined types refer to
393 other DIES for the type information. Thus we need to associate the offset
394 of a DIE for a user defined type with a pointer to the type information.
396 Originally this was done using a simple but expensive algorithm, with an
397 array of unsorted structures, each containing an offset/type-pointer pair.
398 This array was scanned linearly each time a lookup was done. The result
399 was that gdb was spending over half it's startup time munging through this
400 array of pointers looking for a structure that had the right offset member.
402 The second attempt used the same array of structures, but the array was
403 sorted using qsort each time a new offset/type was recorded, and a binary
404 search was used to find the type pointer for a given DIE offset. This was
405 even slower, due to the overhead of sorting the array each time a new
406 offset/type pair was entered.
408 The third attempt uses a fixed size array of type pointers, indexed by a
409 value derived from the DIE offset. Since the minimum DIE size is 4 bytes,
410 we can divide any DIE offset by 4 to obtain a unique index into this fixed
411 size array. Since each element is a 4 byte pointer, it takes exactly as
412 much memory to hold this array as to hold the DWARF info for a given
413 compilation unit. But it gets freed as soon as we are done with it.
414 This has worked well in practice, as a reasonable tradeoff between memory
415 consumption and speed, without having to resort to much more complicated
418 static struct type
**utypes
; /* Pointer to array of user type pointers */
419 static int numutypes
; /* Max number of user type pointers */
421 /* Maintain an array of referenced fundamental types for the current
422 compilation unit being read. For DWARF version 1, we have to construct
423 the fundamental types on the fly, since no information about the
424 fundamental types is supplied. Each such fundamental type is created by
425 calling a language dependent routine to create the type, and then a
426 pointer to that type is then placed in the array at the index specified
427 by it's FT_<TYPENAME> value. The array has a fixed size set by the
428 FT_NUM_MEMBERS compile time constant, which is the number of predefined
429 fundamental types gdb knows how to construct. */
431 static struct type
*ftypes
[FT_NUM_MEMBERS
]; /* Fundamental types */
433 /* Record the language for the compilation unit which is currently being
434 processed. We know it once we have seen the TAG_compile_unit DIE,
435 and we need it while processing the DIE's for that compilation unit.
436 It is eventually saved in the symtab structure, but we don't finalize
437 the symtab struct until we have processed all the DIE's for the
438 compilation unit. We also need to get and save a pointer to the
439 language struct for this language, so we can call the language
440 dependent routines for doing things such as creating fundamental
443 static enum language cu_language
;
444 static const struct language_defn
*cu_language_defn
;
446 /* Forward declarations of static functions so we don't have to worry
447 about ordering within this file. */
449 static void free_utypes (PTR
);
451 static int attribute_size (unsigned int);
453 static CORE_ADDR
target_to_host (char *, int, int, struct objfile
*);
455 static void add_enum_psymbol (struct dieinfo
*, struct objfile
*);
457 static void handle_producer (char *);
460 read_file_scope (struct dieinfo
*, char *, char *, struct objfile
*);
463 read_func_scope (struct dieinfo
*, char *, char *, struct objfile
*);
466 read_lexical_block_scope (struct dieinfo
*, char *, char *, struct objfile
*);
468 static void scan_partial_symbols (char *, char *, struct objfile
*);
471 scan_compilation_units (char *, char *, file_ptr
, file_ptr
, struct objfile
*);
473 static void add_partial_symbol (struct dieinfo
*, struct objfile
*);
475 static void basicdieinfo (struct dieinfo
*, char *, struct objfile
*);
477 static void completedieinfo (struct dieinfo
*, struct objfile
*);
479 static void dwarf_psymtab_to_symtab (struct partial_symtab
*);
481 static void psymtab_to_symtab_1 (struct partial_symtab
*);
483 static void read_ofile_symtab (struct partial_symtab
*);
485 static void process_dies (char *, char *, struct objfile
*);
488 read_structure_scope (struct dieinfo
*, char *, char *, struct objfile
*);
490 static struct type
*decode_array_element_type (char *);
492 static struct type
*decode_subscript_data_item (char *, char *);
494 static void dwarf_read_array_type (struct dieinfo
*);
496 static void read_tag_pointer_type (struct dieinfo
*dip
);
498 static void read_tag_string_type (struct dieinfo
*dip
);
500 static void read_subroutine_type (struct dieinfo
*, char *, char *);
503 read_enumeration (struct dieinfo
*, char *, char *, struct objfile
*);
505 static struct type
*struct_type (struct dieinfo
*, char *, char *,
508 static struct type
*enum_type (struct dieinfo
*, struct objfile
*);
510 static void decode_line_numbers (char *);
512 static struct type
*decode_die_type (struct dieinfo
*);
514 static struct type
*decode_mod_fund_type (char *);
516 static struct type
*decode_mod_u_d_type (char *);
518 static struct type
*decode_modified_type (char *, unsigned int, int);
520 static struct type
*decode_fund_type (unsigned int);
522 static char *create_name (char *, struct obstack
*);
524 static struct type
*lookup_utype (DIE_REF
);
526 static struct type
*alloc_utype (DIE_REF
, struct type
*);
528 static struct symbol
*new_symbol (struct dieinfo
*, struct objfile
*);
531 synthesize_typedef (struct dieinfo
*, struct objfile
*, struct type
*);
533 static int locval (struct dieinfo
*);
535 static void set_cu_language (struct dieinfo
*);
537 static struct type
*dwarf_fundamental_type (struct objfile
*, int);
544 dwarf_fundamental_type -- lookup or create a fundamental type
549 dwarf_fundamental_type (struct objfile *objfile, int typeid)
553 DWARF version 1 doesn't supply any fundamental type information,
554 so gdb has to construct such types. It has a fixed number of
555 fundamental types that it knows how to construct, which is the
556 union of all types that it knows how to construct for all languages
557 that it knows about. These are enumerated in gdbtypes.h.
559 As an example, assume we find a DIE that references a DWARF
560 fundamental type of FT_integer. We first look in the ftypes
561 array to see if we already have such a type, indexed by the
562 gdb internal value of FT_INTEGER. If so, we simply return a
563 pointer to that type. If not, then we ask an appropriate
564 language dependent routine to create a type FT_INTEGER, using
565 defaults reasonable for the current target machine, and install
566 that type in ftypes for future reference.
570 Pointer to a fundamental type.
575 dwarf_fundamental_type (struct objfile
*objfile
, int typeid)
577 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
579 error ("internal error - invalid fundamental type id %d", typeid);
582 /* Look for this particular type in the fundamental type vector. If one is
583 not found, create and install one appropriate for the current language
584 and the current target machine. */
586 if (ftypes
[typeid] == NULL
)
588 ftypes
[typeid] = cu_language_defn
->la_fund_type (objfile
, typeid);
591 return (ftypes
[typeid]);
598 set_cu_language -- set local copy of language for compilation unit
603 set_cu_language (struct dieinfo *dip)
607 Decode the language attribute for a compilation unit DIE and
608 remember what the language was. We use this at various times
609 when processing DIE's for a given compilation unit.
618 set_cu_language (struct dieinfo
*dip
)
620 switch (dip
->at_language
)
624 cu_language
= language_c
;
626 case LANG_C_PLUS_PLUS
:
627 cu_language
= language_cplus
;
630 cu_language
= language_chill
;
633 cu_language
= language_m2
;
637 cu_language
= language_fortran
;
643 /* We don't know anything special about these yet. */
644 cu_language
= language_unknown
;
647 /* If no at_language, try to deduce one from the filename */
648 cu_language
= deduce_language_from_filename (dip
->at_name
);
651 cu_language_defn
= language_def (cu_language
);
658 dwarf_build_psymtabs -- build partial symtabs from DWARF debug info
662 void dwarf_build_psymtabs (struct objfile *objfile,
663 int mainline, file_ptr dbfoff, unsigned int dbfsize,
664 file_ptr lnoffset, unsigned int lnsize)
668 This function is called upon to build partial symtabs from files
669 containing DIE's (Dwarf Information Entries) and DWARF line numbers.
671 It is passed a bfd* containing the DIES
672 and line number information, the corresponding filename for that
673 file, a base address for relocating the symbols, a flag indicating
674 whether or not this debugging information is from a "main symbol
675 table" rather than a shared library or dynamically linked file,
676 and file offset/size pairs for the DIE information and line number
686 dwarf_build_psymtabs (struct objfile
*objfile
, int mainline
, file_ptr dbfoff
,
687 unsigned int dbfsize
, file_ptr lnoffset
,
690 bfd
*abfd
= objfile
->obfd
;
691 struct cleanup
*back_to
;
693 current_objfile
= objfile
;
695 dbbase
= xmalloc (dbsize
);
697 if ((bfd_seek (abfd
, dbfoff
, SEEK_SET
) != 0) ||
698 (bfd_bread (dbbase
, dbsize
, abfd
) != dbsize
))
701 error ("can't read DWARF data from '%s'", bfd_get_filename (abfd
));
703 back_to
= make_cleanup (xfree
, dbbase
);
705 /* If we are reinitializing, or if we have never loaded syms yet, init.
706 Since we have no idea how many DIES we are looking at, we just guess
707 some arbitrary value. */
710 || (objfile
->global_psymbols
.size
== 0
711 && objfile
->static_psymbols
.size
== 0))
713 init_psymbol_list (objfile
, 1024);
716 /* Save the relocation factor where everybody can see it. */
718 base_section_offsets
= objfile
->section_offsets
;
719 baseaddr
= ANOFFSET (objfile
->section_offsets
, 0);
721 /* Follow the compilation unit sibling chain, building a partial symbol
722 table entry for each one. Save enough information about each compilation
723 unit to locate the full DWARF information later. */
725 scan_compilation_units (dbbase
, dbbase
+ dbsize
, dbfoff
, lnoffset
, objfile
);
727 do_cleanups (back_to
);
728 current_objfile
= NULL
;
735 read_lexical_block_scope -- process all dies in a lexical block
739 static void read_lexical_block_scope (struct dieinfo *dip,
740 char *thisdie, char *enddie)
744 Process all the DIES contained within a lexical block scope.
745 Start a new scope, process the dies, and then close the scope.
750 read_lexical_block_scope (struct dieinfo
*dip
, char *thisdie
, char *enddie
,
751 struct objfile
*objfile
)
753 register struct context_stack
*new;
755 push_context (0, dip
->at_low_pc
);
756 process_dies (thisdie
+ dip
->die_length
, enddie
, objfile
);
757 new = pop_context ();
758 if (local_symbols
!= NULL
)
760 finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
761 dip
->at_high_pc
, objfile
);
763 local_symbols
= new->locals
;
770 lookup_utype -- look up a user defined type from die reference
774 static type *lookup_utype (DIE_REF die_ref)
778 Given a DIE reference, lookup the user defined type associated with
779 that DIE, if it has been registered already. If not registered, then
780 return NULL. Alloc_utype() can be called to register an empty
781 type for this reference, which will be filled in later when the
782 actual referenced DIE is processed.
786 lookup_utype (DIE_REF die_ref
)
788 struct type
*type
= NULL
;
791 utypeidx
= (die_ref
- dbroff
) / 4;
792 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
794 complain (&bad_die_ref
, DIE_ID
, DIE_NAME
);
798 type
= *(utypes
+ utypeidx
);
808 alloc_utype -- add a user defined type for die reference
812 static type *alloc_utype (DIE_REF die_ref, struct type *utypep)
816 Given a die reference DIE_REF, and a possible pointer to a user
817 defined type UTYPEP, register that this reference has a user
818 defined type and either use the specified type in UTYPEP or
819 make a new empty type that will be filled in later.
821 We should only be called after calling lookup_utype() to verify that
822 there is not currently a type registered for DIE_REF.
826 alloc_utype (DIE_REF die_ref
, struct type
*utypep
)
831 utypeidx
= (die_ref
- dbroff
) / 4;
832 typep
= utypes
+ utypeidx
;
833 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
835 utypep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
836 complain (&bad_die_ref
, DIE_ID
, DIE_NAME
);
838 else if (*typep
!= NULL
)
841 complain (&dup_user_type_allocation
, DIE_ID
, DIE_NAME
);
847 utypep
= alloc_type (current_objfile
);
858 free_utypes -- free the utypes array and reset pointer & count
862 static void free_utypes (PTR dummy)
866 Called via do_cleanups to free the utypes array, reset the pointer to NULL,
867 and set numutypes back to zero. This ensures that the utypes does not get
868 referenced after being freed.
872 free_utypes (PTR dummy
)
884 decode_die_type -- return a type for a specified die
888 static struct type *decode_die_type (struct dieinfo *dip)
892 Given a pointer to a die information structure DIP, decode the
893 type of the die and return a pointer to the decoded type. All
894 dies without specific types default to type int.
898 decode_die_type (struct dieinfo
*dip
)
900 struct type
*type
= NULL
;
902 if (dip
->at_fund_type
!= 0)
904 type
= decode_fund_type (dip
->at_fund_type
);
906 else if (dip
->at_mod_fund_type
!= NULL
)
908 type
= decode_mod_fund_type (dip
->at_mod_fund_type
);
910 else if (dip
->at_user_def_type
)
912 if ((type
= lookup_utype (dip
->at_user_def_type
)) == NULL
)
914 type
= alloc_utype (dip
->at_user_def_type
, NULL
);
917 else if (dip
->at_mod_u_d_type
)
919 type
= decode_mod_u_d_type (dip
->at_mod_u_d_type
);
923 type
= dwarf_fundamental_type (current_objfile
, FT_VOID
);
932 struct_type -- compute and return the type for a struct or union
936 static struct type *struct_type (struct dieinfo *dip, char *thisdie,
937 char *enddie, struct objfile *objfile)
941 Given pointer to a die information structure for a die which
942 defines a union or structure (and MUST define one or the other),
943 and pointers to the raw die data that define the range of dies which
944 define the members, compute and return the user defined type for the
949 struct_type (struct dieinfo
*dip
, char *thisdie
, char *enddie
,
950 struct objfile
*objfile
)
955 struct nextfield
*next
;
958 struct nextfield
*list
= NULL
;
959 struct nextfield
*new;
966 if ((type
= lookup_utype (dip
->die_ref
)) == NULL
)
968 /* No forward references created an empty type, so install one now */
969 type
= alloc_utype (dip
->die_ref
, NULL
);
971 INIT_CPLUS_SPECIFIC (type
);
972 switch (dip
->die_tag
)
975 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
977 case TAG_structure_type
:
978 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
981 TYPE_CODE (type
) = TYPE_CODE_UNION
;
984 /* Should never happen */
985 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
986 complain (&missing_tag
, DIE_ID
, DIE_NAME
);
989 /* Some compilers try to be helpful by inventing "fake" names for
990 anonymous enums, structures, and unions, like "~0fake" or ".0fake".
991 Thanks, but no thanks... */
992 if (dip
->at_name
!= NULL
993 && *dip
->at_name
!= '~'
994 && *dip
->at_name
!= '.')
996 TYPE_TAG_NAME (type
) = obconcat (&objfile
->type_obstack
,
997 "", "", dip
->at_name
);
999 /* Use whatever size is known. Zero is a valid size. We might however
1000 wish to check has_at_byte_size to make sure that some byte size was
1001 given explicitly, but DWARF doesn't specify that explicit sizes of
1002 zero have to present, so complaining about missing sizes should
1003 probably not be the default. */
1004 TYPE_LENGTH (type
) = dip
->at_byte_size
;
1005 thisdie
+= dip
->die_length
;
1006 while (thisdie
< enddie
)
1008 basicdieinfo (&mbr
, thisdie
, objfile
);
1009 completedieinfo (&mbr
, objfile
);
1010 if (mbr
.die_length
<= SIZEOF_DIE_LENGTH
)
1014 else if (mbr
.at_sibling
!= 0)
1016 nextdie
= dbbase
+ mbr
.at_sibling
- dbroff
;
1020 nextdie
= thisdie
+ mbr
.die_length
;
1022 switch (mbr
.die_tag
)
1025 /* Get space to record the next field's data. */
1026 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1029 /* Save the data. */
1031 obsavestring (mbr
.at_name
, strlen (mbr
.at_name
),
1032 &objfile
->type_obstack
);
1033 FIELD_TYPE (list
->field
) = decode_die_type (&mbr
);
1034 FIELD_BITPOS (list
->field
) = 8 * locval (&mbr
);
1035 /* Handle bit fields. */
1036 FIELD_BITSIZE (list
->field
) = mbr
.at_bit_size
;
1037 if (BITS_BIG_ENDIAN
)
1039 /* For big endian bits, the at_bit_offset gives the
1040 additional bit offset from the MSB of the containing
1041 anonymous object to the MSB of the field. We don't
1042 have to do anything special since we don't need to
1043 know the size of the anonymous object. */
1044 FIELD_BITPOS (list
->field
) += mbr
.at_bit_offset
;
1048 /* For little endian bits, we need to have a non-zero
1049 at_bit_size, so that we know we are in fact dealing
1050 with a bitfield. Compute the bit offset to the MSB
1051 of the anonymous object, subtract off the number of
1052 bits from the MSB of the field to the MSB of the
1053 object, and then subtract off the number of bits of
1054 the field itself. The result is the bit offset of
1055 the LSB of the field. */
1056 if (mbr
.at_bit_size
> 0)
1058 if (mbr
.has_at_byte_size
)
1060 /* The size of the anonymous object containing
1061 the bit field is explicit, so use the
1062 indicated size (in bytes). */
1063 anonymous_size
= mbr
.at_byte_size
;
1067 /* The size of the anonymous object containing
1068 the bit field matches the size of an object
1069 of the bit field's type. DWARF allows
1070 at_byte_size to be left out in such cases, as
1071 a debug information size optimization. */
1072 anonymous_size
= TYPE_LENGTH (list
->field
.type
);
1074 FIELD_BITPOS (list
->field
) +=
1075 anonymous_size
* 8 - mbr
.at_bit_offset
- mbr
.at_bit_size
;
1081 process_dies (thisdie
, nextdie
, objfile
);
1086 /* Now create the vector of fields, and record how big it is. We may
1087 not even have any fields, if this DIE was generated due to a reference
1088 to an anonymous structure or union. In this case, TYPE_FLAG_STUB is
1089 set, which clues gdb in to the fact that it needs to search elsewhere
1090 for the full structure definition. */
1093 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
1097 TYPE_NFIELDS (type
) = nfields
;
1098 TYPE_FIELDS (type
) = (struct field
*)
1099 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
1100 /* Copy the saved-up fields into the field vector. */
1101 for (n
= nfields
; list
; list
= list
->next
)
1103 TYPE_FIELD (type
, --n
) = list
->field
;
1113 read_structure_scope -- process all dies within struct or union
1117 static void read_structure_scope (struct dieinfo *dip,
1118 char *thisdie, char *enddie, struct objfile *objfile)
1122 Called when we find the DIE that starts a structure or union
1123 scope (definition) to process all dies that define the members
1124 of the structure or union. DIP is a pointer to the die info
1125 struct for the DIE that names the structure or union.
1129 Note that we need to call struct_type regardless of whether or not
1130 the DIE has an at_name attribute, since it might be an anonymous
1131 structure or union. This gets the type entered into our set of
1134 However, if the structure is incomplete (an opaque struct/union)
1135 then suppress creating a symbol table entry for it since gdb only
1136 wants to find the one with the complete definition. Note that if
1137 it is complete, we just call new_symbol, which does it's own
1138 checking about whether the struct/union is anonymous or not (and
1139 suppresses creating a symbol table entry itself).
1144 read_structure_scope (struct dieinfo
*dip
, char *thisdie
, char *enddie
,
1145 struct objfile
*objfile
)
1150 type
= struct_type (dip
, thisdie
, enddie
, objfile
);
1151 if (!(TYPE_FLAGS (type
) & TYPE_FLAG_STUB
))
1153 sym
= new_symbol (dip
, objfile
);
1156 SYMBOL_TYPE (sym
) = type
;
1157 if (cu_language
== language_cplus
)
1159 synthesize_typedef (dip
, objfile
, type
);
1169 decode_array_element_type -- decode type of the array elements
1173 static struct type *decode_array_element_type (char *scan, char *end)
1177 As the last step in decoding the array subscript information for an
1178 array DIE, we need to decode the type of the array elements. We are
1179 passed a pointer to this last part of the subscript information and
1180 must return the appropriate type. If the type attribute is not
1181 recognized, just warn about the problem and return type int.
1184 static struct type
*
1185 decode_array_element_type (char *scan
)
1189 unsigned short attribute
;
1190 unsigned short fundtype
;
1193 attribute
= target_to_host (scan
, SIZEOF_ATTRIBUTE
, GET_UNSIGNED
,
1195 scan
+= SIZEOF_ATTRIBUTE
;
1196 if ((nbytes
= attribute_size (attribute
)) == -1)
1198 complain (&bad_array_element_type
, DIE_ID
, DIE_NAME
, attribute
);
1199 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1206 fundtype
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1208 typep
= decode_fund_type (fundtype
);
1210 case AT_mod_fund_type
:
1211 typep
= decode_mod_fund_type (scan
);
1213 case AT_user_def_type
:
1214 die_ref
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1216 if ((typep
= lookup_utype (die_ref
)) == NULL
)
1218 typep
= alloc_utype (die_ref
, NULL
);
1221 case AT_mod_u_d_type
:
1222 typep
= decode_mod_u_d_type (scan
);
1225 complain (&bad_array_element_type
, DIE_ID
, DIE_NAME
, attribute
);
1226 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1237 decode_subscript_data_item -- decode array subscript item
1241 static struct type *
1242 decode_subscript_data_item (char *scan, char *end)
1246 The array subscripts and the data type of the elements of an
1247 array are described by a list of data items, stored as a block
1248 of contiguous bytes. There is a data item describing each array
1249 dimension, and a final data item describing the element type.
1250 The data items are ordered the same as their appearance in the
1251 source (I.E. leftmost dimension first, next to leftmost second,
1254 The data items describing each array dimension consist of four
1255 parts: (1) a format specifier, (2) type type of the subscript
1256 index, (3) a description of the low bound of the array dimension,
1257 and (4) a description of the high bound of the array dimension.
1259 The last data item is the description of the type of each of
1262 We are passed a pointer to the start of the block of bytes
1263 containing the remaining data items, and a pointer to the first
1264 byte past the data. This function recursively decodes the
1265 remaining data items and returns a type.
1267 If we somehow fail to decode some data, we complain about it
1268 and return a type "array of int".
1271 FIXME: This code only implements the forms currently used
1272 by the AT&T and GNU C compilers.
1274 The end pointer is supplied for error checking, maybe we should
1278 static struct type
*
1279 decode_subscript_data_item (char *scan
, char *end
)
1281 struct type
*typep
= NULL
; /* Array type we are building */
1282 struct type
*nexttype
; /* Type of each element (may be array) */
1283 struct type
*indextype
; /* Type of this index */
1284 struct type
*rangetype
;
1285 unsigned int format
;
1286 unsigned short fundtype
;
1287 unsigned long lowbound
;
1288 unsigned long highbound
;
1291 format
= target_to_host (scan
, SIZEOF_FORMAT_SPECIFIER
, GET_UNSIGNED
,
1293 scan
+= SIZEOF_FORMAT_SPECIFIER
;
1297 typep
= decode_array_element_type (scan
);
1300 fundtype
= target_to_host (scan
, SIZEOF_FMT_FT
, GET_UNSIGNED
,
1302 indextype
= decode_fund_type (fundtype
);
1303 scan
+= SIZEOF_FMT_FT
;
1304 nbytes
= TARGET_FT_LONG_SIZE (current_objfile
);
1305 lowbound
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, current_objfile
);
1307 highbound
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, current_objfile
);
1309 nexttype
= decode_subscript_data_item (scan
, end
);
1310 if (nexttype
== NULL
)
1312 /* Munged subscript data or other problem, fake it. */
1313 complain (&subscript_data_items
, DIE_ID
, DIE_NAME
);
1314 nexttype
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1316 rangetype
= create_range_type ((struct type
*) NULL
, indextype
,
1317 lowbound
, highbound
);
1318 typep
= create_array_type ((struct type
*) NULL
, nexttype
, rangetype
);
1327 complain (&unhandled_array_subscript_format
, DIE_ID
, DIE_NAME
, format
);
1328 nexttype
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1329 rangetype
= create_range_type ((struct type
*) NULL
, nexttype
, 0, 0);
1330 typep
= create_array_type ((struct type
*) NULL
, nexttype
, rangetype
);
1333 complain (&unknown_array_subscript_format
, DIE_ID
, DIE_NAME
, format
);
1334 nexttype
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1335 rangetype
= create_range_type ((struct type
*) NULL
, nexttype
, 0, 0);
1336 typep
= create_array_type ((struct type
*) NULL
, nexttype
, rangetype
);
1346 dwarf_read_array_type -- read TAG_array_type DIE
1350 static void dwarf_read_array_type (struct dieinfo *dip)
1354 Extract all information from a TAG_array_type DIE and add to
1355 the user defined type vector.
1359 dwarf_read_array_type (struct dieinfo
*dip
)
1365 unsigned short blocksz
;
1368 if (dip
->at_ordering
!= ORD_row_major
)
1370 /* FIXME: Can gdb even handle column major arrays? */
1371 complain (¬_row_major
, DIE_ID
, DIE_NAME
);
1373 if ((sub
= dip
->at_subscr_data
) != NULL
)
1375 nbytes
= attribute_size (AT_subscr_data
);
1376 blocksz
= target_to_host (sub
, nbytes
, GET_UNSIGNED
, current_objfile
);
1377 subend
= sub
+ nbytes
+ blocksz
;
1379 type
= decode_subscript_data_item (sub
, subend
);
1380 if ((utype
= lookup_utype (dip
->die_ref
)) == NULL
)
1382 /* Install user defined type that has not been referenced yet. */
1383 alloc_utype (dip
->die_ref
, type
);
1385 else if (TYPE_CODE (utype
) == TYPE_CODE_UNDEF
)
1387 /* Ick! A forward ref has already generated a blank type in our
1388 slot, and this type probably already has things pointing to it
1389 (which is what caused it to be created in the first place).
1390 If it's just a place holder we can plop our fully defined type
1391 on top of it. We can't recover the space allocated for our
1392 new type since it might be on an obstack, but we could reuse
1393 it if we kept a list of them, but it might not be worth it
1399 /* Double ick! Not only is a type already in our slot, but
1400 someone has decorated it. Complain and leave it alone. */
1401 complain (&dup_user_type_definition
, DIE_ID
, DIE_NAME
);
1410 read_tag_pointer_type -- read TAG_pointer_type DIE
1414 static void read_tag_pointer_type (struct dieinfo *dip)
1418 Extract all information from a TAG_pointer_type DIE and add to
1419 the user defined type vector.
1423 read_tag_pointer_type (struct dieinfo
*dip
)
1428 type
= decode_die_type (dip
);
1429 if ((utype
= lookup_utype (dip
->die_ref
)) == NULL
)
1431 utype
= lookup_pointer_type (type
);
1432 alloc_utype (dip
->die_ref
, utype
);
1436 TYPE_TARGET_TYPE (utype
) = type
;
1437 TYPE_POINTER_TYPE (type
) = utype
;
1439 /* We assume the machine has only one representation for pointers! */
1440 /* FIXME: Possably a poor assumption */
1441 TYPE_LENGTH (utype
) = TARGET_PTR_BIT
/ TARGET_CHAR_BIT
;
1442 TYPE_CODE (utype
) = TYPE_CODE_PTR
;
1450 read_tag_string_type -- read TAG_string_type DIE
1454 static void read_tag_string_type (struct dieinfo *dip)
1458 Extract all information from a TAG_string_type DIE and add to
1459 the user defined type vector. It isn't really a user defined
1460 type, but it behaves like one, with other DIE's using an
1461 AT_user_def_type attribute to reference it.
1465 read_tag_string_type (struct dieinfo
*dip
)
1468 struct type
*indextype
;
1469 struct type
*rangetype
;
1470 unsigned long lowbound
= 0;
1471 unsigned long highbound
;
1473 if (dip
->has_at_byte_size
)
1475 /* A fixed bounds string */
1476 highbound
= dip
->at_byte_size
- 1;
1480 /* A varying length string. Stub for now. (FIXME) */
1483 indextype
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1484 rangetype
= create_range_type ((struct type
*) NULL
, indextype
, lowbound
,
1487 utype
= lookup_utype (dip
->die_ref
);
1490 /* No type defined, go ahead and create a blank one to use. */
1491 utype
= alloc_utype (dip
->die_ref
, (struct type
*) NULL
);
1495 /* Already a type in our slot due to a forward reference. Make sure it
1496 is a blank one. If not, complain and leave it alone. */
1497 if (TYPE_CODE (utype
) != TYPE_CODE_UNDEF
)
1499 complain (&dup_user_type_definition
, DIE_ID
, DIE_NAME
);
1504 /* Create the string type using the blank type we either found or created. */
1505 utype
= create_string_type (utype
, rangetype
);
1512 read_subroutine_type -- process TAG_subroutine_type dies
1516 static void read_subroutine_type (struct dieinfo *dip, char thisdie,
1521 Handle DIES due to C code like:
1524 int (*funcp)(int a, long l); (Generates TAG_subroutine_type DIE)
1530 The parameter DIES are currently ignored. See if gdb has a way to
1531 include this info in it's type system, and decode them if so. Is
1532 this what the type structure's "arg_types" field is for? (FIXME)
1536 read_subroutine_type (struct dieinfo
*dip
, char *thisdie
, char *enddie
)
1538 struct type
*type
; /* Type that this function returns */
1539 struct type
*ftype
; /* Function that returns above type */
1541 /* Decode the type that this subroutine returns */
1543 type
= decode_die_type (dip
);
1545 /* Check to see if we already have a partially constructed user
1546 defined type for this DIE, from a forward reference. */
1548 if ((ftype
= lookup_utype (dip
->die_ref
)) == NULL
)
1550 /* This is the first reference to one of these types. Make
1551 a new one and place it in the user defined types. */
1552 ftype
= lookup_function_type (type
);
1553 alloc_utype (dip
->die_ref
, ftype
);
1555 else if (TYPE_CODE (ftype
) == TYPE_CODE_UNDEF
)
1557 /* We have an existing partially constructed type, so bash it
1558 into the correct type. */
1559 TYPE_TARGET_TYPE (ftype
) = type
;
1560 TYPE_LENGTH (ftype
) = 1;
1561 TYPE_CODE (ftype
) = TYPE_CODE_FUNC
;
1565 complain (&dup_user_type_definition
, DIE_ID
, DIE_NAME
);
1573 read_enumeration -- process dies which define an enumeration
1577 static void read_enumeration (struct dieinfo *dip, char *thisdie,
1578 char *enddie, struct objfile *objfile)
1582 Given a pointer to a die which begins an enumeration, process all
1583 the dies that define the members of the enumeration.
1587 Note that we need to call enum_type regardless of whether or not we
1588 have a symbol, since we might have an enum without a tag name (thus
1589 no symbol for the tagname).
1593 read_enumeration (struct dieinfo
*dip
, char *thisdie
, char *enddie
,
1594 struct objfile
*objfile
)
1599 type
= enum_type (dip
, objfile
);
1600 sym
= new_symbol (dip
, objfile
);
1603 SYMBOL_TYPE (sym
) = type
;
1604 if (cu_language
== language_cplus
)
1606 synthesize_typedef (dip
, objfile
, type
);
1615 enum_type -- decode and return a type for an enumeration
1619 static type *enum_type (struct dieinfo *dip, struct objfile *objfile)
1623 Given a pointer to a die information structure for the die which
1624 starts an enumeration, process all the dies that define the members
1625 of the enumeration and return a type pointer for the enumeration.
1627 At the same time, for each member of the enumeration, create a
1628 symbol for it with namespace VAR_NAMESPACE and class LOC_CONST,
1629 and give it the type of the enumeration itself.
1633 Note that the DWARF specification explicitly mandates that enum
1634 constants occur in reverse order from the source program order,
1635 for "consistency" and because this ordering is easier for many
1636 compilers to generate. (Draft 6, sec 3.8.5, Enumeration type
1637 Entries). Because gdb wants to see the enum members in program
1638 source order, we have to ensure that the order gets reversed while
1639 we are processing them.
1642 static struct type
*
1643 enum_type (struct dieinfo
*dip
, struct objfile
*objfile
)
1648 struct nextfield
*next
;
1651 struct nextfield
*list
= NULL
;
1652 struct nextfield
*new;
1657 unsigned short blocksz
;
1660 int unsigned_enum
= 1;
1662 if ((type
= lookup_utype (dip
->die_ref
)) == NULL
)
1664 /* No forward references created an empty type, so install one now */
1665 type
= alloc_utype (dip
->die_ref
, NULL
);
1667 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1668 /* Some compilers try to be helpful by inventing "fake" names for
1669 anonymous enums, structures, and unions, like "~0fake" or ".0fake".
1670 Thanks, but no thanks... */
1671 if (dip
->at_name
!= NULL
1672 && *dip
->at_name
!= '~'
1673 && *dip
->at_name
!= '.')
1675 TYPE_TAG_NAME (type
) = obconcat (&objfile
->type_obstack
,
1676 "", "", dip
->at_name
);
1678 if (dip
->at_byte_size
!= 0)
1680 TYPE_LENGTH (type
) = dip
->at_byte_size
;
1682 if ((scan
= dip
->at_element_list
) != NULL
)
1684 if (dip
->short_element_list
)
1686 nbytes
= attribute_size (AT_short_element_list
);
1690 nbytes
= attribute_size (AT_element_list
);
1692 blocksz
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, objfile
);
1693 listend
= scan
+ nbytes
+ blocksz
;
1695 while (scan
< listend
)
1697 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1700 FIELD_TYPE (list
->field
) = NULL
;
1701 FIELD_BITSIZE (list
->field
) = 0;
1702 FIELD_BITPOS (list
->field
) =
1703 target_to_host (scan
, TARGET_FT_LONG_SIZE (objfile
), GET_SIGNED
,
1705 scan
+= TARGET_FT_LONG_SIZE (objfile
);
1706 list
->field
.name
= obsavestring (scan
, strlen (scan
),
1707 &objfile
->type_obstack
);
1708 scan
+= strlen (scan
) + 1;
1710 /* Handcraft a new symbol for this enum member. */
1711 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
1712 sizeof (struct symbol
));
1713 memset (sym
, 0, sizeof (struct symbol
));
1714 SYMBOL_NAME (sym
) = create_name (list
->field
.name
,
1715 &objfile
->symbol_obstack
);
1716 SYMBOL_INIT_LANGUAGE_SPECIFIC (sym
, cu_language
);
1717 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1718 SYMBOL_CLASS (sym
) = LOC_CONST
;
1719 SYMBOL_TYPE (sym
) = type
;
1720 SYMBOL_VALUE (sym
) = FIELD_BITPOS (list
->field
);
1721 if (SYMBOL_VALUE (sym
) < 0)
1723 add_symbol_to_list (sym
, list_in_scope
);
1725 /* Now create the vector of fields, and record how big it is. This is
1726 where we reverse the order, by pulling the members off the list in
1727 reverse order from how they were inserted. If we have no fields
1728 (this is apparently possible in C++) then skip building a field
1733 TYPE_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
1734 TYPE_NFIELDS (type
) = nfields
;
1735 TYPE_FIELDS (type
) = (struct field
*)
1736 obstack_alloc (&objfile
->symbol_obstack
, sizeof (struct field
) * nfields
);
1737 /* Copy the saved-up fields into the field vector. */
1738 for (n
= 0; (n
< nfields
) && (list
!= NULL
); list
= list
->next
)
1740 TYPE_FIELD (type
, n
++) = list
->field
;
1751 read_func_scope -- process all dies within a function scope
1755 Process all dies within a given function scope. We are passed
1756 a die information structure pointer DIP for the die which
1757 starts the function scope, and pointers into the raw die data
1758 that define the dies within the function scope.
1760 For now, we ignore lexical block scopes within the function.
1761 The problem is that AT&T cc does not define a DWARF lexical
1762 block scope for the function itself, while gcc defines a
1763 lexical block scope for the function. We need to think about
1764 how to handle this difference, or if it is even a problem.
1769 read_func_scope (struct dieinfo
*dip
, char *thisdie
, char *enddie
,
1770 struct objfile
*objfile
)
1772 register struct context_stack
*new;
1774 /* AT_name is absent if the function is described with an
1775 AT_abstract_origin tag.
1776 Ignore the function description for now to avoid GDB core dumps.
1777 FIXME: Add code to handle AT_abstract_origin tags properly. */
1778 if (dip
->at_name
== NULL
)
1780 complain (&missing_at_name
, DIE_ID
);
1784 if (objfile
->ei
.entry_point
>= dip
->at_low_pc
&&
1785 objfile
->ei
.entry_point
< dip
->at_high_pc
)
1787 objfile
->ei
.entry_func_lowpc
= dip
->at_low_pc
;
1788 objfile
->ei
.entry_func_highpc
= dip
->at_high_pc
;
1790 new = push_context (0, dip
->at_low_pc
);
1791 new->name
= new_symbol (dip
, objfile
);
1792 list_in_scope
= &local_symbols
;
1793 process_dies (thisdie
+ dip
->die_length
, enddie
, objfile
);
1794 new = pop_context ();
1795 /* Make a block for the local symbols within. */
1796 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1797 new->start_addr
, dip
->at_high_pc
, objfile
);
1798 list_in_scope
= &file_symbols
;
1806 handle_producer -- process the AT_producer attribute
1810 Perform any operations that depend on finding a particular
1811 AT_producer attribute.
1816 handle_producer (char *producer
)
1819 /* If this compilation unit was compiled with g++ or gcc, then set the
1820 processing_gcc_compilation flag. */
1822 if (STREQN (producer
, GCC_PRODUCER
, strlen (GCC_PRODUCER
)))
1824 char version
= producer
[strlen (GCC_PRODUCER
)];
1825 processing_gcc_compilation
= (version
== '2' ? 2 : 1);
1829 processing_gcc_compilation
=
1830 STREQN (producer
, GPLUS_PRODUCER
, strlen (GPLUS_PRODUCER
))
1831 || STREQN (producer
, CHILL_PRODUCER
, strlen (CHILL_PRODUCER
));
1834 /* Select a demangling style if we can identify the producer and if
1835 the current style is auto. We leave the current style alone if it
1836 is not auto. We also leave the demangling style alone if we find a
1837 gcc (cc1) producer, as opposed to a g++ (cc1plus) producer. */
1839 if (AUTO_DEMANGLING
)
1841 if (STREQN (producer
, GPLUS_PRODUCER
, strlen (GPLUS_PRODUCER
)))
1844 /* For now, stay with AUTO_DEMANGLING for g++ output, as we don't
1845 know whether it will use the old style or v3 mangling. */
1846 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1849 else if (STREQN (producer
, LCC_PRODUCER
, strlen (LCC_PRODUCER
)))
1851 set_demangling_style (LUCID_DEMANGLING_STYLE_STRING
);
1861 read_file_scope -- process all dies within a file scope
1865 Process all dies within a given file scope. We are passed a
1866 pointer to the die information structure for the die which
1867 starts the file scope, and pointers into the raw die data which
1868 mark the range of dies within the file scope.
1870 When the partial symbol table is built, the file offset for the line
1871 number table for each compilation unit is saved in the partial symbol
1872 table entry for that compilation unit. As the symbols for each
1873 compilation unit are read, the line number table is read into memory
1874 and the variable lnbase is set to point to it. Thus all we have to
1875 do is use lnbase to access the line number table for the current
1880 read_file_scope (struct dieinfo
*dip
, char *thisdie
, char *enddie
,
1881 struct objfile
*objfile
)
1883 struct cleanup
*back_to
;
1884 struct symtab
*symtab
;
1886 if (objfile
->ei
.entry_point
>= dip
->at_low_pc
&&
1887 objfile
->ei
.entry_point
< dip
->at_high_pc
)
1889 objfile
->ei
.entry_file_lowpc
= dip
->at_low_pc
;
1890 objfile
->ei
.entry_file_highpc
= dip
->at_high_pc
;
1892 set_cu_language (dip
);
1893 if (dip
->at_producer
!= NULL
)
1895 handle_producer (dip
->at_producer
);
1897 numutypes
= (enddie
- thisdie
) / 4;
1898 utypes
= (struct type
**) xmalloc (numutypes
* sizeof (struct type
*));
1899 back_to
= make_cleanup (free_utypes
, NULL
);
1900 memset (utypes
, 0, numutypes
* sizeof (struct type
*));
1901 memset (ftypes
, 0, FT_NUM_MEMBERS
* sizeof (struct type
*));
1902 start_symtab (dip
->at_name
, dip
->at_comp_dir
, dip
->at_low_pc
);
1903 record_debugformat ("DWARF 1");
1904 decode_line_numbers (lnbase
);
1905 process_dies (thisdie
+ dip
->die_length
, enddie
, objfile
);
1907 symtab
= end_symtab (dip
->at_high_pc
, objfile
, 0);
1910 symtab
->language
= cu_language
;
1912 do_cleanups (back_to
);
1919 process_dies -- process a range of DWARF Information Entries
1923 static void process_dies (char *thisdie, char *enddie,
1924 struct objfile *objfile)
1928 Process all DIE's in a specified range. May be (and almost
1929 certainly will be) called recursively.
1933 process_dies (char *thisdie
, char *enddie
, struct objfile
*objfile
)
1938 while (thisdie
< enddie
)
1940 basicdieinfo (&di
, thisdie
, objfile
);
1941 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
1945 else if (di
.die_tag
== TAG_padding
)
1947 nextdie
= thisdie
+ di
.die_length
;
1951 completedieinfo (&di
, objfile
);
1952 if (di
.at_sibling
!= 0)
1954 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
1958 nextdie
= thisdie
+ di
.die_length
;
1960 #ifdef SMASH_TEXT_ADDRESS
1961 /* I think that these are always text, not data, addresses. */
1962 SMASH_TEXT_ADDRESS (di
.at_low_pc
);
1963 SMASH_TEXT_ADDRESS (di
.at_high_pc
);
1967 case TAG_compile_unit
:
1968 /* Skip Tag_compile_unit if we are already inside a compilation
1969 unit, we are unable to handle nested compilation units
1970 properly (FIXME). */
1971 if (current_subfile
== NULL
)
1972 read_file_scope (&di
, thisdie
, nextdie
, objfile
);
1974 nextdie
= thisdie
+ di
.die_length
;
1976 case TAG_global_subroutine
:
1977 case TAG_subroutine
:
1978 if (di
.has_at_low_pc
)
1980 read_func_scope (&di
, thisdie
, nextdie
, objfile
);
1983 case TAG_lexical_block
:
1984 read_lexical_block_scope (&di
, thisdie
, nextdie
, objfile
);
1986 case TAG_class_type
:
1987 case TAG_structure_type
:
1988 case TAG_union_type
:
1989 read_structure_scope (&di
, thisdie
, nextdie
, objfile
);
1991 case TAG_enumeration_type
:
1992 read_enumeration (&di
, thisdie
, nextdie
, objfile
);
1994 case TAG_subroutine_type
:
1995 read_subroutine_type (&di
, thisdie
, nextdie
);
1997 case TAG_array_type
:
1998 dwarf_read_array_type (&di
);
2000 case TAG_pointer_type
:
2001 read_tag_pointer_type (&di
);
2003 case TAG_string_type
:
2004 read_tag_string_type (&di
);
2007 new_symbol (&di
, objfile
);
2019 decode_line_numbers -- decode a line number table fragment
2023 static void decode_line_numbers (char *tblscan, char *tblend,
2024 long length, long base, long line, long pc)
2028 Translate the DWARF line number information to gdb form.
2030 The ".line" section contains one or more line number tables, one for
2031 each ".line" section from the objects that were linked.
2033 The AT_stmt_list attribute for each TAG_source_file entry in the
2034 ".debug" section contains the offset into the ".line" section for the
2035 start of the table for that file.
2037 The table itself has the following structure:
2039 <table length><base address><source statement entry>
2040 4 bytes 4 bytes 10 bytes
2042 The table length is the total size of the table, including the 4 bytes
2043 for the length information.
2045 The base address is the address of the first instruction generated
2046 for the source file.
2048 Each source statement entry has the following structure:
2050 <line number><statement position><address delta>
2051 4 bytes 2 bytes 4 bytes
2053 The line number is relative to the start of the file, starting with
2056 The statement position either -1 (0xFFFF) or the number of characters
2057 from the beginning of the line to the beginning of the statement.
2059 The address delta is the difference between the base address and
2060 the address of the first instruction for the statement.
2062 Note that we must copy the bytes from the packed table to our local
2063 variables before attempting to use them, to avoid alignment problems
2064 on some machines, particularly RISC processors.
2068 Does gdb expect the line numbers to be sorted? They are now by
2069 chance/luck, but are not required to be. (FIXME)
2071 The line with number 0 is unused, gdb apparently can discover the
2072 span of the last line some other way. How? (FIXME)
2076 decode_line_numbers (char *linetable
)
2080 unsigned long length
;
2085 if (linetable
!= NULL
)
2087 tblscan
= tblend
= linetable
;
2088 length
= target_to_host (tblscan
, SIZEOF_LINETBL_LENGTH
, GET_UNSIGNED
,
2090 tblscan
+= SIZEOF_LINETBL_LENGTH
;
2092 base
= target_to_host (tblscan
, TARGET_FT_POINTER_SIZE (objfile
),
2093 GET_UNSIGNED
, current_objfile
);
2094 tblscan
+= TARGET_FT_POINTER_SIZE (objfile
);
2096 while (tblscan
< tblend
)
2098 line
= target_to_host (tblscan
, SIZEOF_LINETBL_LINENO
, GET_UNSIGNED
,
2100 tblscan
+= SIZEOF_LINETBL_LINENO
+ SIZEOF_LINETBL_STMT
;
2101 pc
= target_to_host (tblscan
, SIZEOF_LINETBL_DELTA
, GET_UNSIGNED
,
2103 tblscan
+= SIZEOF_LINETBL_DELTA
;
2107 record_line (current_subfile
, line
, pc
);
2117 locval -- compute the value of a location attribute
2121 static int locval (struct dieinfo *dip)
2125 Given pointer to a string of bytes that define a location, compute
2126 the location and return the value.
2127 A location description containing no atoms indicates that the
2128 object is optimized out. The optimized_out flag is set for those,
2129 the return value is meaningless.
2131 When computing values involving the current value of the frame pointer,
2132 the value zero is used, which results in a value relative to the frame
2133 pointer, rather than the absolute value. This is what GDB wants
2136 When the result is a register number, the isreg flag is set, otherwise
2137 it is cleared. This is a kludge until we figure out a better
2138 way to handle the problem. Gdb's design does not mesh well with the
2139 DWARF notion of a location computing interpreter, which is a shame
2140 because the flexibility goes unused.
2144 Note that stack[0] is unused except as a default error return.
2145 Note that stack overflow is not yet handled.
2149 locval (struct dieinfo
*dip
)
2151 unsigned short nbytes
;
2152 unsigned short locsize
;
2153 auto long stack
[64];
2160 loc
= dip
->at_location
;
2161 nbytes
= attribute_size (AT_location
);
2162 locsize
= target_to_host (loc
, nbytes
, GET_UNSIGNED
, current_objfile
);
2164 end
= loc
+ locsize
;
2169 dip
->optimized_out
= 1;
2170 loc_value_size
= TARGET_FT_LONG_SIZE (current_objfile
);
2173 dip
->optimized_out
= 0;
2174 loc_atom_code
= target_to_host (loc
, SIZEOF_LOC_ATOM_CODE
, GET_UNSIGNED
,
2176 loc
+= SIZEOF_LOC_ATOM_CODE
;
2177 switch (loc_atom_code
)
2184 /* push register (number) */
2186 = DWARF_REG_TO_REGNUM (target_to_host (loc
, loc_value_size
,
2189 loc
+= loc_value_size
;
2193 /* push value of register (number) */
2194 /* Actually, we compute the value as if register has 0, so the
2195 value ends up being the offset from that register. */
2197 dip
->basereg
= target_to_host (loc
, loc_value_size
, GET_UNSIGNED
,
2199 loc
+= loc_value_size
;
2200 stack
[++stacki
] = 0;
2203 /* push address (relocated address) */
2204 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
2205 GET_UNSIGNED
, current_objfile
);
2206 loc
+= loc_value_size
;
2209 /* push constant (number) FIXME: signed or unsigned! */
2210 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
2211 GET_SIGNED
, current_objfile
);
2212 loc
+= loc_value_size
;
2215 /* pop, deref and push 2 bytes (as a long) */
2216 complain (&op_deref2
, DIE_ID
, DIE_NAME
, stack
[stacki
]);
2218 case OP_DEREF4
: /* pop, deref and push 4 bytes (as a long) */
2219 complain (&op_deref4
, DIE_ID
, DIE_NAME
, stack
[stacki
]);
2221 case OP_ADD
: /* pop top 2 items, add, push result */
2222 stack
[stacki
- 1] += stack
[stacki
];
2227 return (stack
[stacki
]);
2234 read_ofile_symtab -- build a full symtab entry from chunk of DIE's
2238 static void read_ofile_symtab (struct partial_symtab *pst)
2242 When expanding a partial symbol table entry to a full symbol table
2243 entry, this is the function that gets called to read in the symbols
2244 for the compilation unit. A pointer to the newly constructed symtab,
2245 which is now the new first one on the objfile's symtab list, is
2246 stashed in the partial symbol table entry.
2250 read_ofile_symtab (struct partial_symtab
*pst
)
2252 struct cleanup
*back_to
;
2253 unsigned long lnsize
;
2256 char lnsizedata
[SIZEOF_LINETBL_LENGTH
];
2258 abfd
= pst
->objfile
->obfd
;
2259 current_objfile
= pst
->objfile
;
2261 /* Allocate a buffer for the entire chunk of DIE's for this compilation
2262 unit, seek to the location in the file, and read in all the DIE's. */
2265 dbsize
= DBLENGTH (pst
);
2266 dbbase
= xmalloc (dbsize
);
2267 dbroff
= DBROFF (pst
);
2268 foffset
= DBFOFF (pst
) + dbroff
;
2269 base_section_offsets
= pst
->section_offsets
;
2270 baseaddr
= ANOFFSET (pst
->section_offsets
, 0);
2271 if (bfd_seek (abfd
, foffset
, SEEK_SET
) ||
2272 (bfd_bread (dbbase
, dbsize
, abfd
) != dbsize
))
2275 error ("can't read DWARF data");
2277 back_to
= make_cleanup (xfree
, dbbase
);
2279 /* If there is a line number table associated with this compilation unit
2280 then read the size of this fragment in bytes, from the fragment itself.
2281 Allocate a buffer for the fragment and read it in for future
2287 if (bfd_seek (abfd
, LNFOFF (pst
), SEEK_SET
) ||
2288 (bfd_bread ((PTR
) lnsizedata
, sizeof (lnsizedata
), abfd
)
2289 != sizeof (lnsizedata
)))
2291 error ("can't read DWARF line number table size");
2293 lnsize
= target_to_host (lnsizedata
, SIZEOF_LINETBL_LENGTH
,
2294 GET_UNSIGNED
, pst
->objfile
);
2295 lnbase
= xmalloc (lnsize
);
2296 if (bfd_seek (abfd
, LNFOFF (pst
), SEEK_SET
) ||
2297 (bfd_bread (lnbase
, lnsize
, abfd
) != lnsize
))
2300 error ("can't read DWARF line numbers");
2302 make_cleanup (xfree
, lnbase
);
2305 process_dies (dbbase
, dbbase
+ dbsize
, pst
->objfile
);
2306 do_cleanups (back_to
);
2307 current_objfile
= NULL
;
2308 pst
->symtab
= pst
->objfile
->symtabs
;
2315 psymtab_to_symtab_1 -- do grunt work for building a full symtab entry
2319 static void psymtab_to_symtab_1 (struct partial_symtab *pst)
2323 Called once for each partial symbol table entry that needs to be
2324 expanded into a full symbol table entry.
2329 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
2332 struct cleanup
*old_chain
;
2338 warning ("psymtab for %s already read in. Shouldn't happen.",
2343 /* Read in all partial symtabs on which this one is dependent */
2344 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2346 if (!pst
->dependencies
[i
]->readin
)
2348 /* Inform about additional files that need to be read in. */
2351 fputs_filtered (" ", gdb_stdout
);
2353 fputs_filtered ("and ", gdb_stdout
);
2355 printf_filtered ("%s...",
2356 pst
->dependencies
[i
]->filename
);
2358 gdb_flush (gdb_stdout
); /* Flush output */
2360 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
2363 if (DBLENGTH (pst
)) /* Otherwise it's a dummy */
2366 old_chain
= make_cleanup (really_free_pendings
, 0);
2367 read_ofile_symtab (pst
);
2370 printf_filtered ("%d DIE's, sorting...", diecount
);
2372 gdb_flush (gdb_stdout
);
2374 sort_symtab_syms (pst
->symtab
);
2375 do_cleanups (old_chain
);
2386 dwarf_psymtab_to_symtab -- build a full symtab entry from partial one
2390 static void dwarf_psymtab_to_symtab (struct partial_symtab *pst)
2394 This is the DWARF support entry point for building a full symbol
2395 table entry from a partial symbol table entry. We are passed a
2396 pointer to the partial symbol table entry that needs to be expanded.
2401 dwarf_psymtab_to_symtab (struct partial_symtab
*pst
)
2408 warning ("psymtab for %s already read in. Shouldn't happen.",
2413 if (DBLENGTH (pst
) || pst
->number_of_dependencies
)
2415 /* Print the message now, before starting serious work, to avoid
2416 disconcerting pauses. */
2419 printf_filtered ("Reading in symbols for %s...",
2421 gdb_flush (gdb_stdout
);
2424 psymtab_to_symtab_1 (pst
);
2426 #if 0 /* FIXME: Check to see what dbxread is doing here and see if
2427 we need to do an equivalent or is this something peculiar to
2429 Match with global symbols. This only needs to be done once,
2430 after all of the symtabs and dependencies have been read in.
2432 scan_file_globals (pst
->objfile
);
2435 /* Finish up the verbose info message. */
2438 printf_filtered ("done.\n");
2439 gdb_flush (gdb_stdout
);
2450 add_enum_psymbol -- add enumeration members to partial symbol table
2454 Given pointer to a DIE that is known to be for an enumeration,
2455 extract the symbolic names of the enumeration members and add
2456 partial symbols for them.
2460 add_enum_psymbol (struct dieinfo
*dip
, struct objfile
*objfile
)
2464 unsigned short blocksz
;
2467 if ((scan
= dip
->at_element_list
) != NULL
)
2469 if (dip
->short_element_list
)
2471 nbytes
= attribute_size (AT_short_element_list
);
2475 nbytes
= attribute_size (AT_element_list
);
2477 blocksz
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, objfile
);
2479 listend
= scan
+ blocksz
;
2480 while (scan
< listend
)
2482 scan
+= TARGET_FT_LONG_SIZE (objfile
);
2483 add_psymbol_to_list (scan
, strlen (scan
), VAR_NAMESPACE
, LOC_CONST
,
2484 &objfile
->static_psymbols
, 0, 0, cu_language
,
2486 scan
+= strlen (scan
) + 1;
2495 add_partial_symbol -- add symbol to partial symbol table
2499 Given a DIE, if it is one of the types that we want to
2500 add to a partial symbol table, finish filling in the die info
2501 and then add a partial symbol table entry for it.
2505 The caller must ensure that the DIE has a valid name attribute.
2509 add_partial_symbol (struct dieinfo
*dip
, struct objfile
*objfile
)
2511 switch (dip
->die_tag
)
2513 case TAG_global_subroutine
:
2514 add_psymbol_to_list (dip
->at_name
, strlen (dip
->at_name
),
2515 VAR_NAMESPACE
, LOC_BLOCK
,
2516 &objfile
->global_psymbols
,
2517 0, dip
->at_low_pc
, cu_language
, objfile
);
2519 case TAG_global_variable
:
2520 add_psymbol_to_list (dip
->at_name
, strlen (dip
->at_name
),
2521 VAR_NAMESPACE
, LOC_STATIC
,
2522 &objfile
->global_psymbols
,
2523 0, 0, cu_language
, objfile
);
2525 case TAG_subroutine
:
2526 add_psymbol_to_list (dip
->at_name
, strlen (dip
->at_name
),
2527 VAR_NAMESPACE
, LOC_BLOCK
,
2528 &objfile
->static_psymbols
,
2529 0, dip
->at_low_pc
, cu_language
, objfile
);
2531 case TAG_local_variable
:
2532 add_psymbol_to_list (dip
->at_name
, strlen (dip
->at_name
),
2533 VAR_NAMESPACE
, LOC_STATIC
,
2534 &objfile
->static_psymbols
,
2535 0, 0, cu_language
, objfile
);
2538 add_psymbol_to_list (dip
->at_name
, strlen (dip
->at_name
),
2539 VAR_NAMESPACE
, LOC_TYPEDEF
,
2540 &objfile
->static_psymbols
,
2541 0, 0, cu_language
, objfile
);
2543 case TAG_class_type
:
2544 case TAG_structure_type
:
2545 case TAG_union_type
:
2546 case TAG_enumeration_type
:
2547 /* Do not add opaque aggregate definitions to the psymtab. */
2548 if (!dip
->has_at_byte_size
)
2550 add_psymbol_to_list (dip
->at_name
, strlen (dip
->at_name
),
2551 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2552 &objfile
->static_psymbols
,
2553 0, 0, cu_language
, objfile
);
2554 if (cu_language
== language_cplus
)
2556 /* For C++, these implicitly act as typedefs as well. */
2557 add_psymbol_to_list (dip
->at_name
, strlen (dip
->at_name
),
2558 VAR_NAMESPACE
, LOC_TYPEDEF
,
2559 &objfile
->static_psymbols
,
2560 0, 0, cu_language
, objfile
);
2570 scan_partial_symbols -- scan DIE's within a single compilation unit
2574 Process the DIE's within a single compilation unit, looking for
2575 interesting DIE's that contribute to the partial symbol table entry
2576 for this compilation unit.
2580 There are some DIE's that may appear both at file scope and within
2581 the scope of a function. We are only interested in the ones at file
2582 scope, and the only way to tell them apart is to keep track of the
2583 scope. For example, consider the test case:
2588 for which the relevant DWARF segment has the structure:
2591 0x23 global subrtn sibling 0x9b
2593 fund_type FT_integer
2598 0x23 local var sibling 0x97
2600 fund_type FT_integer
2601 location OP_BASEREG 0xe
2608 0x1d local var sibling 0xb8
2610 fund_type FT_integer
2611 location OP_ADDR 0x800025dc
2616 We want to include the symbol 'i' in the partial symbol table, but
2617 not the symbol 'j'. In essence, we want to skip all the dies within
2618 the scope of a TAG_global_subroutine DIE.
2620 Don't attempt to add anonymous structures or unions since they have
2621 no name. Anonymous enumerations however are processed, because we
2622 want to extract their member names (the check for a tag name is
2625 Also, for variables and subroutines, check that this is the place
2626 where the actual definition occurs, rather than just a reference
2634 scan_partial_symbols (char *thisdie
, char *enddie
, struct objfile
*objfile
)
2640 while (thisdie
< enddie
)
2642 basicdieinfo (&di
, thisdie
, objfile
);
2643 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
2649 nextdie
= thisdie
+ di
.die_length
;
2650 /* To avoid getting complete die information for every die, we
2651 only do it (below) for the cases we are interested in. */
2654 case TAG_global_subroutine
:
2655 case TAG_subroutine
:
2656 completedieinfo (&di
, objfile
);
2657 if (di
.at_name
&& (di
.has_at_low_pc
|| di
.at_location
))
2659 add_partial_symbol (&di
, objfile
);
2660 /* If there is a sibling attribute, adjust the nextdie
2661 pointer to skip the entire scope of the subroutine.
2662 Apply some sanity checking to make sure we don't
2663 overrun or underrun the range of remaining DIE's */
2664 if (di
.at_sibling
!= 0)
2666 temp
= dbbase
+ di
.at_sibling
- dbroff
;
2667 if ((temp
< thisdie
) || (temp
>= enddie
))
2669 complain (&bad_die_ref
, DIE_ID
, DIE_NAME
,
2679 case TAG_global_variable
:
2680 case TAG_local_variable
:
2681 completedieinfo (&di
, objfile
);
2682 if (di
.at_name
&& (di
.has_at_low_pc
|| di
.at_location
))
2684 add_partial_symbol (&di
, objfile
);
2688 case TAG_class_type
:
2689 case TAG_structure_type
:
2690 case TAG_union_type
:
2691 completedieinfo (&di
, objfile
);
2694 add_partial_symbol (&di
, objfile
);
2697 case TAG_enumeration_type
:
2698 completedieinfo (&di
, objfile
);
2701 add_partial_symbol (&di
, objfile
);
2703 add_enum_psymbol (&di
, objfile
);
2715 scan_compilation_units -- build a psymtab entry for each compilation
2719 This is the top level dwarf parsing routine for building partial
2722 It scans from the beginning of the DWARF table looking for the first
2723 TAG_compile_unit DIE, and then follows the sibling chain to locate
2724 each additional TAG_compile_unit DIE.
2726 For each TAG_compile_unit DIE it creates a partial symtab structure,
2727 calls a subordinate routine to collect all the compilation unit's
2728 global DIE's, file scope DIEs, typedef DIEs, etc, and then links the
2729 new partial symtab structure into the partial symbol table. It also
2730 records the appropriate information in the partial symbol table entry
2731 to allow the chunk of DIE's and line number table for this compilation
2732 unit to be located and re-read later, to generate a complete symbol
2733 table entry for the compilation unit.
2735 Thus it effectively partitions up a chunk of DIE's for multiple
2736 compilation units into smaller DIE chunks and line number tables,
2737 and associates them with a partial symbol table entry.
2741 If any compilation unit has no line number table associated with
2742 it for some reason (a missing at_stmt_list attribute, rather than
2743 just one with a value of zero, which is valid) then we ensure that
2744 the recorded file offset is zero so that the routine which later
2745 reads line number table fragments knows that there is no fragment
2755 scan_compilation_units (char *thisdie
, char *enddie
, file_ptr dbfoff
,
2756 file_ptr lnoffset
, struct objfile
*objfile
)
2760 struct partial_symtab
*pst
;
2763 file_ptr curlnoffset
;
2765 while (thisdie
< enddie
)
2767 basicdieinfo (&di
, thisdie
, objfile
);
2768 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
2772 else if (di
.die_tag
!= TAG_compile_unit
)
2774 nextdie
= thisdie
+ di
.die_length
;
2778 completedieinfo (&di
, objfile
);
2779 set_cu_language (&di
);
2780 if (di
.at_sibling
!= 0)
2782 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
2786 nextdie
= thisdie
+ di
.die_length
;
2788 curoff
= thisdie
- dbbase
;
2789 culength
= nextdie
- thisdie
;
2790 curlnoffset
= di
.has_at_stmt_list
? lnoffset
+ di
.at_stmt_list
: 0;
2792 /* First allocate a new partial symbol table structure */
2794 pst
= start_psymtab_common (objfile
, base_section_offsets
,
2795 di
.at_name
, di
.at_low_pc
,
2796 objfile
->global_psymbols
.next
,
2797 objfile
->static_psymbols
.next
);
2799 pst
->texthigh
= di
.at_high_pc
;
2800 pst
->read_symtab_private
= (char *)
2801 obstack_alloc (&objfile
->psymbol_obstack
,
2802 sizeof (struct dwfinfo
));
2803 DBFOFF (pst
) = dbfoff
;
2804 DBROFF (pst
) = curoff
;
2805 DBLENGTH (pst
) = culength
;
2806 LNFOFF (pst
) = curlnoffset
;
2807 pst
->read_symtab
= dwarf_psymtab_to_symtab
;
2809 /* Now look for partial symbols */
2811 scan_partial_symbols (thisdie
+ di
.die_length
, nextdie
, objfile
);
2813 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
2814 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
2815 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
2816 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
2817 sort_pst_symbols (pst
);
2818 /* If there is already a psymtab or symtab for a file of this name,
2819 remove it. (If there is a symtab, more drastic things also
2820 happen.) This happens in VxWorks. */
2821 free_named_symtabs (pst
->filename
);
2831 new_symbol -- make a symbol table entry for a new symbol
2835 static struct symbol *new_symbol (struct dieinfo *dip,
2836 struct objfile *objfile)
2840 Given a pointer to a DWARF information entry, figure out if we need
2841 to make a symbol table entry for it, and if so, create a new entry
2842 and return a pointer to it.
2845 static struct symbol
*
2846 new_symbol (struct dieinfo
*dip
, struct objfile
*objfile
)
2848 struct symbol
*sym
= NULL
;
2850 if (dip
->at_name
!= NULL
)
2852 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
2853 sizeof (struct symbol
));
2854 OBJSTAT (objfile
, n_syms
++);
2855 memset (sym
, 0, sizeof (struct symbol
));
2856 SYMBOL_NAME (sym
) = create_name (dip
->at_name
,
2857 &objfile
->symbol_obstack
);
2858 /* default assumptions */
2859 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2860 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2861 SYMBOL_TYPE (sym
) = decode_die_type (dip
);
2863 /* If this symbol is from a C++ compilation, then attempt to cache the
2864 demangled form for future reference. This is a typical time versus
2865 space tradeoff, that was decided in favor of time because it sped up
2866 C++ symbol lookups by a factor of about 20. */
2868 SYMBOL_LANGUAGE (sym
) = cu_language
;
2869 SYMBOL_INIT_DEMANGLED_NAME (sym
, &objfile
->symbol_obstack
);
2870 switch (dip
->die_tag
)
2873 SYMBOL_VALUE_ADDRESS (sym
) = dip
->at_low_pc
;
2874 SYMBOL_CLASS (sym
) = LOC_LABEL
;
2876 case TAG_global_subroutine
:
2877 case TAG_subroutine
:
2878 SYMBOL_VALUE_ADDRESS (sym
) = dip
->at_low_pc
;
2879 SYMBOL_TYPE (sym
) = lookup_function_type (SYMBOL_TYPE (sym
));
2880 if (dip
->at_prototyped
)
2881 TYPE_FLAGS (SYMBOL_TYPE (sym
)) |= TYPE_FLAG_PROTOTYPED
;
2882 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
2883 if (dip
->die_tag
== TAG_global_subroutine
)
2885 add_symbol_to_list (sym
, &global_symbols
);
2889 add_symbol_to_list (sym
, list_in_scope
);
2892 case TAG_global_variable
:
2893 if (dip
->at_location
!= NULL
)
2895 SYMBOL_VALUE_ADDRESS (sym
) = locval (dip
);
2896 add_symbol_to_list (sym
, &global_symbols
);
2897 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2898 SYMBOL_VALUE (sym
) += baseaddr
;
2901 case TAG_local_variable
:
2902 if (dip
->at_location
!= NULL
)
2904 int loc
= locval (dip
);
2905 if (dip
->optimized_out
)
2907 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
2909 else if (dip
->isreg
)
2911 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
2913 else if (dip
->offreg
)
2915 SYMBOL_CLASS (sym
) = LOC_BASEREG
;
2916 SYMBOL_BASEREG (sym
) = dip
->basereg
;
2920 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2921 SYMBOL_VALUE (sym
) += baseaddr
;
2923 if (SYMBOL_CLASS (sym
) == LOC_STATIC
)
2925 /* LOC_STATIC address class MUST use SYMBOL_VALUE_ADDRESS,
2926 which may store to a bigger location than SYMBOL_VALUE. */
2927 SYMBOL_VALUE_ADDRESS (sym
) = loc
;
2931 SYMBOL_VALUE (sym
) = loc
;
2933 add_symbol_to_list (sym
, list_in_scope
);
2936 case TAG_formal_parameter
:
2937 if (dip
->at_location
!= NULL
)
2939 SYMBOL_VALUE (sym
) = locval (dip
);
2941 add_symbol_to_list (sym
, list_in_scope
);
2944 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
2946 else if (dip
->offreg
)
2948 SYMBOL_CLASS (sym
) = LOC_BASEREG_ARG
;
2949 SYMBOL_BASEREG (sym
) = dip
->basereg
;
2953 SYMBOL_CLASS (sym
) = LOC_ARG
;
2956 case TAG_unspecified_parameters
:
2957 /* From varargs functions; gdb doesn't seem to have any interest in
2958 this information, so just ignore it for now. (FIXME?) */
2960 case TAG_class_type
:
2961 case TAG_structure_type
:
2962 case TAG_union_type
:
2963 case TAG_enumeration_type
:
2964 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2965 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
2966 add_symbol_to_list (sym
, list_in_scope
);
2969 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2970 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2971 add_symbol_to_list (sym
, list_in_scope
);
2974 /* Not a tag we recognize. Hopefully we aren't processing trash
2975 data, but since we must specifically ignore things we don't
2976 recognize, there is nothing else we should do at this point. */
2987 synthesize_typedef -- make a symbol table entry for a "fake" typedef
2991 static void synthesize_typedef (struct dieinfo *dip,
2992 struct objfile *objfile,
2997 Given a pointer to a DWARF information entry, synthesize a typedef
2998 for the name in the DIE, using the specified type.
3000 This is used for C++ class, structs, unions, and enumerations to
3001 set up the tag name as a type.
3006 synthesize_typedef (struct dieinfo
*dip
, struct objfile
*objfile
,
3009 struct symbol
*sym
= NULL
;
3011 if (dip
->at_name
!= NULL
)
3013 sym
= (struct symbol
*)
3014 obstack_alloc (&objfile
->symbol_obstack
, sizeof (struct symbol
));
3015 OBJSTAT (objfile
, n_syms
++);
3016 memset (sym
, 0, sizeof (struct symbol
));
3017 SYMBOL_NAME (sym
) = create_name (dip
->at_name
,
3018 &objfile
->symbol_obstack
);
3019 SYMBOL_INIT_LANGUAGE_SPECIFIC (sym
, cu_language
);
3020 SYMBOL_TYPE (sym
) = type
;
3021 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
3022 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3023 add_symbol_to_list (sym
, list_in_scope
);
3031 decode_mod_fund_type -- decode a modified fundamental type
3035 static struct type *decode_mod_fund_type (char *typedata)
3039 Decode a block of data containing a modified fundamental
3040 type specification. TYPEDATA is a pointer to the block,
3041 which starts with a length containing the size of the rest
3042 of the block. At the end of the block is a fundmental type
3043 code value that gives the fundamental type. Everything
3044 in between are type modifiers.
3046 We simply compute the number of modifiers and call the general
3047 function decode_modified_type to do the actual work.
3050 static struct type
*
3051 decode_mod_fund_type (char *typedata
)
3053 struct type
*typep
= NULL
;
3054 unsigned short modcount
;
3057 /* Get the total size of the block, exclusive of the size itself */
3059 nbytes
= attribute_size (AT_mod_fund_type
);
3060 modcount
= target_to_host (typedata
, nbytes
, GET_UNSIGNED
, current_objfile
);
3063 /* Deduct the size of the fundamental type bytes at the end of the block. */
3065 modcount
-= attribute_size (AT_fund_type
);
3067 /* Now do the actual decoding */
3069 typep
= decode_modified_type (typedata
, modcount
, AT_mod_fund_type
);
3077 decode_mod_u_d_type -- decode a modified user defined type
3081 static struct type *decode_mod_u_d_type (char *typedata)
3085 Decode a block of data containing a modified user defined
3086 type specification. TYPEDATA is a pointer to the block,
3087 which consists of a two byte length, containing the size
3088 of the rest of the block. At the end of the block is a
3089 four byte value that gives a reference to a user defined type.
3090 Everything in between are type modifiers.
3092 We simply compute the number of modifiers and call the general
3093 function decode_modified_type to do the actual work.
3096 static struct type
*
3097 decode_mod_u_d_type (char *typedata
)
3099 struct type
*typep
= NULL
;
3100 unsigned short modcount
;
3103 /* Get the total size of the block, exclusive of the size itself */
3105 nbytes
= attribute_size (AT_mod_u_d_type
);
3106 modcount
= target_to_host (typedata
, nbytes
, GET_UNSIGNED
, current_objfile
);
3109 /* Deduct the size of the reference type bytes at the end of the block. */
3111 modcount
-= attribute_size (AT_user_def_type
);
3113 /* Now do the actual decoding */
3115 typep
= decode_modified_type (typedata
, modcount
, AT_mod_u_d_type
);
3123 decode_modified_type -- decode modified user or fundamental type
3127 static struct type *decode_modified_type (char *modifiers,
3128 unsigned short modcount, int mtype)
3132 Decode a modified type, either a modified fundamental type or
3133 a modified user defined type. MODIFIERS is a pointer to the
3134 block of bytes that define MODCOUNT modifiers. Immediately
3135 following the last modifier is a short containing the fundamental
3136 type or a long containing the reference to the user defined
3137 type. Which one is determined by MTYPE, which is either
3138 AT_mod_fund_type or AT_mod_u_d_type to indicate what modified
3139 type we are generating.
3141 We call ourself recursively to generate each modified type,`
3142 until MODCOUNT reaches zero, at which point we have consumed
3143 all the modifiers and generate either the fundamental type or
3144 user defined type. When the recursion unwinds, each modifier
3145 is applied in turn to generate the full modified type.
3149 If we find a modifier that we don't recognize, and it is not one
3150 of those reserved for application specific use, then we issue a
3151 warning and simply ignore the modifier.
3155 We currently ignore MOD_const and MOD_volatile. (FIXME)
3159 static struct type
*
3160 decode_modified_type (char *modifiers
, unsigned int modcount
, int mtype
)
3162 struct type
*typep
= NULL
;
3163 unsigned short fundtype
;
3172 case AT_mod_fund_type
:
3173 nbytes
= attribute_size (AT_fund_type
);
3174 fundtype
= target_to_host (modifiers
, nbytes
, GET_UNSIGNED
,
3176 typep
= decode_fund_type (fundtype
);
3178 case AT_mod_u_d_type
:
3179 nbytes
= attribute_size (AT_user_def_type
);
3180 die_ref
= target_to_host (modifiers
, nbytes
, GET_UNSIGNED
,
3182 if ((typep
= lookup_utype (die_ref
)) == NULL
)
3184 typep
= alloc_utype (die_ref
, NULL
);
3188 complain (&botched_modified_type
, DIE_ID
, DIE_NAME
, mtype
);
3189 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
3195 modifier
= *modifiers
++;
3196 typep
= decode_modified_type (modifiers
, --modcount
, mtype
);
3199 case MOD_pointer_to
:
3200 typep
= lookup_pointer_type (typep
);
3202 case MOD_reference_to
:
3203 typep
= lookup_reference_type (typep
);
3206 complain (&const_ignored
, DIE_ID
, DIE_NAME
); /* FIXME */
3209 complain (&volatile_ignored
, DIE_ID
, DIE_NAME
); /* FIXME */
3212 if (!(MOD_lo_user
<= (unsigned char) modifier
3213 && (unsigned char) modifier
<= MOD_hi_user
))
3215 complain (&unknown_type_modifier
, DIE_ID
, DIE_NAME
, modifier
);
3227 decode_fund_type -- translate basic DWARF type to gdb base type
3231 Given an integer that is one of the fundamental DWARF types,
3232 translate it to one of the basic internal gdb types and return
3233 a pointer to the appropriate gdb type (a "struct type *").
3237 For robustness, if we are asked to translate a fundamental
3238 type that we are unprepared to deal with, we return int so
3239 callers can always depend upon a valid type being returned,
3240 and so gdb may at least do something reasonable by default.
3241 If the type is not in the range of those types defined as
3242 application specific types, we also issue a warning.
3245 static struct type
*
3246 decode_fund_type (unsigned int fundtype
)
3248 struct type
*typep
= NULL
;
3254 typep
= dwarf_fundamental_type (current_objfile
, FT_VOID
);
3257 case FT_boolean
: /* Was FT_set in AT&T version */
3258 typep
= dwarf_fundamental_type (current_objfile
, FT_BOOLEAN
);
3261 case FT_pointer
: /* (void *) */
3262 typep
= dwarf_fundamental_type (current_objfile
, FT_VOID
);
3263 typep
= lookup_pointer_type (typep
);
3267 typep
= dwarf_fundamental_type (current_objfile
, FT_CHAR
);
3270 case FT_signed_char
:
3271 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_CHAR
);
3274 case FT_unsigned_char
:
3275 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_CHAR
);
3279 typep
= dwarf_fundamental_type (current_objfile
, FT_SHORT
);
3282 case FT_signed_short
:
3283 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_SHORT
);
3286 case FT_unsigned_short
:
3287 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_SHORT
);
3291 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
3294 case FT_signed_integer
:
3295 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_INTEGER
);
3298 case FT_unsigned_integer
:
3299 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_INTEGER
);
3303 typep
= dwarf_fundamental_type (current_objfile
, FT_LONG
);
3306 case FT_signed_long
:
3307 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_LONG
);
3310 case FT_unsigned_long
:
3311 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_LONG
);
3315 typep
= dwarf_fundamental_type (current_objfile
, FT_LONG_LONG
);
3318 case FT_signed_long_long
:
3319 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_LONG_LONG
);
3322 case FT_unsigned_long_long
:
3323 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_LONG_LONG
);
3327 typep
= dwarf_fundamental_type (current_objfile
, FT_FLOAT
);
3330 case FT_dbl_prec_float
:
3331 typep
= dwarf_fundamental_type (current_objfile
, FT_DBL_PREC_FLOAT
);
3334 case FT_ext_prec_float
:
3335 typep
= dwarf_fundamental_type (current_objfile
, FT_EXT_PREC_FLOAT
);
3339 typep
= dwarf_fundamental_type (current_objfile
, FT_COMPLEX
);
3342 case FT_dbl_prec_complex
:
3343 typep
= dwarf_fundamental_type (current_objfile
, FT_DBL_PREC_COMPLEX
);
3346 case FT_ext_prec_complex
:
3347 typep
= dwarf_fundamental_type (current_objfile
, FT_EXT_PREC_COMPLEX
);
3354 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
3355 if (!(FT_lo_user
<= fundtype
&& fundtype
<= FT_hi_user
))
3357 complain (&unexpected_fund_type
, DIE_ID
, DIE_NAME
, fundtype
);
3368 create_name -- allocate a fresh copy of a string on an obstack
3372 Given a pointer to a string and a pointer to an obstack, allocates
3373 a fresh copy of the string on the specified obstack.
3378 create_name (char *name
, struct obstack
*obstackp
)
3383 length
= strlen (name
) + 1;
3384 newname
= (char *) obstack_alloc (obstackp
, length
);
3385 strcpy (newname
, name
);
3393 basicdieinfo -- extract the minimal die info from raw die data
3397 void basicdieinfo (char *diep, struct dieinfo *dip,
3398 struct objfile *objfile)
3402 Given a pointer to raw DIE data, and a pointer to an instance of a
3403 die info structure, this function extracts the basic information
3404 from the DIE data required to continue processing this DIE, along
3405 with some bookkeeping information about the DIE.
3407 The information we absolutely must have includes the DIE tag,
3408 and the DIE length. If we need the sibling reference, then we
3409 will have to call completedieinfo() to process all the remaining
3412 Note that since there is no guarantee that the data is properly
3413 aligned in memory for the type of access required (indirection
3414 through anything other than a char pointer), and there is no
3415 guarantee that it is in the same byte order as the gdb host,
3416 we call a function which deals with both alignment and byte
3417 swapping issues. Possibly inefficient, but quite portable.
3419 We also take care of some other basic things at this point, such
3420 as ensuring that the instance of the die info structure starts
3421 out completely zero'd and that curdie is initialized for use
3422 in error reporting if we have a problem with the current die.
3426 All DIE's must have at least a valid length, thus the minimum
3427 DIE size is SIZEOF_DIE_LENGTH. In order to have a valid tag, the
3428 DIE size must be at least SIZEOF_DIE_TAG larger, otherwise they
3429 are forced to be TAG_padding DIES.
3431 Padding DIES must be at least SIZEOF_DIE_LENGTH in length, implying
3432 that if a padding DIE is used for alignment and the amount needed is
3433 less than SIZEOF_DIE_LENGTH, then the padding DIE has to be big
3434 enough to align to the next alignment boundry.
3436 We do some basic sanity checking here, such as verifying that the
3437 length of the die would not cause it to overrun the recorded end of
3438 the buffer holding the DIE info. If we find a DIE that is either
3439 too small or too large, we force it's length to zero which should
3440 cause the caller to take appropriate action.
3444 basicdieinfo (struct dieinfo
*dip
, char *diep
, struct objfile
*objfile
)
3447 memset (dip
, 0, sizeof (struct dieinfo
));
3449 dip
->die_ref
= dbroff
+ (diep
- dbbase
);
3450 dip
->die_length
= target_to_host (diep
, SIZEOF_DIE_LENGTH
, GET_UNSIGNED
,
3452 if ((dip
->die_length
< SIZEOF_DIE_LENGTH
) ||
3453 ((diep
+ dip
->die_length
) > (dbbase
+ dbsize
)))
3455 complain (&malformed_die
, DIE_ID
, DIE_NAME
, dip
->die_length
);
3456 dip
->die_length
= 0;
3458 else if (dip
->die_length
< (SIZEOF_DIE_LENGTH
+ SIZEOF_DIE_TAG
))
3460 dip
->die_tag
= TAG_padding
;
3464 diep
+= SIZEOF_DIE_LENGTH
;
3465 dip
->die_tag
= target_to_host (diep
, SIZEOF_DIE_TAG
, GET_UNSIGNED
,
3474 completedieinfo -- finish reading the information for a given DIE
3478 void completedieinfo (struct dieinfo *dip, struct objfile *objfile)
3482 Given a pointer to an already partially initialized die info structure,
3483 scan the raw DIE data and finish filling in the die info structure
3484 from the various attributes found.
3486 Note that since there is no guarantee that the data is properly
3487 aligned in memory for the type of access required (indirection
3488 through anything other than a char pointer), and there is no
3489 guarantee that it is in the same byte order as the gdb host,
3490 we call a function which deals with both alignment and byte
3491 swapping issues. Possibly inefficient, but quite portable.
3495 Each time we are called, we increment the diecount variable, which
3496 keeps an approximate count of the number of dies processed for
3497 each compilation unit. This information is presented to the user
3498 if the info_verbose flag is set.
3503 completedieinfo (struct dieinfo
*dip
, struct objfile
*objfile
)
3505 char *diep
; /* Current pointer into raw DIE data */
3506 char *end
; /* Terminate DIE scan here */
3507 unsigned short attr
; /* Current attribute being scanned */
3508 unsigned short form
; /* Form of the attribute */
3509 int nbytes
; /* Size of next field to read */
3513 end
= diep
+ dip
->die_length
;
3514 diep
+= SIZEOF_DIE_LENGTH
+ SIZEOF_DIE_TAG
;
3517 attr
= target_to_host (diep
, SIZEOF_ATTRIBUTE
, GET_UNSIGNED
, objfile
);
3518 diep
+= SIZEOF_ATTRIBUTE
;
3519 if ((nbytes
= attribute_size (attr
)) == -1)
3521 complain (&unknown_attribute_length
, DIE_ID
, DIE_NAME
);
3528 dip
->at_fund_type
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3532 dip
->at_ordering
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3536 dip
->at_bit_offset
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3540 dip
->at_sibling
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3544 dip
->at_stmt_list
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3546 dip
->has_at_stmt_list
= 1;
3549 dip
->at_low_pc
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3551 dip
->at_low_pc
+= baseaddr
;
3552 dip
->has_at_low_pc
= 1;
3555 dip
->at_high_pc
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3557 dip
->at_high_pc
+= baseaddr
;
3560 dip
->at_language
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3563 case AT_user_def_type
:
3564 dip
->at_user_def_type
= target_to_host (diep
, nbytes
,
3565 GET_UNSIGNED
, objfile
);
3568 dip
->at_byte_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3570 dip
->has_at_byte_size
= 1;
3573 dip
->at_bit_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3577 dip
->at_member
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3581 dip
->at_discr
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3585 dip
->at_location
= diep
;
3587 case AT_mod_fund_type
:
3588 dip
->at_mod_fund_type
= diep
;
3590 case AT_subscr_data
:
3591 dip
->at_subscr_data
= diep
;
3593 case AT_mod_u_d_type
:
3594 dip
->at_mod_u_d_type
= diep
;
3596 case AT_element_list
:
3597 dip
->at_element_list
= diep
;
3598 dip
->short_element_list
= 0;
3600 case AT_short_element_list
:
3601 dip
->at_element_list
= diep
;
3602 dip
->short_element_list
= 1;
3604 case AT_discr_value
:
3605 dip
->at_discr_value
= diep
;
3607 case AT_string_length
:
3608 dip
->at_string_length
= diep
;
3611 dip
->at_name
= diep
;
3614 /* For now, ignore any "hostname:" portion, since gdb doesn't
3615 know how to deal with it. (FIXME). */
3616 dip
->at_comp_dir
= strrchr (diep
, ':');
3617 if (dip
->at_comp_dir
!= NULL
)
3623 dip
->at_comp_dir
= diep
;
3627 dip
->at_producer
= diep
;
3629 case AT_start_scope
:
3630 dip
->at_start_scope
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3633 case AT_stride_size
:
3634 dip
->at_stride_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3638 dip
->at_src_info
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3642 dip
->at_prototyped
= diep
;
3645 /* Found an attribute that we are unprepared to handle. However
3646 it is specifically one of the design goals of DWARF that
3647 consumers should ignore unknown attributes. As long as the
3648 form is one that we recognize (so we know how to skip it),
3649 we can just ignore the unknown attribute. */
3652 form
= FORM_FROM_ATTR (attr
);
3666 diep
+= TARGET_FT_POINTER_SIZE (objfile
);
3669 diep
+= 2 + target_to_host (diep
, nbytes
, GET_UNSIGNED
, objfile
);
3672 diep
+= 4 + target_to_host (diep
, nbytes
, GET_UNSIGNED
, objfile
);
3675 diep
+= strlen (diep
) + 1;
3678 complain (&unknown_attribute_form
, DIE_ID
, DIE_NAME
, form
);
3689 target_to_host -- swap in target data to host
3693 target_to_host (char *from, int nbytes, int signextend,
3694 struct objfile *objfile)
3698 Given pointer to data in target format in FROM, a byte count for
3699 the size of the data in NBYTES, a flag indicating whether or not
3700 the data is signed in SIGNEXTEND, and a pointer to the current
3701 objfile in OBJFILE, convert the data to host format and return
3702 the converted value.
3706 FIXME: If we read data that is known to be signed, and expect to
3707 use it as signed data, then we need to explicitly sign extend the
3708 result until the bfd library is able to do this for us.
3710 FIXME: Would a 32 bit target ever need an 8 byte result?
3715 target_to_host (char *from
, int nbytes
, int signextend
, /* FIXME: Unused */
3716 struct objfile
*objfile
)
3723 rtnval
= bfd_get_64 (objfile
->obfd
, (bfd_byte
*) from
);
3726 rtnval
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) from
);
3729 rtnval
= bfd_get_16 (objfile
->obfd
, (bfd_byte
*) from
);
3732 rtnval
= bfd_get_8 (objfile
->obfd
, (bfd_byte
*) from
);
3735 complain (&no_bfd_get_N
, DIE_ID
, DIE_NAME
, nbytes
);
3746 attribute_size -- compute size of data for a DWARF attribute
3750 static int attribute_size (unsigned int attr)
3754 Given a DWARF attribute in ATTR, compute the size of the first
3755 piece of data associated with this attribute and return that
3758 Returns -1 for unrecognized attributes.
3763 attribute_size (unsigned int attr
)
3765 int nbytes
; /* Size of next data for this attribute */
3766 unsigned short form
; /* Form of the attribute */
3768 form
= FORM_FROM_ATTR (attr
);
3771 case FORM_STRING
: /* A variable length field is next */
3774 case FORM_DATA2
: /* Next 2 byte field is the data itself */
3775 case FORM_BLOCK2
: /* Next 2 byte field is a block length */
3778 case FORM_DATA4
: /* Next 4 byte field is the data itself */
3779 case FORM_BLOCK4
: /* Next 4 byte field is a block length */
3780 case FORM_REF
: /* Next 4 byte field is a DIE offset */
3783 case FORM_DATA8
: /* Next 8 byte field is the data itself */
3786 case FORM_ADDR
: /* Next field size is target sizeof(void *) */
3787 nbytes
= TARGET_FT_POINTER_SIZE (objfile
);
3790 complain (&unknown_attribute_form
, DIE_ID
, DIE_NAME
, form
);