1 /* DWARF 2 debugging format support for GDB.
3 Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
4 2004, 2005, 2006, 2007, 2008, 2009, 2010
5 Free Software Foundation, Inc.
7 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
8 Inc. with support from Florida State University (under contract
9 with the Ada Joint Program Office), and Silicon Graphics, Inc.
10 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
11 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
14 This file is part of GDB.
16 This program is free software; you can redistribute it and/or modify
17 it under the terms of the GNU General Public License as published by
18 the Free Software Foundation; either version 3 of the License, or
19 (at your option) any later version.
21 This program is distributed in the hope that it will be useful,
22 but WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 GNU General Public License for more details.
26 You should have received a copy of the GNU General Public License
27 along with this program. If not, see <http://www.gnu.org/licenses/>. */
37 #include "expression.h"
38 #include "filenames.h" /* for DOSish file names */
41 #include "complaints.h"
43 #include "dwarf2expr.h"
44 #include "dwarf2loc.h"
45 #include "cp-support.h"
51 #include "typeprint.h"
56 #include "gdb_string.h"
57 #include "gdb_assert.h"
58 #include <sys/types.h>
65 #define MAP_FAILED ((void *) -1)
70 /* .debug_info header for a compilation unit
71 Because of alignment constraints, this structure has padding and cannot
72 be mapped directly onto the beginning of the .debug_info section. */
73 typedef struct comp_unit_header
75 unsigned int length
; /* length of the .debug_info
77 unsigned short version
; /* version number -- 2 for DWARF
79 unsigned int abbrev_offset
; /* offset into .debug_abbrev section */
80 unsigned char addr_size
; /* byte size of an address -- 4 */
83 #define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
86 /* .debug_line statement program prologue
87 Because of alignment constraints, this structure has padding and cannot
88 be mapped directly onto the beginning of the .debug_info section. */
89 typedef struct statement_prologue
91 unsigned int total_length
; /* byte length of the statement
93 unsigned short version
; /* version number -- 2 for DWARF
95 unsigned int prologue_length
; /* # bytes between prologue &
97 unsigned char minimum_instruction_length
; /* byte size of
99 unsigned char default_is_stmt
; /* initial value of is_stmt
102 unsigned char line_range
;
103 unsigned char opcode_base
; /* number assigned to first special
105 unsigned char *standard_opcode_lengths
;
109 /* When non-zero, dump DIEs after they are read in. */
110 static int dwarf2_die_debug
= 0;
114 /* When set, the file that we're processing is known to have debugging
115 info for C++ namespaces. GCC 3.3.x did not produce this information,
116 but later versions do. */
118 static int processing_has_namespace_info
;
120 static const struct objfile_data
*dwarf2_objfile_data_key
;
122 struct dwarf2_section_info
128 /* True if we have tried to read this section. */
132 struct dwarf2_per_objfile
134 struct dwarf2_section_info info
;
135 struct dwarf2_section_info abbrev
;
136 struct dwarf2_section_info line
;
137 struct dwarf2_section_info loc
;
138 struct dwarf2_section_info macinfo
;
139 struct dwarf2_section_info str
;
140 struct dwarf2_section_info ranges
;
141 struct dwarf2_section_info types
;
142 struct dwarf2_section_info frame
;
143 struct dwarf2_section_info eh_frame
;
146 struct objfile
*objfile
;
148 /* A list of all the compilation units. This is used to locate
149 the target compilation unit of a particular reference. */
150 struct dwarf2_per_cu_data
**all_comp_units
;
152 /* The number of compilation units in ALL_COMP_UNITS. */
155 /* A chain of compilation units that are currently read in, so that
156 they can be freed later. */
157 struct dwarf2_per_cu_data
*read_in_chain
;
159 /* A table mapping .debug_types signatures to its signatured_type entry.
160 This is NULL if the .debug_types section hasn't been read in yet. */
161 htab_t signatured_types
;
163 /* A flag indicating wether this objfile has a section loaded at a
165 int has_section_at_zero
;
168 static struct dwarf2_per_objfile
*dwarf2_per_objfile
;
170 /* names of the debugging sections */
172 /* Note that if the debugging section has been compressed, it might
173 have a name like .zdebug_info. */
175 #define INFO_SECTION "debug_info"
176 #define ABBREV_SECTION "debug_abbrev"
177 #define LINE_SECTION "debug_line"
178 #define LOC_SECTION "debug_loc"
179 #define MACINFO_SECTION "debug_macinfo"
180 #define STR_SECTION "debug_str"
181 #define RANGES_SECTION "debug_ranges"
182 #define TYPES_SECTION "debug_types"
183 #define FRAME_SECTION "debug_frame"
184 #define EH_FRAME_SECTION "eh_frame"
186 /* local data types */
188 /* We hold several abbreviation tables in memory at the same time. */
189 #ifndef ABBREV_HASH_SIZE
190 #define ABBREV_HASH_SIZE 121
193 /* The data in a compilation unit header, after target2host
194 translation, looks like this. */
195 struct comp_unit_head
199 unsigned char addr_size
;
200 unsigned char signed_addr_p
;
201 unsigned int abbrev_offset
;
203 /* Size of file offsets; either 4 or 8. */
204 unsigned int offset_size
;
206 /* Size of the length field; either 4 or 12. */
207 unsigned int initial_length_size
;
209 /* Offset to the first byte of this compilation unit header in the
210 .debug_info section, for resolving relative reference dies. */
213 /* Offset to first die in this cu from the start of the cu.
214 This will be the first byte following the compilation unit header. */
215 unsigned int first_die_offset
;
218 /* Internal state when decoding a particular compilation unit. */
221 /* The objfile containing this compilation unit. */
222 struct objfile
*objfile
;
224 /* The header of the compilation unit. */
225 struct comp_unit_head header
;
227 /* Base address of this compilation unit. */
228 CORE_ADDR base_address
;
230 /* Non-zero if base_address has been set. */
233 struct function_range
*first_fn
, *last_fn
, *cached_fn
;
235 /* The language we are debugging. */
236 enum language language
;
237 const struct language_defn
*language_defn
;
239 const char *producer
;
241 /* The generic symbol table building routines have separate lists for
242 file scope symbols and all all other scopes (local scopes). So
243 we need to select the right one to pass to add_symbol_to_list().
244 We do it by keeping a pointer to the correct list in list_in_scope.
246 FIXME: The original dwarf code just treated the file scope as the
247 first local scope, and all other local scopes as nested local
248 scopes, and worked fine. Check to see if we really need to
249 distinguish these in buildsym.c. */
250 struct pending
**list_in_scope
;
252 /* DWARF abbreviation table associated with this compilation unit. */
253 struct abbrev_info
**dwarf2_abbrevs
;
255 /* Storage for the abbrev table. */
256 struct obstack abbrev_obstack
;
258 /* Hash table holding all the loaded partial DIEs. */
261 /* Storage for things with the same lifetime as this read-in compilation
262 unit, including partial DIEs. */
263 struct obstack comp_unit_obstack
;
265 /* When multiple dwarf2_cu structures are living in memory, this field
266 chains them all together, so that they can be released efficiently.
267 We will probably also want a generation counter so that most-recently-used
268 compilation units are cached... */
269 struct dwarf2_per_cu_data
*read_in_chain
;
271 /* Backchain to our per_cu entry if the tree has been built. */
272 struct dwarf2_per_cu_data
*per_cu
;
274 /* Pointer to the die -> type map. Although it is stored
275 permanently in per_cu, we copy it here to avoid double
279 /* How many compilation units ago was this CU last referenced? */
282 /* A hash table of die offsets for following references. */
285 /* Full DIEs if read in. */
286 struct die_info
*dies
;
288 /* A set of pointers to dwarf2_per_cu_data objects for compilation
289 units referenced by this one. Only set during full symbol processing;
290 partial symbol tables do not have dependencies. */
293 /* Header data from the line table, during full symbol processing. */
294 struct line_header
*line_header
;
296 /* Mark used when releasing cached dies. */
297 unsigned int mark
: 1;
299 /* This flag will be set if this compilation unit might include
300 inter-compilation-unit references. */
301 unsigned int has_form_ref_addr
: 1;
303 /* This flag will be set if this compilation unit includes any
304 DW_TAG_namespace DIEs. If we know that there are explicit
305 DIEs for namespaces, we don't need to try to infer them
306 from mangled names. */
307 unsigned int has_namespace_info
: 1;
310 /* Persistent data held for a compilation unit, even when not
311 processing it. We put a pointer to this structure in the
312 read_symtab_private field of the psymtab. If we encounter
313 inter-compilation-unit references, we also maintain a sorted
314 list of all compilation units. */
316 struct dwarf2_per_cu_data
318 /* The start offset and length of this compilation unit. 2**29-1
319 bytes should suffice to store the length of any compilation unit
320 - if it doesn't, GDB will fall over anyway.
321 NOTE: Unlike comp_unit_head.length, this length includes
322 initial_length_size. */
324 unsigned int length
: 29;
326 /* Flag indicating this compilation unit will be read in before
327 any of the current compilation units are processed. */
328 unsigned int queued
: 1;
330 /* This flag will be set if we need to load absolutely all DIEs
331 for this compilation unit, instead of just the ones we think
332 are interesting. It gets set if we look for a DIE in the
333 hash table and don't find it. */
334 unsigned int load_all_dies
: 1;
336 /* Non-zero if this CU is from .debug_types.
337 Otherwise it's from .debug_info. */
338 unsigned int from_debug_types
: 1;
340 /* Set iff currently read in. */
341 struct dwarf2_cu
*cu
;
343 /* If full symbols for this CU have been read in, then this field
344 holds a map of DIE offsets to types. It isn't always possible
345 to reconstruct this information later, so we have to preserve
349 /* The partial symbol table associated with this compilation unit,
350 or NULL for partial units (which do not have an associated
352 struct partial_symtab
*psymtab
;
355 /* Entry in the signatured_types hash table. */
357 struct signatured_type
361 /* Offset in .debug_types of the TU (type_unit) for this type. */
364 /* Offset in .debug_types of the type defined by this TU. */
365 unsigned int type_offset
;
367 /* The CU(/TU) of this type. */
368 struct dwarf2_per_cu_data per_cu
;
371 /* Struct used to pass misc. parameters to read_die_and_children, et. al.
372 which are used for both .debug_info and .debug_types dies.
373 All parameters here are unchanging for the life of the call.
374 This struct exists to abstract away the constant parameters of
377 struct die_reader_specs
379 /* The bfd of this objfile. */
382 /* The CU of the DIE we are parsing. */
383 struct dwarf2_cu
*cu
;
385 /* Pointer to start of section buffer.
386 This is either the start of .debug_info or .debug_types. */
387 const gdb_byte
*buffer
;
390 /* The line number information for a compilation unit (found in the
391 .debug_line section) begins with a "statement program header",
392 which contains the following information. */
395 unsigned int total_length
;
396 unsigned short version
;
397 unsigned int header_length
;
398 unsigned char minimum_instruction_length
;
399 unsigned char default_is_stmt
;
401 unsigned char line_range
;
402 unsigned char opcode_base
;
404 /* standard_opcode_lengths[i] is the number of operands for the
405 standard opcode whose value is i. This means that
406 standard_opcode_lengths[0] is unused, and the last meaningful
407 element is standard_opcode_lengths[opcode_base - 1]. */
408 unsigned char *standard_opcode_lengths
;
410 /* The include_directories table. NOTE! These strings are not
411 allocated with xmalloc; instead, they are pointers into
412 debug_line_buffer. If you try to free them, `free' will get
414 unsigned int num_include_dirs
, include_dirs_size
;
417 /* The file_names table. NOTE! These strings are not allocated
418 with xmalloc; instead, they are pointers into debug_line_buffer.
419 Don't try to free them directly. */
420 unsigned int num_file_names
, file_names_size
;
424 unsigned int dir_index
;
425 unsigned int mod_time
;
427 int included_p
; /* Non-zero if referenced by the Line Number Program. */
428 struct symtab
*symtab
; /* The associated symbol table, if any. */
431 /* The start and end of the statement program following this
432 header. These point into dwarf2_per_objfile->line_buffer. */
433 gdb_byte
*statement_program_start
, *statement_program_end
;
436 /* When we construct a partial symbol table entry we only
437 need this much information. */
438 struct partial_die_info
440 /* Offset of this DIE. */
443 /* DWARF-2 tag for this DIE. */
444 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
446 /* Assorted flags describing the data found in this DIE. */
447 unsigned int has_children
: 1;
448 unsigned int is_external
: 1;
449 unsigned int is_declaration
: 1;
450 unsigned int has_type
: 1;
451 unsigned int has_specification
: 1;
452 unsigned int has_pc_info
: 1;
454 /* Flag set if the SCOPE field of this structure has been
456 unsigned int scope_set
: 1;
458 /* Flag set if the DIE has a byte_size attribute. */
459 unsigned int has_byte_size
: 1;
461 /* The name of this DIE. Normally the value of DW_AT_name, but
462 sometimes a default name for unnamed DIEs. */
465 /* The scope to prepend to our children. This is generally
466 allocated on the comp_unit_obstack, so will disappear
467 when this compilation unit leaves the cache. */
470 /* The location description associated with this DIE, if any. */
471 struct dwarf_block
*locdesc
;
473 /* If HAS_PC_INFO, the PC range associated with this DIE. */
477 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
478 DW_AT_sibling, if any. */
481 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
482 DW_AT_specification (or DW_AT_abstract_origin or
484 unsigned int spec_offset
;
486 /* Pointers to this DIE's parent, first child, and next sibling,
488 struct partial_die_info
*die_parent
, *die_child
, *die_sibling
;
491 /* This data structure holds the information of an abbrev. */
494 unsigned int number
; /* number identifying abbrev */
495 enum dwarf_tag tag
; /* dwarf tag */
496 unsigned short has_children
; /* boolean */
497 unsigned short num_attrs
; /* number of attributes */
498 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
499 struct abbrev_info
*next
; /* next in chain */
504 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
505 ENUM_BITFIELD(dwarf_form
) form
: 16;
508 /* Attributes have a name and a value */
511 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
512 ENUM_BITFIELD(dwarf_form
) form
: 15;
514 /* Has DW_STRING already been updated by dwarf2_canonicalize_name? This
515 field should be in u.str (existing only for DW_STRING) but it is kept
516 here for better struct attribute alignment. */
517 unsigned int string_is_canonical
: 1;
522 struct dwarf_block
*blk
;
526 struct signatured_type
*signatured_type
;
531 /* This data structure holds a complete die structure. */
534 /* DWARF-2 tag for this DIE. */
535 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
537 /* Number of attributes */
538 unsigned short num_attrs
;
543 /* Offset in .debug_info or .debug_types section. */
546 /* The dies in a compilation unit form an n-ary tree. PARENT
547 points to this die's parent; CHILD points to the first child of
548 this node; and all the children of a given node are chained
549 together via their SIBLING fields, terminated by a die whose
551 struct die_info
*child
; /* Its first child, if any. */
552 struct die_info
*sibling
; /* Its next sibling, if any. */
553 struct die_info
*parent
; /* Its parent, if any. */
555 /* An array of attributes, with NUM_ATTRS elements. There may be
556 zero, but it's not common and zero-sized arrays are not
557 sufficiently portable C. */
558 struct attribute attrs
[1];
561 struct function_range
564 CORE_ADDR lowpc
, highpc
;
566 struct function_range
*next
;
569 /* Get at parts of an attribute structure */
571 #define DW_STRING(attr) ((attr)->u.str)
572 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
573 #define DW_UNSND(attr) ((attr)->u.unsnd)
574 #define DW_BLOCK(attr) ((attr)->u.blk)
575 #define DW_SND(attr) ((attr)->u.snd)
576 #define DW_ADDR(attr) ((attr)->u.addr)
577 #define DW_SIGNATURED_TYPE(attr) ((attr)->u.signatured_type)
579 /* Blocks are a bunch of untyped bytes. */
586 #ifndef ATTR_ALLOC_CHUNK
587 #define ATTR_ALLOC_CHUNK 4
590 /* Allocate fields for structs, unions and enums in this size. */
591 #ifndef DW_FIELD_ALLOC_CHUNK
592 #define DW_FIELD_ALLOC_CHUNK 4
595 /* A zeroed version of a partial die for initialization purposes. */
596 static struct partial_die_info zeroed_partial_die
;
598 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
599 but this would require a corresponding change in unpack_field_as_long
601 static int bits_per_byte
= 8;
603 /* The routines that read and process dies for a C struct or C++ class
604 pass lists of data member fields and lists of member function fields
605 in an instance of a field_info structure, as defined below. */
608 /* List of data member and baseclasses fields. */
611 struct nextfield
*next
;
616 *fields
, *baseclasses
;
618 /* Number of fields (including baseclasses). */
621 /* Number of baseclasses. */
624 /* Set if the accesibility of one of the fields is not public. */
625 int non_public_fields
;
627 /* Member function fields array, entries are allocated in the order they
628 are encountered in the object file. */
631 struct nextfnfield
*next
;
632 struct fn_field fnfield
;
636 /* Member function fieldlist array, contains name of possibly overloaded
637 member function, number of overloaded member functions and a pointer
638 to the head of the member function field chain. */
643 struct nextfnfield
*head
;
647 /* Number of entries in the fnfieldlists array. */
651 /* One item on the queue of compilation units to read in full symbols
653 struct dwarf2_queue_item
655 struct dwarf2_per_cu_data
*per_cu
;
656 struct dwarf2_queue_item
*next
;
659 /* The current queue. */
660 static struct dwarf2_queue_item
*dwarf2_queue
, *dwarf2_queue_tail
;
662 /* Loaded secondary compilation units are kept in memory until they
663 have not been referenced for the processing of this many
664 compilation units. Set this to zero to disable caching. Cache
665 sizes of up to at least twenty will improve startup time for
666 typical inter-CU-reference binaries, at an obvious memory cost. */
667 static int dwarf2_max_cache_age
= 5;
669 show_dwarf2_max_cache_age (struct ui_file
*file
, int from_tty
,
670 struct cmd_list_element
*c
, const char *value
)
672 fprintf_filtered (file
, _("\
673 The upper bound on the age of cached dwarf2 compilation units is %s.\n"),
678 /* Various complaints about symbol reading that don't abort the process */
681 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
683 complaint (&symfile_complaints
,
684 _("statement list doesn't fit in .debug_line section"));
688 dwarf2_debug_line_missing_file_complaint (void)
690 complaint (&symfile_complaints
,
691 _(".debug_line section has line data without a file"));
695 dwarf2_debug_line_missing_end_sequence_complaint (void)
697 complaint (&symfile_complaints
,
698 _(".debug_line section has line program sequence without an end"));
702 dwarf2_complex_location_expr_complaint (void)
704 complaint (&symfile_complaints
, _("location expression too complex"));
708 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
711 complaint (&symfile_complaints
,
712 _("const value length mismatch for '%s', got %d, expected %d"), arg1
,
717 dwarf2_macros_too_long_complaint (void)
719 complaint (&symfile_complaints
,
720 _("macro info runs off end of `.debug_macinfo' section"));
724 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
726 complaint (&symfile_complaints
,
727 _("macro debug info contains a malformed macro definition:\n`%s'"),
732 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
734 complaint (&symfile_complaints
,
735 _("invalid attribute class or form for '%s' in '%s'"), arg1
, arg2
);
738 /* local function prototypes */
740 static void dwarf2_locate_sections (bfd
*, asection
*, void *);
742 static void dwarf2_create_include_psymtab (char *, struct partial_symtab
*,
745 static void dwarf2_build_include_psymtabs (struct dwarf2_cu
*,
747 struct partial_symtab
*);
749 static void dwarf2_build_psymtabs_hard (struct objfile
*);
751 static void scan_partial_symbols (struct partial_die_info
*,
752 CORE_ADDR
*, CORE_ADDR
*,
753 int, struct dwarf2_cu
*);
755 static void add_partial_symbol (struct partial_die_info
*,
758 static void add_partial_namespace (struct partial_die_info
*pdi
,
759 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
760 int need_pc
, struct dwarf2_cu
*cu
);
762 static void add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
763 CORE_ADDR
*highpc
, int need_pc
,
764 struct dwarf2_cu
*cu
);
766 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
767 struct dwarf2_cu
*cu
);
769 static void add_partial_subprogram (struct partial_die_info
*pdi
,
770 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
771 int need_pc
, struct dwarf2_cu
*cu
);
773 static gdb_byte
*locate_pdi_sibling (struct partial_die_info
*orig_pdi
,
774 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
775 bfd
*abfd
, struct dwarf2_cu
*cu
);
777 static void dwarf2_psymtab_to_symtab (struct partial_symtab
*);
779 static void psymtab_to_symtab_1 (struct partial_symtab
*);
781 static void dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
);
783 static void dwarf2_free_abbrev_table (void *);
785 static struct abbrev_info
*peek_die_abbrev (gdb_byte
*, unsigned int *,
788 static struct abbrev_info
*dwarf2_lookup_abbrev (unsigned int,
791 static struct partial_die_info
*load_partial_dies (bfd
*,
792 gdb_byte
*, gdb_byte
*,
793 int, struct dwarf2_cu
*);
795 static gdb_byte
*read_partial_die (struct partial_die_info
*,
796 struct abbrev_info
*abbrev
,
798 gdb_byte
*, gdb_byte
*,
801 static struct partial_die_info
*find_partial_die (unsigned int,
804 static void fixup_partial_die (struct partial_die_info
*,
807 static gdb_byte
*read_attribute (struct attribute
*, struct attr_abbrev
*,
808 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
810 static gdb_byte
*read_attribute_value (struct attribute
*, unsigned,
811 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
813 static unsigned int read_1_byte (bfd
*, gdb_byte
*);
815 static int read_1_signed_byte (bfd
*, gdb_byte
*);
817 static unsigned int read_2_bytes (bfd
*, gdb_byte
*);
819 static unsigned int read_4_bytes (bfd
*, gdb_byte
*);
821 static ULONGEST
read_8_bytes (bfd
*, gdb_byte
*);
823 static CORE_ADDR
read_address (bfd
*, gdb_byte
*ptr
, struct dwarf2_cu
*,
826 static LONGEST
read_initial_length (bfd
*, gdb_byte
*, unsigned int *);
828 static LONGEST read_checked_initial_length_and_offset
829 (bfd
*, gdb_byte
*, const struct comp_unit_head
*,
830 unsigned int *, unsigned int *);
832 static LONGEST
read_offset (bfd
*, gdb_byte
*, const struct comp_unit_head
*,
835 static LONGEST
read_offset_1 (bfd
*, gdb_byte
*, unsigned int);
837 static gdb_byte
*read_n_bytes (bfd
*, gdb_byte
*, unsigned int);
839 static char *read_string (bfd
*, gdb_byte
*, unsigned int *);
841 static char *read_indirect_string (bfd
*, gdb_byte
*,
842 const struct comp_unit_head
*,
845 static unsigned long read_unsigned_leb128 (bfd
*, gdb_byte
*, unsigned int *);
847 static long read_signed_leb128 (bfd
*, gdb_byte
*, unsigned int *);
849 static gdb_byte
*skip_leb128 (bfd
*, gdb_byte
*);
851 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
853 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
856 static struct attribute
*dwarf2_attr_no_follow (struct die_info
*,
860 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
861 struct dwarf2_cu
*cu
);
863 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
865 static struct die_info
*die_specification (struct die_info
*die
,
866 struct dwarf2_cu
**);
868 static void free_line_header (struct line_header
*lh
);
870 static void add_file_name (struct line_header
*, char *, unsigned int,
871 unsigned int, unsigned int);
873 static struct line_header
*(dwarf_decode_line_header
874 (unsigned int offset
,
875 bfd
*abfd
, struct dwarf2_cu
*cu
));
877 static void dwarf_decode_lines (struct line_header
*, char *, bfd
*,
878 struct dwarf2_cu
*, struct partial_symtab
*);
880 static void dwarf2_start_subfile (char *, char *, char *);
882 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
885 static void dwarf2_const_value (struct attribute
*, struct symbol
*,
888 static void dwarf2_const_value_data (struct attribute
*attr
,
892 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
894 static int need_gnat_info (struct dwarf2_cu
*);
896 static struct type
*die_descriptive_type (struct die_info
*, struct dwarf2_cu
*);
898 static void set_descriptive_type (struct type
*, struct die_info
*,
901 static struct type
*die_containing_type (struct die_info
*,
904 static struct type
*tag_type_to_type (struct die_info
*, struct dwarf2_cu
*);
906 static struct type
*read_type_die (struct die_info
*, struct dwarf2_cu
*);
908 static char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
910 static char *typename_concat (struct obstack
*,
915 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
917 static void read_type_unit_scope (struct die_info
*, struct dwarf2_cu
*);
919 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
921 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
923 static int dwarf2_ranges_read (unsigned, CORE_ADDR
*, CORE_ADDR
*,
924 struct dwarf2_cu
*, struct partial_symtab
*);
926 static int dwarf2_get_pc_bounds (struct die_info
*,
927 CORE_ADDR
*, CORE_ADDR
*, struct dwarf2_cu
*,
928 struct partial_symtab
*);
930 static void get_scope_pc_bounds (struct die_info
*,
931 CORE_ADDR
*, CORE_ADDR
*,
934 static void dwarf2_record_block_ranges (struct die_info
*, struct block
*,
935 CORE_ADDR
, struct dwarf2_cu
*);
937 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
940 static void dwarf2_attach_fields_to_type (struct field_info
*,
941 struct type
*, struct dwarf2_cu
*);
943 static void dwarf2_add_member_fn (struct field_info
*,
944 struct die_info
*, struct type
*,
947 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
948 struct type
*, struct dwarf2_cu
*);
950 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
952 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
954 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
956 static void read_module (struct die_info
*die
, struct dwarf2_cu
*cu
);
958 static void read_import_statement (struct die_info
*die
, struct dwarf2_cu
*);
960 static const char *namespace_name (struct die_info
*die
,
961 int *is_anonymous
, struct dwarf2_cu
*);
963 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
965 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
967 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
970 static struct die_info
*read_comp_unit (gdb_byte
*, struct dwarf2_cu
*);
972 static struct die_info
*read_die_and_children_1 (const struct die_reader_specs
*reader
,
974 gdb_byte
**new_info_ptr
,
975 struct die_info
*parent
);
977 static struct die_info
*read_die_and_children (const struct die_reader_specs
*reader
,
979 gdb_byte
**new_info_ptr
,
980 struct die_info
*parent
);
982 static struct die_info
*read_die_and_siblings (const struct die_reader_specs
*reader
,
984 gdb_byte
**new_info_ptr
,
985 struct die_info
*parent
);
987 static gdb_byte
*read_full_die (const struct die_reader_specs
*reader
,
988 struct die_info
**, gdb_byte
*,
991 static void process_die (struct die_info
*, struct dwarf2_cu
*);
993 static char *dwarf2_canonicalize_name (char *, struct dwarf2_cu
*,
996 static char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
998 static struct die_info
*dwarf2_extension (struct die_info
*die
,
999 struct dwarf2_cu
**);
1001 static char *dwarf_tag_name (unsigned int);
1003 static char *dwarf_attr_name (unsigned int);
1005 static char *dwarf_form_name (unsigned int);
1007 static char *dwarf_stack_op_name (unsigned int);
1009 static char *dwarf_bool_name (unsigned int);
1011 static char *dwarf_type_encoding_name (unsigned int);
1014 static char *dwarf_cfi_name (unsigned int);
1017 static struct die_info
*sibling_die (struct die_info
*);
1019 static void dump_die_shallow (struct ui_file
*, int indent
, struct die_info
*);
1021 static void dump_die_for_error (struct die_info
*);
1023 static void dump_die_1 (struct ui_file
*, int level
, int max_level
,
1026 /*static*/ void dump_die (struct die_info
*, int max_level
);
1028 static void store_in_ref_table (struct die_info
*,
1029 struct dwarf2_cu
*);
1031 static int is_ref_attr (struct attribute
*);
1033 static unsigned int dwarf2_get_ref_die_offset (struct attribute
*);
1035 static LONGEST
dwarf2_get_attr_constant_value (struct attribute
*, int);
1037 static struct die_info
*follow_die_ref_or_sig (struct die_info
*,
1039 struct dwarf2_cu
**);
1041 static struct die_info
*follow_die_ref (struct die_info
*,
1043 struct dwarf2_cu
**);
1045 static struct die_info
*follow_die_sig (struct die_info
*,
1047 struct dwarf2_cu
**);
1049 static void read_signatured_type_at_offset (struct objfile
*objfile
,
1050 unsigned int offset
);
1052 static void read_signatured_type (struct objfile
*,
1053 struct signatured_type
*type_sig
);
1055 /* memory allocation interface */
1057 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1059 static struct abbrev_info
*dwarf_alloc_abbrev (struct dwarf2_cu
*);
1061 static struct die_info
*dwarf_alloc_die (struct dwarf2_cu
*, int);
1063 static void initialize_cu_func_list (struct dwarf2_cu
*);
1065 static void add_to_cu_func_list (const char *, CORE_ADDR
, CORE_ADDR
,
1066 struct dwarf2_cu
*);
1068 static void dwarf_decode_macros (struct line_header
*, unsigned int,
1069 char *, bfd
*, struct dwarf2_cu
*);
1071 static int attr_form_is_block (struct attribute
*);
1073 static int attr_form_is_section_offset (struct attribute
*);
1075 static int attr_form_is_constant (struct attribute
*);
1077 static void dwarf2_symbol_mark_computed (struct attribute
*attr
,
1079 struct dwarf2_cu
*cu
);
1081 static gdb_byte
*skip_one_die (gdb_byte
*buffer
, gdb_byte
*info_ptr
,
1082 struct abbrev_info
*abbrev
,
1083 struct dwarf2_cu
*cu
);
1085 static void free_stack_comp_unit (void *);
1087 static hashval_t
partial_die_hash (const void *item
);
1089 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1091 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1092 (unsigned int offset
, struct objfile
*objfile
);
1094 static struct dwarf2_per_cu_data
*dwarf2_find_comp_unit
1095 (unsigned int offset
, struct objfile
*objfile
);
1097 static struct dwarf2_cu
*alloc_one_comp_unit (struct objfile
*objfile
);
1099 static void free_one_comp_unit (void *);
1101 static void free_cached_comp_units (void *);
1103 static void age_cached_comp_units (void);
1105 static void free_one_cached_comp_unit (void *);
1107 static struct type
*set_die_type (struct die_info
*, struct type
*,
1108 struct dwarf2_cu
*);
1110 static void create_all_comp_units (struct objfile
*);
1112 static void load_full_comp_unit (struct dwarf2_per_cu_data
*,
1115 static void process_full_comp_unit (struct dwarf2_per_cu_data
*);
1117 static void dwarf2_add_dependence (struct dwarf2_cu
*,
1118 struct dwarf2_per_cu_data
*);
1120 static void dwarf2_mark (struct dwarf2_cu
*);
1122 static void dwarf2_clear_marks (struct dwarf2_per_cu_data
*);
1124 static struct type
*get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
1126 /* Try to locate the sections we need for DWARF 2 debugging
1127 information and return true if we have enough to do something. */
1130 dwarf2_has_info (struct objfile
*objfile
)
1132 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
1133 if (!dwarf2_per_objfile
)
1135 /* Initialize per-objfile state. */
1136 struct dwarf2_per_objfile
*data
1137 = obstack_alloc (&objfile
->objfile_obstack
, sizeof (*data
));
1138 memset (data
, 0, sizeof (*data
));
1139 set_objfile_data (objfile
, dwarf2_objfile_data_key
, data
);
1140 dwarf2_per_objfile
= data
;
1142 bfd_map_over_sections (objfile
->obfd
, dwarf2_locate_sections
, NULL
);
1143 dwarf2_per_objfile
->objfile
= objfile
;
1145 return (dwarf2_per_objfile
->info
.asection
!= NULL
1146 && dwarf2_per_objfile
->abbrev
.asection
!= NULL
);
1149 /* When loading sections, we can either look for ".<name>", or for
1150 * ".z<name>", which indicates a compressed section. */
1153 section_is_p (const char *section_name
, const char *name
)
1155 return (section_name
[0] == '.'
1156 && (strcmp (section_name
+ 1, name
) == 0
1157 || (section_name
[1] == 'z'
1158 && strcmp (section_name
+ 2, name
) == 0)));
1161 /* This function is mapped across the sections and remembers the
1162 offset and size of each of the debugging sections we are interested
1166 dwarf2_locate_sections (bfd
*abfd
, asection
*sectp
, void *ignore_ptr
)
1168 if (section_is_p (sectp
->name
, INFO_SECTION
))
1170 dwarf2_per_objfile
->info
.asection
= sectp
;
1171 dwarf2_per_objfile
->info
.size
= bfd_get_section_size (sectp
);
1173 else if (section_is_p (sectp
->name
, ABBREV_SECTION
))
1175 dwarf2_per_objfile
->abbrev
.asection
= sectp
;
1176 dwarf2_per_objfile
->abbrev
.size
= bfd_get_section_size (sectp
);
1178 else if (section_is_p (sectp
->name
, LINE_SECTION
))
1180 dwarf2_per_objfile
->line
.asection
= sectp
;
1181 dwarf2_per_objfile
->line
.size
= bfd_get_section_size (sectp
);
1183 else if (section_is_p (sectp
->name
, LOC_SECTION
))
1185 dwarf2_per_objfile
->loc
.asection
= sectp
;
1186 dwarf2_per_objfile
->loc
.size
= bfd_get_section_size (sectp
);
1188 else if (section_is_p (sectp
->name
, MACINFO_SECTION
))
1190 dwarf2_per_objfile
->macinfo
.asection
= sectp
;
1191 dwarf2_per_objfile
->macinfo
.size
= bfd_get_section_size (sectp
);
1193 else if (section_is_p (sectp
->name
, STR_SECTION
))
1195 dwarf2_per_objfile
->str
.asection
= sectp
;
1196 dwarf2_per_objfile
->str
.size
= bfd_get_section_size (sectp
);
1198 else if (section_is_p (sectp
->name
, FRAME_SECTION
))
1200 dwarf2_per_objfile
->frame
.asection
= sectp
;
1201 dwarf2_per_objfile
->frame
.size
= bfd_get_section_size (sectp
);
1203 else if (section_is_p (sectp
->name
, EH_FRAME_SECTION
))
1205 flagword aflag
= bfd_get_section_flags (ignore_abfd
, sectp
);
1206 if (aflag
& SEC_HAS_CONTENTS
)
1208 dwarf2_per_objfile
->eh_frame
.asection
= sectp
;
1209 dwarf2_per_objfile
->eh_frame
.size
= bfd_get_section_size (sectp
);
1212 else if (section_is_p (sectp
->name
, RANGES_SECTION
))
1214 dwarf2_per_objfile
->ranges
.asection
= sectp
;
1215 dwarf2_per_objfile
->ranges
.size
= bfd_get_section_size (sectp
);
1217 else if (section_is_p (sectp
->name
, TYPES_SECTION
))
1219 dwarf2_per_objfile
->types
.asection
= sectp
;
1220 dwarf2_per_objfile
->types
.size
= bfd_get_section_size (sectp
);
1223 if ((bfd_get_section_flags (abfd
, sectp
) & SEC_LOAD
)
1224 && bfd_section_vma (abfd
, sectp
) == 0)
1225 dwarf2_per_objfile
->has_section_at_zero
= 1;
1228 /* Decompress a section that was compressed using zlib. Store the
1229 decompressed buffer, and its size, in OUTBUF and OUTSIZE. */
1232 zlib_decompress_section (struct objfile
*objfile
, asection
*sectp
,
1233 gdb_byte
**outbuf
, bfd_size_type
*outsize
)
1235 bfd
*abfd
= objfile
->obfd
;
1237 error (_("Support for zlib-compressed DWARF data (from '%s') "
1238 "is disabled in this copy of GDB"),
1239 bfd_get_filename (abfd
));
1241 bfd_size_type compressed_size
= bfd_get_section_size (sectp
);
1242 gdb_byte
*compressed_buffer
= xmalloc (compressed_size
);
1243 struct cleanup
*cleanup
= make_cleanup (xfree
, compressed_buffer
);
1244 bfd_size_type uncompressed_size
;
1245 gdb_byte
*uncompressed_buffer
;
1248 int header_size
= 12;
1250 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
1251 || bfd_bread (compressed_buffer
, compressed_size
, abfd
) != compressed_size
)
1252 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
1253 bfd_get_filename (abfd
));
1255 /* Read the zlib header. In this case, it should be "ZLIB" followed
1256 by the uncompressed section size, 8 bytes in big-endian order. */
1257 if (compressed_size
< header_size
1258 || strncmp (compressed_buffer
, "ZLIB", 4) != 0)
1259 error (_("Dwarf Error: Corrupt DWARF ZLIB header from '%s'"),
1260 bfd_get_filename (abfd
));
1261 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
1262 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
1263 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
1264 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
1265 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
1266 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
1267 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
1268 uncompressed_size
+= compressed_buffer
[11];
1270 /* It is possible the section consists of several compressed
1271 buffers concatenated together, so we uncompress in a loop. */
1275 strm
.avail_in
= compressed_size
- header_size
;
1276 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
1277 strm
.avail_out
= uncompressed_size
;
1278 uncompressed_buffer
= obstack_alloc (&objfile
->objfile_obstack
,
1280 rc
= inflateInit (&strm
);
1281 while (strm
.avail_in
> 0)
1284 error (_("Dwarf Error: setting up DWARF uncompression in '%s': %d"),
1285 bfd_get_filename (abfd
), rc
);
1286 strm
.next_out
= ((Bytef
*) uncompressed_buffer
1287 + (uncompressed_size
- strm
.avail_out
));
1288 rc
= inflate (&strm
, Z_FINISH
);
1289 if (rc
!= Z_STREAM_END
)
1290 error (_("Dwarf Error: zlib error uncompressing from '%s': %d"),
1291 bfd_get_filename (abfd
), rc
);
1292 rc
= inflateReset (&strm
);
1294 rc
= inflateEnd (&strm
);
1296 || strm
.avail_out
!= 0)
1297 error (_("Dwarf Error: concluding DWARF uncompression in '%s': %d"),
1298 bfd_get_filename (abfd
), rc
);
1300 do_cleanups (cleanup
);
1301 *outbuf
= uncompressed_buffer
;
1302 *outsize
= uncompressed_size
;
1306 /* Read the contents of the section SECTP from object file specified by
1307 OBJFILE, store info about the section into INFO.
1308 If the section is compressed, uncompress it before returning. */
1311 dwarf2_read_section (struct objfile
*objfile
, struct dwarf2_section_info
*info
)
1313 bfd
*abfd
= objfile
->obfd
;
1314 asection
*sectp
= info
->asection
;
1315 gdb_byte
*buf
, *retbuf
;
1316 unsigned char header
[4];
1320 info
->buffer
= NULL
;
1321 info
->was_mmapped
= 0;
1324 if (info
->asection
== NULL
|| info
->size
== 0)
1327 /* Check if the file has a 4-byte header indicating compression. */
1328 if (info
->size
> sizeof (header
)
1329 && bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) == 0
1330 && bfd_bread (header
, sizeof (header
), abfd
) == sizeof (header
))
1332 /* Upon decompression, update the buffer and its size. */
1333 if (strncmp (header
, "ZLIB", sizeof (header
)) == 0)
1335 zlib_decompress_section (objfile
, sectp
, &info
->buffer
,
1343 pagesize
= getpagesize ();
1345 /* Only try to mmap sections which are large enough: we don't want to
1346 waste space due to fragmentation. Also, only try mmap for sections
1347 without relocations. */
1349 if (info
->size
> 4 * pagesize
&& (sectp
->flags
& SEC_RELOC
) == 0)
1351 off_t pg_offset
= sectp
->filepos
& ~(pagesize
- 1);
1352 size_t map_length
= info
->size
+ sectp
->filepos
- pg_offset
;
1353 caddr_t retbuf
= bfd_mmap (abfd
, 0, map_length
, PROT_READ
,
1354 MAP_PRIVATE
, pg_offset
);
1356 if (retbuf
!= MAP_FAILED
)
1358 info
->was_mmapped
= 1;
1359 info
->buffer
= retbuf
+ (sectp
->filepos
& (pagesize
- 1)) ;
1360 #if HAVE_POSIX_MADVISE
1361 posix_madvise (retbuf
, map_length
, POSIX_MADV_WILLNEED
);
1368 /* If we get here, we are a normal, not-compressed section. */
1370 = obstack_alloc (&objfile
->objfile_obstack
, info
->size
);
1372 /* When debugging .o files, we may need to apply relocations; see
1373 http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
1374 We never compress sections in .o files, so we only need to
1375 try this when the section is not compressed. */
1376 retbuf
= symfile_relocate_debug_section (objfile
, sectp
, buf
);
1379 info
->buffer
= retbuf
;
1383 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
1384 || bfd_bread (buf
, info
->size
, abfd
) != info
->size
)
1385 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
1386 bfd_get_filename (abfd
));
1389 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
1393 dwarf2_get_section_info (struct objfile
*objfile
, const char *section_name
,
1394 asection
**sectp
, gdb_byte
**bufp
,
1395 bfd_size_type
*sizep
)
1397 struct dwarf2_per_objfile
*data
1398 = objfile_data (objfile
, dwarf2_objfile_data_key
);
1399 struct dwarf2_section_info
*info
;
1401 /* We may see an objfile without any DWARF, in which case we just
1410 if (section_is_p (section_name
, EH_FRAME_SECTION
))
1411 info
= &data
->eh_frame
;
1412 else if (section_is_p (section_name
, FRAME_SECTION
))
1413 info
= &data
->frame
;
1417 if (info
->asection
!= NULL
&& info
->size
!= 0 && info
->buffer
== NULL
)
1418 /* We haven't read this section in yet. Do it now. */
1419 dwarf2_read_section (objfile
, info
);
1421 *sectp
= info
->asection
;
1422 *bufp
= info
->buffer
;
1423 *sizep
= info
->size
;
1426 /* Build a partial symbol table. */
1429 dwarf2_build_psymtabs (struct objfile
*objfile
)
1431 if (objfile
->global_psymbols
.size
== 0 && objfile
->static_psymbols
.size
== 0)
1433 init_psymbol_list (objfile
, 1024);
1436 dwarf2_build_psymtabs_hard (objfile
);
1439 /* Return TRUE if OFFSET is within CU_HEADER. */
1442 offset_in_cu_p (const struct comp_unit_head
*cu_header
, unsigned int offset
)
1444 unsigned int bottom
= cu_header
->offset
;
1445 unsigned int top
= (cu_header
->offset
1447 + cu_header
->initial_length_size
);
1448 return (offset
>= bottom
&& offset
< top
);
1451 /* Read in the comp unit header information from the debug_info at info_ptr.
1452 NOTE: This leaves members offset, first_die_offset to be filled in
1456 read_comp_unit_head (struct comp_unit_head
*cu_header
,
1457 gdb_byte
*info_ptr
, bfd
*abfd
)
1460 unsigned int bytes_read
;
1462 cu_header
->length
= read_initial_length (abfd
, info_ptr
, &bytes_read
);
1463 cu_header
->initial_length_size
= bytes_read
;
1464 cu_header
->offset_size
= (bytes_read
== 4) ? 4 : 8;
1465 info_ptr
+= bytes_read
;
1466 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
1468 cu_header
->abbrev_offset
= read_offset (abfd
, info_ptr
, cu_header
,
1470 info_ptr
+= bytes_read
;
1471 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
1473 signed_addr
= bfd_get_sign_extend_vma (abfd
);
1474 if (signed_addr
< 0)
1475 internal_error (__FILE__
, __LINE__
,
1476 _("read_comp_unit_head: dwarf from non elf file"));
1477 cu_header
->signed_addr_p
= signed_addr
;
1483 partial_read_comp_unit_head (struct comp_unit_head
*header
, gdb_byte
*info_ptr
,
1484 gdb_byte
*buffer
, unsigned int buffer_size
,
1487 gdb_byte
*beg_of_comp_unit
= info_ptr
;
1489 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
1491 if (header
->version
!= 2 && header
->version
!= 3)
1492 error (_("Dwarf Error: wrong version in compilation unit header "
1493 "(is %d, should be %d) [in module %s]"), header
->version
,
1494 2, bfd_get_filename (abfd
));
1496 if (header
->abbrev_offset
>= dwarf2_per_objfile
->abbrev
.size
)
1497 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
1498 "(offset 0x%lx + 6) [in module %s]"),
1499 (long) header
->abbrev_offset
,
1500 (long) (beg_of_comp_unit
- buffer
),
1501 bfd_get_filename (abfd
));
1503 if (beg_of_comp_unit
+ header
->length
+ header
->initial_length_size
1504 > buffer
+ buffer_size
)
1505 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
1506 "(offset 0x%lx + 0) [in module %s]"),
1507 (long) header
->length
,
1508 (long) (beg_of_comp_unit
- buffer
),
1509 bfd_get_filename (abfd
));
1514 /* Read in the types comp unit header information from .debug_types entry at
1515 types_ptr. The result is a pointer to one past the end of the header. */
1518 read_type_comp_unit_head (struct comp_unit_head
*cu_header
,
1519 ULONGEST
*signature
,
1520 gdb_byte
*types_ptr
, bfd
*abfd
)
1522 unsigned int bytes_read
;
1523 gdb_byte
*initial_types_ptr
= types_ptr
;
1525 dwarf2_read_section (dwarf2_per_objfile
->objfile
, &dwarf2_per_objfile
->types
);
1526 cu_header
->offset
= types_ptr
- dwarf2_per_objfile
->types
.buffer
;
1528 types_ptr
= read_comp_unit_head (cu_header
, types_ptr
, abfd
);
1530 *signature
= read_8_bytes (abfd
, types_ptr
);
1532 types_ptr
+= cu_header
->offset_size
;
1533 cu_header
->first_die_offset
= types_ptr
- initial_types_ptr
;
1538 /* Allocate a new partial symtab for file named NAME and mark this new
1539 partial symtab as being an include of PST. */
1542 dwarf2_create_include_psymtab (char *name
, struct partial_symtab
*pst
,
1543 struct objfile
*objfile
)
1545 struct partial_symtab
*subpst
= allocate_psymtab (name
, objfile
);
1547 subpst
->section_offsets
= pst
->section_offsets
;
1548 subpst
->textlow
= 0;
1549 subpst
->texthigh
= 0;
1551 subpst
->dependencies
= (struct partial_symtab
**)
1552 obstack_alloc (&objfile
->objfile_obstack
,
1553 sizeof (struct partial_symtab
*));
1554 subpst
->dependencies
[0] = pst
;
1555 subpst
->number_of_dependencies
= 1;
1557 subpst
->globals_offset
= 0;
1558 subpst
->n_global_syms
= 0;
1559 subpst
->statics_offset
= 0;
1560 subpst
->n_static_syms
= 0;
1561 subpst
->symtab
= NULL
;
1562 subpst
->read_symtab
= pst
->read_symtab
;
1565 /* No private part is necessary for include psymtabs. This property
1566 can be used to differentiate between such include psymtabs and
1567 the regular ones. */
1568 subpst
->read_symtab_private
= NULL
;
1571 /* Read the Line Number Program data and extract the list of files
1572 included by the source file represented by PST. Build an include
1573 partial symtab for each of these included files. */
1576 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
1577 struct die_info
*die
,
1578 struct partial_symtab
*pst
)
1580 struct objfile
*objfile
= cu
->objfile
;
1581 bfd
*abfd
= objfile
->obfd
;
1582 struct line_header
*lh
= NULL
;
1583 struct attribute
*attr
;
1585 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
1588 unsigned int line_offset
= DW_UNSND (attr
);
1589 lh
= dwarf_decode_line_header (line_offset
, abfd
, cu
);
1592 return; /* No linetable, so no includes. */
1594 dwarf_decode_lines (lh
, NULL
, abfd
, cu
, pst
);
1596 free_line_header (lh
);
1600 hash_type_signature (const void *item
)
1602 const struct signatured_type
*type_sig
= item
;
1603 /* This drops the top 32 bits of the signature, but is ok for a hash. */
1604 return type_sig
->signature
;
1608 eq_type_signature (const void *item_lhs
, const void *item_rhs
)
1610 const struct signatured_type
*lhs
= item_lhs
;
1611 const struct signatured_type
*rhs
= item_rhs
;
1612 return lhs
->signature
== rhs
->signature
;
1615 /* Create the hash table of all entries in the .debug_types section.
1616 The result is zero if there is an error (e.g. missing .debug_types section),
1617 otherwise non-zero. */
1620 create_debug_types_hash_table (struct objfile
*objfile
)
1625 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->types
);
1626 info_ptr
= dwarf2_per_objfile
->types
.buffer
;
1628 if (info_ptr
== NULL
)
1630 dwarf2_per_objfile
->signatured_types
= NULL
;
1634 types_htab
= htab_create_alloc_ex (41,
1635 hash_type_signature
,
1638 &objfile
->objfile_obstack
,
1639 hashtab_obstack_allocate
,
1640 dummy_obstack_deallocate
);
1642 if (dwarf2_die_debug
)
1643 fprintf_unfiltered (gdb_stdlog
, "Signatured types:\n");
1645 while (info_ptr
< dwarf2_per_objfile
->types
.buffer
+ dwarf2_per_objfile
->types
.size
)
1647 unsigned int offset
;
1648 unsigned int offset_size
;
1649 unsigned int type_offset
;
1650 unsigned int length
, initial_length_size
;
1651 unsigned short version
;
1653 struct signatured_type
*type_sig
;
1655 gdb_byte
*ptr
= info_ptr
;
1657 offset
= ptr
- dwarf2_per_objfile
->types
.buffer
;
1659 /* We need to read the type's signature in order to build the hash
1660 table, but we don't need to read anything else just yet. */
1662 /* Sanity check to ensure entire cu is present. */
1663 length
= read_initial_length (objfile
->obfd
, ptr
, &initial_length_size
);
1664 if (ptr
+ length
+ initial_length_size
1665 > dwarf2_per_objfile
->types
.buffer
+ dwarf2_per_objfile
->types
.size
)
1667 complaint (&symfile_complaints
,
1668 _("debug type entry runs off end of `.debug_types' section, ignored"));
1672 offset_size
= initial_length_size
== 4 ? 4 : 8;
1673 ptr
+= initial_length_size
;
1674 version
= bfd_get_16 (objfile
->obfd
, ptr
);
1676 ptr
+= offset_size
; /* abbrev offset */
1677 ptr
+= 1; /* address size */
1678 signature
= bfd_get_64 (objfile
->obfd
, ptr
);
1680 type_offset
= read_offset_1 (objfile
->obfd
, ptr
, offset_size
);
1682 type_sig
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*type_sig
));
1683 memset (type_sig
, 0, sizeof (*type_sig
));
1684 type_sig
->signature
= signature
;
1685 type_sig
->offset
= offset
;
1686 type_sig
->type_offset
= type_offset
;
1688 slot
= htab_find_slot (types_htab
, type_sig
, INSERT
);
1689 gdb_assert (slot
!= NULL
);
1692 if (dwarf2_die_debug
)
1693 fprintf_unfiltered (gdb_stdlog
, " offset 0x%x, signature 0x%s\n",
1694 offset
, phex (signature
, sizeof (signature
)));
1696 info_ptr
= info_ptr
+ initial_length_size
+ length
;
1699 dwarf2_per_objfile
->signatured_types
= types_htab
;
1704 /* Lookup a signature based type.
1705 Returns NULL if SIG is not present in the table. */
1707 static struct signatured_type
*
1708 lookup_signatured_type (struct objfile
*objfile
, ULONGEST sig
)
1710 struct signatured_type find_entry
, *entry
;
1712 if (dwarf2_per_objfile
->signatured_types
== NULL
)
1714 complaint (&symfile_complaints
,
1715 _("missing `.debug_types' section for DW_FORM_sig8 die"));
1719 find_entry
.signature
= sig
;
1720 entry
= htab_find (dwarf2_per_objfile
->signatured_types
, &find_entry
);
1724 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
1727 init_cu_die_reader (struct die_reader_specs
*reader
,
1728 struct dwarf2_cu
*cu
)
1730 reader
->abfd
= cu
->objfile
->obfd
;
1732 if (cu
->per_cu
->from_debug_types
)
1734 gdb_assert (dwarf2_per_objfile
->types
.readin
);
1735 reader
->buffer
= dwarf2_per_objfile
->types
.buffer
;
1739 gdb_assert (dwarf2_per_objfile
->info
.readin
);
1740 reader
->buffer
= dwarf2_per_objfile
->info
.buffer
;
1744 /* Find the base address of the compilation unit for range lists and
1745 location lists. It will normally be specified by DW_AT_low_pc.
1746 In DWARF-3 draft 4, the base address could be overridden by
1747 DW_AT_entry_pc. It's been removed, but GCC still uses this for
1748 compilation units with discontinuous ranges. */
1751 dwarf2_find_base_address (struct die_info
*die
, struct dwarf2_cu
*cu
)
1753 struct attribute
*attr
;
1756 cu
->base_address
= 0;
1758 attr
= dwarf2_attr (die
, DW_AT_entry_pc
, cu
);
1761 cu
->base_address
= DW_ADDR (attr
);
1766 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
1769 cu
->base_address
= DW_ADDR (attr
);
1775 /* Subroutine of process_type_comp_unit and dwarf2_build_psymtabs_hard
1776 to combine the common parts.
1777 Process a compilation unit for a psymtab.
1778 BUFFER is a pointer to the beginning of the dwarf section buffer,
1779 either .debug_info or debug_types.
1780 INFO_PTR is a pointer to the start of the CU.
1781 Returns a pointer to the next CU. */
1784 process_psymtab_comp_unit (struct objfile
*objfile
,
1785 struct dwarf2_per_cu_data
*this_cu
,
1786 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
1787 unsigned int buffer_size
)
1789 bfd
*abfd
= objfile
->obfd
;
1790 gdb_byte
*beg_of_comp_unit
= info_ptr
;
1791 struct die_info
*comp_unit_die
;
1792 struct partial_symtab
*pst
;
1794 struct cleanup
*back_to_inner
;
1795 struct dwarf2_cu cu
;
1796 unsigned int bytes_read
;
1797 int has_children
, has_pc_info
;
1798 struct attribute
*attr
;
1800 CORE_ADDR best_lowpc
= 0, best_highpc
= 0;
1801 struct die_reader_specs reader_specs
;
1803 memset (&cu
, 0, sizeof (cu
));
1804 cu
.objfile
= objfile
;
1805 obstack_init (&cu
.comp_unit_obstack
);
1807 back_to_inner
= make_cleanup (free_stack_comp_unit
, &cu
);
1809 info_ptr
= partial_read_comp_unit_head (&cu
.header
, info_ptr
,
1810 buffer
, buffer_size
,
1813 /* Complete the cu_header. */
1814 cu
.header
.offset
= beg_of_comp_unit
- buffer
;
1815 cu
.header
.first_die_offset
= info_ptr
- beg_of_comp_unit
;
1817 cu
.list_in_scope
= &file_symbols
;
1819 /* If this compilation unit was already read in, free the
1820 cached copy in order to read it in again. This is
1821 necessary because we skipped some symbols when we first
1822 read in the compilation unit (see load_partial_dies).
1823 This problem could be avoided, but the benefit is
1825 if (this_cu
->cu
!= NULL
)
1826 free_one_cached_comp_unit (this_cu
->cu
);
1828 /* Note that this is a pointer to our stack frame, being
1829 added to a global data structure. It will be cleaned up
1830 in free_stack_comp_unit when we finish with this
1831 compilation unit. */
1833 cu
.per_cu
= this_cu
;
1835 /* Read the abbrevs for this compilation unit into a table. */
1836 dwarf2_read_abbrevs (abfd
, &cu
);
1837 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
1839 /* Read the compilation unit die. */
1840 if (this_cu
->from_debug_types
)
1841 info_ptr
+= 8 /*signature*/ + cu
.header
.offset_size
;
1842 init_cu_die_reader (&reader_specs
, &cu
);
1843 info_ptr
= read_full_die (&reader_specs
, &comp_unit_die
, info_ptr
,
1846 if (this_cu
->from_debug_types
)
1848 /* offset,length haven't been set yet for type units. */
1849 this_cu
->offset
= cu
.header
.offset
;
1850 this_cu
->length
= cu
.header
.length
+ cu
.header
.initial_length_size
;
1852 else if (comp_unit_die
->tag
== DW_TAG_partial_unit
)
1854 info_ptr
= (beg_of_comp_unit
+ cu
.header
.length
1855 + cu
.header
.initial_length_size
);
1856 do_cleanups (back_to_inner
);
1860 /* Set the language we're debugging. */
1861 attr
= dwarf2_attr (comp_unit_die
, DW_AT_language
, &cu
);
1863 set_cu_language (DW_UNSND (attr
), &cu
);
1865 set_cu_language (language_minimal
, &cu
);
1867 /* Allocate a new partial symbol table structure. */
1868 attr
= dwarf2_attr (comp_unit_die
, DW_AT_name
, &cu
);
1869 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
1870 (attr
!= NULL
) ? DW_STRING (attr
) : "",
1871 /* TEXTLOW and TEXTHIGH are set below. */
1873 objfile
->global_psymbols
.next
,
1874 objfile
->static_psymbols
.next
);
1876 attr
= dwarf2_attr (comp_unit_die
, DW_AT_comp_dir
, &cu
);
1878 pst
->dirname
= DW_STRING (attr
);
1880 pst
->read_symtab_private
= this_cu
;
1882 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1884 /* Store the function that reads in the rest of the symbol table */
1885 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
1887 this_cu
->psymtab
= pst
;
1889 dwarf2_find_base_address (comp_unit_die
, &cu
);
1891 /* Possibly set the default values of LOWPC and HIGHPC from
1893 has_pc_info
= dwarf2_get_pc_bounds (comp_unit_die
, &best_lowpc
,
1894 &best_highpc
, &cu
, pst
);
1895 if (has_pc_info
== 1 && best_lowpc
< best_highpc
)
1896 /* Store the contiguous range if it is not empty; it can be empty for
1897 CUs with no code. */
1898 addrmap_set_empty (objfile
->psymtabs_addrmap
,
1899 best_lowpc
+ baseaddr
,
1900 best_highpc
+ baseaddr
- 1, pst
);
1902 /* Check if comp unit has_children.
1903 If so, read the rest of the partial symbols from this comp unit.
1904 If not, there's no more debug_info for this comp unit. */
1907 struct partial_die_info
*first_die
;
1908 CORE_ADDR lowpc
, highpc
;
1910 lowpc
= ((CORE_ADDR
) -1);
1911 highpc
= ((CORE_ADDR
) 0);
1913 first_die
= load_partial_dies (abfd
, buffer
, info_ptr
, 1, &cu
);
1915 scan_partial_symbols (first_die
, &lowpc
, &highpc
,
1916 ! has_pc_info
, &cu
);
1918 /* If we didn't find a lowpc, set it to highpc to avoid
1919 complaints from `maint check'. */
1920 if (lowpc
== ((CORE_ADDR
) -1))
1923 /* If the compilation unit didn't have an explicit address range,
1924 then use the information extracted from its child dies. */
1928 best_highpc
= highpc
;
1931 pst
->textlow
= best_lowpc
+ baseaddr
;
1932 pst
->texthigh
= best_highpc
+ baseaddr
;
1934 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
1935 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1936 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
1937 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1938 sort_pst_symbols (pst
);
1940 info_ptr
= (beg_of_comp_unit
+ cu
.header
.length
1941 + cu
.header
.initial_length_size
);
1943 if (this_cu
->from_debug_types
)
1945 /* It's not clear we want to do anything with stmt lists here.
1946 Waiting to see what gcc ultimately does. */
1950 /* Get the list of files included in the current compilation unit,
1951 and build a psymtab for each of them. */
1952 dwarf2_build_include_psymtabs (&cu
, comp_unit_die
, pst
);
1955 do_cleanups (back_to_inner
);
1960 /* Traversal function for htab_traverse_noresize.
1961 Process one .debug_types comp-unit. */
1964 process_type_comp_unit (void **slot
, void *info
)
1966 struct signatured_type
*entry
= (struct signatured_type
*) *slot
;
1967 struct objfile
*objfile
= (struct objfile
*) info
;
1968 struct dwarf2_per_cu_data
*this_cu
;
1970 this_cu
= &entry
->per_cu
;
1971 this_cu
->from_debug_types
= 1;
1973 gdb_assert (dwarf2_per_objfile
->types
.readin
);
1974 process_psymtab_comp_unit (objfile
, this_cu
,
1975 dwarf2_per_objfile
->types
.buffer
,
1976 dwarf2_per_objfile
->types
.buffer
+ entry
->offset
,
1977 dwarf2_per_objfile
->types
.size
);
1982 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
1983 Build partial symbol tables for the .debug_types comp-units. */
1986 build_type_psymtabs (struct objfile
*objfile
)
1988 if (! create_debug_types_hash_table (objfile
))
1991 htab_traverse_noresize (dwarf2_per_objfile
->signatured_types
,
1992 process_type_comp_unit
, objfile
);
1995 /* Build the partial symbol table by doing a quick pass through the
1996 .debug_info and .debug_abbrev sections. */
1999 dwarf2_build_psymtabs_hard (struct objfile
*objfile
)
2001 bfd
*abfd
= objfile
->obfd
;
2003 struct cleanup
*back_to
;
2005 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
2006 info_ptr
= dwarf2_per_objfile
->info
.buffer
;
2008 /* Any cached compilation units will be linked by the per-objfile
2009 read_in_chain. Make sure to free them when we're done. */
2010 back_to
= make_cleanup (free_cached_comp_units
, NULL
);
2012 build_type_psymtabs (objfile
);
2014 create_all_comp_units (objfile
);
2016 objfile
->psymtabs_addrmap
=
2017 addrmap_create_mutable (&objfile
->objfile_obstack
);
2019 /* Since the objects we're extracting from .debug_info vary in
2020 length, only the individual functions to extract them (like
2021 read_comp_unit_head and load_partial_die) can really know whether
2022 the buffer is large enough to hold another complete object.
2024 At the moment, they don't actually check that. If .debug_info
2025 holds just one extra byte after the last compilation unit's dies,
2026 then read_comp_unit_head will happily read off the end of the
2027 buffer. read_partial_die is similarly casual. Those functions
2030 For this loop condition, simply checking whether there's any data
2031 left at all should be sufficient. */
2033 while (info_ptr
< (dwarf2_per_objfile
->info
.buffer
2034 + dwarf2_per_objfile
->info
.size
))
2036 struct dwarf2_per_cu_data
*this_cu
;
2038 this_cu
= dwarf2_find_comp_unit (info_ptr
- dwarf2_per_objfile
->info
.buffer
,
2041 info_ptr
= process_psymtab_comp_unit (objfile
, this_cu
,
2042 dwarf2_per_objfile
->info
.buffer
,
2044 dwarf2_per_objfile
->info
.size
);
2047 objfile
->psymtabs_addrmap
= addrmap_create_fixed (objfile
->psymtabs_addrmap
,
2048 &objfile
->objfile_obstack
);
2050 do_cleanups (back_to
);
2053 /* Load the partial DIEs for a secondary CU into memory. */
2056 load_partial_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
2057 struct objfile
*objfile
)
2059 bfd
*abfd
= objfile
->obfd
;
2060 gdb_byte
*info_ptr
, *beg_of_comp_unit
;
2061 struct die_info
*comp_unit_die
;
2062 struct dwarf2_cu
*cu
;
2063 unsigned int bytes_read
;
2064 struct cleanup
*back_to
;
2065 struct attribute
*attr
;
2067 struct die_reader_specs reader_specs
;
2069 gdb_assert (! this_cu
->from_debug_types
);
2071 gdb_assert (dwarf2_per_objfile
->info
.readin
);
2072 info_ptr
= dwarf2_per_objfile
->info
.buffer
+ this_cu
->offset
;
2073 beg_of_comp_unit
= info_ptr
;
2075 cu
= alloc_one_comp_unit (objfile
);
2077 /* ??? Missing cleanup for CU? */
2079 /* Link this compilation unit into the compilation unit tree. */
2081 cu
->per_cu
= this_cu
;
2082 cu
->type_hash
= this_cu
->type_hash
;
2084 info_ptr
= partial_read_comp_unit_head (&cu
->header
, info_ptr
,
2085 dwarf2_per_objfile
->info
.buffer
,
2086 dwarf2_per_objfile
->info
.size
,
2089 /* Complete the cu_header. */
2090 cu
->header
.offset
= this_cu
->offset
;
2091 cu
->header
.first_die_offset
= info_ptr
- beg_of_comp_unit
;
2093 /* Read the abbrevs for this compilation unit into a table. */
2094 dwarf2_read_abbrevs (abfd
, cu
);
2095 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
2097 /* Read the compilation unit die. */
2098 init_cu_die_reader (&reader_specs
, cu
);
2099 info_ptr
= read_full_die (&reader_specs
, &comp_unit_die
, info_ptr
,
2102 /* Set the language we're debugging. */
2103 attr
= dwarf2_attr (comp_unit_die
, DW_AT_language
, cu
);
2105 set_cu_language (DW_UNSND (attr
), cu
);
2107 set_cu_language (language_minimal
, cu
);
2109 /* Check if comp unit has_children.
2110 If so, read the rest of the partial symbols from this comp unit.
2111 If not, there's no more debug_info for this comp unit. */
2113 load_partial_dies (abfd
, dwarf2_per_objfile
->info
.buffer
, info_ptr
, 0, cu
);
2115 do_cleanups (back_to
);
2118 /* Create a list of all compilation units in OBJFILE. We do this only
2119 if an inter-comp-unit reference is found; presumably if there is one,
2120 there will be many, and one will occur early in the .debug_info section.
2121 So there's no point in building this list incrementally. */
2124 create_all_comp_units (struct objfile
*objfile
)
2128 struct dwarf2_per_cu_data
**all_comp_units
;
2131 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
2132 info_ptr
= dwarf2_per_objfile
->info
.buffer
;
2136 all_comp_units
= xmalloc (n_allocated
2137 * sizeof (struct dwarf2_per_cu_data
*));
2139 while (info_ptr
< dwarf2_per_objfile
->info
.buffer
+ dwarf2_per_objfile
->info
.size
)
2141 unsigned int length
, initial_length_size
;
2142 gdb_byte
*beg_of_comp_unit
;
2143 struct dwarf2_per_cu_data
*this_cu
;
2144 unsigned int offset
;
2146 offset
= info_ptr
- dwarf2_per_objfile
->info
.buffer
;
2148 /* Read just enough information to find out where the next
2149 compilation unit is. */
2150 length
= read_initial_length (objfile
->obfd
, info_ptr
,
2151 &initial_length_size
);
2153 /* Save the compilation unit for later lookup. */
2154 this_cu
= obstack_alloc (&objfile
->objfile_obstack
,
2155 sizeof (struct dwarf2_per_cu_data
));
2156 memset (this_cu
, 0, sizeof (*this_cu
));
2157 this_cu
->offset
= offset
;
2158 this_cu
->length
= length
+ initial_length_size
;
2160 if (n_comp_units
== n_allocated
)
2163 all_comp_units
= xrealloc (all_comp_units
,
2165 * sizeof (struct dwarf2_per_cu_data
*));
2167 all_comp_units
[n_comp_units
++] = this_cu
;
2169 info_ptr
= info_ptr
+ this_cu
->length
;
2172 dwarf2_per_objfile
->all_comp_units
2173 = obstack_alloc (&objfile
->objfile_obstack
,
2174 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
2175 memcpy (dwarf2_per_objfile
->all_comp_units
, all_comp_units
,
2176 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
2177 xfree (all_comp_units
);
2178 dwarf2_per_objfile
->n_comp_units
= n_comp_units
;
2181 /* Process all loaded DIEs for compilation unit CU, starting at
2182 FIRST_DIE. The caller should pass NEED_PC == 1 if the compilation
2183 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
2184 DW_AT_ranges). If NEED_PC is set, then this function will set
2185 *LOWPC and *HIGHPC to the lowest and highest PC values found in CU
2186 and record the covered ranges in the addrmap. */
2189 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
2190 CORE_ADDR
*highpc
, int need_pc
, struct dwarf2_cu
*cu
)
2192 struct objfile
*objfile
= cu
->objfile
;
2193 bfd
*abfd
= objfile
->obfd
;
2194 struct partial_die_info
*pdi
;
2196 /* Now, march along the PDI's, descending into ones which have
2197 interesting children but skipping the children of the other ones,
2198 until we reach the end of the compilation unit. */
2204 fixup_partial_die (pdi
, cu
);
2206 /* Anonymous namespaces have no name but have interesting
2207 children, so we need to look at them. Ditto for anonymous
2210 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
2211 || pdi
->tag
== DW_TAG_enumeration_type
)
2215 case DW_TAG_subprogram
:
2216 add_partial_subprogram (pdi
, lowpc
, highpc
, need_pc
, cu
);
2218 case DW_TAG_variable
:
2219 case DW_TAG_typedef
:
2220 case DW_TAG_union_type
:
2221 if (!pdi
->is_declaration
)
2223 add_partial_symbol (pdi
, cu
);
2226 case DW_TAG_class_type
:
2227 case DW_TAG_interface_type
:
2228 case DW_TAG_structure_type
:
2229 if (!pdi
->is_declaration
)
2231 add_partial_symbol (pdi
, cu
);
2234 case DW_TAG_enumeration_type
:
2235 if (!pdi
->is_declaration
)
2236 add_partial_enumeration (pdi
, cu
);
2238 case DW_TAG_base_type
:
2239 case DW_TAG_subrange_type
:
2240 /* File scope base type definitions are added to the partial
2242 add_partial_symbol (pdi
, cu
);
2244 case DW_TAG_namespace
:
2245 add_partial_namespace (pdi
, lowpc
, highpc
, need_pc
, cu
);
2248 add_partial_module (pdi
, lowpc
, highpc
, need_pc
, cu
);
2255 /* If the die has a sibling, skip to the sibling. */
2257 pdi
= pdi
->die_sibling
;
2261 /* Functions used to compute the fully scoped name of a partial DIE.
2263 Normally, this is simple. For C++, the parent DIE's fully scoped
2264 name is concatenated with "::" and the partial DIE's name. For
2265 Java, the same thing occurs except that "." is used instead of "::".
2266 Enumerators are an exception; they use the scope of their parent
2267 enumeration type, i.e. the name of the enumeration type is not
2268 prepended to the enumerator.
2270 There are two complexities. One is DW_AT_specification; in this
2271 case "parent" means the parent of the target of the specification,
2272 instead of the direct parent of the DIE. The other is compilers
2273 which do not emit DW_TAG_namespace; in this case we try to guess
2274 the fully qualified name of structure types from their members'
2275 linkage names. This must be done using the DIE's children rather
2276 than the children of any DW_AT_specification target. We only need
2277 to do this for structures at the top level, i.e. if the target of
2278 any DW_AT_specification (if any; otherwise the DIE itself) does not
2281 /* Compute the scope prefix associated with PDI's parent, in
2282 compilation unit CU. The result will be allocated on CU's
2283 comp_unit_obstack, or a copy of the already allocated PDI->NAME
2284 field. NULL is returned if no prefix is necessary. */
2286 partial_die_parent_scope (struct partial_die_info
*pdi
,
2287 struct dwarf2_cu
*cu
)
2289 char *grandparent_scope
;
2290 struct partial_die_info
*parent
, *real_pdi
;
2292 /* We need to look at our parent DIE; if we have a DW_AT_specification,
2293 then this means the parent of the specification DIE. */
2296 while (real_pdi
->has_specification
)
2297 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
2299 parent
= real_pdi
->die_parent
;
2303 if (parent
->scope_set
)
2304 return parent
->scope
;
2306 fixup_partial_die (parent
, cu
);
2308 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
2310 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
2311 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
2312 Work around this problem here. */
2313 if (cu
->language
== language_cplus
2314 && parent
->tag
== DW_TAG_namespace
2315 && strcmp (parent
->name
, "::") == 0
2316 && grandparent_scope
== NULL
)
2318 parent
->scope
= NULL
;
2319 parent
->scope_set
= 1;
2323 if (parent
->tag
== DW_TAG_namespace
2324 || parent
->tag
== DW_TAG_structure_type
2325 || parent
->tag
== DW_TAG_class_type
2326 || parent
->tag
== DW_TAG_interface_type
2327 || parent
->tag
== DW_TAG_union_type
2328 || parent
->tag
== DW_TAG_enumeration_type
)
2330 if (grandparent_scope
== NULL
)
2331 parent
->scope
= parent
->name
;
2333 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
, grandparent_scope
,
2336 else if (parent
->tag
== DW_TAG_enumerator
)
2337 /* Enumerators should not get the name of the enumeration as a prefix. */
2338 parent
->scope
= grandparent_scope
;
2341 /* FIXME drow/2004-04-01: What should we be doing with
2342 function-local names? For partial symbols, we should probably be
2344 complaint (&symfile_complaints
,
2345 _("unhandled containing DIE tag %d for DIE at %d"),
2346 parent
->tag
, pdi
->offset
);
2347 parent
->scope
= grandparent_scope
;
2350 parent
->scope_set
= 1;
2351 return parent
->scope
;
2354 /* Return the fully scoped name associated with PDI, from compilation unit
2355 CU. The result will be allocated with malloc. */
2357 partial_die_full_name (struct partial_die_info
*pdi
,
2358 struct dwarf2_cu
*cu
)
2362 parent_scope
= partial_die_parent_scope (pdi
, cu
);
2363 if (parent_scope
== NULL
)
2366 return typename_concat (NULL
, parent_scope
, pdi
->name
, cu
);
2370 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
2372 struct objfile
*objfile
= cu
->objfile
;
2374 char *actual_name
= NULL
;
2375 const char *my_prefix
;
2376 const struct partial_symbol
*psym
= NULL
;
2378 int built_actual_name
= 0;
2380 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2382 actual_name
= partial_die_full_name (pdi
, cu
);
2384 built_actual_name
= 1;
2386 if (actual_name
== NULL
)
2387 actual_name
= pdi
->name
;
2391 case DW_TAG_subprogram
:
2392 if (pdi
->is_external
|| cu
->language
== language_ada
)
2394 /* brobecker/2007-12-26: Normally, only "external" DIEs are part
2395 of the global scope. But in Ada, we want to be able to access
2396 nested procedures globally. So all Ada subprograms are stored
2397 in the global scope. */
2398 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
2399 mst_text, objfile); */
2400 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
2402 VAR_DOMAIN
, LOC_BLOCK
,
2403 &objfile
->global_psymbols
,
2404 0, pdi
->lowpc
+ baseaddr
,
2405 cu
->language
, objfile
);
2409 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
2410 mst_file_text, objfile); */
2411 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
2413 VAR_DOMAIN
, LOC_BLOCK
,
2414 &objfile
->static_psymbols
,
2415 0, pdi
->lowpc
+ baseaddr
,
2416 cu
->language
, objfile
);
2419 case DW_TAG_variable
:
2420 if (pdi
->is_external
)
2423 Don't enter into the minimal symbol tables as there is
2424 a minimal symbol table entry from the ELF symbols already.
2425 Enter into partial symbol table if it has a location
2426 descriptor or a type.
2427 If the location descriptor is missing, new_symbol will create
2428 a LOC_UNRESOLVED symbol, the address of the variable will then
2429 be determined from the minimal symbol table whenever the variable
2431 The address for the partial symbol table entry is not
2432 used by GDB, but it comes in handy for debugging partial symbol
2436 addr
= decode_locdesc (pdi
->locdesc
, cu
);
2437 if (pdi
->locdesc
|| pdi
->has_type
)
2438 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
2440 VAR_DOMAIN
, LOC_STATIC
,
2441 &objfile
->global_psymbols
,
2443 cu
->language
, objfile
);
2447 /* Static Variable. Skip symbols without location descriptors. */
2448 if (pdi
->locdesc
== NULL
)
2450 if (built_actual_name
)
2451 xfree (actual_name
);
2454 addr
= decode_locdesc (pdi
->locdesc
, cu
);
2455 /*prim_record_minimal_symbol (actual_name, addr + baseaddr,
2456 mst_file_data, objfile); */
2457 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
2459 VAR_DOMAIN
, LOC_STATIC
,
2460 &objfile
->static_psymbols
,
2462 cu
->language
, objfile
);
2465 case DW_TAG_typedef
:
2466 case DW_TAG_base_type
:
2467 case DW_TAG_subrange_type
:
2468 add_psymbol_to_list (actual_name
, strlen (actual_name
),
2470 VAR_DOMAIN
, LOC_TYPEDEF
,
2471 &objfile
->static_psymbols
,
2472 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
2474 case DW_TAG_namespace
:
2475 add_psymbol_to_list (actual_name
, strlen (actual_name
),
2477 VAR_DOMAIN
, LOC_TYPEDEF
,
2478 &objfile
->global_psymbols
,
2479 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
2481 case DW_TAG_class_type
:
2482 case DW_TAG_interface_type
:
2483 case DW_TAG_structure_type
:
2484 case DW_TAG_union_type
:
2485 case DW_TAG_enumeration_type
:
2486 /* Skip external references. The DWARF standard says in the section
2487 about "Structure, Union, and Class Type Entries": "An incomplete
2488 structure, union or class type is represented by a structure,
2489 union or class entry that does not have a byte size attribute
2490 and that has a DW_AT_declaration attribute." */
2491 if (!pdi
->has_byte_size
&& pdi
->is_declaration
)
2493 if (built_actual_name
)
2494 xfree (actual_name
);
2498 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
2499 static vs. global. */
2500 add_psymbol_to_list (actual_name
, strlen (actual_name
),
2502 STRUCT_DOMAIN
, LOC_TYPEDEF
,
2503 (cu
->language
== language_cplus
2504 || cu
->language
== language_java
)
2505 ? &objfile
->global_psymbols
2506 : &objfile
->static_psymbols
,
2507 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
2510 case DW_TAG_enumerator
:
2511 add_psymbol_to_list (actual_name
, strlen (actual_name
),
2513 VAR_DOMAIN
, LOC_CONST
,
2514 (cu
->language
== language_cplus
2515 || cu
->language
== language_java
)
2516 ? &objfile
->global_psymbols
2517 : &objfile
->static_psymbols
,
2518 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
2524 if (built_actual_name
)
2525 xfree (actual_name
);
2528 /* Read a partial die corresponding to a namespace; also, add a symbol
2529 corresponding to that namespace to the symbol table. NAMESPACE is
2530 the name of the enclosing namespace. */
2533 add_partial_namespace (struct partial_die_info
*pdi
,
2534 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
2535 int need_pc
, struct dwarf2_cu
*cu
)
2537 struct objfile
*objfile
= cu
->objfile
;
2539 /* Add a symbol for the namespace. */
2541 add_partial_symbol (pdi
, cu
);
2543 /* Now scan partial symbols in that namespace. */
2545 if (pdi
->has_children
)
2546 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, need_pc
, cu
);
2549 /* Read a partial die corresponding to a Fortran module. */
2552 add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
2553 CORE_ADDR
*highpc
, int need_pc
, struct dwarf2_cu
*cu
)
2555 /* Now scan partial symbols in that module.
2557 FIXME: Support the separate Fortran module namespaces. */
2559 if (pdi
->has_children
)
2560 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, need_pc
, cu
);
2563 /* Read a partial die corresponding to a subprogram and create a partial
2564 symbol for that subprogram. When the CU language allows it, this
2565 routine also defines a partial symbol for each nested subprogram
2566 that this subprogram contains.
2568 DIE my also be a lexical block, in which case we simply search
2569 recursively for suprograms defined inside that lexical block.
2570 Again, this is only performed when the CU language allows this
2571 type of definitions. */
2574 add_partial_subprogram (struct partial_die_info
*pdi
,
2575 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
2576 int need_pc
, struct dwarf2_cu
*cu
)
2578 if (pdi
->tag
== DW_TAG_subprogram
)
2580 if (pdi
->has_pc_info
)
2582 if (pdi
->lowpc
< *lowpc
)
2583 *lowpc
= pdi
->lowpc
;
2584 if (pdi
->highpc
> *highpc
)
2585 *highpc
= pdi
->highpc
;
2589 struct objfile
*objfile
= cu
->objfile
;
2591 baseaddr
= ANOFFSET (objfile
->section_offsets
,
2592 SECT_OFF_TEXT (objfile
));
2593 addrmap_set_empty (objfile
->psymtabs_addrmap
,
2594 pdi
->lowpc
+ baseaddr
,
2595 pdi
->highpc
- 1 + baseaddr
,
2596 cu
->per_cu
->psymtab
);
2598 if (!pdi
->is_declaration
)
2599 /* Ignore subprogram DIEs that do not have a name, they are
2600 illegal. Do not emit a complaint at this point, we will
2601 do so when we convert this psymtab into a symtab. */
2603 add_partial_symbol (pdi
, cu
);
2607 if (! pdi
->has_children
)
2610 if (cu
->language
== language_ada
)
2612 pdi
= pdi
->die_child
;
2615 fixup_partial_die (pdi
, cu
);
2616 if (pdi
->tag
== DW_TAG_subprogram
2617 || pdi
->tag
== DW_TAG_lexical_block
)
2618 add_partial_subprogram (pdi
, lowpc
, highpc
, need_pc
, cu
);
2619 pdi
= pdi
->die_sibling
;
2624 /* See if we can figure out if the class lives in a namespace. We do
2625 this by looking for a member function; its demangled name will
2626 contain namespace info, if there is any. */
2629 guess_structure_name (struct partial_die_info
*struct_pdi
,
2630 struct dwarf2_cu
*cu
)
2632 if ((cu
->language
== language_cplus
2633 || cu
->language
== language_java
)
2634 && cu
->has_namespace_info
== 0
2635 && struct_pdi
->has_children
)
2637 /* NOTE: carlton/2003-10-07: Getting the info this way changes
2638 what template types look like, because the demangler
2639 frequently doesn't give the same name as the debug info. We
2640 could fix this by only using the demangled name to get the
2641 prefix (but see comment in read_structure_type). */
2643 struct partial_die_info
*real_pdi
;
2645 /* If this DIE (this DIE's specification, if any) has a parent, then
2646 we should not do this. We'll prepend the parent's fully qualified
2647 name when we create the partial symbol. */
2649 real_pdi
= struct_pdi
;
2650 while (real_pdi
->has_specification
)
2651 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
2653 if (real_pdi
->die_parent
!= NULL
)
2658 /* Read a partial die corresponding to an enumeration type. */
2661 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
2662 struct dwarf2_cu
*cu
)
2664 struct objfile
*objfile
= cu
->objfile
;
2665 bfd
*abfd
= objfile
->obfd
;
2666 struct partial_die_info
*pdi
;
2668 if (enum_pdi
->name
!= NULL
)
2669 add_partial_symbol (enum_pdi
, cu
);
2671 pdi
= enum_pdi
->die_child
;
2674 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
2675 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
2677 add_partial_symbol (pdi
, cu
);
2678 pdi
= pdi
->die_sibling
;
2682 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
2683 Return the corresponding abbrev, or NULL if the number is zero (indicating
2684 an empty DIE). In either case *BYTES_READ will be set to the length of
2685 the initial number. */
2687 static struct abbrev_info
*
2688 peek_die_abbrev (gdb_byte
*info_ptr
, unsigned int *bytes_read
,
2689 struct dwarf2_cu
*cu
)
2691 bfd
*abfd
= cu
->objfile
->obfd
;
2692 unsigned int abbrev_number
;
2693 struct abbrev_info
*abbrev
;
2695 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
2697 if (abbrev_number
== 0)
2700 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
2703 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"), abbrev_number
,
2704 bfd_get_filename (abfd
));
2710 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
2711 Returns a pointer to the end of a series of DIEs, terminated by an empty
2712 DIE. Any children of the skipped DIEs will also be skipped. */
2715 skip_children (gdb_byte
*buffer
, gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
2717 struct abbrev_info
*abbrev
;
2718 unsigned int bytes_read
;
2722 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
2724 return info_ptr
+ bytes_read
;
2726 info_ptr
= skip_one_die (buffer
, info_ptr
+ bytes_read
, abbrev
, cu
);
2730 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
2731 INFO_PTR should point just after the initial uleb128 of a DIE, and the
2732 abbrev corresponding to that skipped uleb128 should be passed in
2733 ABBREV. Returns a pointer to this DIE's sibling, skipping any
2737 skip_one_die (gdb_byte
*buffer
, gdb_byte
*info_ptr
,
2738 struct abbrev_info
*abbrev
, struct dwarf2_cu
*cu
)
2740 unsigned int bytes_read
;
2741 struct attribute attr
;
2742 bfd
*abfd
= cu
->objfile
->obfd
;
2743 unsigned int form
, i
;
2745 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
2747 /* The only abbrev we care about is DW_AT_sibling. */
2748 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
2750 read_attribute (&attr
, &abbrev
->attrs
[i
],
2751 abfd
, info_ptr
, cu
);
2752 if (attr
.form
== DW_FORM_ref_addr
)
2753 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
2755 return buffer
+ dwarf2_get_ref_die_offset (&attr
);
2758 /* If it isn't DW_AT_sibling, skip this attribute. */
2759 form
= abbrev
->attrs
[i
].form
;
2763 case DW_FORM_ref_addr
:
2764 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
2765 and later it is offset sized. */
2766 if (cu
->header
.version
== 2)
2767 info_ptr
+= cu
->header
.addr_size
;
2769 info_ptr
+= cu
->header
.offset_size
;
2772 info_ptr
+= cu
->header
.addr_size
;
2792 case DW_FORM_string
:
2793 read_string (abfd
, info_ptr
, &bytes_read
);
2794 info_ptr
+= bytes_read
;
2797 info_ptr
+= cu
->header
.offset_size
;
2800 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2801 info_ptr
+= bytes_read
;
2803 case DW_FORM_block1
:
2804 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
2806 case DW_FORM_block2
:
2807 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
2809 case DW_FORM_block4
:
2810 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
2814 case DW_FORM_ref_udata
:
2815 info_ptr
= skip_leb128 (abfd
, info_ptr
);
2817 case DW_FORM_indirect
:
2818 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2819 info_ptr
+= bytes_read
;
2820 /* We need to continue parsing from here, so just go back to
2822 goto skip_attribute
;
2825 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
2826 dwarf_form_name (form
),
2827 bfd_get_filename (abfd
));
2831 if (abbrev
->has_children
)
2832 return skip_children (buffer
, info_ptr
, cu
);
2837 /* Locate ORIG_PDI's sibling.
2838 INFO_PTR should point to the start of the next DIE after ORIG_PDI
2842 locate_pdi_sibling (struct partial_die_info
*orig_pdi
,
2843 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
2844 bfd
*abfd
, struct dwarf2_cu
*cu
)
2846 /* Do we know the sibling already? */
2848 if (orig_pdi
->sibling
)
2849 return orig_pdi
->sibling
;
2851 /* Are there any children to deal with? */
2853 if (!orig_pdi
->has_children
)
2856 /* Skip the children the long way. */
2858 return skip_children (buffer
, info_ptr
, cu
);
2861 /* Expand this partial symbol table into a full symbol table. */
2864 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
2866 /* FIXME: This is barely more than a stub. */
2871 warning (_("bug: psymtab for %s is already read in."), pst
->filename
);
2877 printf_filtered (_("Reading in symbols for %s..."), pst
->filename
);
2878 gdb_flush (gdb_stdout
);
2881 /* Restore our global data. */
2882 dwarf2_per_objfile
= objfile_data (pst
->objfile
,
2883 dwarf2_objfile_data_key
);
2885 /* If this psymtab is constructed from a debug-only objfile, the
2886 has_section_at_zero flag will not necessarily be correct. We
2887 can get the correct value for this flag by looking at the data
2888 associated with the (presumably stripped) associated objfile. */
2889 if (pst
->objfile
->separate_debug_objfile_backlink
)
2891 struct dwarf2_per_objfile
*dpo_backlink
2892 = objfile_data (pst
->objfile
->separate_debug_objfile_backlink
,
2893 dwarf2_objfile_data_key
);
2894 dwarf2_per_objfile
->has_section_at_zero
2895 = dpo_backlink
->has_section_at_zero
;
2898 psymtab_to_symtab_1 (pst
);
2900 /* Finish up the debug error message. */
2902 printf_filtered (_("done.\n"));
2907 /* Add PER_CU to the queue. */
2910 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
, struct objfile
*objfile
)
2912 struct dwarf2_queue_item
*item
;
2915 item
= xmalloc (sizeof (*item
));
2916 item
->per_cu
= per_cu
;
2919 if (dwarf2_queue
== NULL
)
2920 dwarf2_queue
= item
;
2922 dwarf2_queue_tail
->next
= item
;
2924 dwarf2_queue_tail
= item
;
2927 /* Process the queue. */
2930 process_queue (struct objfile
*objfile
)
2932 struct dwarf2_queue_item
*item
, *next_item
;
2934 /* The queue starts out with one item, but following a DIE reference
2935 may load a new CU, adding it to the end of the queue. */
2936 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
2938 if (item
->per_cu
->psymtab
&& !item
->per_cu
->psymtab
->readin
)
2939 process_full_comp_unit (item
->per_cu
);
2941 item
->per_cu
->queued
= 0;
2942 next_item
= item
->next
;
2946 dwarf2_queue_tail
= NULL
;
2949 /* Free all allocated queue entries. This function only releases anything if
2950 an error was thrown; if the queue was processed then it would have been
2951 freed as we went along. */
2954 dwarf2_release_queue (void *dummy
)
2956 struct dwarf2_queue_item
*item
, *last
;
2958 item
= dwarf2_queue
;
2961 /* Anything still marked queued is likely to be in an
2962 inconsistent state, so discard it. */
2963 if (item
->per_cu
->queued
)
2965 if (item
->per_cu
->cu
!= NULL
)
2966 free_one_cached_comp_unit (item
->per_cu
->cu
);
2967 item
->per_cu
->queued
= 0;
2975 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
2978 /* Read in full symbols for PST, and anything it depends on. */
2981 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
2983 struct dwarf2_per_cu_data
*per_cu
;
2984 struct cleanup
*back_to
;
2987 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2988 if (!pst
->dependencies
[i
]->readin
)
2990 /* Inform about additional files that need to be read in. */
2993 /* FIXME: i18n: Need to make this a single string. */
2994 fputs_filtered (" ", gdb_stdout
);
2996 fputs_filtered ("and ", gdb_stdout
);
2998 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
2999 wrap_here (""); /* Flush output */
3000 gdb_flush (gdb_stdout
);
3002 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
3005 per_cu
= pst
->read_symtab_private
;
3009 /* It's an include file, no symbols to read for it.
3010 Everything is in the parent symtab. */
3015 back_to
= make_cleanup (dwarf2_release_queue
, NULL
);
3017 queue_comp_unit (per_cu
, pst
->objfile
);
3019 if (per_cu
->from_debug_types
)
3020 read_signatured_type_at_offset (pst
->objfile
, per_cu
->offset
);
3022 load_full_comp_unit (per_cu
, pst
->objfile
);
3024 process_queue (pst
->objfile
);
3026 /* Age the cache, releasing compilation units that have not
3027 been used recently. */
3028 age_cached_comp_units ();
3030 do_cleanups (back_to
);
3033 /* Load the DIEs associated with PER_CU into memory. */
3036 load_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
, struct objfile
*objfile
)
3038 bfd
*abfd
= objfile
->obfd
;
3039 struct dwarf2_cu
*cu
;
3040 unsigned int offset
;
3041 gdb_byte
*info_ptr
, *beg_of_comp_unit
;
3042 struct cleanup
*back_to
, *free_cu_cleanup
;
3043 struct attribute
*attr
;
3046 gdb_assert (! per_cu
->from_debug_types
);
3048 /* Set local variables from the partial symbol table info. */
3049 offset
= per_cu
->offset
;
3051 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
3052 info_ptr
= dwarf2_per_objfile
->info
.buffer
+ offset
;
3053 beg_of_comp_unit
= info_ptr
;
3055 cu
= alloc_one_comp_unit (objfile
);
3057 /* If an error occurs while loading, release our storage. */
3058 free_cu_cleanup
= make_cleanup (free_one_comp_unit
, cu
);
3060 /* Read in the comp_unit header. */
3061 info_ptr
= read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
3063 /* Complete the cu_header. */
3064 cu
->header
.offset
= offset
;
3065 cu
->header
.first_die_offset
= info_ptr
- beg_of_comp_unit
;
3067 /* Read the abbrevs for this compilation unit. */
3068 dwarf2_read_abbrevs (abfd
, cu
);
3069 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
3071 /* Link this compilation unit into the compilation unit tree. */
3073 cu
->per_cu
= per_cu
;
3074 cu
->type_hash
= per_cu
->type_hash
;
3076 cu
->dies
= read_comp_unit (info_ptr
, cu
);
3078 /* We try not to read any attributes in this function, because not
3079 all objfiles needed for references have been loaded yet, and symbol
3080 table processing isn't initialized. But we have to set the CU language,
3081 or we won't be able to build types correctly. */
3082 attr
= dwarf2_attr (cu
->dies
, DW_AT_language
, cu
);
3084 set_cu_language (DW_UNSND (attr
), cu
);
3086 set_cu_language (language_minimal
, cu
);
3088 /* Similarly, if we do not read the producer, we can not apply
3089 producer-specific interpretation. */
3090 attr
= dwarf2_attr (cu
->dies
, DW_AT_producer
, cu
);
3092 cu
->producer
= DW_STRING (attr
);
3094 /* Link this CU into read_in_chain. */
3095 per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
3096 dwarf2_per_objfile
->read_in_chain
= per_cu
;
3098 do_cleanups (back_to
);
3100 /* We've successfully allocated this compilation unit. Let our caller
3101 clean it up when finished with it. */
3102 discard_cleanups (free_cu_cleanup
);
3105 /* Generate full symbol information for PST and CU, whose DIEs have
3106 already been loaded into memory. */
3109 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
3111 struct partial_symtab
*pst
= per_cu
->psymtab
;
3112 struct dwarf2_cu
*cu
= per_cu
->cu
;
3113 struct objfile
*objfile
= pst
->objfile
;
3114 bfd
*abfd
= objfile
->obfd
;
3115 CORE_ADDR lowpc
, highpc
;
3116 struct symtab
*symtab
;
3117 struct cleanup
*back_to
;
3120 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3123 back_to
= make_cleanup (really_free_pendings
, NULL
);
3125 cu
->list_in_scope
= &file_symbols
;
3127 dwarf2_find_base_address (cu
->dies
, cu
);
3129 /* Do line number decoding in read_file_scope () */
3130 process_die (cu
->dies
, cu
);
3132 /* Some compilers don't define a DW_AT_high_pc attribute for the
3133 compilation unit. If the DW_AT_high_pc is missing, synthesize
3134 it, by scanning the DIE's below the compilation unit. */
3135 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
3137 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
3139 /* Set symtab language to language from DW_AT_language.
3140 If the compilation is from a C file generated by language preprocessors,
3141 do not set the language if it was already deduced by start_subfile. */
3143 && !(cu
->language
== language_c
&& symtab
->language
!= language_c
))
3145 symtab
->language
= cu
->language
;
3147 pst
->symtab
= symtab
;
3150 do_cleanups (back_to
);
3153 /* Process a die and its children. */
3156 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
3160 case DW_TAG_padding
:
3162 case DW_TAG_compile_unit
:
3163 read_file_scope (die
, cu
);
3165 case DW_TAG_type_unit
:
3166 read_type_unit_scope (die
, cu
);
3168 case DW_TAG_subprogram
:
3169 case DW_TAG_inlined_subroutine
:
3170 read_func_scope (die
, cu
);
3172 case DW_TAG_lexical_block
:
3173 case DW_TAG_try_block
:
3174 case DW_TAG_catch_block
:
3175 read_lexical_block_scope (die
, cu
);
3177 case DW_TAG_class_type
:
3178 case DW_TAG_interface_type
:
3179 case DW_TAG_structure_type
:
3180 case DW_TAG_union_type
:
3181 process_structure_scope (die
, cu
);
3183 case DW_TAG_enumeration_type
:
3184 process_enumeration_scope (die
, cu
);
3187 /* These dies have a type, but processing them does not create
3188 a symbol or recurse to process the children. Therefore we can
3189 read them on-demand through read_type_die. */
3190 case DW_TAG_subroutine_type
:
3191 case DW_TAG_set_type
:
3192 case DW_TAG_array_type
:
3193 case DW_TAG_pointer_type
:
3194 case DW_TAG_ptr_to_member_type
:
3195 case DW_TAG_reference_type
:
3196 case DW_TAG_string_type
:
3199 case DW_TAG_base_type
:
3200 case DW_TAG_subrange_type
:
3201 case DW_TAG_typedef
:
3202 /* Add a typedef symbol for the type definition, if it has a
3204 new_symbol (die
, read_type_die (die
, cu
), cu
);
3206 case DW_TAG_common_block
:
3207 read_common_block (die
, cu
);
3209 case DW_TAG_common_inclusion
:
3211 case DW_TAG_namespace
:
3212 processing_has_namespace_info
= 1;
3213 read_namespace (die
, cu
);
3216 read_module (die
, cu
);
3218 case DW_TAG_imported_declaration
:
3219 case DW_TAG_imported_module
:
3220 processing_has_namespace_info
= 1;
3221 if (die
->child
!= NULL
&& (die
->tag
== DW_TAG_imported_declaration
3222 || cu
->language
!= language_fortran
))
3223 complaint (&symfile_complaints
, _("Tag '%s' has unexpected children"),
3224 dwarf_tag_name (die
->tag
));
3225 read_import_statement (die
, cu
);
3228 new_symbol (die
, NULL
, cu
);
3233 /* A helper function for dwarf2_compute_name which determines whether DIE
3234 needs to have the name of the scope prepended to the name listed in the
3238 die_needs_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
3240 struct attribute
*attr
;
3244 case DW_TAG_namespace
:
3245 case DW_TAG_typedef
:
3246 case DW_TAG_class_type
:
3247 case DW_TAG_interface_type
:
3248 case DW_TAG_structure_type
:
3249 case DW_TAG_union_type
:
3250 case DW_TAG_enumeration_type
:
3251 case DW_TAG_enumerator
:
3252 case DW_TAG_subprogram
:
3256 case DW_TAG_variable
:
3257 /* We only need to prefix "globally" visible variables. These include
3258 any variable marked with DW_AT_external or any variable that
3259 lives in a namespace. [Variables in anonymous namespaces
3260 require prefixing, but they are not DW_AT_external.] */
3262 if (dwarf2_attr (die
, DW_AT_specification
, cu
))
3264 struct dwarf2_cu
*spec_cu
= cu
;
3265 return die_needs_namespace (die_specification (die
, &spec_cu
),
3269 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
3270 if (attr
== NULL
&& die
->parent
->tag
!= DW_TAG_namespace
)
3272 /* A variable in a lexical block of some kind does not need a
3273 namespace, even though in C++ such variables may be external
3274 and have a mangled name. */
3275 if (die
->parent
->tag
== DW_TAG_lexical_block
3276 || die
->parent
->tag
== DW_TAG_try_block
3277 || die
->parent
->tag
== DW_TAG_catch_block
3278 || die
->parent
->tag
== DW_TAG_subprogram
)
3287 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
3288 compute the physname for the object, which include a method's
3289 formal parameters (C++/Java) and return type (Java).
3291 For Ada, return the DIE's linkage name rather than the fully qualified
3292 name. PHYSNAME is ignored..
3294 The result is allocated on the objfile_obstack and canonicalized. */
3297 dwarf2_compute_name (char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
,
3301 name
= dwarf2_name (die
, cu
);
3303 /* These are the only languages we know how to qualify names in. */
3305 && (cu
->language
== language_cplus
|| cu
->language
== language_java
))
3307 if (die_needs_namespace (die
, cu
))
3311 struct ui_file
*buf
;
3313 prefix
= determine_prefix (die
, cu
);
3314 buf
= mem_fileopen ();
3315 if (*prefix
!= '\0')
3317 char *prefixed_name
= typename_concat (NULL
, prefix
, name
, cu
);
3318 fputs_unfiltered (prefixed_name
, buf
);
3319 xfree (prefixed_name
);
3322 fputs_unfiltered (name
? name
: "", buf
);
3324 /* For Java and C++ methods, append formal parameter type
3325 information, if PHYSNAME. */
3327 if (physname
&& die
->tag
== DW_TAG_subprogram
3328 && (cu
->language
== language_cplus
3329 || cu
->language
== language_java
))
3331 struct type
*type
= read_type_die (die
, cu
);
3333 c_type_print_args (type
, buf
, 0, cu
->language
);
3335 if (cu
->language
== language_java
)
3337 /* For java, we must append the return type to method
3339 if (die
->tag
== DW_TAG_subprogram
)
3340 java_print_type (TYPE_TARGET_TYPE (type
), "", buf
,
3343 else if (cu
->language
== language_cplus
)
3345 if (TYPE_NFIELDS (type
) > 0
3346 && TYPE_FIELD_ARTIFICIAL (type
, 0)
3347 && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type
, 0))))
3348 fputs_unfiltered (" const", buf
);
3352 name
= ui_file_obsavestring (buf
, &cu
->objfile
->objfile_obstack
,
3354 ui_file_delete (buf
);
3356 if (cu
->language
== language_cplus
)
3359 = dwarf2_canonicalize_name (name
, cu
,
3360 &cu
->objfile
->objfile_obstack
);
3366 else if (cu
->language
== language_ada
)
3368 /* For Ada unit, we prefer the linkage name over the name, as
3369 the former contains the exported name, which the user expects
3370 to be able to reference. Ideally, we want the user to be able
3371 to reference this entity using either natural or linkage name,
3372 but we haven't started looking at this enhancement yet. */
3373 struct attribute
*attr
;
3375 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
3376 if (attr
&& DW_STRING (attr
))
3377 name
= DW_STRING (attr
);
3383 /* Return the fully qualified name of DIE, based on its DW_AT_name.
3384 If scope qualifiers are appropriate they will be added. The result
3385 will be allocated on the objfile_obstack, or NULL if the DIE does
3386 not have a name. NAME may either be from a previous call to
3387 dwarf2_name or NULL.
3389 The output string will be canonicalized (if C++/Java). */
3392 dwarf2_full_name (char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
3394 return dwarf2_compute_name (name
, die
, cu
, 0);
3397 /* Construct a physname for the given DIE in CU. NAME may either be
3398 from a previous call to dwarf2_name or NULL. The result will be
3399 allocated on the objfile_objstack or NULL if the DIE does not have a
3402 The output string will be canonicalized (if C++/Java). */
3405 dwarf2_physname (char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
3407 return dwarf2_compute_name (name
, die
, cu
, 1);
3410 /* Read the import statement specified by the given die and record it. */
3413 read_import_statement (struct die_info
*die
, struct dwarf2_cu
*cu
)
3415 struct attribute
*import_attr
;
3416 struct die_info
*imported_die
;
3417 struct dwarf2_cu
*imported_cu
;
3418 const char *imported_name
;
3419 const char *imported_name_prefix
;
3420 const char *canonical_name
;
3421 const char *import_alias
;
3422 const char *imported_declaration
= NULL
;
3423 const char *import_prefix
;
3427 import_attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
3428 if (import_attr
== NULL
)
3430 complaint (&symfile_complaints
, _("Tag '%s' has no DW_AT_import"),
3431 dwarf_tag_name (die
->tag
));
3436 imported_die
= follow_die_ref_or_sig (die
, import_attr
, &imported_cu
);
3437 imported_name
= dwarf2_name (imported_die
, imported_cu
);
3438 if (imported_name
== NULL
)
3440 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
3442 The import in the following code:
3456 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
3457 <52> DW_AT_decl_file : 1
3458 <53> DW_AT_decl_line : 6
3459 <54> DW_AT_import : <0x75>
3460 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
3462 <5b> DW_AT_decl_file : 1
3463 <5c> DW_AT_decl_line : 2
3464 <5d> DW_AT_type : <0x6e>
3466 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
3467 <76> DW_AT_byte_size : 4
3468 <77> DW_AT_encoding : 5 (signed)
3470 imports the wrong die ( 0x75 instead of 0x58 ).
3471 This case will be ignored until the gcc bug is fixed. */
3475 /* Figure out the local name after import. */
3476 import_alias
= dwarf2_name (die
, cu
);
3478 /* Figure out where the statement is being imported to. */
3479 import_prefix
= determine_prefix (die
, cu
);
3481 /* Figure out what the scope of the imported die is and prepend it
3482 to the name of the imported die. */
3483 imported_name_prefix
= determine_prefix (imported_die
, imported_cu
);
3485 if (imported_die
->tag
!= DW_TAG_namespace
)
3487 imported_declaration
= imported_name
;
3488 canonical_name
= imported_name_prefix
;
3490 else if (strlen (imported_name_prefix
) > 0)
3492 temp
= alloca (strlen (imported_name_prefix
)
3493 + 2 + strlen (imported_name
) + 1);
3494 strcpy (temp
, imported_name_prefix
);
3495 strcat (temp
, "::");
3496 strcat (temp
, imported_name
);
3497 canonical_name
= temp
;
3500 canonical_name
= imported_name
;
3502 cp_add_using_directive (import_prefix
,
3505 imported_declaration
,
3506 &cu
->objfile
->objfile_obstack
);
3510 initialize_cu_func_list (struct dwarf2_cu
*cu
)
3512 cu
->first_fn
= cu
->last_fn
= cu
->cached_fn
= NULL
;
3516 free_cu_line_header (void *arg
)
3518 struct dwarf2_cu
*cu
= arg
;
3520 free_line_header (cu
->line_header
);
3521 cu
->line_header
= NULL
;
3525 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
3527 struct objfile
*objfile
= cu
->objfile
;
3528 struct comp_unit_head
*cu_header
= &cu
->header
;
3529 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
3530 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
3531 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
3532 struct attribute
*attr
;
3534 char *comp_dir
= NULL
;
3535 struct die_info
*child_die
;
3536 bfd
*abfd
= objfile
->obfd
;
3537 struct line_header
*line_header
= 0;
3540 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3542 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
3544 /* If we didn't find a lowpc, set it to highpc to avoid complaints
3545 from finish_block. */
3546 if (lowpc
== ((CORE_ADDR
) -1))
3551 /* Find the filename. Do not use dwarf2_name here, since the filename
3552 is not a source language identifier. */
3553 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3556 name
= DW_STRING (attr
);
3559 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
3561 comp_dir
= DW_STRING (attr
);
3562 else if (name
!= NULL
&& IS_ABSOLUTE_PATH (name
))
3564 comp_dir
= ldirname (name
);
3565 if (comp_dir
!= NULL
)
3566 make_cleanup (xfree
, comp_dir
);
3568 if (comp_dir
!= NULL
)
3570 /* Irix 6.2 native cc prepends <machine>.: to the compilation
3571 directory, get rid of it. */
3572 char *cp
= strchr (comp_dir
, ':');
3574 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
3581 attr
= dwarf2_attr (die
, DW_AT_language
, cu
);
3584 set_cu_language (DW_UNSND (attr
), cu
);
3587 attr
= dwarf2_attr (die
, DW_AT_producer
, cu
);
3589 cu
->producer
= DW_STRING (attr
);
3591 /* We assume that we're processing GCC output. */
3592 processing_gcc_compilation
= 2;
3594 processing_has_namespace_info
= 0;
3596 start_symtab (name
, comp_dir
, lowpc
);
3597 record_debugformat ("DWARF 2");
3598 record_producer (cu
->producer
);
3600 initialize_cu_func_list (cu
);
3602 /* Decode line number information if present. We do this before
3603 processing child DIEs, so that the line header table is available
3604 for DW_AT_decl_file. */
3605 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
3608 unsigned int line_offset
= DW_UNSND (attr
);
3609 line_header
= dwarf_decode_line_header (line_offset
, abfd
, cu
);
3612 cu
->line_header
= line_header
;
3613 make_cleanup (free_cu_line_header
, cu
);
3614 dwarf_decode_lines (line_header
, comp_dir
, abfd
, cu
, NULL
);
3618 /* Process all dies in compilation unit. */
3619 if (die
->child
!= NULL
)
3621 child_die
= die
->child
;
3622 while (child_die
&& child_die
->tag
)
3624 process_die (child_die
, cu
);
3625 child_die
= sibling_die (child_die
);
3629 /* Decode macro information, if present. Dwarf 2 macro information
3630 refers to information in the line number info statement program
3631 header, so we can only read it if we've read the header
3633 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
3634 if (attr
&& line_header
)
3636 unsigned int macro_offset
= DW_UNSND (attr
);
3637 dwarf_decode_macros (line_header
, macro_offset
,
3638 comp_dir
, abfd
, cu
);
3640 do_cleanups (back_to
);
3643 /* For TUs we want to skip the first top level sibling if it's not the
3644 actual type being defined by this TU. In this case the first top
3645 level sibling is there to provide context only. */
3648 read_type_unit_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
3650 struct objfile
*objfile
= cu
->objfile
;
3651 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
3653 struct attribute
*attr
;
3655 char *comp_dir
= NULL
;
3656 struct die_info
*child_die
;
3657 bfd
*abfd
= objfile
->obfd
;
3658 struct line_header
*line_header
= 0;
3660 /* start_symtab needs a low pc, but we don't really have one.
3661 Do what read_file_scope would do in the absence of such info. */
3662 lowpc
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3664 /* Find the filename. Do not use dwarf2_name here, since the filename
3665 is not a source language identifier. */
3666 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3668 name
= DW_STRING (attr
);
3670 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
3672 comp_dir
= DW_STRING (attr
);
3673 else if (name
!= NULL
&& IS_ABSOLUTE_PATH (name
))
3675 comp_dir
= ldirname (name
);
3676 if (comp_dir
!= NULL
)
3677 make_cleanup (xfree
, comp_dir
);
3683 attr
= dwarf2_attr (die
, DW_AT_language
, cu
);
3685 set_cu_language (DW_UNSND (attr
), cu
);
3687 /* This isn't technically needed today. It is done for symmetry
3688 with read_file_scope. */
3689 attr
= dwarf2_attr (die
, DW_AT_producer
, cu
);
3691 cu
->producer
= DW_STRING (attr
);
3693 /* We assume that we're processing GCC output. */
3694 processing_gcc_compilation
= 2;
3696 processing_has_namespace_info
= 0;
3698 start_symtab (name
, comp_dir
, lowpc
);
3699 record_debugformat ("DWARF 2");
3700 record_producer (cu
->producer
);
3702 /* Process the dies in the type unit. */
3703 if (die
->child
== NULL
)
3705 dump_die_for_error (die
);
3706 error (_("Dwarf Error: Missing children for type unit [in module %s]"),
3707 bfd_get_filename (abfd
));
3710 child_die
= die
->child
;
3712 while (child_die
&& child_die
->tag
)
3714 process_die (child_die
, cu
);
3716 child_die
= sibling_die (child_die
);
3719 do_cleanups (back_to
);
3723 add_to_cu_func_list (const char *name
, CORE_ADDR lowpc
, CORE_ADDR highpc
,
3724 struct dwarf2_cu
*cu
)
3726 struct function_range
*thisfn
;
3728 thisfn
= (struct function_range
*)
3729 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct function_range
));
3730 thisfn
->name
= name
;
3731 thisfn
->lowpc
= lowpc
;
3732 thisfn
->highpc
= highpc
;
3733 thisfn
->seen_line
= 0;
3734 thisfn
->next
= NULL
;
3736 if (cu
->last_fn
== NULL
)
3737 cu
->first_fn
= thisfn
;
3739 cu
->last_fn
->next
= thisfn
;
3741 cu
->last_fn
= thisfn
;
3744 /* qsort helper for inherit_abstract_dies. */
3747 unsigned_int_compar (const void *ap
, const void *bp
)
3749 unsigned int a
= *(unsigned int *) ap
;
3750 unsigned int b
= *(unsigned int *) bp
;
3752 return (a
> b
) - (b
> a
);
3755 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
3756 Inherit only the children of the DW_AT_abstract_origin DIE not being already
3757 referenced by DW_AT_abstract_origin from the children of the current DIE. */
3760 inherit_abstract_dies (struct die_info
*die
, struct dwarf2_cu
*cu
)
3762 struct die_info
*child_die
;
3763 unsigned die_children_count
;
3764 /* CU offsets which were referenced by children of the current DIE. */
3766 unsigned *offsets_end
, *offsetp
;
3767 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
3768 struct die_info
*origin_die
;
3769 /* Iterator of the ORIGIN_DIE children. */
3770 struct die_info
*origin_child_die
;
3771 struct cleanup
*cleanups
;
3772 struct attribute
*attr
;
3774 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
3778 origin_die
= follow_die_ref (die
, attr
, &cu
);
3779 if (die
->tag
!= origin_die
->tag
3780 && !(die
->tag
== DW_TAG_inlined_subroutine
3781 && origin_die
->tag
== DW_TAG_subprogram
))
3782 complaint (&symfile_complaints
,
3783 _("DIE 0x%x and its abstract origin 0x%x have different tags"),
3784 die
->offset
, origin_die
->offset
);
3786 child_die
= die
->child
;
3787 die_children_count
= 0;
3788 while (child_die
&& child_die
->tag
)
3790 child_die
= sibling_die (child_die
);
3791 die_children_count
++;
3793 offsets
= xmalloc (sizeof (*offsets
) * die_children_count
);
3794 cleanups
= make_cleanup (xfree
, offsets
);
3796 offsets_end
= offsets
;
3797 child_die
= die
->child
;
3798 while (child_die
&& child_die
->tag
)
3800 /* For each CHILD_DIE, find the corresponding child of
3801 ORIGIN_DIE. If there is more than one layer of
3802 DW_AT_abstract_origin, follow them all; there shouldn't be,
3803 but GCC versions at least through 4.4 generate this (GCC PR
3805 struct die_info
*child_origin_die
= child_die
;
3808 attr
= dwarf2_attr (child_origin_die
, DW_AT_abstract_origin
, cu
);
3811 child_origin_die
= follow_die_ref (child_origin_die
, attr
, &cu
);
3814 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
3815 counterpart may exist. */
3816 if (child_origin_die
!= child_die
)
3818 if (child_die
->tag
!= child_origin_die
->tag
3819 && !(child_die
->tag
== DW_TAG_inlined_subroutine
3820 && child_origin_die
->tag
== DW_TAG_subprogram
))
3821 complaint (&symfile_complaints
,
3822 _("Child DIE 0x%x and its abstract origin 0x%x have "
3823 "different tags"), child_die
->offset
,
3824 child_origin_die
->offset
);
3825 if (child_origin_die
->parent
!= origin_die
)
3826 complaint (&symfile_complaints
,
3827 _("Child DIE 0x%x and its abstract origin 0x%x have "
3828 "different parents"), child_die
->offset
,
3829 child_origin_die
->offset
);
3831 *offsets_end
++ = child_origin_die
->offset
;
3833 child_die
= sibling_die (child_die
);
3835 qsort (offsets
, offsets_end
- offsets
, sizeof (*offsets
),
3836 unsigned_int_compar
);
3837 for (offsetp
= offsets
+ 1; offsetp
< offsets_end
; offsetp
++)
3838 if (offsetp
[-1] == *offsetp
)
3839 complaint (&symfile_complaints
, _("Multiple children of DIE 0x%x refer "
3840 "to DIE 0x%x as their abstract origin"),
3841 die
->offset
, *offsetp
);
3844 origin_child_die
= origin_die
->child
;
3845 while (origin_child_die
&& origin_child_die
->tag
)
3847 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
3848 while (offsetp
< offsets_end
&& *offsetp
< origin_child_die
->offset
)
3850 if (offsetp
>= offsets_end
|| *offsetp
> origin_child_die
->offset
)
3852 /* Found that ORIGIN_CHILD_DIE is really not referenced. */
3853 process_die (origin_child_die
, cu
);
3855 origin_child_die
= sibling_die (origin_child_die
);
3858 do_cleanups (cleanups
);
3862 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
3864 struct objfile
*objfile
= cu
->objfile
;
3865 struct context_stack
*new;
3868 struct die_info
*child_die
;
3869 struct attribute
*attr
, *call_line
, *call_file
;
3872 struct block
*block
;
3873 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
3877 /* If we do not have call site information, we can't show the
3878 caller of this inlined function. That's too confusing, so
3879 only use the scope for local variables. */
3880 call_line
= dwarf2_attr (die
, DW_AT_call_line
, cu
);
3881 call_file
= dwarf2_attr (die
, DW_AT_call_file
, cu
);
3882 if (call_line
== NULL
|| call_file
== NULL
)
3884 read_lexical_block_scope (die
, cu
);
3889 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3891 name
= dwarf2_name (die
, cu
);
3893 /* Ignore functions with missing or empty names. These are actually
3894 illegal according to the DWARF standard. */
3897 complaint (&symfile_complaints
,
3898 _("missing name for subprogram DIE at %d"), die
->offset
);
3902 /* Ignore functions with missing or invalid low and high pc attributes. */
3903 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
3905 complaint (&symfile_complaints
,
3906 _("cannot get low and high bounds for subprogram DIE at %d"),
3914 /* Record the function range for dwarf_decode_lines. */
3915 add_to_cu_func_list (name
, lowpc
, highpc
, cu
);
3917 new = push_context (0, lowpc
);
3918 new->name
= new_symbol (die
, read_type_die (die
, cu
), cu
);
3920 /* If there is a location expression for DW_AT_frame_base, record
3922 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
3924 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
3925 expression is being recorded directly in the function's symbol
3926 and not in a separate frame-base object. I guess this hack is
3927 to avoid adding some sort of frame-base adjunct/annex to the
3928 function's symbol :-(. The problem with doing this is that it
3929 results in a function symbol with a location expression that
3930 has nothing to do with the location of the function, ouch! The
3931 relationship should be: a function's symbol has-a frame base; a
3932 frame-base has-a location expression. */
3933 dwarf2_symbol_mark_computed (attr
, new->name
, cu
);
3935 cu
->list_in_scope
= &local_symbols
;
3937 if (die
->child
!= NULL
)
3939 child_die
= die
->child
;
3940 while (child_die
&& child_die
->tag
)
3942 process_die (child_die
, cu
);
3943 child_die
= sibling_die (child_die
);
3947 inherit_abstract_dies (die
, cu
);
3949 /* If we have a DW_AT_specification, we might need to import using
3950 directives from the context of the specification DIE. See the
3951 comment in determine_prefix. */
3952 if (cu
->language
== language_cplus
3953 && dwarf2_attr (die
, DW_AT_specification
, cu
))
3955 struct dwarf2_cu
*spec_cu
= cu
;
3956 struct die_info
*spec_die
= die_specification (die
, &spec_cu
);
3960 child_die
= spec_die
->child
;
3961 while (child_die
&& child_die
->tag
)
3963 if (child_die
->tag
== DW_TAG_imported_module
)
3964 process_die (child_die
, spec_cu
);
3965 child_die
= sibling_die (child_die
);
3968 /* In some cases, GCC generates specification DIEs that
3969 themselves contain DW_AT_specification attributes. */
3970 spec_die
= die_specification (spec_die
, &spec_cu
);
3974 new = pop_context ();
3975 /* Make a block for the local symbols within. */
3976 block
= finish_block (new->name
, &local_symbols
, new->old_blocks
,
3977 lowpc
, highpc
, objfile
);
3979 /* For C++, set the block's scope. */
3980 if (cu
->language
== language_cplus
)
3981 cp_set_block_scope (new->name
, block
, &objfile
->objfile_obstack
,
3982 determine_prefix (die
, cu
),
3983 processing_has_namespace_info
);
3985 /* If we have address ranges, record them. */
3986 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
3988 /* In C++, we can have functions nested inside functions (e.g., when
3989 a function declares a class that has methods). This means that
3990 when we finish processing a function scope, we may need to go
3991 back to building a containing block's symbol lists. */
3992 local_symbols
= new->locals
;
3993 param_symbols
= new->params
;
3994 using_directives
= new->using_directives
;
3996 /* If we've finished processing a top-level function, subsequent
3997 symbols go in the file symbol list. */
3998 if (outermost_context_p ())
3999 cu
->list_in_scope
= &file_symbols
;
4002 /* Process all the DIES contained within a lexical block scope. Start
4003 a new scope, process the dies, and then close the scope. */
4006 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
4008 struct objfile
*objfile
= cu
->objfile
;
4009 struct context_stack
*new;
4010 CORE_ADDR lowpc
, highpc
;
4011 struct die_info
*child_die
;
4014 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
4016 /* Ignore blocks with missing or invalid low and high pc attributes. */
4017 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
4018 as multiple lexical blocks? Handling children in a sane way would
4019 be nasty. Might be easier to properly extend generic blocks to
4021 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
4026 push_context (0, lowpc
);
4027 if (die
->child
!= NULL
)
4029 child_die
= die
->child
;
4030 while (child_die
&& child_die
->tag
)
4032 process_die (child_die
, cu
);
4033 child_die
= sibling_die (child_die
);
4036 new = pop_context ();
4038 if (local_symbols
!= NULL
|| using_directives
!= NULL
)
4041 = finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
4044 /* Note that recording ranges after traversing children, as we
4045 do here, means that recording a parent's ranges entails
4046 walking across all its children's ranges as they appear in
4047 the address map, which is quadratic behavior.
4049 It would be nicer to record the parent's ranges before
4050 traversing its children, simply overriding whatever you find
4051 there. But since we don't even decide whether to create a
4052 block until after we've traversed its children, that's hard
4054 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
4056 local_symbols
= new->locals
;
4057 using_directives
= new->using_directives
;
4060 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
4061 Return 1 if the attributes are present and valid, otherwise, return 0.
4062 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
4065 dwarf2_ranges_read (unsigned offset
, CORE_ADDR
*low_return
,
4066 CORE_ADDR
*high_return
, struct dwarf2_cu
*cu
,
4067 struct partial_symtab
*ranges_pst
)
4069 struct objfile
*objfile
= cu
->objfile
;
4070 struct comp_unit_head
*cu_header
= &cu
->header
;
4071 bfd
*obfd
= objfile
->obfd
;
4072 unsigned int addr_size
= cu_header
->addr_size
;
4073 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
4074 /* Base address selection entry. */
4085 found_base
= cu
->base_known
;
4086 base
= cu
->base_address
;
4088 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->ranges
);
4089 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
4091 complaint (&symfile_complaints
,
4092 _("Offset %d out of bounds for DW_AT_ranges attribute"),
4096 buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
4098 /* Read in the largest possible address. */
4099 marker
= read_address (obfd
, buffer
, cu
, &dummy
);
4100 if ((marker
& mask
) == mask
)
4102 /* If we found the largest possible address, then
4103 read the base address. */
4104 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
4105 buffer
+= 2 * addr_size
;
4106 offset
+= 2 * addr_size
;
4112 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
4116 CORE_ADDR range_beginning
, range_end
;
4118 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
4119 buffer
+= addr_size
;
4120 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
4121 buffer
+= addr_size
;
4122 offset
+= 2 * addr_size
;
4124 /* An end of list marker is a pair of zero addresses. */
4125 if (range_beginning
== 0 && range_end
== 0)
4126 /* Found the end of list entry. */
4129 /* Each base address selection entry is a pair of 2 values.
4130 The first is the largest possible address, the second is
4131 the base address. Check for a base address here. */
4132 if ((range_beginning
& mask
) == mask
)
4134 /* If we found the largest possible address, then
4135 read the base address. */
4136 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
4143 /* We have no valid base address for the ranges
4145 complaint (&symfile_complaints
,
4146 _("Invalid .debug_ranges data (no base address)"));
4150 range_beginning
+= base
;
4153 if (ranges_pst
!= NULL
&& range_beginning
< range_end
)
4154 addrmap_set_empty (objfile
->psymtabs_addrmap
,
4155 range_beginning
+ baseaddr
, range_end
- 1 + baseaddr
,
4158 /* FIXME: This is recording everything as a low-high
4159 segment of consecutive addresses. We should have a
4160 data structure for discontiguous block ranges
4164 low
= range_beginning
;
4170 if (range_beginning
< low
)
4171 low
= range_beginning
;
4172 if (range_end
> high
)
4178 /* If the first entry is an end-of-list marker, the range
4179 describes an empty scope, i.e. no instructions. */
4185 *high_return
= high
;
4189 /* Get low and high pc attributes from a die. Return 1 if the attributes
4190 are present and valid, otherwise, return 0. Return -1 if the range is
4191 discontinuous, i.e. derived from DW_AT_ranges information. */
4193 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
4194 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
,
4195 struct partial_symtab
*pst
)
4197 struct attribute
*attr
;
4202 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
4205 high
= DW_ADDR (attr
);
4206 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
4208 low
= DW_ADDR (attr
);
4210 /* Found high w/o low attribute. */
4213 /* Found consecutive range of addresses. */
4218 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
4221 /* Value of the DW_AT_ranges attribute is the offset in the
4222 .debug_ranges section. */
4223 if (!dwarf2_ranges_read (DW_UNSND (attr
), &low
, &high
, cu
, pst
))
4225 /* Found discontinuous range of addresses. */
4233 /* When using the GNU linker, .gnu.linkonce. sections are used to
4234 eliminate duplicate copies of functions and vtables and such.
4235 The linker will arbitrarily choose one and discard the others.
4236 The AT_*_pc values for such functions refer to local labels in
4237 these sections. If the section from that file was discarded, the
4238 labels are not in the output, so the relocs get a value of 0.
4239 If this is a discarded function, mark the pc bounds as invalid,
4240 so that GDB will ignore it. */
4241 if (low
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
4249 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
4250 its low and high PC addresses. Do nothing if these addresses could not
4251 be determined. Otherwise, set LOWPC to the low address if it is smaller,
4252 and HIGHPC to the high address if greater than HIGHPC. */
4255 dwarf2_get_subprogram_pc_bounds (struct die_info
*die
,
4256 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
4257 struct dwarf2_cu
*cu
)
4259 CORE_ADDR low
, high
;
4260 struct die_info
*child
= die
->child
;
4262 if (dwarf2_get_pc_bounds (die
, &low
, &high
, cu
, NULL
))
4264 *lowpc
= min (*lowpc
, low
);
4265 *highpc
= max (*highpc
, high
);
4268 /* If the language does not allow nested subprograms (either inside
4269 subprograms or lexical blocks), we're done. */
4270 if (cu
->language
!= language_ada
)
4273 /* Check all the children of the given DIE. If it contains nested
4274 subprograms, then check their pc bounds. Likewise, we need to
4275 check lexical blocks as well, as they may also contain subprogram
4277 while (child
&& child
->tag
)
4279 if (child
->tag
== DW_TAG_subprogram
4280 || child
->tag
== DW_TAG_lexical_block
)
4281 dwarf2_get_subprogram_pc_bounds (child
, lowpc
, highpc
, cu
);
4282 child
= sibling_die (child
);
4286 /* Get the low and high pc's represented by the scope DIE, and store
4287 them in *LOWPC and *HIGHPC. If the correct values can't be
4288 determined, set *LOWPC to -1 and *HIGHPC to 0. */
4291 get_scope_pc_bounds (struct die_info
*die
,
4292 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
4293 struct dwarf2_cu
*cu
)
4295 CORE_ADDR best_low
= (CORE_ADDR
) -1;
4296 CORE_ADDR best_high
= (CORE_ADDR
) 0;
4297 CORE_ADDR current_low
, current_high
;
4299 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
, NULL
))
4301 best_low
= current_low
;
4302 best_high
= current_high
;
4306 struct die_info
*child
= die
->child
;
4308 while (child
&& child
->tag
)
4310 switch (child
->tag
) {
4311 case DW_TAG_subprogram
:
4312 dwarf2_get_subprogram_pc_bounds (child
, &best_low
, &best_high
, cu
);
4314 case DW_TAG_namespace
:
4315 /* FIXME: carlton/2004-01-16: Should we do this for
4316 DW_TAG_class_type/DW_TAG_structure_type, too? I think
4317 that current GCC's always emit the DIEs corresponding
4318 to definitions of methods of classes as children of a
4319 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
4320 the DIEs giving the declarations, which could be
4321 anywhere). But I don't see any reason why the
4322 standards says that they have to be there. */
4323 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
4325 if (current_low
!= ((CORE_ADDR
) -1))
4327 best_low
= min (best_low
, current_low
);
4328 best_high
= max (best_high
, current_high
);
4336 child
= sibling_die (child
);
4341 *highpc
= best_high
;
4344 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
4347 dwarf2_record_block_ranges (struct die_info
*die
, struct block
*block
,
4348 CORE_ADDR baseaddr
, struct dwarf2_cu
*cu
)
4350 struct attribute
*attr
;
4352 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
4355 CORE_ADDR high
= DW_ADDR (attr
);
4356 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
4359 CORE_ADDR low
= DW_ADDR (attr
);
4360 record_block_range (block
, baseaddr
+ low
, baseaddr
+ high
- 1);
4364 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
4367 bfd
*obfd
= cu
->objfile
->obfd
;
4369 /* The value of the DW_AT_ranges attribute is the offset of the
4370 address range list in the .debug_ranges section. */
4371 unsigned long offset
= DW_UNSND (attr
);
4372 gdb_byte
*buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
4374 /* For some target architectures, but not others, the
4375 read_address function sign-extends the addresses it returns.
4376 To recognize base address selection entries, we need a
4378 unsigned int addr_size
= cu
->header
.addr_size
;
4379 CORE_ADDR base_select_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
4381 /* The base address, to which the next pair is relative. Note
4382 that this 'base' is a DWARF concept: most entries in a range
4383 list are relative, to reduce the number of relocs against the
4384 debugging information. This is separate from this function's
4385 'baseaddr' argument, which GDB uses to relocate debugging
4386 information from a shared library based on the address at
4387 which the library was loaded. */
4388 CORE_ADDR base
= cu
->base_address
;
4389 int base_known
= cu
->base_known
;
4391 gdb_assert (dwarf2_per_objfile
->ranges
.readin
);
4392 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
4394 complaint (&symfile_complaints
,
4395 _("Offset %lu out of bounds for DW_AT_ranges attribute"),
4402 unsigned int bytes_read
;
4403 CORE_ADDR start
, end
;
4405 start
= read_address (obfd
, buffer
, cu
, &bytes_read
);
4406 buffer
+= bytes_read
;
4407 end
= read_address (obfd
, buffer
, cu
, &bytes_read
);
4408 buffer
+= bytes_read
;
4410 /* Did we find the end of the range list? */
4411 if (start
== 0 && end
== 0)
4414 /* Did we find a base address selection entry? */
4415 else if ((start
& base_select_mask
) == base_select_mask
)
4421 /* We found an ordinary address range. */
4426 complaint (&symfile_complaints
,
4427 _("Invalid .debug_ranges data (no base address)"));
4431 record_block_range (block
,
4432 baseaddr
+ base
+ start
,
4433 baseaddr
+ base
+ end
- 1);
4439 /* Add an aggregate field to the field list. */
4442 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
4443 struct dwarf2_cu
*cu
)
4445 struct objfile
*objfile
= cu
->objfile
;
4446 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
4447 struct nextfield
*new_field
;
4448 struct attribute
*attr
;
4450 char *fieldname
= "";
4452 /* Allocate a new field list entry and link it in. */
4453 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
4454 make_cleanup (xfree
, new_field
);
4455 memset (new_field
, 0, sizeof (struct nextfield
));
4457 if (die
->tag
== DW_TAG_inheritance
)
4459 new_field
->next
= fip
->baseclasses
;
4460 fip
->baseclasses
= new_field
;
4464 new_field
->next
= fip
->fields
;
4465 fip
->fields
= new_field
;
4469 /* Handle accessibility and virtuality of field.
4470 The default accessibility for members is public, the default
4471 accessibility for inheritance is private. */
4472 if (die
->tag
!= DW_TAG_inheritance
)
4473 new_field
->accessibility
= DW_ACCESS_public
;
4475 new_field
->accessibility
= DW_ACCESS_private
;
4476 new_field
->virtuality
= DW_VIRTUALITY_none
;
4478 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
4480 new_field
->accessibility
= DW_UNSND (attr
);
4481 if (new_field
->accessibility
!= DW_ACCESS_public
)
4482 fip
->non_public_fields
= 1;
4483 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
4485 new_field
->virtuality
= DW_UNSND (attr
);
4487 fp
= &new_field
->field
;
4489 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
4491 /* Data member other than a C++ static data member. */
4493 /* Get type of field. */
4494 fp
->type
= die_type (die
, cu
);
4496 SET_FIELD_BITPOS (*fp
, 0);
4498 /* Get bit size of field (zero if none). */
4499 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
4502 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
4506 FIELD_BITSIZE (*fp
) = 0;
4509 /* Get bit offset of field. */
4510 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
4513 int byte_offset
= 0;
4515 if (attr_form_is_section_offset (attr
))
4516 dwarf2_complex_location_expr_complaint ();
4517 else if (attr_form_is_constant (attr
))
4518 byte_offset
= dwarf2_get_attr_constant_value (attr
, 0);
4519 else if (attr_form_is_block (attr
))
4520 byte_offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
4522 dwarf2_complex_location_expr_complaint ();
4524 SET_FIELD_BITPOS (*fp
, byte_offset
* bits_per_byte
);
4526 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
4529 if (gdbarch_bits_big_endian (gdbarch
))
4531 /* For big endian bits, the DW_AT_bit_offset gives the
4532 additional bit offset from the MSB of the containing
4533 anonymous object to the MSB of the field. We don't
4534 have to do anything special since we don't need to
4535 know the size of the anonymous object. */
4536 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
4540 /* For little endian bits, compute the bit offset to the
4541 MSB of the anonymous object, subtract off the number of
4542 bits from the MSB of the field to the MSB of the
4543 object, and then subtract off the number of bits of
4544 the field itself. The result is the bit offset of
4545 the LSB of the field. */
4547 int bit_offset
= DW_UNSND (attr
);
4549 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4552 /* The size of the anonymous object containing
4553 the bit field is explicit, so use the
4554 indicated size (in bytes). */
4555 anonymous_size
= DW_UNSND (attr
);
4559 /* The size of the anonymous object containing
4560 the bit field must be inferred from the type
4561 attribute of the data member containing the
4563 anonymous_size
= TYPE_LENGTH (fp
->type
);
4565 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
4566 - bit_offset
- FIELD_BITSIZE (*fp
);
4570 /* Get name of field. */
4571 fieldname
= dwarf2_name (die
, cu
);
4572 if (fieldname
== NULL
)
4575 /* The name is already allocated along with this objfile, so we don't
4576 need to duplicate it for the type. */
4577 fp
->name
= fieldname
;
4579 /* Change accessibility for artificial fields (e.g. virtual table
4580 pointer or virtual base class pointer) to private. */
4581 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
4583 FIELD_ARTIFICIAL (*fp
) = 1;
4584 new_field
->accessibility
= DW_ACCESS_private
;
4585 fip
->non_public_fields
= 1;
4588 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
4590 /* C++ static member. */
4592 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
4593 is a declaration, but all versions of G++ as of this writing
4594 (so through at least 3.2.1) incorrectly generate
4595 DW_TAG_variable tags. */
4599 /* Get name of field. */
4600 fieldname
= dwarf2_name (die
, cu
);
4601 if (fieldname
== NULL
)
4604 /* Get physical name. */
4605 physname
= (char *) dwarf2_physname (fieldname
, die
, cu
);
4607 /* The name is already allocated along with this objfile, so we don't
4608 need to duplicate it for the type. */
4609 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
4610 FIELD_TYPE (*fp
) = die_type (die
, cu
);
4611 FIELD_NAME (*fp
) = fieldname
;
4613 else if (die
->tag
== DW_TAG_inheritance
)
4615 /* C++ base class field. */
4616 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
4619 int byte_offset
= 0;
4621 if (attr_form_is_section_offset (attr
))
4622 dwarf2_complex_location_expr_complaint ();
4623 else if (attr_form_is_constant (attr
))
4624 byte_offset
= dwarf2_get_attr_constant_value (attr
, 0);
4625 else if (attr_form_is_block (attr
))
4626 byte_offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
4628 dwarf2_complex_location_expr_complaint ();
4630 SET_FIELD_BITPOS (*fp
, byte_offset
* bits_per_byte
);
4632 FIELD_BITSIZE (*fp
) = 0;
4633 FIELD_TYPE (*fp
) = die_type (die
, cu
);
4634 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
4635 fip
->nbaseclasses
++;
4639 /* Create the vector of fields, and attach it to the type. */
4642 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
4643 struct dwarf2_cu
*cu
)
4645 int nfields
= fip
->nfields
;
4647 /* Record the field count, allocate space for the array of fields,
4648 and create blank accessibility bitfields if necessary. */
4649 TYPE_NFIELDS (type
) = nfields
;
4650 TYPE_FIELDS (type
) = (struct field
*)
4651 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
4652 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
4654 if (fip
->non_public_fields
&& cu
->language
!= language_ada
)
4656 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
4658 TYPE_FIELD_PRIVATE_BITS (type
) =
4659 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
4660 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
4662 TYPE_FIELD_PROTECTED_BITS (type
) =
4663 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
4664 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
4666 TYPE_FIELD_IGNORE_BITS (type
) =
4667 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
4668 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
4671 /* If the type has baseclasses, allocate and clear a bit vector for
4672 TYPE_FIELD_VIRTUAL_BITS. */
4673 if (fip
->nbaseclasses
&& cu
->language
!= language_ada
)
4675 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
4676 unsigned char *pointer
;
4678 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
4679 pointer
= TYPE_ALLOC (type
, num_bytes
);
4680 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
4681 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
4682 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
4685 /* Copy the saved-up fields into the field vector. Start from the head
4686 of the list, adding to the tail of the field array, so that they end
4687 up in the same order in the array in which they were added to the list. */
4688 while (nfields
-- > 0)
4690 struct nextfield
*fieldp
;
4694 fieldp
= fip
->fields
;
4695 fip
->fields
= fieldp
->next
;
4699 fieldp
= fip
->baseclasses
;
4700 fip
->baseclasses
= fieldp
->next
;
4703 TYPE_FIELD (type
, nfields
) = fieldp
->field
;
4704 switch (fieldp
->accessibility
)
4706 case DW_ACCESS_private
:
4707 if (cu
->language
!= language_ada
)
4708 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
4711 case DW_ACCESS_protected
:
4712 if (cu
->language
!= language_ada
)
4713 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
4716 case DW_ACCESS_public
:
4720 /* Unknown accessibility. Complain and treat it as public. */
4722 complaint (&symfile_complaints
, _("unsupported accessibility %d"),
4723 fieldp
->accessibility
);
4727 if (nfields
< fip
->nbaseclasses
)
4729 switch (fieldp
->virtuality
)
4731 case DW_VIRTUALITY_virtual
:
4732 case DW_VIRTUALITY_pure_virtual
:
4733 if (cu
->language
== language_ada
)
4734 error ("unexpected virtuality in component of Ada type");
4735 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
4742 /* Add a member function to the proper fieldlist. */
4745 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
4746 struct type
*type
, struct dwarf2_cu
*cu
)
4748 struct objfile
*objfile
= cu
->objfile
;
4749 struct attribute
*attr
;
4750 struct fnfieldlist
*flp
;
4752 struct fn_field
*fnp
;
4755 struct nextfnfield
*new_fnfield
;
4756 struct type
*this_type
;
4758 if (cu
->language
== language_ada
)
4759 error ("unexpected member function in Ada type");
4761 /* Get name of member function. */
4762 fieldname
= dwarf2_name (die
, cu
);
4763 if (fieldname
== NULL
)
4766 /* Get the mangled name. */
4767 physname
= (char *) dwarf2_physname (fieldname
, die
, cu
);
4769 /* Look up member function name in fieldlist. */
4770 for (i
= 0; i
< fip
->nfnfields
; i
++)
4772 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
4776 /* Create new list element if necessary. */
4777 if (i
< fip
->nfnfields
)
4778 flp
= &fip
->fnfieldlists
[i
];
4781 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
4783 fip
->fnfieldlists
= (struct fnfieldlist
*)
4784 xrealloc (fip
->fnfieldlists
,
4785 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
4786 * sizeof (struct fnfieldlist
));
4787 if (fip
->nfnfields
== 0)
4788 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
4790 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
4791 flp
->name
= fieldname
;
4797 /* Create a new member function field and chain it to the field list
4799 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
4800 make_cleanup (xfree
, new_fnfield
);
4801 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
4802 new_fnfield
->next
= flp
->head
;
4803 flp
->head
= new_fnfield
;
4806 /* Fill in the member function field info. */
4807 fnp
= &new_fnfield
->fnfield
;
4808 /* The name is already allocated along with this objfile, so we don't
4809 need to duplicate it for the type. */
4810 fnp
->physname
= physname
? physname
: "";
4811 fnp
->type
= alloc_type (objfile
);
4812 this_type
= read_type_die (die
, cu
);
4813 if (this_type
&& TYPE_CODE (this_type
) == TYPE_CODE_FUNC
)
4815 int nparams
= TYPE_NFIELDS (this_type
);
4817 /* TYPE is the domain of this method, and THIS_TYPE is the type
4818 of the method itself (TYPE_CODE_METHOD). */
4819 smash_to_method_type (fnp
->type
, type
,
4820 TYPE_TARGET_TYPE (this_type
),
4821 TYPE_FIELDS (this_type
),
4822 TYPE_NFIELDS (this_type
),
4823 TYPE_VARARGS (this_type
));
4825 /* Handle static member functions.
4826 Dwarf2 has no clean way to discern C++ static and non-static
4827 member functions. G++ helps GDB by marking the first
4828 parameter for non-static member functions (which is the
4829 this pointer) as artificial. We obtain this information
4830 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
4831 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (this_type
, 0) == 0)
4832 fnp
->voffset
= VOFFSET_STATIC
;
4835 complaint (&symfile_complaints
, _("member function type missing for '%s'"),
4838 /* Get fcontext from DW_AT_containing_type if present. */
4839 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
4840 fnp
->fcontext
= die_containing_type (die
, cu
);
4842 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
4843 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
4845 /* Get accessibility. */
4846 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
4849 switch (DW_UNSND (attr
))
4851 case DW_ACCESS_private
:
4852 fnp
->is_private
= 1;
4854 case DW_ACCESS_protected
:
4855 fnp
->is_protected
= 1;
4860 /* Check for artificial methods. */
4861 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
4862 if (attr
&& DW_UNSND (attr
) != 0)
4863 fnp
->is_artificial
= 1;
4865 /* Get index in virtual function table if it is a virtual member
4866 function. For GCC, this is an offset in the appropriate
4867 virtual table, as specified by DW_AT_containing_type. For
4868 everyone else, it is an expression to be evaluated relative
4869 to the object address. */
4871 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
4872 if (attr
&& fnp
->fcontext
)
4874 /* Support the .debug_loc offsets */
4875 if (attr_form_is_block (attr
))
4877 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
4879 else if (attr_form_is_section_offset (attr
))
4881 dwarf2_complex_location_expr_complaint ();
4885 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
4891 /* We only support trivial expressions here. This hack will work
4892 for v3 classes, which always start with the vtable pointer. */
4893 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
> 0
4894 && DW_BLOCK (attr
)->data
[0] == DW_OP_deref
)
4896 struct dwarf_block blk
;
4897 blk
.size
= DW_BLOCK (attr
)->size
- 1;
4898 blk
.data
= DW_BLOCK (attr
)->data
+ 1;
4899 fnp
->voffset
= decode_locdesc (&blk
, cu
);
4900 if ((fnp
->voffset
% cu
->header
.addr_size
) != 0)
4901 dwarf2_complex_location_expr_complaint ();
4903 fnp
->voffset
/= cu
->header
.addr_size
;
4905 fnp
->fcontext
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type
, 0));
4908 dwarf2_complex_location_expr_complaint ();
4912 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
4913 if (attr
&& DW_UNSND (attr
))
4915 /* GCC does this, as of 2008-08-25; PR debug/37237. */
4916 complaint (&symfile_complaints
,
4917 _("Member function \"%s\" (offset %d) is virtual but the vtable offset is not specified"),
4918 fieldname
, die
->offset
);
4919 TYPE_CPLUS_DYNAMIC (type
) = 1;
4924 /* Create the vector of member function fields, and attach it to the type. */
4927 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
4928 struct dwarf2_cu
*cu
)
4930 struct fnfieldlist
*flp
;
4931 int total_length
= 0;
4934 if (cu
->language
== language_ada
)
4935 error ("unexpected member functions in Ada type");
4937 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
4938 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
4939 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
4941 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
4943 struct nextfnfield
*nfp
= flp
->head
;
4944 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
4947 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
4948 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
4949 fn_flp
->fn_fields
= (struct fn_field
*)
4950 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
4951 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
4952 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
4954 total_length
+= flp
->length
;
4957 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
4958 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
4961 /* Returns non-zero if NAME is the name of a vtable member in CU's
4962 language, zero otherwise. */
4964 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
4966 static const char vptr
[] = "_vptr";
4967 static const char vtable
[] = "vtable";
4969 /* Look for the C++ and Java forms of the vtable. */
4970 if ((cu
->language
== language_java
4971 && strncmp (name
, vtable
, sizeof (vtable
) - 1) == 0)
4972 || (strncmp (name
, vptr
, sizeof (vptr
) - 1) == 0
4973 && is_cplus_marker (name
[sizeof (vptr
) - 1])))
4979 /* GCC outputs unnamed structures that are really pointers to member
4980 functions, with the ABI-specified layout. If TYPE describes
4981 such a structure, smash it into a member function type.
4983 GCC shouldn't do this; it should just output pointer to member DIEs.
4984 This is GCC PR debug/28767. */
4987 quirk_gcc_member_function_pointer (struct type
*type
, struct objfile
*objfile
)
4989 struct type
*pfn_type
, *domain_type
, *new_type
;
4991 /* Check for a structure with no name and two children. */
4992 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
|| TYPE_NFIELDS (type
) != 2)
4995 /* Check for __pfn and __delta members. */
4996 if (TYPE_FIELD_NAME (type
, 0) == NULL
4997 || strcmp (TYPE_FIELD_NAME (type
, 0), "__pfn") != 0
4998 || TYPE_FIELD_NAME (type
, 1) == NULL
4999 || strcmp (TYPE_FIELD_NAME (type
, 1), "__delta") != 0)
5002 /* Find the type of the method. */
5003 pfn_type
= TYPE_FIELD_TYPE (type
, 0);
5004 if (pfn_type
== NULL
5005 || TYPE_CODE (pfn_type
) != TYPE_CODE_PTR
5006 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type
)) != TYPE_CODE_FUNC
)
5009 /* Look for the "this" argument. */
5010 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
5011 if (TYPE_NFIELDS (pfn_type
) == 0
5012 /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
5013 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type
, 0)) != TYPE_CODE_PTR
)
5016 domain_type
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type
, 0));
5017 new_type
= alloc_type (objfile
);
5018 smash_to_method_type (new_type
, domain_type
, TYPE_TARGET_TYPE (pfn_type
),
5019 TYPE_FIELDS (pfn_type
), TYPE_NFIELDS (pfn_type
),
5020 TYPE_VARARGS (pfn_type
));
5021 smash_to_methodptr_type (type
, new_type
);
5024 /* Called when we find the DIE that starts a structure or union scope
5025 (definition) to process all dies that define the members of the
5028 NOTE: we need to call struct_type regardless of whether or not the
5029 DIE has an at_name attribute, since it might be an anonymous
5030 structure or union. This gets the type entered into our set of
5033 However, if the structure is incomplete (an opaque struct/union)
5034 then suppress creating a symbol table entry for it since gdb only
5035 wants to find the one with the complete definition. Note that if
5036 it is complete, we just call new_symbol, which does it's own
5037 checking about whether the struct/union is anonymous or not (and
5038 suppresses creating a symbol table entry itself). */
5040 static struct type
*
5041 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5043 struct objfile
*objfile
= cu
->objfile
;
5045 struct attribute
*attr
;
5047 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
5049 /* If the definition of this type lives in .debug_types, read that type.
5050 Don't follow DW_AT_specification though, that will take us back up
5051 the chain and we want to go down. */
5052 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
, cu
);
5055 struct dwarf2_cu
*type_cu
= cu
;
5056 struct die_info
*type_die
= follow_die_ref_or_sig (die
, attr
, &type_cu
);
5057 /* We could just recurse on read_structure_type, but we need to call
5058 get_die_type to ensure only one type for this DIE is created.
5059 This is important, for example, because for c++ classes we need
5060 TYPE_NAME set which is only done by new_symbol. Blech. */
5061 type
= read_type_die (type_die
, type_cu
);
5062 return set_die_type (die
, type
, cu
);
5065 type
= alloc_type (objfile
);
5066 INIT_CPLUS_SPECIFIC (type
);
5068 name
= dwarf2_name (die
, cu
);
5071 if (cu
->language
== language_cplus
5072 || cu
->language
== language_java
)
5074 TYPE_TAG_NAME (type
) = (char *) dwarf2_full_name (name
, die
, cu
);
5075 if (die
->tag
== DW_TAG_structure_type
5076 || die
->tag
== DW_TAG_class_type
)
5077 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
5081 /* The name is already allocated along with this objfile, so
5082 we don't need to duplicate it for the type. */
5083 TYPE_TAG_NAME (type
) = (char *) name
;
5084 if (die
->tag
== DW_TAG_class_type
)
5085 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
5089 if (die
->tag
== DW_TAG_structure_type
)
5091 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
5093 else if (die
->tag
== DW_TAG_union_type
)
5095 TYPE_CODE (type
) = TYPE_CODE_UNION
;
5099 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
5102 if (cu
->language
== language_cplus
&& die
->tag
== DW_TAG_class_type
)
5103 TYPE_DECLARED_CLASS (type
) = 1;
5105 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
5108 TYPE_LENGTH (type
) = DW_UNSND (attr
);
5112 TYPE_LENGTH (type
) = 0;
5115 TYPE_STUB_SUPPORTED (type
) = 1;
5116 if (die_is_declaration (die
, cu
))
5117 TYPE_STUB (type
) = 1;
5118 else if (attr
== NULL
&& die
->child
== NULL
5119 && producer_is_realview (cu
->producer
))
5120 /* RealView does not output the required DW_AT_declaration
5121 on incomplete types. */
5122 TYPE_STUB (type
) = 1;
5124 set_descriptive_type (type
, die
, cu
);
5126 /* We need to add the type field to the die immediately so we don't
5127 infinitely recurse when dealing with pointers to the structure
5128 type within the structure itself. */
5129 set_die_type (die
, type
, cu
);
5131 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
5133 struct field_info fi
;
5134 struct die_info
*child_die
;
5136 memset (&fi
, 0, sizeof (struct field_info
));
5138 child_die
= die
->child
;
5140 while (child_die
&& child_die
->tag
)
5142 if (child_die
->tag
== DW_TAG_member
5143 || child_die
->tag
== DW_TAG_variable
)
5145 /* NOTE: carlton/2002-11-05: A C++ static data member
5146 should be a DW_TAG_member that is a declaration, but
5147 all versions of G++ as of this writing (so through at
5148 least 3.2.1) incorrectly generate DW_TAG_variable
5149 tags for them instead. */
5150 dwarf2_add_field (&fi
, child_die
, cu
);
5152 else if (child_die
->tag
== DW_TAG_subprogram
)
5154 /* C++ member function. */
5155 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
5157 else if (child_die
->tag
== DW_TAG_inheritance
)
5159 /* C++ base class field. */
5160 dwarf2_add_field (&fi
, child_die
, cu
);
5162 child_die
= sibling_die (child_die
);
5165 /* Attach fields and member functions to the type. */
5167 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
5170 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
5172 /* Get the type which refers to the base class (possibly this
5173 class itself) which contains the vtable pointer for the current
5174 class from the DW_AT_containing_type attribute. This use of
5175 DW_AT_containing_type is a GNU extension. */
5177 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
5179 struct type
*t
= die_containing_type (die
, cu
);
5181 TYPE_VPTR_BASETYPE (type
) = t
;
5186 /* Our own class provides vtbl ptr. */
5187 for (i
= TYPE_NFIELDS (t
) - 1;
5188 i
>= TYPE_N_BASECLASSES (t
);
5191 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
5193 if (is_vtable_name (fieldname
, cu
))
5195 TYPE_VPTR_FIELDNO (type
) = i
;
5200 /* Complain if virtual function table field not found. */
5201 if (i
< TYPE_N_BASECLASSES (t
))
5202 complaint (&symfile_complaints
,
5203 _("virtual function table pointer not found when defining class '%s'"),
5204 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
5209 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
5212 else if (cu
->producer
5213 && strncmp (cu
->producer
,
5214 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
5216 /* The IBM XLC compiler does not provide direct indication
5217 of the containing type, but the vtable pointer is
5218 always named __vfp. */
5222 for (i
= TYPE_NFIELDS (type
) - 1;
5223 i
>= TYPE_N_BASECLASSES (type
);
5226 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
5228 TYPE_VPTR_FIELDNO (type
) = i
;
5229 TYPE_VPTR_BASETYPE (type
) = type
;
5237 quirk_gcc_member_function_pointer (type
, cu
->objfile
);
5239 do_cleanups (back_to
);
5244 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
5246 struct objfile
*objfile
= cu
->objfile
;
5247 struct die_info
*child_die
= die
->child
;
5248 struct type
*this_type
;
5250 this_type
= get_die_type (die
, cu
);
5251 if (this_type
== NULL
)
5252 this_type
= read_structure_type (die
, cu
);
5254 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
5255 snapshots) has been known to create a die giving a declaration
5256 for a class that has, as a child, a die giving a definition for a
5257 nested class. So we have to process our children even if the
5258 current die is a declaration. Normally, of course, a declaration
5259 won't have any children at all. */
5261 while (child_die
!= NULL
&& child_die
->tag
)
5263 if (child_die
->tag
== DW_TAG_member
5264 || child_die
->tag
== DW_TAG_variable
5265 || child_die
->tag
== DW_TAG_inheritance
)
5270 process_die (child_die
, cu
);
5272 child_die
= sibling_die (child_die
);
5275 /* Do not consider external references. According to the DWARF standard,
5276 these DIEs are identified by the fact that they have no byte_size
5277 attribute, and a declaration attribute. */
5278 if (dwarf2_attr (die
, DW_AT_byte_size
, cu
) != NULL
5279 || !die_is_declaration (die
, cu
))
5280 new_symbol (die
, this_type
, cu
);
5283 /* Given a DW_AT_enumeration_type die, set its type. We do not
5284 complete the type's fields yet, or create any symbols. */
5286 static struct type
*
5287 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5289 struct objfile
*objfile
= cu
->objfile
;
5291 struct attribute
*attr
;
5294 /* If the definition of this type lives in .debug_types, read that type.
5295 Don't follow DW_AT_specification though, that will take us back up
5296 the chain and we want to go down. */
5297 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
, cu
);
5300 struct dwarf2_cu
*type_cu
= cu
;
5301 struct die_info
*type_die
= follow_die_ref_or_sig (die
, attr
, &type_cu
);
5302 type
= read_type_die (type_die
, type_cu
);
5303 return set_die_type (die
, type
, cu
);
5306 type
= alloc_type (objfile
);
5308 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
5309 name
= dwarf2_full_name (NULL
, die
, cu
);
5311 TYPE_TAG_NAME (type
) = (char *) name
;
5313 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
5316 TYPE_LENGTH (type
) = DW_UNSND (attr
);
5320 TYPE_LENGTH (type
) = 0;
5323 /* The enumeration DIE can be incomplete. In Ada, any type can be
5324 declared as private in the package spec, and then defined only
5325 inside the package body. Such types are known as Taft Amendment
5326 Types. When another package uses such a type, an incomplete DIE
5327 may be generated by the compiler. */
5328 if (die_is_declaration (die
, cu
))
5329 TYPE_STUB (type
) = 1;
5331 return set_die_type (die
, type
, cu
);
5334 /* Given a pointer to a die which begins an enumeration, process all
5335 the dies that define the members of the enumeration, and create the
5336 symbol for the enumeration type.
5338 NOTE: We reverse the order of the element list. */
5341 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
5343 struct objfile
*objfile
= cu
->objfile
;
5344 struct die_info
*child_die
;
5345 struct field
*fields
;
5348 int unsigned_enum
= 1;
5350 struct type
*this_type
;
5354 this_type
= get_die_type (die
, cu
);
5355 if (this_type
== NULL
)
5356 this_type
= read_enumeration_type (die
, cu
);
5357 if (die
->child
!= NULL
)
5359 child_die
= die
->child
;
5360 while (child_die
&& child_die
->tag
)
5362 if (child_die
->tag
!= DW_TAG_enumerator
)
5364 process_die (child_die
, cu
);
5368 name
= dwarf2_name (child_die
, cu
);
5371 sym
= new_symbol (child_die
, this_type
, cu
);
5372 if (SYMBOL_VALUE (sym
) < 0)
5375 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
5377 fields
= (struct field
*)
5379 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
5380 * sizeof (struct field
));
5383 FIELD_NAME (fields
[num_fields
]) = SYMBOL_LINKAGE_NAME (sym
);
5384 FIELD_TYPE (fields
[num_fields
]) = NULL
;
5385 SET_FIELD_BITPOS (fields
[num_fields
], SYMBOL_VALUE (sym
));
5386 FIELD_BITSIZE (fields
[num_fields
]) = 0;
5392 child_die
= sibling_die (child_die
);
5397 TYPE_NFIELDS (this_type
) = num_fields
;
5398 TYPE_FIELDS (this_type
) = (struct field
*)
5399 TYPE_ALLOC (this_type
, sizeof (struct field
) * num_fields
);
5400 memcpy (TYPE_FIELDS (this_type
), fields
,
5401 sizeof (struct field
) * num_fields
);
5405 TYPE_UNSIGNED (this_type
) = 1;
5408 new_symbol (die
, this_type
, cu
);
5411 /* Extract all information from a DW_TAG_array_type DIE and put it in
5412 the DIE's type field. For now, this only handles one dimensional
5415 static struct type
*
5416 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5418 struct objfile
*objfile
= cu
->objfile
;
5419 struct die_info
*child_die
;
5420 struct type
*type
= NULL
;
5421 struct type
*element_type
, *range_type
, *index_type
;
5422 struct type
**range_types
= NULL
;
5423 struct attribute
*attr
;
5425 struct cleanup
*back_to
;
5428 element_type
= die_type (die
, cu
);
5430 /* Irix 6.2 native cc creates array types without children for
5431 arrays with unspecified length. */
5432 if (die
->child
== NULL
)
5434 index_type
= objfile_type (objfile
)->builtin_int
;
5435 range_type
= create_range_type (NULL
, index_type
, 0, -1);
5436 type
= create_array_type (NULL
, element_type
, range_type
);
5437 return set_die_type (die
, type
, cu
);
5440 back_to
= make_cleanup (null_cleanup
, NULL
);
5441 child_die
= die
->child
;
5442 while (child_die
&& child_die
->tag
)
5444 if (child_die
->tag
== DW_TAG_subrange_type
)
5446 struct type
*child_type
= read_type_die (child_die
, cu
);
5447 if (child_type
!= NULL
)
5449 /* The range type was succesfully read. Save it for
5450 the array type creation. */
5451 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
5453 range_types
= (struct type
**)
5454 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
5455 * sizeof (struct type
*));
5457 make_cleanup (free_current_contents
, &range_types
);
5459 range_types
[ndim
++] = child_type
;
5462 child_die
= sibling_die (child_die
);
5465 /* Dwarf2 dimensions are output from left to right, create the
5466 necessary array types in backwards order. */
5468 type
= element_type
;
5470 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
5474 type
= create_array_type (NULL
, type
, range_types
[i
++]);
5479 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
5482 /* Understand Dwarf2 support for vector types (like they occur on
5483 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
5484 array type. This is not part of the Dwarf2/3 standard yet, but a
5485 custom vendor extension. The main difference between a regular
5486 array and the vector variant is that vectors are passed by value
5488 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
5490 make_vector_type (type
);
5492 name
= dwarf2_name (die
, cu
);
5494 TYPE_NAME (type
) = name
;
5496 set_descriptive_type (type
, die
, cu
);
5498 do_cleanups (back_to
);
5500 /* Install the type in the die. */
5501 return set_die_type (die
, type
, cu
);
5504 static enum dwarf_array_dim_ordering
5505 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
5507 struct attribute
*attr
;
5509 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
5511 if (attr
) return DW_SND (attr
);
5514 GNU F77 is a special case, as at 08/2004 array type info is the
5515 opposite order to the dwarf2 specification, but data is still
5516 laid out as per normal fortran.
5518 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
5522 if (cu
->language
== language_fortran
5523 && cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
5525 return DW_ORD_row_major
;
5528 switch (cu
->language_defn
->la_array_ordering
)
5530 case array_column_major
:
5531 return DW_ORD_col_major
;
5532 case array_row_major
:
5534 return DW_ORD_row_major
;
5538 /* Extract all information from a DW_TAG_set_type DIE and put it in
5539 the DIE's type field. */
5541 static struct type
*
5542 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5544 struct type
*set_type
= create_set_type (NULL
, die_type (die
, cu
));
5546 return set_die_type (die
, set_type
, cu
);
5549 /* First cut: install each common block member as a global variable. */
5552 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
5554 struct die_info
*child_die
;
5555 struct attribute
*attr
;
5557 CORE_ADDR base
= (CORE_ADDR
) 0;
5559 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
5562 /* Support the .debug_loc offsets */
5563 if (attr_form_is_block (attr
))
5565 base
= decode_locdesc (DW_BLOCK (attr
), cu
);
5567 else if (attr_form_is_section_offset (attr
))
5569 dwarf2_complex_location_expr_complaint ();
5573 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
5574 "common block member");
5577 if (die
->child
!= NULL
)
5579 child_die
= die
->child
;
5580 while (child_die
&& child_die
->tag
)
5582 sym
= new_symbol (child_die
, NULL
, cu
);
5583 attr
= dwarf2_attr (child_die
, DW_AT_data_member_location
, cu
);
5586 CORE_ADDR byte_offset
= 0;
5588 if (attr_form_is_section_offset (attr
))
5589 dwarf2_complex_location_expr_complaint ();
5590 else if (attr_form_is_constant (attr
))
5591 byte_offset
= dwarf2_get_attr_constant_value (attr
, 0);
5592 else if (attr_form_is_block (attr
))
5593 byte_offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
5595 dwarf2_complex_location_expr_complaint ();
5597 SYMBOL_VALUE_ADDRESS (sym
) = base
+ byte_offset
;
5598 add_symbol_to_list (sym
, &global_symbols
);
5600 child_die
= sibling_die (child_die
);
5605 /* Create a type for a C++ namespace. */
5607 static struct type
*
5608 read_namespace_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5610 struct objfile
*objfile
= cu
->objfile
;
5611 const char *previous_prefix
, *name
;
5615 /* For extensions, reuse the type of the original namespace. */
5616 if (dwarf2_attr (die
, DW_AT_extension
, cu
) != NULL
)
5618 struct die_info
*ext_die
;
5619 struct dwarf2_cu
*ext_cu
= cu
;
5620 ext_die
= dwarf2_extension (die
, &ext_cu
);
5621 type
= read_type_die (ext_die
, ext_cu
);
5622 return set_die_type (die
, type
, cu
);
5625 name
= namespace_name (die
, &is_anonymous
, cu
);
5627 /* Now build the name of the current namespace. */
5629 previous_prefix
= determine_prefix (die
, cu
);
5630 if (previous_prefix
[0] != '\0')
5631 name
= typename_concat (&objfile
->objfile_obstack
,
5632 previous_prefix
, name
, cu
);
5634 /* Create the type. */
5635 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0, NULL
,
5637 TYPE_NAME (type
) = (char *) name
;
5638 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
5640 set_die_type (die
, type
, cu
);
5645 /* Read a C++ namespace. */
5648 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
5650 struct objfile
*objfile
= cu
->objfile
;
5654 /* Add a symbol associated to this if we haven't seen the namespace
5655 before. Also, add a using directive if it's an anonymous
5658 if (dwarf2_attr (die
, DW_AT_extension
, cu
) == NULL
)
5662 type
= read_type_die (die
, cu
);
5663 new_symbol (die
, type
, cu
);
5665 name
= namespace_name (die
, &is_anonymous
, cu
);
5668 const char *previous_prefix
= determine_prefix (die
, cu
);
5669 cp_add_using_directive (previous_prefix
, TYPE_NAME (type
), NULL
,
5670 NULL
, &objfile
->objfile_obstack
);
5674 if (die
->child
!= NULL
)
5676 struct die_info
*child_die
= die
->child
;
5678 while (child_die
&& child_die
->tag
)
5680 process_die (child_die
, cu
);
5681 child_die
= sibling_die (child_die
);
5686 /* Read a Fortran module. */
5689 read_module (struct die_info
*die
, struct dwarf2_cu
*cu
)
5691 struct die_info
*child_die
= die
->child
;
5693 /* FIXME: Support the separate Fortran module namespaces. */
5695 while (child_die
&& child_die
->tag
)
5697 process_die (child_die
, cu
);
5698 child_die
= sibling_die (child_die
);
5702 /* Return the name of the namespace represented by DIE. Set
5703 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
5707 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
5709 struct die_info
*current_die
;
5710 const char *name
= NULL
;
5712 /* Loop through the extensions until we find a name. */
5714 for (current_die
= die
;
5715 current_die
!= NULL
;
5716 current_die
= dwarf2_extension (die
, &cu
))
5718 name
= dwarf2_name (current_die
, cu
);
5723 /* Is it an anonymous namespace? */
5725 *is_anonymous
= (name
== NULL
);
5727 name
= "(anonymous namespace)";
5732 /* Extract all information from a DW_TAG_pointer_type DIE and add to
5733 the user defined type vector. */
5735 static struct type
*
5736 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5738 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
5739 struct comp_unit_head
*cu_header
= &cu
->header
;
5741 struct attribute
*attr_byte_size
;
5742 struct attribute
*attr_address_class
;
5743 int byte_size
, addr_class
;
5745 type
= lookup_pointer_type (die_type (die
, cu
));
5747 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
5749 byte_size
= DW_UNSND (attr_byte_size
);
5751 byte_size
= cu_header
->addr_size
;
5753 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
5754 if (attr_address_class
)
5755 addr_class
= DW_UNSND (attr_address_class
);
5757 addr_class
= DW_ADDR_none
;
5759 /* If the pointer size or address class is different than the
5760 default, create a type variant marked as such and set the
5761 length accordingly. */
5762 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
5764 if (gdbarch_address_class_type_flags_p (gdbarch
))
5768 type_flags
= gdbarch_address_class_type_flags
5769 (gdbarch
, byte_size
, addr_class
);
5770 gdb_assert ((type_flags
& ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
5772 type
= make_type_with_address_space (type
, type_flags
);
5774 else if (TYPE_LENGTH (type
) != byte_size
)
5776 complaint (&symfile_complaints
, _("invalid pointer size %d"), byte_size
);
5779 /* Should we also complain about unhandled address classes? */
5783 TYPE_LENGTH (type
) = byte_size
;
5784 return set_die_type (die
, type
, cu
);
5787 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
5788 the user defined type vector. */
5790 static struct type
*
5791 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5793 struct objfile
*objfile
= cu
->objfile
;
5795 struct type
*to_type
;
5796 struct type
*domain
;
5798 to_type
= die_type (die
, cu
);
5799 domain
= die_containing_type (die
, cu
);
5801 if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_METHOD
)
5802 type
= lookup_methodptr_type (to_type
);
5804 type
= lookup_memberptr_type (to_type
, domain
);
5806 return set_die_type (die
, type
, cu
);
5809 /* Extract all information from a DW_TAG_reference_type DIE and add to
5810 the user defined type vector. */
5812 static struct type
*
5813 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5815 struct comp_unit_head
*cu_header
= &cu
->header
;
5817 struct attribute
*attr
;
5819 type
= lookup_reference_type (die_type (die
, cu
));
5820 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
5823 TYPE_LENGTH (type
) = DW_UNSND (attr
);
5827 TYPE_LENGTH (type
) = cu_header
->addr_size
;
5829 return set_die_type (die
, type
, cu
);
5832 static struct type
*
5833 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5835 struct type
*base_type
, *cv_type
;
5837 base_type
= die_type (die
, cu
);
5838 cv_type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
5839 return set_die_type (die
, cv_type
, cu
);
5842 static struct type
*
5843 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5845 struct type
*base_type
, *cv_type
;
5847 base_type
= die_type (die
, cu
);
5848 cv_type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
5849 return set_die_type (die
, cv_type
, cu
);
5852 /* Extract all information from a DW_TAG_string_type DIE and add to
5853 the user defined type vector. It isn't really a user defined type,
5854 but it behaves like one, with other DIE's using an AT_user_def_type
5855 attribute to reference it. */
5857 static struct type
*
5858 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5860 struct objfile
*objfile
= cu
->objfile
;
5861 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
5862 struct type
*type
, *range_type
, *index_type
, *char_type
;
5863 struct attribute
*attr
;
5864 unsigned int length
;
5866 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
5869 length
= DW_UNSND (attr
);
5873 /* check for the DW_AT_byte_size attribute */
5874 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
5877 length
= DW_UNSND (attr
);
5885 index_type
= objfile_type (objfile
)->builtin_int
;
5886 range_type
= create_range_type (NULL
, index_type
, 1, length
);
5887 char_type
= language_string_char_type (cu
->language_defn
, gdbarch
);
5888 type
= create_string_type (NULL
, char_type
, range_type
);
5890 return set_die_type (die
, type
, cu
);
5893 /* Handle DIES due to C code like:
5897 int (*funcp)(int a, long l);
5901 ('funcp' generates a DW_TAG_subroutine_type DIE)
5904 static struct type
*
5905 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5907 struct type
*type
; /* Type that this function returns */
5908 struct type
*ftype
; /* Function that returns above type */
5909 struct attribute
*attr
;
5911 type
= die_type (die
, cu
);
5912 ftype
= lookup_function_type (type
);
5914 /* All functions in C++, Pascal and Java have prototypes. */
5915 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
5916 if ((attr
&& (DW_UNSND (attr
) != 0))
5917 || cu
->language
== language_cplus
5918 || cu
->language
== language_java
5919 || cu
->language
== language_pascal
)
5920 TYPE_PROTOTYPED (ftype
) = 1;
5921 else if (producer_is_realview (cu
->producer
))
5922 /* RealView does not emit DW_AT_prototyped. We can not
5923 distinguish prototyped and unprototyped functions; default to
5924 prototyped, since that is more common in modern code (and
5925 RealView warns about unprototyped functions). */
5926 TYPE_PROTOTYPED (ftype
) = 1;
5928 /* Store the calling convention in the type if it's available in
5929 the subroutine die. Otherwise set the calling convention to
5930 the default value DW_CC_normal. */
5931 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
5932 TYPE_CALLING_CONVENTION (ftype
) = attr
? DW_UNSND (attr
) : DW_CC_normal
;
5934 /* We need to add the subroutine type to the die immediately so
5935 we don't infinitely recurse when dealing with parameters
5936 declared as the same subroutine type. */
5937 set_die_type (die
, ftype
, cu
);
5939 if (die
->child
!= NULL
)
5941 struct die_info
*child_die
;
5945 /* Count the number of parameters.
5946 FIXME: GDB currently ignores vararg functions, but knows about
5947 vararg member functions. */
5948 child_die
= die
->child
;
5949 while (child_die
&& child_die
->tag
)
5951 if (child_die
->tag
== DW_TAG_formal_parameter
)
5953 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
5954 TYPE_VARARGS (ftype
) = 1;
5955 child_die
= sibling_die (child_die
);
5958 /* Allocate storage for parameters and fill them in. */
5959 TYPE_NFIELDS (ftype
) = nparams
;
5960 TYPE_FIELDS (ftype
) = (struct field
*)
5961 TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
));
5963 child_die
= die
->child
;
5964 while (child_die
&& child_die
->tag
)
5966 if (child_die
->tag
== DW_TAG_formal_parameter
)
5968 /* Dwarf2 has no clean way to discern C++ static and non-static
5969 member functions. G++ helps GDB by marking the first
5970 parameter for non-static member functions (which is the
5971 this pointer) as artificial. We pass this information
5972 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
5973 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
5975 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
5978 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
5980 /* GCC/43521: In java, the formal parameter
5981 "this" is sometimes not marked with DW_AT_artificial. */
5982 if (cu
->language
== language_java
)
5984 const char *name
= dwarf2_name (child_die
, cu
);
5985 if (name
&& !strcmp (name
, "this"))
5986 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 1;
5989 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, cu
);
5992 child_die
= sibling_die (child_die
);
5999 static struct type
*
6000 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
6002 struct objfile
*objfile
= cu
->objfile
;
6003 struct attribute
*attr
;
6004 const char *name
= NULL
;
6005 struct type
*this_type
;
6007 name
= dwarf2_full_name (NULL
, die
, cu
);
6008 this_type
= init_type (TYPE_CODE_TYPEDEF
, 0,
6009 TYPE_FLAG_TARGET_STUB
, NULL
, objfile
);
6010 TYPE_NAME (this_type
) = (char *) name
;
6011 set_die_type (die
, this_type
, cu
);
6012 TYPE_TARGET_TYPE (this_type
) = die_type (die
, cu
);
6016 /* Find a representation of a given base type and install
6017 it in the TYPE field of the die. */
6019 static struct type
*
6020 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
6022 struct objfile
*objfile
= cu
->objfile
;
6024 struct attribute
*attr
;
6025 int encoding
= 0, size
= 0;
6027 enum type_code code
= TYPE_CODE_INT
;
6029 struct type
*target_type
= NULL
;
6031 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
6034 encoding
= DW_UNSND (attr
);
6036 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
6039 size
= DW_UNSND (attr
);
6041 name
= dwarf2_name (die
, cu
);
6044 complaint (&symfile_complaints
,
6045 _("DW_AT_name missing from DW_TAG_base_type"));
6050 case DW_ATE_address
:
6051 /* Turn DW_ATE_address into a void * pointer. */
6052 code
= TYPE_CODE_PTR
;
6053 type_flags
|= TYPE_FLAG_UNSIGNED
;
6054 target_type
= init_type (TYPE_CODE_VOID
, 1, 0, NULL
, objfile
);
6056 case DW_ATE_boolean
:
6057 code
= TYPE_CODE_BOOL
;
6058 type_flags
|= TYPE_FLAG_UNSIGNED
;
6060 case DW_ATE_complex_float
:
6061 code
= TYPE_CODE_COMPLEX
;
6062 target_type
= init_type (TYPE_CODE_FLT
, size
/ 2, 0, NULL
, objfile
);
6064 case DW_ATE_decimal_float
:
6065 code
= TYPE_CODE_DECFLOAT
;
6068 code
= TYPE_CODE_FLT
;
6072 case DW_ATE_unsigned
:
6073 type_flags
|= TYPE_FLAG_UNSIGNED
;
6075 case DW_ATE_signed_char
:
6076 if (cu
->language
== language_ada
|| cu
->language
== language_m2
6077 || cu
->language
== language_pascal
)
6078 code
= TYPE_CODE_CHAR
;
6080 case DW_ATE_unsigned_char
:
6081 if (cu
->language
== language_ada
|| cu
->language
== language_m2
6082 || cu
->language
== language_pascal
)
6083 code
= TYPE_CODE_CHAR
;
6084 type_flags
|= TYPE_FLAG_UNSIGNED
;
6087 complaint (&symfile_complaints
, _("unsupported DW_AT_encoding: '%s'"),
6088 dwarf_type_encoding_name (encoding
));
6092 type
= init_type (code
, size
, type_flags
, NULL
, objfile
);
6093 TYPE_NAME (type
) = name
;
6094 TYPE_TARGET_TYPE (type
) = target_type
;
6096 if (name
&& strcmp (name
, "char") == 0)
6097 TYPE_NOSIGN (type
) = 1;
6099 return set_die_type (die
, type
, cu
);
6102 /* Read the given DW_AT_subrange DIE. */
6104 static struct type
*
6105 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
6107 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
6108 struct type
*base_type
;
6109 struct type
*range_type
;
6110 struct attribute
*attr
;
6114 LONGEST negative_mask
;
6116 base_type
= die_type (die
, cu
);
6117 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
6119 complaint (&symfile_complaints
,
6120 _("DW_AT_type missing from DW_TAG_subrange_type"));
6122 = init_type (TYPE_CODE_INT
, gdbarch_addr_bit (gdbarch
) / 8,
6123 0, NULL
, cu
->objfile
);
6126 if (cu
->language
== language_fortran
)
6128 /* FORTRAN implies a lower bound of 1, if not given. */
6132 /* FIXME: For variable sized arrays either of these could be
6133 a variable rather than a constant value. We'll allow it,
6134 but we don't know how to handle it. */
6135 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
6137 low
= dwarf2_get_attr_constant_value (attr
, 0);
6139 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
6142 if (attr
->form
== DW_FORM_block1
)
6144 /* GCC encodes arrays with unspecified or dynamic length
6145 with a DW_FORM_block1 attribute.
6146 FIXME: GDB does not yet know how to handle dynamic
6147 arrays properly, treat them as arrays with unspecified
6150 FIXME: jimb/2003-09-22: GDB does not really know
6151 how to handle arrays of unspecified length
6152 either; we just represent them as zero-length
6153 arrays. Choose an appropriate upper bound given
6154 the lower bound we've computed above. */
6158 high
= dwarf2_get_attr_constant_value (attr
, 1);
6162 (LONGEST
) -1 << (TYPE_LENGTH (base_type
) * TARGET_CHAR_BIT
- 1);
6163 if (!TYPE_UNSIGNED (base_type
) && (low
& negative_mask
))
6164 low
|= negative_mask
;
6165 if (!TYPE_UNSIGNED (base_type
) && (high
& negative_mask
))
6166 high
|= negative_mask
;
6168 range_type
= create_range_type (NULL
, base_type
, low
, high
);
6170 /* Mark arrays with dynamic length at least as an array of unspecified
6171 length. GDB could check the boundary but before it gets implemented at
6172 least allow accessing the array elements. */
6173 if (attr
&& attr
->form
== DW_FORM_block1
)
6174 TYPE_HIGH_BOUND_UNDEFINED (range_type
) = 1;
6176 name
= dwarf2_name (die
, cu
);
6178 TYPE_NAME (range_type
) = name
;
6180 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
6182 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
6184 set_descriptive_type (range_type
, die
, cu
);
6186 return set_die_type (die
, range_type
, cu
);
6189 static struct type
*
6190 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
6194 /* For now, we only support the C meaning of an unspecified type: void. */
6196 type
= init_type (TYPE_CODE_VOID
, 0, 0, NULL
, cu
->objfile
);
6197 TYPE_NAME (type
) = dwarf2_name (die
, cu
);
6199 return set_die_type (die
, type
, cu
);
6202 /* Trivial hash function for die_info: the hash value of a DIE
6203 is its offset in .debug_info for this objfile. */
6206 die_hash (const void *item
)
6208 const struct die_info
*die
= item
;
6212 /* Trivial comparison function for die_info structures: two DIEs
6213 are equal if they have the same offset. */
6216 die_eq (const void *item_lhs
, const void *item_rhs
)
6218 const struct die_info
*die_lhs
= item_lhs
;
6219 const struct die_info
*die_rhs
= item_rhs
;
6220 return die_lhs
->offset
== die_rhs
->offset
;
6223 /* Read a whole compilation unit into a linked list of dies. */
6225 static struct die_info
*
6226 read_comp_unit (gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
6228 struct die_reader_specs reader_specs
;
6230 gdb_assert (cu
->die_hash
== NULL
);
6232 = htab_create_alloc_ex (cu
->header
.length
/ 12,
6236 &cu
->comp_unit_obstack
,
6237 hashtab_obstack_allocate
,
6238 dummy_obstack_deallocate
);
6240 init_cu_die_reader (&reader_specs
, cu
);
6242 return read_die_and_children (&reader_specs
, info_ptr
, &info_ptr
, NULL
);
6245 /* Main entry point for reading a DIE and all children.
6246 Read the DIE and dump it if requested. */
6248 static struct die_info
*
6249 read_die_and_children (const struct die_reader_specs
*reader
,
6251 gdb_byte
**new_info_ptr
,
6252 struct die_info
*parent
)
6254 struct die_info
*result
= read_die_and_children_1 (reader
, info_ptr
,
6255 new_info_ptr
, parent
);
6257 if (dwarf2_die_debug
)
6259 fprintf_unfiltered (gdb_stdlog
,
6260 "\nRead die from %s of %s:\n",
6261 reader
->buffer
== dwarf2_per_objfile
->info
.buffer
6263 : reader
->buffer
== dwarf2_per_objfile
->types
.buffer
6265 : "unknown section",
6266 reader
->abfd
->filename
);
6267 dump_die (result
, dwarf2_die_debug
);
6273 /* Read a single die and all its descendents. Set the die's sibling
6274 field to NULL; set other fields in the die correctly, and set all
6275 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
6276 location of the info_ptr after reading all of those dies. PARENT
6277 is the parent of the die in question. */
6279 static struct die_info
*
6280 read_die_and_children_1 (const struct die_reader_specs
*reader
,
6282 gdb_byte
**new_info_ptr
,
6283 struct die_info
*parent
)
6285 struct die_info
*die
;
6289 cur_ptr
= read_full_die (reader
, &die
, info_ptr
, &has_children
);
6292 *new_info_ptr
= cur_ptr
;
6295 store_in_ref_table (die
, reader
->cu
);
6298 die
->child
= read_die_and_siblings (reader
, cur_ptr
, new_info_ptr
, die
);
6302 *new_info_ptr
= cur_ptr
;
6305 die
->sibling
= NULL
;
6306 die
->parent
= parent
;
6310 /* Read a die, all of its descendents, and all of its siblings; set
6311 all of the fields of all of the dies correctly. Arguments are as
6312 in read_die_and_children. */
6314 static struct die_info
*
6315 read_die_and_siblings (const struct die_reader_specs
*reader
,
6317 gdb_byte
**new_info_ptr
,
6318 struct die_info
*parent
)
6320 struct die_info
*first_die
, *last_sibling
;
6324 first_die
= last_sibling
= NULL
;
6328 struct die_info
*die
6329 = read_die_and_children_1 (reader
, cur_ptr
, &cur_ptr
, parent
);
6333 *new_info_ptr
= cur_ptr
;
6340 last_sibling
->sibling
= die
;
6346 /* Read the die from the .debug_info section buffer. Set DIEP to
6347 point to a newly allocated die with its information, except for its
6348 child, sibling, and parent fields. Set HAS_CHILDREN to tell
6349 whether the die has children or not. */
6352 read_full_die (const struct die_reader_specs
*reader
,
6353 struct die_info
**diep
, gdb_byte
*info_ptr
,
6356 unsigned int abbrev_number
, bytes_read
, i
, offset
;
6357 struct abbrev_info
*abbrev
;
6358 struct die_info
*die
;
6359 struct dwarf2_cu
*cu
= reader
->cu
;
6360 bfd
*abfd
= reader
->abfd
;
6362 offset
= info_ptr
- reader
->buffer
;
6363 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
6364 info_ptr
+= bytes_read
;
6372 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
6374 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
6376 bfd_get_filename (abfd
));
6378 die
= dwarf_alloc_die (cu
, abbrev
->num_attrs
);
6379 die
->offset
= offset
;
6380 die
->tag
= abbrev
->tag
;
6381 die
->abbrev
= abbrev_number
;
6383 die
->num_attrs
= abbrev
->num_attrs
;
6385 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
6386 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
6387 abfd
, info_ptr
, cu
);
6390 *has_children
= abbrev
->has_children
;
6394 /* In DWARF version 2, the description of the debugging information is
6395 stored in a separate .debug_abbrev section. Before we read any
6396 dies from a section we read in all abbreviations and install them
6397 in a hash table. This function also sets flags in CU describing
6398 the data found in the abbrev table. */
6401 dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
)
6403 struct comp_unit_head
*cu_header
= &cu
->header
;
6404 gdb_byte
*abbrev_ptr
;
6405 struct abbrev_info
*cur_abbrev
;
6406 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
6407 unsigned int abbrev_form
, hash_number
;
6408 struct attr_abbrev
*cur_attrs
;
6409 unsigned int allocated_attrs
;
6411 /* Initialize dwarf2 abbrevs */
6412 obstack_init (&cu
->abbrev_obstack
);
6413 cu
->dwarf2_abbrevs
= obstack_alloc (&cu
->abbrev_obstack
,
6415 * sizeof (struct abbrev_info
*)));
6416 memset (cu
->dwarf2_abbrevs
, 0,
6417 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
6419 dwarf2_read_section (dwarf2_per_objfile
->objfile
,
6420 &dwarf2_per_objfile
->abbrev
);
6421 abbrev_ptr
= dwarf2_per_objfile
->abbrev
.buffer
+ cu_header
->abbrev_offset
;
6422 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
6423 abbrev_ptr
+= bytes_read
;
6425 allocated_attrs
= ATTR_ALLOC_CHUNK
;
6426 cur_attrs
= xmalloc (allocated_attrs
* sizeof (struct attr_abbrev
));
6428 /* loop until we reach an abbrev number of 0 */
6429 while (abbrev_number
)
6431 cur_abbrev
= dwarf_alloc_abbrev (cu
);
6433 /* read in abbrev header */
6434 cur_abbrev
->number
= abbrev_number
;
6435 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
6436 abbrev_ptr
+= bytes_read
;
6437 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
6440 if (cur_abbrev
->tag
== DW_TAG_namespace
)
6441 cu
->has_namespace_info
= 1;
6443 /* now read in declarations */
6444 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
6445 abbrev_ptr
+= bytes_read
;
6446 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
6447 abbrev_ptr
+= bytes_read
;
6450 if (cur_abbrev
->num_attrs
== allocated_attrs
)
6452 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
6454 = xrealloc (cur_attrs
, (allocated_attrs
6455 * sizeof (struct attr_abbrev
)));
6458 /* Record whether this compilation unit might have
6459 inter-compilation-unit references. If we don't know what form
6460 this attribute will have, then it might potentially be a
6461 DW_FORM_ref_addr, so we conservatively expect inter-CU
6464 if (abbrev_form
== DW_FORM_ref_addr
6465 || abbrev_form
== DW_FORM_indirect
)
6466 cu
->has_form_ref_addr
= 1;
6468 cur_attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
6469 cur_attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
6470 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
6471 abbrev_ptr
+= bytes_read
;
6472 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
6473 abbrev_ptr
+= bytes_read
;
6476 cur_abbrev
->attrs
= obstack_alloc (&cu
->abbrev_obstack
,
6477 (cur_abbrev
->num_attrs
6478 * sizeof (struct attr_abbrev
)));
6479 memcpy (cur_abbrev
->attrs
, cur_attrs
,
6480 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
6482 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
6483 cur_abbrev
->next
= cu
->dwarf2_abbrevs
[hash_number
];
6484 cu
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
6486 /* Get next abbreviation.
6487 Under Irix6 the abbreviations for a compilation unit are not
6488 always properly terminated with an abbrev number of 0.
6489 Exit loop if we encounter an abbreviation which we have
6490 already read (which means we are about to read the abbreviations
6491 for the next compile unit) or if the end of the abbreviation
6492 table is reached. */
6493 if ((unsigned int) (abbrev_ptr
- dwarf2_per_objfile
->abbrev
.buffer
)
6494 >= dwarf2_per_objfile
->abbrev
.size
)
6496 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
6497 abbrev_ptr
+= bytes_read
;
6498 if (dwarf2_lookup_abbrev (abbrev_number
, cu
) != NULL
)
6505 /* Release the memory used by the abbrev table for a compilation unit. */
6508 dwarf2_free_abbrev_table (void *ptr_to_cu
)
6510 struct dwarf2_cu
*cu
= ptr_to_cu
;
6512 obstack_free (&cu
->abbrev_obstack
, NULL
);
6513 cu
->dwarf2_abbrevs
= NULL
;
6516 /* Lookup an abbrev_info structure in the abbrev hash table. */
6518 static struct abbrev_info
*
6519 dwarf2_lookup_abbrev (unsigned int number
, struct dwarf2_cu
*cu
)
6521 unsigned int hash_number
;
6522 struct abbrev_info
*abbrev
;
6524 hash_number
= number
% ABBREV_HASH_SIZE
;
6525 abbrev
= cu
->dwarf2_abbrevs
[hash_number
];
6529 if (abbrev
->number
== number
)
6532 abbrev
= abbrev
->next
;
6537 /* Returns nonzero if TAG represents a type that we might generate a partial
6541 is_type_tag_for_partial (int tag
)
6546 /* Some types that would be reasonable to generate partial symbols for,
6547 that we don't at present. */
6548 case DW_TAG_array_type
:
6549 case DW_TAG_file_type
:
6550 case DW_TAG_ptr_to_member_type
:
6551 case DW_TAG_set_type
:
6552 case DW_TAG_string_type
:
6553 case DW_TAG_subroutine_type
:
6555 case DW_TAG_base_type
:
6556 case DW_TAG_class_type
:
6557 case DW_TAG_interface_type
:
6558 case DW_TAG_enumeration_type
:
6559 case DW_TAG_structure_type
:
6560 case DW_TAG_subrange_type
:
6561 case DW_TAG_typedef
:
6562 case DW_TAG_union_type
:
6569 /* Load all DIEs that are interesting for partial symbols into memory. */
6571 static struct partial_die_info
*
6572 load_partial_dies (bfd
*abfd
, gdb_byte
*buffer
, gdb_byte
*info_ptr
,
6573 int building_psymtab
, struct dwarf2_cu
*cu
)
6575 struct partial_die_info
*part_die
;
6576 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
6577 struct abbrev_info
*abbrev
;
6578 unsigned int bytes_read
;
6579 unsigned int load_all
= 0;
6581 int nesting_level
= 1;
6586 if (cu
->per_cu
&& cu
->per_cu
->load_all_dies
)
6590 = htab_create_alloc_ex (cu
->header
.length
/ 12,
6594 &cu
->comp_unit_obstack
,
6595 hashtab_obstack_allocate
,
6596 dummy_obstack_deallocate
);
6598 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
6599 sizeof (struct partial_die_info
));
6603 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
6605 /* A NULL abbrev means the end of a series of children. */
6608 if (--nesting_level
== 0)
6610 /* PART_DIE was probably the last thing allocated on the
6611 comp_unit_obstack, so we could call obstack_free
6612 here. We don't do that because the waste is small,
6613 and will be cleaned up when we're done with this
6614 compilation unit. This way, we're also more robust
6615 against other users of the comp_unit_obstack. */
6618 info_ptr
+= bytes_read
;
6619 last_die
= parent_die
;
6620 parent_die
= parent_die
->die_parent
;
6624 /* Check whether this DIE is interesting enough to save. Normally
6625 we would not be interested in members here, but there may be
6626 later variables referencing them via DW_AT_specification (for
6629 && !is_type_tag_for_partial (abbrev
->tag
)
6630 && abbrev
->tag
!= DW_TAG_enumerator
6631 && abbrev
->tag
!= DW_TAG_subprogram
6632 && abbrev
->tag
!= DW_TAG_lexical_block
6633 && abbrev
->tag
!= DW_TAG_variable
6634 && abbrev
->tag
!= DW_TAG_namespace
6635 && abbrev
->tag
!= DW_TAG_member
)
6637 /* Otherwise we skip to the next sibling, if any. */
6638 info_ptr
= skip_one_die (buffer
, info_ptr
+ bytes_read
, abbrev
, cu
);
6642 info_ptr
= read_partial_die (part_die
, abbrev
, bytes_read
, abfd
,
6643 buffer
, info_ptr
, cu
);
6645 /* This two-pass algorithm for processing partial symbols has a
6646 high cost in cache pressure. Thus, handle some simple cases
6647 here which cover the majority of C partial symbols. DIEs
6648 which neither have specification tags in them, nor could have
6649 specification tags elsewhere pointing at them, can simply be
6650 processed and discarded.
6652 This segment is also optional; scan_partial_symbols and
6653 add_partial_symbol will handle these DIEs if we chain
6654 them in normally. When compilers which do not emit large
6655 quantities of duplicate debug information are more common,
6656 this code can probably be removed. */
6658 /* Any complete simple types at the top level (pretty much all
6659 of them, for a language without namespaces), can be processed
6661 if (parent_die
== NULL
6662 && part_die
->has_specification
== 0
6663 && part_die
->is_declaration
== 0
6664 && (part_die
->tag
== DW_TAG_typedef
6665 || part_die
->tag
== DW_TAG_base_type
6666 || part_die
->tag
== DW_TAG_subrange_type
))
6668 if (building_psymtab
&& part_die
->name
!= NULL
)
6669 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
6670 VAR_DOMAIN
, LOC_TYPEDEF
,
6671 &cu
->objfile
->static_psymbols
,
6672 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
6673 info_ptr
= locate_pdi_sibling (part_die
, buffer
, info_ptr
, abfd
, cu
);
6677 /* If we're at the second level, and we're an enumerator, and
6678 our parent has no specification (meaning possibly lives in a
6679 namespace elsewhere), then we can add the partial symbol now
6680 instead of queueing it. */
6681 if (part_die
->tag
== DW_TAG_enumerator
6682 && parent_die
!= NULL
6683 && parent_die
->die_parent
== NULL
6684 && parent_die
->tag
== DW_TAG_enumeration_type
6685 && parent_die
->has_specification
== 0)
6687 if (part_die
->name
== NULL
)
6688 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
6689 else if (building_psymtab
)
6690 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
6691 VAR_DOMAIN
, LOC_CONST
,
6692 (cu
->language
== language_cplus
6693 || cu
->language
== language_java
)
6694 ? &cu
->objfile
->global_psymbols
6695 : &cu
->objfile
->static_psymbols
,
6696 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
6698 info_ptr
= locate_pdi_sibling (part_die
, buffer
, info_ptr
, abfd
, cu
);
6702 /* We'll save this DIE so link it in. */
6703 part_die
->die_parent
= parent_die
;
6704 part_die
->die_sibling
= NULL
;
6705 part_die
->die_child
= NULL
;
6707 if (last_die
&& last_die
== parent_die
)
6708 last_die
->die_child
= part_die
;
6710 last_die
->die_sibling
= part_die
;
6712 last_die
= part_die
;
6714 if (first_die
== NULL
)
6715 first_die
= part_die
;
6717 /* Maybe add the DIE to the hash table. Not all DIEs that we
6718 find interesting need to be in the hash table, because we
6719 also have the parent/sibling/child chains; only those that we
6720 might refer to by offset later during partial symbol reading.
6722 For now this means things that might have be the target of a
6723 DW_AT_specification, DW_AT_abstract_origin, or
6724 DW_AT_extension. DW_AT_extension will refer only to
6725 namespaces; DW_AT_abstract_origin refers to functions (and
6726 many things under the function DIE, but we do not recurse
6727 into function DIEs during partial symbol reading) and
6728 possibly variables as well; DW_AT_specification refers to
6729 declarations. Declarations ought to have the DW_AT_declaration
6730 flag. It happens that GCC forgets to put it in sometimes, but
6731 only for functions, not for types.
6733 Adding more things than necessary to the hash table is harmless
6734 except for the performance cost. Adding too few will result in
6735 wasted time in find_partial_die, when we reread the compilation
6736 unit with load_all_dies set. */
6739 || abbrev
->tag
== DW_TAG_subprogram
6740 || abbrev
->tag
== DW_TAG_variable
6741 || abbrev
->tag
== DW_TAG_namespace
6742 || part_die
->is_declaration
)
6746 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
6747 part_die
->offset
, INSERT
);
6751 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
6752 sizeof (struct partial_die_info
));
6754 /* For some DIEs we want to follow their children (if any). For C
6755 we have no reason to follow the children of structures; for other
6756 languages we have to, both so that we can get at method physnames
6757 to infer fully qualified class names, and for DW_AT_specification.
6759 For Ada, we need to scan the children of subprograms and lexical
6760 blocks as well because Ada allows the definition of nested
6761 entities that could be interesting for the debugger, such as
6762 nested subprograms for instance. */
6763 if (last_die
->has_children
6765 || last_die
->tag
== DW_TAG_namespace
6766 || last_die
->tag
== DW_TAG_enumeration_type
6767 || (cu
->language
!= language_c
6768 && (last_die
->tag
== DW_TAG_class_type
6769 || last_die
->tag
== DW_TAG_interface_type
6770 || last_die
->tag
== DW_TAG_structure_type
6771 || last_die
->tag
== DW_TAG_union_type
))
6772 || (cu
->language
== language_ada
6773 && (last_die
->tag
== DW_TAG_subprogram
6774 || last_die
->tag
== DW_TAG_lexical_block
))))
6777 parent_die
= last_die
;
6781 /* Otherwise we skip to the next sibling, if any. */
6782 info_ptr
= locate_pdi_sibling (last_die
, buffer
, info_ptr
, abfd
, cu
);
6784 /* Back to the top, do it again. */
6788 /* Read a minimal amount of information into the minimal die structure. */
6791 read_partial_die (struct partial_die_info
*part_die
,
6792 struct abbrev_info
*abbrev
,
6793 unsigned int abbrev_len
, bfd
*abfd
,
6794 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
6795 struct dwarf2_cu
*cu
)
6797 unsigned int bytes_read
, i
;
6798 struct attribute attr
;
6799 int has_low_pc_attr
= 0;
6800 int has_high_pc_attr
= 0;
6802 memset (part_die
, 0, sizeof (struct partial_die_info
));
6804 part_die
->offset
= info_ptr
- buffer
;
6806 info_ptr
+= abbrev_len
;
6811 part_die
->tag
= abbrev
->tag
;
6812 part_die
->has_children
= abbrev
->has_children
;
6814 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
6816 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
, info_ptr
, cu
);
6818 /* Store the data if it is of an attribute we want to keep in a
6819 partial symbol table. */
6823 switch (part_die
->tag
)
6825 case DW_TAG_compile_unit
:
6826 case DW_TAG_type_unit
:
6827 /* Compilation units have a DW_AT_name that is a filename, not
6828 a source language identifier. */
6829 case DW_TAG_enumeration_type
:
6830 case DW_TAG_enumerator
:
6831 /* These tags always have simple identifiers already; no need
6832 to canonicalize them. */
6833 part_die
->name
= DW_STRING (&attr
);
6837 = dwarf2_canonicalize_name (DW_STRING (&attr
), cu
,
6838 &cu
->objfile
->objfile_obstack
);
6842 case DW_AT_MIPS_linkage_name
:
6843 if (cu
->language
== language_ada
)
6844 part_die
->name
= DW_STRING (&attr
);
6847 has_low_pc_attr
= 1;
6848 part_die
->lowpc
= DW_ADDR (&attr
);
6851 has_high_pc_attr
= 1;
6852 part_die
->highpc
= DW_ADDR (&attr
);
6854 case DW_AT_location
:
6855 /* Support the .debug_loc offsets */
6856 if (attr_form_is_block (&attr
))
6858 part_die
->locdesc
= DW_BLOCK (&attr
);
6860 else if (attr_form_is_section_offset (&attr
))
6862 dwarf2_complex_location_expr_complaint ();
6866 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
6867 "partial symbol information");
6870 case DW_AT_external
:
6871 part_die
->is_external
= DW_UNSND (&attr
);
6873 case DW_AT_declaration
:
6874 part_die
->is_declaration
= DW_UNSND (&attr
);
6877 part_die
->has_type
= 1;
6879 case DW_AT_abstract_origin
:
6880 case DW_AT_specification
:
6881 case DW_AT_extension
:
6882 part_die
->has_specification
= 1;
6883 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
);
6886 /* Ignore absolute siblings, they might point outside of
6887 the current compile unit. */
6888 if (attr
.form
== DW_FORM_ref_addr
)
6889 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
6891 part_die
->sibling
= buffer
+ dwarf2_get_ref_die_offset (&attr
);
6893 case DW_AT_byte_size
:
6894 part_die
->has_byte_size
= 1;
6896 case DW_AT_calling_convention
:
6897 /* DWARF doesn't provide a way to identify a program's source-level
6898 entry point. DW_AT_calling_convention attributes are only meant
6899 to describe functions' calling conventions.
6901 However, because it's a necessary piece of information in
6902 Fortran, and because DW_CC_program is the only piece of debugging
6903 information whose definition refers to a 'main program' at all,
6904 several compilers have begun marking Fortran main programs with
6905 DW_CC_program --- even when those functions use the standard
6906 calling conventions.
6908 So until DWARF specifies a way to provide this information and
6909 compilers pick up the new representation, we'll support this
6911 if (DW_UNSND (&attr
) == DW_CC_program
6912 && cu
->language
== language_fortran
)
6913 set_main_name (part_die
->name
);
6920 /* When using the GNU linker, .gnu.linkonce. sections are used to
6921 eliminate duplicate copies of functions and vtables and such.
6922 The linker will arbitrarily choose one and discard the others.
6923 The AT_*_pc values for such functions refer to local labels in
6924 these sections. If the section from that file was discarded, the
6925 labels are not in the output, so the relocs get a value of 0.
6926 If this is a discarded function, mark the pc bounds as invalid,
6927 so that GDB will ignore it. */
6928 if (has_low_pc_attr
&& has_high_pc_attr
6929 && part_die
->lowpc
< part_die
->highpc
6930 && (part_die
->lowpc
!= 0
6931 || dwarf2_per_objfile
->has_section_at_zero
))
6932 part_die
->has_pc_info
= 1;
6937 /* Find a cached partial DIE at OFFSET in CU. */
6939 static struct partial_die_info
*
6940 find_partial_die_in_comp_unit (unsigned int offset
, struct dwarf2_cu
*cu
)
6942 struct partial_die_info
*lookup_die
= NULL
;
6943 struct partial_die_info part_die
;
6945 part_die
.offset
= offset
;
6946 lookup_die
= htab_find_with_hash (cu
->partial_dies
, &part_die
, offset
);
6951 /* Find a partial DIE at OFFSET, which may or may not be in CU,
6952 except in the case of .debug_types DIEs which do not reference
6953 outside their CU (they do however referencing other types via
6956 static struct partial_die_info
*
6957 find_partial_die (unsigned int offset
, struct dwarf2_cu
*cu
)
6959 struct dwarf2_per_cu_data
*per_cu
= NULL
;
6960 struct partial_die_info
*pd
= NULL
;
6962 if (cu
->per_cu
->from_debug_types
)
6964 pd
= find_partial_die_in_comp_unit (offset
, cu
);
6970 if (offset_in_cu_p (&cu
->header
, offset
))
6972 pd
= find_partial_die_in_comp_unit (offset
, cu
);
6977 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
6979 if (per_cu
->cu
== NULL
)
6981 load_partial_comp_unit (per_cu
, cu
->objfile
);
6982 per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
6983 dwarf2_per_objfile
->read_in_chain
= per_cu
;
6986 per_cu
->cu
->last_used
= 0;
6987 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
6989 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
6991 struct cleanup
*back_to
;
6992 struct partial_die_info comp_unit_die
;
6993 struct abbrev_info
*abbrev
;
6994 unsigned int bytes_read
;
6997 per_cu
->load_all_dies
= 1;
6999 /* Re-read the DIEs. */
7000 back_to
= make_cleanup (null_cleanup
, 0);
7001 if (per_cu
->cu
->dwarf2_abbrevs
== NULL
)
7003 dwarf2_read_abbrevs (per_cu
->cu
->objfile
->obfd
, per_cu
->cu
);
7004 make_cleanup (dwarf2_free_abbrev_table
, per_cu
->cu
);
7006 info_ptr
= (dwarf2_per_objfile
->info
.buffer
7007 + per_cu
->cu
->header
.offset
7008 + per_cu
->cu
->header
.first_die_offset
);
7009 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, per_cu
->cu
);
7010 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
7011 per_cu
->cu
->objfile
->obfd
,
7012 dwarf2_per_objfile
->info
.buffer
, info_ptr
,
7014 if (comp_unit_die
.has_children
)
7015 load_partial_dies (per_cu
->cu
->objfile
->obfd
,
7016 dwarf2_per_objfile
->info
.buffer
, info_ptr
,
7018 do_cleanups (back_to
);
7020 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
7026 internal_error (__FILE__
, __LINE__
,
7027 _("could not find partial DIE 0x%x in cache [from module %s]\n"),
7028 offset
, bfd_get_filename (cu
->objfile
->obfd
));
7032 /* Adjust PART_DIE before generating a symbol for it. This function
7033 may set the is_external flag or change the DIE's name. */
7036 fixup_partial_die (struct partial_die_info
*part_die
,
7037 struct dwarf2_cu
*cu
)
7039 /* If we found a reference attribute and the DIE has no name, try
7040 to find a name in the referred to DIE. */
7042 if (part_die
->name
== NULL
&& part_die
->has_specification
)
7044 struct partial_die_info
*spec_die
;
7046 spec_die
= find_partial_die (part_die
->spec_offset
, cu
);
7048 fixup_partial_die (spec_die
, cu
);
7052 part_die
->name
= spec_die
->name
;
7054 /* Copy DW_AT_external attribute if it is set. */
7055 if (spec_die
->is_external
)
7056 part_die
->is_external
= spec_die
->is_external
;
7060 /* Set default names for some unnamed DIEs. */
7061 if (part_die
->name
== NULL
&& (part_die
->tag
== DW_TAG_structure_type
7062 || part_die
->tag
== DW_TAG_class_type
))
7063 part_die
->name
= "(anonymous class)";
7065 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
7066 part_die
->name
= "(anonymous namespace)";
7068 if (part_die
->tag
== DW_TAG_structure_type
7069 || part_die
->tag
== DW_TAG_class_type
7070 || part_die
->tag
== DW_TAG_union_type
)
7071 guess_structure_name (part_die
, cu
);
7074 /* Read an attribute value described by an attribute form. */
7077 read_attribute_value (struct attribute
*attr
, unsigned form
,
7078 bfd
*abfd
, gdb_byte
*info_ptr
,
7079 struct dwarf2_cu
*cu
)
7081 struct comp_unit_head
*cu_header
= &cu
->header
;
7082 unsigned int bytes_read
;
7083 struct dwarf_block
*blk
;
7088 case DW_FORM_ref_addr
:
7089 if (cu
->header
.version
== 2)
7090 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
7092 DW_ADDR (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
7093 info_ptr
+= bytes_read
;
7096 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
7097 info_ptr
+= bytes_read
;
7099 case DW_FORM_block2
:
7100 blk
= dwarf_alloc_block (cu
);
7101 blk
->size
= read_2_bytes (abfd
, info_ptr
);
7103 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
7104 info_ptr
+= blk
->size
;
7105 DW_BLOCK (attr
) = blk
;
7107 case DW_FORM_block4
:
7108 blk
= dwarf_alloc_block (cu
);
7109 blk
->size
= read_4_bytes (abfd
, info_ptr
);
7111 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
7112 info_ptr
+= blk
->size
;
7113 DW_BLOCK (attr
) = blk
;
7116 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
7120 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
7124 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
7127 case DW_FORM_string
:
7128 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
7129 DW_STRING_IS_CANONICAL (attr
) = 0;
7130 info_ptr
+= bytes_read
;
7133 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
7135 DW_STRING_IS_CANONICAL (attr
) = 0;
7136 info_ptr
+= bytes_read
;
7139 blk
= dwarf_alloc_block (cu
);
7140 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
7141 info_ptr
+= bytes_read
;
7142 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
7143 info_ptr
+= blk
->size
;
7144 DW_BLOCK (attr
) = blk
;
7146 case DW_FORM_block1
:
7147 blk
= dwarf_alloc_block (cu
);
7148 blk
->size
= read_1_byte (abfd
, info_ptr
);
7150 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
7151 info_ptr
+= blk
->size
;
7152 DW_BLOCK (attr
) = blk
;
7155 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
7159 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
7163 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
7164 info_ptr
+= bytes_read
;
7167 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
7168 info_ptr
+= bytes_read
;
7171 DW_ADDR (attr
) = cu
->header
.offset
+ read_1_byte (abfd
, info_ptr
);
7175 DW_ADDR (attr
) = cu
->header
.offset
+ read_2_bytes (abfd
, info_ptr
);
7179 DW_ADDR (attr
) = cu
->header
.offset
+ read_4_bytes (abfd
, info_ptr
);
7183 DW_ADDR (attr
) = cu
->header
.offset
+ read_8_bytes (abfd
, info_ptr
);
7187 /* Convert the signature to something we can record in DW_UNSND
7189 NOTE: This is NULL if the type wasn't found. */
7190 DW_SIGNATURED_TYPE (attr
) =
7191 lookup_signatured_type (cu
->objfile
, read_8_bytes (abfd
, info_ptr
));
7194 case DW_FORM_ref_udata
:
7195 DW_ADDR (attr
) = (cu
->header
.offset
7196 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
7197 info_ptr
+= bytes_read
;
7199 case DW_FORM_indirect
:
7200 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
7201 info_ptr
+= bytes_read
;
7202 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu
);
7205 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
7206 dwarf_form_name (form
),
7207 bfd_get_filename (abfd
));
7210 /* We have seen instances where the compiler tried to emit a byte
7211 size attribute of -1 which ended up being encoded as an unsigned
7212 0xffffffff. Although 0xffffffff is technically a valid size value,
7213 an object of this size seems pretty unlikely so we can relatively
7214 safely treat these cases as if the size attribute was invalid and
7215 treat them as zero by default. */
7216 if (attr
->name
== DW_AT_byte_size
7217 && form
== DW_FORM_data4
7218 && DW_UNSND (attr
) >= 0xffffffff)
7221 (&symfile_complaints
,
7222 _("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
7223 hex_string (DW_UNSND (attr
)));
7224 DW_UNSND (attr
) = 0;
7230 /* Read an attribute described by an abbreviated attribute. */
7233 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
7234 bfd
*abfd
, gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
7236 attr
->name
= abbrev
->name
;
7237 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu
);
7240 /* read dwarf information from a buffer */
7243 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
7245 return bfd_get_8 (abfd
, buf
);
7249 read_1_signed_byte (bfd
*abfd
, gdb_byte
*buf
)
7251 return bfd_get_signed_8 (abfd
, buf
);
7255 read_2_bytes (bfd
*abfd
, gdb_byte
*buf
)
7257 return bfd_get_16 (abfd
, buf
);
7261 read_2_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
7263 return bfd_get_signed_16 (abfd
, buf
);
7267 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
7269 return bfd_get_32 (abfd
, buf
);
7273 read_4_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
7275 return bfd_get_signed_32 (abfd
, buf
);
7279 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
7281 return bfd_get_64 (abfd
, buf
);
7285 read_address (bfd
*abfd
, gdb_byte
*buf
, struct dwarf2_cu
*cu
,
7286 unsigned int *bytes_read
)
7288 struct comp_unit_head
*cu_header
= &cu
->header
;
7289 CORE_ADDR retval
= 0;
7291 if (cu_header
->signed_addr_p
)
7293 switch (cu_header
->addr_size
)
7296 retval
= bfd_get_signed_16 (abfd
, buf
);
7299 retval
= bfd_get_signed_32 (abfd
, buf
);
7302 retval
= bfd_get_signed_64 (abfd
, buf
);
7305 internal_error (__FILE__
, __LINE__
,
7306 _("read_address: bad switch, signed [in module %s]"),
7307 bfd_get_filename (abfd
));
7312 switch (cu_header
->addr_size
)
7315 retval
= bfd_get_16 (abfd
, buf
);
7318 retval
= bfd_get_32 (abfd
, buf
);
7321 retval
= bfd_get_64 (abfd
, buf
);
7324 internal_error (__FILE__
, __LINE__
,
7325 _("read_address: bad switch, unsigned [in module %s]"),
7326 bfd_get_filename (abfd
));
7330 *bytes_read
= cu_header
->addr_size
;
7334 /* Read the initial length from a section. The (draft) DWARF 3
7335 specification allows the initial length to take up either 4 bytes
7336 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
7337 bytes describe the length and all offsets will be 8 bytes in length
7340 An older, non-standard 64-bit format is also handled by this
7341 function. The older format in question stores the initial length
7342 as an 8-byte quantity without an escape value. Lengths greater
7343 than 2^32 aren't very common which means that the initial 4 bytes
7344 is almost always zero. Since a length value of zero doesn't make
7345 sense for the 32-bit format, this initial zero can be considered to
7346 be an escape value which indicates the presence of the older 64-bit
7347 format. As written, the code can't detect (old format) lengths
7348 greater than 4GB. If it becomes necessary to handle lengths
7349 somewhat larger than 4GB, we could allow other small values (such
7350 as the non-sensical values of 1, 2, and 3) to also be used as
7351 escape values indicating the presence of the old format.
7353 The value returned via bytes_read should be used to increment the
7354 relevant pointer after calling read_initial_length().
7356 [ Note: read_initial_length() and read_offset() are based on the
7357 document entitled "DWARF Debugging Information Format", revision
7358 3, draft 8, dated November 19, 2001. This document was obtained
7361 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
7363 This document is only a draft and is subject to change. (So beware.)
7365 Details regarding the older, non-standard 64-bit format were
7366 determined empirically by examining 64-bit ELF files produced by
7367 the SGI toolchain on an IRIX 6.5 machine.
7369 - Kevin, July 16, 2002
7373 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read
)
7375 LONGEST length
= bfd_get_32 (abfd
, buf
);
7377 if (length
== 0xffffffff)
7379 length
= bfd_get_64 (abfd
, buf
+ 4);
7382 else if (length
== 0)
7384 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
7385 length
= bfd_get_64 (abfd
, buf
);
7396 /* Cover function for read_initial_length.
7397 Returns the length of the object at BUF, and stores the size of the
7398 initial length in *BYTES_READ and stores the size that offsets will be in
7400 If the initial length size is not equivalent to that specified in
7401 CU_HEADER then issue a complaint.
7402 This is useful when reading non-comp-unit headers. */
7405 read_checked_initial_length_and_offset (bfd
*abfd
, gdb_byte
*buf
,
7406 const struct comp_unit_head
*cu_header
,
7407 unsigned int *bytes_read
,
7408 unsigned int *offset_size
)
7410 LONGEST length
= read_initial_length (abfd
, buf
, bytes_read
);
7412 gdb_assert (cu_header
->initial_length_size
== 4
7413 || cu_header
->initial_length_size
== 8
7414 || cu_header
->initial_length_size
== 12);
7416 if (cu_header
->initial_length_size
!= *bytes_read
)
7417 complaint (&symfile_complaints
,
7418 _("intermixed 32-bit and 64-bit DWARF sections"));
7420 *offset_size
= (*bytes_read
== 4) ? 4 : 8;
7424 /* Read an offset from the data stream. The size of the offset is
7425 given by cu_header->offset_size. */
7428 read_offset (bfd
*abfd
, gdb_byte
*buf
, const struct comp_unit_head
*cu_header
,
7429 unsigned int *bytes_read
)
7431 LONGEST offset
= read_offset_1 (abfd
, buf
, cu_header
->offset_size
);
7432 *bytes_read
= cu_header
->offset_size
;
7436 /* Read an offset from the data stream. */
7439 read_offset_1 (bfd
*abfd
, gdb_byte
*buf
, unsigned int offset_size
)
7443 switch (offset_size
)
7446 retval
= bfd_get_32 (abfd
, buf
);
7449 retval
= bfd_get_64 (abfd
, buf
);
7452 internal_error (__FILE__
, __LINE__
,
7453 _("read_offset_1: bad switch [in module %s]"),
7454 bfd_get_filename (abfd
));
7461 read_n_bytes (bfd
*abfd
, gdb_byte
*buf
, unsigned int size
)
7463 /* If the size of a host char is 8 bits, we can return a pointer
7464 to the buffer, otherwise we have to copy the data to a buffer
7465 allocated on the temporary obstack. */
7466 gdb_assert (HOST_CHAR_BIT
== 8);
7471 read_string (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
7473 /* If the size of a host char is 8 bits, we can return a pointer
7474 to the string, otherwise we have to copy the string to a buffer
7475 allocated on the temporary obstack. */
7476 gdb_assert (HOST_CHAR_BIT
== 8);
7479 *bytes_read_ptr
= 1;
7482 *bytes_read_ptr
= strlen ((char *) buf
) + 1;
7483 return (char *) buf
;
7487 read_indirect_string (bfd
*abfd
, gdb_byte
*buf
,
7488 const struct comp_unit_head
*cu_header
,
7489 unsigned int *bytes_read_ptr
)
7491 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
, bytes_read_ptr
);
7493 dwarf2_read_section (dwarf2_per_objfile
->objfile
, &dwarf2_per_objfile
->str
);
7494 if (dwarf2_per_objfile
->str
.buffer
== NULL
)
7496 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
7497 bfd_get_filename (abfd
));
7500 if (str_offset
>= dwarf2_per_objfile
->str
.size
)
7502 error (_("DW_FORM_strp pointing outside of .debug_str section [in module %s]"),
7503 bfd_get_filename (abfd
));
7506 gdb_assert (HOST_CHAR_BIT
== 8);
7507 if (dwarf2_per_objfile
->str
.buffer
[str_offset
] == '\0')
7509 return (char *) (dwarf2_per_objfile
->str
.buffer
+ str_offset
);
7512 static unsigned long
7513 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
7515 unsigned long result
;
7516 unsigned int num_read
;
7526 byte
= bfd_get_8 (abfd
, buf
);
7529 result
|= ((unsigned long)(byte
& 127) << shift
);
7530 if ((byte
& 128) == 0)
7536 *bytes_read_ptr
= num_read
;
7541 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
7544 int i
, shift
, num_read
;
7553 byte
= bfd_get_8 (abfd
, buf
);
7556 result
|= ((long)(byte
& 127) << shift
);
7558 if ((byte
& 128) == 0)
7563 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
7564 result
|= -(((long)1) << shift
);
7565 *bytes_read_ptr
= num_read
;
7569 /* Return a pointer to just past the end of an LEB128 number in BUF. */
7572 skip_leb128 (bfd
*abfd
, gdb_byte
*buf
)
7578 byte
= bfd_get_8 (abfd
, buf
);
7580 if ((byte
& 128) == 0)
7586 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
7593 cu
->language
= language_c
;
7595 case DW_LANG_C_plus_plus
:
7596 cu
->language
= language_cplus
;
7598 case DW_LANG_Fortran77
:
7599 case DW_LANG_Fortran90
:
7600 case DW_LANG_Fortran95
:
7601 cu
->language
= language_fortran
;
7603 case DW_LANG_Mips_Assembler
:
7604 cu
->language
= language_asm
;
7607 cu
->language
= language_java
;
7611 cu
->language
= language_ada
;
7613 case DW_LANG_Modula2
:
7614 cu
->language
= language_m2
;
7616 case DW_LANG_Pascal83
:
7617 cu
->language
= language_pascal
;
7620 cu
->language
= language_objc
;
7622 case DW_LANG_Cobol74
:
7623 case DW_LANG_Cobol85
:
7625 cu
->language
= language_minimal
;
7628 cu
->language_defn
= language_def (cu
->language
);
7631 /* Return the named attribute or NULL if not there. */
7633 static struct attribute
*
7634 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
7637 struct attribute
*spec
= NULL
;
7639 for (i
= 0; i
< die
->num_attrs
; ++i
)
7641 if (die
->attrs
[i
].name
== name
)
7642 return &die
->attrs
[i
];
7643 if (die
->attrs
[i
].name
== DW_AT_specification
7644 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
7645 spec
= &die
->attrs
[i
];
7650 die
= follow_die_ref (die
, spec
, &cu
);
7651 return dwarf2_attr (die
, name
, cu
);
7657 /* Return the named attribute or NULL if not there,
7658 but do not follow DW_AT_specification, etc.
7659 This is for use in contexts where we're reading .debug_types dies.
7660 Following DW_AT_specification, DW_AT_abstract_origin will take us
7661 back up the chain, and we want to go down. */
7663 static struct attribute
*
7664 dwarf2_attr_no_follow (struct die_info
*die
, unsigned int name
,
7665 struct dwarf2_cu
*cu
)
7669 for (i
= 0; i
< die
->num_attrs
; ++i
)
7670 if (die
->attrs
[i
].name
== name
)
7671 return &die
->attrs
[i
];
7676 /* Return non-zero iff the attribute NAME is defined for the given DIE,
7677 and holds a non-zero value. This function should only be used for
7678 DW_FORM_flag attributes. */
7681 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
7683 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
7685 return (attr
&& DW_UNSND (attr
));
7689 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
7691 /* A DIE is a declaration if it has a DW_AT_declaration attribute
7692 which value is non-zero. However, we have to be careful with
7693 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
7694 (via dwarf2_flag_true_p) follows this attribute. So we may
7695 end up accidently finding a declaration attribute that belongs
7696 to a different DIE referenced by the specification attribute,
7697 even though the given DIE does not have a declaration attribute. */
7698 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
7699 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
7702 /* Return the die giving the specification for DIE, if there is
7703 one. *SPEC_CU is the CU containing DIE on input, and the CU
7704 containing the return value on output. If there is no
7705 specification, but there is an abstract origin, that is
7708 static struct die_info
*
7709 die_specification (struct die_info
*die
, struct dwarf2_cu
**spec_cu
)
7711 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
,
7714 if (spec_attr
== NULL
)
7715 spec_attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, *spec_cu
);
7717 if (spec_attr
== NULL
)
7720 return follow_die_ref (die
, spec_attr
, spec_cu
);
7723 /* Free the line_header structure *LH, and any arrays and strings it
7726 free_line_header (struct line_header
*lh
)
7728 if (lh
->standard_opcode_lengths
)
7729 xfree (lh
->standard_opcode_lengths
);
7731 /* Remember that all the lh->file_names[i].name pointers are
7732 pointers into debug_line_buffer, and don't need to be freed. */
7734 xfree (lh
->file_names
);
7736 /* Similarly for the include directory names. */
7737 if (lh
->include_dirs
)
7738 xfree (lh
->include_dirs
);
7744 /* Add an entry to LH's include directory table. */
7746 add_include_dir (struct line_header
*lh
, char *include_dir
)
7748 /* Grow the array if necessary. */
7749 if (lh
->include_dirs_size
== 0)
7751 lh
->include_dirs_size
= 1; /* for testing */
7752 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
7753 * sizeof (*lh
->include_dirs
));
7755 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
7757 lh
->include_dirs_size
*= 2;
7758 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
7759 (lh
->include_dirs_size
7760 * sizeof (*lh
->include_dirs
)));
7763 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
7767 /* Add an entry to LH's file name table. */
7769 add_file_name (struct line_header
*lh
,
7771 unsigned int dir_index
,
7772 unsigned int mod_time
,
7773 unsigned int length
)
7775 struct file_entry
*fe
;
7777 /* Grow the array if necessary. */
7778 if (lh
->file_names_size
== 0)
7780 lh
->file_names_size
= 1; /* for testing */
7781 lh
->file_names
= xmalloc (lh
->file_names_size
7782 * sizeof (*lh
->file_names
));
7784 else if (lh
->num_file_names
>= lh
->file_names_size
)
7786 lh
->file_names_size
*= 2;
7787 lh
->file_names
= xrealloc (lh
->file_names
,
7788 (lh
->file_names_size
7789 * sizeof (*lh
->file_names
)));
7792 fe
= &lh
->file_names
[lh
->num_file_names
++];
7794 fe
->dir_index
= dir_index
;
7795 fe
->mod_time
= mod_time
;
7796 fe
->length
= length
;
7802 /* Read the statement program header starting at OFFSET in
7803 .debug_line, according to the endianness of ABFD. Return a pointer
7804 to a struct line_header, allocated using xmalloc.
7806 NOTE: the strings in the include directory and file name tables of
7807 the returned object point into debug_line_buffer, and must not be
7809 static struct line_header
*
7810 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
7811 struct dwarf2_cu
*cu
)
7813 struct cleanup
*back_to
;
7814 struct line_header
*lh
;
7816 unsigned int bytes_read
, offset_size
;
7818 char *cur_dir
, *cur_file
;
7820 dwarf2_read_section (dwarf2_per_objfile
->objfile
, &dwarf2_per_objfile
->line
);
7821 if (dwarf2_per_objfile
->line
.buffer
== NULL
)
7823 complaint (&symfile_complaints
, _("missing .debug_line section"));
7827 /* Make sure that at least there's room for the total_length field.
7828 That could be 12 bytes long, but we're just going to fudge that. */
7829 if (offset
+ 4 >= dwarf2_per_objfile
->line
.size
)
7831 dwarf2_statement_list_fits_in_line_number_section_complaint ();
7835 lh
= xmalloc (sizeof (*lh
));
7836 memset (lh
, 0, sizeof (*lh
));
7837 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
7840 line_ptr
= dwarf2_per_objfile
->line
.buffer
+ offset
;
7842 /* Read in the header. */
7844 read_checked_initial_length_and_offset (abfd
, line_ptr
, &cu
->header
,
7845 &bytes_read
, &offset_size
);
7846 line_ptr
+= bytes_read
;
7847 if (line_ptr
+ lh
->total_length
> (dwarf2_per_objfile
->line
.buffer
7848 + dwarf2_per_objfile
->line
.size
))
7850 dwarf2_statement_list_fits_in_line_number_section_complaint ();
7853 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
7854 lh
->version
= read_2_bytes (abfd
, line_ptr
);
7856 lh
->header_length
= read_offset_1 (abfd
, line_ptr
, offset_size
);
7857 line_ptr
+= offset_size
;
7858 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
7860 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
7862 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
7864 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
7866 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
7868 lh
->standard_opcode_lengths
7869 = xmalloc (lh
->opcode_base
* sizeof (lh
->standard_opcode_lengths
[0]));
7871 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
7872 for (i
= 1; i
< lh
->opcode_base
; ++i
)
7874 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
7878 /* Read directory table. */
7879 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
7881 line_ptr
+= bytes_read
;
7882 add_include_dir (lh
, cur_dir
);
7884 line_ptr
+= bytes_read
;
7886 /* Read file name table. */
7887 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
7889 unsigned int dir_index
, mod_time
, length
;
7891 line_ptr
+= bytes_read
;
7892 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
7893 line_ptr
+= bytes_read
;
7894 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
7895 line_ptr
+= bytes_read
;
7896 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
7897 line_ptr
+= bytes_read
;
7899 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
7901 line_ptr
+= bytes_read
;
7902 lh
->statement_program_start
= line_ptr
;
7904 if (line_ptr
> (dwarf2_per_objfile
->line
.buffer
7905 + dwarf2_per_objfile
->line
.size
))
7906 complaint (&symfile_complaints
,
7907 _("line number info header doesn't fit in `.debug_line' section"));
7909 discard_cleanups (back_to
);
7913 /* This function exists to work around a bug in certain compilers
7914 (particularly GCC 2.95), in which the first line number marker of a
7915 function does not show up until after the prologue, right before
7916 the second line number marker. This function shifts ADDRESS down
7917 to the beginning of the function if necessary, and is called on
7918 addresses passed to record_line. */
7921 check_cu_functions (CORE_ADDR address
, struct dwarf2_cu
*cu
)
7923 struct function_range
*fn
;
7925 /* Find the function_range containing address. */
7930 cu
->cached_fn
= cu
->first_fn
;
7934 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
7940 while (fn
&& fn
!= cu
->cached_fn
)
7941 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
7951 if (address
!= fn
->lowpc
)
7952 complaint (&symfile_complaints
,
7953 _("misplaced first line number at 0x%lx for '%s'"),
7954 (unsigned long) address
, fn
->name
);
7959 /* Decode the Line Number Program (LNP) for the given line_header
7960 structure and CU. The actual information extracted and the type
7961 of structures created from the LNP depends on the value of PST.
7963 1. If PST is NULL, then this procedure uses the data from the program
7964 to create all necessary symbol tables, and their linetables.
7965 The compilation directory of the file is passed in COMP_DIR,
7966 and must not be NULL.
7968 2. If PST is not NULL, this procedure reads the program to determine
7969 the list of files included by the unit represented by PST, and
7970 builds all the associated partial symbol tables. In this case,
7971 the value of COMP_DIR is ignored, and can thus be NULL (the COMP_DIR
7972 is not used to compute the full name of the symtab, and therefore
7973 omitting it when building the partial symtab does not introduce
7974 the potential for inconsistency - a partial symtab and its associated
7975 symbtab having a different fullname -). */
7978 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
7979 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
)
7981 gdb_byte
*line_ptr
, *extended_end
;
7983 unsigned int bytes_read
, extended_len
;
7984 unsigned char op_code
, extended_op
, adj_opcode
;
7986 struct objfile
*objfile
= cu
->objfile
;
7987 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
7988 const int decode_for_pst_p
= (pst
!= NULL
);
7989 struct subfile
*last_subfile
= NULL
, *first_subfile
= current_subfile
;
7991 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
7993 line_ptr
= lh
->statement_program_start
;
7994 line_end
= lh
->statement_program_end
;
7996 /* Read the statement sequences until there's nothing left. */
7997 while (line_ptr
< line_end
)
7999 /* state machine registers */
8000 CORE_ADDR address
= 0;
8001 unsigned int file
= 1;
8002 unsigned int line
= 1;
8003 unsigned int column
= 0;
8004 int is_stmt
= lh
->default_is_stmt
;
8005 int basic_block
= 0;
8006 int end_sequence
= 0;
8009 if (!decode_for_pst_p
&& lh
->num_file_names
>= file
)
8011 /* Start a subfile for the current file of the state machine. */
8012 /* lh->include_dirs and lh->file_names are 0-based, but the
8013 directory and file name numbers in the statement program
8015 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
8019 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
8021 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
8024 /* Decode the table. */
8025 while (!end_sequence
)
8027 op_code
= read_1_byte (abfd
, line_ptr
);
8029 if (line_ptr
> line_end
)
8031 dwarf2_debug_line_missing_end_sequence_complaint ();
8035 if (op_code
>= lh
->opcode_base
)
8037 /* Special operand. */
8038 adj_opcode
= op_code
- lh
->opcode_base
;
8039 address
+= (adj_opcode
/ lh
->line_range
)
8040 * lh
->minimum_instruction_length
;
8041 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
8042 if (lh
->num_file_names
< file
|| file
== 0)
8043 dwarf2_debug_line_missing_file_complaint ();
8046 lh
->file_names
[file
- 1].included_p
= 1;
8047 if (!decode_for_pst_p
&& is_stmt
)
8049 if (last_subfile
!= current_subfile
)
8051 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
8053 record_line (last_subfile
, 0, addr
);
8054 last_subfile
= current_subfile
;
8056 /* Append row to matrix using current values. */
8057 addr
= check_cu_functions (address
, cu
);
8058 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
8059 record_line (current_subfile
, line
, addr
);
8064 else switch (op_code
)
8066 case DW_LNS_extended_op
:
8067 extended_len
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
8068 line_ptr
+= bytes_read
;
8069 extended_end
= line_ptr
+ extended_len
;
8070 extended_op
= read_1_byte (abfd
, line_ptr
);
8072 switch (extended_op
)
8074 case DW_LNE_end_sequence
:
8077 case DW_LNE_set_address
:
8078 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
8079 line_ptr
+= bytes_read
;
8080 address
+= baseaddr
;
8082 case DW_LNE_define_file
:
8085 unsigned int dir_index
, mod_time
, length
;
8087 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
8088 line_ptr
+= bytes_read
;
8090 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
8091 line_ptr
+= bytes_read
;
8093 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
8094 line_ptr
+= bytes_read
;
8096 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
8097 line_ptr
+= bytes_read
;
8098 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
8101 case DW_LNE_set_discriminator
:
8102 /* The discriminator is not interesting to the debugger;
8104 line_ptr
= extended_end
;
8107 complaint (&symfile_complaints
,
8108 _("mangled .debug_line section"));
8111 /* Make sure that we parsed the extended op correctly. If e.g.
8112 we expected a different address size than the producer used,
8113 we may have read the wrong number of bytes. */
8114 if (line_ptr
!= extended_end
)
8116 complaint (&symfile_complaints
,
8117 _("mangled .debug_line section"));
8122 if (lh
->num_file_names
< file
|| file
== 0)
8123 dwarf2_debug_line_missing_file_complaint ();
8126 lh
->file_names
[file
- 1].included_p
= 1;
8127 if (!decode_for_pst_p
&& is_stmt
)
8129 if (last_subfile
!= current_subfile
)
8131 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
8133 record_line (last_subfile
, 0, addr
);
8134 last_subfile
= current_subfile
;
8136 addr
= check_cu_functions (address
, cu
);
8137 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
8138 record_line (current_subfile
, line
, addr
);
8143 case DW_LNS_advance_pc
:
8144 address
+= lh
->minimum_instruction_length
8145 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
8146 line_ptr
+= bytes_read
;
8148 case DW_LNS_advance_line
:
8149 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
8150 line_ptr
+= bytes_read
;
8152 case DW_LNS_set_file
:
8154 /* The arrays lh->include_dirs and lh->file_names are
8155 0-based, but the directory and file name numbers in
8156 the statement program are 1-based. */
8157 struct file_entry
*fe
;
8160 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
8161 line_ptr
+= bytes_read
;
8162 if (lh
->num_file_names
< file
|| file
== 0)
8163 dwarf2_debug_line_missing_file_complaint ();
8166 fe
= &lh
->file_names
[file
- 1];
8168 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
8169 if (!decode_for_pst_p
)
8171 last_subfile
= current_subfile
;
8172 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
8177 case DW_LNS_set_column
:
8178 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
8179 line_ptr
+= bytes_read
;
8181 case DW_LNS_negate_stmt
:
8182 is_stmt
= (!is_stmt
);
8184 case DW_LNS_set_basic_block
:
8187 /* Add to the address register of the state machine the
8188 address increment value corresponding to special opcode
8189 255. I.e., this value is scaled by the minimum
8190 instruction length since special opcode 255 would have
8191 scaled the the increment. */
8192 case DW_LNS_const_add_pc
:
8193 address
+= (lh
->minimum_instruction_length
8194 * ((255 - lh
->opcode_base
) / lh
->line_range
));
8196 case DW_LNS_fixed_advance_pc
:
8197 address
+= read_2_bytes (abfd
, line_ptr
);
8202 /* Unknown standard opcode, ignore it. */
8205 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
8207 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
8208 line_ptr
+= bytes_read
;
8213 if (lh
->num_file_names
< file
|| file
== 0)
8214 dwarf2_debug_line_missing_file_complaint ();
8217 lh
->file_names
[file
- 1].included_p
= 1;
8218 if (!decode_for_pst_p
)
8220 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
8221 record_line (current_subfile
, 0, addr
);
8226 if (decode_for_pst_p
)
8230 /* Now that we're done scanning the Line Header Program, we can
8231 create the psymtab of each included file. */
8232 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
8233 if (lh
->file_names
[file_index
].included_p
== 1)
8235 const struct file_entry fe
= lh
->file_names
[file_index
];
8236 char *include_name
= fe
.name
;
8237 char *dir_name
= NULL
;
8238 char *pst_filename
= pst
->filename
;
8241 dir_name
= lh
->include_dirs
[fe
.dir_index
- 1];
8243 if (!IS_ABSOLUTE_PATH (include_name
) && dir_name
!= NULL
)
8245 include_name
= concat (dir_name
, SLASH_STRING
,
8246 include_name
, (char *)NULL
);
8247 make_cleanup (xfree
, include_name
);
8250 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
8252 pst_filename
= concat (pst
->dirname
, SLASH_STRING
,
8253 pst_filename
, (char *)NULL
);
8254 make_cleanup (xfree
, pst_filename
);
8257 if (strcmp (include_name
, pst_filename
) != 0)
8258 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
8263 /* Make sure a symtab is created for every file, even files
8264 which contain only variables (i.e. no code with associated
8268 struct file_entry
*fe
;
8270 for (i
= 0; i
< lh
->num_file_names
; i
++)
8273 fe
= &lh
->file_names
[i
];
8275 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
8276 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
8278 /* Skip the main file; we don't need it, and it must be
8279 allocated last, so that it will show up before the
8280 non-primary symtabs in the objfile's symtab list. */
8281 if (current_subfile
== first_subfile
)
8284 if (current_subfile
->symtab
== NULL
)
8285 current_subfile
->symtab
= allocate_symtab (current_subfile
->name
,
8287 fe
->symtab
= current_subfile
->symtab
;
8292 /* Start a subfile for DWARF. FILENAME is the name of the file and
8293 DIRNAME the name of the source directory which contains FILENAME
8294 or NULL if not known. COMP_DIR is the compilation directory for the
8295 linetable's compilation unit or NULL if not known.
8296 This routine tries to keep line numbers from identical absolute and
8297 relative file names in a common subfile.
8299 Using the `list' example from the GDB testsuite, which resides in
8300 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
8301 of /srcdir/list0.c yields the following debugging information for list0.c:
8303 DW_AT_name: /srcdir/list0.c
8304 DW_AT_comp_dir: /compdir
8305 files.files[0].name: list0.h
8306 files.files[0].dir: /srcdir
8307 files.files[1].name: list0.c
8308 files.files[1].dir: /srcdir
8310 The line number information for list0.c has to end up in a single
8311 subfile, so that `break /srcdir/list0.c:1' works as expected.
8312 start_subfile will ensure that this happens provided that we pass the
8313 concatenation of files.files[1].dir and files.files[1].name as the
8317 dwarf2_start_subfile (char *filename
, char *dirname
, char *comp_dir
)
8321 /* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir).
8322 `start_symtab' will always pass the contents of DW_AT_comp_dir as
8323 second argument to start_subfile. To be consistent, we do the
8324 same here. In order not to lose the line information directory,
8325 we concatenate it to the filename when it makes sense.
8326 Note that the Dwarf3 standard says (speaking of filenames in line
8327 information): ``The directory index is ignored for file names
8328 that represent full path names''. Thus ignoring dirname in the
8329 `else' branch below isn't an issue. */
8331 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
8332 fullname
= concat (dirname
, SLASH_STRING
, filename
, (char *)NULL
);
8334 fullname
= filename
;
8336 start_subfile (fullname
, comp_dir
);
8338 if (fullname
!= filename
)
8343 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
8344 struct dwarf2_cu
*cu
)
8346 struct objfile
*objfile
= cu
->objfile
;
8347 struct comp_unit_head
*cu_header
= &cu
->header
;
8349 /* NOTE drow/2003-01-30: There used to be a comment and some special
8350 code here to turn a symbol with DW_AT_external and a
8351 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
8352 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
8353 with some versions of binutils) where shared libraries could have
8354 relocations against symbols in their debug information - the
8355 minimal symbol would have the right address, but the debug info
8356 would not. It's no longer necessary, because we will explicitly
8357 apply relocations when we read in the debug information now. */
8359 /* A DW_AT_location attribute with no contents indicates that a
8360 variable has been optimized away. */
8361 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
8363 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
8367 /* Handle one degenerate form of location expression specially, to
8368 preserve GDB's previous behavior when section offsets are
8369 specified. If this is just a DW_OP_addr then mark this symbol
8372 if (attr_form_is_block (attr
)
8373 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
8374 && DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
8378 SYMBOL_VALUE_ADDRESS (sym
) =
8379 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
8380 SYMBOL_CLASS (sym
) = LOC_STATIC
;
8381 fixup_symbol_section (sym
, objfile
);
8382 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
8383 SYMBOL_SECTION (sym
));
8387 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
8388 expression evaluator, and use LOC_COMPUTED only when necessary
8389 (i.e. when the value of a register or memory location is
8390 referenced, or a thread-local block, etc.). Then again, it might
8391 not be worthwhile. I'm assuming that it isn't unless performance
8392 or memory numbers show me otherwise. */
8394 dwarf2_symbol_mark_computed (attr
, sym
, cu
);
8395 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
8398 /* Given a pointer to a DWARF information entry, figure out if we need
8399 to make a symbol table entry for it, and if so, create a new entry
8400 and return a pointer to it.
8401 If TYPE is NULL, determine symbol type from the die, otherwise
8402 used the passed type. */
8404 static struct symbol
*
8405 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
8407 struct objfile
*objfile
= cu
->objfile
;
8408 struct symbol
*sym
= NULL
;
8410 struct attribute
*attr
= NULL
;
8411 struct attribute
*attr2
= NULL
;
8413 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
8415 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
8417 name
= dwarf2_name (die
, cu
);
8420 const char *linkagename
;
8422 sym
= (struct symbol
*) obstack_alloc (&objfile
->objfile_obstack
,
8423 sizeof (struct symbol
));
8424 OBJSTAT (objfile
, n_syms
++);
8425 memset (sym
, 0, sizeof (struct symbol
));
8427 /* Cache this symbol's name and the name's demangled form (if any). */
8428 SYMBOL_LANGUAGE (sym
) = cu
->language
;
8429 linkagename
= dwarf2_physname (name
, die
, cu
);
8430 SYMBOL_SET_NAMES (sym
, linkagename
, strlen (linkagename
), 0, objfile
);
8432 /* Default assumptions.
8433 Use the passed type or decode it from the die. */
8434 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
8435 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
8437 SYMBOL_TYPE (sym
) = type
;
8439 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
8440 attr
= dwarf2_attr (die
,
8441 inlined_func
? DW_AT_call_line
: DW_AT_decl_line
,
8445 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
8448 attr
= dwarf2_attr (die
,
8449 inlined_func
? DW_AT_call_file
: DW_AT_decl_file
,
8453 int file_index
= DW_UNSND (attr
);
8454 if (cu
->line_header
== NULL
8455 || file_index
> cu
->line_header
->num_file_names
)
8456 complaint (&symfile_complaints
,
8457 _("file index out of range"));
8458 else if (file_index
> 0)
8460 struct file_entry
*fe
;
8461 fe
= &cu
->line_header
->file_names
[file_index
- 1];
8462 SYMBOL_SYMTAB (sym
) = fe
->symtab
;
8469 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
8472 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
8474 SYMBOL_CLASS (sym
) = LOC_LABEL
;
8476 case DW_TAG_subprogram
:
8477 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
8479 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
8480 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
8481 if ((attr2
&& (DW_UNSND (attr2
) != 0))
8482 || cu
->language
== language_ada
)
8484 /* Subprograms marked external are stored as a global symbol.
8485 Ada subprograms, whether marked external or not, are always
8486 stored as a global symbol, because we want to be able to
8487 access them globally. For instance, we want to be able
8488 to break on a nested subprogram without having to
8489 specify the context. */
8490 add_symbol_to_list (sym
, &global_symbols
);
8494 add_symbol_to_list (sym
, cu
->list_in_scope
);
8497 case DW_TAG_inlined_subroutine
:
8498 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
8500 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
8501 SYMBOL_INLINED (sym
) = 1;
8502 /* Do not add the symbol to any lists. It will be found via
8503 BLOCK_FUNCTION from the blockvector. */
8505 case DW_TAG_variable
:
8506 /* Compilation with minimal debug info may result in variables
8507 with missing type entries. Change the misleading `void' type
8508 to something sensible. */
8509 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
8511 = objfile_type (objfile
)->nodebug_data_symbol
;
8513 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
8516 dwarf2_const_value (attr
, sym
, cu
);
8517 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
8518 if (attr2
&& (DW_UNSND (attr2
) != 0))
8519 add_symbol_to_list (sym
, &global_symbols
);
8521 add_symbol_to_list (sym
, cu
->list_in_scope
);
8524 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
8527 var_decode_location (attr
, sym
, cu
);
8528 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
8529 if (attr2
&& (DW_UNSND (attr2
) != 0))
8531 struct pending
**list_to_add
;
8533 /* A variable with DW_AT_external is never static,
8534 but it may be block-scoped. */
8535 list_to_add
= (cu
->list_in_scope
== &file_symbols
8536 ? &global_symbols
: cu
->list_in_scope
);
8537 add_symbol_to_list (sym
, list_to_add
);
8540 add_symbol_to_list (sym
, cu
->list_in_scope
);
8544 /* We do not know the address of this symbol.
8545 If it is an external symbol and we have type information
8546 for it, enter the symbol as a LOC_UNRESOLVED symbol.
8547 The address of the variable will then be determined from
8548 the minimal symbol table whenever the variable is
8550 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
8551 if (attr2
&& (DW_UNSND (attr2
) != 0)
8552 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
8554 struct pending
**list_to_add
;
8556 /* A variable with DW_AT_external is never static, but it
8557 may be block-scoped. */
8558 list_to_add
= (cu
->list_in_scope
== &file_symbols
8559 ? &global_symbols
: cu
->list_in_scope
);
8561 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
8562 add_symbol_to_list (sym
, list_to_add
);
8564 else if (!die_is_declaration (die
, cu
))
8566 /* Use the default LOC_OPTIMIZED_OUT class. */
8567 gdb_assert (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
);
8568 add_symbol_to_list (sym
, cu
->list_in_scope
);
8572 case DW_TAG_formal_parameter
:
8573 /* If we are inside a function, mark this as an argument. If
8574 not, we might be looking at an argument to an inlined function
8575 when we do not have enough information to show inlined frames;
8576 pretend it's a local variable in that case so that the user can
8578 if (context_stack_depth
> 0
8579 && context_stack
[context_stack_depth
- 1].name
!= NULL
)
8580 SYMBOL_IS_ARGUMENT (sym
) = 1;
8581 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
8584 var_decode_location (attr
, sym
, cu
);
8586 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
8589 dwarf2_const_value (attr
, sym
, cu
);
8591 add_symbol_to_list (sym
, cu
->list_in_scope
);
8593 case DW_TAG_unspecified_parameters
:
8594 /* From varargs functions; gdb doesn't seem to have any
8595 interest in this information, so just ignore it for now.
8598 case DW_TAG_class_type
:
8599 case DW_TAG_interface_type
:
8600 case DW_TAG_structure_type
:
8601 case DW_TAG_union_type
:
8602 case DW_TAG_set_type
:
8603 case DW_TAG_enumeration_type
:
8604 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
8605 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
8607 /* Make sure that the symbol includes appropriate enclosing
8608 classes/namespaces in its name. These are calculated in
8609 read_structure_type, and the correct name is saved in
8612 if (cu
->language
== language_cplus
8613 || cu
->language
== language_java
)
8615 struct type
*type
= SYMBOL_TYPE (sym
);
8617 if (TYPE_TAG_NAME (type
) != NULL
)
8619 /* FIXME: carlton/2003-11-10: Should this use
8620 SYMBOL_SET_NAMES instead? (The same problem also
8621 arises further down in this function.) */
8622 /* The type's name is already allocated along with
8623 this objfile, so we don't need to duplicate it
8625 SYMBOL_LINKAGE_NAME (sym
) = TYPE_TAG_NAME (type
);
8630 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
8631 really ever be static objects: otherwise, if you try
8632 to, say, break of a class's method and you're in a file
8633 which doesn't mention that class, it won't work unless
8634 the check for all static symbols in lookup_symbol_aux
8635 saves you. See the OtherFileClass tests in
8636 gdb.c++/namespace.exp. */
8638 struct pending
**list_to_add
;
8640 list_to_add
= (cu
->list_in_scope
== &file_symbols
8641 && (cu
->language
== language_cplus
8642 || cu
->language
== language_java
)
8643 ? &global_symbols
: cu
->list_in_scope
);
8645 add_symbol_to_list (sym
, list_to_add
);
8647 /* The semantics of C++ state that "struct foo { ... }" also
8648 defines a typedef for "foo". A Java class declaration also
8649 defines a typedef for the class. */
8650 if (cu
->language
== language_cplus
8651 || cu
->language
== language_java
8652 || cu
->language
== language_ada
)
8654 /* The symbol's name is already allocated along with
8655 this objfile, so we don't need to duplicate it for
8657 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
8658 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
8662 case DW_TAG_typedef
:
8663 SYMBOL_LINKAGE_NAME (sym
)
8664 = (char *) dwarf2_full_name (name
, die
, cu
);
8665 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
8666 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
8667 add_symbol_to_list (sym
, cu
->list_in_scope
);
8669 case DW_TAG_base_type
:
8670 case DW_TAG_subrange_type
:
8671 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
8672 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
8673 add_symbol_to_list (sym
, cu
->list_in_scope
);
8675 case DW_TAG_enumerator
:
8676 SYMBOL_LINKAGE_NAME (sym
)
8677 = (char *) dwarf2_full_name (name
, die
, cu
);
8678 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
8681 dwarf2_const_value (attr
, sym
, cu
);
8684 /* NOTE: carlton/2003-11-10: See comment above in the
8685 DW_TAG_class_type, etc. block. */
8687 struct pending
**list_to_add
;
8689 list_to_add
= (cu
->list_in_scope
== &file_symbols
8690 && (cu
->language
== language_cplus
8691 || cu
->language
== language_java
)
8692 ? &global_symbols
: cu
->list_in_scope
);
8694 add_symbol_to_list (sym
, list_to_add
);
8697 case DW_TAG_namespace
:
8698 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
8699 add_symbol_to_list (sym
, &global_symbols
);
8702 /* Not a tag we recognize. Hopefully we aren't processing
8703 trash data, but since we must specifically ignore things
8704 we don't recognize, there is nothing else we should do at
8706 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
8707 dwarf_tag_name (die
->tag
));
8711 /* For the benefit of old versions of GCC, check for anonymous
8712 namespaces based on the demangled name. */
8713 if (!processing_has_namespace_info
8714 && cu
->language
== language_cplus
)
8715 cp_scan_for_anonymous_namespaces (sym
);
8720 /* Copy constant value from an attribute to a symbol. */
8723 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
8724 struct dwarf2_cu
*cu
)
8726 struct objfile
*objfile
= cu
->objfile
;
8727 struct comp_unit_head
*cu_header
= &cu
->header
;
8728 enum bfd_endian byte_order
= bfd_big_endian (objfile
->obfd
) ?
8729 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
8730 struct dwarf_block
*blk
;
8735 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
8736 dwarf2_const_value_length_mismatch_complaint (SYMBOL_PRINT_NAME (sym
),
8737 cu_header
->addr_size
,
8738 TYPE_LENGTH (SYMBOL_TYPE
8740 SYMBOL_VALUE_BYTES (sym
) =
8741 obstack_alloc (&objfile
->objfile_obstack
, cu_header
->addr_size
);
8742 /* NOTE: cagney/2003-05-09: In-lined store_address call with
8743 it's body - store_unsigned_integer. */
8744 store_unsigned_integer (SYMBOL_VALUE_BYTES (sym
), cu_header
->addr_size
,
8745 byte_order
, DW_ADDR (attr
));
8746 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
8748 case DW_FORM_string
:
8750 /* DW_STRING is already allocated on the obstack, point directly
8752 SYMBOL_VALUE_BYTES (sym
) = (gdb_byte
*) DW_STRING (attr
);
8753 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
8755 case DW_FORM_block1
:
8756 case DW_FORM_block2
:
8757 case DW_FORM_block4
:
8759 blk
= DW_BLOCK (attr
);
8760 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
8761 dwarf2_const_value_length_mismatch_complaint (SYMBOL_PRINT_NAME (sym
),
8763 TYPE_LENGTH (SYMBOL_TYPE
8765 SYMBOL_VALUE_BYTES (sym
) =
8766 obstack_alloc (&objfile
->objfile_obstack
, blk
->size
);
8767 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
8768 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
8771 /* The DW_AT_const_value attributes are supposed to carry the
8772 symbol's value "represented as it would be on the target
8773 architecture." By the time we get here, it's already been
8774 converted to host endianness, so we just need to sign- or
8775 zero-extend it as appropriate. */
8777 dwarf2_const_value_data (attr
, sym
, 8);
8780 dwarf2_const_value_data (attr
, sym
, 16);
8783 dwarf2_const_value_data (attr
, sym
, 32);
8786 dwarf2_const_value_data (attr
, sym
, 64);
8790 SYMBOL_VALUE (sym
) = DW_SND (attr
);
8791 SYMBOL_CLASS (sym
) = LOC_CONST
;
8795 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
8796 SYMBOL_CLASS (sym
) = LOC_CONST
;
8800 complaint (&symfile_complaints
,
8801 _("unsupported const value attribute form: '%s'"),
8802 dwarf_form_name (attr
->form
));
8803 SYMBOL_VALUE (sym
) = 0;
8804 SYMBOL_CLASS (sym
) = LOC_CONST
;
8810 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
8811 or zero-extend it as appropriate for the symbol's type. */
8813 dwarf2_const_value_data (struct attribute
*attr
,
8817 LONGEST l
= DW_UNSND (attr
);
8819 if (bits
< sizeof (l
) * 8)
8821 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
8822 l
&= ((LONGEST
) 1 << bits
) - 1;
8824 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
8827 SYMBOL_VALUE (sym
) = l
;
8828 SYMBOL_CLASS (sym
) = LOC_CONST
;
8832 /* Return the type of the die in question using its DW_AT_type attribute. */
8834 static struct type
*
8835 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8838 struct attribute
*type_attr
;
8839 struct die_info
*type_die
;
8841 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
8844 /* A missing DW_AT_type represents a void type. */
8845 return objfile_type (cu
->objfile
)->builtin_void
;
8848 type_die
= follow_die_ref_or_sig (die
, type_attr
, &cu
);
8850 type
= tag_type_to_type (type_die
, cu
);
8853 dump_die_for_error (type_die
);
8854 error (_("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]"),
8860 /* True iff CU's producer generates GNAT Ada auxiliary information
8861 that allows to find parallel types through that information instead
8862 of having to do expensive parallel lookups by type name. */
8865 need_gnat_info (struct dwarf2_cu
*cu
)
8867 /* FIXME: brobecker/2010-10-12: As of now, only the AdaCore version
8868 of GNAT produces this auxiliary information, without any indication
8869 that it is produced. Part of enhancing the FSF version of GNAT
8870 to produce that information will be to put in place an indicator
8871 that we can use in order to determine whether the descriptive type
8872 info is available or not. One suggestion that has been made is
8873 to use a new attribute, attached to the CU die. For now, assume
8874 that the descriptive type info is not available. */
8879 /* Return the auxiliary type of the die in question using its
8880 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
8881 attribute is not present. */
8883 static struct type
*
8884 die_descriptive_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8887 struct attribute
*type_attr
;
8888 struct die_info
*type_die
;
8890 type_attr
= dwarf2_attr (die
, DW_AT_GNAT_descriptive_type
, cu
);
8894 type_die
= follow_die_ref (die
, type_attr
, &cu
);
8895 type
= tag_type_to_type (type_die
, cu
);
8898 dump_die_for_error (type_die
);
8899 error (_("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]"),
8905 /* If DIE has a descriptive_type attribute, then set the TYPE's
8906 descriptive type accordingly. */
8909 set_descriptive_type (struct type
*type
, struct die_info
*die
,
8910 struct dwarf2_cu
*cu
)
8912 struct type
*descriptive_type
= die_descriptive_type (die
, cu
);
8914 if (descriptive_type
)
8916 ALLOCATE_GNAT_AUX_TYPE (type
);
8917 TYPE_DESCRIPTIVE_TYPE (type
) = descriptive_type
;
8921 /* Return the containing type of the die in question using its
8922 DW_AT_containing_type attribute. */
8924 static struct type
*
8925 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8927 struct type
*type
= NULL
;
8928 struct attribute
*type_attr
;
8929 struct die_info
*type_die
= NULL
;
8931 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
8934 type_die
= follow_die_ref_or_sig (die
, type_attr
, &cu
);
8935 type
= tag_type_to_type (type_die
, cu
);
8940 dump_die_for_error (type_die
);
8941 error (_("Dwarf Error: Problem turning containing type into gdb type [in module %s]"),
8947 static struct type
*
8948 tag_type_to_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8950 struct type
*this_type
;
8952 this_type
= read_type_die (die
, cu
);
8955 dump_die_for_error (die
);
8956 error (_("Dwarf Error: Cannot find type of die [in module %s]"),
8962 static struct type
*
8963 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
8965 struct type
*this_type
;
8967 this_type
= get_die_type (die
, cu
);
8973 case DW_TAG_class_type
:
8974 case DW_TAG_interface_type
:
8975 case DW_TAG_structure_type
:
8976 case DW_TAG_union_type
:
8977 this_type
= read_structure_type (die
, cu
);
8979 case DW_TAG_enumeration_type
:
8980 this_type
= read_enumeration_type (die
, cu
);
8982 case DW_TAG_subprogram
:
8983 case DW_TAG_subroutine_type
:
8984 case DW_TAG_inlined_subroutine
:
8985 this_type
= read_subroutine_type (die
, cu
);
8987 case DW_TAG_array_type
:
8988 this_type
= read_array_type (die
, cu
);
8990 case DW_TAG_set_type
:
8991 this_type
= read_set_type (die
, cu
);
8993 case DW_TAG_pointer_type
:
8994 this_type
= read_tag_pointer_type (die
, cu
);
8996 case DW_TAG_ptr_to_member_type
:
8997 this_type
= read_tag_ptr_to_member_type (die
, cu
);
8999 case DW_TAG_reference_type
:
9000 this_type
= read_tag_reference_type (die
, cu
);
9002 case DW_TAG_const_type
:
9003 this_type
= read_tag_const_type (die
, cu
);
9005 case DW_TAG_volatile_type
:
9006 this_type
= read_tag_volatile_type (die
, cu
);
9008 case DW_TAG_string_type
:
9009 this_type
= read_tag_string_type (die
, cu
);
9011 case DW_TAG_typedef
:
9012 this_type
= read_typedef (die
, cu
);
9014 case DW_TAG_subrange_type
:
9015 this_type
= read_subrange_type (die
, cu
);
9017 case DW_TAG_base_type
:
9018 this_type
= read_base_type (die
, cu
);
9020 case DW_TAG_unspecified_type
:
9021 this_type
= read_unspecified_type (die
, cu
);
9023 case DW_TAG_namespace
:
9024 this_type
= read_namespace_type (die
, cu
);
9027 complaint (&symfile_complaints
, _("unexpected tag in read_type_die: '%s'"),
9028 dwarf_tag_name (die
->tag
));
9035 /* Return the name of the namespace/class that DIE is defined within,
9036 or "" if we can't tell. The caller should not xfree the result.
9038 For example, if we're within the method foo() in the following
9048 then determine_prefix on foo's die will return "N::C". */
9051 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
9053 struct die_info
*parent
, *spec_die
;
9054 struct dwarf2_cu
*spec_cu
;
9055 struct type
*parent_type
;
9057 if (cu
->language
!= language_cplus
9058 && cu
->language
!= language_java
)
9061 /* We have to be careful in the presence of DW_AT_specification.
9062 For example, with GCC 3.4, given the code
9066 // Definition of N::foo.
9070 then we'll have a tree of DIEs like this:
9072 1: DW_TAG_compile_unit
9073 2: DW_TAG_namespace // N
9074 3: DW_TAG_subprogram // declaration of N::foo
9075 4: DW_TAG_subprogram // definition of N::foo
9076 DW_AT_specification // refers to die #3
9078 Thus, when processing die #4, we have to pretend that we're in
9079 the context of its DW_AT_specification, namely the contex of die
9082 spec_die
= die_specification (die
, &spec_cu
);
9083 if (spec_die
== NULL
)
9084 parent
= die
->parent
;
9087 parent
= spec_die
->parent
;
9094 switch (parent
->tag
)
9096 case DW_TAG_namespace
:
9097 parent_type
= read_type_die (parent
, cu
);
9098 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
9099 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
9100 Work around this problem here. */
9101 if (cu
->language
== language_cplus
9102 && strcmp (TYPE_TAG_NAME (parent_type
), "::") == 0)
9104 /* We give a name to even anonymous namespaces. */
9105 return TYPE_TAG_NAME (parent_type
);
9106 case DW_TAG_class_type
:
9107 case DW_TAG_interface_type
:
9108 case DW_TAG_structure_type
:
9109 case DW_TAG_union_type
:
9110 parent_type
= read_type_die (parent
, cu
);
9111 if (TYPE_TAG_NAME (parent_type
) != NULL
)
9112 return TYPE_TAG_NAME (parent_type
);
9114 /* An anonymous structure is only allowed non-static data
9115 members; no typedefs, no member functions, et cetera.
9116 So it does not need a prefix. */
9119 return determine_prefix (parent
, cu
);
9123 /* Return a newly-allocated string formed by concatenating PREFIX and
9124 SUFFIX with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
9125 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null,
9126 perform an obconcat, otherwise allocate storage for the result. The CU argument
9127 is used to determine the language and hence, the appropriate separator. */
9129 #define MAX_SEP_LEN 2 /* sizeof ("::") */
9132 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
9133 struct dwarf2_cu
*cu
)
9137 if (suffix
== NULL
|| suffix
[0] == '\0' || prefix
== NULL
|| prefix
[0] == '\0')
9139 else if (cu
->language
== language_java
)
9151 char *retval
= xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1);
9152 strcpy (retval
, prefix
);
9153 strcat (retval
, sep
);
9154 strcat (retval
, suffix
);
9159 /* We have an obstack. */
9160 return obconcat (obs
, prefix
, sep
, suffix
);
9164 /* Return sibling of die, NULL if no sibling. */
9166 static struct die_info
*
9167 sibling_die (struct die_info
*die
)
9169 return die
->sibling
;
9172 /* Get name of a die, return NULL if not found. */
9175 dwarf2_canonicalize_name (char *name
, struct dwarf2_cu
*cu
,
9176 struct obstack
*obstack
)
9178 if (name
&& cu
->language
== language_cplus
)
9180 char *canon_name
= cp_canonicalize_string (name
);
9182 if (canon_name
!= NULL
)
9184 if (strcmp (canon_name
, name
) != 0)
9185 name
= obsavestring (canon_name
, strlen (canon_name
),
9194 /* Get name of a die, return NULL if not found. */
9197 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
9199 struct attribute
*attr
;
9201 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
9202 if (!attr
|| !DW_STRING (attr
))
9207 case DW_TAG_compile_unit
:
9208 /* Compilation units have a DW_AT_name that is a filename, not
9209 a source language identifier. */
9210 case DW_TAG_enumeration_type
:
9211 case DW_TAG_enumerator
:
9212 /* These tags always have simple identifiers already; no need
9213 to canonicalize them. */
9214 return DW_STRING (attr
);
9216 case DW_TAG_subprogram
:
9217 /* Java constructors will all be named "<init>", so return
9218 the class name when we see this special case. */
9219 if (cu
->language
== language_java
9220 && DW_STRING (attr
) != NULL
9221 && strcmp (DW_STRING (attr
), "<init>") == 0)
9223 struct dwarf2_cu
*spec_cu
= cu
;
9224 struct die_info
*spec_die
;
9226 /* GCJ will output '<init>' for Java constructor names.
9227 For this special case, return the name of the parent class. */
9229 /* GCJ may output suprogram DIEs with AT_specification set.
9230 If so, use the name of the specified DIE. */
9231 spec_die
= die_specification (die
, &spec_cu
);
9232 if (spec_die
!= NULL
)
9233 return dwarf2_name (spec_die
, spec_cu
);
9238 if (die
->tag
== DW_TAG_class_type
)
9239 return dwarf2_name (die
, cu
);
9241 while (die
->tag
!= DW_TAG_compile_unit
);
9245 case DW_TAG_class_type
:
9246 case DW_TAG_interface_type
:
9247 case DW_TAG_structure_type
:
9248 case DW_TAG_union_type
:
9249 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
9250 structures or unions. These were of the form "._%d" in GCC 4.1,
9251 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
9252 and GCC 4.4. We work around this problem by ignoring these. */
9253 if (strncmp (DW_STRING (attr
), "._", 2) == 0
9254 || strncmp (DW_STRING (attr
), "<anonymous", 10) == 0)
9262 if (!DW_STRING_IS_CANONICAL (attr
))
9265 = dwarf2_canonicalize_name (DW_STRING (attr
), cu
,
9266 &cu
->objfile
->objfile_obstack
);
9267 DW_STRING_IS_CANONICAL (attr
) = 1;
9269 return DW_STRING (attr
);
9272 /* Return the die that this die in an extension of, or NULL if there
9273 is none. *EXT_CU is the CU containing DIE on input, and the CU
9274 containing the return value on output. */
9276 static struct die_info
*
9277 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
**ext_cu
)
9279 struct attribute
*attr
;
9281 attr
= dwarf2_attr (die
, DW_AT_extension
, *ext_cu
);
9285 return follow_die_ref (die
, attr
, ext_cu
);
9288 /* Convert a DIE tag into its string name. */
9291 dwarf_tag_name (unsigned tag
)
9295 case DW_TAG_padding
:
9296 return "DW_TAG_padding";
9297 case DW_TAG_array_type
:
9298 return "DW_TAG_array_type";
9299 case DW_TAG_class_type
:
9300 return "DW_TAG_class_type";
9301 case DW_TAG_entry_point
:
9302 return "DW_TAG_entry_point";
9303 case DW_TAG_enumeration_type
:
9304 return "DW_TAG_enumeration_type";
9305 case DW_TAG_formal_parameter
:
9306 return "DW_TAG_formal_parameter";
9307 case DW_TAG_imported_declaration
:
9308 return "DW_TAG_imported_declaration";
9310 return "DW_TAG_label";
9311 case DW_TAG_lexical_block
:
9312 return "DW_TAG_lexical_block";
9314 return "DW_TAG_member";
9315 case DW_TAG_pointer_type
:
9316 return "DW_TAG_pointer_type";
9317 case DW_TAG_reference_type
:
9318 return "DW_TAG_reference_type";
9319 case DW_TAG_compile_unit
:
9320 return "DW_TAG_compile_unit";
9321 case DW_TAG_string_type
:
9322 return "DW_TAG_string_type";
9323 case DW_TAG_structure_type
:
9324 return "DW_TAG_structure_type";
9325 case DW_TAG_subroutine_type
:
9326 return "DW_TAG_subroutine_type";
9327 case DW_TAG_typedef
:
9328 return "DW_TAG_typedef";
9329 case DW_TAG_union_type
:
9330 return "DW_TAG_union_type";
9331 case DW_TAG_unspecified_parameters
:
9332 return "DW_TAG_unspecified_parameters";
9333 case DW_TAG_variant
:
9334 return "DW_TAG_variant";
9335 case DW_TAG_common_block
:
9336 return "DW_TAG_common_block";
9337 case DW_TAG_common_inclusion
:
9338 return "DW_TAG_common_inclusion";
9339 case DW_TAG_inheritance
:
9340 return "DW_TAG_inheritance";
9341 case DW_TAG_inlined_subroutine
:
9342 return "DW_TAG_inlined_subroutine";
9344 return "DW_TAG_module";
9345 case DW_TAG_ptr_to_member_type
:
9346 return "DW_TAG_ptr_to_member_type";
9347 case DW_TAG_set_type
:
9348 return "DW_TAG_set_type";
9349 case DW_TAG_subrange_type
:
9350 return "DW_TAG_subrange_type";
9351 case DW_TAG_with_stmt
:
9352 return "DW_TAG_with_stmt";
9353 case DW_TAG_access_declaration
:
9354 return "DW_TAG_access_declaration";
9355 case DW_TAG_base_type
:
9356 return "DW_TAG_base_type";
9357 case DW_TAG_catch_block
:
9358 return "DW_TAG_catch_block";
9359 case DW_TAG_const_type
:
9360 return "DW_TAG_const_type";
9361 case DW_TAG_constant
:
9362 return "DW_TAG_constant";
9363 case DW_TAG_enumerator
:
9364 return "DW_TAG_enumerator";
9365 case DW_TAG_file_type
:
9366 return "DW_TAG_file_type";
9368 return "DW_TAG_friend";
9369 case DW_TAG_namelist
:
9370 return "DW_TAG_namelist";
9371 case DW_TAG_namelist_item
:
9372 return "DW_TAG_namelist_item";
9373 case DW_TAG_packed_type
:
9374 return "DW_TAG_packed_type";
9375 case DW_TAG_subprogram
:
9376 return "DW_TAG_subprogram";
9377 case DW_TAG_template_type_param
:
9378 return "DW_TAG_template_type_param";
9379 case DW_TAG_template_value_param
:
9380 return "DW_TAG_template_value_param";
9381 case DW_TAG_thrown_type
:
9382 return "DW_TAG_thrown_type";
9383 case DW_TAG_try_block
:
9384 return "DW_TAG_try_block";
9385 case DW_TAG_variant_part
:
9386 return "DW_TAG_variant_part";
9387 case DW_TAG_variable
:
9388 return "DW_TAG_variable";
9389 case DW_TAG_volatile_type
:
9390 return "DW_TAG_volatile_type";
9391 case DW_TAG_dwarf_procedure
:
9392 return "DW_TAG_dwarf_procedure";
9393 case DW_TAG_restrict_type
:
9394 return "DW_TAG_restrict_type";
9395 case DW_TAG_interface_type
:
9396 return "DW_TAG_interface_type";
9397 case DW_TAG_namespace
:
9398 return "DW_TAG_namespace";
9399 case DW_TAG_imported_module
:
9400 return "DW_TAG_imported_module";
9401 case DW_TAG_unspecified_type
:
9402 return "DW_TAG_unspecified_type";
9403 case DW_TAG_partial_unit
:
9404 return "DW_TAG_partial_unit";
9405 case DW_TAG_imported_unit
:
9406 return "DW_TAG_imported_unit";
9407 case DW_TAG_condition
:
9408 return "DW_TAG_condition";
9409 case DW_TAG_shared_type
:
9410 return "DW_TAG_shared_type";
9411 case DW_TAG_type_unit
:
9412 return "DW_TAG_type_unit";
9413 case DW_TAG_MIPS_loop
:
9414 return "DW_TAG_MIPS_loop";
9415 case DW_TAG_HP_array_descriptor
:
9416 return "DW_TAG_HP_array_descriptor";
9417 case DW_TAG_format_label
:
9418 return "DW_TAG_format_label";
9419 case DW_TAG_function_template
:
9420 return "DW_TAG_function_template";
9421 case DW_TAG_class_template
:
9422 return "DW_TAG_class_template";
9423 case DW_TAG_GNU_BINCL
:
9424 return "DW_TAG_GNU_BINCL";
9425 case DW_TAG_GNU_EINCL
:
9426 return "DW_TAG_GNU_EINCL";
9427 case DW_TAG_upc_shared_type
:
9428 return "DW_TAG_upc_shared_type";
9429 case DW_TAG_upc_strict_type
:
9430 return "DW_TAG_upc_strict_type";
9431 case DW_TAG_upc_relaxed_type
:
9432 return "DW_TAG_upc_relaxed_type";
9433 case DW_TAG_PGI_kanji_type
:
9434 return "DW_TAG_PGI_kanji_type";
9435 case DW_TAG_PGI_interface_block
:
9436 return "DW_TAG_PGI_interface_block";
9438 return "DW_TAG_<unknown>";
9442 /* Convert a DWARF attribute code into its string name. */
9445 dwarf_attr_name (unsigned attr
)
9450 return "DW_AT_sibling";
9451 case DW_AT_location
:
9452 return "DW_AT_location";
9454 return "DW_AT_name";
9455 case DW_AT_ordering
:
9456 return "DW_AT_ordering";
9457 case DW_AT_subscr_data
:
9458 return "DW_AT_subscr_data";
9459 case DW_AT_byte_size
:
9460 return "DW_AT_byte_size";
9461 case DW_AT_bit_offset
:
9462 return "DW_AT_bit_offset";
9463 case DW_AT_bit_size
:
9464 return "DW_AT_bit_size";
9465 case DW_AT_element_list
:
9466 return "DW_AT_element_list";
9467 case DW_AT_stmt_list
:
9468 return "DW_AT_stmt_list";
9470 return "DW_AT_low_pc";
9472 return "DW_AT_high_pc";
9473 case DW_AT_language
:
9474 return "DW_AT_language";
9476 return "DW_AT_member";
9478 return "DW_AT_discr";
9479 case DW_AT_discr_value
:
9480 return "DW_AT_discr_value";
9481 case DW_AT_visibility
:
9482 return "DW_AT_visibility";
9484 return "DW_AT_import";
9485 case DW_AT_string_length
:
9486 return "DW_AT_string_length";
9487 case DW_AT_common_reference
:
9488 return "DW_AT_common_reference";
9489 case DW_AT_comp_dir
:
9490 return "DW_AT_comp_dir";
9491 case DW_AT_const_value
:
9492 return "DW_AT_const_value";
9493 case DW_AT_containing_type
:
9494 return "DW_AT_containing_type";
9495 case DW_AT_default_value
:
9496 return "DW_AT_default_value";
9498 return "DW_AT_inline";
9499 case DW_AT_is_optional
:
9500 return "DW_AT_is_optional";
9501 case DW_AT_lower_bound
:
9502 return "DW_AT_lower_bound";
9503 case DW_AT_producer
:
9504 return "DW_AT_producer";
9505 case DW_AT_prototyped
:
9506 return "DW_AT_prototyped";
9507 case DW_AT_return_addr
:
9508 return "DW_AT_return_addr";
9509 case DW_AT_start_scope
:
9510 return "DW_AT_start_scope";
9511 case DW_AT_bit_stride
:
9512 return "DW_AT_bit_stride";
9513 case DW_AT_upper_bound
:
9514 return "DW_AT_upper_bound";
9515 case DW_AT_abstract_origin
:
9516 return "DW_AT_abstract_origin";
9517 case DW_AT_accessibility
:
9518 return "DW_AT_accessibility";
9519 case DW_AT_address_class
:
9520 return "DW_AT_address_class";
9521 case DW_AT_artificial
:
9522 return "DW_AT_artificial";
9523 case DW_AT_base_types
:
9524 return "DW_AT_base_types";
9525 case DW_AT_calling_convention
:
9526 return "DW_AT_calling_convention";
9528 return "DW_AT_count";
9529 case DW_AT_data_member_location
:
9530 return "DW_AT_data_member_location";
9531 case DW_AT_decl_column
:
9532 return "DW_AT_decl_column";
9533 case DW_AT_decl_file
:
9534 return "DW_AT_decl_file";
9535 case DW_AT_decl_line
:
9536 return "DW_AT_decl_line";
9537 case DW_AT_declaration
:
9538 return "DW_AT_declaration";
9539 case DW_AT_discr_list
:
9540 return "DW_AT_discr_list";
9541 case DW_AT_encoding
:
9542 return "DW_AT_encoding";
9543 case DW_AT_external
:
9544 return "DW_AT_external";
9545 case DW_AT_frame_base
:
9546 return "DW_AT_frame_base";
9548 return "DW_AT_friend";
9549 case DW_AT_identifier_case
:
9550 return "DW_AT_identifier_case";
9551 case DW_AT_macro_info
:
9552 return "DW_AT_macro_info";
9553 case DW_AT_namelist_items
:
9554 return "DW_AT_namelist_items";
9555 case DW_AT_priority
:
9556 return "DW_AT_priority";
9558 return "DW_AT_segment";
9559 case DW_AT_specification
:
9560 return "DW_AT_specification";
9561 case DW_AT_static_link
:
9562 return "DW_AT_static_link";
9564 return "DW_AT_type";
9565 case DW_AT_use_location
:
9566 return "DW_AT_use_location";
9567 case DW_AT_variable_parameter
:
9568 return "DW_AT_variable_parameter";
9569 case DW_AT_virtuality
:
9570 return "DW_AT_virtuality";
9571 case DW_AT_vtable_elem_location
:
9572 return "DW_AT_vtable_elem_location";
9573 /* DWARF 3 values. */
9574 case DW_AT_allocated
:
9575 return "DW_AT_allocated";
9576 case DW_AT_associated
:
9577 return "DW_AT_associated";
9578 case DW_AT_data_location
:
9579 return "DW_AT_data_location";
9580 case DW_AT_byte_stride
:
9581 return "DW_AT_byte_stride";
9582 case DW_AT_entry_pc
:
9583 return "DW_AT_entry_pc";
9584 case DW_AT_use_UTF8
:
9585 return "DW_AT_use_UTF8";
9586 case DW_AT_extension
:
9587 return "DW_AT_extension";
9589 return "DW_AT_ranges";
9590 case DW_AT_trampoline
:
9591 return "DW_AT_trampoline";
9592 case DW_AT_call_column
:
9593 return "DW_AT_call_column";
9594 case DW_AT_call_file
:
9595 return "DW_AT_call_file";
9596 case DW_AT_call_line
:
9597 return "DW_AT_call_line";
9598 case DW_AT_description
:
9599 return "DW_AT_description";
9600 case DW_AT_binary_scale
:
9601 return "DW_AT_binary_scale";
9602 case DW_AT_decimal_scale
:
9603 return "DW_AT_decimal_scale";
9605 return "DW_AT_small";
9606 case DW_AT_decimal_sign
:
9607 return "DW_AT_decimal_sign";
9608 case DW_AT_digit_count
:
9609 return "DW_AT_digit_count";
9610 case DW_AT_picture_string
:
9611 return "DW_AT_picture_string";
9613 return "DW_AT_mutable";
9614 case DW_AT_threads_scaled
:
9615 return "DW_AT_threads_scaled";
9616 case DW_AT_explicit
:
9617 return "DW_AT_explicit";
9618 case DW_AT_object_pointer
:
9619 return "DW_AT_object_pointer";
9620 case DW_AT_endianity
:
9621 return "DW_AT_endianity";
9622 case DW_AT_elemental
:
9623 return "DW_AT_elemental";
9625 return "DW_AT_pure";
9626 case DW_AT_recursive
:
9627 return "DW_AT_recursive";
9628 /* DWARF 4 values. */
9629 case DW_AT_signature
:
9630 return "DW_AT_signature";
9631 /* SGI/MIPS extensions. */
9632 #ifdef MIPS /* collides with DW_AT_HP_block_index */
9633 case DW_AT_MIPS_fde
:
9634 return "DW_AT_MIPS_fde";
9636 case DW_AT_MIPS_loop_begin
:
9637 return "DW_AT_MIPS_loop_begin";
9638 case DW_AT_MIPS_tail_loop_begin
:
9639 return "DW_AT_MIPS_tail_loop_begin";
9640 case DW_AT_MIPS_epilog_begin
:
9641 return "DW_AT_MIPS_epilog_begin";
9642 case DW_AT_MIPS_loop_unroll_factor
:
9643 return "DW_AT_MIPS_loop_unroll_factor";
9644 case DW_AT_MIPS_software_pipeline_depth
:
9645 return "DW_AT_MIPS_software_pipeline_depth";
9646 case DW_AT_MIPS_linkage_name
:
9647 return "DW_AT_MIPS_linkage_name";
9648 case DW_AT_MIPS_stride
:
9649 return "DW_AT_MIPS_stride";
9650 case DW_AT_MIPS_abstract_name
:
9651 return "DW_AT_MIPS_abstract_name";
9652 case DW_AT_MIPS_clone_origin
:
9653 return "DW_AT_MIPS_clone_origin";
9654 case DW_AT_MIPS_has_inlines
:
9655 return "DW_AT_MIPS_has_inlines";
9656 /* HP extensions. */
9657 #ifndef MIPS /* collides with DW_AT_MIPS_fde */
9658 case DW_AT_HP_block_index
:
9659 return "DW_AT_HP_block_index";
9661 case DW_AT_HP_unmodifiable
:
9662 return "DW_AT_HP_unmodifiable";
9663 case DW_AT_HP_actuals_stmt_list
:
9664 return "DW_AT_HP_actuals_stmt_list";
9665 case DW_AT_HP_proc_per_section
:
9666 return "DW_AT_HP_proc_per_section";
9667 case DW_AT_HP_raw_data_ptr
:
9668 return "DW_AT_HP_raw_data_ptr";
9669 case DW_AT_HP_pass_by_reference
:
9670 return "DW_AT_HP_pass_by_reference";
9671 case DW_AT_HP_opt_level
:
9672 return "DW_AT_HP_opt_level";
9673 case DW_AT_HP_prof_version_id
:
9674 return "DW_AT_HP_prof_version_id";
9675 case DW_AT_HP_opt_flags
:
9676 return "DW_AT_HP_opt_flags";
9677 case DW_AT_HP_cold_region_low_pc
:
9678 return "DW_AT_HP_cold_region_low_pc";
9679 case DW_AT_HP_cold_region_high_pc
:
9680 return "DW_AT_HP_cold_region_high_pc";
9681 case DW_AT_HP_all_variables_modifiable
:
9682 return "DW_AT_HP_all_variables_modifiable";
9683 case DW_AT_HP_linkage_name
:
9684 return "DW_AT_HP_linkage_name";
9685 case DW_AT_HP_prof_flags
:
9686 return "DW_AT_HP_prof_flags";
9687 /* GNU extensions. */
9688 case DW_AT_sf_names
:
9689 return "DW_AT_sf_names";
9690 case DW_AT_src_info
:
9691 return "DW_AT_src_info";
9692 case DW_AT_mac_info
:
9693 return "DW_AT_mac_info";
9694 case DW_AT_src_coords
:
9695 return "DW_AT_src_coords";
9696 case DW_AT_body_begin
:
9697 return "DW_AT_body_begin";
9698 case DW_AT_body_end
:
9699 return "DW_AT_body_end";
9700 case DW_AT_GNU_vector
:
9701 return "DW_AT_GNU_vector";
9702 /* VMS extensions. */
9703 case DW_AT_VMS_rtnbeg_pd_address
:
9704 return "DW_AT_VMS_rtnbeg_pd_address";
9705 /* UPC extension. */
9706 case DW_AT_upc_threads_scaled
:
9707 return "DW_AT_upc_threads_scaled";
9708 /* PGI (STMicroelectronics) extensions. */
9709 case DW_AT_PGI_lbase
:
9710 return "DW_AT_PGI_lbase";
9711 case DW_AT_PGI_soffset
:
9712 return "DW_AT_PGI_soffset";
9713 case DW_AT_PGI_lstride
:
9714 return "DW_AT_PGI_lstride";
9716 return "DW_AT_<unknown>";
9720 /* Convert a DWARF value form code into its string name. */
9723 dwarf_form_name (unsigned form
)
9728 return "DW_FORM_addr";
9729 case DW_FORM_block2
:
9730 return "DW_FORM_block2";
9731 case DW_FORM_block4
:
9732 return "DW_FORM_block4";
9734 return "DW_FORM_data2";
9736 return "DW_FORM_data4";
9738 return "DW_FORM_data8";
9739 case DW_FORM_string
:
9740 return "DW_FORM_string";
9742 return "DW_FORM_block";
9743 case DW_FORM_block1
:
9744 return "DW_FORM_block1";
9746 return "DW_FORM_data1";
9748 return "DW_FORM_flag";
9750 return "DW_FORM_sdata";
9752 return "DW_FORM_strp";
9754 return "DW_FORM_udata";
9755 case DW_FORM_ref_addr
:
9756 return "DW_FORM_ref_addr";
9758 return "DW_FORM_ref1";
9760 return "DW_FORM_ref2";
9762 return "DW_FORM_ref4";
9764 return "DW_FORM_ref8";
9765 case DW_FORM_ref_udata
:
9766 return "DW_FORM_ref_udata";
9767 case DW_FORM_indirect
:
9768 return "DW_FORM_indirect";
9769 case DW_FORM_sec_offset
:
9770 return "DW_FORM_sec_offset";
9771 case DW_FORM_exprloc
:
9772 return "DW_FORM_exprloc";
9773 case DW_FORM_flag_present
:
9774 return "DW_FORM_flag_present";
9776 return "DW_FORM_sig8";
9778 return "DW_FORM_<unknown>";
9782 /* Convert a DWARF stack opcode into its string name. */
9785 dwarf_stack_op_name (unsigned op
)
9790 return "DW_OP_addr";
9792 return "DW_OP_deref";
9794 return "DW_OP_const1u";
9796 return "DW_OP_const1s";
9798 return "DW_OP_const2u";
9800 return "DW_OP_const2s";
9802 return "DW_OP_const4u";
9804 return "DW_OP_const4s";
9806 return "DW_OP_const8u";
9808 return "DW_OP_const8s";
9810 return "DW_OP_constu";
9812 return "DW_OP_consts";
9816 return "DW_OP_drop";
9818 return "DW_OP_over";
9820 return "DW_OP_pick";
9822 return "DW_OP_swap";
9826 return "DW_OP_xderef";
9834 return "DW_OP_minus";
9846 return "DW_OP_plus";
9847 case DW_OP_plus_uconst
:
9848 return "DW_OP_plus_uconst";
9854 return "DW_OP_shra";
9872 return "DW_OP_skip";
9874 return "DW_OP_lit0";
9876 return "DW_OP_lit1";
9878 return "DW_OP_lit2";
9880 return "DW_OP_lit3";
9882 return "DW_OP_lit4";
9884 return "DW_OP_lit5";
9886 return "DW_OP_lit6";
9888 return "DW_OP_lit7";
9890 return "DW_OP_lit8";
9892 return "DW_OP_lit9";
9894 return "DW_OP_lit10";
9896 return "DW_OP_lit11";
9898 return "DW_OP_lit12";
9900 return "DW_OP_lit13";
9902 return "DW_OP_lit14";
9904 return "DW_OP_lit15";
9906 return "DW_OP_lit16";
9908 return "DW_OP_lit17";
9910 return "DW_OP_lit18";
9912 return "DW_OP_lit19";
9914 return "DW_OP_lit20";
9916 return "DW_OP_lit21";
9918 return "DW_OP_lit22";
9920 return "DW_OP_lit23";
9922 return "DW_OP_lit24";
9924 return "DW_OP_lit25";
9926 return "DW_OP_lit26";
9928 return "DW_OP_lit27";
9930 return "DW_OP_lit28";
9932 return "DW_OP_lit29";
9934 return "DW_OP_lit30";
9936 return "DW_OP_lit31";
9938 return "DW_OP_reg0";
9940 return "DW_OP_reg1";
9942 return "DW_OP_reg2";
9944 return "DW_OP_reg3";
9946 return "DW_OP_reg4";
9948 return "DW_OP_reg5";
9950 return "DW_OP_reg6";
9952 return "DW_OP_reg7";
9954 return "DW_OP_reg8";
9956 return "DW_OP_reg9";
9958 return "DW_OP_reg10";
9960 return "DW_OP_reg11";
9962 return "DW_OP_reg12";
9964 return "DW_OP_reg13";
9966 return "DW_OP_reg14";
9968 return "DW_OP_reg15";
9970 return "DW_OP_reg16";
9972 return "DW_OP_reg17";
9974 return "DW_OP_reg18";
9976 return "DW_OP_reg19";
9978 return "DW_OP_reg20";
9980 return "DW_OP_reg21";
9982 return "DW_OP_reg22";
9984 return "DW_OP_reg23";
9986 return "DW_OP_reg24";
9988 return "DW_OP_reg25";
9990 return "DW_OP_reg26";
9992 return "DW_OP_reg27";
9994 return "DW_OP_reg28";
9996 return "DW_OP_reg29";
9998 return "DW_OP_reg30";
10000 return "DW_OP_reg31";
10002 return "DW_OP_breg0";
10004 return "DW_OP_breg1";
10006 return "DW_OP_breg2";
10008 return "DW_OP_breg3";
10010 return "DW_OP_breg4";
10012 return "DW_OP_breg5";
10014 return "DW_OP_breg6";
10016 return "DW_OP_breg7";
10018 return "DW_OP_breg8";
10020 return "DW_OP_breg9";
10022 return "DW_OP_breg10";
10024 return "DW_OP_breg11";
10026 return "DW_OP_breg12";
10028 return "DW_OP_breg13";
10030 return "DW_OP_breg14";
10032 return "DW_OP_breg15";
10034 return "DW_OP_breg16";
10036 return "DW_OP_breg17";
10038 return "DW_OP_breg18";
10040 return "DW_OP_breg19";
10042 return "DW_OP_breg20";
10044 return "DW_OP_breg21";
10046 return "DW_OP_breg22";
10048 return "DW_OP_breg23";
10050 return "DW_OP_breg24";
10052 return "DW_OP_breg25";
10054 return "DW_OP_breg26";
10056 return "DW_OP_breg27";
10058 return "DW_OP_breg28";
10060 return "DW_OP_breg29";
10062 return "DW_OP_breg30";
10064 return "DW_OP_breg31";
10066 return "DW_OP_regx";
10068 return "DW_OP_fbreg";
10070 return "DW_OP_bregx";
10072 return "DW_OP_piece";
10073 case DW_OP_deref_size
:
10074 return "DW_OP_deref_size";
10075 case DW_OP_xderef_size
:
10076 return "DW_OP_xderef_size";
10078 return "DW_OP_nop";
10079 /* DWARF 3 extensions. */
10080 case DW_OP_push_object_address
:
10081 return "DW_OP_push_object_address";
10083 return "DW_OP_call2";
10085 return "DW_OP_call4";
10086 case DW_OP_call_ref
:
10087 return "DW_OP_call_ref";
10088 /* GNU extensions. */
10089 case DW_OP_form_tls_address
:
10090 return "DW_OP_form_tls_address";
10091 case DW_OP_call_frame_cfa
:
10092 return "DW_OP_call_frame_cfa";
10093 case DW_OP_bit_piece
:
10094 return "DW_OP_bit_piece";
10095 case DW_OP_GNU_push_tls_address
:
10096 return "DW_OP_GNU_push_tls_address";
10097 case DW_OP_GNU_uninit
:
10098 return "DW_OP_GNU_uninit";
10099 /* HP extensions. */
10100 case DW_OP_HP_is_value
:
10101 return "DW_OP_HP_is_value";
10102 case DW_OP_HP_fltconst4
:
10103 return "DW_OP_HP_fltconst4";
10104 case DW_OP_HP_fltconst8
:
10105 return "DW_OP_HP_fltconst8";
10106 case DW_OP_HP_mod_range
:
10107 return "DW_OP_HP_mod_range";
10108 case DW_OP_HP_unmod_range
:
10109 return "DW_OP_HP_unmod_range";
10111 return "DW_OP_HP_tls";
10113 return "OP_<unknown>";
10118 dwarf_bool_name (unsigned mybool
)
10126 /* Convert a DWARF type code into its string name. */
10129 dwarf_type_encoding_name (unsigned enc
)
10134 return "DW_ATE_void";
10135 case DW_ATE_address
:
10136 return "DW_ATE_address";
10137 case DW_ATE_boolean
:
10138 return "DW_ATE_boolean";
10139 case DW_ATE_complex_float
:
10140 return "DW_ATE_complex_float";
10142 return "DW_ATE_float";
10143 case DW_ATE_signed
:
10144 return "DW_ATE_signed";
10145 case DW_ATE_signed_char
:
10146 return "DW_ATE_signed_char";
10147 case DW_ATE_unsigned
:
10148 return "DW_ATE_unsigned";
10149 case DW_ATE_unsigned_char
:
10150 return "DW_ATE_unsigned_char";
10152 case DW_ATE_imaginary_float
:
10153 return "DW_ATE_imaginary_float";
10154 case DW_ATE_packed_decimal
:
10155 return "DW_ATE_packed_decimal";
10156 case DW_ATE_numeric_string
:
10157 return "DW_ATE_numeric_string";
10158 case DW_ATE_edited
:
10159 return "DW_ATE_edited";
10160 case DW_ATE_signed_fixed
:
10161 return "DW_ATE_signed_fixed";
10162 case DW_ATE_unsigned_fixed
:
10163 return "DW_ATE_unsigned_fixed";
10164 case DW_ATE_decimal_float
:
10165 return "DW_ATE_decimal_float";
10166 /* HP extensions. */
10167 case DW_ATE_HP_float80
:
10168 return "DW_ATE_HP_float80";
10169 case DW_ATE_HP_complex_float80
:
10170 return "DW_ATE_HP_complex_float80";
10171 case DW_ATE_HP_float128
:
10172 return "DW_ATE_HP_float128";
10173 case DW_ATE_HP_complex_float128
:
10174 return "DW_ATE_HP_complex_float128";
10175 case DW_ATE_HP_floathpintel
:
10176 return "DW_ATE_HP_floathpintel";
10177 case DW_ATE_HP_imaginary_float80
:
10178 return "DW_ATE_HP_imaginary_float80";
10179 case DW_ATE_HP_imaginary_float128
:
10180 return "DW_ATE_HP_imaginary_float128";
10182 return "DW_ATE_<unknown>";
10186 /* Convert a DWARF call frame info operation to its string name. */
10190 dwarf_cfi_name (unsigned cfi_opc
)
10194 case DW_CFA_advance_loc
:
10195 return "DW_CFA_advance_loc";
10196 case DW_CFA_offset
:
10197 return "DW_CFA_offset";
10198 case DW_CFA_restore
:
10199 return "DW_CFA_restore";
10201 return "DW_CFA_nop";
10202 case DW_CFA_set_loc
:
10203 return "DW_CFA_set_loc";
10204 case DW_CFA_advance_loc1
:
10205 return "DW_CFA_advance_loc1";
10206 case DW_CFA_advance_loc2
:
10207 return "DW_CFA_advance_loc2";
10208 case DW_CFA_advance_loc4
:
10209 return "DW_CFA_advance_loc4";
10210 case DW_CFA_offset_extended
:
10211 return "DW_CFA_offset_extended";
10212 case DW_CFA_restore_extended
:
10213 return "DW_CFA_restore_extended";
10214 case DW_CFA_undefined
:
10215 return "DW_CFA_undefined";
10216 case DW_CFA_same_value
:
10217 return "DW_CFA_same_value";
10218 case DW_CFA_register
:
10219 return "DW_CFA_register";
10220 case DW_CFA_remember_state
:
10221 return "DW_CFA_remember_state";
10222 case DW_CFA_restore_state
:
10223 return "DW_CFA_restore_state";
10224 case DW_CFA_def_cfa
:
10225 return "DW_CFA_def_cfa";
10226 case DW_CFA_def_cfa_register
:
10227 return "DW_CFA_def_cfa_register";
10228 case DW_CFA_def_cfa_offset
:
10229 return "DW_CFA_def_cfa_offset";
10231 case DW_CFA_def_cfa_expression
:
10232 return "DW_CFA_def_cfa_expression";
10233 case DW_CFA_expression
:
10234 return "DW_CFA_expression";
10235 case DW_CFA_offset_extended_sf
:
10236 return "DW_CFA_offset_extended_sf";
10237 case DW_CFA_def_cfa_sf
:
10238 return "DW_CFA_def_cfa_sf";
10239 case DW_CFA_def_cfa_offset_sf
:
10240 return "DW_CFA_def_cfa_offset_sf";
10241 case DW_CFA_val_offset
:
10242 return "DW_CFA_val_offset";
10243 case DW_CFA_val_offset_sf
:
10244 return "DW_CFA_val_offset_sf";
10245 case DW_CFA_val_expression
:
10246 return "DW_CFA_val_expression";
10247 /* SGI/MIPS specific. */
10248 case DW_CFA_MIPS_advance_loc8
:
10249 return "DW_CFA_MIPS_advance_loc8";
10250 /* GNU extensions. */
10251 case DW_CFA_GNU_window_save
:
10252 return "DW_CFA_GNU_window_save";
10253 case DW_CFA_GNU_args_size
:
10254 return "DW_CFA_GNU_args_size";
10255 case DW_CFA_GNU_negative_offset_extended
:
10256 return "DW_CFA_GNU_negative_offset_extended";
10258 return "DW_CFA_<unknown>";
10264 dump_die_shallow (struct ui_file
*f
, int indent
, struct die_info
*die
)
10268 print_spaces (indent
, f
);
10269 fprintf_unfiltered (f
, "Die: %s (abbrev %d, offset 0x%x)\n",
10270 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
10272 if (die
->parent
!= NULL
)
10274 print_spaces (indent
, f
);
10275 fprintf_unfiltered (f
, " parent at offset: 0x%x\n",
10276 die
->parent
->offset
);
10279 print_spaces (indent
, f
);
10280 fprintf_unfiltered (f
, " has children: %s\n",
10281 dwarf_bool_name (die
->child
!= NULL
));
10283 print_spaces (indent
, f
);
10284 fprintf_unfiltered (f
, " attributes:\n");
10286 for (i
= 0; i
< die
->num_attrs
; ++i
)
10288 print_spaces (indent
, f
);
10289 fprintf_unfiltered (f
, " %s (%s) ",
10290 dwarf_attr_name (die
->attrs
[i
].name
),
10291 dwarf_form_name (die
->attrs
[i
].form
));
10293 switch (die
->attrs
[i
].form
)
10295 case DW_FORM_ref_addr
:
10297 fprintf_unfiltered (f
, "address: ");
10298 fputs_filtered (hex_string (DW_ADDR (&die
->attrs
[i
])), f
);
10300 case DW_FORM_block2
:
10301 case DW_FORM_block4
:
10302 case DW_FORM_block
:
10303 case DW_FORM_block1
:
10304 fprintf_unfiltered (f
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
10309 fprintf_unfiltered (f
, "constant ref: 0x%lx (adjusted)",
10310 (long) (DW_ADDR (&die
->attrs
[i
])));
10312 case DW_FORM_data1
:
10313 case DW_FORM_data2
:
10314 case DW_FORM_data4
:
10315 case DW_FORM_data8
:
10316 case DW_FORM_udata
:
10317 case DW_FORM_sdata
:
10318 fprintf_unfiltered (f
, "constant: %s",
10319 pulongest (DW_UNSND (&die
->attrs
[i
])));
10322 if (DW_SIGNATURED_TYPE (&die
->attrs
[i
]) != NULL
)
10323 fprintf_unfiltered (f
, "signatured type, offset: 0x%x",
10324 DW_SIGNATURED_TYPE (&die
->attrs
[i
])->offset
);
10326 fprintf_unfiltered (f
, "signatured type, offset: unknown");
10328 case DW_FORM_string
:
10330 fprintf_unfiltered (f
, "string: \"%s\" (%s canonicalized)",
10331 DW_STRING (&die
->attrs
[i
])
10332 ? DW_STRING (&die
->attrs
[i
]) : "",
10333 DW_STRING_IS_CANONICAL (&die
->attrs
[i
]) ? "is" : "not");
10336 if (DW_UNSND (&die
->attrs
[i
]))
10337 fprintf_unfiltered (f
, "flag: TRUE");
10339 fprintf_unfiltered (f
, "flag: FALSE");
10341 case DW_FORM_indirect
:
10342 /* the reader will have reduced the indirect form to
10343 the "base form" so this form should not occur */
10344 fprintf_unfiltered (f
, "unexpected attribute form: DW_FORM_indirect");
10347 fprintf_unfiltered (f
, "unsupported attribute form: %d.",
10348 die
->attrs
[i
].form
);
10351 fprintf_unfiltered (f
, "\n");
10356 dump_die_for_error (struct die_info
*die
)
10358 dump_die_shallow (gdb_stderr
, 0, die
);
10362 dump_die_1 (struct ui_file
*f
, int level
, int max_level
, struct die_info
*die
)
10364 int indent
= level
* 4;
10366 gdb_assert (die
!= NULL
);
10368 if (level
>= max_level
)
10371 dump_die_shallow (f
, indent
, die
);
10373 if (die
->child
!= NULL
)
10375 print_spaces (indent
, f
);
10376 fprintf_unfiltered (f
, " Children:");
10377 if (level
+ 1 < max_level
)
10379 fprintf_unfiltered (f
, "\n");
10380 dump_die_1 (f
, level
+ 1, max_level
, die
->child
);
10384 fprintf_unfiltered (f
, " [not printed, max nesting level reached]\n");
10388 if (die
->sibling
!= NULL
&& level
> 0)
10390 dump_die_1 (f
, level
, max_level
, die
->sibling
);
10394 /* This is called from the pdie macro in gdbinit.in.
10395 It's not static so gcc will keep a copy callable from gdb. */
10398 dump_die (struct die_info
*die
, int max_level
)
10400 dump_die_1 (gdb_stdlog
, 0, max_level
, die
);
10404 store_in_ref_table (struct die_info
*die
, struct dwarf2_cu
*cu
)
10408 slot
= htab_find_slot_with_hash (cu
->die_hash
, die
, die
->offset
, INSERT
);
10414 is_ref_attr (struct attribute
*attr
)
10416 switch (attr
->form
)
10418 case DW_FORM_ref_addr
:
10423 case DW_FORM_ref_udata
:
10430 static unsigned int
10431 dwarf2_get_ref_die_offset (struct attribute
*attr
)
10433 if (is_ref_attr (attr
))
10434 return DW_ADDR (attr
);
10436 complaint (&symfile_complaints
,
10437 _("unsupported die ref attribute form: '%s'"),
10438 dwarf_form_name (attr
->form
));
10442 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
10443 * the value held by the attribute is not constant. */
10446 dwarf2_get_attr_constant_value (struct attribute
*attr
, int default_value
)
10448 if (attr
->form
== DW_FORM_sdata
)
10449 return DW_SND (attr
);
10450 else if (attr
->form
== DW_FORM_udata
10451 || attr
->form
== DW_FORM_data1
10452 || attr
->form
== DW_FORM_data2
10453 || attr
->form
== DW_FORM_data4
10454 || attr
->form
== DW_FORM_data8
)
10455 return DW_UNSND (attr
);
10458 complaint (&symfile_complaints
, _("Attribute value is not a constant (%s)"),
10459 dwarf_form_name (attr
->form
));
10460 return default_value
;
10464 /* THIS_CU has a reference to PER_CU. If necessary, load the new compilation
10465 unit and add it to our queue.
10466 The result is non-zero if PER_CU was queued, otherwise the result is zero
10467 meaning either PER_CU is already queued or it is already loaded. */
10470 maybe_queue_comp_unit (struct dwarf2_cu
*this_cu
,
10471 struct dwarf2_per_cu_data
*per_cu
)
10473 /* Mark the dependence relation so that we don't flush PER_CU
10475 dwarf2_add_dependence (this_cu
, per_cu
);
10477 /* If it's already on the queue, we have nothing to do. */
10478 if (per_cu
->queued
)
10481 /* If the compilation unit is already loaded, just mark it as
10483 if (per_cu
->cu
!= NULL
)
10485 per_cu
->cu
->last_used
= 0;
10489 /* Add it to the queue. */
10490 queue_comp_unit (per_cu
, this_cu
->objfile
);
10495 /* Follow reference or signature attribute ATTR of SRC_DIE.
10496 On entry *REF_CU is the CU of SRC_DIE.
10497 On exit *REF_CU is the CU of the result. */
10499 static struct die_info
*
10500 follow_die_ref_or_sig (struct die_info
*src_die
, struct attribute
*attr
,
10501 struct dwarf2_cu
**ref_cu
)
10503 struct die_info
*die
;
10505 if (is_ref_attr (attr
))
10506 die
= follow_die_ref (src_die
, attr
, ref_cu
);
10507 else if (attr
->form
== DW_FORM_sig8
)
10508 die
= follow_die_sig (src_die
, attr
, ref_cu
);
10511 dump_die_for_error (src_die
);
10512 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
10513 (*ref_cu
)->objfile
->name
);
10519 /* Follow reference attribute ATTR of SRC_DIE.
10520 On entry *REF_CU is the CU of SRC_DIE.
10521 On exit *REF_CU is the CU of the result. */
10523 static struct die_info
*
10524 follow_die_ref (struct die_info
*src_die
, struct attribute
*attr
,
10525 struct dwarf2_cu
**ref_cu
)
10527 struct die_info
*die
;
10528 unsigned int offset
;
10529 struct die_info temp_die
;
10530 struct dwarf2_cu
*target_cu
, *cu
= *ref_cu
;
10532 gdb_assert (cu
->per_cu
!= NULL
);
10534 offset
= dwarf2_get_ref_die_offset (attr
);
10536 if (cu
->per_cu
->from_debug_types
)
10538 /* .debug_types CUs cannot reference anything outside their CU.
10539 If they need to, they have to reference a signatured type via
10541 if (! offset_in_cu_p (&cu
->header
, offset
))
10545 else if (! offset_in_cu_p (&cu
->header
, offset
))
10547 struct dwarf2_per_cu_data
*per_cu
;
10548 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
10550 /* If necessary, add it to the queue and load its DIEs. */
10551 if (maybe_queue_comp_unit (cu
, per_cu
))
10552 load_full_comp_unit (per_cu
, cu
->objfile
);
10554 target_cu
= per_cu
->cu
;
10559 *ref_cu
= target_cu
;
10560 temp_die
.offset
= offset
;
10561 die
= htab_find_with_hash (target_cu
->die_hash
, &temp_die
, offset
);
10567 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced from DIE "
10568 "at 0x%x [in module %s]"),
10569 offset
, src_die
->offset
, cu
->objfile
->name
);
10572 /* Follow the signature attribute ATTR in SRC_DIE.
10573 On entry *REF_CU is the CU of SRC_DIE.
10574 On exit *REF_CU is the CU of the result. */
10576 static struct die_info
*
10577 follow_die_sig (struct die_info
*src_die
, struct attribute
*attr
,
10578 struct dwarf2_cu
**ref_cu
)
10580 struct objfile
*objfile
= (*ref_cu
)->objfile
;
10581 struct die_info temp_die
;
10582 struct signatured_type
*sig_type
= DW_SIGNATURED_TYPE (attr
);
10583 struct dwarf2_cu
*sig_cu
;
10584 struct die_info
*die
;
10586 /* sig_type will be NULL if the signatured type is missing from
10588 if (sig_type
== NULL
)
10589 error (_("Dwarf Error: Cannot find signatured DIE referenced from DIE "
10590 "at 0x%x [in module %s]"),
10591 src_die
->offset
, objfile
->name
);
10593 /* If necessary, add it to the queue and load its DIEs. */
10595 if (maybe_queue_comp_unit (*ref_cu
, &sig_type
->per_cu
))
10596 read_signatured_type (objfile
, sig_type
);
10598 gdb_assert (sig_type
->per_cu
.cu
!= NULL
);
10600 sig_cu
= sig_type
->per_cu
.cu
;
10601 temp_die
.offset
= sig_cu
->header
.offset
+ sig_type
->type_offset
;
10602 die
= htab_find_with_hash (sig_cu
->die_hash
, &temp_die
, temp_die
.offset
);
10609 error (_("Dwarf Error: Cannot find signatured DIE at 0x%x referenced from DIE "
10610 "at 0x%x [in module %s]"),
10611 sig_type
->type_offset
, src_die
->offset
, objfile
->name
);
10614 /* Given an offset of a signatured type, return its signatured_type. */
10616 static struct signatured_type
*
10617 lookup_signatured_type_at_offset (struct objfile
*objfile
, unsigned int offset
)
10619 gdb_byte
*info_ptr
= dwarf2_per_objfile
->types
.buffer
+ offset
;
10620 unsigned int length
, initial_length_size
;
10621 unsigned int sig_offset
;
10622 struct signatured_type find_entry
, *type_sig
;
10624 length
= read_initial_length (objfile
->obfd
, info_ptr
, &initial_length_size
);
10625 sig_offset
= (initial_length_size
10627 + (initial_length_size
== 4 ? 4 : 8) /*debug_abbrev_offset*/
10628 + 1 /*address_size*/);
10629 find_entry
.signature
= bfd_get_64 (objfile
->obfd
, info_ptr
+ sig_offset
);
10630 type_sig
= htab_find (dwarf2_per_objfile
->signatured_types
, &find_entry
);
10632 /* This is only used to lookup previously recorded types.
10633 If we didn't find it, it's our bug. */
10634 gdb_assert (type_sig
!= NULL
);
10635 gdb_assert (offset
== type_sig
->offset
);
10640 /* Read in signatured type at OFFSET and build its CU and die(s). */
10643 read_signatured_type_at_offset (struct objfile
*objfile
,
10644 unsigned int offset
)
10646 struct signatured_type
*type_sig
;
10648 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->types
);
10650 /* We have the section offset, but we need the signature to do the
10651 hash table lookup. */
10652 type_sig
= lookup_signatured_type_at_offset (objfile
, offset
);
10654 gdb_assert (type_sig
->per_cu
.cu
== NULL
);
10656 read_signatured_type (objfile
, type_sig
);
10658 gdb_assert (type_sig
->per_cu
.cu
!= NULL
);
10661 /* Read in a signatured type and build its CU and DIEs. */
10664 read_signatured_type (struct objfile
*objfile
,
10665 struct signatured_type
*type_sig
)
10667 gdb_byte
*types_ptr
= dwarf2_per_objfile
->types
.buffer
+ type_sig
->offset
;
10668 struct die_reader_specs reader_specs
;
10669 struct dwarf2_cu
*cu
;
10670 ULONGEST signature
;
10671 struct cleanup
*back_to
, *free_cu_cleanup
;
10672 struct attribute
*attr
;
10674 gdb_assert (type_sig
->per_cu
.cu
== NULL
);
10676 cu
= xmalloc (sizeof (struct dwarf2_cu
));
10677 memset (cu
, 0, sizeof (struct dwarf2_cu
));
10678 obstack_init (&cu
->comp_unit_obstack
);
10679 cu
->objfile
= objfile
;
10680 type_sig
->per_cu
.cu
= cu
;
10681 cu
->per_cu
= &type_sig
->per_cu
;
10683 /* If an error occurs while loading, release our storage. */
10684 free_cu_cleanup
= make_cleanup (free_one_comp_unit
, cu
);
10686 types_ptr
= read_type_comp_unit_head (&cu
->header
, &signature
,
10687 types_ptr
, objfile
->obfd
);
10688 gdb_assert (signature
== type_sig
->signature
);
10691 = htab_create_alloc_ex (cu
->header
.length
/ 12,
10695 &cu
->comp_unit_obstack
,
10696 hashtab_obstack_allocate
,
10697 dummy_obstack_deallocate
);
10699 dwarf2_read_abbrevs (cu
->objfile
->obfd
, cu
);
10700 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
10702 init_cu_die_reader (&reader_specs
, cu
);
10704 cu
->dies
= read_die_and_children (&reader_specs
, types_ptr
, &types_ptr
,
10707 /* We try not to read any attributes in this function, because not
10708 all objfiles needed for references have been loaded yet, and symbol
10709 table processing isn't initialized. But we have to set the CU language,
10710 or we won't be able to build types correctly. */
10711 attr
= dwarf2_attr (cu
->dies
, DW_AT_language
, cu
);
10713 set_cu_language (DW_UNSND (attr
), cu
);
10715 set_cu_language (language_minimal
, cu
);
10717 do_cleanups (back_to
);
10719 /* We've successfully allocated this compilation unit. Let our caller
10720 clean it up when finished with it. */
10721 discard_cleanups (free_cu_cleanup
);
10723 type_sig
->per_cu
.cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
10724 dwarf2_per_objfile
->read_in_chain
= &type_sig
->per_cu
;
10727 /* Decode simple location descriptions.
10728 Given a pointer to a dwarf block that defines a location, compute
10729 the location and return the value.
10731 NOTE drow/2003-11-18: This function is called in two situations
10732 now: for the address of static or global variables (partial symbols
10733 only) and for offsets into structures which are expected to be
10734 (more or less) constant. The partial symbol case should go away,
10735 and only the constant case should remain. That will let this
10736 function complain more accurately. A few special modes are allowed
10737 without complaint for global variables (for instance, global
10738 register values and thread-local values).
10740 A location description containing no operations indicates that the
10741 object is optimized out. The return value is 0 for that case.
10742 FIXME drow/2003-11-16: No callers check for this case any more; soon all
10743 callers will only want a very basic result and this can become a
10746 Note that stack[0] is unused except as a default error return.
10747 Note that stack overflow is not yet handled. */
10750 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
10752 struct objfile
*objfile
= cu
->objfile
;
10753 struct comp_unit_head
*cu_header
= &cu
->header
;
10755 int size
= blk
->size
;
10756 gdb_byte
*data
= blk
->data
;
10757 CORE_ADDR stack
[64];
10759 unsigned int bytes_read
, unsnd
;
10803 stack
[++stacki
] = op
- DW_OP_lit0
;
10838 stack
[++stacki
] = op
- DW_OP_reg0
;
10840 dwarf2_complex_location_expr_complaint ();
10844 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
10846 stack
[++stacki
] = unsnd
;
10848 dwarf2_complex_location_expr_complaint ();
10852 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
10857 case DW_OP_const1u
:
10858 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
10862 case DW_OP_const1s
:
10863 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
10867 case DW_OP_const2u
:
10868 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
10872 case DW_OP_const2s
:
10873 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
10877 case DW_OP_const4u
:
10878 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
10882 case DW_OP_const4s
:
10883 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
10888 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
10894 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
10899 stack
[stacki
+ 1] = stack
[stacki
];
10904 stack
[stacki
- 1] += stack
[stacki
];
10908 case DW_OP_plus_uconst
:
10909 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
10914 stack
[stacki
- 1] -= stack
[stacki
];
10919 /* If we're not the last op, then we definitely can't encode
10920 this using GDB's address_class enum. This is valid for partial
10921 global symbols, although the variable's address will be bogus
10924 dwarf2_complex_location_expr_complaint ();
10927 case DW_OP_GNU_push_tls_address
:
10928 /* The top of the stack has the offset from the beginning
10929 of the thread control block at which the variable is located. */
10930 /* Nothing should follow this operator, so the top of stack would
10932 /* This is valid for partial global symbols, but the variable's
10933 address will be bogus in the psymtab. */
10935 dwarf2_complex_location_expr_complaint ();
10938 case DW_OP_GNU_uninit
:
10942 complaint (&symfile_complaints
, _("unsupported stack op: '%s'"),
10943 dwarf_stack_op_name (op
));
10944 return (stack
[stacki
]);
10947 return (stack
[stacki
]);
10950 /* memory allocation interface */
10952 static struct dwarf_block
*
10953 dwarf_alloc_block (struct dwarf2_cu
*cu
)
10955 struct dwarf_block
*blk
;
10957 blk
= (struct dwarf_block
*)
10958 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
10962 static struct abbrev_info
*
10963 dwarf_alloc_abbrev (struct dwarf2_cu
*cu
)
10965 struct abbrev_info
*abbrev
;
10967 abbrev
= (struct abbrev_info
*)
10968 obstack_alloc (&cu
->abbrev_obstack
, sizeof (struct abbrev_info
));
10969 memset (abbrev
, 0, sizeof (struct abbrev_info
));
10973 static struct die_info
*
10974 dwarf_alloc_die (struct dwarf2_cu
*cu
, int num_attrs
)
10976 struct die_info
*die
;
10977 size_t size
= sizeof (struct die_info
);
10980 size
+= (num_attrs
- 1) * sizeof (struct attribute
);
10982 die
= (struct die_info
*) obstack_alloc (&cu
->comp_unit_obstack
, size
);
10983 memset (die
, 0, sizeof (struct die_info
));
10988 /* Macro support. */
10991 /* Return the full name of file number I in *LH's file name table.
10992 Use COMP_DIR as the name of the current directory of the
10993 compilation. The result is allocated using xmalloc; the caller is
10994 responsible for freeing it. */
10996 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
10998 /* Is the file number a valid index into the line header's file name
10999 table? Remember that file numbers start with one, not zero. */
11000 if (1 <= file
&& file
<= lh
->num_file_names
)
11002 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
11004 if (IS_ABSOLUTE_PATH (fe
->name
))
11005 return xstrdup (fe
->name
);
11013 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
11019 dir_len
= strlen (dir
);
11020 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
11021 strcpy (full_name
, dir
);
11022 full_name
[dir_len
] = '/';
11023 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
11027 return xstrdup (fe
->name
);
11032 /* The compiler produced a bogus file number. We can at least
11033 record the macro definitions made in the file, even if we
11034 won't be able to find the file by name. */
11035 char fake_name
[80];
11036 sprintf (fake_name
, "<bad macro file number %d>", file
);
11038 complaint (&symfile_complaints
,
11039 _("bad file number in macro information (%d)"),
11042 return xstrdup (fake_name
);
11047 static struct macro_source_file
*
11048 macro_start_file (int file
, int line
,
11049 struct macro_source_file
*current_file
,
11050 const char *comp_dir
,
11051 struct line_header
*lh
, struct objfile
*objfile
)
11053 /* The full name of this source file. */
11054 char *full_name
= file_full_name (file
, lh
, comp_dir
);
11056 /* We don't create a macro table for this compilation unit
11057 at all until we actually get a filename. */
11058 if (! pending_macros
)
11059 pending_macros
= new_macro_table (&objfile
->objfile_obstack
,
11060 objfile
->macro_cache
);
11062 if (! current_file
)
11063 /* If we have no current file, then this must be the start_file
11064 directive for the compilation unit's main source file. */
11065 current_file
= macro_set_main (pending_macros
, full_name
);
11067 current_file
= macro_include (current_file
, line
, full_name
);
11071 return current_file
;
11075 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
11076 followed by a null byte. */
11078 copy_string (const char *buf
, int len
)
11080 char *s
= xmalloc (len
+ 1);
11081 memcpy (s
, buf
, len
);
11088 static const char *
11089 consume_improper_spaces (const char *p
, const char *body
)
11093 complaint (&symfile_complaints
,
11094 _("macro definition contains spaces in formal argument list:\n`%s'"),
11106 parse_macro_definition (struct macro_source_file
*file
, int line
,
11111 /* The body string takes one of two forms. For object-like macro
11112 definitions, it should be:
11114 <macro name> " " <definition>
11116 For function-like macro definitions, it should be:
11118 <macro name> "() " <definition>
11120 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
11122 Spaces may appear only where explicitly indicated, and in the
11125 The Dwarf 2 spec says that an object-like macro's name is always
11126 followed by a space, but versions of GCC around March 2002 omit
11127 the space when the macro's definition is the empty string.
11129 The Dwarf 2 spec says that there should be no spaces between the
11130 formal arguments in a function-like macro's formal argument list,
11131 but versions of GCC around March 2002 include spaces after the
11135 /* Find the extent of the macro name. The macro name is terminated
11136 by either a space or null character (for an object-like macro) or
11137 an opening paren (for a function-like macro). */
11138 for (p
= body
; *p
; p
++)
11139 if (*p
== ' ' || *p
== '(')
11142 if (*p
== ' ' || *p
== '\0')
11144 /* It's an object-like macro. */
11145 int name_len
= p
- body
;
11146 char *name
= copy_string (body
, name_len
);
11147 const char *replacement
;
11150 replacement
= body
+ name_len
+ 1;
11153 dwarf2_macro_malformed_definition_complaint (body
);
11154 replacement
= body
+ name_len
;
11157 macro_define_object (file
, line
, name
, replacement
);
11161 else if (*p
== '(')
11163 /* It's a function-like macro. */
11164 char *name
= copy_string (body
, p
- body
);
11167 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
11171 p
= consume_improper_spaces (p
, body
);
11173 /* Parse the formal argument list. */
11174 while (*p
&& *p
!= ')')
11176 /* Find the extent of the current argument name. */
11177 const char *arg_start
= p
;
11179 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
11182 if (! *p
|| p
== arg_start
)
11183 dwarf2_macro_malformed_definition_complaint (body
);
11186 /* Make sure argv has room for the new argument. */
11187 if (argc
>= argv_size
)
11190 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
11193 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
11196 p
= consume_improper_spaces (p
, body
);
11198 /* Consume the comma, if present. */
11203 p
= consume_improper_spaces (p
, body
);
11212 /* Perfectly formed definition, no complaints. */
11213 macro_define_function (file
, line
, name
,
11214 argc
, (const char **) argv
,
11216 else if (*p
== '\0')
11218 /* Complain, but do define it. */
11219 dwarf2_macro_malformed_definition_complaint (body
);
11220 macro_define_function (file
, line
, name
,
11221 argc
, (const char **) argv
,
11225 /* Just complain. */
11226 dwarf2_macro_malformed_definition_complaint (body
);
11229 /* Just complain. */
11230 dwarf2_macro_malformed_definition_complaint (body
);
11236 for (i
= 0; i
< argc
; i
++)
11242 dwarf2_macro_malformed_definition_complaint (body
);
11247 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
11248 char *comp_dir
, bfd
*abfd
,
11249 struct dwarf2_cu
*cu
)
11251 gdb_byte
*mac_ptr
, *mac_end
;
11252 struct macro_source_file
*current_file
= 0;
11253 enum dwarf_macinfo_record_type macinfo_type
;
11254 int at_commandline
;
11256 dwarf2_read_section (dwarf2_per_objfile
->objfile
,
11257 &dwarf2_per_objfile
->macinfo
);
11258 if (dwarf2_per_objfile
->macinfo
.buffer
== NULL
)
11260 complaint (&symfile_complaints
, _("missing .debug_macinfo section"));
11264 /* First pass: Find the name of the base filename.
11265 This filename is needed in order to process all macros whose definition
11266 (or undefinition) comes from the command line. These macros are defined
11267 before the first DW_MACINFO_start_file entry, and yet still need to be
11268 associated to the base file.
11270 To determine the base file name, we scan the macro definitions until we
11271 reach the first DW_MACINFO_start_file entry. We then initialize
11272 CURRENT_FILE accordingly so that any macro definition found before the
11273 first DW_MACINFO_start_file can still be associated to the base file. */
11275 mac_ptr
= dwarf2_per_objfile
->macinfo
.buffer
+ offset
;
11276 mac_end
= dwarf2_per_objfile
->macinfo
.buffer
11277 + dwarf2_per_objfile
->macinfo
.size
;
11281 /* Do we at least have room for a macinfo type byte? */
11282 if (mac_ptr
>= mac_end
)
11284 /* Complaint is printed during the second pass as GDB will probably
11285 stop the first pass earlier upon finding DW_MACINFO_start_file. */
11289 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
11292 switch (macinfo_type
)
11294 /* A zero macinfo type indicates the end of the macro
11299 case DW_MACINFO_define
:
11300 case DW_MACINFO_undef
:
11301 /* Only skip the data by MAC_PTR. */
11303 unsigned int bytes_read
;
11305 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
11306 mac_ptr
+= bytes_read
;
11307 read_string (abfd
, mac_ptr
, &bytes_read
);
11308 mac_ptr
+= bytes_read
;
11312 case DW_MACINFO_start_file
:
11314 unsigned int bytes_read
;
11317 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
11318 mac_ptr
+= bytes_read
;
11319 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
11320 mac_ptr
+= bytes_read
;
11322 current_file
= macro_start_file (file
, line
, current_file
, comp_dir
,
11327 case DW_MACINFO_end_file
:
11328 /* No data to skip by MAC_PTR. */
11331 case DW_MACINFO_vendor_ext
:
11332 /* Only skip the data by MAC_PTR. */
11334 unsigned int bytes_read
;
11336 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
11337 mac_ptr
+= bytes_read
;
11338 read_string (abfd
, mac_ptr
, &bytes_read
);
11339 mac_ptr
+= bytes_read
;
11346 } while (macinfo_type
!= 0 && current_file
== NULL
);
11348 /* Second pass: Process all entries.
11350 Use the AT_COMMAND_LINE flag to determine whether we are still processing
11351 command-line macro definitions/undefinitions. This flag is unset when we
11352 reach the first DW_MACINFO_start_file entry. */
11354 mac_ptr
= dwarf2_per_objfile
->macinfo
.buffer
+ offset
;
11356 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
11357 GDB is still reading the definitions from command line. First
11358 DW_MACINFO_start_file will need to be ignored as it was already executed
11359 to create CURRENT_FILE for the main source holding also the command line
11360 definitions. On first met DW_MACINFO_start_file this flag is reset to
11361 normally execute all the remaining DW_MACINFO_start_file macinfos. */
11363 at_commandline
= 1;
11367 /* Do we at least have room for a macinfo type byte? */
11368 if (mac_ptr
>= mac_end
)
11370 dwarf2_macros_too_long_complaint ();
11374 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
11377 switch (macinfo_type
)
11379 /* A zero macinfo type indicates the end of the macro
11384 case DW_MACINFO_define
:
11385 case DW_MACINFO_undef
:
11387 unsigned int bytes_read
;
11391 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
11392 mac_ptr
+= bytes_read
;
11393 body
= read_string (abfd
, mac_ptr
, &bytes_read
);
11394 mac_ptr
+= bytes_read
;
11396 if (! current_file
)
11398 /* DWARF violation as no main source is present. */
11399 complaint (&symfile_complaints
,
11400 _("debug info with no main source gives macro %s "
11402 macinfo_type
== DW_MACINFO_define
?
11404 macinfo_type
== DW_MACINFO_undef
?
11405 _("undefinition") :
11406 _("something-or-other"), line
, body
);
11409 if ((line
== 0 && !at_commandline
) || (line
!= 0 && at_commandline
))
11410 complaint (&symfile_complaints
,
11411 _("debug info gives %s macro %s with %s line %d: %s"),
11412 at_commandline
? _("command-line") : _("in-file"),
11413 macinfo_type
== DW_MACINFO_define
?
11415 macinfo_type
== DW_MACINFO_undef
?
11416 _("undefinition") :
11417 _("something-or-other"),
11418 line
== 0 ? _("zero") : _("non-zero"), line
, body
);
11420 if (macinfo_type
== DW_MACINFO_define
)
11421 parse_macro_definition (current_file
, line
, body
);
11422 else if (macinfo_type
== DW_MACINFO_undef
)
11423 macro_undef (current_file
, line
, body
);
11427 case DW_MACINFO_start_file
:
11429 unsigned int bytes_read
;
11432 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
11433 mac_ptr
+= bytes_read
;
11434 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
11435 mac_ptr
+= bytes_read
;
11437 if ((line
== 0 && !at_commandline
) || (line
!= 0 && at_commandline
))
11438 complaint (&symfile_complaints
,
11439 _("debug info gives source %d included "
11440 "from %s at %s line %d"),
11441 file
, at_commandline
? _("command-line") : _("file"),
11442 line
== 0 ? _("zero") : _("non-zero"), line
);
11444 if (at_commandline
)
11446 /* This DW_MACINFO_start_file was executed in the pass one. */
11447 at_commandline
= 0;
11450 current_file
= macro_start_file (file
, line
,
11451 current_file
, comp_dir
,
11456 case DW_MACINFO_end_file
:
11457 if (! current_file
)
11458 complaint (&symfile_complaints
,
11459 _("macro debug info has an unmatched `close_file' directive"));
11462 current_file
= current_file
->included_by
;
11463 if (! current_file
)
11465 enum dwarf_macinfo_record_type next_type
;
11467 /* GCC circa March 2002 doesn't produce the zero
11468 type byte marking the end of the compilation
11469 unit. Complain if it's not there, but exit no
11472 /* Do we at least have room for a macinfo type byte? */
11473 if (mac_ptr
>= mac_end
)
11475 dwarf2_macros_too_long_complaint ();
11479 /* We don't increment mac_ptr here, so this is just
11481 next_type
= read_1_byte (abfd
, mac_ptr
);
11482 if (next_type
!= 0)
11483 complaint (&symfile_complaints
,
11484 _("no terminating 0-type entry for macros in `.debug_macinfo' section"));
11491 case DW_MACINFO_vendor_ext
:
11493 unsigned int bytes_read
;
11497 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
11498 mac_ptr
+= bytes_read
;
11499 string
= read_string (abfd
, mac_ptr
, &bytes_read
);
11500 mac_ptr
+= bytes_read
;
11502 /* We don't recognize any vendor extensions. */
11506 } while (macinfo_type
!= 0);
11509 /* Check if the attribute's form is a DW_FORM_block*
11510 if so return true else false. */
11512 attr_form_is_block (struct attribute
*attr
)
11514 return (attr
== NULL
? 0 :
11515 attr
->form
== DW_FORM_block1
11516 || attr
->form
== DW_FORM_block2
11517 || attr
->form
== DW_FORM_block4
11518 || attr
->form
== DW_FORM_block
);
11521 /* Return non-zero if ATTR's value is a section offset --- classes
11522 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
11523 You may use DW_UNSND (attr) to retrieve such offsets.
11525 Section 7.5.4, "Attribute Encodings", explains that no attribute
11526 may have a value that belongs to more than one of these classes; it
11527 would be ambiguous if we did, because we use the same forms for all
11530 attr_form_is_section_offset (struct attribute
*attr
)
11532 return (attr
->form
== DW_FORM_data4
11533 || attr
->form
== DW_FORM_data8
);
11537 /* Return non-zero if ATTR's value falls in the 'constant' class, or
11538 zero otherwise. When this function returns true, you can apply
11539 dwarf2_get_attr_constant_value to it.
11541 However, note that for some attributes you must check
11542 attr_form_is_section_offset before using this test. DW_FORM_data4
11543 and DW_FORM_data8 are members of both the constant class, and of
11544 the classes that contain offsets into other debug sections
11545 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
11546 that, if an attribute's can be either a constant or one of the
11547 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
11548 taken as section offsets, not constants. */
11550 attr_form_is_constant (struct attribute
*attr
)
11552 switch (attr
->form
)
11554 case DW_FORM_sdata
:
11555 case DW_FORM_udata
:
11556 case DW_FORM_data1
:
11557 case DW_FORM_data2
:
11558 case DW_FORM_data4
:
11559 case DW_FORM_data8
:
11567 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
11568 struct dwarf2_cu
*cu
)
11570 if (attr_form_is_section_offset (attr
)
11571 /* ".debug_loc" may not exist at all, or the offset may be outside
11572 the section. If so, fall through to the complaint in the
11574 && DW_UNSND (attr
) < dwarf2_per_objfile
->loc
.size
)
11576 struct dwarf2_loclist_baton
*baton
;
11578 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
11579 sizeof (struct dwarf2_loclist_baton
));
11580 baton
->per_cu
= cu
->per_cu
;
11581 gdb_assert (baton
->per_cu
);
11583 dwarf2_read_section (dwarf2_per_objfile
->objfile
,
11584 &dwarf2_per_objfile
->loc
);
11586 /* We don't know how long the location list is, but make sure we
11587 don't run off the edge of the section. */
11588 baton
->size
= dwarf2_per_objfile
->loc
.size
- DW_UNSND (attr
);
11589 baton
->data
= dwarf2_per_objfile
->loc
.buffer
+ DW_UNSND (attr
);
11590 baton
->base_address
= cu
->base_address
;
11591 if (cu
->base_known
== 0)
11592 complaint (&symfile_complaints
,
11593 _("Location list used without specifying the CU base address."));
11595 SYMBOL_COMPUTED_OPS (sym
) = &dwarf2_loclist_funcs
;
11596 SYMBOL_LOCATION_BATON (sym
) = baton
;
11600 struct dwarf2_locexpr_baton
*baton
;
11602 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
11603 sizeof (struct dwarf2_locexpr_baton
));
11604 baton
->per_cu
= cu
->per_cu
;
11605 gdb_assert (baton
->per_cu
);
11607 if (attr_form_is_block (attr
))
11609 /* Note that we're just copying the block's data pointer
11610 here, not the actual data. We're still pointing into the
11611 info_buffer for SYM's objfile; right now we never release
11612 that buffer, but when we do clean up properly this may
11614 baton
->size
= DW_BLOCK (attr
)->size
;
11615 baton
->data
= DW_BLOCK (attr
)->data
;
11619 dwarf2_invalid_attrib_class_complaint ("location description",
11620 SYMBOL_NATURAL_NAME (sym
));
11622 baton
->data
= NULL
;
11625 SYMBOL_COMPUTED_OPS (sym
) = &dwarf2_locexpr_funcs
;
11626 SYMBOL_LOCATION_BATON (sym
) = baton
;
11630 /* Return the OBJFILE associated with the compilation unit CU. */
11633 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data
*per_cu
)
11635 struct objfile
*objfile
= per_cu
->psymtab
->objfile
;
11637 /* Return the master objfile, so that we can report and look up the
11638 correct file containing this variable. */
11639 if (objfile
->separate_debug_objfile_backlink
)
11640 objfile
= objfile
->separate_debug_objfile_backlink
;
11645 /* Return the address size given in the compilation unit header for CU. */
11648 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data
*per_cu
)
11651 return per_cu
->cu
->header
.addr_size
;
11654 /* If the CU is not currently read in, we re-read its header. */
11655 struct objfile
*objfile
= per_cu
->psymtab
->objfile
;
11656 struct dwarf2_per_objfile
*per_objfile
11657 = objfile_data (objfile
, dwarf2_objfile_data_key
);
11658 gdb_byte
*info_ptr
= per_objfile
->info
.buffer
+ per_cu
->offset
;
11660 struct comp_unit_head cu_header
;
11661 memset (&cu_header
, 0, sizeof cu_header
);
11662 read_comp_unit_head (&cu_header
, info_ptr
, objfile
->obfd
);
11663 return cu_header
.addr_size
;
11667 /* Locate the .debug_info compilation unit from CU's objfile which contains
11668 the DIE at OFFSET. Raises an error on failure. */
11670 static struct dwarf2_per_cu_data
*
11671 dwarf2_find_containing_comp_unit (unsigned int offset
,
11672 struct objfile
*objfile
)
11674 struct dwarf2_per_cu_data
*this_cu
;
11678 high
= dwarf2_per_objfile
->n_comp_units
- 1;
11681 int mid
= low
+ (high
- low
) / 2;
11682 if (dwarf2_per_objfile
->all_comp_units
[mid
]->offset
>= offset
)
11687 gdb_assert (low
== high
);
11688 if (dwarf2_per_objfile
->all_comp_units
[low
]->offset
> offset
)
11691 error (_("Dwarf Error: could not find partial DIE containing "
11692 "offset 0x%lx [in module %s]"),
11693 (long) offset
, bfd_get_filename (objfile
->obfd
));
11695 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
<= offset
);
11696 return dwarf2_per_objfile
->all_comp_units
[low
-1];
11700 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
11701 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
11702 && offset
>= this_cu
->offset
+ this_cu
->length
)
11703 error (_("invalid dwarf2 offset %u"), offset
);
11704 gdb_assert (offset
< this_cu
->offset
+ this_cu
->length
);
11709 /* Locate the compilation unit from OBJFILE which is located at exactly
11710 OFFSET. Raises an error on failure. */
11712 static struct dwarf2_per_cu_data
*
11713 dwarf2_find_comp_unit (unsigned int offset
, struct objfile
*objfile
)
11715 struct dwarf2_per_cu_data
*this_cu
;
11716 this_cu
= dwarf2_find_containing_comp_unit (offset
, objfile
);
11717 if (this_cu
->offset
!= offset
)
11718 error (_("no compilation unit with offset %u."), offset
);
11722 /* Malloc space for a dwarf2_cu for OBJFILE and initialize it. */
11724 static struct dwarf2_cu
*
11725 alloc_one_comp_unit (struct objfile
*objfile
)
11727 struct dwarf2_cu
*cu
= xcalloc (1, sizeof (struct dwarf2_cu
));
11728 cu
->objfile
= objfile
;
11729 obstack_init (&cu
->comp_unit_obstack
);
11733 /* Release one cached compilation unit, CU. We unlink it from the tree
11734 of compilation units, but we don't remove it from the read_in_chain;
11735 the caller is responsible for that.
11736 NOTE: DATA is a void * because this function is also used as a
11737 cleanup routine. */
11740 free_one_comp_unit (void *data
)
11742 struct dwarf2_cu
*cu
= data
;
11744 if (cu
->per_cu
!= NULL
)
11745 cu
->per_cu
->cu
= NULL
;
11748 obstack_free (&cu
->comp_unit_obstack
, NULL
);
11753 /* This cleanup function is passed the address of a dwarf2_cu on the stack
11754 when we're finished with it. We can't free the pointer itself, but be
11755 sure to unlink it from the cache. Also release any associated storage
11756 and perform cache maintenance.
11758 Only used during partial symbol parsing. */
11761 free_stack_comp_unit (void *data
)
11763 struct dwarf2_cu
*cu
= data
;
11765 obstack_free (&cu
->comp_unit_obstack
, NULL
);
11766 cu
->partial_dies
= NULL
;
11768 if (cu
->per_cu
!= NULL
)
11770 /* This compilation unit is on the stack in our caller, so we
11771 should not xfree it. Just unlink it. */
11772 cu
->per_cu
->cu
= NULL
;
11775 /* If we had a per-cu pointer, then we may have other compilation
11776 units loaded, so age them now. */
11777 age_cached_comp_units ();
11781 /* Free all cached compilation units. */
11784 free_cached_comp_units (void *data
)
11786 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
11788 per_cu
= dwarf2_per_objfile
->read_in_chain
;
11789 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
11790 while (per_cu
!= NULL
)
11792 struct dwarf2_per_cu_data
*next_cu
;
11794 next_cu
= per_cu
->cu
->read_in_chain
;
11796 free_one_comp_unit (per_cu
->cu
);
11797 *last_chain
= next_cu
;
11803 /* Increase the age counter on each cached compilation unit, and free
11804 any that are too old. */
11807 age_cached_comp_units (void)
11809 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
11811 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
11812 per_cu
= dwarf2_per_objfile
->read_in_chain
;
11813 while (per_cu
!= NULL
)
11815 per_cu
->cu
->last_used
++;
11816 if (per_cu
->cu
->last_used
<= dwarf2_max_cache_age
)
11817 dwarf2_mark (per_cu
->cu
);
11818 per_cu
= per_cu
->cu
->read_in_chain
;
11821 per_cu
= dwarf2_per_objfile
->read_in_chain
;
11822 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
11823 while (per_cu
!= NULL
)
11825 struct dwarf2_per_cu_data
*next_cu
;
11827 next_cu
= per_cu
->cu
->read_in_chain
;
11829 if (!per_cu
->cu
->mark
)
11831 free_one_comp_unit (per_cu
->cu
);
11832 *last_chain
= next_cu
;
11835 last_chain
= &per_cu
->cu
->read_in_chain
;
11841 /* Remove a single compilation unit from the cache. */
11844 free_one_cached_comp_unit (void *target_cu
)
11846 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
11848 per_cu
= dwarf2_per_objfile
->read_in_chain
;
11849 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
11850 while (per_cu
!= NULL
)
11852 struct dwarf2_per_cu_data
*next_cu
;
11854 next_cu
= per_cu
->cu
->read_in_chain
;
11856 if (per_cu
->cu
== target_cu
)
11858 free_one_comp_unit (per_cu
->cu
);
11859 *last_chain
= next_cu
;
11863 last_chain
= &per_cu
->cu
->read_in_chain
;
11869 /* Release all extra memory associated with OBJFILE. */
11872 dwarf2_free_objfile (struct objfile
*objfile
)
11874 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
11876 if (dwarf2_per_objfile
== NULL
)
11879 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
11880 free_cached_comp_units (NULL
);
11882 /* Everything else should be on the objfile obstack. */
11885 /* A pair of DIE offset and GDB type pointer. We store these
11886 in a hash table separate from the DIEs, and preserve them
11887 when the DIEs are flushed out of cache. */
11889 struct dwarf2_offset_and_type
11891 unsigned int offset
;
11895 /* Hash function for a dwarf2_offset_and_type. */
11898 offset_and_type_hash (const void *item
)
11900 const struct dwarf2_offset_and_type
*ofs
= item
;
11901 return ofs
->offset
;
11904 /* Equality function for a dwarf2_offset_and_type. */
11907 offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
11909 const struct dwarf2_offset_and_type
*ofs_lhs
= item_lhs
;
11910 const struct dwarf2_offset_and_type
*ofs_rhs
= item_rhs
;
11911 return ofs_lhs
->offset
== ofs_rhs
->offset
;
11914 /* Set the type associated with DIE to TYPE. Save it in CU's hash
11915 table if necessary. For convenience, return TYPE. */
11917 static struct type
*
11918 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
11920 struct dwarf2_offset_and_type
**slot
, ofs
;
11922 /* For Ada types, make sure that the gnat-specific data is always
11923 initialized (if not already set). There are a few types where
11924 we should not be doing so, because the type-specific area is
11925 already used to hold some other piece of info (eg: TYPE_CODE_FLT
11926 where the type-specific area is used to store the floatformat).
11927 But this is not a problem, because the gnat-specific information
11928 is actually not needed for these types. */
11929 if (need_gnat_info (cu
)
11930 && TYPE_CODE (type
) != TYPE_CODE_FUNC
11931 && TYPE_CODE (type
) != TYPE_CODE_FLT
11932 && !HAVE_GNAT_AUX_INFO (type
))
11933 INIT_GNAT_SPECIFIC (type
);
11935 if (cu
->type_hash
== NULL
)
11937 gdb_assert (cu
->per_cu
!= NULL
);
11938 cu
->per_cu
->type_hash
11939 = htab_create_alloc_ex (cu
->header
.length
/ 24,
11940 offset_and_type_hash
,
11941 offset_and_type_eq
,
11943 &cu
->objfile
->objfile_obstack
,
11944 hashtab_obstack_allocate
,
11945 dummy_obstack_deallocate
);
11946 cu
->type_hash
= cu
->per_cu
->type_hash
;
11949 ofs
.offset
= die
->offset
;
11951 slot
= (struct dwarf2_offset_and_type
**)
11952 htab_find_slot_with_hash (cu
->type_hash
, &ofs
, ofs
.offset
, INSERT
);
11953 *slot
= obstack_alloc (&cu
->objfile
->objfile_obstack
, sizeof (**slot
));
11958 /* Find the type for DIE in CU's type_hash, or return NULL if DIE does
11959 not have a saved type. */
11961 static struct type
*
11962 get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
11964 struct dwarf2_offset_and_type
*slot
, ofs
;
11965 htab_t type_hash
= cu
->type_hash
;
11967 if (type_hash
== NULL
)
11970 ofs
.offset
= die
->offset
;
11971 slot
= htab_find_with_hash (type_hash
, &ofs
, ofs
.offset
);
11978 /* Add a dependence relationship from CU to REF_PER_CU. */
11981 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
11982 struct dwarf2_per_cu_data
*ref_per_cu
)
11986 if (cu
->dependencies
== NULL
)
11988 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
11989 NULL
, &cu
->comp_unit_obstack
,
11990 hashtab_obstack_allocate
,
11991 dummy_obstack_deallocate
);
11993 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
11995 *slot
= ref_per_cu
;
11998 /* Subroutine of dwarf2_mark to pass to htab_traverse.
11999 Set the mark field in every compilation unit in the
12000 cache that we must keep because we are keeping CU. */
12003 dwarf2_mark_helper (void **slot
, void *data
)
12005 struct dwarf2_per_cu_data
*per_cu
;
12007 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
12008 if (per_cu
->cu
->mark
)
12010 per_cu
->cu
->mark
= 1;
12012 if (per_cu
->cu
->dependencies
!= NULL
)
12013 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
12018 /* Set the mark field in CU and in every other compilation unit in the
12019 cache that we must keep because we are keeping CU. */
12022 dwarf2_mark (struct dwarf2_cu
*cu
)
12027 if (cu
->dependencies
!= NULL
)
12028 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
12032 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
12036 per_cu
->cu
->mark
= 0;
12037 per_cu
= per_cu
->cu
->read_in_chain
;
12041 /* Trivial hash function for partial_die_info: the hash value of a DIE
12042 is its offset in .debug_info for this objfile. */
12045 partial_die_hash (const void *item
)
12047 const struct partial_die_info
*part_die
= item
;
12048 return part_die
->offset
;
12051 /* Trivial comparison function for partial_die_info structures: two DIEs
12052 are equal if they have the same offset. */
12055 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
12057 const struct partial_die_info
*part_die_lhs
= item_lhs
;
12058 const struct partial_die_info
*part_die_rhs
= item_rhs
;
12059 return part_die_lhs
->offset
== part_die_rhs
->offset
;
12062 static struct cmd_list_element
*set_dwarf2_cmdlist
;
12063 static struct cmd_list_element
*show_dwarf2_cmdlist
;
12066 set_dwarf2_cmd (char *args
, int from_tty
)
12068 help_list (set_dwarf2_cmdlist
, "maintenance set dwarf2 ", -1, gdb_stdout
);
12072 show_dwarf2_cmd (char *args
, int from_tty
)
12074 cmd_show_list (show_dwarf2_cmdlist
, from_tty
, "");
12077 /* If section described by INFO was mmapped, munmap it now. */
12080 munmap_section_buffer (struct dwarf2_section_info
*info
)
12082 if (info
->was_mmapped
)
12085 intptr_t begin
= (intptr_t) info
->buffer
;
12086 intptr_t map_begin
= begin
& ~(pagesize
- 1);
12087 size_t map_length
= info
->size
+ begin
- map_begin
;
12088 gdb_assert (munmap ((void *) map_begin
, map_length
) == 0);
12090 /* Without HAVE_MMAP, we should never be here to begin with. */
12096 /* munmap debug sections for OBJFILE, if necessary. */
12099 dwarf2_per_objfile_free (struct objfile
*objfile
, void *d
)
12101 struct dwarf2_per_objfile
*data
= d
;
12102 munmap_section_buffer (&data
->info
);
12103 munmap_section_buffer (&data
->abbrev
);
12104 munmap_section_buffer (&data
->line
);
12105 munmap_section_buffer (&data
->str
);
12106 munmap_section_buffer (&data
->macinfo
);
12107 munmap_section_buffer (&data
->ranges
);
12108 munmap_section_buffer (&data
->loc
);
12109 munmap_section_buffer (&data
->frame
);
12110 munmap_section_buffer (&data
->eh_frame
);
12113 void _initialize_dwarf2_read (void);
12116 _initialize_dwarf2_read (void)
12118 dwarf2_objfile_data_key
12119 = register_objfile_data_with_cleanup (NULL
, dwarf2_per_objfile_free
);
12121 add_prefix_cmd ("dwarf2", class_maintenance
, set_dwarf2_cmd
, _("\
12122 Set DWARF 2 specific variables.\n\
12123 Configure DWARF 2 variables such as the cache size"),
12124 &set_dwarf2_cmdlist
, "maintenance set dwarf2 ",
12125 0/*allow-unknown*/, &maintenance_set_cmdlist
);
12127 add_prefix_cmd ("dwarf2", class_maintenance
, show_dwarf2_cmd
, _("\
12128 Show DWARF 2 specific variables\n\
12129 Show DWARF 2 variables such as the cache size"),
12130 &show_dwarf2_cmdlist
, "maintenance show dwarf2 ",
12131 0/*allow-unknown*/, &maintenance_show_cmdlist
);
12133 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
12134 &dwarf2_max_cache_age
, _("\
12135 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
12136 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
12137 A higher limit means that cached compilation units will be stored\n\
12138 in memory longer, and more total memory will be used. Zero disables\n\
12139 caching, which can slow down startup."),
12141 show_dwarf2_max_cache_age
,
12142 &set_dwarf2_cmdlist
,
12143 &show_dwarf2_cmdlist
);
12145 add_setshow_zinteger_cmd ("dwarf2-die", no_class
, &dwarf2_die_debug
, _("\
12146 Set debugging of the dwarf2 DIE reader."), _("\
12147 Show debugging of the dwarf2 DIE reader."), _("\
12148 When enabled (non-zero), DIEs are dumped after they are read in.\n\
12149 The value is the maximum depth to print."),
12152 &setdebuglist
, &showdebuglist
);