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"
55 #include "gdb_string.h"
56 #include "gdb_assert.h"
57 #include <sys/types.h>
64 #define MAP_FAILED ((void *) -1)
69 /* .debug_info header for a compilation unit
70 Because of alignment constraints, this structure has padding and cannot
71 be mapped directly onto the beginning of the .debug_info section. */
72 typedef struct comp_unit_header
74 unsigned int length
; /* length of the .debug_info
76 unsigned short version
; /* version number -- 2 for DWARF
78 unsigned int abbrev_offset
; /* offset into .debug_abbrev section */
79 unsigned char addr_size
; /* byte size of an address -- 4 */
82 #define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
85 /* .debug_pubnames header
86 Because of alignment constraints, this structure has padding and cannot
87 be mapped directly onto the beginning of the .debug_info section. */
88 typedef struct pubnames_header
90 unsigned int length
; /* length of the .debug_pubnames
92 unsigned char version
; /* version number -- 2 for DWARF
94 unsigned int info_offset
; /* offset into .debug_info section */
95 unsigned int info_size
; /* byte size of .debug_info section
99 #define _ACTUAL_PUBNAMES_HEADER_SIZE 13
101 /* .debug_pubnames header
102 Because of alignment constraints, this structure has padding and cannot
103 be mapped directly onto the beginning of the .debug_info section. */
104 typedef struct aranges_header
106 unsigned int length
; /* byte len of the .debug_aranges
108 unsigned short version
; /* version number -- 2 for DWARF
110 unsigned int info_offset
; /* offset into .debug_info section */
111 unsigned char addr_size
; /* byte size of an address */
112 unsigned char seg_size
; /* byte size of segment descriptor */
115 #define _ACTUAL_ARANGES_HEADER_SIZE 12
117 /* .debug_line statement program prologue
118 Because of alignment constraints, this structure has padding and cannot
119 be mapped directly onto the beginning of the .debug_info section. */
120 typedef struct statement_prologue
122 unsigned int total_length
; /* byte length of the statement
124 unsigned short version
; /* version number -- 2 for DWARF
126 unsigned int prologue_length
; /* # bytes between prologue &
128 unsigned char minimum_instruction_length
; /* byte size of
130 unsigned char default_is_stmt
; /* initial value of is_stmt
133 unsigned char line_range
;
134 unsigned char opcode_base
; /* number assigned to first special
136 unsigned char *standard_opcode_lengths
;
140 /* When non-zero, dump DIEs after they are read in. */
141 static int dwarf2_die_debug
= 0;
145 /* When set, the file that we're processing is known to have debugging
146 info for C++ namespaces. GCC 3.3.x did not produce this information,
147 but later versions do. */
149 static int processing_has_namespace_info
;
151 static const struct objfile_data
*dwarf2_objfile_data_key
;
153 struct dwarf2_section_info
161 struct dwarf2_per_objfile
163 struct dwarf2_section_info info
;
164 struct dwarf2_section_info abbrev
;
165 struct dwarf2_section_info line
;
166 struct dwarf2_section_info pubnames
;
167 struct dwarf2_section_info aranges
;
168 struct dwarf2_section_info loc
;
169 struct dwarf2_section_info macinfo
;
170 struct dwarf2_section_info str
;
171 struct dwarf2_section_info ranges
;
172 struct dwarf2_section_info types
;
173 struct dwarf2_section_info frame
;
174 struct dwarf2_section_info eh_frame
;
176 /* A list of all the compilation units. This is used to locate
177 the target compilation unit of a particular reference. */
178 struct dwarf2_per_cu_data
**all_comp_units
;
180 /* The number of compilation units in ALL_COMP_UNITS. */
183 /* A chain of compilation units that are currently read in, so that
184 they can be freed later. */
185 struct dwarf2_per_cu_data
*read_in_chain
;
187 /* A table mapping .debug_types signatures to its signatured_type entry.
188 This is NULL if the .debug_types section hasn't been read in yet. */
189 htab_t signatured_types
;
191 /* A flag indicating wether this objfile has a section loaded at a
193 int has_section_at_zero
;
196 static struct dwarf2_per_objfile
*dwarf2_per_objfile
;
198 /* names of the debugging sections */
200 /* Note that if the debugging section has been compressed, it might
201 have a name like .zdebug_info. */
203 #define INFO_SECTION "debug_info"
204 #define ABBREV_SECTION "debug_abbrev"
205 #define LINE_SECTION "debug_line"
206 #define PUBNAMES_SECTION "debug_pubnames"
207 #define ARANGES_SECTION "debug_aranges"
208 #define LOC_SECTION "debug_loc"
209 #define MACINFO_SECTION "debug_macinfo"
210 #define STR_SECTION "debug_str"
211 #define RANGES_SECTION "debug_ranges"
212 #define TYPES_SECTION "debug_types"
213 #define FRAME_SECTION "debug_frame"
214 #define EH_FRAME_SECTION "eh_frame"
216 /* local data types */
218 /* We hold several abbreviation tables in memory at the same time. */
219 #ifndef ABBREV_HASH_SIZE
220 #define ABBREV_HASH_SIZE 121
223 /* The data in a compilation unit header, after target2host
224 translation, looks like this. */
225 struct comp_unit_head
229 unsigned char addr_size
;
230 unsigned char signed_addr_p
;
231 unsigned int abbrev_offset
;
233 /* Size of file offsets; either 4 or 8. */
234 unsigned int offset_size
;
236 /* Size of the length field; either 4 or 12. */
237 unsigned int initial_length_size
;
239 /* Offset to the first byte of this compilation unit header in the
240 .debug_info section, for resolving relative reference dies. */
243 /* Offset to first die in this cu from the start of the cu.
244 This will be the first byte following the compilation unit header. */
245 unsigned int first_die_offset
;
248 /* Internal state when decoding a particular compilation unit. */
251 /* The objfile containing this compilation unit. */
252 struct objfile
*objfile
;
254 /* The header of the compilation unit. */
255 struct comp_unit_head header
;
257 /* Base address of this compilation unit. */
258 CORE_ADDR base_address
;
260 /* Non-zero if base_address has been set. */
263 struct function_range
*first_fn
, *last_fn
, *cached_fn
;
265 /* The language we are debugging. */
266 enum language language
;
267 const struct language_defn
*language_defn
;
269 const char *producer
;
271 /* The generic symbol table building routines have separate lists for
272 file scope symbols and all all other scopes (local scopes). So
273 we need to select the right one to pass to add_symbol_to_list().
274 We do it by keeping a pointer to the correct list in list_in_scope.
276 FIXME: The original dwarf code just treated the file scope as the
277 first local scope, and all other local scopes as nested local
278 scopes, and worked fine. Check to see if we really need to
279 distinguish these in buildsym.c. */
280 struct pending
**list_in_scope
;
282 /* DWARF abbreviation table associated with this compilation unit. */
283 struct abbrev_info
**dwarf2_abbrevs
;
285 /* Storage for the abbrev table. */
286 struct obstack abbrev_obstack
;
288 /* Hash table holding all the loaded partial DIEs. */
291 /* Storage for things with the same lifetime as this read-in compilation
292 unit, including partial DIEs. */
293 struct obstack comp_unit_obstack
;
295 /* When multiple dwarf2_cu structures are living in memory, this field
296 chains them all together, so that they can be released efficiently.
297 We will probably also want a generation counter so that most-recently-used
298 compilation units are cached... */
299 struct dwarf2_per_cu_data
*read_in_chain
;
301 /* Backchain to our per_cu entry if the tree has been built. */
302 struct dwarf2_per_cu_data
*per_cu
;
304 /* Pointer to the die -> type map. Although it is stored
305 permanently in per_cu, we copy it here to avoid double
309 /* How many compilation units ago was this CU last referenced? */
312 /* A hash table of die offsets for following references. */
315 /* Full DIEs if read in. */
316 struct die_info
*dies
;
318 /* A set of pointers to dwarf2_per_cu_data objects for compilation
319 units referenced by this one. Only set during full symbol processing;
320 partial symbol tables do not have dependencies. */
323 /* Header data from the line table, during full symbol processing. */
324 struct line_header
*line_header
;
326 /* Mark used when releasing cached dies. */
327 unsigned int mark
: 1;
329 /* This flag will be set if this compilation unit might include
330 inter-compilation-unit references. */
331 unsigned int has_form_ref_addr
: 1;
333 /* This flag will be set if this compilation unit includes any
334 DW_TAG_namespace DIEs. If we know that there are explicit
335 DIEs for namespaces, we don't need to try to infer them
336 from mangled names. */
337 unsigned int has_namespace_info
: 1;
340 /* Persistent data held for a compilation unit, even when not
341 processing it. We put a pointer to this structure in the
342 read_symtab_private field of the psymtab. If we encounter
343 inter-compilation-unit references, we also maintain a sorted
344 list of all compilation units. */
346 struct dwarf2_per_cu_data
348 /* The start offset and length of this compilation unit. 2**29-1
349 bytes should suffice to store the length of any compilation unit
350 - if it doesn't, GDB will fall over anyway.
351 NOTE: Unlike comp_unit_head.length, this length includes
352 initial_length_size. */
354 unsigned int length
: 29;
356 /* Flag indicating this compilation unit will be read in before
357 any of the current compilation units are processed. */
358 unsigned int queued
: 1;
360 /* This flag will be set if we need to load absolutely all DIEs
361 for this compilation unit, instead of just the ones we think
362 are interesting. It gets set if we look for a DIE in the
363 hash table and don't find it. */
364 unsigned int load_all_dies
: 1;
366 /* Non-zero if this CU is from .debug_types.
367 Otherwise it's from .debug_info. */
368 unsigned int from_debug_types
: 1;
370 /* Set iff currently read in. */
371 struct dwarf2_cu
*cu
;
373 /* If full symbols for this CU have been read in, then this field
374 holds a map of DIE offsets to types. It isn't always possible
375 to reconstruct this information later, so we have to preserve
379 /* The partial symbol table associated with this compilation unit,
380 or NULL for partial units (which do not have an associated
382 struct partial_symtab
*psymtab
;
385 /* Entry in the signatured_types hash table. */
387 struct signatured_type
391 /* Offset in .debug_types of the TU (type_unit) for this type. */
394 /* Offset in .debug_types of the type defined by this TU. */
395 unsigned int type_offset
;
397 /* The CU(/TU) of this type. */
398 struct dwarf2_per_cu_data per_cu
;
401 /* Struct used to pass misc. parameters to read_die_and_children, et. al.
402 which are used for both .debug_info and .debug_types dies.
403 All parameters here are unchanging for the life of the call.
404 This struct exists to abstract away the constant parameters of
407 struct die_reader_specs
409 /* The bfd of this objfile. */
412 /* The CU of the DIE we are parsing. */
413 struct dwarf2_cu
*cu
;
415 /* Pointer to start of section buffer.
416 This is either the start of .debug_info or .debug_types. */
417 const gdb_byte
*buffer
;
420 /* The line number information for a compilation unit (found in the
421 .debug_line section) begins with a "statement program header",
422 which contains the following information. */
425 unsigned int total_length
;
426 unsigned short version
;
427 unsigned int header_length
;
428 unsigned char minimum_instruction_length
;
429 unsigned char default_is_stmt
;
431 unsigned char line_range
;
432 unsigned char opcode_base
;
434 /* standard_opcode_lengths[i] is the number of operands for the
435 standard opcode whose value is i. This means that
436 standard_opcode_lengths[0] is unused, and the last meaningful
437 element is standard_opcode_lengths[opcode_base - 1]. */
438 unsigned char *standard_opcode_lengths
;
440 /* The include_directories table. NOTE! These strings are not
441 allocated with xmalloc; instead, they are pointers into
442 debug_line_buffer. If you try to free them, `free' will get
444 unsigned int num_include_dirs
, include_dirs_size
;
447 /* The file_names table. NOTE! These strings are not allocated
448 with xmalloc; instead, they are pointers into debug_line_buffer.
449 Don't try to free them directly. */
450 unsigned int num_file_names
, file_names_size
;
454 unsigned int dir_index
;
455 unsigned int mod_time
;
457 int included_p
; /* Non-zero if referenced by the Line Number Program. */
458 struct symtab
*symtab
; /* The associated symbol table, if any. */
461 /* The start and end of the statement program following this
462 header. These point into dwarf2_per_objfile->line_buffer. */
463 gdb_byte
*statement_program_start
, *statement_program_end
;
466 /* When we construct a partial symbol table entry we only
467 need this much information. */
468 struct partial_die_info
470 /* Offset of this DIE. */
473 /* DWARF-2 tag for this DIE. */
474 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
476 /* Assorted flags describing the data found in this DIE. */
477 unsigned int has_children
: 1;
478 unsigned int is_external
: 1;
479 unsigned int is_declaration
: 1;
480 unsigned int has_type
: 1;
481 unsigned int has_specification
: 1;
482 unsigned int has_pc_info
: 1;
484 /* Flag set if the SCOPE field of this structure has been
486 unsigned int scope_set
: 1;
488 /* Flag set if the DIE has a byte_size attribute. */
489 unsigned int has_byte_size
: 1;
491 /* The name of this DIE. Normally the value of DW_AT_name, but
492 sometimes a default name for unnamed DIEs. */
495 /* The scope to prepend to our children. This is generally
496 allocated on the comp_unit_obstack, so will disappear
497 when this compilation unit leaves the cache. */
500 /* The location description associated with this DIE, if any. */
501 struct dwarf_block
*locdesc
;
503 /* If HAS_PC_INFO, the PC range associated with this DIE. */
507 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
508 DW_AT_sibling, if any. */
511 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
512 DW_AT_specification (or DW_AT_abstract_origin or
514 unsigned int spec_offset
;
516 /* Pointers to this DIE's parent, first child, and next sibling,
518 struct partial_die_info
*die_parent
, *die_child
, *die_sibling
;
521 /* This data structure holds the information of an abbrev. */
524 unsigned int number
; /* number identifying abbrev */
525 enum dwarf_tag tag
; /* dwarf tag */
526 unsigned short has_children
; /* boolean */
527 unsigned short num_attrs
; /* number of attributes */
528 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
529 struct abbrev_info
*next
; /* next in chain */
534 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
535 ENUM_BITFIELD(dwarf_form
) form
: 16;
538 /* Attributes have a name and a value */
541 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
542 ENUM_BITFIELD(dwarf_form
) form
: 15;
544 /* Has DW_STRING already been updated by dwarf2_canonicalize_name? This
545 field should be in u.str (existing only for DW_STRING) but it is kept
546 here for better struct attribute alignment. */
547 unsigned int string_is_canonical
: 1;
552 struct dwarf_block
*blk
;
556 struct signatured_type
*signatured_type
;
561 /* This data structure holds a complete die structure. */
564 /* DWARF-2 tag for this DIE. */
565 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
567 /* Number of attributes */
568 unsigned short num_attrs
;
573 /* Offset in .debug_info or .debug_types section. */
576 /* The dies in a compilation unit form an n-ary tree. PARENT
577 points to this die's parent; CHILD points to the first child of
578 this node; and all the children of a given node are chained
579 together via their SIBLING fields, terminated by a die whose
581 struct die_info
*child
; /* Its first child, if any. */
582 struct die_info
*sibling
; /* Its next sibling, if any. */
583 struct die_info
*parent
; /* Its parent, if any. */
585 /* An array of attributes, with NUM_ATTRS elements. There may be
586 zero, but it's not common and zero-sized arrays are not
587 sufficiently portable C. */
588 struct attribute attrs
[1];
591 struct function_range
594 CORE_ADDR lowpc
, highpc
;
596 struct function_range
*next
;
599 /* Get at parts of an attribute structure */
601 #define DW_STRING(attr) ((attr)->u.str)
602 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
603 #define DW_UNSND(attr) ((attr)->u.unsnd)
604 #define DW_BLOCK(attr) ((attr)->u.blk)
605 #define DW_SND(attr) ((attr)->u.snd)
606 #define DW_ADDR(attr) ((attr)->u.addr)
607 #define DW_SIGNATURED_TYPE(attr) ((attr)->u.signatured_type)
609 /* Blocks are a bunch of untyped bytes. */
616 #ifndef ATTR_ALLOC_CHUNK
617 #define ATTR_ALLOC_CHUNK 4
620 /* Allocate fields for structs, unions and enums in this size. */
621 #ifndef DW_FIELD_ALLOC_CHUNK
622 #define DW_FIELD_ALLOC_CHUNK 4
625 /* A zeroed version of a partial die for initialization purposes. */
626 static struct partial_die_info zeroed_partial_die
;
628 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
629 but this would require a corresponding change in unpack_field_as_long
631 static int bits_per_byte
= 8;
633 /* The routines that read and process dies for a C struct or C++ class
634 pass lists of data member fields and lists of member function fields
635 in an instance of a field_info structure, as defined below. */
638 /* List of data member and baseclasses fields. */
641 struct nextfield
*next
;
646 *fields
, *baseclasses
;
648 /* Number of fields (including baseclasses). */
651 /* Number of baseclasses. */
654 /* Set if the accesibility of one of the fields is not public. */
655 int non_public_fields
;
657 /* Member function fields array, entries are allocated in the order they
658 are encountered in the object file. */
661 struct nextfnfield
*next
;
662 struct fn_field fnfield
;
666 /* Member function fieldlist array, contains name of possibly overloaded
667 member function, number of overloaded member functions and a pointer
668 to the head of the member function field chain. */
673 struct nextfnfield
*head
;
677 /* Number of entries in the fnfieldlists array. */
681 /* One item on the queue of compilation units to read in full symbols
683 struct dwarf2_queue_item
685 struct dwarf2_per_cu_data
*per_cu
;
686 struct dwarf2_queue_item
*next
;
689 /* The current queue. */
690 static struct dwarf2_queue_item
*dwarf2_queue
, *dwarf2_queue_tail
;
692 /* Loaded secondary compilation units are kept in memory until they
693 have not been referenced for the processing of this many
694 compilation units. Set this to zero to disable caching. Cache
695 sizes of up to at least twenty will improve startup time for
696 typical inter-CU-reference binaries, at an obvious memory cost. */
697 static int dwarf2_max_cache_age
= 5;
699 show_dwarf2_max_cache_age (struct ui_file
*file
, int from_tty
,
700 struct cmd_list_element
*c
, const char *value
)
702 fprintf_filtered (file
, _("\
703 The upper bound on the age of cached dwarf2 compilation units is %s.\n"),
708 /* Various complaints about symbol reading that don't abort the process */
711 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
713 complaint (&symfile_complaints
,
714 _("statement list doesn't fit in .debug_line section"));
718 dwarf2_debug_line_missing_file_complaint (void)
720 complaint (&symfile_complaints
,
721 _(".debug_line section has line data without a file"));
725 dwarf2_debug_line_missing_end_sequence_complaint (void)
727 complaint (&symfile_complaints
,
728 _(".debug_line section has line program sequence without an end"));
732 dwarf2_complex_location_expr_complaint (void)
734 complaint (&symfile_complaints
, _("location expression too complex"));
738 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
741 complaint (&symfile_complaints
,
742 _("const value length mismatch for '%s', got %d, expected %d"), arg1
,
747 dwarf2_macros_too_long_complaint (void)
749 complaint (&symfile_complaints
,
750 _("macro info runs off end of `.debug_macinfo' section"));
754 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
756 complaint (&symfile_complaints
,
757 _("macro debug info contains a malformed macro definition:\n`%s'"),
762 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
764 complaint (&symfile_complaints
,
765 _("invalid attribute class or form for '%s' in '%s'"), arg1
, arg2
);
768 /* local function prototypes */
770 static void dwarf2_locate_sections (bfd
*, asection
*, void *);
773 static void dwarf2_build_psymtabs_easy (struct objfile
*);
776 static void dwarf2_create_include_psymtab (char *, struct partial_symtab
*,
779 static void dwarf2_build_include_psymtabs (struct dwarf2_cu
*,
781 struct partial_symtab
*);
783 static void dwarf2_build_psymtabs_hard (struct objfile
*);
785 static void scan_partial_symbols (struct partial_die_info
*,
786 CORE_ADDR
*, CORE_ADDR
*,
787 int, struct dwarf2_cu
*);
789 static void add_partial_symbol (struct partial_die_info
*,
792 static void add_partial_namespace (struct partial_die_info
*pdi
,
793 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
794 int need_pc
, struct dwarf2_cu
*cu
);
796 static void add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
797 CORE_ADDR
*highpc
, int need_pc
,
798 struct dwarf2_cu
*cu
);
800 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
801 struct dwarf2_cu
*cu
);
803 static void add_partial_subprogram (struct partial_die_info
*pdi
,
804 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
805 int need_pc
, struct dwarf2_cu
*cu
);
807 static gdb_byte
*locate_pdi_sibling (struct partial_die_info
*orig_pdi
,
808 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
809 bfd
*abfd
, struct dwarf2_cu
*cu
);
811 static void dwarf2_psymtab_to_symtab (struct partial_symtab
*);
813 static void psymtab_to_symtab_1 (struct partial_symtab
*);
815 static void dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
);
817 static void dwarf2_free_abbrev_table (void *);
819 static struct abbrev_info
*peek_die_abbrev (gdb_byte
*, unsigned int *,
822 static struct abbrev_info
*dwarf2_lookup_abbrev (unsigned int,
825 static struct partial_die_info
*load_partial_dies (bfd
*,
826 gdb_byte
*, gdb_byte
*,
827 int, struct dwarf2_cu
*);
829 static gdb_byte
*read_partial_die (struct partial_die_info
*,
830 struct abbrev_info
*abbrev
,
832 gdb_byte
*, gdb_byte
*,
835 static struct partial_die_info
*find_partial_die (unsigned int,
838 static void fixup_partial_die (struct partial_die_info
*,
841 static gdb_byte
*read_attribute (struct attribute
*, struct attr_abbrev
*,
842 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
844 static gdb_byte
*read_attribute_value (struct attribute
*, unsigned,
845 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
847 static unsigned int read_1_byte (bfd
*, gdb_byte
*);
849 static int read_1_signed_byte (bfd
*, gdb_byte
*);
851 static unsigned int read_2_bytes (bfd
*, gdb_byte
*);
853 static unsigned int read_4_bytes (bfd
*, gdb_byte
*);
855 static ULONGEST
read_8_bytes (bfd
*, gdb_byte
*);
857 static CORE_ADDR
read_address (bfd
*, gdb_byte
*ptr
, struct dwarf2_cu
*,
860 static LONGEST
read_initial_length (bfd
*, gdb_byte
*, unsigned int *);
862 static LONGEST read_checked_initial_length_and_offset
863 (bfd
*, gdb_byte
*, const struct comp_unit_head
*,
864 unsigned int *, unsigned int *);
866 static LONGEST
read_offset (bfd
*, gdb_byte
*, const struct comp_unit_head
*,
869 static LONGEST
read_offset_1 (bfd
*, gdb_byte
*, unsigned int);
871 static gdb_byte
*read_n_bytes (bfd
*, gdb_byte
*, unsigned int);
873 static char *read_string (bfd
*, gdb_byte
*, unsigned int *);
875 static char *read_indirect_string (bfd
*, gdb_byte
*,
876 const struct comp_unit_head
*,
879 static unsigned long read_unsigned_leb128 (bfd
*, gdb_byte
*, unsigned int *);
881 static long read_signed_leb128 (bfd
*, gdb_byte
*, unsigned int *);
883 static gdb_byte
*skip_leb128 (bfd
*, gdb_byte
*);
885 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
887 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
890 static struct attribute
*dwarf2_attr_no_follow (struct die_info
*,
894 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
895 struct dwarf2_cu
*cu
);
897 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
899 static struct die_info
*die_specification (struct die_info
*die
,
900 struct dwarf2_cu
**);
902 static void free_line_header (struct line_header
*lh
);
904 static void add_file_name (struct line_header
*, char *, unsigned int,
905 unsigned int, unsigned int);
907 static struct line_header
*(dwarf_decode_line_header
908 (unsigned int offset
,
909 bfd
*abfd
, struct dwarf2_cu
*cu
));
911 static void dwarf_decode_lines (struct line_header
*, char *, bfd
*,
912 struct dwarf2_cu
*, struct partial_symtab
*);
914 static void dwarf2_start_subfile (char *, char *, char *);
916 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
919 static void dwarf2_const_value (struct attribute
*, struct symbol
*,
922 static void dwarf2_const_value_data (struct attribute
*attr
,
926 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
928 static int need_gnat_info (struct dwarf2_cu
*);
930 static struct type
*die_descriptive_type (struct die_info
*, struct dwarf2_cu
*);
932 static void set_descriptive_type (struct type
*, struct die_info
*,
935 static struct type
*die_containing_type (struct die_info
*,
938 static struct type
*tag_type_to_type (struct die_info
*, struct dwarf2_cu
*);
940 static struct type
*read_type_die (struct die_info
*, struct dwarf2_cu
*);
942 static char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
944 static char *typename_concat (struct obstack
*,
949 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
951 static void read_type_unit_scope (struct die_info
*, struct dwarf2_cu
*);
953 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
955 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
957 static int dwarf2_ranges_read (unsigned, CORE_ADDR
*, CORE_ADDR
*,
958 struct dwarf2_cu
*, struct partial_symtab
*);
960 static int dwarf2_get_pc_bounds (struct die_info
*,
961 CORE_ADDR
*, CORE_ADDR
*, struct dwarf2_cu
*,
962 struct partial_symtab
*);
964 static void get_scope_pc_bounds (struct die_info
*,
965 CORE_ADDR
*, CORE_ADDR
*,
968 static void dwarf2_record_block_ranges (struct die_info
*, struct block
*,
969 CORE_ADDR
, struct dwarf2_cu
*);
971 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
974 static void dwarf2_attach_fields_to_type (struct field_info
*,
975 struct type
*, struct dwarf2_cu
*);
977 static void dwarf2_add_member_fn (struct field_info
*,
978 struct die_info
*, struct type
*,
981 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
982 struct type
*, struct dwarf2_cu
*);
984 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
986 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
988 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
990 static void read_module (struct die_info
*die
, struct dwarf2_cu
*cu
);
992 static void read_import_statement (struct die_info
*die
, struct dwarf2_cu
*);
994 static const char *namespace_name (struct die_info
*die
,
995 int *is_anonymous
, struct dwarf2_cu
*);
997 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
999 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
1001 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
1002 struct dwarf2_cu
*);
1004 static struct die_info
*read_comp_unit (gdb_byte
*, struct dwarf2_cu
*);
1006 static struct die_info
*read_die_and_children_1 (const struct die_reader_specs
*reader
,
1008 gdb_byte
**new_info_ptr
,
1009 struct die_info
*parent
);
1011 static struct die_info
*read_die_and_children (const struct die_reader_specs
*reader
,
1013 gdb_byte
**new_info_ptr
,
1014 struct die_info
*parent
);
1016 static struct die_info
*read_die_and_siblings (const struct die_reader_specs
*reader
,
1018 gdb_byte
**new_info_ptr
,
1019 struct die_info
*parent
);
1021 static gdb_byte
*read_full_die (const struct die_reader_specs
*reader
,
1022 struct die_info
**, gdb_byte
*,
1025 static void process_die (struct die_info
*, struct dwarf2_cu
*);
1027 static char *dwarf2_canonicalize_name (char *, struct dwarf2_cu
*,
1030 static char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
1032 static struct die_info
*dwarf2_extension (struct die_info
*die
,
1033 struct dwarf2_cu
**);
1035 static char *dwarf_tag_name (unsigned int);
1037 static char *dwarf_attr_name (unsigned int);
1039 static char *dwarf_form_name (unsigned int);
1041 static char *dwarf_stack_op_name (unsigned int);
1043 static char *dwarf_bool_name (unsigned int);
1045 static char *dwarf_type_encoding_name (unsigned int);
1048 static char *dwarf_cfi_name (unsigned int);
1051 static struct die_info
*sibling_die (struct die_info
*);
1053 static void dump_die_shallow (struct ui_file
*, int indent
, struct die_info
*);
1055 static void dump_die_for_error (struct die_info
*);
1057 static void dump_die_1 (struct ui_file
*, int level
, int max_level
,
1060 /*static*/ void dump_die (struct die_info
*, int max_level
);
1062 static void store_in_ref_table (struct die_info
*,
1063 struct dwarf2_cu
*);
1065 static int is_ref_attr (struct attribute
*);
1067 static unsigned int dwarf2_get_ref_die_offset (struct attribute
*);
1069 static LONGEST
dwarf2_get_attr_constant_value (struct attribute
*, int);
1071 static struct die_info
*follow_die_ref_or_sig (struct die_info
*,
1073 struct dwarf2_cu
**);
1075 static struct die_info
*follow_die_ref (struct die_info
*,
1077 struct dwarf2_cu
**);
1079 static struct die_info
*follow_die_sig (struct die_info
*,
1081 struct dwarf2_cu
**);
1083 static void read_signatured_type_at_offset (struct objfile
*objfile
,
1084 unsigned int offset
);
1086 static void read_signatured_type (struct objfile
*,
1087 struct signatured_type
*type_sig
);
1089 /* memory allocation interface */
1091 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1093 static struct abbrev_info
*dwarf_alloc_abbrev (struct dwarf2_cu
*);
1095 static struct die_info
*dwarf_alloc_die (struct dwarf2_cu
*, int);
1097 static void initialize_cu_func_list (struct dwarf2_cu
*);
1099 static void add_to_cu_func_list (const char *, CORE_ADDR
, CORE_ADDR
,
1100 struct dwarf2_cu
*);
1102 static void dwarf_decode_macros (struct line_header
*, unsigned int,
1103 char *, bfd
*, struct dwarf2_cu
*);
1105 static int attr_form_is_block (struct attribute
*);
1107 static int attr_form_is_section_offset (struct attribute
*);
1109 static int attr_form_is_constant (struct attribute
*);
1111 static void dwarf2_symbol_mark_computed (struct attribute
*attr
,
1113 struct dwarf2_cu
*cu
);
1115 static gdb_byte
*skip_one_die (gdb_byte
*buffer
, gdb_byte
*info_ptr
,
1116 struct abbrev_info
*abbrev
,
1117 struct dwarf2_cu
*cu
);
1119 static void free_stack_comp_unit (void *);
1121 static hashval_t
partial_die_hash (const void *item
);
1123 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1125 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1126 (unsigned int offset
, struct objfile
*objfile
);
1128 static struct dwarf2_per_cu_data
*dwarf2_find_comp_unit
1129 (unsigned int offset
, struct objfile
*objfile
);
1131 static struct dwarf2_cu
*alloc_one_comp_unit (struct objfile
*objfile
);
1133 static void free_one_comp_unit (void *);
1135 static void free_cached_comp_units (void *);
1137 static void age_cached_comp_units (void);
1139 static void free_one_cached_comp_unit (void *);
1141 static struct type
*set_die_type (struct die_info
*, struct type
*,
1142 struct dwarf2_cu
*);
1144 static void create_all_comp_units (struct objfile
*);
1146 static void load_full_comp_unit (struct dwarf2_per_cu_data
*,
1149 static void process_full_comp_unit (struct dwarf2_per_cu_data
*);
1151 static void dwarf2_add_dependence (struct dwarf2_cu
*,
1152 struct dwarf2_per_cu_data
*);
1154 static void dwarf2_mark (struct dwarf2_cu
*);
1156 static void dwarf2_clear_marks (struct dwarf2_per_cu_data
*);
1158 static struct type
*get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
1160 /* Try to locate the sections we need for DWARF 2 debugging
1161 information and return true if we have enough to do something. */
1164 dwarf2_has_info (struct objfile
*objfile
)
1166 struct dwarf2_per_objfile
*data
;
1168 /* Initialize per-objfile state. */
1169 data
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*data
));
1170 memset (data
, 0, sizeof (*data
));
1171 set_objfile_data (objfile
, dwarf2_objfile_data_key
, data
);
1172 dwarf2_per_objfile
= data
;
1174 bfd_map_over_sections (objfile
->obfd
, dwarf2_locate_sections
, NULL
);
1175 return (data
->info
.asection
!= NULL
&& data
->abbrev
.asection
!= NULL
);
1178 /* When loading sections, we can either look for ".<name>", or for
1179 * ".z<name>", which indicates a compressed section. */
1182 section_is_p (const char *section_name
, const char *name
)
1184 return (section_name
[0] == '.'
1185 && (strcmp (section_name
+ 1, name
) == 0
1186 || (section_name
[1] == 'z'
1187 && strcmp (section_name
+ 2, name
) == 0)));
1190 /* This function is mapped across the sections and remembers the
1191 offset and size of each of the debugging sections we are interested
1195 dwarf2_locate_sections (bfd
*abfd
, asection
*sectp
, void *ignore_ptr
)
1197 if (section_is_p (sectp
->name
, INFO_SECTION
))
1199 dwarf2_per_objfile
->info
.asection
= sectp
;
1200 dwarf2_per_objfile
->info
.size
= bfd_get_section_size (sectp
);
1202 else if (section_is_p (sectp
->name
, ABBREV_SECTION
))
1204 dwarf2_per_objfile
->abbrev
.asection
= sectp
;
1205 dwarf2_per_objfile
->abbrev
.size
= bfd_get_section_size (sectp
);
1207 else if (section_is_p (sectp
->name
, LINE_SECTION
))
1209 dwarf2_per_objfile
->line
.asection
= sectp
;
1210 dwarf2_per_objfile
->line
.size
= bfd_get_section_size (sectp
);
1212 else if (section_is_p (sectp
->name
, PUBNAMES_SECTION
))
1214 dwarf2_per_objfile
->pubnames
.asection
= sectp
;
1215 dwarf2_per_objfile
->pubnames
.size
= bfd_get_section_size (sectp
);
1217 else if (section_is_p (sectp
->name
, ARANGES_SECTION
))
1219 dwarf2_per_objfile
->aranges
.asection
= sectp
;
1220 dwarf2_per_objfile
->aranges
.size
= bfd_get_section_size (sectp
);
1222 else if (section_is_p (sectp
->name
, LOC_SECTION
))
1224 dwarf2_per_objfile
->loc
.asection
= sectp
;
1225 dwarf2_per_objfile
->loc
.size
= bfd_get_section_size (sectp
);
1227 else if (section_is_p (sectp
->name
, MACINFO_SECTION
))
1229 dwarf2_per_objfile
->macinfo
.asection
= sectp
;
1230 dwarf2_per_objfile
->macinfo
.size
= bfd_get_section_size (sectp
);
1232 else if (section_is_p (sectp
->name
, STR_SECTION
))
1234 dwarf2_per_objfile
->str
.asection
= sectp
;
1235 dwarf2_per_objfile
->str
.size
= bfd_get_section_size (sectp
);
1237 else if (section_is_p (sectp
->name
, FRAME_SECTION
))
1239 dwarf2_per_objfile
->frame
.asection
= sectp
;
1240 dwarf2_per_objfile
->frame
.size
= bfd_get_section_size (sectp
);
1242 else if (section_is_p (sectp
->name
, EH_FRAME_SECTION
))
1244 flagword aflag
= bfd_get_section_flags (ignore_abfd
, sectp
);
1245 if (aflag
& SEC_HAS_CONTENTS
)
1247 dwarf2_per_objfile
->eh_frame
.asection
= sectp
;
1248 dwarf2_per_objfile
->eh_frame
.size
= bfd_get_section_size (sectp
);
1251 else if (section_is_p (sectp
->name
, RANGES_SECTION
))
1253 dwarf2_per_objfile
->ranges
.asection
= sectp
;
1254 dwarf2_per_objfile
->ranges
.size
= bfd_get_section_size (sectp
);
1256 else if (section_is_p (sectp
->name
, TYPES_SECTION
))
1258 dwarf2_per_objfile
->types
.asection
= sectp
;
1259 dwarf2_per_objfile
->types
.size
= bfd_get_section_size (sectp
);
1262 if ((bfd_get_section_flags (abfd
, sectp
) & SEC_LOAD
)
1263 && bfd_section_vma (abfd
, sectp
) == 0)
1264 dwarf2_per_objfile
->has_section_at_zero
= 1;
1267 /* Decompress a section that was compressed using zlib. Store the
1268 decompressed buffer, and its size, in OUTBUF and OUTSIZE. */
1271 zlib_decompress_section (struct objfile
*objfile
, asection
*sectp
,
1272 gdb_byte
**outbuf
, bfd_size_type
*outsize
)
1274 bfd
*abfd
= objfile
->obfd
;
1276 error (_("Support for zlib-compressed DWARF data (from '%s') "
1277 "is disabled in this copy of GDB"),
1278 bfd_get_filename (abfd
));
1280 bfd_size_type compressed_size
= bfd_get_section_size (sectp
);
1281 gdb_byte
*compressed_buffer
= xmalloc (compressed_size
);
1282 struct cleanup
*cleanup
= make_cleanup (xfree
, compressed_buffer
);
1283 bfd_size_type uncompressed_size
;
1284 gdb_byte
*uncompressed_buffer
;
1287 int header_size
= 12;
1289 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
1290 || bfd_bread (compressed_buffer
, compressed_size
, abfd
) != compressed_size
)
1291 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
1292 bfd_get_filename (abfd
));
1294 /* Read the zlib header. In this case, it should be "ZLIB" followed
1295 by the uncompressed section size, 8 bytes in big-endian order. */
1296 if (compressed_size
< header_size
1297 || strncmp (compressed_buffer
, "ZLIB", 4) != 0)
1298 error (_("Dwarf Error: Corrupt DWARF ZLIB header from '%s'"),
1299 bfd_get_filename (abfd
));
1300 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
1301 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
1302 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
1303 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
1304 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
1305 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
1306 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
1307 uncompressed_size
+= compressed_buffer
[11];
1309 /* It is possible the section consists of several compressed
1310 buffers concatenated together, so we uncompress in a loop. */
1314 strm
.avail_in
= compressed_size
- header_size
;
1315 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
1316 strm
.avail_out
= uncompressed_size
;
1317 uncompressed_buffer
= obstack_alloc (&objfile
->objfile_obstack
,
1319 rc
= inflateInit (&strm
);
1320 while (strm
.avail_in
> 0)
1323 error (_("Dwarf Error: setting up DWARF uncompression in '%s': %d"),
1324 bfd_get_filename (abfd
), rc
);
1325 strm
.next_out
= ((Bytef
*) uncompressed_buffer
1326 + (uncompressed_size
- strm
.avail_out
));
1327 rc
= inflate (&strm
, Z_FINISH
);
1328 if (rc
!= Z_STREAM_END
)
1329 error (_("Dwarf Error: zlib error uncompressing from '%s': %d"),
1330 bfd_get_filename (abfd
), rc
);
1331 rc
= inflateReset (&strm
);
1333 rc
= inflateEnd (&strm
);
1335 || strm
.avail_out
!= 0)
1336 error (_("Dwarf Error: concluding DWARF uncompression in '%s': %d"),
1337 bfd_get_filename (abfd
), rc
);
1339 do_cleanups (cleanup
);
1340 *outbuf
= uncompressed_buffer
;
1341 *outsize
= uncompressed_size
;
1345 /* Read the contents of the section SECTP from object file specified by
1346 OBJFILE, store info about the section into INFO.
1347 If the section is compressed, uncompress it before returning. */
1350 dwarf2_read_section (struct objfile
*objfile
, struct dwarf2_section_info
*info
)
1352 bfd
*abfd
= objfile
->obfd
;
1353 asection
*sectp
= info
->asection
;
1354 gdb_byte
*buf
, *retbuf
;
1355 unsigned char header
[4];
1357 info
->buffer
= NULL
;
1358 info
->was_mmapped
= 0;
1360 if (info
->asection
== NULL
|| info
->size
== 0)
1363 /* Check if the file has a 4-byte header indicating compression. */
1364 if (info
->size
> sizeof (header
)
1365 && bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) == 0
1366 && bfd_bread (header
, sizeof (header
), abfd
) == sizeof (header
))
1368 /* Upon decompression, update the buffer and its size. */
1369 if (strncmp (header
, "ZLIB", sizeof (header
)) == 0)
1371 zlib_decompress_section (objfile
, sectp
, &info
->buffer
,
1379 pagesize
= getpagesize ();
1381 /* Only try to mmap sections which are large enough: we don't want to
1382 waste space due to fragmentation. Also, only try mmap for sections
1383 without relocations. */
1385 if (info
->size
> 4 * pagesize
&& (sectp
->flags
& SEC_RELOC
) == 0)
1387 off_t pg_offset
= sectp
->filepos
& ~(pagesize
- 1);
1388 size_t map_length
= info
->size
+ sectp
->filepos
- pg_offset
;
1389 caddr_t retbuf
= bfd_mmap (abfd
, 0, map_length
, PROT_READ
,
1390 MAP_PRIVATE
, pg_offset
);
1392 if (retbuf
!= MAP_FAILED
)
1394 info
->was_mmapped
= 1;
1395 info
->buffer
= retbuf
+ (sectp
->filepos
& (pagesize
- 1)) ;
1401 /* If we get here, we are a normal, not-compressed section. */
1403 = obstack_alloc (&objfile
->objfile_obstack
, info
->size
);
1405 /* When debugging .o files, we may need to apply relocations; see
1406 http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
1407 We never compress sections in .o files, so we only need to
1408 try this when the section is not compressed. */
1409 retbuf
= symfile_relocate_debug_section (objfile
, sectp
, buf
);
1412 info
->buffer
= retbuf
;
1416 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
1417 || bfd_bread (buf
, info
->size
, abfd
) != info
->size
)
1418 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
1419 bfd_get_filename (abfd
));
1422 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
1426 dwarf2_get_section_info (struct objfile
*objfile
, const char *section_name
,
1427 asection
**sectp
, gdb_byte
**bufp
,
1428 bfd_size_type
*sizep
)
1430 struct dwarf2_per_objfile
*data
1431 = objfile_data (objfile
, dwarf2_objfile_data_key
);
1432 struct dwarf2_section_info
*info
;
1433 if (section_is_p (section_name
, EH_FRAME_SECTION
))
1434 info
= &data
->eh_frame
;
1435 else if (section_is_p (section_name
, FRAME_SECTION
))
1436 info
= &data
->frame
;
1440 if (info
->asection
!= NULL
&& info
->size
!= 0 && info
->buffer
== NULL
)
1441 /* We haven't read this section in yet. Do it now. */
1442 dwarf2_read_section (objfile
, info
);
1444 *sectp
= info
->asection
;
1445 *bufp
= info
->buffer
;
1446 *sizep
= info
->size
;
1449 /* Build a partial symbol table. */
1452 dwarf2_build_psymtabs (struct objfile
*objfile
)
1454 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
1455 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->abbrev
);
1456 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->line
);
1457 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->str
);
1458 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->macinfo
);
1459 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->ranges
);
1460 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->types
);
1461 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->loc
);
1462 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->eh_frame
);
1463 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->frame
);
1465 if (objfile
->global_psymbols
.size
== 0 && objfile
->static_psymbols
.size
== 0)
1467 init_psymbol_list (objfile
, 1024);
1471 if (dwarf_aranges_offset
&& dwarf_pubnames_offset
)
1473 /* Things are significantly easier if we have .debug_aranges and
1474 .debug_pubnames sections */
1476 dwarf2_build_psymtabs_easy (objfile
);
1480 /* only test this case for now */
1482 /* In this case we have to work a bit harder */
1483 dwarf2_build_psymtabs_hard (objfile
);
1488 /* Build the partial symbol table from the information in the
1489 .debug_pubnames and .debug_aranges sections. */
1492 dwarf2_build_psymtabs_easy (struct objfile
*objfile
)
1494 bfd
*abfd
= objfile
->obfd
;
1495 char *aranges_buffer
, *pubnames_buffer
;
1496 char *aranges_ptr
, *pubnames_ptr
;
1497 unsigned int entry_length
, version
, info_offset
, info_size
;
1499 pubnames_buffer
= dwarf2_read_section (objfile
,
1500 dwarf_pubnames_section
);
1501 pubnames_ptr
= pubnames_buffer
;
1502 while ((pubnames_ptr
- pubnames_buffer
) < dwarf2_per_objfile
->pubnames
.size
)
1504 unsigned int bytes_read
;
1506 entry_length
= read_initial_length (abfd
, pubnames_ptr
, &bytes_read
);
1507 pubnames_ptr
+= bytes_read
;
1508 version
= read_1_byte (abfd
, pubnames_ptr
);
1510 info_offset
= read_4_bytes (abfd
, pubnames_ptr
);
1512 info_size
= read_4_bytes (abfd
, pubnames_ptr
);
1516 aranges_buffer
= dwarf2_read_section (objfile
,
1517 dwarf_aranges_section
);
1522 /* Return TRUE if OFFSET is within CU_HEADER. */
1525 offset_in_cu_p (const struct comp_unit_head
*cu_header
, unsigned int offset
)
1527 unsigned int bottom
= cu_header
->offset
;
1528 unsigned int top
= (cu_header
->offset
1530 + cu_header
->initial_length_size
);
1531 return (offset
>= bottom
&& offset
< top
);
1534 /* Read in the comp unit header information from the debug_info at info_ptr.
1535 NOTE: This leaves members offset, first_die_offset to be filled in
1539 read_comp_unit_head (struct comp_unit_head
*cu_header
,
1540 gdb_byte
*info_ptr
, bfd
*abfd
)
1543 unsigned int bytes_read
;
1545 cu_header
->length
= read_initial_length (abfd
, info_ptr
, &bytes_read
);
1546 cu_header
->initial_length_size
= bytes_read
;
1547 cu_header
->offset_size
= (bytes_read
== 4) ? 4 : 8;
1548 info_ptr
+= bytes_read
;
1549 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
1551 cu_header
->abbrev_offset
= read_offset (abfd
, info_ptr
, cu_header
,
1553 info_ptr
+= bytes_read
;
1554 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
1556 signed_addr
= bfd_get_sign_extend_vma (abfd
);
1557 if (signed_addr
< 0)
1558 internal_error (__FILE__
, __LINE__
,
1559 _("read_comp_unit_head: dwarf from non elf file"));
1560 cu_header
->signed_addr_p
= signed_addr
;
1566 partial_read_comp_unit_head (struct comp_unit_head
*header
, gdb_byte
*info_ptr
,
1567 gdb_byte
*buffer
, unsigned int buffer_size
,
1570 gdb_byte
*beg_of_comp_unit
= info_ptr
;
1572 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
1574 if (header
->version
!= 2 && header
->version
!= 3)
1575 error (_("Dwarf Error: wrong version in compilation unit header "
1576 "(is %d, should be %d) [in module %s]"), header
->version
,
1577 2, bfd_get_filename (abfd
));
1579 if (header
->abbrev_offset
>= dwarf2_per_objfile
->abbrev
.size
)
1580 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
1581 "(offset 0x%lx + 6) [in module %s]"),
1582 (long) header
->abbrev_offset
,
1583 (long) (beg_of_comp_unit
- buffer
),
1584 bfd_get_filename (abfd
));
1586 if (beg_of_comp_unit
+ header
->length
+ header
->initial_length_size
1587 > buffer
+ buffer_size
)
1588 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
1589 "(offset 0x%lx + 0) [in module %s]"),
1590 (long) header
->length
,
1591 (long) (beg_of_comp_unit
- buffer
),
1592 bfd_get_filename (abfd
));
1597 /* Read in the types comp unit header information from .debug_types entry at
1598 types_ptr. The result is a pointer to one past the end of the header. */
1601 read_type_comp_unit_head (struct comp_unit_head
*cu_header
,
1602 ULONGEST
*signature
,
1603 gdb_byte
*types_ptr
, bfd
*abfd
)
1605 unsigned int bytes_read
;
1606 gdb_byte
*initial_types_ptr
= types_ptr
;
1608 cu_header
->offset
= types_ptr
- dwarf2_per_objfile
->types
.buffer
;
1610 types_ptr
= read_comp_unit_head (cu_header
, types_ptr
, abfd
);
1612 *signature
= read_8_bytes (abfd
, types_ptr
);
1614 types_ptr
+= cu_header
->offset_size
;
1615 cu_header
->first_die_offset
= types_ptr
- initial_types_ptr
;
1620 /* Allocate a new partial symtab for file named NAME and mark this new
1621 partial symtab as being an include of PST. */
1624 dwarf2_create_include_psymtab (char *name
, struct partial_symtab
*pst
,
1625 struct objfile
*objfile
)
1627 struct partial_symtab
*subpst
= allocate_psymtab (name
, objfile
);
1629 subpst
->section_offsets
= pst
->section_offsets
;
1630 subpst
->textlow
= 0;
1631 subpst
->texthigh
= 0;
1633 subpst
->dependencies
= (struct partial_symtab
**)
1634 obstack_alloc (&objfile
->objfile_obstack
,
1635 sizeof (struct partial_symtab
*));
1636 subpst
->dependencies
[0] = pst
;
1637 subpst
->number_of_dependencies
= 1;
1639 subpst
->globals_offset
= 0;
1640 subpst
->n_global_syms
= 0;
1641 subpst
->statics_offset
= 0;
1642 subpst
->n_static_syms
= 0;
1643 subpst
->symtab
= NULL
;
1644 subpst
->read_symtab
= pst
->read_symtab
;
1647 /* No private part is necessary for include psymtabs. This property
1648 can be used to differentiate between such include psymtabs and
1649 the regular ones. */
1650 subpst
->read_symtab_private
= NULL
;
1653 /* Read the Line Number Program data and extract the list of files
1654 included by the source file represented by PST. Build an include
1655 partial symtab for each of these included files. */
1658 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
1659 struct die_info
*die
,
1660 struct partial_symtab
*pst
)
1662 struct objfile
*objfile
= cu
->objfile
;
1663 bfd
*abfd
= objfile
->obfd
;
1664 struct line_header
*lh
= NULL
;
1665 struct attribute
*attr
;
1667 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
1670 unsigned int line_offset
= DW_UNSND (attr
);
1671 lh
= dwarf_decode_line_header (line_offset
, abfd
, cu
);
1674 return; /* No linetable, so no includes. */
1676 dwarf_decode_lines (lh
, NULL
, abfd
, cu
, pst
);
1678 free_line_header (lh
);
1682 hash_type_signature (const void *item
)
1684 const struct signatured_type
*type_sig
= item
;
1685 /* This drops the top 32 bits of the signature, but is ok for a hash. */
1686 return type_sig
->signature
;
1690 eq_type_signature (const void *item_lhs
, const void *item_rhs
)
1692 const struct signatured_type
*lhs
= item_lhs
;
1693 const struct signatured_type
*rhs
= item_rhs
;
1694 return lhs
->signature
== rhs
->signature
;
1697 /* Create the hash table of all entries in the .debug_types section.
1698 The result is zero if there is an error (e.g. missing .debug_types section),
1699 otherwise non-zero. */
1702 create_debug_types_hash_table (struct objfile
*objfile
)
1704 gdb_byte
*info_ptr
= dwarf2_per_objfile
->types
.buffer
;
1707 if (info_ptr
== NULL
)
1709 dwarf2_per_objfile
->signatured_types
= NULL
;
1713 types_htab
= htab_create_alloc_ex (41,
1714 hash_type_signature
,
1717 &objfile
->objfile_obstack
,
1718 hashtab_obstack_allocate
,
1719 dummy_obstack_deallocate
);
1721 if (dwarf2_die_debug
)
1722 fprintf_unfiltered (gdb_stdlog
, "Signatured types:\n");
1724 while (info_ptr
< dwarf2_per_objfile
->types
.buffer
+ dwarf2_per_objfile
->types
.size
)
1726 unsigned int offset
;
1727 unsigned int offset_size
;
1728 unsigned int type_offset
;
1729 unsigned int length
, initial_length_size
;
1730 unsigned short version
;
1732 struct signatured_type
*type_sig
;
1734 gdb_byte
*ptr
= info_ptr
;
1736 offset
= ptr
- dwarf2_per_objfile
->types
.buffer
;
1738 /* We need to read the type's signature in order to build the hash
1739 table, but we don't need to read anything else just yet. */
1741 /* Sanity check to ensure entire cu is present. */
1742 length
= read_initial_length (objfile
->obfd
, ptr
, &initial_length_size
);
1743 if (ptr
+ length
+ initial_length_size
1744 > dwarf2_per_objfile
->types
.buffer
+ dwarf2_per_objfile
->types
.size
)
1746 complaint (&symfile_complaints
,
1747 _("debug type entry runs off end of `.debug_types' section, ignored"));
1751 offset_size
= initial_length_size
== 4 ? 4 : 8;
1752 ptr
+= initial_length_size
;
1753 version
= bfd_get_16 (objfile
->obfd
, ptr
);
1755 ptr
+= offset_size
; /* abbrev offset */
1756 ptr
+= 1; /* address size */
1757 signature
= bfd_get_64 (objfile
->obfd
, ptr
);
1759 type_offset
= read_offset_1 (objfile
->obfd
, ptr
, offset_size
);
1761 type_sig
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*type_sig
));
1762 memset (type_sig
, 0, sizeof (*type_sig
));
1763 type_sig
->signature
= signature
;
1764 type_sig
->offset
= offset
;
1765 type_sig
->type_offset
= type_offset
;
1767 slot
= htab_find_slot (types_htab
, type_sig
, INSERT
);
1768 gdb_assert (slot
!= NULL
);
1771 if (dwarf2_die_debug
)
1772 fprintf_unfiltered (gdb_stdlog
, " offset 0x%x, signature 0x%s\n",
1773 offset
, phex (signature
, sizeof (signature
)));
1775 info_ptr
= info_ptr
+ initial_length_size
+ length
;
1778 dwarf2_per_objfile
->signatured_types
= types_htab
;
1783 /* Lookup a signature based type.
1784 Returns NULL if SIG is not present in the table. */
1786 static struct signatured_type
*
1787 lookup_signatured_type (struct objfile
*objfile
, ULONGEST sig
)
1789 struct signatured_type find_entry
, *entry
;
1791 if (dwarf2_per_objfile
->signatured_types
== NULL
)
1793 complaint (&symfile_complaints
,
1794 _("missing `.debug_types' section for DW_FORM_sig8 die"));
1798 find_entry
.signature
= sig
;
1799 entry
= htab_find (dwarf2_per_objfile
->signatured_types
, &find_entry
);
1803 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
1806 init_cu_die_reader (struct die_reader_specs
*reader
,
1807 struct dwarf2_cu
*cu
)
1809 reader
->abfd
= cu
->objfile
->obfd
;
1811 if (cu
->per_cu
->from_debug_types
)
1812 reader
->buffer
= dwarf2_per_objfile
->types
.buffer
;
1814 reader
->buffer
= dwarf2_per_objfile
->info
.buffer
;
1817 /* Find the base address of the compilation unit for range lists and
1818 location lists. It will normally be specified by DW_AT_low_pc.
1819 In DWARF-3 draft 4, the base address could be overridden by
1820 DW_AT_entry_pc. It's been removed, but GCC still uses this for
1821 compilation units with discontinuous ranges. */
1824 dwarf2_find_base_address (struct die_info
*die
, struct dwarf2_cu
*cu
)
1826 struct attribute
*attr
;
1829 cu
->base_address
= 0;
1831 attr
= dwarf2_attr (die
, DW_AT_entry_pc
, cu
);
1834 cu
->base_address
= DW_ADDR (attr
);
1839 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
1842 cu
->base_address
= DW_ADDR (attr
);
1848 /* Subroutine of process_type_comp_unit and dwarf2_build_psymtabs_hard
1849 to combine the common parts.
1850 Process a compilation unit for a psymtab.
1851 BUFFER is a pointer to the beginning of the dwarf section buffer,
1852 either .debug_info or debug_types.
1853 INFO_PTR is a pointer to the start of the CU.
1854 Returns a pointer to the next CU. */
1857 process_psymtab_comp_unit (struct objfile
*objfile
,
1858 struct dwarf2_per_cu_data
*this_cu
,
1859 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
1860 unsigned int buffer_size
)
1862 bfd
*abfd
= objfile
->obfd
;
1863 gdb_byte
*beg_of_comp_unit
= info_ptr
;
1864 struct die_info
*comp_unit_die
;
1865 struct partial_symtab
*pst
;
1867 struct cleanup
*back_to_inner
;
1868 struct dwarf2_cu cu
;
1869 unsigned int bytes_read
;
1870 int has_children
, has_pc_info
;
1871 struct attribute
*attr
;
1873 CORE_ADDR best_lowpc
= 0, best_highpc
= 0;
1874 struct die_reader_specs reader_specs
;
1876 memset (&cu
, 0, sizeof (cu
));
1877 cu
.objfile
= objfile
;
1878 obstack_init (&cu
.comp_unit_obstack
);
1880 back_to_inner
= make_cleanup (free_stack_comp_unit
, &cu
);
1882 info_ptr
= partial_read_comp_unit_head (&cu
.header
, info_ptr
,
1883 buffer
, buffer_size
,
1886 /* Complete the cu_header. */
1887 cu
.header
.offset
= beg_of_comp_unit
- buffer
;
1888 cu
.header
.first_die_offset
= info_ptr
- beg_of_comp_unit
;
1890 cu
.list_in_scope
= &file_symbols
;
1892 /* If this compilation unit was already read in, free the
1893 cached copy in order to read it in again. This is
1894 necessary because we skipped some symbols when we first
1895 read in the compilation unit (see load_partial_dies).
1896 This problem could be avoided, but the benefit is
1898 if (this_cu
->cu
!= NULL
)
1899 free_one_cached_comp_unit (this_cu
->cu
);
1901 /* Note that this is a pointer to our stack frame, being
1902 added to a global data structure. It will be cleaned up
1903 in free_stack_comp_unit when we finish with this
1904 compilation unit. */
1906 cu
.per_cu
= this_cu
;
1908 /* Read the abbrevs for this compilation unit into a table. */
1909 dwarf2_read_abbrevs (abfd
, &cu
);
1910 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
1912 /* Read the compilation unit die. */
1913 if (this_cu
->from_debug_types
)
1914 info_ptr
+= 8 /*signature*/ + cu
.header
.offset_size
;
1915 init_cu_die_reader (&reader_specs
, &cu
);
1916 info_ptr
= read_full_die (&reader_specs
, &comp_unit_die
, info_ptr
,
1919 if (this_cu
->from_debug_types
)
1921 /* offset,length haven't been set yet for type units. */
1922 this_cu
->offset
= cu
.header
.offset
;
1923 this_cu
->length
= cu
.header
.length
+ cu
.header
.initial_length_size
;
1925 else if (comp_unit_die
->tag
== DW_TAG_partial_unit
)
1927 info_ptr
= (beg_of_comp_unit
+ cu
.header
.length
1928 + cu
.header
.initial_length_size
);
1929 do_cleanups (back_to_inner
);
1933 /* Set the language we're debugging. */
1934 attr
= dwarf2_attr (comp_unit_die
, DW_AT_language
, &cu
);
1936 set_cu_language (DW_UNSND (attr
), &cu
);
1938 set_cu_language (language_minimal
, &cu
);
1940 /* Allocate a new partial symbol table structure. */
1941 attr
= dwarf2_attr (comp_unit_die
, DW_AT_name
, &cu
);
1942 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
1943 (attr
!= NULL
) ? DW_STRING (attr
) : "",
1944 /* TEXTLOW and TEXTHIGH are set below. */
1946 objfile
->global_psymbols
.next
,
1947 objfile
->static_psymbols
.next
);
1949 attr
= dwarf2_attr (comp_unit_die
, DW_AT_comp_dir
, &cu
);
1951 pst
->dirname
= DW_STRING (attr
);
1953 pst
->read_symtab_private
= (char *) this_cu
;
1955 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1957 /* Store the function that reads in the rest of the symbol table */
1958 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
1960 this_cu
->psymtab
= pst
;
1962 dwarf2_find_base_address (comp_unit_die
, &cu
);
1964 /* Possibly set the default values of LOWPC and HIGHPC from
1966 has_pc_info
= dwarf2_get_pc_bounds (comp_unit_die
, &best_lowpc
,
1967 &best_highpc
, &cu
, pst
);
1968 if (has_pc_info
== 1 && best_lowpc
< best_highpc
)
1969 /* Store the contiguous range if it is not empty; it can be empty for
1970 CUs with no code. */
1971 addrmap_set_empty (objfile
->psymtabs_addrmap
,
1972 best_lowpc
+ baseaddr
,
1973 best_highpc
+ baseaddr
- 1, pst
);
1975 /* Check if comp unit has_children.
1976 If so, read the rest of the partial symbols from this comp unit.
1977 If not, there's no more debug_info for this comp unit. */
1980 struct partial_die_info
*first_die
;
1981 CORE_ADDR lowpc
, highpc
;
1983 lowpc
= ((CORE_ADDR
) -1);
1984 highpc
= ((CORE_ADDR
) 0);
1986 first_die
= load_partial_dies (abfd
, buffer
, info_ptr
, 1, &cu
);
1988 scan_partial_symbols (first_die
, &lowpc
, &highpc
,
1989 ! has_pc_info
, &cu
);
1991 /* If we didn't find a lowpc, set it to highpc to avoid
1992 complaints from `maint check'. */
1993 if (lowpc
== ((CORE_ADDR
) -1))
1996 /* If the compilation unit didn't have an explicit address range,
1997 then use the information extracted from its child dies. */
2001 best_highpc
= highpc
;
2004 pst
->textlow
= best_lowpc
+ baseaddr
;
2005 pst
->texthigh
= best_highpc
+ baseaddr
;
2007 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
2008 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
2009 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
2010 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
2011 sort_pst_symbols (pst
);
2013 info_ptr
= (beg_of_comp_unit
+ cu
.header
.length
2014 + cu
.header
.initial_length_size
);
2016 if (this_cu
->from_debug_types
)
2018 /* It's not clear we want to do anything with stmt lists here.
2019 Waiting to see what gcc ultimately does. */
2023 /* Get the list of files included in the current compilation unit,
2024 and build a psymtab for each of them. */
2025 dwarf2_build_include_psymtabs (&cu
, comp_unit_die
, pst
);
2028 do_cleanups (back_to_inner
);
2033 /* Traversal function for htab_traverse_noresize.
2034 Process one .debug_types comp-unit. */
2037 process_type_comp_unit (void **slot
, void *info
)
2039 struct signatured_type
*entry
= (struct signatured_type
*) *slot
;
2040 struct objfile
*objfile
= (struct objfile
*) info
;
2041 struct dwarf2_per_cu_data
*this_cu
;
2043 this_cu
= &entry
->per_cu
;
2044 this_cu
->from_debug_types
= 1;
2046 process_psymtab_comp_unit (objfile
, this_cu
,
2047 dwarf2_per_objfile
->types
.buffer
,
2048 dwarf2_per_objfile
->types
.buffer
+ entry
->offset
,
2049 dwarf2_per_objfile
->types
.size
);
2054 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
2055 Build partial symbol tables for the .debug_types comp-units. */
2058 build_type_psymtabs (struct objfile
*objfile
)
2060 if (! create_debug_types_hash_table (objfile
))
2063 htab_traverse_noresize (dwarf2_per_objfile
->signatured_types
,
2064 process_type_comp_unit
, objfile
);
2067 /* Build the partial symbol table by doing a quick pass through the
2068 .debug_info and .debug_abbrev sections. */
2071 dwarf2_build_psymtabs_hard (struct objfile
*objfile
)
2073 /* Instead of reading this into a big buffer, we should probably use
2074 mmap() on architectures that support it. (FIXME) */
2075 bfd
*abfd
= objfile
->obfd
;
2077 struct cleanup
*back_to
;
2079 info_ptr
= dwarf2_per_objfile
->info
.buffer
;
2081 /* Any cached compilation units will be linked by the per-objfile
2082 read_in_chain. Make sure to free them when we're done. */
2083 back_to
= make_cleanup (free_cached_comp_units
, NULL
);
2085 build_type_psymtabs (objfile
);
2087 create_all_comp_units (objfile
);
2089 objfile
->psymtabs_addrmap
=
2090 addrmap_create_mutable (&objfile
->objfile_obstack
);
2092 /* Since the objects we're extracting from .debug_info vary in
2093 length, only the individual functions to extract them (like
2094 read_comp_unit_head and load_partial_die) can really know whether
2095 the buffer is large enough to hold another complete object.
2097 At the moment, they don't actually check that. If .debug_info
2098 holds just one extra byte after the last compilation unit's dies,
2099 then read_comp_unit_head will happily read off the end of the
2100 buffer. read_partial_die is similarly casual. Those functions
2103 For this loop condition, simply checking whether there's any data
2104 left at all should be sufficient. */
2106 while (info_ptr
< (dwarf2_per_objfile
->info
.buffer
2107 + dwarf2_per_objfile
->info
.size
))
2109 struct dwarf2_per_cu_data
*this_cu
;
2111 this_cu
= dwarf2_find_comp_unit (info_ptr
- dwarf2_per_objfile
->info
.buffer
,
2114 info_ptr
= process_psymtab_comp_unit (objfile
, this_cu
,
2115 dwarf2_per_objfile
->info
.buffer
,
2117 dwarf2_per_objfile
->info
.size
);
2120 objfile
->psymtabs_addrmap
= addrmap_create_fixed (objfile
->psymtabs_addrmap
,
2121 &objfile
->objfile_obstack
);
2123 do_cleanups (back_to
);
2126 /* Load the partial DIEs for a secondary CU into memory. */
2129 load_partial_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
2130 struct objfile
*objfile
)
2132 bfd
*abfd
= objfile
->obfd
;
2133 gdb_byte
*info_ptr
, *beg_of_comp_unit
;
2134 struct die_info
*comp_unit_die
;
2135 struct dwarf2_cu
*cu
;
2136 unsigned int bytes_read
;
2137 struct cleanup
*back_to
;
2138 struct attribute
*attr
;
2140 struct die_reader_specs reader_specs
;
2142 gdb_assert (! this_cu
->from_debug_types
);
2144 info_ptr
= dwarf2_per_objfile
->info
.buffer
+ this_cu
->offset
;
2145 beg_of_comp_unit
= info_ptr
;
2147 cu
= alloc_one_comp_unit (objfile
);
2149 /* ??? Missing cleanup for CU? */
2151 /* Link this compilation unit into the compilation unit tree. */
2153 cu
->per_cu
= this_cu
;
2154 cu
->type_hash
= this_cu
->type_hash
;
2156 info_ptr
= partial_read_comp_unit_head (&cu
->header
, info_ptr
,
2157 dwarf2_per_objfile
->info
.buffer
,
2158 dwarf2_per_objfile
->info
.size
,
2161 /* Complete the cu_header. */
2162 cu
->header
.offset
= this_cu
->offset
;
2163 cu
->header
.first_die_offset
= info_ptr
- beg_of_comp_unit
;
2165 /* Read the abbrevs for this compilation unit into a table. */
2166 dwarf2_read_abbrevs (abfd
, cu
);
2167 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
2169 /* Read the compilation unit die. */
2170 init_cu_die_reader (&reader_specs
, cu
);
2171 info_ptr
= read_full_die (&reader_specs
, &comp_unit_die
, info_ptr
,
2174 /* Set the language we're debugging. */
2175 attr
= dwarf2_attr (comp_unit_die
, DW_AT_language
, cu
);
2177 set_cu_language (DW_UNSND (attr
), cu
);
2179 set_cu_language (language_minimal
, cu
);
2181 /* Check if comp unit has_children.
2182 If so, read the rest of the partial symbols from this comp unit.
2183 If not, there's no more debug_info for this comp unit. */
2185 load_partial_dies (abfd
, dwarf2_per_objfile
->info
.buffer
, info_ptr
, 0, cu
);
2187 do_cleanups (back_to
);
2190 /* Create a list of all compilation units in OBJFILE. We do this only
2191 if an inter-comp-unit reference is found; presumably if there is one,
2192 there will be many, and one will occur early in the .debug_info section.
2193 So there's no point in building this list incrementally. */
2196 create_all_comp_units (struct objfile
*objfile
)
2200 struct dwarf2_per_cu_data
**all_comp_units
;
2201 gdb_byte
*info_ptr
= dwarf2_per_objfile
->info
.buffer
;
2205 all_comp_units
= xmalloc (n_allocated
2206 * sizeof (struct dwarf2_per_cu_data
*));
2208 while (info_ptr
< dwarf2_per_objfile
->info
.buffer
+ dwarf2_per_objfile
->info
.size
)
2210 unsigned int length
, initial_length_size
;
2211 gdb_byte
*beg_of_comp_unit
;
2212 struct dwarf2_per_cu_data
*this_cu
;
2213 unsigned int offset
;
2215 offset
= info_ptr
- dwarf2_per_objfile
->info
.buffer
;
2217 /* Read just enough information to find out where the next
2218 compilation unit is. */
2219 length
= read_initial_length (objfile
->obfd
, info_ptr
,
2220 &initial_length_size
);
2222 /* Save the compilation unit for later lookup. */
2223 this_cu
= obstack_alloc (&objfile
->objfile_obstack
,
2224 sizeof (struct dwarf2_per_cu_data
));
2225 memset (this_cu
, 0, sizeof (*this_cu
));
2226 this_cu
->offset
= offset
;
2227 this_cu
->length
= length
+ initial_length_size
;
2229 if (n_comp_units
== n_allocated
)
2232 all_comp_units
= xrealloc (all_comp_units
,
2234 * sizeof (struct dwarf2_per_cu_data
*));
2236 all_comp_units
[n_comp_units
++] = this_cu
;
2238 info_ptr
= info_ptr
+ this_cu
->length
;
2241 dwarf2_per_objfile
->all_comp_units
2242 = obstack_alloc (&objfile
->objfile_obstack
,
2243 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
2244 memcpy (dwarf2_per_objfile
->all_comp_units
, all_comp_units
,
2245 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
2246 xfree (all_comp_units
);
2247 dwarf2_per_objfile
->n_comp_units
= n_comp_units
;
2250 /* Process all loaded DIEs for compilation unit CU, starting at
2251 FIRST_DIE. The caller should pass NEED_PC == 1 if the compilation
2252 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
2253 DW_AT_ranges). If NEED_PC is set, then this function will set
2254 *LOWPC and *HIGHPC to the lowest and highest PC values found in CU
2255 and record the covered ranges in the addrmap. */
2258 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
2259 CORE_ADDR
*highpc
, int need_pc
, struct dwarf2_cu
*cu
)
2261 struct objfile
*objfile
= cu
->objfile
;
2262 bfd
*abfd
= objfile
->obfd
;
2263 struct partial_die_info
*pdi
;
2265 /* Now, march along the PDI's, descending into ones which have
2266 interesting children but skipping the children of the other ones,
2267 until we reach the end of the compilation unit. */
2273 fixup_partial_die (pdi
, cu
);
2275 /* Anonymous namespaces have no name but have interesting
2276 children, so we need to look at them. Ditto for anonymous
2279 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
2280 || pdi
->tag
== DW_TAG_enumeration_type
)
2284 case DW_TAG_subprogram
:
2285 add_partial_subprogram (pdi
, lowpc
, highpc
, need_pc
, cu
);
2287 case DW_TAG_variable
:
2288 case DW_TAG_typedef
:
2289 case DW_TAG_union_type
:
2290 if (!pdi
->is_declaration
)
2292 add_partial_symbol (pdi
, cu
);
2295 case DW_TAG_class_type
:
2296 case DW_TAG_interface_type
:
2297 case DW_TAG_structure_type
:
2298 if (!pdi
->is_declaration
)
2300 add_partial_symbol (pdi
, cu
);
2303 case DW_TAG_enumeration_type
:
2304 if (!pdi
->is_declaration
)
2305 add_partial_enumeration (pdi
, cu
);
2307 case DW_TAG_base_type
:
2308 case DW_TAG_subrange_type
:
2309 /* File scope base type definitions are added to the partial
2311 add_partial_symbol (pdi
, cu
);
2313 case DW_TAG_namespace
:
2314 add_partial_namespace (pdi
, lowpc
, highpc
, need_pc
, cu
);
2317 add_partial_module (pdi
, lowpc
, highpc
, need_pc
, cu
);
2324 /* If the die has a sibling, skip to the sibling. */
2326 pdi
= pdi
->die_sibling
;
2330 /* Functions used to compute the fully scoped name of a partial DIE.
2332 Normally, this is simple. For C++, the parent DIE's fully scoped
2333 name is concatenated with "::" and the partial DIE's name. For
2334 Java, the same thing occurs except that "." is used instead of "::".
2335 Enumerators are an exception; they use the scope of their parent
2336 enumeration type, i.e. the name of the enumeration type is not
2337 prepended to the enumerator.
2339 There are two complexities. One is DW_AT_specification; in this
2340 case "parent" means the parent of the target of the specification,
2341 instead of the direct parent of the DIE. The other is compilers
2342 which do not emit DW_TAG_namespace; in this case we try to guess
2343 the fully qualified name of structure types from their members'
2344 linkage names. This must be done using the DIE's children rather
2345 than the children of any DW_AT_specification target. We only need
2346 to do this for structures at the top level, i.e. if the target of
2347 any DW_AT_specification (if any; otherwise the DIE itself) does not
2350 /* Compute the scope prefix associated with PDI's parent, in
2351 compilation unit CU. The result will be allocated on CU's
2352 comp_unit_obstack, or a copy of the already allocated PDI->NAME
2353 field. NULL is returned if no prefix is necessary. */
2355 partial_die_parent_scope (struct partial_die_info
*pdi
,
2356 struct dwarf2_cu
*cu
)
2358 char *grandparent_scope
;
2359 struct partial_die_info
*parent
, *real_pdi
;
2361 /* We need to look at our parent DIE; if we have a DW_AT_specification,
2362 then this means the parent of the specification DIE. */
2365 while (real_pdi
->has_specification
)
2366 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
2368 parent
= real_pdi
->die_parent
;
2372 if (parent
->scope_set
)
2373 return parent
->scope
;
2375 fixup_partial_die (parent
, cu
);
2377 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
2379 if (parent
->tag
== DW_TAG_namespace
2380 || parent
->tag
== DW_TAG_structure_type
2381 || parent
->tag
== DW_TAG_class_type
2382 || parent
->tag
== DW_TAG_interface_type
2383 || parent
->tag
== DW_TAG_union_type
2384 || parent
->tag
== DW_TAG_enumeration_type
)
2386 if (grandparent_scope
== NULL
)
2387 parent
->scope
= parent
->name
;
2389 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
, grandparent_scope
,
2392 else if (parent
->tag
== DW_TAG_enumerator
)
2393 /* Enumerators should not get the name of the enumeration as a prefix. */
2394 parent
->scope
= grandparent_scope
;
2397 /* FIXME drow/2004-04-01: What should we be doing with
2398 function-local names? For partial symbols, we should probably be
2400 complaint (&symfile_complaints
,
2401 _("unhandled containing DIE tag %d for DIE at %d"),
2402 parent
->tag
, pdi
->offset
);
2403 parent
->scope
= grandparent_scope
;
2406 parent
->scope_set
= 1;
2407 return parent
->scope
;
2410 /* Return the fully scoped name associated with PDI, from compilation unit
2411 CU. The result will be allocated with malloc. */
2413 partial_die_full_name (struct partial_die_info
*pdi
,
2414 struct dwarf2_cu
*cu
)
2418 parent_scope
= partial_die_parent_scope (pdi
, cu
);
2419 if (parent_scope
== NULL
)
2422 return typename_concat (NULL
, parent_scope
, pdi
->name
, cu
);
2426 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
2428 struct objfile
*objfile
= cu
->objfile
;
2430 char *actual_name
= NULL
;
2431 const char *my_prefix
;
2432 const struct partial_symbol
*psym
= NULL
;
2434 int built_actual_name
= 0;
2436 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2438 actual_name
= partial_die_full_name (pdi
, cu
);
2440 built_actual_name
= 1;
2442 if (actual_name
== NULL
)
2443 actual_name
= pdi
->name
;
2447 case DW_TAG_subprogram
:
2448 if (pdi
->is_external
|| cu
->language
== language_ada
)
2450 /* brobecker/2007-12-26: Normally, only "external" DIEs are part
2451 of the global scope. But in Ada, we want to be able to access
2452 nested procedures globally. So all Ada subprograms are stored
2453 in the global scope. */
2454 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
2455 mst_text, objfile); */
2456 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
2458 VAR_DOMAIN
, LOC_BLOCK
,
2459 &objfile
->global_psymbols
,
2460 0, pdi
->lowpc
+ baseaddr
,
2461 cu
->language
, objfile
);
2465 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
2466 mst_file_text, objfile); */
2467 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
2469 VAR_DOMAIN
, LOC_BLOCK
,
2470 &objfile
->static_psymbols
,
2471 0, pdi
->lowpc
+ baseaddr
,
2472 cu
->language
, objfile
);
2475 case DW_TAG_variable
:
2476 if (pdi
->is_external
)
2479 Don't enter into the minimal symbol tables as there is
2480 a minimal symbol table entry from the ELF symbols already.
2481 Enter into partial symbol table if it has a location
2482 descriptor or a type.
2483 If the location descriptor is missing, new_symbol will create
2484 a LOC_UNRESOLVED symbol, the address of the variable will then
2485 be determined from the minimal symbol table whenever the variable
2487 The address for the partial symbol table entry is not
2488 used by GDB, but it comes in handy for debugging partial symbol
2492 addr
= decode_locdesc (pdi
->locdesc
, cu
);
2493 if (pdi
->locdesc
|| pdi
->has_type
)
2494 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
2496 VAR_DOMAIN
, LOC_STATIC
,
2497 &objfile
->global_psymbols
,
2499 cu
->language
, objfile
);
2503 /* Static Variable. Skip symbols without location descriptors. */
2504 if (pdi
->locdesc
== NULL
)
2506 if (built_actual_name
)
2507 xfree (actual_name
);
2510 addr
= decode_locdesc (pdi
->locdesc
, cu
);
2511 /*prim_record_minimal_symbol (actual_name, addr + baseaddr,
2512 mst_file_data, objfile); */
2513 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
2515 VAR_DOMAIN
, LOC_STATIC
,
2516 &objfile
->static_psymbols
,
2518 cu
->language
, objfile
);
2521 case DW_TAG_typedef
:
2522 case DW_TAG_base_type
:
2523 case DW_TAG_subrange_type
:
2524 add_psymbol_to_list (actual_name
, strlen (actual_name
),
2526 VAR_DOMAIN
, LOC_TYPEDEF
,
2527 &objfile
->static_psymbols
,
2528 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
2530 case DW_TAG_namespace
:
2531 add_psymbol_to_list (actual_name
, strlen (actual_name
),
2533 VAR_DOMAIN
, LOC_TYPEDEF
,
2534 &objfile
->global_psymbols
,
2535 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
2537 case DW_TAG_class_type
:
2538 case DW_TAG_interface_type
:
2539 case DW_TAG_structure_type
:
2540 case DW_TAG_union_type
:
2541 case DW_TAG_enumeration_type
:
2542 /* Skip external references. The DWARF standard says in the section
2543 about "Structure, Union, and Class Type Entries": "An incomplete
2544 structure, union or class type is represented by a structure,
2545 union or class entry that does not have a byte size attribute
2546 and that has a DW_AT_declaration attribute." */
2547 if (!pdi
->has_byte_size
&& pdi
->is_declaration
)
2549 if (built_actual_name
)
2550 xfree (actual_name
);
2554 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
2555 static vs. global. */
2556 add_psymbol_to_list (actual_name
, strlen (actual_name
),
2558 STRUCT_DOMAIN
, LOC_TYPEDEF
,
2559 (cu
->language
== language_cplus
2560 || cu
->language
== language_java
)
2561 ? &objfile
->global_psymbols
2562 : &objfile
->static_psymbols
,
2563 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
2566 case DW_TAG_enumerator
:
2567 add_psymbol_to_list (actual_name
, strlen (actual_name
),
2569 VAR_DOMAIN
, LOC_CONST
,
2570 (cu
->language
== language_cplus
2571 || cu
->language
== language_java
)
2572 ? &objfile
->global_psymbols
2573 : &objfile
->static_psymbols
,
2574 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
2580 if (built_actual_name
)
2581 xfree (actual_name
);
2584 /* Read a partial die corresponding to a namespace; also, add a symbol
2585 corresponding to that namespace to the symbol table. NAMESPACE is
2586 the name of the enclosing namespace. */
2589 add_partial_namespace (struct partial_die_info
*pdi
,
2590 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
2591 int need_pc
, struct dwarf2_cu
*cu
)
2593 struct objfile
*objfile
= cu
->objfile
;
2595 /* Add a symbol for the namespace. */
2597 add_partial_symbol (pdi
, cu
);
2599 /* Now scan partial symbols in that namespace. */
2601 if (pdi
->has_children
)
2602 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, need_pc
, cu
);
2605 /* Read a partial die corresponding to a Fortran module. */
2608 add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
2609 CORE_ADDR
*highpc
, int need_pc
, struct dwarf2_cu
*cu
)
2611 /* Now scan partial symbols in that module.
2613 FIXME: Support the separate Fortran module namespaces. */
2615 if (pdi
->has_children
)
2616 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, need_pc
, cu
);
2619 /* Read a partial die corresponding to a subprogram and create a partial
2620 symbol for that subprogram. When the CU language allows it, this
2621 routine also defines a partial symbol for each nested subprogram
2622 that this subprogram contains.
2624 DIE my also be a lexical block, in which case we simply search
2625 recursively for suprograms defined inside that lexical block.
2626 Again, this is only performed when the CU language allows this
2627 type of definitions. */
2630 add_partial_subprogram (struct partial_die_info
*pdi
,
2631 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
2632 int need_pc
, struct dwarf2_cu
*cu
)
2634 if (pdi
->tag
== DW_TAG_subprogram
)
2636 if (pdi
->has_pc_info
)
2638 if (pdi
->lowpc
< *lowpc
)
2639 *lowpc
= pdi
->lowpc
;
2640 if (pdi
->highpc
> *highpc
)
2641 *highpc
= pdi
->highpc
;
2645 struct objfile
*objfile
= cu
->objfile
;
2647 baseaddr
= ANOFFSET (objfile
->section_offsets
,
2648 SECT_OFF_TEXT (objfile
));
2649 addrmap_set_empty (objfile
->psymtabs_addrmap
,
2650 pdi
->lowpc
+ baseaddr
,
2651 pdi
->highpc
- 1 + baseaddr
,
2652 cu
->per_cu
->psymtab
);
2654 if (!pdi
->is_declaration
)
2655 add_partial_symbol (pdi
, cu
);
2659 if (! pdi
->has_children
)
2662 if (cu
->language
== language_ada
)
2664 pdi
= pdi
->die_child
;
2667 fixup_partial_die (pdi
, cu
);
2668 if (pdi
->tag
== DW_TAG_subprogram
2669 || pdi
->tag
== DW_TAG_lexical_block
)
2670 add_partial_subprogram (pdi
, lowpc
, highpc
, need_pc
, cu
);
2671 pdi
= pdi
->die_sibling
;
2676 /* See if we can figure out if the class lives in a namespace. We do
2677 this by looking for a member function; its demangled name will
2678 contain namespace info, if there is any. */
2681 guess_structure_name (struct partial_die_info
*struct_pdi
,
2682 struct dwarf2_cu
*cu
)
2684 if ((cu
->language
== language_cplus
2685 || cu
->language
== language_java
)
2686 && cu
->has_namespace_info
== 0
2687 && struct_pdi
->has_children
)
2689 /* NOTE: carlton/2003-10-07: Getting the info this way changes
2690 what template types look like, because the demangler
2691 frequently doesn't give the same name as the debug info. We
2692 could fix this by only using the demangled name to get the
2693 prefix (but see comment in read_structure_type). */
2695 struct partial_die_info
*real_pdi
;
2697 /* If this DIE (this DIE's specification, if any) has a parent, then
2698 we should not do this. We'll prepend the parent's fully qualified
2699 name when we create the partial symbol. */
2701 real_pdi
= struct_pdi
;
2702 while (real_pdi
->has_specification
)
2703 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
2705 if (real_pdi
->die_parent
!= NULL
)
2710 /* Read a partial die corresponding to an enumeration type. */
2713 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
2714 struct dwarf2_cu
*cu
)
2716 struct objfile
*objfile
= cu
->objfile
;
2717 bfd
*abfd
= objfile
->obfd
;
2718 struct partial_die_info
*pdi
;
2720 if (enum_pdi
->name
!= NULL
)
2721 add_partial_symbol (enum_pdi
, cu
);
2723 pdi
= enum_pdi
->die_child
;
2726 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
2727 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
2729 add_partial_symbol (pdi
, cu
);
2730 pdi
= pdi
->die_sibling
;
2734 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
2735 Return the corresponding abbrev, or NULL if the number is zero (indicating
2736 an empty DIE). In either case *BYTES_READ will be set to the length of
2737 the initial number. */
2739 static struct abbrev_info
*
2740 peek_die_abbrev (gdb_byte
*info_ptr
, unsigned int *bytes_read
,
2741 struct dwarf2_cu
*cu
)
2743 bfd
*abfd
= cu
->objfile
->obfd
;
2744 unsigned int abbrev_number
;
2745 struct abbrev_info
*abbrev
;
2747 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
2749 if (abbrev_number
== 0)
2752 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
2755 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"), abbrev_number
,
2756 bfd_get_filename (abfd
));
2762 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
2763 Returns a pointer to the end of a series of DIEs, terminated by an empty
2764 DIE. Any children of the skipped DIEs will also be skipped. */
2767 skip_children (gdb_byte
*buffer
, gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
2769 struct abbrev_info
*abbrev
;
2770 unsigned int bytes_read
;
2774 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
2776 return info_ptr
+ bytes_read
;
2778 info_ptr
= skip_one_die (buffer
, info_ptr
+ bytes_read
, abbrev
, cu
);
2782 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
2783 INFO_PTR should point just after the initial uleb128 of a DIE, and the
2784 abbrev corresponding to that skipped uleb128 should be passed in
2785 ABBREV. Returns a pointer to this DIE's sibling, skipping any
2789 skip_one_die (gdb_byte
*buffer
, gdb_byte
*info_ptr
,
2790 struct abbrev_info
*abbrev
, struct dwarf2_cu
*cu
)
2792 unsigned int bytes_read
;
2793 struct attribute attr
;
2794 bfd
*abfd
= cu
->objfile
->obfd
;
2795 unsigned int form
, i
;
2797 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
2799 /* The only abbrev we care about is DW_AT_sibling. */
2800 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
2802 read_attribute (&attr
, &abbrev
->attrs
[i
],
2803 abfd
, info_ptr
, cu
);
2804 if (attr
.form
== DW_FORM_ref_addr
)
2805 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
2807 return buffer
+ dwarf2_get_ref_die_offset (&attr
);
2810 /* If it isn't DW_AT_sibling, skip this attribute. */
2811 form
= abbrev
->attrs
[i
].form
;
2815 case DW_FORM_ref_addr
:
2816 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
2817 and later it is offset sized. */
2818 if (cu
->header
.version
== 2)
2819 info_ptr
+= cu
->header
.addr_size
;
2821 info_ptr
+= cu
->header
.offset_size
;
2824 info_ptr
+= cu
->header
.addr_size
;
2844 case DW_FORM_string
:
2845 read_string (abfd
, info_ptr
, &bytes_read
);
2846 info_ptr
+= bytes_read
;
2849 info_ptr
+= cu
->header
.offset_size
;
2852 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2853 info_ptr
+= bytes_read
;
2855 case DW_FORM_block1
:
2856 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
2858 case DW_FORM_block2
:
2859 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
2861 case DW_FORM_block4
:
2862 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
2866 case DW_FORM_ref_udata
:
2867 info_ptr
= skip_leb128 (abfd
, info_ptr
);
2869 case DW_FORM_indirect
:
2870 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2871 info_ptr
+= bytes_read
;
2872 /* We need to continue parsing from here, so just go back to
2874 goto skip_attribute
;
2877 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
2878 dwarf_form_name (form
),
2879 bfd_get_filename (abfd
));
2883 if (abbrev
->has_children
)
2884 return skip_children (buffer
, info_ptr
, cu
);
2889 /* Locate ORIG_PDI's sibling.
2890 INFO_PTR should point to the start of the next DIE after ORIG_PDI
2894 locate_pdi_sibling (struct partial_die_info
*orig_pdi
,
2895 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
2896 bfd
*abfd
, struct dwarf2_cu
*cu
)
2898 /* Do we know the sibling already? */
2900 if (orig_pdi
->sibling
)
2901 return orig_pdi
->sibling
;
2903 /* Are there any children to deal with? */
2905 if (!orig_pdi
->has_children
)
2908 /* Skip the children the long way. */
2910 return skip_children (buffer
, info_ptr
, cu
);
2913 /* Expand this partial symbol table into a full symbol table. */
2916 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
2918 /* FIXME: This is barely more than a stub. */
2923 warning (_("bug: psymtab for %s is already read in."), pst
->filename
);
2929 printf_filtered (_("Reading in symbols for %s..."), pst
->filename
);
2930 gdb_flush (gdb_stdout
);
2933 /* Restore our global data. */
2934 dwarf2_per_objfile
= objfile_data (pst
->objfile
,
2935 dwarf2_objfile_data_key
);
2937 /* If this psymtab is constructed from a debug-only objfile, the
2938 has_section_at_zero flag will not necessarily be correct. We
2939 can get the correct value for this flag by looking at the data
2940 associated with the (presumably stripped) associated objfile. */
2941 if (pst
->objfile
->separate_debug_objfile_backlink
)
2943 struct dwarf2_per_objfile
*dpo_backlink
2944 = objfile_data (pst
->objfile
->separate_debug_objfile_backlink
,
2945 dwarf2_objfile_data_key
);
2946 dwarf2_per_objfile
->has_section_at_zero
2947 = dpo_backlink
->has_section_at_zero
;
2950 psymtab_to_symtab_1 (pst
);
2952 /* Finish up the debug error message. */
2954 printf_filtered (_("done.\n"));
2959 /* Add PER_CU to the queue. */
2962 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
, struct objfile
*objfile
)
2964 struct dwarf2_queue_item
*item
;
2967 item
= xmalloc (sizeof (*item
));
2968 item
->per_cu
= per_cu
;
2971 if (dwarf2_queue
== NULL
)
2972 dwarf2_queue
= item
;
2974 dwarf2_queue_tail
->next
= item
;
2976 dwarf2_queue_tail
= item
;
2979 /* Process the queue. */
2982 process_queue (struct objfile
*objfile
)
2984 struct dwarf2_queue_item
*item
, *next_item
;
2986 /* The queue starts out with one item, but following a DIE reference
2987 may load a new CU, adding it to the end of the queue. */
2988 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
2990 if (item
->per_cu
->psymtab
&& !item
->per_cu
->psymtab
->readin
)
2991 process_full_comp_unit (item
->per_cu
);
2993 item
->per_cu
->queued
= 0;
2994 next_item
= item
->next
;
2998 dwarf2_queue_tail
= NULL
;
3001 /* Free all allocated queue entries. This function only releases anything if
3002 an error was thrown; if the queue was processed then it would have been
3003 freed as we went along. */
3006 dwarf2_release_queue (void *dummy
)
3008 struct dwarf2_queue_item
*item
, *last
;
3010 item
= dwarf2_queue
;
3013 /* Anything still marked queued is likely to be in an
3014 inconsistent state, so discard it. */
3015 if (item
->per_cu
->queued
)
3017 if (item
->per_cu
->cu
!= NULL
)
3018 free_one_cached_comp_unit (item
->per_cu
->cu
);
3019 item
->per_cu
->queued
= 0;
3027 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
3030 /* Read in full symbols for PST, and anything it depends on. */
3033 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
3035 struct dwarf2_per_cu_data
*per_cu
;
3036 struct cleanup
*back_to
;
3039 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
3040 if (!pst
->dependencies
[i
]->readin
)
3042 /* Inform about additional files that need to be read in. */
3045 /* FIXME: i18n: Need to make this a single string. */
3046 fputs_filtered (" ", gdb_stdout
);
3048 fputs_filtered ("and ", gdb_stdout
);
3050 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
3051 wrap_here (""); /* Flush output */
3052 gdb_flush (gdb_stdout
);
3054 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
3057 per_cu
= (struct dwarf2_per_cu_data
*) pst
->read_symtab_private
;
3061 /* It's an include file, no symbols to read for it.
3062 Everything is in the parent symtab. */
3067 back_to
= make_cleanup (dwarf2_release_queue
, NULL
);
3069 queue_comp_unit (per_cu
, pst
->objfile
);
3071 if (per_cu
->from_debug_types
)
3072 read_signatured_type_at_offset (pst
->objfile
, per_cu
->offset
);
3074 load_full_comp_unit (per_cu
, pst
->objfile
);
3076 process_queue (pst
->objfile
);
3078 /* Age the cache, releasing compilation units that have not
3079 been used recently. */
3080 age_cached_comp_units ();
3082 do_cleanups (back_to
);
3085 /* Load the DIEs associated with PER_CU into memory. */
3088 load_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
, struct objfile
*objfile
)
3090 bfd
*abfd
= objfile
->obfd
;
3091 struct dwarf2_cu
*cu
;
3092 unsigned int offset
;
3093 gdb_byte
*info_ptr
, *beg_of_comp_unit
;
3094 struct cleanup
*back_to
, *free_cu_cleanup
;
3095 struct attribute
*attr
;
3098 gdb_assert (! per_cu
->from_debug_types
);
3100 /* Set local variables from the partial symbol table info. */
3101 offset
= per_cu
->offset
;
3103 info_ptr
= dwarf2_per_objfile
->info
.buffer
+ offset
;
3104 beg_of_comp_unit
= info_ptr
;
3106 cu
= alloc_one_comp_unit (objfile
);
3108 /* If an error occurs while loading, release our storage. */
3109 free_cu_cleanup
= make_cleanup (free_one_comp_unit
, cu
);
3111 /* Read in the comp_unit header. */
3112 info_ptr
= read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
3114 /* Complete the cu_header. */
3115 cu
->header
.offset
= offset
;
3116 cu
->header
.first_die_offset
= info_ptr
- beg_of_comp_unit
;
3118 /* Read the abbrevs for this compilation unit. */
3119 dwarf2_read_abbrevs (abfd
, cu
);
3120 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
3122 /* Link this compilation unit into the compilation unit tree. */
3124 cu
->per_cu
= per_cu
;
3125 cu
->type_hash
= per_cu
->type_hash
;
3127 cu
->dies
= read_comp_unit (info_ptr
, cu
);
3129 /* We try not to read any attributes in this function, because not
3130 all objfiles needed for references have been loaded yet, and symbol
3131 table processing isn't initialized. But we have to set the CU language,
3132 or we won't be able to build types correctly. */
3133 attr
= dwarf2_attr (cu
->dies
, DW_AT_language
, cu
);
3135 set_cu_language (DW_UNSND (attr
), cu
);
3137 set_cu_language (language_minimal
, cu
);
3139 /* Link this CU into read_in_chain. */
3140 per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
3141 dwarf2_per_objfile
->read_in_chain
= per_cu
;
3143 do_cleanups (back_to
);
3145 /* We've successfully allocated this compilation unit. Let our caller
3146 clean it up when finished with it. */
3147 discard_cleanups (free_cu_cleanup
);
3150 /* Generate full symbol information for PST and CU, whose DIEs have
3151 already been loaded into memory. */
3154 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
3156 struct partial_symtab
*pst
= per_cu
->psymtab
;
3157 struct dwarf2_cu
*cu
= per_cu
->cu
;
3158 struct objfile
*objfile
= pst
->objfile
;
3159 bfd
*abfd
= objfile
->obfd
;
3160 CORE_ADDR lowpc
, highpc
;
3161 struct symtab
*symtab
;
3162 struct cleanup
*back_to
;
3165 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3168 back_to
= make_cleanup (really_free_pendings
, NULL
);
3170 cu
->list_in_scope
= &file_symbols
;
3172 dwarf2_find_base_address (cu
->dies
, cu
);
3174 /* Do line number decoding in read_file_scope () */
3175 process_die (cu
->dies
, cu
);
3177 /* Some compilers don't define a DW_AT_high_pc attribute for the
3178 compilation unit. If the DW_AT_high_pc is missing, synthesize
3179 it, by scanning the DIE's below the compilation unit. */
3180 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
3182 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
3184 /* Set symtab language to language from DW_AT_language.
3185 If the compilation is from a C file generated by language preprocessors,
3186 do not set the language if it was already deduced by start_subfile. */
3188 && !(cu
->language
== language_c
&& symtab
->language
!= language_c
))
3190 symtab
->language
= cu
->language
;
3192 pst
->symtab
= symtab
;
3195 do_cleanups (back_to
);
3198 /* Process a die and its children. */
3201 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
3205 case DW_TAG_padding
:
3207 case DW_TAG_compile_unit
:
3208 read_file_scope (die
, cu
);
3210 case DW_TAG_type_unit
:
3211 read_type_unit_scope (die
, cu
);
3213 case DW_TAG_subprogram
:
3214 case DW_TAG_inlined_subroutine
:
3215 read_func_scope (die
, cu
);
3217 case DW_TAG_lexical_block
:
3218 case DW_TAG_try_block
:
3219 case DW_TAG_catch_block
:
3220 read_lexical_block_scope (die
, cu
);
3222 case DW_TAG_class_type
:
3223 case DW_TAG_interface_type
:
3224 case DW_TAG_structure_type
:
3225 case DW_TAG_union_type
:
3226 process_structure_scope (die
, cu
);
3228 case DW_TAG_enumeration_type
:
3229 process_enumeration_scope (die
, cu
);
3232 /* These dies have a type, but processing them does not create
3233 a symbol or recurse to process the children. Therefore we can
3234 read them on-demand through read_type_die. */
3235 case DW_TAG_subroutine_type
:
3236 case DW_TAG_set_type
:
3237 case DW_TAG_array_type
:
3238 case DW_TAG_pointer_type
:
3239 case DW_TAG_ptr_to_member_type
:
3240 case DW_TAG_reference_type
:
3241 case DW_TAG_string_type
:
3244 case DW_TAG_base_type
:
3245 case DW_TAG_subrange_type
:
3246 case DW_TAG_typedef
:
3247 /* Add a typedef symbol for the type definition, if it has a
3249 new_symbol (die
, read_type_die (die
, cu
), cu
);
3251 case DW_TAG_common_block
:
3252 read_common_block (die
, cu
);
3254 case DW_TAG_common_inclusion
:
3256 case DW_TAG_namespace
:
3257 processing_has_namespace_info
= 1;
3258 read_namespace (die
, cu
);
3261 read_module (die
, cu
);
3263 case DW_TAG_imported_declaration
:
3264 case DW_TAG_imported_module
:
3265 processing_has_namespace_info
= 1;
3266 if (die
->child
!= NULL
&& (die
->tag
== DW_TAG_imported_declaration
3267 || cu
->language
!= language_fortran
))
3268 complaint (&symfile_complaints
, _("Tag '%s' has unexpected children"),
3269 dwarf_tag_name (die
->tag
));
3270 read_import_statement (die
, cu
);
3273 new_symbol (die
, NULL
, cu
);
3278 /* A helper function for dwarf2_compute_name which determines whether DIE
3279 needs to have the name of the scope prepended to the name listed in the
3283 die_needs_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
3287 case DW_TAG_namespace
:
3288 case DW_TAG_typedef
:
3289 case DW_TAG_class_type
:
3290 case DW_TAG_interface_type
:
3291 case DW_TAG_structure_type
:
3292 case DW_TAG_union_type
:
3293 case DW_TAG_enumeration_type
:
3294 case DW_TAG_enumerator
:
3295 case DW_TAG_subprogram
:
3299 case DW_TAG_variable
:
3300 /* We only need to prefix "globally" visible variables. These include
3301 any variable marked with DW_AT_external or any variable that
3302 lives in a namespace. [Variables in anonymous namespaces
3303 require prefixing, but they are not DW_AT_external.] */
3305 if (dwarf2_attr (die
, DW_AT_specification
, cu
))
3307 struct dwarf2_cu
*spec_cu
= cu
;
3308 return die_needs_namespace (die_specification (die
, &spec_cu
),
3312 if (dwarf2_attr (die
, DW_AT_external
, cu
)
3313 || die
->parent
->tag
== DW_TAG_namespace
)
3323 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
3324 compute the physname for the object, which include a method's
3325 formal parameters (C++/Java) and return type (Java).
3327 The result is allocated on the objfile_obstack and canonicalized. */
3330 dwarf2_compute_name (char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
,
3334 name
= dwarf2_name (die
, cu
);
3336 /* These are the only languages we know how to qualify names in. */
3338 && (cu
->language
== language_cplus
|| cu
->language
== language_java
))
3340 if (die_needs_namespace (die
, cu
))
3344 struct ui_file
*buf
;
3346 prefix
= determine_prefix (die
, cu
);
3347 buf
= mem_fileopen ();
3348 if (*prefix
!= '\0')
3350 char *prefixed_name
= typename_concat (NULL
, prefix
, name
, cu
);
3351 fputs_unfiltered (prefixed_name
, buf
);
3352 xfree (prefixed_name
);
3355 fputs_unfiltered (name
? name
: "", buf
);
3357 /* For Java and C++ methods, append formal parameter type
3358 information, if PHYSNAME. */
3360 if (physname
&& die
->tag
== DW_TAG_subprogram
3361 && (cu
->language
== language_cplus
3362 || cu
->language
== language_java
))
3364 struct type
*type
= read_type_die (die
, cu
);
3366 c_type_print_args (type
, buf
, 0, cu
->language
);
3368 if (cu
->language
== language_java
)
3370 /* For java, we must append the return type to method
3372 if (die
->tag
== DW_TAG_subprogram
)
3373 java_print_type (TYPE_TARGET_TYPE (type
), "", buf
,
3376 else if (cu
->language
== language_cplus
)
3378 if (TYPE_NFIELDS (type
) > 0
3379 && TYPE_FIELD_ARTIFICIAL (type
, 0)
3380 && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type
, 0))))
3381 fputs_unfiltered (" const", buf
);
3385 name
= ui_file_obsavestring (buf
, &cu
->objfile
->objfile_obstack
,
3387 ui_file_delete (buf
);
3389 if (cu
->language
== language_cplus
)
3392 = dwarf2_canonicalize_name (name
, cu
,
3393 &cu
->objfile
->objfile_obstack
);
3403 /* Return the fully qualified name of DIE, based on its DW_AT_name.
3404 If scope qualifiers are appropriate they will be added. The result
3405 will be allocated on the objfile_obstack, or NULL if the DIE does
3406 not have a name. NAME may either be from a previous call to
3407 dwarf2_name or NULL.
3409 The output string will be canonicalized (if C++/Java). */
3412 dwarf2_full_name (char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
3414 return dwarf2_compute_name (name
, die
, cu
, 0);
3417 /* Construct a physname for the given DIE in CU. NAME may either be
3418 from a previous call to dwarf2_name or NULL. The result will be
3419 allocated on the objfile_objstack or NULL if the DIE does not have a
3422 The output string will be canonicalized (if C++/Java). */
3425 dwarf2_physname (char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
3427 return dwarf2_compute_name (name
, die
, cu
, 1);
3430 /* Read the import statement specified by the given die and record it. */
3433 read_import_statement (struct die_info
*die
, struct dwarf2_cu
*cu
)
3435 struct attribute
*import_attr
;
3436 struct die_info
*imported_die
;
3437 struct dwarf2_cu
*imported_cu
;
3438 const char *imported_name
;
3439 const char *imported_name_prefix
;
3442 const char *import_prefix
;
3443 char *canonical_name
;
3445 import_attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
3446 if (import_attr
== NULL
)
3448 complaint (&symfile_complaints
, _("Tag '%s' has no DW_AT_import"),
3449 dwarf_tag_name (die
->tag
));
3454 imported_die
= follow_die_ref_or_sig (die
, import_attr
, &imported_cu
);
3455 imported_name
= dwarf2_name (imported_die
, imported_cu
);
3456 if (imported_name
== NULL
)
3458 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
3460 The import in the following code:
3474 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
3475 <52> DW_AT_decl_file : 1
3476 <53> DW_AT_decl_line : 6
3477 <54> DW_AT_import : <0x75>
3478 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
3480 <5b> DW_AT_decl_file : 1
3481 <5c> DW_AT_decl_line : 2
3482 <5d> DW_AT_type : <0x6e>
3484 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
3485 <76> DW_AT_byte_size : 4
3486 <77> DW_AT_encoding : 5 (signed)
3488 imports the wrong die ( 0x75 instead of 0x58 ).
3489 This case will be ignored until the gcc bug is fixed. */
3493 /* Figure out the local name after import. */
3494 import_alias
= dwarf2_name (die
, cu
);
3496 /* Figure out where the statement is being imported to. */
3497 import_prefix
= determine_prefix (die
, cu
);
3499 /* Figure out what the scope of the imported die is and prepend it
3500 to the name of the imported die. */
3501 imported_name_prefix
= determine_prefix (imported_die
, imported_cu
);
3503 if (strlen (imported_name_prefix
) > 0)
3505 canonical_name
= alloca (strlen (imported_name_prefix
)
3506 + 2 + strlen (imported_name
) + 1);
3507 strcpy (canonical_name
, imported_name_prefix
);
3508 strcat (canonical_name
, "::");
3509 strcat (canonical_name
, imported_name
);
3513 canonical_name
= alloca (strlen (imported_name
) + 1);
3514 strcpy (canonical_name
, imported_name
);
3517 using_directives
= cp_add_using (import_prefix
,
3524 initialize_cu_func_list (struct dwarf2_cu
*cu
)
3526 cu
->first_fn
= cu
->last_fn
= cu
->cached_fn
= NULL
;
3530 free_cu_line_header (void *arg
)
3532 struct dwarf2_cu
*cu
= arg
;
3534 free_line_header (cu
->line_header
);
3535 cu
->line_header
= NULL
;
3539 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
3541 struct objfile
*objfile
= cu
->objfile
;
3542 struct comp_unit_head
*cu_header
= &cu
->header
;
3543 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
3544 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
3545 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
3546 struct attribute
*attr
;
3548 char *comp_dir
= NULL
;
3549 struct die_info
*child_die
;
3550 bfd
*abfd
= objfile
->obfd
;
3551 struct line_header
*line_header
= 0;
3554 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3556 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
3558 /* If we didn't find a lowpc, set it to highpc to avoid complaints
3559 from finish_block. */
3560 if (lowpc
== ((CORE_ADDR
) -1))
3565 /* Find the filename. Do not use dwarf2_name here, since the filename
3566 is not a source language identifier. */
3567 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3570 name
= DW_STRING (attr
);
3573 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
3575 comp_dir
= DW_STRING (attr
);
3576 else if (name
!= NULL
&& IS_ABSOLUTE_PATH (name
))
3578 comp_dir
= ldirname (name
);
3579 if (comp_dir
!= NULL
)
3580 make_cleanup (xfree
, comp_dir
);
3582 if (comp_dir
!= NULL
)
3584 /* Irix 6.2 native cc prepends <machine>.: to the compilation
3585 directory, get rid of it. */
3586 char *cp
= strchr (comp_dir
, ':');
3588 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
3595 attr
= dwarf2_attr (die
, DW_AT_language
, cu
);
3598 set_cu_language (DW_UNSND (attr
), cu
);
3601 attr
= dwarf2_attr (die
, DW_AT_producer
, cu
);
3603 cu
->producer
= DW_STRING (attr
);
3605 /* We assume that we're processing GCC output. */
3606 processing_gcc_compilation
= 2;
3608 processing_has_namespace_info
= 0;
3610 start_symtab (name
, comp_dir
, lowpc
);
3611 record_debugformat ("DWARF 2");
3612 record_producer (cu
->producer
);
3614 initialize_cu_func_list (cu
);
3616 /* Decode line number information if present. We do this before
3617 processing child DIEs, so that the line header table is available
3618 for DW_AT_decl_file. */
3619 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
3622 unsigned int line_offset
= DW_UNSND (attr
);
3623 line_header
= dwarf_decode_line_header (line_offset
, abfd
, cu
);
3626 cu
->line_header
= line_header
;
3627 make_cleanup (free_cu_line_header
, cu
);
3628 dwarf_decode_lines (line_header
, comp_dir
, abfd
, cu
, NULL
);
3632 /* Process all dies in compilation unit. */
3633 if (die
->child
!= NULL
)
3635 child_die
= die
->child
;
3636 while (child_die
&& child_die
->tag
)
3638 process_die (child_die
, cu
);
3639 child_die
= sibling_die (child_die
);
3643 /* Decode macro information, if present. Dwarf 2 macro information
3644 refers to information in the line number info statement program
3645 header, so we can only read it if we've read the header
3647 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
3648 if (attr
&& line_header
)
3650 unsigned int macro_offset
= DW_UNSND (attr
);
3651 dwarf_decode_macros (line_header
, macro_offset
,
3652 comp_dir
, abfd
, cu
);
3654 do_cleanups (back_to
);
3657 /* For TUs we want to skip the first top level sibling if it's not the
3658 actual type being defined by this TU. In this case the first top
3659 level sibling is there to provide context only. */
3662 read_type_unit_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
3664 struct objfile
*objfile
= cu
->objfile
;
3665 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
3667 struct attribute
*attr
;
3669 char *comp_dir
= NULL
;
3670 struct die_info
*child_die
;
3671 bfd
*abfd
= objfile
->obfd
;
3672 struct line_header
*line_header
= 0;
3674 /* start_symtab needs a low pc, but we don't really have one.
3675 Do what read_file_scope would do in the absence of such info. */
3676 lowpc
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3678 /* Find the filename. Do not use dwarf2_name here, since the filename
3679 is not a source language identifier. */
3680 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3682 name
= DW_STRING (attr
);
3684 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
3686 comp_dir
= DW_STRING (attr
);
3687 else if (name
!= NULL
&& IS_ABSOLUTE_PATH (name
))
3689 comp_dir
= ldirname (name
);
3690 if (comp_dir
!= NULL
)
3691 make_cleanup (xfree
, comp_dir
);
3697 attr
= dwarf2_attr (die
, DW_AT_language
, cu
);
3699 set_cu_language (DW_UNSND (attr
), cu
);
3701 /* This isn't technically needed today. It is done for symmetry
3702 with read_file_scope. */
3703 attr
= dwarf2_attr (die
, DW_AT_producer
, cu
);
3705 cu
->producer
= DW_STRING (attr
);
3707 /* We assume that we're processing GCC output. */
3708 processing_gcc_compilation
= 2;
3710 processing_has_namespace_info
= 0;
3712 start_symtab (name
, comp_dir
, lowpc
);
3713 record_debugformat ("DWARF 2");
3714 record_producer (cu
->producer
);
3716 /* Process the dies in the type unit. */
3717 if (die
->child
== NULL
)
3719 dump_die_for_error (die
);
3720 error (_("Dwarf Error: Missing children for type unit [in module %s]"),
3721 bfd_get_filename (abfd
));
3724 child_die
= die
->child
;
3726 while (child_die
&& child_die
->tag
)
3728 process_die (child_die
, cu
);
3730 child_die
= sibling_die (child_die
);
3733 do_cleanups (back_to
);
3737 add_to_cu_func_list (const char *name
, CORE_ADDR lowpc
, CORE_ADDR highpc
,
3738 struct dwarf2_cu
*cu
)
3740 struct function_range
*thisfn
;
3742 thisfn
= (struct function_range
*)
3743 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct function_range
));
3744 thisfn
->name
= name
;
3745 thisfn
->lowpc
= lowpc
;
3746 thisfn
->highpc
= highpc
;
3747 thisfn
->seen_line
= 0;
3748 thisfn
->next
= NULL
;
3750 if (cu
->last_fn
== NULL
)
3751 cu
->first_fn
= thisfn
;
3753 cu
->last_fn
->next
= thisfn
;
3755 cu
->last_fn
= thisfn
;
3758 /* qsort helper for inherit_abstract_dies. */
3761 unsigned_int_compar (const void *ap
, const void *bp
)
3763 unsigned int a
= *(unsigned int *) ap
;
3764 unsigned int b
= *(unsigned int *) bp
;
3766 return (a
> b
) - (b
> a
);
3769 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
3770 Inherit only the children of the DW_AT_abstract_origin DIE not being already
3771 referenced by DW_AT_abstract_origin from the children of the current DIE. */
3774 inherit_abstract_dies (struct die_info
*die
, struct dwarf2_cu
*cu
)
3776 struct die_info
*child_die
;
3777 unsigned die_children_count
;
3778 /* CU offsets which were referenced by children of the current DIE. */
3780 unsigned *offsets_end
, *offsetp
;
3781 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
3782 struct die_info
*origin_die
;
3783 /* Iterator of the ORIGIN_DIE children. */
3784 struct die_info
*origin_child_die
;
3785 struct cleanup
*cleanups
;
3786 struct attribute
*attr
;
3788 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
3792 origin_die
= follow_die_ref (die
, attr
, &cu
);
3793 if (die
->tag
!= origin_die
->tag
3794 && !(die
->tag
== DW_TAG_inlined_subroutine
3795 && origin_die
->tag
== DW_TAG_subprogram
))
3796 complaint (&symfile_complaints
,
3797 _("DIE 0x%x and its abstract origin 0x%x have different tags"),
3798 die
->offset
, origin_die
->offset
);
3800 child_die
= die
->child
;
3801 die_children_count
= 0;
3802 while (child_die
&& child_die
->tag
)
3804 child_die
= sibling_die (child_die
);
3805 die_children_count
++;
3807 offsets
= xmalloc (sizeof (*offsets
) * die_children_count
);
3808 cleanups
= make_cleanup (xfree
, offsets
);
3810 offsets_end
= offsets
;
3811 child_die
= die
->child
;
3812 while (child_die
&& child_die
->tag
)
3814 /* For each CHILD_DIE, find the corresponding child of
3815 ORIGIN_DIE. If there is more than one layer of
3816 DW_AT_abstract_origin, follow them all; there shouldn't be,
3817 but GCC versions at least through 4.4 generate this (GCC PR
3819 struct die_info
*child_origin_die
= child_die
;
3822 attr
= dwarf2_attr (child_origin_die
, DW_AT_abstract_origin
, cu
);
3825 child_origin_die
= follow_die_ref (child_origin_die
, attr
, &cu
);
3828 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
3829 counterpart may exist. */
3830 if (child_origin_die
!= child_die
)
3832 if (child_die
->tag
!= child_origin_die
->tag
3833 && !(child_die
->tag
== DW_TAG_inlined_subroutine
3834 && child_origin_die
->tag
== DW_TAG_subprogram
))
3835 complaint (&symfile_complaints
,
3836 _("Child DIE 0x%x and its abstract origin 0x%x have "
3837 "different tags"), child_die
->offset
,
3838 child_origin_die
->offset
);
3839 if (child_origin_die
->parent
!= origin_die
)
3840 complaint (&symfile_complaints
,
3841 _("Child DIE 0x%x and its abstract origin 0x%x have "
3842 "different parents"), child_die
->offset
,
3843 child_origin_die
->offset
);
3845 *offsets_end
++ = child_origin_die
->offset
;
3847 child_die
= sibling_die (child_die
);
3849 qsort (offsets
, offsets_end
- offsets
, sizeof (*offsets
),
3850 unsigned_int_compar
);
3851 for (offsetp
= offsets
+ 1; offsetp
< offsets_end
; offsetp
++)
3852 if (offsetp
[-1] == *offsetp
)
3853 complaint (&symfile_complaints
, _("Multiple children of DIE 0x%x refer "
3854 "to DIE 0x%x as their abstract origin"),
3855 die
->offset
, *offsetp
);
3858 origin_child_die
= origin_die
->child
;
3859 while (origin_child_die
&& origin_child_die
->tag
)
3861 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
3862 while (offsetp
< offsets_end
&& *offsetp
< origin_child_die
->offset
)
3864 if (offsetp
>= offsets_end
|| *offsetp
> origin_child_die
->offset
)
3866 /* Found that ORIGIN_CHILD_DIE is really not referenced. */
3867 process_die (origin_child_die
, cu
);
3869 origin_child_die
= sibling_die (origin_child_die
);
3872 do_cleanups (cleanups
);
3876 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
3878 struct objfile
*objfile
= cu
->objfile
;
3879 struct context_stack
*new;
3882 struct die_info
*child_die
;
3883 struct attribute
*attr
, *call_line
, *call_file
;
3886 struct block
*block
;
3887 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
3891 /* If we do not have call site information, we can't show the
3892 caller of this inlined function. That's too confusing, so
3893 only use the scope for local variables. */
3894 call_line
= dwarf2_attr (die
, DW_AT_call_line
, cu
);
3895 call_file
= dwarf2_attr (die
, DW_AT_call_file
, cu
);
3896 if (call_line
== NULL
|| call_file
== NULL
)
3898 read_lexical_block_scope (die
, cu
);
3903 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3905 name
= dwarf2_name (die
, cu
);
3907 /* Ignore functions with missing or empty names and functions with
3908 missing or invalid low and high pc attributes. */
3909 if (name
== NULL
|| !dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
3915 /* Record the function range for dwarf_decode_lines. */
3916 add_to_cu_func_list (name
, lowpc
, highpc
, cu
);
3918 new = push_context (0, lowpc
);
3919 new->name
= new_symbol (die
, read_type_die (die
, cu
), cu
);
3921 /* If there is a location expression for DW_AT_frame_base, record
3923 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
3925 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
3926 expression is being recorded directly in the function's symbol
3927 and not in a separate frame-base object. I guess this hack is
3928 to avoid adding some sort of frame-base adjunct/annex to the
3929 function's symbol :-(. The problem with doing this is that it
3930 results in a function symbol with a location expression that
3931 has nothing to do with the location of the function, ouch! The
3932 relationship should be: a function's symbol has-a frame base; a
3933 frame-base has-a location expression. */
3934 dwarf2_symbol_mark_computed (attr
, new->name
, cu
);
3936 cu
->list_in_scope
= &local_symbols
;
3938 if (die
->child
!= NULL
)
3940 child_die
= die
->child
;
3941 while (child_die
&& child_die
->tag
)
3943 process_die (child_die
, cu
);
3944 child_die
= sibling_die (child_die
);
3948 inherit_abstract_dies (die
, cu
);
3950 new = pop_context ();
3951 /* Make a block for the local symbols within. */
3952 block
= finish_block (new->name
, &local_symbols
, new->old_blocks
,
3953 lowpc
, highpc
, objfile
);
3955 /* For C++, set the block's scope. */
3956 if (cu
->language
== language_cplus
)
3957 cp_set_block_scope (new->name
, block
, &objfile
->objfile_obstack
,
3958 determine_prefix (die
, cu
),
3959 processing_has_namespace_info
);
3961 /* If we have address ranges, record them. */
3962 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
3964 /* In C++, we can have functions nested inside functions (e.g., when
3965 a function declares a class that has methods). This means that
3966 when we finish processing a function scope, we may need to go
3967 back to building a containing block's symbol lists. */
3968 local_symbols
= new->locals
;
3969 param_symbols
= new->params
;
3970 using_directives
= new->using_directives
;
3972 /* If we've finished processing a top-level function, subsequent
3973 symbols go in the file symbol list. */
3974 if (outermost_context_p ())
3975 cu
->list_in_scope
= &file_symbols
;
3978 /* Process all the DIES contained within a lexical block scope. Start
3979 a new scope, process the dies, and then close the scope. */
3982 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
3984 struct objfile
*objfile
= cu
->objfile
;
3985 struct context_stack
*new;
3986 CORE_ADDR lowpc
, highpc
;
3987 struct die_info
*child_die
;
3990 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3992 /* Ignore blocks with missing or invalid low and high pc attributes. */
3993 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
3994 as multiple lexical blocks? Handling children in a sane way would
3995 be nasty. Might be easier to properly extend generic blocks to
3997 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
4002 push_context (0, lowpc
);
4003 if (die
->child
!= NULL
)
4005 child_die
= die
->child
;
4006 while (child_die
&& child_die
->tag
)
4008 process_die (child_die
, cu
);
4009 child_die
= sibling_die (child_die
);
4012 new = pop_context ();
4014 if (local_symbols
!= NULL
|| using_directives
!= NULL
)
4017 = finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
4020 /* Note that recording ranges after traversing children, as we
4021 do here, means that recording a parent's ranges entails
4022 walking across all its children's ranges as they appear in
4023 the address map, which is quadratic behavior.
4025 It would be nicer to record the parent's ranges before
4026 traversing its children, simply overriding whatever you find
4027 there. But since we don't even decide whether to create a
4028 block until after we've traversed its children, that's hard
4030 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
4032 local_symbols
= new->locals
;
4033 using_directives
= new->using_directives
;
4036 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
4037 Return 1 if the attributes are present and valid, otherwise, return 0.
4038 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
4041 dwarf2_ranges_read (unsigned offset
, CORE_ADDR
*low_return
,
4042 CORE_ADDR
*high_return
, struct dwarf2_cu
*cu
,
4043 struct partial_symtab
*ranges_pst
)
4045 struct objfile
*objfile
= cu
->objfile
;
4046 struct comp_unit_head
*cu_header
= &cu
->header
;
4047 bfd
*obfd
= objfile
->obfd
;
4048 unsigned int addr_size
= cu_header
->addr_size
;
4049 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
4050 /* Base address selection entry. */
4061 found_base
= cu
->base_known
;
4062 base
= cu
->base_address
;
4064 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
4066 complaint (&symfile_complaints
,
4067 _("Offset %d out of bounds for DW_AT_ranges attribute"),
4071 buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
4073 /* Read in the largest possible address. */
4074 marker
= read_address (obfd
, buffer
, cu
, &dummy
);
4075 if ((marker
& mask
) == mask
)
4077 /* If we found the largest possible address, then
4078 read the base address. */
4079 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
4080 buffer
+= 2 * addr_size
;
4081 offset
+= 2 * addr_size
;
4087 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
4091 CORE_ADDR range_beginning
, range_end
;
4093 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
4094 buffer
+= addr_size
;
4095 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
4096 buffer
+= addr_size
;
4097 offset
+= 2 * addr_size
;
4099 /* An end of list marker is a pair of zero addresses. */
4100 if (range_beginning
== 0 && range_end
== 0)
4101 /* Found the end of list entry. */
4104 /* Each base address selection entry is a pair of 2 values.
4105 The first is the largest possible address, the second is
4106 the base address. Check for a base address here. */
4107 if ((range_beginning
& mask
) == mask
)
4109 /* If we found the largest possible address, then
4110 read the base address. */
4111 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
4118 /* We have no valid base address for the ranges
4120 complaint (&symfile_complaints
,
4121 _("Invalid .debug_ranges data (no base address)"));
4125 range_beginning
+= base
;
4128 if (ranges_pst
!= NULL
&& range_beginning
< range_end
)
4129 addrmap_set_empty (objfile
->psymtabs_addrmap
,
4130 range_beginning
+ baseaddr
, range_end
- 1 + baseaddr
,
4133 /* FIXME: This is recording everything as a low-high
4134 segment of consecutive addresses. We should have a
4135 data structure for discontiguous block ranges
4139 low
= range_beginning
;
4145 if (range_beginning
< low
)
4146 low
= range_beginning
;
4147 if (range_end
> high
)
4153 /* If the first entry is an end-of-list marker, the range
4154 describes an empty scope, i.e. no instructions. */
4160 *high_return
= high
;
4164 /* Get low and high pc attributes from a die. Return 1 if the attributes
4165 are present and valid, otherwise, return 0. Return -1 if the range is
4166 discontinuous, i.e. derived from DW_AT_ranges information. */
4168 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
4169 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
,
4170 struct partial_symtab
*pst
)
4172 struct attribute
*attr
;
4177 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
4180 high
= DW_ADDR (attr
);
4181 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
4183 low
= DW_ADDR (attr
);
4185 /* Found high w/o low attribute. */
4188 /* Found consecutive range of addresses. */
4193 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
4196 /* Value of the DW_AT_ranges attribute is the offset in the
4197 .debug_ranges section. */
4198 if (!dwarf2_ranges_read (DW_UNSND (attr
), &low
, &high
, cu
, pst
))
4200 /* Found discontinuous range of addresses. */
4208 /* When using the GNU linker, .gnu.linkonce. sections are used to
4209 eliminate duplicate copies of functions and vtables and such.
4210 The linker will arbitrarily choose one and discard the others.
4211 The AT_*_pc values for such functions refer to local labels in
4212 these sections. If the section from that file was discarded, the
4213 labels are not in the output, so the relocs get a value of 0.
4214 If this is a discarded function, mark the pc bounds as invalid,
4215 so that GDB will ignore it. */
4216 if (low
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
4224 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
4225 its low and high PC addresses. Do nothing if these addresses could not
4226 be determined. Otherwise, set LOWPC to the low address if it is smaller,
4227 and HIGHPC to the high address if greater than HIGHPC. */
4230 dwarf2_get_subprogram_pc_bounds (struct die_info
*die
,
4231 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
4232 struct dwarf2_cu
*cu
)
4234 CORE_ADDR low
, high
;
4235 struct die_info
*child
= die
->child
;
4237 if (dwarf2_get_pc_bounds (die
, &low
, &high
, cu
, NULL
))
4239 *lowpc
= min (*lowpc
, low
);
4240 *highpc
= max (*highpc
, high
);
4243 /* If the language does not allow nested subprograms (either inside
4244 subprograms or lexical blocks), we're done. */
4245 if (cu
->language
!= language_ada
)
4248 /* Check all the children of the given DIE. If it contains nested
4249 subprograms, then check their pc bounds. Likewise, we need to
4250 check lexical blocks as well, as they may also contain subprogram
4252 while (child
&& child
->tag
)
4254 if (child
->tag
== DW_TAG_subprogram
4255 || child
->tag
== DW_TAG_lexical_block
)
4256 dwarf2_get_subprogram_pc_bounds (child
, lowpc
, highpc
, cu
);
4257 child
= sibling_die (child
);
4261 /* Get the low and high pc's represented by the scope DIE, and store
4262 them in *LOWPC and *HIGHPC. If the correct values can't be
4263 determined, set *LOWPC to -1 and *HIGHPC to 0. */
4266 get_scope_pc_bounds (struct die_info
*die
,
4267 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
4268 struct dwarf2_cu
*cu
)
4270 CORE_ADDR best_low
= (CORE_ADDR
) -1;
4271 CORE_ADDR best_high
= (CORE_ADDR
) 0;
4272 CORE_ADDR current_low
, current_high
;
4274 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
, NULL
))
4276 best_low
= current_low
;
4277 best_high
= current_high
;
4281 struct die_info
*child
= die
->child
;
4283 while (child
&& child
->tag
)
4285 switch (child
->tag
) {
4286 case DW_TAG_subprogram
:
4287 dwarf2_get_subprogram_pc_bounds (child
, &best_low
, &best_high
, cu
);
4289 case DW_TAG_namespace
:
4290 /* FIXME: carlton/2004-01-16: Should we do this for
4291 DW_TAG_class_type/DW_TAG_structure_type, too? I think
4292 that current GCC's always emit the DIEs corresponding
4293 to definitions of methods of classes as children of a
4294 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
4295 the DIEs giving the declarations, which could be
4296 anywhere). But I don't see any reason why the
4297 standards says that they have to be there. */
4298 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
4300 if (current_low
!= ((CORE_ADDR
) -1))
4302 best_low
= min (best_low
, current_low
);
4303 best_high
= max (best_high
, current_high
);
4311 child
= sibling_die (child
);
4316 *highpc
= best_high
;
4319 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
4322 dwarf2_record_block_ranges (struct die_info
*die
, struct block
*block
,
4323 CORE_ADDR baseaddr
, struct dwarf2_cu
*cu
)
4325 struct attribute
*attr
;
4327 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
4330 CORE_ADDR high
= DW_ADDR (attr
);
4331 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
4334 CORE_ADDR low
= DW_ADDR (attr
);
4335 record_block_range (block
, baseaddr
+ low
, baseaddr
+ high
- 1);
4339 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
4342 bfd
*obfd
= cu
->objfile
->obfd
;
4344 /* The value of the DW_AT_ranges attribute is the offset of the
4345 address range list in the .debug_ranges section. */
4346 unsigned long offset
= DW_UNSND (attr
);
4347 gdb_byte
*buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
4349 /* For some target architectures, but not others, the
4350 read_address function sign-extends the addresses it returns.
4351 To recognize base address selection entries, we need a
4353 unsigned int addr_size
= cu
->header
.addr_size
;
4354 CORE_ADDR base_select_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
4356 /* The base address, to which the next pair is relative. Note
4357 that this 'base' is a DWARF concept: most entries in a range
4358 list are relative, to reduce the number of relocs against the
4359 debugging information. This is separate from this function's
4360 'baseaddr' argument, which GDB uses to relocate debugging
4361 information from a shared library based on the address at
4362 which the library was loaded. */
4363 CORE_ADDR base
= cu
->base_address
;
4364 int base_known
= cu
->base_known
;
4366 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
4368 complaint (&symfile_complaints
,
4369 _("Offset %lu out of bounds for DW_AT_ranges attribute"),
4376 unsigned int bytes_read
;
4377 CORE_ADDR start
, end
;
4379 start
= read_address (obfd
, buffer
, cu
, &bytes_read
);
4380 buffer
+= bytes_read
;
4381 end
= read_address (obfd
, buffer
, cu
, &bytes_read
);
4382 buffer
+= bytes_read
;
4384 /* Did we find the end of the range list? */
4385 if (start
== 0 && end
== 0)
4388 /* Did we find a base address selection entry? */
4389 else if ((start
& base_select_mask
) == base_select_mask
)
4395 /* We found an ordinary address range. */
4400 complaint (&symfile_complaints
,
4401 _("Invalid .debug_ranges data (no base address)"));
4405 record_block_range (block
,
4406 baseaddr
+ base
+ start
,
4407 baseaddr
+ base
+ end
- 1);
4413 /* Add an aggregate field to the field list. */
4416 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
4417 struct dwarf2_cu
*cu
)
4419 struct objfile
*objfile
= cu
->objfile
;
4420 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
4421 struct nextfield
*new_field
;
4422 struct attribute
*attr
;
4424 char *fieldname
= "";
4426 /* Allocate a new field list entry and link it in. */
4427 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
4428 make_cleanup (xfree
, new_field
);
4429 memset (new_field
, 0, sizeof (struct nextfield
));
4431 if (die
->tag
== DW_TAG_inheritance
)
4433 new_field
->next
= fip
->baseclasses
;
4434 fip
->baseclasses
= new_field
;
4438 new_field
->next
= fip
->fields
;
4439 fip
->fields
= new_field
;
4443 /* Handle accessibility and virtuality of field.
4444 The default accessibility for members is public, the default
4445 accessibility for inheritance is private. */
4446 if (die
->tag
!= DW_TAG_inheritance
)
4447 new_field
->accessibility
= DW_ACCESS_public
;
4449 new_field
->accessibility
= DW_ACCESS_private
;
4450 new_field
->virtuality
= DW_VIRTUALITY_none
;
4452 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
4454 new_field
->accessibility
= DW_UNSND (attr
);
4455 if (new_field
->accessibility
!= DW_ACCESS_public
)
4456 fip
->non_public_fields
= 1;
4457 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
4459 new_field
->virtuality
= DW_UNSND (attr
);
4461 fp
= &new_field
->field
;
4463 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
4465 /* Data member other than a C++ static data member. */
4467 /* Get type of field. */
4468 fp
->type
= die_type (die
, cu
);
4470 SET_FIELD_BITPOS (*fp
, 0);
4472 /* Get bit size of field (zero if none). */
4473 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
4476 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
4480 FIELD_BITSIZE (*fp
) = 0;
4483 /* Get bit offset of field. */
4484 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
4487 int byte_offset
= 0;
4489 if (attr_form_is_section_offset (attr
))
4490 dwarf2_complex_location_expr_complaint ();
4491 else if (attr_form_is_constant (attr
))
4492 byte_offset
= dwarf2_get_attr_constant_value (attr
, 0);
4493 else if (attr_form_is_block (attr
))
4494 byte_offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
4496 dwarf2_complex_location_expr_complaint ();
4498 SET_FIELD_BITPOS (*fp
, byte_offset
* bits_per_byte
);
4500 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
4503 if (gdbarch_bits_big_endian (gdbarch
))
4505 /* For big endian bits, the DW_AT_bit_offset gives the
4506 additional bit offset from the MSB of the containing
4507 anonymous object to the MSB of the field. We don't
4508 have to do anything special since we don't need to
4509 know the size of the anonymous object. */
4510 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
4514 /* For little endian bits, compute the bit offset to the
4515 MSB of the anonymous object, subtract off the number of
4516 bits from the MSB of the field to the MSB of the
4517 object, and then subtract off the number of bits of
4518 the field itself. The result is the bit offset of
4519 the LSB of the field. */
4521 int bit_offset
= DW_UNSND (attr
);
4523 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4526 /* The size of the anonymous object containing
4527 the bit field is explicit, so use the
4528 indicated size (in bytes). */
4529 anonymous_size
= DW_UNSND (attr
);
4533 /* The size of the anonymous object containing
4534 the bit field must be inferred from the type
4535 attribute of the data member containing the
4537 anonymous_size
= TYPE_LENGTH (fp
->type
);
4539 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
4540 - bit_offset
- FIELD_BITSIZE (*fp
);
4544 /* Get name of field. */
4545 fieldname
= dwarf2_name (die
, cu
);
4546 if (fieldname
== NULL
)
4549 /* The name is already allocated along with this objfile, so we don't
4550 need to duplicate it for the type. */
4551 fp
->name
= fieldname
;
4553 /* Change accessibility for artificial fields (e.g. virtual table
4554 pointer or virtual base class pointer) to private. */
4555 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
4557 FIELD_ARTIFICIAL (*fp
) = 1;
4558 new_field
->accessibility
= DW_ACCESS_private
;
4559 fip
->non_public_fields
= 1;
4562 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
4564 /* C++ static member. */
4566 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
4567 is a declaration, but all versions of G++ as of this writing
4568 (so through at least 3.2.1) incorrectly generate
4569 DW_TAG_variable tags. */
4573 /* Get name of field. */
4574 fieldname
= dwarf2_name (die
, cu
);
4575 if (fieldname
== NULL
)
4578 /* Get physical name. */
4579 physname
= (char *) dwarf2_physname (fieldname
, die
, cu
);
4581 /* The name is already allocated along with this objfile, so we don't
4582 need to duplicate it for the type. */
4583 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
4584 FIELD_TYPE (*fp
) = die_type (die
, cu
);
4585 FIELD_NAME (*fp
) = fieldname
;
4587 else if (die
->tag
== DW_TAG_inheritance
)
4589 /* C++ base class field. */
4590 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
4593 int byte_offset
= 0;
4595 if (attr_form_is_section_offset (attr
))
4596 dwarf2_complex_location_expr_complaint ();
4597 else if (attr_form_is_constant (attr
))
4598 byte_offset
= dwarf2_get_attr_constant_value (attr
, 0);
4599 else if (attr_form_is_block (attr
))
4600 byte_offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
4602 dwarf2_complex_location_expr_complaint ();
4604 SET_FIELD_BITPOS (*fp
, byte_offset
* bits_per_byte
);
4606 FIELD_BITSIZE (*fp
) = 0;
4607 FIELD_TYPE (*fp
) = die_type (die
, cu
);
4608 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
4609 fip
->nbaseclasses
++;
4613 /* Create the vector of fields, and attach it to the type. */
4616 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
4617 struct dwarf2_cu
*cu
)
4619 int nfields
= fip
->nfields
;
4621 /* Record the field count, allocate space for the array of fields,
4622 and create blank accessibility bitfields if necessary. */
4623 TYPE_NFIELDS (type
) = nfields
;
4624 TYPE_FIELDS (type
) = (struct field
*)
4625 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
4626 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
4628 if (fip
->non_public_fields
&& cu
->language
!= language_ada
)
4630 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
4632 TYPE_FIELD_PRIVATE_BITS (type
) =
4633 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
4634 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
4636 TYPE_FIELD_PROTECTED_BITS (type
) =
4637 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
4638 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
4640 TYPE_FIELD_IGNORE_BITS (type
) =
4641 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
4642 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
4645 /* If the type has baseclasses, allocate and clear a bit vector for
4646 TYPE_FIELD_VIRTUAL_BITS. */
4647 if (fip
->nbaseclasses
&& cu
->language
!= language_ada
)
4649 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
4650 unsigned char *pointer
;
4652 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
4653 pointer
= TYPE_ALLOC (type
, num_bytes
);
4654 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
4655 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
4656 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
4659 /* Copy the saved-up fields into the field vector. Start from the head
4660 of the list, adding to the tail of the field array, so that they end
4661 up in the same order in the array in which they were added to the list. */
4662 while (nfields
-- > 0)
4664 struct nextfield
*fieldp
;
4668 fieldp
= fip
->fields
;
4669 fip
->fields
= fieldp
->next
;
4673 fieldp
= fip
->baseclasses
;
4674 fip
->baseclasses
= fieldp
->next
;
4677 TYPE_FIELD (type
, nfields
) = fieldp
->field
;
4678 switch (fieldp
->accessibility
)
4680 case DW_ACCESS_private
:
4681 if (cu
->language
!= language_ada
)
4682 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
4685 case DW_ACCESS_protected
:
4686 if (cu
->language
!= language_ada
)
4687 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
4690 case DW_ACCESS_public
:
4694 /* Unknown accessibility. Complain and treat it as public. */
4696 complaint (&symfile_complaints
, _("unsupported accessibility %d"),
4697 fieldp
->accessibility
);
4701 if (nfields
< fip
->nbaseclasses
)
4703 switch (fieldp
->virtuality
)
4705 case DW_VIRTUALITY_virtual
:
4706 case DW_VIRTUALITY_pure_virtual
:
4707 if (cu
->language
== language_ada
)
4708 error ("unexpected virtuality in component of Ada type");
4709 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
4716 /* Add a member function to the proper fieldlist. */
4719 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
4720 struct type
*type
, struct dwarf2_cu
*cu
)
4722 struct objfile
*objfile
= cu
->objfile
;
4723 struct attribute
*attr
;
4724 struct fnfieldlist
*flp
;
4726 struct fn_field
*fnp
;
4729 struct nextfnfield
*new_fnfield
;
4730 struct type
*this_type
;
4732 if (cu
->language
== language_ada
)
4733 error ("unexpected member function in Ada type");
4735 /* Get name of member function. */
4736 fieldname
= dwarf2_name (die
, cu
);
4737 if (fieldname
== NULL
)
4740 /* Get the mangled name. */
4741 physname
= (char *) dwarf2_physname (fieldname
, die
, cu
);
4743 /* Look up member function name in fieldlist. */
4744 for (i
= 0; i
< fip
->nfnfields
; i
++)
4746 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
4750 /* Create new list element if necessary. */
4751 if (i
< fip
->nfnfields
)
4752 flp
= &fip
->fnfieldlists
[i
];
4755 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
4757 fip
->fnfieldlists
= (struct fnfieldlist
*)
4758 xrealloc (fip
->fnfieldlists
,
4759 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
4760 * sizeof (struct fnfieldlist
));
4761 if (fip
->nfnfields
== 0)
4762 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
4764 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
4765 flp
->name
= fieldname
;
4771 /* Create a new member function field and chain it to the field list
4773 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
4774 make_cleanup (xfree
, new_fnfield
);
4775 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
4776 new_fnfield
->next
= flp
->head
;
4777 flp
->head
= new_fnfield
;
4780 /* Fill in the member function field info. */
4781 fnp
= &new_fnfield
->fnfield
;
4782 /* The name is already allocated along with this objfile, so we don't
4783 need to duplicate it for the type. */
4784 fnp
->physname
= physname
? physname
: "";
4785 fnp
->type
= alloc_type (objfile
);
4786 this_type
= read_type_die (die
, cu
);
4787 if (this_type
&& TYPE_CODE (this_type
) == TYPE_CODE_FUNC
)
4789 int nparams
= TYPE_NFIELDS (this_type
);
4791 /* TYPE is the domain of this method, and THIS_TYPE is the type
4792 of the method itself (TYPE_CODE_METHOD). */
4793 smash_to_method_type (fnp
->type
, type
,
4794 TYPE_TARGET_TYPE (this_type
),
4795 TYPE_FIELDS (this_type
),
4796 TYPE_NFIELDS (this_type
),
4797 TYPE_VARARGS (this_type
));
4799 /* Handle static member functions.
4800 Dwarf2 has no clean way to discern C++ static and non-static
4801 member functions. G++ helps GDB by marking the first
4802 parameter for non-static member functions (which is the
4803 this pointer) as artificial. We obtain this information
4804 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
4805 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (this_type
, 0) == 0)
4806 fnp
->voffset
= VOFFSET_STATIC
;
4809 complaint (&symfile_complaints
, _("member function type missing for '%s'"),
4812 /* Get fcontext from DW_AT_containing_type if present. */
4813 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
4814 fnp
->fcontext
= die_containing_type (die
, cu
);
4816 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
4817 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
4819 /* Get accessibility. */
4820 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
4823 switch (DW_UNSND (attr
))
4825 case DW_ACCESS_private
:
4826 fnp
->is_private
= 1;
4828 case DW_ACCESS_protected
:
4829 fnp
->is_protected
= 1;
4834 /* Check for artificial methods. */
4835 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
4836 if (attr
&& DW_UNSND (attr
) != 0)
4837 fnp
->is_artificial
= 1;
4839 /* Get index in virtual function table if it is a virtual member
4840 function. For GCC, this is an offset in the appropriate
4841 virtual table, as specified by DW_AT_containing_type. For
4842 everyone else, it is an expression to be evaluated relative
4843 to the object address. */
4845 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
4846 if (attr
&& fnp
->fcontext
)
4848 /* Support the .debug_loc offsets */
4849 if (attr_form_is_block (attr
))
4851 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
4853 else if (attr_form_is_section_offset (attr
))
4855 dwarf2_complex_location_expr_complaint ();
4859 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
4865 /* We only support trivial expressions here. This hack will work
4866 for v3 classes, which always start with the vtable pointer. */
4867 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
> 0
4868 && DW_BLOCK (attr
)->data
[0] == DW_OP_deref
)
4870 struct dwarf_block blk
;
4871 blk
.size
= DW_BLOCK (attr
)->size
- 1;
4872 blk
.data
= DW_BLOCK (attr
)->data
+ 1;
4873 fnp
->voffset
= decode_locdesc (&blk
, cu
);
4874 if ((fnp
->voffset
% cu
->header
.addr_size
) != 0)
4875 dwarf2_complex_location_expr_complaint ();
4877 fnp
->voffset
/= cu
->header
.addr_size
;
4879 fnp
->fcontext
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type
, 0));
4882 dwarf2_complex_location_expr_complaint ();
4886 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
4887 if (attr
&& DW_UNSND (attr
))
4889 /* GCC does this, as of 2008-08-25; PR debug/37237. */
4890 complaint (&symfile_complaints
,
4891 _("Member function \"%s\" (offset %d) is virtual but the vtable offset is not specified"),
4892 fieldname
, die
->offset
);
4893 TYPE_CPLUS_DYNAMIC (type
) = 1;
4898 /* Create the vector of member function fields, and attach it to the type. */
4901 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
4902 struct dwarf2_cu
*cu
)
4904 struct fnfieldlist
*flp
;
4905 int total_length
= 0;
4908 if (cu
->language
== language_ada
)
4909 error ("unexpected member functions in Ada type");
4911 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
4912 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
4913 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
4915 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
4917 struct nextfnfield
*nfp
= flp
->head
;
4918 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
4921 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
4922 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
4923 fn_flp
->fn_fields
= (struct fn_field
*)
4924 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
4925 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
4926 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
4928 total_length
+= flp
->length
;
4931 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
4932 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
4935 /* Returns non-zero if NAME is the name of a vtable member in CU's
4936 language, zero otherwise. */
4938 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
4940 static const char vptr
[] = "_vptr";
4941 static const char vtable
[] = "vtable";
4943 /* Look for the C++ and Java forms of the vtable. */
4944 if ((cu
->language
== language_java
4945 && strncmp (name
, vtable
, sizeof (vtable
) - 1) == 0)
4946 || (strncmp (name
, vptr
, sizeof (vptr
) - 1) == 0
4947 && is_cplus_marker (name
[sizeof (vptr
) - 1])))
4953 /* GCC outputs unnamed structures that are really pointers to member
4954 functions, with the ABI-specified layout. If TYPE describes
4955 such a structure, smash it into a member function type.
4957 GCC shouldn't do this; it should just output pointer to member DIEs.
4958 This is GCC PR debug/28767. */
4961 quirk_gcc_member_function_pointer (struct type
*type
, struct objfile
*objfile
)
4963 struct type
*pfn_type
, *domain_type
, *new_type
;
4965 /* Check for a structure with no name and two children. */
4966 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
|| TYPE_NFIELDS (type
) != 2)
4969 /* Check for __pfn and __delta members. */
4970 if (TYPE_FIELD_NAME (type
, 0) == NULL
4971 || strcmp (TYPE_FIELD_NAME (type
, 0), "__pfn") != 0
4972 || TYPE_FIELD_NAME (type
, 1) == NULL
4973 || strcmp (TYPE_FIELD_NAME (type
, 1), "__delta") != 0)
4976 /* Find the type of the method. */
4977 pfn_type
= TYPE_FIELD_TYPE (type
, 0);
4978 if (pfn_type
== NULL
4979 || TYPE_CODE (pfn_type
) != TYPE_CODE_PTR
4980 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type
)) != TYPE_CODE_FUNC
)
4983 /* Look for the "this" argument. */
4984 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
4985 if (TYPE_NFIELDS (pfn_type
) == 0
4986 /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
4987 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type
, 0)) != TYPE_CODE_PTR
)
4990 domain_type
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type
, 0));
4991 new_type
= alloc_type (objfile
);
4992 smash_to_method_type (new_type
, domain_type
, TYPE_TARGET_TYPE (pfn_type
),
4993 TYPE_FIELDS (pfn_type
), TYPE_NFIELDS (pfn_type
),
4994 TYPE_VARARGS (pfn_type
));
4995 smash_to_methodptr_type (type
, new_type
);
4998 /* Called when we find the DIE that starts a structure or union scope
4999 (definition) to process all dies that define the members of the
5002 NOTE: we need to call struct_type regardless of whether or not the
5003 DIE has an at_name attribute, since it might be an anonymous
5004 structure or union. This gets the type entered into our set of
5007 However, if the structure is incomplete (an opaque struct/union)
5008 then suppress creating a symbol table entry for it since gdb only
5009 wants to find the one with the complete definition. Note that if
5010 it is complete, we just call new_symbol, which does it's own
5011 checking about whether the struct/union is anonymous or not (and
5012 suppresses creating a symbol table entry itself). */
5014 static struct type
*
5015 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5017 struct objfile
*objfile
= cu
->objfile
;
5019 struct attribute
*attr
;
5021 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
5023 /* If the definition of this type lives in .debug_types, read that type.
5024 Don't follow DW_AT_specification though, that will take us back up
5025 the chain and we want to go down. */
5026 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
, cu
);
5029 struct dwarf2_cu
*type_cu
= cu
;
5030 struct die_info
*type_die
= follow_die_ref_or_sig (die
, attr
, &type_cu
);
5031 /* We could just recurse on read_structure_type, but we need to call
5032 get_die_type to ensure only one type for this DIE is created.
5033 This is important, for example, because for c++ classes we need
5034 TYPE_NAME set which is only done by new_symbol. Blech. */
5035 type
= read_type_die (type_die
, type_cu
);
5036 return set_die_type (die
, type
, cu
);
5039 type
= alloc_type (objfile
);
5040 INIT_CPLUS_SPECIFIC (type
);
5042 name
= dwarf2_name (die
, cu
);
5045 if (cu
->language
== language_cplus
5046 || cu
->language
== language_java
)
5048 TYPE_TAG_NAME (type
) = (char *) dwarf2_full_name (name
, die
, cu
);
5049 if (die
->tag
== DW_TAG_structure_type
5050 || die
->tag
== DW_TAG_class_type
)
5051 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
5055 /* The name is already allocated along with this objfile, so
5056 we don't need to duplicate it for the type. */
5057 TYPE_TAG_NAME (type
) = (char *) name
;
5058 if (die
->tag
== DW_TAG_class_type
)
5059 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
5063 if (die
->tag
== DW_TAG_structure_type
)
5065 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
5067 else if (die
->tag
== DW_TAG_union_type
)
5069 TYPE_CODE (type
) = TYPE_CODE_UNION
;
5073 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
5076 if (cu
->language
== language_cplus
&& die
->tag
== DW_TAG_class_type
)
5077 TYPE_DECLARED_CLASS (type
) = 1;
5079 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
5082 TYPE_LENGTH (type
) = DW_UNSND (attr
);
5086 TYPE_LENGTH (type
) = 0;
5089 TYPE_STUB_SUPPORTED (type
) = 1;
5090 if (die_is_declaration (die
, cu
))
5091 TYPE_STUB (type
) = 1;
5093 set_descriptive_type (type
, die
, cu
);
5095 /* We need to add the type field to the die immediately so we don't
5096 infinitely recurse when dealing with pointers to the structure
5097 type within the structure itself. */
5098 set_die_type (die
, type
, cu
);
5100 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
5102 struct field_info fi
;
5103 struct die_info
*child_die
;
5105 memset (&fi
, 0, sizeof (struct field_info
));
5107 child_die
= die
->child
;
5109 while (child_die
&& child_die
->tag
)
5111 if (child_die
->tag
== DW_TAG_member
5112 || child_die
->tag
== DW_TAG_variable
)
5114 /* NOTE: carlton/2002-11-05: A C++ static data member
5115 should be a DW_TAG_member that is a declaration, but
5116 all versions of G++ as of this writing (so through at
5117 least 3.2.1) incorrectly generate DW_TAG_variable
5118 tags for them instead. */
5119 dwarf2_add_field (&fi
, child_die
, cu
);
5121 else if (child_die
->tag
== DW_TAG_subprogram
)
5123 /* C++ member function. */
5124 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
5126 else if (child_die
->tag
== DW_TAG_inheritance
)
5128 /* C++ base class field. */
5129 dwarf2_add_field (&fi
, child_die
, cu
);
5131 child_die
= sibling_die (child_die
);
5134 /* Attach fields and member functions to the type. */
5136 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
5139 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
5141 /* Get the type which refers to the base class (possibly this
5142 class itself) which contains the vtable pointer for the current
5143 class from the DW_AT_containing_type attribute. This use of
5144 DW_AT_containing_type is a GNU extension. */
5146 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
5148 struct type
*t
= die_containing_type (die
, cu
);
5150 TYPE_VPTR_BASETYPE (type
) = t
;
5155 /* Our own class provides vtbl ptr. */
5156 for (i
= TYPE_NFIELDS (t
) - 1;
5157 i
>= TYPE_N_BASECLASSES (t
);
5160 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
5162 if (is_vtable_name (fieldname
, cu
))
5164 TYPE_VPTR_FIELDNO (type
) = i
;
5169 /* Complain if virtual function table field not found. */
5170 if (i
< TYPE_N_BASECLASSES (t
))
5171 complaint (&symfile_complaints
,
5172 _("virtual function table pointer not found when defining class '%s'"),
5173 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
5178 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
5181 else if (cu
->producer
5182 && strncmp (cu
->producer
,
5183 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
5185 /* The IBM XLC compiler does not provide direct indication
5186 of the containing type, but the vtable pointer is
5187 always named __vfp. */
5191 for (i
= TYPE_NFIELDS (type
) - 1;
5192 i
>= TYPE_N_BASECLASSES (type
);
5195 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
5197 TYPE_VPTR_FIELDNO (type
) = i
;
5198 TYPE_VPTR_BASETYPE (type
) = type
;
5206 quirk_gcc_member_function_pointer (type
, cu
->objfile
);
5208 do_cleanups (back_to
);
5213 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
5215 struct objfile
*objfile
= cu
->objfile
;
5216 struct die_info
*child_die
= die
->child
;
5217 struct type
*this_type
;
5219 this_type
= get_die_type (die
, cu
);
5220 if (this_type
== NULL
)
5221 this_type
= read_structure_type (die
, cu
);
5223 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
5224 snapshots) has been known to create a die giving a declaration
5225 for a class that has, as a child, a die giving a definition for a
5226 nested class. So we have to process our children even if the
5227 current die is a declaration. Normally, of course, a declaration
5228 won't have any children at all. */
5230 while (child_die
!= NULL
&& child_die
->tag
)
5232 if (child_die
->tag
== DW_TAG_member
5233 || child_die
->tag
== DW_TAG_variable
5234 || child_die
->tag
== DW_TAG_inheritance
)
5239 process_die (child_die
, cu
);
5241 child_die
= sibling_die (child_die
);
5244 /* Do not consider external references. According to the DWARF standard,
5245 these DIEs are identified by the fact that they have no byte_size
5246 attribute, and a declaration attribute. */
5247 if (dwarf2_attr (die
, DW_AT_byte_size
, cu
) != NULL
5248 || !die_is_declaration (die
, cu
))
5249 new_symbol (die
, this_type
, cu
);
5252 /* Given a DW_AT_enumeration_type die, set its type. We do not
5253 complete the type's fields yet, or create any symbols. */
5255 static struct type
*
5256 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5258 struct objfile
*objfile
= cu
->objfile
;
5260 struct attribute
*attr
;
5263 /* If the definition of this type lives in .debug_types, read that type.
5264 Don't follow DW_AT_specification though, that will take us back up
5265 the chain and we want to go down. */
5266 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
, cu
);
5269 struct dwarf2_cu
*type_cu
= cu
;
5270 struct die_info
*type_die
= follow_die_ref_or_sig (die
, attr
, &type_cu
);
5271 type
= read_type_die (type_die
, type_cu
);
5272 return set_die_type (die
, type
, cu
);
5275 type
= alloc_type (objfile
);
5277 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
5278 name
= dwarf2_full_name (NULL
, die
, cu
);
5280 TYPE_TAG_NAME (type
) = (char *) name
;
5282 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
5285 TYPE_LENGTH (type
) = DW_UNSND (attr
);
5289 TYPE_LENGTH (type
) = 0;
5292 /* The enumeration DIE can be incomplete. In Ada, any type can be
5293 declared as private in the package spec, and then defined only
5294 inside the package body. Such types are known as Taft Amendment
5295 Types. When another package uses such a type, an incomplete DIE
5296 may be generated by the compiler. */
5297 if (die_is_declaration (die
, cu
))
5298 TYPE_STUB (type
) = 1;
5300 return set_die_type (die
, type
, cu
);
5303 /* Given a pointer to a die which begins an enumeration, process all
5304 the dies that define the members of the enumeration, and create the
5305 symbol for the enumeration type.
5307 NOTE: We reverse the order of the element list. */
5310 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
5312 struct objfile
*objfile
= cu
->objfile
;
5313 struct die_info
*child_die
;
5314 struct field
*fields
;
5317 int unsigned_enum
= 1;
5319 struct type
*this_type
;
5323 this_type
= get_die_type (die
, cu
);
5324 if (this_type
== NULL
)
5325 this_type
= read_enumeration_type (die
, cu
);
5326 if (die
->child
!= NULL
)
5328 child_die
= die
->child
;
5329 while (child_die
&& child_die
->tag
)
5331 if (child_die
->tag
!= DW_TAG_enumerator
)
5333 process_die (child_die
, cu
);
5337 name
= dwarf2_name (child_die
, cu
);
5340 sym
= new_symbol (child_die
, this_type
, cu
);
5341 if (SYMBOL_VALUE (sym
) < 0)
5344 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
5346 fields
= (struct field
*)
5348 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
5349 * sizeof (struct field
));
5352 FIELD_NAME (fields
[num_fields
]) = SYMBOL_LINKAGE_NAME (sym
);
5353 FIELD_TYPE (fields
[num_fields
]) = NULL
;
5354 SET_FIELD_BITPOS (fields
[num_fields
], SYMBOL_VALUE (sym
));
5355 FIELD_BITSIZE (fields
[num_fields
]) = 0;
5361 child_die
= sibling_die (child_die
);
5366 TYPE_NFIELDS (this_type
) = num_fields
;
5367 TYPE_FIELDS (this_type
) = (struct field
*)
5368 TYPE_ALLOC (this_type
, sizeof (struct field
) * num_fields
);
5369 memcpy (TYPE_FIELDS (this_type
), fields
,
5370 sizeof (struct field
) * num_fields
);
5374 TYPE_UNSIGNED (this_type
) = 1;
5377 new_symbol (die
, this_type
, cu
);
5380 /* Extract all information from a DW_TAG_array_type DIE and put it in
5381 the DIE's type field. For now, this only handles one dimensional
5384 static struct type
*
5385 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5387 struct objfile
*objfile
= cu
->objfile
;
5388 struct die_info
*child_die
;
5389 struct type
*type
= NULL
;
5390 struct type
*element_type
, *range_type
, *index_type
;
5391 struct type
**range_types
= NULL
;
5392 struct attribute
*attr
;
5394 struct cleanup
*back_to
;
5397 element_type
= die_type (die
, cu
);
5399 /* Irix 6.2 native cc creates array types without children for
5400 arrays with unspecified length. */
5401 if (die
->child
== NULL
)
5403 index_type
= objfile_type (objfile
)->builtin_int
;
5404 range_type
= create_range_type (NULL
, index_type
, 0, -1);
5405 type
= create_array_type (NULL
, element_type
, range_type
);
5406 return set_die_type (die
, type
, cu
);
5409 back_to
= make_cleanup (null_cleanup
, NULL
);
5410 child_die
= die
->child
;
5411 while (child_die
&& child_die
->tag
)
5413 if (child_die
->tag
== DW_TAG_subrange_type
)
5415 struct type
*child_type
= read_type_die (child_die
, cu
);
5416 if (child_type
!= NULL
)
5418 /* The range type was succesfully read. Save it for
5419 the array type creation. */
5420 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
5422 range_types
= (struct type
**)
5423 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
5424 * sizeof (struct type
*));
5426 make_cleanup (free_current_contents
, &range_types
);
5428 range_types
[ndim
++] = child_type
;
5431 child_die
= sibling_die (child_die
);
5434 /* Dwarf2 dimensions are output from left to right, create the
5435 necessary array types in backwards order. */
5437 type
= element_type
;
5439 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
5443 type
= create_array_type (NULL
, type
, range_types
[i
++]);
5448 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
5451 /* Understand Dwarf2 support for vector types (like they occur on
5452 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
5453 array type. This is not part of the Dwarf2/3 standard yet, but a
5454 custom vendor extension. The main difference between a regular
5455 array and the vector variant is that vectors are passed by value
5457 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
5459 make_vector_type (type
);
5461 name
= dwarf2_name (die
, cu
);
5463 TYPE_NAME (type
) = name
;
5465 set_descriptive_type (type
, die
, cu
);
5467 do_cleanups (back_to
);
5469 /* Install the type in the die. */
5470 return set_die_type (die
, type
, cu
);
5473 static enum dwarf_array_dim_ordering
5474 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
5476 struct attribute
*attr
;
5478 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
5480 if (attr
) return DW_SND (attr
);
5483 GNU F77 is a special case, as at 08/2004 array type info is the
5484 opposite order to the dwarf2 specification, but data is still
5485 laid out as per normal fortran.
5487 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
5491 if (cu
->language
== language_fortran
5492 && cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
5494 return DW_ORD_row_major
;
5497 switch (cu
->language_defn
->la_array_ordering
)
5499 case array_column_major
:
5500 return DW_ORD_col_major
;
5501 case array_row_major
:
5503 return DW_ORD_row_major
;
5507 /* Extract all information from a DW_TAG_set_type DIE and put it in
5508 the DIE's type field. */
5510 static struct type
*
5511 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5513 struct type
*set_type
= create_set_type (NULL
, die_type (die
, cu
));
5515 return set_die_type (die
, set_type
, cu
);
5518 /* First cut: install each common block member as a global variable. */
5521 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
5523 struct die_info
*child_die
;
5524 struct attribute
*attr
;
5526 CORE_ADDR base
= (CORE_ADDR
) 0;
5528 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
5531 /* Support the .debug_loc offsets */
5532 if (attr_form_is_block (attr
))
5534 base
= decode_locdesc (DW_BLOCK (attr
), cu
);
5536 else if (attr_form_is_section_offset (attr
))
5538 dwarf2_complex_location_expr_complaint ();
5542 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
5543 "common block member");
5546 if (die
->child
!= NULL
)
5548 child_die
= die
->child
;
5549 while (child_die
&& child_die
->tag
)
5551 sym
= new_symbol (child_die
, NULL
, cu
);
5552 attr
= dwarf2_attr (child_die
, DW_AT_data_member_location
, cu
);
5555 CORE_ADDR byte_offset
= 0;
5557 if (attr_form_is_section_offset (attr
))
5558 dwarf2_complex_location_expr_complaint ();
5559 else if (attr_form_is_constant (attr
))
5560 byte_offset
= dwarf2_get_attr_constant_value (attr
, 0);
5561 else if (attr_form_is_block (attr
))
5562 byte_offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
5564 dwarf2_complex_location_expr_complaint ();
5566 SYMBOL_VALUE_ADDRESS (sym
) = base
+ byte_offset
;
5567 add_symbol_to_list (sym
, &global_symbols
);
5569 child_die
= sibling_die (child_die
);
5574 /* Create a type for a C++ namespace. */
5576 static struct type
*
5577 read_namespace_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5579 struct objfile
*objfile
= cu
->objfile
;
5580 const char *previous_prefix
, *name
;
5584 /* For extensions, reuse the type of the original namespace. */
5585 if (dwarf2_attr (die
, DW_AT_extension
, cu
) != NULL
)
5587 struct die_info
*ext_die
;
5588 struct dwarf2_cu
*ext_cu
= cu
;
5589 ext_die
= dwarf2_extension (die
, &ext_cu
);
5590 type
= read_type_die (ext_die
, ext_cu
);
5591 return set_die_type (die
, type
, cu
);
5594 name
= namespace_name (die
, &is_anonymous
, cu
);
5596 /* Now build the name of the current namespace. */
5598 previous_prefix
= determine_prefix (die
, cu
);
5599 if (previous_prefix
[0] != '\0')
5600 name
= typename_concat (&objfile
->objfile_obstack
,
5601 previous_prefix
, name
, cu
);
5603 /* Create the type. */
5604 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0, NULL
,
5606 TYPE_NAME (type
) = (char *) name
;
5607 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
5609 set_die_type (die
, type
, cu
);
5614 /* Read a C++ namespace. */
5617 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
5619 struct objfile
*objfile
= cu
->objfile
;
5623 /* Add a symbol associated to this if we haven't seen the namespace
5624 before. Also, add a using directive if it's an anonymous
5627 if (dwarf2_attr (die
, DW_AT_extension
, cu
) == NULL
)
5631 type
= read_type_die (die
, cu
);
5632 new_symbol (die
, type
, cu
);
5634 name
= namespace_name (die
, &is_anonymous
, cu
);
5637 const char *previous_prefix
= determine_prefix (die
, cu
);
5638 cp_add_using_directive (previous_prefix
, TYPE_NAME (type
), NULL
);
5642 if (die
->child
!= NULL
)
5644 struct die_info
*child_die
= die
->child
;
5646 while (child_die
&& child_die
->tag
)
5648 process_die (child_die
, cu
);
5649 child_die
= sibling_die (child_die
);
5654 /* Read a Fortran module. */
5657 read_module (struct die_info
*die
, struct dwarf2_cu
*cu
)
5659 struct die_info
*child_die
= die
->child
;
5661 /* FIXME: Support the separate Fortran module namespaces. */
5663 while (child_die
&& child_die
->tag
)
5665 process_die (child_die
, cu
);
5666 child_die
= sibling_die (child_die
);
5670 /* Return the name of the namespace represented by DIE. Set
5671 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
5675 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
5677 struct die_info
*current_die
;
5678 const char *name
= NULL
;
5680 /* Loop through the extensions until we find a name. */
5682 for (current_die
= die
;
5683 current_die
!= NULL
;
5684 current_die
= dwarf2_extension (die
, &cu
))
5686 name
= dwarf2_name (current_die
, cu
);
5691 /* Is it an anonymous namespace? */
5693 *is_anonymous
= (name
== NULL
);
5695 name
= "(anonymous namespace)";
5700 /* Extract all information from a DW_TAG_pointer_type DIE and add to
5701 the user defined type vector. */
5703 static struct type
*
5704 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5706 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
5707 struct comp_unit_head
*cu_header
= &cu
->header
;
5709 struct attribute
*attr_byte_size
;
5710 struct attribute
*attr_address_class
;
5711 int byte_size
, addr_class
;
5713 type
= lookup_pointer_type (die_type (die
, cu
));
5715 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
5717 byte_size
= DW_UNSND (attr_byte_size
);
5719 byte_size
= cu_header
->addr_size
;
5721 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
5722 if (attr_address_class
)
5723 addr_class
= DW_UNSND (attr_address_class
);
5725 addr_class
= DW_ADDR_none
;
5727 /* If the pointer size or address class is different than the
5728 default, create a type variant marked as such and set the
5729 length accordingly. */
5730 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
5732 if (gdbarch_address_class_type_flags_p (gdbarch
))
5736 type_flags
= gdbarch_address_class_type_flags
5737 (gdbarch
, byte_size
, addr_class
);
5738 gdb_assert ((type_flags
& ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
5740 type
= make_type_with_address_space (type
, type_flags
);
5742 else if (TYPE_LENGTH (type
) != byte_size
)
5744 complaint (&symfile_complaints
, _("invalid pointer size %d"), byte_size
);
5747 /* Should we also complain about unhandled address classes? */
5751 TYPE_LENGTH (type
) = byte_size
;
5752 return set_die_type (die
, type
, cu
);
5755 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
5756 the user defined type vector. */
5758 static struct type
*
5759 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5761 struct objfile
*objfile
= cu
->objfile
;
5763 struct type
*to_type
;
5764 struct type
*domain
;
5766 to_type
= die_type (die
, cu
);
5767 domain
= die_containing_type (die
, cu
);
5769 if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_METHOD
)
5770 type
= lookup_methodptr_type (to_type
);
5772 type
= lookup_memberptr_type (to_type
, domain
);
5774 return set_die_type (die
, type
, cu
);
5777 /* Extract all information from a DW_TAG_reference_type DIE and add to
5778 the user defined type vector. */
5780 static struct type
*
5781 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5783 struct comp_unit_head
*cu_header
= &cu
->header
;
5785 struct attribute
*attr
;
5787 type
= lookup_reference_type (die_type (die
, cu
));
5788 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
5791 TYPE_LENGTH (type
) = DW_UNSND (attr
);
5795 TYPE_LENGTH (type
) = cu_header
->addr_size
;
5797 return set_die_type (die
, type
, cu
);
5800 static struct type
*
5801 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5803 struct type
*base_type
, *cv_type
;
5805 base_type
= die_type (die
, cu
);
5806 cv_type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
5807 return set_die_type (die
, cv_type
, cu
);
5810 static struct type
*
5811 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5813 struct type
*base_type
, *cv_type
;
5815 base_type
= die_type (die
, cu
);
5816 cv_type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
5817 return set_die_type (die
, cv_type
, cu
);
5820 /* Extract all information from a DW_TAG_string_type DIE and add to
5821 the user defined type vector. It isn't really a user defined type,
5822 but it behaves like one, with other DIE's using an AT_user_def_type
5823 attribute to reference it. */
5825 static struct type
*
5826 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5828 struct objfile
*objfile
= cu
->objfile
;
5829 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
5830 struct type
*type
, *range_type
, *index_type
, *char_type
;
5831 struct attribute
*attr
;
5832 unsigned int length
;
5834 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
5837 length
= DW_UNSND (attr
);
5841 /* check for the DW_AT_byte_size attribute */
5842 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
5845 length
= DW_UNSND (attr
);
5853 index_type
= objfile_type (objfile
)->builtin_int
;
5854 range_type
= create_range_type (NULL
, index_type
, 1, length
);
5855 char_type
= language_string_char_type (cu
->language_defn
, gdbarch
);
5856 type
= create_string_type (NULL
, char_type
, range_type
);
5858 return set_die_type (die
, type
, cu
);
5861 /* Handle DIES due to C code like:
5865 int (*funcp)(int a, long l);
5869 ('funcp' generates a DW_TAG_subroutine_type DIE)
5872 static struct type
*
5873 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5875 struct type
*type
; /* Type that this function returns */
5876 struct type
*ftype
; /* Function that returns above type */
5877 struct attribute
*attr
;
5879 type
= die_type (die
, cu
);
5880 ftype
= lookup_function_type (type
);
5882 /* All functions in C++, Pascal and Java have prototypes. */
5883 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
5884 if ((attr
&& (DW_UNSND (attr
) != 0))
5885 || cu
->language
== language_cplus
5886 || cu
->language
== language_java
5887 || cu
->language
== language_pascal
)
5888 TYPE_PROTOTYPED (ftype
) = 1;
5890 /* Store the calling convention in the type if it's available in
5891 the subroutine die. Otherwise set the calling convention to
5892 the default value DW_CC_normal. */
5893 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
5894 TYPE_CALLING_CONVENTION (ftype
) = attr
? DW_UNSND (attr
) : DW_CC_normal
;
5896 /* We need to add the subroutine type to the die immediately so
5897 we don't infinitely recurse when dealing with parameters
5898 declared as the same subroutine type. */
5899 set_die_type (die
, ftype
, cu
);
5901 if (die
->child
!= NULL
)
5903 struct die_info
*child_die
;
5907 /* Count the number of parameters.
5908 FIXME: GDB currently ignores vararg functions, but knows about
5909 vararg member functions. */
5910 child_die
= die
->child
;
5911 while (child_die
&& child_die
->tag
)
5913 if (child_die
->tag
== DW_TAG_formal_parameter
)
5915 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
5916 TYPE_VARARGS (ftype
) = 1;
5917 child_die
= sibling_die (child_die
);
5920 /* Allocate storage for parameters and fill them in. */
5921 TYPE_NFIELDS (ftype
) = nparams
;
5922 TYPE_FIELDS (ftype
) = (struct field
*)
5923 TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
));
5925 child_die
= die
->child
;
5926 while (child_die
&& child_die
->tag
)
5928 if (child_die
->tag
== DW_TAG_formal_parameter
)
5930 /* Dwarf2 has no clean way to discern C++ static and non-static
5931 member functions. G++ helps GDB by marking the first
5932 parameter for non-static member functions (which is the
5933 this pointer) as artificial. We pass this information
5934 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
5935 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
5937 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
5939 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
5940 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, cu
);
5943 child_die
= sibling_die (child_die
);
5950 static struct type
*
5951 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
5953 struct objfile
*objfile
= cu
->objfile
;
5954 struct attribute
*attr
;
5955 const char *name
= NULL
;
5956 struct type
*this_type
;
5958 name
= dwarf2_full_name (NULL
, die
, cu
);
5959 this_type
= init_type (TYPE_CODE_TYPEDEF
, 0,
5960 TYPE_FLAG_TARGET_STUB
, NULL
, objfile
);
5961 TYPE_NAME (this_type
) = (char *) name
;
5962 set_die_type (die
, this_type
, cu
);
5963 TYPE_TARGET_TYPE (this_type
) = die_type (die
, cu
);
5967 /* Find a representation of a given base type and install
5968 it in the TYPE field of the die. */
5970 static struct type
*
5971 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5973 struct objfile
*objfile
= cu
->objfile
;
5975 struct attribute
*attr
;
5976 int encoding
= 0, size
= 0;
5978 enum type_code code
= TYPE_CODE_INT
;
5980 struct type
*target_type
= NULL
;
5982 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
5985 encoding
= DW_UNSND (attr
);
5987 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
5990 size
= DW_UNSND (attr
);
5992 name
= dwarf2_name (die
, cu
);
5995 complaint (&symfile_complaints
,
5996 _("DW_AT_name missing from DW_TAG_base_type"));
6001 case DW_ATE_address
:
6002 /* Turn DW_ATE_address into a void * pointer. */
6003 code
= TYPE_CODE_PTR
;
6004 type_flags
|= TYPE_FLAG_UNSIGNED
;
6005 target_type
= init_type (TYPE_CODE_VOID
, 1, 0, NULL
, objfile
);
6007 case DW_ATE_boolean
:
6008 code
= TYPE_CODE_BOOL
;
6009 type_flags
|= TYPE_FLAG_UNSIGNED
;
6011 case DW_ATE_complex_float
:
6012 code
= TYPE_CODE_COMPLEX
;
6013 target_type
= init_type (TYPE_CODE_FLT
, size
/ 2, 0, NULL
, objfile
);
6015 case DW_ATE_decimal_float
:
6016 code
= TYPE_CODE_DECFLOAT
;
6019 code
= TYPE_CODE_FLT
;
6023 case DW_ATE_unsigned
:
6024 type_flags
|= TYPE_FLAG_UNSIGNED
;
6026 case DW_ATE_signed_char
:
6027 if (cu
->language
== language_ada
|| cu
->language
== language_m2
6028 || cu
->language
== language_pascal
)
6029 code
= TYPE_CODE_CHAR
;
6031 case DW_ATE_unsigned_char
:
6032 if (cu
->language
== language_ada
|| cu
->language
== language_m2
6033 || cu
->language
== language_pascal
)
6034 code
= TYPE_CODE_CHAR
;
6035 type_flags
|= TYPE_FLAG_UNSIGNED
;
6038 complaint (&symfile_complaints
, _("unsupported DW_AT_encoding: '%s'"),
6039 dwarf_type_encoding_name (encoding
));
6043 type
= init_type (code
, size
, type_flags
, NULL
, objfile
);
6044 TYPE_NAME (type
) = name
;
6045 TYPE_TARGET_TYPE (type
) = target_type
;
6047 if (name
&& strcmp (name
, "char") == 0)
6048 TYPE_NOSIGN (type
) = 1;
6050 return set_die_type (die
, type
, cu
);
6053 /* Read the given DW_AT_subrange DIE. */
6055 static struct type
*
6056 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
6058 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
6059 struct type
*base_type
;
6060 struct type
*range_type
;
6061 struct attribute
*attr
;
6065 LONGEST negative_mask
;
6067 base_type
= die_type (die
, cu
);
6068 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
6070 complaint (&symfile_complaints
,
6071 _("DW_AT_type missing from DW_TAG_subrange_type"));
6073 = init_type (TYPE_CODE_INT
, gdbarch_addr_bit (gdbarch
) / 8,
6074 0, NULL
, cu
->objfile
);
6077 if (cu
->language
== language_fortran
)
6079 /* FORTRAN implies a lower bound of 1, if not given. */
6083 /* FIXME: For variable sized arrays either of these could be
6084 a variable rather than a constant value. We'll allow it,
6085 but we don't know how to handle it. */
6086 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
6088 low
= dwarf2_get_attr_constant_value (attr
, 0);
6090 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
6093 if (attr
->form
== DW_FORM_block1
)
6095 /* GCC encodes arrays with unspecified or dynamic length
6096 with a DW_FORM_block1 attribute.
6097 FIXME: GDB does not yet know how to handle dynamic
6098 arrays properly, treat them as arrays with unspecified
6101 FIXME: jimb/2003-09-22: GDB does not really know
6102 how to handle arrays of unspecified length
6103 either; we just represent them as zero-length
6104 arrays. Choose an appropriate upper bound given
6105 the lower bound we've computed above. */
6109 high
= dwarf2_get_attr_constant_value (attr
, 1);
6113 (LONGEST
) -1 << (TYPE_LENGTH (base_type
) * TARGET_CHAR_BIT
- 1);
6114 if (!TYPE_UNSIGNED (base_type
) && (low
& negative_mask
))
6115 low
|= negative_mask
;
6116 if (!TYPE_UNSIGNED (base_type
) && (high
& negative_mask
))
6117 high
|= negative_mask
;
6119 range_type
= create_range_type (NULL
, base_type
, low
, high
);
6121 name
= dwarf2_name (die
, cu
);
6123 TYPE_NAME (range_type
) = name
;
6125 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
6127 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
6129 set_descriptive_type (range_type
, die
, cu
);
6131 return set_die_type (die
, range_type
, cu
);
6134 static struct type
*
6135 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
6139 /* For now, we only support the C meaning of an unspecified type: void. */
6141 type
= init_type (TYPE_CODE_VOID
, 0, 0, NULL
, cu
->objfile
);
6142 TYPE_NAME (type
) = dwarf2_name (die
, cu
);
6144 return set_die_type (die
, type
, cu
);
6147 /* Trivial hash function for die_info: the hash value of a DIE
6148 is its offset in .debug_info for this objfile. */
6151 die_hash (const void *item
)
6153 const struct die_info
*die
= item
;
6157 /* Trivial comparison function for die_info structures: two DIEs
6158 are equal if they have the same offset. */
6161 die_eq (const void *item_lhs
, const void *item_rhs
)
6163 const struct die_info
*die_lhs
= item_lhs
;
6164 const struct die_info
*die_rhs
= item_rhs
;
6165 return die_lhs
->offset
== die_rhs
->offset
;
6168 /* Read a whole compilation unit into a linked list of dies. */
6170 static struct die_info
*
6171 read_comp_unit (gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
6173 struct die_reader_specs reader_specs
;
6175 gdb_assert (cu
->die_hash
== NULL
);
6177 = htab_create_alloc_ex (cu
->header
.length
/ 12,
6181 &cu
->comp_unit_obstack
,
6182 hashtab_obstack_allocate
,
6183 dummy_obstack_deallocate
);
6185 init_cu_die_reader (&reader_specs
, cu
);
6187 return read_die_and_children (&reader_specs
, info_ptr
, &info_ptr
, NULL
);
6190 /* Main entry point for reading a DIE and all children.
6191 Read the DIE and dump it if requested. */
6193 static struct die_info
*
6194 read_die_and_children (const struct die_reader_specs
*reader
,
6196 gdb_byte
**new_info_ptr
,
6197 struct die_info
*parent
)
6199 struct die_info
*result
= read_die_and_children_1 (reader
, info_ptr
,
6200 new_info_ptr
, parent
);
6202 if (dwarf2_die_debug
)
6204 fprintf_unfiltered (gdb_stdlog
,
6205 "\nRead die from %s of %s:\n",
6206 reader
->buffer
== dwarf2_per_objfile
->info
.buffer
6208 : reader
->buffer
== dwarf2_per_objfile
->types
.buffer
6210 : "unknown section",
6211 reader
->abfd
->filename
);
6212 dump_die (result
, dwarf2_die_debug
);
6218 /* Read a single die and all its descendents. Set the die's sibling
6219 field to NULL; set other fields in the die correctly, and set all
6220 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
6221 location of the info_ptr after reading all of those dies. PARENT
6222 is the parent of the die in question. */
6224 static struct die_info
*
6225 read_die_and_children_1 (const struct die_reader_specs
*reader
,
6227 gdb_byte
**new_info_ptr
,
6228 struct die_info
*parent
)
6230 struct die_info
*die
;
6234 cur_ptr
= read_full_die (reader
, &die
, info_ptr
, &has_children
);
6237 *new_info_ptr
= cur_ptr
;
6240 store_in_ref_table (die
, reader
->cu
);
6243 die
->child
= read_die_and_siblings (reader
, cur_ptr
, new_info_ptr
, die
);
6247 *new_info_ptr
= cur_ptr
;
6250 die
->sibling
= NULL
;
6251 die
->parent
= parent
;
6255 /* Read a die, all of its descendents, and all of its siblings; set
6256 all of the fields of all of the dies correctly. Arguments are as
6257 in read_die_and_children. */
6259 static struct die_info
*
6260 read_die_and_siblings (const struct die_reader_specs
*reader
,
6262 gdb_byte
**new_info_ptr
,
6263 struct die_info
*parent
)
6265 struct die_info
*first_die
, *last_sibling
;
6269 first_die
= last_sibling
= NULL
;
6273 struct die_info
*die
6274 = read_die_and_children_1 (reader
, cur_ptr
, &cur_ptr
, parent
);
6278 *new_info_ptr
= cur_ptr
;
6285 last_sibling
->sibling
= die
;
6291 /* Read the die from the .debug_info section buffer. Set DIEP to
6292 point to a newly allocated die with its information, except for its
6293 child, sibling, and parent fields. Set HAS_CHILDREN to tell
6294 whether the die has children or not. */
6297 read_full_die (const struct die_reader_specs
*reader
,
6298 struct die_info
**diep
, gdb_byte
*info_ptr
,
6301 unsigned int abbrev_number
, bytes_read
, i
, offset
;
6302 struct abbrev_info
*abbrev
;
6303 struct die_info
*die
;
6304 struct dwarf2_cu
*cu
= reader
->cu
;
6305 bfd
*abfd
= reader
->abfd
;
6307 offset
= info_ptr
- reader
->buffer
;
6308 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
6309 info_ptr
+= bytes_read
;
6317 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
6319 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
6321 bfd_get_filename (abfd
));
6323 die
= dwarf_alloc_die (cu
, abbrev
->num_attrs
);
6324 die
->offset
= offset
;
6325 die
->tag
= abbrev
->tag
;
6326 die
->abbrev
= abbrev_number
;
6328 die
->num_attrs
= abbrev
->num_attrs
;
6330 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
6331 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
6332 abfd
, info_ptr
, cu
);
6335 *has_children
= abbrev
->has_children
;
6339 /* In DWARF version 2, the description of the debugging information is
6340 stored in a separate .debug_abbrev section. Before we read any
6341 dies from a section we read in all abbreviations and install them
6342 in a hash table. This function also sets flags in CU describing
6343 the data found in the abbrev table. */
6346 dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
)
6348 struct comp_unit_head
*cu_header
= &cu
->header
;
6349 gdb_byte
*abbrev_ptr
;
6350 struct abbrev_info
*cur_abbrev
;
6351 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
6352 unsigned int abbrev_form
, hash_number
;
6353 struct attr_abbrev
*cur_attrs
;
6354 unsigned int allocated_attrs
;
6356 /* Initialize dwarf2 abbrevs */
6357 obstack_init (&cu
->abbrev_obstack
);
6358 cu
->dwarf2_abbrevs
= obstack_alloc (&cu
->abbrev_obstack
,
6360 * sizeof (struct abbrev_info
*)));
6361 memset (cu
->dwarf2_abbrevs
, 0,
6362 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
6364 abbrev_ptr
= dwarf2_per_objfile
->abbrev
.buffer
+ cu_header
->abbrev_offset
;
6365 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
6366 abbrev_ptr
+= bytes_read
;
6368 allocated_attrs
= ATTR_ALLOC_CHUNK
;
6369 cur_attrs
= xmalloc (allocated_attrs
* sizeof (struct attr_abbrev
));
6371 /* loop until we reach an abbrev number of 0 */
6372 while (abbrev_number
)
6374 cur_abbrev
= dwarf_alloc_abbrev (cu
);
6376 /* read in abbrev header */
6377 cur_abbrev
->number
= abbrev_number
;
6378 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
6379 abbrev_ptr
+= bytes_read
;
6380 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
6383 if (cur_abbrev
->tag
== DW_TAG_namespace
)
6384 cu
->has_namespace_info
= 1;
6386 /* now read in declarations */
6387 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
6388 abbrev_ptr
+= bytes_read
;
6389 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
6390 abbrev_ptr
+= bytes_read
;
6393 if (cur_abbrev
->num_attrs
== allocated_attrs
)
6395 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
6397 = xrealloc (cur_attrs
, (allocated_attrs
6398 * sizeof (struct attr_abbrev
)));
6401 /* Record whether this compilation unit might have
6402 inter-compilation-unit references. If we don't know what form
6403 this attribute will have, then it might potentially be a
6404 DW_FORM_ref_addr, so we conservatively expect inter-CU
6407 if (abbrev_form
== DW_FORM_ref_addr
6408 || abbrev_form
== DW_FORM_indirect
)
6409 cu
->has_form_ref_addr
= 1;
6411 cur_attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
6412 cur_attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
6413 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
6414 abbrev_ptr
+= bytes_read
;
6415 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
6416 abbrev_ptr
+= bytes_read
;
6419 cur_abbrev
->attrs
= obstack_alloc (&cu
->abbrev_obstack
,
6420 (cur_abbrev
->num_attrs
6421 * sizeof (struct attr_abbrev
)));
6422 memcpy (cur_abbrev
->attrs
, cur_attrs
,
6423 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
6425 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
6426 cur_abbrev
->next
= cu
->dwarf2_abbrevs
[hash_number
];
6427 cu
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
6429 /* Get next abbreviation.
6430 Under Irix6 the abbreviations for a compilation unit are not
6431 always properly terminated with an abbrev number of 0.
6432 Exit loop if we encounter an abbreviation which we have
6433 already read (which means we are about to read the abbreviations
6434 for the next compile unit) or if the end of the abbreviation
6435 table is reached. */
6436 if ((unsigned int) (abbrev_ptr
- dwarf2_per_objfile
->abbrev
.buffer
)
6437 >= dwarf2_per_objfile
->abbrev
.size
)
6439 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
6440 abbrev_ptr
+= bytes_read
;
6441 if (dwarf2_lookup_abbrev (abbrev_number
, cu
) != NULL
)
6448 /* Release the memory used by the abbrev table for a compilation unit. */
6451 dwarf2_free_abbrev_table (void *ptr_to_cu
)
6453 struct dwarf2_cu
*cu
= ptr_to_cu
;
6455 obstack_free (&cu
->abbrev_obstack
, NULL
);
6456 cu
->dwarf2_abbrevs
= NULL
;
6459 /* Lookup an abbrev_info structure in the abbrev hash table. */
6461 static struct abbrev_info
*
6462 dwarf2_lookup_abbrev (unsigned int number
, struct dwarf2_cu
*cu
)
6464 unsigned int hash_number
;
6465 struct abbrev_info
*abbrev
;
6467 hash_number
= number
% ABBREV_HASH_SIZE
;
6468 abbrev
= cu
->dwarf2_abbrevs
[hash_number
];
6472 if (abbrev
->number
== number
)
6475 abbrev
= abbrev
->next
;
6480 /* Returns nonzero if TAG represents a type that we might generate a partial
6484 is_type_tag_for_partial (int tag
)
6489 /* Some types that would be reasonable to generate partial symbols for,
6490 that we don't at present. */
6491 case DW_TAG_array_type
:
6492 case DW_TAG_file_type
:
6493 case DW_TAG_ptr_to_member_type
:
6494 case DW_TAG_set_type
:
6495 case DW_TAG_string_type
:
6496 case DW_TAG_subroutine_type
:
6498 case DW_TAG_base_type
:
6499 case DW_TAG_class_type
:
6500 case DW_TAG_interface_type
:
6501 case DW_TAG_enumeration_type
:
6502 case DW_TAG_structure_type
:
6503 case DW_TAG_subrange_type
:
6504 case DW_TAG_typedef
:
6505 case DW_TAG_union_type
:
6512 /* Load all DIEs that are interesting for partial symbols into memory. */
6514 static struct partial_die_info
*
6515 load_partial_dies (bfd
*abfd
, gdb_byte
*buffer
, gdb_byte
*info_ptr
,
6516 int building_psymtab
, struct dwarf2_cu
*cu
)
6518 struct partial_die_info
*part_die
;
6519 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
6520 struct abbrev_info
*abbrev
;
6521 unsigned int bytes_read
;
6522 unsigned int load_all
= 0;
6524 int nesting_level
= 1;
6529 if (cu
->per_cu
&& cu
->per_cu
->load_all_dies
)
6533 = htab_create_alloc_ex (cu
->header
.length
/ 12,
6537 &cu
->comp_unit_obstack
,
6538 hashtab_obstack_allocate
,
6539 dummy_obstack_deallocate
);
6541 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
6542 sizeof (struct partial_die_info
));
6546 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
6548 /* A NULL abbrev means the end of a series of children. */
6551 if (--nesting_level
== 0)
6553 /* PART_DIE was probably the last thing allocated on the
6554 comp_unit_obstack, so we could call obstack_free
6555 here. We don't do that because the waste is small,
6556 and will be cleaned up when we're done with this
6557 compilation unit. This way, we're also more robust
6558 against other users of the comp_unit_obstack. */
6561 info_ptr
+= bytes_read
;
6562 last_die
= parent_die
;
6563 parent_die
= parent_die
->die_parent
;
6567 /* Check whether this DIE is interesting enough to save. Normally
6568 we would not be interested in members here, but there may be
6569 later variables referencing them via DW_AT_specification (for
6572 && !is_type_tag_for_partial (abbrev
->tag
)
6573 && abbrev
->tag
!= DW_TAG_enumerator
6574 && abbrev
->tag
!= DW_TAG_subprogram
6575 && abbrev
->tag
!= DW_TAG_lexical_block
6576 && abbrev
->tag
!= DW_TAG_variable
6577 && abbrev
->tag
!= DW_TAG_namespace
6578 && abbrev
->tag
!= DW_TAG_member
)
6580 /* Otherwise we skip to the next sibling, if any. */
6581 info_ptr
= skip_one_die (buffer
, info_ptr
+ bytes_read
, abbrev
, cu
);
6585 info_ptr
= read_partial_die (part_die
, abbrev
, bytes_read
, abfd
,
6586 buffer
, info_ptr
, cu
);
6588 /* This two-pass algorithm for processing partial symbols has a
6589 high cost in cache pressure. Thus, handle some simple cases
6590 here which cover the majority of C partial symbols. DIEs
6591 which neither have specification tags in them, nor could have
6592 specification tags elsewhere pointing at them, can simply be
6593 processed and discarded.
6595 This segment is also optional; scan_partial_symbols and
6596 add_partial_symbol will handle these DIEs if we chain
6597 them in normally. When compilers which do not emit large
6598 quantities of duplicate debug information are more common,
6599 this code can probably be removed. */
6601 /* Any complete simple types at the top level (pretty much all
6602 of them, for a language without namespaces), can be processed
6604 if (parent_die
== NULL
6605 && part_die
->has_specification
== 0
6606 && part_die
->is_declaration
== 0
6607 && (part_die
->tag
== DW_TAG_typedef
6608 || part_die
->tag
== DW_TAG_base_type
6609 || part_die
->tag
== DW_TAG_subrange_type
))
6611 if (building_psymtab
&& part_die
->name
!= NULL
)
6612 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
6613 VAR_DOMAIN
, LOC_TYPEDEF
,
6614 &cu
->objfile
->static_psymbols
,
6615 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
6616 info_ptr
= locate_pdi_sibling (part_die
, buffer
, info_ptr
, abfd
, cu
);
6620 /* If we're at the second level, and we're an enumerator, and
6621 our parent has no specification (meaning possibly lives in a
6622 namespace elsewhere), then we can add the partial symbol now
6623 instead of queueing it. */
6624 if (part_die
->tag
== DW_TAG_enumerator
6625 && parent_die
!= NULL
6626 && parent_die
->die_parent
== NULL
6627 && parent_die
->tag
== DW_TAG_enumeration_type
6628 && parent_die
->has_specification
== 0)
6630 if (part_die
->name
== NULL
)
6631 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
6632 else if (building_psymtab
)
6633 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
6634 VAR_DOMAIN
, LOC_CONST
,
6635 (cu
->language
== language_cplus
6636 || cu
->language
== language_java
)
6637 ? &cu
->objfile
->global_psymbols
6638 : &cu
->objfile
->static_psymbols
,
6639 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
6641 info_ptr
= locate_pdi_sibling (part_die
, buffer
, info_ptr
, abfd
, cu
);
6645 /* We'll save this DIE so link it in. */
6646 part_die
->die_parent
= parent_die
;
6647 part_die
->die_sibling
= NULL
;
6648 part_die
->die_child
= NULL
;
6650 if (last_die
&& last_die
== parent_die
)
6651 last_die
->die_child
= part_die
;
6653 last_die
->die_sibling
= part_die
;
6655 last_die
= part_die
;
6657 if (first_die
== NULL
)
6658 first_die
= part_die
;
6660 /* Maybe add the DIE to the hash table. Not all DIEs that we
6661 find interesting need to be in the hash table, because we
6662 also have the parent/sibling/child chains; only those that we
6663 might refer to by offset later during partial symbol reading.
6665 For now this means things that might have be the target of a
6666 DW_AT_specification, DW_AT_abstract_origin, or
6667 DW_AT_extension. DW_AT_extension will refer only to
6668 namespaces; DW_AT_abstract_origin refers to functions (and
6669 many things under the function DIE, but we do not recurse
6670 into function DIEs during partial symbol reading) and
6671 possibly variables as well; DW_AT_specification refers to
6672 declarations. Declarations ought to have the DW_AT_declaration
6673 flag. It happens that GCC forgets to put it in sometimes, but
6674 only for functions, not for types.
6676 Adding more things than necessary to the hash table is harmless
6677 except for the performance cost. Adding too few will result in
6678 wasted time in find_partial_die, when we reread the compilation
6679 unit with load_all_dies set. */
6682 || abbrev
->tag
== DW_TAG_subprogram
6683 || abbrev
->tag
== DW_TAG_variable
6684 || abbrev
->tag
== DW_TAG_namespace
6685 || part_die
->is_declaration
)
6689 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
6690 part_die
->offset
, INSERT
);
6694 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
6695 sizeof (struct partial_die_info
));
6697 /* For some DIEs we want to follow their children (if any). For C
6698 we have no reason to follow the children of structures; for other
6699 languages we have to, both so that we can get at method physnames
6700 to infer fully qualified class names, and for DW_AT_specification.
6702 For Ada, we need to scan the children of subprograms and lexical
6703 blocks as well because Ada allows the definition of nested
6704 entities that could be interesting for the debugger, such as
6705 nested subprograms for instance. */
6706 if (last_die
->has_children
6708 || last_die
->tag
== DW_TAG_namespace
6709 || last_die
->tag
== DW_TAG_enumeration_type
6710 || (cu
->language
!= language_c
6711 && (last_die
->tag
== DW_TAG_class_type
6712 || last_die
->tag
== DW_TAG_interface_type
6713 || last_die
->tag
== DW_TAG_structure_type
6714 || last_die
->tag
== DW_TAG_union_type
))
6715 || (cu
->language
== language_ada
6716 && (last_die
->tag
== DW_TAG_subprogram
6717 || last_die
->tag
== DW_TAG_lexical_block
))))
6720 parent_die
= last_die
;
6724 /* Otherwise we skip to the next sibling, if any. */
6725 info_ptr
= locate_pdi_sibling (last_die
, buffer
, info_ptr
, abfd
, cu
);
6727 /* Back to the top, do it again. */
6731 /* Read a minimal amount of information into the minimal die structure. */
6734 read_partial_die (struct partial_die_info
*part_die
,
6735 struct abbrev_info
*abbrev
,
6736 unsigned int abbrev_len
, bfd
*abfd
,
6737 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
6738 struct dwarf2_cu
*cu
)
6740 unsigned int bytes_read
, i
;
6741 struct attribute attr
;
6742 int has_low_pc_attr
= 0;
6743 int has_high_pc_attr
= 0;
6745 memset (part_die
, 0, sizeof (struct partial_die_info
));
6747 part_die
->offset
= info_ptr
- buffer
;
6749 info_ptr
+= abbrev_len
;
6754 part_die
->tag
= abbrev
->tag
;
6755 part_die
->has_children
= abbrev
->has_children
;
6757 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
6759 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
, info_ptr
, cu
);
6761 /* Store the data if it is of an attribute we want to keep in a
6762 partial symbol table. */
6766 switch (part_die
->tag
)
6768 case DW_TAG_compile_unit
:
6769 case DW_TAG_type_unit
:
6770 /* Compilation units have a DW_AT_name that is a filename, not
6771 a source language identifier. */
6772 case DW_TAG_enumeration_type
:
6773 case DW_TAG_enumerator
:
6774 /* These tags always have simple identifiers already; no need
6775 to canonicalize them. */
6776 part_die
->name
= DW_STRING (&attr
);
6780 = dwarf2_canonicalize_name (DW_STRING (&attr
), cu
,
6781 &cu
->objfile
->objfile_obstack
);
6785 case DW_AT_MIPS_linkage_name
:
6786 if (cu
->language
== language_ada
)
6787 part_die
->name
= DW_STRING (&attr
);
6790 has_low_pc_attr
= 1;
6791 part_die
->lowpc
= DW_ADDR (&attr
);
6794 has_high_pc_attr
= 1;
6795 part_die
->highpc
= DW_ADDR (&attr
);
6797 case DW_AT_location
:
6798 /* Support the .debug_loc offsets */
6799 if (attr_form_is_block (&attr
))
6801 part_die
->locdesc
= DW_BLOCK (&attr
);
6803 else if (attr_form_is_section_offset (&attr
))
6805 dwarf2_complex_location_expr_complaint ();
6809 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
6810 "partial symbol information");
6813 case DW_AT_external
:
6814 part_die
->is_external
= DW_UNSND (&attr
);
6816 case DW_AT_declaration
:
6817 part_die
->is_declaration
= DW_UNSND (&attr
);
6820 part_die
->has_type
= 1;
6822 case DW_AT_abstract_origin
:
6823 case DW_AT_specification
:
6824 case DW_AT_extension
:
6825 part_die
->has_specification
= 1;
6826 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
);
6829 /* Ignore absolute siblings, they might point outside of
6830 the current compile unit. */
6831 if (attr
.form
== DW_FORM_ref_addr
)
6832 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
6834 part_die
->sibling
= buffer
+ dwarf2_get_ref_die_offset (&attr
);
6836 case DW_AT_byte_size
:
6837 part_die
->has_byte_size
= 1;
6839 case DW_AT_calling_convention
:
6840 /* DWARF doesn't provide a way to identify a program's source-level
6841 entry point. DW_AT_calling_convention attributes are only meant
6842 to describe functions' calling conventions.
6844 However, because it's a necessary piece of information in
6845 Fortran, and because DW_CC_program is the only piece of debugging
6846 information whose definition refers to a 'main program' at all,
6847 several compilers have begun marking Fortran main programs with
6848 DW_CC_program --- even when those functions use the standard
6849 calling conventions.
6851 So until DWARF specifies a way to provide this information and
6852 compilers pick up the new representation, we'll support this
6854 if (DW_UNSND (&attr
) == DW_CC_program
6855 && cu
->language
== language_fortran
)
6856 set_main_name (part_die
->name
);
6863 /* When using the GNU linker, .gnu.linkonce. sections are used to
6864 eliminate duplicate copies of functions and vtables and such.
6865 The linker will arbitrarily choose one and discard the others.
6866 The AT_*_pc values for such functions refer to local labels in
6867 these sections. If the section from that file was discarded, the
6868 labels are not in the output, so the relocs get a value of 0.
6869 If this is a discarded function, mark the pc bounds as invalid,
6870 so that GDB will ignore it. */
6871 if (has_low_pc_attr
&& has_high_pc_attr
6872 && part_die
->lowpc
< part_die
->highpc
6873 && (part_die
->lowpc
!= 0
6874 || dwarf2_per_objfile
->has_section_at_zero
))
6875 part_die
->has_pc_info
= 1;
6880 /* Find a cached partial DIE at OFFSET in CU. */
6882 static struct partial_die_info
*
6883 find_partial_die_in_comp_unit (unsigned int offset
, struct dwarf2_cu
*cu
)
6885 struct partial_die_info
*lookup_die
= NULL
;
6886 struct partial_die_info part_die
;
6888 part_die
.offset
= offset
;
6889 lookup_die
= htab_find_with_hash (cu
->partial_dies
, &part_die
, offset
);
6894 /* Find a partial DIE at OFFSET, which may or may not be in CU,
6895 except in the case of .debug_types DIEs which do not reference
6896 outside their CU (they do however referencing other types via
6899 static struct partial_die_info
*
6900 find_partial_die (unsigned int offset
, struct dwarf2_cu
*cu
)
6902 struct dwarf2_per_cu_data
*per_cu
= NULL
;
6903 struct partial_die_info
*pd
= NULL
;
6905 if (cu
->per_cu
->from_debug_types
)
6907 pd
= find_partial_die_in_comp_unit (offset
, cu
);
6913 if (offset_in_cu_p (&cu
->header
, offset
))
6915 pd
= find_partial_die_in_comp_unit (offset
, cu
);
6920 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
6922 if (per_cu
->cu
== NULL
)
6924 load_partial_comp_unit (per_cu
, cu
->objfile
);
6925 per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
6926 dwarf2_per_objfile
->read_in_chain
= per_cu
;
6929 per_cu
->cu
->last_used
= 0;
6930 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
6932 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
6934 struct cleanup
*back_to
;
6935 struct partial_die_info comp_unit_die
;
6936 struct abbrev_info
*abbrev
;
6937 unsigned int bytes_read
;
6940 per_cu
->load_all_dies
= 1;
6942 /* Re-read the DIEs. */
6943 back_to
= make_cleanup (null_cleanup
, 0);
6944 if (per_cu
->cu
->dwarf2_abbrevs
== NULL
)
6946 dwarf2_read_abbrevs (per_cu
->cu
->objfile
->obfd
, per_cu
->cu
);
6947 make_cleanup (dwarf2_free_abbrev_table
, per_cu
->cu
);
6949 info_ptr
= (dwarf2_per_objfile
->info
.buffer
6950 + per_cu
->cu
->header
.offset
6951 + per_cu
->cu
->header
.first_die_offset
);
6952 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, per_cu
->cu
);
6953 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
6954 per_cu
->cu
->objfile
->obfd
,
6955 dwarf2_per_objfile
->info
.buffer
, info_ptr
,
6957 if (comp_unit_die
.has_children
)
6958 load_partial_dies (per_cu
->cu
->objfile
->obfd
,
6959 dwarf2_per_objfile
->info
.buffer
, info_ptr
,
6961 do_cleanups (back_to
);
6963 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
6969 internal_error (__FILE__
, __LINE__
,
6970 _("could not find partial DIE 0x%x in cache [from module %s]\n"),
6971 offset
, bfd_get_filename (cu
->objfile
->obfd
));
6975 /* Adjust PART_DIE before generating a symbol for it. This function
6976 may set the is_external flag or change the DIE's name. */
6979 fixup_partial_die (struct partial_die_info
*part_die
,
6980 struct dwarf2_cu
*cu
)
6982 /* If we found a reference attribute and the DIE has no name, try
6983 to find a name in the referred to DIE. */
6985 if (part_die
->name
== NULL
&& part_die
->has_specification
)
6987 struct partial_die_info
*spec_die
;
6989 spec_die
= find_partial_die (part_die
->spec_offset
, cu
);
6991 fixup_partial_die (spec_die
, cu
);
6995 part_die
->name
= spec_die
->name
;
6997 /* Copy DW_AT_external attribute if it is set. */
6998 if (spec_die
->is_external
)
6999 part_die
->is_external
= spec_die
->is_external
;
7003 /* Set default names for some unnamed DIEs. */
7004 if (part_die
->name
== NULL
&& (part_die
->tag
== DW_TAG_structure_type
7005 || part_die
->tag
== DW_TAG_class_type
))
7006 part_die
->name
= "(anonymous class)";
7008 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
7009 part_die
->name
= "(anonymous namespace)";
7011 if (part_die
->tag
== DW_TAG_structure_type
7012 || part_die
->tag
== DW_TAG_class_type
7013 || part_die
->tag
== DW_TAG_union_type
)
7014 guess_structure_name (part_die
, cu
);
7017 /* Read an attribute value described by an attribute form. */
7020 read_attribute_value (struct attribute
*attr
, unsigned form
,
7021 bfd
*abfd
, gdb_byte
*info_ptr
,
7022 struct dwarf2_cu
*cu
)
7024 struct comp_unit_head
*cu_header
= &cu
->header
;
7025 unsigned int bytes_read
;
7026 struct dwarf_block
*blk
;
7031 case DW_FORM_ref_addr
:
7032 if (cu
->header
.version
== 2)
7033 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
7035 DW_ADDR (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
7036 info_ptr
+= bytes_read
;
7039 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
7040 info_ptr
+= bytes_read
;
7042 case DW_FORM_block2
:
7043 blk
= dwarf_alloc_block (cu
);
7044 blk
->size
= read_2_bytes (abfd
, info_ptr
);
7046 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
7047 info_ptr
+= blk
->size
;
7048 DW_BLOCK (attr
) = blk
;
7050 case DW_FORM_block4
:
7051 blk
= dwarf_alloc_block (cu
);
7052 blk
->size
= read_4_bytes (abfd
, info_ptr
);
7054 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
7055 info_ptr
+= blk
->size
;
7056 DW_BLOCK (attr
) = blk
;
7059 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
7063 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
7067 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
7070 case DW_FORM_string
:
7071 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
7072 DW_STRING_IS_CANONICAL (attr
) = 0;
7073 info_ptr
+= bytes_read
;
7076 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
7078 DW_STRING_IS_CANONICAL (attr
) = 0;
7079 info_ptr
+= bytes_read
;
7082 blk
= dwarf_alloc_block (cu
);
7083 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
7084 info_ptr
+= bytes_read
;
7085 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
7086 info_ptr
+= blk
->size
;
7087 DW_BLOCK (attr
) = blk
;
7089 case DW_FORM_block1
:
7090 blk
= dwarf_alloc_block (cu
);
7091 blk
->size
= read_1_byte (abfd
, info_ptr
);
7093 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
7094 info_ptr
+= blk
->size
;
7095 DW_BLOCK (attr
) = blk
;
7098 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
7102 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
7106 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
7107 info_ptr
+= bytes_read
;
7110 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
7111 info_ptr
+= bytes_read
;
7114 DW_ADDR (attr
) = cu
->header
.offset
+ read_1_byte (abfd
, info_ptr
);
7118 DW_ADDR (attr
) = cu
->header
.offset
+ read_2_bytes (abfd
, info_ptr
);
7122 DW_ADDR (attr
) = cu
->header
.offset
+ read_4_bytes (abfd
, info_ptr
);
7126 DW_ADDR (attr
) = cu
->header
.offset
+ read_8_bytes (abfd
, info_ptr
);
7130 /* Convert the signature to something we can record in DW_UNSND
7132 NOTE: This is NULL if the type wasn't found. */
7133 DW_SIGNATURED_TYPE (attr
) =
7134 lookup_signatured_type (cu
->objfile
, read_8_bytes (abfd
, info_ptr
));
7137 case DW_FORM_ref_udata
:
7138 DW_ADDR (attr
) = (cu
->header
.offset
7139 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
7140 info_ptr
+= bytes_read
;
7142 case DW_FORM_indirect
:
7143 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
7144 info_ptr
+= bytes_read
;
7145 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu
);
7148 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
7149 dwarf_form_name (form
),
7150 bfd_get_filename (abfd
));
7153 /* We have seen instances where the compiler tried to emit a byte
7154 size attribute of -1 which ended up being encoded as an unsigned
7155 0xffffffff. Although 0xffffffff is technically a valid size value,
7156 an object of this size seems pretty unlikely so we can relatively
7157 safely treat these cases as if the size attribute was invalid and
7158 treat them as zero by default. */
7159 if (attr
->name
== DW_AT_byte_size
7160 && form
== DW_FORM_data4
7161 && DW_UNSND (attr
) >= 0xffffffff)
7164 (&symfile_complaints
,
7165 _("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
7166 hex_string (DW_UNSND (attr
)));
7167 DW_UNSND (attr
) = 0;
7173 /* Read an attribute described by an abbreviated attribute. */
7176 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
7177 bfd
*abfd
, gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
7179 attr
->name
= abbrev
->name
;
7180 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu
);
7183 /* read dwarf information from a buffer */
7186 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
7188 return bfd_get_8 (abfd
, buf
);
7192 read_1_signed_byte (bfd
*abfd
, gdb_byte
*buf
)
7194 return bfd_get_signed_8 (abfd
, buf
);
7198 read_2_bytes (bfd
*abfd
, gdb_byte
*buf
)
7200 return bfd_get_16 (abfd
, buf
);
7204 read_2_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
7206 return bfd_get_signed_16 (abfd
, buf
);
7210 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
7212 return bfd_get_32 (abfd
, buf
);
7216 read_4_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
7218 return bfd_get_signed_32 (abfd
, buf
);
7222 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
7224 return bfd_get_64 (abfd
, buf
);
7228 read_address (bfd
*abfd
, gdb_byte
*buf
, struct dwarf2_cu
*cu
,
7229 unsigned int *bytes_read
)
7231 struct comp_unit_head
*cu_header
= &cu
->header
;
7232 CORE_ADDR retval
= 0;
7234 if (cu_header
->signed_addr_p
)
7236 switch (cu_header
->addr_size
)
7239 retval
= bfd_get_signed_16 (abfd
, buf
);
7242 retval
= bfd_get_signed_32 (abfd
, buf
);
7245 retval
= bfd_get_signed_64 (abfd
, buf
);
7248 internal_error (__FILE__
, __LINE__
,
7249 _("read_address: bad switch, signed [in module %s]"),
7250 bfd_get_filename (abfd
));
7255 switch (cu_header
->addr_size
)
7258 retval
= bfd_get_16 (abfd
, buf
);
7261 retval
= bfd_get_32 (abfd
, buf
);
7264 retval
= bfd_get_64 (abfd
, buf
);
7267 internal_error (__FILE__
, __LINE__
,
7268 _("read_address: bad switch, unsigned [in module %s]"),
7269 bfd_get_filename (abfd
));
7273 *bytes_read
= cu_header
->addr_size
;
7277 /* Read the initial length from a section. The (draft) DWARF 3
7278 specification allows the initial length to take up either 4 bytes
7279 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
7280 bytes describe the length and all offsets will be 8 bytes in length
7283 An older, non-standard 64-bit format is also handled by this
7284 function. The older format in question stores the initial length
7285 as an 8-byte quantity without an escape value. Lengths greater
7286 than 2^32 aren't very common which means that the initial 4 bytes
7287 is almost always zero. Since a length value of zero doesn't make
7288 sense for the 32-bit format, this initial zero can be considered to
7289 be an escape value which indicates the presence of the older 64-bit
7290 format. As written, the code can't detect (old format) lengths
7291 greater than 4GB. If it becomes necessary to handle lengths
7292 somewhat larger than 4GB, we could allow other small values (such
7293 as the non-sensical values of 1, 2, and 3) to also be used as
7294 escape values indicating the presence of the old format.
7296 The value returned via bytes_read should be used to increment the
7297 relevant pointer after calling read_initial_length().
7299 [ Note: read_initial_length() and read_offset() are based on the
7300 document entitled "DWARF Debugging Information Format", revision
7301 3, draft 8, dated November 19, 2001. This document was obtained
7304 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
7306 This document is only a draft and is subject to change. (So beware.)
7308 Details regarding the older, non-standard 64-bit format were
7309 determined empirically by examining 64-bit ELF files produced by
7310 the SGI toolchain on an IRIX 6.5 machine.
7312 - Kevin, July 16, 2002
7316 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read
)
7318 LONGEST length
= bfd_get_32 (abfd
, buf
);
7320 if (length
== 0xffffffff)
7322 length
= bfd_get_64 (abfd
, buf
+ 4);
7325 else if (length
== 0)
7327 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
7328 length
= bfd_get_64 (abfd
, buf
);
7339 /* Cover function for read_initial_length.
7340 Returns the length of the object at BUF, and stores the size of the
7341 initial length in *BYTES_READ and stores the size that offsets will be in
7343 If the initial length size is not equivalent to that specified in
7344 CU_HEADER then issue a complaint.
7345 This is useful when reading non-comp-unit headers. */
7348 read_checked_initial_length_and_offset (bfd
*abfd
, gdb_byte
*buf
,
7349 const struct comp_unit_head
*cu_header
,
7350 unsigned int *bytes_read
,
7351 unsigned int *offset_size
)
7353 LONGEST length
= read_initial_length (abfd
, buf
, bytes_read
);
7355 gdb_assert (cu_header
->initial_length_size
== 4
7356 || cu_header
->initial_length_size
== 8
7357 || cu_header
->initial_length_size
== 12);
7359 if (cu_header
->initial_length_size
!= *bytes_read
)
7360 complaint (&symfile_complaints
,
7361 _("intermixed 32-bit and 64-bit DWARF sections"));
7363 *offset_size
= (*bytes_read
== 4) ? 4 : 8;
7367 /* Read an offset from the data stream. The size of the offset is
7368 given by cu_header->offset_size. */
7371 read_offset (bfd
*abfd
, gdb_byte
*buf
, const struct comp_unit_head
*cu_header
,
7372 unsigned int *bytes_read
)
7374 LONGEST offset
= read_offset_1 (abfd
, buf
, cu_header
->offset_size
);
7375 *bytes_read
= cu_header
->offset_size
;
7379 /* Read an offset from the data stream. */
7382 read_offset_1 (bfd
*abfd
, gdb_byte
*buf
, unsigned int offset_size
)
7386 switch (offset_size
)
7389 retval
= bfd_get_32 (abfd
, buf
);
7392 retval
= bfd_get_64 (abfd
, buf
);
7395 internal_error (__FILE__
, __LINE__
,
7396 _("read_offset_1: bad switch [in module %s]"),
7397 bfd_get_filename (abfd
));
7404 read_n_bytes (bfd
*abfd
, gdb_byte
*buf
, unsigned int size
)
7406 /* If the size of a host char is 8 bits, we can return a pointer
7407 to the buffer, otherwise we have to copy the data to a buffer
7408 allocated on the temporary obstack. */
7409 gdb_assert (HOST_CHAR_BIT
== 8);
7414 read_string (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
7416 /* If the size of a host char is 8 bits, we can return a pointer
7417 to the string, otherwise we have to copy the string to a buffer
7418 allocated on the temporary obstack. */
7419 gdb_assert (HOST_CHAR_BIT
== 8);
7422 *bytes_read_ptr
= 1;
7425 *bytes_read_ptr
= strlen ((char *) buf
) + 1;
7426 return (char *) buf
;
7430 read_indirect_string (bfd
*abfd
, gdb_byte
*buf
,
7431 const struct comp_unit_head
*cu_header
,
7432 unsigned int *bytes_read_ptr
)
7434 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
, bytes_read_ptr
);
7436 if (dwarf2_per_objfile
->str
.buffer
== NULL
)
7438 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
7439 bfd_get_filename (abfd
));
7442 if (str_offset
>= dwarf2_per_objfile
->str
.size
)
7444 error (_("DW_FORM_strp pointing outside of .debug_str section [in module %s]"),
7445 bfd_get_filename (abfd
));
7448 gdb_assert (HOST_CHAR_BIT
== 8);
7449 if (dwarf2_per_objfile
->str
.buffer
[str_offset
] == '\0')
7451 return (char *) (dwarf2_per_objfile
->str
.buffer
+ str_offset
);
7454 static unsigned long
7455 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
7457 unsigned long result
;
7458 unsigned int num_read
;
7468 byte
= bfd_get_8 (abfd
, buf
);
7471 result
|= ((unsigned long)(byte
& 127) << shift
);
7472 if ((byte
& 128) == 0)
7478 *bytes_read_ptr
= num_read
;
7483 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
7486 int i
, shift
, num_read
;
7495 byte
= bfd_get_8 (abfd
, buf
);
7498 result
|= ((long)(byte
& 127) << shift
);
7500 if ((byte
& 128) == 0)
7505 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
7506 result
|= -(((long)1) << shift
);
7507 *bytes_read_ptr
= num_read
;
7511 /* Return a pointer to just past the end of an LEB128 number in BUF. */
7514 skip_leb128 (bfd
*abfd
, gdb_byte
*buf
)
7520 byte
= bfd_get_8 (abfd
, buf
);
7522 if ((byte
& 128) == 0)
7528 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
7535 cu
->language
= language_c
;
7537 case DW_LANG_C_plus_plus
:
7538 cu
->language
= language_cplus
;
7540 case DW_LANG_Fortran77
:
7541 case DW_LANG_Fortran90
:
7542 case DW_LANG_Fortran95
:
7543 cu
->language
= language_fortran
;
7545 case DW_LANG_Mips_Assembler
:
7546 cu
->language
= language_asm
;
7549 cu
->language
= language_java
;
7553 cu
->language
= language_ada
;
7555 case DW_LANG_Modula2
:
7556 cu
->language
= language_m2
;
7558 case DW_LANG_Pascal83
:
7559 cu
->language
= language_pascal
;
7562 cu
->language
= language_objc
;
7564 case DW_LANG_Cobol74
:
7565 case DW_LANG_Cobol85
:
7567 cu
->language
= language_minimal
;
7570 cu
->language_defn
= language_def (cu
->language
);
7573 /* Return the named attribute or NULL if not there. */
7575 static struct attribute
*
7576 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
7579 struct attribute
*spec
= NULL
;
7581 for (i
= 0; i
< die
->num_attrs
; ++i
)
7583 if (die
->attrs
[i
].name
== name
)
7584 return &die
->attrs
[i
];
7585 if (die
->attrs
[i
].name
== DW_AT_specification
7586 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
7587 spec
= &die
->attrs
[i
];
7592 die
= follow_die_ref (die
, spec
, &cu
);
7593 return dwarf2_attr (die
, name
, cu
);
7599 /* Return the named attribute or NULL if not there,
7600 but do not follow DW_AT_specification, etc.
7601 This is for use in contexts where we're reading .debug_types dies.
7602 Following DW_AT_specification, DW_AT_abstract_origin will take us
7603 back up the chain, and we want to go down. */
7605 static struct attribute
*
7606 dwarf2_attr_no_follow (struct die_info
*die
, unsigned int name
,
7607 struct dwarf2_cu
*cu
)
7611 for (i
= 0; i
< die
->num_attrs
; ++i
)
7612 if (die
->attrs
[i
].name
== name
)
7613 return &die
->attrs
[i
];
7618 /* Return non-zero iff the attribute NAME is defined for the given DIE,
7619 and holds a non-zero value. This function should only be used for
7620 DW_FORM_flag attributes. */
7623 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
7625 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
7627 return (attr
&& DW_UNSND (attr
));
7631 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
7633 /* A DIE is a declaration if it has a DW_AT_declaration attribute
7634 which value is non-zero. However, we have to be careful with
7635 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
7636 (via dwarf2_flag_true_p) follows this attribute. So we may
7637 end up accidently finding a declaration attribute that belongs
7638 to a different DIE referenced by the specification attribute,
7639 even though the given DIE does not have a declaration attribute. */
7640 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
7641 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
7644 /* Return the die giving the specification for DIE, if there is
7645 one. *SPEC_CU is the CU containing DIE on input, and the CU
7646 containing the return value on output. If there is no
7647 specification, but there is an abstract origin, that is
7650 static struct die_info
*
7651 die_specification (struct die_info
*die
, struct dwarf2_cu
**spec_cu
)
7653 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
,
7656 if (spec_attr
== NULL
)
7657 spec_attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, *spec_cu
);
7659 if (spec_attr
== NULL
)
7662 return follow_die_ref (die
, spec_attr
, spec_cu
);
7665 /* Free the line_header structure *LH, and any arrays and strings it
7668 free_line_header (struct line_header
*lh
)
7670 if (lh
->standard_opcode_lengths
)
7671 xfree (lh
->standard_opcode_lengths
);
7673 /* Remember that all the lh->file_names[i].name pointers are
7674 pointers into debug_line_buffer, and don't need to be freed. */
7676 xfree (lh
->file_names
);
7678 /* Similarly for the include directory names. */
7679 if (lh
->include_dirs
)
7680 xfree (lh
->include_dirs
);
7686 /* Add an entry to LH's include directory table. */
7688 add_include_dir (struct line_header
*lh
, char *include_dir
)
7690 /* Grow the array if necessary. */
7691 if (lh
->include_dirs_size
== 0)
7693 lh
->include_dirs_size
= 1; /* for testing */
7694 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
7695 * sizeof (*lh
->include_dirs
));
7697 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
7699 lh
->include_dirs_size
*= 2;
7700 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
7701 (lh
->include_dirs_size
7702 * sizeof (*lh
->include_dirs
)));
7705 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
7709 /* Add an entry to LH's file name table. */
7711 add_file_name (struct line_header
*lh
,
7713 unsigned int dir_index
,
7714 unsigned int mod_time
,
7715 unsigned int length
)
7717 struct file_entry
*fe
;
7719 /* Grow the array if necessary. */
7720 if (lh
->file_names_size
== 0)
7722 lh
->file_names_size
= 1; /* for testing */
7723 lh
->file_names
= xmalloc (lh
->file_names_size
7724 * sizeof (*lh
->file_names
));
7726 else if (lh
->num_file_names
>= lh
->file_names_size
)
7728 lh
->file_names_size
*= 2;
7729 lh
->file_names
= xrealloc (lh
->file_names
,
7730 (lh
->file_names_size
7731 * sizeof (*lh
->file_names
)));
7734 fe
= &lh
->file_names
[lh
->num_file_names
++];
7736 fe
->dir_index
= dir_index
;
7737 fe
->mod_time
= mod_time
;
7738 fe
->length
= length
;
7744 /* Read the statement program header starting at OFFSET in
7745 .debug_line, according to the endianness of ABFD. Return a pointer
7746 to a struct line_header, allocated using xmalloc.
7748 NOTE: the strings in the include directory and file name tables of
7749 the returned object point into debug_line_buffer, and must not be
7751 static struct line_header
*
7752 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
7753 struct dwarf2_cu
*cu
)
7755 struct cleanup
*back_to
;
7756 struct line_header
*lh
;
7758 unsigned int bytes_read
, offset_size
;
7760 char *cur_dir
, *cur_file
;
7762 if (dwarf2_per_objfile
->line
.buffer
== NULL
)
7764 complaint (&symfile_complaints
, _("missing .debug_line section"));
7768 /* Make sure that at least there's room for the total_length field.
7769 That could be 12 bytes long, but we're just going to fudge that. */
7770 if (offset
+ 4 >= dwarf2_per_objfile
->line
.size
)
7772 dwarf2_statement_list_fits_in_line_number_section_complaint ();
7776 lh
= xmalloc (sizeof (*lh
));
7777 memset (lh
, 0, sizeof (*lh
));
7778 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
7781 line_ptr
= dwarf2_per_objfile
->line
.buffer
+ offset
;
7783 /* Read in the header. */
7785 read_checked_initial_length_and_offset (abfd
, line_ptr
, &cu
->header
,
7786 &bytes_read
, &offset_size
);
7787 line_ptr
+= bytes_read
;
7788 if (line_ptr
+ lh
->total_length
> (dwarf2_per_objfile
->line
.buffer
7789 + dwarf2_per_objfile
->line
.size
))
7791 dwarf2_statement_list_fits_in_line_number_section_complaint ();
7794 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
7795 lh
->version
= read_2_bytes (abfd
, line_ptr
);
7797 lh
->header_length
= read_offset_1 (abfd
, line_ptr
, offset_size
);
7798 line_ptr
+= offset_size
;
7799 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
7801 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
7803 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
7805 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
7807 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
7809 lh
->standard_opcode_lengths
7810 = xmalloc (lh
->opcode_base
* sizeof (lh
->standard_opcode_lengths
[0]));
7812 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
7813 for (i
= 1; i
< lh
->opcode_base
; ++i
)
7815 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
7819 /* Read directory table. */
7820 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
7822 line_ptr
+= bytes_read
;
7823 add_include_dir (lh
, cur_dir
);
7825 line_ptr
+= bytes_read
;
7827 /* Read file name table. */
7828 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
7830 unsigned int dir_index
, mod_time
, length
;
7832 line_ptr
+= bytes_read
;
7833 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
7834 line_ptr
+= bytes_read
;
7835 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
7836 line_ptr
+= bytes_read
;
7837 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
7838 line_ptr
+= bytes_read
;
7840 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
7842 line_ptr
+= bytes_read
;
7843 lh
->statement_program_start
= line_ptr
;
7845 if (line_ptr
> (dwarf2_per_objfile
->line
.buffer
7846 + dwarf2_per_objfile
->line
.size
))
7847 complaint (&symfile_complaints
,
7848 _("line number info header doesn't fit in `.debug_line' section"));
7850 discard_cleanups (back_to
);
7854 /* This function exists to work around a bug in certain compilers
7855 (particularly GCC 2.95), in which the first line number marker of a
7856 function does not show up until after the prologue, right before
7857 the second line number marker. This function shifts ADDRESS down
7858 to the beginning of the function if necessary, and is called on
7859 addresses passed to record_line. */
7862 check_cu_functions (CORE_ADDR address
, struct dwarf2_cu
*cu
)
7864 struct function_range
*fn
;
7866 /* Find the function_range containing address. */
7871 cu
->cached_fn
= cu
->first_fn
;
7875 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
7881 while (fn
&& fn
!= cu
->cached_fn
)
7882 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
7892 if (address
!= fn
->lowpc
)
7893 complaint (&symfile_complaints
,
7894 _("misplaced first line number at 0x%lx for '%s'"),
7895 (unsigned long) address
, fn
->name
);
7900 /* Decode the Line Number Program (LNP) for the given line_header
7901 structure and CU. The actual information extracted and the type
7902 of structures created from the LNP depends on the value of PST.
7904 1. If PST is NULL, then this procedure uses the data from the program
7905 to create all necessary symbol tables, and their linetables.
7906 The compilation directory of the file is passed in COMP_DIR,
7907 and must not be NULL.
7909 2. If PST is not NULL, this procedure reads the program to determine
7910 the list of files included by the unit represented by PST, and
7911 builds all the associated partial symbol tables. In this case,
7912 the value of COMP_DIR is ignored, and can thus be NULL (the COMP_DIR
7913 is not used to compute the full name of the symtab, and therefore
7914 omitting it when building the partial symtab does not introduce
7915 the potential for inconsistency - a partial symtab and its associated
7916 symbtab having a different fullname -). */
7919 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
7920 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
)
7922 gdb_byte
*line_ptr
, *extended_end
;
7924 unsigned int bytes_read
, extended_len
;
7925 unsigned char op_code
, extended_op
, adj_opcode
;
7927 struct objfile
*objfile
= cu
->objfile
;
7928 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
7929 const int decode_for_pst_p
= (pst
!= NULL
);
7930 struct subfile
*last_subfile
= NULL
, *first_subfile
= current_subfile
;
7932 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
7934 line_ptr
= lh
->statement_program_start
;
7935 line_end
= lh
->statement_program_end
;
7937 /* Read the statement sequences until there's nothing left. */
7938 while (line_ptr
< line_end
)
7940 /* state machine registers */
7941 CORE_ADDR address
= 0;
7942 unsigned int file
= 1;
7943 unsigned int line
= 1;
7944 unsigned int column
= 0;
7945 int is_stmt
= lh
->default_is_stmt
;
7946 int basic_block
= 0;
7947 int end_sequence
= 0;
7950 if (!decode_for_pst_p
&& lh
->num_file_names
>= file
)
7952 /* Start a subfile for the current file of the state machine. */
7953 /* lh->include_dirs and lh->file_names are 0-based, but the
7954 directory and file name numbers in the statement program
7956 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
7960 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
7962 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
7965 /* Decode the table. */
7966 while (!end_sequence
)
7968 op_code
= read_1_byte (abfd
, line_ptr
);
7970 if (line_ptr
> line_end
)
7972 dwarf2_debug_line_missing_end_sequence_complaint ();
7976 if (op_code
>= lh
->opcode_base
)
7978 /* Special operand. */
7979 adj_opcode
= op_code
- lh
->opcode_base
;
7980 address
+= (adj_opcode
/ lh
->line_range
)
7981 * lh
->minimum_instruction_length
;
7982 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
7983 if (lh
->num_file_names
< file
|| file
== 0)
7984 dwarf2_debug_line_missing_file_complaint ();
7987 lh
->file_names
[file
- 1].included_p
= 1;
7988 if (!decode_for_pst_p
&& is_stmt
)
7990 if (last_subfile
!= current_subfile
)
7992 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
7994 record_line (last_subfile
, 0, addr
);
7995 last_subfile
= current_subfile
;
7997 /* Append row to matrix using current values. */
7998 addr
= check_cu_functions (address
, cu
);
7999 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
8000 record_line (current_subfile
, line
, addr
);
8005 else switch (op_code
)
8007 case DW_LNS_extended_op
:
8008 extended_len
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
8009 line_ptr
+= bytes_read
;
8010 extended_end
= line_ptr
+ extended_len
;
8011 extended_op
= read_1_byte (abfd
, line_ptr
);
8013 switch (extended_op
)
8015 case DW_LNE_end_sequence
:
8018 case DW_LNE_set_address
:
8019 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
8020 line_ptr
+= bytes_read
;
8021 address
+= baseaddr
;
8023 case DW_LNE_define_file
:
8026 unsigned int dir_index
, mod_time
, length
;
8028 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
8029 line_ptr
+= bytes_read
;
8031 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
8032 line_ptr
+= bytes_read
;
8034 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
8035 line_ptr
+= bytes_read
;
8037 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
8038 line_ptr
+= bytes_read
;
8039 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
8042 case DW_LNE_set_discriminator
:
8043 /* The discriminator is not interesting to the debugger;
8045 line_ptr
= extended_end
;
8048 complaint (&symfile_complaints
,
8049 _("mangled .debug_line section"));
8052 /* Make sure that we parsed the extended op correctly. If e.g.
8053 we expected a different address size than the producer used,
8054 we may have read the wrong number of bytes. */
8055 if (line_ptr
!= extended_end
)
8057 complaint (&symfile_complaints
,
8058 _("mangled .debug_line section"));
8063 if (lh
->num_file_names
< file
|| file
== 0)
8064 dwarf2_debug_line_missing_file_complaint ();
8067 lh
->file_names
[file
- 1].included_p
= 1;
8068 if (!decode_for_pst_p
&& is_stmt
)
8070 if (last_subfile
!= current_subfile
)
8072 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
8074 record_line (last_subfile
, 0, addr
);
8075 last_subfile
= current_subfile
;
8077 addr
= check_cu_functions (address
, cu
);
8078 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
8079 record_line (current_subfile
, line
, addr
);
8084 case DW_LNS_advance_pc
:
8085 address
+= lh
->minimum_instruction_length
8086 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
8087 line_ptr
+= bytes_read
;
8089 case DW_LNS_advance_line
:
8090 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
8091 line_ptr
+= bytes_read
;
8093 case DW_LNS_set_file
:
8095 /* The arrays lh->include_dirs and lh->file_names are
8096 0-based, but the directory and file name numbers in
8097 the statement program are 1-based. */
8098 struct file_entry
*fe
;
8101 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
8102 line_ptr
+= bytes_read
;
8103 if (lh
->num_file_names
< file
|| file
== 0)
8104 dwarf2_debug_line_missing_file_complaint ();
8107 fe
= &lh
->file_names
[file
- 1];
8109 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
8110 if (!decode_for_pst_p
)
8112 last_subfile
= current_subfile
;
8113 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
8118 case DW_LNS_set_column
:
8119 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
8120 line_ptr
+= bytes_read
;
8122 case DW_LNS_negate_stmt
:
8123 is_stmt
= (!is_stmt
);
8125 case DW_LNS_set_basic_block
:
8128 /* Add to the address register of the state machine the
8129 address increment value corresponding to special opcode
8130 255. I.e., this value is scaled by the minimum
8131 instruction length since special opcode 255 would have
8132 scaled the the increment. */
8133 case DW_LNS_const_add_pc
:
8134 address
+= (lh
->minimum_instruction_length
8135 * ((255 - lh
->opcode_base
) / lh
->line_range
));
8137 case DW_LNS_fixed_advance_pc
:
8138 address
+= read_2_bytes (abfd
, line_ptr
);
8143 /* Unknown standard opcode, ignore it. */
8146 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
8148 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
8149 line_ptr
+= bytes_read
;
8154 if (lh
->num_file_names
< file
|| file
== 0)
8155 dwarf2_debug_line_missing_file_complaint ();
8158 lh
->file_names
[file
- 1].included_p
= 1;
8159 if (!decode_for_pst_p
)
8161 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
8162 record_line (current_subfile
, 0, addr
);
8167 if (decode_for_pst_p
)
8171 /* Now that we're done scanning the Line Header Program, we can
8172 create the psymtab of each included file. */
8173 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
8174 if (lh
->file_names
[file_index
].included_p
== 1)
8176 const struct file_entry fe
= lh
->file_names
[file_index
];
8177 char *include_name
= fe
.name
;
8178 char *dir_name
= NULL
;
8179 char *pst_filename
= pst
->filename
;
8182 dir_name
= lh
->include_dirs
[fe
.dir_index
- 1];
8184 if (!IS_ABSOLUTE_PATH (include_name
) && dir_name
!= NULL
)
8186 include_name
= concat (dir_name
, SLASH_STRING
,
8187 include_name
, (char *)NULL
);
8188 make_cleanup (xfree
, include_name
);
8191 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
8193 pst_filename
= concat (pst
->dirname
, SLASH_STRING
,
8194 pst_filename
, (char *)NULL
);
8195 make_cleanup (xfree
, pst_filename
);
8198 if (strcmp (include_name
, pst_filename
) != 0)
8199 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
8204 /* Make sure a symtab is created for every file, even files
8205 which contain only variables (i.e. no code with associated
8209 struct file_entry
*fe
;
8211 for (i
= 0; i
< lh
->num_file_names
; i
++)
8214 fe
= &lh
->file_names
[i
];
8216 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
8217 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
8219 /* Skip the main file; we don't need it, and it must be
8220 allocated last, so that it will show up before the
8221 non-primary symtabs in the objfile's symtab list. */
8222 if (current_subfile
== first_subfile
)
8225 if (current_subfile
->symtab
== NULL
)
8226 current_subfile
->symtab
= allocate_symtab (current_subfile
->name
,
8228 fe
->symtab
= current_subfile
->symtab
;
8233 /* Start a subfile for DWARF. FILENAME is the name of the file and
8234 DIRNAME the name of the source directory which contains FILENAME
8235 or NULL if not known. COMP_DIR is the compilation directory for the
8236 linetable's compilation unit or NULL if not known.
8237 This routine tries to keep line numbers from identical absolute and
8238 relative file names in a common subfile.
8240 Using the `list' example from the GDB testsuite, which resides in
8241 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
8242 of /srcdir/list0.c yields the following debugging information for list0.c:
8244 DW_AT_name: /srcdir/list0.c
8245 DW_AT_comp_dir: /compdir
8246 files.files[0].name: list0.h
8247 files.files[0].dir: /srcdir
8248 files.files[1].name: list0.c
8249 files.files[1].dir: /srcdir
8251 The line number information for list0.c has to end up in a single
8252 subfile, so that `break /srcdir/list0.c:1' works as expected.
8253 start_subfile will ensure that this happens provided that we pass the
8254 concatenation of files.files[1].dir and files.files[1].name as the
8258 dwarf2_start_subfile (char *filename
, char *dirname
, char *comp_dir
)
8262 /* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir).
8263 `start_symtab' will always pass the contents of DW_AT_comp_dir as
8264 second argument to start_subfile. To be consistent, we do the
8265 same here. In order not to lose the line information directory,
8266 we concatenate it to the filename when it makes sense.
8267 Note that the Dwarf3 standard says (speaking of filenames in line
8268 information): ``The directory index is ignored for file names
8269 that represent full path names''. Thus ignoring dirname in the
8270 `else' branch below isn't an issue. */
8272 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
8273 fullname
= concat (dirname
, SLASH_STRING
, filename
, (char *)NULL
);
8275 fullname
= filename
;
8277 start_subfile (fullname
, comp_dir
);
8279 if (fullname
!= filename
)
8284 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
8285 struct dwarf2_cu
*cu
)
8287 struct objfile
*objfile
= cu
->objfile
;
8288 struct comp_unit_head
*cu_header
= &cu
->header
;
8290 /* NOTE drow/2003-01-30: There used to be a comment and some special
8291 code here to turn a symbol with DW_AT_external and a
8292 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
8293 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
8294 with some versions of binutils) where shared libraries could have
8295 relocations against symbols in their debug information - the
8296 minimal symbol would have the right address, but the debug info
8297 would not. It's no longer necessary, because we will explicitly
8298 apply relocations when we read in the debug information now. */
8300 /* A DW_AT_location attribute with no contents indicates that a
8301 variable has been optimized away. */
8302 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
8304 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
8308 /* Handle one degenerate form of location expression specially, to
8309 preserve GDB's previous behavior when section offsets are
8310 specified. If this is just a DW_OP_addr then mark this symbol
8313 if (attr_form_is_block (attr
)
8314 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
8315 && DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
8319 SYMBOL_VALUE_ADDRESS (sym
) =
8320 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
8321 SYMBOL_CLASS (sym
) = LOC_STATIC
;
8322 fixup_symbol_section (sym
, objfile
);
8323 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
8324 SYMBOL_SECTION (sym
));
8328 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
8329 expression evaluator, and use LOC_COMPUTED only when necessary
8330 (i.e. when the value of a register or memory location is
8331 referenced, or a thread-local block, etc.). Then again, it might
8332 not be worthwhile. I'm assuming that it isn't unless performance
8333 or memory numbers show me otherwise. */
8335 dwarf2_symbol_mark_computed (attr
, sym
, cu
);
8336 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
8339 /* Given a pointer to a DWARF information entry, figure out if we need
8340 to make a symbol table entry for it, and if so, create a new entry
8341 and return a pointer to it.
8342 If TYPE is NULL, determine symbol type from the die, otherwise
8343 used the passed type. */
8345 static struct symbol
*
8346 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
8348 struct objfile
*objfile
= cu
->objfile
;
8349 struct symbol
*sym
= NULL
;
8351 struct attribute
*attr
= NULL
;
8352 struct attribute
*attr2
= NULL
;
8354 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
8356 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
8358 name
= dwarf2_name (die
, cu
);
8361 const char *linkagename
;
8363 sym
= (struct symbol
*) obstack_alloc (&objfile
->objfile_obstack
,
8364 sizeof (struct symbol
));
8365 OBJSTAT (objfile
, n_syms
++);
8366 memset (sym
, 0, sizeof (struct symbol
));
8368 /* Cache this symbol's name and the name's demangled form (if any). */
8369 SYMBOL_LANGUAGE (sym
) = cu
->language
;
8370 linkagename
= dwarf2_physname (name
, die
, cu
);
8371 SYMBOL_SET_NAMES (sym
, linkagename
, strlen (linkagename
), 0, objfile
);
8373 /* Default assumptions.
8374 Use the passed type or decode it from the die. */
8375 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
8376 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
8378 SYMBOL_TYPE (sym
) = type
;
8380 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
8381 attr
= dwarf2_attr (die
,
8382 inlined_func
? DW_AT_call_line
: DW_AT_decl_line
,
8386 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
8389 attr
= dwarf2_attr (die
,
8390 inlined_func
? DW_AT_call_file
: DW_AT_decl_file
,
8394 int file_index
= DW_UNSND (attr
);
8395 if (cu
->line_header
== NULL
8396 || file_index
> cu
->line_header
->num_file_names
)
8397 complaint (&symfile_complaints
,
8398 _("file index out of range"));
8399 else if (file_index
> 0)
8401 struct file_entry
*fe
;
8402 fe
= &cu
->line_header
->file_names
[file_index
- 1];
8403 SYMBOL_SYMTAB (sym
) = fe
->symtab
;
8410 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
8413 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
8415 SYMBOL_CLASS (sym
) = LOC_LABEL
;
8417 case DW_TAG_subprogram
:
8418 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
8420 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
8421 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
8422 if ((attr2
&& (DW_UNSND (attr2
) != 0))
8423 || cu
->language
== language_ada
)
8425 /* Subprograms marked external are stored as a global symbol.
8426 Ada subprograms, whether marked external or not, are always
8427 stored as a global symbol, because we want to be able to
8428 access them globally. For instance, we want to be able
8429 to break on a nested subprogram without having to
8430 specify the context. */
8431 add_symbol_to_list (sym
, &global_symbols
);
8435 add_symbol_to_list (sym
, cu
->list_in_scope
);
8438 case DW_TAG_inlined_subroutine
:
8439 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
8441 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
8442 SYMBOL_INLINED (sym
) = 1;
8443 /* Do not add the symbol to any lists. It will be found via
8444 BLOCK_FUNCTION from the blockvector. */
8446 case DW_TAG_variable
:
8447 /* Compilation with minimal debug info may result in variables
8448 with missing type entries. Change the misleading `void' type
8449 to something sensible. */
8450 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
8452 = objfile_type (objfile
)->nodebug_data_symbol
;
8454 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
8457 dwarf2_const_value (attr
, sym
, cu
);
8458 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
8459 if (attr2
&& (DW_UNSND (attr2
) != 0))
8460 add_symbol_to_list (sym
, &global_symbols
);
8462 add_symbol_to_list (sym
, cu
->list_in_scope
);
8465 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
8468 var_decode_location (attr
, sym
, cu
);
8469 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
8470 if (attr2
&& (DW_UNSND (attr2
) != 0))
8471 add_symbol_to_list (sym
, &global_symbols
);
8473 add_symbol_to_list (sym
, cu
->list_in_scope
);
8477 /* We do not know the address of this symbol.
8478 If it is an external symbol and we have type information
8479 for it, enter the symbol as a LOC_UNRESOLVED symbol.
8480 The address of the variable will then be determined from
8481 the minimal symbol table whenever the variable is
8483 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
8484 if (attr2
&& (DW_UNSND (attr2
) != 0)
8485 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
8487 struct pending
**list_to_add
;
8489 /* A variable with DW_AT_external is never static, but it
8490 may be block-scoped. */
8491 list_to_add
= (cu
->list_in_scope
== &file_symbols
8492 ? &global_symbols
: cu
->list_in_scope
);
8494 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
8495 add_symbol_to_list (sym
, list_to_add
);
8497 else if (!die_is_declaration (die
, cu
))
8499 /* Use the default LOC_OPTIMIZED_OUT class. */
8500 gdb_assert (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
);
8501 add_symbol_to_list (sym
, cu
->list_in_scope
);
8505 case DW_TAG_formal_parameter
:
8506 /* If we are inside a function, mark this as an argument. If
8507 not, we might be looking at an argument to an inlined function
8508 when we do not have enough information to show inlined frames;
8509 pretend it's a local variable in that case so that the user can
8511 if (context_stack_depth
> 0
8512 && context_stack
[context_stack_depth
- 1].name
!= NULL
)
8513 SYMBOL_IS_ARGUMENT (sym
) = 1;
8514 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
8517 var_decode_location (attr
, sym
, cu
);
8519 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
8522 dwarf2_const_value (attr
, sym
, cu
);
8524 add_symbol_to_list (sym
, cu
->list_in_scope
);
8526 case DW_TAG_unspecified_parameters
:
8527 /* From varargs functions; gdb doesn't seem to have any
8528 interest in this information, so just ignore it for now.
8531 case DW_TAG_class_type
:
8532 case DW_TAG_interface_type
:
8533 case DW_TAG_structure_type
:
8534 case DW_TAG_union_type
:
8535 case DW_TAG_set_type
:
8536 case DW_TAG_enumeration_type
:
8537 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
8538 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
8540 /* Make sure that the symbol includes appropriate enclosing
8541 classes/namespaces in its name. These are calculated in
8542 read_structure_type, and the correct name is saved in
8545 if (cu
->language
== language_cplus
8546 || cu
->language
== language_java
)
8548 struct type
*type
= SYMBOL_TYPE (sym
);
8550 if (TYPE_TAG_NAME (type
) != NULL
)
8552 /* FIXME: carlton/2003-11-10: Should this use
8553 SYMBOL_SET_NAMES instead? (The same problem also
8554 arises further down in this function.) */
8555 /* The type's name is already allocated along with
8556 this objfile, so we don't need to duplicate it
8558 SYMBOL_LINKAGE_NAME (sym
) = TYPE_TAG_NAME (type
);
8563 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
8564 really ever be static objects: otherwise, if you try
8565 to, say, break of a class's method and you're in a file
8566 which doesn't mention that class, it won't work unless
8567 the check for all static symbols in lookup_symbol_aux
8568 saves you. See the OtherFileClass tests in
8569 gdb.c++/namespace.exp. */
8571 struct pending
**list_to_add
;
8573 list_to_add
= (cu
->list_in_scope
== &file_symbols
8574 && (cu
->language
== language_cplus
8575 || cu
->language
== language_java
)
8576 ? &global_symbols
: cu
->list_in_scope
);
8578 add_symbol_to_list (sym
, list_to_add
);
8580 /* The semantics of C++ state that "struct foo { ... }" also
8581 defines a typedef for "foo". A Java class declaration also
8582 defines a typedef for the class. */
8583 if (cu
->language
== language_cplus
8584 || cu
->language
== language_java
8585 || cu
->language
== language_ada
)
8587 /* The symbol's name is already allocated along with
8588 this objfile, so we don't need to duplicate it for
8590 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
8591 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
8595 case DW_TAG_typedef
:
8596 SYMBOL_LINKAGE_NAME (sym
)
8597 = (char *) dwarf2_full_name (name
, die
, cu
);
8598 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
8599 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
8600 add_symbol_to_list (sym
, cu
->list_in_scope
);
8602 case DW_TAG_base_type
:
8603 case DW_TAG_subrange_type
:
8604 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
8605 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
8606 add_symbol_to_list (sym
, cu
->list_in_scope
);
8608 case DW_TAG_enumerator
:
8609 SYMBOL_LINKAGE_NAME (sym
)
8610 = (char *) dwarf2_full_name (name
, die
, cu
);
8611 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
8614 dwarf2_const_value (attr
, sym
, cu
);
8617 /* NOTE: carlton/2003-11-10: See comment above in the
8618 DW_TAG_class_type, etc. block. */
8620 struct pending
**list_to_add
;
8622 list_to_add
= (cu
->list_in_scope
== &file_symbols
8623 && (cu
->language
== language_cplus
8624 || cu
->language
== language_java
)
8625 ? &global_symbols
: cu
->list_in_scope
);
8627 add_symbol_to_list (sym
, list_to_add
);
8630 case DW_TAG_namespace
:
8631 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
8632 add_symbol_to_list (sym
, &global_symbols
);
8635 /* Not a tag we recognize. Hopefully we aren't processing
8636 trash data, but since we must specifically ignore things
8637 we don't recognize, there is nothing else we should do at
8639 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
8640 dwarf_tag_name (die
->tag
));
8644 /* For the benefit of old versions of GCC, check for anonymous
8645 namespaces based on the demangled name. */
8646 if (!processing_has_namespace_info
8647 && cu
->language
== language_cplus
)
8648 cp_scan_for_anonymous_namespaces (sym
);
8653 /* Copy constant value from an attribute to a symbol. */
8656 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
8657 struct dwarf2_cu
*cu
)
8659 struct objfile
*objfile
= cu
->objfile
;
8660 struct comp_unit_head
*cu_header
= &cu
->header
;
8661 enum bfd_endian byte_order
= bfd_big_endian (objfile
->obfd
) ?
8662 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
8663 struct dwarf_block
*blk
;
8668 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
8669 dwarf2_const_value_length_mismatch_complaint (SYMBOL_PRINT_NAME (sym
),
8670 cu_header
->addr_size
,
8671 TYPE_LENGTH (SYMBOL_TYPE
8673 SYMBOL_VALUE_BYTES (sym
) =
8674 obstack_alloc (&objfile
->objfile_obstack
, cu_header
->addr_size
);
8675 /* NOTE: cagney/2003-05-09: In-lined store_address call with
8676 it's body - store_unsigned_integer. */
8677 store_unsigned_integer (SYMBOL_VALUE_BYTES (sym
), cu_header
->addr_size
,
8678 byte_order
, DW_ADDR (attr
));
8679 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
8681 case DW_FORM_string
:
8683 /* DW_STRING is already allocated on the obstack, point directly
8685 SYMBOL_VALUE_BYTES (sym
) = (gdb_byte
*) DW_STRING (attr
);
8686 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
8688 case DW_FORM_block1
:
8689 case DW_FORM_block2
:
8690 case DW_FORM_block4
:
8692 blk
= DW_BLOCK (attr
);
8693 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
8694 dwarf2_const_value_length_mismatch_complaint (SYMBOL_PRINT_NAME (sym
),
8696 TYPE_LENGTH (SYMBOL_TYPE
8698 SYMBOL_VALUE_BYTES (sym
) =
8699 obstack_alloc (&objfile
->objfile_obstack
, blk
->size
);
8700 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
8701 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
8704 /* The DW_AT_const_value attributes are supposed to carry the
8705 symbol's value "represented as it would be on the target
8706 architecture." By the time we get here, it's already been
8707 converted to host endianness, so we just need to sign- or
8708 zero-extend it as appropriate. */
8710 dwarf2_const_value_data (attr
, sym
, 8);
8713 dwarf2_const_value_data (attr
, sym
, 16);
8716 dwarf2_const_value_data (attr
, sym
, 32);
8719 dwarf2_const_value_data (attr
, sym
, 64);
8723 SYMBOL_VALUE (sym
) = DW_SND (attr
);
8724 SYMBOL_CLASS (sym
) = LOC_CONST
;
8728 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
8729 SYMBOL_CLASS (sym
) = LOC_CONST
;
8733 complaint (&symfile_complaints
,
8734 _("unsupported const value attribute form: '%s'"),
8735 dwarf_form_name (attr
->form
));
8736 SYMBOL_VALUE (sym
) = 0;
8737 SYMBOL_CLASS (sym
) = LOC_CONST
;
8743 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
8744 or zero-extend it as appropriate for the symbol's type. */
8746 dwarf2_const_value_data (struct attribute
*attr
,
8750 LONGEST l
= DW_UNSND (attr
);
8752 if (bits
< sizeof (l
) * 8)
8754 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
8755 l
&= ((LONGEST
) 1 << bits
) - 1;
8757 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
8760 SYMBOL_VALUE (sym
) = l
;
8761 SYMBOL_CLASS (sym
) = LOC_CONST
;
8765 /* Return the type of the die in question using its DW_AT_type attribute. */
8767 static struct type
*
8768 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8771 struct attribute
*type_attr
;
8772 struct die_info
*type_die
;
8774 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
8777 /* A missing DW_AT_type represents a void type. */
8778 return objfile_type (cu
->objfile
)->builtin_void
;
8781 type_die
= follow_die_ref_or_sig (die
, type_attr
, &cu
);
8783 type
= tag_type_to_type (type_die
, cu
);
8786 dump_die_for_error (type_die
);
8787 error (_("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]"),
8793 /* True iff CU's producer generates GNAT Ada auxiliary information
8794 that allows to find parallel types through that information instead
8795 of having to do expensive parallel lookups by type name. */
8798 need_gnat_info (struct dwarf2_cu
*cu
)
8800 /* FIXME: brobecker/2010-10-12: As of now, only the AdaCore version
8801 of GNAT produces this auxiliary information, without any indication
8802 that it is produced. Part of enhancing the FSF version of GNAT
8803 to produce that information will be to put in place an indicator
8804 that we can use in order to determine whether the descriptive type
8805 info is available or not. One suggestion that has been made is
8806 to use a new attribute, attached to the CU die. For now, assume
8807 that the descriptive type info is not available. */
8812 /* Return the auxiliary type of the die in question using its
8813 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
8814 attribute is not present. */
8816 static struct type
*
8817 die_descriptive_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8820 struct attribute
*type_attr
;
8821 struct die_info
*type_die
;
8823 type_attr
= dwarf2_attr (die
, DW_AT_GNAT_descriptive_type
, cu
);
8827 type_die
= follow_die_ref (die
, type_attr
, &cu
);
8828 type
= tag_type_to_type (type_die
, cu
);
8831 dump_die_for_error (type_die
);
8832 error (_("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]"),
8838 /* If DIE has a descriptive_type attribute, then set the TYPE's
8839 descriptive type accordingly. */
8842 set_descriptive_type (struct type
*type
, struct die_info
*die
,
8843 struct dwarf2_cu
*cu
)
8845 struct type
*descriptive_type
= die_descriptive_type (die
, cu
);
8847 if (descriptive_type
)
8849 ALLOCATE_GNAT_AUX_TYPE (type
);
8850 TYPE_DESCRIPTIVE_TYPE (type
) = descriptive_type
;
8854 /* Return the containing type of the die in question using its
8855 DW_AT_containing_type attribute. */
8857 static struct type
*
8858 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8860 struct type
*type
= NULL
;
8861 struct attribute
*type_attr
;
8862 struct die_info
*type_die
= NULL
;
8864 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
8867 type_die
= follow_die_ref_or_sig (die
, type_attr
, &cu
);
8868 type
= tag_type_to_type (type_die
, cu
);
8873 dump_die_for_error (type_die
);
8874 error (_("Dwarf Error: Problem turning containing type into gdb type [in module %s]"),
8880 static struct type
*
8881 tag_type_to_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8883 struct type
*this_type
;
8885 this_type
= read_type_die (die
, cu
);
8888 dump_die_for_error (die
);
8889 error (_("Dwarf Error: Cannot find type of die [in module %s]"),
8895 static struct type
*
8896 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
8898 struct type
*this_type
;
8900 this_type
= get_die_type (die
, cu
);
8906 case DW_TAG_class_type
:
8907 case DW_TAG_interface_type
:
8908 case DW_TAG_structure_type
:
8909 case DW_TAG_union_type
:
8910 this_type
= read_structure_type (die
, cu
);
8912 case DW_TAG_enumeration_type
:
8913 this_type
= read_enumeration_type (die
, cu
);
8915 case DW_TAG_subprogram
:
8916 case DW_TAG_subroutine_type
:
8917 case DW_TAG_inlined_subroutine
:
8918 this_type
= read_subroutine_type (die
, cu
);
8920 case DW_TAG_array_type
:
8921 this_type
= read_array_type (die
, cu
);
8923 case DW_TAG_set_type
:
8924 this_type
= read_set_type (die
, cu
);
8926 case DW_TAG_pointer_type
:
8927 this_type
= read_tag_pointer_type (die
, cu
);
8929 case DW_TAG_ptr_to_member_type
:
8930 this_type
= read_tag_ptr_to_member_type (die
, cu
);
8932 case DW_TAG_reference_type
:
8933 this_type
= read_tag_reference_type (die
, cu
);
8935 case DW_TAG_const_type
:
8936 this_type
= read_tag_const_type (die
, cu
);
8938 case DW_TAG_volatile_type
:
8939 this_type
= read_tag_volatile_type (die
, cu
);
8941 case DW_TAG_string_type
:
8942 this_type
= read_tag_string_type (die
, cu
);
8944 case DW_TAG_typedef
:
8945 this_type
= read_typedef (die
, cu
);
8947 case DW_TAG_subrange_type
:
8948 this_type
= read_subrange_type (die
, cu
);
8950 case DW_TAG_base_type
:
8951 this_type
= read_base_type (die
, cu
);
8953 case DW_TAG_unspecified_type
:
8954 this_type
= read_unspecified_type (die
, cu
);
8956 case DW_TAG_namespace
:
8957 this_type
= read_namespace_type (die
, cu
);
8960 complaint (&symfile_complaints
, _("unexpected tag in read_type_die: '%s'"),
8961 dwarf_tag_name (die
->tag
));
8968 /* Return the name of the namespace/class that DIE is defined within,
8969 or "" if we can't tell. The caller should not xfree the result.
8971 For example, if we're within the method foo() in the following
8981 then determine_prefix on foo's die will return "N::C". */
8984 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
8986 struct die_info
*parent
, *spec_die
;
8987 struct dwarf2_cu
*spec_cu
;
8988 struct type
*parent_type
;
8990 if (cu
->language
!= language_cplus
8991 && cu
->language
!= language_java
)
8994 /* We have to be careful in the presence of DW_AT_specification.
8995 For example, with GCC 3.4, given the code
8999 // Definition of N::foo.
9003 then we'll have a tree of DIEs like this:
9005 1: DW_TAG_compile_unit
9006 2: DW_TAG_namespace // N
9007 3: DW_TAG_subprogram // declaration of N::foo
9008 4: DW_TAG_subprogram // definition of N::foo
9009 DW_AT_specification // refers to die #3
9011 Thus, when processing die #4, we have to pretend that we're in
9012 the context of its DW_AT_specification, namely the contex of die
9015 spec_die
= die_specification (die
, &spec_cu
);
9016 if (spec_die
== NULL
)
9017 parent
= die
->parent
;
9020 parent
= spec_die
->parent
;
9027 switch (parent
->tag
)
9029 case DW_TAG_namespace
:
9030 parent_type
= read_type_die (parent
, cu
);
9031 /* We give a name to even anonymous namespaces. */
9032 return TYPE_TAG_NAME (parent_type
);
9033 case DW_TAG_class_type
:
9034 case DW_TAG_interface_type
:
9035 case DW_TAG_structure_type
:
9036 case DW_TAG_union_type
:
9037 parent_type
= read_type_die (parent
, cu
);
9038 if (TYPE_TAG_NAME (parent_type
) != NULL
)
9039 return TYPE_TAG_NAME (parent_type
);
9041 /* An anonymous structure is only allowed non-static data
9042 members; no typedefs, no member functions, et cetera.
9043 So it does not need a prefix. */
9046 return determine_prefix (parent
, cu
);
9050 /* Return a newly-allocated string formed by concatenating PREFIX and
9051 SUFFIX with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
9052 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null,
9053 perform an obconcat, otherwise allocate storage for the result. The CU argument
9054 is used to determine the language and hence, the appropriate separator. */
9056 #define MAX_SEP_LEN 2 /* sizeof ("::") */
9059 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
9060 struct dwarf2_cu
*cu
)
9064 if (suffix
== NULL
|| suffix
[0] == '\0' || prefix
== NULL
|| prefix
[0] == '\0')
9066 else if (cu
->language
== language_java
)
9078 char *retval
= xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1);
9079 strcpy (retval
, prefix
);
9080 strcat (retval
, sep
);
9081 strcat (retval
, suffix
);
9086 /* We have an obstack. */
9087 return obconcat (obs
, prefix
, sep
, suffix
);
9091 /* Return sibling of die, NULL if no sibling. */
9093 static struct die_info
*
9094 sibling_die (struct die_info
*die
)
9096 return die
->sibling
;
9099 /* Get name of a die, return NULL if not found. */
9102 dwarf2_canonicalize_name (char *name
, struct dwarf2_cu
*cu
,
9103 struct obstack
*obstack
)
9105 if (name
&& cu
->language
== language_cplus
)
9107 char *canon_name
= cp_canonicalize_string (name
);
9109 if (canon_name
!= NULL
)
9111 if (strcmp (canon_name
, name
) != 0)
9112 name
= obsavestring (canon_name
, strlen (canon_name
),
9121 /* Get name of a die, return NULL if not found. */
9124 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
9126 struct attribute
*attr
;
9128 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
9129 if (!attr
|| !DW_STRING (attr
))
9134 case DW_TAG_compile_unit
:
9135 /* Compilation units have a DW_AT_name that is a filename, not
9136 a source language identifier. */
9137 case DW_TAG_enumeration_type
:
9138 case DW_TAG_enumerator
:
9139 /* These tags always have simple identifiers already; no need
9140 to canonicalize them. */
9141 return DW_STRING (attr
);
9143 if (!DW_STRING_IS_CANONICAL (attr
))
9146 = dwarf2_canonicalize_name (DW_STRING (attr
), cu
,
9147 &cu
->objfile
->objfile_obstack
);
9148 DW_STRING_IS_CANONICAL (attr
) = 1;
9150 return DW_STRING (attr
);
9154 /* Return the die that this die in an extension of, or NULL if there
9155 is none. *EXT_CU is the CU containing DIE on input, and the CU
9156 containing the return value on output. */
9158 static struct die_info
*
9159 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
**ext_cu
)
9161 struct attribute
*attr
;
9163 attr
= dwarf2_attr (die
, DW_AT_extension
, *ext_cu
);
9167 return follow_die_ref (die
, attr
, ext_cu
);
9170 /* Convert a DIE tag into its string name. */
9173 dwarf_tag_name (unsigned tag
)
9177 case DW_TAG_padding
:
9178 return "DW_TAG_padding";
9179 case DW_TAG_array_type
:
9180 return "DW_TAG_array_type";
9181 case DW_TAG_class_type
:
9182 return "DW_TAG_class_type";
9183 case DW_TAG_entry_point
:
9184 return "DW_TAG_entry_point";
9185 case DW_TAG_enumeration_type
:
9186 return "DW_TAG_enumeration_type";
9187 case DW_TAG_formal_parameter
:
9188 return "DW_TAG_formal_parameter";
9189 case DW_TAG_imported_declaration
:
9190 return "DW_TAG_imported_declaration";
9192 return "DW_TAG_label";
9193 case DW_TAG_lexical_block
:
9194 return "DW_TAG_lexical_block";
9196 return "DW_TAG_member";
9197 case DW_TAG_pointer_type
:
9198 return "DW_TAG_pointer_type";
9199 case DW_TAG_reference_type
:
9200 return "DW_TAG_reference_type";
9201 case DW_TAG_compile_unit
:
9202 return "DW_TAG_compile_unit";
9203 case DW_TAG_string_type
:
9204 return "DW_TAG_string_type";
9205 case DW_TAG_structure_type
:
9206 return "DW_TAG_structure_type";
9207 case DW_TAG_subroutine_type
:
9208 return "DW_TAG_subroutine_type";
9209 case DW_TAG_typedef
:
9210 return "DW_TAG_typedef";
9211 case DW_TAG_union_type
:
9212 return "DW_TAG_union_type";
9213 case DW_TAG_unspecified_parameters
:
9214 return "DW_TAG_unspecified_parameters";
9215 case DW_TAG_variant
:
9216 return "DW_TAG_variant";
9217 case DW_TAG_common_block
:
9218 return "DW_TAG_common_block";
9219 case DW_TAG_common_inclusion
:
9220 return "DW_TAG_common_inclusion";
9221 case DW_TAG_inheritance
:
9222 return "DW_TAG_inheritance";
9223 case DW_TAG_inlined_subroutine
:
9224 return "DW_TAG_inlined_subroutine";
9226 return "DW_TAG_module";
9227 case DW_TAG_ptr_to_member_type
:
9228 return "DW_TAG_ptr_to_member_type";
9229 case DW_TAG_set_type
:
9230 return "DW_TAG_set_type";
9231 case DW_TAG_subrange_type
:
9232 return "DW_TAG_subrange_type";
9233 case DW_TAG_with_stmt
:
9234 return "DW_TAG_with_stmt";
9235 case DW_TAG_access_declaration
:
9236 return "DW_TAG_access_declaration";
9237 case DW_TAG_base_type
:
9238 return "DW_TAG_base_type";
9239 case DW_TAG_catch_block
:
9240 return "DW_TAG_catch_block";
9241 case DW_TAG_const_type
:
9242 return "DW_TAG_const_type";
9243 case DW_TAG_constant
:
9244 return "DW_TAG_constant";
9245 case DW_TAG_enumerator
:
9246 return "DW_TAG_enumerator";
9247 case DW_TAG_file_type
:
9248 return "DW_TAG_file_type";
9250 return "DW_TAG_friend";
9251 case DW_TAG_namelist
:
9252 return "DW_TAG_namelist";
9253 case DW_TAG_namelist_item
:
9254 return "DW_TAG_namelist_item";
9255 case DW_TAG_packed_type
:
9256 return "DW_TAG_packed_type";
9257 case DW_TAG_subprogram
:
9258 return "DW_TAG_subprogram";
9259 case DW_TAG_template_type_param
:
9260 return "DW_TAG_template_type_param";
9261 case DW_TAG_template_value_param
:
9262 return "DW_TAG_template_value_param";
9263 case DW_TAG_thrown_type
:
9264 return "DW_TAG_thrown_type";
9265 case DW_TAG_try_block
:
9266 return "DW_TAG_try_block";
9267 case DW_TAG_variant_part
:
9268 return "DW_TAG_variant_part";
9269 case DW_TAG_variable
:
9270 return "DW_TAG_variable";
9271 case DW_TAG_volatile_type
:
9272 return "DW_TAG_volatile_type";
9273 case DW_TAG_dwarf_procedure
:
9274 return "DW_TAG_dwarf_procedure";
9275 case DW_TAG_restrict_type
:
9276 return "DW_TAG_restrict_type";
9277 case DW_TAG_interface_type
:
9278 return "DW_TAG_interface_type";
9279 case DW_TAG_namespace
:
9280 return "DW_TAG_namespace";
9281 case DW_TAG_imported_module
:
9282 return "DW_TAG_imported_module";
9283 case DW_TAG_unspecified_type
:
9284 return "DW_TAG_unspecified_type";
9285 case DW_TAG_partial_unit
:
9286 return "DW_TAG_partial_unit";
9287 case DW_TAG_imported_unit
:
9288 return "DW_TAG_imported_unit";
9289 case DW_TAG_condition
:
9290 return "DW_TAG_condition";
9291 case DW_TAG_shared_type
:
9292 return "DW_TAG_shared_type";
9293 case DW_TAG_type_unit
:
9294 return "DW_TAG_type_unit";
9295 case DW_TAG_MIPS_loop
:
9296 return "DW_TAG_MIPS_loop";
9297 case DW_TAG_HP_array_descriptor
:
9298 return "DW_TAG_HP_array_descriptor";
9299 case DW_TAG_format_label
:
9300 return "DW_TAG_format_label";
9301 case DW_TAG_function_template
:
9302 return "DW_TAG_function_template";
9303 case DW_TAG_class_template
:
9304 return "DW_TAG_class_template";
9305 case DW_TAG_GNU_BINCL
:
9306 return "DW_TAG_GNU_BINCL";
9307 case DW_TAG_GNU_EINCL
:
9308 return "DW_TAG_GNU_EINCL";
9309 case DW_TAG_upc_shared_type
:
9310 return "DW_TAG_upc_shared_type";
9311 case DW_TAG_upc_strict_type
:
9312 return "DW_TAG_upc_strict_type";
9313 case DW_TAG_upc_relaxed_type
:
9314 return "DW_TAG_upc_relaxed_type";
9315 case DW_TAG_PGI_kanji_type
:
9316 return "DW_TAG_PGI_kanji_type";
9317 case DW_TAG_PGI_interface_block
:
9318 return "DW_TAG_PGI_interface_block";
9320 return "DW_TAG_<unknown>";
9324 /* Convert a DWARF attribute code into its string name. */
9327 dwarf_attr_name (unsigned attr
)
9332 return "DW_AT_sibling";
9333 case DW_AT_location
:
9334 return "DW_AT_location";
9336 return "DW_AT_name";
9337 case DW_AT_ordering
:
9338 return "DW_AT_ordering";
9339 case DW_AT_subscr_data
:
9340 return "DW_AT_subscr_data";
9341 case DW_AT_byte_size
:
9342 return "DW_AT_byte_size";
9343 case DW_AT_bit_offset
:
9344 return "DW_AT_bit_offset";
9345 case DW_AT_bit_size
:
9346 return "DW_AT_bit_size";
9347 case DW_AT_element_list
:
9348 return "DW_AT_element_list";
9349 case DW_AT_stmt_list
:
9350 return "DW_AT_stmt_list";
9352 return "DW_AT_low_pc";
9354 return "DW_AT_high_pc";
9355 case DW_AT_language
:
9356 return "DW_AT_language";
9358 return "DW_AT_member";
9360 return "DW_AT_discr";
9361 case DW_AT_discr_value
:
9362 return "DW_AT_discr_value";
9363 case DW_AT_visibility
:
9364 return "DW_AT_visibility";
9366 return "DW_AT_import";
9367 case DW_AT_string_length
:
9368 return "DW_AT_string_length";
9369 case DW_AT_common_reference
:
9370 return "DW_AT_common_reference";
9371 case DW_AT_comp_dir
:
9372 return "DW_AT_comp_dir";
9373 case DW_AT_const_value
:
9374 return "DW_AT_const_value";
9375 case DW_AT_containing_type
:
9376 return "DW_AT_containing_type";
9377 case DW_AT_default_value
:
9378 return "DW_AT_default_value";
9380 return "DW_AT_inline";
9381 case DW_AT_is_optional
:
9382 return "DW_AT_is_optional";
9383 case DW_AT_lower_bound
:
9384 return "DW_AT_lower_bound";
9385 case DW_AT_producer
:
9386 return "DW_AT_producer";
9387 case DW_AT_prototyped
:
9388 return "DW_AT_prototyped";
9389 case DW_AT_return_addr
:
9390 return "DW_AT_return_addr";
9391 case DW_AT_start_scope
:
9392 return "DW_AT_start_scope";
9393 case DW_AT_bit_stride
:
9394 return "DW_AT_bit_stride";
9395 case DW_AT_upper_bound
:
9396 return "DW_AT_upper_bound";
9397 case DW_AT_abstract_origin
:
9398 return "DW_AT_abstract_origin";
9399 case DW_AT_accessibility
:
9400 return "DW_AT_accessibility";
9401 case DW_AT_address_class
:
9402 return "DW_AT_address_class";
9403 case DW_AT_artificial
:
9404 return "DW_AT_artificial";
9405 case DW_AT_base_types
:
9406 return "DW_AT_base_types";
9407 case DW_AT_calling_convention
:
9408 return "DW_AT_calling_convention";
9410 return "DW_AT_count";
9411 case DW_AT_data_member_location
:
9412 return "DW_AT_data_member_location";
9413 case DW_AT_decl_column
:
9414 return "DW_AT_decl_column";
9415 case DW_AT_decl_file
:
9416 return "DW_AT_decl_file";
9417 case DW_AT_decl_line
:
9418 return "DW_AT_decl_line";
9419 case DW_AT_declaration
:
9420 return "DW_AT_declaration";
9421 case DW_AT_discr_list
:
9422 return "DW_AT_discr_list";
9423 case DW_AT_encoding
:
9424 return "DW_AT_encoding";
9425 case DW_AT_external
:
9426 return "DW_AT_external";
9427 case DW_AT_frame_base
:
9428 return "DW_AT_frame_base";
9430 return "DW_AT_friend";
9431 case DW_AT_identifier_case
:
9432 return "DW_AT_identifier_case";
9433 case DW_AT_macro_info
:
9434 return "DW_AT_macro_info";
9435 case DW_AT_namelist_items
:
9436 return "DW_AT_namelist_items";
9437 case DW_AT_priority
:
9438 return "DW_AT_priority";
9440 return "DW_AT_segment";
9441 case DW_AT_specification
:
9442 return "DW_AT_specification";
9443 case DW_AT_static_link
:
9444 return "DW_AT_static_link";
9446 return "DW_AT_type";
9447 case DW_AT_use_location
:
9448 return "DW_AT_use_location";
9449 case DW_AT_variable_parameter
:
9450 return "DW_AT_variable_parameter";
9451 case DW_AT_virtuality
:
9452 return "DW_AT_virtuality";
9453 case DW_AT_vtable_elem_location
:
9454 return "DW_AT_vtable_elem_location";
9455 /* DWARF 3 values. */
9456 case DW_AT_allocated
:
9457 return "DW_AT_allocated";
9458 case DW_AT_associated
:
9459 return "DW_AT_associated";
9460 case DW_AT_data_location
:
9461 return "DW_AT_data_location";
9462 case DW_AT_byte_stride
:
9463 return "DW_AT_byte_stride";
9464 case DW_AT_entry_pc
:
9465 return "DW_AT_entry_pc";
9466 case DW_AT_use_UTF8
:
9467 return "DW_AT_use_UTF8";
9468 case DW_AT_extension
:
9469 return "DW_AT_extension";
9471 return "DW_AT_ranges";
9472 case DW_AT_trampoline
:
9473 return "DW_AT_trampoline";
9474 case DW_AT_call_column
:
9475 return "DW_AT_call_column";
9476 case DW_AT_call_file
:
9477 return "DW_AT_call_file";
9478 case DW_AT_call_line
:
9479 return "DW_AT_call_line";
9480 case DW_AT_description
:
9481 return "DW_AT_description";
9482 case DW_AT_binary_scale
:
9483 return "DW_AT_binary_scale";
9484 case DW_AT_decimal_scale
:
9485 return "DW_AT_decimal_scale";
9487 return "DW_AT_small";
9488 case DW_AT_decimal_sign
:
9489 return "DW_AT_decimal_sign";
9490 case DW_AT_digit_count
:
9491 return "DW_AT_digit_count";
9492 case DW_AT_picture_string
:
9493 return "DW_AT_picture_string";
9495 return "DW_AT_mutable";
9496 case DW_AT_threads_scaled
:
9497 return "DW_AT_threads_scaled";
9498 case DW_AT_explicit
:
9499 return "DW_AT_explicit";
9500 case DW_AT_object_pointer
:
9501 return "DW_AT_object_pointer";
9502 case DW_AT_endianity
:
9503 return "DW_AT_endianity";
9504 case DW_AT_elemental
:
9505 return "DW_AT_elemental";
9507 return "DW_AT_pure";
9508 case DW_AT_recursive
:
9509 return "DW_AT_recursive";
9510 /* DWARF 4 values. */
9511 case DW_AT_signature
:
9512 return "DW_AT_signature";
9513 /* SGI/MIPS extensions. */
9514 #ifdef MIPS /* collides with DW_AT_HP_block_index */
9515 case DW_AT_MIPS_fde
:
9516 return "DW_AT_MIPS_fde";
9518 case DW_AT_MIPS_loop_begin
:
9519 return "DW_AT_MIPS_loop_begin";
9520 case DW_AT_MIPS_tail_loop_begin
:
9521 return "DW_AT_MIPS_tail_loop_begin";
9522 case DW_AT_MIPS_epilog_begin
:
9523 return "DW_AT_MIPS_epilog_begin";
9524 case DW_AT_MIPS_loop_unroll_factor
:
9525 return "DW_AT_MIPS_loop_unroll_factor";
9526 case DW_AT_MIPS_software_pipeline_depth
:
9527 return "DW_AT_MIPS_software_pipeline_depth";
9528 case DW_AT_MIPS_linkage_name
:
9529 return "DW_AT_MIPS_linkage_name";
9530 case DW_AT_MIPS_stride
:
9531 return "DW_AT_MIPS_stride";
9532 case DW_AT_MIPS_abstract_name
:
9533 return "DW_AT_MIPS_abstract_name";
9534 case DW_AT_MIPS_clone_origin
:
9535 return "DW_AT_MIPS_clone_origin";
9536 case DW_AT_MIPS_has_inlines
:
9537 return "DW_AT_MIPS_has_inlines";
9538 /* HP extensions. */
9539 #ifndef MIPS /* collides with DW_AT_MIPS_fde */
9540 case DW_AT_HP_block_index
:
9541 return "DW_AT_HP_block_index";
9543 case DW_AT_HP_unmodifiable
:
9544 return "DW_AT_HP_unmodifiable";
9545 case DW_AT_HP_actuals_stmt_list
:
9546 return "DW_AT_HP_actuals_stmt_list";
9547 case DW_AT_HP_proc_per_section
:
9548 return "DW_AT_HP_proc_per_section";
9549 case DW_AT_HP_raw_data_ptr
:
9550 return "DW_AT_HP_raw_data_ptr";
9551 case DW_AT_HP_pass_by_reference
:
9552 return "DW_AT_HP_pass_by_reference";
9553 case DW_AT_HP_opt_level
:
9554 return "DW_AT_HP_opt_level";
9555 case DW_AT_HP_prof_version_id
:
9556 return "DW_AT_HP_prof_version_id";
9557 case DW_AT_HP_opt_flags
:
9558 return "DW_AT_HP_opt_flags";
9559 case DW_AT_HP_cold_region_low_pc
:
9560 return "DW_AT_HP_cold_region_low_pc";
9561 case DW_AT_HP_cold_region_high_pc
:
9562 return "DW_AT_HP_cold_region_high_pc";
9563 case DW_AT_HP_all_variables_modifiable
:
9564 return "DW_AT_HP_all_variables_modifiable";
9565 case DW_AT_HP_linkage_name
:
9566 return "DW_AT_HP_linkage_name";
9567 case DW_AT_HP_prof_flags
:
9568 return "DW_AT_HP_prof_flags";
9569 /* GNU extensions. */
9570 case DW_AT_sf_names
:
9571 return "DW_AT_sf_names";
9572 case DW_AT_src_info
:
9573 return "DW_AT_src_info";
9574 case DW_AT_mac_info
:
9575 return "DW_AT_mac_info";
9576 case DW_AT_src_coords
:
9577 return "DW_AT_src_coords";
9578 case DW_AT_body_begin
:
9579 return "DW_AT_body_begin";
9580 case DW_AT_body_end
:
9581 return "DW_AT_body_end";
9582 case DW_AT_GNU_vector
:
9583 return "DW_AT_GNU_vector";
9584 /* VMS extensions. */
9585 case DW_AT_VMS_rtnbeg_pd_address
:
9586 return "DW_AT_VMS_rtnbeg_pd_address";
9587 /* UPC extension. */
9588 case DW_AT_upc_threads_scaled
:
9589 return "DW_AT_upc_threads_scaled";
9590 /* PGI (STMicroelectronics) extensions. */
9591 case DW_AT_PGI_lbase
:
9592 return "DW_AT_PGI_lbase";
9593 case DW_AT_PGI_soffset
:
9594 return "DW_AT_PGI_soffset";
9595 case DW_AT_PGI_lstride
:
9596 return "DW_AT_PGI_lstride";
9598 return "DW_AT_<unknown>";
9602 /* Convert a DWARF value form code into its string name. */
9605 dwarf_form_name (unsigned form
)
9610 return "DW_FORM_addr";
9611 case DW_FORM_block2
:
9612 return "DW_FORM_block2";
9613 case DW_FORM_block4
:
9614 return "DW_FORM_block4";
9616 return "DW_FORM_data2";
9618 return "DW_FORM_data4";
9620 return "DW_FORM_data8";
9621 case DW_FORM_string
:
9622 return "DW_FORM_string";
9624 return "DW_FORM_block";
9625 case DW_FORM_block1
:
9626 return "DW_FORM_block1";
9628 return "DW_FORM_data1";
9630 return "DW_FORM_flag";
9632 return "DW_FORM_sdata";
9634 return "DW_FORM_strp";
9636 return "DW_FORM_udata";
9637 case DW_FORM_ref_addr
:
9638 return "DW_FORM_ref_addr";
9640 return "DW_FORM_ref1";
9642 return "DW_FORM_ref2";
9644 return "DW_FORM_ref4";
9646 return "DW_FORM_ref8";
9647 case DW_FORM_ref_udata
:
9648 return "DW_FORM_ref_udata";
9649 case DW_FORM_indirect
:
9650 return "DW_FORM_indirect";
9651 case DW_FORM_sec_offset
:
9652 return "DW_FORM_sec_offset";
9653 case DW_FORM_exprloc
:
9654 return "DW_FORM_exprloc";
9655 case DW_FORM_flag_present
:
9656 return "DW_FORM_flag_present";
9658 return "DW_FORM_sig8";
9660 return "DW_FORM_<unknown>";
9664 /* Convert a DWARF stack opcode into its string name. */
9667 dwarf_stack_op_name (unsigned op
)
9672 return "DW_OP_addr";
9674 return "DW_OP_deref";
9676 return "DW_OP_const1u";
9678 return "DW_OP_const1s";
9680 return "DW_OP_const2u";
9682 return "DW_OP_const2s";
9684 return "DW_OP_const4u";
9686 return "DW_OP_const4s";
9688 return "DW_OP_const8u";
9690 return "DW_OP_const8s";
9692 return "DW_OP_constu";
9694 return "DW_OP_consts";
9698 return "DW_OP_drop";
9700 return "DW_OP_over";
9702 return "DW_OP_pick";
9704 return "DW_OP_swap";
9708 return "DW_OP_xderef";
9716 return "DW_OP_minus";
9728 return "DW_OP_plus";
9729 case DW_OP_plus_uconst
:
9730 return "DW_OP_plus_uconst";
9736 return "DW_OP_shra";
9754 return "DW_OP_skip";
9756 return "DW_OP_lit0";
9758 return "DW_OP_lit1";
9760 return "DW_OP_lit2";
9762 return "DW_OP_lit3";
9764 return "DW_OP_lit4";
9766 return "DW_OP_lit5";
9768 return "DW_OP_lit6";
9770 return "DW_OP_lit7";
9772 return "DW_OP_lit8";
9774 return "DW_OP_lit9";
9776 return "DW_OP_lit10";
9778 return "DW_OP_lit11";
9780 return "DW_OP_lit12";
9782 return "DW_OP_lit13";
9784 return "DW_OP_lit14";
9786 return "DW_OP_lit15";
9788 return "DW_OP_lit16";
9790 return "DW_OP_lit17";
9792 return "DW_OP_lit18";
9794 return "DW_OP_lit19";
9796 return "DW_OP_lit20";
9798 return "DW_OP_lit21";
9800 return "DW_OP_lit22";
9802 return "DW_OP_lit23";
9804 return "DW_OP_lit24";
9806 return "DW_OP_lit25";
9808 return "DW_OP_lit26";
9810 return "DW_OP_lit27";
9812 return "DW_OP_lit28";
9814 return "DW_OP_lit29";
9816 return "DW_OP_lit30";
9818 return "DW_OP_lit31";
9820 return "DW_OP_reg0";
9822 return "DW_OP_reg1";
9824 return "DW_OP_reg2";
9826 return "DW_OP_reg3";
9828 return "DW_OP_reg4";
9830 return "DW_OP_reg5";
9832 return "DW_OP_reg6";
9834 return "DW_OP_reg7";
9836 return "DW_OP_reg8";
9838 return "DW_OP_reg9";
9840 return "DW_OP_reg10";
9842 return "DW_OP_reg11";
9844 return "DW_OP_reg12";
9846 return "DW_OP_reg13";
9848 return "DW_OP_reg14";
9850 return "DW_OP_reg15";
9852 return "DW_OP_reg16";
9854 return "DW_OP_reg17";
9856 return "DW_OP_reg18";
9858 return "DW_OP_reg19";
9860 return "DW_OP_reg20";
9862 return "DW_OP_reg21";
9864 return "DW_OP_reg22";
9866 return "DW_OP_reg23";
9868 return "DW_OP_reg24";
9870 return "DW_OP_reg25";
9872 return "DW_OP_reg26";
9874 return "DW_OP_reg27";
9876 return "DW_OP_reg28";
9878 return "DW_OP_reg29";
9880 return "DW_OP_reg30";
9882 return "DW_OP_reg31";
9884 return "DW_OP_breg0";
9886 return "DW_OP_breg1";
9888 return "DW_OP_breg2";
9890 return "DW_OP_breg3";
9892 return "DW_OP_breg4";
9894 return "DW_OP_breg5";
9896 return "DW_OP_breg6";
9898 return "DW_OP_breg7";
9900 return "DW_OP_breg8";
9902 return "DW_OP_breg9";
9904 return "DW_OP_breg10";
9906 return "DW_OP_breg11";
9908 return "DW_OP_breg12";
9910 return "DW_OP_breg13";
9912 return "DW_OP_breg14";
9914 return "DW_OP_breg15";
9916 return "DW_OP_breg16";
9918 return "DW_OP_breg17";
9920 return "DW_OP_breg18";
9922 return "DW_OP_breg19";
9924 return "DW_OP_breg20";
9926 return "DW_OP_breg21";
9928 return "DW_OP_breg22";
9930 return "DW_OP_breg23";
9932 return "DW_OP_breg24";
9934 return "DW_OP_breg25";
9936 return "DW_OP_breg26";
9938 return "DW_OP_breg27";
9940 return "DW_OP_breg28";
9942 return "DW_OP_breg29";
9944 return "DW_OP_breg30";
9946 return "DW_OP_breg31";
9948 return "DW_OP_regx";
9950 return "DW_OP_fbreg";
9952 return "DW_OP_bregx";
9954 return "DW_OP_piece";
9955 case DW_OP_deref_size
:
9956 return "DW_OP_deref_size";
9957 case DW_OP_xderef_size
:
9958 return "DW_OP_xderef_size";
9961 /* DWARF 3 extensions. */
9962 case DW_OP_push_object_address
:
9963 return "DW_OP_push_object_address";
9965 return "DW_OP_call2";
9967 return "DW_OP_call4";
9968 case DW_OP_call_ref
:
9969 return "DW_OP_call_ref";
9970 /* GNU extensions. */
9971 case DW_OP_form_tls_address
:
9972 return "DW_OP_form_tls_address";
9973 case DW_OP_call_frame_cfa
:
9974 return "DW_OP_call_frame_cfa";
9975 case DW_OP_bit_piece
:
9976 return "DW_OP_bit_piece";
9977 case DW_OP_GNU_push_tls_address
:
9978 return "DW_OP_GNU_push_tls_address";
9979 case DW_OP_GNU_uninit
:
9980 return "DW_OP_GNU_uninit";
9981 /* HP extensions. */
9982 case DW_OP_HP_is_value
:
9983 return "DW_OP_HP_is_value";
9984 case DW_OP_HP_fltconst4
:
9985 return "DW_OP_HP_fltconst4";
9986 case DW_OP_HP_fltconst8
:
9987 return "DW_OP_HP_fltconst8";
9988 case DW_OP_HP_mod_range
:
9989 return "DW_OP_HP_mod_range";
9990 case DW_OP_HP_unmod_range
:
9991 return "DW_OP_HP_unmod_range";
9993 return "DW_OP_HP_tls";
9995 return "OP_<unknown>";
10000 dwarf_bool_name (unsigned mybool
)
10008 /* Convert a DWARF type code into its string name. */
10011 dwarf_type_encoding_name (unsigned enc
)
10016 return "DW_ATE_void";
10017 case DW_ATE_address
:
10018 return "DW_ATE_address";
10019 case DW_ATE_boolean
:
10020 return "DW_ATE_boolean";
10021 case DW_ATE_complex_float
:
10022 return "DW_ATE_complex_float";
10024 return "DW_ATE_float";
10025 case DW_ATE_signed
:
10026 return "DW_ATE_signed";
10027 case DW_ATE_signed_char
:
10028 return "DW_ATE_signed_char";
10029 case DW_ATE_unsigned
:
10030 return "DW_ATE_unsigned";
10031 case DW_ATE_unsigned_char
:
10032 return "DW_ATE_unsigned_char";
10034 case DW_ATE_imaginary_float
:
10035 return "DW_ATE_imaginary_float";
10036 case DW_ATE_packed_decimal
:
10037 return "DW_ATE_packed_decimal";
10038 case DW_ATE_numeric_string
:
10039 return "DW_ATE_numeric_string";
10040 case DW_ATE_edited
:
10041 return "DW_ATE_edited";
10042 case DW_ATE_signed_fixed
:
10043 return "DW_ATE_signed_fixed";
10044 case DW_ATE_unsigned_fixed
:
10045 return "DW_ATE_unsigned_fixed";
10046 case DW_ATE_decimal_float
:
10047 return "DW_ATE_decimal_float";
10048 /* HP extensions. */
10049 case DW_ATE_HP_float80
:
10050 return "DW_ATE_HP_float80";
10051 case DW_ATE_HP_complex_float80
:
10052 return "DW_ATE_HP_complex_float80";
10053 case DW_ATE_HP_float128
:
10054 return "DW_ATE_HP_float128";
10055 case DW_ATE_HP_complex_float128
:
10056 return "DW_ATE_HP_complex_float128";
10057 case DW_ATE_HP_floathpintel
:
10058 return "DW_ATE_HP_floathpintel";
10059 case DW_ATE_HP_imaginary_float80
:
10060 return "DW_ATE_HP_imaginary_float80";
10061 case DW_ATE_HP_imaginary_float128
:
10062 return "DW_ATE_HP_imaginary_float128";
10064 return "DW_ATE_<unknown>";
10068 /* Convert a DWARF call frame info operation to its string name. */
10072 dwarf_cfi_name (unsigned cfi_opc
)
10076 case DW_CFA_advance_loc
:
10077 return "DW_CFA_advance_loc";
10078 case DW_CFA_offset
:
10079 return "DW_CFA_offset";
10080 case DW_CFA_restore
:
10081 return "DW_CFA_restore";
10083 return "DW_CFA_nop";
10084 case DW_CFA_set_loc
:
10085 return "DW_CFA_set_loc";
10086 case DW_CFA_advance_loc1
:
10087 return "DW_CFA_advance_loc1";
10088 case DW_CFA_advance_loc2
:
10089 return "DW_CFA_advance_loc2";
10090 case DW_CFA_advance_loc4
:
10091 return "DW_CFA_advance_loc4";
10092 case DW_CFA_offset_extended
:
10093 return "DW_CFA_offset_extended";
10094 case DW_CFA_restore_extended
:
10095 return "DW_CFA_restore_extended";
10096 case DW_CFA_undefined
:
10097 return "DW_CFA_undefined";
10098 case DW_CFA_same_value
:
10099 return "DW_CFA_same_value";
10100 case DW_CFA_register
:
10101 return "DW_CFA_register";
10102 case DW_CFA_remember_state
:
10103 return "DW_CFA_remember_state";
10104 case DW_CFA_restore_state
:
10105 return "DW_CFA_restore_state";
10106 case DW_CFA_def_cfa
:
10107 return "DW_CFA_def_cfa";
10108 case DW_CFA_def_cfa_register
:
10109 return "DW_CFA_def_cfa_register";
10110 case DW_CFA_def_cfa_offset
:
10111 return "DW_CFA_def_cfa_offset";
10113 case DW_CFA_def_cfa_expression
:
10114 return "DW_CFA_def_cfa_expression";
10115 case DW_CFA_expression
:
10116 return "DW_CFA_expression";
10117 case DW_CFA_offset_extended_sf
:
10118 return "DW_CFA_offset_extended_sf";
10119 case DW_CFA_def_cfa_sf
:
10120 return "DW_CFA_def_cfa_sf";
10121 case DW_CFA_def_cfa_offset_sf
:
10122 return "DW_CFA_def_cfa_offset_sf";
10123 case DW_CFA_val_offset
:
10124 return "DW_CFA_val_offset";
10125 case DW_CFA_val_offset_sf
:
10126 return "DW_CFA_val_offset_sf";
10127 case DW_CFA_val_expression
:
10128 return "DW_CFA_val_expression";
10129 /* SGI/MIPS specific. */
10130 case DW_CFA_MIPS_advance_loc8
:
10131 return "DW_CFA_MIPS_advance_loc8";
10132 /* GNU extensions. */
10133 case DW_CFA_GNU_window_save
:
10134 return "DW_CFA_GNU_window_save";
10135 case DW_CFA_GNU_args_size
:
10136 return "DW_CFA_GNU_args_size";
10137 case DW_CFA_GNU_negative_offset_extended
:
10138 return "DW_CFA_GNU_negative_offset_extended";
10140 return "DW_CFA_<unknown>";
10146 dump_die_shallow (struct ui_file
*f
, int indent
, struct die_info
*die
)
10150 print_spaces (indent
, f
);
10151 fprintf_unfiltered (f
, "Die: %s (abbrev %d, offset 0x%x)\n",
10152 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
10154 if (die
->parent
!= NULL
)
10156 print_spaces (indent
, f
);
10157 fprintf_unfiltered (f
, " parent at offset: 0x%x\n",
10158 die
->parent
->offset
);
10161 print_spaces (indent
, f
);
10162 fprintf_unfiltered (f
, " has children: %s\n",
10163 dwarf_bool_name (die
->child
!= NULL
));
10165 print_spaces (indent
, f
);
10166 fprintf_unfiltered (f
, " attributes:\n");
10168 for (i
= 0; i
< die
->num_attrs
; ++i
)
10170 print_spaces (indent
, f
);
10171 fprintf_unfiltered (f
, " %s (%s) ",
10172 dwarf_attr_name (die
->attrs
[i
].name
),
10173 dwarf_form_name (die
->attrs
[i
].form
));
10175 switch (die
->attrs
[i
].form
)
10177 case DW_FORM_ref_addr
:
10179 fprintf_unfiltered (f
, "address: ");
10180 fputs_filtered (hex_string (DW_ADDR (&die
->attrs
[i
])), f
);
10182 case DW_FORM_block2
:
10183 case DW_FORM_block4
:
10184 case DW_FORM_block
:
10185 case DW_FORM_block1
:
10186 fprintf_unfiltered (f
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
10191 fprintf_unfiltered (f
, "constant ref: 0x%lx (adjusted)",
10192 (long) (DW_ADDR (&die
->attrs
[i
])));
10194 case DW_FORM_data1
:
10195 case DW_FORM_data2
:
10196 case DW_FORM_data4
:
10197 case DW_FORM_data8
:
10198 case DW_FORM_udata
:
10199 case DW_FORM_sdata
:
10200 fprintf_unfiltered (f
, "constant: %s",
10201 pulongest (DW_UNSND (&die
->attrs
[i
])));
10204 if (DW_SIGNATURED_TYPE (&die
->attrs
[i
]) != NULL
)
10205 fprintf_unfiltered (f
, "signatured type, offset: 0x%x",
10206 DW_SIGNATURED_TYPE (&die
->attrs
[i
])->offset
);
10208 fprintf_unfiltered (f
, "signatured type, offset: unknown");
10210 case DW_FORM_string
:
10212 fprintf_unfiltered (f
, "string: \"%s\" (%s canonicalized)",
10213 DW_STRING (&die
->attrs
[i
])
10214 ? DW_STRING (&die
->attrs
[i
]) : "",
10215 DW_STRING_IS_CANONICAL (&die
->attrs
[i
]) ? "is" : "not");
10218 if (DW_UNSND (&die
->attrs
[i
]))
10219 fprintf_unfiltered (f
, "flag: TRUE");
10221 fprintf_unfiltered (f
, "flag: FALSE");
10223 case DW_FORM_indirect
:
10224 /* the reader will have reduced the indirect form to
10225 the "base form" so this form should not occur */
10226 fprintf_unfiltered (f
, "unexpected attribute form: DW_FORM_indirect");
10229 fprintf_unfiltered (f
, "unsupported attribute form: %d.",
10230 die
->attrs
[i
].form
);
10233 fprintf_unfiltered (f
, "\n");
10238 dump_die_for_error (struct die_info
*die
)
10240 dump_die_shallow (gdb_stderr
, 0, die
);
10244 dump_die_1 (struct ui_file
*f
, int level
, int max_level
, struct die_info
*die
)
10246 int indent
= level
* 4;
10248 gdb_assert (die
!= NULL
);
10250 if (level
>= max_level
)
10253 dump_die_shallow (f
, indent
, die
);
10255 if (die
->child
!= NULL
)
10257 print_spaces (indent
, f
);
10258 fprintf_unfiltered (f
, " Children:");
10259 if (level
+ 1 < max_level
)
10261 fprintf_unfiltered (f
, "\n");
10262 dump_die_1 (f
, level
+ 1, max_level
, die
->child
);
10266 fprintf_unfiltered (f
, " [not printed, max nesting level reached]\n");
10270 if (die
->sibling
!= NULL
&& level
> 0)
10272 dump_die_1 (f
, level
, max_level
, die
->sibling
);
10276 /* This is called from the pdie macro in gdbinit.in.
10277 It's not static so gcc will keep a copy callable from gdb. */
10280 dump_die (struct die_info
*die
, int max_level
)
10282 dump_die_1 (gdb_stdlog
, 0, max_level
, die
);
10286 store_in_ref_table (struct die_info
*die
, struct dwarf2_cu
*cu
)
10290 slot
= htab_find_slot_with_hash (cu
->die_hash
, die
, die
->offset
, INSERT
);
10296 is_ref_attr (struct attribute
*attr
)
10298 switch (attr
->form
)
10300 case DW_FORM_ref_addr
:
10305 case DW_FORM_ref_udata
:
10312 static unsigned int
10313 dwarf2_get_ref_die_offset (struct attribute
*attr
)
10315 if (is_ref_attr (attr
))
10316 return DW_ADDR (attr
);
10318 complaint (&symfile_complaints
,
10319 _("unsupported die ref attribute form: '%s'"),
10320 dwarf_form_name (attr
->form
));
10324 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
10325 * the value held by the attribute is not constant. */
10328 dwarf2_get_attr_constant_value (struct attribute
*attr
, int default_value
)
10330 if (attr
->form
== DW_FORM_sdata
)
10331 return DW_SND (attr
);
10332 else if (attr
->form
== DW_FORM_udata
10333 || attr
->form
== DW_FORM_data1
10334 || attr
->form
== DW_FORM_data2
10335 || attr
->form
== DW_FORM_data4
10336 || attr
->form
== DW_FORM_data8
)
10337 return DW_UNSND (attr
);
10340 complaint (&symfile_complaints
, _("Attribute value is not a constant (%s)"),
10341 dwarf_form_name (attr
->form
));
10342 return default_value
;
10346 /* THIS_CU has a reference to PER_CU. If necessary, load the new compilation
10347 unit and add it to our queue.
10348 The result is non-zero if PER_CU was queued, otherwise the result is zero
10349 meaning either PER_CU is already queued or it is already loaded. */
10352 maybe_queue_comp_unit (struct dwarf2_cu
*this_cu
,
10353 struct dwarf2_per_cu_data
*per_cu
)
10355 /* Mark the dependence relation so that we don't flush PER_CU
10357 dwarf2_add_dependence (this_cu
, per_cu
);
10359 /* If it's already on the queue, we have nothing to do. */
10360 if (per_cu
->queued
)
10363 /* If the compilation unit is already loaded, just mark it as
10365 if (per_cu
->cu
!= NULL
)
10367 per_cu
->cu
->last_used
= 0;
10371 /* Add it to the queue. */
10372 queue_comp_unit (per_cu
, this_cu
->objfile
);
10377 /* Follow reference or signature attribute ATTR of SRC_DIE.
10378 On entry *REF_CU is the CU of SRC_DIE.
10379 On exit *REF_CU is the CU of the result. */
10381 static struct die_info
*
10382 follow_die_ref_or_sig (struct die_info
*src_die
, struct attribute
*attr
,
10383 struct dwarf2_cu
**ref_cu
)
10385 struct die_info
*die
;
10387 if (is_ref_attr (attr
))
10388 die
= follow_die_ref (src_die
, attr
, ref_cu
);
10389 else if (attr
->form
== DW_FORM_sig8
)
10390 die
= follow_die_sig (src_die
, attr
, ref_cu
);
10393 dump_die_for_error (src_die
);
10394 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
10395 (*ref_cu
)->objfile
->name
);
10401 /* Follow reference attribute ATTR of SRC_DIE.
10402 On entry *REF_CU is the CU of SRC_DIE.
10403 On exit *REF_CU is the CU of the result. */
10405 static struct die_info
*
10406 follow_die_ref (struct die_info
*src_die
, struct attribute
*attr
,
10407 struct dwarf2_cu
**ref_cu
)
10409 struct die_info
*die
;
10410 unsigned int offset
;
10411 struct die_info temp_die
;
10412 struct dwarf2_cu
*target_cu
, *cu
= *ref_cu
;
10414 gdb_assert (cu
->per_cu
!= NULL
);
10416 offset
= dwarf2_get_ref_die_offset (attr
);
10418 if (cu
->per_cu
->from_debug_types
)
10420 /* .debug_types CUs cannot reference anything outside their CU.
10421 If they need to, they have to reference a signatured type via
10423 if (! offset_in_cu_p (&cu
->header
, offset
))
10427 else if (! offset_in_cu_p (&cu
->header
, offset
))
10429 struct dwarf2_per_cu_data
*per_cu
;
10430 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
10432 /* If necessary, add it to the queue and load its DIEs. */
10433 if (maybe_queue_comp_unit (cu
, per_cu
))
10434 load_full_comp_unit (per_cu
, cu
->objfile
);
10436 target_cu
= per_cu
->cu
;
10441 *ref_cu
= target_cu
;
10442 temp_die
.offset
= offset
;
10443 die
= htab_find_with_hash (target_cu
->die_hash
, &temp_die
, offset
);
10449 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced from DIE "
10450 "at 0x%x [in module %s]"),
10451 offset
, src_die
->offset
, cu
->objfile
->name
);
10454 /* Follow the signature attribute ATTR in SRC_DIE.
10455 On entry *REF_CU is the CU of SRC_DIE.
10456 On exit *REF_CU is the CU of the result. */
10458 static struct die_info
*
10459 follow_die_sig (struct die_info
*src_die
, struct attribute
*attr
,
10460 struct dwarf2_cu
**ref_cu
)
10462 struct objfile
*objfile
= (*ref_cu
)->objfile
;
10463 struct die_info temp_die
;
10464 struct signatured_type
*sig_type
= DW_SIGNATURED_TYPE (attr
);
10465 struct dwarf2_cu
*sig_cu
;
10466 struct die_info
*die
;
10468 /* sig_type will be NULL if the signatured type is missing from
10470 if (sig_type
== NULL
)
10471 error (_("Dwarf Error: Cannot find signatured DIE referenced from DIE "
10472 "at 0x%x [in module %s]"),
10473 src_die
->offset
, objfile
->name
);
10475 /* If necessary, add it to the queue and load its DIEs. */
10477 if (maybe_queue_comp_unit (*ref_cu
, &sig_type
->per_cu
))
10478 read_signatured_type (objfile
, sig_type
);
10480 gdb_assert (sig_type
->per_cu
.cu
!= NULL
);
10482 sig_cu
= sig_type
->per_cu
.cu
;
10483 temp_die
.offset
= sig_cu
->header
.offset
+ sig_type
->type_offset
;
10484 die
= htab_find_with_hash (sig_cu
->die_hash
, &temp_die
, temp_die
.offset
);
10491 error (_("Dwarf Error: Cannot find signatured DIE at 0x%x referenced from DIE "
10492 "at 0x%x [in module %s]"),
10493 sig_type
->type_offset
, src_die
->offset
, objfile
->name
);
10496 /* Given an offset of a signatured type, return its signatured_type. */
10498 static struct signatured_type
*
10499 lookup_signatured_type_at_offset (struct objfile
*objfile
, unsigned int offset
)
10501 gdb_byte
*info_ptr
= dwarf2_per_objfile
->types
.buffer
+ offset
;
10502 unsigned int length
, initial_length_size
;
10503 unsigned int sig_offset
;
10504 struct signatured_type find_entry
, *type_sig
;
10506 length
= read_initial_length (objfile
->obfd
, info_ptr
, &initial_length_size
);
10507 sig_offset
= (initial_length_size
10509 + (initial_length_size
== 4 ? 4 : 8) /*debug_abbrev_offset*/
10510 + 1 /*address_size*/);
10511 find_entry
.signature
= bfd_get_64 (objfile
->obfd
, info_ptr
+ sig_offset
);
10512 type_sig
= htab_find (dwarf2_per_objfile
->signatured_types
, &find_entry
);
10514 /* This is only used to lookup previously recorded types.
10515 If we didn't find it, it's our bug. */
10516 gdb_assert (type_sig
!= NULL
);
10517 gdb_assert (offset
== type_sig
->offset
);
10522 /* Read in signatured type at OFFSET and build its CU and die(s). */
10525 read_signatured_type_at_offset (struct objfile
*objfile
,
10526 unsigned int offset
)
10528 struct signatured_type
*type_sig
;
10530 /* We have the section offset, but we need the signature to do the
10531 hash table lookup. */
10532 type_sig
= lookup_signatured_type_at_offset (objfile
, offset
);
10534 gdb_assert (type_sig
->per_cu
.cu
== NULL
);
10536 read_signatured_type (objfile
, type_sig
);
10538 gdb_assert (type_sig
->per_cu
.cu
!= NULL
);
10541 /* Read in a signatured type and build its CU and DIEs. */
10544 read_signatured_type (struct objfile
*objfile
,
10545 struct signatured_type
*type_sig
)
10547 gdb_byte
*types_ptr
= dwarf2_per_objfile
->types
.buffer
+ type_sig
->offset
;
10548 struct die_reader_specs reader_specs
;
10549 struct dwarf2_cu
*cu
;
10550 ULONGEST signature
;
10551 struct cleanup
*back_to
, *free_cu_cleanup
;
10552 struct attribute
*attr
;
10554 gdb_assert (type_sig
->per_cu
.cu
== NULL
);
10556 cu
= xmalloc (sizeof (struct dwarf2_cu
));
10557 memset (cu
, 0, sizeof (struct dwarf2_cu
));
10558 obstack_init (&cu
->comp_unit_obstack
);
10559 cu
->objfile
= objfile
;
10560 type_sig
->per_cu
.cu
= cu
;
10561 cu
->per_cu
= &type_sig
->per_cu
;
10563 /* If an error occurs while loading, release our storage. */
10564 free_cu_cleanup
= make_cleanup (free_one_comp_unit
, cu
);
10566 types_ptr
= read_type_comp_unit_head (&cu
->header
, &signature
,
10567 types_ptr
, objfile
->obfd
);
10568 gdb_assert (signature
== type_sig
->signature
);
10571 = htab_create_alloc_ex (cu
->header
.length
/ 12,
10575 &cu
->comp_unit_obstack
,
10576 hashtab_obstack_allocate
,
10577 dummy_obstack_deallocate
);
10579 dwarf2_read_abbrevs (cu
->objfile
->obfd
, cu
);
10580 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
10582 init_cu_die_reader (&reader_specs
, cu
);
10584 cu
->dies
= read_die_and_children (&reader_specs
, types_ptr
, &types_ptr
,
10587 /* We try not to read any attributes in this function, because not
10588 all objfiles needed for references have been loaded yet, and symbol
10589 table processing isn't initialized. But we have to set the CU language,
10590 or we won't be able to build types correctly. */
10591 attr
= dwarf2_attr (cu
->dies
, DW_AT_language
, cu
);
10593 set_cu_language (DW_UNSND (attr
), cu
);
10595 set_cu_language (language_minimal
, cu
);
10597 do_cleanups (back_to
);
10599 /* We've successfully allocated this compilation unit. Let our caller
10600 clean it up when finished with it. */
10601 discard_cleanups (free_cu_cleanup
);
10603 type_sig
->per_cu
.cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
10604 dwarf2_per_objfile
->read_in_chain
= &type_sig
->per_cu
;
10607 /* Decode simple location descriptions.
10608 Given a pointer to a dwarf block that defines a location, compute
10609 the location and return the value.
10611 NOTE drow/2003-11-18: This function is called in two situations
10612 now: for the address of static or global variables (partial symbols
10613 only) and for offsets into structures which are expected to be
10614 (more or less) constant. The partial symbol case should go away,
10615 and only the constant case should remain. That will let this
10616 function complain more accurately. A few special modes are allowed
10617 without complaint for global variables (for instance, global
10618 register values and thread-local values).
10620 A location description containing no operations indicates that the
10621 object is optimized out. The return value is 0 for that case.
10622 FIXME drow/2003-11-16: No callers check for this case any more; soon all
10623 callers will only want a very basic result and this can become a
10626 Note that stack[0] is unused except as a default error return.
10627 Note that stack overflow is not yet handled. */
10630 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
10632 struct objfile
*objfile
= cu
->objfile
;
10633 struct comp_unit_head
*cu_header
= &cu
->header
;
10635 int size
= blk
->size
;
10636 gdb_byte
*data
= blk
->data
;
10637 CORE_ADDR stack
[64];
10639 unsigned int bytes_read
, unsnd
;
10683 stack
[++stacki
] = op
- DW_OP_lit0
;
10718 stack
[++stacki
] = op
- DW_OP_reg0
;
10720 dwarf2_complex_location_expr_complaint ();
10724 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
10726 stack
[++stacki
] = unsnd
;
10728 dwarf2_complex_location_expr_complaint ();
10732 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
10737 case DW_OP_const1u
:
10738 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
10742 case DW_OP_const1s
:
10743 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
10747 case DW_OP_const2u
:
10748 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
10752 case DW_OP_const2s
:
10753 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
10757 case DW_OP_const4u
:
10758 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
10762 case DW_OP_const4s
:
10763 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
10768 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
10774 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
10779 stack
[stacki
+ 1] = stack
[stacki
];
10784 stack
[stacki
- 1] += stack
[stacki
];
10788 case DW_OP_plus_uconst
:
10789 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
10794 stack
[stacki
- 1] -= stack
[stacki
];
10799 /* If we're not the last op, then we definitely can't encode
10800 this using GDB's address_class enum. This is valid for partial
10801 global symbols, although the variable's address will be bogus
10804 dwarf2_complex_location_expr_complaint ();
10807 case DW_OP_GNU_push_tls_address
:
10808 /* The top of the stack has the offset from the beginning
10809 of the thread control block at which the variable is located. */
10810 /* Nothing should follow this operator, so the top of stack would
10812 /* This is valid for partial global symbols, but the variable's
10813 address will be bogus in the psymtab. */
10815 dwarf2_complex_location_expr_complaint ();
10818 case DW_OP_GNU_uninit
:
10822 complaint (&symfile_complaints
, _("unsupported stack op: '%s'"),
10823 dwarf_stack_op_name (op
));
10824 return (stack
[stacki
]);
10827 return (stack
[stacki
]);
10830 /* memory allocation interface */
10832 static struct dwarf_block
*
10833 dwarf_alloc_block (struct dwarf2_cu
*cu
)
10835 struct dwarf_block
*blk
;
10837 blk
= (struct dwarf_block
*)
10838 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
10842 static struct abbrev_info
*
10843 dwarf_alloc_abbrev (struct dwarf2_cu
*cu
)
10845 struct abbrev_info
*abbrev
;
10847 abbrev
= (struct abbrev_info
*)
10848 obstack_alloc (&cu
->abbrev_obstack
, sizeof (struct abbrev_info
));
10849 memset (abbrev
, 0, sizeof (struct abbrev_info
));
10853 static struct die_info
*
10854 dwarf_alloc_die (struct dwarf2_cu
*cu
, int num_attrs
)
10856 struct die_info
*die
;
10857 size_t size
= sizeof (struct die_info
);
10860 size
+= (num_attrs
- 1) * sizeof (struct attribute
);
10862 die
= (struct die_info
*) obstack_alloc (&cu
->comp_unit_obstack
, size
);
10863 memset (die
, 0, sizeof (struct die_info
));
10868 /* Macro support. */
10871 /* Return the full name of file number I in *LH's file name table.
10872 Use COMP_DIR as the name of the current directory of the
10873 compilation. The result is allocated using xmalloc; the caller is
10874 responsible for freeing it. */
10876 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
10878 /* Is the file number a valid index into the line header's file name
10879 table? Remember that file numbers start with one, not zero. */
10880 if (1 <= file
&& file
<= lh
->num_file_names
)
10882 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
10884 if (IS_ABSOLUTE_PATH (fe
->name
))
10885 return xstrdup (fe
->name
);
10893 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
10899 dir_len
= strlen (dir
);
10900 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
10901 strcpy (full_name
, dir
);
10902 full_name
[dir_len
] = '/';
10903 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
10907 return xstrdup (fe
->name
);
10912 /* The compiler produced a bogus file number. We can at least
10913 record the macro definitions made in the file, even if we
10914 won't be able to find the file by name. */
10915 char fake_name
[80];
10916 sprintf (fake_name
, "<bad macro file number %d>", file
);
10918 complaint (&symfile_complaints
,
10919 _("bad file number in macro information (%d)"),
10922 return xstrdup (fake_name
);
10927 static struct macro_source_file
*
10928 macro_start_file (int file
, int line
,
10929 struct macro_source_file
*current_file
,
10930 const char *comp_dir
,
10931 struct line_header
*lh
, struct objfile
*objfile
)
10933 /* The full name of this source file. */
10934 char *full_name
= file_full_name (file
, lh
, comp_dir
);
10936 /* We don't create a macro table for this compilation unit
10937 at all until we actually get a filename. */
10938 if (! pending_macros
)
10939 pending_macros
= new_macro_table (&objfile
->objfile_obstack
,
10940 objfile
->macro_cache
);
10942 if (! current_file
)
10943 /* If we have no current file, then this must be the start_file
10944 directive for the compilation unit's main source file. */
10945 current_file
= macro_set_main (pending_macros
, full_name
);
10947 current_file
= macro_include (current_file
, line
, full_name
);
10951 return current_file
;
10955 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
10956 followed by a null byte. */
10958 copy_string (const char *buf
, int len
)
10960 char *s
= xmalloc (len
+ 1);
10961 memcpy (s
, buf
, len
);
10968 static const char *
10969 consume_improper_spaces (const char *p
, const char *body
)
10973 complaint (&symfile_complaints
,
10974 _("macro definition contains spaces in formal argument list:\n`%s'"),
10986 parse_macro_definition (struct macro_source_file
*file
, int line
,
10991 /* The body string takes one of two forms. For object-like macro
10992 definitions, it should be:
10994 <macro name> " " <definition>
10996 For function-like macro definitions, it should be:
10998 <macro name> "() " <definition>
11000 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
11002 Spaces may appear only where explicitly indicated, and in the
11005 The Dwarf 2 spec says that an object-like macro's name is always
11006 followed by a space, but versions of GCC around March 2002 omit
11007 the space when the macro's definition is the empty string.
11009 The Dwarf 2 spec says that there should be no spaces between the
11010 formal arguments in a function-like macro's formal argument list,
11011 but versions of GCC around March 2002 include spaces after the
11015 /* Find the extent of the macro name. The macro name is terminated
11016 by either a space or null character (for an object-like macro) or
11017 an opening paren (for a function-like macro). */
11018 for (p
= body
; *p
; p
++)
11019 if (*p
== ' ' || *p
== '(')
11022 if (*p
== ' ' || *p
== '\0')
11024 /* It's an object-like macro. */
11025 int name_len
= p
- body
;
11026 char *name
= copy_string (body
, name_len
);
11027 const char *replacement
;
11030 replacement
= body
+ name_len
+ 1;
11033 dwarf2_macro_malformed_definition_complaint (body
);
11034 replacement
= body
+ name_len
;
11037 macro_define_object (file
, line
, name
, replacement
);
11041 else if (*p
== '(')
11043 /* It's a function-like macro. */
11044 char *name
= copy_string (body
, p
- body
);
11047 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
11051 p
= consume_improper_spaces (p
, body
);
11053 /* Parse the formal argument list. */
11054 while (*p
&& *p
!= ')')
11056 /* Find the extent of the current argument name. */
11057 const char *arg_start
= p
;
11059 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
11062 if (! *p
|| p
== arg_start
)
11063 dwarf2_macro_malformed_definition_complaint (body
);
11066 /* Make sure argv has room for the new argument. */
11067 if (argc
>= argv_size
)
11070 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
11073 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
11076 p
= consume_improper_spaces (p
, body
);
11078 /* Consume the comma, if present. */
11083 p
= consume_improper_spaces (p
, body
);
11092 /* Perfectly formed definition, no complaints. */
11093 macro_define_function (file
, line
, name
,
11094 argc
, (const char **) argv
,
11096 else if (*p
== '\0')
11098 /* Complain, but do define it. */
11099 dwarf2_macro_malformed_definition_complaint (body
);
11100 macro_define_function (file
, line
, name
,
11101 argc
, (const char **) argv
,
11105 /* Just complain. */
11106 dwarf2_macro_malformed_definition_complaint (body
);
11109 /* Just complain. */
11110 dwarf2_macro_malformed_definition_complaint (body
);
11116 for (i
= 0; i
< argc
; i
++)
11122 dwarf2_macro_malformed_definition_complaint (body
);
11127 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
11128 char *comp_dir
, bfd
*abfd
,
11129 struct dwarf2_cu
*cu
)
11131 gdb_byte
*mac_ptr
, *mac_end
;
11132 struct macro_source_file
*current_file
= 0;
11133 enum dwarf_macinfo_record_type macinfo_type
;
11134 int at_commandline
;
11136 if (dwarf2_per_objfile
->macinfo
.buffer
== NULL
)
11138 complaint (&symfile_complaints
, _("missing .debug_macinfo section"));
11142 /* First pass: Find the name of the base filename.
11143 This filename is needed in order to process all macros whose definition
11144 (or undefinition) comes from the command line. These macros are defined
11145 before the first DW_MACINFO_start_file entry, and yet still need to be
11146 associated to the base file.
11148 To determine the base file name, we scan the macro definitions until we
11149 reach the first DW_MACINFO_start_file entry. We then initialize
11150 CURRENT_FILE accordingly so that any macro definition found before the
11151 first DW_MACINFO_start_file can still be associated to the base file. */
11153 mac_ptr
= dwarf2_per_objfile
->macinfo
.buffer
+ offset
;
11154 mac_end
= dwarf2_per_objfile
->macinfo
.buffer
11155 + dwarf2_per_objfile
->macinfo
.size
;
11159 /* Do we at least have room for a macinfo type byte? */
11160 if (mac_ptr
>= mac_end
)
11162 /* Complaint is printed during the second pass as GDB will probably
11163 stop the first pass earlier upon finding DW_MACINFO_start_file. */
11167 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
11170 switch (macinfo_type
)
11172 /* A zero macinfo type indicates the end of the macro
11177 case DW_MACINFO_define
:
11178 case DW_MACINFO_undef
:
11179 /* Only skip the data by MAC_PTR. */
11181 unsigned int bytes_read
;
11183 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
11184 mac_ptr
+= bytes_read
;
11185 read_string (abfd
, mac_ptr
, &bytes_read
);
11186 mac_ptr
+= bytes_read
;
11190 case DW_MACINFO_start_file
:
11192 unsigned int bytes_read
;
11195 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
11196 mac_ptr
+= bytes_read
;
11197 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
11198 mac_ptr
+= bytes_read
;
11200 current_file
= macro_start_file (file
, line
, current_file
, comp_dir
,
11205 case DW_MACINFO_end_file
:
11206 /* No data to skip by MAC_PTR. */
11209 case DW_MACINFO_vendor_ext
:
11210 /* Only skip the data by MAC_PTR. */
11212 unsigned int bytes_read
;
11214 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
11215 mac_ptr
+= bytes_read
;
11216 read_string (abfd
, mac_ptr
, &bytes_read
);
11217 mac_ptr
+= bytes_read
;
11224 } while (macinfo_type
!= 0 && current_file
== NULL
);
11226 /* Second pass: Process all entries.
11228 Use the AT_COMMAND_LINE flag to determine whether we are still processing
11229 command-line macro definitions/undefinitions. This flag is unset when we
11230 reach the first DW_MACINFO_start_file entry. */
11232 mac_ptr
= dwarf2_per_objfile
->macinfo
.buffer
+ offset
;
11234 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
11235 GDB is still reading the definitions from command line. First
11236 DW_MACINFO_start_file will need to be ignored as it was already executed
11237 to create CURRENT_FILE for the main source holding also the command line
11238 definitions. On first met DW_MACINFO_start_file this flag is reset to
11239 normally execute all the remaining DW_MACINFO_start_file macinfos. */
11241 at_commandline
= 1;
11245 /* Do we at least have room for a macinfo type byte? */
11246 if (mac_ptr
>= mac_end
)
11248 dwarf2_macros_too_long_complaint ();
11252 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
11255 switch (macinfo_type
)
11257 /* A zero macinfo type indicates the end of the macro
11262 case DW_MACINFO_define
:
11263 case DW_MACINFO_undef
:
11265 unsigned int bytes_read
;
11269 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
11270 mac_ptr
+= bytes_read
;
11271 body
= read_string (abfd
, mac_ptr
, &bytes_read
);
11272 mac_ptr
+= bytes_read
;
11274 if (! current_file
)
11276 /* DWARF violation as no main source is present. */
11277 complaint (&symfile_complaints
,
11278 _("debug info with no main source gives macro %s "
11280 macinfo_type
== DW_MACINFO_define
?
11282 macinfo_type
== DW_MACINFO_undef
?
11283 _("undefinition") :
11284 _("something-or-other"), line
, body
);
11287 if ((line
== 0 && !at_commandline
) || (line
!= 0 && at_commandline
))
11288 complaint (&symfile_complaints
,
11289 _("debug info gives %s macro %s with %s line %d: %s"),
11290 at_commandline
? _("command-line") : _("in-file"),
11291 macinfo_type
== DW_MACINFO_define
?
11293 macinfo_type
== DW_MACINFO_undef
?
11294 _("undefinition") :
11295 _("something-or-other"),
11296 line
== 0 ? _("zero") : _("non-zero"), line
, body
);
11298 if (macinfo_type
== DW_MACINFO_define
)
11299 parse_macro_definition (current_file
, line
, body
);
11300 else if (macinfo_type
== DW_MACINFO_undef
)
11301 macro_undef (current_file
, line
, body
);
11305 case DW_MACINFO_start_file
:
11307 unsigned int bytes_read
;
11310 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
11311 mac_ptr
+= bytes_read
;
11312 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
11313 mac_ptr
+= bytes_read
;
11315 if ((line
== 0 && !at_commandline
) || (line
!= 0 && at_commandline
))
11316 complaint (&symfile_complaints
,
11317 _("debug info gives source %d included "
11318 "from %s at %s line %d"),
11319 file
, at_commandline
? _("command-line") : _("file"),
11320 line
== 0 ? _("zero") : _("non-zero"), line
);
11322 if (at_commandline
)
11324 /* This DW_MACINFO_start_file was executed in the pass one. */
11325 at_commandline
= 0;
11328 current_file
= macro_start_file (file
, line
,
11329 current_file
, comp_dir
,
11334 case DW_MACINFO_end_file
:
11335 if (! current_file
)
11336 complaint (&symfile_complaints
,
11337 _("macro debug info has an unmatched `close_file' directive"));
11340 current_file
= current_file
->included_by
;
11341 if (! current_file
)
11343 enum dwarf_macinfo_record_type next_type
;
11345 /* GCC circa March 2002 doesn't produce the zero
11346 type byte marking the end of the compilation
11347 unit. Complain if it's not there, but exit no
11350 /* Do we at least have room for a macinfo type byte? */
11351 if (mac_ptr
>= mac_end
)
11353 dwarf2_macros_too_long_complaint ();
11357 /* We don't increment mac_ptr here, so this is just
11359 next_type
= read_1_byte (abfd
, mac_ptr
);
11360 if (next_type
!= 0)
11361 complaint (&symfile_complaints
,
11362 _("no terminating 0-type entry for macros in `.debug_macinfo' section"));
11369 case DW_MACINFO_vendor_ext
:
11371 unsigned int bytes_read
;
11375 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
11376 mac_ptr
+= bytes_read
;
11377 string
= read_string (abfd
, mac_ptr
, &bytes_read
);
11378 mac_ptr
+= bytes_read
;
11380 /* We don't recognize any vendor extensions. */
11384 } while (macinfo_type
!= 0);
11387 /* Check if the attribute's form is a DW_FORM_block*
11388 if so return true else false. */
11390 attr_form_is_block (struct attribute
*attr
)
11392 return (attr
== NULL
? 0 :
11393 attr
->form
== DW_FORM_block1
11394 || attr
->form
== DW_FORM_block2
11395 || attr
->form
== DW_FORM_block4
11396 || attr
->form
== DW_FORM_block
);
11399 /* Return non-zero if ATTR's value is a section offset --- classes
11400 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
11401 You may use DW_UNSND (attr) to retrieve such offsets.
11403 Section 7.5.4, "Attribute Encodings", explains that no attribute
11404 may have a value that belongs to more than one of these classes; it
11405 would be ambiguous if we did, because we use the same forms for all
11408 attr_form_is_section_offset (struct attribute
*attr
)
11410 return (attr
->form
== DW_FORM_data4
11411 || attr
->form
== DW_FORM_data8
);
11415 /* Return non-zero if ATTR's value falls in the 'constant' class, or
11416 zero otherwise. When this function returns true, you can apply
11417 dwarf2_get_attr_constant_value to it.
11419 However, note that for some attributes you must check
11420 attr_form_is_section_offset before using this test. DW_FORM_data4
11421 and DW_FORM_data8 are members of both the constant class, and of
11422 the classes that contain offsets into other debug sections
11423 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
11424 that, if an attribute's can be either a constant or one of the
11425 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
11426 taken as section offsets, not constants. */
11428 attr_form_is_constant (struct attribute
*attr
)
11430 switch (attr
->form
)
11432 case DW_FORM_sdata
:
11433 case DW_FORM_udata
:
11434 case DW_FORM_data1
:
11435 case DW_FORM_data2
:
11436 case DW_FORM_data4
:
11437 case DW_FORM_data8
:
11445 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
11446 struct dwarf2_cu
*cu
)
11448 if (attr_form_is_section_offset (attr
)
11449 /* ".debug_loc" may not exist at all, or the offset may be outside
11450 the section. If so, fall through to the complaint in the
11452 && DW_UNSND (attr
) < dwarf2_per_objfile
->loc
.size
)
11454 struct dwarf2_loclist_baton
*baton
;
11456 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
11457 sizeof (struct dwarf2_loclist_baton
));
11458 baton
->per_cu
= cu
->per_cu
;
11459 gdb_assert (baton
->per_cu
);
11461 /* We don't know how long the location list is, but make sure we
11462 don't run off the edge of the section. */
11463 baton
->size
= dwarf2_per_objfile
->loc
.size
- DW_UNSND (attr
);
11464 baton
->data
= dwarf2_per_objfile
->loc
.buffer
+ DW_UNSND (attr
);
11465 baton
->base_address
= cu
->base_address
;
11466 if (cu
->base_known
== 0)
11467 complaint (&symfile_complaints
,
11468 _("Location list used without specifying the CU base address."));
11470 SYMBOL_COMPUTED_OPS (sym
) = &dwarf2_loclist_funcs
;
11471 SYMBOL_LOCATION_BATON (sym
) = baton
;
11475 struct dwarf2_locexpr_baton
*baton
;
11477 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
11478 sizeof (struct dwarf2_locexpr_baton
));
11479 baton
->per_cu
= cu
->per_cu
;
11480 gdb_assert (baton
->per_cu
);
11482 if (attr_form_is_block (attr
))
11484 /* Note that we're just copying the block's data pointer
11485 here, not the actual data. We're still pointing into the
11486 info_buffer for SYM's objfile; right now we never release
11487 that buffer, but when we do clean up properly this may
11489 baton
->size
= DW_BLOCK (attr
)->size
;
11490 baton
->data
= DW_BLOCK (attr
)->data
;
11494 dwarf2_invalid_attrib_class_complaint ("location description",
11495 SYMBOL_NATURAL_NAME (sym
));
11497 baton
->data
= NULL
;
11500 SYMBOL_COMPUTED_OPS (sym
) = &dwarf2_locexpr_funcs
;
11501 SYMBOL_LOCATION_BATON (sym
) = baton
;
11505 /* Return the OBJFILE associated with the compilation unit CU. */
11508 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data
*per_cu
)
11510 struct objfile
*objfile
= per_cu
->psymtab
->objfile
;
11512 /* Return the master objfile, so that we can report and look up the
11513 correct file containing this variable. */
11514 if (objfile
->separate_debug_objfile_backlink
)
11515 objfile
= objfile
->separate_debug_objfile_backlink
;
11520 /* Return the address size given in the compilation unit header for CU. */
11523 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data
*per_cu
)
11526 return per_cu
->cu
->header
.addr_size
;
11529 /* If the CU is not currently read in, we re-read its header. */
11530 struct objfile
*objfile
= per_cu
->psymtab
->objfile
;
11531 struct dwarf2_per_objfile
*per_objfile
11532 = objfile_data (objfile
, dwarf2_objfile_data_key
);
11533 gdb_byte
*info_ptr
= per_objfile
->info
.buffer
+ per_cu
->offset
;
11535 struct comp_unit_head cu_header
;
11536 memset (&cu_header
, 0, sizeof cu_header
);
11537 read_comp_unit_head (&cu_header
, info_ptr
, objfile
->obfd
);
11538 return cu_header
.addr_size
;
11542 /* Locate the .debug_info compilation unit from CU's objfile which contains
11543 the DIE at OFFSET. Raises an error on failure. */
11545 static struct dwarf2_per_cu_data
*
11546 dwarf2_find_containing_comp_unit (unsigned int offset
,
11547 struct objfile
*objfile
)
11549 struct dwarf2_per_cu_data
*this_cu
;
11553 high
= dwarf2_per_objfile
->n_comp_units
- 1;
11556 int mid
= low
+ (high
- low
) / 2;
11557 if (dwarf2_per_objfile
->all_comp_units
[mid
]->offset
>= offset
)
11562 gdb_assert (low
== high
);
11563 if (dwarf2_per_objfile
->all_comp_units
[low
]->offset
> offset
)
11566 error (_("Dwarf Error: could not find partial DIE containing "
11567 "offset 0x%lx [in module %s]"),
11568 (long) offset
, bfd_get_filename (objfile
->obfd
));
11570 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
<= offset
);
11571 return dwarf2_per_objfile
->all_comp_units
[low
-1];
11575 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
11576 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
11577 && offset
>= this_cu
->offset
+ this_cu
->length
)
11578 error (_("invalid dwarf2 offset %u"), offset
);
11579 gdb_assert (offset
< this_cu
->offset
+ this_cu
->length
);
11584 /* Locate the compilation unit from OBJFILE which is located at exactly
11585 OFFSET. Raises an error on failure. */
11587 static struct dwarf2_per_cu_data
*
11588 dwarf2_find_comp_unit (unsigned int offset
, struct objfile
*objfile
)
11590 struct dwarf2_per_cu_data
*this_cu
;
11591 this_cu
= dwarf2_find_containing_comp_unit (offset
, objfile
);
11592 if (this_cu
->offset
!= offset
)
11593 error (_("no compilation unit with offset %u."), offset
);
11597 /* Malloc space for a dwarf2_cu for OBJFILE and initialize it. */
11599 static struct dwarf2_cu
*
11600 alloc_one_comp_unit (struct objfile
*objfile
)
11602 struct dwarf2_cu
*cu
= xcalloc (1, sizeof (struct dwarf2_cu
));
11603 cu
->objfile
= objfile
;
11604 obstack_init (&cu
->comp_unit_obstack
);
11608 /* Release one cached compilation unit, CU. We unlink it from the tree
11609 of compilation units, but we don't remove it from the read_in_chain;
11610 the caller is responsible for that.
11611 NOTE: DATA is a void * because this function is also used as a
11612 cleanup routine. */
11615 free_one_comp_unit (void *data
)
11617 struct dwarf2_cu
*cu
= data
;
11619 if (cu
->per_cu
!= NULL
)
11620 cu
->per_cu
->cu
= NULL
;
11623 obstack_free (&cu
->comp_unit_obstack
, NULL
);
11628 /* This cleanup function is passed the address of a dwarf2_cu on the stack
11629 when we're finished with it. We can't free the pointer itself, but be
11630 sure to unlink it from the cache. Also release any associated storage
11631 and perform cache maintenance.
11633 Only used during partial symbol parsing. */
11636 free_stack_comp_unit (void *data
)
11638 struct dwarf2_cu
*cu
= data
;
11640 obstack_free (&cu
->comp_unit_obstack
, NULL
);
11641 cu
->partial_dies
= NULL
;
11643 if (cu
->per_cu
!= NULL
)
11645 /* This compilation unit is on the stack in our caller, so we
11646 should not xfree it. Just unlink it. */
11647 cu
->per_cu
->cu
= NULL
;
11650 /* If we had a per-cu pointer, then we may have other compilation
11651 units loaded, so age them now. */
11652 age_cached_comp_units ();
11656 /* Free all cached compilation units. */
11659 free_cached_comp_units (void *data
)
11661 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
11663 per_cu
= dwarf2_per_objfile
->read_in_chain
;
11664 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
11665 while (per_cu
!= NULL
)
11667 struct dwarf2_per_cu_data
*next_cu
;
11669 next_cu
= per_cu
->cu
->read_in_chain
;
11671 free_one_comp_unit (per_cu
->cu
);
11672 *last_chain
= next_cu
;
11678 /* Increase the age counter on each cached compilation unit, and free
11679 any that are too old. */
11682 age_cached_comp_units (void)
11684 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
11686 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
11687 per_cu
= dwarf2_per_objfile
->read_in_chain
;
11688 while (per_cu
!= NULL
)
11690 per_cu
->cu
->last_used
++;
11691 if (per_cu
->cu
->last_used
<= dwarf2_max_cache_age
)
11692 dwarf2_mark (per_cu
->cu
);
11693 per_cu
= per_cu
->cu
->read_in_chain
;
11696 per_cu
= dwarf2_per_objfile
->read_in_chain
;
11697 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
11698 while (per_cu
!= NULL
)
11700 struct dwarf2_per_cu_data
*next_cu
;
11702 next_cu
= per_cu
->cu
->read_in_chain
;
11704 if (!per_cu
->cu
->mark
)
11706 free_one_comp_unit (per_cu
->cu
);
11707 *last_chain
= next_cu
;
11710 last_chain
= &per_cu
->cu
->read_in_chain
;
11716 /* Remove a single compilation unit from the cache. */
11719 free_one_cached_comp_unit (void *target_cu
)
11721 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
11723 per_cu
= dwarf2_per_objfile
->read_in_chain
;
11724 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
11725 while (per_cu
!= NULL
)
11727 struct dwarf2_per_cu_data
*next_cu
;
11729 next_cu
= per_cu
->cu
->read_in_chain
;
11731 if (per_cu
->cu
== target_cu
)
11733 free_one_comp_unit (per_cu
->cu
);
11734 *last_chain
= next_cu
;
11738 last_chain
= &per_cu
->cu
->read_in_chain
;
11744 /* Release all extra memory associated with OBJFILE. */
11747 dwarf2_free_objfile (struct objfile
*objfile
)
11749 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
11751 if (dwarf2_per_objfile
== NULL
)
11754 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
11755 free_cached_comp_units (NULL
);
11757 /* Everything else should be on the objfile obstack. */
11760 /* A pair of DIE offset and GDB type pointer. We store these
11761 in a hash table separate from the DIEs, and preserve them
11762 when the DIEs are flushed out of cache. */
11764 struct dwarf2_offset_and_type
11766 unsigned int offset
;
11770 /* Hash function for a dwarf2_offset_and_type. */
11773 offset_and_type_hash (const void *item
)
11775 const struct dwarf2_offset_and_type
*ofs
= item
;
11776 return ofs
->offset
;
11779 /* Equality function for a dwarf2_offset_and_type. */
11782 offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
11784 const struct dwarf2_offset_and_type
*ofs_lhs
= item_lhs
;
11785 const struct dwarf2_offset_and_type
*ofs_rhs
= item_rhs
;
11786 return ofs_lhs
->offset
== ofs_rhs
->offset
;
11789 /* Set the type associated with DIE to TYPE. Save it in CU's hash
11790 table if necessary. For convenience, return TYPE. */
11792 static struct type
*
11793 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
11795 struct dwarf2_offset_and_type
**slot
, ofs
;
11797 /* For Ada types, make sure that the gnat-specific data is always
11798 initialized (if not already set). There are a few types where
11799 we should not be doing so, because the type-specific area is
11800 already used to hold some other piece of info (eg: TYPE_CODE_FLT
11801 where the type-specific area is used to store the floatformat).
11802 But this is not a problem, because the gnat-specific information
11803 is actually not needed for these types. */
11804 if (need_gnat_info (cu
)
11805 && TYPE_CODE (type
) != TYPE_CODE_FUNC
11806 && TYPE_CODE (type
) != TYPE_CODE_FLT
11807 && !HAVE_GNAT_AUX_INFO (type
))
11808 INIT_GNAT_SPECIFIC (type
);
11810 if (cu
->type_hash
== NULL
)
11812 gdb_assert (cu
->per_cu
!= NULL
);
11813 cu
->per_cu
->type_hash
11814 = htab_create_alloc_ex (cu
->header
.length
/ 24,
11815 offset_and_type_hash
,
11816 offset_and_type_eq
,
11818 &cu
->objfile
->objfile_obstack
,
11819 hashtab_obstack_allocate
,
11820 dummy_obstack_deallocate
);
11821 cu
->type_hash
= cu
->per_cu
->type_hash
;
11824 ofs
.offset
= die
->offset
;
11826 slot
= (struct dwarf2_offset_and_type
**)
11827 htab_find_slot_with_hash (cu
->type_hash
, &ofs
, ofs
.offset
, INSERT
);
11828 *slot
= obstack_alloc (&cu
->objfile
->objfile_obstack
, sizeof (**slot
));
11833 /* Find the type for DIE in CU's type_hash, or return NULL if DIE does
11834 not have a saved type. */
11836 static struct type
*
11837 get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
11839 struct dwarf2_offset_and_type
*slot
, ofs
;
11840 htab_t type_hash
= cu
->type_hash
;
11842 if (type_hash
== NULL
)
11845 ofs
.offset
= die
->offset
;
11846 slot
= htab_find_with_hash (type_hash
, &ofs
, ofs
.offset
);
11853 /* Add a dependence relationship from CU to REF_PER_CU. */
11856 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
11857 struct dwarf2_per_cu_data
*ref_per_cu
)
11861 if (cu
->dependencies
== NULL
)
11863 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
11864 NULL
, &cu
->comp_unit_obstack
,
11865 hashtab_obstack_allocate
,
11866 dummy_obstack_deallocate
);
11868 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
11870 *slot
= ref_per_cu
;
11873 /* Subroutine of dwarf2_mark to pass to htab_traverse.
11874 Set the mark field in every compilation unit in the
11875 cache that we must keep because we are keeping CU. */
11878 dwarf2_mark_helper (void **slot
, void *data
)
11880 struct dwarf2_per_cu_data
*per_cu
;
11882 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
11883 if (per_cu
->cu
->mark
)
11885 per_cu
->cu
->mark
= 1;
11887 if (per_cu
->cu
->dependencies
!= NULL
)
11888 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
11893 /* Set the mark field in CU and in every other compilation unit in the
11894 cache that we must keep because we are keeping CU. */
11897 dwarf2_mark (struct dwarf2_cu
*cu
)
11902 if (cu
->dependencies
!= NULL
)
11903 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
11907 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
11911 per_cu
->cu
->mark
= 0;
11912 per_cu
= per_cu
->cu
->read_in_chain
;
11916 /* Trivial hash function for partial_die_info: the hash value of a DIE
11917 is its offset in .debug_info for this objfile. */
11920 partial_die_hash (const void *item
)
11922 const struct partial_die_info
*part_die
= item
;
11923 return part_die
->offset
;
11926 /* Trivial comparison function for partial_die_info structures: two DIEs
11927 are equal if they have the same offset. */
11930 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
11932 const struct partial_die_info
*part_die_lhs
= item_lhs
;
11933 const struct partial_die_info
*part_die_rhs
= item_rhs
;
11934 return part_die_lhs
->offset
== part_die_rhs
->offset
;
11937 static struct cmd_list_element
*set_dwarf2_cmdlist
;
11938 static struct cmd_list_element
*show_dwarf2_cmdlist
;
11941 set_dwarf2_cmd (char *args
, int from_tty
)
11943 help_list (set_dwarf2_cmdlist
, "maintenance set dwarf2 ", -1, gdb_stdout
);
11947 show_dwarf2_cmd (char *args
, int from_tty
)
11949 cmd_show_list (show_dwarf2_cmdlist
, from_tty
, "");
11952 /* If section described by INFO was mmapped, munmap it now. */
11955 munmap_section_buffer (struct dwarf2_section_info
*info
)
11957 if (info
->was_mmapped
)
11960 intptr_t begin
= (intptr_t) info
->buffer
;
11961 intptr_t map_begin
= begin
& ~(pagesize
- 1);
11962 size_t map_length
= info
->size
+ begin
- map_begin
;
11963 gdb_assert (munmap ((void *) map_begin
, map_length
) == 0);
11965 /* Without HAVE_MMAP, we should never be here to begin with. */
11971 /* munmap debug sections for OBJFILE, if necessary. */
11974 dwarf2_per_objfile_free (struct objfile
*objfile
, void *d
)
11976 struct dwarf2_per_objfile
*data
= d
;
11977 munmap_section_buffer (&data
->info
);
11978 munmap_section_buffer (&data
->abbrev
);
11979 munmap_section_buffer (&data
->line
);
11980 munmap_section_buffer (&data
->str
);
11981 munmap_section_buffer (&data
->macinfo
);
11982 munmap_section_buffer (&data
->ranges
);
11983 munmap_section_buffer (&data
->loc
);
11984 munmap_section_buffer (&data
->frame
);
11985 munmap_section_buffer (&data
->eh_frame
);
11988 void _initialize_dwarf2_read (void);
11991 _initialize_dwarf2_read (void)
11993 dwarf2_objfile_data_key
11994 = register_objfile_data_with_cleanup (NULL
, dwarf2_per_objfile_free
);
11996 add_prefix_cmd ("dwarf2", class_maintenance
, set_dwarf2_cmd
, _("\
11997 Set DWARF 2 specific variables.\n\
11998 Configure DWARF 2 variables such as the cache size"),
11999 &set_dwarf2_cmdlist
, "maintenance set dwarf2 ",
12000 0/*allow-unknown*/, &maintenance_set_cmdlist
);
12002 add_prefix_cmd ("dwarf2", class_maintenance
, show_dwarf2_cmd
, _("\
12003 Show DWARF 2 specific variables\n\
12004 Show DWARF 2 variables such as the cache size"),
12005 &show_dwarf2_cmdlist
, "maintenance show dwarf2 ",
12006 0/*allow-unknown*/, &maintenance_show_cmdlist
);
12008 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
12009 &dwarf2_max_cache_age
, _("\
12010 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
12011 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
12012 A higher limit means that cached compilation units will be stored\n\
12013 in memory longer, and more total memory will be used. Zero disables\n\
12014 caching, which can slow down startup."),
12016 show_dwarf2_max_cache_age
,
12017 &set_dwarf2_cmdlist
,
12018 &show_dwarf2_cmdlist
);
12020 add_setshow_zinteger_cmd ("dwarf2-die", no_class
, &dwarf2_die_debug
, _("\
12021 Set debugging of the dwarf2 DIE reader."), _("\
12022 Show debugging of the dwarf2 DIE reader."), _("\
12023 When enabled (non-zero), DIEs are dumped after they are read in.\n\
12024 The value is the maximum depth to print."),
12027 &setdebuglist
, &showdebuglist
);