1 /* DWARF 2 debugging format support for GDB.
3 Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
4 2004, 2005, 2006, 2007, 2008, 2009, 2010
5 Free Software Foundation, Inc.
7 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
8 Inc. with support from Florida State University (under contract
9 with the Ada Joint Program Office), and Silicon Graphics, Inc.
10 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
11 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
14 This file is part of GDB.
16 This program is free software; you can redistribute it and/or modify
17 it under the terms of the GNU General Public License as published by
18 the Free Software Foundation; either version 3 of the License, or
19 (at your option) any later version.
21 This program is distributed in the hope that it will be useful,
22 but WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 GNU General Public License for more details.
26 You should have received a copy of the GNU General Public License
27 along with this program. If not, see <http://www.gnu.org/licenses/>. */
37 #include "expression.h"
38 #include "filenames.h" /* for DOSish file names */
41 #include "complaints.h"
43 #include "dwarf2expr.h"
44 #include "dwarf2loc.h"
45 #include "cp-support.h"
51 #include "typeprint.h"
56 #include "gdb_string.h"
57 #include "gdb_assert.h"
58 #include <sys/types.h>
65 #define MAP_FAILED ((void *) -1)
70 /* .debug_info header for a compilation unit
71 Because of alignment constraints, this structure has padding and cannot
72 be mapped directly onto the beginning of the .debug_info section. */
73 typedef struct comp_unit_header
75 unsigned int length
; /* length of the .debug_info
77 unsigned short version
; /* version number -- 2 for DWARF
79 unsigned int abbrev_offset
; /* offset into .debug_abbrev section */
80 unsigned char addr_size
; /* byte size of an address -- 4 */
83 #define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
86 /* .debug_line statement program prologue
87 Because of alignment constraints, this structure has padding and cannot
88 be mapped directly onto the beginning of the .debug_info section. */
89 typedef struct statement_prologue
91 unsigned int total_length
; /* byte length of the statement
93 unsigned short version
; /* version number -- 2 for DWARF
95 unsigned int prologue_length
; /* # bytes between prologue &
97 unsigned char minimum_instruction_length
; /* byte size of
99 unsigned char default_is_stmt
; /* initial value of is_stmt
102 unsigned char line_range
;
103 unsigned char opcode_base
; /* number assigned to first special
105 unsigned char *standard_opcode_lengths
;
109 /* When non-zero, dump DIEs after they are read in. */
110 static int dwarf2_die_debug
= 0;
114 /* When set, the file that we're processing is known to have debugging
115 info for C++ namespaces. GCC 3.3.x did not produce this information,
116 but later versions do. */
118 static int processing_has_namespace_info
;
120 static const struct objfile_data
*dwarf2_objfile_data_key
;
122 struct dwarf2_section_info
128 /* True if we have tried to read this section. */
132 struct dwarf2_per_objfile
134 struct dwarf2_section_info info
;
135 struct dwarf2_section_info abbrev
;
136 struct dwarf2_section_info line
;
137 struct dwarf2_section_info loc
;
138 struct dwarf2_section_info macinfo
;
139 struct dwarf2_section_info str
;
140 struct dwarf2_section_info ranges
;
141 struct dwarf2_section_info types
;
142 struct dwarf2_section_info frame
;
143 struct dwarf2_section_info eh_frame
;
146 struct objfile
*objfile
;
148 /* A list of all the compilation units. This is used to locate
149 the target compilation unit of a particular reference. */
150 struct dwarf2_per_cu_data
**all_comp_units
;
152 /* The number of compilation units in ALL_COMP_UNITS. */
155 /* A chain of compilation units that are currently read in, so that
156 they can be freed later. */
157 struct dwarf2_per_cu_data
*read_in_chain
;
159 /* A table mapping .debug_types signatures to its signatured_type entry.
160 This is NULL if the .debug_types section hasn't been read in yet. */
161 htab_t signatured_types
;
163 /* A flag indicating wether this objfile has a section loaded at a
165 int has_section_at_zero
;
168 static struct dwarf2_per_objfile
*dwarf2_per_objfile
;
170 /* names of the debugging sections */
172 /* Note that if the debugging section has been compressed, it might
173 have a name like .zdebug_info. */
175 #define INFO_SECTION "debug_info"
176 #define ABBREV_SECTION "debug_abbrev"
177 #define LINE_SECTION "debug_line"
178 #define LOC_SECTION "debug_loc"
179 #define MACINFO_SECTION "debug_macinfo"
180 #define STR_SECTION "debug_str"
181 #define RANGES_SECTION "debug_ranges"
182 #define TYPES_SECTION "debug_types"
183 #define FRAME_SECTION "debug_frame"
184 #define EH_FRAME_SECTION "eh_frame"
186 /* local data types */
188 /* We hold several abbreviation tables in memory at the same time. */
189 #ifndef ABBREV_HASH_SIZE
190 #define ABBREV_HASH_SIZE 121
193 /* The data in a compilation unit header, after target2host
194 translation, looks like this. */
195 struct comp_unit_head
199 unsigned char addr_size
;
200 unsigned char signed_addr_p
;
201 unsigned int abbrev_offset
;
203 /* Size of file offsets; either 4 or 8. */
204 unsigned int offset_size
;
206 /* Size of the length field; either 4 or 12. */
207 unsigned int initial_length_size
;
209 /* Offset to the first byte of this compilation unit header in the
210 .debug_info section, for resolving relative reference dies. */
213 /* Offset to first die in this cu from the start of the cu.
214 This will be the first byte following the compilation unit header. */
215 unsigned int first_die_offset
;
218 /* Internal state when decoding a particular compilation unit. */
221 /* The objfile containing this compilation unit. */
222 struct objfile
*objfile
;
224 /* The header of the compilation unit. */
225 struct comp_unit_head header
;
227 /* Base address of this compilation unit. */
228 CORE_ADDR base_address
;
230 /* Non-zero if base_address has been set. */
233 struct function_range
*first_fn
, *last_fn
, *cached_fn
;
235 /* The language we are debugging. */
236 enum language language
;
237 const struct language_defn
*language_defn
;
239 const char *producer
;
241 /* The generic symbol table building routines have separate lists for
242 file scope symbols and all all other scopes (local scopes). So
243 we need to select the right one to pass to add_symbol_to_list().
244 We do it by keeping a pointer to the correct list in list_in_scope.
246 FIXME: The original dwarf code just treated the file scope as the
247 first local scope, and all other local scopes as nested local
248 scopes, and worked fine. Check to see if we really need to
249 distinguish these in buildsym.c. */
250 struct pending
**list_in_scope
;
252 /* DWARF abbreviation table associated with this compilation unit. */
253 struct abbrev_info
**dwarf2_abbrevs
;
255 /* Storage for the abbrev table. */
256 struct obstack abbrev_obstack
;
258 /* Hash table holding all the loaded partial DIEs. */
261 /* Storage for things with the same lifetime as this read-in compilation
262 unit, including partial DIEs. */
263 struct obstack comp_unit_obstack
;
265 /* When multiple dwarf2_cu structures are living in memory, this field
266 chains them all together, so that they can be released efficiently.
267 We will probably also want a generation counter so that most-recently-used
268 compilation units are cached... */
269 struct dwarf2_per_cu_data
*read_in_chain
;
271 /* Backchain to our per_cu entry if the tree has been built. */
272 struct dwarf2_per_cu_data
*per_cu
;
274 /* Pointer to the die -> type map. Although it is stored
275 permanently in per_cu, we copy it here to avoid double
279 /* How many compilation units ago was this CU last referenced? */
282 /* A hash table of die offsets for following references. */
285 /* Full DIEs if read in. */
286 struct die_info
*dies
;
288 /* A set of pointers to dwarf2_per_cu_data objects for compilation
289 units referenced by this one. Only set during full symbol processing;
290 partial symbol tables do not have dependencies. */
293 /* Header data from the line table, during full symbol processing. */
294 struct line_header
*line_header
;
296 /* Mark used when releasing cached dies. */
297 unsigned int mark
: 1;
299 /* This flag will be set if this compilation unit might include
300 inter-compilation-unit references. */
301 unsigned int has_form_ref_addr
: 1;
303 /* This flag will be set if this compilation unit includes any
304 DW_TAG_namespace DIEs. If we know that there are explicit
305 DIEs for namespaces, we don't need to try to infer them
306 from mangled names. */
307 unsigned int has_namespace_info
: 1;
310 /* Persistent data held for a compilation unit, even when not
311 processing it. We put a pointer to this structure in the
312 read_symtab_private field of the psymtab. If we encounter
313 inter-compilation-unit references, we also maintain a sorted
314 list of all compilation units. */
316 struct dwarf2_per_cu_data
318 /* The start offset and length of this compilation unit. 2**29-1
319 bytes should suffice to store the length of any compilation unit
320 - if it doesn't, GDB will fall over anyway.
321 NOTE: Unlike comp_unit_head.length, this length includes
322 initial_length_size. */
324 unsigned int length
: 29;
326 /* Flag indicating this compilation unit will be read in before
327 any of the current compilation units are processed. */
328 unsigned int queued
: 1;
330 /* This flag will be set if we need to load absolutely all DIEs
331 for this compilation unit, instead of just the ones we think
332 are interesting. It gets set if we look for a DIE in the
333 hash table and don't find it. */
334 unsigned int load_all_dies
: 1;
336 /* Non-zero if this CU is from .debug_types.
337 Otherwise it's from .debug_info. */
338 unsigned int from_debug_types
: 1;
340 /* Set iff currently read in. */
341 struct dwarf2_cu
*cu
;
343 /* If full symbols for this CU have been read in, then this field
344 holds a map of DIE offsets to types. It isn't always possible
345 to reconstruct this information later, so we have to preserve
349 /* The partial symbol table associated with this compilation unit,
350 or NULL for partial units (which do not have an associated
352 struct partial_symtab
*psymtab
;
355 /* Entry in the signatured_types hash table. */
357 struct signatured_type
361 /* Offset in .debug_types of the TU (type_unit) for this type. */
364 /* Offset in .debug_types of the type defined by this TU. */
365 unsigned int type_offset
;
367 /* The CU(/TU) of this type. */
368 struct dwarf2_per_cu_data per_cu
;
371 /* Struct used to pass misc. parameters to read_die_and_children, et. al.
372 which are used for both .debug_info and .debug_types dies.
373 All parameters here are unchanging for the life of the call.
374 This struct exists to abstract away the constant parameters of
377 struct die_reader_specs
379 /* The bfd of this objfile. */
382 /* The CU of the DIE we are parsing. */
383 struct dwarf2_cu
*cu
;
385 /* Pointer to start of section buffer.
386 This is either the start of .debug_info or .debug_types. */
387 const gdb_byte
*buffer
;
390 /* The line number information for a compilation unit (found in the
391 .debug_line section) begins with a "statement program header",
392 which contains the following information. */
395 unsigned int total_length
;
396 unsigned short version
;
397 unsigned int header_length
;
398 unsigned char minimum_instruction_length
;
399 unsigned char maximum_ops_per_instruction
;
400 unsigned char default_is_stmt
;
402 unsigned char line_range
;
403 unsigned char opcode_base
;
405 /* standard_opcode_lengths[i] is the number of operands for the
406 standard opcode whose value is i. This means that
407 standard_opcode_lengths[0] is unused, and the last meaningful
408 element is standard_opcode_lengths[opcode_base - 1]. */
409 unsigned char *standard_opcode_lengths
;
411 /* The include_directories table. NOTE! These strings are not
412 allocated with xmalloc; instead, they are pointers into
413 debug_line_buffer. If you try to free them, `free' will get
415 unsigned int num_include_dirs
, include_dirs_size
;
418 /* The file_names table. NOTE! These strings are not allocated
419 with xmalloc; instead, they are pointers into debug_line_buffer.
420 Don't try to free them directly. */
421 unsigned int num_file_names
, file_names_size
;
425 unsigned int dir_index
;
426 unsigned int mod_time
;
428 int included_p
; /* Non-zero if referenced by the Line Number Program. */
429 struct symtab
*symtab
; /* The associated symbol table, if any. */
432 /* The start and end of the statement program following this
433 header. These point into dwarf2_per_objfile->line_buffer. */
434 gdb_byte
*statement_program_start
, *statement_program_end
;
437 /* When we construct a partial symbol table entry we only
438 need this much information. */
439 struct partial_die_info
441 /* Offset of this DIE. */
444 /* DWARF-2 tag for this DIE. */
445 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
447 /* Assorted flags describing the data found in this DIE. */
448 unsigned int has_children
: 1;
449 unsigned int is_external
: 1;
450 unsigned int is_declaration
: 1;
451 unsigned int has_type
: 1;
452 unsigned int has_specification
: 1;
453 unsigned int has_pc_info
: 1;
455 /* Flag set if the SCOPE field of this structure has been
457 unsigned int scope_set
: 1;
459 /* Flag set if the DIE has a byte_size attribute. */
460 unsigned int has_byte_size
: 1;
462 /* The name of this DIE. Normally the value of DW_AT_name, but
463 sometimes a default name for unnamed DIEs. */
466 /* The scope to prepend to our children. This is generally
467 allocated on the comp_unit_obstack, so will disappear
468 when this compilation unit leaves the cache. */
471 /* The location description associated with this DIE, if any. */
472 struct dwarf_block
*locdesc
;
474 /* If HAS_PC_INFO, the PC range associated with this DIE. */
478 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
479 DW_AT_sibling, if any. */
482 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
483 DW_AT_specification (or DW_AT_abstract_origin or
485 unsigned int spec_offset
;
487 /* Pointers to this DIE's parent, first child, and next sibling,
489 struct partial_die_info
*die_parent
, *die_child
, *die_sibling
;
492 /* This data structure holds the information of an abbrev. */
495 unsigned int number
; /* number identifying abbrev */
496 enum dwarf_tag tag
; /* dwarf tag */
497 unsigned short has_children
; /* boolean */
498 unsigned short num_attrs
; /* number of attributes */
499 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
500 struct abbrev_info
*next
; /* next in chain */
505 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
506 ENUM_BITFIELD(dwarf_form
) form
: 16;
509 /* Attributes have a name and a value */
512 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
513 ENUM_BITFIELD(dwarf_form
) form
: 15;
515 /* Has DW_STRING already been updated by dwarf2_canonicalize_name? This
516 field should be in u.str (existing only for DW_STRING) but it is kept
517 here for better struct attribute alignment. */
518 unsigned int string_is_canonical
: 1;
523 struct dwarf_block
*blk
;
527 struct signatured_type
*signatured_type
;
532 /* This data structure holds a complete die structure. */
535 /* DWARF-2 tag for this DIE. */
536 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
538 /* Number of attributes */
539 unsigned short num_attrs
;
544 /* Offset in .debug_info or .debug_types section. */
547 /* The dies in a compilation unit form an n-ary tree. PARENT
548 points to this die's parent; CHILD points to the first child of
549 this node; and all the children of a given node are chained
550 together via their SIBLING fields, terminated by a die whose
552 struct die_info
*child
; /* Its first child, if any. */
553 struct die_info
*sibling
; /* Its next sibling, if any. */
554 struct die_info
*parent
; /* Its parent, if any. */
556 /* An array of attributes, with NUM_ATTRS elements. There may be
557 zero, but it's not common and zero-sized arrays are not
558 sufficiently portable C. */
559 struct attribute attrs
[1];
562 struct function_range
565 CORE_ADDR lowpc
, highpc
;
567 struct function_range
*next
;
570 /* Get at parts of an attribute structure */
572 #define DW_STRING(attr) ((attr)->u.str)
573 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
574 #define DW_UNSND(attr) ((attr)->u.unsnd)
575 #define DW_BLOCK(attr) ((attr)->u.blk)
576 #define DW_SND(attr) ((attr)->u.snd)
577 #define DW_ADDR(attr) ((attr)->u.addr)
578 #define DW_SIGNATURED_TYPE(attr) ((attr)->u.signatured_type)
580 /* Blocks are a bunch of untyped bytes. */
587 #ifndef ATTR_ALLOC_CHUNK
588 #define ATTR_ALLOC_CHUNK 4
591 /* Allocate fields for structs, unions and enums in this size. */
592 #ifndef DW_FIELD_ALLOC_CHUNK
593 #define DW_FIELD_ALLOC_CHUNK 4
596 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
597 but this would require a corresponding change in unpack_field_as_long
599 static int bits_per_byte
= 8;
601 /* The routines that read and process dies for a C struct or C++ class
602 pass lists of data member fields and lists of member function fields
603 in an instance of a field_info structure, as defined below. */
606 /* List of data member and baseclasses fields. */
609 struct nextfield
*next
;
614 *fields
, *baseclasses
;
616 /* Number of fields (including baseclasses). */
619 /* Number of baseclasses. */
622 /* Set if the accesibility of one of the fields is not public. */
623 int non_public_fields
;
625 /* Member function fields array, entries are allocated in the order they
626 are encountered in the object file. */
629 struct nextfnfield
*next
;
630 struct fn_field fnfield
;
634 /* Member function fieldlist array, contains name of possibly overloaded
635 member function, number of overloaded member functions and a pointer
636 to the head of the member function field chain. */
641 struct nextfnfield
*head
;
645 /* Number of entries in the fnfieldlists array. */
649 /* One item on the queue of compilation units to read in full symbols
651 struct dwarf2_queue_item
653 struct dwarf2_per_cu_data
*per_cu
;
654 struct dwarf2_queue_item
*next
;
657 /* The current queue. */
658 static struct dwarf2_queue_item
*dwarf2_queue
, *dwarf2_queue_tail
;
660 /* Loaded secondary compilation units are kept in memory until they
661 have not been referenced for the processing of this many
662 compilation units. Set this to zero to disable caching. Cache
663 sizes of up to at least twenty will improve startup time for
664 typical inter-CU-reference binaries, at an obvious memory cost. */
665 static int dwarf2_max_cache_age
= 5;
667 show_dwarf2_max_cache_age (struct ui_file
*file
, int from_tty
,
668 struct cmd_list_element
*c
, const char *value
)
670 fprintf_filtered (file
, _("\
671 The upper bound on the age of cached dwarf2 compilation units is %s.\n"),
676 /* Various complaints about symbol reading that don't abort the process */
679 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
681 complaint (&symfile_complaints
,
682 _("statement list doesn't fit in .debug_line section"));
686 dwarf2_debug_line_missing_file_complaint (void)
688 complaint (&symfile_complaints
,
689 _(".debug_line section has line data without a file"));
693 dwarf2_debug_line_missing_end_sequence_complaint (void)
695 complaint (&symfile_complaints
,
696 _(".debug_line section has line program sequence without an end"));
700 dwarf2_complex_location_expr_complaint (void)
702 complaint (&symfile_complaints
, _("location expression too complex"));
706 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
709 complaint (&symfile_complaints
,
710 _("const value length mismatch for '%s', got %d, expected %d"), arg1
,
715 dwarf2_macros_too_long_complaint (void)
717 complaint (&symfile_complaints
,
718 _("macro info runs off end of `.debug_macinfo' section"));
722 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
724 complaint (&symfile_complaints
,
725 _("macro debug info contains a malformed macro definition:\n`%s'"),
730 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
732 complaint (&symfile_complaints
,
733 _("invalid attribute class or form for '%s' in '%s'"), arg1
, arg2
);
736 /* local function prototypes */
738 static void dwarf2_locate_sections (bfd
*, asection
*, void *);
740 static void dwarf2_create_include_psymtab (char *, struct partial_symtab
*,
743 static void dwarf2_build_include_psymtabs (struct dwarf2_cu
*,
745 struct partial_symtab
*);
747 static void dwarf2_build_psymtabs_hard (struct objfile
*);
749 static void scan_partial_symbols (struct partial_die_info
*,
750 CORE_ADDR
*, CORE_ADDR
*,
751 int, struct dwarf2_cu
*);
753 static void add_partial_symbol (struct partial_die_info
*,
756 static void add_partial_namespace (struct partial_die_info
*pdi
,
757 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
758 int need_pc
, struct dwarf2_cu
*cu
);
760 static void add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
761 CORE_ADDR
*highpc
, int need_pc
,
762 struct dwarf2_cu
*cu
);
764 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
765 struct dwarf2_cu
*cu
);
767 static void add_partial_subprogram (struct partial_die_info
*pdi
,
768 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
769 int need_pc
, struct dwarf2_cu
*cu
);
771 static gdb_byte
*locate_pdi_sibling (struct partial_die_info
*orig_pdi
,
772 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
773 bfd
*abfd
, struct dwarf2_cu
*cu
);
775 static void dwarf2_psymtab_to_symtab (struct partial_symtab
*);
777 static void psymtab_to_symtab_1 (struct partial_symtab
*);
779 static void dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
);
781 static void dwarf2_free_abbrev_table (void *);
783 static struct abbrev_info
*peek_die_abbrev (gdb_byte
*, unsigned int *,
786 static struct abbrev_info
*dwarf2_lookup_abbrev (unsigned int,
789 static struct partial_die_info
*load_partial_dies (bfd
*,
790 gdb_byte
*, gdb_byte
*,
791 int, struct dwarf2_cu
*);
793 static gdb_byte
*read_partial_die (struct partial_die_info
*,
794 struct abbrev_info
*abbrev
,
796 gdb_byte
*, gdb_byte
*,
799 static struct partial_die_info
*find_partial_die (unsigned int,
802 static void fixup_partial_die (struct partial_die_info
*,
805 static gdb_byte
*read_attribute (struct attribute
*, struct attr_abbrev
*,
806 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
808 static gdb_byte
*read_attribute_value (struct attribute
*, unsigned,
809 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
811 static unsigned int read_1_byte (bfd
*, gdb_byte
*);
813 static int read_1_signed_byte (bfd
*, gdb_byte
*);
815 static unsigned int read_2_bytes (bfd
*, gdb_byte
*);
817 static unsigned int read_4_bytes (bfd
*, gdb_byte
*);
819 static ULONGEST
read_8_bytes (bfd
*, gdb_byte
*);
821 static CORE_ADDR
read_address (bfd
*, gdb_byte
*ptr
, struct dwarf2_cu
*,
824 static LONGEST
read_initial_length (bfd
*, gdb_byte
*, unsigned int *);
826 static LONGEST read_checked_initial_length_and_offset
827 (bfd
*, gdb_byte
*, const struct comp_unit_head
*,
828 unsigned int *, unsigned int *);
830 static LONGEST
read_offset (bfd
*, gdb_byte
*, const struct comp_unit_head
*,
833 static LONGEST
read_offset_1 (bfd
*, gdb_byte
*, unsigned int);
835 static gdb_byte
*read_n_bytes (bfd
*, gdb_byte
*, unsigned int);
837 static char *read_string (bfd
*, gdb_byte
*, unsigned int *);
839 static char *read_indirect_string (bfd
*, gdb_byte
*,
840 const struct comp_unit_head
*,
843 static unsigned long read_unsigned_leb128 (bfd
*, gdb_byte
*, unsigned int *);
845 static long read_signed_leb128 (bfd
*, gdb_byte
*, unsigned int *);
847 static gdb_byte
*skip_leb128 (bfd
*, gdb_byte
*);
849 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
851 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
854 static struct attribute
*dwarf2_attr_no_follow (struct die_info
*,
858 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
859 struct dwarf2_cu
*cu
);
861 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
863 static struct die_info
*die_specification (struct die_info
*die
,
864 struct dwarf2_cu
**);
866 static void free_line_header (struct line_header
*lh
);
868 static void add_file_name (struct line_header
*, char *, unsigned int,
869 unsigned int, unsigned int);
871 static struct line_header
*(dwarf_decode_line_header
872 (unsigned int offset
,
873 bfd
*abfd
, struct dwarf2_cu
*cu
));
875 static void dwarf_decode_lines (struct line_header
*, char *, bfd
*,
876 struct dwarf2_cu
*, struct partial_symtab
*);
878 static void dwarf2_start_subfile (char *, char *, char *);
880 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
883 static void dwarf2_const_value (struct attribute
*, struct symbol
*,
886 static void dwarf2_const_value_data (struct attribute
*attr
,
890 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
892 static int need_gnat_info (struct dwarf2_cu
*);
894 static struct type
*die_descriptive_type (struct die_info
*, struct dwarf2_cu
*);
896 static void set_descriptive_type (struct type
*, struct die_info
*,
899 static struct type
*die_containing_type (struct die_info
*,
902 static struct type
*tag_type_to_type (struct die_info
*, struct dwarf2_cu
*);
904 static struct type
*read_type_die (struct die_info
*, struct dwarf2_cu
*);
906 static char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
908 static char *typename_concat (struct obstack
*,
913 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
915 static void read_type_unit_scope (struct die_info
*, struct dwarf2_cu
*);
917 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
919 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
921 static int dwarf2_ranges_read (unsigned, CORE_ADDR
*, CORE_ADDR
*,
922 struct dwarf2_cu
*, struct partial_symtab
*);
924 static int dwarf2_get_pc_bounds (struct die_info
*,
925 CORE_ADDR
*, CORE_ADDR
*, struct dwarf2_cu
*,
926 struct partial_symtab
*);
928 static void get_scope_pc_bounds (struct die_info
*,
929 CORE_ADDR
*, CORE_ADDR
*,
932 static void dwarf2_record_block_ranges (struct die_info
*, struct block
*,
933 CORE_ADDR
, struct dwarf2_cu
*);
935 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
938 static void dwarf2_attach_fields_to_type (struct field_info
*,
939 struct type
*, struct dwarf2_cu
*);
941 static void dwarf2_add_member_fn (struct field_info
*,
942 struct die_info
*, struct type
*,
945 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
946 struct type
*, struct dwarf2_cu
*);
948 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
950 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
952 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
954 static void read_module (struct die_info
*die
, struct dwarf2_cu
*cu
);
956 static void read_import_statement (struct die_info
*die
, struct dwarf2_cu
*);
958 static const char *namespace_name (struct die_info
*die
,
959 int *is_anonymous
, struct dwarf2_cu
*);
961 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
963 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
965 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
968 static struct die_info
*read_comp_unit (gdb_byte
*, struct dwarf2_cu
*);
970 static struct die_info
*read_die_and_children_1 (const struct die_reader_specs
*reader
,
972 gdb_byte
**new_info_ptr
,
973 struct die_info
*parent
);
975 static struct die_info
*read_die_and_children (const struct die_reader_specs
*reader
,
977 gdb_byte
**new_info_ptr
,
978 struct die_info
*parent
);
980 static struct die_info
*read_die_and_siblings (const struct die_reader_specs
*reader
,
982 gdb_byte
**new_info_ptr
,
983 struct die_info
*parent
);
985 static gdb_byte
*read_full_die (const struct die_reader_specs
*reader
,
986 struct die_info
**, gdb_byte
*,
989 static void process_die (struct die_info
*, struct dwarf2_cu
*);
991 static char *dwarf2_canonicalize_name (char *, struct dwarf2_cu
*,
994 static char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
996 static struct die_info
*dwarf2_extension (struct die_info
*die
,
997 struct dwarf2_cu
**);
999 static char *dwarf_tag_name (unsigned int);
1001 static char *dwarf_attr_name (unsigned int);
1003 static char *dwarf_form_name (unsigned int);
1005 static char *dwarf_bool_name (unsigned int);
1007 static char *dwarf_type_encoding_name (unsigned int);
1010 static char *dwarf_cfi_name (unsigned int);
1013 static struct die_info
*sibling_die (struct die_info
*);
1015 static void dump_die_shallow (struct ui_file
*, int indent
, struct die_info
*);
1017 static void dump_die_for_error (struct die_info
*);
1019 static void dump_die_1 (struct ui_file
*, int level
, int max_level
,
1022 /*static*/ void dump_die (struct die_info
*, int max_level
);
1024 static void store_in_ref_table (struct die_info
*,
1025 struct dwarf2_cu
*);
1027 static int is_ref_attr (struct attribute
*);
1029 static unsigned int dwarf2_get_ref_die_offset (struct attribute
*);
1031 static LONGEST
dwarf2_get_attr_constant_value (struct attribute
*, int);
1033 static struct die_info
*follow_die_ref_or_sig (struct die_info
*,
1035 struct dwarf2_cu
**);
1037 static struct die_info
*follow_die_ref (struct die_info
*,
1039 struct dwarf2_cu
**);
1041 static struct die_info
*follow_die_sig (struct die_info
*,
1043 struct dwarf2_cu
**);
1045 static void read_signatured_type_at_offset (struct objfile
*objfile
,
1046 unsigned int offset
);
1048 static void read_signatured_type (struct objfile
*,
1049 struct signatured_type
*type_sig
);
1051 /* memory allocation interface */
1053 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1055 static struct abbrev_info
*dwarf_alloc_abbrev (struct dwarf2_cu
*);
1057 static struct die_info
*dwarf_alloc_die (struct dwarf2_cu
*, int);
1059 static void initialize_cu_func_list (struct dwarf2_cu
*);
1061 static void add_to_cu_func_list (const char *, CORE_ADDR
, CORE_ADDR
,
1062 struct dwarf2_cu
*);
1064 static void dwarf_decode_macros (struct line_header
*, unsigned int,
1065 char *, bfd
*, struct dwarf2_cu
*);
1067 static int attr_form_is_block (struct attribute
*);
1069 static int attr_form_is_section_offset (struct attribute
*);
1071 static int attr_form_is_constant (struct attribute
*);
1073 static void dwarf2_symbol_mark_computed (struct attribute
*attr
,
1075 struct dwarf2_cu
*cu
);
1077 static gdb_byte
*skip_one_die (gdb_byte
*buffer
, gdb_byte
*info_ptr
,
1078 struct abbrev_info
*abbrev
,
1079 struct dwarf2_cu
*cu
);
1081 static void free_stack_comp_unit (void *);
1083 static hashval_t
partial_die_hash (const void *item
);
1085 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1087 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1088 (unsigned int offset
, struct objfile
*objfile
);
1090 static struct dwarf2_per_cu_data
*dwarf2_find_comp_unit
1091 (unsigned int offset
, struct objfile
*objfile
);
1093 static struct dwarf2_cu
*alloc_one_comp_unit (struct objfile
*objfile
);
1095 static void free_one_comp_unit (void *);
1097 static void free_cached_comp_units (void *);
1099 static void age_cached_comp_units (void);
1101 static void free_one_cached_comp_unit (void *);
1103 static struct type
*set_die_type (struct die_info
*, struct type
*,
1104 struct dwarf2_cu
*);
1106 static void create_all_comp_units (struct objfile
*);
1108 static void load_full_comp_unit (struct dwarf2_per_cu_data
*,
1111 static void process_full_comp_unit (struct dwarf2_per_cu_data
*);
1113 static void dwarf2_add_dependence (struct dwarf2_cu
*,
1114 struct dwarf2_per_cu_data
*);
1116 static void dwarf2_mark (struct dwarf2_cu
*);
1118 static void dwarf2_clear_marks (struct dwarf2_per_cu_data
*);
1120 static struct type
*get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
1122 /* Try to locate the sections we need for DWARF 2 debugging
1123 information and return true if we have enough to do something. */
1126 dwarf2_has_info (struct objfile
*objfile
)
1128 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
1129 if (!dwarf2_per_objfile
)
1131 /* Initialize per-objfile state. */
1132 struct dwarf2_per_objfile
*data
1133 = obstack_alloc (&objfile
->objfile_obstack
, sizeof (*data
));
1135 memset (data
, 0, sizeof (*data
));
1136 set_objfile_data (objfile
, dwarf2_objfile_data_key
, data
);
1137 dwarf2_per_objfile
= data
;
1139 bfd_map_over_sections (objfile
->obfd
, dwarf2_locate_sections
, NULL
);
1140 dwarf2_per_objfile
->objfile
= objfile
;
1142 return (dwarf2_per_objfile
->info
.asection
!= NULL
1143 && dwarf2_per_objfile
->abbrev
.asection
!= NULL
);
1146 /* When loading sections, we can either look for ".<name>", or for
1147 * ".z<name>", which indicates a compressed section. */
1150 section_is_p (const char *section_name
, const char *name
)
1152 return (section_name
[0] == '.'
1153 && (strcmp (section_name
+ 1, name
) == 0
1154 || (section_name
[1] == 'z'
1155 && strcmp (section_name
+ 2, name
) == 0)));
1158 /* This function is mapped across the sections and remembers the
1159 offset and size of each of the debugging sections we are interested
1163 dwarf2_locate_sections (bfd
*abfd
, asection
*sectp
, void *ignore_ptr
)
1165 if (section_is_p (sectp
->name
, INFO_SECTION
))
1167 dwarf2_per_objfile
->info
.asection
= sectp
;
1168 dwarf2_per_objfile
->info
.size
= bfd_get_section_size (sectp
);
1170 else if (section_is_p (sectp
->name
, ABBREV_SECTION
))
1172 dwarf2_per_objfile
->abbrev
.asection
= sectp
;
1173 dwarf2_per_objfile
->abbrev
.size
= bfd_get_section_size (sectp
);
1175 else if (section_is_p (sectp
->name
, LINE_SECTION
))
1177 dwarf2_per_objfile
->line
.asection
= sectp
;
1178 dwarf2_per_objfile
->line
.size
= bfd_get_section_size (sectp
);
1180 else if (section_is_p (sectp
->name
, LOC_SECTION
))
1182 dwarf2_per_objfile
->loc
.asection
= sectp
;
1183 dwarf2_per_objfile
->loc
.size
= bfd_get_section_size (sectp
);
1185 else if (section_is_p (sectp
->name
, MACINFO_SECTION
))
1187 dwarf2_per_objfile
->macinfo
.asection
= sectp
;
1188 dwarf2_per_objfile
->macinfo
.size
= bfd_get_section_size (sectp
);
1190 else if (section_is_p (sectp
->name
, STR_SECTION
))
1192 dwarf2_per_objfile
->str
.asection
= sectp
;
1193 dwarf2_per_objfile
->str
.size
= bfd_get_section_size (sectp
);
1195 else if (section_is_p (sectp
->name
, FRAME_SECTION
))
1197 dwarf2_per_objfile
->frame
.asection
= sectp
;
1198 dwarf2_per_objfile
->frame
.size
= bfd_get_section_size (sectp
);
1200 else if (section_is_p (sectp
->name
, EH_FRAME_SECTION
))
1202 flagword aflag
= bfd_get_section_flags (ignore_abfd
, sectp
);
1204 if (aflag
& SEC_HAS_CONTENTS
)
1206 dwarf2_per_objfile
->eh_frame
.asection
= sectp
;
1207 dwarf2_per_objfile
->eh_frame
.size
= bfd_get_section_size (sectp
);
1210 else if (section_is_p (sectp
->name
, RANGES_SECTION
))
1212 dwarf2_per_objfile
->ranges
.asection
= sectp
;
1213 dwarf2_per_objfile
->ranges
.size
= bfd_get_section_size (sectp
);
1215 else if (section_is_p (sectp
->name
, TYPES_SECTION
))
1217 dwarf2_per_objfile
->types
.asection
= sectp
;
1218 dwarf2_per_objfile
->types
.size
= bfd_get_section_size (sectp
);
1221 if ((bfd_get_section_flags (abfd
, sectp
) & SEC_LOAD
)
1222 && bfd_section_vma (abfd
, sectp
) == 0)
1223 dwarf2_per_objfile
->has_section_at_zero
= 1;
1226 /* Decompress a section that was compressed using zlib. Store the
1227 decompressed buffer, and its size, in OUTBUF and OUTSIZE. */
1230 zlib_decompress_section (struct objfile
*objfile
, asection
*sectp
,
1231 gdb_byte
**outbuf
, bfd_size_type
*outsize
)
1233 bfd
*abfd
= objfile
->obfd
;
1235 error (_("Support for zlib-compressed DWARF data (from '%s') "
1236 "is disabled in this copy of GDB"),
1237 bfd_get_filename (abfd
));
1239 bfd_size_type compressed_size
= bfd_get_section_size (sectp
);
1240 gdb_byte
*compressed_buffer
= xmalloc (compressed_size
);
1241 struct cleanup
*cleanup
= make_cleanup (xfree
, compressed_buffer
);
1242 bfd_size_type uncompressed_size
;
1243 gdb_byte
*uncompressed_buffer
;
1246 int header_size
= 12;
1248 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
1249 || bfd_bread (compressed_buffer
, compressed_size
, abfd
) != compressed_size
)
1250 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
1251 bfd_get_filename (abfd
));
1253 /* Read the zlib header. In this case, it should be "ZLIB" followed
1254 by the uncompressed section size, 8 bytes in big-endian order. */
1255 if (compressed_size
< header_size
1256 || strncmp (compressed_buffer
, "ZLIB", 4) != 0)
1257 error (_("Dwarf Error: Corrupt DWARF ZLIB header from '%s'"),
1258 bfd_get_filename (abfd
));
1259 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
1260 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
1261 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
1262 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
1263 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
1264 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
1265 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
1266 uncompressed_size
+= compressed_buffer
[11];
1268 /* It is possible the section consists of several compressed
1269 buffers concatenated together, so we uncompress in a loop. */
1273 strm
.avail_in
= compressed_size
- header_size
;
1274 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
1275 strm
.avail_out
= uncompressed_size
;
1276 uncompressed_buffer
= obstack_alloc (&objfile
->objfile_obstack
,
1278 rc
= inflateInit (&strm
);
1279 while (strm
.avail_in
> 0)
1282 error (_("Dwarf Error: setting up DWARF uncompression in '%s': %d"),
1283 bfd_get_filename (abfd
), rc
);
1284 strm
.next_out
= ((Bytef
*) uncompressed_buffer
1285 + (uncompressed_size
- strm
.avail_out
));
1286 rc
= inflate (&strm
, Z_FINISH
);
1287 if (rc
!= Z_STREAM_END
)
1288 error (_("Dwarf Error: zlib error uncompressing from '%s': %d"),
1289 bfd_get_filename (abfd
), rc
);
1290 rc
= inflateReset (&strm
);
1292 rc
= inflateEnd (&strm
);
1294 || strm
.avail_out
!= 0)
1295 error (_("Dwarf Error: concluding DWARF uncompression in '%s': %d"),
1296 bfd_get_filename (abfd
), rc
);
1298 do_cleanups (cleanup
);
1299 *outbuf
= uncompressed_buffer
;
1300 *outsize
= uncompressed_size
;
1304 /* Read the contents of the section SECTP from object file specified by
1305 OBJFILE, store info about the section into INFO.
1306 If the section is compressed, uncompress it before returning. */
1309 dwarf2_read_section (struct objfile
*objfile
, struct dwarf2_section_info
*info
)
1311 bfd
*abfd
= objfile
->obfd
;
1312 asection
*sectp
= info
->asection
;
1313 gdb_byte
*buf
, *retbuf
;
1314 unsigned char header
[4];
1318 info
->buffer
= NULL
;
1319 info
->was_mmapped
= 0;
1322 if (info
->asection
== NULL
|| info
->size
== 0)
1325 /* Check if the file has a 4-byte header indicating compression. */
1326 if (info
->size
> sizeof (header
)
1327 && bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) == 0
1328 && bfd_bread (header
, sizeof (header
), abfd
) == sizeof (header
))
1330 /* Upon decompression, update the buffer and its size. */
1331 if (strncmp (header
, "ZLIB", sizeof (header
)) == 0)
1333 zlib_decompress_section (objfile
, sectp
, &info
->buffer
,
1341 pagesize
= getpagesize ();
1343 /* Only try to mmap sections which are large enough: we don't want to
1344 waste space due to fragmentation. Also, only try mmap for sections
1345 without relocations. */
1347 if (info
->size
> 4 * pagesize
&& (sectp
->flags
& SEC_RELOC
) == 0)
1349 off_t pg_offset
= sectp
->filepos
& ~(pagesize
- 1);
1350 size_t map_length
= info
->size
+ sectp
->filepos
- pg_offset
;
1351 caddr_t retbuf
= bfd_mmap (abfd
, 0, map_length
, PROT_READ
,
1352 MAP_PRIVATE
, pg_offset
);
1354 if (retbuf
!= MAP_FAILED
)
1356 info
->was_mmapped
= 1;
1357 info
->buffer
= retbuf
+ (sectp
->filepos
& (pagesize
- 1)) ;
1358 #if HAVE_POSIX_MADVISE
1359 posix_madvise (retbuf
, map_length
, POSIX_MADV_WILLNEED
);
1366 /* If we get here, we are a normal, not-compressed section. */
1368 = obstack_alloc (&objfile
->objfile_obstack
, info
->size
);
1370 /* When debugging .o files, we may need to apply relocations; see
1371 http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
1372 We never compress sections in .o files, so we only need to
1373 try this when the section is not compressed. */
1374 retbuf
= symfile_relocate_debug_section (objfile
, sectp
, buf
);
1377 info
->buffer
= retbuf
;
1381 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
1382 || bfd_bread (buf
, info
->size
, abfd
) != info
->size
)
1383 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
1384 bfd_get_filename (abfd
));
1387 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
1391 dwarf2_get_section_info (struct objfile
*objfile
, const char *section_name
,
1392 asection
**sectp
, gdb_byte
**bufp
,
1393 bfd_size_type
*sizep
)
1395 struct dwarf2_per_objfile
*data
1396 = objfile_data (objfile
, dwarf2_objfile_data_key
);
1397 struct dwarf2_section_info
*info
;
1399 /* We may see an objfile without any DWARF, in which case we just
1408 if (section_is_p (section_name
, EH_FRAME_SECTION
))
1409 info
= &data
->eh_frame
;
1410 else if (section_is_p (section_name
, FRAME_SECTION
))
1411 info
= &data
->frame
;
1415 if (info
->asection
!= NULL
&& info
->size
!= 0 && info
->buffer
== NULL
)
1416 /* We haven't read this section in yet. Do it now. */
1417 dwarf2_read_section (objfile
, info
);
1419 *sectp
= info
->asection
;
1420 *bufp
= info
->buffer
;
1421 *sizep
= info
->size
;
1424 /* Build a partial symbol table. */
1427 dwarf2_build_psymtabs (struct objfile
*objfile
)
1429 if (objfile
->global_psymbols
.size
== 0 && objfile
->static_psymbols
.size
== 0)
1431 init_psymbol_list (objfile
, 1024);
1434 dwarf2_build_psymtabs_hard (objfile
);
1437 /* Return TRUE if OFFSET is within CU_HEADER. */
1440 offset_in_cu_p (const struct comp_unit_head
*cu_header
, unsigned int offset
)
1442 unsigned int bottom
= cu_header
->offset
;
1443 unsigned int top
= (cu_header
->offset
1445 + cu_header
->initial_length_size
);
1447 return (offset
>= bottom
&& offset
< top
);
1450 /* Read in the comp unit header information from the debug_info at info_ptr.
1451 NOTE: This leaves members offset, first_die_offset to be filled in
1455 read_comp_unit_head (struct comp_unit_head
*cu_header
,
1456 gdb_byte
*info_ptr
, bfd
*abfd
)
1459 unsigned int bytes_read
;
1461 cu_header
->length
= read_initial_length (abfd
, info_ptr
, &bytes_read
);
1462 cu_header
->initial_length_size
= bytes_read
;
1463 cu_header
->offset_size
= (bytes_read
== 4) ? 4 : 8;
1464 info_ptr
+= bytes_read
;
1465 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
1467 cu_header
->abbrev_offset
= read_offset (abfd
, info_ptr
, cu_header
,
1469 info_ptr
+= bytes_read
;
1470 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
1472 signed_addr
= bfd_get_sign_extend_vma (abfd
);
1473 if (signed_addr
< 0)
1474 internal_error (__FILE__
, __LINE__
,
1475 _("read_comp_unit_head: dwarf from non elf file"));
1476 cu_header
->signed_addr_p
= signed_addr
;
1482 partial_read_comp_unit_head (struct comp_unit_head
*header
, gdb_byte
*info_ptr
,
1483 gdb_byte
*buffer
, unsigned int buffer_size
,
1486 gdb_byte
*beg_of_comp_unit
= info_ptr
;
1488 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
1490 if (header
->version
!= 2 && header
->version
!= 3 && header
->version
!= 4)
1491 error (_("Dwarf Error: wrong version in compilation unit header "
1492 "(is %d, should be 2, 3, or 4) [in module %s]"), header
->version
,
1493 bfd_get_filename (abfd
));
1495 if (header
->abbrev_offset
>= dwarf2_per_objfile
->abbrev
.size
)
1496 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
1497 "(offset 0x%lx + 6) [in module %s]"),
1498 (long) header
->abbrev_offset
,
1499 (long) (beg_of_comp_unit
- buffer
),
1500 bfd_get_filename (abfd
));
1502 if (beg_of_comp_unit
+ header
->length
+ header
->initial_length_size
1503 > buffer
+ buffer_size
)
1504 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
1505 "(offset 0x%lx + 0) [in module %s]"),
1506 (long) header
->length
,
1507 (long) (beg_of_comp_unit
- buffer
),
1508 bfd_get_filename (abfd
));
1513 /* Read in the types comp unit header information from .debug_types entry at
1514 types_ptr. The result is a pointer to one past the end of the header. */
1517 read_type_comp_unit_head (struct comp_unit_head
*cu_header
,
1518 ULONGEST
*signature
,
1519 gdb_byte
*types_ptr
, bfd
*abfd
)
1521 gdb_byte
*initial_types_ptr
= types_ptr
;
1523 dwarf2_read_section (dwarf2_per_objfile
->objfile
,
1524 &dwarf2_per_objfile
->types
);
1525 cu_header
->offset
= types_ptr
- dwarf2_per_objfile
->types
.buffer
;
1527 types_ptr
= read_comp_unit_head (cu_header
, types_ptr
, abfd
);
1529 *signature
= read_8_bytes (abfd
, types_ptr
);
1531 types_ptr
+= cu_header
->offset_size
;
1532 cu_header
->first_die_offset
= types_ptr
- initial_types_ptr
;
1537 /* Allocate a new partial symtab for file named NAME and mark this new
1538 partial symtab as being an include of PST. */
1541 dwarf2_create_include_psymtab (char *name
, struct partial_symtab
*pst
,
1542 struct objfile
*objfile
)
1544 struct partial_symtab
*subpst
= allocate_psymtab (name
, objfile
);
1546 subpst
->section_offsets
= pst
->section_offsets
;
1547 subpst
->textlow
= 0;
1548 subpst
->texthigh
= 0;
1550 subpst
->dependencies
= (struct partial_symtab
**)
1551 obstack_alloc (&objfile
->objfile_obstack
,
1552 sizeof (struct partial_symtab
*));
1553 subpst
->dependencies
[0] = pst
;
1554 subpst
->number_of_dependencies
= 1;
1556 subpst
->globals_offset
= 0;
1557 subpst
->n_global_syms
= 0;
1558 subpst
->statics_offset
= 0;
1559 subpst
->n_static_syms
= 0;
1560 subpst
->symtab
= NULL
;
1561 subpst
->read_symtab
= pst
->read_symtab
;
1564 /* No private part is necessary for include psymtabs. This property
1565 can be used to differentiate between such include psymtabs and
1566 the regular ones. */
1567 subpst
->read_symtab_private
= NULL
;
1570 /* Read the Line Number Program data and extract the list of files
1571 included by the source file represented by PST. Build an include
1572 partial symtab for each of these included files. */
1575 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
1576 struct die_info
*die
,
1577 struct partial_symtab
*pst
)
1579 struct objfile
*objfile
= cu
->objfile
;
1580 bfd
*abfd
= objfile
->obfd
;
1581 struct line_header
*lh
= NULL
;
1582 struct attribute
*attr
;
1584 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
1587 unsigned int line_offset
= DW_UNSND (attr
);
1589 lh
= dwarf_decode_line_header (line_offset
, abfd
, cu
);
1592 return; /* No linetable, so no includes. */
1594 dwarf_decode_lines (lh
, NULL
, abfd
, cu
, pst
);
1596 free_line_header (lh
);
1600 hash_type_signature (const void *item
)
1602 const struct signatured_type
*type_sig
= item
;
1604 /* This drops the top 32 bits of the signature, but is ok for a hash. */
1605 return type_sig
->signature
;
1609 eq_type_signature (const void *item_lhs
, const void *item_rhs
)
1611 const struct signatured_type
*lhs
= item_lhs
;
1612 const struct signatured_type
*rhs
= item_rhs
;
1614 return lhs
->signature
== rhs
->signature
;
1617 /* Create the hash table of all entries in the .debug_types section.
1618 The result is zero if there is an error (e.g. missing .debug_types section),
1619 otherwise non-zero. */
1622 create_debug_types_hash_table (struct objfile
*objfile
)
1627 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->types
);
1628 info_ptr
= dwarf2_per_objfile
->types
.buffer
;
1630 if (info_ptr
== NULL
)
1632 dwarf2_per_objfile
->signatured_types
= NULL
;
1636 types_htab
= htab_create_alloc_ex (41,
1637 hash_type_signature
,
1640 &objfile
->objfile_obstack
,
1641 hashtab_obstack_allocate
,
1642 dummy_obstack_deallocate
);
1644 if (dwarf2_die_debug
)
1645 fprintf_unfiltered (gdb_stdlog
, "Signatured types:\n");
1647 while (info_ptr
< dwarf2_per_objfile
->types
.buffer
+ dwarf2_per_objfile
->types
.size
)
1649 unsigned int offset
;
1650 unsigned int offset_size
;
1651 unsigned int type_offset
;
1652 unsigned int length
, initial_length_size
;
1653 unsigned short version
;
1655 struct signatured_type
*type_sig
;
1657 gdb_byte
*ptr
= info_ptr
;
1659 offset
= ptr
- dwarf2_per_objfile
->types
.buffer
;
1661 /* We need to read the type's signature in order to build the hash
1662 table, but we don't need to read anything else just yet. */
1664 /* Sanity check to ensure entire cu is present. */
1665 length
= read_initial_length (objfile
->obfd
, ptr
, &initial_length_size
);
1666 if (ptr
+ length
+ initial_length_size
1667 > dwarf2_per_objfile
->types
.buffer
+ dwarf2_per_objfile
->types
.size
)
1669 complaint (&symfile_complaints
,
1670 _("debug type entry runs off end of `.debug_types' section, ignored"));
1674 offset_size
= initial_length_size
== 4 ? 4 : 8;
1675 ptr
+= initial_length_size
;
1676 version
= bfd_get_16 (objfile
->obfd
, ptr
);
1678 ptr
+= offset_size
; /* abbrev offset */
1679 ptr
+= 1; /* address size */
1680 signature
= bfd_get_64 (objfile
->obfd
, ptr
);
1682 type_offset
= read_offset_1 (objfile
->obfd
, ptr
, offset_size
);
1684 type_sig
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*type_sig
));
1685 memset (type_sig
, 0, sizeof (*type_sig
));
1686 type_sig
->signature
= signature
;
1687 type_sig
->offset
= offset
;
1688 type_sig
->type_offset
= type_offset
;
1690 slot
= htab_find_slot (types_htab
, type_sig
, INSERT
);
1691 gdb_assert (slot
!= NULL
);
1694 if (dwarf2_die_debug
)
1695 fprintf_unfiltered (gdb_stdlog
, " offset 0x%x, signature 0x%s\n",
1696 offset
, phex (signature
, sizeof (signature
)));
1698 info_ptr
= info_ptr
+ initial_length_size
+ length
;
1701 dwarf2_per_objfile
->signatured_types
= types_htab
;
1706 /* Lookup a signature based type.
1707 Returns NULL if SIG is not present in the table. */
1709 static struct signatured_type
*
1710 lookup_signatured_type (struct objfile
*objfile
, ULONGEST sig
)
1712 struct signatured_type find_entry
, *entry
;
1714 if (dwarf2_per_objfile
->signatured_types
== NULL
)
1716 complaint (&symfile_complaints
,
1717 _("missing `.debug_types' section for DW_FORM_sig8 die"));
1721 find_entry
.signature
= sig
;
1722 entry
= htab_find (dwarf2_per_objfile
->signatured_types
, &find_entry
);
1726 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
1729 init_cu_die_reader (struct die_reader_specs
*reader
,
1730 struct dwarf2_cu
*cu
)
1732 reader
->abfd
= cu
->objfile
->obfd
;
1734 if (cu
->per_cu
->from_debug_types
)
1736 gdb_assert (dwarf2_per_objfile
->types
.readin
);
1737 reader
->buffer
= dwarf2_per_objfile
->types
.buffer
;
1741 gdb_assert (dwarf2_per_objfile
->info
.readin
);
1742 reader
->buffer
= dwarf2_per_objfile
->info
.buffer
;
1746 /* Find the base address of the compilation unit for range lists and
1747 location lists. It will normally be specified by DW_AT_low_pc.
1748 In DWARF-3 draft 4, the base address could be overridden by
1749 DW_AT_entry_pc. It's been removed, but GCC still uses this for
1750 compilation units with discontinuous ranges. */
1753 dwarf2_find_base_address (struct die_info
*die
, struct dwarf2_cu
*cu
)
1755 struct attribute
*attr
;
1758 cu
->base_address
= 0;
1760 attr
= dwarf2_attr (die
, DW_AT_entry_pc
, cu
);
1763 cu
->base_address
= DW_ADDR (attr
);
1768 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
1771 cu
->base_address
= DW_ADDR (attr
);
1777 /* Subroutine of process_type_comp_unit and dwarf2_build_psymtabs_hard
1778 to combine the common parts.
1779 Process a compilation unit for a psymtab.
1780 BUFFER is a pointer to the beginning of the dwarf section buffer,
1781 either .debug_info or debug_types.
1782 INFO_PTR is a pointer to the start of the CU.
1783 Returns a pointer to the next CU. */
1786 process_psymtab_comp_unit (struct objfile
*objfile
,
1787 struct dwarf2_per_cu_data
*this_cu
,
1788 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
1789 unsigned int buffer_size
)
1791 bfd
*abfd
= objfile
->obfd
;
1792 gdb_byte
*beg_of_comp_unit
= info_ptr
;
1793 struct die_info
*comp_unit_die
;
1794 struct partial_symtab
*pst
;
1796 struct cleanup
*back_to_inner
;
1797 struct dwarf2_cu cu
;
1798 int has_children
, has_pc_info
;
1799 struct attribute
*attr
;
1800 CORE_ADDR best_lowpc
= 0, best_highpc
= 0;
1801 struct die_reader_specs reader_specs
;
1803 memset (&cu
, 0, sizeof (cu
));
1804 cu
.objfile
= objfile
;
1805 obstack_init (&cu
.comp_unit_obstack
);
1807 back_to_inner
= make_cleanup (free_stack_comp_unit
, &cu
);
1809 info_ptr
= partial_read_comp_unit_head (&cu
.header
, info_ptr
,
1810 buffer
, buffer_size
,
1813 /* Complete the cu_header. */
1814 cu
.header
.offset
= beg_of_comp_unit
- buffer
;
1815 cu
.header
.first_die_offset
= info_ptr
- beg_of_comp_unit
;
1817 cu
.list_in_scope
= &file_symbols
;
1819 /* If this compilation unit was already read in, free the
1820 cached copy in order to read it in again. This is
1821 necessary because we skipped some symbols when we first
1822 read in the compilation unit (see load_partial_dies).
1823 This problem could be avoided, but the benefit is
1825 if (this_cu
->cu
!= NULL
)
1826 free_one_cached_comp_unit (this_cu
->cu
);
1828 /* Note that this is a pointer to our stack frame, being
1829 added to a global data structure. It will be cleaned up
1830 in free_stack_comp_unit when we finish with this
1831 compilation unit. */
1833 cu
.per_cu
= this_cu
;
1835 /* Read the abbrevs for this compilation unit into a table. */
1836 dwarf2_read_abbrevs (abfd
, &cu
);
1837 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
1839 /* Read the compilation unit die. */
1840 if (this_cu
->from_debug_types
)
1841 info_ptr
+= 8 /*signature*/ + cu
.header
.offset_size
;
1842 init_cu_die_reader (&reader_specs
, &cu
);
1843 info_ptr
= read_full_die (&reader_specs
, &comp_unit_die
, info_ptr
,
1846 if (this_cu
->from_debug_types
)
1848 /* offset,length haven't been set yet for type units. */
1849 this_cu
->offset
= cu
.header
.offset
;
1850 this_cu
->length
= cu
.header
.length
+ cu
.header
.initial_length_size
;
1852 else if (comp_unit_die
->tag
== DW_TAG_partial_unit
)
1854 info_ptr
= (beg_of_comp_unit
+ cu
.header
.length
1855 + cu
.header
.initial_length_size
);
1856 do_cleanups (back_to_inner
);
1860 /* Set the language we're debugging. */
1861 attr
= dwarf2_attr (comp_unit_die
, DW_AT_language
, &cu
);
1863 set_cu_language (DW_UNSND (attr
), &cu
);
1865 set_cu_language (language_minimal
, &cu
);
1867 /* Allocate a new partial symbol table structure. */
1868 attr
= dwarf2_attr (comp_unit_die
, DW_AT_name
, &cu
);
1869 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
1870 (attr
!= NULL
) ? DW_STRING (attr
) : "",
1871 /* TEXTLOW and TEXTHIGH are set below. */
1873 objfile
->global_psymbols
.next
,
1874 objfile
->static_psymbols
.next
);
1876 attr
= dwarf2_attr (comp_unit_die
, DW_AT_comp_dir
, &cu
);
1878 pst
->dirname
= DW_STRING (attr
);
1880 pst
->read_symtab_private
= this_cu
;
1882 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1884 /* Store the function that reads in the rest of the symbol table */
1885 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
1887 this_cu
->psymtab
= pst
;
1889 dwarf2_find_base_address (comp_unit_die
, &cu
);
1891 /* Possibly set the default values of LOWPC and HIGHPC from
1893 has_pc_info
= dwarf2_get_pc_bounds (comp_unit_die
, &best_lowpc
,
1894 &best_highpc
, &cu
, pst
);
1895 if (has_pc_info
== 1 && best_lowpc
< best_highpc
)
1896 /* Store the contiguous range if it is not empty; it can be empty for
1897 CUs with no code. */
1898 addrmap_set_empty (objfile
->psymtabs_addrmap
,
1899 best_lowpc
+ baseaddr
,
1900 best_highpc
+ baseaddr
- 1, pst
);
1902 /* Check if comp unit has_children.
1903 If so, read the rest of the partial symbols from this comp unit.
1904 If not, there's no more debug_info for this comp unit. */
1907 struct partial_die_info
*first_die
;
1908 CORE_ADDR lowpc
, highpc
;
1910 lowpc
= ((CORE_ADDR
) -1);
1911 highpc
= ((CORE_ADDR
) 0);
1913 first_die
= load_partial_dies (abfd
, buffer
, info_ptr
, 1, &cu
);
1915 scan_partial_symbols (first_die
, &lowpc
, &highpc
,
1916 ! has_pc_info
, &cu
);
1918 /* If we didn't find a lowpc, set it to highpc to avoid
1919 complaints from `maint check'. */
1920 if (lowpc
== ((CORE_ADDR
) -1))
1923 /* If the compilation unit didn't have an explicit address range,
1924 then use the information extracted from its child dies. */
1928 best_highpc
= highpc
;
1931 pst
->textlow
= best_lowpc
+ baseaddr
;
1932 pst
->texthigh
= best_highpc
+ baseaddr
;
1934 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
1935 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1936 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
1937 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1938 sort_pst_symbols (pst
);
1940 info_ptr
= (beg_of_comp_unit
+ cu
.header
.length
1941 + cu
.header
.initial_length_size
);
1943 if (this_cu
->from_debug_types
)
1945 /* It's not clear we want to do anything with stmt lists here.
1946 Waiting to see what gcc ultimately does. */
1950 /* Get the list of files included in the current compilation unit,
1951 and build a psymtab for each of them. */
1952 dwarf2_build_include_psymtabs (&cu
, comp_unit_die
, pst
);
1955 do_cleanups (back_to_inner
);
1960 /* Traversal function for htab_traverse_noresize.
1961 Process one .debug_types comp-unit. */
1964 process_type_comp_unit (void **slot
, void *info
)
1966 struct signatured_type
*entry
= (struct signatured_type
*) *slot
;
1967 struct objfile
*objfile
= (struct objfile
*) info
;
1968 struct dwarf2_per_cu_data
*this_cu
;
1970 this_cu
= &entry
->per_cu
;
1971 this_cu
->from_debug_types
= 1;
1973 gdb_assert (dwarf2_per_objfile
->types
.readin
);
1974 process_psymtab_comp_unit (objfile
, this_cu
,
1975 dwarf2_per_objfile
->types
.buffer
,
1976 dwarf2_per_objfile
->types
.buffer
+ entry
->offset
,
1977 dwarf2_per_objfile
->types
.size
);
1982 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
1983 Build partial symbol tables for the .debug_types comp-units. */
1986 build_type_psymtabs (struct objfile
*objfile
)
1988 if (! create_debug_types_hash_table (objfile
))
1991 htab_traverse_noresize (dwarf2_per_objfile
->signatured_types
,
1992 process_type_comp_unit
, objfile
);
1995 /* Build the partial symbol table by doing a quick pass through the
1996 .debug_info and .debug_abbrev sections. */
1999 dwarf2_build_psymtabs_hard (struct objfile
*objfile
)
2002 struct cleanup
*back_to
;
2004 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
2005 info_ptr
= dwarf2_per_objfile
->info
.buffer
;
2007 /* Any cached compilation units will be linked by the per-objfile
2008 read_in_chain. Make sure to free them when we're done. */
2009 back_to
= make_cleanup (free_cached_comp_units
, NULL
);
2011 build_type_psymtabs (objfile
);
2013 create_all_comp_units (objfile
);
2015 objfile
->psymtabs_addrmap
=
2016 addrmap_create_mutable (&objfile
->objfile_obstack
);
2018 /* Since the objects we're extracting from .debug_info vary in
2019 length, only the individual functions to extract them (like
2020 read_comp_unit_head and load_partial_die) can really know whether
2021 the buffer is large enough to hold another complete object.
2023 At the moment, they don't actually check that. If .debug_info
2024 holds just one extra byte after the last compilation unit's dies,
2025 then read_comp_unit_head will happily read off the end of the
2026 buffer. read_partial_die is similarly casual. Those functions
2029 For this loop condition, simply checking whether there's any data
2030 left at all should be sufficient. */
2032 while (info_ptr
< (dwarf2_per_objfile
->info
.buffer
2033 + dwarf2_per_objfile
->info
.size
))
2035 struct dwarf2_per_cu_data
*this_cu
;
2037 this_cu
= dwarf2_find_comp_unit (info_ptr
- dwarf2_per_objfile
->info
.buffer
,
2040 info_ptr
= process_psymtab_comp_unit (objfile
, this_cu
,
2041 dwarf2_per_objfile
->info
.buffer
,
2043 dwarf2_per_objfile
->info
.size
);
2046 objfile
->psymtabs_addrmap
= addrmap_create_fixed (objfile
->psymtabs_addrmap
,
2047 &objfile
->objfile_obstack
);
2049 do_cleanups (back_to
);
2052 /* Load the partial DIEs for a secondary CU into memory. */
2055 load_partial_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
2056 struct objfile
*objfile
)
2058 bfd
*abfd
= objfile
->obfd
;
2059 gdb_byte
*info_ptr
, *beg_of_comp_unit
;
2060 struct die_info
*comp_unit_die
;
2061 struct dwarf2_cu
*cu
;
2062 struct cleanup
*back_to
;
2063 struct attribute
*attr
;
2065 struct die_reader_specs reader_specs
;
2067 gdb_assert (! this_cu
->from_debug_types
);
2069 gdb_assert (dwarf2_per_objfile
->info
.readin
);
2070 info_ptr
= dwarf2_per_objfile
->info
.buffer
+ this_cu
->offset
;
2071 beg_of_comp_unit
= info_ptr
;
2073 cu
= alloc_one_comp_unit (objfile
);
2075 /* ??? Missing cleanup for CU? */
2077 /* Link this compilation unit into the compilation unit tree. */
2079 cu
->per_cu
= this_cu
;
2080 cu
->type_hash
= this_cu
->type_hash
;
2082 info_ptr
= partial_read_comp_unit_head (&cu
->header
, info_ptr
,
2083 dwarf2_per_objfile
->info
.buffer
,
2084 dwarf2_per_objfile
->info
.size
,
2087 /* Complete the cu_header. */
2088 cu
->header
.offset
= this_cu
->offset
;
2089 cu
->header
.first_die_offset
= info_ptr
- beg_of_comp_unit
;
2091 /* Read the abbrevs for this compilation unit into a table. */
2092 dwarf2_read_abbrevs (abfd
, cu
);
2093 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
2095 /* Read the compilation unit die. */
2096 init_cu_die_reader (&reader_specs
, cu
);
2097 info_ptr
= read_full_die (&reader_specs
, &comp_unit_die
, info_ptr
,
2100 /* Set the language we're debugging. */
2101 attr
= dwarf2_attr (comp_unit_die
, DW_AT_language
, cu
);
2103 set_cu_language (DW_UNSND (attr
), cu
);
2105 set_cu_language (language_minimal
, cu
);
2107 /* Check if comp unit has_children.
2108 If so, read the rest of the partial symbols from this comp unit.
2109 If not, there's no more debug_info for this comp unit. */
2111 load_partial_dies (abfd
, dwarf2_per_objfile
->info
.buffer
, info_ptr
, 0, cu
);
2113 do_cleanups (back_to
);
2116 /* Create a list of all compilation units in OBJFILE. We do this only
2117 if an inter-comp-unit reference is found; presumably if there is one,
2118 there will be many, and one will occur early in the .debug_info section.
2119 So there's no point in building this list incrementally. */
2122 create_all_comp_units (struct objfile
*objfile
)
2126 struct dwarf2_per_cu_data
**all_comp_units
;
2129 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
2130 info_ptr
= dwarf2_per_objfile
->info
.buffer
;
2134 all_comp_units
= xmalloc (n_allocated
2135 * sizeof (struct dwarf2_per_cu_data
*));
2137 while (info_ptr
< dwarf2_per_objfile
->info
.buffer
+ dwarf2_per_objfile
->info
.size
)
2139 unsigned int length
, initial_length_size
;
2140 struct dwarf2_per_cu_data
*this_cu
;
2141 unsigned int offset
;
2143 offset
= info_ptr
- dwarf2_per_objfile
->info
.buffer
;
2145 /* Read just enough information to find out where the next
2146 compilation unit is. */
2147 length
= read_initial_length (objfile
->obfd
, info_ptr
,
2148 &initial_length_size
);
2150 /* Save the compilation unit for later lookup. */
2151 this_cu
= obstack_alloc (&objfile
->objfile_obstack
,
2152 sizeof (struct dwarf2_per_cu_data
));
2153 memset (this_cu
, 0, sizeof (*this_cu
));
2154 this_cu
->offset
= offset
;
2155 this_cu
->length
= length
+ initial_length_size
;
2157 if (n_comp_units
== n_allocated
)
2160 all_comp_units
= xrealloc (all_comp_units
,
2162 * sizeof (struct dwarf2_per_cu_data
*));
2164 all_comp_units
[n_comp_units
++] = this_cu
;
2166 info_ptr
= info_ptr
+ this_cu
->length
;
2169 dwarf2_per_objfile
->all_comp_units
2170 = obstack_alloc (&objfile
->objfile_obstack
,
2171 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
2172 memcpy (dwarf2_per_objfile
->all_comp_units
, all_comp_units
,
2173 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
2174 xfree (all_comp_units
);
2175 dwarf2_per_objfile
->n_comp_units
= n_comp_units
;
2178 /* Process all loaded DIEs for compilation unit CU, starting at
2179 FIRST_DIE. The caller should pass NEED_PC == 1 if the compilation
2180 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
2181 DW_AT_ranges). If NEED_PC is set, then this function will set
2182 *LOWPC and *HIGHPC to the lowest and highest PC values found in CU
2183 and record the covered ranges in the addrmap. */
2186 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
2187 CORE_ADDR
*highpc
, int need_pc
, struct dwarf2_cu
*cu
)
2189 struct partial_die_info
*pdi
;
2191 /* Now, march along the PDI's, descending into ones which have
2192 interesting children but skipping the children of the other ones,
2193 until we reach the end of the compilation unit. */
2199 fixup_partial_die (pdi
, cu
);
2201 /* Anonymous namespaces have no name but have interesting
2202 children, so we need to look at them. Ditto for anonymous
2205 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
2206 || pdi
->tag
== DW_TAG_enumeration_type
)
2210 case DW_TAG_subprogram
:
2211 add_partial_subprogram (pdi
, lowpc
, highpc
, need_pc
, cu
);
2213 case DW_TAG_variable
:
2214 case DW_TAG_typedef
:
2215 case DW_TAG_union_type
:
2216 if (!pdi
->is_declaration
)
2218 add_partial_symbol (pdi
, cu
);
2221 case DW_TAG_class_type
:
2222 case DW_TAG_interface_type
:
2223 case DW_TAG_structure_type
:
2224 if (!pdi
->is_declaration
)
2226 add_partial_symbol (pdi
, cu
);
2229 case DW_TAG_enumeration_type
:
2230 if (!pdi
->is_declaration
)
2231 add_partial_enumeration (pdi
, cu
);
2233 case DW_TAG_base_type
:
2234 case DW_TAG_subrange_type
:
2235 /* File scope base type definitions are added to the partial
2237 add_partial_symbol (pdi
, cu
);
2239 case DW_TAG_namespace
:
2240 add_partial_namespace (pdi
, lowpc
, highpc
, need_pc
, cu
);
2243 add_partial_module (pdi
, lowpc
, highpc
, need_pc
, cu
);
2250 /* If the die has a sibling, skip to the sibling. */
2252 pdi
= pdi
->die_sibling
;
2256 /* Functions used to compute the fully scoped name of a partial DIE.
2258 Normally, this is simple. For C++, the parent DIE's fully scoped
2259 name is concatenated with "::" and the partial DIE's name. For
2260 Java, the same thing occurs except that "." is used instead of "::".
2261 Enumerators are an exception; they use the scope of their parent
2262 enumeration type, i.e. the name of the enumeration type is not
2263 prepended to the enumerator.
2265 There are two complexities. One is DW_AT_specification; in this
2266 case "parent" means the parent of the target of the specification,
2267 instead of the direct parent of the DIE. The other is compilers
2268 which do not emit DW_TAG_namespace; in this case we try to guess
2269 the fully qualified name of structure types from their members'
2270 linkage names. This must be done using the DIE's children rather
2271 than the children of any DW_AT_specification target. We only need
2272 to do this for structures at the top level, i.e. if the target of
2273 any DW_AT_specification (if any; otherwise the DIE itself) does not
2276 /* Compute the scope prefix associated with PDI's parent, in
2277 compilation unit CU. The result will be allocated on CU's
2278 comp_unit_obstack, or a copy of the already allocated PDI->NAME
2279 field. NULL is returned if no prefix is necessary. */
2281 partial_die_parent_scope (struct partial_die_info
*pdi
,
2282 struct dwarf2_cu
*cu
)
2284 char *grandparent_scope
;
2285 struct partial_die_info
*parent
, *real_pdi
;
2287 /* We need to look at our parent DIE; if we have a DW_AT_specification,
2288 then this means the parent of the specification DIE. */
2291 while (real_pdi
->has_specification
)
2292 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
2294 parent
= real_pdi
->die_parent
;
2298 if (parent
->scope_set
)
2299 return parent
->scope
;
2301 fixup_partial_die (parent
, cu
);
2303 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
2305 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
2306 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
2307 Work around this problem here. */
2308 if (cu
->language
== language_cplus
2309 && parent
->tag
== DW_TAG_namespace
2310 && strcmp (parent
->name
, "::") == 0
2311 && grandparent_scope
== NULL
)
2313 parent
->scope
= NULL
;
2314 parent
->scope_set
= 1;
2318 if (parent
->tag
== DW_TAG_namespace
2319 || parent
->tag
== DW_TAG_structure_type
2320 || parent
->tag
== DW_TAG_class_type
2321 || parent
->tag
== DW_TAG_interface_type
2322 || parent
->tag
== DW_TAG_union_type
2323 || parent
->tag
== DW_TAG_enumeration_type
)
2325 if (grandparent_scope
== NULL
)
2326 parent
->scope
= parent
->name
;
2328 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
, grandparent_scope
,
2331 else if (parent
->tag
== DW_TAG_enumerator
)
2332 /* Enumerators should not get the name of the enumeration as a prefix. */
2333 parent
->scope
= grandparent_scope
;
2336 /* FIXME drow/2004-04-01: What should we be doing with
2337 function-local names? For partial symbols, we should probably be
2339 complaint (&symfile_complaints
,
2340 _("unhandled containing DIE tag %d for DIE at %d"),
2341 parent
->tag
, pdi
->offset
);
2342 parent
->scope
= grandparent_scope
;
2345 parent
->scope_set
= 1;
2346 return parent
->scope
;
2349 /* Return the fully scoped name associated with PDI, from compilation unit
2350 CU. The result will be allocated with malloc. */
2352 partial_die_full_name (struct partial_die_info
*pdi
,
2353 struct dwarf2_cu
*cu
)
2357 parent_scope
= partial_die_parent_scope (pdi
, cu
);
2358 if (parent_scope
== NULL
)
2361 return typename_concat (NULL
, parent_scope
, pdi
->name
, cu
);
2365 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
2367 struct objfile
*objfile
= cu
->objfile
;
2369 char *actual_name
= NULL
;
2370 const struct partial_symbol
*psym
= NULL
;
2372 int built_actual_name
= 0;
2374 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2376 actual_name
= partial_die_full_name (pdi
, cu
);
2378 built_actual_name
= 1;
2380 if (actual_name
== NULL
)
2381 actual_name
= pdi
->name
;
2385 case DW_TAG_subprogram
:
2386 if (pdi
->is_external
|| cu
->language
== language_ada
)
2388 /* brobecker/2007-12-26: Normally, only "external" DIEs are part
2389 of the global scope. But in Ada, we want to be able to access
2390 nested procedures globally. So all Ada subprograms are stored
2391 in the global scope. */
2392 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
2393 mst_text, objfile); */
2394 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
2396 VAR_DOMAIN
, LOC_BLOCK
,
2397 &objfile
->global_psymbols
,
2398 0, pdi
->lowpc
+ baseaddr
,
2399 cu
->language
, objfile
);
2403 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
2404 mst_file_text, objfile); */
2405 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
2407 VAR_DOMAIN
, LOC_BLOCK
,
2408 &objfile
->static_psymbols
,
2409 0, pdi
->lowpc
+ baseaddr
,
2410 cu
->language
, objfile
);
2413 case DW_TAG_variable
:
2414 if (pdi
->is_external
)
2417 Don't enter into the minimal symbol tables as there is
2418 a minimal symbol table entry from the ELF symbols already.
2419 Enter into partial symbol table if it has a location
2420 descriptor or a type.
2421 If the location descriptor is missing, new_symbol will create
2422 a LOC_UNRESOLVED symbol, the address of the variable will then
2423 be determined from the minimal symbol table whenever the variable
2425 The address for the partial symbol table entry is not
2426 used by GDB, but it comes in handy for debugging partial symbol
2430 addr
= decode_locdesc (pdi
->locdesc
, cu
);
2431 if (pdi
->locdesc
|| pdi
->has_type
)
2432 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
2434 VAR_DOMAIN
, LOC_STATIC
,
2435 &objfile
->global_psymbols
,
2437 cu
->language
, objfile
);
2441 /* Static Variable. Skip symbols without location descriptors. */
2442 if (pdi
->locdesc
== NULL
)
2444 if (built_actual_name
)
2445 xfree (actual_name
);
2448 addr
= decode_locdesc (pdi
->locdesc
, cu
);
2449 /*prim_record_minimal_symbol (actual_name, addr + baseaddr,
2450 mst_file_data, objfile); */
2451 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
2453 VAR_DOMAIN
, LOC_STATIC
,
2454 &objfile
->static_psymbols
,
2456 cu
->language
, objfile
);
2459 case DW_TAG_typedef
:
2460 case DW_TAG_base_type
:
2461 case DW_TAG_subrange_type
:
2462 add_psymbol_to_list (actual_name
, strlen (actual_name
),
2464 VAR_DOMAIN
, LOC_TYPEDEF
,
2465 &objfile
->static_psymbols
,
2466 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
2468 case DW_TAG_namespace
:
2469 add_psymbol_to_list (actual_name
, strlen (actual_name
),
2471 VAR_DOMAIN
, LOC_TYPEDEF
,
2472 &objfile
->global_psymbols
,
2473 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
2475 case DW_TAG_class_type
:
2476 case DW_TAG_interface_type
:
2477 case DW_TAG_structure_type
:
2478 case DW_TAG_union_type
:
2479 case DW_TAG_enumeration_type
:
2480 /* Skip external references. The DWARF standard says in the section
2481 about "Structure, Union, and Class Type Entries": "An incomplete
2482 structure, union or class type is represented by a structure,
2483 union or class entry that does not have a byte size attribute
2484 and that has a DW_AT_declaration attribute." */
2485 if (!pdi
->has_byte_size
&& pdi
->is_declaration
)
2487 if (built_actual_name
)
2488 xfree (actual_name
);
2492 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
2493 static vs. global. */
2494 add_psymbol_to_list (actual_name
, strlen (actual_name
),
2496 STRUCT_DOMAIN
, LOC_TYPEDEF
,
2497 (cu
->language
== language_cplus
2498 || cu
->language
== language_java
)
2499 ? &objfile
->global_psymbols
2500 : &objfile
->static_psymbols
,
2501 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
2504 case DW_TAG_enumerator
:
2505 add_psymbol_to_list (actual_name
, strlen (actual_name
),
2507 VAR_DOMAIN
, LOC_CONST
,
2508 (cu
->language
== language_cplus
2509 || cu
->language
== language_java
)
2510 ? &objfile
->global_psymbols
2511 : &objfile
->static_psymbols
,
2512 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
2518 if (built_actual_name
)
2519 xfree (actual_name
);
2522 /* Read a partial die corresponding to a namespace; also, add a symbol
2523 corresponding to that namespace to the symbol table. NAMESPACE is
2524 the name of the enclosing namespace. */
2527 add_partial_namespace (struct partial_die_info
*pdi
,
2528 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
2529 int need_pc
, struct dwarf2_cu
*cu
)
2531 /* Add a symbol for the namespace. */
2533 add_partial_symbol (pdi
, cu
);
2535 /* Now scan partial symbols in that namespace. */
2537 if (pdi
->has_children
)
2538 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, need_pc
, cu
);
2541 /* Read a partial die corresponding to a Fortran module. */
2544 add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
2545 CORE_ADDR
*highpc
, int need_pc
, struct dwarf2_cu
*cu
)
2547 /* Now scan partial symbols in that module.
2549 FIXME: Support the separate Fortran module namespaces. */
2551 if (pdi
->has_children
)
2552 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, need_pc
, cu
);
2555 /* Read a partial die corresponding to a subprogram and create a partial
2556 symbol for that subprogram. When the CU language allows it, this
2557 routine also defines a partial symbol for each nested subprogram
2558 that this subprogram contains.
2560 DIE my also be a lexical block, in which case we simply search
2561 recursively for suprograms defined inside that lexical block.
2562 Again, this is only performed when the CU language allows this
2563 type of definitions. */
2566 add_partial_subprogram (struct partial_die_info
*pdi
,
2567 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
2568 int need_pc
, struct dwarf2_cu
*cu
)
2570 if (pdi
->tag
== DW_TAG_subprogram
)
2572 if (pdi
->has_pc_info
)
2574 if (pdi
->lowpc
< *lowpc
)
2575 *lowpc
= pdi
->lowpc
;
2576 if (pdi
->highpc
> *highpc
)
2577 *highpc
= pdi
->highpc
;
2581 struct objfile
*objfile
= cu
->objfile
;
2583 baseaddr
= ANOFFSET (objfile
->section_offsets
,
2584 SECT_OFF_TEXT (objfile
));
2585 addrmap_set_empty (objfile
->psymtabs_addrmap
,
2586 pdi
->lowpc
+ baseaddr
,
2587 pdi
->highpc
- 1 + baseaddr
,
2588 cu
->per_cu
->psymtab
);
2590 if (!pdi
->is_declaration
)
2591 /* Ignore subprogram DIEs that do not have a name, they are
2592 illegal. Do not emit a complaint at this point, we will
2593 do so when we convert this psymtab into a symtab. */
2595 add_partial_symbol (pdi
, cu
);
2599 if (! pdi
->has_children
)
2602 if (cu
->language
== language_ada
)
2604 pdi
= pdi
->die_child
;
2607 fixup_partial_die (pdi
, cu
);
2608 if (pdi
->tag
== DW_TAG_subprogram
2609 || pdi
->tag
== DW_TAG_lexical_block
)
2610 add_partial_subprogram (pdi
, lowpc
, highpc
, need_pc
, cu
);
2611 pdi
= pdi
->die_sibling
;
2616 /* See if we can figure out if the class lives in a namespace. We do
2617 this by looking for a member function; its demangled name will
2618 contain namespace info, if there is any. */
2621 guess_structure_name (struct partial_die_info
*struct_pdi
,
2622 struct dwarf2_cu
*cu
)
2624 if ((cu
->language
== language_cplus
2625 || cu
->language
== language_java
)
2626 && cu
->has_namespace_info
== 0
2627 && struct_pdi
->has_children
)
2629 /* NOTE: carlton/2003-10-07: Getting the info this way changes
2630 what template types look like, because the demangler
2631 frequently doesn't give the same name as the debug info. We
2632 could fix this by only using the demangled name to get the
2633 prefix (but see comment in read_structure_type). */
2635 struct partial_die_info
*real_pdi
;
2637 /* If this DIE (this DIE's specification, if any) has a parent, then
2638 we should not do this. We'll prepend the parent's fully qualified
2639 name when we create the partial symbol. */
2641 real_pdi
= struct_pdi
;
2642 while (real_pdi
->has_specification
)
2643 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
2645 if (real_pdi
->die_parent
!= NULL
)
2650 /* Read a partial die corresponding to an enumeration type. */
2653 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
2654 struct dwarf2_cu
*cu
)
2656 struct partial_die_info
*pdi
;
2658 if (enum_pdi
->name
!= NULL
)
2659 add_partial_symbol (enum_pdi
, cu
);
2661 pdi
= enum_pdi
->die_child
;
2664 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
2665 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
2667 add_partial_symbol (pdi
, cu
);
2668 pdi
= pdi
->die_sibling
;
2672 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
2673 Return the corresponding abbrev, or NULL if the number is zero (indicating
2674 an empty DIE). In either case *BYTES_READ will be set to the length of
2675 the initial number. */
2677 static struct abbrev_info
*
2678 peek_die_abbrev (gdb_byte
*info_ptr
, unsigned int *bytes_read
,
2679 struct dwarf2_cu
*cu
)
2681 bfd
*abfd
= cu
->objfile
->obfd
;
2682 unsigned int abbrev_number
;
2683 struct abbrev_info
*abbrev
;
2685 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
2687 if (abbrev_number
== 0)
2690 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
2693 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"), abbrev_number
,
2694 bfd_get_filename (abfd
));
2700 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
2701 Returns a pointer to the end of a series of DIEs, terminated by an empty
2702 DIE. Any children of the skipped DIEs will also be skipped. */
2705 skip_children (gdb_byte
*buffer
, gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
2707 struct abbrev_info
*abbrev
;
2708 unsigned int bytes_read
;
2712 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
2714 return info_ptr
+ bytes_read
;
2716 info_ptr
= skip_one_die (buffer
, info_ptr
+ bytes_read
, abbrev
, cu
);
2720 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
2721 INFO_PTR should point just after the initial uleb128 of a DIE, and the
2722 abbrev corresponding to that skipped uleb128 should be passed in
2723 ABBREV. Returns a pointer to this DIE's sibling, skipping any
2727 skip_one_die (gdb_byte
*buffer
, gdb_byte
*info_ptr
,
2728 struct abbrev_info
*abbrev
, struct dwarf2_cu
*cu
)
2730 unsigned int bytes_read
;
2731 struct attribute attr
;
2732 bfd
*abfd
= cu
->objfile
->obfd
;
2733 unsigned int form
, i
;
2735 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
2737 /* The only abbrev we care about is DW_AT_sibling. */
2738 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
2740 read_attribute (&attr
, &abbrev
->attrs
[i
],
2741 abfd
, info_ptr
, cu
);
2742 if (attr
.form
== DW_FORM_ref_addr
)
2743 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
2745 return buffer
+ dwarf2_get_ref_die_offset (&attr
);
2748 /* If it isn't DW_AT_sibling, skip this attribute. */
2749 form
= abbrev
->attrs
[i
].form
;
2753 case DW_FORM_ref_addr
:
2754 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
2755 and later it is offset sized. */
2756 if (cu
->header
.version
== 2)
2757 info_ptr
+= cu
->header
.addr_size
;
2759 info_ptr
+= cu
->header
.offset_size
;
2762 info_ptr
+= cu
->header
.addr_size
;
2769 case DW_FORM_flag_present
:
2784 case DW_FORM_string
:
2785 read_string (abfd
, info_ptr
, &bytes_read
);
2786 info_ptr
+= bytes_read
;
2788 case DW_FORM_sec_offset
:
2790 info_ptr
+= cu
->header
.offset_size
;
2792 case DW_FORM_exprloc
:
2794 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2795 info_ptr
+= bytes_read
;
2797 case DW_FORM_block1
:
2798 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
2800 case DW_FORM_block2
:
2801 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
2803 case DW_FORM_block4
:
2804 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
2808 case DW_FORM_ref_udata
:
2809 info_ptr
= skip_leb128 (abfd
, info_ptr
);
2811 case DW_FORM_indirect
:
2812 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2813 info_ptr
+= bytes_read
;
2814 /* We need to continue parsing from here, so just go back to
2816 goto skip_attribute
;
2819 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
2820 dwarf_form_name (form
),
2821 bfd_get_filename (abfd
));
2825 if (abbrev
->has_children
)
2826 return skip_children (buffer
, info_ptr
, cu
);
2831 /* Locate ORIG_PDI's sibling.
2832 INFO_PTR should point to the start of the next DIE after ORIG_PDI
2836 locate_pdi_sibling (struct partial_die_info
*orig_pdi
,
2837 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
2838 bfd
*abfd
, struct dwarf2_cu
*cu
)
2840 /* Do we know the sibling already? */
2842 if (orig_pdi
->sibling
)
2843 return orig_pdi
->sibling
;
2845 /* Are there any children to deal with? */
2847 if (!orig_pdi
->has_children
)
2850 /* Skip the children the long way. */
2852 return skip_children (buffer
, info_ptr
, cu
);
2855 /* Expand this partial symbol table into a full symbol table. */
2858 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
2860 /* FIXME: This is barely more than a stub. */
2865 warning (_("bug: psymtab for %s is already read in."), pst
->filename
);
2871 printf_filtered (_("Reading in symbols for %s..."), pst
->filename
);
2872 gdb_flush (gdb_stdout
);
2875 /* Restore our global data. */
2876 dwarf2_per_objfile
= objfile_data (pst
->objfile
,
2877 dwarf2_objfile_data_key
);
2879 /* If this psymtab is constructed from a debug-only objfile, the
2880 has_section_at_zero flag will not necessarily be correct. We
2881 can get the correct value for this flag by looking at the data
2882 associated with the (presumably stripped) associated objfile. */
2883 if (pst
->objfile
->separate_debug_objfile_backlink
)
2885 struct dwarf2_per_objfile
*dpo_backlink
2886 = objfile_data (pst
->objfile
->separate_debug_objfile_backlink
,
2887 dwarf2_objfile_data_key
);
2889 dwarf2_per_objfile
->has_section_at_zero
2890 = dpo_backlink
->has_section_at_zero
;
2893 psymtab_to_symtab_1 (pst
);
2895 /* Finish up the debug error message. */
2897 printf_filtered (_("done.\n"));
2902 /* Add PER_CU to the queue. */
2905 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
, struct objfile
*objfile
)
2907 struct dwarf2_queue_item
*item
;
2910 item
= xmalloc (sizeof (*item
));
2911 item
->per_cu
= per_cu
;
2914 if (dwarf2_queue
== NULL
)
2915 dwarf2_queue
= item
;
2917 dwarf2_queue_tail
->next
= item
;
2919 dwarf2_queue_tail
= item
;
2922 /* Process the queue. */
2925 process_queue (struct objfile
*objfile
)
2927 struct dwarf2_queue_item
*item
, *next_item
;
2929 /* The queue starts out with one item, but following a DIE reference
2930 may load a new CU, adding it to the end of the queue. */
2931 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
2933 if (item
->per_cu
->psymtab
&& !item
->per_cu
->psymtab
->readin
)
2934 process_full_comp_unit (item
->per_cu
);
2936 item
->per_cu
->queued
= 0;
2937 next_item
= item
->next
;
2941 dwarf2_queue_tail
= NULL
;
2944 /* Free all allocated queue entries. This function only releases anything if
2945 an error was thrown; if the queue was processed then it would have been
2946 freed as we went along. */
2949 dwarf2_release_queue (void *dummy
)
2951 struct dwarf2_queue_item
*item
, *last
;
2953 item
= dwarf2_queue
;
2956 /* Anything still marked queued is likely to be in an
2957 inconsistent state, so discard it. */
2958 if (item
->per_cu
->queued
)
2960 if (item
->per_cu
->cu
!= NULL
)
2961 free_one_cached_comp_unit (item
->per_cu
->cu
);
2962 item
->per_cu
->queued
= 0;
2970 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
2973 /* Read in full symbols for PST, and anything it depends on. */
2976 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
2978 struct dwarf2_per_cu_data
*per_cu
;
2979 struct cleanup
*back_to
;
2982 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2983 if (!pst
->dependencies
[i
]->readin
)
2985 /* Inform about additional files that need to be read in. */
2988 /* FIXME: i18n: Need to make this a single string. */
2989 fputs_filtered (" ", gdb_stdout
);
2991 fputs_filtered ("and ", gdb_stdout
);
2993 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
2994 wrap_here (""); /* Flush output */
2995 gdb_flush (gdb_stdout
);
2997 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
3000 per_cu
= pst
->read_symtab_private
;
3004 /* It's an include file, no symbols to read for it.
3005 Everything is in the parent symtab. */
3010 back_to
= make_cleanup (dwarf2_release_queue
, NULL
);
3012 queue_comp_unit (per_cu
, pst
->objfile
);
3014 if (per_cu
->from_debug_types
)
3015 read_signatured_type_at_offset (pst
->objfile
, per_cu
->offset
);
3017 load_full_comp_unit (per_cu
, pst
->objfile
);
3019 process_queue (pst
->objfile
);
3021 /* Age the cache, releasing compilation units that have not
3022 been used recently. */
3023 age_cached_comp_units ();
3025 do_cleanups (back_to
);
3028 /* Load the DIEs associated with PER_CU into memory. */
3031 load_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
, struct objfile
*objfile
)
3033 bfd
*abfd
= objfile
->obfd
;
3034 struct dwarf2_cu
*cu
;
3035 unsigned int offset
;
3036 gdb_byte
*info_ptr
, *beg_of_comp_unit
;
3037 struct cleanup
*back_to
, *free_cu_cleanup
;
3038 struct attribute
*attr
;
3040 gdb_assert (! per_cu
->from_debug_types
);
3042 /* Set local variables from the partial symbol table info. */
3043 offset
= per_cu
->offset
;
3045 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
3046 info_ptr
= dwarf2_per_objfile
->info
.buffer
+ offset
;
3047 beg_of_comp_unit
= info_ptr
;
3049 cu
= alloc_one_comp_unit (objfile
);
3051 /* If an error occurs while loading, release our storage. */
3052 free_cu_cleanup
= make_cleanup (free_one_comp_unit
, cu
);
3054 /* Read in the comp_unit header. */
3055 info_ptr
= read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
3057 /* Complete the cu_header. */
3058 cu
->header
.offset
= offset
;
3059 cu
->header
.first_die_offset
= info_ptr
- beg_of_comp_unit
;
3061 /* Read the abbrevs for this compilation unit. */
3062 dwarf2_read_abbrevs (abfd
, cu
);
3063 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
3065 /* Link this compilation unit into the compilation unit tree. */
3067 cu
->per_cu
= per_cu
;
3068 cu
->type_hash
= per_cu
->type_hash
;
3070 cu
->dies
= read_comp_unit (info_ptr
, cu
);
3072 /* We try not to read any attributes in this function, because not
3073 all objfiles needed for references have been loaded yet, and symbol
3074 table processing isn't initialized. But we have to set the CU language,
3075 or we won't be able to build types correctly. */
3076 attr
= dwarf2_attr (cu
->dies
, DW_AT_language
, cu
);
3078 set_cu_language (DW_UNSND (attr
), cu
);
3080 set_cu_language (language_minimal
, cu
);
3082 /* Similarly, if we do not read the producer, we can not apply
3083 producer-specific interpretation. */
3084 attr
= dwarf2_attr (cu
->dies
, DW_AT_producer
, cu
);
3086 cu
->producer
= DW_STRING (attr
);
3088 /* Link this CU into read_in_chain. */
3089 per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
3090 dwarf2_per_objfile
->read_in_chain
= per_cu
;
3092 do_cleanups (back_to
);
3094 /* We've successfully allocated this compilation unit. Let our caller
3095 clean it up when finished with it. */
3096 discard_cleanups (free_cu_cleanup
);
3099 /* Generate full symbol information for PST and CU, whose DIEs have
3100 already been loaded into memory. */
3103 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
3105 struct partial_symtab
*pst
= per_cu
->psymtab
;
3106 struct dwarf2_cu
*cu
= per_cu
->cu
;
3107 struct objfile
*objfile
= pst
->objfile
;
3108 CORE_ADDR lowpc
, highpc
;
3109 struct symtab
*symtab
;
3110 struct cleanup
*back_to
;
3113 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3116 back_to
= make_cleanup (really_free_pendings
, NULL
);
3118 cu
->list_in_scope
= &file_symbols
;
3120 dwarf2_find_base_address (cu
->dies
, cu
);
3122 /* Do line number decoding in read_file_scope () */
3123 process_die (cu
->dies
, cu
);
3125 /* Some compilers don't define a DW_AT_high_pc attribute for the
3126 compilation unit. If the DW_AT_high_pc is missing, synthesize
3127 it, by scanning the DIE's below the compilation unit. */
3128 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
3130 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
3132 /* Set symtab language to language from DW_AT_language.
3133 If the compilation is from a C file generated by language preprocessors,
3134 do not set the language if it was already deduced by start_subfile. */
3136 && !(cu
->language
== language_c
&& symtab
->language
!= language_c
))
3138 symtab
->language
= cu
->language
;
3140 pst
->symtab
= symtab
;
3143 do_cleanups (back_to
);
3146 /* Process a die and its children. */
3149 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
3153 case DW_TAG_padding
:
3155 case DW_TAG_compile_unit
:
3156 read_file_scope (die
, cu
);
3158 case DW_TAG_type_unit
:
3159 read_type_unit_scope (die
, cu
);
3161 case DW_TAG_subprogram
:
3162 case DW_TAG_inlined_subroutine
:
3163 read_func_scope (die
, cu
);
3165 case DW_TAG_lexical_block
:
3166 case DW_TAG_try_block
:
3167 case DW_TAG_catch_block
:
3168 read_lexical_block_scope (die
, cu
);
3170 case DW_TAG_class_type
:
3171 case DW_TAG_interface_type
:
3172 case DW_TAG_structure_type
:
3173 case DW_TAG_union_type
:
3174 process_structure_scope (die
, cu
);
3176 case DW_TAG_enumeration_type
:
3177 process_enumeration_scope (die
, cu
);
3180 /* These dies have a type, but processing them does not create
3181 a symbol or recurse to process the children. Therefore we can
3182 read them on-demand through read_type_die. */
3183 case DW_TAG_subroutine_type
:
3184 case DW_TAG_set_type
:
3185 case DW_TAG_array_type
:
3186 case DW_TAG_pointer_type
:
3187 case DW_TAG_ptr_to_member_type
:
3188 case DW_TAG_reference_type
:
3189 case DW_TAG_string_type
:
3192 case DW_TAG_base_type
:
3193 case DW_TAG_subrange_type
:
3194 case DW_TAG_typedef
:
3195 case DW_TAG_const_type
:
3196 case DW_TAG_volatile_type
:
3197 /* Add a typedef symbol for the type definition, if it has a
3199 new_symbol (die
, read_type_die (die
, cu
), cu
);
3201 case DW_TAG_common_block
:
3202 read_common_block (die
, cu
);
3204 case DW_TAG_common_inclusion
:
3206 case DW_TAG_namespace
:
3207 processing_has_namespace_info
= 1;
3208 read_namespace (die
, cu
);
3211 read_module (die
, cu
);
3213 case DW_TAG_imported_declaration
:
3214 case DW_TAG_imported_module
:
3215 processing_has_namespace_info
= 1;
3216 if (die
->child
!= NULL
&& (die
->tag
== DW_TAG_imported_declaration
3217 || cu
->language
!= language_fortran
))
3218 complaint (&symfile_complaints
, _("Tag '%s' has unexpected children"),
3219 dwarf_tag_name (die
->tag
));
3220 read_import_statement (die
, cu
);
3223 new_symbol (die
, NULL
, cu
);
3228 /* A helper function for dwarf2_compute_name which determines whether DIE
3229 needs to have the name of the scope prepended to the name listed in the
3233 die_needs_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
3235 struct attribute
*attr
;
3239 case DW_TAG_namespace
:
3240 case DW_TAG_typedef
:
3241 case DW_TAG_class_type
:
3242 case DW_TAG_interface_type
:
3243 case DW_TAG_structure_type
:
3244 case DW_TAG_union_type
:
3245 case DW_TAG_enumeration_type
:
3246 case DW_TAG_enumerator
:
3247 case DW_TAG_subprogram
:
3251 case DW_TAG_variable
:
3252 /* We only need to prefix "globally" visible variables. These include
3253 any variable marked with DW_AT_external or any variable that
3254 lives in a namespace. [Variables in anonymous namespaces
3255 require prefixing, but they are not DW_AT_external.] */
3257 if (dwarf2_attr (die
, DW_AT_specification
, cu
))
3259 struct dwarf2_cu
*spec_cu
= cu
;
3261 return die_needs_namespace (die_specification (die
, &spec_cu
),
3265 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
3266 if (attr
== NULL
&& die
->parent
->tag
!= DW_TAG_namespace
)
3268 /* A variable in a lexical block of some kind does not need a
3269 namespace, even though in C++ such variables may be external
3270 and have a mangled name. */
3271 if (die
->parent
->tag
== DW_TAG_lexical_block
3272 || die
->parent
->tag
== DW_TAG_try_block
3273 || die
->parent
->tag
== DW_TAG_catch_block
3274 || die
->parent
->tag
== DW_TAG_subprogram
)
3283 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
3284 compute the physname for the object, which include a method's
3285 formal parameters (C++/Java) and return type (Java).
3287 For Ada, return the DIE's linkage name rather than the fully qualified
3288 name. PHYSNAME is ignored..
3290 The result is allocated on the objfile_obstack and canonicalized. */
3293 dwarf2_compute_name (char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
,
3297 name
= dwarf2_name (die
, cu
);
3299 /* These are the only languages we know how to qualify names in. */
3301 && (cu
->language
== language_cplus
|| cu
->language
== language_java
))
3303 if (die_needs_namespace (die
, cu
))
3307 struct ui_file
*buf
;
3309 prefix
= determine_prefix (die
, cu
);
3310 buf
= mem_fileopen ();
3311 if (*prefix
!= '\0')
3313 char *prefixed_name
= typename_concat (NULL
, prefix
, name
, cu
);
3315 fputs_unfiltered (prefixed_name
, buf
);
3316 xfree (prefixed_name
);
3319 fputs_unfiltered (name
? name
: "", buf
);
3321 /* For Java and C++ methods, append formal parameter type
3322 information, if PHYSNAME. */
3324 if (physname
&& die
->tag
== DW_TAG_subprogram
3325 && (cu
->language
== language_cplus
3326 || cu
->language
== language_java
))
3328 struct type
*type
= read_type_die (die
, cu
);
3330 c_type_print_args (type
, buf
, 0, cu
->language
);
3332 if (cu
->language
== language_java
)
3334 /* For java, we must append the return type to method
3336 if (die
->tag
== DW_TAG_subprogram
)
3337 java_print_type (TYPE_TARGET_TYPE (type
), "", buf
,
3340 else if (cu
->language
== language_cplus
)
3342 if (TYPE_NFIELDS (type
) > 0
3343 && TYPE_FIELD_ARTIFICIAL (type
, 0)
3344 && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type
, 0))))
3345 fputs_unfiltered (" const", buf
);
3349 name
= ui_file_obsavestring (buf
, &cu
->objfile
->objfile_obstack
,
3351 ui_file_delete (buf
);
3353 if (cu
->language
== language_cplus
)
3356 = dwarf2_canonicalize_name (name
, cu
,
3357 &cu
->objfile
->objfile_obstack
);
3364 else if (cu
->language
== language_ada
)
3366 /* For Ada unit, we prefer the linkage name over the name, as
3367 the former contains the exported name, which the user expects
3368 to be able to reference. Ideally, we want the user to be able
3369 to reference this entity using either natural or linkage name,
3370 but we haven't started looking at this enhancement yet. */
3371 struct attribute
*attr
;
3373 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
3375 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
3376 if (attr
&& DW_STRING (attr
))
3377 name
= DW_STRING (attr
);
3383 /* Return the fully qualified name of DIE, based on its DW_AT_name.
3384 If scope qualifiers are appropriate they will be added. The result
3385 will be allocated on the objfile_obstack, or NULL if the DIE does
3386 not have a name. NAME may either be from a previous call to
3387 dwarf2_name or NULL.
3389 The output string will be canonicalized (if C++/Java). */
3392 dwarf2_full_name (char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
3394 return dwarf2_compute_name (name
, die
, cu
, 0);
3397 /* Construct a physname for the given DIE in CU. NAME may either be
3398 from a previous call to dwarf2_name or NULL. The result will be
3399 allocated on the objfile_objstack or NULL if the DIE does not have a
3402 The output string will be canonicalized (if C++/Java). */
3405 dwarf2_physname (char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
3407 return dwarf2_compute_name (name
, die
, cu
, 1);
3410 /* Read the import statement specified by the given die and record it. */
3413 read_import_statement (struct die_info
*die
, struct dwarf2_cu
*cu
)
3415 struct attribute
*import_attr
;
3416 struct die_info
*imported_die
;
3417 struct dwarf2_cu
*imported_cu
;
3418 const char *imported_name
;
3419 const char *imported_name_prefix
;
3420 const char *canonical_name
;
3421 const char *import_alias
;
3422 const char *imported_declaration
= NULL
;
3423 const char *import_prefix
;
3427 import_attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
3428 if (import_attr
== NULL
)
3430 complaint (&symfile_complaints
, _("Tag '%s' has no DW_AT_import"),
3431 dwarf_tag_name (die
->tag
));
3436 imported_die
= follow_die_ref_or_sig (die
, import_attr
, &imported_cu
);
3437 imported_name
= dwarf2_name (imported_die
, imported_cu
);
3438 if (imported_name
== NULL
)
3440 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
3442 The import in the following code:
3456 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
3457 <52> DW_AT_decl_file : 1
3458 <53> DW_AT_decl_line : 6
3459 <54> DW_AT_import : <0x75>
3460 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
3462 <5b> DW_AT_decl_file : 1
3463 <5c> DW_AT_decl_line : 2
3464 <5d> DW_AT_type : <0x6e>
3466 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
3467 <76> DW_AT_byte_size : 4
3468 <77> DW_AT_encoding : 5 (signed)
3470 imports the wrong die ( 0x75 instead of 0x58 ).
3471 This case will be ignored until the gcc bug is fixed. */
3475 /* Figure out the local name after import. */
3476 import_alias
= dwarf2_name (die
, cu
);
3478 /* Figure out where the statement is being imported to. */
3479 import_prefix
= determine_prefix (die
, cu
);
3481 /* Figure out what the scope of the imported die is and prepend it
3482 to the name of the imported die. */
3483 imported_name_prefix
= determine_prefix (imported_die
, imported_cu
);
3485 if (imported_die
->tag
!= DW_TAG_namespace
)
3487 imported_declaration
= imported_name
;
3488 canonical_name
= imported_name_prefix
;
3490 else if (strlen (imported_name_prefix
) > 0)
3492 temp
= alloca (strlen (imported_name_prefix
)
3493 + 2 + strlen (imported_name
) + 1);
3494 strcpy (temp
, imported_name_prefix
);
3495 strcat (temp
, "::");
3496 strcat (temp
, imported_name
);
3497 canonical_name
= temp
;
3500 canonical_name
= imported_name
;
3502 cp_add_using_directive (import_prefix
,
3505 imported_declaration
,
3506 &cu
->objfile
->objfile_obstack
);
3510 initialize_cu_func_list (struct dwarf2_cu
*cu
)
3512 cu
->first_fn
= cu
->last_fn
= cu
->cached_fn
= NULL
;
3516 free_cu_line_header (void *arg
)
3518 struct dwarf2_cu
*cu
= arg
;
3520 free_line_header (cu
->line_header
);
3521 cu
->line_header
= NULL
;
3525 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
3527 struct objfile
*objfile
= cu
->objfile
;
3528 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
3529 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
3530 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
3531 struct attribute
*attr
;
3533 char *comp_dir
= NULL
;
3534 struct die_info
*child_die
;
3535 bfd
*abfd
= objfile
->obfd
;
3536 struct line_header
*line_header
= 0;
3539 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3541 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
3543 /* If we didn't find a lowpc, set it to highpc to avoid complaints
3544 from finish_block. */
3545 if (lowpc
== ((CORE_ADDR
) -1))
3550 /* Find the filename. Do not use dwarf2_name here, since the filename
3551 is not a source language identifier. */
3552 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3555 name
= DW_STRING (attr
);
3558 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
3560 comp_dir
= DW_STRING (attr
);
3561 else if (name
!= NULL
&& IS_ABSOLUTE_PATH (name
))
3563 comp_dir
= ldirname (name
);
3564 if (comp_dir
!= NULL
)
3565 make_cleanup (xfree
, comp_dir
);
3567 if (comp_dir
!= NULL
)
3569 /* Irix 6.2 native cc prepends <machine>.: to the compilation
3570 directory, get rid of it. */
3571 char *cp
= strchr (comp_dir
, ':');
3573 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
3580 attr
= dwarf2_attr (die
, DW_AT_language
, cu
);
3583 set_cu_language (DW_UNSND (attr
), cu
);
3586 attr
= dwarf2_attr (die
, DW_AT_producer
, cu
);
3588 cu
->producer
= DW_STRING (attr
);
3590 /* We assume that we're processing GCC output. */
3591 processing_gcc_compilation
= 2;
3593 processing_has_namespace_info
= 0;
3595 start_symtab (name
, comp_dir
, lowpc
);
3596 record_debugformat ("DWARF 2");
3597 record_producer (cu
->producer
);
3599 initialize_cu_func_list (cu
);
3601 /* Decode line number information if present. We do this before
3602 processing child DIEs, so that the line header table is available
3603 for DW_AT_decl_file. */
3604 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
3607 unsigned int line_offset
= DW_UNSND (attr
);
3608 line_header
= dwarf_decode_line_header (line_offset
, abfd
, cu
);
3611 cu
->line_header
= line_header
;
3612 make_cleanup (free_cu_line_header
, cu
);
3613 dwarf_decode_lines (line_header
, comp_dir
, abfd
, cu
, NULL
);
3617 /* Process all dies in compilation unit. */
3618 if (die
->child
!= NULL
)
3620 child_die
= die
->child
;
3621 while (child_die
&& child_die
->tag
)
3623 process_die (child_die
, cu
);
3624 child_die
= sibling_die (child_die
);
3628 /* Decode macro information, if present. Dwarf 2 macro information
3629 refers to information in the line number info statement program
3630 header, so we can only read it if we've read the header
3632 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
3633 if (attr
&& line_header
)
3635 unsigned int macro_offset
= DW_UNSND (attr
);
3637 dwarf_decode_macros (line_header
, macro_offset
,
3638 comp_dir
, abfd
, cu
);
3640 do_cleanups (back_to
);
3643 /* For TUs we want to skip the first top level sibling if it's not the
3644 actual type being defined by this TU. In this case the first top
3645 level sibling is there to provide context only. */
3648 read_type_unit_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
3650 struct objfile
*objfile
= cu
->objfile
;
3651 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
3653 struct attribute
*attr
;
3655 char *comp_dir
= NULL
;
3656 struct die_info
*child_die
;
3657 bfd
*abfd
= objfile
->obfd
;
3659 /* start_symtab needs a low pc, but we don't really have one.
3660 Do what read_file_scope would do in the absence of such info. */
3661 lowpc
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3663 /* Find the filename. Do not use dwarf2_name here, since the filename
3664 is not a source language identifier. */
3665 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3667 name
= DW_STRING (attr
);
3669 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
3671 comp_dir
= DW_STRING (attr
);
3672 else if (name
!= NULL
&& IS_ABSOLUTE_PATH (name
))
3674 comp_dir
= ldirname (name
);
3675 if (comp_dir
!= NULL
)
3676 make_cleanup (xfree
, comp_dir
);
3682 attr
= dwarf2_attr (die
, DW_AT_language
, cu
);
3684 set_cu_language (DW_UNSND (attr
), cu
);
3686 /* This isn't technically needed today. It is done for symmetry
3687 with read_file_scope. */
3688 attr
= dwarf2_attr (die
, DW_AT_producer
, cu
);
3690 cu
->producer
= DW_STRING (attr
);
3692 /* We assume that we're processing GCC output. */
3693 processing_gcc_compilation
= 2;
3695 processing_has_namespace_info
= 0;
3697 start_symtab (name
, comp_dir
, lowpc
);
3698 record_debugformat ("DWARF 2");
3699 record_producer (cu
->producer
);
3701 /* Process the dies in the type unit. */
3702 if (die
->child
== NULL
)
3704 dump_die_for_error (die
);
3705 error (_("Dwarf Error: Missing children for type unit [in module %s]"),
3706 bfd_get_filename (abfd
));
3709 child_die
= die
->child
;
3711 while (child_die
&& child_die
->tag
)
3713 process_die (child_die
, cu
);
3715 child_die
= sibling_die (child_die
);
3718 do_cleanups (back_to
);
3722 add_to_cu_func_list (const char *name
, CORE_ADDR lowpc
, CORE_ADDR highpc
,
3723 struct dwarf2_cu
*cu
)
3725 struct function_range
*thisfn
;
3727 thisfn
= (struct function_range
*)
3728 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct function_range
));
3729 thisfn
->name
= name
;
3730 thisfn
->lowpc
= lowpc
;
3731 thisfn
->highpc
= highpc
;
3732 thisfn
->seen_line
= 0;
3733 thisfn
->next
= NULL
;
3735 if (cu
->last_fn
== NULL
)
3736 cu
->first_fn
= thisfn
;
3738 cu
->last_fn
->next
= thisfn
;
3740 cu
->last_fn
= thisfn
;
3743 /* qsort helper for inherit_abstract_dies. */
3746 unsigned_int_compar (const void *ap
, const void *bp
)
3748 unsigned int a
= *(unsigned int *) ap
;
3749 unsigned int b
= *(unsigned int *) bp
;
3751 return (a
> b
) - (b
> a
);
3754 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
3755 Inherit only the children of the DW_AT_abstract_origin DIE not being already
3756 referenced by DW_AT_abstract_origin from the children of the current DIE. */
3759 inherit_abstract_dies (struct die_info
*die
, struct dwarf2_cu
*cu
)
3761 struct die_info
*child_die
;
3762 unsigned die_children_count
;
3763 /* CU offsets which were referenced by children of the current DIE. */
3765 unsigned *offsets_end
, *offsetp
;
3766 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
3767 struct die_info
*origin_die
;
3768 /* Iterator of the ORIGIN_DIE children. */
3769 struct die_info
*origin_child_die
;
3770 struct cleanup
*cleanups
;
3771 struct attribute
*attr
;
3773 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
3777 origin_die
= follow_die_ref (die
, attr
, &cu
);
3778 if (die
->tag
!= origin_die
->tag
3779 && !(die
->tag
== DW_TAG_inlined_subroutine
3780 && origin_die
->tag
== DW_TAG_subprogram
))
3781 complaint (&symfile_complaints
,
3782 _("DIE 0x%x and its abstract origin 0x%x have different tags"),
3783 die
->offset
, origin_die
->offset
);
3785 child_die
= die
->child
;
3786 die_children_count
= 0;
3787 while (child_die
&& child_die
->tag
)
3789 child_die
= sibling_die (child_die
);
3790 die_children_count
++;
3792 offsets
= xmalloc (sizeof (*offsets
) * die_children_count
);
3793 cleanups
= make_cleanup (xfree
, offsets
);
3795 offsets_end
= offsets
;
3796 child_die
= die
->child
;
3797 while (child_die
&& child_die
->tag
)
3799 /* For each CHILD_DIE, find the corresponding child of
3800 ORIGIN_DIE. If there is more than one layer of
3801 DW_AT_abstract_origin, follow them all; there shouldn't be,
3802 but GCC versions at least through 4.4 generate this (GCC PR
3804 struct die_info
*child_origin_die
= child_die
;
3808 attr
= dwarf2_attr (child_origin_die
, DW_AT_abstract_origin
, cu
);
3811 child_origin_die
= follow_die_ref (child_origin_die
, attr
, &cu
);
3814 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
3815 counterpart may exist. */
3816 if (child_origin_die
!= child_die
)
3818 if (child_die
->tag
!= child_origin_die
->tag
3819 && !(child_die
->tag
== DW_TAG_inlined_subroutine
3820 && child_origin_die
->tag
== DW_TAG_subprogram
))
3821 complaint (&symfile_complaints
,
3822 _("Child DIE 0x%x and its abstract origin 0x%x have "
3823 "different tags"), child_die
->offset
,
3824 child_origin_die
->offset
);
3825 if (child_origin_die
->parent
!= origin_die
)
3826 complaint (&symfile_complaints
,
3827 _("Child DIE 0x%x and its abstract origin 0x%x have "
3828 "different parents"), child_die
->offset
,
3829 child_origin_die
->offset
);
3831 *offsets_end
++ = child_origin_die
->offset
;
3833 child_die
= sibling_die (child_die
);
3835 qsort (offsets
, offsets_end
- offsets
, sizeof (*offsets
),
3836 unsigned_int_compar
);
3837 for (offsetp
= offsets
+ 1; offsetp
< offsets_end
; offsetp
++)
3838 if (offsetp
[-1] == *offsetp
)
3839 complaint (&symfile_complaints
, _("Multiple children of DIE 0x%x refer "
3840 "to DIE 0x%x as their abstract origin"),
3841 die
->offset
, *offsetp
);
3844 origin_child_die
= origin_die
->child
;
3845 while (origin_child_die
&& origin_child_die
->tag
)
3847 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
3848 while (offsetp
< offsets_end
&& *offsetp
< origin_child_die
->offset
)
3850 if (offsetp
>= offsets_end
|| *offsetp
> origin_child_die
->offset
)
3852 /* Found that ORIGIN_CHILD_DIE is really not referenced. */
3853 process_die (origin_child_die
, cu
);
3855 origin_child_die
= sibling_die (origin_child_die
);
3858 do_cleanups (cleanups
);
3862 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
3864 struct objfile
*objfile
= cu
->objfile
;
3865 struct context_stack
*new;
3868 struct die_info
*child_die
;
3869 struct attribute
*attr
, *call_line
, *call_file
;
3872 struct block
*block
;
3873 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
3877 /* If we do not have call site information, we can't show the
3878 caller of this inlined function. That's too confusing, so
3879 only use the scope for local variables. */
3880 call_line
= dwarf2_attr (die
, DW_AT_call_line
, cu
);
3881 call_file
= dwarf2_attr (die
, DW_AT_call_file
, cu
);
3882 if (call_line
== NULL
|| call_file
== NULL
)
3884 read_lexical_block_scope (die
, cu
);
3889 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3891 name
= dwarf2_name (die
, cu
);
3893 /* Ignore functions with missing or empty names. These are actually
3894 illegal according to the DWARF standard. */
3897 complaint (&symfile_complaints
,
3898 _("missing name for subprogram DIE at %d"), die
->offset
);
3902 /* Ignore functions with missing or invalid low and high pc attributes. */
3903 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
3905 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
3906 if (!attr
|| !DW_UNSND (attr
))
3907 complaint (&symfile_complaints
,
3908 _("cannot get low and high bounds for subprogram DIE at %d"),
3916 /* Record the function range for dwarf_decode_lines. */
3917 add_to_cu_func_list (name
, lowpc
, highpc
, cu
);
3919 new = push_context (0, lowpc
);
3920 new->name
= new_symbol (die
, read_type_die (die
, cu
), cu
);
3922 /* If there is a location expression for DW_AT_frame_base, record
3924 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
3926 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
3927 expression is being recorded directly in the function's symbol
3928 and not in a separate frame-base object. I guess this hack is
3929 to avoid adding some sort of frame-base adjunct/annex to the
3930 function's symbol :-(. The problem with doing this is that it
3931 results in a function symbol with a location expression that
3932 has nothing to do with the location of the function, ouch! The
3933 relationship should be: a function's symbol has-a frame base; a
3934 frame-base has-a location expression. */
3935 dwarf2_symbol_mark_computed (attr
, new->name
, cu
);
3937 cu
->list_in_scope
= &local_symbols
;
3939 if (die
->child
!= NULL
)
3941 child_die
= die
->child
;
3942 while (child_die
&& child_die
->tag
)
3944 process_die (child_die
, cu
);
3945 child_die
= sibling_die (child_die
);
3949 inherit_abstract_dies (die
, cu
);
3951 /* If we have a DW_AT_specification, we might need to import using
3952 directives from the context of the specification DIE. See the
3953 comment in determine_prefix. */
3954 if (cu
->language
== language_cplus
3955 && dwarf2_attr (die
, DW_AT_specification
, cu
))
3957 struct dwarf2_cu
*spec_cu
= cu
;
3958 struct die_info
*spec_die
= die_specification (die
, &spec_cu
);
3962 child_die
= spec_die
->child
;
3963 while (child_die
&& child_die
->tag
)
3965 if (child_die
->tag
== DW_TAG_imported_module
)
3966 process_die (child_die
, spec_cu
);
3967 child_die
= sibling_die (child_die
);
3970 /* In some cases, GCC generates specification DIEs that
3971 themselves contain DW_AT_specification attributes. */
3972 spec_die
= die_specification (spec_die
, &spec_cu
);
3976 new = pop_context ();
3977 /* Make a block for the local symbols within. */
3978 block
= finish_block (new->name
, &local_symbols
, new->old_blocks
,
3979 lowpc
, highpc
, objfile
);
3981 /* For C++, set the block's scope. */
3982 if (cu
->language
== language_cplus
)
3983 cp_set_block_scope (new->name
, block
, &objfile
->objfile_obstack
,
3984 determine_prefix (die
, cu
),
3985 processing_has_namespace_info
);
3987 /* If we have address ranges, record them. */
3988 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
3990 /* In C++, we can have functions nested inside functions (e.g., when
3991 a function declares a class that has methods). This means that
3992 when we finish processing a function scope, we may need to go
3993 back to building a containing block's symbol lists. */
3994 local_symbols
= new->locals
;
3995 param_symbols
= new->params
;
3996 using_directives
= new->using_directives
;
3998 /* If we've finished processing a top-level function, subsequent
3999 symbols go in the file symbol list. */
4000 if (outermost_context_p ())
4001 cu
->list_in_scope
= &file_symbols
;
4004 /* Process all the DIES contained within a lexical block scope. Start
4005 a new scope, process the dies, and then close the scope. */
4008 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
4010 struct objfile
*objfile
= cu
->objfile
;
4011 struct context_stack
*new;
4012 CORE_ADDR lowpc
, highpc
;
4013 struct die_info
*child_die
;
4016 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
4018 /* Ignore blocks with missing or invalid low and high pc attributes. */
4019 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
4020 as multiple lexical blocks? Handling children in a sane way would
4021 be nasty. Might be easier to properly extend generic blocks to
4023 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
4028 push_context (0, lowpc
);
4029 if (die
->child
!= NULL
)
4031 child_die
= die
->child
;
4032 while (child_die
&& child_die
->tag
)
4034 process_die (child_die
, cu
);
4035 child_die
= sibling_die (child_die
);
4038 new = pop_context ();
4040 if (local_symbols
!= NULL
|| using_directives
!= NULL
)
4043 = finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
4046 /* Note that recording ranges after traversing children, as we
4047 do here, means that recording a parent's ranges entails
4048 walking across all its children's ranges as they appear in
4049 the address map, which is quadratic behavior.
4051 It would be nicer to record the parent's ranges before
4052 traversing its children, simply overriding whatever you find
4053 there. But since we don't even decide whether to create a
4054 block until after we've traversed its children, that's hard
4056 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
4058 local_symbols
= new->locals
;
4059 using_directives
= new->using_directives
;
4062 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
4063 Return 1 if the attributes are present and valid, otherwise, return 0.
4064 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
4067 dwarf2_ranges_read (unsigned offset
, CORE_ADDR
*low_return
,
4068 CORE_ADDR
*high_return
, struct dwarf2_cu
*cu
,
4069 struct partial_symtab
*ranges_pst
)
4071 struct objfile
*objfile
= cu
->objfile
;
4072 struct comp_unit_head
*cu_header
= &cu
->header
;
4073 bfd
*obfd
= objfile
->obfd
;
4074 unsigned int addr_size
= cu_header
->addr_size
;
4075 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
4076 /* Base address selection entry. */
4087 found_base
= cu
->base_known
;
4088 base
= cu
->base_address
;
4090 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->ranges
);
4091 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
4093 complaint (&symfile_complaints
,
4094 _("Offset %d out of bounds for DW_AT_ranges attribute"),
4098 buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
4100 /* Read in the largest possible address. */
4101 marker
= read_address (obfd
, buffer
, cu
, &dummy
);
4102 if ((marker
& mask
) == mask
)
4104 /* If we found the largest possible address, then
4105 read the base address. */
4106 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
4107 buffer
+= 2 * addr_size
;
4108 offset
+= 2 * addr_size
;
4114 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
4118 CORE_ADDR range_beginning
, range_end
;
4120 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
4121 buffer
+= addr_size
;
4122 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
4123 buffer
+= addr_size
;
4124 offset
+= 2 * addr_size
;
4126 /* An end of list marker is a pair of zero addresses. */
4127 if (range_beginning
== 0 && range_end
== 0)
4128 /* Found the end of list entry. */
4131 /* Each base address selection entry is a pair of 2 values.
4132 The first is the largest possible address, the second is
4133 the base address. Check for a base address here. */
4134 if ((range_beginning
& mask
) == mask
)
4136 /* If we found the largest possible address, then
4137 read the base address. */
4138 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
4145 /* We have no valid base address for the ranges
4147 complaint (&symfile_complaints
,
4148 _("Invalid .debug_ranges data (no base address)"));
4152 range_beginning
+= base
;
4155 if (ranges_pst
!= NULL
&& range_beginning
< range_end
)
4156 addrmap_set_empty (objfile
->psymtabs_addrmap
,
4157 range_beginning
+ baseaddr
, range_end
- 1 + baseaddr
,
4160 /* FIXME: This is recording everything as a low-high
4161 segment of consecutive addresses. We should have a
4162 data structure for discontiguous block ranges
4166 low
= range_beginning
;
4172 if (range_beginning
< low
)
4173 low
= range_beginning
;
4174 if (range_end
> high
)
4180 /* If the first entry is an end-of-list marker, the range
4181 describes an empty scope, i.e. no instructions. */
4187 *high_return
= high
;
4191 /* Get low and high pc attributes from a die. Return 1 if the attributes
4192 are present and valid, otherwise, return 0. Return -1 if the range is
4193 discontinuous, i.e. derived from DW_AT_ranges information. */
4195 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
4196 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
,
4197 struct partial_symtab
*pst
)
4199 struct attribute
*attr
;
4204 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
4207 high
= DW_ADDR (attr
);
4208 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
4210 low
= DW_ADDR (attr
);
4212 /* Found high w/o low attribute. */
4215 /* Found consecutive range of addresses. */
4220 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
4223 /* Value of the DW_AT_ranges attribute is the offset in the
4224 .debug_ranges section. */
4225 if (!dwarf2_ranges_read (DW_UNSND (attr
), &low
, &high
, cu
, pst
))
4227 /* Found discontinuous range of addresses. */
4235 /* When using the GNU linker, .gnu.linkonce. sections are used to
4236 eliminate duplicate copies of functions and vtables and such.
4237 The linker will arbitrarily choose one and discard the others.
4238 The AT_*_pc values for such functions refer to local labels in
4239 these sections. If the section from that file was discarded, the
4240 labels are not in the output, so the relocs get a value of 0.
4241 If this is a discarded function, mark the pc bounds as invalid,
4242 so that GDB will ignore it. */
4243 if (low
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
4251 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
4252 its low and high PC addresses. Do nothing if these addresses could not
4253 be determined. Otherwise, set LOWPC to the low address if it is smaller,
4254 and HIGHPC to the high address if greater than HIGHPC. */
4257 dwarf2_get_subprogram_pc_bounds (struct die_info
*die
,
4258 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
4259 struct dwarf2_cu
*cu
)
4261 CORE_ADDR low
, high
;
4262 struct die_info
*child
= die
->child
;
4264 if (dwarf2_get_pc_bounds (die
, &low
, &high
, cu
, NULL
))
4266 *lowpc
= min (*lowpc
, low
);
4267 *highpc
= max (*highpc
, high
);
4270 /* If the language does not allow nested subprograms (either inside
4271 subprograms or lexical blocks), we're done. */
4272 if (cu
->language
!= language_ada
)
4275 /* Check all the children of the given DIE. If it contains nested
4276 subprograms, then check their pc bounds. Likewise, we need to
4277 check lexical blocks as well, as they may also contain subprogram
4279 while (child
&& child
->tag
)
4281 if (child
->tag
== DW_TAG_subprogram
4282 || child
->tag
== DW_TAG_lexical_block
)
4283 dwarf2_get_subprogram_pc_bounds (child
, lowpc
, highpc
, cu
);
4284 child
= sibling_die (child
);
4288 /* Get the low and high pc's represented by the scope DIE, and store
4289 them in *LOWPC and *HIGHPC. If the correct values can't be
4290 determined, set *LOWPC to -1 and *HIGHPC to 0. */
4293 get_scope_pc_bounds (struct die_info
*die
,
4294 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
4295 struct dwarf2_cu
*cu
)
4297 CORE_ADDR best_low
= (CORE_ADDR
) -1;
4298 CORE_ADDR best_high
= (CORE_ADDR
) 0;
4299 CORE_ADDR current_low
, current_high
;
4301 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
, NULL
))
4303 best_low
= current_low
;
4304 best_high
= current_high
;
4308 struct die_info
*child
= die
->child
;
4310 while (child
&& child
->tag
)
4312 switch (child
->tag
) {
4313 case DW_TAG_subprogram
:
4314 dwarf2_get_subprogram_pc_bounds (child
, &best_low
, &best_high
, cu
);
4316 case DW_TAG_namespace
:
4317 /* FIXME: carlton/2004-01-16: Should we do this for
4318 DW_TAG_class_type/DW_TAG_structure_type, too? I think
4319 that current GCC's always emit the DIEs corresponding
4320 to definitions of methods of classes as children of a
4321 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
4322 the DIEs giving the declarations, which could be
4323 anywhere). But I don't see any reason why the
4324 standards says that they have to be there. */
4325 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
4327 if (current_low
!= ((CORE_ADDR
) -1))
4329 best_low
= min (best_low
, current_low
);
4330 best_high
= max (best_high
, current_high
);
4338 child
= sibling_die (child
);
4343 *highpc
= best_high
;
4346 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
4349 dwarf2_record_block_ranges (struct die_info
*die
, struct block
*block
,
4350 CORE_ADDR baseaddr
, struct dwarf2_cu
*cu
)
4352 struct attribute
*attr
;
4354 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
4357 CORE_ADDR high
= DW_ADDR (attr
);
4359 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
4362 CORE_ADDR low
= DW_ADDR (attr
);
4364 record_block_range (block
, baseaddr
+ low
, baseaddr
+ high
- 1);
4368 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
4371 bfd
*obfd
= cu
->objfile
->obfd
;
4373 /* The value of the DW_AT_ranges attribute is the offset of the
4374 address range list in the .debug_ranges section. */
4375 unsigned long offset
= DW_UNSND (attr
);
4376 gdb_byte
*buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
4378 /* For some target architectures, but not others, the
4379 read_address function sign-extends the addresses it returns.
4380 To recognize base address selection entries, we need a
4382 unsigned int addr_size
= cu
->header
.addr_size
;
4383 CORE_ADDR base_select_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
4385 /* The base address, to which the next pair is relative. Note
4386 that this 'base' is a DWARF concept: most entries in a range
4387 list are relative, to reduce the number of relocs against the
4388 debugging information. This is separate from this function's
4389 'baseaddr' argument, which GDB uses to relocate debugging
4390 information from a shared library based on the address at
4391 which the library was loaded. */
4392 CORE_ADDR base
= cu
->base_address
;
4393 int base_known
= cu
->base_known
;
4395 gdb_assert (dwarf2_per_objfile
->ranges
.readin
);
4396 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
4398 complaint (&symfile_complaints
,
4399 _("Offset %lu out of bounds for DW_AT_ranges attribute"),
4406 unsigned int bytes_read
;
4407 CORE_ADDR start
, end
;
4409 start
= read_address (obfd
, buffer
, cu
, &bytes_read
);
4410 buffer
+= bytes_read
;
4411 end
= read_address (obfd
, buffer
, cu
, &bytes_read
);
4412 buffer
+= bytes_read
;
4414 /* Did we find the end of the range list? */
4415 if (start
== 0 && end
== 0)
4418 /* Did we find a base address selection entry? */
4419 else if ((start
& base_select_mask
) == base_select_mask
)
4425 /* We found an ordinary address range. */
4430 complaint (&symfile_complaints
,
4431 _("Invalid .debug_ranges data (no base address)"));
4435 record_block_range (block
,
4436 baseaddr
+ base
+ start
,
4437 baseaddr
+ base
+ end
- 1);
4443 /* Add an aggregate field to the field list. */
4446 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
4447 struct dwarf2_cu
*cu
)
4449 struct objfile
*objfile
= cu
->objfile
;
4450 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
4451 struct nextfield
*new_field
;
4452 struct attribute
*attr
;
4454 char *fieldname
= "";
4456 /* Allocate a new field list entry and link it in. */
4457 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
4458 make_cleanup (xfree
, new_field
);
4459 memset (new_field
, 0, sizeof (struct nextfield
));
4461 if (die
->tag
== DW_TAG_inheritance
)
4463 new_field
->next
= fip
->baseclasses
;
4464 fip
->baseclasses
= new_field
;
4468 new_field
->next
= fip
->fields
;
4469 fip
->fields
= new_field
;
4473 /* Handle accessibility and virtuality of field.
4474 The default accessibility for members is public, the default
4475 accessibility for inheritance is private. */
4476 if (die
->tag
!= DW_TAG_inheritance
)
4477 new_field
->accessibility
= DW_ACCESS_public
;
4479 new_field
->accessibility
= DW_ACCESS_private
;
4480 new_field
->virtuality
= DW_VIRTUALITY_none
;
4482 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
4484 new_field
->accessibility
= DW_UNSND (attr
);
4485 if (new_field
->accessibility
!= DW_ACCESS_public
)
4486 fip
->non_public_fields
= 1;
4487 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
4489 new_field
->virtuality
= DW_UNSND (attr
);
4491 fp
= &new_field
->field
;
4493 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
4495 /* Data member other than a C++ static data member. */
4497 /* Get type of field. */
4498 fp
->type
= die_type (die
, cu
);
4500 SET_FIELD_BITPOS (*fp
, 0);
4502 /* Get bit size of field (zero if none). */
4503 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
4506 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
4510 FIELD_BITSIZE (*fp
) = 0;
4513 /* Get bit offset of field. */
4514 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
4517 int byte_offset
= 0;
4519 if (attr_form_is_section_offset (attr
))
4520 dwarf2_complex_location_expr_complaint ();
4521 else if (attr_form_is_constant (attr
))
4522 byte_offset
= dwarf2_get_attr_constant_value (attr
, 0);
4523 else if (attr_form_is_block (attr
))
4524 byte_offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
4526 dwarf2_complex_location_expr_complaint ();
4528 SET_FIELD_BITPOS (*fp
, byte_offset
* bits_per_byte
);
4530 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
4533 if (gdbarch_bits_big_endian (gdbarch
))
4535 /* For big endian bits, the DW_AT_bit_offset gives the
4536 additional bit offset from the MSB of the containing
4537 anonymous object to the MSB of the field. We don't
4538 have to do anything special since we don't need to
4539 know the size of the anonymous object. */
4540 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
4544 /* For little endian bits, compute the bit offset to the
4545 MSB of the anonymous object, subtract off the number of
4546 bits from the MSB of the field to the MSB of the
4547 object, and then subtract off the number of bits of
4548 the field itself. The result is the bit offset of
4549 the LSB of the field. */
4551 int bit_offset
= DW_UNSND (attr
);
4553 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4556 /* The size of the anonymous object containing
4557 the bit field is explicit, so use the
4558 indicated size (in bytes). */
4559 anonymous_size
= DW_UNSND (attr
);
4563 /* The size of the anonymous object containing
4564 the bit field must be inferred from the type
4565 attribute of the data member containing the
4567 anonymous_size
= TYPE_LENGTH (fp
->type
);
4569 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
4570 - bit_offset
- FIELD_BITSIZE (*fp
);
4574 /* Get name of field. */
4575 fieldname
= dwarf2_name (die
, cu
);
4576 if (fieldname
== NULL
)
4579 /* The name is already allocated along with this objfile, so we don't
4580 need to duplicate it for the type. */
4581 fp
->name
= fieldname
;
4583 /* Change accessibility for artificial fields (e.g. virtual table
4584 pointer or virtual base class pointer) to private. */
4585 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
4587 FIELD_ARTIFICIAL (*fp
) = 1;
4588 new_field
->accessibility
= DW_ACCESS_private
;
4589 fip
->non_public_fields
= 1;
4592 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
4594 /* C++ static member. */
4596 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
4597 is a declaration, but all versions of G++ as of this writing
4598 (so through at least 3.2.1) incorrectly generate
4599 DW_TAG_variable tags. */
4603 /* Get name of field. */
4604 fieldname
= dwarf2_name (die
, cu
);
4605 if (fieldname
== NULL
)
4608 /* Get physical name. */
4609 physname
= (char *) dwarf2_physname (fieldname
, die
, cu
);
4611 /* The name is already allocated along with this objfile, so we don't
4612 need to duplicate it for the type. */
4613 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
4614 FIELD_TYPE (*fp
) = die_type (die
, cu
);
4615 FIELD_NAME (*fp
) = fieldname
;
4617 else if (die
->tag
== DW_TAG_inheritance
)
4619 /* C++ base class field. */
4620 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
4623 int byte_offset
= 0;
4625 if (attr_form_is_section_offset (attr
))
4626 dwarf2_complex_location_expr_complaint ();
4627 else if (attr_form_is_constant (attr
))
4628 byte_offset
= dwarf2_get_attr_constant_value (attr
, 0);
4629 else if (attr_form_is_block (attr
))
4630 byte_offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
4632 dwarf2_complex_location_expr_complaint ();
4634 SET_FIELD_BITPOS (*fp
, byte_offset
* bits_per_byte
);
4636 FIELD_BITSIZE (*fp
) = 0;
4637 FIELD_TYPE (*fp
) = die_type (die
, cu
);
4638 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
4639 fip
->nbaseclasses
++;
4643 /* Create the vector of fields, and attach it to the type. */
4646 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
4647 struct dwarf2_cu
*cu
)
4649 int nfields
= fip
->nfields
;
4651 /* Record the field count, allocate space for the array of fields,
4652 and create blank accessibility bitfields if necessary. */
4653 TYPE_NFIELDS (type
) = nfields
;
4654 TYPE_FIELDS (type
) = (struct field
*)
4655 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
4656 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
4658 if (fip
->non_public_fields
&& cu
->language
!= language_ada
)
4660 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
4662 TYPE_FIELD_PRIVATE_BITS (type
) =
4663 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
4664 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
4666 TYPE_FIELD_PROTECTED_BITS (type
) =
4667 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
4668 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
4670 TYPE_FIELD_IGNORE_BITS (type
) =
4671 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
4672 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
4675 /* If the type has baseclasses, allocate and clear a bit vector for
4676 TYPE_FIELD_VIRTUAL_BITS. */
4677 if (fip
->nbaseclasses
&& cu
->language
!= language_ada
)
4679 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
4680 unsigned char *pointer
;
4682 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
4683 pointer
= TYPE_ALLOC (type
, num_bytes
);
4684 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
4685 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
4686 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
4689 /* Copy the saved-up fields into the field vector. Start from the head
4690 of the list, adding to the tail of the field array, so that they end
4691 up in the same order in the array in which they were added to the list. */
4692 while (nfields
-- > 0)
4694 struct nextfield
*fieldp
;
4698 fieldp
= fip
->fields
;
4699 fip
->fields
= fieldp
->next
;
4703 fieldp
= fip
->baseclasses
;
4704 fip
->baseclasses
= fieldp
->next
;
4707 TYPE_FIELD (type
, nfields
) = fieldp
->field
;
4708 switch (fieldp
->accessibility
)
4710 case DW_ACCESS_private
:
4711 if (cu
->language
!= language_ada
)
4712 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
4715 case DW_ACCESS_protected
:
4716 if (cu
->language
!= language_ada
)
4717 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
4720 case DW_ACCESS_public
:
4724 /* Unknown accessibility. Complain and treat it as public. */
4726 complaint (&symfile_complaints
, _("unsupported accessibility %d"),
4727 fieldp
->accessibility
);
4731 if (nfields
< fip
->nbaseclasses
)
4733 switch (fieldp
->virtuality
)
4735 case DW_VIRTUALITY_virtual
:
4736 case DW_VIRTUALITY_pure_virtual
:
4737 if (cu
->language
== language_ada
)
4738 error ("unexpected virtuality in component of Ada type");
4739 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
4746 /* Add a member function to the proper fieldlist. */
4749 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
4750 struct type
*type
, struct dwarf2_cu
*cu
)
4752 struct objfile
*objfile
= cu
->objfile
;
4753 struct attribute
*attr
;
4754 struct fnfieldlist
*flp
;
4756 struct fn_field
*fnp
;
4759 struct nextfnfield
*new_fnfield
;
4760 struct type
*this_type
;
4762 if (cu
->language
== language_ada
)
4763 error ("unexpected member function in Ada type");
4765 /* Get name of member function. */
4766 fieldname
= dwarf2_name (die
, cu
);
4767 if (fieldname
== NULL
)
4770 /* Get the mangled name. */
4771 physname
= (char *) dwarf2_physname (fieldname
, die
, cu
);
4773 /* Look up member function name in fieldlist. */
4774 for (i
= 0; i
< fip
->nfnfields
; i
++)
4776 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
4780 /* Create new list element if necessary. */
4781 if (i
< fip
->nfnfields
)
4782 flp
= &fip
->fnfieldlists
[i
];
4785 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
4787 fip
->fnfieldlists
= (struct fnfieldlist
*)
4788 xrealloc (fip
->fnfieldlists
,
4789 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
4790 * sizeof (struct fnfieldlist
));
4791 if (fip
->nfnfields
== 0)
4792 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
4794 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
4795 flp
->name
= fieldname
;
4801 /* Create a new member function field and chain it to the field list
4803 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
4804 make_cleanup (xfree
, new_fnfield
);
4805 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
4806 new_fnfield
->next
= flp
->head
;
4807 flp
->head
= new_fnfield
;
4810 /* Fill in the member function field info. */
4811 fnp
= &new_fnfield
->fnfield
;
4812 /* The name is already allocated along with this objfile, so we don't
4813 need to duplicate it for the type. */
4814 fnp
->physname
= physname
? physname
: "";
4815 fnp
->type
= alloc_type (objfile
);
4816 this_type
= read_type_die (die
, cu
);
4817 if (this_type
&& TYPE_CODE (this_type
) == TYPE_CODE_FUNC
)
4819 int nparams
= TYPE_NFIELDS (this_type
);
4821 /* TYPE is the domain of this method, and THIS_TYPE is the type
4822 of the method itself (TYPE_CODE_METHOD). */
4823 smash_to_method_type (fnp
->type
, type
,
4824 TYPE_TARGET_TYPE (this_type
),
4825 TYPE_FIELDS (this_type
),
4826 TYPE_NFIELDS (this_type
),
4827 TYPE_VARARGS (this_type
));
4829 /* Handle static member functions.
4830 Dwarf2 has no clean way to discern C++ static and non-static
4831 member functions. G++ helps GDB by marking the first
4832 parameter for non-static member functions (which is the
4833 this pointer) as artificial. We obtain this information
4834 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
4835 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (this_type
, 0) == 0)
4836 fnp
->voffset
= VOFFSET_STATIC
;
4839 complaint (&symfile_complaints
, _("member function type missing for '%s'"),
4842 /* Get fcontext from DW_AT_containing_type if present. */
4843 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
4844 fnp
->fcontext
= die_containing_type (die
, cu
);
4846 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
4847 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
4849 /* Get accessibility. */
4850 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
4853 switch (DW_UNSND (attr
))
4855 case DW_ACCESS_private
:
4856 fnp
->is_private
= 1;
4858 case DW_ACCESS_protected
:
4859 fnp
->is_protected
= 1;
4864 /* Check for artificial methods. */
4865 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
4866 if (attr
&& DW_UNSND (attr
) != 0)
4867 fnp
->is_artificial
= 1;
4869 /* Get index in virtual function table if it is a virtual member
4870 function. For GCC, this is an offset in the appropriate
4871 virtual table, as specified by DW_AT_containing_type. For
4872 everyone else, it is an expression to be evaluated relative
4873 to the object address. */
4875 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
4876 if (attr
&& fnp
->fcontext
)
4878 /* Support the .debug_loc offsets */
4879 if (attr_form_is_block (attr
))
4881 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
4883 else if (attr_form_is_section_offset (attr
))
4885 dwarf2_complex_location_expr_complaint ();
4889 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
4895 /* We only support trivial expressions here. This hack will work
4896 for v3 classes, which always start with the vtable pointer. */
4897 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
> 0
4898 && DW_BLOCK (attr
)->data
[0] == DW_OP_deref
)
4900 struct dwarf_block blk
;
4902 blk
.size
= DW_BLOCK (attr
)->size
- 1;
4903 blk
.data
= DW_BLOCK (attr
)->data
+ 1;
4904 fnp
->voffset
= decode_locdesc (&blk
, cu
);
4905 if ((fnp
->voffset
% cu
->header
.addr_size
) != 0)
4906 dwarf2_complex_location_expr_complaint ();
4908 fnp
->voffset
/= cu
->header
.addr_size
;
4910 fnp
->fcontext
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type
, 0));
4913 dwarf2_complex_location_expr_complaint ();
4917 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
4918 if (attr
&& DW_UNSND (attr
))
4920 /* GCC does this, as of 2008-08-25; PR debug/37237. */
4921 complaint (&symfile_complaints
,
4922 _("Member function \"%s\" (offset %d) is virtual but the vtable offset is not specified"),
4923 fieldname
, die
->offset
);
4924 TYPE_CPLUS_DYNAMIC (type
) = 1;
4929 /* Create the vector of member function fields, and attach it to the type. */
4932 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
4933 struct dwarf2_cu
*cu
)
4935 struct fnfieldlist
*flp
;
4936 int total_length
= 0;
4939 if (cu
->language
== language_ada
)
4940 error ("unexpected member functions in Ada type");
4942 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
4943 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
4944 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
4946 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
4948 struct nextfnfield
*nfp
= flp
->head
;
4949 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
4952 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
4953 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
4954 fn_flp
->fn_fields
= (struct fn_field
*)
4955 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
4956 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
4957 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
4959 total_length
+= flp
->length
;
4962 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
4963 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
4966 /* Returns non-zero if NAME is the name of a vtable member in CU's
4967 language, zero otherwise. */
4969 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
4971 static const char vptr
[] = "_vptr";
4972 static const char vtable
[] = "vtable";
4974 /* Look for the C++ and Java forms of the vtable. */
4975 if ((cu
->language
== language_java
4976 && strncmp (name
, vtable
, sizeof (vtable
) - 1) == 0)
4977 || (strncmp (name
, vptr
, sizeof (vptr
) - 1) == 0
4978 && is_cplus_marker (name
[sizeof (vptr
) - 1])))
4984 /* GCC outputs unnamed structures that are really pointers to member
4985 functions, with the ABI-specified layout. If TYPE describes
4986 such a structure, smash it into a member function type.
4988 GCC shouldn't do this; it should just output pointer to member DIEs.
4989 This is GCC PR debug/28767. */
4992 quirk_gcc_member_function_pointer (struct type
*type
, struct objfile
*objfile
)
4994 struct type
*pfn_type
, *domain_type
, *new_type
;
4996 /* Check for a structure with no name and two children. */
4997 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
|| TYPE_NFIELDS (type
) != 2)
5000 /* Check for __pfn and __delta members. */
5001 if (TYPE_FIELD_NAME (type
, 0) == NULL
5002 || strcmp (TYPE_FIELD_NAME (type
, 0), "__pfn") != 0
5003 || TYPE_FIELD_NAME (type
, 1) == NULL
5004 || strcmp (TYPE_FIELD_NAME (type
, 1), "__delta") != 0)
5007 /* Find the type of the method. */
5008 pfn_type
= TYPE_FIELD_TYPE (type
, 0);
5009 if (pfn_type
== NULL
5010 || TYPE_CODE (pfn_type
) != TYPE_CODE_PTR
5011 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type
)) != TYPE_CODE_FUNC
)
5014 /* Look for the "this" argument. */
5015 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
5016 if (TYPE_NFIELDS (pfn_type
) == 0
5017 /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
5018 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type
, 0)) != TYPE_CODE_PTR
)
5021 domain_type
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type
, 0));
5022 new_type
= alloc_type (objfile
);
5023 smash_to_method_type (new_type
, domain_type
, TYPE_TARGET_TYPE (pfn_type
),
5024 TYPE_FIELDS (pfn_type
), TYPE_NFIELDS (pfn_type
),
5025 TYPE_VARARGS (pfn_type
));
5026 smash_to_methodptr_type (type
, new_type
);
5029 /* Called when we find the DIE that starts a structure or union scope
5030 (definition) to process all dies that define the members of the
5033 NOTE: we need to call struct_type regardless of whether or not the
5034 DIE has an at_name attribute, since it might be an anonymous
5035 structure or union. This gets the type entered into our set of
5038 However, if the structure is incomplete (an opaque struct/union)
5039 then suppress creating a symbol table entry for it since gdb only
5040 wants to find the one with the complete definition. Note that if
5041 it is complete, we just call new_symbol, which does it's own
5042 checking about whether the struct/union is anonymous or not (and
5043 suppresses creating a symbol table entry itself). */
5045 static struct type
*
5046 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5048 struct objfile
*objfile
= cu
->objfile
;
5050 struct attribute
*attr
;
5052 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
5054 /* If the definition of this type lives in .debug_types, read that type.
5055 Don't follow DW_AT_specification though, that will take us back up
5056 the chain and we want to go down. */
5057 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
, cu
);
5060 struct dwarf2_cu
*type_cu
= cu
;
5061 struct die_info
*type_die
= follow_die_ref_or_sig (die
, attr
, &type_cu
);
5063 /* We could just recurse on read_structure_type, but we need to call
5064 get_die_type to ensure only one type for this DIE is created.
5065 This is important, for example, because for c++ classes we need
5066 TYPE_NAME set which is only done by new_symbol. Blech. */
5067 type
= read_type_die (type_die
, type_cu
);
5068 return set_die_type (die
, type
, cu
);
5071 type
= alloc_type (objfile
);
5072 INIT_CPLUS_SPECIFIC (type
);
5074 name
= dwarf2_name (die
, cu
);
5077 if (cu
->language
== language_cplus
5078 || cu
->language
== language_java
)
5080 TYPE_TAG_NAME (type
) = (char *) dwarf2_full_name (name
, die
, cu
);
5081 if (die
->tag
== DW_TAG_structure_type
5082 || die
->tag
== DW_TAG_class_type
)
5083 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
5087 /* The name is already allocated along with this objfile, so
5088 we don't need to duplicate it for the type. */
5089 TYPE_TAG_NAME (type
) = (char *) name
;
5090 if (die
->tag
== DW_TAG_class_type
)
5091 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
5095 if (die
->tag
== DW_TAG_structure_type
)
5097 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
5099 else if (die
->tag
== DW_TAG_union_type
)
5101 TYPE_CODE (type
) = TYPE_CODE_UNION
;
5105 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
5108 if (cu
->language
== language_cplus
&& die
->tag
== DW_TAG_class_type
)
5109 TYPE_DECLARED_CLASS (type
) = 1;
5111 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
5114 TYPE_LENGTH (type
) = DW_UNSND (attr
);
5118 TYPE_LENGTH (type
) = 0;
5121 TYPE_STUB_SUPPORTED (type
) = 1;
5122 if (die_is_declaration (die
, cu
))
5123 TYPE_STUB (type
) = 1;
5124 else if (attr
== NULL
&& die
->child
== NULL
5125 && producer_is_realview (cu
->producer
))
5126 /* RealView does not output the required DW_AT_declaration
5127 on incomplete types. */
5128 TYPE_STUB (type
) = 1;
5130 set_descriptive_type (type
, die
, cu
);
5132 /* We need to add the type field to the die immediately so we don't
5133 infinitely recurse when dealing with pointers to the structure
5134 type within the structure itself. */
5135 set_die_type (die
, type
, cu
);
5137 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
5139 struct field_info fi
;
5140 struct die_info
*child_die
;
5142 memset (&fi
, 0, sizeof (struct field_info
));
5144 child_die
= die
->child
;
5146 while (child_die
&& child_die
->tag
)
5148 if (child_die
->tag
== DW_TAG_member
5149 || child_die
->tag
== DW_TAG_variable
)
5151 /* NOTE: carlton/2002-11-05: A C++ static data member
5152 should be a DW_TAG_member that is a declaration, but
5153 all versions of G++ as of this writing (so through at
5154 least 3.2.1) incorrectly generate DW_TAG_variable
5155 tags for them instead. */
5156 dwarf2_add_field (&fi
, child_die
, cu
);
5158 else if (child_die
->tag
== DW_TAG_subprogram
)
5160 /* C++ member function. */
5161 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
5163 else if (child_die
->tag
== DW_TAG_inheritance
)
5165 /* C++ base class field. */
5166 dwarf2_add_field (&fi
, child_die
, cu
);
5168 child_die
= sibling_die (child_die
);
5171 /* Attach fields and member functions to the type. */
5173 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
5176 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
5178 /* Get the type which refers to the base class (possibly this
5179 class itself) which contains the vtable pointer for the current
5180 class from the DW_AT_containing_type attribute. This use of
5181 DW_AT_containing_type is a GNU extension. */
5183 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
5185 struct type
*t
= die_containing_type (die
, cu
);
5187 TYPE_VPTR_BASETYPE (type
) = t
;
5192 /* Our own class provides vtbl ptr. */
5193 for (i
= TYPE_NFIELDS (t
) - 1;
5194 i
>= TYPE_N_BASECLASSES (t
);
5197 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
5199 if (is_vtable_name (fieldname
, cu
))
5201 TYPE_VPTR_FIELDNO (type
) = i
;
5206 /* Complain if virtual function table field not found. */
5207 if (i
< TYPE_N_BASECLASSES (t
))
5208 complaint (&symfile_complaints
,
5209 _("virtual function table pointer not found when defining class '%s'"),
5210 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
5215 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
5218 else if (cu
->producer
5219 && strncmp (cu
->producer
,
5220 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
5222 /* The IBM XLC compiler does not provide direct indication
5223 of the containing type, but the vtable pointer is
5224 always named __vfp. */
5228 for (i
= TYPE_NFIELDS (type
) - 1;
5229 i
>= TYPE_N_BASECLASSES (type
);
5232 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
5234 TYPE_VPTR_FIELDNO (type
) = i
;
5235 TYPE_VPTR_BASETYPE (type
) = type
;
5243 quirk_gcc_member_function_pointer (type
, cu
->objfile
);
5245 do_cleanups (back_to
);
5250 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
5252 struct die_info
*child_die
= die
->child
;
5253 struct type
*this_type
;
5255 this_type
= get_die_type (die
, cu
);
5256 if (this_type
== NULL
)
5257 this_type
= read_structure_type (die
, cu
);
5259 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
5260 snapshots) has been known to create a die giving a declaration
5261 for a class that has, as a child, a die giving a definition for a
5262 nested class. So we have to process our children even if the
5263 current die is a declaration. Normally, of course, a declaration
5264 won't have any children at all. */
5266 while (child_die
!= NULL
&& child_die
->tag
)
5268 if (child_die
->tag
== DW_TAG_member
5269 || child_die
->tag
== DW_TAG_variable
5270 || child_die
->tag
== DW_TAG_inheritance
)
5275 process_die (child_die
, cu
);
5277 child_die
= sibling_die (child_die
);
5280 /* Do not consider external references. According to the DWARF standard,
5281 these DIEs are identified by the fact that they have no byte_size
5282 attribute, and a declaration attribute. */
5283 if (dwarf2_attr (die
, DW_AT_byte_size
, cu
) != NULL
5284 || !die_is_declaration (die
, cu
))
5285 new_symbol (die
, this_type
, cu
);
5288 /* Given a DW_AT_enumeration_type die, set its type. We do not
5289 complete the type's fields yet, or create any symbols. */
5291 static struct type
*
5292 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5294 struct objfile
*objfile
= cu
->objfile
;
5296 struct attribute
*attr
;
5299 /* If the definition of this type lives in .debug_types, read that type.
5300 Don't follow DW_AT_specification though, that will take us back up
5301 the chain and we want to go down. */
5302 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
, cu
);
5305 struct dwarf2_cu
*type_cu
= cu
;
5306 struct die_info
*type_die
= follow_die_ref_or_sig (die
, attr
, &type_cu
);
5308 type
= read_type_die (type_die
, type_cu
);
5309 return set_die_type (die
, type
, cu
);
5312 type
= alloc_type (objfile
);
5314 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
5315 name
= dwarf2_full_name (NULL
, die
, cu
);
5317 TYPE_TAG_NAME (type
) = (char *) name
;
5319 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
5322 TYPE_LENGTH (type
) = DW_UNSND (attr
);
5326 TYPE_LENGTH (type
) = 0;
5329 /* The enumeration DIE can be incomplete. In Ada, any type can be
5330 declared as private in the package spec, and then defined only
5331 inside the package body. Such types are known as Taft Amendment
5332 Types. When another package uses such a type, an incomplete DIE
5333 may be generated by the compiler. */
5334 if (die_is_declaration (die
, cu
))
5335 TYPE_STUB (type
) = 1;
5337 return set_die_type (die
, type
, cu
);
5340 /* Given a pointer to a die which begins an enumeration, process all
5341 the dies that define the members of the enumeration, and create the
5342 symbol for the enumeration type.
5344 NOTE: We reverse the order of the element list. */
5347 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
5349 struct die_info
*child_die
;
5350 struct field
*fields
;
5353 int unsigned_enum
= 1;
5355 struct type
*this_type
;
5359 this_type
= get_die_type (die
, cu
);
5360 if (this_type
== NULL
)
5361 this_type
= read_enumeration_type (die
, cu
);
5362 if (die
->child
!= NULL
)
5364 child_die
= die
->child
;
5365 while (child_die
&& child_die
->tag
)
5367 if (child_die
->tag
!= DW_TAG_enumerator
)
5369 process_die (child_die
, cu
);
5373 name
= dwarf2_name (child_die
, cu
);
5376 sym
= new_symbol (child_die
, this_type
, cu
);
5377 if (SYMBOL_VALUE (sym
) < 0)
5380 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
5382 fields
= (struct field
*)
5384 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
5385 * sizeof (struct field
));
5388 FIELD_NAME (fields
[num_fields
]) = SYMBOL_LINKAGE_NAME (sym
);
5389 FIELD_TYPE (fields
[num_fields
]) = NULL
;
5390 SET_FIELD_BITPOS (fields
[num_fields
], SYMBOL_VALUE (sym
));
5391 FIELD_BITSIZE (fields
[num_fields
]) = 0;
5397 child_die
= sibling_die (child_die
);
5402 TYPE_NFIELDS (this_type
) = num_fields
;
5403 TYPE_FIELDS (this_type
) = (struct field
*)
5404 TYPE_ALLOC (this_type
, sizeof (struct field
) * num_fields
);
5405 memcpy (TYPE_FIELDS (this_type
), fields
,
5406 sizeof (struct field
) * num_fields
);
5410 TYPE_UNSIGNED (this_type
) = 1;
5413 new_symbol (die
, this_type
, cu
);
5416 /* Extract all information from a DW_TAG_array_type DIE and put it in
5417 the DIE's type field. For now, this only handles one dimensional
5420 static struct type
*
5421 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5423 struct objfile
*objfile
= cu
->objfile
;
5424 struct die_info
*child_die
;
5425 struct type
*type
= NULL
;
5426 struct type
*element_type
, *range_type
, *index_type
;
5427 struct type
**range_types
= NULL
;
5428 struct attribute
*attr
;
5430 struct cleanup
*back_to
;
5433 element_type
= die_type (die
, cu
);
5435 /* Irix 6.2 native cc creates array types without children for
5436 arrays with unspecified length. */
5437 if (die
->child
== NULL
)
5439 index_type
= objfile_type (objfile
)->builtin_int
;
5440 range_type
= create_range_type (NULL
, index_type
, 0, -1);
5441 type
= create_array_type (NULL
, element_type
, range_type
);
5442 return set_die_type (die
, type
, cu
);
5445 back_to
= make_cleanup (null_cleanup
, NULL
);
5446 child_die
= die
->child
;
5447 while (child_die
&& child_die
->tag
)
5449 if (child_die
->tag
== DW_TAG_subrange_type
)
5451 struct type
*child_type
= read_type_die (child_die
, cu
);
5453 if (child_type
!= NULL
)
5455 /* The range type was succesfully read. Save it for
5456 the array type creation. */
5457 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
5459 range_types
= (struct type
**)
5460 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
5461 * sizeof (struct type
*));
5463 make_cleanup (free_current_contents
, &range_types
);
5465 range_types
[ndim
++] = child_type
;
5468 child_die
= sibling_die (child_die
);
5471 /* Dwarf2 dimensions are output from left to right, create the
5472 necessary array types in backwards order. */
5474 type
= element_type
;
5476 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
5481 type
= create_array_type (NULL
, type
, range_types
[i
++]);
5486 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
5489 /* Understand Dwarf2 support for vector types (like they occur on
5490 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
5491 array type. This is not part of the Dwarf2/3 standard yet, but a
5492 custom vendor extension. The main difference between a regular
5493 array and the vector variant is that vectors are passed by value
5495 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
5497 make_vector_type (type
);
5499 name
= dwarf2_name (die
, cu
);
5501 TYPE_NAME (type
) = name
;
5503 set_descriptive_type (type
, die
, cu
);
5505 do_cleanups (back_to
);
5507 /* Install the type in the die. */
5508 return set_die_type (die
, type
, cu
);
5511 static enum dwarf_array_dim_ordering
5512 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
5514 struct attribute
*attr
;
5516 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
5518 if (attr
) return DW_SND (attr
);
5521 GNU F77 is a special case, as at 08/2004 array type info is the
5522 opposite order to the dwarf2 specification, but data is still
5523 laid out as per normal fortran.
5525 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
5529 if (cu
->language
== language_fortran
5530 && cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
5532 return DW_ORD_row_major
;
5535 switch (cu
->language_defn
->la_array_ordering
)
5537 case array_column_major
:
5538 return DW_ORD_col_major
;
5539 case array_row_major
:
5541 return DW_ORD_row_major
;
5545 /* Extract all information from a DW_TAG_set_type DIE and put it in
5546 the DIE's type field. */
5548 static struct type
*
5549 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5551 struct type
*set_type
= create_set_type (NULL
, die_type (die
, cu
));
5552 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
5555 TYPE_LENGTH (set_type
) = DW_UNSND (attr
);
5556 return set_die_type (die
, set_type
, cu
);
5559 /* First cut: install each common block member as a global variable. */
5562 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
5564 struct die_info
*child_die
;
5565 struct attribute
*attr
;
5567 CORE_ADDR base
= (CORE_ADDR
) 0;
5569 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
5572 /* Support the .debug_loc offsets */
5573 if (attr_form_is_block (attr
))
5575 base
= decode_locdesc (DW_BLOCK (attr
), cu
);
5577 else if (attr_form_is_section_offset (attr
))
5579 dwarf2_complex_location_expr_complaint ();
5583 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
5584 "common block member");
5587 if (die
->child
!= NULL
)
5589 child_die
= die
->child
;
5590 while (child_die
&& child_die
->tag
)
5592 sym
= new_symbol (child_die
, NULL
, cu
);
5593 attr
= dwarf2_attr (child_die
, DW_AT_data_member_location
, cu
);
5596 CORE_ADDR byte_offset
= 0;
5598 if (attr_form_is_section_offset (attr
))
5599 dwarf2_complex_location_expr_complaint ();
5600 else if (attr_form_is_constant (attr
))
5601 byte_offset
= dwarf2_get_attr_constant_value (attr
, 0);
5602 else if (attr_form_is_block (attr
))
5603 byte_offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
5605 dwarf2_complex_location_expr_complaint ();
5607 SYMBOL_VALUE_ADDRESS (sym
) = base
+ byte_offset
;
5608 add_symbol_to_list (sym
, &global_symbols
);
5610 child_die
= sibling_die (child_die
);
5615 /* Create a type for a C++ namespace. */
5617 static struct type
*
5618 read_namespace_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5620 struct objfile
*objfile
= cu
->objfile
;
5621 const char *previous_prefix
, *name
;
5625 /* For extensions, reuse the type of the original namespace. */
5626 if (dwarf2_attr (die
, DW_AT_extension
, cu
) != NULL
)
5628 struct die_info
*ext_die
;
5629 struct dwarf2_cu
*ext_cu
= cu
;
5631 ext_die
= dwarf2_extension (die
, &ext_cu
);
5632 type
= read_type_die (ext_die
, ext_cu
);
5633 return set_die_type (die
, type
, cu
);
5636 name
= namespace_name (die
, &is_anonymous
, cu
);
5638 /* Now build the name of the current namespace. */
5640 previous_prefix
= determine_prefix (die
, cu
);
5641 if (previous_prefix
[0] != '\0')
5642 name
= typename_concat (&objfile
->objfile_obstack
,
5643 previous_prefix
, name
, cu
);
5645 /* Create the type. */
5646 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0, NULL
,
5648 TYPE_NAME (type
) = (char *) name
;
5649 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
5651 return set_die_type (die
, type
, cu
);
5654 /* Read a C++ namespace. */
5657 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
5659 struct objfile
*objfile
= cu
->objfile
;
5663 /* Add a symbol associated to this if we haven't seen the namespace
5664 before. Also, add a using directive if it's an anonymous
5667 if (dwarf2_attr (die
, DW_AT_extension
, cu
) == NULL
)
5671 type
= read_type_die (die
, cu
);
5672 new_symbol (die
, type
, cu
);
5674 name
= namespace_name (die
, &is_anonymous
, cu
);
5677 const char *previous_prefix
= determine_prefix (die
, cu
);
5679 cp_add_using_directive (previous_prefix
, TYPE_NAME (type
), NULL
,
5680 NULL
, &objfile
->objfile_obstack
);
5684 if (die
->child
!= NULL
)
5686 struct die_info
*child_die
= die
->child
;
5688 while (child_die
&& child_die
->tag
)
5690 process_die (child_die
, cu
);
5691 child_die
= sibling_die (child_die
);
5696 /* Read a Fortran module. */
5699 read_module (struct die_info
*die
, struct dwarf2_cu
*cu
)
5701 struct die_info
*child_die
= die
->child
;
5703 /* FIXME: Support the separate Fortran module namespaces. */
5705 while (child_die
&& child_die
->tag
)
5707 process_die (child_die
, cu
);
5708 child_die
= sibling_die (child_die
);
5712 /* Return the name of the namespace represented by DIE. Set
5713 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
5717 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
5719 struct die_info
*current_die
;
5720 const char *name
= NULL
;
5722 /* Loop through the extensions until we find a name. */
5724 for (current_die
= die
;
5725 current_die
!= NULL
;
5726 current_die
= dwarf2_extension (die
, &cu
))
5728 name
= dwarf2_name (current_die
, cu
);
5733 /* Is it an anonymous namespace? */
5735 *is_anonymous
= (name
== NULL
);
5737 name
= "(anonymous namespace)";
5742 /* Extract all information from a DW_TAG_pointer_type DIE and add to
5743 the user defined type vector. */
5745 static struct type
*
5746 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5748 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
5749 struct comp_unit_head
*cu_header
= &cu
->header
;
5751 struct attribute
*attr_byte_size
;
5752 struct attribute
*attr_address_class
;
5753 int byte_size
, addr_class
;
5755 type
= lookup_pointer_type (die_type (die
, cu
));
5757 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
5759 byte_size
= DW_UNSND (attr_byte_size
);
5761 byte_size
= cu_header
->addr_size
;
5763 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
5764 if (attr_address_class
)
5765 addr_class
= DW_UNSND (attr_address_class
);
5767 addr_class
= DW_ADDR_none
;
5769 /* If the pointer size or address class is different than the
5770 default, create a type variant marked as such and set the
5771 length accordingly. */
5772 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
5774 if (gdbarch_address_class_type_flags_p (gdbarch
))
5778 type_flags
= gdbarch_address_class_type_flags
5779 (gdbarch
, byte_size
, addr_class
);
5780 gdb_assert ((type_flags
& ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
5782 type
= make_type_with_address_space (type
, type_flags
);
5784 else if (TYPE_LENGTH (type
) != byte_size
)
5786 complaint (&symfile_complaints
, _("invalid pointer size %d"), byte_size
);
5790 /* Should we also complain about unhandled address classes? */
5794 TYPE_LENGTH (type
) = byte_size
;
5795 return set_die_type (die
, type
, cu
);
5798 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
5799 the user defined type vector. */
5801 static struct type
*
5802 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5805 struct type
*to_type
;
5806 struct type
*domain
;
5808 to_type
= die_type (die
, cu
);
5809 domain
= die_containing_type (die
, cu
);
5811 if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_METHOD
)
5812 type
= lookup_methodptr_type (to_type
);
5814 type
= lookup_memberptr_type (to_type
, domain
);
5816 return set_die_type (die
, type
, cu
);
5819 /* Extract all information from a DW_TAG_reference_type DIE and add to
5820 the user defined type vector. */
5822 static struct type
*
5823 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5825 struct comp_unit_head
*cu_header
= &cu
->header
;
5827 struct attribute
*attr
;
5829 type
= lookup_reference_type (die_type (die
, cu
));
5830 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
5833 TYPE_LENGTH (type
) = DW_UNSND (attr
);
5837 TYPE_LENGTH (type
) = cu_header
->addr_size
;
5839 return set_die_type (die
, type
, cu
);
5842 static struct type
*
5843 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5845 struct type
*base_type
, *cv_type
;
5847 base_type
= die_type (die
, cu
);
5848 cv_type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
5849 return set_die_type (die
, cv_type
, cu
);
5852 static struct type
*
5853 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5855 struct type
*base_type
, *cv_type
;
5857 base_type
= die_type (die
, cu
);
5858 cv_type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
5859 return set_die_type (die
, cv_type
, cu
);
5862 /* Extract all information from a DW_TAG_string_type DIE and add to
5863 the user defined type vector. It isn't really a user defined type,
5864 but it behaves like one, with other DIE's using an AT_user_def_type
5865 attribute to reference it. */
5867 static struct type
*
5868 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5870 struct objfile
*objfile
= cu
->objfile
;
5871 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
5872 struct type
*type
, *range_type
, *index_type
, *char_type
;
5873 struct attribute
*attr
;
5874 unsigned int length
;
5876 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
5879 length
= DW_UNSND (attr
);
5883 /* check for the DW_AT_byte_size attribute */
5884 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
5887 length
= DW_UNSND (attr
);
5895 index_type
= objfile_type (objfile
)->builtin_int
;
5896 range_type
= create_range_type (NULL
, index_type
, 1, length
);
5897 char_type
= language_string_char_type (cu
->language_defn
, gdbarch
);
5898 type
= create_string_type (NULL
, char_type
, range_type
);
5900 return set_die_type (die
, type
, cu
);
5903 /* Handle DIES due to C code like:
5907 int (*funcp)(int a, long l);
5911 ('funcp' generates a DW_TAG_subroutine_type DIE)
5914 static struct type
*
5915 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5917 struct type
*type
; /* Type that this function returns */
5918 struct type
*ftype
; /* Function that returns above type */
5919 struct attribute
*attr
;
5921 type
= die_type (die
, cu
);
5922 ftype
= lookup_function_type (type
);
5924 /* All functions in C++, Pascal and Java have prototypes. */
5925 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
5926 if ((attr
&& (DW_UNSND (attr
) != 0))
5927 || cu
->language
== language_cplus
5928 || cu
->language
== language_java
5929 || cu
->language
== language_pascal
)
5930 TYPE_PROTOTYPED (ftype
) = 1;
5931 else if (producer_is_realview (cu
->producer
))
5932 /* RealView does not emit DW_AT_prototyped. We can not
5933 distinguish prototyped and unprototyped functions; default to
5934 prototyped, since that is more common in modern code (and
5935 RealView warns about unprototyped functions). */
5936 TYPE_PROTOTYPED (ftype
) = 1;
5938 /* Store the calling convention in the type if it's available in
5939 the subroutine die. Otherwise set the calling convention to
5940 the default value DW_CC_normal. */
5941 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
5942 TYPE_CALLING_CONVENTION (ftype
) = attr
? DW_UNSND (attr
) : DW_CC_normal
;
5944 /* We need to add the subroutine type to the die immediately so
5945 we don't infinitely recurse when dealing with parameters
5946 declared as the same subroutine type. */
5947 set_die_type (die
, ftype
, cu
);
5949 if (die
->child
!= NULL
)
5951 struct type
*void_type
= objfile_type (cu
->objfile
)->builtin_void
;
5952 struct die_info
*child_die
;
5953 int nparams
, iparams
;
5955 /* Count the number of parameters.
5956 FIXME: GDB currently ignores vararg functions, but knows about
5957 vararg member functions. */
5959 child_die
= die
->child
;
5960 while (child_die
&& child_die
->tag
)
5962 if (child_die
->tag
== DW_TAG_formal_parameter
)
5964 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
5965 TYPE_VARARGS (ftype
) = 1;
5966 child_die
= sibling_die (child_die
);
5969 /* Allocate storage for parameters and fill them in. */
5970 TYPE_NFIELDS (ftype
) = nparams
;
5971 TYPE_FIELDS (ftype
) = (struct field
*)
5972 TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
));
5974 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
5975 even if we error out during the parameters reading below. */
5976 for (iparams
= 0; iparams
< nparams
; iparams
++)
5977 TYPE_FIELD_TYPE (ftype
, iparams
) = void_type
;
5980 child_die
= die
->child
;
5981 while (child_die
&& child_die
->tag
)
5983 if (child_die
->tag
== DW_TAG_formal_parameter
)
5985 /* Dwarf2 has no clean way to discern C++ static and non-static
5986 member functions. G++ helps GDB by marking the first
5987 parameter for non-static member functions (which is the
5988 this pointer) as artificial. We pass this information
5989 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
5990 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
5992 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
5995 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
5997 /* GCC/43521: In java, the formal parameter
5998 "this" is sometimes not marked with DW_AT_artificial. */
5999 if (cu
->language
== language_java
)
6001 const char *name
= dwarf2_name (child_die
, cu
);
6003 if (name
&& !strcmp (name
, "this"))
6004 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 1;
6007 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, cu
);
6010 child_die
= sibling_die (child_die
);
6017 static struct type
*
6018 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
6020 struct objfile
*objfile
= cu
->objfile
;
6021 const char *name
= NULL
;
6022 struct type
*this_type
;
6024 name
= dwarf2_full_name (NULL
, die
, cu
);
6025 this_type
= init_type (TYPE_CODE_TYPEDEF
, 0,
6026 TYPE_FLAG_TARGET_STUB
, NULL
, objfile
);
6027 TYPE_NAME (this_type
) = (char *) name
;
6028 set_die_type (die
, this_type
, cu
);
6029 TYPE_TARGET_TYPE (this_type
) = die_type (die
, cu
);
6033 /* Find a representation of a given base type and install
6034 it in the TYPE field of the die. */
6036 static struct type
*
6037 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
6039 struct objfile
*objfile
= cu
->objfile
;
6041 struct attribute
*attr
;
6042 int encoding
= 0, size
= 0;
6044 enum type_code code
= TYPE_CODE_INT
;
6046 struct type
*target_type
= NULL
;
6048 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
6051 encoding
= DW_UNSND (attr
);
6053 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
6056 size
= DW_UNSND (attr
);
6058 name
= dwarf2_name (die
, cu
);
6061 complaint (&symfile_complaints
,
6062 _("DW_AT_name missing from DW_TAG_base_type"));
6067 case DW_ATE_address
:
6068 /* Turn DW_ATE_address into a void * pointer. */
6069 code
= TYPE_CODE_PTR
;
6070 type_flags
|= TYPE_FLAG_UNSIGNED
;
6071 target_type
= init_type (TYPE_CODE_VOID
, 1, 0, NULL
, objfile
);
6073 case DW_ATE_boolean
:
6074 code
= TYPE_CODE_BOOL
;
6075 type_flags
|= TYPE_FLAG_UNSIGNED
;
6077 case DW_ATE_complex_float
:
6078 code
= TYPE_CODE_COMPLEX
;
6079 target_type
= init_type (TYPE_CODE_FLT
, size
/ 2, 0, NULL
, objfile
);
6081 case DW_ATE_decimal_float
:
6082 code
= TYPE_CODE_DECFLOAT
;
6085 code
= TYPE_CODE_FLT
;
6089 case DW_ATE_unsigned
:
6090 type_flags
|= TYPE_FLAG_UNSIGNED
;
6092 case DW_ATE_signed_char
:
6093 if (cu
->language
== language_ada
|| cu
->language
== language_m2
6094 || cu
->language
== language_pascal
)
6095 code
= TYPE_CODE_CHAR
;
6097 case DW_ATE_unsigned_char
:
6098 if (cu
->language
== language_ada
|| cu
->language
== language_m2
6099 || cu
->language
== language_pascal
)
6100 code
= TYPE_CODE_CHAR
;
6101 type_flags
|= TYPE_FLAG_UNSIGNED
;
6104 complaint (&symfile_complaints
, _("unsupported DW_AT_encoding: '%s'"),
6105 dwarf_type_encoding_name (encoding
));
6109 type
= init_type (code
, size
, type_flags
, NULL
, objfile
);
6110 TYPE_NAME (type
) = name
;
6111 TYPE_TARGET_TYPE (type
) = target_type
;
6113 if (name
&& strcmp (name
, "char") == 0)
6114 TYPE_NOSIGN (type
) = 1;
6116 return set_die_type (die
, type
, cu
);
6119 /* Read the given DW_AT_subrange DIE. */
6121 static struct type
*
6122 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
6124 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
6125 struct type
*base_type
;
6126 struct type
*range_type
;
6127 struct attribute
*attr
;
6131 LONGEST negative_mask
;
6133 base_type
= die_type (die
, cu
);
6135 if (cu
->language
== language_fortran
)
6137 /* FORTRAN implies a lower bound of 1, if not given. */
6141 /* FIXME: For variable sized arrays either of these could be
6142 a variable rather than a constant value. We'll allow it,
6143 but we don't know how to handle it. */
6144 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
6146 low
= dwarf2_get_attr_constant_value (attr
, 0);
6148 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
6151 if (attr
->form
== DW_FORM_block1
|| is_ref_attr (attr
))
6153 /* GCC encodes arrays with unspecified or dynamic length
6154 with a DW_FORM_block1 attribute or a reference attribute.
6155 FIXME: GDB does not yet know how to handle dynamic
6156 arrays properly, treat them as arrays with unspecified
6159 FIXME: jimb/2003-09-22: GDB does not really know
6160 how to handle arrays of unspecified length
6161 either; we just represent them as zero-length
6162 arrays. Choose an appropriate upper bound given
6163 the lower bound we've computed above. */
6167 high
= dwarf2_get_attr_constant_value (attr
, 1);
6171 attr
= dwarf2_attr (die
, DW_AT_count
, cu
);
6174 int count
= dwarf2_get_attr_constant_value (attr
, 1);
6175 high
= low
+ count
- 1;
6179 /* Dwarf-2 specifications explicitly allows to create subrange types
6180 without specifying a base type.
6181 In that case, the base type must be set to the type of
6182 the lower bound, upper bound or count, in that order, if any of these
6183 three attributes references an object that has a type.
6184 If no base type is found, the Dwarf-2 specifications say that
6185 a signed integer type of size equal to the size of an address should
6187 For the following C code: `extern char gdb_int [];'
6188 GCC produces an empty range DIE.
6189 FIXME: muller/2010-05-28: Possible references to object for low bound,
6190 high bound or count are not yet handled by this code.
6192 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
6194 struct objfile
*objfile
= cu
->objfile
;
6195 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
6196 int addr_size
= gdbarch_addr_bit (gdbarch
) /8;
6197 struct type
*int_type
= objfile_type (objfile
)->builtin_int
;
6199 /* Test "int", "long int", and "long long int" objfile types,
6200 and select the first one having a size above or equal to the
6201 architecture address size. */
6202 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
6203 base_type
= int_type
;
6206 int_type
= objfile_type (objfile
)->builtin_long
;
6207 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
6208 base_type
= int_type
;
6211 int_type
= objfile_type (objfile
)->builtin_long_long
;
6212 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
6213 base_type
= int_type
;
6219 (LONGEST
) -1 << (TYPE_LENGTH (base_type
) * TARGET_CHAR_BIT
- 1);
6220 if (!TYPE_UNSIGNED (base_type
) && (low
& negative_mask
))
6221 low
|= negative_mask
;
6222 if (!TYPE_UNSIGNED (base_type
) && (high
& negative_mask
))
6223 high
|= negative_mask
;
6225 range_type
= create_range_type (NULL
, base_type
, low
, high
);
6227 /* Mark arrays with dynamic length at least as an array of unspecified
6228 length. GDB could check the boundary but before it gets implemented at
6229 least allow accessing the array elements. */
6230 if (attr
&& attr
->form
== DW_FORM_block1
)
6231 TYPE_HIGH_BOUND_UNDEFINED (range_type
) = 1;
6233 name
= dwarf2_name (die
, cu
);
6235 TYPE_NAME (range_type
) = name
;
6237 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
6239 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
6241 set_descriptive_type (range_type
, die
, cu
);
6243 return set_die_type (die
, range_type
, cu
);
6246 static struct type
*
6247 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
6251 /* For now, we only support the C meaning of an unspecified type: void. */
6253 type
= init_type (TYPE_CODE_VOID
, 0, 0, NULL
, cu
->objfile
);
6254 TYPE_NAME (type
) = dwarf2_name (die
, cu
);
6256 return set_die_type (die
, type
, cu
);
6259 /* Trivial hash function for die_info: the hash value of a DIE
6260 is its offset in .debug_info for this objfile. */
6263 die_hash (const void *item
)
6265 const struct die_info
*die
= item
;
6270 /* Trivial comparison function for die_info structures: two DIEs
6271 are equal if they have the same offset. */
6274 die_eq (const void *item_lhs
, const void *item_rhs
)
6276 const struct die_info
*die_lhs
= item_lhs
;
6277 const struct die_info
*die_rhs
= item_rhs
;
6279 return die_lhs
->offset
== die_rhs
->offset
;
6282 /* Read a whole compilation unit into a linked list of dies. */
6284 static struct die_info
*
6285 read_comp_unit (gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
6287 struct die_reader_specs reader_specs
;
6289 gdb_assert (cu
->die_hash
== NULL
);
6291 = htab_create_alloc_ex (cu
->header
.length
/ 12,
6295 &cu
->comp_unit_obstack
,
6296 hashtab_obstack_allocate
,
6297 dummy_obstack_deallocate
);
6299 init_cu_die_reader (&reader_specs
, cu
);
6301 return read_die_and_children (&reader_specs
, info_ptr
, &info_ptr
, NULL
);
6304 /* Main entry point for reading a DIE and all children.
6305 Read the DIE and dump it if requested. */
6307 static struct die_info
*
6308 read_die_and_children (const struct die_reader_specs
*reader
,
6310 gdb_byte
**new_info_ptr
,
6311 struct die_info
*parent
)
6313 struct die_info
*result
= read_die_and_children_1 (reader
, info_ptr
,
6314 new_info_ptr
, parent
);
6316 if (dwarf2_die_debug
)
6318 fprintf_unfiltered (gdb_stdlog
,
6319 "\nRead die from %s of %s:\n",
6320 reader
->buffer
== dwarf2_per_objfile
->info
.buffer
6322 : reader
->buffer
== dwarf2_per_objfile
->types
.buffer
6324 : "unknown section",
6325 reader
->abfd
->filename
);
6326 dump_die (result
, dwarf2_die_debug
);
6332 /* Read a single die and all its descendents. Set the die's sibling
6333 field to NULL; set other fields in the die correctly, and set all
6334 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
6335 location of the info_ptr after reading all of those dies. PARENT
6336 is the parent of the die in question. */
6338 static struct die_info
*
6339 read_die_and_children_1 (const struct die_reader_specs
*reader
,
6341 gdb_byte
**new_info_ptr
,
6342 struct die_info
*parent
)
6344 struct die_info
*die
;
6348 cur_ptr
= read_full_die (reader
, &die
, info_ptr
, &has_children
);
6351 *new_info_ptr
= cur_ptr
;
6354 store_in_ref_table (die
, reader
->cu
);
6357 die
->child
= read_die_and_siblings (reader
, cur_ptr
, new_info_ptr
, die
);
6361 *new_info_ptr
= cur_ptr
;
6364 die
->sibling
= NULL
;
6365 die
->parent
= parent
;
6369 /* Read a die, all of its descendents, and all of its siblings; set
6370 all of the fields of all of the dies correctly. Arguments are as
6371 in read_die_and_children. */
6373 static struct die_info
*
6374 read_die_and_siblings (const struct die_reader_specs
*reader
,
6376 gdb_byte
**new_info_ptr
,
6377 struct die_info
*parent
)
6379 struct die_info
*first_die
, *last_sibling
;
6383 first_die
= last_sibling
= NULL
;
6387 struct die_info
*die
6388 = read_die_and_children_1 (reader
, cur_ptr
, &cur_ptr
, parent
);
6392 *new_info_ptr
= cur_ptr
;
6399 last_sibling
->sibling
= die
;
6405 /* Read the die from the .debug_info section buffer. Set DIEP to
6406 point to a newly allocated die with its information, except for its
6407 child, sibling, and parent fields. Set HAS_CHILDREN to tell
6408 whether the die has children or not. */
6411 read_full_die (const struct die_reader_specs
*reader
,
6412 struct die_info
**diep
, gdb_byte
*info_ptr
,
6415 unsigned int abbrev_number
, bytes_read
, i
, offset
;
6416 struct abbrev_info
*abbrev
;
6417 struct die_info
*die
;
6418 struct dwarf2_cu
*cu
= reader
->cu
;
6419 bfd
*abfd
= reader
->abfd
;
6421 offset
= info_ptr
- reader
->buffer
;
6422 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
6423 info_ptr
+= bytes_read
;
6431 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
6433 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
6435 bfd_get_filename (abfd
));
6437 die
= dwarf_alloc_die (cu
, abbrev
->num_attrs
);
6438 die
->offset
= offset
;
6439 die
->tag
= abbrev
->tag
;
6440 die
->abbrev
= abbrev_number
;
6442 die
->num_attrs
= abbrev
->num_attrs
;
6444 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
6445 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
6446 abfd
, info_ptr
, cu
);
6449 *has_children
= abbrev
->has_children
;
6453 /* In DWARF version 2, the description of the debugging information is
6454 stored in a separate .debug_abbrev section. Before we read any
6455 dies from a section we read in all abbreviations and install them
6456 in a hash table. This function also sets flags in CU describing
6457 the data found in the abbrev table. */
6460 dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
)
6462 struct comp_unit_head
*cu_header
= &cu
->header
;
6463 gdb_byte
*abbrev_ptr
;
6464 struct abbrev_info
*cur_abbrev
;
6465 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
6466 unsigned int abbrev_form
, hash_number
;
6467 struct attr_abbrev
*cur_attrs
;
6468 unsigned int allocated_attrs
;
6470 /* Initialize dwarf2 abbrevs */
6471 obstack_init (&cu
->abbrev_obstack
);
6472 cu
->dwarf2_abbrevs
= obstack_alloc (&cu
->abbrev_obstack
,
6474 * sizeof (struct abbrev_info
*)));
6475 memset (cu
->dwarf2_abbrevs
, 0,
6476 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
6478 dwarf2_read_section (dwarf2_per_objfile
->objfile
,
6479 &dwarf2_per_objfile
->abbrev
);
6480 abbrev_ptr
= dwarf2_per_objfile
->abbrev
.buffer
+ cu_header
->abbrev_offset
;
6481 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
6482 abbrev_ptr
+= bytes_read
;
6484 allocated_attrs
= ATTR_ALLOC_CHUNK
;
6485 cur_attrs
= xmalloc (allocated_attrs
* sizeof (struct attr_abbrev
));
6487 /* loop until we reach an abbrev number of 0 */
6488 while (abbrev_number
)
6490 cur_abbrev
= dwarf_alloc_abbrev (cu
);
6492 /* read in abbrev header */
6493 cur_abbrev
->number
= abbrev_number
;
6494 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
6495 abbrev_ptr
+= bytes_read
;
6496 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
6499 if (cur_abbrev
->tag
== DW_TAG_namespace
)
6500 cu
->has_namespace_info
= 1;
6502 /* now read in declarations */
6503 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
6504 abbrev_ptr
+= bytes_read
;
6505 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
6506 abbrev_ptr
+= bytes_read
;
6509 if (cur_abbrev
->num_attrs
== allocated_attrs
)
6511 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
6513 = xrealloc (cur_attrs
, (allocated_attrs
6514 * sizeof (struct attr_abbrev
)));
6517 /* Record whether this compilation unit might have
6518 inter-compilation-unit references. If we don't know what form
6519 this attribute will have, then it might potentially be a
6520 DW_FORM_ref_addr, so we conservatively expect inter-CU
6523 if (abbrev_form
== DW_FORM_ref_addr
6524 || abbrev_form
== DW_FORM_indirect
)
6525 cu
->has_form_ref_addr
= 1;
6527 cur_attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
6528 cur_attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
6529 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
6530 abbrev_ptr
+= bytes_read
;
6531 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
6532 abbrev_ptr
+= bytes_read
;
6535 cur_abbrev
->attrs
= obstack_alloc (&cu
->abbrev_obstack
,
6536 (cur_abbrev
->num_attrs
6537 * sizeof (struct attr_abbrev
)));
6538 memcpy (cur_abbrev
->attrs
, cur_attrs
,
6539 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
6541 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
6542 cur_abbrev
->next
= cu
->dwarf2_abbrevs
[hash_number
];
6543 cu
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
6545 /* Get next abbreviation.
6546 Under Irix6 the abbreviations for a compilation unit are not
6547 always properly terminated with an abbrev number of 0.
6548 Exit loop if we encounter an abbreviation which we have
6549 already read (which means we are about to read the abbreviations
6550 for the next compile unit) or if the end of the abbreviation
6551 table is reached. */
6552 if ((unsigned int) (abbrev_ptr
- dwarf2_per_objfile
->abbrev
.buffer
)
6553 >= dwarf2_per_objfile
->abbrev
.size
)
6555 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
6556 abbrev_ptr
+= bytes_read
;
6557 if (dwarf2_lookup_abbrev (abbrev_number
, cu
) != NULL
)
6564 /* Release the memory used by the abbrev table for a compilation unit. */
6567 dwarf2_free_abbrev_table (void *ptr_to_cu
)
6569 struct dwarf2_cu
*cu
= ptr_to_cu
;
6571 obstack_free (&cu
->abbrev_obstack
, NULL
);
6572 cu
->dwarf2_abbrevs
= NULL
;
6575 /* Lookup an abbrev_info structure in the abbrev hash table. */
6577 static struct abbrev_info
*
6578 dwarf2_lookup_abbrev (unsigned int number
, struct dwarf2_cu
*cu
)
6580 unsigned int hash_number
;
6581 struct abbrev_info
*abbrev
;
6583 hash_number
= number
% ABBREV_HASH_SIZE
;
6584 abbrev
= cu
->dwarf2_abbrevs
[hash_number
];
6588 if (abbrev
->number
== number
)
6591 abbrev
= abbrev
->next
;
6596 /* Returns nonzero if TAG represents a type that we might generate a partial
6600 is_type_tag_for_partial (int tag
)
6605 /* Some types that would be reasonable to generate partial symbols for,
6606 that we don't at present. */
6607 case DW_TAG_array_type
:
6608 case DW_TAG_file_type
:
6609 case DW_TAG_ptr_to_member_type
:
6610 case DW_TAG_set_type
:
6611 case DW_TAG_string_type
:
6612 case DW_TAG_subroutine_type
:
6614 case DW_TAG_base_type
:
6615 case DW_TAG_class_type
:
6616 case DW_TAG_interface_type
:
6617 case DW_TAG_enumeration_type
:
6618 case DW_TAG_structure_type
:
6619 case DW_TAG_subrange_type
:
6620 case DW_TAG_typedef
:
6621 case DW_TAG_union_type
:
6628 /* Load all DIEs that are interesting for partial symbols into memory. */
6630 static struct partial_die_info
*
6631 load_partial_dies (bfd
*abfd
, gdb_byte
*buffer
, gdb_byte
*info_ptr
,
6632 int building_psymtab
, struct dwarf2_cu
*cu
)
6634 struct partial_die_info
*part_die
;
6635 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
6636 struct abbrev_info
*abbrev
;
6637 unsigned int bytes_read
;
6638 unsigned int load_all
= 0;
6640 int nesting_level
= 1;
6645 if (cu
->per_cu
&& cu
->per_cu
->load_all_dies
)
6649 = htab_create_alloc_ex (cu
->header
.length
/ 12,
6653 &cu
->comp_unit_obstack
,
6654 hashtab_obstack_allocate
,
6655 dummy_obstack_deallocate
);
6657 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
6658 sizeof (struct partial_die_info
));
6662 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
6664 /* A NULL abbrev means the end of a series of children. */
6667 if (--nesting_level
== 0)
6669 /* PART_DIE was probably the last thing allocated on the
6670 comp_unit_obstack, so we could call obstack_free
6671 here. We don't do that because the waste is small,
6672 and will be cleaned up when we're done with this
6673 compilation unit. This way, we're also more robust
6674 against other users of the comp_unit_obstack. */
6677 info_ptr
+= bytes_read
;
6678 last_die
= parent_die
;
6679 parent_die
= parent_die
->die_parent
;
6683 /* Check whether this DIE is interesting enough to save. Normally
6684 we would not be interested in members here, but there may be
6685 later variables referencing them via DW_AT_specification (for
6688 && !is_type_tag_for_partial (abbrev
->tag
)
6689 && abbrev
->tag
!= DW_TAG_enumerator
6690 && abbrev
->tag
!= DW_TAG_subprogram
6691 && abbrev
->tag
!= DW_TAG_lexical_block
6692 && abbrev
->tag
!= DW_TAG_variable
6693 && abbrev
->tag
!= DW_TAG_namespace
6694 && abbrev
->tag
!= DW_TAG_member
)
6696 /* Otherwise we skip to the next sibling, if any. */
6697 info_ptr
= skip_one_die (buffer
, info_ptr
+ bytes_read
, abbrev
, cu
);
6701 info_ptr
= read_partial_die (part_die
, abbrev
, bytes_read
, abfd
,
6702 buffer
, info_ptr
, cu
);
6704 /* This two-pass algorithm for processing partial symbols has a
6705 high cost in cache pressure. Thus, handle some simple cases
6706 here which cover the majority of C partial symbols. DIEs
6707 which neither have specification tags in them, nor could have
6708 specification tags elsewhere pointing at them, can simply be
6709 processed and discarded.
6711 This segment is also optional; scan_partial_symbols and
6712 add_partial_symbol will handle these DIEs if we chain
6713 them in normally. When compilers which do not emit large
6714 quantities of duplicate debug information are more common,
6715 this code can probably be removed. */
6717 /* Any complete simple types at the top level (pretty much all
6718 of them, for a language without namespaces), can be processed
6720 if (parent_die
== NULL
6721 && part_die
->has_specification
== 0
6722 && part_die
->is_declaration
== 0
6723 && (part_die
->tag
== DW_TAG_typedef
6724 || part_die
->tag
== DW_TAG_base_type
6725 || part_die
->tag
== DW_TAG_subrange_type
))
6727 if (building_psymtab
&& part_die
->name
!= NULL
)
6728 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
6729 VAR_DOMAIN
, LOC_TYPEDEF
,
6730 &cu
->objfile
->static_psymbols
,
6731 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
6732 info_ptr
= locate_pdi_sibling (part_die
, buffer
, info_ptr
, abfd
, cu
);
6736 /* If we're at the second level, and we're an enumerator, and
6737 our parent has no specification (meaning possibly lives in a
6738 namespace elsewhere), then we can add the partial symbol now
6739 instead of queueing it. */
6740 if (part_die
->tag
== DW_TAG_enumerator
6741 && parent_die
!= NULL
6742 && parent_die
->die_parent
== NULL
6743 && parent_die
->tag
== DW_TAG_enumeration_type
6744 && parent_die
->has_specification
== 0)
6746 if (part_die
->name
== NULL
)
6747 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
6748 else if (building_psymtab
)
6749 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
6750 VAR_DOMAIN
, LOC_CONST
,
6751 (cu
->language
== language_cplus
6752 || cu
->language
== language_java
)
6753 ? &cu
->objfile
->global_psymbols
6754 : &cu
->objfile
->static_psymbols
,
6755 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
6757 info_ptr
= locate_pdi_sibling (part_die
, buffer
, info_ptr
, abfd
, cu
);
6761 /* We'll save this DIE so link it in. */
6762 part_die
->die_parent
= parent_die
;
6763 part_die
->die_sibling
= NULL
;
6764 part_die
->die_child
= NULL
;
6766 if (last_die
&& last_die
== parent_die
)
6767 last_die
->die_child
= part_die
;
6769 last_die
->die_sibling
= part_die
;
6771 last_die
= part_die
;
6773 if (first_die
== NULL
)
6774 first_die
= part_die
;
6776 /* Maybe add the DIE to the hash table. Not all DIEs that we
6777 find interesting need to be in the hash table, because we
6778 also have the parent/sibling/child chains; only those that we
6779 might refer to by offset later during partial symbol reading.
6781 For now this means things that might have be the target of a
6782 DW_AT_specification, DW_AT_abstract_origin, or
6783 DW_AT_extension. DW_AT_extension will refer only to
6784 namespaces; DW_AT_abstract_origin refers to functions (and
6785 many things under the function DIE, but we do not recurse
6786 into function DIEs during partial symbol reading) and
6787 possibly variables as well; DW_AT_specification refers to
6788 declarations. Declarations ought to have the DW_AT_declaration
6789 flag. It happens that GCC forgets to put it in sometimes, but
6790 only for functions, not for types.
6792 Adding more things than necessary to the hash table is harmless
6793 except for the performance cost. Adding too few will result in
6794 wasted time in find_partial_die, when we reread the compilation
6795 unit with load_all_dies set. */
6798 || abbrev
->tag
== DW_TAG_subprogram
6799 || abbrev
->tag
== DW_TAG_variable
6800 || abbrev
->tag
== DW_TAG_namespace
6801 || part_die
->is_declaration
)
6805 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
6806 part_die
->offset
, INSERT
);
6810 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
6811 sizeof (struct partial_die_info
));
6813 /* For some DIEs we want to follow their children (if any). For C
6814 we have no reason to follow the children of structures; for other
6815 languages we have to, both so that we can get at method physnames
6816 to infer fully qualified class names, and for DW_AT_specification.
6818 For Ada, we need to scan the children of subprograms and lexical
6819 blocks as well because Ada allows the definition of nested
6820 entities that could be interesting for the debugger, such as
6821 nested subprograms for instance. */
6822 if (last_die
->has_children
6824 || last_die
->tag
== DW_TAG_namespace
6825 || last_die
->tag
== DW_TAG_enumeration_type
6826 || (cu
->language
!= language_c
6827 && (last_die
->tag
== DW_TAG_class_type
6828 || last_die
->tag
== DW_TAG_interface_type
6829 || last_die
->tag
== DW_TAG_structure_type
6830 || last_die
->tag
== DW_TAG_union_type
))
6831 || (cu
->language
== language_ada
6832 && (last_die
->tag
== DW_TAG_subprogram
6833 || last_die
->tag
== DW_TAG_lexical_block
))))
6836 parent_die
= last_die
;
6840 /* Otherwise we skip to the next sibling, if any. */
6841 info_ptr
= locate_pdi_sibling (last_die
, buffer
, info_ptr
, abfd
, cu
);
6843 /* Back to the top, do it again. */
6847 /* Read a minimal amount of information into the minimal die structure. */
6850 read_partial_die (struct partial_die_info
*part_die
,
6851 struct abbrev_info
*abbrev
,
6852 unsigned int abbrev_len
, bfd
*abfd
,
6853 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
6854 struct dwarf2_cu
*cu
)
6857 struct attribute attr
;
6858 int has_low_pc_attr
= 0;
6859 int has_high_pc_attr
= 0;
6861 memset (part_die
, 0, sizeof (struct partial_die_info
));
6863 part_die
->offset
= info_ptr
- buffer
;
6865 info_ptr
+= abbrev_len
;
6870 part_die
->tag
= abbrev
->tag
;
6871 part_die
->has_children
= abbrev
->has_children
;
6873 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
6875 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
, info_ptr
, cu
);
6877 /* Store the data if it is of an attribute we want to keep in a
6878 partial symbol table. */
6882 switch (part_die
->tag
)
6884 case DW_TAG_compile_unit
:
6885 case DW_TAG_type_unit
:
6886 /* Compilation units have a DW_AT_name that is a filename, not
6887 a source language identifier. */
6888 case DW_TAG_enumeration_type
:
6889 case DW_TAG_enumerator
:
6890 /* These tags always have simple identifiers already; no need
6891 to canonicalize them. */
6892 part_die
->name
= DW_STRING (&attr
);
6896 = dwarf2_canonicalize_name (DW_STRING (&attr
), cu
,
6897 &cu
->objfile
->objfile_obstack
);
6901 case DW_AT_linkage_name
:
6902 case DW_AT_MIPS_linkage_name
:
6903 /* Note that both forms of linkage name might appear. We
6904 assume they will be the same, and we only store the last
6906 if (cu
->language
== language_ada
)
6907 part_die
->name
= DW_STRING (&attr
);
6910 has_low_pc_attr
= 1;
6911 part_die
->lowpc
= DW_ADDR (&attr
);
6914 has_high_pc_attr
= 1;
6915 part_die
->highpc
= DW_ADDR (&attr
);
6917 case DW_AT_location
:
6918 /* Support the .debug_loc offsets */
6919 if (attr_form_is_block (&attr
))
6921 part_die
->locdesc
= DW_BLOCK (&attr
);
6923 else if (attr_form_is_section_offset (&attr
))
6925 dwarf2_complex_location_expr_complaint ();
6929 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
6930 "partial symbol information");
6933 case DW_AT_external
:
6934 part_die
->is_external
= DW_UNSND (&attr
);
6936 case DW_AT_declaration
:
6937 part_die
->is_declaration
= DW_UNSND (&attr
);
6940 part_die
->has_type
= 1;
6942 case DW_AT_abstract_origin
:
6943 case DW_AT_specification
:
6944 case DW_AT_extension
:
6945 part_die
->has_specification
= 1;
6946 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
);
6949 /* Ignore absolute siblings, they might point outside of
6950 the current compile unit. */
6951 if (attr
.form
== DW_FORM_ref_addr
)
6952 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
6954 part_die
->sibling
= buffer
+ dwarf2_get_ref_die_offset (&attr
);
6956 case DW_AT_byte_size
:
6957 part_die
->has_byte_size
= 1;
6959 case DW_AT_calling_convention
:
6960 /* DWARF doesn't provide a way to identify a program's source-level
6961 entry point. DW_AT_calling_convention attributes are only meant
6962 to describe functions' calling conventions.
6964 However, because it's a necessary piece of information in
6965 Fortran, and because DW_CC_program is the only piece of debugging
6966 information whose definition refers to a 'main program' at all,
6967 several compilers have begun marking Fortran main programs with
6968 DW_CC_program --- even when those functions use the standard
6969 calling conventions.
6971 So until DWARF specifies a way to provide this information and
6972 compilers pick up the new representation, we'll support this
6974 if (DW_UNSND (&attr
) == DW_CC_program
6975 && cu
->language
== language_fortran
)
6976 set_main_name (part_die
->name
);
6983 /* When using the GNU linker, .gnu.linkonce. sections are used to
6984 eliminate duplicate copies of functions and vtables and such.
6985 The linker will arbitrarily choose one and discard the others.
6986 The AT_*_pc values for such functions refer to local labels in
6987 these sections. If the section from that file was discarded, the
6988 labels are not in the output, so the relocs get a value of 0.
6989 If this is a discarded function, mark the pc bounds as invalid,
6990 so that GDB will ignore it. */
6991 if (has_low_pc_attr
&& has_high_pc_attr
6992 && part_die
->lowpc
< part_die
->highpc
6993 && (part_die
->lowpc
!= 0
6994 || dwarf2_per_objfile
->has_section_at_zero
))
6995 part_die
->has_pc_info
= 1;
7000 /* Find a cached partial DIE at OFFSET in CU. */
7002 static struct partial_die_info
*
7003 find_partial_die_in_comp_unit (unsigned int offset
, struct dwarf2_cu
*cu
)
7005 struct partial_die_info
*lookup_die
= NULL
;
7006 struct partial_die_info part_die
;
7008 part_die
.offset
= offset
;
7009 lookup_die
= htab_find_with_hash (cu
->partial_dies
, &part_die
, offset
);
7014 /* Find a partial DIE at OFFSET, which may or may not be in CU,
7015 except in the case of .debug_types DIEs which do not reference
7016 outside their CU (they do however referencing other types via
7019 static struct partial_die_info
*
7020 find_partial_die (unsigned int offset
, struct dwarf2_cu
*cu
)
7022 struct dwarf2_per_cu_data
*per_cu
= NULL
;
7023 struct partial_die_info
*pd
= NULL
;
7025 if (cu
->per_cu
->from_debug_types
)
7027 pd
= find_partial_die_in_comp_unit (offset
, cu
);
7033 if (offset_in_cu_p (&cu
->header
, offset
))
7035 pd
= find_partial_die_in_comp_unit (offset
, cu
);
7040 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
7042 if (per_cu
->cu
== NULL
)
7044 load_partial_comp_unit (per_cu
, cu
->objfile
);
7045 per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
7046 dwarf2_per_objfile
->read_in_chain
= per_cu
;
7049 per_cu
->cu
->last_used
= 0;
7050 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
7052 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
7054 struct cleanup
*back_to
;
7055 struct partial_die_info comp_unit_die
;
7056 struct abbrev_info
*abbrev
;
7057 unsigned int bytes_read
;
7060 per_cu
->load_all_dies
= 1;
7062 /* Re-read the DIEs. */
7063 back_to
= make_cleanup (null_cleanup
, 0);
7064 if (per_cu
->cu
->dwarf2_abbrevs
== NULL
)
7066 dwarf2_read_abbrevs (per_cu
->cu
->objfile
->obfd
, per_cu
->cu
);
7067 make_cleanup (dwarf2_free_abbrev_table
, per_cu
->cu
);
7069 info_ptr
= (dwarf2_per_objfile
->info
.buffer
7070 + per_cu
->cu
->header
.offset
7071 + per_cu
->cu
->header
.first_die_offset
);
7072 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, per_cu
->cu
);
7073 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
7074 per_cu
->cu
->objfile
->obfd
,
7075 dwarf2_per_objfile
->info
.buffer
, info_ptr
,
7077 if (comp_unit_die
.has_children
)
7078 load_partial_dies (per_cu
->cu
->objfile
->obfd
,
7079 dwarf2_per_objfile
->info
.buffer
, info_ptr
,
7081 do_cleanups (back_to
);
7083 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
7089 internal_error (__FILE__
, __LINE__
,
7090 _("could not find partial DIE 0x%x in cache [from module %s]\n"),
7091 offset
, bfd_get_filename (cu
->objfile
->obfd
));
7095 /* Adjust PART_DIE before generating a symbol for it. This function
7096 may set the is_external flag or change the DIE's name. */
7099 fixup_partial_die (struct partial_die_info
*part_die
,
7100 struct dwarf2_cu
*cu
)
7102 /* If we found a reference attribute and the DIE has no name, try
7103 to find a name in the referred to DIE. */
7105 if (part_die
->name
== NULL
&& part_die
->has_specification
)
7107 struct partial_die_info
*spec_die
;
7109 spec_die
= find_partial_die (part_die
->spec_offset
, cu
);
7111 fixup_partial_die (spec_die
, cu
);
7115 part_die
->name
= spec_die
->name
;
7117 /* Copy DW_AT_external attribute if it is set. */
7118 if (spec_die
->is_external
)
7119 part_die
->is_external
= spec_die
->is_external
;
7123 /* Set default names for some unnamed DIEs. */
7124 if (part_die
->name
== NULL
&& (part_die
->tag
== DW_TAG_structure_type
7125 || part_die
->tag
== DW_TAG_class_type
))
7126 part_die
->name
= "(anonymous class)";
7128 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
7129 part_die
->name
= "(anonymous namespace)";
7131 if (part_die
->tag
== DW_TAG_structure_type
7132 || part_die
->tag
== DW_TAG_class_type
7133 || part_die
->tag
== DW_TAG_union_type
)
7134 guess_structure_name (part_die
, cu
);
7137 /* Read an attribute value described by an attribute form. */
7140 read_attribute_value (struct attribute
*attr
, unsigned form
,
7141 bfd
*abfd
, gdb_byte
*info_ptr
,
7142 struct dwarf2_cu
*cu
)
7144 struct comp_unit_head
*cu_header
= &cu
->header
;
7145 unsigned int bytes_read
;
7146 struct dwarf_block
*blk
;
7151 case DW_FORM_ref_addr
:
7152 if (cu
->header
.version
== 2)
7153 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
7155 DW_ADDR (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
7156 info_ptr
+= bytes_read
;
7159 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
7160 info_ptr
+= bytes_read
;
7162 case DW_FORM_block2
:
7163 blk
= dwarf_alloc_block (cu
);
7164 blk
->size
= read_2_bytes (abfd
, info_ptr
);
7166 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
7167 info_ptr
+= blk
->size
;
7168 DW_BLOCK (attr
) = blk
;
7170 case DW_FORM_block4
:
7171 blk
= dwarf_alloc_block (cu
);
7172 blk
->size
= read_4_bytes (abfd
, info_ptr
);
7174 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
7175 info_ptr
+= blk
->size
;
7176 DW_BLOCK (attr
) = blk
;
7179 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
7183 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
7187 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
7190 case DW_FORM_sec_offset
:
7191 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
7192 info_ptr
+= bytes_read
;
7194 case DW_FORM_string
:
7195 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
7196 DW_STRING_IS_CANONICAL (attr
) = 0;
7197 info_ptr
+= bytes_read
;
7200 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
7202 DW_STRING_IS_CANONICAL (attr
) = 0;
7203 info_ptr
+= bytes_read
;
7205 case DW_FORM_exprloc
:
7207 blk
= dwarf_alloc_block (cu
);
7208 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
7209 info_ptr
+= bytes_read
;
7210 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
7211 info_ptr
+= blk
->size
;
7212 DW_BLOCK (attr
) = blk
;
7214 case DW_FORM_block1
:
7215 blk
= dwarf_alloc_block (cu
);
7216 blk
->size
= read_1_byte (abfd
, info_ptr
);
7218 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
7219 info_ptr
+= blk
->size
;
7220 DW_BLOCK (attr
) = blk
;
7223 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
7227 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
7230 case DW_FORM_flag_present
:
7231 DW_UNSND (attr
) = 1;
7234 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
7235 info_ptr
+= bytes_read
;
7238 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
7239 info_ptr
+= bytes_read
;
7242 DW_ADDR (attr
) = cu
->header
.offset
+ read_1_byte (abfd
, info_ptr
);
7246 DW_ADDR (attr
) = cu
->header
.offset
+ read_2_bytes (abfd
, info_ptr
);
7250 DW_ADDR (attr
) = cu
->header
.offset
+ read_4_bytes (abfd
, info_ptr
);
7254 DW_ADDR (attr
) = cu
->header
.offset
+ read_8_bytes (abfd
, info_ptr
);
7258 /* Convert the signature to something we can record in DW_UNSND
7260 NOTE: This is NULL if the type wasn't found. */
7261 DW_SIGNATURED_TYPE (attr
) =
7262 lookup_signatured_type (cu
->objfile
, read_8_bytes (abfd
, info_ptr
));
7265 case DW_FORM_ref_udata
:
7266 DW_ADDR (attr
) = (cu
->header
.offset
7267 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
7268 info_ptr
+= bytes_read
;
7270 case DW_FORM_indirect
:
7271 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
7272 info_ptr
+= bytes_read
;
7273 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu
);
7276 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
7277 dwarf_form_name (form
),
7278 bfd_get_filename (abfd
));
7281 /* We have seen instances where the compiler tried to emit a byte
7282 size attribute of -1 which ended up being encoded as an unsigned
7283 0xffffffff. Although 0xffffffff is technically a valid size value,
7284 an object of this size seems pretty unlikely so we can relatively
7285 safely treat these cases as if the size attribute was invalid and
7286 treat them as zero by default. */
7287 if (attr
->name
== DW_AT_byte_size
7288 && form
== DW_FORM_data4
7289 && DW_UNSND (attr
) >= 0xffffffff)
7292 (&symfile_complaints
,
7293 _("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
7294 hex_string (DW_UNSND (attr
)));
7295 DW_UNSND (attr
) = 0;
7301 /* Read an attribute described by an abbreviated attribute. */
7304 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
7305 bfd
*abfd
, gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
7307 attr
->name
= abbrev
->name
;
7308 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu
);
7311 /* read dwarf information from a buffer */
7314 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
7316 return bfd_get_8 (abfd
, buf
);
7320 read_1_signed_byte (bfd
*abfd
, gdb_byte
*buf
)
7322 return bfd_get_signed_8 (abfd
, buf
);
7326 read_2_bytes (bfd
*abfd
, gdb_byte
*buf
)
7328 return bfd_get_16 (abfd
, buf
);
7332 read_2_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
7334 return bfd_get_signed_16 (abfd
, buf
);
7338 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
7340 return bfd_get_32 (abfd
, buf
);
7344 read_4_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
7346 return bfd_get_signed_32 (abfd
, buf
);
7350 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
7352 return bfd_get_64 (abfd
, buf
);
7356 read_address (bfd
*abfd
, gdb_byte
*buf
, struct dwarf2_cu
*cu
,
7357 unsigned int *bytes_read
)
7359 struct comp_unit_head
*cu_header
= &cu
->header
;
7360 CORE_ADDR retval
= 0;
7362 if (cu_header
->signed_addr_p
)
7364 switch (cu_header
->addr_size
)
7367 retval
= bfd_get_signed_16 (abfd
, buf
);
7370 retval
= bfd_get_signed_32 (abfd
, buf
);
7373 retval
= bfd_get_signed_64 (abfd
, buf
);
7376 internal_error (__FILE__
, __LINE__
,
7377 _("read_address: bad switch, signed [in module %s]"),
7378 bfd_get_filename (abfd
));
7383 switch (cu_header
->addr_size
)
7386 retval
= bfd_get_16 (abfd
, buf
);
7389 retval
= bfd_get_32 (abfd
, buf
);
7392 retval
= bfd_get_64 (abfd
, buf
);
7395 internal_error (__FILE__
, __LINE__
,
7396 _("read_address: bad switch, unsigned [in module %s]"),
7397 bfd_get_filename (abfd
));
7401 *bytes_read
= cu_header
->addr_size
;
7405 /* Read the initial length from a section. The (draft) DWARF 3
7406 specification allows the initial length to take up either 4 bytes
7407 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
7408 bytes describe the length and all offsets will be 8 bytes in length
7411 An older, non-standard 64-bit format is also handled by this
7412 function. The older format in question stores the initial length
7413 as an 8-byte quantity without an escape value. Lengths greater
7414 than 2^32 aren't very common which means that the initial 4 bytes
7415 is almost always zero. Since a length value of zero doesn't make
7416 sense for the 32-bit format, this initial zero can be considered to
7417 be an escape value which indicates the presence of the older 64-bit
7418 format. As written, the code can't detect (old format) lengths
7419 greater than 4GB. If it becomes necessary to handle lengths
7420 somewhat larger than 4GB, we could allow other small values (such
7421 as the non-sensical values of 1, 2, and 3) to also be used as
7422 escape values indicating the presence of the old format.
7424 The value returned via bytes_read should be used to increment the
7425 relevant pointer after calling read_initial_length().
7427 [ Note: read_initial_length() and read_offset() are based on the
7428 document entitled "DWARF Debugging Information Format", revision
7429 3, draft 8, dated November 19, 2001. This document was obtained
7432 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
7434 This document is only a draft and is subject to change. (So beware.)
7436 Details regarding the older, non-standard 64-bit format were
7437 determined empirically by examining 64-bit ELF files produced by
7438 the SGI toolchain on an IRIX 6.5 machine.
7440 - Kevin, July 16, 2002
7444 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read
)
7446 LONGEST length
= bfd_get_32 (abfd
, buf
);
7448 if (length
== 0xffffffff)
7450 length
= bfd_get_64 (abfd
, buf
+ 4);
7453 else if (length
== 0)
7455 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
7456 length
= bfd_get_64 (abfd
, buf
);
7467 /* Cover function for read_initial_length.
7468 Returns the length of the object at BUF, and stores the size of the
7469 initial length in *BYTES_READ and stores the size that offsets will be in
7471 If the initial length size is not equivalent to that specified in
7472 CU_HEADER then issue a complaint.
7473 This is useful when reading non-comp-unit headers. */
7476 read_checked_initial_length_and_offset (bfd
*abfd
, gdb_byte
*buf
,
7477 const struct comp_unit_head
*cu_header
,
7478 unsigned int *bytes_read
,
7479 unsigned int *offset_size
)
7481 LONGEST length
= read_initial_length (abfd
, buf
, bytes_read
);
7483 gdb_assert (cu_header
->initial_length_size
== 4
7484 || cu_header
->initial_length_size
== 8
7485 || cu_header
->initial_length_size
== 12);
7487 if (cu_header
->initial_length_size
!= *bytes_read
)
7488 complaint (&symfile_complaints
,
7489 _("intermixed 32-bit and 64-bit DWARF sections"));
7491 *offset_size
= (*bytes_read
== 4) ? 4 : 8;
7495 /* Read an offset from the data stream. The size of the offset is
7496 given by cu_header->offset_size. */
7499 read_offset (bfd
*abfd
, gdb_byte
*buf
, const struct comp_unit_head
*cu_header
,
7500 unsigned int *bytes_read
)
7502 LONGEST offset
= read_offset_1 (abfd
, buf
, cu_header
->offset_size
);
7504 *bytes_read
= cu_header
->offset_size
;
7508 /* Read an offset from the data stream. */
7511 read_offset_1 (bfd
*abfd
, gdb_byte
*buf
, unsigned int offset_size
)
7515 switch (offset_size
)
7518 retval
= bfd_get_32 (abfd
, buf
);
7521 retval
= bfd_get_64 (abfd
, buf
);
7524 internal_error (__FILE__
, __LINE__
,
7525 _("read_offset_1: bad switch [in module %s]"),
7526 bfd_get_filename (abfd
));
7533 read_n_bytes (bfd
*abfd
, gdb_byte
*buf
, unsigned int size
)
7535 /* If the size of a host char is 8 bits, we can return a pointer
7536 to the buffer, otherwise we have to copy the data to a buffer
7537 allocated on the temporary obstack. */
7538 gdb_assert (HOST_CHAR_BIT
== 8);
7543 read_string (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
7545 /* If the size of a host char is 8 bits, we can return a pointer
7546 to the string, otherwise we have to copy the string to a buffer
7547 allocated on the temporary obstack. */
7548 gdb_assert (HOST_CHAR_BIT
== 8);
7551 *bytes_read_ptr
= 1;
7554 *bytes_read_ptr
= strlen ((char *) buf
) + 1;
7555 return (char *) buf
;
7559 read_indirect_string (bfd
*abfd
, gdb_byte
*buf
,
7560 const struct comp_unit_head
*cu_header
,
7561 unsigned int *bytes_read_ptr
)
7563 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
, bytes_read_ptr
);
7565 dwarf2_read_section (dwarf2_per_objfile
->objfile
, &dwarf2_per_objfile
->str
);
7566 if (dwarf2_per_objfile
->str
.buffer
== NULL
)
7568 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
7569 bfd_get_filename (abfd
));
7572 if (str_offset
>= dwarf2_per_objfile
->str
.size
)
7574 error (_("DW_FORM_strp pointing outside of .debug_str section [in module %s]"),
7575 bfd_get_filename (abfd
));
7578 gdb_assert (HOST_CHAR_BIT
== 8);
7579 if (dwarf2_per_objfile
->str
.buffer
[str_offset
] == '\0')
7581 return (char *) (dwarf2_per_objfile
->str
.buffer
+ str_offset
);
7584 static unsigned long
7585 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
7587 unsigned long result
;
7588 unsigned int num_read
;
7598 byte
= bfd_get_8 (abfd
, buf
);
7601 result
|= ((unsigned long)(byte
& 127) << shift
);
7602 if ((byte
& 128) == 0)
7608 *bytes_read_ptr
= num_read
;
7613 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
7616 int i
, shift
, num_read
;
7625 byte
= bfd_get_8 (abfd
, buf
);
7628 result
|= ((long)(byte
& 127) << shift
);
7630 if ((byte
& 128) == 0)
7635 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
7636 result
|= -(((long)1) << shift
);
7637 *bytes_read_ptr
= num_read
;
7641 /* Return a pointer to just past the end of an LEB128 number in BUF. */
7644 skip_leb128 (bfd
*abfd
, gdb_byte
*buf
)
7650 byte
= bfd_get_8 (abfd
, buf
);
7652 if ((byte
& 128) == 0)
7658 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
7665 cu
->language
= language_c
;
7667 case DW_LANG_C_plus_plus
:
7668 cu
->language
= language_cplus
;
7671 cu
->language
= language_d
;
7673 case DW_LANG_Fortran77
:
7674 case DW_LANG_Fortran90
:
7675 case DW_LANG_Fortran95
:
7676 cu
->language
= language_fortran
;
7678 case DW_LANG_Mips_Assembler
:
7679 cu
->language
= language_asm
;
7682 cu
->language
= language_java
;
7686 cu
->language
= language_ada
;
7688 case DW_LANG_Modula2
:
7689 cu
->language
= language_m2
;
7691 case DW_LANG_Pascal83
:
7692 cu
->language
= language_pascal
;
7695 cu
->language
= language_objc
;
7697 case DW_LANG_Cobol74
:
7698 case DW_LANG_Cobol85
:
7700 cu
->language
= language_minimal
;
7703 cu
->language_defn
= language_def (cu
->language
);
7706 /* Return the named attribute or NULL if not there. */
7708 static struct attribute
*
7709 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
7712 struct attribute
*spec
= NULL
;
7714 for (i
= 0; i
< die
->num_attrs
; ++i
)
7716 if (die
->attrs
[i
].name
== name
)
7717 return &die
->attrs
[i
];
7718 if (die
->attrs
[i
].name
== DW_AT_specification
7719 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
7720 spec
= &die
->attrs
[i
];
7725 die
= follow_die_ref (die
, spec
, &cu
);
7726 return dwarf2_attr (die
, name
, cu
);
7732 /* Return the named attribute or NULL if not there,
7733 but do not follow DW_AT_specification, etc.
7734 This is for use in contexts where we're reading .debug_types dies.
7735 Following DW_AT_specification, DW_AT_abstract_origin will take us
7736 back up the chain, and we want to go down. */
7738 static struct attribute
*
7739 dwarf2_attr_no_follow (struct die_info
*die
, unsigned int name
,
7740 struct dwarf2_cu
*cu
)
7744 for (i
= 0; i
< die
->num_attrs
; ++i
)
7745 if (die
->attrs
[i
].name
== name
)
7746 return &die
->attrs
[i
];
7751 /* Return non-zero iff the attribute NAME is defined for the given DIE,
7752 and holds a non-zero value. This function should only be used for
7753 DW_FORM_flag or DW_FORM_flag_present attributes. */
7756 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
7758 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
7760 return (attr
&& DW_UNSND (attr
));
7764 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
7766 /* A DIE is a declaration if it has a DW_AT_declaration attribute
7767 which value is non-zero. However, we have to be careful with
7768 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
7769 (via dwarf2_flag_true_p) follows this attribute. So we may
7770 end up accidently finding a declaration attribute that belongs
7771 to a different DIE referenced by the specification attribute,
7772 even though the given DIE does not have a declaration attribute. */
7773 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
7774 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
7777 /* Return the die giving the specification for DIE, if there is
7778 one. *SPEC_CU is the CU containing DIE on input, and the CU
7779 containing the return value on output. If there is no
7780 specification, but there is an abstract origin, that is
7783 static struct die_info
*
7784 die_specification (struct die_info
*die
, struct dwarf2_cu
**spec_cu
)
7786 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
,
7789 if (spec_attr
== NULL
)
7790 spec_attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, *spec_cu
);
7792 if (spec_attr
== NULL
)
7795 return follow_die_ref (die
, spec_attr
, spec_cu
);
7798 /* Free the line_header structure *LH, and any arrays and strings it
7801 free_line_header (struct line_header
*lh
)
7803 if (lh
->standard_opcode_lengths
)
7804 xfree (lh
->standard_opcode_lengths
);
7806 /* Remember that all the lh->file_names[i].name pointers are
7807 pointers into debug_line_buffer, and don't need to be freed. */
7809 xfree (lh
->file_names
);
7811 /* Similarly for the include directory names. */
7812 if (lh
->include_dirs
)
7813 xfree (lh
->include_dirs
);
7819 /* Add an entry to LH's include directory table. */
7821 add_include_dir (struct line_header
*lh
, char *include_dir
)
7823 /* Grow the array if necessary. */
7824 if (lh
->include_dirs_size
== 0)
7826 lh
->include_dirs_size
= 1; /* for testing */
7827 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
7828 * sizeof (*lh
->include_dirs
));
7830 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
7832 lh
->include_dirs_size
*= 2;
7833 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
7834 (lh
->include_dirs_size
7835 * sizeof (*lh
->include_dirs
)));
7838 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
7842 /* Add an entry to LH's file name table. */
7844 add_file_name (struct line_header
*lh
,
7846 unsigned int dir_index
,
7847 unsigned int mod_time
,
7848 unsigned int length
)
7850 struct file_entry
*fe
;
7852 /* Grow the array if necessary. */
7853 if (lh
->file_names_size
== 0)
7855 lh
->file_names_size
= 1; /* for testing */
7856 lh
->file_names
= xmalloc (lh
->file_names_size
7857 * sizeof (*lh
->file_names
));
7859 else if (lh
->num_file_names
>= lh
->file_names_size
)
7861 lh
->file_names_size
*= 2;
7862 lh
->file_names
= xrealloc (lh
->file_names
,
7863 (lh
->file_names_size
7864 * sizeof (*lh
->file_names
)));
7867 fe
= &lh
->file_names
[lh
->num_file_names
++];
7869 fe
->dir_index
= dir_index
;
7870 fe
->mod_time
= mod_time
;
7871 fe
->length
= length
;
7877 /* Read the statement program header starting at OFFSET in
7878 .debug_line, according to the endianness of ABFD. Return a pointer
7879 to a struct line_header, allocated using xmalloc.
7881 NOTE: the strings in the include directory and file name tables of
7882 the returned object point into debug_line_buffer, and must not be
7884 static struct line_header
*
7885 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
7886 struct dwarf2_cu
*cu
)
7888 struct cleanup
*back_to
;
7889 struct line_header
*lh
;
7891 unsigned int bytes_read
, offset_size
;
7893 char *cur_dir
, *cur_file
;
7895 dwarf2_read_section (dwarf2_per_objfile
->objfile
, &dwarf2_per_objfile
->line
);
7896 if (dwarf2_per_objfile
->line
.buffer
== NULL
)
7898 complaint (&symfile_complaints
, _("missing .debug_line section"));
7902 /* Make sure that at least there's room for the total_length field.
7903 That could be 12 bytes long, but we're just going to fudge that. */
7904 if (offset
+ 4 >= dwarf2_per_objfile
->line
.size
)
7906 dwarf2_statement_list_fits_in_line_number_section_complaint ();
7910 lh
= xmalloc (sizeof (*lh
));
7911 memset (lh
, 0, sizeof (*lh
));
7912 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
7915 line_ptr
= dwarf2_per_objfile
->line
.buffer
+ offset
;
7917 /* Read in the header. */
7919 read_checked_initial_length_and_offset (abfd
, line_ptr
, &cu
->header
,
7920 &bytes_read
, &offset_size
);
7921 line_ptr
+= bytes_read
;
7922 if (line_ptr
+ lh
->total_length
> (dwarf2_per_objfile
->line
.buffer
7923 + dwarf2_per_objfile
->line
.size
))
7925 dwarf2_statement_list_fits_in_line_number_section_complaint ();
7928 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
7929 lh
->version
= read_2_bytes (abfd
, line_ptr
);
7931 lh
->header_length
= read_offset_1 (abfd
, line_ptr
, offset_size
);
7932 line_ptr
+= offset_size
;
7933 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
7935 if (lh
->version
>= 4)
7937 lh
->maximum_ops_per_instruction
= read_1_byte (abfd
, line_ptr
);
7941 lh
->maximum_ops_per_instruction
= 1;
7943 if (lh
->maximum_ops_per_instruction
== 0)
7945 lh
->maximum_ops_per_instruction
= 1;
7946 complaint (&symfile_complaints
,
7947 _("invalid maximum_ops_per_instruction in `.debug_line' section"));
7950 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
7952 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
7954 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
7956 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
7958 lh
->standard_opcode_lengths
7959 = xmalloc (lh
->opcode_base
* sizeof (lh
->standard_opcode_lengths
[0]));
7961 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
7962 for (i
= 1; i
< lh
->opcode_base
; ++i
)
7964 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
7968 /* Read directory table. */
7969 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
7971 line_ptr
+= bytes_read
;
7972 add_include_dir (lh
, cur_dir
);
7974 line_ptr
+= bytes_read
;
7976 /* Read file name table. */
7977 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
7979 unsigned int dir_index
, mod_time
, length
;
7981 line_ptr
+= bytes_read
;
7982 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
7983 line_ptr
+= bytes_read
;
7984 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
7985 line_ptr
+= bytes_read
;
7986 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
7987 line_ptr
+= bytes_read
;
7989 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
7991 line_ptr
+= bytes_read
;
7992 lh
->statement_program_start
= line_ptr
;
7994 if (line_ptr
> (dwarf2_per_objfile
->line
.buffer
7995 + dwarf2_per_objfile
->line
.size
))
7996 complaint (&symfile_complaints
,
7997 _("line number info header doesn't fit in `.debug_line' section"));
7999 discard_cleanups (back_to
);
8003 /* This function exists to work around a bug in certain compilers
8004 (particularly GCC 2.95), in which the first line number marker of a
8005 function does not show up until after the prologue, right before
8006 the second line number marker. This function shifts ADDRESS down
8007 to the beginning of the function if necessary, and is called on
8008 addresses passed to record_line. */
8011 check_cu_functions (CORE_ADDR address
, struct dwarf2_cu
*cu
)
8013 struct function_range
*fn
;
8015 /* Find the function_range containing address. */
8020 cu
->cached_fn
= cu
->first_fn
;
8024 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
8030 while (fn
&& fn
!= cu
->cached_fn
)
8031 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
8041 if (address
!= fn
->lowpc
)
8042 complaint (&symfile_complaints
,
8043 _("misplaced first line number at 0x%lx for '%s'"),
8044 (unsigned long) address
, fn
->name
);
8049 /* Decode the Line Number Program (LNP) for the given line_header
8050 structure and CU. The actual information extracted and the type
8051 of structures created from the LNP depends on the value of PST.
8053 1. If PST is NULL, then this procedure uses the data from the program
8054 to create all necessary symbol tables, and their linetables.
8055 The compilation directory of the file is passed in COMP_DIR,
8056 and must not be NULL.
8058 2. If PST is not NULL, this procedure reads the program to determine
8059 the list of files included by the unit represented by PST, and
8060 builds all the associated partial symbol tables. In this case,
8061 the value of COMP_DIR is ignored, and can thus be NULL (the COMP_DIR
8062 is not used to compute the full name of the symtab, and therefore
8063 omitting it when building the partial symtab does not introduce
8064 the potential for inconsistency - a partial symtab and its associated
8065 symbtab having a different fullname -). */
8068 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
8069 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
)
8071 gdb_byte
*line_ptr
, *extended_end
;
8073 unsigned int bytes_read
, extended_len
;
8074 unsigned char op_code
, extended_op
, adj_opcode
;
8076 struct objfile
*objfile
= cu
->objfile
;
8077 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
8078 const int decode_for_pst_p
= (pst
!= NULL
);
8079 struct subfile
*last_subfile
= NULL
, *first_subfile
= current_subfile
;
8081 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
8083 line_ptr
= lh
->statement_program_start
;
8084 line_end
= lh
->statement_program_end
;
8086 /* Read the statement sequences until there's nothing left. */
8087 while (line_ptr
< line_end
)
8089 /* state machine registers */
8090 CORE_ADDR address
= 0;
8091 unsigned int file
= 1;
8092 unsigned int line
= 1;
8093 unsigned int column
= 0;
8094 int is_stmt
= lh
->default_is_stmt
;
8095 int basic_block
= 0;
8096 int end_sequence
= 0;
8098 unsigned char op_index
= 0;
8100 if (!decode_for_pst_p
&& lh
->num_file_names
>= file
)
8102 /* Start a subfile for the current file of the state machine. */
8103 /* lh->include_dirs and lh->file_names are 0-based, but the
8104 directory and file name numbers in the statement program
8106 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
8110 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
8112 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
8115 /* Decode the table. */
8116 while (!end_sequence
)
8118 op_code
= read_1_byte (abfd
, line_ptr
);
8120 if (line_ptr
> line_end
)
8122 dwarf2_debug_line_missing_end_sequence_complaint ();
8126 if (op_code
>= lh
->opcode_base
)
8128 /* Special operand. */
8129 adj_opcode
= op_code
- lh
->opcode_base
;
8130 address
+= (((op_index
+ (adj_opcode
/ lh
->line_range
))
8131 / lh
->maximum_ops_per_instruction
)
8132 * lh
->minimum_instruction_length
);
8133 op_index
= ((op_index
+ (adj_opcode
/ lh
->line_range
))
8134 % lh
->maximum_ops_per_instruction
);
8135 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
8136 if (lh
->num_file_names
< file
|| file
== 0)
8137 dwarf2_debug_line_missing_file_complaint ();
8138 /* For now we ignore lines not starting on an
8139 instruction boundary. */
8140 else if (op_index
== 0)
8142 lh
->file_names
[file
- 1].included_p
= 1;
8143 if (!decode_for_pst_p
&& is_stmt
)
8145 if (last_subfile
!= current_subfile
)
8147 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
8149 record_line (last_subfile
, 0, addr
);
8150 last_subfile
= current_subfile
;
8152 /* Append row to matrix using current values. */
8153 addr
= check_cu_functions (address
, cu
);
8154 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
8155 record_line (current_subfile
, line
, addr
);
8160 else switch (op_code
)
8162 case DW_LNS_extended_op
:
8163 extended_len
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
8164 line_ptr
+= bytes_read
;
8165 extended_end
= line_ptr
+ extended_len
;
8166 extended_op
= read_1_byte (abfd
, line_ptr
);
8168 switch (extended_op
)
8170 case DW_LNE_end_sequence
:
8173 case DW_LNE_set_address
:
8174 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
8176 line_ptr
+= bytes_read
;
8177 address
+= baseaddr
;
8179 case DW_LNE_define_file
:
8182 unsigned int dir_index
, mod_time
, length
;
8184 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
8185 line_ptr
+= bytes_read
;
8187 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
8188 line_ptr
+= bytes_read
;
8190 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
8191 line_ptr
+= bytes_read
;
8193 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
8194 line_ptr
+= bytes_read
;
8195 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
8198 case DW_LNE_set_discriminator
:
8199 /* The discriminator is not interesting to the debugger;
8201 line_ptr
= extended_end
;
8204 complaint (&symfile_complaints
,
8205 _("mangled .debug_line section"));
8208 /* Make sure that we parsed the extended op correctly. If e.g.
8209 we expected a different address size than the producer used,
8210 we may have read the wrong number of bytes. */
8211 if (line_ptr
!= extended_end
)
8213 complaint (&symfile_complaints
,
8214 _("mangled .debug_line section"));
8219 if (lh
->num_file_names
< file
|| file
== 0)
8220 dwarf2_debug_line_missing_file_complaint ();
8223 lh
->file_names
[file
- 1].included_p
= 1;
8224 if (!decode_for_pst_p
&& is_stmt
)
8226 if (last_subfile
!= current_subfile
)
8228 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
8230 record_line (last_subfile
, 0, addr
);
8231 last_subfile
= current_subfile
;
8233 addr
= check_cu_functions (address
, cu
);
8234 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
8235 record_line (current_subfile
, line
, addr
);
8240 case DW_LNS_advance_pc
:
8243 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
8245 address
+= (((op_index
+ adjust
)
8246 / lh
->maximum_ops_per_instruction
)
8247 * lh
->minimum_instruction_length
);
8248 op_index
= ((op_index
+ adjust
)
8249 % lh
->maximum_ops_per_instruction
);
8250 line_ptr
+= bytes_read
;
8253 case DW_LNS_advance_line
:
8254 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
8255 line_ptr
+= bytes_read
;
8257 case DW_LNS_set_file
:
8259 /* The arrays lh->include_dirs and lh->file_names are
8260 0-based, but the directory and file name numbers in
8261 the statement program are 1-based. */
8262 struct file_entry
*fe
;
8265 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
8266 line_ptr
+= bytes_read
;
8267 if (lh
->num_file_names
< file
|| file
== 0)
8268 dwarf2_debug_line_missing_file_complaint ();
8271 fe
= &lh
->file_names
[file
- 1];
8273 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
8274 if (!decode_for_pst_p
)
8276 last_subfile
= current_subfile
;
8277 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
8282 case DW_LNS_set_column
:
8283 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
8284 line_ptr
+= bytes_read
;
8286 case DW_LNS_negate_stmt
:
8287 is_stmt
= (!is_stmt
);
8289 case DW_LNS_set_basic_block
:
8292 /* Add to the address register of the state machine the
8293 address increment value corresponding to special opcode
8294 255. I.e., this value is scaled by the minimum
8295 instruction length since special opcode 255 would have
8296 scaled the the increment. */
8297 case DW_LNS_const_add_pc
:
8299 CORE_ADDR adjust
= (255 - lh
->opcode_base
) / lh
->line_range
;
8301 address
+= (((op_index
+ adjust
)
8302 / lh
->maximum_ops_per_instruction
)
8303 * lh
->minimum_instruction_length
);
8304 op_index
= ((op_index
+ adjust
)
8305 % lh
->maximum_ops_per_instruction
);
8308 case DW_LNS_fixed_advance_pc
:
8309 address
+= read_2_bytes (abfd
, line_ptr
);
8315 /* Unknown standard opcode, ignore it. */
8318 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
8320 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
8321 line_ptr
+= bytes_read
;
8326 if (lh
->num_file_names
< file
|| file
== 0)
8327 dwarf2_debug_line_missing_file_complaint ();
8330 lh
->file_names
[file
- 1].included_p
= 1;
8331 if (!decode_for_pst_p
)
8333 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
8334 record_line (current_subfile
, 0, addr
);
8339 if (decode_for_pst_p
)
8343 /* Now that we're done scanning the Line Header Program, we can
8344 create the psymtab of each included file. */
8345 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
8346 if (lh
->file_names
[file_index
].included_p
== 1)
8348 const struct file_entry fe
= lh
->file_names
[file_index
];
8349 char *include_name
= fe
.name
;
8350 char *dir_name
= NULL
;
8351 char *pst_filename
= pst
->filename
;
8354 dir_name
= lh
->include_dirs
[fe
.dir_index
- 1];
8356 if (!IS_ABSOLUTE_PATH (include_name
) && dir_name
!= NULL
)
8358 include_name
= concat (dir_name
, SLASH_STRING
,
8359 include_name
, (char *)NULL
);
8360 make_cleanup (xfree
, include_name
);
8363 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
8365 pst_filename
= concat (pst
->dirname
, SLASH_STRING
,
8366 pst_filename
, (char *)NULL
);
8367 make_cleanup (xfree
, pst_filename
);
8370 if (strcmp (include_name
, pst_filename
) != 0)
8371 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
8376 /* Make sure a symtab is created for every file, even files
8377 which contain only variables (i.e. no code with associated
8381 struct file_entry
*fe
;
8383 for (i
= 0; i
< lh
->num_file_names
; i
++)
8387 fe
= &lh
->file_names
[i
];
8389 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
8390 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
8392 /* Skip the main file; we don't need it, and it must be
8393 allocated last, so that it will show up before the
8394 non-primary symtabs in the objfile's symtab list. */
8395 if (current_subfile
== first_subfile
)
8398 if (current_subfile
->symtab
== NULL
)
8399 current_subfile
->symtab
= allocate_symtab (current_subfile
->name
,
8401 fe
->symtab
= current_subfile
->symtab
;
8406 /* Start a subfile for DWARF. FILENAME is the name of the file and
8407 DIRNAME the name of the source directory which contains FILENAME
8408 or NULL if not known. COMP_DIR is the compilation directory for the
8409 linetable's compilation unit or NULL if not known.
8410 This routine tries to keep line numbers from identical absolute and
8411 relative file names in a common subfile.
8413 Using the `list' example from the GDB testsuite, which resides in
8414 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
8415 of /srcdir/list0.c yields the following debugging information for list0.c:
8417 DW_AT_name: /srcdir/list0.c
8418 DW_AT_comp_dir: /compdir
8419 files.files[0].name: list0.h
8420 files.files[0].dir: /srcdir
8421 files.files[1].name: list0.c
8422 files.files[1].dir: /srcdir
8424 The line number information for list0.c has to end up in a single
8425 subfile, so that `break /srcdir/list0.c:1' works as expected.
8426 start_subfile will ensure that this happens provided that we pass the
8427 concatenation of files.files[1].dir and files.files[1].name as the
8431 dwarf2_start_subfile (char *filename
, char *dirname
, char *comp_dir
)
8435 /* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir).
8436 `start_symtab' will always pass the contents of DW_AT_comp_dir as
8437 second argument to start_subfile. To be consistent, we do the
8438 same here. In order not to lose the line information directory,
8439 we concatenate it to the filename when it makes sense.
8440 Note that the Dwarf3 standard says (speaking of filenames in line
8441 information): ``The directory index is ignored for file names
8442 that represent full path names''. Thus ignoring dirname in the
8443 `else' branch below isn't an issue. */
8445 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
8446 fullname
= concat (dirname
, SLASH_STRING
, filename
, (char *)NULL
);
8448 fullname
= filename
;
8450 start_subfile (fullname
, comp_dir
);
8452 if (fullname
!= filename
)
8457 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
8458 struct dwarf2_cu
*cu
)
8460 struct objfile
*objfile
= cu
->objfile
;
8461 struct comp_unit_head
*cu_header
= &cu
->header
;
8463 /* NOTE drow/2003-01-30: There used to be a comment and some special
8464 code here to turn a symbol with DW_AT_external and a
8465 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
8466 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
8467 with some versions of binutils) where shared libraries could have
8468 relocations against symbols in their debug information - the
8469 minimal symbol would have the right address, but the debug info
8470 would not. It's no longer necessary, because we will explicitly
8471 apply relocations when we read in the debug information now. */
8473 /* A DW_AT_location attribute with no contents indicates that a
8474 variable has been optimized away. */
8475 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
8477 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
8481 /* Handle one degenerate form of location expression specially, to
8482 preserve GDB's previous behavior when section offsets are
8483 specified. If this is just a DW_OP_addr then mark this symbol
8486 if (attr_form_is_block (attr
)
8487 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
8488 && DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
8492 SYMBOL_VALUE_ADDRESS (sym
) =
8493 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
8494 SYMBOL_CLASS (sym
) = LOC_STATIC
;
8495 fixup_symbol_section (sym
, objfile
);
8496 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
8497 SYMBOL_SECTION (sym
));
8501 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
8502 expression evaluator, and use LOC_COMPUTED only when necessary
8503 (i.e. when the value of a register or memory location is
8504 referenced, or a thread-local block, etc.). Then again, it might
8505 not be worthwhile. I'm assuming that it isn't unless performance
8506 or memory numbers show me otherwise. */
8508 dwarf2_symbol_mark_computed (attr
, sym
, cu
);
8509 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
8512 /* Given a pointer to a DWARF information entry, figure out if we need
8513 to make a symbol table entry for it, and if so, create a new entry
8514 and return a pointer to it.
8515 If TYPE is NULL, determine symbol type from the die, otherwise
8516 used the passed type. */
8518 static struct symbol
*
8519 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
8521 struct objfile
*objfile
= cu
->objfile
;
8522 struct symbol
*sym
= NULL
;
8524 struct attribute
*attr
= NULL
;
8525 struct attribute
*attr2
= NULL
;
8527 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
8529 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
8531 name
= dwarf2_name (die
, cu
);
8534 const char *linkagename
;
8536 sym
= (struct symbol
*) obstack_alloc (&objfile
->objfile_obstack
,
8537 sizeof (struct symbol
));
8538 OBJSTAT (objfile
, n_syms
++);
8539 memset (sym
, 0, sizeof (struct symbol
));
8541 /* Cache this symbol's name and the name's demangled form (if any). */
8542 SYMBOL_LANGUAGE (sym
) = cu
->language
;
8543 linkagename
= dwarf2_physname (name
, die
, cu
);
8544 SYMBOL_SET_NAMES (sym
, linkagename
, strlen (linkagename
), 0, objfile
);
8546 /* Default assumptions.
8547 Use the passed type or decode it from the die. */
8548 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
8549 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
8551 SYMBOL_TYPE (sym
) = type
;
8553 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
8554 attr
= dwarf2_attr (die
,
8555 inlined_func
? DW_AT_call_line
: DW_AT_decl_line
,
8559 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
8562 attr
= dwarf2_attr (die
,
8563 inlined_func
? DW_AT_call_file
: DW_AT_decl_file
,
8567 int file_index
= DW_UNSND (attr
);
8569 if (cu
->line_header
== NULL
8570 || file_index
> cu
->line_header
->num_file_names
)
8571 complaint (&symfile_complaints
,
8572 _("file index out of range"));
8573 else if (file_index
> 0)
8575 struct file_entry
*fe
;
8577 fe
= &cu
->line_header
->file_names
[file_index
- 1];
8578 SYMBOL_SYMTAB (sym
) = fe
->symtab
;
8585 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
8588 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
8590 SYMBOL_CLASS (sym
) = LOC_LABEL
;
8592 case DW_TAG_subprogram
:
8593 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
8595 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
8596 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
8597 if ((attr2
&& (DW_UNSND (attr2
) != 0))
8598 || cu
->language
== language_ada
)
8600 /* Subprograms marked external are stored as a global symbol.
8601 Ada subprograms, whether marked external or not, are always
8602 stored as a global symbol, because we want to be able to
8603 access them globally. For instance, we want to be able
8604 to break on a nested subprogram without having to
8605 specify the context. */
8606 add_symbol_to_list (sym
, &global_symbols
);
8610 add_symbol_to_list (sym
, cu
->list_in_scope
);
8613 case DW_TAG_inlined_subroutine
:
8614 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
8616 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
8617 SYMBOL_INLINED (sym
) = 1;
8618 /* Do not add the symbol to any lists. It will be found via
8619 BLOCK_FUNCTION from the blockvector. */
8621 case DW_TAG_variable
:
8622 /* Compilation with minimal debug info may result in variables
8623 with missing type entries. Change the misleading `void' type
8624 to something sensible. */
8625 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
8627 = objfile_type (objfile
)->nodebug_data_symbol
;
8629 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
8632 dwarf2_const_value (attr
, sym
, cu
);
8633 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
8634 if (attr2
&& (DW_UNSND (attr2
) != 0))
8635 add_symbol_to_list (sym
, &global_symbols
);
8637 add_symbol_to_list (sym
, cu
->list_in_scope
);
8640 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
8643 var_decode_location (attr
, sym
, cu
);
8644 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
8645 if (attr2
&& (DW_UNSND (attr2
) != 0))
8647 struct pending
**list_to_add
;
8649 /* A variable with DW_AT_external is never static,
8650 but it may be block-scoped. */
8651 list_to_add
= (cu
->list_in_scope
== &file_symbols
8652 ? &global_symbols
: cu
->list_in_scope
);
8653 add_symbol_to_list (sym
, list_to_add
);
8656 add_symbol_to_list (sym
, cu
->list_in_scope
);
8660 /* We do not know the address of this symbol.
8661 If it is an external symbol and we have type information
8662 for it, enter the symbol as a LOC_UNRESOLVED symbol.
8663 The address of the variable will then be determined from
8664 the minimal symbol table whenever the variable is
8666 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
8667 if (attr2
&& (DW_UNSND (attr2
) != 0)
8668 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
8670 struct pending
**list_to_add
;
8672 /* A variable with DW_AT_external is never static, but it
8673 may be block-scoped. */
8674 list_to_add
= (cu
->list_in_scope
== &file_symbols
8675 ? &global_symbols
: cu
->list_in_scope
);
8677 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
8678 add_symbol_to_list (sym
, list_to_add
);
8680 else if (!die_is_declaration (die
, cu
))
8682 /* Use the default LOC_OPTIMIZED_OUT class. */
8683 gdb_assert (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
);
8684 add_symbol_to_list (sym
, cu
->list_in_scope
);
8688 case DW_TAG_formal_parameter
:
8689 /* If we are inside a function, mark this as an argument. If
8690 not, we might be looking at an argument to an inlined function
8691 when we do not have enough information to show inlined frames;
8692 pretend it's a local variable in that case so that the user can
8694 if (context_stack_depth
> 0
8695 && context_stack
[context_stack_depth
- 1].name
!= NULL
)
8696 SYMBOL_IS_ARGUMENT (sym
) = 1;
8697 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
8700 var_decode_location (attr
, sym
, cu
);
8702 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
8705 dwarf2_const_value (attr
, sym
, cu
);
8707 attr
= dwarf2_attr (die
, DW_AT_variable_parameter
, cu
);
8708 if (attr
&& DW_UNSND (attr
))
8710 struct type
*ref_type
;
8712 ref_type
= lookup_reference_type (SYMBOL_TYPE (sym
));
8713 SYMBOL_TYPE (sym
) = ref_type
;
8716 add_symbol_to_list (sym
, cu
->list_in_scope
);
8718 case DW_TAG_unspecified_parameters
:
8719 /* From varargs functions; gdb doesn't seem to have any
8720 interest in this information, so just ignore it for now.
8723 case DW_TAG_class_type
:
8724 case DW_TAG_interface_type
:
8725 case DW_TAG_structure_type
:
8726 case DW_TAG_union_type
:
8727 case DW_TAG_set_type
:
8728 case DW_TAG_enumeration_type
:
8729 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
8730 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
8732 /* Make sure that the symbol includes appropriate enclosing
8733 classes/namespaces in its name. These are calculated in
8734 read_structure_type, and the correct name is saved in
8737 if (cu
->language
== language_cplus
8738 || cu
->language
== language_java
)
8740 struct type
*type
= SYMBOL_TYPE (sym
);
8742 if (TYPE_TAG_NAME (type
) != NULL
)
8744 /* FIXME: carlton/2003-11-10: Should this use
8745 SYMBOL_SET_NAMES instead? (The same problem also
8746 arises further down in this function.) */
8747 /* The type's name is already allocated along with
8748 this objfile, so we don't need to duplicate it
8750 SYMBOL_LINKAGE_NAME (sym
) = TYPE_TAG_NAME (type
);
8755 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
8756 really ever be static objects: otherwise, if you try
8757 to, say, break of a class's method and you're in a file
8758 which doesn't mention that class, it won't work unless
8759 the check for all static symbols in lookup_symbol_aux
8760 saves you. See the OtherFileClass tests in
8761 gdb.c++/namespace.exp. */
8763 struct pending
**list_to_add
;
8765 list_to_add
= (cu
->list_in_scope
== &file_symbols
8766 && (cu
->language
== language_cplus
8767 || cu
->language
== language_java
)
8768 ? &global_symbols
: cu
->list_in_scope
);
8770 add_symbol_to_list (sym
, list_to_add
);
8772 /* The semantics of C++ state that "struct foo { ... }" also
8773 defines a typedef for "foo". A Java class declaration also
8774 defines a typedef for the class. */
8775 if (cu
->language
== language_cplus
8776 || cu
->language
== language_java
8777 || cu
->language
== language_ada
)
8779 /* The symbol's name is already allocated along with
8780 this objfile, so we don't need to duplicate it for
8782 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
8783 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
8787 case DW_TAG_typedef
:
8788 SYMBOL_LINKAGE_NAME (sym
)
8789 = (char *) dwarf2_full_name (name
, die
, cu
);
8790 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
8791 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
8792 add_symbol_to_list (sym
, cu
->list_in_scope
);
8794 case DW_TAG_base_type
:
8795 case DW_TAG_subrange_type
:
8796 case DW_TAG_const_type
:
8797 case DW_TAG_volatile_type
:
8798 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
8799 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
8800 add_symbol_to_list (sym
, cu
->list_in_scope
);
8802 case DW_TAG_enumerator
:
8803 SYMBOL_LINKAGE_NAME (sym
)
8804 = (char *) dwarf2_full_name (name
, die
, cu
);
8805 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
8808 dwarf2_const_value (attr
, sym
, cu
);
8811 /* NOTE: carlton/2003-11-10: See comment above in the
8812 DW_TAG_class_type, etc. block. */
8814 struct pending
**list_to_add
;
8816 list_to_add
= (cu
->list_in_scope
== &file_symbols
8817 && (cu
->language
== language_cplus
8818 || cu
->language
== language_java
)
8819 ? &global_symbols
: cu
->list_in_scope
);
8821 add_symbol_to_list (sym
, list_to_add
);
8824 case DW_TAG_namespace
:
8825 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
8826 add_symbol_to_list (sym
, &global_symbols
);
8829 /* Not a tag we recognize. Hopefully we aren't processing
8830 trash data, but since we must specifically ignore things
8831 we don't recognize, there is nothing else we should do at
8833 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
8834 dwarf_tag_name (die
->tag
));
8838 /* For the benefit of old versions of GCC, check for anonymous
8839 namespaces based on the demangled name. */
8840 if (!processing_has_namespace_info
8841 && cu
->language
== language_cplus
)
8842 cp_scan_for_anonymous_namespaces (sym
);
8847 /* Copy constant value from an attribute to a symbol. */
8850 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
8851 struct dwarf2_cu
*cu
)
8853 struct objfile
*objfile
= cu
->objfile
;
8854 struct comp_unit_head
*cu_header
= &cu
->header
;
8855 enum bfd_endian byte_order
= bfd_big_endian (objfile
->obfd
) ?
8856 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
8857 struct dwarf_block
*blk
;
8862 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
8863 dwarf2_const_value_length_mismatch_complaint (SYMBOL_PRINT_NAME (sym
),
8864 cu_header
->addr_size
,
8865 TYPE_LENGTH (SYMBOL_TYPE
8867 SYMBOL_VALUE_BYTES (sym
) =
8868 obstack_alloc (&objfile
->objfile_obstack
, cu_header
->addr_size
);
8869 /* NOTE: cagney/2003-05-09: In-lined store_address call with
8870 it's body - store_unsigned_integer. */
8871 store_unsigned_integer (SYMBOL_VALUE_BYTES (sym
), cu_header
->addr_size
,
8872 byte_order
, DW_ADDR (attr
));
8873 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
8875 case DW_FORM_string
:
8877 /* DW_STRING is already allocated on the obstack, point directly
8879 SYMBOL_VALUE_BYTES (sym
) = (gdb_byte
*) DW_STRING (attr
);
8880 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
8882 case DW_FORM_block1
:
8883 case DW_FORM_block2
:
8884 case DW_FORM_block4
:
8886 case DW_FORM_exprloc
:
8887 blk
= DW_BLOCK (attr
);
8888 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
8889 dwarf2_const_value_length_mismatch_complaint (SYMBOL_PRINT_NAME (sym
),
8891 TYPE_LENGTH (SYMBOL_TYPE
8893 SYMBOL_VALUE_BYTES (sym
) =
8894 obstack_alloc (&objfile
->objfile_obstack
, blk
->size
);
8895 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
8896 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
8899 /* The DW_AT_const_value attributes are supposed to carry the
8900 symbol's value "represented as it would be on the target
8901 architecture." By the time we get here, it's already been
8902 converted to host endianness, so we just need to sign- or
8903 zero-extend it as appropriate. */
8905 dwarf2_const_value_data (attr
, sym
, 8);
8908 dwarf2_const_value_data (attr
, sym
, 16);
8911 dwarf2_const_value_data (attr
, sym
, 32);
8914 dwarf2_const_value_data (attr
, sym
, 64);
8918 SYMBOL_VALUE (sym
) = DW_SND (attr
);
8919 SYMBOL_CLASS (sym
) = LOC_CONST
;
8923 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
8924 SYMBOL_CLASS (sym
) = LOC_CONST
;
8928 complaint (&symfile_complaints
,
8929 _("unsupported const value attribute form: '%s'"),
8930 dwarf_form_name (attr
->form
));
8931 SYMBOL_VALUE (sym
) = 0;
8932 SYMBOL_CLASS (sym
) = LOC_CONST
;
8938 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
8939 or zero-extend it as appropriate for the symbol's type. */
8941 dwarf2_const_value_data (struct attribute
*attr
,
8945 LONGEST l
= DW_UNSND (attr
);
8947 if (bits
< sizeof (l
) * 8)
8949 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
8950 l
&= ((LONGEST
) 1 << bits
) - 1;
8952 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
8955 SYMBOL_VALUE (sym
) = l
;
8956 SYMBOL_CLASS (sym
) = LOC_CONST
;
8960 /* Return the type of the die in question using its DW_AT_type attribute. */
8962 static struct type
*
8963 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8965 struct attribute
*type_attr
;
8966 struct die_info
*type_die
;
8968 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
8971 /* A missing DW_AT_type represents a void type. */
8972 return objfile_type (cu
->objfile
)->builtin_void
;
8975 type_die
= follow_die_ref_or_sig (die
, type_attr
, &cu
);
8977 return tag_type_to_type (type_die
, cu
);
8980 /* True iff CU's producer generates GNAT Ada auxiliary information
8981 that allows to find parallel types through that information instead
8982 of having to do expensive parallel lookups by type name. */
8985 need_gnat_info (struct dwarf2_cu
*cu
)
8987 /* FIXME: brobecker/2010-10-12: As of now, only the AdaCore version
8988 of GNAT produces this auxiliary information, without any indication
8989 that it is produced. Part of enhancing the FSF version of GNAT
8990 to produce that information will be to put in place an indicator
8991 that we can use in order to determine whether the descriptive type
8992 info is available or not. One suggestion that has been made is
8993 to use a new attribute, attached to the CU die. For now, assume
8994 that the descriptive type info is not available. */
8999 /* Return the auxiliary type of the die in question using its
9000 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
9001 attribute is not present. */
9003 static struct type
*
9004 die_descriptive_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
9006 struct attribute
*type_attr
;
9007 struct die_info
*type_die
;
9009 type_attr
= dwarf2_attr (die
, DW_AT_GNAT_descriptive_type
, cu
);
9013 type_die
= follow_die_ref (die
, type_attr
, &cu
);
9014 return tag_type_to_type (type_die
, cu
);
9017 /* If DIE has a descriptive_type attribute, then set the TYPE's
9018 descriptive type accordingly. */
9021 set_descriptive_type (struct type
*type
, struct die_info
*die
,
9022 struct dwarf2_cu
*cu
)
9024 struct type
*descriptive_type
= die_descriptive_type (die
, cu
);
9026 if (descriptive_type
)
9028 ALLOCATE_GNAT_AUX_TYPE (type
);
9029 TYPE_DESCRIPTIVE_TYPE (type
) = descriptive_type
;
9033 /* Return the containing type of the die in question using its
9034 DW_AT_containing_type attribute. */
9036 static struct type
*
9037 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
9039 struct attribute
*type_attr
;
9040 struct die_info
*type_die
;
9042 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
9044 error (_("Dwarf Error: Problem turning containing type into gdb type "
9045 "[in module %s]"), cu
->objfile
->name
);
9047 type_die
= follow_die_ref_or_sig (die
, type_attr
, &cu
);
9048 return tag_type_to_type (type_die
, cu
);
9051 static struct type
*
9052 tag_type_to_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
9054 struct type
*this_type
;
9056 this_type
= read_type_die (die
, cu
);
9059 dump_die_for_error (die
);
9060 error (_("Dwarf Error: Cannot find type of die [in module %s]"),
9066 static struct type
*
9067 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
9069 struct type
*this_type
;
9071 this_type
= get_die_type (die
, cu
);
9077 case DW_TAG_class_type
:
9078 case DW_TAG_interface_type
:
9079 case DW_TAG_structure_type
:
9080 case DW_TAG_union_type
:
9081 this_type
= read_structure_type (die
, cu
);
9083 case DW_TAG_enumeration_type
:
9084 this_type
= read_enumeration_type (die
, cu
);
9086 case DW_TAG_subprogram
:
9087 case DW_TAG_subroutine_type
:
9088 case DW_TAG_inlined_subroutine
:
9089 this_type
= read_subroutine_type (die
, cu
);
9091 case DW_TAG_array_type
:
9092 this_type
= read_array_type (die
, cu
);
9094 case DW_TAG_set_type
:
9095 this_type
= read_set_type (die
, cu
);
9097 case DW_TAG_pointer_type
:
9098 this_type
= read_tag_pointer_type (die
, cu
);
9100 case DW_TAG_ptr_to_member_type
:
9101 this_type
= read_tag_ptr_to_member_type (die
, cu
);
9103 case DW_TAG_reference_type
:
9104 this_type
= read_tag_reference_type (die
, cu
);
9106 case DW_TAG_const_type
:
9107 this_type
= read_tag_const_type (die
, cu
);
9109 case DW_TAG_volatile_type
:
9110 this_type
= read_tag_volatile_type (die
, cu
);
9112 case DW_TAG_string_type
:
9113 this_type
= read_tag_string_type (die
, cu
);
9115 case DW_TAG_typedef
:
9116 this_type
= read_typedef (die
, cu
);
9118 case DW_TAG_subrange_type
:
9119 this_type
= read_subrange_type (die
, cu
);
9121 case DW_TAG_base_type
:
9122 this_type
= read_base_type (die
, cu
);
9124 case DW_TAG_unspecified_type
:
9125 this_type
= read_unspecified_type (die
, cu
);
9127 case DW_TAG_namespace
:
9128 this_type
= read_namespace_type (die
, cu
);
9131 complaint (&symfile_complaints
, _("unexpected tag in read_type_die: '%s'"),
9132 dwarf_tag_name (die
->tag
));
9139 /* Return the name of the namespace/class that DIE is defined within,
9140 or "" if we can't tell. The caller should not xfree the result.
9142 For example, if we're within the method foo() in the following
9152 then determine_prefix on foo's die will return "N::C". */
9155 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
9157 struct die_info
*parent
, *spec_die
;
9158 struct dwarf2_cu
*spec_cu
;
9159 struct type
*parent_type
;
9161 if (cu
->language
!= language_cplus
9162 && cu
->language
!= language_java
)
9165 /* We have to be careful in the presence of DW_AT_specification.
9166 For example, with GCC 3.4, given the code
9170 // Definition of N::foo.
9174 then we'll have a tree of DIEs like this:
9176 1: DW_TAG_compile_unit
9177 2: DW_TAG_namespace // N
9178 3: DW_TAG_subprogram // declaration of N::foo
9179 4: DW_TAG_subprogram // definition of N::foo
9180 DW_AT_specification // refers to die #3
9182 Thus, when processing die #4, we have to pretend that we're in
9183 the context of its DW_AT_specification, namely the contex of die
9186 spec_die
= die_specification (die
, &spec_cu
);
9187 if (spec_die
== NULL
)
9188 parent
= die
->parent
;
9191 parent
= spec_die
->parent
;
9198 switch (parent
->tag
)
9200 case DW_TAG_namespace
:
9201 parent_type
= read_type_die (parent
, cu
);
9202 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
9203 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
9204 Work around this problem here. */
9205 if (cu
->language
== language_cplus
9206 && strcmp (TYPE_TAG_NAME (parent_type
), "::") == 0)
9208 /* We give a name to even anonymous namespaces. */
9209 return TYPE_TAG_NAME (parent_type
);
9210 case DW_TAG_class_type
:
9211 case DW_TAG_interface_type
:
9212 case DW_TAG_structure_type
:
9213 case DW_TAG_union_type
:
9214 parent_type
= read_type_die (parent
, cu
);
9215 if (TYPE_TAG_NAME (parent_type
) != NULL
)
9216 return TYPE_TAG_NAME (parent_type
);
9218 /* An anonymous structure is only allowed non-static data
9219 members; no typedefs, no member functions, et cetera.
9220 So it does not need a prefix. */
9223 return determine_prefix (parent
, cu
);
9227 /* Return a newly-allocated string formed by concatenating PREFIX and
9228 SUFFIX with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
9229 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null,
9230 perform an obconcat, otherwise allocate storage for the result. The CU argument
9231 is used to determine the language and hence, the appropriate separator. */
9233 #define MAX_SEP_LEN 2 /* sizeof ("::") */
9236 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
9237 struct dwarf2_cu
*cu
)
9241 if (suffix
== NULL
|| suffix
[0] == '\0' || prefix
== NULL
|| prefix
[0] == '\0')
9243 else if (cu
->language
== language_java
)
9255 char *retval
= xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1);
9257 strcpy (retval
, prefix
);
9258 strcat (retval
, sep
);
9259 strcat (retval
, suffix
);
9264 /* We have an obstack. */
9265 return obconcat (obs
, prefix
, sep
, suffix
, (char *) NULL
);
9269 /* Return sibling of die, NULL if no sibling. */
9271 static struct die_info
*
9272 sibling_die (struct die_info
*die
)
9274 return die
->sibling
;
9277 /* Get name of a die, return NULL if not found. */
9280 dwarf2_canonicalize_name (char *name
, struct dwarf2_cu
*cu
,
9281 struct obstack
*obstack
)
9283 if (name
&& cu
->language
== language_cplus
)
9285 char *canon_name
= cp_canonicalize_string (name
);
9287 if (canon_name
!= NULL
)
9289 if (strcmp (canon_name
, name
) != 0)
9290 name
= obsavestring (canon_name
, strlen (canon_name
),
9299 /* Get name of a die, return NULL if not found. */
9302 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
9304 struct attribute
*attr
;
9306 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
9307 if (!attr
|| !DW_STRING (attr
))
9312 case DW_TAG_compile_unit
:
9313 /* Compilation units have a DW_AT_name that is a filename, not
9314 a source language identifier. */
9315 case DW_TAG_enumeration_type
:
9316 case DW_TAG_enumerator
:
9317 /* These tags always have simple identifiers already; no need
9318 to canonicalize them. */
9319 return DW_STRING (attr
);
9321 case DW_TAG_subprogram
:
9322 /* Java constructors will all be named "<init>", so return
9323 the class name when we see this special case. */
9324 if (cu
->language
== language_java
9325 && DW_STRING (attr
) != NULL
9326 && strcmp (DW_STRING (attr
), "<init>") == 0)
9328 struct dwarf2_cu
*spec_cu
= cu
;
9329 struct die_info
*spec_die
;
9331 /* GCJ will output '<init>' for Java constructor names.
9332 For this special case, return the name of the parent class. */
9334 /* GCJ may output suprogram DIEs with AT_specification set.
9335 If so, use the name of the specified DIE. */
9336 spec_die
= die_specification (die
, &spec_cu
);
9337 if (spec_die
!= NULL
)
9338 return dwarf2_name (spec_die
, spec_cu
);
9343 if (die
->tag
== DW_TAG_class_type
)
9344 return dwarf2_name (die
, cu
);
9346 while (die
->tag
!= DW_TAG_compile_unit
);
9350 case DW_TAG_class_type
:
9351 case DW_TAG_interface_type
:
9352 case DW_TAG_structure_type
:
9353 case DW_TAG_union_type
:
9354 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
9355 structures or unions. These were of the form "._%d" in GCC 4.1,
9356 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
9357 and GCC 4.4. We work around this problem by ignoring these. */
9358 if (strncmp (DW_STRING (attr
), "._", 2) == 0
9359 || strncmp (DW_STRING (attr
), "<anonymous", 10) == 0)
9367 if (!DW_STRING_IS_CANONICAL (attr
))
9370 = dwarf2_canonicalize_name (DW_STRING (attr
), cu
,
9371 &cu
->objfile
->objfile_obstack
);
9372 DW_STRING_IS_CANONICAL (attr
) = 1;
9374 return DW_STRING (attr
);
9377 /* Return the die that this die in an extension of, or NULL if there
9378 is none. *EXT_CU is the CU containing DIE on input, and the CU
9379 containing the return value on output. */
9381 static struct die_info
*
9382 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
**ext_cu
)
9384 struct attribute
*attr
;
9386 attr
= dwarf2_attr (die
, DW_AT_extension
, *ext_cu
);
9390 return follow_die_ref (die
, attr
, ext_cu
);
9393 /* Convert a DIE tag into its string name. */
9396 dwarf_tag_name (unsigned tag
)
9400 case DW_TAG_padding
:
9401 return "DW_TAG_padding";
9402 case DW_TAG_array_type
:
9403 return "DW_TAG_array_type";
9404 case DW_TAG_class_type
:
9405 return "DW_TAG_class_type";
9406 case DW_TAG_entry_point
:
9407 return "DW_TAG_entry_point";
9408 case DW_TAG_enumeration_type
:
9409 return "DW_TAG_enumeration_type";
9410 case DW_TAG_formal_parameter
:
9411 return "DW_TAG_formal_parameter";
9412 case DW_TAG_imported_declaration
:
9413 return "DW_TAG_imported_declaration";
9415 return "DW_TAG_label";
9416 case DW_TAG_lexical_block
:
9417 return "DW_TAG_lexical_block";
9419 return "DW_TAG_member";
9420 case DW_TAG_pointer_type
:
9421 return "DW_TAG_pointer_type";
9422 case DW_TAG_reference_type
:
9423 return "DW_TAG_reference_type";
9424 case DW_TAG_compile_unit
:
9425 return "DW_TAG_compile_unit";
9426 case DW_TAG_string_type
:
9427 return "DW_TAG_string_type";
9428 case DW_TAG_structure_type
:
9429 return "DW_TAG_structure_type";
9430 case DW_TAG_subroutine_type
:
9431 return "DW_TAG_subroutine_type";
9432 case DW_TAG_typedef
:
9433 return "DW_TAG_typedef";
9434 case DW_TAG_union_type
:
9435 return "DW_TAG_union_type";
9436 case DW_TAG_unspecified_parameters
:
9437 return "DW_TAG_unspecified_parameters";
9438 case DW_TAG_variant
:
9439 return "DW_TAG_variant";
9440 case DW_TAG_common_block
:
9441 return "DW_TAG_common_block";
9442 case DW_TAG_common_inclusion
:
9443 return "DW_TAG_common_inclusion";
9444 case DW_TAG_inheritance
:
9445 return "DW_TAG_inheritance";
9446 case DW_TAG_inlined_subroutine
:
9447 return "DW_TAG_inlined_subroutine";
9449 return "DW_TAG_module";
9450 case DW_TAG_ptr_to_member_type
:
9451 return "DW_TAG_ptr_to_member_type";
9452 case DW_TAG_set_type
:
9453 return "DW_TAG_set_type";
9454 case DW_TAG_subrange_type
:
9455 return "DW_TAG_subrange_type";
9456 case DW_TAG_with_stmt
:
9457 return "DW_TAG_with_stmt";
9458 case DW_TAG_access_declaration
:
9459 return "DW_TAG_access_declaration";
9460 case DW_TAG_base_type
:
9461 return "DW_TAG_base_type";
9462 case DW_TAG_catch_block
:
9463 return "DW_TAG_catch_block";
9464 case DW_TAG_const_type
:
9465 return "DW_TAG_const_type";
9466 case DW_TAG_constant
:
9467 return "DW_TAG_constant";
9468 case DW_TAG_enumerator
:
9469 return "DW_TAG_enumerator";
9470 case DW_TAG_file_type
:
9471 return "DW_TAG_file_type";
9473 return "DW_TAG_friend";
9474 case DW_TAG_namelist
:
9475 return "DW_TAG_namelist";
9476 case DW_TAG_namelist_item
:
9477 return "DW_TAG_namelist_item";
9478 case DW_TAG_packed_type
:
9479 return "DW_TAG_packed_type";
9480 case DW_TAG_subprogram
:
9481 return "DW_TAG_subprogram";
9482 case DW_TAG_template_type_param
:
9483 return "DW_TAG_template_type_param";
9484 case DW_TAG_template_value_param
:
9485 return "DW_TAG_template_value_param";
9486 case DW_TAG_thrown_type
:
9487 return "DW_TAG_thrown_type";
9488 case DW_TAG_try_block
:
9489 return "DW_TAG_try_block";
9490 case DW_TAG_variant_part
:
9491 return "DW_TAG_variant_part";
9492 case DW_TAG_variable
:
9493 return "DW_TAG_variable";
9494 case DW_TAG_volatile_type
:
9495 return "DW_TAG_volatile_type";
9496 case DW_TAG_dwarf_procedure
:
9497 return "DW_TAG_dwarf_procedure";
9498 case DW_TAG_restrict_type
:
9499 return "DW_TAG_restrict_type";
9500 case DW_TAG_interface_type
:
9501 return "DW_TAG_interface_type";
9502 case DW_TAG_namespace
:
9503 return "DW_TAG_namespace";
9504 case DW_TAG_imported_module
:
9505 return "DW_TAG_imported_module";
9506 case DW_TAG_unspecified_type
:
9507 return "DW_TAG_unspecified_type";
9508 case DW_TAG_partial_unit
:
9509 return "DW_TAG_partial_unit";
9510 case DW_TAG_imported_unit
:
9511 return "DW_TAG_imported_unit";
9512 case DW_TAG_condition
:
9513 return "DW_TAG_condition";
9514 case DW_TAG_shared_type
:
9515 return "DW_TAG_shared_type";
9516 case DW_TAG_type_unit
:
9517 return "DW_TAG_type_unit";
9518 case DW_TAG_MIPS_loop
:
9519 return "DW_TAG_MIPS_loop";
9520 case DW_TAG_HP_array_descriptor
:
9521 return "DW_TAG_HP_array_descriptor";
9522 case DW_TAG_format_label
:
9523 return "DW_TAG_format_label";
9524 case DW_TAG_function_template
:
9525 return "DW_TAG_function_template";
9526 case DW_TAG_class_template
:
9527 return "DW_TAG_class_template";
9528 case DW_TAG_GNU_BINCL
:
9529 return "DW_TAG_GNU_BINCL";
9530 case DW_TAG_GNU_EINCL
:
9531 return "DW_TAG_GNU_EINCL";
9532 case DW_TAG_upc_shared_type
:
9533 return "DW_TAG_upc_shared_type";
9534 case DW_TAG_upc_strict_type
:
9535 return "DW_TAG_upc_strict_type";
9536 case DW_TAG_upc_relaxed_type
:
9537 return "DW_TAG_upc_relaxed_type";
9538 case DW_TAG_PGI_kanji_type
:
9539 return "DW_TAG_PGI_kanji_type";
9540 case DW_TAG_PGI_interface_block
:
9541 return "DW_TAG_PGI_interface_block";
9543 return "DW_TAG_<unknown>";
9547 /* Convert a DWARF attribute code into its string name. */
9550 dwarf_attr_name (unsigned attr
)
9555 return "DW_AT_sibling";
9556 case DW_AT_location
:
9557 return "DW_AT_location";
9559 return "DW_AT_name";
9560 case DW_AT_ordering
:
9561 return "DW_AT_ordering";
9562 case DW_AT_subscr_data
:
9563 return "DW_AT_subscr_data";
9564 case DW_AT_byte_size
:
9565 return "DW_AT_byte_size";
9566 case DW_AT_bit_offset
:
9567 return "DW_AT_bit_offset";
9568 case DW_AT_bit_size
:
9569 return "DW_AT_bit_size";
9570 case DW_AT_element_list
:
9571 return "DW_AT_element_list";
9572 case DW_AT_stmt_list
:
9573 return "DW_AT_stmt_list";
9575 return "DW_AT_low_pc";
9577 return "DW_AT_high_pc";
9578 case DW_AT_language
:
9579 return "DW_AT_language";
9581 return "DW_AT_member";
9583 return "DW_AT_discr";
9584 case DW_AT_discr_value
:
9585 return "DW_AT_discr_value";
9586 case DW_AT_visibility
:
9587 return "DW_AT_visibility";
9589 return "DW_AT_import";
9590 case DW_AT_string_length
:
9591 return "DW_AT_string_length";
9592 case DW_AT_common_reference
:
9593 return "DW_AT_common_reference";
9594 case DW_AT_comp_dir
:
9595 return "DW_AT_comp_dir";
9596 case DW_AT_const_value
:
9597 return "DW_AT_const_value";
9598 case DW_AT_containing_type
:
9599 return "DW_AT_containing_type";
9600 case DW_AT_default_value
:
9601 return "DW_AT_default_value";
9603 return "DW_AT_inline";
9604 case DW_AT_is_optional
:
9605 return "DW_AT_is_optional";
9606 case DW_AT_lower_bound
:
9607 return "DW_AT_lower_bound";
9608 case DW_AT_producer
:
9609 return "DW_AT_producer";
9610 case DW_AT_prototyped
:
9611 return "DW_AT_prototyped";
9612 case DW_AT_return_addr
:
9613 return "DW_AT_return_addr";
9614 case DW_AT_start_scope
:
9615 return "DW_AT_start_scope";
9616 case DW_AT_bit_stride
:
9617 return "DW_AT_bit_stride";
9618 case DW_AT_upper_bound
:
9619 return "DW_AT_upper_bound";
9620 case DW_AT_abstract_origin
:
9621 return "DW_AT_abstract_origin";
9622 case DW_AT_accessibility
:
9623 return "DW_AT_accessibility";
9624 case DW_AT_address_class
:
9625 return "DW_AT_address_class";
9626 case DW_AT_artificial
:
9627 return "DW_AT_artificial";
9628 case DW_AT_base_types
:
9629 return "DW_AT_base_types";
9630 case DW_AT_calling_convention
:
9631 return "DW_AT_calling_convention";
9633 return "DW_AT_count";
9634 case DW_AT_data_member_location
:
9635 return "DW_AT_data_member_location";
9636 case DW_AT_decl_column
:
9637 return "DW_AT_decl_column";
9638 case DW_AT_decl_file
:
9639 return "DW_AT_decl_file";
9640 case DW_AT_decl_line
:
9641 return "DW_AT_decl_line";
9642 case DW_AT_declaration
:
9643 return "DW_AT_declaration";
9644 case DW_AT_discr_list
:
9645 return "DW_AT_discr_list";
9646 case DW_AT_encoding
:
9647 return "DW_AT_encoding";
9648 case DW_AT_external
:
9649 return "DW_AT_external";
9650 case DW_AT_frame_base
:
9651 return "DW_AT_frame_base";
9653 return "DW_AT_friend";
9654 case DW_AT_identifier_case
:
9655 return "DW_AT_identifier_case";
9656 case DW_AT_macro_info
:
9657 return "DW_AT_macro_info";
9658 case DW_AT_namelist_items
:
9659 return "DW_AT_namelist_items";
9660 case DW_AT_priority
:
9661 return "DW_AT_priority";
9663 return "DW_AT_segment";
9664 case DW_AT_specification
:
9665 return "DW_AT_specification";
9666 case DW_AT_static_link
:
9667 return "DW_AT_static_link";
9669 return "DW_AT_type";
9670 case DW_AT_use_location
:
9671 return "DW_AT_use_location";
9672 case DW_AT_variable_parameter
:
9673 return "DW_AT_variable_parameter";
9674 case DW_AT_virtuality
:
9675 return "DW_AT_virtuality";
9676 case DW_AT_vtable_elem_location
:
9677 return "DW_AT_vtable_elem_location";
9678 /* DWARF 3 values. */
9679 case DW_AT_allocated
:
9680 return "DW_AT_allocated";
9681 case DW_AT_associated
:
9682 return "DW_AT_associated";
9683 case DW_AT_data_location
:
9684 return "DW_AT_data_location";
9685 case DW_AT_byte_stride
:
9686 return "DW_AT_byte_stride";
9687 case DW_AT_entry_pc
:
9688 return "DW_AT_entry_pc";
9689 case DW_AT_use_UTF8
:
9690 return "DW_AT_use_UTF8";
9691 case DW_AT_extension
:
9692 return "DW_AT_extension";
9694 return "DW_AT_ranges";
9695 case DW_AT_trampoline
:
9696 return "DW_AT_trampoline";
9697 case DW_AT_call_column
:
9698 return "DW_AT_call_column";
9699 case DW_AT_call_file
:
9700 return "DW_AT_call_file";
9701 case DW_AT_call_line
:
9702 return "DW_AT_call_line";
9703 case DW_AT_description
:
9704 return "DW_AT_description";
9705 case DW_AT_binary_scale
:
9706 return "DW_AT_binary_scale";
9707 case DW_AT_decimal_scale
:
9708 return "DW_AT_decimal_scale";
9710 return "DW_AT_small";
9711 case DW_AT_decimal_sign
:
9712 return "DW_AT_decimal_sign";
9713 case DW_AT_digit_count
:
9714 return "DW_AT_digit_count";
9715 case DW_AT_picture_string
:
9716 return "DW_AT_picture_string";
9718 return "DW_AT_mutable";
9719 case DW_AT_threads_scaled
:
9720 return "DW_AT_threads_scaled";
9721 case DW_AT_explicit
:
9722 return "DW_AT_explicit";
9723 case DW_AT_object_pointer
:
9724 return "DW_AT_object_pointer";
9725 case DW_AT_endianity
:
9726 return "DW_AT_endianity";
9727 case DW_AT_elemental
:
9728 return "DW_AT_elemental";
9730 return "DW_AT_pure";
9731 case DW_AT_recursive
:
9732 return "DW_AT_recursive";
9733 /* DWARF 4 values. */
9734 case DW_AT_signature
:
9735 return "DW_AT_signature";
9736 case DW_AT_linkage_name
:
9737 return "DW_AT_linkage_name";
9738 /* SGI/MIPS extensions. */
9739 #ifdef MIPS /* collides with DW_AT_HP_block_index */
9740 case DW_AT_MIPS_fde
:
9741 return "DW_AT_MIPS_fde";
9743 case DW_AT_MIPS_loop_begin
:
9744 return "DW_AT_MIPS_loop_begin";
9745 case DW_AT_MIPS_tail_loop_begin
:
9746 return "DW_AT_MIPS_tail_loop_begin";
9747 case DW_AT_MIPS_epilog_begin
:
9748 return "DW_AT_MIPS_epilog_begin";
9749 case DW_AT_MIPS_loop_unroll_factor
:
9750 return "DW_AT_MIPS_loop_unroll_factor";
9751 case DW_AT_MIPS_software_pipeline_depth
:
9752 return "DW_AT_MIPS_software_pipeline_depth";
9753 case DW_AT_MIPS_linkage_name
:
9754 return "DW_AT_MIPS_linkage_name";
9755 case DW_AT_MIPS_stride
:
9756 return "DW_AT_MIPS_stride";
9757 case DW_AT_MIPS_abstract_name
:
9758 return "DW_AT_MIPS_abstract_name";
9759 case DW_AT_MIPS_clone_origin
:
9760 return "DW_AT_MIPS_clone_origin";
9761 case DW_AT_MIPS_has_inlines
:
9762 return "DW_AT_MIPS_has_inlines";
9763 /* HP extensions. */
9764 #ifndef MIPS /* collides with DW_AT_MIPS_fde */
9765 case DW_AT_HP_block_index
:
9766 return "DW_AT_HP_block_index";
9768 case DW_AT_HP_unmodifiable
:
9769 return "DW_AT_HP_unmodifiable";
9770 case DW_AT_HP_actuals_stmt_list
:
9771 return "DW_AT_HP_actuals_stmt_list";
9772 case DW_AT_HP_proc_per_section
:
9773 return "DW_AT_HP_proc_per_section";
9774 case DW_AT_HP_raw_data_ptr
:
9775 return "DW_AT_HP_raw_data_ptr";
9776 case DW_AT_HP_pass_by_reference
:
9777 return "DW_AT_HP_pass_by_reference";
9778 case DW_AT_HP_opt_level
:
9779 return "DW_AT_HP_opt_level";
9780 case DW_AT_HP_prof_version_id
:
9781 return "DW_AT_HP_prof_version_id";
9782 case DW_AT_HP_opt_flags
:
9783 return "DW_AT_HP_opt_flags";
9784 case DW_AT_HP_cold_region_low_pc
:
9785 return "DW_AT_HP_cold_region_low_pc";
9786 case DW_AT_HP_cold_region_high_pc
:
9787 return "DW_AT_HP_cold_region_high_pc";
9788 case DW_AT_HP_all_variables_modifiable
:
9789 return "DW_AT_HP_all_variables_modifiable";
9790 case DW_AT_HP_linkage_name
:
9791 return "DW_AT_HP_linkage_name";
9792 case DW_AT_HP_prof_flags
:
9793 return "DW_AT_HP_prof_flags";
9794 /* GNU extensions. */
9795 case DW_AT_sf_names
:
9796 return "DW_AT_sf_names";
9797 case DW_AT_src_info
:
9798 return "DW_AT_src_info";
9799 case DW_AT_mac_info
:
9800 return "DW_AT_mac_info";
9801 case DW_AT_src_coords
:
9802 return "DW_AT_src_coords";
9803 case DW_AT_body_begin
:
9804 return "DW_AT_body_begin";
9805 case DW_AT_body_end
:
9806 return "DW_AT_body_end";
9807 case DW_AT_GNU_vector
:
9808 return "DW_AT_GNU_vector";
9809 /* VMS extensions. */
9810 case DW_AT_VMS_rtnbeg_pd_address
:
9811 return "DW_AT_VMS_rtnbeg_pd_address";
9812 /* UPC extension. */
9813 case DW_AT_upc_threads_scaled
:
9814 return "DW_AT_upc_threads_scaled";
9815 /* PGI (STMicroelectronics) extensions. */
9816 case DW_AT_PGI_lbase
:
9817 return "DW_AT_PGI_lbase";
9818 case DW_AT_PGI_soffset
:
9819 return "DW_AT_PGI_soffset";
9820 case DW_AT_PGI_lstride
:
9821 return "DW_AT_PGI_lstride";
9823 return "DW_AT_<unknown>";
9827 /* Convert a DWARF value form code into its string name. */
9830 dwarf_form_name (unsigned form
)
9835 return "DW_FORM_addr";
9836 case DW_FORM_block2
:
9837 return "DW_FORM_block2";
9838 case DW_FORM_block4
:
9839 return "DW_FORM_block4";
9841 return "DW_FORM_data2";
9843 return "DW_FORM_data4";
9845 return "DW_FORM_data8";
9846 case DW_FORM_string
:
9847 return "DW_FORM_string";
9849 return "DW_FORM_block";
9850 case DW_FORM_block1
:
9851 return "DW_FORM_block1";
9853 return "DW_FORM_data1";
9855 return "DW_FORM_flag";
9857 return "DW_FORM_sdata";
9859 return "DW_FORM_strp";
9861 return "DW_FORM_udata";
9862 case DW_FORM_ref_addr
:
9863 return "DW_FORM_ref_addr";
9865 return "DW_FORM_ref1";
9867 return "DW_FORM_ref2";
9869 return "DW_FORM_ref4";
9871 return "DW_FORM_ref8";
9872 case DW_FORM_ref_udata
:
9873 return "DW_FORM_ref_udata";
9874 case DW_FORM_indirect
:
9875 return "DW_FORM_indirect";
9876 case DW_FORM_sec_offset
:
9877 return "DW_FORM_sec_offset";
9878 case DW_FORM_exprloc
:
9879 return "DW_FORM_exprloc";
9880 case DW_FORM_flag_present
:
9881 return "DW_FORM_flag_present";
9883 return "DW_FORM_sig8";
9885 return "DW_FORM_<unknown>";
9889 /* Convert a DWARF stack opcode into its string name. */
9892 dwarf_stack_op_name (unsigned op
, int def
)
9897 return "DW_OP_addr";
9899 return "DW_OP_deref";
9901 return "DW_OP_const1u";
9903 return "DW_OP_const1s";
9905 return "DW_OP_const2u";
9907 return "DW_OP_const2s";
9909 return "DW_OP_const4u";
9911 return "DW_OP_const4s";
9913 return "DW_OP_const8u";
9915 return "DW_OP_const8s";
9917 return "DW_OP_constu";
9919 return "DW_OP_consts";
9923 return "DW_OP_drop";
9925 return "DW_OP_over";
9927 return "DW_OP_pick";
9929 return "DW_OP_swap";
9933 return "DW_OP_xderef";
9941 return "DW_OP_minus";
9953 return "DW_OP_plus";
9954 case DW_OP_plus_uconst
:
9955 return "DW_OP_plus_uconst";
9961 return "DW_OP_shra";
9979 return "DW_OP_skip";
9981 return "DW_OP_lit0";
9983 return "DW_OP_lit1";
9985 return "DW_OP_lit2";
9987 return "DW_OP_lit3";
9989 return "DW_OP_lit4";
9991 return "DW_OP_lit5";
9993 return "DW_OP_lit6";
9995 return "DW_OP_lit7";
9997 return "DW_OP_lit8";
9999 return "DW_OP_lit9";
10001 return "DW_OP_lit10";
10003 return "DW_OP_lit11";
10005 return "DW_OP_lit12";
10007 return "DW_OP_lit13";
10009 return "DW_OP_lit14";
10011 return "DW_OP_lit15";
10013 return "DW_OP_lit16";
10015 return "DW_OP_lit17";
10017 return "DW_OP_lit18";
10019 return "DW_OP_lit19";
10021 return "DW_OP_lit20";
10023 return "DW_OP_lit21";
10025 return "DW_OP_lit22";
10027 return "DW_OP_lit23";
10029 return "DW_OP_lit24";
10031 return "DW_OP_lit25";
10033 return "DW_OP_lit26";
10035 return "DW_OP_lit27";
10037 return "DW_OP_lit28";
10039 return "DW_OP_lit29";
10041 return "DW_OP_lit30";
10043 return "DW_OP_lit31";
10045 return "DW_OP_reg0";
10047 return "DW_OP_reg1";
10049 return "DW_OP_reg2";
10051 return "DW_OP_reg3";
10053 return "DW_OP_reg4";
10055 return "DW_OP_reg5";
10057 return "DW_OP_reg6";
10059 return "DW_OP_reg7";
10061 return "DW_OP_reg8";
10063 return "DW_OP_reg9";
10065 return "DW_OP_reg10";
10067 return "DW_OP_reg11";
10069 return "DW_OP_reg12";
10071 return "DW_OP_reg13";
10073 return "DW_OP_reg14";
10075 return "DW_OP_reg15";
10077 return "DW_OP_reg16";
10079 return "DW_OP_reg17";
10081 return "DW_OP_reg18";
10083 return "DW_OP_reg19";
10085 return "DW_OP_reg20";
10087 return "DW_OP_reg21";
10089 return "DW_OP_reg22";
10091 return "DW_OP_reg23";
10093 return "DW_OP_reg24";
10095 return "DW_OP_reg25";
10097 return "DW_OP_reg26";
10099 return "DW_OP_reg27";
10101 return "DW_OP_reg28";
10103 return "DW_OP_reg29";
10105 return "DW_OP_reg30";
10107 return "DW_OP_reg31";
10109 return "DW_OP_breg0";
10111 return "DW_OP_breg1";
10113 return "DW_OP_breg2";
10115 return "DW_OP_breg3";
10117 return "DW_OP_breg4";
10119 return "DW_OP_breg5";
10121 return "DW_OP_breg6";
10123 return "DW_OP_breg7";
10125 return "DW_OP_breg8";
10127 return "DW_OP_breg9";
10129 return "DW_OP_breg10";
10131 return "DW_OP_breg11";
10133 return "DW_OP_breg12";
10135 return "DW_OP_breg13";
10137 return "DW_OP_breg14";
10139 return "DW_OP_breg15";
10141 return "DW_OP_breg16";
10143 return "DW_OP_breg17";
10145 return "DW_OP_breg18";
10147 return "DW_OP_breg19";
10149 return "DW_OP_breg20";
10151 return "DW_OP_breg21";
10153 return "DW_OP_breg22";
10155 return "DW_OP_breg23";
10157 return "DW_OP_breg24";
10159 return "DW_OP_breg25";
10161 return "DW_OP_breg26";
10163 return "DW_OP_breg27";
10165 return "DW_OP_breg28";
10167 return "DW_OP_breg29";
10169 return "DW_OP_breg30";
10171 return "DW_OP_breg31";
10173 return "DW_OP_regx";
10175 return "DW_OP_fbreg";
10177 return "DW_OP_bregx";
10179 return "DW_OP_piece";
10180 case DW_OP_deref_size
:
10181 return "DW_OP_deref_size";
10182 case DW_OP_xderef_size
:
10183 return "DW_OP_xderef_size";
10185 return "DW_OP_nop";
10186 /* DWARF 3 extensions. */
10187 case DW_OP_push_object_address
:
10188 return "DW_OP_push_object_address";
10190 return "DW_OP_call2";
10192 return "DW_OP_call4";
10193 case DW_OP_call_ref
:
10194 return "DW_OP_call_ref";
10195 case DW_OP_form_tls_address
:
10196 return "DW_OP_form_tls_address";
10197 case DW_OP_call_frame_cfa
:
10198 return "DW_OP_call_frame_cfa";
10199 case DW_OP_bit_piece
:
10200 return "DW_OP_bit_piece";
10201 /* DWARF 4 extensions. */
10202 case DW_OP_implicit_value
:
10203 return "DW_OP_implicit_value";
10204 case DW_OP_stack_value
:
10205 return "DW_OP_stack_value";
10206 /* GNU extensions. */
10207 case DW_OP_GNU_push_tls_address
:
10208 return "DW_OP_GNU_push_tls_address";
10209 case DW_OP_GNU_uninit
:
10210 return "DW_OP_GNU_uninit";
10212 return def
? "OP_<unknown>" : NULL
;
10217 dwarf_bool_name (unsigned mybool
)
10225 /* Convert a DWARF type code into its string name. */
10228 dwarf_type_encoding_name (unsigned enc
)
10233 return "DW_ATE_void";
10234 case DW_ATE_address
:
10235 return "DW_ATE_address";
10236 case DW_ATE_boolean
:
10237 return "DW_ATE_boolean";
10238 case DW_ATE_complex_float
:
10239 return "DW_ATE_complex_float";
10241 return "DW_ATE_float";
10242 case DW_ATE_signed
:
10243 return "DW_ATE_signed";
10244 case DW_ATE_signed_char
:
10245 return "DW_ATE_signed_char";
10246 case DW_ATE_unsigned
:
10247 return "DW_ATE_unsigned";
10248 case DW_ATE_unsigned_char
:
10249 return "DW_ATE_unsigned_char";
10251 case DW_ATE_imaginary_float
:
10252 return "DW_ATE_imaginary_float";
10253 case DW_ATE_packed_decimal
:
10254 return "DW_ATE_packed_decimal";
10255 case DW_ATE_numeric_string
:
10256 return "DW_ATE_numeric_string";
10257 case DW_ATE_edited
:
10258 return "DW_ATE_edited";
10259 case DW_ATE_signed_fixed
:
10260 return "DW_ATE_signed_fixed";
10261 case DW_ATE_unsigned_fixed
:
10262 return "DW_ATE_unsigned_fixed";
10263 case DW_ATE_decimal_float
:
10264 return "DW_ATE_decimal_float";
10265 /* HP extensions. */
10266 case DW_ATE_HP_float80
:
10267 return "DW_ATE_HP_float80";
10268 case DW_ATE_HP_complex_float80
:
10269 return "DW_ATE_HP_complex_float80";
10270 case DW_ATE_HP_float128
:
10271 return "DW_ATE_HP_float128";
10272 case DW_ATE_HP_complex_float128
:
10273 return "DW_ATE_HP_complex_float128";
10274 case DW_ATE_HP_floathpintel
:
10275 return "DW_ATE_HP_floathpintel";
10276 case DW_ATE_HP_imaginary_float80
:
10277 return "DW_ATE_HP_imaginary_float80";
10278 case DW_ATE_HP_imaginary_float128
:
10279 return "DW_ATE_HP_imaginary_float128";
10281 return "DW_ATE_<unknown>";
10285 /* Convert a DWARF call frame info operation to its string name. */
10289 dwarf_cfi_name (unsigned cfi_opc
)
10293 case DW_CFA_advance_loc
:
10294 return "DW_CFA_advance_loc";
10295 case DW_CFA_offset
:
10296 return "DW_CFA_offset";
10297 case DW_CFA_restore
:
10298 return "DW_CFA_restore";
10300 return "DW_CFA_nop";
10301 case DW_CFA_set_loc
:
10302 return "DW_CFA_set_loc";
10303 case DW_CFA_advance_loc1
:
10304 return "DW_CFA_advance_loc1";
10305 case DW_CFA_advance_loc2
:
10306 return "DW_CFA_advance_loc2";
10307 case DW_CFA_advance_loc4
:
10308 return "DW_CFA_advance_loc4";
10309 case DW_CFA_offset_extended
:
10310 return "DW_CFA_offset_extended";
10311 case DW_CFA_restore_extended
:
10312 return "DW_CFA_restore_extended";
10313 case DW_CFA_undefined
:
10314 return "DW_CFA_undefined";
10315 case DW_CFA_same_value
:
10316 return "DW_CFA_same_value";
10317 case DW_CFA_register
:
10318 return "DW_CFA_register";
10319 case DW_CFA_remember_state
:
10320 return "DW_CFA_remember_state";
10321 case DW_CFA_restore_state
:
10322 return "DW_CFA_restore_state";
10323 case DW_CFA_def_cfa
:
10324 return "DW_CFA_def_cfa";
10325 case DW_CFA_def_cfa_register
:
10326 return "DW_CFA_def_cfa_register";
10327 case DW_CFA_def_cfa_offset
:
10328 return "DW_CFA_def_cfa_offset";
10330 case DW_CFA_def_cfa_expression
:
10331 return "DW_CFA_def_cfa_expression";
10332 case DW_CFA_expression
:
10333 return "DW_CFA_expression";
10334 case DW_CFA_offset_extended_sf
:
10335 return "DW_CFA_offset_extended_sf";
10336 case DW_CFA_def_cfa_sf
:
10337 return "DW_CFA_def_cfa_sf";
10338 case DW_CFA_def_cfa_offset_sf
:
10339 return "DW_CFA_def_cfa_offset_sf";
10340 case DW_CFA_val_offset
:
10341 return "DW_CFA_val_offset";
10342 case DW_CFA_val_offset_sf
:
10343 return "DW_CFA_val_offset_sf";
10344 case DW_CFA_val_expression
:
10345 return "DW_CFA_val_expression";
10346 /* SGI/MIPS specific. */
10347 case DW_CFA_MIPS_advance_loc8
:
10348 return "DW_CFA_MIPS_advance_loc8";
10349 /* GNU extensions. */
10350 case DW_CFA_GNU_window_save
:
10351 return "DW_CFA_GNU_window_save";
10352 case DW_CFA_GNU_args_size
:
10353 return "DW_CFA_GNU_args_size";
10354 case DW_CFA_GNU_negative_offset_extended
:
10355 return "DW_CFA_GNU_negative_offset_extended";
10357 return "DW_CFA_<unknown>";
10363 dump_die_shallow (struct ui_file
*f
, int indent
, struct die_info
*die
)
10367 print_spaces (indent
, f
);
10368 fprintf_unfiltered (f
, "Die: %s (abbrev %d, offset 0x%x)\n",
10369 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
10371 if (die
->parent
!= NULL
)
10373 print_spaces (indent
, f
);
10374 fprintf_unfiltered (f
, " parent at offset: 0x%x\n",
10375 die
->parent
->offset
);
10378 print_spaces (indent
, f
);
10379 fprintf_unfiltered (f
, " has children: %s\n",
10380 dwarf_bool_name (die
->child
!= NULL
));
10382 print_spaces (indent
, f
);
10383 fprintf_unfiltered (f
, " attributes:\n");
10385 for (i
= 0; i
< die
->num_attrs
; ++i
)
10387 print_spaces (indent
, f
);
10388 fprintf_unfiltered (f
, " %s (%s) ",
10389 dwarf_attr_name (die
->attrs
[i
].name
),
10390 dwarf_form_name (die
->attrs
[i
].form
));
10392 switch (die
->attrs
[i
].form
)
10394 case DW_FORM_ref_addr
:
10396 fprintf_unfiltered (f
, "address: ");
10397 fputs_filtered (hex_string (DW_ADDR (&die
->attrs
[i
])), f
);
10399 case DW_FORM_block2
:
10400 case DW_FORM_block4
:
10401 case DW_FORM_block
:
10402 case DW_FORM_block1
:
10403 fprintf_unfiltered (f
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
10405 case DW_FORM_exprloc
:
10406 fprintf_unfiltered (f
, "expression: size %u",
10407 DW_BLOCK (&die
->attrs
[i
])->size
);
10412 fprintf_unfiltered (f
, "constant ref: 0x%lx (adjusted)",
10413 (long) (DW_ADDR (&die
->attrs
[i
])));
10415 case DW_FORM_data1
:
10416 case DW_FORM_data2
:
10417 case DW_FORM_data4
:
10418 case DW_FORM_data8
:
10419 case DW_FORM_udata
:
10420 case DW_FORM_sdata
:
10421 fprintf_unfiltered (f
, "constant: %s",
10422 pulongest (DW_UNSND (&die
->attrs
[i
])));
10424 case DW_FORM_sec_offset
:
10425 fprintf_unfiltered (f
, "section offset: %s",
10426 pulongest (DW_UNSND (&die
->attrs
[i
])));
10429 if (DW_SIGNATURED_TYPE (&die
->attrs
[i
]) != NULL
)
10430 fprintf_unfiltered (f
, "signatured type, offset: 0x%x",
10431 DW_SIGNATURED_TYPE (&die
->attrs
[i
])->offset
);
10433 fprintf_unfiltered (f
, "signatured type, offset: unknown");
10435 case DW_FORM_string
:
10437 fprintf_unfiltered (f
, "string: \"%s\" (%s canonicalized)",
10438 DW_STRING (&die
->attrs
[i
])
10439 ? DW_STRING (&die
->attrs
[i
]) : "",
10440 DW_STRING_IS_CANONICAL (&die
->attrs
[i
]) ? "is" : "not");
10443 if (DW_UNSND (&die
->attrs
[i
]))
10444 fprintf_unfiltered (f
, "flag: TRUE");
10446 fprintf_unfiltered (f
, "flag: FALSE");
10448 case DW_FORM_flag_present
:
10449 fprintf_unfiltered (f
, "flag: TRUE");
10451 case DW_FORM_indirect
:
10452 /* the reader will have reduced the indirect form to
10453 the "base form" so this form should not occur */
10454 fprintf_unfiltered (f
, "unexpected attribute form: DW_FORM_indirect");
10457 fprintf_unfiltered (f
, "unsupported attribute form: %d.",
10458 die
->attrs
[i
].form
);
10461 fprintf_unfiltered (f
, "\n");
10466 dump_die_for_error (struct die_info
*die
)
10468 dump_die_shallow (gdb_stderr
, 0, die
);
10472 dump_die_1 (struct ui_file
*f
, int level
, int max_level
, struct die_info
*die
)
10474 int indent
= level
* 4;
10476 gdb_assert (die
!= NULL
);
10478 if (level
>= max_level
)
10481 dump_die_shallow (f
, indent
, die
);
10483 if (die
->child
!= NULL
)
10485 print_spaces (indent
, f
);
10486 fprintf_unfiltered (f
, " Children:");
10487 if (level
+ 1 < max_level
)
10489 fprintf_unfiltered (f
, "\n");
10490 dump_die_1 (f
, level
+ 1, max_level
, die
->child
);
10494 fprintf_unfiltered (f
, " [not printed, max nesting level reached]\n");
10498 if (die
->sibling
!= NULL
&& level
> 0)
10500 dump_die_1 (f
, level
, max_level
, die
->sibling
);
10504 /* This is called from the pdie macro in gdbinit.in.
10505 It's not static so gcc will keep a copy callable from gdb. */
10508 dump_die (struct die_info
*die
, int max_level
)
10510 dump_die_1 (gdb_stdlog
, 0, max_level
, die
);
10514 store_in_ref_table (struct die_info
*die
, struct dwarf2_cu
*cu
)
10518 slot
= htab_find_slot_with_hash (cu
->die_hash
, die
, die
->offset
, INSERT
);
10524 is_ref_attr (struct attribute
*attr
)
10526 switch (attr
->form
)
10528 case DW_FORM_ref_addr
:
10533 case DW_FORM_ref_udata
:
10540 static unsigned int
10541 dwarf2_get_ref_die_offset (struct attribute
*attr
)
10543 if (is_ref_attr (attr
))
10544 return DW_ADDR (attr
);
10546 complaint (&symfile_complaints
,
10547 _("unsupported die ref attribute form: '%s'"),
10548 dwarf_form_name (attr
->form
));
10552 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
10553 * the value held by the attribute is not constant. */
10556 dwarf2_get_attr_constant_value (struct attribute
*attr
, int default_value
)
10558 if (attr
->form
== DW_FORM_sdata
)
10559 return DW_SND (attr
);
10560 else if (attr
->form
== DW_FORM_udata
10561 || attr
->form
== DW_FORM_data1
10562 || attr
->form
== DW_FORM_data2
10563 || attr
->form
== DW_FORM_data4
10564 || attr
->form
== DW_FORM_data8
)
10565 return DW_UNSND (attr
);
10568 complaint (&symfile_complaints
, _("Attribute value is not a constant (%s)"),
10569 dwarf_form_name (attr
->form
));
10570 return default_value
;
10574 /* THIS_CU has a reference to PER_CU. If necessary, load the new compilation
10575 unit and add it to our queue.
10576 The result is non-zero if PER_CU was queued, otherwise the result is zero
10577 meaning either PER_CU is already queued or it is already loaded. */
10580 maybe_queue_comp_unit (struct dwarf2_cu
*this_cu
,
10581 struct dwarf2_per_cu_data
*per_cu
)
10583 /* Mark the dependence relation so that we don't flush PER_CU
10585 dwarf2_add_dependence (this_cu
, per_cu
);
10587 /* If it's already on the queue, we have nothing to do. */
10588 if (per_cu
->queued
)
10591 /* If the compilation unit is already loaded, just mark it as
10593 if (per_cu
->cu
!= NULL
)
10595 per_cu
->cu
->last_used
= 0;
10599 /* Add it to the queue. */
10600 queue_comp_unit (per_cu
, this_cu
->objfile
);
10605 /* Follow reference or signature attribute ATTR of SRC_DIE.
10606 On entry *REF_CU is the CU of SRC_DIE.
10607 On exit *REF_CU is the CU of the result. */
10609 static struct die_info
*
10610 follow_die_ref_or_sig (struct die_info
*src_die
, struct attribute
*attr
,
10611 struct dwarf2_cu
**ref_cu
)
10613 struct die_info
*die
;
10615 if (is_ref_attr (attr
))
10616 die
= follow_die_ref (src_die
, attr
, ref_cu
);
10617 else if (attr
->form
== DW_FORM_sig8
)
10618 die
= follow_die_sig (src_die
, attr
, ref_cu
);
10621 dump_die_for_error (src_die
);
10622 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
10623 (*ref_cu
)->objfile
->name
);
10629 /* Follow reference attribute ATTR of SRC_DIE.
10630 On entry *REF_CU is the CU of SRC_DIE.
10631 On exit *REF_CU is the CU of the result. */
10633 static struct die_info
*
10634 follow_die_ref (struct die_info
*src_die
, struct attribute
*attr
,
10635 struct dwarf2_cu
**ref_cu
)
10637 struct die_info
*die
;
10638 unsigned int offset
;
10639 struct die_info temp_die
;
10640 struct dwarf2_cu
*target_cu
, *cu
= *ref_cu
;
10642 gdb_assert (cu
->per_cu
!= NULL
);
10644 offset
= dwarf2_get_ref_die_offset (attr
);
10646 if (cu
->per_cu
->from_debug_types
)
10648 /* .debug_types CUs cannot reference anything outside their CU.
10649 If they need to, they have to reference a signatured type via
10651 if (! offset_in_cu_p (&cu
->header
, offset
))
10655 else if (! offset_in_cu_p (&cu
->header
, offset
))
10657 struct dwarf2_per_cu_data
*per_cu
;
10659 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
10661 /* If necessary, add it to the queue and load its DIEs. */
10662 if (maybe_queue_comp_unit (cu
, per_cu
))
10663 load_full_comp_unit (per_cu
, cu
->objfile
);
10665 target_cu
= per_cu
->cu
;
10670 *ref_cu
= target_cu
;
10671 temp_die
.offset
= offset
;
10672 die
= htab_find_with_hash (target_cu
->die_hash
, &temp_die
, offset
);
10678 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced from DIE "
10679 "at 0x%x [in module %s]"),
10680 offset
, src_die
->offset
, cu
->objfile
->name
);
10683 /* Follow the signature attribute ATTR in SRC_DIE.
10684 On entry *REF_CU is the CU of SRC_DIE.
10685 On exit *REF_CU is the CU of the result. */
10687 static struct die_info
*
10688 follow_die_sig (struct die_info
*src_die
, struct attribute
*attr
,
10689 struct dwarf2_cu
**ref_cu
)
10691 struct objfile
*objfile
= (*ref_cu
)->objfile
;
10692 struct die_info temp_die
;
10693 struct signatured_type
*sig_type
= DW_SIGNATURED_TYPE (attr
);
10694 struct dwarf2_cu
*sig_cu
;
10695 struct die_info
*die
;
10697 /* sig_type will be NULL if the signatured type is missing from
10699 if (sig_type
== NULL
)
10700 error (_("Dwarf Error: Cannot find signatured DIE referenced from DIE "
10701 "at 0x%x [in module %s]"),
10702 src_die
->offset
, objfile
->name
);
10704 /* If necessary, add it to the queue and load its DIEs. */
10706 if (maybe_queue_comp_unit (*ref_cu
, &sig_type
->per_cu
))
10707 read_signatured_type (objfile
, sig_type
);
10709 gdb_assert (sig_type
->per_cu
.cu
!= NULL
);
10711 sig_cu
= sig_type
->per_cu
.cu
;
10712 temp_die
.offset
= sig_cu
->header
.offset
+ sig_type
->type_offset
;
10713 die
= htab_find_with_hash (sig_cu
->die_hash
, &temp_die
, temp_die
.offset
);
10720 error (_("Dwarf Error: Cannot find signatured DIE at 0x%x referenced from DIE "
10721 "at 0x%x [in module %s]"),
10722 sig_type
->type_offset
, src_die
->offset
, objfile
->name
);
10725 /* Given an offset of a signatured type, return its signatured_type. */
10727 static struct signatured_type
*
10728 lookup_signatured_type_at_offset (struct objfile
*objfile
, unsigned int offset
)
10730 gdb_byte
*info_ptr
= dwarf2_per_objfile
->types
.buffer
+ offset
;
10731 unsigned int length
, initial_length_size
;
10732 unsigned int sig_offset
;
10733 struct signatured_type find_entry
, *type_sig
;
10735 length
= read_initial_length (objfile
->obfd
, info_ptr
, &initial_length_size
);
10736 sig_offset
= (initial_length_size
10738 + (initial_length_size
== 4 ? 4 : 8) /*debug_abbrev_offset*/
10739 + 1 /*address_size*/);
10740 find_entry
.signature
= bfd_get_64 (objfile
->obfd
, info_ptr
+ sig_offset
);
10741 type_sig
= htab_find (dwarf2_per_objfile
->signatured_types
, &find_entry
);
10743 /* This is only used to lookup previously recorded types.
10744 If we didn't find it, it's our bug. */
10745 gdb_assert (type_sig
!= NULL
);
10746 gdb_assert (offset
== type_sig
->offset
);
10751 /* Read in signatured type at OFFSET and build its CU and die(s). */
10754 read_signatured_type_at_offset (struct objfile
*objfile
,
10755 unsigned int offset
)
10757 struct signatured_type
*type_sig
;
10759 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->types
);
10761 /* We have the section offset, but we need the signature to do the
10762 hash table lookup. */
10763 type_sig
= lookup_signatured_type_at_offset (objfile
, offset
);
10765 gdb_assert (type_sig
->per_cu
.cu
== NULL
);
10767 read_signatured_type (objfile
, type_sig
);
10769 gdb_assert (type_sig
->per_cu
.cu
!= NULL
);
10772 /* Read in a signatured type and build its CU and DIEs. */
10775 read_signatured_type (struct objfile
*objfile
,
10776 struct signatured_type
*type_sig
)
10778 gdb_byte
*types_ptr
= dwarf2_per_objfile
->types
.buffer
+ type_sig
->offset
;
10779 struct die_reader_specs reader_specs
;
10780 struct dwarf2_cu
*cu
;
10781 ULONGEST signature
;
10782 struct cleanup
*back_to
, *free_cu_cleanup
;
10783 struct attribute
*attr
;
10785 gdb_assert (type_sig
->per_cu
.cu
== NULL
);
10787 cu
= xmalloc (sizeof (struct dwarf2_cu
));
10788 memset (cu
, 0, sizeof (struct dwarf2_cu
));
10789 obstack_init (&cu
->comp_unit_obstack
);
10790 cu
->objfile
= objfile
;
10791 type_sig
->per_cu
.cu
= cu
;
10792 cu
->per_cu
= &type_sig
->per_cu
;
10794 /* If an error occurs while loading, release our storage. */
10795 free_cu_cleanup
= make_cleanup (free_one_comp_unit
, cu
);
10797 types_ptr
= read_type_comp_unit_head (&cu
->header
, &signature
,
10798 types_ptr
, objfile
->obfd
);
10799 gdb_assert (signature
== type_sig
->signature
);
10802 = htab_create_alloc_ex (cu
->header
.length
/ 12,
10806 &cu
->comp_unit_obstack
,
10807 hashtab_obstack_allocate
,
10808 dummy_obstack_deallocate
);
10810 dwarf2_read_abbrevs (cu
->objfile
->obfd
, cu
);
10811 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
10813 init_cu_die_reader (&reader_specs
, cu
);
10815 cu
->dies
= read_die_and_children (&reader_specs
, types_ptr
, &types_ptr
,
10818 /* We try not to read any attributes in this function, because not
10819 all objfiles needed for references have been loaded yet, and symbol
10820 table processing isn't initialized. But we have to set the CU language,
10821 or we won't be able to build types correctly. */
10822 attr
= dwarf2_attr (cu
->dies
, DW_AT_language
, cu
);
10824 set_cu_language (DW_UNSND (attr
), cu
);
10826 set_cu_language (language_minimal
, cu
);
10828 do_cleanups (back_to
);
10830 /* We've successfully allocated this compilation unit. Let our caller
10831 clean it up when finished with it. */
10832 discard_cleanups (free_cu_cleanup
);
10834 type_sig
->per_cu
.cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
10835 dwarf2_per_objfile
->read_in_chain
= &type_sig
->per_cu
;
10838 /* Decode simple location descriptions.
10839 Given a pointer to a dwarf block that defines a location, compute
10840 the location and return the value.
10842 NOTE drow/2003-11-18: This function is called in two situations
10843 now: for the address of static or global variables (partial symbols
10844 only) and for offsets into structures which are expected to be
10845 (more or less) constant. The partial symbol case should go away,
10846 and only the constant case should remain. That will let this
10847 function complain more accurately. A few special modes are allowed
10848 without complaint for global variables (for instance, global
10849 register values and thread-local values).
10851 A location description containing no operations indicates that the
10852 object is optimized out. The return value is 0 for that case.
10853 FIXME drow/2003-11-16: No callers check for this case any more; soon all
10854 callers will only want a very basic result and this can become a
10857 Note that stack[0] is unused except as a default error return.
10858 Note that stack overflow is not yet handled. */
10861 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
10863 struct objfile
*objfile
= cu
->objfile
;
10865 int size
= blk
->size
;
10866 gdb_byte
*data
= blk
->data
;
10867 CORE_ADDR stack
[64];
10869 unsigned int bytes_read
, unsnd
;
10913 stack
[++stacki
] = op
- DW_OP_lit0
;
10948 stack
[++stacki
] = op
- DW_OP_reg0
;
10950 dwarf2_complex_location_expr_complaint ();
10954 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
10956 stack
[++stacki
] = unsnd
;
10958 dwarf2_complex_location_expr_complaint ();
10962 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
10967 case DW_OP_const1u
:
10968 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
10972 case DW_OP_const1s
:
10973 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
10977 case DW_OP_const2u
:
10978 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
10982 case DW_OP_const2s
:
10983 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
10987 case DW_OP_const4u
:
10988 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
10992 case DW_OP_const4s
:
10993 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
10998 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
11004 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
11009 stack
[stacki
+ 1] = stack
[stacki
];
11014 stack
[stacki
- 1] += stack
[stacki
];
11018 case DW_OP_plus_uconst
:
11019 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
11024 stack
[stacki
- 1] -= stack
[stacki
];
11029 /* If we're not the last op, then we definitely can't encode
11030 this using GDB's address_class enum. This is valid for partial
11031 global symbols, although the variable's address will be bogus
11034 dwarf2_complex_location_expr_complaint ();
11037 case DW_OP_GNU_push_tls_address
:
11038 /* The top of the stack has the offset from the beginning
11039 of the thread control block at which the variable is located. */
11040 /* Nothing should follow this operator, so the top of stack would
11042 /* This is valid for partial global symbols, but the variable's
11043 address will be bogus in the psymtab. */
11045 dwarf2_complex_location_expr_complaint ();
11048 case DW_OP_GNU_uninit
:
11052 complaint (&symfile_complaints
, _("unsupported stack op: '%s'"),
11053 dwarf_stack_op_name (op
, 1));
11054 return (stack
[stacki
]);
11057 return (stack
[stacki
]);
11060 /* memory allocation interface */
11062 static struct dwarf_block
*
11063 dwarf_alloc_block (struct dwarf2_cu
*cu
)
11065 struct dwarf_block
*blk
;
11067 blk
= (struct dwarf_block
*)
11068 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
11072 static struct abbrev_info
*
11073 dwarf_alloc_abbrev (struct dwarf2_cu
*cu
)
11075 struct abbrev_info
*abbrev
;
11077 abbrev
= (struct abbrev_info
*)
11078 obstack_alloc (&cu
->abbrev_obstack
, sizeof (struct abbrev_info
));
11079 memset (abbrev
, 0, sizeof (struct abbrev_info
));
11083 static struct die_info
*
11084 dwarf_alloc_die (struct dwarf2_cu
*cu
, int num_attrs
)
11086 struct die_info
*die
;
11087 size_t size
= sizeof (struct die_info
);
11090 size
+= (num_attrs
- 1) * sizeof (struct attribute
);
11092 die
= (struct die_info
*) obstack_alloc (&cu
->comp_unit_obstack
, size
);
11093 memset (die
, 0, sizeof (struct die_info
));
11098 /* Macro support. */
11101 /* Return the full name of file number I in *LH's file name table.
11102 Use COMP_DIR as the name of the current directory of the
11103 compilation. The result is allocated using xmalloc; the caller is
11104 responsible for freeing it. */
11106 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
11108 /* Is the file number a valid index into the line header's file name
11109 table? Remember that file numbers start with one, not zero. */
11110 if (1 <= file
&& file
<= lh
->num_file_names
)
11112 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
11114 if (IS_ABSOLUTE_PATH (fe
->name
))
11115 return xstrdup (fe
->name
);
11123 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
11129 dir_len
= strlen (dir
);
11130 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
11131 strcpy (full_name
, dir
);
11132 full_name
[dir_len
] = '/';
11133 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
11137 return xstrdup (fe
->name
);
11142 /* The compiler produced a bogus file number. We can at least
11143 record the macro definitions made in the file, even if we
11144 won't be able to find the file by name. */
11145 char fake_name
[80];
11147 sprintf (fake_name
, "<bad macro file number %d>", file
);
11149 complaint (&symfile_complaints
,
11150 _("bad file number in macro information (%d)"),
11153 return xstrdup (fake_name
);
11158 static struct macro_source_file
*
11159 macro_start_file (int file
, int line
,
11160 struct macro_source_file
*current_file
,
11161 const char *comp_dir
,
11162 struct line_header
*lh
, struct objfile
*objfile
)
11164 /* The full name of this source file. */
11165 char *full_name
= file_full_name (file
, lh
, comp_dir
);
11167 /* We don't create a macro table for this compilation unit
11168 at all until we actually get a filename. */
11169 if (! pending_macros
)
11170 pending_macros
= new_macro_table (&objfile
->objfile_obstack
,
11171 objfile
->macro_cache
);
11173 if (! current_file
)
11174 /* If we have no current file, then this must be the start_file
11175 directive for the compilation unit's main source file. */
11176 current_file
= macro_set_main (pending_macros
, full_name
);
11178 current_file
= macro_include (current_file
, line
, full_name
);
11182 return current_file
;
11186 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
11187 followed by a null byte. */
11189 copy_string (const char *buf
, int len
)
11191 char *s
= xmalloc (len
+ 1);
11193 memcpy (s
, buf
, len
);
11199 static const char *
11200 consume_improper_spaces (const char *p
, const char *body
)
11204 complaint (&symfile_complaints
,
11205 _("macro definition contains spaces in formal argument list:\n`%s'"),
11217 parse_macro_definition (struct macro_source_file
*file
, int line
,
11222 /* The body string takes one of two forms. For object-like macro
11223 definitions, it should be:
11225 <macro name> " " <definition>
11227 For function-like macro definitions, it should be:
11229 <macro name> "() " <definition>
11231 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
11233 Spaces may appear only where explicitly indicated, and in the
11236 The Dwarf 2 spec says that an object-like macro's name is always
11237 followed by a space, but versions of GCC around March 2002 omit
11238 the space when the macro's definition is the empty string.
11240 The Dwarf 2 spec says that there should be no spaces between the
11241 formal arguments in a function-like macro's formal argument list,
11242 but versions of GCC around March 2002 include spaces after the
11246 /* Find the extent of the macro name. The macro name is terminated
11247 by either a space or null character (for an object-like macro) or
11248 an opening paren (for a function-like macro). */
11249 for (p
= body
; *p
; p
++)
11250 if (*p
== ' ' || *p
== '(')
11253 if (*p
== ' ' || *p
== '\0')
11255 /* It's an object-like macro. */
11256 int name_len
= p
- body
;
11257 char *name
= copy_string (body
, name_len
);
11258 const char *replacement
;
11261 replacement
= body
+ name_len
+ 1;
11264 dwarf2_macro_malformed_definition_complaint (body
);
11265 replacement
= body
+ name_len
;
11268 macro_define_object (file
, line
, name
, replacement
);
11272 else if (*p
== '(')
11274 /* It's a function-like macro. */
11275 char *name
= copy_string (body
, p
- body
);
11278 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
11282 p
= consume_improper_spaces (p
, body
);
11284 /* Parse the formal argument list. */
11285 while (*p
&& *p
!= ')')
11287 /* Find the extent of the current argument name. */
11288 const char *arg_start
= p
;
11290 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
11293 if (! *p
|| p
== arg_start
)
11294 dwarf2_macro_malformed_definition_complaint (body
);
11297 /* Make sure argv has room for the new argument. */
11298 if (argc
>= argv_size
)
11301 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
11304 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
11307 p
= consume_improper_spaces (p
, body
);
11309 /* Consume the comma, if present. */
11314 p
= consume_improper_spaces (p
, body
);
11323 /* Perfectly formed definition, no complaints. */
11324 macro_define_function (file
, line
, name
,
11325 argc
, (const char **) argv
,
11327 else if (*p
== '\0')
11329 /* Complain, but do define it. */
11330 dwarf2_macro_malformed_definition_complaint (body
);
11331 macro_define_function (file
, line
, name
,
11332 argc
, (const char **) argv
,
11336 /* Just complain. */
11337 dwarf2_macro_malformed_definition_complaint (body
);
11340 /* Just complain. */
11341 dwarf2_macro_malformed_definition_complaint (body
);
11347 for (i
= 0; i
< argc
; i
++)
11353 dwarf2_macro_malformed_definition_complaint (body
);
11358 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
11359 char *comp_dir
, bfd
*abfd
,
11360 struct dwarf2_cu
*cu
)
11362 gdb_byte
*mac_ptr
, *mac_end
;
11363 struct macro_source_file
*current_file
= 0;
11364 enum dwarf_macinfo_record_type macinfo_type
;
11365 int at_commandline
;
11367 dwarf2_read_section (dwarf2_per_objfile
->objfile
,
11368 &dwarf2_per_objfile
->macinfo
);
11369 if (dwarf2_per_objfile
->macinfo
.buffer
== NULL
)
11371 complaint (&symfile_complaints
, _("missing .debug_macinfo section"));
11375 /* First pass: Find the name of the base filename.
11376 This filename is needed in order to process all macros whose definition
11377 (or undefinition) comes from the command line. These macros are defined
11378 before the first DW_MACINFO_start_file entry, and yet still need to be
11379 associated to the base file.
11381 To determine the base file name, we scan the macro definitions until we
11382 reach the first DW_MACINFO_start_file entry. We then initialize
11383 CURRENT_FILE accordingly so that any macro definition found before the
11384 first DW_MACINFO_start_file can still be associated to the base file. */
11386 mac_ptr
= dwarf2_per_objfile
->macinfo
.buffer
+ offset
;
11387 mac_end
= dwarf2_per_objfile
->macinfo
.buffer
11388 + dwarf2_per_objfile
->macinfo
.size
;
11392 /* Do we at least have room for a macinfo type byte? */
11393 if (mac_ptr
>= mac_end
)
11395 /* Complaint is printed during the second pass as GDB will probably
11396 stop the first pass earlier upon finding DW_MACINFO_start_file. */
11400 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
11403 switch (macinfo_type
)
11405 /* A zero macinfo type indicates the end of the macro
11410 case DW_MACINFO_define
:
11411 case DW_MACINFO_undef
:
11412 /* Only skip the data by MAC_PTR. */
11414 unsigned int bytes_read
;
11416 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
11417 mac_ptr
+= bytes_read
;
11418 read_string (abfd
, mac_ptr
, &bytes_read
);
11419 mac_ptr
+= bytes_read
;
11423 case DW_MACINFO_start_file
:
11425 unsigned int bytes_read
;
11428 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
11429 mac_ptr
+= bytes_read
;
11430 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
11431 mac_ptr
+= bytes_read
;
11433 current_file
= macro_start_file (file
, line
, current_file
, comp_dir
,
11438 case DW_MACINFO_end_file
:
11439 /* No data to skip by MAC_PTR. */
11442 case DW_MACINFO_vendor_ext
:
11443 /* Only skip the data by MAC_PTR. */
11445 unsigned int bytes_read
;
11447 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
11448 mac_ptr
+= bytes_read
;
11449 read_string (abfd
, mac_ptr
, &bytes_read
);
11450 mac_ptr
+= bytes_read
;
11457 } while (macinfo_type
!= 0 && current_file
== NULL
);
11459 /* Second pass: Process all entries.
11461 Use the AT_COMMAND_LINE flag to determine whether we are still processing
11462 command-line macro definitions/undefinitions. This flag is unset when we
11463 reach the first DW_MACINFO_start_file entry. */
11465 mac_ptr
= dwarf2_per_objfile
->macinfo
.buffer
+ offset
;
11467 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
11468 GDB is still reading the definitions from command line. First
11469 DW_MACINFO_start_file will need to be ignored as it was already executed
11470 to create CURRENT_FILE for the main source holding also the command line
11471 definitions. On first met DW_MACINFO_start_file this flag is reset to
11472 normally execute all the remaining DW_MACINFO_start_file macinfos. */
11474 at_commandline
= 1;
11478 /* Do we at least have room for a macinfo type byte? */
11479 if (mac_ptr
>= mac_end
)
11481 dwarf2_macros_too_long_complaint ();
11485 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
11488 switch (macinfo_type
)
11490 /* A zero macinfo type indicates the end of the macro
11495 case DW_MACINFO_define
:
11496 case DW_MACINFO_undef
:
11498 unsigned int bytes_read
;
11502 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
11503 mac_ptr
+= bytes_read
;
11504 body
= read_string (abfd
, mac_ptr
, &bytes_read
);
11505 mac_ptr
+= bytes_read
;
11507 if (! current_file
)
11509 /* DWARF violation as no main source is present. */
11510 complaint (&symfile_complaints
,
11511 _("debug info with no main source gives macro %s "
11513 macinfo_type
== DW_MACINFO_define
?
11515 macinfo_type
== DW_MACINFO_undef
?
11516 _("undefinition") :
11517 _("something-or-other"), line
, body
);
11520 if ((line
== 0 && !at_commandline
) || (line
!= 0 && at_commandline
))
11521 complaint (&symfile_complaints
,
11522 _("debug info gives %s macro %s with %s line %d: %s"),
11523 at_commandline
? _("command-line") : _("in-file"),
11524 macinfo_type
== DW_MACINFO_define
?
11526 macinfo_type
== DW_MACINFO_undef
?
11527 _("undefinition") :
11528 _("something-or-other"),
11529 line
== 0 ? _("zero") : _("non-zero"), line
, body
);
11531 if (macinfo_type
== DW_MACINFO_define
)
11532 parse_macro_definition (current_file
, line
, body
);
11533 else if (macinfo_type
== DW_MACINFO_undef
)
11534 macro_undef (current_file
, line
, body
);
11538 case DW_MACINFO_start_file
:
11540 unsigned int bytes_read
;
11543 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
11544 mac_ptr
+= bytes_read
;
11545 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
11546 mac_ptr
+= bytes_read
;
11548 if ((line
== 0 && !at_commandline
) || (line
!= 0 && at_commandline
))
11549 complaint (&symfile_complaints
,
11550 _("debug info gives source %d included "
11551 "from %s at %s line %d"),
11552 file
, at_commandline
? _("command-line") : _("file"),
11553 line
== 0 ? _("zero") : _("non-zero"), line
);
11555 if (at_commandline
)
11557 /* This DW_MACINFO_start_file was executed in the pass one. */
11558 at_commandline
= 0;
11561 current_file
= macro_start_file (file
, line
,
11562 current_file
, comp_dir
,
11567 case DW_MACINFO_end_file
:
11568 if (! current_file
)
11569 complaint (&symfile_complaints
,
11570 _("macro debug info has an unmatched `close_file' directive"));
11573 current_file
= current_file
->included_by
;
11574 if (! current_file
)
11576 enum dwarf_macinfo_record_type next_type
;
11578 /* GCC circa March 2002 doesn't produce the zero
11579 type byte marking the end of the compilation
11580 unit. Complain if it's not there, but exit no
11583 /* Do we at least have room for a macinfo type byte? */
11584 if (mac_ptr
>= mac_end
)
11586 dwarf2_macros_too_long_complaint ();
11590 /* We don't increment mac_ptr here, so this is just
11592 next_type
= read_1_byte (abfd
, mac_ptr
);
11593 if (next_type
!= 0)
11594 complaint (&symfile_complaints
,
11595 _("no terminating 0-type entry for macros in `.debug_macinfo' section"));
11602 case DW_MACINFO_vendor_ext
:
11604 unsigned int bytes_read
;
11608 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
11609 mac_ptr
+= bytes_read
;
11610 string
= read_string (abfd
, mac_ptr
, &bytes_read
);
11611 mac_ptr
+= bytes_read
;
11613 /* We don't recognize any vendor extensions. */
11617 } while (macinfo_type
!= 0);
11620 /* Check if the attribute's form is a DW_FORM_block*
11621 if so return true else false. */
11623 attr_form_is_block (struct attribute
*attr
)
11625 return (attr
== NULL
? 0 :
11626 attr
->form
== DW_FORM_block1
11627 || attr
->form
== DW_FORM_block2
11628 || attr
->form
== DW_FORM_block4
11629 || attr
->form
== DW_FORM_block
11630 || attr
->form
== DW_FORM_exprloc
);
11633 /* Return non-zero if ATTR's value is a section offset --- classes
11634 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
11635 You may use DW_UNSND (attr) to retrieve such offsets.
11637 Section 7.5.4, "Attribute Encodings", explains that no attribute
11638 may have a value that belongs to more than one of these classes; it
11639 would be ambiguous if we did, because we use the same forms for all
11642 attr_form_is_section_offset (struct attribute
*attr
)
11644 return (attr
->form
== DW_FORM_data4
11645 || attr
->form
== DW_FORM_data8
11646 || attr
->form
== DW_FORM_sec_offset
);
11650 /* Return non-zero if ATTR's value falls in the 'constant' class, or
11651 zero otherwise. When this function returns true, you can apply
11652 dwarf2_get_attr_constant_value to it.
11654 However, note that for some attributes you must check
11655 attr_form_is_section_offset before using this test. DW_FORM_data4
11656 and DW_FORM_data8 are members of both the constant class, and of
11657 the classes that contain offsets into other debug sections
11658 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
11659 that, if an attribute's can be either a constant or one of the
11660 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
11661 taken as section offsets, not constants. */
11663 attr_form_is_constant (struct attribute
*attr
)
11665 switch (attr
->form
)
11667 case DW_FORM_sdata
:
11668 case DW_FORM_udata
:
11669 case DW_FORM_data1
:
11670 case DW_FORM_data2
:
11671 case DW_FORM_data4
:
11672 case DW_FORM_data8
:
11680 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
11681 struct dwarf2_cu
*cu
)
11683 if (attr_form_is_section_offset (attr
)
11684 /* ".debug_loc" may not exist at all, or the offset may be outside
11685 the section. If so, fall through to the complaint in the
11687 && DW_UNSND (attr
) < dwarf2_per_objfile
->loc
.size
)
11689 struct dwarf2_loclist_baton
*baton
;
11691 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
11692 sizeof (struct dwarf2_loclist_baton
));
11693 baton
->per_cu
= cu
->per_cu
;
11694 gdb_assert (baton
->per_cu
);
11696 dwarf2_read_section (dwarf2_per_objfile
->objfile
,
11697 &dwarf2_per_objfile
->loc
);
11699 /* We don't know how long the location list is, but make sure we
11700 don't run off the edge of the section. */
11701 baton
->size
= dwarf2_per_objfile
->loc
.size
- DW_UNSND (attr
);
11702 baton
->data
= dwarf2_per_objfile
->loc
.buffer
+ DW_UNSND (attr
);
11703 baton
->base_address
= cu
->base_address
;
11704 if (cu
->base_known
== 0)
11705 complaint (&symfile_complaints
,
11706 _("Location list used without specifying the CU base address."));
11708 SYMBOL_COMPUTED_OPS (sym
) = &dwarf2_loclist_funcs
;
11709 SYMBOL_LOCATION_BATON (sym
) = baton
;
11713 struct dwarf2_locexpr_baton
*baton
;
11715 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
11716 sizeof (struct dwarf2_locexpr_baton
));
11717 baton
->per_cu
= cu
->per_cu
;
11718 gdb_assert (baton
->per_cu
);
11720 if (attr_form_is_block (attr
))
11722 /* Note that we're just copying the block's data pointer
11723 here, not the actual data. We're still pointing into the
11724 info_buffer for SYM's objfile; right now we never release
11725 that buffer, but when we do clean up properly this may
11727 baton
->size
= DW_BLOCK (attr
)->size
;
11728 baton
->data
= DW_BLOCK (attr
)->data
;
11732 dwarf2_invalid_attrib_class_complaint ("location description",
11733 SYMBOL_NATURAL_NAME (sym
));
11735 baton
->data
= NULL
;
11738 SYMBOL_COMPUTED_OPS (sym
) = &dwarf2_locexpr_funcs
;
11739 SYMBOL_LOCATION_BATON (sym
) = baton
;
11743 /* Return the OBJFILE associated with the compilation unit CU. */
11746 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data
*per_cu
)
11748 struct objfile
*objfile
= per_cu
->psymtab
->objfile
;
11750 /* Return the master objfile, so that we can report and look up the
11751 correct file containing this variable. */
11752 if (objfile
->separate_debug_objfile_backlink
)
11753 objfile
= objfile
->separate_debug_objfile_backlink
;
11758 /* Return the address size given in the compilation unit header for CU. */
11761 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data
*per_cu
)
11764 return per_cu
->cu
->header
.addr_size
;
11767 /* If the CU is not currently read in, we re-read its header. */
11768 struct objfile
*objfile
= per_cu
->psymtab
->objfile
;
11769 struct dwarf2_per_objfile
*per_objfile
11770 = objfile_data (objfile
, dwarf2_objfile_data_key
);
11771 gdb_byte
*info_ptr
= per_objfile
->info
.buffer
+ per_cu
->offset
;
11772 struct comp_unit_head cu_header
;
11774 memset (&cu_header
, 0, sizeof cu_header
);
11775 read_comp_unit_head (&cu_header
, info_ptr
, objfile
->obfd
);
11776 return cu_header
.addr_size
;
11780 /* Return the offset size given in the compilation unit header for CU. */
11783 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data
*per_cu
)
11786 return per_cu
->cu
->header
.offset_size
;
11789 /* If the CU is not currently read in, we re-read its header. */
11790 struct objfile
*objfile
= per_cu
->psymtab
->objfile
;
11791 struct dwarf2_per_objfile
*per_objfile
11792 = objfile_data (objfile
, dwarf2_objfile_data_key
);
11793 gdb_byte
*info_ptr
= per_objfile
->info
.buffer
+ per_cu
->offset
;
11794 struct comp_unit_head cu_header
;
11796 memset (&cu_header
, 0, sizeof cu_header
);
11797 read_comp_unit_head (&cu_header
, info_ptr
, objfile
->obfd
);
11798 return cu_header
.offset_size
;
11802 /* Locate the .debug_info compilation unit from CU's objfile which contains
11803 the DIE at OFFSET. Raises an error on failure. */
11805 static struct dwarf2_per_cu_data
*
11806 dwarf2_find_containing_comp_unit (unsigned int offset
,
11807 struct objfile
*objfile
)
11809 struct dwarf2_per_cu_data
*this_cu
;
11813 high
= dwarf2_per_objfile
->n_comp_units
- 1;
11816 int mid
= low
+ (high
- low
) / 2;
11818 if (dwarf2_per_objfile
->all_comp_units
[mid
]->offset
>= offset
)
11823 gdb_assert (low
== high
);
11824 if (dwarf2_per_objfile
->all_comp_units
[low
]->offset
> offset
)
11827 error (_("Dwarf Error: could not find partial DIE containing "
11828 "offset 0x%lx [in module %s]"),
11829 (long) offset
, bfd_get_filename (objfile
->obfd
));
11831 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
<= offset
);
11832 return dwarf2_per_objfile
->all_comp_units
[low
-1];
11836 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
11837 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
11838 && offset
>= this_cu
->offset
+ this_cu
->length
)
11839 error (_("invalid dwarf2 offset %u"), offset
);
11840 gdb_assert (offset
< this_cu
->offset
+ this_cu
->length
);
11845 /* Locate the compilation unit from OBJFILE which is located at exactly
11846 OFFSET. Raises an error on failure. */
11848 static struct dwarf2_per_cu_data
*
11849 dwarf2_find_comp_unit (unsigned int offset
, struct objfile
*objfile
)
11851 struct dwarf2_per_cu_data
*this_cu
;
11853 this_cu
= dwarf2_find_containing_comp_unit (offset
, objfile
);
11854 if (this_cu
->offset
!= offset
)
11855 error (_("no compilation unit with offset %u."), offset
);
11859 /* Malloc space for a dwarf2_cu for OBJFILE and initialize it. */
11861 static struct dwarf2_cu
*
11862 alloc_one_comp_unit (struct objfile
*objfile
)
11864 struct dwarf2_cu
*cu
= xcalloc (1, sizeof (struct dwarf2_cu
));
11865 cu
->objfile
= objfile
;
11866 obstack_init (&cu
->comp_unit_obstack
);
11870 /* Release one cached compilation unit, CU. We unlink it from the tree
11871 of compilation units, but we don't remove it from the read_in_chain;
11872 the caller is responsible for that.
11873 NOTE: DATA is a void * because this function is also used as a
11874 cleanup routine. */
11877 free_one_comp_unit (void *data
)
11879 struct dwarf2_cu
*cu
= data
;
11881 if (cu
->per_cu
!= NULL
)
11882 cu
->per_cu
->cu
= NULL
;
11885 obstack_free (&cu
->comp_unit_obstack
, NULL
);
11890 /* This cleanup function is passed the address of a dwarf2_cu on the stack
11891 when we're finished with it. We can't free the pointer itself, but be
11892 sure to unlink it from the cache. Also release any associated storage
11893 and perform cache maintenance.
11895 Only used during partial symbol parsing. */
11898 free_stack_comp_unit (void *data
)
11900 struct dwarf2_cu
*cu
= data
;
11902 obstack_free (&cu
->comp_unit_obstack
, NULL
);
11903 cu
->partial_dies
= NULL
;
11905 if (cu
->per_cu
!= NULL
)
11907 /* This compilation unit is on the stack in our caller, so we
11908 should not xfree it. Just unlink it. */
11909 cu
->per_cu
->cu
= NULL
;
11912 /* If we had a per-cu pointer, then we may have other compilation
11913 units loaded, so age them now. */
11914 age_cached_comp_units ();
11918 /* Free all cached compilation units. */
11921 free_cached_comp_units (void *data
)
11923 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
11925 per_cu
= dwarf2_per_objfile
->read_in_chain
;
11926 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
11927 while (per_cu
!= NULL
)
11929 struct dwarf2_per_cu_data
*next_cu
;
11931 next_cu
= per_cu
->cu
->read_in_chain
;
11933 free_one_comp_unit (per_cu
->cu
);
11934 *last_chain
= next_cu
;
11940 /* Increase the age counter on each cached compilation unit, and free
11941 any that are too old. */
11944 age_cached_comp_units (void)
11946 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
11948 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
11949 per_cu
= dwarf2_per_objfile
->read_in_chain
;
11950 while (per_cu
!= NULL
)
11952 per_cu
->cu
->last_used
++;
11953 if (per_cu
->cu
->last_used
<= dwarf2_max_cache_age
)
11954 dwarf2_mark (per_cu
->cu
);
11955 per_cu
= per_cu
->cu
->read_in_chain
;
11958 per_cu
= dwarf2_per_objfile
->read_in_chain
;
11959 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
11960 while (per_cu
!= NULL
)
11962 struct dwarf2_per_cu_data
*next_cu
;
11964 next_cu
= per_cu
->cu
->read_in_chain
;
11966 if (!per_cu
->cu
->mark
)
11968 free_one_comp_unit (per_cu
->cu
);
11969 *last_chain
= next_cu
;
11972 last_chain
= &per_cu
->cu
->read_in_chain
;
11978 /* Remove a single compilation unit from the cache. */
11981 free_one_cached_comp_unit (void *target_cu
)
11983 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
11985 per_cu
= dwarf2_per_objfile
->read_in_chain
;
11986 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
11987 while (per_cu
!= NULL
)
11989 struct dwarf2_per_cu_data
*next_cu
;
11991 next_cu
= per_cu
->cu
->read_in_chain
;
11993 if (per_cu
->cu
== target_cu
)
11995 free_one_comp_unit (per_cu
->cu
);
11996 *last_chain
= next_cu
;
12000 last_chain
= &per_cu
->cu
->read_in_chain
;
12006 /* Release all extra memory associated with OBJFILE. */
12009 dwarf2_free_objfile (struct objfile
*objfile
)
12011 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
12013 if (dwarf2_per_objfile
== NULL
)
12016 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
12017 free_cached_comp_units (NULL
);
12019 /* Everything else should be on the objfile obstack. */
12022 /* A pair of DIE offset and GDB type pointer. We store these
12023 in a hash table separate from the DIEs, and preserve them
12024 when the DIEs are flushed out of cache. */
12026 struct dwarf2_offset_and_type
12028 unsigned int offset
;
12032 /* Hash function for a dwarf2_offset_and_type. */
12035 offset_and_type_hash (const void *item
)
12037 const struct dwarf2_offset_and_type
*ofs
= item
;
12039 return ofs
->offset
;
12042 /* Equality function for a dwarf2_offset_and_type. */
12045 offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
12047 const struct dwarf2_offset_and_type
*ofs_lhs
= item_lhs
;
12048 const struct dwarf2_offset_and_type
*ofs_rhs
= item_rhs
;
12050 return ofs_lhs
->offset
== ofs_rhs
->offset
;
12053 /* Set the type associated with DIE to TYPE. Save it in CU's hash
12054 table if necessary. For convenience, return TYPE. */
12056 static struct type
*
12057 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
12059 struct dwarf2_offset_and_type
**slot
, ofs
;
12061 /* For Ada types, make sure that the gnat-specific data is always
12062 initialized (if not already set). There are a few types where
12063 we should not be doing so, because the type-specific area is
12064 already used to hold some other piece of info (eg: TYPE_CODE_FLT
12065 where the type-specific area is used to store the floatformat).
12066 But this is not a problem, because the gnat-specific information
12067 is actually not needed for these types. */
12068 if (need_gnat_info (cu
)
12069 && TYPE_CODE (type
) != TYPE_CODE_FUNC
12070 && TYPE_CODE (type
) != TYPE_CODE_FLT
12071 && !HAVE_GNAT_AUX_INFO (type
))
12072 INIT_GNAT_SPECIFIC (type
);
12074 if (cu
->type_hash
== NULL
)
12076 gdb_assert (cu
->per_cu
!= NULL
);
12077 cu
->per_cu
->type_hash
12078 = htab_create_alloc_ex (cu
->header
.length
/ 24,
12079 offset_and_type_hash
,
12080 offset_and_type_eq
,
12082 &cu
->objfile
->objfile_obstack
,
12083 hashtab_obstack_allocate
,
12084 dummy_obstack_deallocate
);
12085 cu
->type_hash
= cu
->per_cu
->type_hash
;
12088 ofs
.offset
= die
->offset
;
12090 slot
= (struct dwarf2_offset_and_type
**)
12091 htab_find_slot_with_hash (cu
->type_hash
, &ofs
, ofs
.offset
, INSERT
);
12092 *slot
= obstack_alloc (&cu
->objfile
->objfile_obstack
, sizeof (**slot
));
12097 /* Find the type for DIE in CU's type_hash, or return NULL if DIE does
12098 not have a saved type. */
12100 static struct type
*
12101 get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
12103 struct dwarf2_offset_and_type
*slot
, ofs
;
12104 htab_t type_hash
= cu
->type_hash
;
12106 if (type_hash
== NULL
)
12109 ofs
.offset
= die
->offset
;
12110 slot
= htab_find_with_hash (type_hash
, &ofs
, ofs
.offset
);
12117 /* Add a dependence relationship from CU to REF_PER_CU. */
12120 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
12121 struct dwarf2_per_cu_data
*ref_per_cu
)
12125 if (cu
->dependencies
== NULL
)
12127 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
12128 NULL
, &cu
->comp_unit_obstack
,
12129 hashtab_obstack_allocate
,
12130 dummy_obstack_deallocate
);
12132 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
12134 *slot
= ref_per_cu
;
12137 /* Subroutine of dwarf2_mark to pass to htab_traverse.
12138 Set the mark field in every compilation unit in the
12139 cache that we must keep because we are keeping CU. */
12142 dwarf2_mark_helper (void **slot
, void *data
)
12144 struct dwarf2_per_cu_data
*per_cu
;
12146 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
12147 if (per_cu
->cu
->mark
)
12149 per_cu
->cu
->mark
= 1;
12151 if (per_cu
->cu
->dependencies
!= NULL
)
12152 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
12157 /* Set the mark field in CU and in every other compilation unit in the
12158 cache that we must keep because we are keeping CU. */
12161 dwarf2_mark (struct dwarf2_cu
*cu
)
12166 if (cu
->dependencies
!= NULL
)
12167 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
12171 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
12175 per_cu
->cu
->mark
= 0;
12176 per_cu
= per_cu
->cu
->read_in_chain
;
12180 /* Trivial hash function for partial_die_info: the hash value of a DIE
12181 is its offset in .debug_info for this objfile. */
12184 partial_die_hash (const void *item
)
12186 const struct partial_die_info
*part_die
= item
;
12188 return part_die
->offset
;
12191 /* Trivial comparison function for partial_die_info structures: two DIEs
12192 are equal if they have the same offset. */
12195 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
12197 const struct partial_die_info
*part_die_lhs
= item_lhs
;
12198 const struct partial_die_info
*part_die_rhs
= item_rhs
;
12200 return part_die_lhs
->offset
== part_die_rhs
->offset
;
12203 static struct cmd_list_element
*set_dwarf2_cmdlist
;
12204 static struct cmd_list_element
*show_dwarf2_cmdlist
;
12207 set_dwarf2_cmd (char *args
, int from_tty
)
12209 help_list (set_dwarf2_cmdlist
, "maintenance set dwarf2 ", -1, gdb_stdout
);
12213 show_dwarf2_cmd (char *args
, int from_tty
)
12215 cmd_show_list (show_dwarf2_cmdlist
, from_tty
, "");
12218 /* If section described by INFO was mmapped, munmap it now. */
12221 munmap_section_buffer (struct dwarf2_section_info
*info
)
12223 if (info
->was_mmapped
)
12226 intptr_t begin
= (intptr_t) info
->buffer
;
12227 intptr_t map_begin
= begin
& ~(pagesize
- 1);
12228 size_t map_length
= info
->size
+ begin
- map_begin
;
12230 gdb_assert (munmap ((void *) map_begin
, map_length
) == 0);
12232 /* Without HAVE_MMAP, we should never be here to begin with. */
12238 /* munmap debug sections for OBJFILE, if necessary. */
12241 dwarf2_per_objfile_free (struct objfile
*objfile
, void *d
)
12243 struct dwarf2_per_objfile
*data
= d
;
12245 munmap_section_buffer (&data
->info
);
12246 munmap_section_buffer (&data
->abbrev
);
12247 munmap_section_buffer (&data
->line
);
12248 munmap_section_buffer (&data
->str
);
12249 munmap_section_buffer (&data
->macinfo
);
12250 munmap_section_buffer (&data
->ranges
);
12251 munmap_section_buffer (&data
->loc
);
12252 munmap_section_buffer (&data
->frame
);
12253 munmap_section_buffer (&data
->eh_frame
);
12256 int dwarf2_always_disassemble
;
12259 show_dwarf2_always_disassemble (struct ui_file
*file
, int from_tty
,
12260 struct cmd_list_element
*c
, const char *value
)
12262 fprintf_filtered (file
, _("\
12263 Whether to always disassemble DWARF expressions is %s.\n"),
12267 void _initialize_dwarf2_read (void);
12270 _initialize_dwarf2_read (void)
12272 dwarf2_objfile_data_key
12273 = register_objfile_data_with_cleanup (NULL
, dwarf2_per_objfile_free
);
12275 add_prefix_cmd ("dwarf2", class_maintenance
, set_dwarf2_cmd
, _("\
12276 Set DWARF 2 specific variables.\n\
12277 Configure DWARF 2 variables such as the cache size"),
12278 &set_dwarf2_cmdlist
, "maintenance set dwarf2 ",
12279 0/*allow-unknown*/, &maintenance_set_cmdlist
);
12281 add_prefix_cmd ("dwarf2", class_maintenance
, show_dwarf2_cmd
, _("\
12282 Show DWARF 2 specific variables\n\
12283 Show DWARF 2 variables such as the cache size"),
12284 &show_dwarf2_cmdlist
, "maintenance show dwarf2 ",
12285 0/*allow-unknown*/, &maintenance_show_cmdlist
);
12287 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
12288 &dwarf2_max_cache_age
, _("\
12289 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
12290 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
12291 A higher limit means that cached compilation units will be stored\n\
12292 in memory longer, and more total memory will be used. Zero disables\n\
12293 caching, which can slow down startup."),
12295 show_dwarf2_max_cache_age
,
12296 &set_dwarf2_cmdlist
,
12297 &show_dwarf2_cmdlist
);
12299 add_setshow_boolean_cmd ("always-disassemble", class_obscure
,
12300 &dwarf2_always_disassemble
, _("\
12301 Set whether `info address' always disassembles DWARF expressions."), _("\
12302 Show whether `info address' always disassembles DWARF expressions."), _("\
12303 When enabled, DWARF expressions are always printed in an assembly-like\n\
12304 syntax. When disabled, expressions will be printed in a more\n\
12305 conversational style, when possible."),
12307 show_dwarf2_always_disassemble
,
12308 &set_dwarf2_cmdlist
,
12309 &show_dwarf2_cmdlist
);
12311 add_setshow_zinteger_cmd ("dwarf2-die", no_class
, &dwarf2_die_debug
, _("\
12312 Set debugging of the dwarf2 DIE reader."), _("\
12313 Show debugging of the dwarf2 DIE reader."), _("\
12314 When enabled (non-zero), DIEs are dumped after they are read in.\n\
12315 The value is the maximum depth to print."),
12318 &setdebuglist
, &showdebuglist
);