1 /* DWARF 2 debugging format support for GDB.
3 Copyright (C) 1994-2012 Free Software Foundation, Inc.
5 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
6 Inc. with support from Florida State University (under contract
7 with the Ada Joint Program Office), and Silicon Graphics, Inc.
8 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
9 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
12 This file is part of GDB.
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 3 of the License, or
17 (at your option) any later version.
19 This program is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with this program. If not, see <http://www.gnu.org/licenses/>. */
27 /* FIXME: Various die-reading functions need to be more careful with
28 reading off the end of the section.
29 E.g., load_partial_dies, read_partial_die. */
39 #include "gdb-demangle.h"
40 #include "expression.h"
41 #include "filenames.h" /* for DOSish file names */
44 #include "complaints.h"
46 #include "dwarf2expr.h"
47 #include "dwarf2loc.h"
48 #include "cp-support.h"
54 #include "typeprint.h"
57 #include "exceptions.h"
59 #include "completer.h"
66 #include "gdb_string.h"
67 #include "gdb_assert.h"
68 #include <sys/types.h>
75 #define MAP_FAILED ((void *) -1)
79 typedef struct symbol
*symbolp
;
82 /* When non-zero, dump DIEs after they are read in. */
83 static int dwarf2_die_debug
= 0;
85 /* When non-zero, cross-check physname against demangler. */
86 static int check_physname
= 0;
90 /* When set, the file that we're processing is known to have debugging
91 info for C++ namespaces. GCC 3.3.x did not produce this information,
92 but later versions do. */
94 static int processing_has_namespace_info
;
96 static const struct objfile_data
*dwarf2_objfile_data_key
;
98 struct dwarf2_section_info
103 /* Not NULL if the section was actually mmapped. */
105 /* Page aligned size of mmapped area. */
106 bfd_size_type map_len
;
107 /* True if we have tried to read this section. */
111 typedef struct dwarf2_section_info dwarf2_section_info_def
;
112 DEF_VEC_O (dwarf2_section_info_def
);
114 /* All offsets in the index are of this type. It must be
115 architecture-independent. */
116 typedef uint32_t offset_type
;
118 DEF_VEC_I (offset_type
);
120 /* A description of the mapped index. The file format is described in
121 a comment by the code that writes the index. */
124 /* Index data format version. */
127 /* The total length of the buffer. */
130 /* A pointer to the address table data. */
131 const gdb_byte
*address_table
;
133 /* Size of the address table data in bytes. */
134 offset_type address_table_size
;
136 /* The symbol table, implemented as a hash table. */
137 const offset_type
*symbol_table
;
139 /* Size in slots, each slot is 2 offset_types. */
140 offset_type symbol_table_slots
;
142 /* A pointer to the constant pool. */
143 const char *constant_pool
;
146 /* Collection of data recorded per objfile.
147 This hangs off of dwarf2_objfile_data_key. */
149 struct dwarf2_per_objfile
151 struct dwarf2_section_info info
;
152 struct dwarf2_section_info abbrev
;
153 struct dwarf2_section_info line
;
154 struct dwarf2_section_info loc
;
155 struct dwarf2_section_info macinfo
;
156 struct dwarf2_section_info macro
;
157 struct dwarf2_section_info str
;
158 struct dwarf2_section_info ranges
;
159 struct dwarf2_section_info frame
;
160 struct dwarf2_section_info eh_frame
;
161 struct dwarf2_section_info gdb_index
;
163 VEC (dwarf2_section_info_def
) *types
;
166 struct objfile
*objfile
;
168 /* Table of all the compilation units. This is used to locate
169 the target compilation unit of a particular reference. */
170 struct dwarf2_per_cu_data
**all_comp_units
;
172 /* The number of compilation units in ALL_COMP_UNITS. */
175 /* The number of .debug_types-related CUs. */
178 /* The .debug_types-related CUs (TUs). */
179 struct dwarf2_per_cu_data
**all_type_units
;
181 /* A chain of compilation units that are currently read in, so that
182 they can be freed later. */
183 struct dwarf2_per_cu_data
*read_in_chain
;
185 /* A table mapping .debug_types signatures to its signatured_type entry.
186 This is NULL if the .debug_types section hasn't been read in yet. */
187 htab_t signatured_types
;
189 /* A flag indicating wether this objfile has a section loaded at a
191 int has_section_at_zero
;
193 /* True if we are using the mapped index,
194 or we are faking it for OBJF_READNOW's sake. */
195 unsigned char using_index
;
197 /* The mapped index, or NULL if .gdb_index is missing or not being used. */
198 struct mapped_index
*index_table
;
200 /* When using index_table, this keeps track of all quick_file_names entries.
201 TUs can share line table entries with CUs or other TUs, and there can be
202 a lot more TUs than unique line tables, so we maintain a separate table
203 of all line table entries to support the sharing. */
204 htab_t quick_file_names_table
;
206 /* Set during partial symbol reading, to prevent queueing of full
208 int reading_partial_symbols
;
210 /* Table mapping type .debug_info DIE offsets to types.
211 This is NULL if not allocated yet.
212 It (currently) makes sense to allocate debug_types_type_hash lazily.
213 To keep things simple we allocate both lazily. */
214 htab_t debug_info_type_hash
;
216 /* Table mapping type .debug_types DIE offsets to types.
217 This is NULL if not allocated yet. */
218 htab_t debug_types_type_hash
;
221 static struct dwarf2_per_objfile
*dwarf2_per_objfile
;
223 /* Default names of the debugging sections. */
225 /* Note that if the debugging section has been compressed, it might
226 have a name like .zdebug_info. */
228 static const struct dwarf2_debug_sections dwarf2_elf_names
=
230 { ".debug_info", ".zdebug_info" },
231 { ".debug_abbrev", ".zdebug_abbrev" },
232 { ".debug_line", ".zdebug_line" },
233 { ".debug_loc", ".zdebug_loc" },
234 { ".debug_macinfo", ".zdebug_macinfo" },
235 { ".debug_macro", ".zdebug_macro" },
236 { ".debug_str", ".zdebug_str" },
237 { ".debug_ranges", ".zdebug_ranges" },
238 { ".debug_types", ".zdebug_types" },
239 { ".debug_frame", ".zdebug_frame" },
240 { ".eh_frame", NULL
},
241 { ".gdb_index", ".zgdb_index" },
245 /* local data types */
247 /* We hold several abbreviation tables in memory at the same time. */
248 #ifndef ABBREV_HASH_SIZE
249 #define ABBREV_HASH_SIZE 121
252 /* The data in a compilation unit header, after target2host
253 translation, looks like this. */
254 struct comp_unit_head
258 unsigned char addr_size
;
259 unsigned char signed_addr_p
;
260 unsigned int abbrev_offset
;
262 /* Size of file offsets; either 4 or 8. */
263 unsigned int offset_size
;
265 /* Size of the length field; either 4 or 12. */
266 unsigned int initial_length_size
;
268 /* Offset to the first byte of this compilation unit header in the
269 .debug_info section, for resolving relative reference dies. */
272 /* Offset to first die in this cu from the start of the cu.
273 This will be the first byte following the compilation unit header. */
274 unsigned int first_die_offset
;
277 /* Type used for delaying computation of method physnames.
278 See comments for compute_delayed_physnames. */
279 struct delayed_method_info
281 /* The type to which the method is attached, i.e., its parent class. */
284 /* The index of the method in the type's function fieldlists. */
287 /* The index of the method in the fieldlist. */
290 /* The name of the DIE. */
293 /* The DIE associated with this method. */
294 struct die_info
*die
;
297 typedef struct delayed_method_info delayed_method_info
;
298 DEF_VEC_O (delayed_method_info
);
300 /* Internal state when decoding a particular compilation unit. */
303 /* The objfile containing this compilation unit. */
304 struct objfile
*objfile
;
306 /* The header of the compilation unit. */
307 struct comp_unit_head header
;
309 /* Base address of this compilation unit. */
310 CORE_ADDR base_address
;
312 /* Non-zero if base_address has been set. */
315 /* The language we are debugging. */
316 enum language language
;
317 const struct language_defn
*language_defn
;
319 const char *producer
;
321 /* The generic symbol table building routines have separate lists for
322 file scope symbols and all all other scopes (local scopes). So
323 we need to select the right one to pass to add_symbol_to_list().
324 We do it by keeping a pointer to the correct list in list_in_scope.
326 FIXME: The original dwarf code just treated the file scope as the
327 first local scope, and all other local scopes as nested local
328 scopes, and worked fine. Check to see if we really need to
329 distinguish these in buildsym.c. */
330 struct pending
**list_in_scope
;
332 /* DWARF abbreviation table associated with this compilation unit. */
333 struct abbrev_info
**dwarf2_abbrevs
;
335 /* Storage for the abbrev table. */
336 struct obstack abbrev_obstack
;
338 /* Hash table holding all the loaded partial DIEs. */
341 /* Storage for things with the same lifetime as this read-in compilation
342 unit, including partial DIEs. */
343 struct obstack comp_unit_obstack
;
345 /* When multiple dwarf2_cu structures are living in memory, this field
346 chains them all together, so that they can be released efficiently.
347 We will probably also want a generation counter so that most-recently-used
348 compilation units are cached... */
349 struct dwarf2_per_cu_data
*read_in_chain
;
351 /* Backchain to our per_cu entry if the tree has been built. */
352 struct dwarf2_per_cu_data
*per_cu
;
354 /* How many compilation units ago was this CU last referenced? */
357 /* A hash table of die offsets for following references. */
360 /* Full DIEs if read in. */
361 struct die_info
*dies
;
363 /* A set of pointers to dwarf2_per_cu_data objects for compilation
364 units referenced by this one. Only set during full symbol processing;
365 partial symbol tables do not have dependencies. */
368 /* Header data from the line table, during full symbol processing. */
369 struct line_header
*line_header
;
371 /* A list of methods which need to have physnames computed
372 after all type information has been read. */
373 VEC (delayed_method_info
) *method_list
;
375 /* To be copied to symtab->call_site_htab. */
376 htab_t call_site_htab
;
378 /* Mark used when releasing cached dies. */
379 unsigned int mark
: 1;
381 /* This flag will be set if this compilation unit might include
382 inter-compilation-unit references. */
383 unsigned int has_form_ref_addr
: 1;
385 /* This flag will be set if this compilation unit includes any
386 DW_TAG_namespace DIEs. If we know that there are explicit
387 DIEs for namespaces, we don't need to try to infer them
388 from mangled names. */
389 unsigned int has_namespace_info
: 1;
391 /* This CU references .debug_loc. See the symtab->locations_valid field.
392 This test is imperfect as there may exist optimized debug code not using
393 any location list and still facing inlining issues if handled as
394 unoptimized code. For a future better test see GCC PR other/32998. */
395 unsigned int has_loclist
: 1;
398 /* Persistent data held for a compilation unit, even when not
399 processing it. We put a pointer to this structure in the
400 read_symtab_private field of the psymtab. */
402 struct dwarf2_per_cu_data
404 /* The start offset and length of this compilation unit. 2**29-1
405 bytes should suffice to store the length of any compilation unit
406 - if it doesn't, GDB will fall over anyway.
407 NOTE: Unlike comp_unit_head.length, this length includes
408 initial_length_size. */
410 unsigned int length
: 29;
412 /* Flag indicating this compilation unit will be read in before
413 any of the current compilation units are processed. */
414 unsigned int queued
: 1;
416 /* This flag will be set if we need to load absolutely all DIEs
417 for this compilation unit, instead of just the ones we think
418 are interesting. It gets set if we look for a DIE in the
419 hash table and don't find it. */
420 unsigned int load_all_dies
: 1;
422 /* Non-null if this CU is from .debug_types; in which case it points
423 to the section. Otherwise it's from .debug_info. */
424 struct dwarf2_section_info
*debug_types_section
;
426 /* Set to non-NULL iff this CU is currently loaded. When it gets freed out
427 of the CU cache it gets reset to NULL again. */
428 struct dwarf2_cu
*cu
;
430 /* The corresponding objfile.
431 Normally we can get the objfile from dwarf2_per_objfile.
432 However we can enter this file with just a "per_cu" handle. */
433 struct objfile
*objfile
;
435 /* When using partial symbol tables, the 'psymtab' field is active.
436 Otherwise the 'quick' field is active. */
439 /* The partial symbol table associated with this compilation unit,
440 or NULL for partial units (which do not have an associated
442 struct partial_symtab
*psymtab
;
444 /* Data needed by the "quick" functions. */
445 struct dwarf2_per_cu_quick_data
*quick
;
449 /* Entry in the signatured_types hash table. */
451 struct signatured_type
455 /* Offset in .debug_types of the type defined by this TU. */
456 unsigned int type_offset
;
458 /* The CU(/TU) of this type. */
459 struct dwarf2_per_cu_data per_cu
;
462 /* Struct used to pass misc. parameters to read_die_and_children, et
463 al. which are used for both .debug_info and .debug_types dies.
464 All parameters here are unchanging for the life of the call. This
465 struct exists to abstract away the constant parameters of die
468 struct die_reader_specs
470 /* The bfd of this objfile. */
473 /* The CU of the DIE we are parsing. */
474 struct dwarf2_cu
*cu
;
476 /* Pointer to start of section buffer.
477 This is either the start of .debug_info or .debug_types. */
478 const gdb_byte
*buffer
;
481 /* The line number information for a compilation unit (found in the
482 .debug_line section) begins with a "statement program header",
483 which contains the following information. */
486 unsigned int total_length
;
487 unsigned short version
;
488 unsigned int header_length
;
489 unsigned char minimum_instruction_length
;
490 unsigned char maximum_ops_per_instruction
;
491 unsigned char default_is_stmt
;
493 unsigned char line_range
;
494 unsigned char opcode_base
;
496 /* standard_opcode_lengths[i] is the number of operands for the
497 standard opcode whose value is i. This means that
498 standard_opcode_lengths[0] is unused, and the last meaningful
499 element is standard_opcode_lengths[opcode_base - 1]. */
500 unsigned char *standard_opcode_lengths
;
502 /* The include_directories table. NOTE! These strings are not
503 allocated with xmalloc; instead, they are pointers into
504 debug_line_buffer. If you try to free them, `free' will get
506 unsigned int num_include_dirs
, include_dirs_size
;
509 /* The file_names table. NOTE! These strings are not allocated
510 with xmalloc; instead, they are pointers into debug_line_buffer.
511 Don't try to free them directly. */
512 unsigned int num_file_names
, file_names_size
;
516 unsigned int dir_index
;
517 unsigned int mod_time
;
519 int included_p
; /* Non-zero if referenced by the Line Number Program. */
520 struct symtab
*symtab
; /* The associated symbol table, if any. */
523 /* The start and end of the statement program following this
524 header. These point into dwarf2_per_objfile->line_buffer. */
525 gdb_byte
*statement_program_start
, *statement_program_end
;
528 /* When we construct a partial symbol table entry we only
529 need this much information. */
530 struct partial_die_info
532 /* Offset of this DIE. */
535 /* DWARF-2 tag for this DIE. */
536 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
538 /* Assorted flags describing the data found in this DIE. */
539 unsigned int has_children
: 1;
540 unsigned int is_external
: 1;
541 unsigned int is_declaration
: 1;
542 unsigned int has_type
: 1;
543 unsigned int has_specification
: 1;
544 unsigned int has_pc_info
: 1;
546 /* Flag set if the SCOPE field of this structure has been
548 unsigned int scope_set
: 1;
550 /* Flag set if the DIE has a byte_size attribute. */
551 unsigned int has_byte_size
: 1;
553 /* Flag set if any of the DIE's children are template arguments. */
554 unsigned int has_template_arguments
: 1;
556 /* Flag set if fixup_partial_die has been called on this die. */
557 unsigned int fixup_called
: 1;
559 /* The name of this DIE. Normally the value of DW_AT_name, but
560 sometimes a default name for unnamed DIEs. */
563 /* The linkage name, if present. */
564 const char *linkage_name
;
566 /* The scope to prepend to our children. This is generally
567 allocated on the comp_unit_obstack, so will disappear
568 when this compilation unit leaves the cache. */
571 /* The location description associated with this DIE, if any. */
572 struct dwarf_block
*locdesc
;
574 /* If HAS_PC_INFO, the PC range associated with this DIE. */
578 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
579 DW_AT_sibling, if any. */
580 /* NOTE: This member isn't strictly necessary, read_partial_die could
581 return DW_AT_sibling values to its caller load_partial_dies. */
584 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
585 DW_AT_specification (or DW_AT_abstract_origin or
587 unsigned int spec_offset
;
589 /* Pointers to this DIE's parent, first child, and next sibling,
591 struct partial_die_info
*die_parent
, *die_child
, *die_sibling
;
594 /* This data structure holds the information of an abbrev. */
597 unsigned int number
; /* number identifying abbrev */
598 enum dwarf_tag tag
; /* dwarf tag */
599 unsigned short has_children
; /* boolean */
600 unsigned short num_attrs
; /* number of attributes */
601 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
602 struct abbrev_info
*next
; /* next in chain */
607 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
608 ENUM_BITFIELD(dwarf_form
) form
: 16;
611 /* Attributes have a name and a value. */
614 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
615 ENUM_BITFIELD(dwarf_form
) form
: 15;
617 /* Has DW_STRING already been updated by dwarf2_canonicalize_name? This
618 field should be in u.str (existing only for DW_STRING) but it is kept
619 here for better struct attribute alignment. */
620 unsigned int string_is_canonical
: 1;
625 struct dwarf_block
*blk
;
629 struct signatured_type
*signatured_type
;
634 /* This data structure holds a complete die structure. */
637 /* DWARF-2 tag for this DIE. */
638 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
640 /* Number of attributes */
641 unsigned char num_attrs
;
643 /* True if we're presently building the full type name for the
644 type derived from this DIE. */
645 unsigned char building_fullname
: 1;
650 /* Offset in .debug_info or .debug_types section. */
653 /* The dies in a compilation unit form an n-ary tree. PARENT
654 points to this die's parent; CHILD points to the first child of
655 this node; and all the children of a given node are chained
656 together via their SIBLING fields. */
657 struct die_info
*child
; /* Its first child, if any. */
658 struct die_info
*sibling
; /* Its next sibling, if any. */
659 struct die_info
*parent
; /* Its parent, if any. */
661 /* An array of attributes, with NUM_ATTRS elements. There may be
662 zero, but it's not common and zero-sized arrays are not
663 sufficiently portable C. */
664 struct attribute attrs
[1];
667 /* Get at parts of an attribute structure. */
669 #define DW_STRING(attr) ((attr)->u.str)
670 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
671 #define DW_UNSND(attr) ((attr)->u.unsnd)
672 #define DW_BLOCK(attr) ((attr)->u.blk)
673 #define DW_SND(attr) ((attr)->u.snd)
674 #define DW_ADDR(attr) ((attr)->u.addr)
675 #define DW_SIGNATURED_TYPE(attr) ((attr)->u.signatured_type)
677 /* Blocks are a bunch of untyped bytes. */
682 /* Valid only if SIZE is not zero. */
686 #ifndef ATTR_ALLOC_CHUNK
687 #define ATTR_ALLOC_CHUNK 4
690 /* Allocate fields for structs, unions and enums in this size. */
691 #ifndef DW_FIELD_ALLOC_CHUNK
692 #define DW_FIELD_ALLOC_CHUNK 4
695 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
696 but this would require a corresponding change in unpack_field_as_long
698 static int bits_per_byte
= 8;
700 /* The routines that read and process dies for a C struct or C++ class
701 pass lists of data member fields and lists of member function fields
702 in an instance of a field_info structure, as defined below. */
705 /* List of data member and baseclasses fields. */
708 struct nextfield
*next
;
713 *fields
, *baseclasses
;
715 /* Number of fields (including baseclasses). */
718 /* Number of baseclasses. */
721 /* Set if the accesibility of one of the fields is not public. */
722 int non_public_fields
;
724 /* Member function fields array, entries are allocated in the order they
725 are encountered in the object file. */
728 struct nextfnfield
*next
;
729 struct fn_field fnfield
;
733 /* Member function fieldlist array, contains name of possibly overloaded
734 member function, number of overloaded member functions and a pointer
735 to the head of the member function field chain. */
740 struct nextfnfield
*head
;
744 /* Number of entries in the fnfieldlists array. */
747 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
748 a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
749 struct typedef_field_list
751 struct typedef_field field
;
752 struct typedef_field_list
*next
;
755 unsigned typedef_field_list_count
;
758 /* One item on the queue of compilation units to read in full symbols
760 struct dwarf2_queue_item
762 struct dwarf2_per_cu_data
*per_cu
;
763 struct dwarf2_queue_item
*next
;
766 /* The current queue. */
767 static struct dwarf2_queue_item
*dwarf2_queue
, *dwarf2_queue_tail
;
769 /* Loaded secondary compilation units are kept in memory until they
770 have not been referenced for the processing of this many
771 compilation units. Set this to zero to disable caching. Cache
772 sizes of up to at least twenty will improve startup time for
773 typical inter-CU-reference binaries, at an obvious memory cost. */
774 static int dwarf2_max_cache_age
= 5;
776 show_dwarf2_max_cache_age (struct ui_file
*file
, int from_tty
,
777 struct cmd_list_element
*c
, const char *value
)
779 fprintf_filtered (file
, _("The upper bound on the age of cached "
780 "dwarf2 compilation units is %s.\n"),
785 /* Various complaints about symbol reading that don't abort the process. */
788 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
790 complaint (&symfile_complaints
,
791 _("statement list doesn't fit in .debug_line section"));
795 dwarf2_debug_line_missing_file_complaint (void)
797 complaint (&symfile_complaints
,
798 _(".debug_line section has line data without a file"));
802 dwarf2_debug_line_missing_end_sequence_complaint (void)
804 complaint (&symfile_complaints
,
805 _(".debug_line section has line "
806 "program sequence without an end"));
810 dwarf2_complex_location_expr_complaint (void)
812 complaint (&symfile_complaints
, _("location expression too complex"));
816 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
819 complaint (&symfile_complaints
,
820 _("const value length mismatch for '%s', got %d, expected %d"),
825 dwarf2_macros_too_long_complaint (struct dwarf2_section_info
*section
)
827 complaint (&symfile_complaints
,
828 _("macro info runs off end of `%s' section"),
829 section
->asection
->name
);
833 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
835 complaint (&symfile_complaints
,
836 _("macro debug info contains a "
837 "malformed macro definition:\n`%s'"),
842 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
844 complaint (&symfile_complaints
,
845 _("invalid attribute class or form for '%s' in '%s'"),
849 /* local function prototypes */
851 static void dwarf2_locate_sections (bfd
*, asection
*, void *);
853 static void dwarf2_create_include_psymtab (char *, struct partial_symtab
*,
856 static void dwarf2_find_base_address (struct die_info
*die
,
857 struct dwarf2_cu
*cu
);
859 static void dwarf2_build_psymtabs_hard (struct objfile
*);
861 static void scan_partial_symbols (struct partial_die_info
*,
862 CORE_ADDR
*, CORE_ADDR
*,
863 int, struct dwarf2_cu
*);
865 static void add_partial_symbol (struct partial_die_info
*,
868 static void add_partial_namespace (struct partial_die_info
*pdi
,
869 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
870 int need_pc
, struct dwarf2_cu
*cu
);
872 static void add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
873 CORE_ADDR
*highpc
, int need_pc
,
874 struct dwarf2_cu
*cu
);
876 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
877 struct dwarf2_cu
*cu
);
879 static void add_partial_subprogram (struct partial_die_info
*pdi
,
880 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
881 int need_pc
, struct dwarf2_cu
*cu
);
883 static gdb_byte
*locate_pdi_sibling (struct partial_die_info
*orig_pdi
,
884 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
885 bfd
*abfd
, struct dwarf2_cu
*cu
);
887 static void dwarf2_psymtab_to_symtab (struct partial_symtab
*);
889 static void psymtab_to_symtab_1 (struct partial_symtab
*);
891 static void dwarf2_read_abbrevs (struct dwarf2_cu
*cu
);
893 static void dwarf2_free_abbrev_table (void *);
895 static unsigned int peek_abbrev_code (bfd
*, gdb_byte
*);
897 static struct abbrev_info
*peek_die_abbrev (gdb_byte
*, unsigned int *,
900 static struct abbrev_info
*dwarf2_lookup_abbrev (unsigned int,
903 static struct partial_die_info
*load_partial_dies (bfd
*,
904 gdb_byte
*, gdb_byte
*,
905 int, struct dwarf2_cu
*);
907 static gdb_byte
*read_partial_die (struct partial_die_info
*,
908 struct abbrev_info
*abbrev
,
910 gdb_byte
*, gdb_byte
*,
913 static struct partial_die_info
*find_partial_die (unsigned int,
916 static void fixup_partial_die (struct partial_die_info
*,
919 static gdb_byte
*read_attribute (struct attribute
*, struct attr_abbrev
*,
920 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
922 static gdb_byte
*read_attribute_value (struct attribute
*, unsigned,
923 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
925 static unsigned int read_1_byte (bfd
*, gdb_byte
*);
927 static int read_1_signed_byte (bfd
*, gdb_byte
*);
929 static unsigned int read_2_bytes (bfd
*, gdb_byte
*);
931 static unsigned int read_4_bytes (bfd
*, gdb_byte
*);
933 static ULONGEST
read_8_bytes (bfd
*, gdb_byte
*);
935 static CORE_ADDR
read_address (bfd
*, gdb_byte
*ptr
, struct dwarf2_cu
*,
938 static LONGEST
read_initial_length (bfd
*, gdb_byte
*, unsigned int *);
940 static LONGEST read_checked_initial_length_and_offset
941 (bfd
*, gdb_byte
*, const struct comp_unit_head
*,
942 unsigned int *, unsigned int *);
944 static LONGEST
read_offset (bfd
*, gdb_byte
*, const struct comp_unit_head
*,
947 static LONGEST
read_offset_1 (bfd
*, gdb_byte
*, unsigned int);
949 static gdb_byte
*read_n_bytes (bfd
*, gdb_byte
*, unsigned int);
951 static char *read_direct_string (bfd
*, gdb_byte
*, unsigned int *);
953 static char *read_indirect_string (bfd
*, gdb_byte
*,
954 const struct comp_unit_head
*,
957 static unsigned long read_unsigned_leb128 (bfd
*, gdb_byte
*, unsigned int *);
959 static long read_signed_leb128 (bfd
*, gdb_byte
*, unsigned int *);
961 static gdb_byte
*skip_leb128 (bfd
*, gdb_byte
*);
963 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
965 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
968 static struct attribute
*dwarf2_attr_no_follow (struct die_info
*,
972 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
973 struct dwarf2_cu
*cu
);
975 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
977 static struct die_info
*die_specification (struct die_info
*die
,
978 struct dwarf2_cu
**);
980 static void free_line_header (struct line_header
*lh
);
982 static void add_file_name (struct line_header
*, char *, unsigned int,
983 unsigned int, unsigned int);
985 static struct line_header
*(dwarf_decode_line_header
986 (unsigned int offset
,
987 bfd
*abfd
, struct dwarf2_cu
*cu
));
989 static void dwarf_decode_lines (struct line_header
*, const char *,
990 struct dwarf2_cu
*, struct partial_symtab
*,
993 static void dwarf2_start_subfile (char *, const char *, const char *);
995 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
998 static struct symbol
*new_symbol_full (struct die_info
*, struct type
*,
999 struct dwarf2_cu
*, struct symbol
*);
1001 static void dwarf2_const_value (struct attribute
*, struct symbol
*,
1002 struct dwarf2_cu
*);
1004 static void dwarf2_const_value_attr (struct attribute
*attr
,
1007 struct obstack
*obstack
,
1008 struct dwarf2_cu
*cu
, long *value
,
1010 struct dwarf2_locexpr_baton
**baton
);
1012 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
1014 static int need_gnat_info (struct dwarf2_cu
*);
1016 static struct type
*die_descriptive_type (struct die_info
*,
1017 struct dwarf2_cu
*);
1019 static void set_descriptive_type (struct type
*, struct die_info
*,
1020 struct dwarf2_cu
*);
1022 static struct type
*die_containing_type (struct die_info
*,
1023 struct dwarf2_cu
*);
1025 static struct type
*lookup_die_type (struct die_info
*, struct attribute
*,
1026 struct dwarf2_cu
*);
1028 static struct type
*read_type_die (struct die_info
*, struct dwarf2_cu
*);
1030 static struct type
*read_type_die_1 (struct die_info
*, struct dwarf2_cu
*);
1032 static char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
1034 static char *typename_concat (struct obstack
*obs
, const char *prefix
,
1035 const char *suffix
, int physname
,
1036 struct dwarf2_cu
*cu
);
1038 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
1040 static void read_type_unit_scope (struct die_info
*, struct dwarf2_cu
*);
1042 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
1044 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
1046 static void read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
);
1048 static int dwarf2_ranges_read (unsigned, CORE_ADDR
*, CORE_ADDR
*,
1049 struct dwarf2_cu
*, struct partial_symtab
*);
1051 static int dwarf2_get_pc_bounds (struct die_info
*,
1052 CORE_ADDR
*, CORE_ADDR
*, struct dwarf2_cu
*,
1053 struct partial_symtab
*);
1055 static void get_scope_pc_bounds (struct die_info
*,
1056 CORE_ADDR
*, CORE_ADDR
*,
1057 struct dwarf2_cu
*);
1059 static void dwarf2_record_block_ranges (struct die_info
*, struct block
*,
1060 CORE_ADDR
, struct dwarf2_cu
*);
1062 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
1063 struct dwarf2_cu
*);
1065 static void dwarf2_attach_fields_to_type (struct field_info
*,
1066 struct type
*, struct dwarf2_cu
*);
1068 static void dwarf2_add_member_fn (struct field_info
*,
1069 struct die_info
*, struct type
*,
1070 struct dwarf2_cu
*);
1072 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
1074 struct dwarf2_cu
*);
1076 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
1078 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
1080 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
1082 static void read_module (struct die_info
*die
, struct dwarf2_cu
*cu
);
1084 static void read_import_statement (struct die_info
*die
, struct dwarf2_cu
*);
1086 static struct type
*read_module_type (struct die_info
*die
,
1087 struct dwarf2_cu
*cu
);
1089 static const char *namespace_name (struct die_info
*die
,
1090 int *is_anonymous
, struct dwarf2_cu
*);
1092 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
1094 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
1096 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
1097 struct dwarf2_cu
*);
1099 static struct die_info
*read_comp_unit (gdb_byte
*, struct dwarf2_cu
*);
1101 static struct die_info
*read_die_and_children_1 (const struct die_reader_specs
*reader
,
1103 gdb_byte
**new_info_ptr
,
1104 struct die_info
*parent
);
1106 static struct die_info
*read_die_and_children (const struct die_reader_specs
*reader
,
1108 gdb_byte
**new_info_ptr
,
1109 struct die_info
*parent
);
1111 static struct die_info
*read_die_and_siblings (const struct die_reader_specs
*reader
,
1113 gdb_byte
**new_info_ptr
,
1114 struct die_info
*parent
);
1116 static gdb_byte
*read_full_die (const struct die_reader_specs
*reader
,
1117 struct die_info
**, gdb_byte
*,
1120 static void process_die (struct die_info
*, struct dwarf2_cu
*);
1122 static char *dwarf2_canonicalize_name (char *, struct dwarf2_cu
*,
1125 static char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
1127 static const char *dwarf2_full_name (char *name
,
1128 struct die_info
*die
,
1129 struct dwarf2_cu
*cu
);
1131 static struct die_info
*dwarf2_extension (struct die_info
*die
,
1132 struct dwarf2_cu
**);
1134 static char *dwarf_tag_name (unsigned int);
1136 static char *dwarf_attr_name (unsigned int);
1138 static char *dwarf_form_name (unsigned int);
1140 static char *dwarf_bool_name (unsigned int);
1142 static char *dwarf_type_encoding_name (unsigned int);
1145 static char *dwarf_cfi_name (unsigned int);
1148 static struct die_info
*sibling_die (struct die_info
*);
1150 static void dump_die_shallow (struct ui_file
*, int indent
, struct die_info
*);
1152 static void dump_die_for_error (struct die_info
*);
1154 static void dump_die_1 (struct ui_file
*, int level
, int max_level
,
1157 /*static*/ void dump_die (struct die_info
*, int max_level
);
1159 static void store_in_ref_table (struct die_info
*,
1160 struct dwarf2_cu
*);
1162 static int is_ref_attr (struct attribute
*);
1164 static unsigned int dwarf2_get_ref_die_offset (struct attribute
*);
1166 static LONGEST
dwarf2_get_attr_constant_value (struct attribute
*, int);
1168 static struct die_info
*follow_die_ref_or_sig (struct die_info
*,
1170 struct dwarf2_cu
**);
1172 static struct die_info
*follow_die_ref (struct die_info
*,
1174 struct dwarf2_cu
**);
1176 static struct die_info
*follow_die_sig (struct die_info
*,
1178 struct dwarf2_cu
**);
1180 static struct signatured_type
*lookup_signatured_type_at_offset
1181 (struct objfile
*objfile
,
1182 struct dwarf2_section_info
*section
,
1183 unsigned int offset
);
1185 static void load_full_type_unit (struct dwarf2_per_cu_data
*per_cu
);
1187 static void read_signatured_type (struct signatured_type
*type_sig
);
1189 /* memory allocation interface */
1191 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1193 static struct abbrev_info
*dwarf_alloc_abbrev (struct dwarf2_cu
*);
1195 static struct die_info
*dwarf_alloc_die (struct dwarf2_cu
*, int);
1197 static void dwarf_decode_macros (struct line_header
*, unsigned int,
1198 char *, bfd
*, struct dwarf2_cu
*,
1199 struct dwarf2_section_info
*,
1202 static int attr_form_is_block (struct attribute
*);
1204 static int attr_form_is_section_offset (struct attribute
*);
1206 static int attr_form_is_constant (struct attribute
*);
1208 static void fill_in_loclist_baton (struct dwarf2_cu
*cu
,
1209 struct dwarf2_loclist_baton
*baton
,
1210 struct attribute
*attr
);
1212 static void dwarf2_symbol_mark_computed (struct attribute
*attr
,
1214 struct dwarf2_cu
*cu
);
1216 static gdb_byte
*skip_one_die (gdb_byte
*buffer
, gdb_byte
*info_ptr
,
1217 struct abbrev_info
*abbrev
,
1218 struct dwarf2_cu
*cu
);
1220 static void free_stack_comp_unit (void *);
1222 static hashval_t
partial_die_hash (const void *item
);
1224 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1226 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1227 (unsigned int offset
, struct objfile
*objfile
);
1229 static void init_one_comp_unit (struct dwarf2_cu
*cu
,
1230 struct dwarf2_per_cu_data
*per_cu
);
1232 static void prepare_one_comp_unit (struct dwarf2_cu
*cu
,
1233 struct die_info
*comp_unit_die
);
1235 static void free_heap_comp_unit (void *);
1237 static void free_cached_comp_units (void *);
1239 static void age_cached_comp_units (void);
1241 static void free_one_cached_comp_unit (void *);
1243 static struct type
*set_die_type (struct die_info
*, struct type
*,
1244 struct dwarf2_cu
*);
1246 static void create_all_comp_units (struct objfile
*);
1248 static int create_debug_types_hash_table (struct objfile
*objfile
);
1250 static void load_full_comp_unit (struct dwarf2_per_cu_data
*);
1252 static void process_full_comp_unit (struct dwarf2_per_cu_data
*);
1254 static void dwarf2_add_dependence (struct dwarf2_cu
*,
1255 struct dwarf2_per_cu_data
*);
1257 static void dwarf2_mark (struct dwarf2_cu
*);
1259 static void dwarf2_clear_marks (struct dwarf2_per_cu_data
*);
1261 static struct type
*get_die_type_at_offset (unsigned int,
1262 struct dwarf2_per_cu_data
*per_cu
);
1264 static struct type
*get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
1266 static void dwarf2_release_queue (void *dummy
);
1268 static void queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
);
1270 static void process_queue (void);
1272 static void find_file_and_directory (struct die_info
*die
,
1273 struct dwarf2_cu
*cu
,
1274 char **name
, char **comp_dir
);
1276 static char *file_full_name (int file
, struct line_header
*lh
,
1277 const char *comp_dir
);
1279 static gdb_byte
*read_and_check_comp_unit_head
1280 (struct comp_unit_head
*header
,
1281 struct dwarf2_section_info
*section
, gdb_byte
*info_ptr
,
1282 int is_debug_types_section
);
1284 static void init_cu_die_reader (struct die_reader_specs
*reader
,
1285 struct dwarf2_cu
*cu
);
1287 static htab_t
allocate_signatured_type_table (struct objfile
*objfile
);
1291 /* Convert VALUE between big- and little-endian. */
1293 byte_swap (offset_type value
)
1297 result
= (value
& 0xff) << 24;
1298 result
|= (value
& 0xff00) << 8;
1299 result
|= (value
& 0xff0000) >> 8;
1300 result
|= (value
& 0xff000000) >> 24;
1304 #define MAYBE_SWAP(V) byte_swap (V)
1307 #define MAYBE_SWAP(V) (V)
1308 #endif /* WORDS_BIGENDIAN */
1310 /* The suffix for an index file. */
1311 #define INDEX_SUFFIX ".gdb-index"
1313 static const char *dwarf2_physname (char *name
, struct die_info
*die
,
1314 struct dwarf2_cu
*cu
);
1316 /* Try to locate the sections we need for DWARF 2 debugging
1317 information and return true if we have enough to do something.
1318 NAMES points to the dwarf2 section names, or is NULL if the standard
1319 ELF names are used. */
1322 dwarf2_has_info (struct objfile
*objfile
,
1323 const struct dwarf2_debug_sections
*names
)
1325 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
1326 if (!dwarf2_per_objfile
)
1328 /* Initialize per-objfile state. */
1329 struct dwarf2_per_objfile
*data
1330 = obstack_alloc (&objfile
->objfile_obstack
, sizeof (*data
));
1332 memset (data
, 0, sizeof (*data
));
1333 set_objfile_data (objfile
, dwarf2_objfile_data_key
, data
);
1334 dwarf2_per_objfile
= data
;
1336 bfd_map_over_sections (objfile
->obfd
, dwarf2_locate_sections
,
1338 dwarf2_per_objfile
->objfile
= objfile
;
1340 return (dwarf2_per_objfile
->info
.asection
!= NULL
1341 && dwarf2_per_objfile
->abbrev
.asection
!= NULL
);
1344 /* When loading sections, we look either for uncompressed section or for
1345 compressed section names. */
1348 section_is_p (const char *section_name
,
1349 const struct dwarf2_section_names
*names
)
1351 if (names
->normal
!= NULL
1352 && strcmp (section_name
, names
->normal
) == 0)
1354 if (names
->compressed
!= NULL
1355 && strcmp (section_name
, names
->compressed
) == 0)
1360 /* This function is mapped across the sections and remembers the
1361 offset and size of each of the debugging sections we are interested
1365 dwarf2_locate_sections (bfd
*abfd
, asection
*sectp
, void *vnames
)
1367 const struct dwarf2_debug_sections
*names
;
1370 names
= &dwarf2_elf_names
;
1372 names
= (const struct dwarf2_debug_sections
*) vnames
;
1374 if (section_is_p (sectp
->name
, &names
->info
))
1376 dwarf2_per_objfile
->info
.asection
= sectp
;
1377 dwarf2_per_objfile
->info
.size
= bfd_get_section_size (sectp
);
1379 else if (section_is_p (sectp
->name
, &names
->abbrev
))
1381 dwarf2_per_objfile
->abbrev
.asection
= sectp
;
1382 dwarf2_per_objfile
->abbrev
.size
= bfd_get_section_size (sectp
);
1384 else if (section_is_p (sectp
->name
, &names
->line
))
1386 dwarf2_per_objfile
->line
.asection
= sectp
;
1387 dwarf2_per_objfile
->line
.size
= bfd_get_section_size (sectp
);
1389 else if (section_is_p (sectp
->name
, &names
->loc
))
1391 dwarf2_per_objfile
->loc
.asection
= sectp
;
1392 dwarf2_per_objfile
->loc
.size
= bfd_get_section_size (sectp
);
1394 else if (section_is_p (sectp
->name
, &names
->macinfo
))
1396 dwarf2_per_objfile
->macinfo
.asection
= sectp
;
1397 dwarf2_per_objfile
->macinfo
.size
= bfd_get_section_size (sectp
);
1399 else if (section_is_p (sectp
->name
, &names
->macro
))
1401 dwarf2_per_objfile
->macro
.asection
= sectp
;
1402 dwarf2_per_objfile
->macro
.size
= bfd_get_section_size (sectp
);
1404 else if (section_is_p (sectp
->name
, &names
->str
))
1406 dwarf2_per_objfile
->str
.asection
= sectp
;
1407 dwarf2_per_objfile
->str
.size
= bfd_get_section_size (sectp
);
1409 else if (section_is_p (sectp
->name
, &names
->frame
))
1411 dwarf2_per_objfile
->frame
.asection
= sectp
;
1412 dwarf2_per_objfile
->frame
.size
= bfd_get_section_size (sectp
);
1414 else if (section_is_p (sectp
->name
, &names
->eh_frame
))
1416 flagword aflag
= bfd_get_section_flags (ignore_abfd
, sectp
);
1418 if (aflag
& SEC_HAS_CONTENTS
)
1420 dwarf2_per_objfile
->eh_frame
.asection
= sectp
;
1421 dwarf2_per_objfile
->eh_frame
.size
= bfd_get_section_size (sectp
);
1424 else if (section_is_p (sectp
->name
, &names
->ranges
))
1426 dwarf2_per_objfile
->ranges
.asection
= sectp
;
1427 dwarf2_per_objfile
->ranges
.size
= bfd_get_section_size (sectp
);
1429 else if (section_is_p (sectp
->name
, &names
->types
))
1431 struct dwarf2_section_info type_section
;
1433 memset (&type_section
, 0, sizeof (type_section
));
1434 type_section
.asection
= sectp
;
1435 type_section
.size
= bfd_get_section_size (sectp
);
1437 VEC_safe_push (dwarf2_section_info_def
, dwarf2_per_objfile
->types
,
1440 else if (section_is_p (sectp
->name
, &names
->gdb_index
))
1442 dwarf2_per_objfile
->gdb_index
.asection
= sectp
;
1443 dwarf2_per_objfile
->gdb_index
.size
= bfd_get_section_size (sectp
);
1446 if ((bfd_get_section_flags (abfd
, sectp
) & SEC_LOAD
)
1447 && bfd_section_vma (abfd
, sectp
) == 0)
1448 dwarf2_per_objfile
->has_section_at_zero
= 1;
1451 /* Decompress a section that was compressed using zlib. Store the
1452 decompressed buffer, and its size, in OUTBUF and OUTSIZE. */
1455 zlib_decompress_section (struct objfile
*objfile
, asection
*sectp
,
1456 gdb_byte
**outbuf
, bfd_size_type
*outsize
)
1458 bfd
*abfd
= objfile
->obfd
;
1460 error (_("Support for zlib-compressed DWARF data (from '%s') "
1461 "is disabled in this copy of GDB"),
1462 bfd_get_filename (abfd
));
1464 bfd_size_type compressed_size
= bfd_get_section_size (sectp
);
1465 gdb_byte
*compressed_buffer
= xmalloc (compressed_size
);
1466 struct cleanup
*cleanup
= make_cleanup (xfree
, compressed_buffer
);
1467 bfd_size_type uncompressed_size
;
1468 gdb_byte
*uncompressed_buffer
;
1471 int header_size
= 12;
1473 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
1474 || bfd_bread (compressed_buffer
,
1475 compressed_size
, abfd
) != compressed_size
)
1476 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
1477 bfd_get_filename (abfd
));
1479 /* Read the zlib header. In this case, it should be "ZLIB" followed
1480 by the uncompressed section size, 8 bytes in big-endian order. */
1481 if (compressed_size
< header_size
1482 || strncmp (compressed_buffer
, "ZLIB", 4) != 0)
1483 error (_("Dwarf Error: Corrupt DWARF ZLIB header from '%s'"),
1484 bfd_get_filename (abfd
));
1485 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
1486 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
1487 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
1488 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
1489 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
1490 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
1491 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
1492 uncompressed_size
+= compressed_buffer
[11];
1494 /* It is possible the section consists of several compressed
1495 buffers concatenated together, so we uncompress in a loop. */
1499 strm
.avail_in
= compressed_size
- header_size
;
1500 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
1501 strm
.avail_out
= uncompressed_size
;
1502 uncompressed_buffer
= obstack_alloc (&objfile
->objfile_obstack
,
1504 rc
= inflateInit (&strm
);
1505 while (strm
.avail_in
> 0)
1508 error (_("Dwarf Error: setting up DWARF uncompression in '%s': %d"),
1509 bfd_get_filename (abfd
), rc
);
1510 strm
.next_out
= ((Bytef
*) uncompressed_buffer
1511 + (uncompressed_size
- strm
.avail_out
));
1512 rc
= inflate (&strm
, Z_FINISH
);
1513 if (rc
!= Z_STREAM_END
)
1514 error (_("Dwarf Error: zlib error uncompressing from '%s': %d"),
1515 bfd_get_filename (abfd
), rc
);
1516 rc
= inflateReset (&strm
);
1518 rc
= inflateEnd (&strm
);
1520 || strm
.avail_out
!= 0)
1521 error (_("Dwarf Error: concluding DWARF uncompression in '%s': %d"),
1522 bfd_get_filename (abfd
), rc
);
1524 do_cleanups (cleanup
);
1525 *outbuf
= uncompressed_buffer
;
1526 *outsize
= uncompressed_size
;
1530 /* A helper function that decides whether a section is empty. */
1533 dwarf2_section_empty_p (struct dwarf2_section_info
*info
)
1535 return info
->asection
== NULL
|| info
->size
== 0;
1538 /* Read the contents of the section INFO from object file specified by
1539 OBJFILE, store info about the section into INFO.
1540 If the section is compressed, uncompress it before returning. */
1543 dwarf2_read_section (struct objfile
*objfile
, struct dwarf2_section_info
*info
)
1545 bfd
*abfd
= objfile
->obfd
;
1546 asection
*sectp
= info
->asection
;
1547 gdb_byte
*buf
, *retbuf
;
1548 unsigned char header
[4];
1552 info
->buffer
= NULL
;
1553 info
->map_addr
= NULL
;
1556 if (dwarf2_section_empty_p (info
))
1559 /* Check if the file has a 4-byte header indicating compression. */
1560 if (info
->size
> sizeof (header
)
1561 && bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) == 0
1562 && bfd_bread (header
, sizeof (header
), abfd
) == sizeof (header
))
1564 /* Upon decompression, update the buffer and its size. */
1565 if (strncmp (header
, "ZLIB", sizeof (header
)) == 0)
1567 zlib_decompress_section (objfile
, sectp
, &info
->buffer
,
1575 pagesize
= getpagesize ();
1577 /* Only try to mmap sections which are large enough: we don't want to
1578 waste space due to fragmentation. Also, only try mmap for sections
1579 without relocations. */
1581 if (info
->size
> 4 * pagesize
&& (sectp
->flags
& SEC_RELOC
) == 0)
1583 info
->buffer
= bfd_mmap (abfd
, 0, info
->size
, PROT_READ
,
1584 MAP_PRIVATE
, sectp
->filepos
,
1585 &info
->map_addr
, &info
->map_len
);
1587 if ((caddr_t
)info
->buffer
!= MAP_FAILED
)
1589 #if HAVE_POSIX_MADVISE
1590 posix_madvise (info
->map_addr
, info
->map_len
, POSIX_MADV_WILLNEED
);
1597 /* If we get here, we are a normal, not-compressed section. */
1599 = obstack_alloc (&objfile
->objfile_obstack
, info
->size
);
1601 /* When debugging .o files, we may need to apply relocations; see
1602 http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
1603 We never compress sections in .o files, so we only need to
1604 try this when the section is not compressed. */
1605 retbuf
= symfile_relocate_debug_section (objfile
, sectp
, buf
);
1608 info
->buffer
= retbuf
;
1612 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
1613 || bfd_bread (buf
, info
->size
, abfd
) != info
->size
)
1614 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
1615 bfd_get_filename (abfd
));
1618 /* A helper function that returns the size of a section in a safe way.
1619 If you are positive that the section has been read before using the
1620 size, then it is safe to refer to the dwarf2_section_info object's
1621 "size" field directly. In other cases, you must call this
1622 function, because for compressed sections the size field is not set
1623 correctly until the section has been read. */
1625 static bfd_size_type
1626 dwarf2_section_size (struct objfile
*objfile
,
1627 struct dwarf2_section_info
*info
)
1630 dwarf2_read_section (objfile
, info
);
1634 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
1638 dwarf2_get_section_info (struct objfile
*objfile
,
1639 enum dwarf2_section_enum sect
,
1640 asection
**sectp
, gdb_byte
**bufp
,
1641 bfd_size_type
*sizep
)
1643 struct dwarf2_per_objfile
*data
1644 = objfile_data (objfile
, dwarf2_objfile_data_key
);
1645 struct dwarf2_section_info
*info
;
1647 /* We may see an objfile without any DWARF, in which case we just
1658 case DWARF2_DEBUG_FRAME
:
1659 info
= &data
->frame
;
1661 case DWARF2_EH_FRAME
:
1662 info
= &data
->eh_frame
;
1665 gdb_assert_not_reached ("unexpected section");
1668 dwarf2_read_section (objfile
, info
);
1670 *sectp
= info
->asection
;
1671 *bufp
= info
->buffer
;
1672 *sizep
= info
->size
;
1676 /* DWARF quick_symbols_functions support. */
1678 /* TUs can share .debug_line entries, and there can be a lot more TUs than
1679 unique line tables, so we maintain a separate table of all .debug_line
1680 derived entries to support the sharing.
1681 All the quick functions need is the list of file names. We discard the
1682 line_header when we're done and don't need to record it here. */
1683 struct quick_file_names
1685 /* The offset in .debug_line of the line table. We hash on this. */
1686 unsigned int offset
;
1688 /* The number of entries in file_names, real_names. */
1689 unsigned int num_file_names
;
1691 /* The file names from the line table, after being run through
1693 const char **file_names
;
1695 /* The file names from the line table after being run through
1696 gdb_realpath. These are computed lazily. */
1697 const char **real_names
;
1700 /* When using the index (and thus not using psymtabs), each CU has an
1701 object of this type. This is used to hold information needed by
1702 the various "quick" methods. */
1703 struct dwarf2_per_cu_quick_data
1705 /* The file table. This can be NULL if there was no file table
1706 or it's currently not read in.
1707 NOTE: This points into dwarf2_per_objfile->quick_file_names_table. */
1708 struct quick_file_names
*file_names
;
1710 /* The corresponding symbol table. This is NULL if symbols for this
1711 CU have not yet been read. */
1712 struct symtab
*symtab
;
1714 /* A temporary mark bit used when iterating over all CUs in
1715 expand_symtabs_matching. */
1716 unsigned int mark
: 1;
1718 /* True if we've tried to read the file table and found there isn't one.
1719 There will be no point in trying to read it again next time. */
1720 unsigned int no_file_data
: 1;
1723 /* Hash function for a quick_file_names. */
1726 hash_file_name_entry (const void *e
)
1728 const struct quick_file_names
*file_data
= e
;
1730 return file_data
->offset
;
1733 /* Equality function for a quick_file_names. */
1736 eq_file_name_entry (const void *a
, const void *b
)
1738 const struct quick_file_names
*ea
= a
;
1739 const struct quick_file_names
*eb
= b
;
1741 return ea
->offset
== eb
->offset
;
1744 /* Delete function for a quick_file_names. */
1747 delete_file_name_entry (void *e
)
1749 struct quick_file_names
*file_data
= e
;
1752 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
1754 xfree ((void*) file_data
->file_names
[i
]);
1755 if (file_data
->real_names
)
1756 xfree ((void*) file_data
->real_names
[i
]);
1759 /* The space for the struct itself lives on objfile_obstack,
1760 so we don't free it here. */
1763 /* Create a quick_file_names hash table. */
1766 create_quick_file_names_table (unsigned int nr_initial_entries
)
1768 return htab_create_alloc (nr_initial_entries
,
1769 hash_file_name_entry
, eq_file_name_entry
,
1770 delete_file_name_entry
, xcalloc
, xfree
);
1773 /* Read in PER_CU->CU. This function is unrelated to symtabs, symtab would
1774 have to be created afterwards. You should call age_cached_comp_units after
1775 processing PER_CU->CU. dw2_setup must have been already called. */
1778 load_cu (struct dwarf2_per_cu_data
*per_cu
)
1780 if (per_cu
->debug_types_section
)
1781 load_full_type_unit (per_cu
);
1783 load_full_comp_unit (per_cu
);
1785 gdb_assert (per_cu
->cu
!= NULL
);
1787 dwarf2_find_base_address (per_cu
->cu
->dies
, per_cu
->cu
);
1790 /* Read in the symbols for PER_CU. */
1793 dw2_do_instantiate_symtab (struct dwarf2_per_cu_data
*per_cu
)
1795 struct cleanup
*back_to
;
1797 back_to
= make_cleanup (dwarf2_release_queue
, NULL
);
1799 queue_comp_unit (per_cu
);
1805 /* Age the cache, releasing compilation units that have not
1806 been used recently. */
1807 age_cached_comp_units ();
1809 do_cleanups (back_to
);
1812 /* Ensure that the symbols for PER_CU have been read in. OBJFILE is
1813 the objfile from which this CU came. Returns the resulting symbol
1816 static struct symtab
*
1817 dw2_instantiate_symtab (struct dwarf2_per_cu_data
*per_cu
)
1819 if (!per_cu
->v
.quick
->symtab
)
1821 struct cleanup
*back_to
= make_cleanup (free_cached_comp_units
, NULL
);
1822 increment_reading_symtab ();
1823 dw2_do_instantiate_symtab (per_cu
);
1824 do_cleanups (back_to
);
1826 return per_cu
->v
.quick
->symtab
;
1829 /* Return the CU given its index. */
1831 static struct dwarf2_per_cu_data
*
1832 dw2_get_cu (int index
)
1834 if (index
>= dwarf2_per_objfile
->n_comp_units
)
1836 index
-= dwarf2_per_objfile
->n_comp_units
;
1837 return dwarf2_per_objfile
->all_type_units
[index
];
1839 return dwarf2_per_objfile
->all_comp_units
[index
];
1842 /* A helper function that knows how to read a 64-bit value in a way
1843 that doesn't make gdb die. Returns 1 if the conversion went ok, 0
1847 extract_cu_value (const char *bytes
, ULONGEST
*result
)
1849 if (sizeof (ULONGEST
) < 8)
1853 /* Ignore the upper 4 bytes if they are all zero. */
1854 for (i
= 0; i
< 4; ++i
)
1855 if (bytes
[i
+ 4] != 0)
1858 *result
= extract_unsigned_integer (bytes
, 4, BFD_ENDIAN_LITTLE
);
1861 *result
= extract_unsigned_integer (bytes
, 8, BFD_ENDIAN_LITTLE
);
1865 /* Read the CU list from the mapped index, and use it to create all
1866 the CU objects for this objfile. Return 0 if something went wrong,
1867 1 if everything went ok. */
1870 create_cus_from_index (struct objfile
*objfile
, const gdb_byte
*cu_list
,
1871 offset_type cu_list_elements
)
1875 dwarf2_per_objfile
->n_comp_units
= cu_list_elements
/ 2;
1876 dwarf2_per_objfile
->all_comp_units
1877 = obstack_alloc (&objfile
->objfile_obstack
,
1878 dwarf2_per_objfile
->n_comp_units
1879 * sizeof (struct dwarf2_per_cu_data
*));
1881 for (i
= 0; i
< cu_list_elements
; i
+= 2)
1883 struct dwarf2_per_cu_data
*the_cu
;
1884 ULONGEST offset
, length
;
1886 if (!extract_cu_value (cu_list
, &offset
)
1887 || !extract_cu_value (cu_list
+ 8, &length
))
1891 the_cu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
1892 struct dwarf2_per_cu_data
);
1893 the_cu
->offset
= offset
;
1894 the_cu
->length
= length
;
1895 the_cu
->objfile
= objfile
;
1896 the_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
1897 struct dwarf2_per_cu_quick_data
);
1898 dwarf2_per_objfile
->all_comp_units
[i
/ 2] = the_cu
;
1904 /* Create the signatured type hash table from the index. */
1907 create_signatured_type_table_from_index (struct objfile
*objfile
,
1908 struct dwarf2_section_info
*section
,
1909 const gdb_byte
*bytes
,
1910 offset_type elements
)
1913 htab_t sig_types_hash
;
1915 dwarf2_per_objfile
->n_type_units
= elements
/ 3;
1916 dwarf2_per_objfile
->all_type_units
1917 = obstack_alloc (&objfile
->objfile_obstack
,
1918 dwarf2_per_objfile
->n_type_units
1919 * sizeof (struct dwarf2_per_cu_data
*));
1921 sig_types_hash
= allocate_signatured_type_table (objfile
);
1923 for (i
= 0; i
< elements
; i
+= 3)
1925 struct signatured_type
*type_sig
;
1926 ULONGEST offset
, type_offset
, signature
;
1929 if (!extract_cu_value (bytes
, &offset
)
1930 || !extract_cu_value (bytes
+ 8, &type_offset
))
1932 signature
= extract_unsigned_integer (bytes
+ 16, 8, BFD_ENDIAN_LITTLE
);
1935 type_sig
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
1936 struct signatured_type
);
1937 type_sig
->signature
= signature
;
1938 type_sig
->type_offset
= type_offset
;
1939 type_sig
->per_cu
.debug_types_section
= section
;
1940 type_sig
->per_cu
.offset
= offset
;
1941 type_sig
->per_cu
.objfile
= objfile
;
1942 type_sig
->per_cu
.v
.quick
1943 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
1944 struct dwarf2_per_cu_quick_data
);
1946 slot
= htab_find_slot (sig_types_hash
, type_sig
, INSERT
);
1949 dwarf2_per_objfile
->all_type_units
[i
/ 3] = &type_sig
->per_cu
;
1952 dwarf2_per_objfile
->signatured_types
= sig_types_hash
;
1957 /* Read the address map data from the mapped index, and use it to
1958 populate the objfile's psymtabs_addrmap. */
1961 create_addrmap_from_index (struct objfile
*objfile
, struct mapped_index
*index
)
1963 const gdb_byte
*iter
, *end
;
1964 struct obstack temp_obstack
;
1965 struct addrmap
*mutable_map
;
1966 struct cleanup
*cleanup
;
1969 obstack_init (&temp_obstack
);
1970 cleanup
= make_cleanup_obstack_free (&temp_obstack
);
1971 mutable_map
= addrmap_create_mutable (&temp_obstack
);
1973 iter
= index
->address_table
;
1974 end
= iter
+ index
->address_table_size
;
1976 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1980 ULONGEST hi
, lo
, cu_index
;
1981 lo
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
1983 hi
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
1985 cu_index
= extract_unsigned_integer (iter
, 4, BFD_ENDIAN_LITTLE
);
1988 addrmap_set_empty (mutable_map
, lo
+ baseaddr
, hi
+ baseaddr
- 1,
1989 dw2_get_cu (cu_index
));
1992 objfile
->psymtabs_addrmap
= addrmap_create_fixed (mutable_map
,
1993 &objfile
->objfile_obstack
);
1994 do_cleanups (cleanup
);
1997 /* The hash function for strings in the mapped index. This is the same as
1998 SYMBOL_HASH_NEXT, but we keep a separate copy to maintain control over the
1999 implementation. This is necessary because the hash function is tied to the
2000 format of the mapped index file. The hash values do not have to match with
2003 Use INT_MAX for INDEX_VERSION if you generate the current index format. */
2006 mapped_index_string_hash (int index_version
, const void *p
)
2008 const unsigned char *str
= (const unsigned char *) p
;
2012 while ((c
= *str
++) != 0)
2014 if (index_version
>= 5)
2016 r
= r
* 67 + c
- 113;
2022 /* Find a slot in the mapped index INDEX for the object named NAME.
2023 If NAME is found, set *VEC_OUT to point to the CU vector in the
2024 constant pool and return 1. If NAME cannot be found, return 0. */
2027 find_slot_in_mapped_hash (struct mapped_index
*index
, const char *name
,
2028 offset_type
**vec_out
)
2030 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
2032 offset_type slot
, step
;
2033 int (*cmp
) (const char *, const char *);
2035 if (current_language
->la_language
== language_cplus
2036 || current_language
->la_language
== language_java
2037 || current_language
->la_language
== language_fortran
)
2039 /* NAME is already canonical. Drop any qualifiers as .gdb_index does
2041 const char *paren
= strchr (name
, '(');
2047 dup
= xmalloc (paren
- name
+ 1);
2048 memcpy (dup
, name
, paren
- name
);
2049 dup
[paren
- name
] = 0;
2051 make_cleanup (xfree
, dup
);
2056 /* Index version 4 did not support case insensitive searches. But the
2057 indexes for case insensitive languages are built in lowercase, therefore
2058 simulate our NAME being searched is also lowercased. */
2059 hash
= mapped_index_string_hash ((index
->version
== 4
2060 && case_sensitivity
== case_sensitive_off
2061 ? 5 : index
->version
),
2064 slot
= hash
& (index
->symbol_table_slots
- 1);
2065 step
= ((hash
* 17) & (index
->symbol_table_slots
- 1)) | 1;
2066 cmp
= (case_sensitivity
== case_sensitive_on
? strcmp
: strcasecmp
);
2070 /* Convert a slot number to an offset into the table. */
2071 offset_type i
= 2 * slot
;
2073 if (index
->symbol_table
[i
] == 0 && index
->symbol_table
[i
+ 1] == 0)
2075 do_cleanups (back_to
);
2079 str
= index
->constant_pool
+ MAYBE_SWAP (index
->symbol_table
[i
]);
2080 if (!cmp (name
, str
))
2082 *vec_out
= (offset_type
*) (index
->constant_pool
2083 + MAYBE_SWAP (index
->symbol_table
[i
+ 1]));
2084 do_cleanups (back_to
);
2088 slot
= (slot
+ step
) & (index
->symbol_table_slots
- 1);
2092 /* Read the index file. If everything went ok, initialize the "quick"
2093 elements of all the CUs and return 1. Otherwise, return 0. */
2096 dwarf2_read_index (struct objfile
*objfile
)
2099 struct mapped_index
*map
;
2100 offset_type
*metadata
;
2101 const gdb_byte
*cu_list
;
2102 const gdb_byte
*types_list
= NULL
;
2103 offset_type version
, cu_list_elements
;
2104 offset_type types_list_elements
= 0;
2107 if (dwarf2_section_empty_p (&dwarf2_per_objfile
->gdb_index
))
2110 /* Older elfutils strip versions could keep the section in the main
2111 executable while splitting it for the separate debug info file. */
2112 if ((bfd_get_file_flags (dwarf2_per_objfile
->gdb_index
.asection
)
2113 & SEC_HAS_CONTENTS
) == 0)
2116 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->gdb_index
);
2118 addr
= dwarf2_per_objfile
->gdb_index
.buffer
;
2119 /* Version check. */
2120 version
= MAYBE_SWAP (*(offset_type
*) addr
);
2121 /* Versions earlier than 3 emitted every copy of a psymbol. This
2122 causes the index to behave very poorly for certain requests. Version 3
2123 contained incomplete addrmap. So, it seems better to just ignore such
2124 indices. Index version 4 uses a different hash function than index
2125 version 5 and later. */
2128 /* Indexes with higher version than the one supported by GDB may be no
2129 longer backward compatible. */
2133 map
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct mapped_index
);
2134 map
->version
= version
;
2135 map
->total_size
= dwarf2_per_objfile
->gdb_index
.size
;
2137 metadata
= (offset_type
*) (addr
+ sizeof (offset_type
));
2140 cu_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
2141 cu_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1]) - MAYBE_SWAP (metadata
[i
]))
2145 types_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
2146 types_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1])
2147 - MAYBE_SWAP (metadata
[i
]))
2151 map
->address_table
= addr
+ MAYBE_SWAP (metadata
[i
]);
2152 map
->address_table_size
= (MAYBE_SWAP (metadata
[i
+ 1])
2153 - MAYBE_SWAP (metadata
[i
]));
2156 map
->symbol_table
= (offset_type
*) (addr
+ MAYBE_SWAP (metadata
[i
]));
2157 map
->symbol_table_slots
= ((MAYBE_SWAP (metadata
[i
+ 1])
2158 - MAYBE_SWAP (metadata
[i
]))
2159 / (2 * sizeof (offset_type
)));
2162 map
->constant_pool
= addr
+ MAYBE_SWAP (metadata
[i
]);
2164 if (!create_cus_from_index (objfile
, cu_list
, cu_list_elements
))
2167 if (types_list_elements
)
2169 struct dwarf2_section_info
*section
;
2171 /* We can only handle a single .debug_types when we have an
2173 if (VEC_length (dwarf2_section_info_def
, dwarf2_per_objfile
->types
) != 1)
2176 section
= VEC_index (dwarf2_section_info_def
,
2177 dwarf2_per_objfile
->types
, 0);
2179 if (!create_signatured_type_table_from_index (objfile
, section
,
2181 types_list_elements
))
2185 create_addrmap_from_index (objfile
, map
);
2187 dwarf2_per_objfile
->index_table
= map
;
2188 dwarf2_per_objfile
->using_index
= 1;
2189 dwarf2_per_objfile
->quick_file_names_table
=
2190 create_quick_file_names_table (dwarf2_per_objfile
->n_comp_units
);
2195 /* A helper for the "quick" functions which sets the global
2196 dwarf2_per_objfile according to OBJFILE. */
2199 dw2_setup (struct objfile
*objfile
)
2201 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
2202 gdb_assert (dwarf2_per_objfile
);
2205 /* A helper for the "quick" functions which attempts to read the line
2206 table for THIS_CU. */
2208 static struct quick_file_names
*
2209 dw2_get_file_names (struct objfile
*objfile
,
2210 struct dwarf2_per_cu_data
*this_cu
)
2212 bfd
*abfd
= objfile
->obfd
;
2213 struct line_header
*lh
;
2214 struct attribute
*attr
;
2215 struct cleanup
*cleanups
;
2216 struct die_info
*comp_unit_die
;
2217 struct dwarf2_section_info
* sec
;
2219 int has_children
, i
;
2220 struct dwarf2_cu cu
;
2221 unsigned int bytes_read
;
2222 struct die_reader_specs reader_specs
;
2223 char *name
, *comp_dir
;
2225 struct quick_file_names
*qfn
;
2226 unsigned int line_offset
;
2228 if (this_cu
->v
.quick
->file_names
!= NULL
)
2229 return this_cu
->v
.quick
->file_names
;
2230 /* If we know there is no line data, no point in looking again. */
2231 if (this_cu
->v
.quick
->no_file_data
)
2234 init_one_comp_unit (&cu
, this_cu
);
2235 cleanups
= make_cleanup (free_stack_comp_unit
, &cu
);
2237 if (this_cu
->debug_types_section
)
2238 sec
= this_cu
->debug_types_section
;
2240 sec
= &dwarf2_per_objfile
->info
;
2241 dwarf2_read_section (objfile
, sec
);
2242 info_ptr
= sec
->buffer
+ this_cu
->offset
;
2244 info_ptr
= read_and_check_comp_unit_head (&cu
.header
, sec
, info_ptr
,
2245 this_cu
->debug_types_section
!= NULL
);
2247 /* Skip dummy compilation units. */
2248 if (info_ptr
>= (sec
->buffer
+ sec
->size
)
2249 || peek_abbrev_code (abfd
, info_ptr
) == 0)
2251 do_cleanups (cleanups
);
2255 dwarf2_read_abbrevs (&cu
);
2256 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
2258 init_cu_die_reader (&reader_specs
, &cu
);
2259 read_full_die (&reader_specs
, &comp_unit_die
, info_ptr
,
2265 attr
= dwarf2_attr (comp_unit_die
, DW_AT_stmt_list
, &cu
);
2268 struct quick_file_names find_entry
;
2270 line_offset
= DW_UNSND (attr
);
2272 /* We may have already read in this line header (TU line header sharing).
2273 If we have we're done. */
2274 find_entry
.offset
= line_offset
;
2275 slot
= htab_find_slot (dwarf2_per_objfile
->quick_file_names_table
,
2276 &find_entry
, INSERT
);
2279 do_cleanups (cleanups
);
2280 this_cu
->v
.quick
->file_names
= *slot
;
2284 lh
= dwarf_decode_line_header (line_offset
, abfd
, &cu
);
2288 do_cleanups (cleanups
);
2289 this_cu
->v
.quick
->no_file_data
= 1;
2293 qfn
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*qfn
));
2294 qfn
->offset
= line_offset
;
2295 gdb_assert (slot
!= NULL
);
2298 find_file_and_directory (comp_unit_die
, &cu
, &name
, &comp_dir
);
2300 qfn
->num_file_names
= lh
->num_file_names
;
2301 qfn
->file_names
= obstack_alloc (&objfile
->objfile_obstack
,
2302 lh
->num_file_names
* sizeof (char *));
2303 for (i
= 0; i
< lh
->num_file_names
; ++i
)
2304 qfn
->file_names
[i
] = file_full_name (i
+ 1, lh
, comp_dir
);
2305 qfn
->real_names
= NULL
;
2307 free_line_header (lh
);
2308 do_cleanups (cleanups
);
2310 this_cu
->v
.quick
->file_names
= qfn
;
2314 /* A helper for the "quick" functions which computes and caches the
2315 real path for a given file name from the line table. */
2318 dw2_get_real_path (struct objfile
*objfile
,
2319 struct quick_file_names
*qfn
, int index
)
2321 if (qfn
->real_names
== NULL
)
2322 qfn
->real_names
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
2323 qfn
->num_file_names
, sizeof (char *));
2325 if (qfn
->real_names
[index
] == NULL
)
2326 qfn
->real_names
[index
] = gdb_realpath (qfn
->file_names
[index
]);
2328 return qfn
->real_names
[index
];
2331 static struct symtab
*
2332 dw2_find_last_source_symtab (struct objfile
*objfile
)
2336 dw2_setup (objfile
);
2337 index
= dwarf2_per_objfile
->n_comp_units
- 1;
2338 return dw2_instantiate_symtab (dw2_get_cu (index
));
2341 /* Traversal function for dw2_forget_cached_source_info. */
2344 dw2_free_cached_file_names (void **slot
, void *info
)
2346 struct quick_file_names
*file_data
= (struct quick_file_names
*) *slot
;
2348 if (file_data
->real_names
)
2352 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
2354 xfree ((void*) file_data
->real_names
[i
]);
2355 file_data
->real_names
[i
] = NULL
;
2363 dw2_forget_cached_source_info (struct objfile
*objfile
)
2365 dw2_setup (objfile
);
2367 htab_traverse_noresize (dwarf2_per_objfile
->quick_file_names_table
,
2368 dw2_free_cached_file_names
, NULL
);
2371 /* Helper function for dw2_map_symtabs_matching_filename that expands
2372 the symtabs and calls the iterator. */
2375 dw2_map_expand_apply (struct objfile
*objfile
,
2376 struct dwarf2_per_cu_data
*per_cu
,
2378 const char *full_path
, const char *real_path
,
2379 int (*callback
) (struct symtab
*, void *),
2382 struct symtab
*last_made
= objfile
->symtabs
;
2384 /* Don't visit already-expanded CUs. */
2385 if (per_cu
->v
.quick
->symtab
)
2388 /* This may expand more than one symtab, and we want to iterate over
2390 dw2_instantiate_symtab (per_cu
);
2392 return iterate_over_some_symtabs (name
, full_path
, real_path
, callback
, data
,
2393 objfile
->symtabs
, last_made
);
2396 /* Implementation of the map_symtabs_matching_filename method. */
2399 dw2_map_symtabs_matching_filename (struct objfile
*objfile
, const char *name
,
2400 const char *full_path
, const char *real_path
,
2401 int (*callback
) (struct symtab
*, void *),
2405 const char *name_basename
= lbasename (name
);
2406 int check_basename
= name_basename
== name
;
2407 struct dwarf2_per_cu_data
*base_cu
= NULL
;
2409 dw2_setup (objfile
);
2411 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2412 + dwarf2_per_objfile
->n_type_units
); ++i
)
2415 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2416 struct quick_file_names
*file_data
;
2418 /* We only need to look at symtabs not already expanded. */
2419 if (per_cu
->v
.quick
->symtab
)
2422 file_data
= dw2_get_file_names (objfile
, per_cu
);
2423 if (file_data
== NULL
)
2426 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
2428 const char *this_name
= file_data
->file_names
[j
];
2430 if (FILENAME_CMP (name
, this_name
) == 0)
2432 if (dw2_map_expand_apply (objfile
, per_cu
,
2433 name
, full_path
, real_path
,
2438 if (check_basename
&& ! base_cu
2439 && FILENAME_CMP (lbasename (this_name
), name
) == 0)
2442 /* Before we invoke realpath, which can get expensive when many
2443 files are involved, do a quick comparison of the basenames. */
2444 if (! basenames_may_differ
2445 && FILENAME_CMP (lbasename (this_name
), name_basename
) != 0)
2448 if (full_path
!= NULL
)
2450 const char *this_real_name
= dw2_get_real_path (objfile
,
2453 if (this_real_name
!= NULL
2454 && FILENAME_CMP (full_path
, this_real_name
) == 0)
2456 if (dw2_map_expand_apply (objfile
, per_cu
,
2457 name
, full_path
, real_path
,
2463 if (real_path
!= NULL
)
2465 const char *this_real_name
= dw2_get_real_path (objfile
,
2468 if (this_real_name
!= NULL
2469 && FILENAME_CMP (real_path
, this_real_name
) == 0)
2471 if (dw2_map_expand_apply (objfile
, per_cu
,
2472 name
, full_path
, real_path
,
2482 if (dw2_map_expand_apply (objfile
, base_cu
,
2483 name
, full_path
, real_path
,
2491 static struct symtab
*
2492 dw2_lookup_symbol (struct objfile
*objfile
, int block_index
,
2493 const char *name
, domain_enum domain
)
2495 /* We do all the work in the pre_expand_symtabs_matching hook
2500 /* A helper function that expands all symtabs that hold an object
2504 dw2_do_expand_symtabs_matching (struct objfile
*objfile
, const char *name
)
2506 dw2_setup (objfile
);
2508 /* index_table is NULL if OBJF_READNOW. */
2509 if (dwarf2_per_objfile
->index_table
)
2513 if (find_slot_in_mapped_hash (dwarf2_per_objfile
->index_table
,
2516 offset_type i
, len
= MAYBE_SWAP (*vec
);
2517 for (i
= 0; i
< len
; ++i
)
2519 offset_type cu_index
= MAYBE_SWAP (vec
[i
+ 1]);
2520 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (cu_index
);
2522 dw2_instantiate_symtab (per_cu
);
2529 dw2_pre_expand_symtabs_matching (struct objfile
*objfile
,
2530 enum block_enum block_kind
, const char *name
,
2533 dw2_do_expand_symtabs_matching (objfile
, name
);
2537 dw2_print_stats (struct objfile
*objfile
)
2541 dw2_setup (objfile
);
2543 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2544 + dwarf2_per_objfile
->n_type_units
); ++i
)
2546 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2548 if (!per_cu
->v
.quick
->symtab
)
2551 printf_filtered (_(" Number of unread CUs: %d\n"), count
);
2555 dw2_dump (struct objfile
*objfile
)
2557 /* Nothing worth printing. */
2561 dw2_relocate (struct objfile
*objfile
, struct section_offsets
*new_offsets
,
2562 struct section_offsets
*delta
)
2564 /* There's nothing to relocate here. */
2568 dw2_expand_symtabs_for_function (struct objfile
*objfile
,
2569 const char *func_name
)
2571 dw2_do_expand_symtabs_matching (objfile
, func_name
);
2575 dw2_expand_all_symtabs (struct objfile
*objfile
)
2579 dw2_setup (objfile
);
2581 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2582 + dwarf2_per_objfile
->n_type_units
); ++i
)
2584 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2586 dw2_instantiate_symtab (per_cu
);
2591 dw2_expand_symtabs_with_filename (struct objfile
*objfile
,
2592 const char *filename
)
2596 dw2_setup (objfile
);
2598 /* We don't need to consider type units here.
2599 This is only called for examining code, e.g. expand_line_sal.
2600 There can be an order of magnitude (or more) more type units
2601 than comp units, and we avoid them if we can. */
2603 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
2606 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2607 struct quick_file_names
*file_data
;
2609 /* We only need to look at symtabs not already expanded. */
2610 if (per_cu
->v
.quick
->symtab
)
2613 file_data
= dw2_get_file_names (objfile
, per_cu
);
2614 if (file_data
== NULL
)
2617 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
2619 const char *this_name
= file_data
->file_names
[j
];
2620 if (FILENAME_CMP (this_name
, filename
) == 0)
2622 dw2_instantiate_symtab (per_cu
);
2630 dw2_find_symbol_file (struct objfile
*objfile
, const char *name
)
2632 struct dwarf2_per_cu_data
*per_cu
;
2634 struct quick_file_names
*file_data
;
2636 dw2_setup (objfile
);
2638 /* index_table is NULL if OBJF_READNOW. */
2639 if (!dwarf2_per_objfile
->index_table
)
2643 ALL_OBJFILE_SYMTABS (objfile
, s
)
2646 struct blockvector
*bv
= BLOCKVECTOR (s
);
2647 const struct block
*block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
2648 struct symbol
*sym
= lookup_block_symbol (block
, name
, VAR_DOMAIN
);
2651 return sym
->symtab
->filename
;
2656 if (!find_slot_in_mapped_hash (dwarf2_per_objfile
->index_table
,
2660 /* Note that this just looks at the very first one named NAME -- but
2661 actually we are looking for a function. find_main_filename
2662 should be rewritten so that it doesn't require a custom hook. It
2663 could just use the ordinary symbol tables. */
2664 /* vec[0] is the length, which must always be >0. */
2665 per_cu
= dw2_get_cu (MAYBE_SWAP (vec
[1]));
2667 file_data
= dw2_get_file_names (objfile
, per_cu
);
2668 if (file_data
== NULL
)
2671 return file_data
->file_names
[file_data
->num_file_names
- 1];
2675 dw2_map_matching_symbols (const char * name
, domain_enum
namespace,
2676 struct objfile
*objfile
, int global
,
2677 int (*callback
) (struct block
*,
2678 struct symbol
*, void *),
2679 void *data
, symbol_compare_ftype
*match
,
2680 symbol_compare_ftype
*ordered_compare
)
2682 /* Currently unimplemented; used for Ada. The function can be called if the
2683 current language is Ada for a non-Ada objfile using GNU index. As Ada
2684 does not look for non-Ada symbols this function should just return. */
2688 dw2_expand_symtabs_matching
2689 (struct objfile
*objfile
,
2690 int (*file_matcher
) (const char *, void *),
2691 int (*name_matcher
) (const struct language_defn
*, const char *, void *),
2692 enum search_domain kind
,
2697 struct mapped_index
*index
;
2699 dw2_setup (objfile
);
2701 /* index_table is NULL if OBJF_READNOW. */
2702 if (!dwarf2_per_objfile
->index_table
)
2704 index
= dwarf2_per_objfile
->index_table
;
2706 if (file_matcher
!= NULL
)
2707 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2708 + dwarf2_per_objfile
->n_type_units
); ++i
)
2711 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2712 struct quick_file_names
*file_data
;
2714 per_cu
->v
.quick
->mark
= 0;
2716 /* We only need to look at symtabs not already expanded. */
2717 if (per_cu
->v
.quick
->symtab
)
2720 file_data
= dw2_get_file_names (objfile
, per_cu
);
2721 if (file_data
== NULL
)
2724 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
2726 if (file_matcher (file_data
->file_names
[j
], data
))
2728 per_cu
->v
.quick
->mark
= 1;
2734 for (iter
= 0; iter
< index
->symbol_table_slots
; ++iter
)
2736 offset_type idx
= 2 * iter
;
2738 offset_type
*vec
, vec_len
, vec_idx
;
2740 if (index
->symbol_table
[idx
] == 0 && index
->symbol_table
[idx
+ 1] == 0)
2743 name
= index
->constant_pool
+ MAYBE_SWAP (index
->symbol_table
[idx
]);
2745 if (! (*name_matcher
) (current_language
, name
, data
))
2748 /* The name was matched, now expand corresponding CUs that were
2750 vec
= (offset_type
*) (index
->constant_pool
2751 + MAYBE_SWAP (index
->symbol_table
[idx
+ 1]));
2752 vec_len
= MAYBE_SWAP (vec
[0]);
2753 for (vec_idx
= 0; vec_idx
< vec_len
; ++vec_idx
)
2755 struct dwarf2_per_cu_data
*per_cu
;
2757 per_cu
= dw2_get_cu (MAYBE_SWAP (vec
[vec_idx
+ 1]));
2758 if (file_matcher
== NULL
|| per_cu
->v
.quick
->mark
)
2759 dw2_instantiate_symtab (per_cu
);
2764 static struct symtab
*
2765 dw2_find_pc_sect_symtab (struct objfile
*objfile
,
2766 struct minimal_symbol
*msymbol
,
2768 struct obj_section
*section
,
2771 struct dwarf2_per_cu_data
*data
;
2773 dw2_setup (objfile
);
2775 if (!objfile
->psymtabs_addrmap
)
2778 data
= addrmap_find (objfile
->psymtabs_addrmap
, pc
);
2782 if (warn_if_readin
&& data
->v
.quick
->symtab
)
2783 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
2784 paddress (get_objfile_arch (objfile
), pc
));
2786 return dw2_instantiate_symtab (data
);
2790 dw2_map_symbol_filenames (struct objfile
*objfile
, symbol_filename_ftype
*fun
,
2791 void *data
, int need_fullname
)
2795 dw2_setup (objfile
);
2797 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2798 + dwarf2_per_objfile
->n_type_units
); ++i
)
2801 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2802 struct quick_file_names
*file_data
;
2804 /* We only need to look at symtabs not already expanded. */
2805 if (per_cu
->v
.quick
->symtab
)
2808 file_data
= dw2_get_file_names (objfile
, per_cu
);
2809 if (file_data
== NULL
)
2812 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
2814 const char *this_real_name
;
2817 this_real_name
= dw2_get_real_path (objfile
, file_data
, j
);
2819 this_real_name
= NULL
;
2820 (*fun
) (file_data
->file_names
[j
], this_real_name
, data
);
2826 dw2_has_symbols (struct objfile
*objfile
)
2831 const struct quick_symbol_functions dwarf2_gdb_index_functions
=
2834 dw2_find_last_source_symtab
,
2835 dw2_forget_cached_source_info
,
2836 dw2_map_symtabs_matching_filename
,
2838 dw2_pre_expand_symtabs_matching
,
2842 dw2_expand_symtabs_for_function
,
2843 dw2_expand_all_symtabs
,
2844 dw2_expand_symtabs_with_filename
,
2845 dw2_find_symbol_file
,
2846 dw2_map_matching_symbols
,
2847 dw2_expand_symtabs_matching
,
2848 dw2_find_pc_sect_symtab
,
2849 dw2_map_symbol_filenames
2852 /* Initialize for reading DWARF for this objfile. Return 0 if this
2853 file will use psymtabs, or 1 if using the GNU index. */
2856 dwarf2_initialize_objfile (struct objfile
*objfile
)
2858 /* If we're about to read full symbols, don't bother with the
2859 indices. In this case we also don't care if some other debug
2860 format is making psymtabs, because they are all about to be
2862 if ((objfile
->flags
& OBJF_READNOW
))
2866 dwarf2_per_objfile
->using_index
= 1;
2867 create_all_comp_units (objfile
);
2868 create_debug_types_hash_table (objfile
);
2869 dwarf2_per_objfile
->quick_file_names_table
=
2870 create_quick_file_names_table (dwarf2_per_objfile
->n_comp_units
);
2872 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2873 + dwarf2_per_objfile
->n_type_units
); ++i
)
2875 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2877 per_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2878 struct dwarf2_per_cu_quick_data
);
2881 /* Return 1 so that gdb sees the "quick" functions. However,
2882 these functions will be no-ops because we will have expanded
2887 if (dwarf2_read_index (objfile
))
2895 /* Build a partial symbol table. */
2898 dwarf2_build_psymtabs (struct objfile
*objfile
)
2900 if (objfile
->global_psymbols
.size
== 0 && objfile
->static_psymbols
.size
== 0)
2902 init_psymbol_list (objfile
, 1024);
2905 dwarf2_build_psymtabs_hard (objfile
);
2908 /* Return TRUE if OFFSET is within CU_HEADER. */
2911 offset_in_cu_p (const struct comp_unit_head
*cu_header
, unsigned int offset
)
2913 unsigned int bottom
= cu_header
->offset
;
2914 unsigned int top
= (cu_header
->offset
2916 + cu_header
->initial_length_size
);
2918 return (offset
>= bottom
&& offset
< top
);
2921 /* Read in the comp unit header information from the debug_info at info_ptr.
2922 NOTE: This leaves members offset, first_die_offset to be filled in
2926 read_comp_unit_head (struct comp_unit_head
*cu_header
,
2927 gdb_byte
*info_ptr
, bfd
*abfd
)
2930 unsigned int bytes_read
;
2932 cu_header
->length
= read_initial_length (abfd
, info_ptr
, &bytes_read
);
2933 cu_header
->initial_length_size
= bytes_read
;
2934 cu_header
->offset_size
= (bytes_read
== 4) ? 4 : 8;
2935 info_ptr
+= bytes_read
;
2936 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
2938 cu_header
->abbrev_offset
= read_offset (abfd
, info_ptr
, cu_header
,
2940 info_ptr
+= bytes_read
;
2941 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
2943 signed_addr
= bfd_get_sign_extend_vma (abfd
);
2944 if (signed_addr
< 0)
2945 internal_error (__FILE__
, __LINE__
,
2946 _("read_comp_unit_head: dwarf from non elf file"));
2947 cu_header
->signed_addr_p
= signed_addr
;
2952 /* Subroutine of read_and_check_comp_unit_head and
2953 read_and_check_type_unit_head to simplify them.
2954 Perform various error checking on the header. */
2957 error_check_comp_unit_head (struct comp_unit_head
*header
,
2958 struct dwarf2_section_info
*section
)
2960 bfd
*abfd
= section
->asection
->owner
;
2961 const char *filename
= bfd_get_filename (abfd
);
2963 if (header
->version
!= 2 && header
->version
!= 3 && header
->version
!= 4)
2964 error (_("Dwarf Error: wrong version in compilation unit header "
2965 "(is %d, should be 2, 3, or 4) [in module %s]"), header
->version
,
2968 if (header
->abbrev_offset
2969 >= dwarf2_section_size (dwarf2_per_objfile
->objfile
,
2970 &dwarf2_per_objfile
->abbrev
))
2971 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
2972 "(offset 0x%lx + 6) [in module %s]"),
2973 (long) header
->abbrev_offset
, (long) header
->offset
,
2976 /* Cast to unsigned long to use 64-bit arithmetic when possible to
2977 avoid potential 32-bit overflow. */
2978 if (((unsigned long) header
->offset
2979 + header
->length
+ header
->initial_length_size
)
2981 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
2982 "(offset 0x%lx + 0) [in module %s]"),
2983 (long) header
->length
, (long) header
->offset
,
2987 /* Read in a CU/TU header and perform some basic error checking.
2988 The contents of the header are stored in HEADER.
2989 The result is a pointer to the start of the first DIE. */
2992 read_and_check_comp_unit_head (struct comp_unit_head
*header
,
2993 struct dwarf2_section_info
*section
,
2995 int is_debug_types_section
)
2997 gdb_byte
*beg_of_comp_unit
= info_ptr
;
2998 bfd
*abfd
= section
->asection
->owner
;
3000 header
->offset
= beg_of_comp_unit
- section
->buffer
;
3002 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
3004 /* If we're reading a type unit, skip over the signature and
3005 type_offset fields. */
3006 if (is_debug_types_section
)
3007 info_ptr
+= 8 /*signature*/ + header
->offset_size
;
3009 header
->first_die_offset
= info_ptr
- beg_of_comp_unit
;
3011 error_check_comp_unit_head (header
, section
);
3016 /* Read in the types comp unit header information from .debug_types entry at
3017 types_ptr. The result is a pointer to one past the end of the header. */
3020 read_and_check_type_unit_head (struct comp_unit_head
*header
,
3021 struct dwarf2_section_info
*section
,
3023 ULONGEST
*signature
, unsigned int *type_offset
)
3025 gdb_byte
*beg_of_comp_unit
= info_ptr
;
3026 bfd
*abfd
= section
->asection
->owner
;
3028 header
->offset
= beg_of_comp_unit
- section
->buffer
;
3030 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
3032 /* If we're reading a type unit, skip over the signature and
3033 type_offset fields. */
3034 if (signature
!= NULL
)
3035 *signature
= read_8_bytes (abfd
, info_ptr
);
3037 if (type_offset
!= NULL
)
3038 *type_offset
= read_offset_1 (abfd
, info_ptr
, header
->offset_size
);
3039 info_ptr
+= header
->offset_size
;
3041 header
->first_die_offset
= info_ptr
- beg_of_comp_unit
;
3043 error_check_comp_unit_head (header
, section
);
3048 /* Allocate a new partial symtab for file named NAME and mark this new
3049 partial symtab as being an include of PST. */
3052 dwarf2_create_include_psymtab (char *name
, struct partial_symtab
*pst
,
3053 struct objfile
*objfile
)
3055 struct partial_symtab
*subpst
= allocate_psymtab (name
, objfile
);
3057 subpst
->section_offsets
= pst
->section_offsets
;
3058 subpst
->textlow
= 0;
3059 subpst
->texthigh
= 0;
3061 subpst
->dependencies
= (struct partial_symtab
**)
3062 obstack_alloc (&objfile
->objfile_obstack
,
3063 sizeof (struct partial_symtab
*));
3064 subpst
->dependencies
[0] = pst
;
3065 subpst
->number_of_dependencies
= 1;
3067 subpst
->globals_offset
= 0;
3068 subpst
->n_global_syms
= 0;
3069 subpst
->statics_offset
= 0;
3070 subpst
->n_static_syms
= 0;
3071 subpst
->symtab
= NULL
;
3072 subpst
->read_symtab
= pst
->read_symtab
;
3075 /* No private part is necessary for include psymtabs. This property
3076 can be used to differentiate between such include psymtabs and
3077 the regular ones. */
3078 subpst
->read_symtab_private
= NULL
;
3081 /* Read the Line Number Program data and extract the list of files
3082 included by the source file represented by PST. Build an include
3083 partial symtab for each of these included files. */
3086 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
3087 struct die_info
*die
,
3088 struct partial_symtab
*pst
)
3090 struct objfile
*objfile
= cu
->objfile
;
3091 bfd
*abfd
= objfile
->obfd
;
3092 struct line_header
*lh
= NULL
;
3093 struct attribute
*attr
;
3095 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
3098 unsigned int line_offset
= DW_UNSND (attr
);
3100 lh
= dwarf_decode_line_header (line_offset
, abfd
, cu
);
3103 return; /* No linetable, so no includes. */
3105 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). */
3106 dwarf_decode_lines (lh
, pst
->dirname
, cu
, pst
, 1);
3108 free_line_header (lh
);
3112 hash_type_signature (const void *item
)
3114 const struct signatured_type
*type_sig
= item
;
3116 /* This drops the top 32 bits of the signature, but is ok for a hash. */
3117 return type_sig
->signature
;
3121 eq_type_signature (const void *item_lhs
, const void *item_rhs
)
3123 const struct signatured_type
*lhs
= item_lhs
;
3124 const struct signatured_type
*rhs
= item_rhs
;
3126 return lhs
->signature
== rhs
->signature
;
3129 /* Allocate a hash table for signatured types. */
3132 allocate_signatured_type_table (struct objfile
*objfile
)
3134 return htab_create_alloc_ex (41,
3135 hash_type_signature
,
3138 &objfile
->objfile_obstack
,
3139 hashtab_obstack_allocate
,
3140 dummy_obstack_deallocate
);
3143 /* A helper function to add a signatured type CU to a table. */
3146 add_signatured_type_cu_to_table (void **slot
, void *datum
)
3148 struct signatured_type
*sigt
= *slot
;
3149 struct dwarf2_per_cu_data
***datap
= datum
;
3151 **datap
= &sigt
->per_cu
;
3157 /* Create the hash table of all entries in the .debug_types section(s).
3158 The result is zero if there is an error (e.g. missing .debug_types section),
3159 otherwise non-zero. */
3162 create_debug_types_hash_table (struct objfile
*objfile
)
3164 htab_t types_htab
= NULL
;
3165 struct dwarf2_per_cu_data
**iter
;
3167 struct dwarf2_section_info
*section
;
3169 if (VEC_empty (dwarf2_section_info_def
, dwarf2_per_objfile
->types
))
3171 dwarf2_per_objfile
->signatured_types
= NULL
;
3176 VEC_iterate (dwarf2_section_info_def
, dwarf2_per_objfile
->types
,
3180 gdb_byte
*info_ptr
, *end_ptr
;
3182 dwarf2_read_section (objfile
, section
);
3183 info_ptr
= section
->buffer
;
3185 if (info_ptr
== NULL
)
3188 if (types_htab
== NULL
)
3189 types_htab
= allocate_signatured_type_table (objfile
);
3191 if (dwarf2_die_debug
)
3192 fprintf_unfiltered (gdb_stdlog
, "Signatured types:\n");
3194 end_ptr
= info_ptr
+ section
->size
;
3195 while (info_ptr
< end_ptr
)
3197 unsigned int offset
;
3198 unsigned int type_offset
;
3200 struct signatured_type
*type_sig
;
3202 gdb_byte
*ptr
= info_ptr
;
3203 struct comp_unit_head header
;
3205 offset
= ptr
- section
->buffer
;
3207 /* We need to read the type's signature in order to build the hash
3208 table, but we don't need anything else just yet. */
3210 ptr
= read_and_check_type_unit_head (&header
, section
, ptr
,
3211 &signature
, &type_offset
);
3213 /* Skip dummy type units. */
3214 if (ptr
>= end_ptr
|| peek_abbrev_code (objfile
->obfd
, ptr
) == 0)
3216 info_ptr
= info_ptr
+ header
.initial_length_size
+ header
.length
;
3220 type_sig
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*type_sig
));
3221 memset (type_sig
, 0, sizeof (*type_sig
));
3222 type_sig
->signature
= signature
;
3223 type_sig
->type_offset
= type_offset
;
3224 type_sig
->per_cu
.objfile
= objfile
;
3225 type_sig
->per_cu
.debug_types_section
= section
;
3226 type_sig
->per_cu
.offset
= offset
;
3228 slot
= htab_find_slot (types_htab
, type_sig
, INSERT
);
3229 gdb_assert (slot
!= NULL
);
3232 const struct signatured_type
*dup_sig
= *slot
;
3234 complaint (&symfile_complaints
,
3235 _("debug type entry at offset 0x%x is duplicate to the "
3236 "entry at offset 0x%x, signature 0x%s"),
3237 offset
, dup_sig
->per_cu
.offset
,
3238 phex (signature
, sizeof (signature
)));
3239 gdb_assert (signature
== dup_sig
->signature
);
3243 if (dwarf2_die_debug
)
3244 fprintf_unfiltered (gdb_stdlog
, " offset 0x%x, signature 0x%s\n",
3245 offset
, phex (signature
, sizeof (signature
)));
3247 info_ptr
= info_ptr
+ header
.initial_length_size
+ header
.length
;
3251 dwarf2_per_objfile
->signatured_types
= types_htab
;
3253 dwarf2_per_objfile
->n_type_units
= htab_elements (types_htab
);
3254 dwarf2_per_objfile
->all_type_units
3255 = obstack_alloc (&objfile
->objfile_obstack
,
3256 dwarf2_per_objfile
->n_type_units
3257 * sizeof (struct dwarf2_per_cu_data
*));
3258 iter
= &dwarf2_per_objfile
->all_type_units
[0];
3259 htab_traverse_noresize (types_htab
, add_signatured_type_cu_to_table
, &iter
);
3260 gdb_assert (iter
- &dwarf2_per_objfile
->all_type_units
[0]
3261 == dwarf2_per_objfile
->n_type_units
);
3266 /* Lookup a signature based type.
3267 Returns NULL if SIG is not present in the table. */
3269 static struct signatured_type
*
3270 lookup_signatured_type (struct objfile
*objfile
, ULONGEST sig
)
3272 struct signatured_type find_entry
, *entry
;
3274 if (dwarf2_per_objfile
->signatured_types
== NULL
)
3276 complaint (&symfile_complaints
,
3277 _("missing `.debug_types' section for DW_FORM_ref_sig8 die"));
3281 find_entry
.signature
= sig
;
3282 entry
= htab_find (dwarf2_per_objfile
->signatured_types
, &find_entry
);
3286 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
3289 init_cu_die_reader (struct die_reader_specs
*reader
,
3290 struct dwarf2_cu
*cu
)
3292 reader
->abfd
= cu
->objfile
->obfd
;
3294 if (cu
->per_cu
->debug_types_section
)
3296 gdb_assert (cu
->per_cu
->debug_types_section
->readin
);
3297 reader
->buffer
= cu
->per_cu
->debug_types_section
->buffer
;
3301 gdb_assert (dwarf2_per_objfile
->info
.readin
);
3302 reader
->buffer
= dwarf2_per_objfile
->info
.buffer
;
3306 /* Find the base address of the compilation unit for range lists and
3307 location lists. It will normally be specified by DW_AT_low_pc.
3308 In DWARF-3 draft 4, the base address could be overridden by
3309 DW_AT_entry_pc. It's been removed, but GCC still uses this for
3310 compilation units with discontinuous ranges. */
3313 dwarf2_find_base_address (struct die_info
*die
, struct dwarf2_cu
*cu
)
3315 struct attribute
*attr
;
3318 cu
->base_address
= 0;
3320 attr
= dwarf2_attr (die
, DW_AT_entry_pc
, cu
);
3323 cu
->base_address
= DW_ADDR (attr
);
3328 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
3331 cu
->base_address
= DW_ADDR (attr
);
3337 /* Subroutine of process_type_comp_unit and dwarf2_build_psymtabs_hard
3338 to combine the common parts.
3339 Process compilation unit THIS_CU for a psymtab.
3340 SECTION is the section the CU/TU comes from,
3341 either .debug_info or .debug_types. */
3344 process_psymtab_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
3345 struct dwarf2_section_info
*section
,
3346 int is_debug_types_section
)
3348 struct objfile
*objfile
= this_cu
->objfile
;
3349 bfd
*abfd
= objfile
->obfd
;
3350 gdb_byte
*buffer
= section
->buffer
;
3351 gdb_byte
*info_ptr
= buffer
+ this_cu
->offset
;
3352 unsigned int buffer_size
= section
->size
;
3353 gdb_byte
*beg_of_comp_unit
= info_ptr
;
3354 struct die_info
*comp_unit_die
;
3355 struct partial_symtab
*pst
;
3357 struct cleanup
*back_to_inner
;
3358 struct dwarf2_cu cu
;
3359 int has_children
, has_pc_info
;
3360 struct attribute
*attr
;
3361 CORE_ADDR best_lowpc
= 0, best_highpc
= 0;
3362 struct die_reader_specs reader_specs
;
3363 const char *filename
;
3365 /* If this compilation unit was already read in, free the
3366 cached copy in order to read it in again. This is
3367 necessary because we skipped some symbols when we first
3368 read in the compilation unit (see load_partial_dies).
3369 This problem could be avoided, but the benefit is
3371 if (this_cu
->cu
!= NULL
)
3372 free_one_cached_comp_unit (this_cu
->cu
);
3374 /* Note that this is a pointer to our stack frame, being
3375 added to a global data structure. It will be cleaned up
3376 in free_stack_comp_unit when we finish with this
3377 compilation unit. */
3378 init_one_comp_unit (&cu
, this_cu
);
3379 back_to_inner
= make_cleanup (free_stack_comp_unit
, &cu
);
3381 info_ptr
= read_and_check_comp_unit_head (&cu
.header
, section
, info_ptr
,
3382 is_debug_types_section
);
3384 /* Skip dummy compilation units. */
3385 if (info_ptr
>= buffer
+ buffer_size
3386 || peek_abbrev_code (abfd
, info_ptr
) == 0)
3388 do_cleanups (back_to_inner
);
3392 cu
.list_in_scope
= &file_symbols
;
3394 /* Read the abbrevs for this compilation unit into a table. */
3395 dwarf2_read_abbrevs (&cu
);
3396 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
3398 /* Read the compilation unit die. */
3399 init_cu_die_reader (&reader_specs
, &cu
);
3400 info_ptr
= read_full_die (&reader_specs
, &comp_unit_die
, info_ptr
,
3403 if (is_debug_types_section
)
3405 /* LENGTH has not been set yet for type units. */
3406 gdb_assert (this_cu
->offset
== cu
.header
.offset
);
3407 this_cu
->length
= cu
.header
.length
+ cu
.header
.initial_length_size
;
3409 else if (comp_unit_die
->tag
== DW_TAG_partial_unit
)
3411 do_cleanups (back_to_inner
);
3415 prepare_one_comp_unit (&cu
, comp_unit_die
);
3417 /* Allocate a new partial symbol table structure. */
3418 attr
= dwarf2_attr (comp_unit_die
, DW_AT_name
, &cu
);
3419 if (attr
== NULL
|| !DW_STRING (attr
))
3422 filename
= DW_STRING (attr
);
3423 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
3425 /* TEXTLOW and TEXTHIGH are set below. */
3427 objfile
->global_psymbols
.next
,
3428 objfile
->static_psymbols
.next
);
3429 pst
->psymtabs_addrmap_supported
= 1;
3431 attr
= dwarf2_attr (comp_unit_die
, DW_AT_comp_dir
, &cu
);
3433 pst
->dirname
= DW_STRING (attr
);
3435 pst
->read_symtab_private
= this_cu
;
3437 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3439 /* Store the function that reads in the rest of the symbol table. */
3440 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
3442 this_cu
->v
.psymtab
= pst
;
3444 dwarf2_find_base_address (comp_unit_die
, &cu
);
3446 /* Possibly set the default values of LOWPC and HIGHPC from
3448 has_pc_info
= dwarf2_get_pc_bounds (comp_unit_die
, &best_lowpc
,
3449 &best_highpc
, &cu
, pst
);
3450 if (has_pc_info
== 1 && best_lowpc
< best_highpc
)
3451 /* Store the contiguous range if it is not empty; it can be empty for
3452 CUs with no code. */
3453 addrmap_set_empty (objfile
->psymtabs_addrmap
,
3454 best_lowpc
+ baseaddr
,
3455 best_highpc
+ baseaddr
- 1, pst
);
3457 /* Check if comp unit has_children.
3458 If so, read the rest of the partial symbols from this comp unit.
3459 If not, there's no more debug_info for this comp unit. */
3462 struct partial_die_info
*first_die
;
3463 CORE_ADDR lowpc
, highpc
;
3465 lowpc
= ((CORE_ADDR
) -1);
3466 highpc
= ((CORE_ADDR
) 0);
3468 first_die
= load_partial_dies (abfd
, buffer
, info_ptr
, 1, &cu
);
3470 scan_partial_symbols (first_die
, &lowpc
, &highpc
,
3471 ! has_pc_info
, &cu
);
3473 /* If we didn't find a lowpc, set it to highpc to avoid
3474 complaints from `maint check'. */
3475 if (lowpc
== ((CORE_ADDR
) -1))
3478 /* If the compilation unit didn't have an explicit address range,
3479 then use the information extracted from its child dies. */
3483 best_highpc
= highpc
;
3486 pst
->textlow
= best_lowpc
+ baseaddr
;
3487 pst
->texthigh
= best_highpc
+ baseaddr
;
3489 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
3490 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
3491 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
3492 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
3493 sort_pst_symbols (pst
);
3495 if (is_debug_types_section
)
3497 /* It's not clear we want to do anything with stmt lists here.
3498 Waiting to see what gcc ultimately does. */
3502 /* Get the list of files included in the current compilation unit,
3503 and build a psymtab for each of them. */
3504 dwarf2_build_include_psymtabs (&cu
, comp_unit_die
, pst
);
3507 do_cleanups (back_to_inner
);
3510 /* Traversal function for htab_traverse_noresize.
3511 Process one .debug_types comp-unit. */
3514 process_type_comp_unit (void **slot
, void *info
)
3516 struct signatured_type
*entry
= (struct signatured_type
*) *slot
;
3517 struct dwarf2_per_cu_data
*this_cu
;
3519 gdb_assert (info
== NULL
);
3520 this_cu
= &entry
->per_cu
;
3522 gdb_assert (this_cu
->debug_types_section
->readin
);
3523 process_psymtab_comp_unit (this_cu
, this_cu
->debug_types_section
, 1);
3528 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
3529 Build partial symbol tables for the .debug_types comp-units. */
3532 build_type_psymtabs (struct objfile
*objfile
)
3534 if (! create_debug_types_hash_table (objfile
))
3537 htab_traverse_noresize (dwarf2_per_objfile
->signatured_types
,
3538 process_type_comp_unit
, NULL
);
3541 /* A cleanup function that clears objfile's psymtabs_addrmap field. */
3544 psymtabs_addrmap_cleanup (void *o
)
3546 struct objfile
*objfile
= o
;
3548 objfile
->psymtabs_addrmap
= NULL
;
3551 /* Build the partial symbol table by doing a quick pass through the
3552 .debug_info and .debug_abbrev sections. */
3555 dwarf2_build_psymtabs_hard (struct objfile
*objfile
)
3557 struct cleanup
*back_to
, *addrmap_cleanup
;
3558 struct obstack temp_obstack
;
3561 dwarf2_per_objfile
->reading_partial_symbols
= 1;
3563 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
3565 /* Any cached compilation units will be linked by the per-objfile
3566 read_in_chain. Make sure to free them when we're done. */
3567 back_to
= make_cleanup (free_cached_comp_units
, NULL
);
3569 build_type_psymtabs (objfile
);
3571 create_all_comp_units (objfile
);
3573 /* Create a temporary address map on a temporary obstack. We later
3574 copy this to the final obstack. */
3575 obstack_init (&temp_obstack
);
3576 make_cleanup_obstack_free (&temp_obstack
);
3577 objfile
->psymtabs_addrmap
= addrmap_create_mutable (&temp_obstack
);
3578 addrmap_cleanup
= make_cleanup (psymtabs_addrmap_cleanup
, objfile
);
3580 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
3582 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
3584 process_psymtab_comp_unit (per_cu
, &dwarf2_per_objfile
->info
, 0);
3587 objfile
->psymtabs_addrmap
= addrmap_create_fixed (objfile
->psymtabs_addrmap
,
3588 &objfile
->objfile_obstack
);
3589 discard_cleanups (addrmap_cleanup
);
3591 do_cleanups (back_to
);
3594 /* Load the partial DIEs for a secondary CU into memory. */
3597 load_partial_comp_unit (struct dwarf2_per_cu_data
*this_cu
)
3599 struct objfile
*objfile
= this_cu
->objfile
;
3600 bfd
*abfd
= objfile
->obfd
;
3602 struct die_info
*comp_unit_die
;
3603 struct dwarf2_cu
*cu
;
3604 struct cleanup
*free_abbrevs_cleanup
, *free_cu_cleanup
= NULL
;
3606 struct die_reader_specs reader_specs
;
3608 struct dwarf2_section_info
*section
= &dwarf2_per_objfile
->info
;
3610 gdb_assert (! this_cu
->debug_types_section
);
3612 gdb_assert (section
->readin
);
3613 info_ptr
= section
->buffer
+ this_cu
->offset
;
3615 if (this_cu
->cu
== NULL
)
3617 cu
= xmalloc (sizeof (*cu
));
3618 init_one_comp_unit (cu
, this_cu
);
3622 /* If an error occurs while loading, release our storage. */
3623 free_cu_cleanup
= make_cleanup (free_heap_comp_unit
, cu
);
3625 info_ptr
= read_and_check_comp_unit_head (&cu
->header
, section
, info_ptr
,
3628 /* Skip dummy compilation units. */
3629 if (info_ptr
>= (section
->buffer
+ section
->size
)
3630 || peek_abbrev_code (abfd
, info_ptr
) == 0)
3632 do_cleanups (free_cu_cleanup
);
3636 /* Link this CU into read_in_chain. */
3637 this_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
3638 dwarf2_per_objfile
->read_in_chain
= this_cu
;
3643 info_ptr
+= cu
->header
.first_die_offset
;
3646 /* Read the abbrevs for this compilation unit into a table. */
3647 gdb_assert (cu
->dwarf2_abbrevs
== NULL
);
3648 dwarf2_read_abbrevs (cu
);
3649 free_abbrevs_cleanup
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
3651 /* Read the compilation unit die. */
3652 init_cu_die_reader (&reader_specs
, cu
);
3653 info_ptr
= read_full_die (&reader_specs
, &comp_unit_die
, info_ptr
,
3656 prepare_one_comp_unit (cu
, comp_unit_die
);
3658 /* Check if comp unit has_children.
3659 If so, read the rest of the partial symbols from this comp unit.
3660 If not, there's no more debug_info for this comp unit. */
3662 load_partial_dies (abfd
, section
->buffer
, info_ptr
, 0, cu
);
3664 do_cleanups (free_abbrevs_cleanup
);
3668 /* We've successfully allocated this compilation unit. Let our
3669 caller clean it up when finished with it. */
3670 discard_cleanups (free_cu_cleanup
);
3674 /* Create a list of all compilation units in OBJFILE.
3675 This is only done for -readnow and building partial symtabs. */
3678 create_all_comp_units (struct objfile
*objfile
)
3682 struct dwarf2_per_cu_data
**all_comp_units
;
3685 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
3686 info_ptr
= dwarf2_per_objfile
->info
.buffer
;
3690 all_comp_units
= xmalloc (n_allocated
3691 * sizeof (struct dwarf2_per_cu_data
*));
3693 while (info_ptr
< dwarf2_per_objfile
->info
.buffer
3694 + dwarf2_per_objfile
->info
.size
)
3696 unsigned int length
, initial_length_size
;
3697 struct dwarf2_per_cu_data
*this_cu
;
3698 unsigned int offset
;
3700 offset
= info_ptr
- dwarf2_per_objfile
->info
.buffer
;
3702 /* Read just enough information to find out where the next
3703 compilation unit is. */
3704 length
= read_initial_length (objfile
->obfd
, info_ptr
,
3705 &initial_length_size
);
3707 /* Save the compilation unit for later lookup. */
3708 this_cu
= obstack_alloc (&objfile
->objfile_obstack
,
3709 sizeof (struct dwarf2_per_cu_data
));
3710 memset (this_cu
, 0, sizeof (*this_cu
));
3711 this_cu
->offset
= offset
;
3712 this_cu
->length
= length
+ initial_length_size
;
3713 this_cu
->objfile
= objfile
;
3715 if (n_comp_units
== n_allocated
)
3718 all_comp_units
= xrealloc (all_comp_units
,
3720 * sizeof (struct dwarf2_per_cu_data
*));
3722 all_comp_units
[n_comp_units
++] = this_cu
;
3724 info_ptr
= info_ptr
+ this_cu
->length
;
3727 dwarf2_per_objfile
->all_comp_units
3728 = obstack_alloc (&objfile
->objfile_obstack
,
3729 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
3730 memcpy (dwarf2_per_objfile
->all_comp_units
, all_comp_units
,
3731 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
3732 xfree (all_comp_units
);
3733 dwarf2_per_objfile
->n_comp_units
= n_comp_units
;
3736 /* Process all loaded DIEs for compilation unit CU, starting at
3737 FIRST_DIE. The caller should pass NEED_PC == 1 if the compilation
3738 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
3739 DW_AT_ranges). If NEED_PC is set, then this function will set
3740 *LOWPC and *HIGHPC to the lowest and highest PC values found in CU
3741 and record the covered ranges in the addrmap. */
3744 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
3745 CORE_ADDR
*highpc
, int need_pc
, struct dwarf2_cu
*cu
)
3747 struct partial_die_info
*pdi
;
3749 /* Now, march along the PDI's, descending into ones which have
3750 interesting children but skipping the children of the other ones,
3751 until we reach the end of the compilation unit. */
3757 fixup_partial_die (pdi
, cu
);
3759 /* Anonymous namespaces or modules have no name but have interesting
3760 children, so we need to look at them. Ditto for anonymous
3763 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
3764 || pdi
->tag
== DW_TAG_module
|| pdi
->tag
== DW_TAG_enumeration_type
)
3768 case DW_TAG_subprogram
:
3769 add_partial_subprogram (pdi
, lowpc
, highpc
, need_pc
, cu
);
3771 case DW_TAG_constant
:
3772 case DW_TAG_variable
:
3773 case DW_TAG_typedef
:
3774 case DW_TAG_union_type
:
3775 if (!pdi
->is_declaration
)
3777 add_partial_symbol (pdi
, cu
);
3780 case DW_TAG_class_type
:
3781 case DW_TAG_interface_type
:
3782 case DW_TAG_structure_type
:
3783 if (!pdi
->is_declaration
)
3785 add_partial_symbol (pdi
, cu
);
3788 case DW_TAG_enumeration_type
:
3789 if (!pdi
->is_declaration
)
3790 add_partial_enumeration (pdi
, cu
);
3792 case DW_TAG_base_type
:
3793 case DW_TAG_subrange_type
:
3794 /* File scope base type definitions are added to the partial
3796 add_partial_symbol (pdi
, cu
);
3798 case DW_TAG_namespace
:
3799 add_partial_namespace (pdi
, lowpc
, highpc
, need_pc
, cu
);
3802 add_partial_module (pdi
, lowpc
, highpc
, need_pc
, cu
);
3809 /* If the die has a sibling, skip to the sibling. */
3811 pdi
= pdi
->die_sibling
;
3815 /* Functions used to compute the fully scoped name of a partial DIE.
3817 Normally, this is simple. For C++, the parent DIE's fully scoped
3818 name is concatenated with "::" and the partial DIE's name. For
3819 Java, the same thing occurs except that "." is used instead of "::".
3820 Enumerators are an exception; they use the scope of their parent
3821 enumeration type, i.e. the name of the enumeration type is not
3822 prepended to the enumerator.
3824 There are two complexities. One is DW_AT_specification; in this
3825 case "parent" means the parent of the target of the specification,
3826 instead of the direct parent of the DIE. The other is compilers
3827 which do not emit DW_TAG_namespace; in this case we try to guess
3828 the fully qualified name of structure types from their members'
3829 linkage names. This must be done using the DIE's children rather
3830 than the children of any DW_AT_specification target. We only need
3831 to do this for structures at the top level, i.e. if the target of
3832 any DW_AT_specification (if any; otherwise the DIE itself) does not
3835 /* Compute the scope prefix associated with PDI's parent, in
3836 compilation unit CU. The result will be allocated on CU's
3837 comp_unit_obstack, or a copy of the already allocated PDI->NAME
3838 field. NULL is returned if no prefix is necessary. */
3840 partial_die_parent_scope (struct partial_die_info
*pdi
,
3841 struct dwarf2_cu
*cu
)
3843 char *grandparent_scope
;
3844 struct partial_die_info
*parent
, *real_pdi
;
3846 /* We need to look at our parent DIE; if we have a DW_AT_specification,
3847 then this means the parent of the specification DIE. */
3850 while (real_pdi
->has_specification
)
3851 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
3853 parent
= real_pdi
->die_parent
;
3857 if (parent
->scope_set
)
3858 return parent
->scope
;
3860 fixup_partial_die (parent
, cu
);
3862 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
3864 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
3865 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
3866 Work around this problem here. */
3867 if (cu
->language
== language_cplus
3868 && parent
->tag
== DW_TAG_namespace
3869 && strcmp (parent
->name
, "::") == 0
3870 && grandparent_scope
== NULL
)
3872 parent
->scope
= NULL
;
3873 parent
->scope_set
= 1;
3877 if (pdi
->tag
== DW_TAG_enumerator
)
3878 /* Enumerators should not get the name of the enumeration as a prefix. */
3879 parent
->scope
= grandparent_scope
;
3880 else if (parent
->tag
== DW_TAG_namespace
3881 || parent
->tag
== DW_TAG_module
3882 || parent
->tag
== DW_TAG_structure_type
3883 || parent
->tag
== DW_TAG_class_type
3884 || parent
->tag
== DW_TAG_interface_type
3885 || parent
->tag
== DW_TAG_union_type
3886 || parent
->tag
== DW_TAG_enumeration_type
)
3888 if (grandparent_scope
== NULL
)
3889 parent
->scope
= parent
->name
;
3891 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
,
3893 parent
->name
, 0, cu
);
3897 /* FIXME drow/2004-04-01: What should we be doing with
3898 function-local names? For partial symbols, we should probably be
3900 complaint (&symfile_complaints
,
3901 _("unhandled containing DIE tag %d for DIE at %d"),
3902 parent
->tag
, pdi
->offset
);
3903 parent
->scope
= grandparent_scope
;
3906 parent
->scope_set
= 1;
3907 return parent
->scope
;
3910 /* Return the fully scoped name associated with PDI, from compilation unit
3911 CU. The result will be allocated with malloc. */
3913 partial_die_full_name (struct partial_die_info
*pdi
,
3914 struct dwarf2_cu
*cu
)
3918 /* If this is a template instantiation, we can not work out the
3919 template arguments from partial DIEs. So, unfortunately, we have
3920 to go through the full DIEs. At least any work we do building
3921 types here will be reused if full symbols are loaded later. */
3922 if (pdi
->has_template_arguments
)
3924 fixup_partial_die (pdi
, cu
);
3926 if (pdi
->name
!= NULL
&& strchr (pdi
->name
, '<') == NULL
)
3928 struct die_info
*die
;
3929 struct attribute attr
;
3930 struct dwarf2_cu
*ref_cu
= cu
;
3933 attr
.form
= DW_FORM_ref_addr
;
3934 attr
.u
.addr
= pdi
->offset
;
3935 die
= follow_die_ref (NULL
, &attr
, &ref_cu
);
3937 return xstrdup (dwarf2_full_name (NULL
, die
, ref_cu
));
3941 parent_scope
= partial_die_parent_scope (pdi
, cu
);
3942 if (parent_scope
== NULL
)
3945 return typename_concat (NULL
, parent_scope
, pdi
->name
, 0, cu
);
3949 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
3951 struct objfile
*objfile
= cu
->objfile
;
3953 char *actual_name
= NULL
;
3954 const struct partial_symbol
*psym
= NULL
;
3956 int built_actual_name
= 0;
3958 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3960 actual_name
= partial_die_full_name (pdi
, cu
);
3962 built_actual_name
= 1;
3964 if (actual_name
== NULL
)
3965 actual_name
= pdi
->name
;
3969 case DW_TAG_subprogram
:
3970 if (pdi
->is_external
|| cu
->language
== language_ada
)
3972 /* brobecker/2007-12-26: Normally, only "external" DIEs are part
3973 of the global scope. But in Ada, we want to be able to access
3974 nested procedures globally. So all Ada subprograms are stored
3975 in the global scope. */
3976 /* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
3977 mst_text, objfile); */
3978 add_psymbol_to_list (actual_name
, strlen (actual_name
),
3980 VAR_DOMAIN
, LOC_BLOCK
,
3981 &objfile
->global_psymbols
,
3982 0, pdi
->lowpc
+ baseaddr
,
3983 cu
->language
, objfile
);
3987 /* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
3988 mst_file_text, objfile); */
3989 add_psymbol_to_list (actual_name
, strlen (actual_name
),
3991 VAR_DOMAIN
, LOC_BLOCK
,
3992 &objfile
->static_psymbols
,
3993 0, pdi
->lowpc
+ baseaddr
,
3994 cu
->language
, objfile
);
3997 case DW_TAG_constant
:
3999 struct psymbol_allocation_list
*list
;
4001 if (pdi
->is_external
)
4002 list
= &objfile
->global_psymbols
;
4004 list
= &objfile
->static_psymbols
;
4005 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4006 built_actual_name
, VAR_DOMAIN
, LOC_STATIC
,
4007 list
, 0, 0, cu
->language
, objfile
);
4010 case DW_TAG_variable
:
4012 addr
= decode_locdesc (pdi
->locdesc
, cu
);
4016 && !dwarf2_per_objfile
->has_section_at_zero
)
4018 /* A global or static variable may also have been stripped
4019 out by the linker if unused, in which case its address
4020 will be nullified; do not add such variables into partial
4021 symbol table then. */
4023 else if (pdi
->is_external
)
4026 Don't enter into the minimal symbol tables as there is
4027 a minimal symbol table entry from the ELF symbols already.
4028 Enter into partial symbol table if it has a location
4029 descriptor or a type.
4030 If the location descriptor is missing, new_symbol will create
4031 a LOC_UNRESOLVED symbol, the address of the variable will then
4032 be determined from the minimal symbol table whenever the variable
4034 The address for the partial symbol table entry is not
4035 used by GDB, but it comes in handy for debugging partial symbol
4038 if (pdi
->locdesc
|| pdi
->has_type
)
4039 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4041 VAR_DOMAIN
, LOC_STATIC
,
4042 &objfile
->global_psymbols
,
4044 cu
->language
, objfile
);
4048 /* Static Variable. Skip symbols without location descriptors. */
4049 if (pdi
->locdesc
== NULL
)
4051 if (built_actual_name
)
4052 xfree (actual_name
);
4055 /* prim_record_minimal_symbol (actual_name, addr + baseaddr,
4056 mst_file_data, objfile); */
4057 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4059 VAR_DOMAIN
, LOC_STATIC
,
4060 &objfile
->static_psymbols
,
4062 cu
->language
, objfile
);
4065 case DW_TAG_typedef
:
4066 case DW_TAG_base_type
:
4067 case DW_TAG_subrange_type
:
4068 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4070 VAR_DOMAIN
, LOC_TYPEDEF
,
4071 &objfile
->static_psymbols
,
4072 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
4074 case DW_TAG_namespace
:
4075 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4077 VAR_DOMAIN
, LOC_TYPEDEF
,
4078 &objfile
->global_psymbols
,
4079 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
4081 case DW_TAG_class_type
:
4082 case DW_TAG_interface_type
:
4083 case DW_TAG_structure_type
:
4084 case DW_TAG_union_type
:
4085 case DW_TAG_enumeration_type
:
4086 /* Skip external references. The DWARF standard says in the section
4087 about "Structure, Union, and Class Type Entries": "An incomplete
4088 structure, union or class type is represented by a structure,
4089 union or class entry that does not have a byte size attribute
4090 and that has a DW_AT_declaration attribute." */
4091 if (!pdi
->has_byte_size
&& pdi
->is_declaration
)
4093 if (built_actual_name
)
4094 xfree (actual_name
);
4098 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
4099 static vs. global. */
4100 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4102 STRUCT_DOMAIN
, LOC_TYPEDEF
,
4103 (cu
->language
== language_cplus
4104 || cu
->language
== language_java
)
4105 ? &objfile
->global_psymbols
4106 : &objfile
->static_psymbols
,
4107 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
4110 case DW_TAG_enumerator
:
4111 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4113 VAR_DOMAIN
, LOC_CONST
,
4114 (cu
->language
== language_cplus
4115 || cu
->language
== language_java
)
4116 ? &objfile
->global_psymbols
4117 : &objfile
->static_psymbols
,
4118 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
4124 if (built_actual_name
)
4125 xfree (actual_name
);
4128 /* Read a partial die corresponding to a namespace; also, add a symbol
4129 corresponding to that namespace to the symbol table. NAMESPACE is
4130 the name of the enclosing namespace. */
4133 add_partial_namespace (struct partial_die_info
*pdi
,
4134 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
4135 int need_pc
, struct dwarf2_cu
*cu
)
4137 /* Add a symbol for the namespace. */
4139 add_partial_symbol (pdi
, cu
);
4141 /* Now scan partial symbols in that namespace. */
4143 if (pdi
->has_children
)
4144 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, need_pc
, cu
);
4147 /* Read a partial die corresponding to a Fortran module. */
4150 add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
4151 CORE_ADDR
*highpc
, int need_pc
, struct dwarf2_cu
*cu
)
4153 /* Now scan partial symbols in that module. */
4155 if (pdi
->has_children
)
4156 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, need_pc
, cu
);
4159 /* Read a partial die corresponding to a subprogram and create a partial
4160 symbol for that subprogram. When the CU language allows it, this
4161 routine also defines a partial symbol for each nested subprogram
4162 that this subprogram contains.
4164 DIE my also be a lexical block, in which case we simply search
4165 recursively for suprograms defined inside that lexical block.
4166 Again, this is only performed when the CU language allows this
4167 type of definitions. */
4170 add_partial_subprogram (struct partial_die_info
*pdi
,
4171 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
4172 int need_pc
, struct dwarf2_cu
*cu
)
4174 if (pdi
->tag
== DW_TAG_subprogram
)
4176 if (pdi
->has_pc_info
)
4178 if (pdi
->lowpc
< *lowpc
)
4179 *lowpc
= pdi
->lowpc
;
4180 if (pdi
->highpc
> *highpc
)
4181 *highpc
= pdi
->highpc
;
4185 struct objfile
*objfile
= cu
->objfile
;
4187 baseaddr
= ANOFFSET (objfile
->section_offsets
,
4188 SECT_OFF_TEXT (objfile
));
4189 addrmap_set_empty (objfile
->psymtabs_addrmap
,
4190 pdi
->lowpc
+ baseaddr
,
4191 pdi
->highpc
- 1 + baseaddr
,
4192 cu
->per_cu
->v
.psymtab
);
4194 if (!pdi
->is_declaration
)
4195 /* Ignore subprogram DIEs that do not have a name, they are
4196 illegal. Do not emit a complaint at this point, we will
4197 do so when we convert this psymtab into a symtab. */
4199 add_partial_symbol (pdi
, cu
);
4203 if (! pdi
->has_children
)
4206 if (cu
->language
== language_ada
)
4208 pdi
= pdi
->die_child
;
4211 fixup_partial_die (pdi
, cu
);
4212 if (pdi
->tag
== DW_TAG_subprogram
4213 || pdi
->tag
== DW_TAG_lexical_block
)
4214 add_partial_subprogram (pdi
, lowpc
, highpc
, need_pc
, cu
);
4215 pdi
= pdi
->die_sibling
;
4220 /* Read a partial die corresponding to an enumeration type. */
4223 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
4224 struct dwarf2_cu
*cu
)
4226 struct partial_die_info
*pdi
;
4228 if (enum_pdi
->name
!= NULL
)
4229 add_partial_symbol (enum_pdi
, cu
);
4231 pdi
= enum_pdi
->die_child
;
4234 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
4235 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
4237 add_partial_symbol (pdi
, cu
);
4238 pdi
= pdi
->die_sibling
;
4242 /* Return the initial uleb128 in the die at INFO_PTR. */
4245 peek_abbrev_code (bfd
*abfd
, gdb_byte
*info_ptr
)
4247 unsigned int bytes_read
;
4249 return read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4252 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
4253 Return the corresponding abbrev, or NULL if the number is zero (indicating
4254 an empty DIE). In either case *BYTES_READ will be set to the length of
4255 the initial number. */
4257 static struct abbrev_info
*
4258 peek_die_abbrev (gdb_byte
*info_ptr
, unsigned int *bytes_read
,
4259 struct dwarf2_cu
*cu
)
4261 bfd
*abfd
= cu
->objfile
->obfd
;
4262 unsigned int abbrev_number
;
4263 struct abbrev_info
*abbrev
;
4265 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
4267 if (abbrev_number
== 0)
4270 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
4273 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"),
4274 abbrev_number
, bfd_get_filename (abfd
));
4280 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
4281 Returns a pointer to the end of a series of DIEs, terminated by an empty
4282 DIE. Any children of the skipped DIEs will also be skipped. */
4285 skip_children (gdb_byte
*buffer
, gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
4287 struct abbrev_info
*abbrev
;
4288 unsigned int bytes_read
;
4292 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
4294 return info_ptr
+ bytes_read
;
4296 info_ptr
= skip_one_die (buffer
, info_ptr
+ bytes_read
, abbrev
, cu
);
4300 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
4301 INFO_PTR should point just after the initial uleb128 of a DIE, and the
4302 abbrev corresponding to that skipped uleb128 should be passed in
4303 ABBREV. Returns a pointer to this DIE's sibling, skipping any
4307 skip_one_die (gdb_byte
*buffer
, gdb_byte
*info_ptr
,
4308 struct abbrev_info
*abbrev
, struct dwarf2_cu
*cu
)
4310 unsigned int bytes_read
;
4311 struct attribute attr
;
4312 bfd
*abfd
= cu
->objfile
->obfd
;
4313 unsigned int form
, i
;
4315 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
4317 /* The only abbrev we care about is DW_AT_sibling. */
4318 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
4320 read_attribute (&attr
, &abbrev
->attrs
[i
],
4321 abfd
, info_ptr
, cu
);
4322 if (attr
.form
== DW_FORM_ref_addr
)
4323 complaint (&symfile_complaints
,
4324 _("ignoring absolute DW_AT_sibling"));
4326 return buffer
+ dwarf2_get_ref_die_offset (&attr
);
4329 /* If it isn't DW_AT_sibling, skip this attribute. */
4330 form
= abbrev
->attrs
[i
].form
;
4334 case DW_FORM_ref_addr
:
4335 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
4336 and later it is offset sized. */
4337 if (cu
->header
.version
== 2)
4338 info_ptr
+= cu
->header
.addr_size
;
4340 info_ptr
+= cu
->header
.offset_size
;
4343 info_ptr
+= cu
->header
.addr_size
;
4350 case DW_FORM_flag_present
:
4362 case DW_FORM_ref_sig8
:
4365 case DW_FORM_string
:
4366 read_direct_string (abfd
, info_ptr
, &bytes_read
);
4367 info_ptr
+= bytes_read
;
4369 case DW_FORM_sec_offset
:
4371 info_ptr
+= cu
->header
.offset_size
;
4373 case DW_FORM_exprloc
:
4375 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4376 info_ptr
+= bytes_read
;
4378 case DW_FORM_block1
:
4379 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
4381 case DW_FORM_block2
:
4382 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
4384 case DW_FORM_block4
:
4385 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
4389 case DW_FORM_ref_udata
:
4390 info_ptr
= skip_leb128 (abfd
, info_ptr
);
4392 case DW_FORM_indirect
:
4393 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4394 info_ptr
+= bytes_read
;
4395 /* We need to continue parsing from here, so just go back to
4397 goto skip_attribute
;
4400 error (_("Dwarf Error: Cannot handle %s "
4401 "in DWARF reader [in module %s]"),
4402 dwarf_form_name (form
),
4403 bfd_get_filename (abfd
));
4407 if (abbrev
->has_children
)
4408 return skip_children (buffer
, info_ptr
, cu
);
4413 /* Locate ORIG_PDI's sibling.
4414 INFO_PTR should point to the start of the next DIE after ORIG_PDI
4418 locate_pdi_sibling (struct partial_die_info
*orig_pdi
,
4419 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
4420 bfd
*abfd
, struct dwarf2_cu
*cu
)
4422 /* Do we know the sibling already? */
4424 if (orig_pdi
->sibling
)
4425 return orig_pdi
->sibling
;
4427 /* Are there any children to deal with? */
4429 if (!orig_pdi
->has_children
)
4432 /* Skip the children the long way. */
4434 return skip_children (buffer
, info_ptr
, cu
);
4437 /* Expand this partial symbol table into a full symbol table. */
4440 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
4446 warning (_("bug: psymtab for %s is already read in."),
4453 printf_filtered (_("Reading in symbols for %s..."),
4455 gdb_flush (gdb_stdout
);
4458 /* Restore our global data. */
4459 dwarf2_per_objfile
= objfile_data (pst
->objfile
,
4460 dwarf2_objfile_data_key
);
4462 /* If this psymtab is constructed from a debug-only objfile, the
4463 has_section_at_zero flag will not necessarily be correct. We
4464 can get the correct value for this flag by looking at the data
4465 associated with the (presumably stripped) associated objfile. */
4466 if (pst
->objfile
->separate_debug_objfile_backlink
)
4468 struct dwarf2_per_objfile
*dpo_backlink
4469 = objfile_data (pst
->objfile
->separate_debug_objfile_backlink
,
4470 dwarf2_objfile_data_key
);
4472 dwarf2_per_objfile
->has_section_at_zero
4473 = dpo_backlink
->has_section_at_zero
;
4476 dwarf2_per_objfile
->reading_partial_symbols
= 0;
4478 psymtab_to_symtab_1 (pst
);
4480 /* Finish up the debug error message. */
4482 printf_filtered (_("done.\n"));
4487 /* Reading in full CUs. */
4489 /* Add PER_CU to the queue. */
4492 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
4494 struct dwarf2_queue_item
*item
;
4497 item
= xmalloc (sizeof (*item
));
4498 item
->per_cu
= per_cu
;
4501 if (dwarf2_queue
== NULL
)
4502 dwarf2_queue
= item
;
4504 dwarf2_queue_tail
->next
= item
;
4506 dwarf2_queue_tail
= item
;
4509 /* Process the queue. */
4512 process_queue (void)
4514 struct dwarf2_queue_item
*item
, *next_item
;
4516 /* The queue starts out with one item, but following a DIE reference
4517 may load a new CU, adding it to the end of the queue. */
4518 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
4520 if (dwarf2_per_objfile
->using_index
4521 ? !item
->per_cu
->v
.quick
->symtab
4522 : (item
->per_cu
->v
.psymtab
&& !item
->per_cu
->v
.psymtab
->readin
))
4523 process_full_comp_unit (item
->per_cu
);
4525 item
->per_cu
->queued
= 0;
4526 next_item
= item
->next
;
4530 dwarf2_queue_tail
= NULL
;
4533 /* Free all allocated queue entries. This function only releases anything if
4534 an error was thrown; if the queue was processed then it would have been
4535 freed as we went along. */
4538 dwarf2_release_queue (void *dummy
)
4540 struct dwarf2_queue_item
*item
, *last
;
4542 item
= dwarf2_queue
;
4545 /* Anything still marked queued is likely to be in an
4546 inconsistent state, so discard it. */
4547 if (item
->per_cu
->queued
)
4549 if (item
->per_cu
->cu
!= NULL
)
4550 free_one_cached_comp_unit (item
->per_cu
->cu
);
4551 item
->per_cu
->queued
= 0;
4559 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
4562 /* Read in full symbols for PST, and anything it depends on. */
4565 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
4567 struct dwarf2_per_cu_data
*per_cu
;
4568 struct cleanup
*back_to
;
4571 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
4572 if (!pst
->dependencies
[i
]->readin
)
4574 /* Inform about additional files that need to be read in. */
4577 /* FIXME: i18n: Need to make this a single string. */
4578 fputs_filtered (" ", gdb_stdout
);
4580 fputs_filtered ("and ", gdb_stdout
);
4582 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
4583 wrap_here (""); /* Flush output. */
4584 gdb_flush (gdb_stdout
);
4586 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
4589 per_cu
= pst
->read_symtab_private
;
4593 /* It's an include file, no symbols to read for it.
4594 Everything is in the parent symtab. */
4599 dw2_do_instantiate_symtab (per_cu
);
4602 /* Load the DIEs associated with PER_CU into memory. */
4605 load_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
4607 struct objfile
*objfile
= per_cu
->objfile
;
4608 bfd
*abfd
= objfile
->obfd
;
4609 struct dwarf2_cu
*cu
;
4610 unsigned int offset
;
4611 gdb_byte
*info_ptr
, *beg_of_comp_unit
;
4612 struct cleanup
*free_abbrevs_cleanup
= NULL
, *free_cu_cleanup
= NULL
;
4613 struct attribute
*attr
;
4616 gdb_assert (! per_cu
->debug_types_section
);
4618 /* Set local variables from the partial symbol table info. */
4619 offset
= per_cu
->offset
;
4621 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
4622 info_ptr
= dwarf2_per_objfile
->info
.buffer
+ offset
;
4623 beg_of_comp_unit
= info_ptr
;
4625 if (per_cu
->cu
== NULL
)
4627 cu
= xmalloc (sizeof (*cu
));
4628 init_one_comp_unit (cu
, per_cu
);
4632 /* If an error occurs while loading, release our storage. */
4633 free_cu_cleanup
= make_cleanup (free_heap_comp_unit
, cu
);
4635 /* Read in the comp_unit header. */
4636 info_ptr
= read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
4638 /* Skip dummy compilation units. */
4639 if (info_ptr
>= (dwarf2_per_objfile
->info
.buffer
4640 + dwarf2_per_objfile
->info
.size
)
4641 || peek_abbrev_code (abfd
, info_ptr
) == 0)
4643 do_cleanups (free_cu_cleanup
);
4647 /* Complete the cu_header. */
4648 cu
->header
.offset
= offset
;
4649 cu
->header
.first_die_offset
= info_ptr
- beg_of_comp_unit
;
4651 /* Read the abbrevs for this compilation unit. */
4652 dwarf2_read_abbrevs (cu
);
4653 free_abbrevs_cleanup
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
4655 /* Link this CU into read_in_chain. */
4656 per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
4657 dwarf2_per_objfile
->read_in_chain
= per_cu
;
4662 info_ptr
+= cu
->header
.first_die_offset
;
4665 cu
->dies
= read_comp_unit (info_ptr
, cu
);
4667 /* We try not to read any attributes in this function, because not
4668 all CUs needed for references have been loaded yet, and symbol
4669 table processing isn't initialized. But we have to set the CU language,
4670 or we won't be able to build types correctly. */
4671 prepare_one_comp_unit (cu
, cu
->dies
);
4673 /* Similarly, if we do not read the producer, we can not apply
4674 producer-specific interpretation. */
4675 attr
= dwarf2_attr (cu
->dies
, DW_AT_producer
, cu
);
4677 cu
->producer
= DW_STRING (attr
);
4681 do_cleanups (free_abbrevs_cleanup
);
4683 /* We've successfully allocated this compilation unit. Let our
4684 caller clean it up when finished with it. */
4685 discard_cleanups (free_cu_cleanup
);
4689 /* Add a DIE to the delayed physname list. */
4692 add_to_method_list (struct type
*type
, int fnfield_index
, int index
,
4693 const char *name
, struct die_info
*die
,
4694 struct dwarf2_cu
*cu
)
4696 struct delayed_method_info mi
;
4698 mi
.fnfield_index
= fnfield_index
;
4702 VEC_safe_push (delayed_method_info
, cu
->method_list
, &mi
);
4705 /* A cleanup for freeing the delayed method list. */
4708 free_delayed_list (void *ptr
)
4710 struct dwarf2_cu
*cu
= (struct dwarf2_cu
*) ptr
;
4711 if (cu
->method_list
!= NULL
)
4713 VEC_free (delayed_method_info
, cu
->method_list
);
4714 cu
->method_list
= NULL
;
4718 /* Compute the physnames of any methods on the CU's method list.
4720 The computation of method physnames is delayed in order to avoid the
4721 (bad) condition that one of the method's formal parameters is of an as yet
4725 compute_delayed_physnames (struct dwarf2_cu
*cu
)
4728 struct delayed_method_info
*mi
;
4729 for (i
= 0; VEC_iterate (delayed_method_info
, cu
->method_list
, i
, mi
) ; ++i
)
4731 const char *physname
;
4732 struct fn_fieldlist
*fn_flp
4733 = &TYPE_FN_FIELDLIST (mi
->type
, mi
->fnfield_index
);
4734 physname
= dwarf2_physname ((char *) mi
->name
, mi
->die
, cu
);
4735 fn_flp
->fn_fields
[mi
->index
].physname
= physname
? physname
: "";
4739 /* Generate full symbol information for PER_CU, whose DIEs have
4740 already been loaded into memory. */
4743 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
4745 struct dwarf2_cu
*cu
= per_cu
->cu
;
4746 struct objfile
*objfile
= per_cu
->objfile
;
4747 CORE_ADDR lowpc
, highpc
;
4748 struct symtab
*symtab
;
4749 struct cleanup
*back_to
, *delayed_list_cleanup
;
4752 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
4755 back_to
= make_cleanup (really_free_pendings
, NULL
);
4756 delayed_list_cleanup
= make_cleanup (free_delayed_list
, cu
);
4758 cu
->list_in_scope
= &file_symbols
;
4760 /* Do line number decoding in read_file_scope () */
4761 process_die (cu
->dies
, cu
);
4763 /* Now that we have processed all the DIEs in the CU, all the types
4764 should be complete, and it should now be safe to compute all of the
4766 compute_delayed_physnames (cu
);
4767 do_cleanups (delayed_list_cleanup
);
4769 /* Some compilers don't define a DW_AT_high_pc attribute for the
4770 compilation unit. If the DW_AT_high_pc is missing, synthesize
4771 it, by scanning the DIE's below the compilation unit. */
4772 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
4774 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
4778 int gcc_4_minor
= producer_is_gcc_ge_4 (cu
->producer
);
4780 /* Set symtab language to language from DW_AT_language. If the
4781 compilation is from a C file generated by language preprocessors, do
4782 not set the language if it was already deduced by start_subfile. */
4783 if (!(cu
->language
== language_c
&& symtab
->language
!= language_c
))
4784 symtab
->language
= cu
->language
;
4786 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
4787 produce DW_AT_location with location lists but it can be possibly
4788 invalid without -fvar-tracking.
4790 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
4791 needed, it would be wrong due to missing DW_AT_producer there.
4793 Still one can confuse GDB by using non-standard GCC compilation
4794 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
4796 if (cu
->has_loclist
&& gcc_4_minor
>= 0)
4797 symtab
->locations_valid
= 1;
4799 if (gcc_4_minor
>= 5)
4800 symtab
->epilogue_unwind_valid
= 1;
4802 symtab
->call_site_htab
= cu
->call_site_htab
;
4805 if (dwarf2_per_objfile
->using_index
)
4806 per_cu
->v
.quick
->symtab
= symtab
;
4809 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
4810 pst
->symtab
= symtab
;
4814 do_cleanups (back_to
);
4817 /* Process a die and its children. */
4820 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
4824 case DW_TAG_padding
:
4826 case DW_TAG_compile_unit
:
4827 read_file_scope (die
, cu
);
4829 case DW_TAG_type_unit
:
4830 read_type_unit_scope (die
, cu
);
4832 case DW_TAG_subprogram
:
4833 case DW_TAG_inlined_subroutine
:
4834 read_func_scope (die
, cu
);
4836 case DW_TAG_lexical_block
:
4837 case DW_TAG_try_block
:
4838 case DW_TAG_catch_block
:
4839 read_lexical_block_scope (die
, cu
);
4841 case DW_TAG_GNU_call_site
:
4842 read_call_site_scope (die
, cu
);
4844 case DW_TAG_class_type
:
4845 case DW_TAG_interface_type
:
4846 case DW_TAG_structure_type
:
4847 case DW_TAG_union_type
:
4848 process_structure_scope (die
, cu
);
4850 case DW_TAG_enumeration_type
:
4851 process_enumeration_scope (die
, cu
);
4854 /* These dies have a type, but processing them does not create
4855 a symbol or recurse to process the children. Therefore we can
4856 read them on-demand through read_type_die. */
4857 case DW_TAG_subroutine_type
:
4858 case DW_TAG_set_type
:
4859 case DW_TAG_array_type
:
4860 case DW_TAG_pointer_type
:
4861 case DW_TAG_ptr_to_member_type
:
4862 case DW_TAG_reference_type
:
4863 case DW_TAG_string_type
:
4866 case DW_TAG_base_type
:
4867 case DW_TAG_subrange_type
:
4868 case DW_TAG_typedef
:
4869 /* Add a typedef symbol for the type definition, if it has a
4871 new_symbol (die
, read_type_die (die
, cu
), cu
);
4873 case DW_TAG_common_block
:
4874 read_common_block (die
, cu
);
4876 case DW_TAG_common_inclusion
:
4878 case DW_TAG_namespace
:
4879 processing_has_namespace_info
= 1;
4880 read_namespace (die
, cu
);
4883 processing_has_namespace_info
= 1;
4884 read_module (die
, cu
);
4886 case DW_TAG_imported_declaration
:
4887 case DW_TAG_imported_module
:
4888 processing_has_namespace_info
= 1;
4889 if (die
->child
!= NULL
&& (die
->tag
== DW_TAG_imported_declaration
4890 || cu
->language
!= language_fortran
))
4891 complaint (&symfile_complaints
, _("Tag '%s' has unexpected children"),
4892 dwarf_tag_name (die
->tag
));
4893 read_import_statement (die
, cu
);
4896 new_symbol (die
, NULL
, cu
);
4901 /* A helper function for dwarf2_compute_name which determines whether DIE
4902 needs to have the name of the scope prepended to the name listed in the
4906 die_needs_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
4908 struct attribute
*attr
;
4912 case DW_TAG_namespace
:
4913 case DW_TAG_typedef
:
4914 case DW_TAG_class_type
:
4915 case DW_TAG_interface_type
:
4916 case DW_TAG_structure_type
:
4917 case DW_TAG_union_type
:
4918 case DW_TAG_enumeration_type
:
4919 case DW_TAG_enumerator
:
4920 case DW_TAG_subprogram
:
4924 case DW_TAG_variable
:
4925 case DW_TAG_constant
:
4926 /* We only need to prefix "globally" visible variables. These include
4927 any variable marked with DW_AT_external or any variable that
4928 lives in a namespace. [Variables in anonymous namespaces
4929 require prefixing, but they are not DW_AT_external.] */
4931 if (dwarf2_attr (die
, DW_AT_specification
, cu
))
4933 struct dwarf2_cu
*spec_cu
= cu
;
4935 return die_needs_namespace (die_specification (die
, &spec_cu
),
4939 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
4940 if (attr
== NULL
&& die
->parent
->tag
!= DW_TAG_namespace
4941 && die
->parent
->tag
!= DW_TAG_module
)
4943 /* A variable in a lexical block of some kind does not need a
4944 namespace, even though in C++ such variables may be external
4945 and have a mangled name. */
4946 if (die
->parent
->tag
== DW_TAG_lexical_block
4947 || die
->parent
->tag
== DW_TAG_try_block
4948 || die
->parent
->tag
== DW_TAG_catch_block
4949 || die
->parent
->tag
== DW_TAG_subprogram
)
4958 /* Retrieve the last character from a mem_file. */
4961 do_ui_file_peek_last (void *object
, const char *buffer
, long length
)
4963 char *last_char_p
= (char *) object
;
4966 *last_char_p
= buffer
[length
- 1];
4969 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
4970 compute the physname for the object, which include a method's
4971 formal parameters (C++/Java) and return type (Java).
4973 For Ada, return the DIE's linkage name rather than the fully qualified
4974 name. PHYSNAME is ignored..
4976 The result is allocated on the objfile_obstack and canonicalized. */
4979 dwarf2_compute_name (char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
,
4982 struct objfile
*objfile
= cu
->objfile
;
4985 name
= dwarf2_name (die
, cu
);
4987 /* For Fortran GDB prefers DW_AT_*linkage_name if present but otherwise
4988 compute it by typename_concat inside GDB. */
4989 if (cu
->language
== language_ada
4990 || (cu
->language
== language_fortran
&& physname
))
4992 /* For Ada unit, we prefer the linkage name over the name, as
4993 the former contains the exported name, which the user expects
4994 to be able to reference. Ideally, we want the user to be able
4995 to reference this entity using either natural or linkage name,
4996 but we haven't started looking at this enhancement yet. */
4997 struct attribute
*attr
;
4999 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
5001 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
5002 if (attr
&& DW_STRING (attr
))
5003 return DW_STRING (attr
);
5006 /* These are the only languages we know how to qualify names in. */
5008 && (cu
->language
== language_cplus
|| cu
->language
== language_java
5009 || cu
->language
== language_fortran
))
5011 if (die_needs_namespace (die
, cu
))
5015 struct ui_file
*buf
;
5017 prefix
= determine_prefix (die
, cu
);
5018 buf
= mem_fileopen ();
5019 if (*prefix
!= '\0')
5021 char *prefixed_name
= typename_concat (NULL
, prefix
, name
,
5024 fputs_unfiltered (prefixed_name
, buf
);
5025 xfree (prefixed_name
);
5028 fputs_unfiltered (name
, buf
);
5030 /* Template parameters may be specified in the DIE's DW_AT_name, or
5031 as children with DW_TAG_template_type_param or
5032 DW_TAG_value_type_param. If the latter, add them to the name
5033 here. If the name already has template parameters, then
5034 skip this step; some versions of GCC emit both, and
5035 it is more efficient to use the pre-computed name.
5037 Something to keep in mind about this process: it is very
5038 unlikely, or in some cases downright impossible, to produce
5039 something that will match the mangled name of a function.
5040 If the definition of the function has the same debug info,
5041 we should be able to match up with it anyway. But fallbacks
5042 using the minimal symbol, for instance to find a method
5043 implemented in a stripped copy of libstdc++, will not work.
5044 If we do not have debug info for the definition, we will have to
5045 match them up some other way.
5047 When we do name matching there is a related problem with function
5048 templates; two instantiated function templates are allowed to
5049 differ only by their return types, which we do not add here. */
5051 if (cu
->language
== language_cplus
&& strchr (name
, '<') == NULL
)
5053 struct attribute
*attr
;
5054 struct die_info
*child
;
5057 die
->building_fullname
= 1;
5059 for (child
= die
->child
; child
!= NULL
; child
= child
->sibling
)
5064 struct dwarf2_locexpr_baton
*baton
;
5067 if (child
->tag
!= DW_TAG_template_type_param
5068 && child
->tag
!= DW_TAG_template_value_param
)
5073 fputs_unfiltered ("<", buf
);
5077 fputs_unfiltered (", ", buf
);
5079 attr
= dwarf2_attr (child
, DW_AT_type
, cu
);
5082 complaint (&symfile_complaints
,
5083 _("template parameter missing DW_AT_type"));
5084 fputs_unfiltered ("UNKNOWN_TYPE", buf
);
5087 type
= die_type (child
, cu
);
5089 if (child
->tag
== DW_TAG_template_type_param
)
5091 c_print_type (type
, "", buf
, -1, 0);
5095 attr
= dwarf2_attr (child
, DW_AT_const_value
, cu
);
5098 complaint (&symfile_complaints
,
5099 _("template parameter missing "
5100 "DW_AT_const_value"));
5101 fputs_unfiltered ("UNKNOWN_VALUE", buf
);
5105 dwarf2_const_value_attr (attr
, type
, name
,
5106 &cu
->comp_unit_obstack
, cu
,
5107 &value
, &bytes
, &baton
);
5109 if (TYPE_NOSIGN (type
))
5110 /* GDB prints characters as NUMBER 'CHAR'. If that's
5111 changed, this can use value_print instead. */
5112 c_printchar (value
, type
, buf
);
5115 struct value_print_options opts
;
5118 v
= dwarf2_evaluate_loc_desc (type
, NULL
,
5122 else if (bytes
!= NULL
)
5124 v
= allocate_value (type
);
5125 memcpy (value_contents_writeable (v
), bytes
,
5126 TYPE_LENGTH (type
));
5129 v
= value_from_longest (type
, value
);
5131 /* Specify decimal so that we do not depend on
5133 get_formatted_print_options (&opts
, 'd');
5135 value_print (v
, buf
, &opts
);
5141 die
->building_fullname
= 0;
5145 /* Close the argument list, with a space if necessary
5146 (nested templates). */
5147 char last_char
= '\0';
5148 ui_file_put (buf
, do_ui_file_peek_last
, &last_char
);
5149 if (last_char
== '>')
5150 fputs_unfiltered (" >", buf
);
5152 fputs_unfiltered (">", buf
);
5156 /* For Java and C++ methods, append formal parameter type
5157 information, if PHYSNAME. */
5159 if (physname
&& die
->tag
== DW_TAG_subprogram
5160 && (cu
->language
== language_cplus
5161 || cu
->language
== language_java
))
5163 struct type
*type
= read_type_die (die
, cu
);
5165 c_type_print_args (type
, buf
, 1, cu
->language
);
5167 if (cu
->language
== language_java
)
5169 /* For java, we must append the return type to method
5171 if (die
->tag
== DW_TAG_subprogram
)
5172 java_print_type (TYPE_TARGET_TYPE (type
), "", buf
,
5175 else if (cu
->language
== language_cplus
)
5177 /* Assume that an artificial first parameter is
5178 "this", but do not crash if it is not. RealView
5179 marks unnamed (and thus unused) parameters as
5180 artificial; there is no way to differentiate
5182 if (TYPE_NFIELDS (type
) > 0
5183 && TYPE_FIELD_ARTIFICIAL (type
, 0)
5184 && TYPE_CODE (TYPE_FIELD_TYPE (type
, 0)) == TYPE_CODE_PTR
5185 && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type
,
5187 fputs_unfiltered (" const", buf
);
5191 name
= ui_file_obsavestring (buf
, &objfile
->objfile_obstack
,
5193 ui_file_delete (buf
);
5195 if (cu
->language
== language_cplus
)
5198 = dwarf2_canonicalize_name (name
, cu
,
5199 &objfile
->objfile_obstack
);
5210 /* Return the fully qualified name of DIE, based on its DW_AT_name.
5211 If scope qualifiers are appropriate they will be added. The result
5212 will be allocated on the objfile_obstack, or NULL if the DIE does
5213 not have a name. NAME may either be from a previous call to
5214 dwarf2_name or NULL.
5216 The output string will be canonicalized (if C++/Java). */
5219 dwarf2_full_name (char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
5221 return dwarf2_compute_name (name
, die
, cu
, 0);
5224 /* Construct a physname for the given DIE in CU. NAME may either be
5225 from a previous call to dwarf2_name or NULL. The result will be
5226 allocated on the objfile_objstack or NULL if the DIE does not have a
5229 The output string will be canonicalized (if C++/Java). */
5232 dwarf2_physname (char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
5234 struct objfile
*objfile
= cu
->objfile
;
5235 struct attribute
*attr
;
5236 const char *retval
, *mangled
= NULL
, *canon
= NULL
;
5237 struct cleanup
*back_to
;
5240 /* In this case dwarf2_compute_name is just a shortcut not building anything
5242 if (!die_needs_namespace (die
, cu
))
5243 return dwarf2_compute_name (name
, die
, cu
, 1);
5245 back_to
= make_cleanup (null_cleanup
, NULL
);
5247 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
5249 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
5251 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
5253 if (attr
&& DW_STRING (attr
))
5257 mangled
= DW_STRING (attr
);
5259 /* Use DMGL_RET_DROP for C++ template functions to suppress their return
5260 type. It is easier for GDB users to search for such functions as
5261 `name(params)' than `long name(params)'. In such case the minimal
5262 symbol names do not match the full symbol names but for template
5263 functions there is never a need to look up their definition from their
5264 declaration so the only disadvantage remains the minimal symbol
5265 variant `long name(params)' does not have the proper inferior type.
5268 demangled
= cplus_demangle (mangled
, (DMGL_PARAMS
| DMGL_ANSI
5269 | (cu
->language
== language_java
5270 ? DMGL_JAVA
| DMGL_RET_POSTFIX
5274 make_cleanup (xfree
, demangled
);
5284 if (canon
== NULL
|| check_physname
)
5286 const char *physname
= dwarf2_compute_name (name
, die
, cu
, 1);
5288 if (canon
!= NULL
&& strcmp (physname
, canon
) != 0)
5290 /* It may not mean a bug in GDB. The compiler could also
5291 compute DW_AT_linkage_name incorrectly. But in such case
5292 GDB would need to be bug-to-bug compatible. */
5294 complaint (&symfile_complaints
,
5295 _("Computed physname <%s> does not match demangled <%s> "
5296 "(from linkage <%s>) - DIE at 0x%x [in module %s]"),
5297 physname
, canon
, mangled
, die
->offset
, objfile
->name
);
5299 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
5300 is available here - over computed PHYSNAME. It is safer
5301 against both buggy GDB and buggy compilers. */
5315 retval
= obsavestring (retval
, strlen (retval
),
5316 &objfile
->objfile_obstack
);
5318 do_cleanups (back_to
);
5322 /* Read the import statement specified by the given die and record it. */
5325 read_import_statement (struct die_info
*die
, struct dwarf2_cu
*cu
)
5327 struct objfile
*objfile
= cu
->objfile
;
5328 struct attribute
*import_attr
;
5329 struct die_info
*imported_die
, *child_die
;
5330 struct dwarf2_cu
*imported_cu
;
5331 const char *imported_name
;
5332 const char *imported_name_prefix
;
5333 const char *canonical_name
;
5334 const char *import_alias
;
5335 const char *imported_declaration
= NULL
;
5336 const char *import_prefix
;
5337 VEC (const_char_ptr
) *excludes
= NULL
;
5338 struct cleanup
*cleanups
;
5342 import_attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
5343 if (import_attr
== NULL
)
5345 complaint (&symfile_complaints
, _("Tag '%s' has no DW_AT_import"),
5346 dwarf_tag_name (die
->tag
));
5351 imported_die
= follow_die_ref_or_sig (die
, import_attr
, &imported_cu
);
5352 imported_name
= dwarf2_name (imported_die
, imported_cu
);
5353 if (imported_name
== NULL
)
5355 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
5357 The import in the following code:
5371 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
5372 <52> DW_AT_decl_file : 1
5373 <53> DW_AT_decl_line : 6
5374 <54> DW_AT_import : <0x75>
5375 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
5377 <5b> DW_AT_decl_file : 1
5378 <5c> DW_AT_decl_line : 2
5379 <5d> DW_AT_type : <0x6e>
5381 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
5382 <76> DW_AT_byte_size : 4
5383 <77> DW_AT_encoding : 5 (signed)
5385 imports the wrong die ( 0x75 instead of 0x58 ).
5386 This case will be ignored until the gcc bug is fixed. */
5390 /* Figure out the local name after import. */
5391 import_alias
= dwarf2_name (die
, cu
);
5393 /* Figure out where the statement is being imported to. */
5394 import_prefix
= determine_prefix (die
, cu
);
5396 /* Figure out what the scope of the imported die is and prepend it
5397 to the name of the imported die. */
5398 imported_name_prefix
= determine_prefix (imported_die
, imported_cu
);
5400 if (imported_die
->tag
!= DW_TAG_namespace
5401 && imported_die
->tag
!= DW_TAG_module
)
5403 imported_declaration
= imported_name
;
5404 canonical_name
= imported_name_prefix
;
5406 else if (strlen (imported_name_prefix
) > 0)
5408 temp
= alloca (strlen (imported_name_prefix
)
5409 + 2 + strlen (imported_name
) + 1);
5410 strcpy (temp
, imported_name_prefix
);
5411 strcat (temp
, "::");
5412 strcat (temp
, imported_name
);
5413 canonical_name
= temp
;
5416 canonical_name
= imported_name
;
5418 cleanups
= make_cleanup (VEC_cleanup (const_char_ptr
), &excludes
);
5420 if (die
->tag
== DW_TAG_imported_module
&& cu
->language
== language_fortran
)
5421 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
5422 child_die
= sibling_die (child_die
))
5424 /* DWARF-4: A Fortran use statement with a “rename list” may be
5425 represented by an imported module entry with an import attribute
5426 referring to the module and owned entries corresponding to those
5427 entities that are renamed as part of being imported. */
5429 if (child_die
->tag
!= DW_TAG_imported_declaration
)
5431 complaint (&symfile_complaints
,
5432 _("child DW_TAG_imported_declaration expected "
5433 "- DIE at 0x%x [in module %s]"),
5434 child_die
->offset
, objfile
->name
);
5438 import_attr
= dwarf2_attr (child_die
, DW_AT_import
, cu
);
5439 if (import_attr
== NULL
)
5441 complaint (&symfile_complaints
, _("Tag '%s' has no DW_AT_import"),
5442 dwarf_tag_name (child_die
->tag
));
5447 imported_die
= follow_die_ref_or_sig (child_die
, import_attr
,
5449 imported_name
= dwarf2_name (imported_die
, imported_cu
);
5450 if (imported_name
== NULL
)
5452 complaint (&symfile_complaints
,
5453 _("child DW_TAG_imported_declaration has unknown "
5454 "imported name - DIE at 0x%x [in module %s]"),
5455 child_die
->offset
, objfile
->name
);
5459 VEC_safe_push (const_char_ptr
, excludes
, imported_name
);
5461 process_die (child_die
, cu
);
5464 cp_add_using_directive (import_prefix
,
5467 imported_declaration
,
5469 &objfile
->objfile_obstack
);
5471 do_cleanups (cleanups
);
5474 /* Cleanup function for read_file_scope. */
5477 free_cu_line_header (void *arg
)
5479 struct dwarf2_cu
*cu
= arg
;
5481 free_line_header (cu
->line_header
);
5482 cu
->line_header
= NULL
;
5486 find_file_and_directory (struct die_info
*die
, struct dwarf2_cu
*cu
,
5487 char **name
, char **comp_dir
)
5489 struct attribute
*attr
;
5494 /* Find the filename. Do not use dwarf2_name here, since the filename
5495 is not a source language identifier. */
5496 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
5499 *name
= DW_STRING (attr
);
5502 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
5504 *comp_dir
= DW_STRING (attr
);
5505 else if (*name
!= NULL
&& IS_ABSOLUTE_PATH (*name
))
5507 *comp_dir
= ldirname (*name
);
5508 if (*comp_dir
!= NULL
)
5509 make_cleanup (xfree
, *comp_dir
);
5511 if (*comp_dir
!= NULL
)
5513 /* Irix 6.2 native cc prepends <machine>.: to the compilation
5514 directory, get rid of it. */
5515 char *cp
= strchr (*comp_dir
, ':');
5517 if (cp
&& cp
!= *comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
5522 *name
= "<unknown>";
5525 /* Handle DW_AT_stmt_list for a compilation unit or type unit.
5526 DIE is the DW_TAG_compile_unit or DW_TAG_type_unit die for CU.
5527 COMP_DIR is the compilation directory.
5528 WANT_LINE_INFO is non-zero if the pc/line-number mapping is needed. */
5531 handle_DW_AT_stmt_list (struct die_info
*die
, struct dwarf2_cu
*cu
,
5532 const char *comp_dir
, int want_line_info
)
5534 struct attribute
*attr
;
5535 struct objfile
*objfile
= cu
->objfile
;
5536 bfd
*abfd
= objfile
->obfd
;
5538 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
5541 unsigned int line_offset
= DW_UNSND (attr
);
5542 struct line_header
*line_header
5543 = dwarf_decode_line_header (line_offset
, abfd
, cu
);
5547 cu
->line_header
= line_header
;
5548 make_cleanup (free_cu_line_header
, cu
);
5549 dwarf_decode_lines (line_header
, comp_dir
, cu
, NULL
, want_line_info
);
5554 /* Process DW_TAG_compile_unit. */
5557 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
5559 struct objfile
*objfile
= cu
->objfile
;
5560 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
5561 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
5562 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
5563 struct attribute
*attr
;
5565 char *comp_dir
= NULL
;
5566 struct die_info
*child_die
;
5567 bfd
*abfd
= objfile
->obfd
;
5570 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
5572 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
5574 /* If we didn't find a lowpc, set it to highpc to avoid complaints
5575 from finish_block. */
5576 if (lowpc
== ((CORE_ADDR
) -1))
5581 find_file_and_directory (die
, cu
, &name
, &comp_dir
);
5583 attr
= dwarf2_attr (die
, DW_AT_language
, cu
);
5586 set_cu_language (DW_UNSND (attr
), cu
);
5589 attr
= dwarf2_attr (die
, DW_AT_producer
, cu
);
5591 cu
->producer
= DW_STRING (attr
);
5593 /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
5594 standardised yet. As a workaround for the language detection we fall
5595 back to the DW_AT_producer string. */
5596 if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL") != NULL
)
5597 cu
->language
= language_opencl
;
5599 /* We assume that we're processing GCC output. */
5600 processing_gcc_compilation
= 2;
5602 processing_has_namespace_info
= 0;
5604 start_symtab (name
, comp_dir
, lowpc
);
5605 record_debugformat ("DWARF 2");
5606 record_producer (cu
->producer
);
5608 /* Decode line number information if present. We do this before
5609 processing child DIEs, so that the line header table is available
5610 for DW_AT_decl_file. */
5611 handle_DW_AT_stmt_list (die
, cu
, comp_dir
, 1);
5613 /* Process all dies in compilation unit. */
5614 if (die
->child
!= NULL
)
5616 child_die
= die
->child
;
5617 while (child_die
&& child_die
->tag
)
5619 process_die (child_die
, cu
);
5620 child_die
= sibling_die (child_die
);
5624 /* Decode macro information, if present. Dwarf 2 macro information
5625 refers to information in the line number info statement program
5626 header, so we can only read it if we've read the header
5628 attr
= dwarf2_attr (die
, DW_AT_GNU_macros
, cu
);
5629 if (attr
&& cu
->line_header
)
5631 if (dwarf2_attr (die
, DW_AT_macro_info
, cu
))
5632 complaint (&symfile_complaints
,
5633 _("CU refers to both DW_AT_GNU_macros and DW_AT_macro_info"));
5635 dwarf_decode_macros (cu
->line_header
, DW_UNSND (attr
),
5637 &dwarf2_per_objfile
->macro
, 1);
5641 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
5642 if (attr
&& cu
->line_header
)
5644 unsigned int macro_offset
= DW_UNSND (attr
);
5646 dwarf_decode_macros (cu
->line_header
, macro_offset
,
5648 &dwarf2_per_objfile
->macinfo
, 0);
5652 do_cleanups (back_to
);
5655 /* Process DW_TAG_type_unit.
5656 For TUs we want to skip the first top level sibling if it's not the
5657 actual type being defined by this TU. In this case the first top
5658 level sibling is there to provide context only. */
5661 read_type_unit_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
5663 struct objfile
*objfile
= cu
->objfile
;
5664 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
5666 struct attribute
*attr
;
5668 char *comp_dir
= NULL
;
5669 struct die_info
*child_die
;
5670 bfd
*abfd
= objfile
->obfd
;
5672 /* start_symtab needs a low pc, but we don't really have one.
5673 Do what read_file_scope would do in the absence of such info. */
5674 lowpc
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
5676 /* Find the filename. Do not use dwarf2_name here, since the filename
5677 is not a source language identifier. */
5678 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
5680 name
= DW_STRING (attr
);
5682 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
5684 comp_dir
= DW_STRING (attr
);
5685 else if (name
!= NULL
&& IS_ABSOLUTE_PATH (name
))
5687 comp_dir
= ldirname (name
);
5688 if (comp_dir
!= NULL
)
5689 make_cleanup (xfree
, comp_dir
);
5695 attr
= dwarf2_attr (die
, DW_AT_language
, cu
);
5697 set_cu_language (DW_UNSND (attr
), cu
);
5699 /* This isn't technically needed today. It is done for symmetry
5700 with read_file_scope. */
5701 attr
= dwarf2_attr (die
, DW_AT_producer
, cu
);
5703 cu
->producer
= DW_STRING (attr
);
5705 /* We assume that we're processing GCC output. */
5706 processing_gcc_compilation
= 2;
5708 processing_has_namespace_info
= 0;
5710 start_symtab (name
, comp_dir
, lowpc
);
5711 record_debugformat ("DWARF 2");
5712 record_producer (cu
->producer
);
5714 /* Decode line number information if present. We do this before
5715 processing child DIEs, so that the line header table is available
5716 for DW_AT_decl_file.
5717 We don't need the pc/line-number mapping for type units. */
5718 handle_DW_AT_stmt_list (die
, cu
, comp_dir
, 0);
5720 /* Process the dies in the type unit. */
5721 if (die
->child
== NULL
)
5723 dump_die_for_error (die
);
5724 error (_("Dwarf Error: Missing children for type unit [in module %s]"),
5725 bfd_get_filename (abfd
));
5728 child_die
= die
->child
;
5730 while (child_die
&& child_die
->tag
)
5732 process_die (child_die
, cu
);
5734 child_die
= sibling_die (child_die
);
5737 do_cleanups (back_to
);
5740 /* qsort helper for inherit_abstract_dies. */
5743 unsigned_int_compar (const void *ap
, const void *bp
)
5745 unsigned int a
= *(unsigned int *) ap
;
5746 unsigned int b
= *(unsigned int *) bp
;
5748 return (a
> b
) - (b
> a
);
5751 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
5752 Inherit only the children of the DW_AT_abstract_origin DIE not being
5753 already referenced by DW_AT_abstract_origin from the children of the
5757 inherit_abstract_dies (struct die_info
*die
, struct dwarf2_cu
*cu
)
5759 struct die_info
*child_die
;
5760 unsigned die_children_count
;
5761 /* CU offsets which were referenced by children of the current DIE. */
5763 unsigned *offsets_end
, *offsetp
;
5764 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
5765 struct die_info
*origin_die
;
5766 /* Iterator of the ORIGIN_DIE children. */
5767 struct die_info
*origin_child_die
;
5768 struct cleanup
*cleanups
;
5769 struct attribute
*attr
;
5770 struct dwarf2_cu
*origin_cu
;
5771 struct pending
**origin_previous_list_in_scope
;
5773 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
5777 /* Note that following die references may follow to a die in a
5781 origin_die
= follow_die_ref (die
, attr
, &origin_cu
);
5783 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
5785 origin_previous_list_in_scope
= origin_cu
->list_in_scope
;
5786 origin_cu
->list_in_scope
= cu
->list_in_scope
;
5788 if (die
->tag
!= origin_die
->tag
5789 && !(die
->tag
== DW_TAG_inlined_subroutine
5790 && origin_die
->tag
== DW_TAG_subprogram
))
5791 complaint (&symfile_complaints
,
5792 _("DIE 0x%x and its abstract origin 0x%x have different tags"),
5793 die
->offset
, origin_die
->offset
);
5795 child_die
= die
->child
;
5796 die_children_count
= 0;
5797 while (child_die
&& child_die
->tag
)
5799 child_die
= sibling_die (child_die
);
5800 die_children_count
++;
5802 offsets
= xmalloc (sizeof (*offsets
) * die_children_count
);
5803 cleanups
= make_cleanup (xfree
, offsets
);
5805 offsets_end
= offsets
;
5806 child_die
= die
->child
;
5807 while (child_die
&& child_die
->tag
)
5809 /* For each CHILD_DIE, find the corresponding child of
5810 ORIGIN_DIE. If there is more than one layer of
5811 DW_AT_abstract_origin, follow them all; there shouldn't be,
5812 but GCC versions at least through 4.4 generate this (GCC PR
5814 struct die_info
*child_origin_die
= child_die
;
5815 struct dwarf2_cu
*child_origin_cu
= cu
;
5819 attr
= dwarf2_attr (child_origin_die
, DW_AT_abstract_origin
,
5823 child_origin_die
= follow_die_ref (child_origin_die
, attr
,
5827 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
5828 counterpart may exist. */
5829 if (child_origin_die
!= child_die
)
5831 if (child_die
->tag
!= child_origin_die
->tag
5832 && !(child_die
->tag
== DW_TAG_inlined_subroutine
5833 && child_origin_die
->tag
== DW_TAG_subprogram
))
5834 complaint (&symfile_complaints
,
5835 _("Child DIE 0x%x and its abstract origin 0x%x have "
5836 "different tags"), child_die
->offset
,
5837 child_origin_die
->offset
);
5838 if (child_origin_die
->parent
!= origin_die
)
5839 complaint (&symfile_complaints
,
5840 _("Child DIE 0x%x and its abstract origin 0x%x have "
5841 "different parents"), child_die
->offset
,
5842 child_origin_die
->offset
);
5844 *offsets_end
++ = child_origin_die
->offset
;
5846 child_die
= sibling_die (child_die
);
5848 qsort (offsets
, offsets_end
- offsets
, sizeof (*offsets
),
5849 unsigned_int_compar
);
5850 for (offsetp
= offsets
+ 1; offsetp
< offsets_end
; offsetp
++)
5851 if (offsetp
[-1] == *offsetp
)
5852 complaint (&symfile_complaints
,
5853 _("Multiple children of DIE 0x%x refer "
5854 "to DIE 0x%x as their abstract origin"),
5855 die
->offset
, *offsetp
);
5858 origin_child_die
= origin_die
->child
;
5859 while (origin_child_die
&& origin_child_die
->tag
)
5861 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
5862 while (offsetp
< offsets_end
&& *offsetp
< origin_child_die
->offset
)
5864 if (offsetp
>= offsets_end
|| *offsetp
> origin_child_die
->offset
)
5866 /* Found that ORIGIN_CHILD_DIE is really not referenced. */
5867 process_die (origin_child_die
, origin_cu
);
5869 origin_child_die
= sibling_die (origin_child_die
);
5871 origin_cu
->list_in_scope
= origin_previous_list_in_scope
;
5873 do_cleanups (cleanups
);
5877 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
5879 struct objfile
*objfile
= cu
->objfile
;
5880 struct context_stack
*new;
5883 struct die_info
*child_die
;
5884 struct attribute
*attr
, *call_line
, *call_file
;
5887 struct block
*block
;
5888 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
5889 VEC (symbolp
) *template_args
= NULL
;
5890 struct template_symbol
*templ_func
= NULL
;
5894 /* If we do not have call site information, we can't show the
5895 caller of this inlined function. That's too confusing, so
5896 only use the scope for local variables. */
5897 call_line
= dwarf2_attr (die
, DW_AT_call_line
, cu
);
5898 call_file
= dwarf2_attr (die
, DW_AT_call_file
, cu
);
5899 if (call_line
== NULL
|| call_file
== NULL
)
5901 read_lexical_block_scope (die
, cu
);
5906 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
5908 name
= dwarf2_name (die
, cu
);
5910 /* Ignore functions with missing or empty names. These are actually
5911 illegal according to the DWARF standard. */
5914 complaint (&symfile_complaints
,
5915 _("missing name for subprogram DIE at %d"), die
->offset
);
5919 /* Ignore functions with missing or invalid low and high pc attributes. */
5920 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
5922 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
5923 if (!attr
|| !DW_UNSND (attr
))
5924 complaint (&symfile_complaints
,
5925 _("cannot get low and high bounds "
5926 "for subprogram DIE at %d"),
5934 /* If we have any template arguments, then we must allocate a
5935 different sort of symbol. */
5936 for (child_die
= die
->child
; child_die
; child_die
= sibling_die (child_die
))
5938 if (child_die
->tag
== DW_TAG_template_type_param
5939 || child_die
->tag
== DW_TAG_template_value_param
)
5941 templ_func
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
5942 struct template_symbol
);
5943 templ_func
->base
.is_cplus_template_function
= 1;
5948 new = push_context (0, lowpc
);
5949 new->name
= new_symbol_full (die
, read_type_die (die
, cu
), cu
,
5950 (struct symbol
*) templ_func
);
5952 /* If there is a location expression for DW_AT_frame_base, record
5954 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
5956 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
5957 expression is being recorded directly in the function's symbol
5958 and not in a separate frame-base object. I guess this hack is
5959 to avoid adding some sort of frame-base adjunct/annex to the
5960 function's symbol :-(. The problem with doing this is that it
5961 results in a function symbol with a location expression that
5962 has nothing to do with the location of the function, ouch! The
5963 relationship should be: a function's symbol has-a frame base; a
5964 frame-base has-a location expression. */
5965 dwarf2_symbol_mark_computed (attr
, new->name
, cu
);
5967 cu
->list_in_scope
= &local_symbols
;
5969 if (die
->child
!= NULL
)
5971 child_die
= die
->child
;
5972 while (child_die
&& child_die
->tag
)
5974 if (child_die
->tag
== DW_TAG_template_type_param
5975 || child_die
->tag
== DW_TAG_template_value_param
)
5977 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
5980 VEC_safe_push (symbolp
, template_args
, arg
);
5983 process_die (child_die
, cu
);
5984 child_die
= sibling_die (child_die
);
5988 inherit_abstract_dies (die
, cu
);
5990 /* If we have a DW_AT_specification, we might need to import using
5991 directives from the context of the specification DIE. See the
5992 comment in determine_prefix. */
5993 if (cu
->language
== language_cplus
5994 && dwarf2_attr (die
, DW_AT_specification
, cu
))
5996 struct dwarf2_cu
*spec_cu
= cu
;
5997 struct die_info
*spec_die
= die_specification (die
, &spec_cu
);
6001 child_die
= spec_die
->child
;
6002 while (child_die
&& child_die
->tag
)
6004 if (child_die
->tag
== DW_TAG_imported_module
)
6005 process_die (child_die
, spec_cu
);
6006 child_die
= sibling_die (child_die
);
6009 /* In some cases, GCC generates specification DIEs that
6010 themselves contain DW_AT_specification attributes. */
6011 spec_die
= die_specification (spec_die
, &spec_cu
);
6015 new = pop_context ();
6016 /* Make a block for the local symbols within. */
6017 block
= finish_block (new->name
, &local_symbols
, new->old_blocks
,
6018 lowpc
, highpc
, objfile
);
6020 /* For C++, set the block's scope. */
6021 if (cu
->language
== language_cplus
|| cu
->language
== language_fortran
)
6022 cp_set_block_scope (new->name
, block
, &objfile
->objfile_obstack
,
6023 determine_prefix (die
, cu
),
6024 processing_has_namespace_info
);
6026 /* If we have address ranges, record them. */
6027 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
6029 /* Attach template arguments to function. */
6030 if (! VEC_empty (symbolp
, template_args
))
6032 gdb_assert (templ_func
!= NULL
);
6034 templ_func
->n_template_arguments
= VEC_length (symbolp
, template_args
);
6035 templ_func
->template_arguments
6036 = obstack_alloc (&objfile
->objfile_obstack
,
6037 (templ_func
->n_template_arguments
6038 * sizeof (struct symbol
*)));
6039 memcpy (templ_func
->template_arguments
,
6040 VEC_address (symbolp
, template_args
),
6041 (templ_func
->n_template_arguments
* sizeof (struct symbol
*)));
6042 VEC_free (symbolp
, template_args
);
6045 /* In C++, we can have functions nested inside functions (e.g., when
6046 a function declares a class that has methods). This means that
6047 when we finish processing a function scope, we may need to go
6048 back to building a containing block's symbol lists. */
6049 local_symbols
= new->locals
;
6050 param_symbols
= new->params
;
6051 using_directives
= new->using_directives
;
6053 /* If we've finished processing a top-level function, subsequent
6054 symbols go in the file symbol list. */
6055 if (outermost_context_p ())
6056 cu
->list_in_scope
= &file_symbols
;
6059 /* Process all the DIES contained within a lexical block scope. Start
6060 a new scope, process the dies, and then close the scope. */
6063 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
6065 struct objfile
*objfile
= cu
->objfile
;
6066 struct context_stack
*new;
6067 CORE_ADDR lowpc
, highpc
;
6068 struct die_info
*child_die
;
6071 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6073 /* Ignore blocks with missing or invalid low and high pc attributes. */
6074 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
6075 as multiple lexical blocks? Handling children in a sane way would
6076 be nasty. Might be easier to properly extend generic blocks to
6078 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
6083 push_context (0, lowpc
);
6084 if (die
->child
!= NULL
)
6086 child_die
= die
->child
;
6087 while (child_die
&& child_die
->tag
)
6089 process_die (child_die
, cu
);
6090 child_die
= sibling_die (child_die
);
6093 new = pop_context ();
6095 if (local_symbols
!= NULL
|| using_directives
!= NULL
)
6098 = finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
6101 /* Note that recording ranges after traversing children, as we
6102 do here, means that recording a parent's ranges entails
6103 walking across all its children's ranges as they appear in
6104 the address map, which is quadratic behavior.
6106 It would be nicer to record the parent's ranges before
6107 traversing its children, simply overriding whatever you find
6108 there. But since we don't even decide whether to create a
6109 block until after we've traversed its children, that's hard
6111 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
6113 local_symbols
= new->locals
;
6114 using_directives
= new->using_directives
;
6117 /* Read in DW_TAG_GNU_call_site and insert it to CU->call_site_htab. */
6120 read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
6122 struct objfile
*objfile
= cu
->objfile
;
6123 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
6124 CORE_ADDR pc
, baseaddr
;
6125 struct attribute
*attr
;
6126 struct call_site
*call_site
, call_site_local
;
6129 struct die_info
*child_die
;
6131 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6133 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
6136 complaint (&symfile_complaints
,
6137 _("missing DW_AT_low_pc for DW_TAG_GNU_call_site "
6138 "DIE 0x%x [in module %s]"),
6139 die
->offset
, objfile
->name
);
6142 pc
= DW_ADDR (attr
) + baseaddr
;
6144 if (cu
->call_site_htab
== NULL
)
6145 cu
->call_site_htab
= htab_create_alloc_ex (16, core_addr_hash
, core_addr_eq
,
6146 NULL
, &objfile
->objfile_obstack
,
6147 hashtab_obstack_allocate
, NULL
);
6148 call_site_local
.pc
= pc
;
6149 slot
= htab_find_slot (cu
->call_site_htab
, &call_site_local
, INSERT
);
6152 complaint (&symfile_complaints
,
6153 _("Duplicate PC %s for DW_TAG_GNU_call_site "
6154 "DIE 0x%x [in module %s]"),
6155 paddress (gdbarch
, pc
), die
->offset
, objfile
->name
);
6159 /* Count parameters at the caller. */
6162 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
6163 child_die
= sibling_die (child_die
))
6165 if (child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
6167 complaint (&symfile_complaints
,
6168 _("Tag %d is not DW_TAG_GNU_call_site_parameter in "
6169 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
6170 child_die
->tag
, child_die
->offset
, objfile
->name
);
6177 call_site
= obstack_alloc (&objfile
->objfile_obstack
,
6178 (sizeof (*call_site
)
6179 + (sizeof (*call_site
->parameter
)
6182 memset (call_site
, 0, sizeof (*call_site
) - sizeof (*call_site
->parameter
));
6185 if (dwarf2_flag_true_p (die
, DW_AT_GNU_tail_call
, cu
))
6187 struct die_info
*func_die
;
6189 /* Skip also over DW_TAG_inlined_subroutine. */
6190 for (func_die
= die
->parent
;
6191 func_die
&& func_die
->tag
!= DW_TAG_subprogram
6192 && func_die
->tag
!= DW_TAG_subroutine_type
;
6193 func_die
= func_die
->parent
);
6195 /* DW_AT_GNU_all_call_sites is a superset
6196 of DW_AT_GNU_all_tail_call_sites. */
6198 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_call_sites
, cu
)
6199 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_tail_call_sites
, cu
))
6201 /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
6202 not complete. But keep CALL_SITE for look ups via call_site_htab,
6203 both the initial caller containing the real return address PC and
6204 the final callee containing the current PC of a chain of tail
6205 calls do not need to have the tail call list complete. But any
6206 function candidate for a virtual tail call frame searched via
6207 TYPE_TAIL_CALL_LIST must have the tail call list complete to be
6208 determined unambiguously. */
6212 struct type
*func_type
= NULL
;
6215 func_type
= get_die_type (func_die
, cu
);
6216 if (func_type
!= NULL
)
6218 gdb_assert (TYPE_CODE (func_type
) == TYPE_CODE_FUNC
);
6220 /* Enlist this call site to the function. */
6221 call_site
->tail_call_next
= TYPE_TAIL_CALL_LIST (func_type
);
6222 TYPE_TAIL_CALL_LIST (func_type
) = call_site
;
6225 complaint (&symfile_complaints
,
6226 _("Cannot find function owning DW_TAG_GNU_call_site "
6227 "DIE 0x%x [in module %s]"),
6228 die
->offset
, objfile
->name
);
6232 attr
= dwarf2_attr (die
, DW_AT_GNU_call_site_target
, cu
);
6234 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
6235 SET_FIELD_DWARF_BLOCK (call_site
->target
, NULL
);
6236 if (!attr
|| (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0))
6237 /* Keep NULL DWARF_BLOCK. */;
6238 else if (attr_form_is_block (attr
))
6240 struct dwarf2_locexpr_baton
*dlbaton
;
6242 dlbaton
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*dlbaton
));
6243 dlbaton
->data
= DW_BLOCK (attr
)->data
;
6244 dlbaton
->size
= DW_BLOCK (attr
)->size
;
6245 dlbaton
->per_cu
= cu
->per_cu
;
6247 SET_FIELD_DWARF_BLOCK (call_site
->target
, dlbaton
);
6249 else if (is_ref_attr (attr
))
6251 struct dwarf2_cu
*target_cu
= cu
;
6252 struct die_info
*target_die
;
6254 target_die
= follow_die_ref_or_sig (die
, attr
, &target_cu
);
6255 gdb_assert (target_cu
->objfile
== objfile
);
6256 if (die_is_declaration (target_die
, target_cu
))
6258 const char *target_physname
;
6260 target_physname
= dwarf2_physname (NULL
, target_die
, target_cu
);
6261 if (target_physname
== NULL
)
6262 complaint (&symfile_complaints
,
6263 _("DW_AT_GNU_call_site_target target DIE has invalid "
6264 "physname, for referencing DIE 0x%x [in module %s]"),
6265 die
->offset
, objfile
->name
);
6267 SET_FIELD_PHYSNAME (call_site
->target
, (char *) target_physname
);
6273 /* DW_AT_entry_pc should be preferred. */
6274 if (!dwarf2_get_pc_bounds (target_die
, &lowpc
, NULL
, target_cu
, NULL
))
6275 complaint (&symfile_complaints
,
6276 _("DW_AT_GNU_call_site_target target DIE has invalid "
6277 "low pc, for referencing DIE 0x%x [in module %s]"),
6278 die
->offset
, objfile
->name
);
6280 SET_FIELD_PHYSADDR (call_site
->target
, lowpc
+ baseaddr
);
6284 complaint (&symfile_complaints
,
6285 _("DW_TAG_GNU_call_site DW_AT_GNU_call_site_target is neither "
6286 "block nor reference, for DIE 0x%x [in module %s]"),
6287 die
->offset
, objfile
->name
);
6289 call_site
->per_cu
= cu
->per_cu
;
6291 for (child_die
= die
->child
;
6292 child_die
&& child_die
->tag
;
6293 child_die
= sibling_die (child_die
))
6295 struct dwarf2_locexpr_baton
*dlbaton
;
6296 struct call_site_parameter
*parameter
;
6298 if (child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
6300 /* Already printed the complaint above. */
6304 gdb_assert (call_site
->parameter_count
< nparams
);
6305 parameter
= &call_site
->parameter
[call_site
->parameter_count
];
6307 /* DW_AT_location specifies the register number. Value of the data
6308 assumed for the register is contained in DW_AT_GNU_call_site_value. */
6310 attr
= dwarf2_attr (child_die
, DW_AT_location
, cu
);
6311 if (!attr
|| !attr_form_is_block (attr
))
6313 complaint (&symfile_complaints
,
6314 _("No DW_FORM_block* DW_AT_location for "
6315 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
6316 child_die
->offset
, objfile
->name
);
6319 parameter
->dwarf_reg
= dwarf_block_to_dwarf_reg (DW_BLOCK (attr
)->data
,
6320 &DW_BLOCK (attr
)->data
[DW_BLOCK (attr
)->size
]);
6321 if (parameter
->dwarf_reg
== -1
6322 && !dwarf_block_to_sp_offset (gdbarch
, DW_BLOCK (attr
)->data
,
6323 &DW_BLOCK (attr
)->data
[DW_BLOCK (attr
)->size
],
6324 ¶meter
->fb_offset
))
6326 complaint (&symfile_complaints
,
6327 _("Only single DW_OP_reg or DW_OP_fbreg is supported "
6328 "for DW_FORM_block* DW_AT_location for "
6329 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
6330 child_die
->offset
, objfile
->name
);
6334 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_value
, cu
);
6335 if (!attr_form_is_block (attr
))
6337 complaint (&symfile_complaints
,
6338 _("No DW_FORM_block* DW_AT_GNU_call_site_value for "
6339 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
6340 child_die
->offset
, objfile
->name
);
6343 parameter
->value
= DW_BLOCK (attr
)->data
;
6344 parameter
->value_size
= DW_BLOCK (attr
)->size
;
6346 /* Parameters are not pre-cleared by memset above. */
6347 parameter
->data_value
= NULL
;
6348 parameter
->data_value_size
= 0;
6349 call_site
->parameter_count
++;
6351 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_data_value
, cu
);
6354 if (!attr_form_is_block (attr
))
6355 complaint (&symfile_complaints
,
6356 _("No DW_FORM_block* DW_AT_GNU_call_site_data_value for "
6357 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
6358 child_die
->offset
, objfile
->name
);
6361 parameter
->data_value
= DW_BLOCK (attr
)->data
;
6362 parameter
->data_value_size
= DW_BLOCK (attr
)->size
;
6368 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
6369 Return 1 if the attributes are present and valid, otherwise, return 0.
6370 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
6373 dwarf2_ranges_read (unsigned offset
, CORE_ADDR
*low_return
,
6374 CORE_ADDR
*high_return
, struct dwarf2_cu
*cu
,
6375 struct partial_symtab
*ranges_pst
)
6377 struct objfile
*objfile
= cu
->objfile
;
6378 struct comp_unit_head
*cu_header
= &cu
->header
;
6379 bfd
*obfd
= objfile
->obfd
;
6380 unsigned int addr_size
= cu_header
->addr_size
;
6381 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
6382 /* Base address selection entry. */
6393 found_base
= cu
->base_known
;
6394 base
= cu
->base_address
;
6396 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->ranges
);
6397 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
6399 complaint (&symfile_complaints
,
6400 _("Offset %d out of bounds for DW_AT_ranges attribute"),
6404 buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
6406 /* Read in the largest possible address. */
6407 marker
= read_address (obfd
, buffer
, cu
, &dummy
);
6408 if ((marker
& mask
) == mask
)
6410 /* If we found the largest possible address, then
6411 read the base address. */
6412 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
6413 buffer
+= 2 * addr_size
;
6414 offset
+= 2 * addr_size
;
6420 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6424 CORE_ADDR range_beginning
, range_end
;
6426 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
6427 buffer
+= addr_size
;
6428 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
6429 buffer
+= addr_size
;
6430 offset
+= 2 * addr_size
;
6432 /* An end of list marker is a pair of zero addresses. */
6433 if (range_beginning
== 0 && range_end
== 0)
6434 /* Found the end of list entry. */
6437 /* Each base address selection entry is a pair of 2 values.
6438 The first is the largest possible address, the second is
6439 the base address. Check for a base address here. */
6440 if ((range_beginning
& mask
) == mask
)
6442 /* If we found the largest possible address, then
6443 read the base address. */
6444 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
6451 /* We have no valid base address for the ranges
6453 complaint (&symfile_complaints
,
6454 _("Invalid .debug_ranges data (no base address)"));
6458 if (range_beginning
> range_end
)
6460 /* Inverted range entries are invalid. */
6461 complaint (&symfile_complaints
,
6462 _("Invalid .debug_ranges data (inverted range)"));
6466 /* Empty range entries have no effect. */
6467 if (range_beginning
== range_end
)
6470 range_beginning
+= base
;
6473 if (ranges_pst
!= NULL
)
6474 addrmap_set_empty (objfile
->psymtabs_addrmap
,
6475 range_beginning
+ baseaddr
,
6476 range_end
- 1 + baseaddr
,
6479 /* FIXME: This is recording everything as a low-high
6480 segment of consecutive addresses. We should have a
6481 data structure for discontiguous block ranges
6485 low
= range_beginning
;
6491 if (range_beginning
< low
)
6492 low
= range_beginning
;
6493 if (range_end
> high
)
6499 /* If the first entry is an end-of-list marker, the range
6500 describes an empty scope, i.e. no instructions. */
6506 *high_return
= high
;
6510 /* Get low and high pc attributes from a die. Return 1 if the attributes
6511 are present and valid, otherwise, return 0. Return -1 if the range is
6512 discontinuous, i.e. derived from DW_AT_ranges information. */
6514 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
6515 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
,
6516 struct partial_symtab
*pst
)
6518 struct attribute
*attr
;
6523 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
6526 high
= DW_ADDR (attr
);
6527 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
6529 low
= DW_ADDR (attr
);
6531 /* Found high w/o low attribute. */
6534 /* Found consecutive range of addresses. */
6539 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
6542 /* Value of the DW_AT_ranges attribute is the offset in the
6543 .debug_ranges section. */
6544 if (!dwarf2_ranges_read (DW_UNSND (attr
), &low
, &high
, cu
, pst
))
6546 /* Found discontinuous range of addresses. */
6551 /* read_partial_die has also the strict LOW < HIGH requirement. */
6555 /* When using the GNU linker, .gnu.linkonce. sections are used to
6556 eliminate duplicate copies of functions and vtables and such.
6557 The linker will arbitrarily choose one and discard the others.
6558 The AT_*_pc values for such functions refer to local labels in
6559 these sections. If the section from that file was discarded, the
6560 labels are not in the output, so the relocs get a value of 0.
6561 If this is a discarded function, mark the pc bounds as invalid,
6562 so that GDB will ignore it. */
6563 if (low
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
6572 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
6573 its low and high PC addresses. Do nothing if these addresses could not
6574 be determined. Otherwise, set LOWPC to the low address if it is smaller,
6575 and HIGHPC to the high address if greater than HIGHPC. */
6578 dwarf2_get_subprogram_pc_bounds (struct die_info
*die
,
6579 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
6580 struct dwarf2_cu
*cu
)
6582 CORE_ADDR low
, high
;
6583 struct die_info
*child
= die
->child
;
6585 if (dwarf2_get_pc_bounds (die
, &low
, &high
, cu
, NULL
))
6587 *lowpc
= min (*lowpc
, low
);
6588 *highpc
= max (*highpc
, high
);
6591 /* If the language does not allow nested subprograms (either inside
6592 subprograms or lexical blocks), we're done. */
6593 if (cu
->language
!= language_ada
)
6596 /* Check all the children of the given DIE. If it contains nested
6597 subprograms, then check their pc bounds. Likewise, we need to
6598 check lexical blocks as well, as they may also contain subprogram
6600 while (child
&& child
->tag
)
6602 if (child
->tag
== DW_TAG_subprogram
6603 || child
->tag
== DW_TAG_lexical_block
)
6604 dwarf2_get_subprogram_pc_bounds (child
, lowpc
, highpc
, cu
);
6605 child
= sibling_die (child
);
6609 /* Get the low and high pc's represented by the scope DIE, and store
6610 them in *LOWPC and *HIGHPC. If the correct values can't be
6611 determined, set *LOWPC to -1 and *HIGHPC to 0. */
6614 get_scope_pc_bounds (struct die_info
*die
,
6615 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
6616 struct dwarf2_cu
*cu
)
6618 CORE_ADDR best_low
= (CORE_ADDR
) -1;
6619 CORE_ADDR best_high
= (CORE_ADDR
) 0;
6620 CORE_ADDR current_low
, current_high
;
6622 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
, NULL
))
6624 best_low
= current_low
;
6625 best_high
= current_high
;
6629 struct die_info
*child
= die
->child
;
6631 while (child
&& child
->tag
)
6633 switch (child
->tag
) {
6634 case DW_TAG_subprogram
:
6635 dwarf2_get_subprogram_pc_bounds (child
, &best_low
, &best_high
, cu
);
6637 case DW_TAG_namespace
:
6639 /* FIXME: carlton/2004-01-16: Should we do this for
6640 DW_TAG_class_type/DW_TAG_structure_type, too? I think
6641 that current GCC's always emit the DIEs corresponding
6642 to definitions of methods of classes as children of a
6643 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
6644 the DIEs giving the declarations, which could be
6645 anywhere). But I don't see any reason why the
6646 standards says that they have to be there. */
6647 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
6649 if (current_low
!= ((CORE_ADDR
) -1))
6651 best_low
= min (best_low
, current_low
);
6652 best_high
= max (best_high
, current_high
);
6660 child
= sibling_die (child
);
6665 *highpc
= best_high
;
6668 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
6671 dwarf2_record_block_ranges (struct die_info
*die
, struct block
*block
,
6672 CORE_ADDR baseaddr
, struct dwarf2_cu
*cu
)
6674 struct objfile
*objfile
= cu
->objfile
;
6675 struct attribute
*attr
;
6677 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
6680 CORE_ADDR high
= DW_ADDR (attr
);
6682 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
6685 CORE_ADDR low
= DW_ADDR (attr
);
6687 record_block_range (block
, baseaddr
+ low
, baseaddr
+ high
- 1);
6691 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
6694 bfd
*obfd
= objfile
->obfd
;
6696 /* The value of the DW_AT_ranges attribute is the offset of the
6697 address range list in the .debug_ranges section. */
6698 unsigned long offset
= DW_UNSND (attr
);
6699 gdb_byte
*buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
6701 /* For some target architectures, but not others, the
6702 read_address function sign-extends the addresses it returns.
6703 To recognize base address selection entries, we need a
6705 unsigned int addr_size
= cu
->header
.addr_size
;
6706 CORE_ADDR base_select_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
6708 /* The base address, to which the next pair is relative. Note
6709 that this 'base' is a DWARF concept: most entries in a range
6710 list are relative, to reduce the number of relocs against the
6711 debugging information. This is separate from this function's
6712 'baseaddr' argument, which GDB uses to relocate debugging
6713 information from a shared library based on the address at
6714 which the library was loaded. */
6715 CORE_ADDR base
= cu
->base_address
;
6716 int base_known
= cu
->base_known
;
6718 gdb_assert (dwarf2_per_objfile
->ranges
.readin
);
6719 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
6721 complaint (&symfile_complaints
,
6722 _("Offset %lu out of bounds for DW_AT_ranges attribute"),
6729 unsigned int bytes_read
;
6730 CORE_ADDR start
, end
;
6732 start
= read_address (obfd
, buffer
, cu
, &bytes_read
);
6733 buffer
+= bytes_read
;
6734 end
= read_address (obfd
, buffer
, cu
, &bytes_read
);
6735 buffer
+= bytes_read
;
6737 /* Did we find the end of the range list? */
6738 if (start
== 0 && end
== 0)
6741 /* Did we find a base address selection entry? */
6742 else if ((start
& base_select_mask
) == base_select_mask
)
6748 /* We found an ordinary address range. */
6753 complaint (&symfile_complaints
,
6754 _("Invalid .debug_ranges data "
6755 "(no base address)"));
6761 /* Inverted range entries are invalid. */
6762 complaint (&symfile_complaints
,
6763 _("Invalid .debug_ranges data "
6764 "(inverted range)"));
6768 /* Empty range entries have no effect. */
6772 record_block_range (block
,
6773 baseaddr
+ base
+ start
,
6774 baseaddr
+ base
+ end
- 1);
6780 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
6781 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
6782 during 4.6.0 experimental. */
6785 producer_is_gxx_lt_4_6 (struct dwarf2_cu
*cu
)
6788 int major
, minor
, release
;
6790 if (cu
->producer
== NULL
)
6792 /* For unknown compilers expect their behavior is DWARF version
6795 GCC started to support .debug_types sections by -gdwarf-4 since
6796 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
6797 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
6798 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
6799 interpreted incorrectly by GDB now - GCC PR debug/48229. */
6804 /* Skip any identifier after "GNU " - such as "C++" or "Java". */
6806 if (strncmp (cu
->producer
, "GNU ", strlen ("GNU ")) != 0)
6808 /* For non-GCC compilers expect their behavior is DWARF version
6813 cs
= &cu
->producer
[strlen ("GNU ")];
6814 while (*cs
&& !isdigit (*cs
))
6816 if (sscanf (cs
, "%d.%d.%d", &major
, &minor
, &release
) != 3)
6818 /* Not recognized as GCC. */
6823 return major
< 4 || (major
== 4 && minor
< 6);
6826 /* Return the default accessibility type if it is not overriden by
6827 DW_AT_accessibility. */
6829 static enum dwarf_access_attribute
6830 dwarf2_default_access_attribute (struct die_info
*die
, struct dwarf2_cu
*cu
)
6832 if (cu
->header
.version
< 3 || producer_is_gxx_lt_4_6 (cu
))
6834 /* The default DWARF 2 accessibility for members is public, the default
6835 accessibility for inheritance is private. */
6837 if (die
->tag
!= DW_TAG_inheritance
)
6838 return DW_ACCESS_public
;
6840 return DW_ACCESS_private
;
6844 /* DWARF 3+ defines the default accessibility a different way. The same
6845 rules apply now for DW_TAG_inheritance as for the members and it only
6846 depends on the container kind. */
6848 if (die
->parent
->tag
== DW_TAG_class_type
)
6849 return DW_ACCESS_private
;
6851 return DW_ACCESS_public
;
6855 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
6856 offset. If the attribute was not found return 0, otherwise return
6857 1. If it was found but could not properly be handled, set *OFFSET
6861 handle_data_member_location (struct die_info
*die
, struct dwarf2_cu
*cu
,
6864 struct attribute
*attr
;
6866 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
6871 /* Note that we do not check for a section offset first here.
6872 This is because DW_AT_data_member_location is new in DWARF 4,
6873 so if we see it, we can assume that a constant form is really
6874 a constant and not a section offset. */
6875 if (attr_form_is_constant (attr
))
6876 *offset
= dwarf2_get_attr_constant_value (attr
, 0);
6877 else if (attr_form_is_section_offset (attr
))
6878 dwarf2_complex_location_expr_complaint ();
6879 else if (attr_form_is_block (attr
))
6880 *offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
6882 dwarf2_complex_location_expr_complaint ();
6890 /* Add an aggregate field to the field list. */
6893 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
6894 struct dwarf2_cu
*cu
)
6896 struct objfile
*objfile
= cu
->objfile
;
6897 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
6898 struct nextfield
*new_field
;
6899 struct attribute
*attr
;
6901 char *fieldname
= "";
6903 /* Allocate a new field list entry and link it in. */
6904 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
6905 make_cleanup (xfree
, new_field
);
6906 memset (new_field
, 0, sizeof (struct nextfield
));
6908 if (die
->tag
== DW_TAG_inheritance
)
6910 new_field
->next
= fip
->baseclasses
;
6911 fip
->baseclasses
= new_field
;
6915 new_field
->next
= fip
->fields
;
6916 fip
->fields
= new_field
;
6920 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
6922 new_field
->accessibility
= DW_UNSND (attr
);
6924 new_field
->accessibility
= dwarf2_default_access_attribute (die
, cu
);
6925 if (new_field
->accessibility
!= DW_ACCESS_public
)
6926 fip
->non_public_fields
= 1;
6928 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
6930 new_field
->virtuality
= DW_UNSND (attr
);
6932 new_field
->virtuality
= DW_VIRTUALITY_none
;
6934 fp
= &new_field
->field
;
6936 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
6940 /* Data member other than a C++ static data member. */
6942 /* Get type of field. */
6943 fp
->type
= die_type (die
, cu
);
6945 SET_FIELD_BITPOS (*fp
, 0);
6947 /* Get bit size of field (zero if none). */
6948 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
6951 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
6955 FIELD_BITSIZE (*fp
) = 0;
6958 /* Get bit offset of field. */
6959 if (handle_data_member_location (die
, cu
, &offset
))
6960 SET_FIELD_BITPOS (*fp
, offset
* bits_per_byte
);
6961 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
6964 if (gdbarch_bits_big_endian (gdbarch
))
6966 /* For big endian bits, the DW_AT_bit_offset gives the
6967 additional bit offset from the MSB of the containing
6968 anonymous object to the MSB of the field. We don't
6969 have to do anything special since we don't need to
6970 know the size of the anonymous object. */
6971 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
6975 /* For little endian bits, compute the bit offset to the
6976 MSB of the anonymous object, subtract off the number of
6977 bits from the MSB of the field to the MSB of the
6978 object, and then subtract off the number of bits of
6979 the field itself. The result is the bit offset of
6980 the LSB of the field. */
6982 int bit_offset
= DW_UNSND (attr
);
6984 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
6987 /* The size of the anonymous object containing
6988 the bit field is explicit, so use the
6989 indicated size (in bytes). */
6990 anonymous_size
= DW_UNSND (attr
);
6994 /* The size of the anonymous object containing
6995 the bit field must be inferred from the type
6996 attribute of the data member containing the
6998 anonymous_size
= TYPE_LENGTH (fp
->type
);
7000 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
7001 - bit_offset
- FIELD_BITSIZE (*fp
);
7005 /* Get name of field. */
7006 fieldname
= dwarf2_name (die
, cu
);
7007 if (fieldname
== NULL
)
7010 /* The name is already allocated along with this objfile, so we don't
7011 need to duplicate it for the type. */
7012 fp
->name
= fieldname
;
7014 /* Change accessibility for artificial fields (e.g. virtual table
7015 pointer or virtual base class pointer) to private. */
7016 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
7018 FIELD_ARTIFICIAL (*fp
) = 1;
7019 new_field
->accessibility
= DW_ACCESS_private
;
7020 fip
->non_public_fields
= 1;
7023 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
7025 /* C++ static member. */
7027 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
7028 is a declaration, but all versions of G++ as of this writing
7029 (so through at least 3.2.1) incorrectly generate
7030 DW_TAG_variable tags. */
7032 const char *physname
;
7034 /* Get name of field. */
7035 fieldname
= dwarf2_name (die
, cu
);
7036 if (fieldname
== NULL
)
7039 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
7041 /* Only create a symbol if this is an external value.
7042 new_symbol checks this and puts the value in the global symbol
7043 table, which we want. If it is not external, new_symbol
7044 will try to put the value in cu->list_in_scope which is wrong. */
7045 && dwarf2_flag_true_p (die
, DW_AT_external
, cu
))
7047 /* A static const member, not much different than an enum as far as
7048 we're concerned, except that we can support more types. */
7049 new_symbol (die
, NULL
, cu
);
7052 /* Get physical name. */
7053 physname
= dwarf2_physname (fieldname
, die
, cu
);
7055 /* The name is already allocated along with this objfile, so we don't
7056 need to duplicate it for the type. */
7057 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
7058 FIELD_TYPE (*fp
) = die_type (die
, cu
);
7059 FIELD_NAME (*fp
) = fieldname
;
7061 else if (die
->tag
== DW_TAG_inheritance
)
7065 /* C++ base class field. */
7066 if (handle_data_member_location (die
, cu
, &offset
))
7067 SET_FIELD_BITPOS (*fp
, offset
* bits_per_byte
);
7068 FIELD_BITSIZE (*fp
) = 0;
7069 FIELD_TYPE (*fp
) = die_type (die
, cu
);
7070 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
7071 fip
->nbaseclasses
++;
7075 /* Add a typedef defined in the scope of the FIP's class. */
7078 dwarf2_add_typedef (struct field_info
*fip
, struct die_info
*die
,
7079 struct dwarf2_cu
*cu
)
7081 struct objfile
*objfile
= cu
->objfile
;
7082 struct typedef_field_list
*new_field
;
7083 struct attribute
*attr
;
7084 struct typedef_field
*fp
;
7085 char *fieldname
= "";
7087 /* Allocate a new field list entry and link it in. */
7088 new_field
= xzalloc (sizeof (*new_field
));
7089 make_cleanup (xfree
, new_field
);
7091 gdb_assert (die
->tag
== DW_TAG_typedef
);
7093 fp
= &new_field
->field
;
7095 /* Get name of field. */
7096 fp
->name
= dwarf2_name (die
, cu
);
7097 if (fp
->name
== NULL
)
7100 fp
->type
= read_type_die (die
, cu
);
7102 new_field
->next
= fip
->typedef_field_list
;
7103 fip
->typedef_field_list
= new_field
;
7104 fip
->typedef_field_list_count
++;
7107 /* Create the vector of fields, and attach it to the type. */
7110 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
7111 struct dwarf2_cu
*cu
)
7113 int nfields
= fip
->nfields
;
7115 /* Record the field count, allocate space for the array of fields,
7116 and create blank accessibility bitfields if necessary. */
7117 TYPE_NFIELDS (type
) = nfields
;
7118 TYPE_FIELDS (type
) = (struct field
*)
7119 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
7120 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
7122 if (fip
->non_public_fields
&& cu
->language
!= language_ada
)
7124 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
7126 TYPE_FIELD_PRIVATE_BITS (type
) =
7127 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
7128 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
7130 TYPE_FIELD_PROTECTED_BITS (type
) =
7131 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
7132 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
7134 TYPE_FIELD_IGNORE_BITS (type
) =
7135 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
7136 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
7139 /* If the type has baseclasses, allocate and clear a bit vector for
7140 TYPE_FIELD_VIRTUAL_BITS. */
7141 if (fip
->nbaseclasses
&& cu
->language
!= language_ada
)
7143 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
7144 unsigned char *pointer
;
7146 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
7147 pointer
= TYPE_ALLOC (type
, num_bytes
);
7148 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
7149 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
7150 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
7153 /* Copy the saved-up fields into the field vector. Start from the head of
7154 the list, adding to the tail of the field array, so that they end up in
7155 the same order in the array in which they were added to the list. */
7156 while (nfields
-- > 0)
7158 struct nextfield
*fieldp
;
7162 fieldp
= fip
->fields
;
7163 fip
->fields
= fieldp
->next
;
7167 fieldp
= fip
->baseclasses
;
7168 fip
->baseclasses
= fieldp
->next
;
7171 TYPE_FIELD (type
, nfields
) = fieldp
->field
;
7172 switch (fieldp
->accessibility
)
7174 case DW_ACCESS_private
:
7175 if (cu
->language
!= language_ada
)
7176 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
7179 case DW_ACCESS_protected
:
7180 if (cu
->language
!= language_ada
)
7181 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
7184 case DW_ACCESS_public
:
7188 /* Unknown accessibility. Complain and treat it as public. */
7190 complaint (&symfile_complaints
, _("unsupported accessibility %d"),
7191 fieldp
->accessibility
);
7195 if (nfields
< fip
->nbaseclasses
)
7197 switch (fieldp
->virtuality
)
7199 case DW_VIRTUALITY_virtual
:
7200 case DW_VIRTUALITY_pure_virtual
:
7201 if (cu
->language
== language_ada
)
7202 error (_("unexpected virtuality in component of Ada type"));
7203 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
7210 /* Add a member function to the proper fieldlist. */
7213 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
7214 struct type
*type
, struct dwarf2_cu
*cu
)
7216 struct objfile
*objfile
= cu
->objfile
;
7217 struct attribute
*attr
;
7218 struct fnfieldlist
*flp
;
7220 struct fn_field
*fnp
;
7222 struct nextfnfield
*new_fnfield
;
7223 struct type
*this_type
;
7224 enum dwarf_access_attribute accessibility
;
7226 if (cu
->language
== language_ada
)
7227 error (_("unexpected member function in Ada type"));
7229 /* Get name of member function. */
7230 fieldname
= dwarf2_name (die
, cu
);
7231 if (fieldname
== NULL
)
7234 /* Look up member function name in fieldlist. */
7235 for (i
= 0; i
< fip
->nfnfields
; i
++)
7237 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
7241 /* Create new list element if necessary. */
7242 if (i
< fip
->nfnfields
)
7243 flp
= &fip
->fnfieldlists
[i
];
7246 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
7248 fip
->fnfieldlists
= (struct fnfieldlist
*)
7249 xrealloc (fip
->fnfieldlists
,
7250 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
7251 * sizeof (struct fnfieldlist
));
7252 if (fip
->nfnfields
== 0)
7253 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
7255 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
7256 flp
->name
= fieldname
;
7259 i
= fip
->nfnfields
++;
7262 /* Create a new member function field and chain it to the field list
7264 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
7265 make_cleanup (xfree
, new_fnfield
);
7266 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
7267 new_fnfield
->next
= flp
->head
;
7268 flp
->head
= new_fnfield
;
7271 /* Fill in the member function field info. */
7272 fnp
= &new_fnfield
->fnfield
;
7274 /* Delay processing of the physname until later. */
7275 if (cu
->language
== language_cplus
|| cu
->language
== language_java
)
7277 add_to_method_list (type
, i
, flp
->length
- 1, fieldname
,
7282 const char *physname
= dwarf2_physname (fieldname
, die
, cu
);
7283 fnp
->physname
= physname
? physname
: "";
7286 fnp
->type
= alloc_type (objfile
);
7287 this_type
= read_type_die (die
, cu
);
7288 if (this_type
&& TYPE_CODE (this_type
) == TYPE_CODE_FUNC
)
7290 int nparams
= TYPE_NFIELDS (this_type
);
7292 /* TYPE is the domain of this method, and THIS_TYPE is the type
7293 of the method itself (TYPE_CODE_METHOD). */
7294 smash_to_method_type (fnp
->type
, type
,
7295 TYPE_TARGET_TYPE (this_type
),
7296 TYPE_FIELDS (this_type
),
7297 TYPE_NFIELDS (this_type
),
7298 TYPE_VARARGS (this_type
));
7300 /* Handle static member functions.
7301 Dwarf2 has no clean way to discern C++ static and non-static
7302 member functions. G++ helps GDB by marking the first
7303 parameter for non-static member functions (which is the this
7304 pointer) as artificial. We obtain this information from
7305 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
7306 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (this_type
, 0) == 0)
7307 fnp
->voffset
= VOFFSET_STATIC
;
7310 complaint (&symfile_complaints
, _("member function type missing for '%s'"),
7311 dwarf2_full_name (fieldname
, die
, cu
));
7313 /* Get fcontext from DW_AT_containing_type if present. */
7314 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
7315 fnp
->fcontext
= die_containing_type (die
, cu
);
7317 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
7318 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
7320 /* Get accessibility. */
7321 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
7323 accessibility
= DW_UNSND (attr
);
7325 accessibility
= dwarf2_default_access_attribute (die
, cu
);
7326 switch (accessibility
)
7328 case DW_ACCESS_private
:
7329 fnp
->is_private
= 1;
7331 case DW_ACCESS_protected
:
7332 fnp
->is_protected
= 1;
7336 /* Check for artificial methods. */
7337 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
7338 if (attr
&& DW_UNSND (attr
) != 0)
7339 fnp
->is_artificial
= 1;
7341 /* Get index in virtual function table if it is a virtual member
7342 function. For older versions of GCC, this is an offset in the
7343 appropriate virtual table, as specified by DW_AT_containing_type.
7344 For everyone else, it is an expression to be evaluated relative
7345 to the object address. */
7347 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
7350 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
> 0)
7352 if (DW_BLOCK (attr
)->data
[0] == DW_OP_constu
)
7354 /* Old-style GCC. */
7355 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
7357 else if (DW_BLOCK (attr
)->data
[0] == DW_OP_deref
7358 || (DW_BLOCK (attr
)->size
> 1
7359 && DW_BLOCK (attr
)->data
[0] == DW_OP_deref_size
7360 && DW_BLOCK (attr
)->data
[1] == cu
->header
.addr_size
))
7362 struct dwarf_block blk
;
7365 offset
= (DW_BLOCK (attr
)->data
[0] == DW_OP_deref
7367 blk
.size
= DW_BLOCK (attr
)->size
- offset
;
7368 blk
.data
= DW_BLOCK (attr
)->data
+ offset
;
7369 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
);
7370 if ((fnp
->voffset
% cu
->header
.addr_size
) != 0)
7371 dwarf2_complex_location_expr_complaint ();
7373 fnp
->voffset
/= cu
->header
.addr_size
;
7377 dwarf2_complex_location_expr_complaint ();
7380 fnp
->fcontext
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type
, 0));
7382 else if (attr_form_is_section_offset (attr
))
7384 dwarf2_complex_location_expr_complaint ();
7388 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
7394 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
7395 if (attr
&& DW_UNSND (attr
))
7397 /* GCC does this, as of 2008-08-25; PR debug/37237. */
7398 complaint (&symfile_complaints
,
7399 _("Member function \"%s\" (offset %d) is virtual "
7400 "but the vtable offset is not specified"),
7401 fieldname
, die
->offset
);
7402 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
7403 TYPE_CPLUS_DYNAMIC (type
) = 1;
7408 /* Create the vector of member function fields, and attach it to the type. */
7411 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
7412 struct dwarf2_cu
*cu
)
7414 struct fnfieldlist
*flp
;
7417 if (cu
->language
== language_ada
)
7418 error (_("unexpected member functions in Ada type"));
7420 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
7421 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
7422 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
7424 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
7426 struct nextfnfield
*nfp
= flp
->head
;
7427 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
7430 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
7431 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
7432 fn_flp
->fn_fields
= (struct fn_field
*)
7433 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
7434 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
7435 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
7438 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
7441 /* Returns non-zero if NAME is the name of a vtable member in CU's
7442 language, zero otherwise. */
7444 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
7446 static const char vptr
[] = "_vptr";
7447 static const char vtable
[] = "vtable";
7449 /* Look for the C++ and Java forms of the vtable. */
7450 if ((cu
->language
== language_java
7451 && strncmp (name
, vtable
, sizeof (vtable
) - 1) == 0)
7452 || (strncmp (name
, vptr
, sizeof (vptr
) - 1) == 0
7453 && is_cplus_marker (name
[sizeof (vptr
) - 1])))
7459 /* GCC outputs unnamed structures that are really pointers to member
7460 functions, with the ABI-specified layout. If TYPE describes
7461 such a structure, smash it into a member function type.
7463 GCC shouldn't do this; it should just output pointer to member DIEs.
7464 This is GCC PR debug/28767. */
7467 quirk_gcc_member_function_pointer (struct type
*type
, struct objfile
*objfile
)
7469 struct type
*pfn_type
, *domain_type
, *new_type
;
7471 /* Check for a structure with no name and two children. */
7472 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
|| TYPE_NFIELDS (type
) != 2)
7475 /* Check for __pfn and __delta members. */
7476 if (TYPE_FIELD_NAME (type
, 0) == NULL
7477 || strcmp (TYPE_FIELD_NAME (type
, 0), "__pfn") != 0
7478 || TYPE_FIELD_NAME (type
, 1) == NULL
7479 || strcmp (TYPE_FIELD_NAME (type
, 1), "__delta") != 0)
7482 /* Find the type of the method. */
7483 pfn_type
= TYPE_FIELD_TYPE (type
, 0);
7484 if (pfn_type
== NULL
7485 || TYPE_CODE (pfn_type
) != TYPE_CODE_PTR
7486 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type
)) != TYPE_CODE_FUNC
)
7489 /* Look for the "this" argument. */
7490 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
7491 if (TYPE_NFIELDS (pfn_type
) == 0
7492 /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
7493 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type
, 0)) != TYPE_CODE_PTR
)
7496 domain_type
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type
, 0));
7497 new_type
= alloc_type (objfile
);
7498 smash_to_method_type (new_type
, domain_type
, TYPE_TARGET_TYPE (pfn_type
),
7499 TYPE_FIELDS (pfn_type
), TYPE_NFIELDS (pfn_type
),
7500 TYPE_VARARGS (pfn_type
));
7501 smash_to_methodptr_type (type
, new_type
);
7504 /* Called when we find the DIE that starts a structure or union scope
7505 (definition) to create a type for the structure or union. Fill in
7506 the type's name and general properties; the members will not be
7507 processed until process_structure_type.
7509 NOTE: we need to call these functions regardless of whether or not the
7510 DIE has a DW_AT_name attribute, since it might be an anonymous
7511 structure or union. This gets the type entered into our set of
7514 However, if the structure is incomplete (an opaque struct/union)
7515 then suppress creating a symbol table entry for it since gdb only
7516 wants to find the one with the complete definition. Note that if
7517 it is complete, we just call new_symbol, which does it's own
7518 checking about whether the struct/union is anonymous or not (and
7519 suppresses creating a symbol table entry itself). */
7521 static struct type
*
7522 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7524 struct objfile
*objfile
= cu
->objfile
;
7526 struct attribute
*attr
;
7529 /* If the definition of this type lives in .debug_types, read that type.
7530 Don't follow DW_AT_specification though, that will take us back up
7531 the chain and we want to go down. */
7532 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
, cu
);
7535 struct dwarf2_cu
*type_cu
= cu
;
7536 struct die_info
*type_die
= follow_die_ref_or_sig (die
, attr
, &type_cu
);
7538 /* We could just recurse on read_structure_type, but we need to call
7539 get_die_type to ensure only one type for this DIE is created.
7540 This is important, for example, because for c++ classes we need
7541 TYPE_NAME set which is only done by new_symbol. Blech. */
7542 type
= read_type_die (type_die
, type_cu
);
7544 /* TYPE_CU may not be the same as CU.
7545 Ensure TYPE is recorded in CU's type_hash table. */
7546 return set_die_type (die
, type
, cu
);
7549 type
= alloc_type (objfile
);
7550 INIT_CPLUS_SPECIFIC (type
);
7552 name
= dwarf2_name (die
, cu
);
7555 if (cu
->language
== language_cplus
7556 || cu
->language
== language_java
)
7558 char *full_name
= (char *) dwarf2_full_name (name
, die
, cu
);
7560 /* dwarf2_full_name might have already finished building the DIE's
7561 type. If so, there is no need to continue. */
7562 if (get_die_type (die
, cu
) != NULL
)
7563 return get_die_type (die
, cu
);
7565 TYPE_TAG_NAME (type
) = full_name
;
7566 if (die
->tag
== DW_TAG_structure_type
7567 || die
->tag
== DW_TAG_class_type
)
7568 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
7572 /* The name is already allocated along with this objfile, so
7573 we don't need to duplicate it for the type. */
7574 TYPE_TAG_NAME (type
) = (char *) name
;
7575 if (die
->tag
== DW_TAG_class_type
)
7576 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
7580 if (die
->tag
== DW_TAG_structure_type
)
7582 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
7584 else if (die
->tag
== DW_TAG_union_type
)
7586 TYPE_CODE (type
) = TYPE_CODE_UNION
;
7590 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
7593 if (cu
->language
== language_cplus
&& die
->tag
== DW_TAG_class_type
)
7594 TYPE_DECLARED_CLASS (type
) = 1;
7596 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
7599 TYPE_LENGTH (type
) = DW_UNSND (attr
);
7603 TYPE_LENGTH (type
) = 0;
7606 TYPE_STUB_SUPPORTED (type
) = 1;
7607 if (die_is_declaration (die
, cu
))
7608 TYPE_STUB (type
) = 1;
7609 else if (attr
== NULL
&& die
->child
== NULL
7610 && producer_is_realview (cu
->producer
))
7611 /* RealView does not output the required DW_AT_declaration
7612 on incomplete types. */
7613 TYPE_STUB (type
) = 1;
7615 /* We need to add the type field to the die immediately so we don't
7616 infinitely recurse when dealing with pointers to the structure
7617 type within the structure itself. */
7618 set_die_type (die
, type
, cu
);
7620 /* set_die_type should be already done. */
7621 set_descriptive_type (type
, die
, cu
);
7626 /* Finish creating a structure or union type, including filling in
7627 its members and creating a symbol for it. */
7630 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
7632 struct objfile
*objfile
= cu
->objfile
;
7633 struct die_info
*child_die
= die
->child
;
7636 type
= get_die_type (die
, cu
);
7638 type
= read_structure_type (die
, cu
);
7640 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
7642 struct field_info fi
;
7643 struct die_info
*child_die
;
7644 VEC (symbolp
) *template_args
= NULL
;
7645 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
7647 memset (&fi
, 0, sizeof (struct field_info
));
7649 child_die
= die
->child
;
7651 while (child_die
&& child_die
->tag
)
7653 if (child_die
->tag
== DW_TAG_member
7654 || child_die
->tag
== DW_TAG_variable
)
7656 /* NOTE: carlton/2002-11-05: A C++ static data member
7657 should be a DW_TAG_member that is a declaration, but
7658 all versions of G++ as of this writing (so through at
7659 least 3.2.1) incorrectly generate DW_TAG_variable
7660 tags for them instead. */
7661 dwarf2_add_field (&fi
, child_die
, cu
);
7663 else if (child_die
->tag
== DW_TAG_subprogram
)
7665 /* C++ member function. */
7666 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
7668 else if (child_die
->tag
== DW_TAG_inheritance
)
7670 /* C++ base class field. */
7671 dwarf2_add_field (&fi
, child_die
, cu
);
7673 else if (child_die
->tag
== DW_TAG_typedef
)
7674 dwarf2_add_typedef (&fi
, child_die
, cu
);
7675 else if (child_die
->tag
== DW_TAG_template_type_param
7676 || child_die
->tag
== DW_TAG_template_value_param
)
7678 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
7681 VEC_safe_push (symbolp
, template_args
, arg
);
7684 child_die
= sibling_die (child_die
);
7687 /* Attach template arguments to type. */
7688 if (! VEC_empty (symbolp
, template_args
))
7690 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
7691 TYPE_N_TEMPLATE_ARGUMENTS (type
)
7692 = VEC_length (symbolp
, template_args
);
7693 TYPE_TEMPLATE_ARGUMENTS (type
)
7694 = obstack_alloc (&objfile
->objfile_obstack
,
7695 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
7696 * sizeof (struct symbol
*)));
7697 memcpy (TYPE_TEMPLATE_ARGUMENTS (type
),
7698 VEC_address (symbolp
, template_args
),
7699 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
7700 * sizeof (struct symbol
*)));
7701 VEC_free (symbolp
, template_args
);
7704 /* Attach fields and member functions to the type. */
7706 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
7709 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
7711 /* Get the type which refers to the base class (possibly this
7712 class itself) which contains the vtable pointer for the current
7713 class from the DW_AT_containing_type attribute. This use of
7714 DW_AT_containing_type is a GNU extension. */
7716 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
7718 struct type
*t
= die_containing_type (die
, cu
);
7720 TYPE_VPTR_BASETYPE (type
) = t
;
7725 /* Our own class provides vtbl ptr. */
7726 for (i
= TYPE_NFIELDS (t
) - 1;
7727 i
>= TYPE_N_BASECLASSES (t
);
7730 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
7732 if (is_vtable_name (fieldname
, cu
))
7734 TYPE_VPTR_FIELDNO (type
) = i
;
7739 /* Complain if virtual function table field not found. */
7740 if (i
< TYPE_N_BASECLASSES (t
))
7741 complaint (&symfile_complaints
,
7742 _("virtual function table pointer "
7743 "not found when defining class '%s'"),
7744 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
7749 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
7752 else if (cu
->producer
7753 && strncmp (cu
->producer
,
7754 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
7756 /* The IBM XLC compiler does not provide direct indication
7757 of the containing type, but the vtable pointer is
7758 always named __vfp. */
7762 for (i
= TYPE_NFIELDS (type
) - 1;
7763 i
>= TYPE_N_BASECLASSES (type
);
7766 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
7768 TYPE_VPTR_FIELDNO (type
) = i
;
7769 TYPE_VPTR_BASETYPE (type
) = type
;
7776 /* Copy fi.typedef_field_list linked list elements content into the
7777 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
7778 if (fi
.typedef_field_list
)
7780 int i
= fi
.typedef_field_list_count
;
7782 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
7783 TYPE_TYPEDEF_FIELD_ARRAY (type
)
7784 = TYPE_ALLOC (type
, sizeof (TYPE_TYPEDEF_FIELD (type
, 0)) * i
);
7785 TYPE_TYPEDEF_FIELD_COUNT (type
) = i
;
7787 /* Reverse the list order to keep the debug info elements order. */
7790 struct typedef_field
*dest
, *src
;
7792 dest
= &TYPE_TYPEDEF_FIELD (type
, i
);
7793 src
= &fi
.typedef_field_list
->field
;
7794 fi
.typedef_field_list
= fi
.typedef_field_list
->next
;
7799 do_cleanups (back_to
);
7801 if (HAVE_CPLUS_STRUCT (type
))
7802 TYPE_CPLUS_REALLY_JAVA (type
) = cu
->language
== language_java
;
7805 quirk_gcc_member_function_pointer (type
, objfile
);
7807 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
7808 snapshots) has been known to create a die giving a declaration
7809 for a class that has, as a child, a die giving a definition for a
7810 nested class. So we have to process our children even if the
7811 current die is a declaration. Normally, of course, a declaration
7812 won't have any children at all. */
7814 while (child_die
!= NULL
&& child_die
->tag
)
7816 if (child_die
->tag
== DW_TAG_member
7817 || child_die
->tag
== DW_TAG_variable
7818 || child_die
->tag
== DW_TAG_inheritance
7819 || child_die
->tag
== DW_TAG_template_value_param
7820 || child_die
->tag
== DW_TAG_template_type_param
)
7825 process_die (child_die
, cu
);
7827 child_die
= sibling_die (child_die
);
7830 /* Do not consider external references. According to the DWARF standard,
7831 these DIEs are identified by the fact that they have no byte_size
7832 attribute, and a declaration attribute. */
7833 if (dwarf2_attr (die
, DW_AT_byte_size
, cu
) != NULL
7834 || !die_is_declaration (die
, cu
))
7835 new_symbol (die
, type
, cu
);
7838 /* Given a DW_AT_enumeration_type die, set its type. We do not
7839 complete the type's fields yet, or create any symbols. */
7841 static struct type
*
7842 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7844 struct objfile
*objfile
= cu
->objfile
;
7846 struct attribute
*attr
;
7849 /* If the definition of this type lives in .debug_types, read that type.
7850 Don't follow DW_AT_specification though, that will take us back up
7851 the chain and we want to go down. */
7852 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
, cu
);
7855 struct dwarf2_cu
*type_cu
= cu
;
7856 struct die_info
*type_die
= follow_die_ref_or_sig (die
, attr
, &type_cu
);
7858 type
= read_type_die (type_die
, type_cu
);
7860 /* TYPE_CU may not be the same as CU.
7861 Ensure TYPE is recorded in CU's type_hash table. */
7862 return set_die_type (die
, type
, cu
);
7865 type
= alloc_type (objfile
);
7867 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
7868 name
= dwarf2_full_name (NULL
, die
, cu
);
7870 TYPE_TAG_NAME (type
) = (char *) name
;
7872 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
7875 TYPE_LENGTH (type
) = DW_UNSND (attr
);
7879 TYPE_LENGTH (type
) = 0;
7882 /* The enumeration DIE can be incomplete. In Ada, any type can be
7883 declared as private in the package spec, and then defined only
7884 inside the package body. Such types are known as Taft Amendment
7885 Types. When another package uses such a type, an incomplete DIE
7886 may be generated by the compiler. */
7887 if (die_is_declaration (die
, cu
))
7888 TYPE_STUB (type
) = 1;
7890 return set_die_type (die
, type
, cu
);
7893 /* Given a pointer to a die which begins an enumeration, process all
7894 the dies that define the members of the enumeration, and create the
7895 symbol for the enumeration type.
7897 NOTE: We reverse the order of the element list. */
7900 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
7902 struct type
*this_type
;
7904 this_type
= get_die_type (die
, cu
);
7905 if (this_type
== NULL
)
7906 this_type
= read_enumeration_type (die
, cu
);
7908 if (die
->child
!= NULL
)
7910 struct die_info
*child_die
;
7912 struct field
*fields
= NULL
;
7914 int unsigned_enum
= 1;
7917 child_die
= die
->child
;
7918 while (child_die
&& child_die
->tag
)
7920 if (child_die
->tag
!= DW_TAG_enumerator
)
7922 process_die (child_die
, cu
);
7926 name
= dwarf2_name (child_die
, cu
);
7929 sym
= new_symbol (child_die
, this_type
, cu
);
7930 if (SYMBOL_VALUE (sym
) < 0)
7933 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
7935 fields
= (struct field
*)
7937 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
7938 * sizeof (struct field
));
7941 FIELD_NAME (fields
[num_fields
]) = SYMBOL_LINKAGE_NAME (sym
);
7942 FIELD_TYPE (fields
[num_fields
]) = NULL
;
7943 SET_FIELD_BITPOS (fields
[num_fields
], SYMBOL_VALUE (sym
));
7944 FIELD_BITSIZE (fields
[num_fields
]) = 0;
7950 child_die
= sibling_die (child_die
);
7955 TYPE_NFIELDS (this_type
) = num_fields
;
7956 TYPE_FIELDS (this_type
) = (struct field
*)
7957 TYPE_ALLOC (this_type
, sizeof (struct field
) * num_fields
);
7958 memcpy (TYPE_FIELDS (this_type
), fields
,
7959 sizeof (struct field
) * num_fields
);
7963 TYPE_UNSIGNED (this_type
) = 1;
7966 /* If we are reading an enum from a .debug_types unit, and the enum
7967 is a declaration, and the enum is not the signatured type in the
7968 unit, then we do not want to add a symbol for it. Adding a
7969 symbol would in some cases obscure the true definition of the
7970 enum, giving users an incomplete type when the definition is
7971 actually available. Note that we do not want to do this for all
7972 enums which are just declarations, because C++0x allows forward
7973 enum declarations. */
7974 if (cu
->per_cu
->debug_types_section
7975 && die_is_declaration (die
, cu
))
7977 struct signatured_type
*type_sig
;
7980 = lookup_signatured_type_at_offset (dwarf2_per_objfile
->objfile
,
7981 cu
->per_cu
->debug_types_section
,
7982 cu
->per_cu
->offset
);
7983 if (type_sig
->type_offset
!= die
->offset
)
7987 new_symbol (die
, this_type
, cu
);
7990 /* Extract all information from a DW_TAG_array_type DIE and put it in
7991 the DIE's type field. For now, this only handles one dimensional
7994 static struct type
*
7995 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7997 struct objfile
*objfile
= cu
->objfile
;
7998 struct die_info
*child_die
;
8000 struct type
*element_type
, *range_type
, *index_type
;
8001 struct type
**range_types
= NULL
;
8002 struct attribute
*attr
;
8004 struct cleanup
*back_to
;
8007 element_type
= die_type (die
, cu
);
8009 /* The die_type call above may have already set the type for this DIE. */
8010 type
= get_die_type (die
, cu
);
8014 /* Irix 6.2 native cc creates array types without children for
8015 arrays with unspecified length. */
8016 if (die
->child
== NULL
)
8018 index_type
= objfile_type (objfile
)->builtin_int
;
8019 range_type
= create_range_type (NULL
, index_type
, 0, -1);
8020 type
= create_array_type (NULL
, element_type
, range_type
);
8021 return set_die_type (die
, type
, cu
);
8024 back_to
= make_cleanup (null_cleanup
, NULL
);
8025 child_die
= die
->child
;
8026 while (child_die
&& child_die
->tag
)
8028 if (child_die
->tag
== DW_TAG_subrange_type
)
8030 struct type
*child_type
= read_type_die (child_die
, cu
);
8032 if (child_type
!= NULL
)
8034 /* The range type was succesfully read. Save it for the
8035 array type creation. */
8036 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
8038 range_types
= (struct type
**)
8039 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
8040 * sizeof (struct type
*));
8042 make_cleanup (free_current_contents
, &range_types
);
8044 range_types
[ndim
++] = child_type
;
8047 child_die
= sibling_die (child_die
);
8050 /* Dwarf2 dimensions are output from left to right, create the
8051 necessary array types in backwards order. */
8053 type
= element_type
;
8055 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
8060 type
= create_array_type (NULL
, type
, range_types
[i
++]);
8065 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
8068 /* Understand Dwarf2 support for vector types (like they occur on
8069 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
8070 array type. This is not part of the Dwarf2/3 standard yet, but a
8071 custom vendor extension. The main difference between a regular
8072 array and the vector variant is that vectors are passed by value
8074 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
8076 make_vector_type (type
);
8078 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
8079 implementation may choose to implement triple vectors using this
8081 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
8084 if (DW_UNSND (attr
) >= TYPE_LENGTH (type
))
8085 TYPE_LENGTH (type
) = DW_UNSND (attr
);
8087 complaint (&symfile_complaints
,
8088 _("DW_AT_byte_size for array type smaller "
8089 "than the total size of elements"));
8092 name
= dwarf2_name (die
, cu
);
8094 TYPE_NAME (type
) = name
;
8096 /* Install the type in the die. */
8097 set_die_type (die
, type
, cu
);
8099 /* set_die_type should be already done. */
8100 set_descriptive_type (type
, die
, cu
);
8102 do_cleanups (back_to
);
8107 static enum dwarf_array_dim_ordering
8108 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
8110 struct attribute
*attr
;
8112 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
8114 if (attr
) return DW_SND (attr
);
8116 /* GNU F77 is a special case, as at 08/2004 array type info is the
8117 opposite order to the dwarf2 specification, but data is still
8118 laid out as per normal fortran.
8120 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
8121 version checking. */
8123 if (cu
->language
== language_fortran
8124 && cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
8126 return DW_ORD_row_major
;
8129 switch (cu
->language_defn
->la_array_ordering
)
8131 case array_column_major
:
8132 return DW_ORD_col_major
;
8133 case array_row_major
:
8135 return DW_ORD_row_major
;
8139 /* Extract all information from a DW_TAG_set_type DIE and put it in
8140 the DIE's type field. */
8142 static struct type
*
8143 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8145 struct type
*domain_type
, *set_type
;
8146 struct attribute
*attr
;
8148 domain_type
= die_type (die
, cu
);
8150 /* The die_type call above may have already set the type for this DIE. */
8151 set_type
= get_die_type (die
, cu
);
8155 set_type
= create_set_type (NULL
, domain_type
);
8157 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
8159 TYPE_LENGTH (set_type
) = DW_UNSND (attr
);
8161 return set_die_type (die
, set_type
, cu
);
8164 /* First cut: install each common block member as a global variable. */
8167 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
8169 struct die_info
*child_die
;
8170 struct attribute
*attr
;
8172 CORE_ADDR base
= (CORE_ADDR
) 0;
8174 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
8177 /* Support the .debug_loc offsets. */
8178 if (attr_form_is_block (attr
))
8180 base
= decode_locdesc (DW_BLOCK (attr
), cu
);
8182 else if (attr_form_is_section_offset (attr
))
8184 dwarf2_complex_location_expr_complaint ();
8188 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
8189 "common block member");
8192 if (die
->child
!= NULL
)
8194 child_die
= die
->child
;
8195 while (child_die
&& child_die
->tag
)
8199 sym
= new_symbol (child_die
, NULL
, cu
);
8201 && handle_data_member_location (child_die
, cu
, &offset
))
8203 SYMBOL_VALUE_ADDRESS (sym
) = base
+ offset
;
8204 add_symbol_to_list (sym
, &global_symbols
);
8206 child_die
= sibling_die (child_die
);
8211 /* Create a type for a C++ namespace. */
8213 static struct type
*
8214 read_namespace_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8216 struct objfile
*objfile
= cu
->objfile
;
8217 const char *previous_prefix
, *name
;
8221 /* For extensions, reuse the type of the original namespace. */
8222 if (dwarf2_attr (die
, DW_AT_extension
, cu
) != NULL
)
8224 struct die_info
*ext_die
;
8225 struct dwarf2_cu
*ext_cu
= cu
;
8227 ext_die
= dwarf2_extension (die
, &ext_cu
);
8228 type
= read_type_die (ext_die
, ext_cu
);
8230 /* EXT_CU may not be the same as CU.
8231 Ensure TYPE is recorded in CU's type_hash table. */
8232 return set_die_type (die
, type
, cu
);
8235 name
= namespace_name (die
, &is_anonymous
, cu
);
8237 /* Now build the name of the current namespace. */
8239 previous_prefix
= determine_prefix (die
, cu
);
8240 if (previous_prefix
[0] != '\0')
8241 name
= typename_concat (&objfile
->objfile_obstack
,
8242 previous_prefix
, name
, 0, cu
);
8244 /* Create the type. */
8245 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0, NULL
,
8247 TYPE_NAME (type
) = (char *) name
;
8248 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
8250 return set_die_type (die
, type
, cu
);
8253 /* Read a C++ namespace. */
8256 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
8258 struct objfile
*objfile
= cu
->objfile
;
8261 /* Add a symbol associated to this if we haven't seen the namespace
8262 before. Also, add a using directive if it's an anonymous
8265 if (dwarf2_attr (die
, DW_AT_extension
, cu
) == NULL
)
8269 type
= read_type_die (die
, cu
);
8270 new_symbol (die
, type
, cu
);
8272 namespace_name (die
, &is_anonymous
, cu
);
8275 const char *previous_prefix
= determine_prefix (die
, cu
);
8277 cp_add_using_directive (previous_prefix
, TYPE_NAME (type
), NULL
,
8278 NULL
, NULL
, &objfile
->objfile_obstack
);
8282 if (die
->child
!= NULL
)
8284 struct die_info
*child_die
= die
->child
;
8286 while (child_die
&& child_die
->tag
)
8288 process_die (child_die
, cu
);
8289 child_die
= sibling_die (child_die
);
8294 /* Read a Fortran module as type. This DIE can be only a declaration used for
8295 imported module. Still we need that type as local Fortran "use ... only"
8296 declaration imports depend on the created type in determine_prefix. */
8298 static struct type
*
8299 read_module_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8301 struct objfile
*objfile
= cu
->objfile
;
8305 module_name
= dwarf2_name (die
, cu
);
8307 complaint (&symfile_complaints
,
8308 _("DW_TAG_module has no name, offset 0x%x"),
8310 type
= init_type (TYPE_CODE_MODULE
, 0, 0, module_name
, objfile
);
8312 /* determine_prefix uses TYPE_TAG_NAME. */
8313 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
8315 return set_die_type (die
, type
, cu
);
8318 /* Read a Fortran module. */
8321 read_module (struct die_info
*die
, struct dwarf2_cu
*cu
)
8323 struct die_info
*child_die
= die
->child
;
8325 while (child_die
&& child_die
->tag
)
8327 process_die (child_die
, cu
);
8328 child_die
= sibling_die (child_die
);
8332 /* Return the name of the namespace represented by DIE. Set
8333 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
8337 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
8339 struct die_info
*current_die
;
8340 const char *name
= NULL
;
8342 /* Loop through the extensions until we find a name. */
8344 for (current_die
= die
;
8345 current_die
!= NULL
;
8346 current_die
= dwarf2_extension (die
, &cu
))
8348 name
= dwarf2_name (current_die
, cu
);
8353 /* Is it an anonymous namespace? */
8355 *is_anonymous
= (name
== NULL
);
8357 name
= CP_ANONYMOUS_NAMESPACE_STR
;
8362 /* Extract all information from a DW_TAG_pointer_type DIE and add to
8363 the user defined type vector. */
8365 static struct type
*
8366 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8368 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
8369 struct comp_unit_head
*cu_header
= &cu
->header
;
8371 struct attribute
*attr_byte_size
;
8372 struct attribute
*attr_address_class
;
8373 int byte_size
, addr_class
;
8374 struct type
*target_type
;
8376 target_type
= die_type (die
, cu
);
8378 /* The die_type call above may have already set the type for this DIE. */
8379 type
= get_die_type (die
, cu
);
8383 type
= lookup_pointer_type (target_type
);
8385 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
8387 byte_size
= DW_UNSND (attr_byte_size
);
8389 byte_size
= cu_header
->addr_size
;
8391 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
8392 if (attr_address_class
)
8393 addr_class
= DW_UNSND (attr_address_class
);
8395 addr_class
= DW_ADDR_none
;
8397 /* If the pointer size or address class is different than the
8398 default, create a type variant marked as such and set the
8399 length accordingly. */
8400 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
8402 if (gdbarch_address_class_type_flags_p (gdbarch
))
8406 type_flags
= gdbarch_address_class_type_flags
8407 (gdbarch
, byte_size
, addr_class
);
8408 gdb_assert ((type_flags
& ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
8410 type
= make_type_with_address_space (type
, type_flags
);
8412 else if (TYPE_LENGTH (type
) != byte_size
)
8414 complaint (&symfile_complaints
,
8415 _("invalid pointer size %d"), byte_size
);
8419 /* Should we also complain about unhandled address classes? */
8423 TYPE_LENGTH (type
) = byte_size
;
8424 return set_die_type (die
, type
, cu
);
8427 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
8428 the user defined type vector. */
8430 static struct type
*
8431 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8434 struct type
*to_type
;
8435 struct type
*domain
;
8437 to_type
= die_type (die
, cu
);
8438 domain
= die_containing_type (die
, cu
);
8440 /* The calls above may have already set the type for this DIE. */
8441 type
= get_die_type (die
, cu
);
8445 if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_METHOD
)
8446 type
= lookup_methodptr_type (to_type
);
8448 type
= lookup_memberptr_type (to_type
, domain
);
8450 return set_die_type (die
, type
, cu
);
8453 /* Extract all information from a DW_TAG_reference_type DIE and add to
8454 the user defined type vector. */
8456 static struct type
*
8457 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8459 struct comp_unit_head
*cu_header
= &cu
->header
;
8460 struct type
*type
, *target_type
;
8461 struct attribute
*attr
;
8463 target_type
= die_type (die
, cu
);
8465 /* The die_type call above may have already set the type for this DIE. */
8466 type
= get_die_type (die
, cu
);
8470 type
= lookup_reference_type (target_type
);
8471 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
8474 TYPE_LENGTH (type
) = DW_UNSND (attr
);
8478 TYPE_LENGTH (type
) = cu_header
->addr_size
;
8480 return set_die_type (die
, type
, cu
);
8483 static struct type
*
8484 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8486 struct type
*base_type
, *cv_type
;
8488 base_type
= die_type (die
, cu
);
8490 /* The die_type call above may have already set the type for this DIE. */
8491 cv_type
= get_die_type (die
, cu
);
8495 /* In case the const qualifier is applied to an array type, the element type
8496 is so qualified, not the array type (section 6.7.3 of C99). */
8497 if (TYPE_CODE (base_type
) == TYPE_CODE_ARRAY
)
8499 struct type
*el_type
, *inner_array
;
8501 base_type
= copy_type (base_type
);
8502 inner_array
= base_type
;
8504 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array
)) == TYPE_CODE_ARRAY
)
8506 TYPE_TARGET_TYPE (inner_array
) =
8507 copy_type (TYPE_TARGET_TYPE (inner_array
));
8508 inner_array
= TYPE_TARGET_TYPE (inner_array
);
8511 el_type
= TYPE_TARGET_TYPE (inner_array
);
8512 TYPE_TARGET_TYPE (inner_array
) =
8513 make_cv_type (1, TYPE_VOLATILE (el_type
), el_type
, NULL
);
8515 return set_die_type (die
, base_type
, cu
);
8518 cv_type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
8519 return set_die_type (die
, cv_type
, cu
);
8522 static struct type
*
8523 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8525 struct type
*base_type
, *cv_type
;
8527 base_type
= die_type (die
, cu
);
8529 /* The die_type call above may have already set the type for this DIE. */
8530 cv_type
= get_die_type (die
, cu
);
8534 cv_type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
8535 return set_die_type (die
, cv_type
, cu
);
8538 /* Extract all information from a DW_TAG_string_type DIE and add to
8539 the user defined type vector. It isn't really a user defined type,
8540 but it behaves like one, with other DIE's using an AT_user_def_type
8541 attribute to reference it. */
8543 static struct type
*
8544 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8546 struct objfile
*objfile
= cu
->objfile
;
8547 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
8548 struct type
*type
, *range_type
, *index_type
, *char_type
;
8549 struct attribute
*attr
;
8550 unsigned int length
;
8552 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
8555 length
= DW_UNSND (attr
);
8559 /* Check for the DW_AT_byte_size attribute. */
8560 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
8563 length
= DW_UNSND (attr
);
8571 index_type
= objfile_type (objfile
)->builtin_int
;
8572 range_type
= create_range_type (NULL
, index_type
, 1, length
);
8573 char_type
= language_string_char_type (cu
->language_defn
, gdbarch
);
8574 type
= create_string_type (NULL
, char_type
, range_type
);
8576 return set_die_type (die
, type
, cu
);
8579 /* Handle DIES due to C code like:
8583 int (*funcp)(int a, long l);
8587 ('funcp' generates a DW_TAG_subroutine_type DIE). */
8589 static struct type
*
8590 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8592 struct objfile
*objfile
= cu
->objfile
;
8593 struct type
*type
; /* Type that this function returns. */
8594 struct type
*ftype
; /* Function that returns above type. */
8595 struct attribute
*attr
;
8597 type
= die_type (die
, cu
);
8599 /* The die_type call above may have already set the type for this DIE. */
8600 ftype
= get_die_type (die
, cu
);
8604 ftype
= lookup_function_type (type
);
8606 /* All functions in C++, Pascal and Java have prototypes. */
8607 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
8608 if ((attr
&& (DW_UNSND (attr
) != 0))
8609 || cu
->language
== language_cplus
8610 || cu
->language
== language_java
8611 || cu
->language
== language_pascal
)
8612 TYPE_PROTOTYPED (ftype
) = 1;
8613 else if (producer_is_realview (cu
->producer
))
8614 /* RealView does not emit DW_AT_prototyped. We can not
8615 distinguish prototyped and unprototyped functions; default to
8616 prototyped, since that is more common in modern code (and
8617 RealView warns about unprototyped functions). */
8618 TYPE_PROTOTYPED (ftype
) = 1;
8620 /* Store the calling convention in the type if it's available in
8621 the subroutine die. Otherwise set the calling convention to
8622 the default value DW_CC_normal. */
8623 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
8625 TYPE_CALLING_CONVENTION (ftype
) = DW_UNSND (attr
);
8626 else if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL"))
8627 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_GDB_IBM_OpenCL
;
8629 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_normal
;
8631 /* We need to add the subroutine type to the die immediately so
8632 we don't infinitely recurse when dealing with parameters
8633 declared as the same subroutine type. */
8634 set_die_type (die
, ftype
, cu
);
8636 if (die
->child
!= NULL
)
8638 struct type
*void_type
= objfile_type (objfile
)->builtin_void
;
8639 struct die_info
*child_die
;
8640 int nparams
, iparams
;
8642 /* Count the number of parameters.
8643 FIXME: GDB currently ignores vararg functions, but knows about
8644 vararg member functions. */
8646 child_die
= die
->child
;
8647 while (child_die
&& child_die
->tag
)
8649 if (child_die
->tag
== DW_TAG_formal_parameter
)
8651 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
8652 TYPE_VARARGS (ftype
) = 1;
8653 child_die
= sibling_die (child_die
);
8656 /* Allocate storage for parameters and fill them in. */
8657 TYPE_NFIELDS (ftype
) = nparams
;
8658 TYPE_FIELDS (ftype
) = (struct field
*)
8659 TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
));
8661 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
8662 even if we error out during the parameters reading below. */
8663 for (iparams
= 0; iparams
< nparams
; iparams
++)
8664 TYPE_FIELD_TYPE (ftype
, iparams
) = void_type
;
8667 child_die
= die
->child
;
8668 while (child_die
&& child_die
->tag
)
8670 if (child_die
->tag
== DW_TAG_formal_parameter
)
8672 struct type
*arg_type
;
8674 /* DWARF version 2 has no clean way to discern C++
8675 static and non-static member functions. G++ helps
8676 GDB by marking the first parameter for non-static
8677 member functions (which is the this pointer) as
8678 artificial. We pass this information to
8679 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
8681 DWARF version 3 added DW_AT_object_pointer, which GCC
8682 4.5 does not yet generate. */
8683 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
8685 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
8688 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
8690 /* GCC/43521: In java, the formal parameter
8691 "this" is sometimes not marked with DW_AT_artificial. */
8692 if (cu
->language
== language_java
)
8694 const char *name
= dwarf2_name (child_die
, cu
);
8696 if (name
&& !strcmp (name
, "this"))
8697 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 1;
8700 arg_type
= die_type (child_die
, cu
);
8702 /* RealView does not mark THIS as const, which the testsuite
8703 expects. GCC marks THIS as const in method definitions,
8704 but not in the class specifications (GCC PR 43053). */
8705 if (cu
->language
== language_cplus
&& !TYPE_CONST (arg_type
)
8706 && TYPE_FIELD_ARTIFICIAL (ftype
, iparams
))
8709 struct dwarf2_cu
*arg_cu
= cu
;
8710 const char *name
= dwarf2_name (child_die
, cu
);
8712 attr
= dwarf2_attr (die
, DW_AT_object_pointer
, cu
);
8715 /* If the compiler emits this, use it. */
8716 if (follow_die_ref (die
, attr
, &arg_cu
) == child_die
)
8719 else if (name
&& strcmp (name
, "this") == 0)
8720 /* Function definitions will have the argument names. */
8722 else if (name
== NULL
&& iparams
== 0)
8723 /* Declarations may not have the names, so like
8724 elsewhere in GDB, assume an artificial first
8725 argument is "this". */
8729 arg_type
= make_cv_type (1, TYPE_VOLATILE (arg_type
),
8733 TYPE_FIELD_TYPE (ftype
, iparams
) = arg_type
;
8736 child_die
= sibling_die (child_die
);
8743 static struct type
*
8744 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
8746 struct objfile
*objfile
= cu
->objfile
;
8747 const char *name
= NULL
;
8748 struct type
*this_type
, *target_type
;
8750 name
= dwarf2_full_name (NULL
, die
, cu
);
8751 this_type
= init_type (TYPE_CODE_TYPEDEF
, 0,
8752 TYPE_FLAG_TARGET_STUB
, NULL
, objfile
);
8753 TYPE_NAME (this_type
) = (char *) name
;
8754 set_die_type (die
, this_type
, cu
);
8755 target_type
= die_type (die
, cu
);
8756 if (target_type
!= this_type
)
8757 TYPE_TARGET_TYPE (this_type
) = target_type
;
8760 /* Self-referential typedefs are, it seems, not allowed by the DWARF
8761 spec and cause infinite loops in GDB. */
8762 complaint (&symfile_complaints
,
8763 _("Self-referential DW_TAG_typedef "
8764 "- DIE at 0x%x [in module %s]"),
8765 die
->offset
, objfile
->name
);
8766 TYPE_TARGET_TYPE (this_type
) = NULL
;
8771 /* Find a representation of a given base type and install
8772 it in the TYPE field of the die. */
8774 static struct type
*
8775 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8777 struct objfile
*objfile
= cu
->objfile
;
8779 struct attribute
*attr
;
8780 int encoding
= 0, size
= 0;
8782 enum type_code code
= TYPE_CODE_INT
;
8784 struct type
*target_type
= NULL
;
8786 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
8789 encoding
= DW_UNSND (attr
);
8791 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
8794 size
= DW_UNSND (attr
);
8796 name
= dwarf2_name (die
, cu
);
8799 complaint (&symfile_complaints
,
8800 _("DW_AT_name missing from DW_TAG_base_type"));
8805 case DW_ATE_address
:
8806 /* Turn DW_ATE_address into a void * pointer. */
8807 code
= TYPE_CODE_PTR
;
8808 type_flags
|= TYPE_FLAG_UNSIGNED
;
8809 target_type
= init_type (TYPE_CODE_VOID
, 1, 0, NULL
, objfile
);
8811 case DW_ATE_boolean
:
8812 code
= TYPE_CODE_BOOL
;
8813 type_flags
|= TYPE_FLAG_UNSIGNED
;
8815 case DW_ATE_complex_float
:
8816 code
= TYPE_CODE_COMPLEX
;
8817 target_type
= init_type (TYPE_CODE_FLT
, size
/ 2, 0, NULL
, objfile
);
8819 case DW_ATE_decimal_float
:
8820 code
= TYPE_CODE_DECFLOAT
;
8823 code
= TYPE_CODE_FLT
;
8827 case DW_ATE_unsigned
:
8828 type_flags
|= TYPE_FLAG_UNSIGNED
;
8829 if (cu
->language
== language_fortran
8831 && strncmp (name
, "character(", sizeof ("character(") - 1) == 0)
8832 code
= TYPE_CODE_CHAR
;
8834 case DW_ATE_signed_char
:
8835 if (cu
->language
== language_ada
|| cu
->language
== language_m2
8836 || cu
->language
== language_pascal
8837 || cu
->language
== language_fortran
)
8838 code
= TYPE_CODE_CHAR
;
8840 case DW_ATE_unsigned_char
:
8841 if (cu
->language
== language_ada
|| cu
->language
== language_m2
8842 || cu
->language
== language_pascal
8843 || cu
->language
== language_fortran
)
8844 code
= TYPE_CODE_CHAR
;
8845 type_flags
|= TYPE_FLAG_UNSIGNED
;
8848 /* We just treat this as an integer and then recognize the
8849 type by name elsewhere. */
8853 complaint (&symfile_complaints
, _("unsupported DW_AT_encoding: '%s'"),
8854 dwarf_type_encoding_name (encoding
));
8858 type
= init_type (code
, size
, type_flags
, NULL
, objfile
);
8859 TYPE_NAME (type
) = name
;
8860 TYPE_TARGET_TYPE (type
) = target_type
;
8862 if (name
&& strcmp (name
, "char") == 0)
8863 TYPE_NOSIGN (type
) = 1;
8865 return set_die_type (die
, type
, cu
);
8868 /* Read the given DW_AT_subrange DIE. */
8870 static struct type
*
8871 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8873 struct type
*base_type
;
8874 struct type
*range_type
;
8875 struct attribute
*attr
;
8879 LONGEST negative_mask
;
8881 base_type
= die_type (die
, cu
);
8882 /* Preserve BASE_TYPE's original type, just set its LENGTH. */
8883 check_typedef (base_type
);
8885 /* The die_type call above may have already set the type for this DIE. */
8886 range_type
= get_die_type (die
, cu
);
8890 if (cu
->language
== language_fortran
)
8892 /* FORTRAN implies a lower bound of 1, if not given. */
8896 /* FIXME: For variable sized arrays either of these could be
8897 a variable rather than a constant value. We'll allow it,
8898 but we don't know how to handle it. */
8899 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
8901 low
= dwarf2_get_attr_constant_value (attr
, 0);
8903 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
8906 if (attr_form_is_block (attr
) || is_ref_attr (attr
))
8908 /* GCC encodes arrays with unspecified or dynamic length
8909 with a DW_FORM_block1 attribute or a reference attribute.
8910 FIXME: GDB does not yet know how to handle dynamic
8911 arrays properly, treat them as arrays with unspecified
8914 FIXME: jimb/2003-09-22: GDB does not really know
8915 how to handle arrays of unspecified length
8916 either; we just represent them as zero-length
8917 arrays. Choose an appropriate upper bound given
8918 the lower bound we've computed above. */
8922 high
= dwarf2_get_attr_constant_value (attr
, 1);
8926 attr
= dwarf2_attr (die
, DW_AT_count
, cu
);
8929 int count
= dwarf2_get_attr_constant_value (attr
, 1);
8930 high
= low
+ count
- 1;
8934 /* Unspecified array length. */
8939 /* Dwarf-2 specifications explicitly allows to create subrange types
8940 without specifying a base type.
8941 In that case, the base type must be set to the type of
8942 the lower bound, upper bound or count, in that order, if any of these
8943 three attributes references an object that has a type.
8944 If no base type is found, the Dwarf-2 specifications say that
8945 a signed integer type of size equal to the size of an address should
8947 For the following C code: `extern char gdb_int [];'
8948 GCC produces an empty range DIE.
8949 FIXME: muller/2010-05-28: Possible references to object for low bound,
8950 high bound or count are not yet handled by this code. */
8951 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
8953 struct objfile
*objfile
= cu
->objfile
;
8954 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
8955 int addr_size
= gdbarch_addr_bit (gdbarch
) /8;
8956 struct type
*int_type
= objfile_type (objfile
)->builtin_int
;
8958 /* Test "int", "long int", and "long long int" objfile types,
8959 and select the first one having a size above or equal to the
8960 architecture address size. */
8961 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
8962 base_type
= int_type
;
8965 int_type
= objfile_type (objfile
)->builtin_long
;
8966 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
8967 base_type
= int_type
;
8970 int_type
= objfile_type (objfile
)->builtin_long_long
;
8971 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
8972 base_type
= int_type
;
8978 (LONGEST
) -1 << (TYPE_LENGTH (base_type
) * TARGET_CHAR_BIT
- 1);
8979 if (!TYPE_UNSIGNED (base_type
) && (low
& negative_mask
))
8980 low
|= negative_mask
;
8981 if (!TYPE_UNSIGNED (base_type
) && (high
& negative_mask
))
8982 high
|= negative_mask
;
8984 range_type
= create_range_type (NULL
, base_type
, low
, high
);
8986 /* Mark arrays with dynamic length at least as an array of unspecified
8987 length. GDB could check the boundary but before it gets implemented at
8988 least allow accessing the array elements. */
8989 if (attr
&& attr_form_is_block (attr
))
8990 TYPE_HIGH_BOUND_UNDEFINED (range_type
) = 1;
8992 /* Ada expects an empty array on no boundary attributes. */
8993 if (attr
== NULL
&& cu
->language
!= language_ada
)
8994 TYPE_HIGH_BOUND_UNDEFINED (range_type
) = 1;
8996 name
= dwarf2_name (die
, cu
);
8998 TYPE_NAME (range_type
) = name
;
9000 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
9002 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
9004 set_die_type (die
, range_type
, cu
);
9006 /* set_die_type should be already done. */
9007 set_descriptive_type (range_type
, die
, cu
);
9012 static struct type
*
9013 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
9017 /* For now, we only support the C meaning of an unspecified type: void. */
9019 type
= init_type (TYPE_CODE_VOID
, 0, 0, NULL
, cu
->objfile
);
9020 TYPE_NAME (type
) = dwarf2_name (die
, cu
);
9022 return set_die_type (die
, type
, cu
);
9025 /* Trivial hash function for die_info: the hash value of a DIE
9026 is its offset in .debug_info for this objfile. */
9029 die_hash (const void *item
)
9031 const struct die_info
*die
= item
;
9036 /* Trivial comparison function for die_info structures: two DIEs
9037 are equal if they have the same offset. */
9040 die_eq (const void *item_lhs
, const void *item_rhs
)
9042 const struct die_info
*die_lhs
= item_lhs
;
9043 const struct die_info
*die_rhs
= item_rhs
;
9045 return die_lhs
->offset
== die_rhs
->offset
;
9048 /* Read a whole compilation unit into a linked list of dies. */
9050 static struct die_info
*
9051 read_comp_unit (gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
9053 struct die_reader_specs reader_specs
;
9054 int read_abbrevs
= 0;
9055 struct cleanup
*back_to
= NULL
;
9056 struct die_info
*die
;
9058 if (cu
->dwarf2_abbrevs
== NULL
)
9060 dwarf2_read_abbrevs (cu
);
9061 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
9065 gdb_assert (cu
->die_hash
== NULL
);
9067 = htab_create_alloc_ex (cu
->header
.length
/ 12,
9071 &cu
->comp_unit_obstack
,
9072 hashtab_obstack_allocate
,
9073 dummy_obstack_deallocate
);
9075 init_cu_die_reader (&reader_specs
, cu
);
9077 die
= read_die_and_children (&reader_specs
, info_ptr
, &info_ptr
, NULL
);
9080 do_cleanups (back_to
);
9085 /* Main entry point for reading a DIE and all children.
9086 Read the DIE and dump it if requested. */
9088 static struct die_info
*
9089 read_die_and_children (const struct die_reader_specs
*reader
,
9091 gdb_byte
**new_info_ptr
,
9092 struct die_info
*parent
)
9094 struct die_info
*result
= read_die_and_children_1 (reader
, info_ptr
,
9095 new_info_ptr
, parent
);
9097 if (dwarf2_die_debug
)
9099 fprintf_unfiltered (gdb_stdlog
,
9100 "\nRead die from %s of %s:\n",
9101 (reader
->cu
->per_cu
->debug_types_section
9104 reader
->abfd
->filename
);
9105 dump_die (result
, dwarf2_die_debug
);
9111 /* Read a single die and all its descendents. Set the die's sibling
9112 field to NULL; set other fields in the die correctly, and set all
9113 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
9114 location of the info_ptr after reading all of those dies. PARENT
9115 is the parent of the die in question. */
9117 static struct die_info
*
9118 read_die_and_children_1 (const struct die_reader_specs
*reader
,
9120 gdb_byte
**new_info_ptr
,
9121 struct die_info
*parent
)
9123 struct die_info
*die
;
9127 cur_ptr
= read_full_die (reader
, &die
, info_ptr
, &has_children
);
9130 *new_info_ptr
= cur_ptr
;
9133 store_in_ref_table (die
, reader
->cu
);
9136 die
->child
= read_die_and_siblings (reader
, cur_ptr
, new_info_ptr
, die
);
9140 *new_info_ptr
= cur_ptr
;
9143 die
->sibling
= NULL
;
9144 die
->parent
= parent
;
9148 /* Read a die, all of its descendents, and all of its siblings; set
9149 all of the fields of all of the dies correctly. Arguments are as
9150 in read_die_and_children. */
9152 static struct die_info
*
9153 read_die_and_siblings (const struct die_reader_specs
*reader
,
9155 gdb_byte
**new_info_ptr
,
9156 struct die_info
*parent
)
9158 struct die_info
*first_die
, *last_sibling
;
9162 first_die
= last_sibling
= NULL
;
9166 struct die_info
*die
9167 = read_die_and_children_1 (reader
, cur_ptr
, &cur_ptr
, parent
);
9171 *new_info_ptr
= cur_ptr
;
9178 last_sibling
->sibling
= die
;
9184 /* Read the die from the .debug_info section buffer. Set DIEP to
9185 point to a newly allocated die with its information, except for its
9186 child, sibling, and parent fields. Set HAS_CHILDREN to tell
9187 whether the die has children or not. */
9190 read_full_die (const struct die_reader_specs
*reader
,
9191 struct die_info
**diep
, gdb_byte
*info_ptr
,
9194 unsigned int abbrev_number
, bytes_read
, i
, offset
;
9195 struct abbrev_info
*abbrev
;
9196 struct die_info
*die
;
9197 struct dwarf2_cu
*cu
= reader
->cu
;
9198 bfd
*abfd
= reader
->abfd
;
9200 offset
= info_ptr
- reader
->buffer
;
9201 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
9202 info_ptr
+= bytes_read
;
9210 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
9212 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
9214 bfd_get_filename (abfd
));
9216 die
= dwarf_alloc_die (cu
, abbrev
->num_attrs
);
9217 die
->offset
= offset
;
9218 die
->tag
= abbrev
->tag
;
9219 die
->abbrev
= abbrev_number
;
9221 die
->num_attrs
= abbrev
->num_attrs
;
9223 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
9224 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
9225 abfd
, info_ptr
, cu
);
9228 *has_children
= abbrev
->has_children
;
9232 /* In DWARF version 2, the description of the debugging information is
9233 stored in a separate .debug_abbrev section. Before we read any
9234 dies from a section we read in all abbreviations and install them
9235 in a hash table. This function also sets flags in CU describing
9236 the data found in the abbrev table. */
9239 dwarf2_read_abbrevs (struct dwarf2_cu
*cu
)
9241 bfd
*abfd
= cu
->objfile
->obfd
;
9242 struct comp_unit_head
*cu_header
= &cu
->header
;
9243 gdb_byte
*abbrev_ptr
;
9244 struct abbrev_info
*cur_abbrev
;
9245 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
9246 unsigned int abbrev_form
, hash_number
;
9247 struct attr_abbrev
*cur_attrs
;
9248 unsigned int allocated_attrs
;
9250 /* Initialize dwarf2 abbrevs. */
9251 obstack_init (&cu
->abbrev_obstack
);
9252 cu
->dwarf2_abbrevs
= obstack_alloc (&cu
->abbrev_obstack
,
9254 * sizeof (struct abbrev_info
*)));
9255 memset (cu
->dwarf2_abbrevs
, 0,
9256 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
9258 dwarf2_read_section (dwarf2_per_objfile
->objfile
,
9259 &dwarf2_per_objfile
->abbrev
);
9260 abbrev_ptr
= dwarf2_per_objfile
->abbrev
.buffer
+ cu_header
->abbrev_offset
;
9261 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
9262 abbrev_ptr
+= bytes_read
;
9264 allocated_attrs
= ATTR_ALLOC_CHUNK
;
9265 cur_attrs
= xmalloc (allocated_attrs
* sizeof (struct attr_abbrev
));
9267 /* Loop until we reach an abbrev number of 0. */
9268 while (abbrev_number
)
9270 cur_abbrev
= dwarf_alloc_abbrev (cu
);
9272 /* read in abbrev header */
9273 cur_abbrev
->number
= abbrev_number
;
9274 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
9275 abbrev_ptr
+= bytes_read
;
9276 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
9279 if (cur_abbrev
->tag
== DW_TAG_namespace
)
9280 cu
->has_namespace_info
= 1;
9282 /* now read in declarations */
9283 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
9284 abbrev_ptr
+= bytes_read
;
9285 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
9286 abbrev_ptr
+= bytes_read
;
9289 if (cur_abbrev
->num_attrs
== allocated_attrs
)
9291 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
9293 = xrealloc (cur_attrs
, (allocated_attrs
9294 * sizeof (struct attr_abbrev
)));
9297 /* Record whether this compilation unit might have
9298 inter-compilation-unit references. If we don't know what form
9299 this attribute will have, then it might potentially be a
9300 DW_FORM_ref_addr, so we conservatively expect inter-CU
9303 if (abbrev_form
== DW_FORM_ref_addr
9304 || abbrev_form
== DW_FORM_indirect
)
9305 cu
->has_form_ref_addr
= 1;
9307 cur_attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
9308 cur_attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
9309 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
9310 abbrev_ptr
+= bytes_read
;
9311 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
9312 abbrev_ptr
+= bytes_read
;
9315 cur_abbrev
->attrs
= obstack_alloc (&cu
->abbrev_obstack
,
9316 (cur_abbrev
->num_attrs
9317 * sizeof (struct attr_abbrev
)));
9318 memcpy (cur_abbrev
->attrs
, cur_attrs
,
9319 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
9321 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
9322 cur_abbrev
->next
= cu
->dwarf2_abbrevs
[hash_number
];
9323 cu
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
9325 /* Get next abbreviation.
9326 Under Irix6 the abbreviations for a compilation unit are not
9327 always properly terminated with an abbrev number of 0.
9328 Exit loop if we encounter an abbreviation which we have
9329 already read (which means we are about to read the abbreviations
9330 for the next compile unit) or if the end of the abbreviation
9331 table is reached. */
9332 if ((unsigned int) (abbrev_ptr
- dwarf2_per_objfile
->abbrev
.buffer
)
9333 >= dwarf2_per_objfile
->abbrev
.size
)
9335 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
9336 abbrev_ptr
+= bytes_read
;
9337 if (dwarf2_lookup_abbrev (abbrev_number
, cu
) != NULL
)
9344 /* Release the memory used by the abbrev table for a compilation unit. */
9347 dwarf2_free_abbrev_table (void *ptr_to_cu
)
9349 struct dwarf2_cu
*cu
= ptr_to_cu
;
9351 obstack_free (&cu
->abbrev_obstack
, NULL
);
9352 cu
->dwarf2_abbrevs
= NULL
;
9355 /* Lookup an abbrev_info structure in the abbrev hash table. */
9357 static struct abbrev_info
*
9358 dwarf2_lookup_abbrev (unsigned int number
, struct dwarf2_cu
*cu
)
9360 unsigned int hash_number
;
9361 struct abbrev_info
*abbrev
;
9363 hash_number
= number
% ABBREV_HASH_SIZE
;
9364 abbrev
= cu
->dwarf2_abbrevs
[hash_number
];
9368 if (abbrev
->number
== number
)
9371 abbrev
= abbrev
->next
;
9376 /* Returns nonzero if TAG represents a type that we might generate a partial
9380 is_type_tag_for_partial (int tag
)
9385 /* Some types that would be reasonable to generate partial symbols for,
9386 that we don't at present. */
9387 case DW_TAG_array_type
:
9388 case DW_TAG_file_type
:
9389 case DW_TAG_ptr_to_member_type
:
9390 case DW_TAG_set_type
:
9391 case DW_TAG_string_type
:
9392 case DW_TAG_subroutine_type
:
9394 case DW_TAG_base_type
:
9395 case DW_TAG_class_type
:
9396 case DW_TAG_interface_type
:
9397 case DW_TAG_enumeration_type
:
9398 case DW_TAG_structure_type
:
9399 case DW_TAG_subrange_type
:
9400 case DW_TAG_typedef
:
9401 case DW_TAG_union_type
:
9408 /* Load all DIEs that are interesting for partial symbols into memory. */
9410 static struct partial_die_info
*
9411 load_partial_dies (bfd
*abfd
, gdb_byte
*buffer
, gdb_byte
*info_ptr
,
9412 int building_psymtab
, struct dwarf2_cu
*cu
)
9414 struct objfile
*objfile
= cu
->objfile
;
9415 struct partial_die_info
*part_die
;
9416 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
9417 struct abbrev_info
*abbrev
;
9418 unsigned int bytes_read
;
9419 unsigned int load_all
= 0;
9421 int nesting_level
= 1;
9426 if (cu
->per_cu
&& cu
->per_cu
->load_all_dies
)
9430 = htab_create_alloc_ex (cu
->header
.length
/ 12,
9434 &cu
->comp_unit_obstack
,
9435 hashtab_obstack_allocate
,
9436 dummy_obstack_deallocate
);
9438 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
9439 sizeof (struct partial_die_info
));
9443 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
9445 /* A NULL abbrev means the end of a series of children. */
9448 if (--nesting_level
== 0)
9450 /* PART_DIE was probably the last thing allocated on the
9451 comp_unit_obstack, so we could call obstack_free
9452 here. We don't do that because the waste is small,
9453 and will be cleaned up when we're done with this
9454 compilation unit. This way, we're also more robust
9455 against other users of the comp_unit_obstack. */
9458 info_ptr
+= bytes_read
;
9459 last_die
= parent_die
;
9460 parent_die
= parent_die
->die_parent
;
9464 /* Check for template arguments. We never save these; if
9465 they're seen, we just mark the parent, and go on our way. */
9466 if (parent_die
!= NULL
9467 && cu
->language
== language_cplus
9468 && (abbrev
->tag
== DW_TAG_template_type_param
9469 || abbrev
->tag
== DW_TAG_template_value_param
))
9471 parent_die
->has_template_arguments
= 1;
9475 /* We don't need a partial DIE for the template argument. */
9476 info_ptr
= skip_one_die (buffer
, info_ptr
+ bytes_read
, abbrev
,
9482 /* We only recurse into subprograms looking for template arguments.
9483 Skip their other children. */
9485 && cu
->language
== language_cplus
9486 && parent_die
!= NULL
9487 && parent_die
->tag
== DW_TAG_subprogram
)
9489 info_ptr
= skip_one_die (buffer
, info_ptr
+ bytes_read
, abbrev
, cu
);
9493 /* Check whether this DIE is interesting enough to save. Normally
9494 we would not be interested in members here, but there may be
9495 later variables referencing them via DW_AT_specification (for
9498 && !is_type_tag_for_partial (abbrev
->tag
)
9499 && abbrev
->tag
!= DW_TAG_constant
9500 && abbrev
->tag
!= DW_TAG_enumerator
9501 && abbrev
->tag
!= DW_TAG_subprogram
9502 && abbrev
->tag
!= DW_TAG_lexical_block
9503 && abbrev
->tag
!= DW_TAG_variable
9504 && abbrev
->tag
!= DW_TAG_namespace
9505 && abbrev
->tag
!= DW_TAG_module
9506 && abbrev
->tag
!= DW_TAG_member
)
9508 /* Otherwise we skip to the next sibling, if any. */
9509 info_ptr
= skip_one_die (buffer
, info_ptr
+ bytes_read
, abbrev
, cu
);
9513 info_ptr
= read_partial_die (part_die
, abbrev
, bytes_read
, abfd
,
9514 buffer
, info_ptr
, cu
);
9516 /* This two-pass algorithm for processing partial symbols has a
9517 high cost in cache pressure. Thus, handle some simple cases
9518 here which cover the majority of C partial symbols. DIEs
9519 which neither have specification tags in them, nor could have
9520 specification tags elsewhere pointing at them, can simply be
9521 processed and discarded.
9523 This segment is also optional; scan_partial_symbols and
9524 add_partial_symbol will handle these DIEs if we chain
9525 them in normally. When compilers which do not emit large
9526 quantities of duplicate debug information are more common,
9527 this code can probably be removed. */
9529 /* Any complete simple types at the top level (pretty much all
9530 of them, for a language without namespaces), can be processed
9532 if (parent_die
== NULL
9533 && part_die
->has_specification
== 0
9534 && part_die
->is_declaration
== 0
9535 && ((part_die
->tag
== DW_TAG_typedef
&& !part_die
->has_children
)
9536 || part_die
->tag
== DW_TAG_base_type
9537 || part_die
->tag
== DW_TAG_subrange_type
))
9539 if (building_psymtab
&& part_die
->name
!= NULL
)
9540 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
9541 VAR_DOMAIN
, LOC_TYPEDEF
,
9542 &objfile
->static_psymbols
,
9543 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
9544 info_ptr
= locate_pdi_sibling (part_die
, buffer
, info_ptr
, abfd
, cu
);
9548 /* The exception for DW_TAG_typedef with has_children above is
9549 a workaround of GCC PR debug/47510. In the case of this complaint
9550 type_name_no_tag_or_error will error on such types later.
9552 GDB skipped children of DW_TAG_typedef by the shortcut above and then
9553 it could not find the child DIEs referenced later, this is checked
9554 above. In correct DWARF DW_TAG_typedef should have no children. */
9556 if (part_die
->tag
== DW_TAG_typedef
&& part_die
->has_children
)
9557 complaint (&symfile_complaints
,
9558 _("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
9559 "- DIE at 0x%x [in module %s]"),
9560 part_die
->offset
, objfile
->name
);
9562 /* If we're at the second level, and we're an enumerator, and
9563 our parent has no specification (meaning possibly lives in a
9564 namespace elsewhere), then we can add the partial symbol now
9565 instead of queueing it. */
9566 if (part_die
->tag
== DW_TAG_enumerator
9567 && parent_die
!= NULL
9568 && parent_die
->die_parent
== NULL
9569 && parent_die
->tag
== DW_TAG_enumeration_type
9570 && parent_die
->has_specification
== 0)
9572 if (part_die
->name
== NULL
)
9573 complaint (&symfile_complaints
,
9574 _("malformed enumerator DIE ignored"));
9575 else if (building_psymtab
)
9576 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
9577 VAR_DOMAIN
, LOC_CONST
,
9578 (cu
->language
== language_cplus
9579 || cu
->language
== language_java
)
9580 ? &objfile
->global_psymbols
9581 : &objfile
->static_psymbols
,
9582 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
9584 info_ptr
= locate_pdi_sibling (part_die
, buffer
, info_ptr
, abfd
, cu
);
9588 /* We'll save this DIE so link it in. */
9589 part_die
->die_parent
= parent_die
;
9590 part_die
->die_sibling
= NULL
;
9591 part_die
->die_child
= NULL
;
9593 if (last_die
&& last_die
== parent_die
)
9594 last_die
->die_child
= part_die
;
9596 last_die
->die_sibling
= part_die
;
9598 last_die
= part_die
;
9600 if (first_die
== NULL
)
9601 first_die
= part_die
;
9603 /* Maybe add the DIE to the hash table. Not all DIEs that we
9604 find interesting need to be in the hash table, because we
9605 also have the parent/sibling/child chains; only those that we
9606 might refer to by offset later during partial symbol reading.
9608 For now this means things that might have be the target of a
9609 DW_AT_specification, DW_AT_abstract_origin, or
9610 DW_AT_extension. DW_AT_extension will refer only to
9611 namespaces; DW_AT_abstract_origin refers to functions (and
9612 many things under the function DIE, but we do not recurse
9613 into function DIEs during partial symbol reading) and
9614 possibly variables as well; DW_AT_specification refers to
9615 declarations. Declarations ought to have the DW_AT_declaration
9616 flag. It happens that GCC forgets to put it in sometimes, but
9617 only for functions, not for types.
9619 Adding more things than necessary to the hash table is harmless
9620 except for the performance cost. Adding too few will result in
9621 wasted time in find_partial_die, when we reread the compilation
9622 unit with load_all_dies set. */
9625 || abbrev
->tag
== DW_TAG_constant
9626 || abbrev
->tag
== DW_TAG_subprogram
9627 || abbrev
->tag
== DW_TAG_variable
9628 || abbrev
->tag
== DW_TAG_namespace
9629 || part_die
->is_declaration
)
9633 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
9634 part_die
->offset
, INSERT
);
9638 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
9639 sizeof (struct partial_die_info
));
9641 /* For some DIEs we want to follow their children (if any). For C
9642 we have no reason to follow the children of structures; for other
9643 languages we have to, so that we can get at method physnames
9644 to infer fully qualified class names, for DW_AT_specification,
9645 and for C++ template arguments. For C++, we also look one level
9646 inside functions to find template arguments (if the name of the
9647 function does not already contain the template arguments).
9649 For Ada, we need to scan the children of subprograms and lexical
9650 blocks as well because Ada allows the definition of nested
9651 entities that could be interesting for the debugger, such as
9652 nested subprograms for instance. */
9653 if (last_die
->has_children
9655 || last_die
->tag
== DW_TAG_namespace
9656 || last_die
->tag
== DW_TAG_module
9657 || last_die
->tag
== DW_TAG_enumeration_type
9658 || (cu
->language
== language_cplus
9659 && last_die
->tag
== DW_TAG_subprogram
9660 && (last_die
->name
== NULL
9661 || strchr (last_die
->name
, '<') == NULL
))
9662 || (cu
->language
!= language_c
9663 && (last_die
->tag
== DW_TAG_class_type
9664 || last_die
->tag
== DW_TAG_interface_type
9665 || last_die
->tag
== DW_TAG_structure_type
9666 || last_die
->tag
== DW_TAG_union_type
))
9667 || (cu
->language
== language_ada
9668 && (last_die
->tag
== DW_TAG_subprogram
9669 || last_die
->tag
== DW_TAG_lexical_block
))))
9672 parent_die
= last_die
;
9676 /* Otherwise we skip to the next sibling, if any. */
9677 info_ptr
= locate_pdi_sibling (last_die
, buffer
, info_ptr
, abfd
, cu
);
9679 /* Back to the top, do it again. */
9683 /* Read a minimal amount of information into the minimal die structure. */
9686 read_partial_die (struct partial_die_info
*part_die
,
9687 struct abbrev_info
*abbrev
,
9688 unsigned int abbrev_len
, bfd
*abfd
,
9689 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
9690 struct dwarf2_cu
*cu
)
9692 struct objfile
*objfile
= cu
->objfile
;
9694 struct attribute attr
;
9695 int has_low_pc_attr
= 0;
9696 int has_high_pc_attr
= 0;
9698 memset (part_die
, 0, sizeof (struct partial_die_info
));
9700 part_die
->offset
= info_ptr
- buffer
;
9702 info_ptr
+= abbrev_len
;
9707 part_die
->tag
= abbrev
->tag
;
9708 part_die
->has_children
= abbrev
->has_children
;
9710 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
9712 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
, info_ptr
, cu
);
9714 /* Store the data if it is of an attribute we want to keep in a
9715 partial symbol table. */
9719 switch (part_die
->tag
)
9721 case DW_TAG_compile_unit
:
9722 case DW_TAG_type_unit
:
9723 /* Compilation units have a DW_AT_name that is a filename, not
9724 a source language identifier. */
9725 case DW_TAG_enumeration_type
:
9726 case DW_TAG_enumerator
:
9727 /* These tags always have simple identifiers already; no need
9728 to canonicalize them. */
9729 part_die
->name
= DW_STRING (&attr
);
9733 = dwarf2_canonicalize_name (DW_STRING (&attr
), cu
,
9734 &objfile
->objfile_obstack
);
9738 case DW_AT_linkage_name
:
9739 case DW_AT_MIPS_linkage_name
:
9740 /* Note that both forms of linkage name might appear. We
9741 assume they will be the same, and we only store the last
9743 if (cu
->language
== language_ada
)
9744 part_die
->name
= DW_STRING (&attr
);
9745 part_die
->linkage_name
= DW_STRING (&attr
);
9748 has_low_pc_attr
= 1;
9749 part_die
->lowpc
= DW_ADDR (&attr
);
9752 has_high_pc_attr
= 1;
9753 part_die
->highpc
= DW_ADDR (&attr
);
9755 case DW_AT_location
:
9756 /* Support the .debug_loc offsets. */
9757 if (attr_form_is_block (&attr
))
9759 part_die
->locdesc
= DW_BLOCK (&attr
);
9761 else if (attr_form_is_section_offset (&attr
))
9763 dwarf2_complex_location_expr_complaint ();
9767 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
9768 "partial symbol information");
9771 case DW_AT_external
:
9772 part_die
->is_external
= DW_UNSND (&attr
);
9774 case DW_AT_declaration
:
9775 part_die
->is_declaration
= DW_UNSND (&attr
);
9778 part_die
->has_type
= 1;
9780 case DW_AT_abstract_origin
:
9781 case DW_AT_specification
:
9782 case DW_AT_extension
:
9783 part_die
->has_specification
= 1;
9784 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
);
9787 /* Ignore absolute siblings, they might point outside of
9788 the current compile unit. */
9789 if (attr
.form
== DW_FORM_ref_addr
)
9790 complaint (&symfile_complaints
,
9791 _("ignoring absolute DW_AT_sibling"));
9793 part_die
->sibling
= buffer
+ dwarf2_get_ref_die_offset (&attr
);
9795 case DW_AT_byte_size
:
9796 part_die
->has_byte_size
= 1;
9798 case DW_AT_calling_convention
:
9799 /* DWARF doesn't provide a way to identify a program's source-level
9800 entry point. DW_AT_calling_convention attributes are only meant
9801 to describe functions' calling conventions.
9803 However, because it's a necessary piece of information in
9804 Fortran, and because DW_CC_program is the only piece of debugging
9805 information whose definition refers to a 'main program' at all,
9806 several compilers have begun marking Fortran main programs with
9807 DW_CC_program --- even when those functions use the standard
9808 calling conventions.
9810 So until DWARF specifies a way to provide this information and
9811 compilers pick up the new representation, we'll support this
9813 if (DW_UNSND (&attr
) == DW_CC_program
9814 && cu
->language
== language_fortran
)
9816 set_main_name (part_die
->name
);
9818 /* As this DIE has a static linkage the name would be difficult
9819 to look up later. */
9820 language_of_main
= language_fortran
;
9828 if (has_low_pc_attr
&& has_high_pc_attr
)
9830 /* When using the GNU linker, .gnu.linkonce. sections are used to
9831 eliminate duplicate copies of functions and vtables and such.
9832 The linker will arbitrarily choose one and discard the others.
9833 The AT_*_pc values for such functions refer to local labels in
9834 these sections. If the section from that file was discarded, the
9835 labels are not in the output, so the relocs get a value of 0.
9836 If this is a discarded function, mark the pc bounds as invalid,
9837 so that GDB will ignore it. */
9838 if (part_die
->lowpc
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
9840 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
9842 complaint (&symfile_complaints
,
9843 _("DW_AT_low_pc %s is zero "
9844 "for DIE at 0x%x [in module %s]"),
9845 paddress (gdbarch
, part_die
->lowpc
),
9846 part_die
->offset
, objfile
->name
);
9848 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
9849 else if (part_die
->lowpc
>= part_die
->highpc
)
9851 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
9853 complaint (&symfile_complaints
,
9854 _("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
9855 "for DIE at 0x%x [in module %s]"),
9856 paddress (gdbarch
, part_die
->lowpc
),
9857 paddress (gdbarch
, part_die
->highpc
),
9858 part_die
->offset
, objfile
->name
);
9861 part_die
->has_pc_info
= 1;
9867 /* Find a cached partial DIE at OFFSET in CU. */
9869 static struct partial_die_info
*
9870 find_partial_die_in_comp_unit (unsigned int offset
, struct dwarf2_cu
*cu
)
9872 struct partial_die_info
*lookup_die
= NULL
;
9873 struct partial_die_info part_die
;
9875 part_die
.offset
= offset
;
9876 lookup_die
= htab_find_with_hash (cu
->partial_dies
, &part_die
, offset
);
9881 /* Find a partial DIE at OFFSET, which may or may not be in CU,
9882 except in the case of .debug_types DIEs which do not reference
9883 outside their CU (they do however referencing other types via
9884 DW_FORM_ref_sig8). */
9886 static struct partial_die_info
*
9887 find_partial_die (unsigned int offset
, struct dwarf2_cu
*cu
)
9889 struct objfile
*objfile
= cu
->objfile
;
9890 struct dwarf2_per_cu_data
*per_cu
= NULL
;
9891 struct partial_die_info
*pd
= NULL
;
9893 if (cu
->per_cu
->debug_types_section
)
9895 pd
= find_partial_die_in_comp_unit (offset
, cu
);
9901 if (offset_in_cu_p (&cu
->header
, offset
))
9903 pd
= find_partial_die_in_comp_unit (offset
, cu
);
9908 per_cu
= dwarf2_find_containing_comp_unit (offset
, objfile
);
9910 if (per_cu
->cu
== NULL
|| per_cu
->cu
->partial_dies
== NULL
)
9911 load_partial_comp_unit (per_cu
);
9913 per_cu
->cu
->last_used
= 0;
9914 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
9916 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
9918 struct cleanup
*back_to
;
9919 struct partial_die_info comp_unit_die
;
9920 struct abbrev_info
*abbrev
;
9921 unsigned int bytes_read
;
9924 per_cu
->load_all_dies
= 1;
9926 /* Re-read the DIEs. */
9927 back_to
= make_cleanup (null_cleanup
, 0);
9928 if (per_cu
->cu
->dwarf2_abbrevs
== NULL
)
9930 dwarf2_read_abbrevs (per_cu
->cu
);
9931 make_cleanup (dwarf2_free_abbrev_table
, per_cu
->cu
);
9933 info_ptr
= (dwarf2_per_objfile
->info
.buffer
9934 + per_cu
->cu
->header
.offset
9935 + per_cu
->cu
->header
.first_die_offset
);
9936 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, per_cu
->cu
);
9937 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
9939 dwarf2_per_objfile
->info
.buffer
, info_ptr
,
9941 if (comp_unit_die
.has_children
)
9942 load_partial_dies (objfile
->obfd
,
9943 dwarf2_per_objfile
->info
.buffer
, info_ptr
,
9945 do_cleanups (back_to
);
9947 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
9953 internal_error (__FILE__
, __LINE__
,
9954 _("could not find partial DIE 0x%x "
9955 "in cache [from module %s]\n"),
9956 offset
, bfd_get_filename (objfile
->obfd
));
9960 /* See if we can figure out if the class lives in a namespace. We do
9961 this by looking for a member function; its demangled name will
9962 contain namespace info, if there is any. */
9965 guess_partial_die_structure_name (struct partial_die_info
*struct_pdi
,
9966 struct dwarf2_cu
*cu
)
9968 /* NOTE: carlton/2003-10-07: Getting the info this way changes
9969 what template types look like, because the demangler
9970 frequently doesn't give the same name as the debug info. We
9971 could fix this by only using the demangled name to get the
9972 prefix (but see comment in read_structure_type). */
9974 struct partial_die_info
*real_pdi
;
9975 struct partial_die_info
*child_pdi
;
9977 /* If this DIE (this DIE's specification, if any) has a parent, then
9978 we should not do this. We'll prepend the parent's fully qualified
9979 name when we create the partial symbol. */
9981 real_pdi
= struct_pdi
;
9982 while (real_pdi
->has_specification
)
9983 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
9985 if (real_pdi
->die_parent
!= NULL
)
9988 for (child_pdi
= struct_pdi
->die_child
;
9990 child_pdi
= child_pdi
->die_sibling
)
9992 if (child_pdi
->tag
== DW_TAG_subprogram
9993 && child_pdi
->linkage_name
!= NULL
)
9995 char *actual_class_name
9996 = language_class_name_from_physname (cu
->language_defn
,
9997 child_pdi
->linkage_name
);
9998 if (actual_class_name
!= NULL
)
10001 = obsavestring (actual_class_name
,
10002 strlen (actual_class_name
),
10003 &cu
->objfile
->objfile_obstack
);
10004 xfree (actual_class_name
);
10011 /* Adjust PART_DIE before generating a symbol for it. This function
10012 may set the is_external flag or change the DIE's name. */
10015 fixup_partial_die (struct partial_die_info
*part_die
,
10016 struct dwarf2_cu
*cu
)
10018 /* Once we've fixed up a die, there's no point in doing so again.
10019 This also avoids a memory leak if we were to call
10020 guess_partial_die_structure_name multiple times. */
10021 if (part_die
->fixup_called
)
10024 /* If we found a reference attribute and the DIE has no name, try
10025 to find a name in the referred to DIE. */
10027 if (part_die
->name
== NULL
&& part_die
->has_specification
)
10029 struct partial_die_info
*spec_die
;
10031 spec_die
= find_partial_die (part_die
->spec_offset
, cu
);
10033 fixup_partial_die (spec_die
, cu
);
10035 if (spec_die
->name
)
10037 part_die
->name
= spec_die
->name
;
10039 /* Copy DW_AT_external attribute if it is set. */
10040 if (spec_die
->is_external
)
10041 part_die
->is_external
= spec_die
->is_external
;
10045 /* Set default names for some unnamed DIEs. */
10047 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
10048 part_die
->name
= CP_ANONYMOUS_NAMESPACE_STR
;
10050 /* If there is no parent die to provide a namespace, and there are
10051 children, see if we can determine the namespace from their linkage
10053 NOTE: We need to do this even if cu->has_namespace_info != 0.
10054 gcc-4.5 -gdwarf-4 can drop the enclosing namespace. */
10055 if (cu
->language
== language_cplus
10056 && !VEC_empty (dwarf2_section_info_def
, dwarf2_per_objfile
->types
)
10057 && part_die
->die_parent
== NULL
10058 && part_die
->has_children
10059 && (part_die
->tag
== DW_TAG_class_type
10060 || part_die
->tag
== DW_TAG_structure_type
10061 || part_die
->tag
== DW_TAG_union_type
))
10062 guess_partial_die_structure_name (part_die
, cu
);
10064 /* GCC might emit a nameless struct or union that has a linkage
10065 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
10066 if (part_die
->name
== NULL
10067 && (part_die
->tag
== DW_TAG_class_type
10068 || part_die
->tag
== DW_TAG_interface_type
10069 || part_die
->tag
== DW_TAG_structure_type
10070 || part_die
->tag
== DW_TAG_union_type
)
10071 && part_die
->linkage_name
!= NULL
)
10075 demangled
= cplus_demangle (part_die
->linkage_name
, DMGL_TYPES
);
10080 /* Strip any leading namespaces/classes, keep only the base name.
10081 DW_AT_name for named DIEs does not contain the prefixes. */
10082 base
= strrchr (demangled
, ':');
10083 if (base
&& base
> demangled
&& base
[-1] == ':')
10088 part_die
->name
= obsavestring (base
, strlen (base
),
10089 &cu
->objfile
->objfile_obstack
);
10094 part_die
->fixup_called
= 1;
10097 /* Read an attribute value described by an attribute form. */
10100 read_attribute_value (struct attribute
*attr
, unsigned form
,
10101 bfd
*abfd
, gdb_byte
*info_ptr
,
10102 struct dwarf2_cu
*cu
)
10104 struct comp_unit_head
*cu_header
= &cu
->header
;
10105 unsigned int bytes_read
;
10106 struct dwarf_block
*blk
;
10111 case DW_FORM_ref_addr
:
10112 if (cu
->header
.version
== 2)
10113 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
10115 DW_ADDR (attr
) = read_offset (abfd
, info_ptr
,
10116 &cu
->header
, &bytes_read
);
10117 info_ptr
+= bytes_read
;
10120 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
10121 info_ptr
+= bytes_read
;
10123 case DW_FORM_block2
:
10124 blk
= dwarf_alloc_block (cu
);
10125 blk
->size
= read_2_bytes (abfd
, info_ptr
);
10127 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
10128 info_ptr
+= blk
->size
;
10129 DW_BLOCK (attr
) = blk
;
10131 case DW_FORM_block4
:
10132 blk
= dwarf_alloc_block (cu
);
10133 blk
->size
= read_4_bytes (abfd
, info_ptr
);
10135 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
10136 info_ptr
+= blk
->size
;
10137 DW_BLOCK (attr
) = blk
;
10139 case DW_FORM_data2
:
10140 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
10143 case DW_FORM_data4
:
10144 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
10147 case DW_FORM_data8
:
10148 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
10151 case DW_FORM_sec_offset
:
10152 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
10153 info_ptr
+= bytes_read
;
10155 case DW_FORM_string
:
10156 DW_STRING (attr
) = read_direct_string (abfd
, info_ptr
, &bytes_read
);
10157 DW_STRING_IS_CANONICAL (attr
) = 0;
10158 info_ptr
+= bytes_read
;
10161 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
10163 DW_STRING_IS_CANONICAL (attr
) = 0;
10164 info_ptr
+= bytes_read
;
10166 case DW_FORM_exprloc
:
10167 case DW_FORM_block
:
10168 blk
= dwarf_alloc_block (cu
);
10169 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
10170 info_ptr
+= bytes_read
;
10171 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
10172 info_ptr
+= blk
->size
;
10173 DW_BLOCK (attr
) = blk
;
10175 case DW_FORM_block1
:
10176 blk
= dwarf_alloc_block (cu
);
10177 blk
->size
= read_1_byte (abfd
, info_ptr
);
10179 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
10180 info_ptr
+= blk
->size
;
10181 DW_BLOCK (attr
) = blk
;
10183 case DW_FORM_data1
:
10184 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
10188 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
10191 case DW_FORM_flag_present
:
10192 DW_UNSND (attr
) = 1;
10194 case DW_FORM_sdata
:
10195 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
10196 info_ptr
+= bytes_read
;
10198 case DW_FORM_udata
:
10199 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
10200 info_ptr
+= bytes_read
;
10203 DW_ADDR (attr
) = cu
->header
.offset
+ read_1_byte (abfd
, info_ptr
);
10207 DW_ADDR (attr
) = cu
->header
.offset
+ read_2_bytes (abfd
, info_ptr
);
10211 DW_ADDR (attr
) = cu
->header
.offset
+ read_4_bytes (abfd
, info_ptr
);
10215 DW_ADDR (attr
) = cu
->header
.offset
+ read_8_bytes (abfd
, info_ptr
);
10218 case DW_FORM_ref_sig8
:
10219 /* Convert the signature to something we can record in DW_UNSND
10221 NOTE: This is NULL if the type wasn't found. */
10222 DW_SIGNATURED_TYPE (attr
) =
10223 lookup_signatured_type (cu
->objfile
, read_8_bytes (abfd
, info_ptr
));
10226 case DW_FORM_ref_udata
:
10227 DW_ADDR (attr
) = (cu
->header
.offset
10228 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
10229 info_ptr
+= bytes_read
;
10231 case DW_FORM_indirect
:
10232 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
10233 info_ptr
+= bytes_read
;
10234 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu
);
10237 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
10238 dwarf_form_name (form
),
10239 bfd_get_filename (abfd
));
10242 /* We have seen instances where the compiler tried to emit a byte
10243 size attribute of -1 which ended up being encoded as an unsigned
10244 0xffffffff. Although 0xffffffff is technically a valid size value,
10245 an object of this size seems pretty unlikely so we can relatively
10246 safely treat these cases as if the size attribute was invalid and
10247 treat them as zero by default. */
10248 if (attr
->name
== DW_AT_byte_size
10249 && form
== DW_FORM_data4
10250 && DW_UNSND (attr
) >= 0xffffffff)
10253 (&symfile_complaints
,
10254 _("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
10255 hex_string (DW_UNSND (attr
)));
10256 DW_UNSND (attr
) = 0;
10262 /* Read an attribute described by an abbreviated attribute. */
10265 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
10266 bfd
*abfd
, gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
10268 attr
->name
= abbrev
->name
;
10269 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu
);
10272 /* Read dwarf information from a buffer. */
10274 static unsigned int
10275 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
10277 return bfd_get_8 (abfd
, buf
);
10281 read_1_signed_byte (bfd
*abfd
, gdb_byte
*buf
)
10283 return bfd_get_signed_8 (abfd
, buf
);
10286 static unsigned int
10287 read_2_bytes (bfd
*abfd
, gdb_byte
*buf
)
10289 return bfd_get_16 (abfd
, buf
);
10293 read_2_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
10295 return bfd_get_signed_16 (abfd
, buf
);
10298 static unsigned int
10299 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
10301 return bfd_get_32 (abfd
, buf
);
10305 read_4_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
10307 return bfd_get_signed_32 (abfd
, buf
);
10311 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
10313 return bfd_get_64 (abfd
, buf
);
10317 read_address (bfd
*abfd
, gdb_byte
*buf
, struct dwarf2_cu
*cu
,
10318 unsigned int *bytes_read
)
10320 struct comp_unit_head
*cu_header
= &cu
->header
;
10321 CORE_ADDR retval
= 0;
10323 if (cu_header
->signed_addr_p
)
10325 switch (cu_header
->addr_size
)
10328 retval
= bfd_get_signed_16 (abfd
, buf
);
10331 retval
= bfd_get_signed_32 (abfd
, buf
);
10334 retval
= bfd_get_signed_64 (abfd
, buf
);
10337 internal_error (__FILE__
, __LINE__
,
10338 _("read_address: bad switch, signed [in module %s]"),
10339 bfd_get_filename (abfd
));
10344 switch (cu_header
->addr_size
)
10347 retval
= bfd_get_16 (abfd
, buf
);
10350 retval
= bfd_get_32 (abfd
, buf
);
10353 retval
= bfd_get_64 (abfd
, buf
);
10356 internal_error (__FILE__
, __LINE__
,
10357 _("read_address: bad switch, "
10358 "unsigned [in module %s]"),
10359 bfd_get_filename (abfd
));
10363 *bytes_read
= cu_header
->addr_size
;
10367 /* Read the initial length from a section. The (draft) DWARF 3
10368 specification allows the initial length to take up either 4 bytes
10369 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
10370 bytes describe the length and all offsets will be 8 bytes in length
10373 An older, non-standard 64-bit format is also handled by this
10374 function. The older format in question stores the initial length
10375 as an 8-byte quantity without an escape value. Lengths greater
10376 than 2^32 aren't very common which means that the initial 4 bytes
10377 is almost always zero. Since a length value of zero doesn't make
10378 sense for the 32-bit format, this initial zero can be considered to
10379 be an escape value which indicates the presence of the older 64-bit
10380 format. As written, the code can't detect (old format) lengths
10381 greater than 4GB. If it becomes necessary to handle lengths
10382 somewhat larger than 4GB, we could allow other small values (such
10383 as the non-sensical values of 1, 2, and 3) to also be used as
10384 escape values indicating the presence of the old format.
10386 The value returned via bytes_read should be used to increment the
10387 relevant pointer after calling read_initial_length().
10389 [ Note: read_initial_length() and read_offset() are based on the
10390 document entitled "DWARF Debugging Information Format", revision
10391 3, draft 8, dated November 19, 2001. This document was obtained
10394 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
10396 This document is only a draft and is subject to change. (So beware.)
10398 Details regarding the older, non-standard 64-bit format were
10399 determined empirically by examining 64-bit ELF files produced by
10400 the SGI toolchain on an IRIX 6.5 machine.
10402 - Kevin, July 16, 2002
10406 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read
)
10408 LONGEST length
= bfd_get_32 (abfd
, buf
);
10410 if (length
== 0xffffffff)
10412 length
= bfd_get_64 (abfd
, buf
+ 4);
10415 else if (length
== 0)
10417 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
10418 length
= bfd_get_64 (abfd
, buf
);
10429 /* Cover function for read_initial_length.
10430 Returns the length of the object at BUF, and stores the size of the
10431 initial length in *BYTES_READ and stores the size that offsets will be in
10433 If the initial length size is not equivalent to that specified in
10434 CU_HEADER then issue a complaint.
10435 This is useful when reading non-comp-unit headers. */
10438 read_checked_initial_length_and_offset (bfd
*abfd
, gdb_byte
*buf
,
10439 const struct comp_unit_head
*cu_header
,
10440 unsigned int *bytes_read
,
10441 unsigned int *offset_size
)
10443 LONGEST length
= read_initial_length (abfd
, buf
, bytes_read
);
10445 gdb_assert (cu_header
->initial_length_size
== 4
10446 || cu_header
->initial_length_size
== 8
10447 || cu_header
->initial_length_size
== 12);
10449 if (cu_header
->initial_length_size
!= *bytes_read
)
10450 complaint (&symfile_complaints
,
10451 _("intermixed 32-bit and 64-bit DWARF sections"));
10453 *offset_size
= (*bytes_read
== 4) ? 4 : 8;
10457 /* Read an offset from the data stream. The size of the offset is
10458 given by cu_header->offset_size. */
10461 read_offset (bfd
*abfd
, gdb_byte
*buf
, const struct comp_unit_head
*cu_header
,
10462 unsigned int *bytes_read
)
10464 LONGEST offset
= read_offset_1 (abfd
, buf
, cu_header
->offset_size
);
10466 *bytes_read
= cu_header
->offset_size
;
10470 /* Read an offset from the data stream. */
10473 read_offset_1 (bfd
*abfd
, gdb_byte
*buf
, unsigned int offset_size
)
10475 LONGEST retval
= 0;
10477 switch (offset_size
)
10480 retval
= bfd_get_32 (abfd
, buf
);
10483 retval
= bfd_get_64 (abfd
, buf
);
10486 internal_error (__FILE__
, __LINE__
,
10487 _("read_offset_1: bad switch [in module %s]"),
10488 bfd_get_filename (abfd
));
10495 read_n_bytes (bfd
*abfd
, gdb_byte
*buf
, unsigned int size
)
10497 /* If the size of a host char is 8 bits, we can return a pointer
10498 to the buffer, otherwise we have to copy the data to a buffer
10499 allocated on the temporary obstack. */
10500 gdb_assert (HOST_CHAR_BIT
== 8);
10505 read_direct_string (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
10507 /* If the size of a host char is 8 bits, we can return a pointer
10508 to the string, otherwise we have to copy the string to a buffer
10509 allocated on the temporary obstack. */
10510 gdb_assert (HOST_CHAR_BIT
== 8);
10513 *bytes_read_ptr
= 1;
10516 *bytes_read_ptr
= strlen ((char *) buf
) + 1;
10517 return (char *) buf
;
10521 read_indirect_string_at_offset (bfd
*abfd
, LONGEST str_offset
)
10523 dwarf2_read_section (dwarf2_per_objfile
->objfile
, &dwarf2_per_objfile
->str
);
10524 if (dwarf2_per_objfile
->str
.buffer
== NULL
)
10525 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
10526 bfd_get_filename (abfd
));
10527 if (str_offset
>= dwarf2_per_objfile
->str
.size
)
10528 error (_("DW_FORM_strp pointing outside of "
10529 ".debug_str section [in module %s]"),
10530 bfd_get_filename (abfd
));
10531 gdb_assert (HOST_CHAR_BIT
== 8);
10532 if (dwarf2_per_objfile
->str
.buffer
[str_offset
] == '\0')
10534 return (char *) (dwarf2_per_objfile
->str
.buffer
+ str_offset
);
10538 read_indirect_string (bfd
*abfd
, gdb_byte
*buf
,
10539 const struct comp_unit_head
*cu_header
,
10540 unsigned int *bytes_read_ptr
)
10542 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
, bytes_read_ptr
);
10544 return read_indirect_string_at_offset (abfd
, str_offset
);
10547 static unsigned long
10548 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
10550 unsigned long result
;
10551 unsigned int num_read
;
10553 unsigned char byte
;
10561 byte
= bfd_get_8 (abfd
, buf
);
10564 result
|= ((unsigned long)(byte
& 127) << shift
);
10565 if ((byte
& 128) == 0)
10571 *bytes_read_ptr
= num_read
;
10576 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
10579 int i
, shift
, num_read
;
10580 unsigned char byte
;
10588 byte
= bfd_get_8 (abfd
, buf
);
10591 result
|= ((long)(byte
& 127) << shift
);
10593 if ((byte
& 128) == 0)
10598 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
10599 result
|= -(((long)1) << shift
);
10600 *bytes_read_ptr
= num_read
;
10604 /* Return a pointer to just past the end of an LEB128 number in BUF. */
10607 skip_leb128 (bfd
*abfd
, gdb_byte
*buf
)
10613 byte
= bfd_get_8 (abfd
, buf
);
10615 if ((byte
& 128) == 0)
10621 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
10628 cu
->language
= language_c
;
10630 case DW_LANG_C_plus_plus
:
10631 cu
->language
= language_cplus
;
10634 cu
->language
= language_d
;
10636 case DW_LANG_Fortran77
:
10637 case DW_LANG_Fortran90
:
10638 case DW_LANG_Fortran95
:
10639 cu
->language
= language_fortran
;
10641 case DW_LANG_Mips_Assembler
:
10642 cu
->language
= language_asm
;
10645 cu
->language
= language_java
;
10647 case DW_LANG_Ada83
:
10648 case DW_LANG_Ada95
:
10649 cu
->language
= language_ada
;
10651 case DW_LANG_Modula2
:
10652 cu
->language
= language_m2
;
10654 case DW_LANG_Pascal83
:
10655 cu
->language
= language_pascal
;
10658 cu
->language
= language_objc
;
10660 case DW_LANG_Cobol74
:
10661 case DW_LANG_Cobol85
:
10663 cu
->language
= language_minimal
;
10666 cu
->language_defn
= language_def (cu
->language
);
10669 /* Return the named attribute or NULL if not there. */
10671 static struct attribute
*
10672 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
10675 struct attribute
*spec
= NULL
;
10677 for (i
= 0; i
< die
->num_attrs
; ++i
)
10679 if (die
->attrs
[i
].name
== name
)
10680 return &die
->attrs
[i
];
10681 if (die
->attrs
[i
].name
== DW_AT_specification
10682 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
10683 spec
= &die
->attrs
[i
];
10688 die
= follow_die_ref (die
, spec
, &cu
);
10689 return dwarf2_attr (die
, name
, cu
);
10695 /* Return the named attribute or NULL if not there,
10696 but do not follow DW_AT_specification, etc.
10697 This is for use in contexts where we're reading .debug_types dies.
10698 Following DW_AT_specification, DW_AT_abstract_origin will take us
10699 back up the chain, and we want to go down. */
10701 static struct attribute
*
10702 dwarf2_attr_no_follow (struct die_info
*die
, unsigned int name
,
10703 struct dwarf2_cu
*cu
)
10707 for (i
= 0; i
< die
->num_attrs
; ++i
)
10708 if (die
->attrs
[i
].name
== name
)
10709 return &die
->attrs
[i
];
10714 /* Return non-zero iff the attribute NAME is defined for the given DIE,
10715 and holds a non-zero value. This function should only be used for
10716 DW_FORM_flag or DW_FORM_flag_present attributes. */
10719 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
10721 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
10723 return (attr
&& DW_UNSND (attr
));
10727 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
10729 /* A DIE is a declaration if it has a DW_AT_declaration attribute
10730 which value is non-zero. However, we have to be careful with
10731 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
10732 (via dwarf2_flag_true_p) follows this attribute. So we may
10733 end up accidently finding a declaration attribute that belongs
10734 to a different DIE referenced by the specification attribute,
10735 even though the given DIE does not have a declaration attribute. */
10736 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
10737 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
10740 /* Return the die giving the specification for DIE, if there is
10741 one. *SPEC_CU is the CU containing DIE on input, and the CU
10742 containing the return value on output. If there is no
10743 specification, but there is an abstract origin, that is
10746 static struct die_info
*
10747 die_specification (struct die_info
*die
, struct dwarf2_cu
**spec_cu
)
10749 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
,
10752 if (spec_attr
== NULL
)
10753 spec_attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, *spec_cu
);
10755 if (spec_attr
== NULL
)
10758 return follow_die_ref (die
, spec_attr
, spec_cu
);
10761 /* Free the line_header structure *LH, and any arrays and strings it
10763 NOTE: This is also used as a "cleanup" function. */
10766 free_line_header (struct line_header
*lh
)
10768 if (lh
->standard_opcode_lengths
)
10769 xfree (lh
->standard_opcode_lengths
);
10771 /* Remember that all the lh->file_names[i].name pointers are
10772 pointers into debug_line_buffer, and don't need to be freed. */
10773 if (lh
->file_names
)
10774 xfree (lh
->file_names
);
10776 /* Similarly for the include directory names. */
10777 if (lh
->include_dirs
)
10778 xfree (lh
->include_dirs
);
10783 /* Add an entry to LH's include directory table. */
10786 add_include_dir (struct line_header
*lh
, char *include_dir
)
10788 /* Grow the array if necessary. */
10789 if (lh
->include_dirs_size
== 0)
10791 lh
->include_dirs_size
= 1; /* for testing */
10792 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
10793 * sizeof (*lh
->include_dirs
));
10795 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
10797 lh
->include_dirs_size
*= 2;
10798 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
10799 (lh
->include_dirs_size
10800 * sizeof (*lh
->include_dirs
)));
10803 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
10806 /* Add an entry to LH's file name table. */
10809 add_file_name (struct line_header
*lh
,
10811 unsigned int dir_index
,
10812 unsigned int mod_time
,
10813 unsigned int length
)
10815 struct file_entry
*fe
;
10817 /* Grow the array if necessary. */
10818 if (lh
->file_names_size
== 0)
10820 lh
->file_names_size
= 1; /* for testing */
10821 lh
->file_names
= xmalloc (lh
->file_names_size
10822 * sizeof (*lh
->file_names
));
10824 else if (lh
->num_file_names
>= lh
->file_names_size
)
10826 lh
->file_names_size
*= 2;
10827 lh
->file_names
= xrealloc (lh
->file_names
,
10828 (lh
->file_names_size
10829 * sizeof (*lh
->file_names
)));
10832 fe
= &lh
->file_names
[lh
->num_file_names
++];
10834 fe
->dir_index
= dir_index
;
10835 fe
->mod_time
= mod_time
;
10836 fe
->length
= length
;
10837 fe
->included_p
= 0;
10841 /* Read the statement program header starting at OFFSET in
10842 .debug_line, according to the endianness of ABFD. Return a pointer
10843 to a struct line_header, allocated using xmalloc.
10845 NOTE: the strings in the include directory and file name tables of
10846 the returned object point into debug_line_buffer, and must not be
10849 static struct line_header
*
10850 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
10851 struct dwarf2_cu
*cu
)
10853 struct cleanup
*back_to
;
10854 struct line_header
*lh
;
10855 gdb_byte
*line_ptr
;
10856 unsigned int bytes_read
, offset_size
;
10858 char *cur_dir
, *cur_file
;
10860 dwarf2_read_section (dwarf2_per_objfile
->objfile
, &dwarf2_per_objfile
->line
);
10861 if (dwarf2_per_objfile
->line
.buffer
== NULL
)
10863 complaint (&symfile_complaints
, _("missing .debug_line section"));
10867 /* Make sure that at least there's room for the total_length field.
10868 That could be 12 bytes long, but we're just going to fudge that. */
10869 if (offset
+ 4 >= dwarf2_per_objfile
->line
.size
)
10871 dwarf2_statement_list_fits_in_line_number_section_complaint ();
10875 lh
= xmalloc (sizeof (*lh
));
10876 memset (lh
, 0, sizeof (*lh
));
10877 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
10880 line_ptr
= dwarf2_per_objfile
->line
.buffer
+ offset
;
10882 /* Read in the header. */
10884 read_checked_initial_length_and_offset (abfd
, line_ptr
, &cu
->header
,
10885 &bytes_read
, &offset_size
);
10886 line_ptr
+= bytes_read
;
10887 if (line_ptr
+ lh
->total_length
> (dwarf2_per_objfile
->line
.buffer
10888 + dwarf2_per_objfile
->line
.size
))
10890 dwarf2_statement_list_fits_in_line_number_section_complaint ();
10893 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
10894 lh
->version
= read_2_bytes (abfd
, line_ptr
);
10896 lh
->header_length
= read_offset_1 (abfd
, line_ptr
, offset_size
);
10897 line_ptr
+= offset_size
;
10898 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
10900 if (lh
->version
>= 4)
10902 lh
->maximum_ops_per_instruction
= read_1_byte (abfd
, line_ptr
);
10906 lh
->maximum_ops_per_instruction
= 1;
10908 if (lh
->maximum_ops_per_instruction
== 0)
10910 lh
->maximum_ops_per_instruction
= 1;
10911 complaint (&symfile_complaints
,
10912 _("invalid maximum_ops_per_instruction "
10913 "in `.debug_line' section"));
10916 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
10918 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
10920 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
10922 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
10924 lh
->standard_opcode_lengths
10925 = xmalloc (lh
->opcode_base
* sizeof (lh
->standard_opcode_lengths
[0]));
10927 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
10928 for (i
= 1; i
< lh
->opcode_base
; ++i
)
10930 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
10934 /* Read directory table. */
10935 while ((cur_dir
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
10937 line_ptr
+= bytes_read
;
10938 add_include_dir (lh
, cur_dir
);
10940 line_ptr
+= bytes_read
;
10942 /* Read file name table. */
10943 while ((cur_file
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
10945 unsigned int dir_index
, mod_time
, length
;
10947 line_ptr
+= bytes_read
;
10948 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
10949 line_ptr
+= bytes_read
;
10950 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
10951 line_ptr
+= bytes_read
;
10952 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
10953 line_ptr
+= bytes_read
;
10955 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
10957 line_ptr
+= bytes_read
;
10958 lh
->statement_program_start
= line_ptr
;
10960 if (line_ptr
> (dwarf2_per_objfile
->line
.buffer
10961 + dwarf2_per_objfile
->line
.size
))
10962 complaint (&symfile_complaints
,
10963 _("line number info header doesn't "
10964 "fit in `.debug_line' section"));
10966 discard_cleanups (back_to
);
10970 /* Subroutine of dwarf_decode_lines to simplify it.
10971 Return the file name of the psymtab for included file FILE_INDEX
10972 in line header LH of PST.
10973 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
10974 If space for the result is malloc'd, it will be freed by a cleanup.
10975 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename. */
10978 psymtab_include_file_name (const struct line_header
*lh
, int file_index
,
10979 const struct partial_symtab
*pst
,
10980 const char *comp_dir
)
10982 const struct file_entry fe
= lh
->file_names
[file_index
];
10983 char *include_name
= fe
.name
;
10984 char *include_name_to_compare
= include_name
;
10985 char *dir_name
= NULL
;
10986 const char *pst_filename
;
10987 char *copied_name
= NULL
;
10991 dir_name
= lh
->include_dirs
[fe
.dir_index
- 1];
10993 if (!IS_ABSOLUTE_PATH (include_name
)
10994 && (dir_name
!= NULL
|| comp_dir
!= NULL
))
10996 /* Avoid creating a duplicate psymtab for PST.
10997 We do this by comparing INCLUDE_NAME and PST_FILENAME.
10998 Before we do the comparison, however, we need to account
10999 for DIR_NAME and COMP_DIR.
11000 First prepend dir_name (if non-NULL). If we still don't
11001 have an absolute path prepend comp_dir (if non-NULL).
11002 However, the directory we record in the include-file's
11003 psymtab does not contain COMP_DIR (to match the
11004 corresponding symtab(s)).
11009 bash$ gcc -g ./hello.c
11010 include_name = "hello.c"
11012 DW_AT_comp_dir = comp_dir = "/tmp"
11013 DW_AT_name = "./hello.c" */
11015 if (dir_name
!= NULL
)
11017 include_name
= concat (dir_name
, SLASH_STRING
,
11018 include_name
, (char *)NULL
);
11019 include_name_to_compare
= include_name
;
11020 make_cleanup (xfree
, include_name
);
11022 if (!IS_ABSOLUTE_PATH (include_name
) && comp_dir
!= NULL
)
11024 include_name_to_compare
= concat (comp_dir
, SLASH_STRING
,
11025 include_name
, (char *)NULL
);
11029 pst_filename
= pst
->filename
;
11030 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
11032 copied_name
= concat (pst
->dirname
, SLASH_STRING
,
11033 pst_filename
, (char *)NULL
);
11034 pst_filename
= copied_name
;
11037 file_is_pst
= FILENAME_CMP (include_name_to_compare
, pst_filename
) == 0;
11039 if (include_name_to_compare
!= include_name
)
11040 xfree (include_name_to_compare
);
11041 if (copied_name
!= NULL
)
11042 xfree (copied_name
);
11046 return include_name
;
11049 /* Ignore this record_line request. */
11052 noop_record_line (struct subfile
*subfile
, int line
, CORE_ADDR pc
)
11057 /* Subroutine of dwarf_decode_lines to simplify it.
11058 Process the line number information in LH. */
11061 dwarf_decode_lines_1 (struct line_header
*lh
, const char *comp_dir
,
11062 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
)
11064 gdb_byte
*line_ptr
, *extended_end
;
11065 gdb_byte
*line_end
;
11066 unsigned int bytes_read
, extended_len
;
11067 unsigned char op_code
, extended_op
, adj_opcode
;
11068 CORE_ADDR baseaddr
;
11069 struct objfile
*objfile
= cu
->objfile
;
11070 bfd
*abfd
= objfile
->obfd
;
11071 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
11072 const int decode_for_pst_p
= (pst
!= NULL
);
11073 struct subfile
*last_subfile
= NULL
;
11074 void (*p_record_line
) (struct subfile
*subfile
, int line
, CORE_ADDR pc
)
11077 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
11079 line_ptr
= lh
->statement_program_start
;
11080 line_end
= lh
->statement_program_end
;
11082 /* Read the statement sequences until there's nothing left. */
11083 while (line_ptr
< line_end
)
11085 /* state machine registers */
11086 CORE_ADDR address
= 0;
11087 unsigned int file
= 1;
11088 unsigned int line
= 1;
11089 unsigned int column
= 0;
11090 int is_stmt
= lh
->default_is_stmt
;
11091 int basic_block
= 0;
11092 int end_sequence
= 0;
11094 unsigned char op_index
= 0;
11096 if (!decode_for_pst_p
&& lh
->num_file_names
>= file
)
11098 /* Start a subfile for the current file of the state machine. */
11099 /* lh->include_dirs and lh->file_names are 0-based, but the
11100 directory and file name numbers in the statement program
11102 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
11106 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
11108 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
11111 /* Decode the table. */
11112 while (!end_sequence
)
11114 op_code
= read_1_byte (abfd
, line_ptr
);
11116 if (line_ptr
> line_end
)
11118 dwarf2_debug_line_missing_end_sequence_complaint ();
11122 if (op_code
>= lh
->opcode_base
)
11124 /* Special operand. */
11125 adj_opcode
= op_code
- lh
->opcode_base
;
11126 address
+= (((op_index
+ (adj_opcode
/ lh
->line_range
))
11127 / lh
->maximum_ops_per_instruction
)
11128 * lh
->minimum_instruction_length
);
11129 op_index
= ((op_index
+ (adj_opcode
/ lh
->line_range
))
11130 % lh
->maximum_ops_per_instruction
);
11131 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
11132 if (lh
->num_file_names
< file
|| file
== 0)
11133 dwarf2_debug_line_missing_file_complaint ();
11134 /* For now we ignore lines not starting on an
11135 instruction boundary. */
11136 else if (op_index
== 0)
11138 lh
->file_names
[file
- 1].included_p
= 1;
11139 if (!decode_for_pst_p
&& is_stmt
)
11141 if (last_subfile
!= current_subfile
)
11143 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
11145 (*p_record_line
) (last_subfile
, 0, addr
);
11146 last_subfile
= current_subfile
;
11148 /* Append row to matrix using current values. */
11149 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
11150 (*p_record_line
) (current_subfile
, line
, addr
);
11155 else switch (op_code
)
11157 case DW_LNS_extended_op
:
11158 extended_len
= read_unsigned_leb128 (abfd
, line_ptr
,
11160 line_ptr
+= bytes_read
;
11161 extended_end
= line_ptr
+ extended_len
;
11162 extended_op
= read_1_byte (abfd
, line_ptr
);
11164 switch (extended_op
)
11166 case DW_LNE_end_sequence
:
11167 p_record_line
= record_line
;
11170 case DW_LNE_set_address
:
11171 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
11173 if (address
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
11175 /* This line table is for a function which has been
11176 GCd by the linker. Ignore it. PR gdb/12528 */
11179 = line_ptr
- dwarf2_per_objfile
->line
.buffer
;
11181 complaint (&symfile_complaints
,
11182 _(".debug_line address at offset 0x%lx is 0 "
11184 line_offset
, objfile
->name
);
11185 p_record_line
= noop_record_line
;
11189 line_ptr
+= bytes_read
;
11190 address
+= baseaddr
;
11192 case DW_LNE_define_file
:
11195 unsigned int dir_index
, mod_time
, length
;
11197 cur_file
= read_direct_string (abfd
, line_ptr
,
11199 line_ptr
+= bytes_read
;
11201 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
11202 line_ptr
+= bytes_read
;
11204 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
11205 line_ptr
+= bytes_read
;
11207 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
11208 line_ptr
+= bytes_read
;
11209 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
11212 case DW_LNE_set_discriminator
:
11213 /* The discriminator is not interesting to the debugger;
11215 line_ptr
= extended_end
;
11218 complaint (&symfile_complaints
,
11219 _("mangled .debug_line section"));
11222 /* Make sure that we parsed the extended op correctly. If e.g.
11223 we expected a different address size than the producer used,
11224 we may have read the wrong number of bytes. */
11225 if (line_ptr
!= extended_end
)
11227 complaint (&symfile_complaints
,
11228 _("mangled .debug_line section"));
11233 if (lh
->num_file_names
< file
|| file
== 0)
11234 dwarf2_debug_line_missing_file_complaint ();
11237 lh
->file_names
[file
- 1].included_p
= 1;
11238 if (!decode_for_pst_p
&& is_stmt
)
11240 if (last_subfile
!= current_subfile
)
11242 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
11244 (*p_record_line
) (last_subfile
, 0, addr
);
11245 last_subfile
= current_subfile
;
11247 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
11248 (*p_record_line
) (current_subfile
, line
, addr
);
11253 case DW_LNS_advance_pc
:
11256 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
11258 address
+= (((op_index
+ adjust
)
11259 / lh
->maximum_ops_per_instruction
)
11260 * lh
->minimum_instruction_length
);
11261 op_index
= ((op_index
+ adjust
)
11262 % lh
->maximum_ops_per_instruction
);
11263 line_ptr
+= bytes_read
;
11266 case DW_LNS_advance_line
:
11267 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
11268 line_ptr
+= bytes_read
;
11270 case DW_LNS_set_file
:
11272 /* The arrays lh->include_dirs and lh->file_names are
11273 0-based, but the directory and file name numbers in
11274 the statement program are 1-based. */
11275 struct file_entry
*fe
;
11278 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
11279 line_ptr
+= bytes_read
;
11280 if (lh
->num_file_names
< file
|| file
== 0)
11281 dwarf2_debug_line_missing_file_complaint ();
11284 fe
= &lh
->file_names
[file
- 1];
11286 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
11287 if (!decode_for_pst_p
)
11289 last_subfile
= current_subfile
;
11290 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
11295 case DW_LNS_set_column
:
11296 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
11297 line_ptr
+= bytes_read
;
11299 case DW_LNS_negate_stmt
:
11300 is_stmt
= (!is_stmt
);
11302 case DW_LNS_set_basic_block
:
11305 /* Add to the address register of the state machine the
11306 address increment value corresponding to special opcode
11307 255. I.e., this value is scaled by the minimum
11308 instruction length since special opcode 255 would have
11309 scaled the increment. */
11310 case DW_LNS_const_add_pc
:
11312 CORE_ADDR adjust
= (255 - lh
->opcode_base
) / lh
->line_range
;
11314 address
+= (((op_index
+ adjust
)
11315 / lh
->maximum_ops_per_instruction
)
11316 * lh
->minimum_instruction_length
);
11317 op_index
= ((op_index
+ adjust
)
11318 % lh
->maximum_ops_per_instruction
);
11321 case DW_LNS_fixed_advance_pc
:
11322 address
+= read_2_bytes (abfd
, line_ptr
);
11328 /* Unknown standard opcode, ignore it. */
11331 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
11333 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
11334 line_ptr
+= bytes_read
;
11339 if (lh
->num_file_names
< file
|| file
== 0)
11340 dwarf2_debug_line_missing_file_complaint ();
11343 lh
->file_names
[file
- 1].included_p
= 1;
11344 if (!decode_for_pst_p
)
11346 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
11347 (*p_record_line
) (current_subfile
, 0, addr
);
11353 /* Decode the Line Number Program (LNP) for the given line_header
11354 structure and CU. The actual information extracted and the type
11355 of structures created from the LNP depends on the value of PST.
11357 1. If PST is NULL, then this procedure uses the data from the program
11358 to create all necessary symbol tables, and their linetables.
11360 2. If PST is not NULL, this procedure reads the program to determine
11361 the list of files included by the unit represented by PST, and
11362 builds all the associated partial symbol tables.
11364 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
11365 It is used for relative paths in the line table.
11366 NOTE: When processing partial symtabs (pst != NULL),
11367 comp_dir == pst->dirname.
11369 NOTE: It is important that psymtabs have the same file name (via strcmp)
11370 as the corresponding symtab. Since COMP_DIR is not used in the name of the
11371 symtab we don't use it in the name of the psymtabs we create.
11372 E.g. expand_line_sal requires this when finding psymtabs to expand.
11373 A good testcase for this is mb-inline.exp. */
11376 dwarf_decode_lines (struct line_header
*lh
, const char *comp_dir
,
11377 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
,
11378 int want_line_info
)
11380 struct objfile
*objfile
= cu
->objfile
;
11381 const int decode_for_pst_p
= (pst
!= NULL
);
11382 struct subfile
*first_subfile
= current_subfile
;
11384 if (want_line_info
)
11385 dwarf_decode_lines_1 (lh
, comp_dir
, cu
, pst
);
11387 if (decode_for_pst_p
)
11391 /* Now that we're done scanning the Line Header Program, we can
11392 create the psymtab of each included file. */
11393 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
11394 if (lh
->file_names
[file_index
].included_p
== 1)
11396 char *include_name
=
11397 psymtab_include_file_name (lh
, file_index
, pst
, comp_dir
);
11398 if (include_name
!= NULL
)
11399 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
11404 /* Make sure a symtab is created for every file, even files
11405 which contain only variables (i.e. no code with associated
11409 for (i
= 0; i
< lh
->num_file_names
; i
++)
11412 struct file_entry
*fe
;
11414 fe
= &lh
->file_names
[i
];
11416 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
11417 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
11419 /* Skip the main file; we don't need it, and it must be
11420 allocated last, so that it will show up before the
11421 non-primary symtabs in the objfile's symtab list. */
11422 if (current_subfile
== first_subfile
)
11425 if (current_subfile
->symtab
== NULL
)
11426 current_subfile
->symtab
= allocate_symtab (current_subfile
->name
,
11428 fe
->symtab
= current_subfile
->symtab
;
11433 /* Start a subfile for DWARF. FILENAME is the name of the file and
11434 DIRNAME the name of the source directory which contains FILENAME
11435 or NULL if not known. COMP_DIR is the compilation directory for the
11436 linetable's compilation unit or NULL if not known.
11437 This routine tries to keep line numbers from identical absolute and
11438 relative file names in a common subfile.
11440 Using the `list' example from the GDB testsuite, which resides in
11441 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
11442 of /srcdir/list0.c yields the following debugging information for list0.c:
11444 DW_AT_name: /srcdir/list0.c
11445 DW_AT_comp_dir: /compdir
11446 files.files[0].name: list0.h
11447 files.files[0].dir: /srcdir
11448 files.files[1].name: list0.c
11449 files.files[1].dir: /srcdir
11451 The line number information for list0.c has to end up in a single
11452 subfile, so that `break /srcdir/list0.c:1' works as expected.
11453 start_subfile will ensure that this happens provided that we pass the
11454 concatenation of files.files[1].dir and files.files[1].name as the
11458 dwarf2_start_subfile (char *filename
, const char *dirname
,
11459 const char *comp_dir
)
11463 /* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir).
11464 `start_symtab' will always pass the contents of DW_AT_comp_dir as
11465 second argument to start_subfile. To be consistent, we do the
11466 same here. In order not to lose the line information directory,
11467 we concatenate it to the filename when it makes sense.
11468 Note that the Dwarf3 standard says (speaking of filenames in line
11469 information): ``The directory index is ignored for file names
11470 that represent full path names''. Thus ignoring dirname in the
11471 `else' branch below isn't an issue. */
11473 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
11474 fullname
= concat (dirname
, SLASH_STRING
, filename
, (char *)NULL
);
11476 fullname
= filename
;
11478 start_subfile (fullname
, comp_dir
);
11480 if (fullname
!= filename
)
11485 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
11486 struct dwarf2_cu
*cu
)
11488 struct objfile
*objfile
= cu
->objfile
;
11489 struct comp_unit_head
*cu_header
= &cu
->header
;
11491 /* NOTE drow/2003-01-30: There used to be a comment and some special
11492 code here to turn a symbol with DW_AT_external and a
11493 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
11494 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
11495 with some versions of binutils) where shared libraries could have
11496 relocations against symbols in their debug information - the
11497 minimal symbol would have the right address, but the debug info
11498 would not. It's no longer necessary, because we will explicitly
11499 apply relocations when we read in the debug information now. */
11501 /* A DW_AT_location attribute with no contents indicates that a
11502 variable has been optimized away. */
11503 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
11505 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
11509 /* Handle one degenerate form of location expression specially, to
11510 preserve GDB's previous behavior when section offsets are
11511 specified. If this is just a DW_OP_addr then mark this symbol
11514 if (attr_form_is_block (attr
)
11515 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
11516 && DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
11518 unsigned int dummy
;
11520 SYMBOL_VALUE_ADDRESS (sym
) =
11521 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
11522 SYMBOL_CLASS (sym
) = LOC_STATIC
;
11523 fixup_symbol_section (sym
, objfile
);
11524 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
11525 SYMBOL_SECTION (sym
));
11529 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
11530 expression evaluator, and use LOC_COMPUTED only when necessary
11531 (i.e. when the value of a register or memory location is
11532 referenced, or a thread-local block, etc.). Then again, it might
11533 not be worthwhile. I'm assuming that it isn't unless performance
11534 or memory numbers show me otherwise. */
11536 dwarf2_symbol_mark_computed (attr
, sym
, cu
);
11537 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
11539 if (SYMBOL_COMPUTED_OPS (sym
) == &dwarf2_loclist_funcs
)
11540 cu
->has_loclist
= 1;
11543 /* Given a pointer to a DWARF information entry, figure out if we need
11544 to make a symbol table entry for it, and if so, create a new entry
11545 and return a pointer to it.
11546 If TYPE is NULL, determine symbol type from the die, otherwise
11547 used the passed type.
11548 If SPACE is not NULL, use it to hold the new symbol. If it is
11549 NULL, allocate a new symbol on the objfile's obstack. */
11551 static struct symbol
*
11552 new_symbol_full (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
,
11553 struct symbol
*space
)
11555 struct objfile
*objfile
= cu
->objfile
;
11556 struct symbol
*sym
= NULL
;
11558 struct attribute
*attr
= NULL
;
11559 struct attribute
*attr2
= NULL
;
11560 CORE_ADDR baseaddr
;
11561 struct pending
**list_to_add
= NULL
;
11563 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
11565 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
11567 name
= dwarf2_name (die
, cu
);
11570 const char *linkagename
;
11571 int suppress_add
= 0;
11576 sym
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct symbol
);
11577 OBJSTAT (objfile
, n_syms
++);
11579 /* Cache this symbol's name and the name's demangled form (if any). */
11580 SYMBOL_SET_LANGUAGE (sym
, cu
->language
);
11581 linkagename
= dwarf2_physname (name
, die
, cu
);
11582 SYMBOL_SET_NAMES (sym
, linkagename
, strlen (linkagename
), 0, objfile
);
11584 /* Fortran does not have mangling standard and the mangling does differ
11585 between gfortran, iFort etc. */
11586 if (cu
->language
== language_fortran
11587 && symbol_get_demangled_name (&(sym
->ginfo
)) == NULL
)
11588 symbol_set_demangled_name (&(sym
->ginfo
),
11589 (char *) dwarf2_full_name (name
, die
, cu
),
11592 /* Default assumptions.
11593 Use the passed type or decode it from the die. */
11594 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
11595 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
11597 SYMBOL_TYPE (sym
) = type
;
11599 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
11600 attr
= dwarf2_attr (die
,
11601 inlined_func
? DW_AT_call_line
: DW_AT_decl_line
,
11605 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
11608 attr
= dwarf2_attr (die
,
11609 inlined_func
? DW_AT_call_file
: DW_AT_decl_file
,
11613 int file_index
= DW_UNSND (attr
);
11615 if (cu
->line_header
== NULL
11616 || file_index
> cu
->line_header
->num_file_names
)
11617 complaint (&symfile_complaints
,
11618 _("file index out of range"));
11619 else if (file_index
> 0)
11621 struct file_entry
*fe
;
11623 fe
= &cu
->line_header
->file_names
[file_index
- 1];
11624 SYMBOL_SYMTAB (sym
) = fe
->symtab
;
11631 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
11634 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
11636 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_core_addr
;
11637 SYMBOL_DOMAIN (sym
) = LABEL_DOMAIN
;
11638 SYMBOL_CLASS (sym
) = LOC_LABEL
;
11639 add_symbol_to_list (sym
, cu
->list_in_scope
);
11641 case DW_TAG_subprogram
:
11642 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
11644 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
11645 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
11646 if ((attr2
&& (DW_UNSND (attr2
) != 0))
11647 || cu
->language
== language_ada
)
11649 /* Subprograms marked external are stored as a global symbol.
11650 Ada subprograms, whether marked external or not, are always
11651 stored as a global symbol, because we want to be able to
11652 access them globally. For instance, we want to be able
11653 to break on a nested subprogram without having to
11654 specify the context. */
11655 list_to_add
= &global_symbols
;
11659 list_to_add
= cu
->list_in_scope
;
11662 case DW_TAG_inlined_subroutine
:
11663 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
11665 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
11666 SYMBOL_INLINED (sym
) = 1;
11667 /* Do not add the symbol to any lists. It will be found via
11668 BLOCK_FUNCTION from the blockvector. */
11670 case DW_TAG_template_value_param
:
11672 /* Fall through. */
11673 case DW_TAG_constant
:
11674 case DW_TAG_variable
:
11675 case DW_TAG_member
:
11676 /* Compilation with minimal debug info may result in
11677 variables with missing type entries. Change the
11678 misleading `void' type to something sensible. */
11679 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
11681 = objfile_type (objfile
)->nodebug_data_symbol
;
11683 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
11684 /* In the case of DW_TAG_member, we should only be called for
11685 static const members. */
11686 if (die
->tag
== DW_TAG_member
)
11688 /* dwarf2_add_field uses die_is_declaration,
11689 so we do the same. */
11690 gdb_assert (die_is_declaration (die
, cu
));
11695 dwarf2_const_value (attr
, sym
, cu
);
11696 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
11699 if (attr2
&& (DW_UNSND (attr2
) != 0))
11700 list_to_add
= &global_symbols
;
11702 list_to_add
= cu
->list_in_scope
;
11706 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
11709 var_decode_location (attr
, sym
, cu
);
11710 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
11711 if (SYMBOL_CLASS (sym
) == LOC_STATIC
11712 && SYMBOL_VALUE_ADDRESS (sym
) == 0
11713 && !dwarf2_per_objfile
->has_section_at_zero
)
11715 /* When a static variable is eliminated by the linker,
11716 the corresponding debug information is not stripped
11717 out, but the variable address is set to null;
11718 do not add such variables into symbol table. */
11720 else if (attr2
&& (DW_UNSND (attr2
) != 0))
11722 /* Workaround gfortran PR debug/40040 - it uses
11723 DW_AT_location for variables in -fPIC libraries which may
11724 get overriden by other libraries/executable and get
11725 a different address. Resolve it by the minimal symbol
11726 which may come from inferior's executable using copy
11727 relocation. Make this workaround only for gfortran as for
11728 other compilers GDB cannot guess the minimal symbol
11729 Fortran mangling kind. */
11730 if (cu
->language
== language_fortran
&& die
->parent
11731 && die
->parent
->tag
== DW_TAG_module
11733 && strncmp (cu
->producer
, "GNU Fortran ", 12) == 0)
11734 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
11736 /* A variable with DW_AT_external is never static,
11737 but it may be block-scoped. */
11738 list_to_add
= (cu
->list_in_scope
== &file_symbols
11739 ? &global_symbols
: cu
->list_in_scope
);
11742 list_to_add
= cu
->list_in_scope
;
11746 /* We do not know the address of this symbol.
11747 If it is an external symbol and we have type information
11748 for it, enter the symbol as a LOC_UNRESOLVED symbol.
11749 The address of the variable will then be determined from
11750 the minimal symbol table whenever the variable is
11752 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
11753 if (attr2
&& (DW_UNSND (attr2
) != 0)
11754 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
11756 /* A variable with DW_AT_external is never static, but it
11757 may be block-scoped. */
11758 list_to_add
= (cu
->list_in_scope
== &file_symbols
11759 ? &global_symbols
: cu
->list_in_scope
);
11761 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
11763 else if (!die_is_declaration (die
, cu
))
11765 /* Use the default LOC_OPTIMIZED_OUT class. */
11766 gdb_assert (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
);
11768 list_to_add
= cu
->list_in_scope
;
11772 case DW_TAG_formal_parameter
:
11773 /* If we are inside a function, mark this as an argument. If
11774 not, we might be looking at an argument to an inlined function
11775 when we do not have enough information to show inlined frames;
11776 pretend it's a local variable in that case so that the user can
11778 if (context_stack_depth
> 0
11779 && context_stack
[context_stack_depth
- 1].name
!= NULL
)
11780 SYMBOL_IS_ARGUMENT (sym
) = 1;
11781 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
11784 var_decode_location (attr
, sym
, cu
);
11786 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
11789 dwarf2_const_value (attr
, sym
, cu
);
11792 list_to_add
= cu
->list_in_scope
;
11794 case DW_TAG_unspecified_parameters
:
11795 /* From varargs functions; gdb doesn't seem to have any
11796 interest in this information, so just ignore it for now.
11799 case DW_TAG_template_type_param
:
11801 /* Fall through. */
11802 case DW_TAG_class_type
:
11803 case DW_TAG_interface_type
:
11804 case DW_TAG_structure_type
:
11805 case DW_TAG_union_type
:
11806 case DW_TAG_set_type
:
11807 case DW_TAG_enumeration_type
:
11808 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
11809 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
11812 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
11813 really ever be static objects: otherwise, if you try
11814 to, say, break of a class's method and you're in a file
11815 which doesn't mention that class, it won't work unless
11816 the check for all static symbols in lookup_symbol_aux
11817 saves you. See the OtherFileClass tests in
11818 gdb.c++/namespace.exp. */
11822 list_to_add
= (cu
->list_in_scope
== &file_symbols
11823 && (cu
->language
== language_cplus
11824 || cu
->language
== language_java
)
11825 ? &global_symbols
: cu
->list_in_scope
);
11827 /* The semantics of C++ state that "struct foo {
11828 ... }" also defines a typedef for "foo". A Java
11829 class declaration also defines a typedef for the
11831 if (cu
->language
== language_cplus
11832 || cu
->language
== language_java
11833 || cu
->language
== language_ada
)
11835 /* The symbol's name is already allocated along
11836 with this objfile, so we don't need to
11837 duplicate it for the type. */
11838 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
11839 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
11844 case DW_TAG_typedef
:
11845 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
11846 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
11847 list_to_add
= cu
->list_in_scope
;
11849 case DW_TAG_base_type
:
11850 case DW_TAG_subrange_type
:
11851 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
11852 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
11853 list_to_add
= cu
->list_in_scope
;
11855 case DW_TAG_enumerator
:
11856 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
11859 dwarf2_const_value (attr
, sym
, cu
);
11862 /* NOTE: carlton/2003-11-10: See comment above in the
11863 DW_TAG_class_type, etc. block. */
11865 list_to_add
= (cu
->list_in_scope
== &file_symbols
11866 && (cu
->language
== language_cplus
11867 || cu
->language
== language_java
)
11868 ? &global_symbols
: cu
->list_in_scope
);
11871 case DW_TAG_namespace
:
11872 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
11873 list_to_add
= &global_symbols
;
11876 /* Not a tag we recognize. Hopefully we aren't processing
11877 trash data, but since we must specifically ignore things
11878 we don't recognize, there is nothing else we should do at
11880 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
11881 dwarf_tag_name (die
->tag
));
11887 sym
->hash_next
= objfile
->template_symbols
;
11888 objfile
->template_symbols
= sym
;
11889 list_to_add
= NULL
;
11892 if (list_to_add
!= NULL
)
11893 add_symbol_to_list (sym
, list_to_add
);
11895 /* For the benefit of old versions of GCC, check for anonymous
11896 namespaces based on the demangled name. */
11897 if (!processing_has_namespace_info
11898 && cu
->language
== language_cplus
)
11899 cp_scan_for_anonymous_namespaces (sym
, objfile
);
11904 /* A wrapper for new_symbol_full that always allocates a new symbol. */
11906 static struct symbol
*
11907 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
11909 return new_symbol_full (die
, type
, cu
, NULL
);
11912 /* Given an attr with a DW_FORM_dataN value in host byte order,
11913 zero-extend it as appropriate for the symbol's type. The DWARF
11914 standard (v4) is not entirely clear about the meaning of using
11915 DW_FORM_dataN for a constant with a signed type, where the type is
11916 wider than the data. The conclusion of a discussion on the DWARF
11917 list was that this is unspecified. We choose to always zero-extend
11918 because that is the interpretation long in use by GCC. */
11921 dwarf2_const_value_data (struct attribute
*attr
, struct type
*type
,
11922 const char *name
, struct obstack
*obstack
,
11923 struct dwarf2_cu
*cu
, long *value
, int bits
)
11925 struct objfile
*objfile
= cu
->objfile
;
11926 enum bfd_endian byte_order
= bfd_big_endian (objfile
->obfd
) ?
11927 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
11928 LONGEST l
= DW_UNSND (attr
);
11930 if (bits
< sizeof (*value
) * 8)
11932 l
&= ((LONGEST
) 1 << bits
) - 1;
11935 else if (bits
== sizeof (*value
) * 8)
11939 gdb_byte
*bytes
= obstack_alloc (obstack
, bits
/ 8);
11940 store_unsigned_integer (bytes
, bits
/ 8, byte_order
, l
);
11947 /* Read a constant value from an attribute. Either set *VALUE, or if
11948 the value does not fit in *VALUE, set *BYTES - either already
11949 allocated on the objfile obstack, or newly allocated on OBSTACK,
11950 or, set *BATON, if we translated the constant to a location
11954 dwarf2_const_value_attr (struct attribute
*attr
, struct type
*type
,
11955 const char *name
, struct obstack
*obstack
,
11956 struct dwarf2_cu
*cu
,
11957 long *value
, gdb_byte
**bytes
,
11958 struct dwarf2_locexpr_baton
**baton
)
11960 struct objfile
*objfile
= cu
->objfile
;
11961 struct comp_unit_head
*cu_header
= &cu
->header
;
11962 struct dwarf_block
*blk
;
11963 enum bfd_endian byte_order
= (bfd_big_endian (objfile
->obfd
) ?
11964 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
11970 switch (attr
->form
)
11976 if (TYPE_LENGTH (type
) != cu_header
->addr_size
)
11977 dwarf2_const_value_length_mismatch_complaint (name
,
11978 cu_header
->addr_size
,
11979 TYPE_LENGTH (type
));
11980 /* Symbols of this form are reasonably rare, so we just
11981 piggyback on the existing location code rather than writing
11982 a new implementation of symbol_computed_ops. */
11983 *baton
= obstack_alloc (&objfile
->objfile_obstack
,
11984 sizeof (struct dwarf2_locexpr_baton
));
11985 (*baton
)->per_cu
= cu
->per_cu
;
11986 gdb_assert ((*baton
)->per_cu
);
11988 (*baton
)->size
= 2 + cu_header
->addr_size
;
11989 data
= obstack_alloc (&objfile
->objfile_obstack
, (*baton
)->size
);
11990 (*baton
)->data
= data
;
11992 data
[0] = DW_OP_addr
;
11993 store_unsigned_integer (&data
[1], cu_header
->addr_size
,
11994 byte_order
, DW_ADDR (attr
));
11995 data
[cu_header
->addr_size
+ 1] = DW_OP_stack_value
;
11998 case DW_FORM_string
:
12000 /* DW_STRING is already allocated on the objfile obstack, point
12002 *bytes
= (gdb_byte
*) DW_STRING (attr
);
12004 case DW_FORM_block1
:
12005 case DW_FORM_block2
:
12006 case DW_FORM_block4
:
12007 case DW_FORM_block
:
12008 case DW_FORM_exprloc
:
12009 blk
= DW_BLOCK (attr
);
12010 if (TYPE_LENGTH (type
) != blk
->size
)
12011 dwarf2_const_value_length_mismatch_complaint (name
, blk
->size
,
12012 TYPE_LENGTH (type
));
12013 *bytes
= blk
->data
;
12016 /* The DW_AT_const_value attributes are supposed to carry the
12017 symbol's value "represented as it would be on the target
12018 architecture." By the time we get here, it's already been
12019 converted to host endianness, so we just need to sign- or
12020 zero-extend it as appropriate. */
12021 case DW_FORM_data1
:
12022 *bytes
= dwarf2_const_value_data (attr
, type
, name
,
12023 obstack
, cu
, value
, 8);
12025 case DW_FORM_data2
:
12026 *bytes
= dwarf2_const_value_data (attr
, type
, name
,
12027 obstack
, cu
, value
, 16);
12029 case DW_FORM_data4
:
12030 *bytes
= dwarf2_const_value_data (attr
, type
, name
,
12031 obstack
, cu
, value
, 32);
12033 case DW_FORM_data8
:
12034 *bytes
= dwarf2_const_value_data (attr
, type
, name
,
12035 obstack
, cu
, value
, 64);
12038 case DW_FORM_sdata
:
12039 *value
= DW_SND (attr
);
12042 case DW_FORM_udata
:
12043 *value
= DW_UNSND (attr
);
12047 complaint (&symfile_complaints
,
12048 _("unsupported const value attribute form: '%s'"),
12049 dwarf_form_name (attr
->form
));
12056 /* Copy constant value from an attribute to a symbol. */
12059 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
12060 struct dwarf2_cu
*cu
)
12062 struct objfile
*objfile
= cu
->objfile
;
12063 struct comp_unit_head
*cu_header
= &cu
->header
;
12066 struct dwarf2_locexpr_baton
*baton
;
12068 dwarf2_const_value_attr (attr
, SYMBOL_TYPE (sym
),
12069 SYMBOL_PRINT_NAME (sym
),
12070 &objfile
->objfile_obstack
, cu
,
12071 &value
, &bytes
, &baton
);
12075 SYMBOL_COMPUTED_OPS (sym
) = &dwarf2_locexpr_funcs
;
12076 SYMBOL_LOCATION_BATON (sym
) = baton
;
12077 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
12079 else if (bytes
!= NULL
)
12081 SYMBOL_VALUE_BYTES (sym
) = bytes
;
12082 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
12086 SYMBOL_VALUE (sym
) = value
;
12087 SYMBOL_CLASS (sym
) = LOC_CONST
;
12091 /* Return the type of the die in question using its DW_AT_type attribute. */
12093 static struct type
*
12094 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
12096 struct attribute
*type_attr
;
12098 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
12101 /* A missing DW_AT_type represents a void type. */
12102 return objfile_type (cu
->objfile
)->builtin_void
;
12105 return lookup_die_type (die
, type_attr
, cu
);
12108 /* True iff CU's producer generates GNAT Ada auxiliary information
12109 that allows to find parallel types through that information instead
12110 of having to do expensive parallel lookups by type name. */
12113 need_gnat_info (struct dwarf2_cu
*cu
)
12115 /* FIXME: brobecker/2010-10-12: As of now, only the AdaCore version
12116 of GNAT produces this auxiliary information, without any indication
12117 that it is produced. Part of enhancing the FSF version of GNAT
12118 to produce that information will be to put in place an indicator
12119 that we can use in order to determine whether the descriptive type
12120 info is available or not. One suggestion that has been made is
12121 to use a new attribute, attached to the CU die. For now, assume
12122 that the descriptive type info is not available. */
12126 /* Return the auxiliary type of the die in question using its
12127 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
12128 attribute is not present. */
12130 static struct type
*
12131 die_descriptive_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
12133 struct attribute
*type_attr
;
12135 type_attr
= dwarf2_attr (die
, DW_AT_GNAT_descriptive_type
, cu
);
12139 return lookup_die_type (die
, type_attr
, cu
);
12142 /* If DIE has a descriptive_type attribute, then set the TYPE's
12143 descriptive type accordingly. */
12146 set_descriptive_type (struct type
*type
, struct die_info
*die
,
12147 struct dwarf2_cu
*cu
)
12149 struct type
*descriptive_type
= die_descriptive_type (die
, cu
);
12151 if (descriptive_type
)
12153 ALLOCATE_GNAT_AUX_TYPE (type
);
12154 TYPE_DESCRIPTIVE_TYPE (type
) = descriptive_type
;
12158 /* Return the containing type of the die in question using its
12159 DW_AT_containing_type attribute. */
12161 static struct type
*
12162 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
12164 struct attribute
*type_attr
;
12166 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
12168 error (_("Dwarf Error: Problem turning containing type into gdb type "
12169 "[in module %s]"), cu
->objfile
->name
);
12171 return lookup_die_type (die
, type_attr
, cu
);
12174 /* Look up the type of DIE in CU using its type attribute ATTR.
12175 If there is no type substitute an error marker. */
12177 static struct type
*
12178 lookup_die_type (struct die_info
*die
, struct attribute
*attr
,
12179 struct dwarf2_cu
*cu
)
12181 struct objfile
*objfile
= cu
->objfile
;
12182 struct type
*this_type
;
12184 /* First see if we have it cached. */
12186 if (is_ref_attr (attr
))
12188 unsigned int offset
= dwarf2_get_ref_die_offset (attr
);
12190 this_type
= get_die_type_at_offset (offset
, cu
->per_cu
);
12192 else if (attr
->form
== DW_FORM_ref_sig8
)
12194 struct signatured_type
*sig_type
= DW_SIGNATURED_TYPE (attr
);
12195 struct dwarf2_cu
*sig_cu
;
12196 unsigned int offset
;
12198 /* sig_type will be NULL if the signatured type is missing from
12200 if (sig_type
== NULL
)
12201 error (_("Dwarf Error: Cannot find signatured DIE referenced from DIE "
12202 "at 0x%x [in module %s]"),
12203 die
->offset
, objfile
->name
);
12205 gdb_assert (sig_type
->per_cu
.debug_types_section
);
12206 offset
= sig_type
->per_cu
.offset
+ sig_type
->type_offset
;
12207 this_type
= get_die_type_at_offset (offset
, &sig_type
->per_cu
);
12211 dump_die_for_error (die
);
12212 error (_("Dwarf Error: Bad type attribute %s [in module %s]"),
12213 dwarf_attr_name (attr
->name
), objfile
->name
);
12216 /* If not cached we need to read it in. */
12218 if (this_type
== NULL
)
12220 struct die_info
*type_die
;
12221 struct dwarf2_cu
*type_cu
= cu
;
12223 type_die
= follow_die_ref_or_sig (die
, attr
, &type_cu
);
12224 /* If the type is cached, we should have found it above. */
12225 gdb_assert (get_die_type (type_die
, type_cu
) == NULL
);
12226 this_type
= read_type_die_1 (type_die
, type_cu
);
12229 /* If we still don't have a type use an error marker. */
12231 if (this_type
== NULL
)
12233 char *message
, *saved
;
12235 /* read_type_die already issued a complaint. */
12236 message
= xstrprintf (_("<unknown type in %s, CU 0x%x, DIE 0x%x>"),
12240 saved
= obstack_copy0 (&objfile
->objfile_obstack
,
12241 message
, strlen (message
));
12244 this_type
= init_type (TYPE_CODE_ERROR
, 0, 0, saved
, objfile
);
12250 /* Return the type in DIE, CU.
12251 Returns NULL for invalid types.
12253 This first does a lookup in the appropriate type_hash table,
12254 and only reads the die in if necessary.
12256 NOTE: This can be called when reading in partial or full symbols. */
12258 static struct type
*
12259 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
12261 struct type
*this_type
;
12263 this_type
= get_die_type (die
, cu
);
12267 return read_type_die_1 (die
, cu
);
12270 /* Read the type in DIE, CU.
12271 Returns NULL for invalid types. */
12273 static struct type
*
12274 read_type_die_1 (struct die_info
*die
, struct dwarf2_cu
*cu
)
12276 struct type
*this_type
= NULL
;
12280 case DW_TAG_class_type
:
12281 case DW_TAG_interface_type
:
12282 case DW_TAG_structure_type
:
12283 case DW_TAG_union_type
:
12284 this_type
= read_structure_type (die
, cu
);
12286 case DW_TAG_enumeration_type
:
12287 this_type
= read_enumeration_type (die
, cu
);
12289 case DW_TAG_subprogram
:
12290 case DW_TAG_subroutine_type
:
12291 case DW_TAG_inlined_subroutine
:
12292 this_type
= read_subroutine_type (die
, cu
);
12294 case DW_TAG_array_type
:
12295 this_type
= read_array_type (die
, cu
);
12297 case DW_TAG_set_type
:
12298 this_type
= read_set_type (die
, cu
);
12300 case DW_TAG_pointer_type
:
12301 this_type
= read_tag_pointer_type (die
, cu
);
12303 case DW_TAG_ptr_to_member_type
:
12304 this_type
= read_tag_ptr_to_member_type (die
, cu
);
12306 case DW_TAG_reference_type
:
12307 this_type
= read_tag_reference_type (die
, cu
);
12309 case DW_TAG_const_type
:
12310 this_type
= read_tag_const_type (die
, cu
);
12312 case DW_TAG_volatile_type
:
12313 this_type
= read_tag_volatile_type (die
, cu
);
12315 case DW_TAG_string_type
:
12316 this_type
= read_tag_string_type (die
, cu
);
12318 case DW_TAG_typedef
:
12319 this_type
= read_typedef (die
, cu
);
12321 case DW_TAG_subrange_type
:
12322 this_type
= read_subrange_type (die
, cu
);
12324 case DW_TAG_base_type
:
12325 this_type
= read_base_type (die
, cu
);
12327 case DW_TAG_unspecified_type
:
12328 this_type
= read_unspecified_type (die
, cu
);
12330 case DW_TAG_namespace
:
12331 this_type
= read_namespace_type (die
, cu
);
12333 case DW_TAG_module
:
12334 this_type
= read_module_type (die
, cu
);
12337 complaint (&symfile_complaints
,
12338 _("unexpected tag in read_type_die: '%s'"),
12339 dwarf_tag_name (die
->tag
));
12346 /* See if we can figure out if the class lives in a namespace. We do
12347 this by looking for a member function; its demangled name will
12348 contain namespace info, if there is any.
12349 Return the computed name or NULL.
12350 Space for the result is allocated on the objfile's obstack.
12351 This is the full-die version of guess_partial_die_structure_name.
12352 In this case we know DIE has no useful parent. */
12355 guess_full_die_structure_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
12357 struct die_info
*spec_die
;
12358 struct dwarf2_cu
*spec_cu
;
12359 struct die_info
*child
;
12362 spec_die
= die_specification (die
, &spec_cu
);
12363 if (spec_die
!= NULL
)
12369 for (child
= die
->child
;
12371 child
= child
->sibling
)
12373 if (child
->tag
== DW_TAG_subprogram
)
12375 struct attribute
*attr
;
12377 attr
= dwarf2_attr (child
, DW_AT_linkage_name
, cu
);
12379 attr
= dwarf2_attr (child
, DW_AT_MIPS_linkage_name
, cu
);
12383 = language_class_name_from_physname (cu
->language_defn
,
12387 if (actual_name
!= NULL
)
12389 char *die_name
= dwarf2_name (die
, cu
);
12391 if (die_name
!= NULL
12392 && strcmp (die_name
, actual_name
) != 0)
12394 /* Strip off the class name from the full name.
12395 We want the prefix. */
12396 int die_name_len
= strlen (die_name
);
12397 int actual_name_len
= strlen (actual_name
);
12399 /* Test for '::' as a sanity check. */
12400 if (actual_name_len
> die_name_len
+ 2
12401 && actual_name
[actual_name_len
12402 - die_name_len
- 1] == ':')
12404 obsavestring (actual_name
,
12405 actual_name_len
- die_name_len
- 2,
12406 &cu
->objfile
->objfile_obstack
);
12409 xfree (actual_name
);
12418 /* GCC might emit a nameless typedef that has a linkage name. Determine the
12419 prefix part in such case. See
12420 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
12423 anonymous_struct_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
12425 struct attribute
*attr
;
12428 if (die
->tag
!= DW_TAG_class_type
&& die
->tag
!= DW_TAG_interface_type
12429 && die
->tag
!= DW_TAG_structure_type
&& die
->tag
!= DW_TAG_union_type
)
12432 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
12433 if (attr
!= NULL
&& DW_STRING (attr
) != NULL
)
12436 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
12438 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
12439 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
12442 /* dwarf2_name had to be already called. */
12443 gdb_assert (DW_STRING_IS_CANONICAL (attr
));
12445 /* Strip the base name, keep any leading namespaces/classes. */
12446 base
= strrchr (DW_STRING (attr
), ':');
12447 if (base
== NULL
|| base
== DW_STRING (attr
) || base
[-1] != ':')
12450 return obsavestring (DW_STRING (attr
), &base
[-1] - DW_STRING (attr
),
12451 &cu
->objfile
->objfile_obstack
);
12454 /* Return the name of the namespace/class that DIE is defined within,
12455 or "" if we can't tell. The caller should not xfree the result.
12457 For example, if we're within the method foo() in the following
12467 then determine_prefix on foo's die will return "N::C". */
12470 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
12472 struct die_info
*parent
, *spec_die
;
12473 struct dwarf2_cu
*spec_cu
;
12474 struct type
*parent_type
;
12477 if (cu
->language
!= language_cplus
&& cu
->language
!= language_java
12478 && cu
->language
!= language_fortran
)
12481 retval
= anonymous_struct_prefix (die
, cu
);
12485 /* We have to be careful in the presence of DW_AT_specification.
12486 For example, with GCC 3.4, given the code
12490 // Definition of N::foo.
12494 then we'll have a tree of DIEs like this:
12496 1: DW_TAG_compile_unit
12497 2: DW_TAG_namespace // N
12498 3: DW_TAG_subprogram // declaration of N::foo
12499 4: DW_TAG_subprogram // definition of N::foo
12500 DW_AT_specification // refers to die #3
12502 Thus, when processing die #4, we have to pretend that we're in
12503 the context of its DW_AT_specification, namely the contex of die
12506 spec_die
= die_specification (die
, &spec_cu
);
12507 if (spec_die
== NULL
)
12508 parent
= die
->parent
;
12511 parent
= spec_die
->parent
;
12515 if (parent
== NULL
)
12517 else if (parent
->building_fullname
)
12520 const char *parent_name
;
12522 /* It has been seen on RealView 2.2 built binaries,
12523 DW_TAG_template_type_param types actually _defined_ as
12524 children of the parent class:
12527 template class <class Enum> Class{};
12528 Class<enum E> class_e;
12530 1: DW_TAG_class_type (Class)
12531 2: DW_TAG_enumeration_type (E)
12532 3: DW_TAG_enumerator (enum1:0)
12533 3: DW_TAG_enumerator (enum2:1)
12535 2: DW_TAG_template_type_param
12536 DW_AT_type DW_FORM_ref_udata (E)
12538 Besides being broken debug info, it can put GDB into an
12539 infinite loop. Consider:
12541 When we're building the full name for Class<E>, we'll start
12542 at Class, and go look over its template type parameters,
12543 finding E. We'll then try to build the full name of E, and
12544 reach here. We're now trying to build the full name of E,
12545 and look over the parent DIE for containing scope. In the
12546 broken case, if we followed the parent DIE of E, we'd again
12547 find Class, and once again go look at its template type
12548 arguments, etc., etc. Simply don't consider such parent die
12549 as source-level parent of this die (it can't be, the language
12550 doesn't allow it), and break the loop here. */
12551 name
= dwarf2_name (die
, cu
);
12552 parent_name
= dwarf2_name (parent
, cu
);
12553 complaint (&symfile_complaints
,
12554 _("template param type '%s' defined within parent '%s'"),
12555 name
? name
: "<unknown>",
12556 parent_name
? parent_name
: "<unknown>");
12560 switch (parent
->tag
)
12562 case DW_TAG_namespace
:
12563 parent_type
= read_type_die (parent
, cu
);
12564 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
12565 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
12566 Work around this problem here. */
12567 if (cu
->language
== language_cplus
12568 && strcmp (TYPE_TAG_NAME (parent_type
), "::") == 0)
12570 /* We give a name to even anonymous namespaces. */
12571 return TYPE_TAG_NAME (parent_type
);
12572 case DW_TAG_class_type
:
12573 case DW_TAG_interface_type
:
12574 case DW_TAG_structure_type
:
12575 case DW_TAG_union_type
:
12576 case DW_TAG_module
:
12577 parent_type
= read_type_die (parent
, cu
);
12578 if (TYPE_TAG_NAME (parent_type
) != NULL
)
12579 return TYPE_TAG_NAME (parent_type
);
12581 /* An anonymous structure is only allowed non-static data
12582 members; no typedefs, no member functions, et cetera.
12583 So it does not need a prefix. */
12585 case DW_TAG_compile_unit
:
12586 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
12587 if (cu
->language
== language_cplus
12588 && !VEC_empty (dwarf2_section_info_def
, dwarf2_per_objfile
->types
)
12589 && die
->child
!= NULL
12590 && (die
->tag
== DW_TAG_class_type
12591 || die
->tag
== DW_TAG_structure_type
12592 || die
->tag
== DW_TAG_union_type
))
12594 char *name
= guess_full_die_structure_name (die
, cu
);
12600 return determine_prefix (parent
, cu
);
12604 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
12605 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
12606 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
12607 an obconcat, otherwise allocate storage for the result. The CU argument is
12608 used to determine the language and hence, the appropriate separator. */
12610 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
12613 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
12614 int physname
, struct dwarf2_cu
*cu
)
12616 const char *lead
= "";
12619 if (suffix
== NULL
|| suffix
[0] == '\0'
12620 || prefix
== NULL
|| prefix
[0] == '\0')
12622 else if (cu
->language
== language_java
)
12624 else if (cu
->language
== language_fortran
&& physname
)
12626 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
12627 DW_AT_MIPS_linkage_name is preferred and used instead. */
12635 if (prefix
== NULL
)
12637 if (suffix
== NULL
)
12643 = xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1);
12645 strcpy (retval
, lead
);
12646 strcat (retval
, prefix
);
12647 strcat (retval
, sep
);
12648 strcat (retval
, suffix
);
12653 /* We have an obstack. */
12654 return obconcat (obs
, lead
, prefix
, sep
, suffix
, (char *) NULL
);
12658 /* Return sibling of die, NULL if no sibling. */
12660 static struct die_info
*
12661 sibling_die (struct die_info
*die
)
12663 return die
->sibling
;
12666 /* Get name of a die, return NULL if not found. */
12669 dwarf2_canonicalize_name (char *name
, struct dwarf2_cu
*cu
,
12670 struct obstack
*obstack
)
12672 if (name
&& cu
->language
== language_cplus
)
12674 char *canon_name
= cp_canonicalize_string (name
);
12676 if (canon_name
!= NULL
)
12678 if (strcmp (canon_name
, name
) != 0)
12679 name
= obsavestring (canon_name
, strlen (canon_name
),
12681 xfree (canon_name
);
12688 /* Get name of a die, return NULL if not found. */
12691 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
12693 struct attribute
*attr
;
12695 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
12696 if ((!attr
|| !DW_STRING (attr
))
12697 && die
->tag
!= DW_TAG_class_type
12698 && die
->tag
!= DW_TAG_interface_type
12699 && die
->tag
!= DW_TAG_structure_type
12700 && die
->tag
!= DW_TAG_union_type
)
12705 case DW_TAG_compile_unit
:
12706 /* Compilation units have a DW_AT_name that is a filename, not
12707 a source language identifier. */
12708 case DW_TAG_enumeration_type
:
12709 case DW_TAG_enumerator
:
12710 /* These tags always have simple identifiers already; no need
12711 to canonicalize them. */
12712 return DW_STRING (attr
);
12714 case DW_TAG_subprogram
:
12715 /* Java constructors will all be named "<init>", so return
12716 the class name when we see this special case. */
12717 if (cu
->language
== language_java
12718 && DW_STRING (attr
) != NULL
12719 && strcmp (DW_STRING (attr
), "<init>") == 0)
12721 struct dwarf2_cu
*spec_cu
= cu
;
12722 struct die_info
*spec_die
;
12724 /* GCJ will output '<init>' for Java constructor names.
12725 For this special case, return the name of the parent class. */
12727 /* GCJ may output suprogram DIEs with AT_specification set.
12728 If so, use the name of the specified DIE. */
12729 spec_die
= die_specification (die
, &spec_cu
);
12730 if (spec_die
!= NULL
)
12731 return dwarf2_name (spec_die
, spec_cu
);
12736 if (die
->tag
== DW_TAG_class_type
)
12737 return dwarf2_name (die
, cu
);
12739 while (die
->tag
!= DW_TAG_compile_unit
);
12743 case DW_TAG_class_type
:
12744 case DW_TAG_interface_type
:
12745 case DW_TAG_structure_type
:
12746 case DW_TAG_union_type
:
12747 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
12748 structures or unions. These were of the form "._%d" in GCC 4.1,
12749 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
12750 and GCC 4.4. We work around this problem by ignoring these. */
12751 if (attr
&& DW_STRING (attr
)
12752 && (strncmp (DW_STRING (attr
), "._", 2) == 0
12753 || strncmp (DW_STRING (attr
), "<anonymous", 10) == 0))
12756 /* GCC might emit a nameless typedef that has a linkage name. See
12757 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
12758 if (!attr
|| DW_STRING (attr
) == NULL
)
12760 char *demangled
= NULL
;
12762 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
12764 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
12766 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
12769 /* Avoid demangling DW_STRING (attr) the second time on a second
12770 call for the same DIE. */
12771 if (!DW_STRING_IS_CANONICAL (attr
))
12772 demangled
= cplus_demangle (DW_STRING (attr
), DMGL_TYPES
);
12778 /* FIXME: we already did this for the partial symbol... */
12779 DW_STRING (attr
) = obsavestring (demangled
, strlen (demangled
),
12780 &cu
->objfile
->objfile_obstack
);
12781 DW_STRING_IS_CANONICAL (attr
) = 1;
12784 /* Strip any leading namespaces/classes, keep only the base name.
12785 DW_AT_name for named DIEs does not contain the prefixes. */
12786 base
= strrchr (DW_STRING (attr
), ':');
12787 if (base
&& base
> DW_STRING (attr
) && base
[-1] == ':')
12790 return DW_STRING (attr
);
12799 if (!DW_STRING_IS_CANONICAL (attr
))
12802 = dwarf2_canonicalize_name (DW_STRING (attr
), cu
,
12803 &cu
->objfile
->objfile_obstack
);
12804 DW_STRING_IS_CANONICAL (attr
) = 1;
12806 return DW_STRING (attr
);
12809 /* Return the die that this die in an extension of, or NULL if there
12810 is none. *EXT_CU is the CU containing DIE on input, and the CU
12811 containing the return value on output. */
12813 static struct die_info
*
12814 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
**ext_cu
)
12816 struct attribute
*attr
;
12818 attr
= dwarf2_attr (die
, DW_AT_extension
, *ext_cu
);
12822 return follow_die_ref (die
, attr
, ext_cu
);
12825 /* Convert a DIE tag into its string name. */
12828 dwarf_tag_name (unsigned tag
)
12832 case DW_TAG_padding
:
12833 return "DW_TAG_padding";
12834 case DW_TAG_array_type
:
12835 return "DW_TAG_array_type";
12836 case DW_TAG_class_type
:
12837 return "DW_TAG_class_type";
12838 case DW_TAG_entry_point
:
12839 return "DW_TAG_entry_point";
12840 case DW_TAG_enumeration_type
:
12841 return "DW_TAG_enumeration_type";
12842 case DW_TAG_formal_parameter
:
12843 return "DW_TAG_formal_parameter";
12844 case DW_TAG_imported_declaration
:
12845 return "DW_TAG_imported_declaration";
12847 return "DW_TAG_label";
12848 case DW_TAG_lexical_block
:
12849 return "DW_TAG_lexical_block";
12850 case DW_TAG_member
:
12851 return "DW_TAG_member";
12852 case DW_TAG_pointer_type
:
12853 return "DW_TAG_pointer_type";
12854 case DW_TAG_reference_type
:
12855 return "DW_TAG_reference_type";
12856 case DW_TAG_compile_unit
:
12857 return "DW_TAG_compile_unit";
12858 case DW_TAG_string_type
:
12859 return "DW_TAG_string_type";
12860 case DW_TAG_structure_type
:
12861 return "DW_TAG_structure_type";
12862 case DW_TAG_subroutine_type
:
12863 return "DW_TAG_subroutine_type";
12864 case DW_TAG_typedef
:
12865 return "DW_TAG_typedef";
12866 case DW_TAG_union_type
:
12867 return "DW_TAG_union_type";
12868 case DW_TAG_unspecified_parameters
:
12869 return "DW_TAG_unspecified_parameters";
12870 case DW_TAG_variant
:
12871 return "DW_TAG_variant";
12872 case DW_TAG_common_block
:
12873 return "DW_TAG_common_block";
12874 case DW_TAG_common_inclusion
:
12875 return "DW_TAG_common_inclusion";
12876 case DW_TAG_inheritance
:
12877 return "DW_TAG_inheritance";
12878 case DW_TAG_inlined_subroutine
:
12879 return "DW_TAG_inlined_subroutine";
12880 case DW_TAG_module
:
12881 return "DW_TAG_module";
12882 case DW_TAG_ptr_to_member_type
:
12883 return "DW_TAG_ptr_to_member_type";
12884 case DW_TAG_set_type
:
12885 return "DW_TAG_set_type";
12886 case DW_TAG_subrange_type
:
12887 return "DW_TAG_subrange_type";
12888 case DW_TAG_with_stmt
:
12889 return "DW_TAG_with_stmt";
12890 case DW_TAG_access_declaration
:
12891 return "DW_TAG_access_declaration";
12892 case DW_TAG_base_type
:
12893 return "DW_TAG_base_type";
12894 case DW_TAG_catch_block
:
12895 return "DW_TAG_catch_block";
12896 case DW_TAG_const_type
:
12897 return "DW_TAG_const_type";
12898 case DW_TAG_constant
:
12899 return "DW_TAG_constant";
12900 case DW_TAG_enumerator
:
12901 return "DW_TAG_enumerator";
12902 case DW_TAG_file_type
:
12903 return "DW_TAG_file_type";
12904 case DW_TAG_friend
:
12905 return "DW_TAG_friend";
12906 case DW_TAG_namelist
:
12907 return "DW_TAG_namelist";
12908 case DW_TAG_namelist_item
:
12909 return "DW_TAG_namelist_item";
12910 case DW_TAG_packed_type
:
12911 return "DW_TAG_packed_type";
12912 case DW_TAG_subprogram
:
12913 return "DW_TAG_subprogram";
12914 case DW_TAG_template_type_param
:
12915 return "DW_TAG_template_type_param";
12916 case DW_TAG_template_value_param
:
12917 return "DW_TAG_template_value_param";
12918 case DW_TAG_thrown_type
:
12919 return "DW_TAG_thrown_type";
12920 case DW_TAG_try_block
:
12921 return "DW_TAG_try_block";
12922 case DW_TAG_variant_part
:
12923 return "DW_TAG_variant_part";
12924 case DW_TAG_variable
:
12925 return "DW_TAG_variable";
12926 case DW_TAG_volatile_type
:
12927 return "DW_TAG_volatile_type";
12928 case DW_TAG_dwarf_procedure
:
12929 return "DW_TAG_dwarf_procedure";
12930 case DW_TAG_restrict_type
:
12931 return "DW_TAG_restrict_type";
12932 case DW_TAG_interface_type
:
12933 return "DW_TAG_interface_type";
12934 case DW_TAG_namespace
:
12935 return "DW_TAG_namespace";
12936 case DW_TAG_imported_module
:
12937 return "DW_TAG_imported_module";
12938 case DW_TAG_unspecified_type
:
12939 return "DW_TAG_unspecified_type";
12940 case DW_TAG_partial_unit
:
12941 return "DW_TAG_partial_unit";
12942 case DW_TAG_imported_unit
:
12943 return "DW_TAG_imported_unit";
12944 case DW_TAG_condition
:
12945 return "DW_TAG_condition";
12946 case DW_TAG_shared_type
:
12947 return "DW_TAG_shared_type";
12948 case DW_TAG_type_unit
:
12949 return "DW_TAG_type_unit";
12950 case DW_TAG_MIPS_loop
:
12951 return "DW_TAG_MIPS_loop";
12952 case DW_TAG_HP_array_descriptor
:
12953 return "DW_TAG_HP_array_descriptor";
12954 case DW_TAG_format_label
:
12955 return "DW_TAG_format_label";
12956 case DW_TAG_function_template
:
12957 return "DW_TAG_function_template";
12958 case DW_TAG_class_template
:
12959 return "DW_TAG_class_template";
12960 case DW_TAG_GNU_BINCL
:
12961 return "DW_TAG_GNU_BINCL";
12962 case DW_TAG_GNU_EINCL
:
12963 return "DW_TAG_GNU_EINCL";
12964 case DW_TAG_upc_shared_type
:
12965 return "DW_TAG_upc_shared_type";
12966 case DW_TAG_upc_strict_type
:
12967 return "DW_TAG_upc_strict_type";
12968 case DW_TAG_upc_relaxed_type
:
12969 return "DW_TAG_upc_relaxed_type";
12970 case DW_TAG_PGI_kanji_type
:
12971 return "DW_TAG_PGI_kanji_type";
12972 case DW_TAG_PGI_interface_block
:
12973 return "DW_TAG_PGI_interface_block";
12974 case DW_TAG_GNU_call_site
:
12975 return "DW_TAG_GNU_call_site";
12977 return "DW_TAG_<unknown>";
12981 /* Convert a DWARF attribute code into its string name. */
12984 dwarf_attr_name (unsigned attr
)
12988 case DW_AT_sibling
:
12989 return "DW_AT_sibling";
12990 case DW_AT_location
:
12991 return "DW_AT_location";
12993 return "DW_AT_name";
12994 case DW_AT_ordering
:
12995 return "DW_AT_ordering";
12996 case DW_AT_subscr_data
:
12997 return "DW_AT_subscr_data";
12998 case DW_AT_byte_size
:
12999 return "DW_AT_byte_size";
13000 case DW_AT_bit_offset
:
13001 return "DW_AT_bit_offset";
13002 case DW_AT_bit_size
:
13003 return "DW_AT_bit_size";
13004 case DW_AT_element_list
:
13005 return "DW_AT_element_list";
13006 case DW_AT_stmt_list
:
13007 return "DW_AT_stmt_list";
13009 return "DW_AT_low_pc";
13010 case DW_AT_high_pc
:
13011 return "DW_AT_high_pc";
13012 case DW_AT_language
:
13013 return "DW_AT_language";
13015 return "DW_AT_member";
13017 return "DW_AT_discr";
13018 case DW_AT_discr_value
:
13019 return "DW_AT_discr_value";
13020 case DW_AT_visibility
:
13021 return "DW_AT_visibility";
13023 return "DW_AT_import";
13024 case DW_AT_string_length
:
13025 return "DW_AT_string_length";
13026 case DW_AT_common_reference
:
13027 return "DW_AT_common_reference";
13028 case DW_AT_comp_dir
:
13029 return "DW_AT_comp_dir";
13030 case DW_AT_const_value
:
13031 return "DW_AT_const_value";
13032 case DW_AT_containing_type
:
13033 return "DW_AT_containing_type";
13034 case DW_AT_default_value
:
13035 return "DW_AT_default_value";
13037 return "DW_AT_inline";
13038 case DW_AT_is_optional
:
13039 return "DW_AT_is_optional";
13040 case DW_AT_lower_bound
:
13041 return "DW_AT_lower_bound";
13042 case DW_AT_producer
:
13043 return "DW_AT_producer";
13044 case DW_AT_prototyped
:
13045 return "DW_AT_prototyped";
13046 case DW_AT_return_addr
:
13047 return "DW_AT_return_addr";
13048 case DW_AT_start_scope
:
13049 return "DW_AT_start_scope";
13050 case DW_AT_bit_stride
:
13051 return "DW_AT_bit_stride";
13052 case DW_AT_upper_bound
:
13053 return "DW_AT_upper_bound";
13054 case DW_AT_abstract_origin
:
13055 return "DW_AT_abstract_origin";
13056 case DW_AT_accessibility
:
13057 return "DW_AT_accessibility";
13058 case DW_AT_address_class
:
13059 return "DW_AT_address_class";
13060 case DW_AT_artificial
:
13061 return "DW_AT_artificial";
13062 case DW_AT_base_types
:
13063 return "DW_AT_base_types";
13064 case DW_AT_calling_convention
:
13065 return "DW_AT_calling_convention";
13067 return "DW_AT_count";
13068 case DW_AT_data_member_location
:
13069 return "DW_AT_data_member_location";
13070 case DW_AT_decl_column
:
13071 return "DW_AT_decl_column";
13072 case DW_AT_decl_file
:
13073 return "DW_AT_decl_file";
13074 case DW_AT_decl_line
:
13075 return "DW_AT_decl_line";
13076 case DW_AT_declaration
:
13077 return "DW_AT_declaration";
13078 case DW_AT_discr_list
:
13079 return "DW_AT_discr_list";
13080 case DW_AT_encoding
:
13081 return "DW_AT_encoding";
13082 case DW_AT_external
:
13083 return "DW_AT_external";
13084 case DW_AT_frame_base
:
13085 return "DW_AT_frame_base";
13087 return "DW_AT_friend";
13088 case DW_AT_identifier_case
:
13089 return "DW_AT_identifier_case";
13090 case DW_AT_macro_info
:
13091 return "DW_AT_macro_info";
13092 case DW_AT_namelist_items
:
13093 return "DW_AT_namelist_items";
13094 case DW_AT_priority
:
13095 return "DW_AT_priority";
13096 case DW_AT_segment
:
13097 return "DW_AT_segment";
13098 case DW_AT_specification
:
13099 return "DW_AT_specification";
13100 case DW_AT_static_link
:
13101 return "DW_AT_static_link";
13103 return "DW_AT_type";
13104 case DW_AT_use_location
:
13105 return "DW_AT_use_location";
13106 case DW_AT_variable_parameter
:
13107 return "DW_AT_variable_parameter";
13108 case DW_AT_virtuality
:
13109 return "DW_AT_virtuality";
13110 case DW_AT_vtable_elem_location
:
13111 return "DW_AT_vtable_elem_location";
13112 /* DWARF 3 values. */
13113 case DW_AT_allocated
:
13114 return "DW_AT_allocated";
13115 case DW_AT_associated
:
13116 return "DW_AT_associated";
13117 case DW_AT_data_location
:
13118 return "DW_AT_data_location";
13119 case DW_AT_byte_stride
:
13120 return "DW_AT_byte_stride";
13121 case DW_AT_entry_pc
:
13122 return "DW_AT_entry_pc";
13123 case DW_AT_use_UTF8
:
13124 return "DW_AT_use_UTF8";
13125 case DW_AT_extension
:
13126 return "DW_AT_extension";
13128 return "DW_AT_ranges";
13129 case DW_AT_trampoline
:
13130 return "DW_AT_trampoline";
13131 case DW_AT_call_column
:
13132 return "DW_AT_call_column";
13133 case DW_AT_call_file
:
13134 return "DW_AT_call_file";
13135 case DW_AT_call_line
:
13136 return "DW_AT_call_line";
13137 case DW_AT_description
:
13138 return "DW_AT_description";
13139 case DW_AT_binary_scale
:
13140 return "DW_AT_binary_scale";
13141 case DW_AT_decimal_scale
:
13142 return "DW_AT_decimal_scale";
13144 return "DW_AT_small";
13145 case DW_AT_decimal_sign
:
13146 return "DW_AT_decimal_sign";
13147 case DW_AT_digit_count
:
13148 return "DW_AT_digit_count";
13149 case DW_AT_picture_string
:
13150 return "DW_AT_picture_string";
13151 case DW_AT_mutable
:
13152 return "DW_AT_mutable";
13153 case DW_AT_threads_scaled
:
13154 return "DW_AT_threads_scaled";
13155 case DW_AT_explicit
:
13156 return "DW_AT_explicit";
13157 case DW_AT_object_pointer
:
13158 return "DW_AT_object_pointer";
13159 case DW_AT_endianity
:
13160 return "DW_AT_endianity";
13161 case DW_AT_elemental
:
13162 return "DW_AT_elemental";
13164 return "DW_AT_pure";
13165 case DW_AT_recursive
:
13166 return "DW_AT_recursive";
13167 /* DWARF 4 values. */
13168 case DW_AT_signature
:
13169 return "DW_AT_signature";
13170 case DW_AT_linkage_name
:
13171 return "DW_AT_linkage_name";
13172 /* SGI/MIPS extensions. */
13173 #ifdef MIPS /* collides with DW_AT_HP_block_index */
13174 case DW_AT_MIPS_fde
:
13175 return "DW_AT_MIPS_fde";
13177 case DW_AT_MIPS_loop_begin
:
13178 return "DW_AT_MIPS_loop_begin";
13179 case DW_AT_MIPS_tail_loop_begin
:
13180 return "DW_AT_MIPS_tail_loop_begin";
13181 case DW_AT_MIPS_epilog_begin
:
13182 return "DW_AT_MIPS_epilog_begin";
13183 case DW_AT_MIPS_loop_unroll_factor
:
13184 return "DW_AT_MIPS_loop_unroll_factor";
13185 case DW_AT_MIPS_software_pipeline_depth
:
13186 return "DW_AT_MIPS_software_pipeline_depth";
13187 case DW_AT_MIPS_linkage_name
:
13188 return "DW_AT_MIPS_linkage_name";
13189 case DW_AT_MIPS_stride
:
13190 return "DW_AT_MIPS_stride";
13191 case DW_AT_MIPS_abstract_name
:
13192 return "DW_AT_MIPS_abstract_name";
13193 case DW_AT_MIPS_clone_origin
:
13194 return "DW_AT_MIPS_clone_origin";
13195 case DW_AT_MIPS_has_inlines
:
13196 return "DW_AT_MIPS_has_inlines";
13197 /* HP extensions. */
13198 #ifndef MIPS /* collides with DW_AT_MIPS_fde */
13199 case DW_AT_HP_block_index
:
13200 return "DW_AT_HP_block_index";
13202 case DW_AT_HP_unmodifiable
:
13203 return "DW_AT_HP_unmodifiable";
13204 case DW_AT_HP_actuals_stmt_list
:
13205 return "DW_AT_HP_actuals_stmt_list";
13206 case DW_AT_HP_proc_per_section
:
13207 return "DW_AT_HP_proc_per_section";
13208 case DW_AT_HP_raw_data_ptr
:
13209 return "DW_AT_HP_raw_data_ptr";
13210 case DW_AT_HP_pass_by_reference
:
13211 return "DW_AT_HP_pass_by_reference";
13212 case DW_AT_HP_opt_level
:
13213 return "DW_AT_HP_opt_level";
13214 case DW_AT_HP_prof_version_id
:
13215 return "DW_AT_HP_prof_version_id";
13216 case DW_AT_HP_opt_flags
:
13217 return "DW_AT_HP_opt_flags";
13218 case DW_AT_HP_cold_region_low_pc
:
13219 return "DW_AT_HP_cold_region_low_pc";
13220 case DW_AT_HP_cold_region_high_pc
:
13221 return "DW_AT_HP_cold_region_high_pc";
13222 case DW_AT_HP_all_variables_modifiable
:
13223 return "DW_AT_HP_all_variables_modifiable";
13224 case DW_AT_HP_linkage_name
:
13225 return "DW_AT_HP_linkage_name";
13226 case DW_AT_HP_prof_flags
:
13227 return "DW_AT_HP_prof_flags";
13228 /* GNU extensions. */
13229 case DW_AT_sf_names
:
13230 return "DW_AT_sf_names";
13231 case DW_AT_src_info
:
13232 return "DW_AT_src_info";
13233 case DW_AT_mac_info
:
13234 return "DW_AT_mac_info";
13235 case DW_AT_src_coords
:
13236 return "DW_AT_src_coords";
13237 case DW_AT_body_begin
:
13238 return "DW_AT_body_begin";
13239 case DW_AT_body_end
:
13240 return "DW_AT_body_end";
13241 case DW_AT_GNU_vector
:
13242 return "DW_AT_GNU_vector";
13243 case DW_AT_GNU_odr_signature
:
13244 return "DW_AT_GNU_odr_signature";
13245 /* VMS extensions. */
13246 case DW_AT_VMS_rtnbeg_pd_address
:
13247 return "DW_AT_VMS_rtnbeg_pd_address";
13248 /* UPC extension. */
13249 case DW_AT_upc_threads_scaled
:
13250 return "DW_AT_upc_threads_scaled";
13251 /* PGI (STMicroelectronics) extensions. */
13252 case DW_AT_PGI_lbase
:
13253 return "DW_AT_PGI_lbase";
13254 case DW_AT_PGI_soffset
:
13255 return "DW_AT_PGI_soffset";
13256 case DW_AT_PGI_lstride
:
13257 return "DW_AT_PGI_lstride";
13259 return "DW_AT_<unknown>";
13263 /* Convert a DWARF value form code into its string name. */
13266 dwarf_form_name (unsigned form
)
13271 return "DW_FORM_addr";
13272 case DW_FORM_block2
:
13273 return "DW_FORM_block2";
13274 case DW_FORM_block4
:
13275 return "DW_FORM_block4";
13276 case DW_FORM_data2
:
13277 return "DW_FORM_data2";
13278 case DW_FORM_data4
:
13279 return "DW_FORM_data4";
13280 case DW_FORM_data8
:
13281 return "DW_FORM_data8";
13282 case DW_FORM_string
:
13283 return "DW_FORM_string";
13284 case DW_FORM_block
:
13285 return "DW_FORM_block";
13286 case DW_FORM_block1
:
13287 return "DW_FORM_block1";
13288 case DW_FORM_data1
:
13289 return "DW_FORM_data1";
13291 return "DW_FORM_flag";
13292 case DW_FORM_sdata
:
13293 return "DW_FORM_sdata";
13295 return "DW_FORM_strp";
13296 case DW_FORM_udata
:
13297 return "DW_FORM_udata";
13298 case DW_FORM_ref_addr
:
13299 return "DW_FORM_ref_addr";
13301 return "DW_FORM_ref1";
13303 return "DW_FORM_ref2";
13305 return "DW_FORM_ref4";
13307 return "DW_FORM_ref8";
13308 case DW_FORM_ref_udata
:
13309 return "DW_FORM_ref_udata";
13310 case DW_FORM_indirect
:
13311 return "DW_FORM_indirect";
13312 case DW_FORM_sec_offset
:
13313 return "DW_FORM_sec_offset";
13314 case DW_FORM_exprloc
:
13315 return "DW_FORM_exprloc";
13316 case DW_FORM_flag_present
:
13317 return "DW_FORM_flag_present";
13318 case DW_FORM_ref_sig8
:
13319 return "DW_FORM_ref_sig8";
13321 return "DW_FORM_<unknown>";
13325 /* Convert a DWARF stack opcode into its string name. */
13328 dwarf_stack_op_name (unsigned op
)
13333 return "DW_OP_addr";
13335 return "DW_OP_deref";
13336 case DW_OP_const1u
:
13337 return "DW_OP_const1u";
13338 case DW_OP_const1s
:
13339 return "DW_OP_const1s";
13340 case DW_OP_const2u
:
13341 return "DW_OP_const2u";
13342 case DW_OP_const2s
:
13343 return "DW_OP_const2s";
13344 case DW_OP_const4u
:
13345 return "DW_OP_const4u";
13346 case DW_OP_const4s
:
13347 return "DW_OP_const4s";
13348 case DW_OP_const8u
:
13349 return "DW_OP_const8u";
13350 case DW_OP_const8s
:
13351 return "DW_OP_const8s";
13353 return "DW_OP_constu";
13355 return "DW_OP_consts";
13357 return "DW_OP_dup";
13359 return "DW_OP_drop";
13361 return "DW_OP_over";
13363 return "DW_OP_pick";
13365 return "DW_OP_swap";
13367 return "DW_OP_rot";
13369 return "DW_OP_xderef";
13371 return "DW_OP_abs";
13373 return "DW_OP_and";
13375 return "DW_OP_div";
13377 return "DW_OP_minus";
13379 return "DW_OP_mod";
13381 return "DW_OP_mul";
13383 return "DW_OP_neg";
13385 return "DW_OP_not";
13389 return "DW_OP_plus";
13390 case DW_OP_plus_uconst
:
13391 return "DW_OP_plus_uconst";
13393 return "DW_OP_shl";
13395 return "DW_OP_shr";
13397 return "DW_OP_shra";
13399 return "DW_OP_xor";
13401 return "DW_OP_bra";
13415 return "DW_OP_skip";
13417 return "DW_OP_lit0";
13419 return "DW_OP_lit1";
13421 return "DW_OP_lit2";
13423 return "DW_OP_lit3";
13425 return "DW_OP_lit4";
13427 return "DW_OP_lit5";
13429 return "DW_OP_lit6";
13431 return "DW_OP_lit7";
13433 return "DW_OP_lit8";
13435 return "DW_OP_lit9";
13437 return "DW_OP_lit10";
13439 return "DW_OP_lit11";
13441 return "DW_OP_lit12";
13443 return "DW_OP_lit13";
13445 return "DW_OP_lit14";
13447 return "DW_OP_lit15";
13449 return "DW_OP_lit16";
13451 return "DW_OP_lit17";
13453 return "DW_OP_lit18";
13455 return "DW_OP_lit19";
13457 return "DW_OP_lit20";
13459 return "DW_OP_lit21";
13461 return "DW_OP_lit22";
13463 return "DW_OP_lit23";
13465 return "DW_OP_lit24";
13467 return "DW_OP_lit25";
13469 return "DW_OP_lit26";
13471 return "DW_OP_lit27";
13473 return "DW_OP_lit28";
13475 return "DW_OP_lit29";
13477 return "DW_OP_lit30";
13479 return "DW_OP_lit31";
13481 return "DW_OP_reg0";
13483 return "DW_OP_reg1";
13485 return "DW_OP_reg2";
13487 return "DW_OP_reg3";
13489 return "DW_OP_reg4";
13491 return "DW_OP_reg5";
13493 return "DW_OP_reg6";
13495 return "DW_OP_reg7";
13497 return "DW_OP_reg8";
13499 return "DW_OP_reg9";
13501 return "DW_OP_reg10";
13503 return "DW_OP_reg11";
13505 return "DW_OP_reg12";
13507 return "DW_OP_reg13";
13509 return "DW_OP_reg14";
13511 return "DW_OP_reg15";
13513 return "DW_OP_reg16";
13515 return "DW_OP_reg17";
13517 return "DW_OP_reg18";
13519 return "DW_OP_reg19";
13521 return "DW_OP_reg20";
13523 return "DW_OP_reg21";
13525 return "DW_OP_reg22";
13527 return "DW_OP_reg23";
13529 return "DW_OP_reg24";
13531 return "DW_OP_reg25";
13533 return "DW_OP_reg26";
13535 return "DW_OP_reg27";
13537 return "DW_OP_reg28";
13539 return "DW_OP_reg29";
13541 return "DW_OP_reg30";
13543 return "DW_OP_reg31";
13545 return "DW_OP_breg0";
13547 return "DW_OP_breg1";
13549 return "DW_OP_breg2";
13551 return "DW_OP_breg3";
13553 return "DW_OP_breg4";
13555 return "DW_OP_breg5";
13557 return "DW_OP_breg6";
13559 return "DW_OP_breg7";
13561 return "DW_OP_breg8";
13563 return "DW_OP_breg9";
13565 return "DW_OP_breg10";
13567 return "DW_OP_breg11";
13569 return "DW_OP_breg12";
13571 return "DW_OP_breg13";
13573 return "DW_OP_breg14";
13575 return "DW_OP_breg15";
13577 return "DW_OP_breg16";
13579 return "DW_OP_breg17";
13581 return "DW_OP_breg18";
13583 return "DW_OP_breg19";
13585 return "DW_OP_breg20";
13587 return "DW_OP_breg21";
13589 return "DW_OP_breg22";
13591 return "DW_OP_breg23";
13593 return "DW_OP_breg24";
13595 return "DW_OP_breg25";
13597 return "DW_OP_breg26";
13599 return "DW_OP_breg27";
13601 return "DW_OP_breg28";
13603 return "DW_OP_breg29";
13605 return "DW_OP_breg30";
13607 return "DW_OP_breg31";
13609 return "DW_OP_regx";
13611 return "DW_OP_fbreg";
13613 return "DW_OP_bregx";
13615 return "DW_OP_piece";
13616 case DW_OP_deref_size
:
13617 return "DW_OP_deref_size";
13618 case DW_OP_xderef_size
:
13619 return "DW_OP_xderef_size";
13621 return "DW_OP_nop";
13622 /* DWARF 3 extensions. */
13623 case DW_OP_push_object_address
:
13624 return "DW_OP_push_object_address";
13626 return "DW_OP_call2";
13628 return "DW_OP_call4";
13629 case DW_OP_call_ref
:
13630 return "DW_OP_call_ref";
13631 case DW_OP_form_tls_address
:
13632 return "DW_OP_form_tls_address";
13633 case DW_OP_call_frame_cfa
:
13634 return "DW_OP_call_frame_cfa";
13635 case DW_OP_bit_piece
:
13636 return "DW_OP_bit_piece";
13637 /* DWARF 4 extensions. */
13638 case DW_OP_implicit_value
:
13639 return "DW_OP_implicit_value";
13640 case DW_OP_stack_value
:
13641 return "DW_OP_stack_value";
13642 /* GNU extensions. */
13643 case DW_OP_GNU_push_tls_address
:
13644 return "DW_OP_GNU_push_tls_address";
13645 case DW_OP_GNU_uninit
:
13646 return "DW_OP_GNU_uninit";
13647 case DW_OP_GNU_implicit_pointer
:
13648 return "DW_OP_GNU_implicit_pointer";
13649 case DW_OP_GNU_entry_value
:
13650 return "DW_OP_GNU_entry_value";
13651 case DW_OP_GNU_const_type
:
13652 return "DW_OP_GNU_const_type";
13653 case DW_OP_GNU_regval_type
:
13654 return "DW_OP_GNU_regval_type";
13655 case DW_OP_GNU_deref_type
:
13656 return "DW_OP_GNU_deref_type";
13657 case DW_OP_GNU_convert
:
13658 return "DW_OP_GNU_convert";
13659 case DW_OP_GNU_reinterpret
:
13660 return "DW_OP_GNU_reinterpret";
13667 dwarf_bool_name (unsigned mybool
)
13675 /* Convert a DWARF type code into its string name. */
13678 dwarf_type_encoding_name (unsigned enc
)
13683 return "DW_ATE_void";
13684 case DW_ATE_address
:
13685 return "DW_ATE_address";
13686 case DW_ATE_boolean
:
13687 return "DW_ATE_boolean";
13688 case DW_ATE_complex_float
:
13689 return "DW_ATE_complex_float";
13691 return "DW_ATE_float";
13692 case DW_ATE_signed
:
13693 return "DW_ATE_signed";
13694 case DW_ATE_signed_char
:
13695 return "DW_ATE_signed_char";
13696 case DW_ATE_unsigned
:
13697 return "DW_ATE_unsigned";
13698 case DW_ATE_unsigned_char
:
13699 return "DW_ATE_unsigned_char";
13701 case DW_ATE_imaginary_float
:
13702 return "DW_ATE_imaginary_float";
13703 case DW_ATE_packed_decimal
:
13704 return "DW_ATE_packed_decimal";
13705 case DW_ATE_numeric_string
:
13706 return "DW_ATE_numeric_string";
13707 case DW_ATE_edited
:
13708 return "DW_ATE_edited";
13709 case DW_ATE_signed_fixed
:
13710 return "DW_ATE_signed_fixed";
13711 case DW_ATE_unsigned_fixed
:
13712 return "DW_ATE_unsigned_fixed";
13713 case DW_ATE_decimal_float
:
13714 return "DW_ATE_decimal_float";
13717 return "DW_ATE_UTF";
13718 /* HP extensions. */
13719 case DW_ATE_HP_float80
:
13720 return "DW_ATE_HP_float80";
13721 case DW_ATE_HP_complex_float80
:
13722 return "DW_ATE_HP_complex_float80";
13723 case DW_ATE_HP_float128
:
13724 return "DW_ATE_HP_float128";
13725 case DW_ATE_HP_complex_float128
:
13726 return "DW_ATE_HP_complex_float128";
13727 case DW_ATE_HP_floathpintel
:
13728 return "DW_ATE_HP_floathpintel";
13729 case DW_ATE_HP_imaginary_float80
:
13730 return "DW_ATE_HP_imaginary_float80";
13731 case DW_ATE_HP_imaginary_float128
:
13732 return "DW_ATE_HP_imaginary_float128";
13734 return "DW_ATE_<unknown>";
13738 /* Convert a DWARF call frame info operation to its string name. */
13742 dwarf_cfi_name (unsigned cfi_opc
)
13746 case DW_CFA_advance_loc
:
13747 return "DW_CFA_advance_loc";
13748 case DW_CFA_offset
:
13749 return "DW_CFA_offset";
13750 case DW_CFA_restore
:
13751 return "DW_CFA_restore";
13753 return "DW_CFA_nop";
13754 case DW_CFA_set_loc
:
13755 return "DW_CFA_set_loc";
13756 case DW_CFA_advance_loc1
:
13757 return "DW_CFA_advance_loc1";
13758 case DW_CFA_advance_loc2
:
13759 return "DW_CFA_advance_loc2";
13760 case DW_CFA_advance_loc4
:
13761 return "DW_CFA_advance_loc4";
13762 case DW_CFA_offset_extended
:
13763 return "DW_CFA_offset_extended";
13764 case DW_CFA_restore_extended
:
13765 return "DW_CFA_restore_extended";
13766 case DW_CFA_undefined
:
13767 return "DW_CFA_undefined";
13768 case DW_CFA_same_value
:
13769 return "DW_CFA_same_value";
13770 case DW_CFA_register
:
13771 return "DW_CFA_register";
13772 case DW_CFA_remember_state
:
13773 return "DW_CFA_remember_state";
13774 case DW_CFA_restore_state
:
13775 return "DW_CFA_restore_state";
13776 case DW_CFA_def_cfa
:
13777 return "DW_CFA_def_cfa";
13778 case DW_CFA_def_cfa_register
:
13779 return "DW_CFA_def_cfa_register";
13780 case DW_CFA_def_cfa_offset
:
13781 return "DW_CFA_def_cfa_offset";
13783 case DW_CFA_def_cfa_expression
:
13784 return "DW_CFA_def_cfa_expression";
13785 case DW_CFA_expression
:
13786 return "DW_CFA_expression";
13787 case DW_CFA_offset_extended_sf
:
13788 return "DW_CFA_offset_extended_sf";
13789 case DW_CFA_def_cfa_sf
:
13790 return "DW_CFA_def_cfa_sf";
13791 case DW_CFA_def_cfa_offset_sf
:
13792 return "DW_CFA_def_cfa_offset_sf";
13793 case DW_CFA_val_offset
:
13794 return "DW_CFA_val_offset";
13795 case DW_CFA_val_offset_sf
:
13796 return "DW_CFA_val_offset_sf";
13797 case DW_CFA_val_expression
:
13798 return "DW_CFA_val_expression";
13799 /* SGI/MIPS specific. */
13800 case DW_CFA_MIPS_advance_loc8
:
13801 return "DW_CFA_MIPS_advance_loc8";
13802 /* GNU extensions. */
13803 case DW_CFA_GNU_window_save
:
13804 return "DW_CFA_GNU_window_save";
13805 case DW_CFA_GNU_args_size
:
13806 return "DW_CFA_GNU_args_size";
13807 case DW_CFA_GNU_negative_offset_extended
:
13808 return "DW_CFA_GNU_negative_offset_extended";
13810 return "DW_CFA_<unknown>";
13816 dump_die_shallow (struct ui_file
*f
, int indent
, struct die_info
*die
)
13820 print_spaces (indent
, f
);
13821 fprintf_unfiltered (f
, "Die: %s (abbrev %d, offset 0x%x)\n",
13822 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
13824 if (die
->parent
!= NULL
)
13826 print_spaces (indent
, f
);
13827 fprintf_unfiltered (f
, " parent at offset: 0x%x\n",
13828 die
->parent
->offset
);
13831 print_spaces (indent
, f
);
13832 fprintf_unfiltered (f
, " has children: %s\n",
13833 dwarf_bool_name (die
->child
!= NULL
));
13835 print_spaces (indent
, f
);
13836 fprintf_unfiltered (f
, " attributes:\n");
13838 for (i
= 0; i
< die
->num_attrs
; ++i
)
13840 print_spaces (indent
, f
);
13841 fprintf_unfiltered (f
, " %s (%s) ",
13842 dwarf_attr_name (die
->attrs
[i
].name
),
13843 dwarf_form_name (die
->attrs
[i
].form
));
13845 switch (die
->attrs
[i
].form
)
13847 case DW_FORM_ref_addr
:
13849 fprintf_unfiltered (f
, "address: ");
13850 fputs_filtered (hex_string (DW_ADDR (&die
->attrs
[i
])), f
);
13852 case DW_FORM_block2
:
13853 case DW_FORM_block4
:
13854 case DW_FORM_block
:
13855 case DW_FORM_block1
:
13856 fprintf_unfiltered (f
, "block: size %d",
13857 DW_BLOCK (&die
->attrs
[i
])->size
);
13859 case DW_FORM_exprloc
:
13860 fprintf_unfiltered (f
, "expression: size %u",
13861 DW_BLOCK (&die
->attrs
[i
])->size
);
13866 fprintf_unfiltered (f
, "constant ref: 0x%lx (adjusted)",
13867 (long) (DW_ADDR (&die
->attrs
[i
])));
13869 case DW_FORM_data1
:
13870 case DW_FORM_data2
:
13871 case DW_FORM_data4
:
13872 case DW_FORM_data8
:
13873 case DW_FORM_udata
:
13874 case DW_FORM_sdata
:
13875 fprintf_unfiltered (f
, "constant: %s",
13876 pulongest (DW_UNSND (&die
->attrs
[i
])));
13878 case DW_FORM_sec_offset
:
13879 fprintf_unfiltered (f
, "section offset: %s",
13880 pulongest (DW_UNSND (&die
->attrs
[i
])));
13882 case DW_FORM_ref_sig8
:
13883 if (DW_SIGNATURED_TYPE (&die
->attrs
[i
]) != NULL
)
13884 fprintf_unfiltered (f
, "signatured type, offset: 0x%x",
13885 DW_SIGNATURED_TYPE (&die
->attrs
[i
])->per_cu
.offset
);
13887 fprintf_unfiltered (f
, "signatured type, offset: unknown");
13889 case DW_FORM_string
:
13891 fprintf_unfiltered (f
, "string: \"%s\" (%s canonicalized)",
13892 DW_STRING (&die
->attrs
[i
])
13893 ? DW_STRING (&die
->attrs
[i
]) : "",
13894 DW_STRING_IS_CANONICAL (&die
->attrs
[i
]) ? "is" : "not");
13897 if (DW_UNSND (&die
->attrs
[i
]))
13898 fprintf_unfiltered (f
, "flag: TRUE");
13900 fprintf_unfiltered (f
, "flag: FALSE");
13902 case DW_FORM_flag_present
:
13903 fprintf_unfiltered (f
, "flag: TRUE");
13905 case DW_FORM_indirect
:
13906 /* The reader will have reduced the indirect form to
13907 the "base form" so this form should not occur. */
13908 fprintf_unfiltered (f
,
13909 "unexpected attribute form: DW_FORM_indirect");
13912 fprintf_unfiltered (f
, "unsupported attribute form: %d.",
13913 die
->attrs
[i
].form
);
13916 fprintf_unfiltered (f
, "\n");
13921 dump_die_for_error (struct die_info
*die
)
13923 dump_die_shallow (gdb_stderr
, 0, die
);
13927 dump_die_1 (struct ui_file
*f
, int level
, int max_level
, struct die_info
*die
)
13929 int indent
= level
* 4;
13931 gdb_assert (die
!= NULL
);
13933 if (level
>= max_level
)
13936 dump_die_shallow (f
, indent
, die
);
13938 if (die
->child
!= NULL
)
13940 print_spaces (indent
, f
);
13941 fprintf_unfiltered (f
, " Children:");
13942 if (level
+ 1 < max_level
)
13944 fprintf_unfiltered (f
, "\n");
13945 dump_die_1 (f
, level
+ 1, max_level
, die
->child
);
13949 fprintf_unfiltered (f
,
13950 " [not printed, max nesting level reached]\n");
13954 if (die
->sibling
!= NULL
&& level
> 0)
13956 dump_die_1 (f
, level
, max_level
, die
->sibling
);
13960 /* This is called from the pdie macro in gdbinit.in.
13961 It's not static so gcc will keep a copy callable from gdb. */
13964 dump_die (struct die_info
*die
, int max_level
)
13966 dump_die_1 (gdb_stdlog
, 0, max_level
, die
);
13970 store_in_ref_table (struct die_info
*die
, struct dwarf2_cu
*cu
)
13974 slot
= htab_find_slot_with_hash (cu
->die_hash
, die
, die
->offset
, INSERT
);
13980 is_ref_attr (struct attribute
*attr
)
13982 switch (attr
->form
)
13984 case DW_FORM_ref_addr
:
13989 case DW_FORM_ref_udata
:
13996 static unsigned int
13997 dwarf2_get_ref_die_offset (struct attribute
*attr
)
13999 if (is_ref_attr (attr
))
14000 return DW_ADDR (attr
);
14002 complaint (&symfile_complaints
,
14003 _("unsupported die ref attribute form: '%s'"),
14004 dwarf_form_name (attr
->form
));
14008 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
14009 * the value held by the attribute is not constant. */
14012 dwarf2_get_attr_constant_value (struct attribute
*attr
, int default_value
)
14014 if (attr
->form
== DW_FORM_sdata
)
14015 return DW_SND (attr
);
14016 else if (attr
->form
== DW_FORM_udata
14017 || attr
->form
== DW_FORM_data1
14018 || attr
->form
== DW_FORM_data2
14019 || attr
->form
== DW_FORM_data4
14020 || attr
->form
== DW_FORM_data8
)
14021 return DW_UNSND (attr
);
14024 complaint (&symfile_complaints
,
14025 _("Attribute value is not a constant (%s)"),
14026 dwarf_form_name (attr
->form
));
14027 return default_value
;
14031 /* THIS_CU has a reference to PER_CU. If necessary, load the new compilation
14032 unit and add it to our queue.
14033 The result is non-zero if PER_CU was queued, otherwise the result is zero
14034 meaning either PER_CU is already queued or it is already loaded. */
14037 maybe_queue_comp_unit (struct dwarf2_cu
*this_cu
,
14038 struct dwarf2_per_cu_data
*per_cu
)
14040 /* We may arrive here during partial symbol reading, if we need full
14041 DIEs to process an unusual case (e.g. template arguments). Do
14042 not queue PER_CU, just tell our caller to load its DIEs. */
14043 if (dwarf2_per_objfile
->reading_partial_symbols
)
14045 if (per_cu
->cu
== NULL
|| per_cu
->cu
->dies
== NULL
)
14050 /* Mark the dependence relation so that we don't flush PER_CU
14052 dwarf2_add_dependence (this_cu
, per_cu
);
14054 /* If it's already on the queue, we have nothing to do. */
14055 if (per_cu
->queued
)
14058 /* If the compilation unit is already loaded, just mark it as
14060 if (per_cu
->cu
!= NULL
)
14062 per_cu
->cu
->last_used
= 0;
14066 /* Add it to the queue. */
14067 queue_comp_unit (per_cu
);
14072 /* Follow reference or signature attribute ATTR of SRC_DIE.
14073 On entry *REF_CU is the CU of SRC_DIE.
14074 On exit *REF_CU is the CU of the result. */
14076 static struct die_info
*
14077 follow_die_ref_or_sig (struct die_info
*src_die
, struct attribute
*attr
,
14078 struct dwarf2_cu
**ref_cu
)
14080 struct die_info
*die
;
14082 if (is_ref_attr (attr
))
14083 die
= follow_die_ref (src_die
, attr
, ref_cu
);
14084 else if (attr
->form
== DW_FORM_ref_sig8
)
14085 die
= follow_die_sig (src_die
, attr
, ref_cu
);
14088 dump_die_for_error (src_die
);
14089 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
14090 (*ref_cu
)->objfile
->name
);
14096 /* Follow reference OFFSET.
14097 On entry *REF_CU is the CU of the source die referencing OFFSET.
14098 On exit *REF_CU is the CU of the result.
14099 Returns NULL if OFFSET is invalid. */
14101 static struct die_info
*
14102 follow_die_offset (unsigned int offset
, struct dwarf2_cu
**ref_cu
)
14104 struct die_info temp_die
;
14105 struct dwarf2_cu
*target_cu
, *cu
= *ref_cu
;
14107 gdb_assert (cu
->per_cu
!= NULL
);
14111 if (cu
->per_cu
->debug_types_section
)
14113 /* .debug_types CUs cannot reference anything outside their CU.
14114 If they need to, they have to reference a signatured type via
14115 DW_FORM_ref_sig8. */
14116 if (! offset_in_cu_p (&cu
->header
, offset
))
14119 else if (! offset_in_cu_p (&cu
->header
, offset
))
14121 struct dwarf2_per_cu_data
*per_cu
;
14123 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
14125 /* If necessary, add it to the queue and load its DIEs. */
14126 if (maybe_queue_comp_unit (cu
, per_cu
))
14127 load_full_comp_unit (per_cu
);
14129 target_cu
= per_cu
->cu
;
14131 else if (cu
->dies
== NULL
)
14133 /* We're loading full DIEs during partial symbol reading. */
14134 gdb_assert (dwarf2_per_objfile
->reading_partial_symbols
);
14135 load_full_comp_unit (cu
->per_cu
);
14138 *ref_cu
= target_cu
;
14139 temp_die
.offset
= offset
;
14140 return htab_find_with_hash (target_cu
->die_hash
, &temp_die
, offset
);
14143 /* Follow reference attribute ATTR of SRC_DIE.
14144 On entry *REF_CU is the CU of SRC_DIE.
14145 On exit *REF_CU is the CU of the result. */
14147 static struct die_info
*
14148 follow_die_ref (struct die_info
*src_die
, struct attribute
*attr
,
14149 struct dwarf2_cu
**ref_cu
)
14151 unsigned int offset
= dwarf2_get_ref_die_offset (attr
);
14152 struct dwarf2_cu
*cu
= *ref_cu
;
14153 struct die_info
*die
;
14155 die
= follow_die_offset (offset
, ref_cu
);
14157 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced from DIE "
14158 "at 0x%x [in module %s]"),
14159 offset
, src_die
->offset
, cu
->objfile
->name
);
14164 /* Return DWARF block referenced by DW_AT_location of DIE at OFFSET at PER_CU.
14165 Returned value is intended for DW_OP_call*. Returned
14166 dwarf2_locexpr_baton->data has lifetime of PER_CU->OBJFILE. */
14168 struct dwarf2_locexpr_baton
14169 dwarf2_fetch_die_location_block (unsigned int offset
,
14170 struct dwarf2_per_cu_data
*per_cu
,
14171 CORE_ADDR (*get_frame_pc
) (void *baton
),
14174 struct dwarf2_cu
*cu
;
14175 struct die_info
*die
;
14176 struct attribute
*attr
;
14177 struct dwarf2_locexpr_baton retval
;
14179 dw2_setup (per_cu
->objfile
);
14181 if (per_cu
->cu
== NULL
)
14185 die
= follow_die_offset (offset
, &cu
);
14187 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
14188 offset
, per_cu
->objfile
->name
);
14190 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
14193 /* DWARF: "If there is no such attribute, then there is no effect.".
14194 DATA is ignored if SIZE is 0. */
14196 retval
.data
= NULL
;
14199 else if (attr_form_is_section_offset (attr
))
14201 struct dwarf2_loclist_baton loclist_baton
;
14202 CORE_ADDR pc
= (*get_frame_pc
) (baton
);
14205 fill_in_loclist_baton (cu
, &loclist_baton
, attr
);
14207 retval
.data
= dwarf2_find_location_expression (&loclist_baton
,
14209 retval
.size
= size
;
14213 if (!attr_form_is_block (attr
))
14214 error (_("Dwarf Error: DIE at 0x%x referenced in module %s "
14215 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
14216 offset
, per_cu
->objfile
->name
);
14218 retval
.data
= DW_BLOCK (attr
)->data
;
14219 retval
.size
= DW_BLOCK (attr
)->size
;
14221 retval
.per_cu
= cu
->per_cu
;
14223 age_cached_comp_units ();
14228 /* Return the type of the DIE at DIE_OFFSET in the CU named by
14232 dwarf2_get_die_type (unsigned int die_offset
,
14233 struct dwarf2_per_cu_data
*per_cu
)
14235 dw2_setup (per_cu
->objfile
);
14236 return get_die_type_at_offset (die_offset
, per_cu
);
14239 /* Follow the signature attribute ATTR in SRC_DIE.
14240 On entry *REF_CU is the CU of SRC_DIE.
14241 On exit *REF_CU is the CU of the result. */
14243 static struct die_info
*
14244 follow_die_sig (struct die_info
*src_die
, struct attribute
*attr
,
14245 struct dwarf2_cu
**ref_cu
)
14247 struct objfile
*objfile
= (*ref_cu
)->objfile
;
14248 struct die_info temp_die
;
14249 struct signatured_type
*sig_type
= DW_SIGNATURED_TYPE (attr
);
14250 struct dwarf2_cu
*sig_cu
;
14251 struct die_info
*die
;
14253 /* sig_type will be NULL if the signatured type is missing from
14255 if (sig_type
== NULL
)
14256 error (_("Dwarf Error: Cannot find signatured DIE referenced from DIE "
14257 "at 0x%x [in module %s]"),
14258 src_die
->offset
, objfile
->name
);
14260 /* If necessary, add it to the queue and load its DIEs. */
14262 if (maybe_queue_comp_unit (*ref_cu
, &sig_type
->per_cu
))
14263 read_signatured_type (sig_type
);
14265 gdb_assert (sig_type
->per_cu
.cu
!= NULL
);
14267 sig_cu
= sig_type
->per_cu
.cu
;
14268 temp_die
.offset
= sig_cu
->header
.offset
+ sig_type
->type_offset
;
14269 die
= htab_find_with_hash (sig_cu
->die_hash
, &temp_die
, temp_die
.offset
);
14276 error (_("Dwarf Error: Cannot find signatured DIE at 0x%x referenced "
14277 "from DIE at 0x%x [in module %s]"),
14278 sig_type
->type_offset
, src_die
->offset
, objfile
->name
);
14281 /* Given an offset of a signatured type, return its signatured_type. */
14283 static struct signatured_type
*
14284 lookup_signatured_type_at_offset (struct objfile
*objfile
,
14285 struct dwarf2_section_info
*section
,
14286 unsigned int offset
)
14288 gdb_byte
*info_ptr
= section
->buffer
+ offset
;
14289 unsigned int length
, initial_length_size
;
14290 unsigned int sig_offset
;
14291 struct signatured_type find_entry
, *type_sig
;
14293 length
= read_initial_length (objfile
->obfd
, info_ptr
, &initial_length_size
);
14294 sig_offset
= (initial_length_size
14296 + (initial_length_size
== 4 ? 4 : 8) /*debug_abbrev_offset*/
14297 + 1 /*address_size*/);
14298 find_entry
.signature
= bfd_get_64 (objfile
->obfd
, info_ptr
+ sig_offset
);
14299 type_sig
= htab_find (dwarf2_per_objfile
->signatured_types
, &find_entry
);
14301 /* This is only used to lookup previously recorded types.
14302 If we didn't find it, it's our bug. */
14303 gdb_assert (type_sig
!= NULL
);
14304 gdb_assert (offset
== type_sig
->per_cu
.offset
);
14309 /* Load the DIEs associated with type unit PER_CU into memory. */
14312 load_full_type_unit (struct dwarf2_per_cu_data
*per_cu
)
14314 struct objfile
*objfile
= per_cu
->objfile
;
14315 struct dwarf2_section_info
*sect
= per_cu
->debug_types_section
;
14316 unsigned int offset
= per_cu
->offset
;
14317 struct signatured_type
*type_sig
;
14319 dwarf2_read_section (objfile
, sect
);
14321 /* We have the section offset, but we need the signature to do the
14322 hash table lookup. */
14323 /* FIXME: This is sorta unnecessary, read_signatured_type only uses
14324 the signature to assert we found the right one.
14325 Ok, but it's a lot of work. We should simplify things so any needed
14326 assert doesn't require all this clumsiness. */
14327 type_sig
= lookup_signatured_type_at_offset (objfile
, sect
, offset
);
14329 gdb_assert (type_sig
->per_cu
.cu
== NULL
);
14331 read_signatured_type (type_sig
);
14333 gdb_assert (type_sig
->per_cu
.cu
!= NULL
);
14336 /* Read in a signatured type and build its CU and DIEs. */
14339 read_signatured_type (struct signatured_type
*type_sig
)
14341 struct objfile
*objfile
= type_sig
->per_cu
.objfile
;
14342 gdb_byte
*types_ptr
;
14343 struct die_reader_specs reader_specs
;
14344 struct dwarf2_cu
*cu
;
14345 ULONGEST signature
;
14346 struct cleanup
*back_to
, *free_cu_cleanup
;
14347 struct dwarf2_section_info
*section
= type_sig
->per_cu
.debug_types_section
;
14349 dwarf2_read_section (objfile
, section
);
14350 types_ptr
= section
->buffer
+ type_sig
->per_cu
.offset
;
14352 gdb_assert (type_sig
->per_cu
.cu
== NULL
);
14354 cu
= xmalloc (sizeof (*cu
));
14355 init_one_comp_unit (cu
, &type_sig
->per_cu
);
14357 /* If an error occurs while loading, release our storage. */
14358 free_cu_cleanup
= make_cleanup (free_heap_comp_unit
, cu
);
14360 types_ptr
= read_and_check_type_unit_head (&cu
->header
, section
, types_ptr
,
14362 gdb_assert (signature
== type_sig
->signature
);
14365 = htab_create_alloc_ex (cu
->header
.length
/ 12,
14369 &cu
->comp_unit_obstack
,
14370 hashtab_obstack_allocate
,
14371 dummy_obstack_deallocate
);
14373 dwarf2_read_abbrevs (cu
);
14374 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
14376 init_cu_die_reader (&reader_specs
, cu
);
14378 cu
->dies
= read_die_and_children (&reader_specs
, types_ptr
, &types_ptr
,
14381 /* We try not to read any attributes in this function, because not
14382 all CUs needed for references have been loaded yet, and symbol
14383 table processing isn't initialized. But we have to set the CU language,
14384 or we won't be able to build types correctly. */
14385 prepare_one_comp_unit (cu
, cu
->dies
);
14387 do_cleanups (back_to
);
14389 /* We've successfully allocated this compilation unit. Let our caller
14390 clean it up when finished with it. */
14391 discard_cleanups (free_cu_cleanup
);
14393 type_sig
->per_cu
.cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
14394 dwarf2_per_objfile
->read_in_chain
= &type_sig
->per_cu
;
14397 /* Decode simple location descriptions.
14398 Given a pointer to a dwarf block that defines a location, compute
14399 the location and return the value.
14401 NOTE drow/2003-11-18: This function is called in two situations
14402 now: for the address of static or global variables (partial symbols
14403 only) and for offsets into structures which are expected to be
14404 (more or less) constant. The partial symbol case should go away,
14405 and only the constant case should remain. That will let this
14406 function complain more accurately. A few special modes are allowed
14407 without complaint for global variables (for instance, global
14408 register values and thread-local values).
14410 A location description containing no operations indicates that the
14411 object is optimized out. The return value is 0 for that case.
14412 FIXME drow/2003-11-16: No callers check for this case any more; soon all
14413 callers will only want a very basic result and this can become a
14416 Note that stack[0] is unused except as a default error return. */
14419 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
14421 struct objfile
*objfile
= cu
->objfile
;
14423 int size
= blk
->size
;
14424 gdb_byte
*data
= blk
->data
;
14425 CORE_ADDR stack
[64];
14427 unsigned int bytes_read
, unsnd
;
14433 stack
[++stacki
] = 0;
14472 stack
[++stacki
] = op
- DW_OP_lit0
;
14507 stack
[++stacki
] = op
- DW_OP_reg0
;
14509 dwarf2_complex_location_expr_complaint ();
14513 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
14515 stack
[++stacki
] = unsnd
;
14517 dwarf2_complex_location_expr_complaint ();
14521 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
14526 case DW_OP_const1u
:
14527 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
14531 case DW_OP_const1s
:
14532 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
14536 case DW_OP_const2u
:
14537 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
14541 case DW_OP_const2s
:
14542 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
14546 case DW_OP_const4u
:
14547 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
14551 case DW_OP_const4s
:
14552 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
14556 case DW_OP_const8u
:
14557 stack
[++stacki
] = read_8_bytes (objfile
->obfd
, &data
[i
]);
14562 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
14568 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
14573 stack
[stacki
+ 1] = stack
[stacki
];
14578 stack
[stacki
- 1] += stack
[stacki
];
14582 case DW_OP_plus_uconst
:
14583 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
),
14589 stack
[stacki
- 1] -= stack
[stacki
];
14594 /* If we're not the last op, then we definitely can't encode
14595 this using GDB's address_class enum. This is valid for partial
14596 global symbols, although the variable's address will be bogus
14599 dwarf2_complex_location_expr_complaint ();
14602 case DW_OP_GNU_push_tls_address
:
14603 /* The top of the stack has the offset from the beginning
14604 of the thread control block at which the variable is located. */
14605 /* Nothing should follow this operator, so the top of stack would
14607 /* This is valid for partial global symbols, but the variable's
14608 address will be bogus in the psymtab. Make it always at least
14609 non-zero to not look as a variable garbage collected by linker
14610 which have DW_OP_addr 0. */
14612 dwarf2_complex_location_expr_complaint ();
14616 case DW_OP_GNU_uninit
:
14621 const char *name
= dwarf_stack_op_name (op
);
14624 complaint (&symfile_complaints
, _("unsupported stack op: '%s'"),
14627 complaint (&symfile_complaints
, _("unsupported stack op: '%02x'"),
14631 return (stack
[stacki
]);
14634 /* Enforce maximum stack depth of SIZE-1 to avoid writing
14635 outside of the allocated space. Also enforce minimum>0. */
14636 if (stacki
>= ARRAY_SIZE (stack
) - 1)
14638 complaint (&symfile_complaints
,
14639 _("location description stack overflow"));
14645 complaint (&symfile_complaints
,
14646 _("location description stack underflow"));
14650 return (stack
[stacki
]);
14653 /* memory allocation interface */
14655 static struct dwarf_block
*
14656 dwarf_alloc_block (struct dwarf2_cu
*cu
)
14658 struct dwarf_block
*blk
;
14660 blk
= (struct dwarf_block
*)
14661 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
14665 static struct abbrev_info
*
14666 dwarf_alloc_abbrev (struct dwarf2_cu
*cu
)
14668 struct abbrev_info
*abbrev
;
14670 abbrev
= (struct abbrev_info
*)
14671 obstack_alloc (&cu
->abbrev_obstack
, sizeof (struct abbrev_info
));
14672 memset (abbrev
, 0, sizeof (struct abbrev_info
));
14676 static struct die_info
*
14677 dwarf_alloc_die (struct dwarf2_cu
*cu
, int num_attrs
)
14679 struct die_info
*die
;
14680 size_t size
= sizeof (struct die_info
);
14683 size
+= (num_attrs
- 1) * sizeof (struct attribute
);
14685 die
= (struct die_info
*) obstack_alloc (&cu
->comp_unit_obstack
, size
);
14686 memset (die
, 0, sizeof (struct die_info
));
14691 /* Macro support. */
14693 /* Return the full name of file number I in *LH's file name table.
14694 Use COMP_DIR as the name of the current directory of the
14695 compilation. The result is allocated using xmalloc; the caller is
14696 responsible for freeing it. */
14698 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
14700 /* Is the file number a valid index into the line header's file name
14701 table? Remember that file numbers start with one, not zero. */
14702 if (1 <= file
&& file
<= lh
->num_file_names
)
14704 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
14706 if (IS_ABSOLUTE_PATH (fe
->name
))
14707 return xstrdup (fe
->name
);
14715 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
14721 dir_len
= strlen (dir
);
14722 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
14723 strcpy (full_name
, dir
);
14724 full_name
[dir_len
] = '/';
14725 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
14729 return xstrdup (fe
->name
);
14734 /* The compiler produced a bogus file number. We can at least
14735 record the macro definitions made in the file, even if we
14736 won't be able to find the file by name. */
14737 char fake_name
[80];
14739 sprintf (fake_name
, "<bad macro file number %d>", file
);
14741 complaint (&symfile_complaints
,
14742 _("bad file number in macro information (%d)"),
14745 return xstrdup (fake_name
);
14750 static struct macro_source_file
*
14751 macro_start_file (int file
, int line
,
14752 struct macro_source_file
*current_file
,
14753 const char *comp_dir
,
14754 struct line_header
*lh
, struct objfile
*objfile
)
14756 /* The full name of this source file. */
14757 char *full_name
= file_full_name (file
, lh
, comp_dir
);
14759 /* We don't create a macro table for this compilation unit
14760 at all until we actually get a filename. */
14761 if (! pending_macros
)
14762 pending_macros
= new_macro_table (&objfile
->objfile_obstack
,
14763 objfile
->macro_cache
);
14765 if (! current_file
)
14766 /* If we have no current file, then this must be the start_file
14767 directive for the compilation unit's main source file. */
14768 current_file
= macro_set_main (pending_macros
, full_name
);
14770 current_file
= macro_include (current_file
, line
, full_name
);
14774 return current_file
;
14778 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
14779 followed by a null byte. */
14781 copy_string (const char *buf
, int len
)
14783 char *s
= xmalloc (len
+ 1);
14785 memcpy (s
, buf
, len
);
14791 static const char *
14792 consume_improper_spaces (const char *p
, const char *body
)
14796 complaint (&symfile_complaints
,
14797 _("macro definition contains spaces "
14798 "in formal argument list:\n`%s'"),
14810 parse_macro_definition (struct macro_source_file
*file
, int line
,
14815 /* The body string takes one of two forms. For object-like macro
14816 definitions, it should be:
14818 <macro name> " " <definition>
14820 For function-like macro definitions, it should be:
14822 <macro name> "() " <definition>
14824 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
14826 Spaces may appear only where explicitly indicated, and in the
14829 The Dwarf 2 spec says that an object-like macro's name is always
14830 followed by a space, but versions of GCC around March 2002 omit
14831 the space when the macro's definition is the empty string.
14833 The Dwarf 2 spec says that there should be no spaces between the
14834 formal arguments in a function-like macro's formal argument list,
14835 but versions of GCC around March 2002 include spaces after the
14839 /* Find the extent of the macro name. The macro name is terminated
14840 by either a space or null character (for an object-like macro) or
14841 an opening paren (for a function-like macro). */
14842 for (p
= body
; *p
; p
++)
14843 if (*p
== ' ' || *p
== '(')
14846 if (*p
== ' ' || *p
== '\0')
14848 /* It's an object-like macro. */
14849 int name_len
= p
- body
;
14850 char *name
= copy_string (body
, name_len
);
14851 const char *replacement
;
14854 replacement
= body
+ name_len
+ 1;
14857 dwarf2_macro_malformed_definition_complaint (body
);
14858 replacement
= body
+ name_len
;
14861 macro_define_object (file
, line
, name
, replacement
);
14865 else if (*p
== '(')
14867 /* It's a function-like macro. */
14868 char *name
= copy_string (body
, p
- body
);
14871 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
14875 p
= consume_improper_spaces (p
, body
);
14877 /* Parse the formal argument list. */
14878 while (*p
&& *p
!= ')')
14880 /* Find the extent of the current argument name. */
14881 const char *arg_start
= p
;
14883 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
14886 if (! *p
|| p
== arg_start
)
14887 dwarf2_macro_malformed_definition_complaint (body
);
14890 /* Make sure argv has room for the new argument. */
14891 if (argc
>= argv_size
)
14894 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
14897 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
14900 p
= consume_improper_spaces (p
, body
);
14902 /* Consume the comma, if present. */
14907 p
= consume_improper_spaces (p
, body
);
14916 /* Perfectly formed definition, no complaints. */
14917 macro_define_function (file
, line
, name
,
14918 argc
, (const char **) argv
,
14920 else if (*p
== '\0')
14922 /* Complain, but do define it. */
14923 dwarf2_macro_malformed_definition_complaint (body
);
14924 macro_define_function (file
, line
, name
,
14925 argc
, (const char **) argv
,
14929 /* Just complain. */
14930 dwarf2_macro_malformed_definition_complaint (body
);
14933 /* Just complain. */
14934 dwarf2_macro_malformed_definition_complaint (body
);
14940 for (i
= 0; i
< argc
; i
++)
14946 dwarf2_macro_malformed_definition_complaint (body
);
14949 /* Skip some bytes from BYTES according to the form given in FORM.
14950 Returns the new pointer. */
14953 skip_form_bytes (bfd
*abfd
, gdb_byte
*bytes
,
14954 enum dwarf_form form
,
14955 unsigned int offset_size
,
14956 struct dwarf2_section_info
*section
)
14958 unsigned int bytes_read
;
14962 case DW_FORM_data1
:
14967 case DW_FORM_data2
:
14971 case DW_FORM_data4
:
14975 case DW_FORM_data8
:
14979 case DW_FORM_string
:
14980 read_direct_string (abfd
, bytes
, &bytes_read
);
14981 bytes
+= bytes_read
;
14984 case DW_FORM_sec_offset
:
14986 bytes
+= offset_size
;
14989 case DW_FORM_block
:
14990 bytes
+= read_unsigned_leb128 (abfd
, bytes
, &bytes_read
);
14991 bytes
+= bytes_read
;
14994 case DW_FORM_block1
:
14995 bytes
+= 1 + read_1_byte (abfd
, bytes
);
14997 case DW_FORM_block2
:
14998 bytes
+= 2 + read_2_bytes (abfd
, bytes
);
15000 case DW_FORM_block4
:
15001 bytes
+= 4 + read_4_bytes (abfd
, bytes
);
15004 case DW_FORM_sdata
:
15005 case DW_FORM_udata
:
15006 bytes
= skip_leb128 (abfd
, bytes
);
15012 complaint (&symfile_complaints
,
15013 _("invalid form 0x%x in `%s'"),
15015 section
->asection
->name
);
15023 /* A helper for dwarf_decode_macros that handles skipping an unknown
15024 opcode. Returns an updated pointer to the macro data buffer; or,
15025 on error, issues a complaint and returns NULL. */
15028 skip_unknown_opcode (unsigned int opcode
,
15029 gdb_byte
**opcode_definitions
,
15032 unsigned int offset_size
,
15033 struct dwarf2_section_info
*section
)
15035 unsigned int bytes_read
, i
;
15039 if (opcode_definitions
[opcode
] == NULL
)
15041 complaint (&symfile_complaints
,
15042 _("unrecognized DW_MACFINO opcode 0x%x"),
15047 defn
= opcode_definitions
[opcode
];
15048 arg
= read_unsigned_leb128 (abfd
, defn
, &bytes_read
);
15049 defn
+= bytes_read
;
15051 for (i
= 0; i
< arg
; ++i
)
15053 mac_ptr
= skip_form_bytes (abfd
, mac_ptr
, defn
[i
], offset_size
, section
);
15054 if (mac_ptr
== NULL
)
15056 /* skip_form_bytes already issued the complaint. */
15064 /* A helper function which parses the header of a macro section.
15065 If the macro section is the extended (for now called "GNU") type,
15066 then this updates *OFFSET_SIZE. Returns a pointer to just after
15067 the header, or issues a complaint and returns NULL on error. */
15070 dwarf_parse_macro_header (gdb_byte
**opcode_definitions
,
15073 unsigned int *offset_size
,
15074 int section_is_gnu
)
15076 memset (opcode_definitions
, 0, 256 * sizeof (gdb_byte
*));
15078 if (section_is_gnu
)
15080 unsigned int version
, flags
;
15082 version
= read_2_bytes (abfd
, mac_ptr
);
15085 complaint (&symfile_complaints
,
15086 _("unrecognized version `%d' in .debug_macro section"),
15092 flags
= read_1_byte (abfd
, mac_ptr
);
15094 *offset_size
= (flags
& 1) ? 8 : 4;
15096 if ((flags
& 2) != 0)
15097 /* We don't need the line table offset. */
15098 mac_ptr
+= *offset_size
;
15100 /* Vendor opcode descriptions. */
15101 if ((flags
& 4) != 0)
15103 unsigned int i
, count
;
15105 count
= read_1_byte (abfd
, mac_ptr
);
15107 for (i
= 0; i
< count
; ++i
)
15109 unsigned int opcode
, bytes_read
;
15112 opcode
= read_1_byte (abfd
, mac_ptr
);
15114 opcode_definitions
[opcode
] = mac_ptr
;
15115 arg
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15116 mac_ptr
+= bytes_read
;
15125 /* A helper for dwarf_decode_macros that handles the GNU extensions,
15126 including DW_GNU_MACINFO_transparent_include. */
15129 dwarf_decode_macro_bytes (bfd
*abfd
, gdb_byte
*mac_ptr
, gdb_byte
*mac_end
,
15130 struct macro_source_file
*current_file
,
15131 struct line_header
*lh
, char *comp_dir
,
15132 struct dwarf2_section_info
*section
,
15133 int section_is_gnu
,
15134 unsigned int offset_size
,
15135 struct objfile
*objfile
)
15137 enum dwarf_macro_record_type macinfo_type
;
15138 int at_commandline
;
15139 gdb_byte
*opcode_definitions
[256];
15141 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
15142 &offset_size
, section_is_gnu
);
15143 if (mac_ptr
== NULL
)
15145 /* We already issued a complaint. */
15149 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
15150 GDB is still reading the definitions from command line. First
15151 DW_MACINFO_start_file will need to be ignored as it was already executed
15152 to create CURRENT_FILE for the main source holding also the command line
15153 definitions. On first met DW_MACINFO_start_file this flag is reset to
15154 normally execute all the remaining DW_MACINFO_start_file macinfos. */
15156 at_commandline
= 1;
15160 /* Do we at least have room for a macinfo type byte? */
15161 if (mac_ptr
>= mac_end
)
15163 dwarf2_macros_too_long_complaint (section
);
15167 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
15170 /* Note that we rely on the fact that the corresponding GNU and
15171 DWARF constants are the same. */
15172 switch (macinfo_type
)
15174 /* A zero macinfo type indicates the end of the macro
15179 case DW_MACRO_GNU_define
:
15180 case DW_MACRO_GNU_undef
:
15181 case DW_MACRO_GNU_define_indirect
:
15182 case DW_MACRO_GNU_undef_indirect
:
15184 unsigned int bytes_read
;
15189 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15190 mac_ptr
+= bytes_read
;
15192 if (macinfo_type
== DW_MACRO_GNU_define
15193 || macinfo_type
== DW_MACRO_GNU_undef
)
15195 body
= read_direct_string (abfd
, mac_ptr
, &bytes_read
);
15196 mac_ptr
+= bytes_read
;
15200 LONGEST str_offset
;
15202 str_offset
= read_offset_1 (abfd
, mac_ptr
, offset_size
);
15203 mac_ptr
+= offset_size
;
15205 body
= read_indirect_string_at_offset (abfd
, str_offset
);
15208 is_define
= (macinfo_type
== DW_MACRO_GNU_define
15209 || macinfo_type
== DW_MACRO_GNU_define_indirect
);
15210 if (! current_file
)
15212 /* DWARF violation as no main source is present. */
15213 complaint (&symfile_complaints
,
15214 _("debug info with no main source gives macro %s "
15216 is_define
? _("definition") : _("undefinition"),
15220 if ((line
== 0 && !at_commandline
)
15221 || (line
!= 0 && at_commandline
))
15222 complaint (&symfile_complaints
,
15223 _("debug info gives %s macro %s with %s line %d: %s"),
15224 at_commandline
? _("command-line") : _("in-file"),
15225 is_define
? _("definition") : _("undefinition"),
15226 line
== 0 ? _("zero") : _("non-zero"), line
, body
);
15229 parse_macro_definition (current_file
, line
, body
);
15232 gdb_assert (macinfo_type
== DW_MACRO_GNU_undef
15233 || macinfo_type
== DW_MACRO_GNU_undef_indirect
);
15234 macro_undef (current_file
, line
, body
);
15239 case DW_MACRO_GNU_start_file
:
15241 unsigned int bytes_read
;
15244 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15245 mac_ptr
+= bytes_read
;
15246 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15247 mac_ptr
+= bytes_read
;
15249 if ((line
== 0 && !at_commandline
)
15250 || (line
!= 0 && at_commandline
))
15251 complaint (&symfile_complaints
,
15252 _("debug info gives source %d included "
15253 "from %s at %s line %d"),
15254 file
, at_commandline
? _("command-line") : _("file"),
15255 line
== 0 ? _("zero") : _("non-zero"), line
);
15257 if (at_commandline
)
15259 /* This DW_MACRO_GNU_start_file was executed in the
15261 at_commandline
= 0;
15264 current_file
= macro_start_file (file
, line
,
15265 current_file
, comp_dir
,
15270 case DW_MACRO_GNU_end_file
:
15271 if (! current_file
)
15272 complaint (&symfile_complaints
,
15273 _("macro debug info has an unmatched "
15274 "`close_file' directive"));
15277 current_file
= current_file
->included_by
;
15278 if (! current_file
)
15280 enum dwarf_macro_record_type next_type
;
15282 /* GCC circa March 2002 doesn't produce the zero
15283 type byte marking the end of the compilation
15284 unit. Complain if it's not there, but exit no
15287 /* Do we at least have room for a macinfo type byte? */
15288 if (mac_ptr
>= mac_end
)
15290 dwarf2_macros_too_long_complaint (section
);
15294 /* We don't increment mac_ptr here, so this is just
15296 next_type
= read_1_byte (abfd
, mac_ptr
);
15297 if (next_type
!= 0)
15298 complaint (&symfile_complaints
,
15299 _("no terminating 0-type entry for "
15300 "macros in `.debug_macinfo' section"));
15307 case DW_MACRO_GNU_transparent_include
:
15311 offset
= read_offset_1 (abfd
, mac_ptr
, offset_size
);
15312 mac_ptr
+= offset_size
;
15314 dwarf_decode_macro_bytes (abfd
,
15315 section
->buffer
+ offset
,
15316 mac_end
, current_file
,
15318 section
, section_is_gnu
,
15319 offset_size
, objfile
);
15323 case DW_MACINFO_vendor_ext
:
15324 if (!section_is_gnu
)
15326 unsigned int bytes_read
;
15329 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15330 mac_ptr
+= bytes_read
;
15331 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
15332 mac_ptr
+= bytes_read
;
15334 /* We don't recognize any vendor extensions. */
15340 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
15341 mac_ptr
, abfd
, offset_size
,
15343 if (mac_ptr
== NULL
)
15347 } while (macinfo_type
!= 0);
15351 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
15352 char *comp_dir
, bfd
*abfd
,
15353 struct dwarf2_cu
*cu
,
15354 struct dwarf2_section_info
*section
,
15355 int section_is_gnu
)
15357 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
15358 gdb_byte
*mac_ptr
, *mac_end
;
15359 struct macro_source_file
*current_file
= 0;
15360 enum dwarf_macro_record_type macinfo_type
;
15361 unsigned int offset_size
= cu
->header
.offset_size
;
15362 gdb_byte
*opcode_definitions
[256];
15364 dwarf2_read_section (objfile
, section
);
15365 if (section
->buffer
== NULL
)
15367 complaint (&symfile_complaints
, _("missing %s section"),
15368 section
->asection
->name
);
15372 /* First pass: Find the name of the base filename.
15373 This filename is needed in order to process all macros whose definition
15374 (or undefinition) comes from the command line. These macros are defined
15375 before the first DW_MACINFO_start_file entry, and yet still need to be
15376 associated to the base file.
15378 To determine the base file name, we scan the macro definitions until we
15379 reach the first DW_MACINFO_start_file entry. We then initialize
15380 CURRENT_FILE accordingly so that any macro definition found before the
15381 first DW_MACINFO_start_file can still be associated to the base file. */
15383 mac_ptr
= section
->buffer
+ offset
;
15384 mac_end
= section
->buffer
+ section
->size
;
15386 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
15387 &offset_size
, section_is_gnu
);
15388 if (mac_ptr
== NULL
)
15390 /* We already issued a complaint. */
15396 /* Do we at least have room for a macinfo type byte? */
15397 if (mac_ptr
>= mac_end
)
15399 /* Complaint is printed during the second pass as GDB will probably
15400 stop the first pass earlier upon finding
15401 DW_MACINFO_start_file. */
15405 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
15408 /* Note that we rely on the fact that the corresponding GNU and
15409 DWARF constants are the same. */
15410 switch (macinfo_type
)
15412 /* A zero macinfo type indicates the end of the macro
15417 case DW_MACRO_GNU_define
:
15418 case DW_MACRO_GNU_undef
:
15419 /* Only skip the data by MAC_PTR. */
15421 unsigned int bytes_read
;
15423 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15424 mac_ptr
+= bytes_read
;
15425 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
15426 mac_ptr
+= bytes_read
;
15430 case DW_MACRO_GNU_start_file
:
15432 unsigned int bytes_read
;
15435 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15436 mac_ptr
+= bytes_read
;
15437 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15438 mac_ptr
+= bytes_read
;
15440 current_file
= macro_start_file (file
, line
, current_file
,
15441 comp_dir
, lh
, objfile
);
15445 case DW_MACRO_GNU_end_file
:
15446 /* No data to skip by MAC_PTR. */
15449 case DW_MACRO_GNU_define_indirect
:
15450 case DW_MACRO_GNU_undef_indirect
:
15452 unsigned int bytes_read
;
15454 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15455 mac_ptr
+= bytes_read
;
15456 mac_ptr
+= offset_size
;
15460 case DW_MACRO_GNU_transparent_include
:
15461 /* Note that, according to the spec, a transparent include
15462 chain cannot call DW_MACRO_GNU_start_file. So, we can just
15463 skip this opcode. */
15464 mac_ptr
+= offset_size
;
15467 case DW_MACINFO_vendor_ext
:
15468 /* Only skip the data by MAC_PTR. */
15469 if (!section_is_gnu
)
15471 unsigned int bytes_read
;
15473 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15474 mac_ptr
+= bytes_read
;
15475 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
15476 mac_ptr
+= bytes_read
;
15481 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
15482 mac_ptr
, abfd
, offset_size
,
15484 if (mac_ptr
== NULL
)
15488 } while (macinfo_type
!= 0 && current_file
== NULL
);
15490 /* Second pass: Process all entries.
15492 Use the AT_COMMAND_LINE flag to determine whether we are still processing
15493 command-line macro definitions/undefinitions. This flag is unset when we
15494 reach the first DW_MACINFO_start_file entry. */
15496 dwarf_decode_macro_bytes (abfd
, section
->buffer
+ offset
, mac_end
,
15497 current_file
, lh
, comp_dir
, section
, section_is_gnu
,
15498 offset_size
, objfile
);
15501 /* Check if the attribute's form is a DW_FORM_block*
15502 if so return true else false. */
15504 attr_form_is_block (struct attribute
*attr
)
15506 return (attr
== NULL
? 0 :
15507 attr
->form
== DW_FORM_block1
15508 || attr
->form
== DW_FORM_block2
15509 || attr
->form
== DW_FORM_block4
15510 || attr
->form
== DW_FORM_block
15511 || attr
->form
== DW_FORM_exprloc
);
15514 /* Return non-zero if ATTR's value is a section offset --- classes
15515 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
15516 You may use DW_UNSND (attr) to retrieve such offsets.
15518 Section 7.5.4, "Attribute Encodings", explains that no attribute
15519 may have a value that belongs to more than one of these classes; it
15520 would be ambiguous if we did, because we use the same forms for all
15523 attr_form_is_section_offset (struct attribute
*attr
)
15525 return (attr
->form
== DW_FORM_data4
15526 || attr
->form
== DW_FORM_data8
15527 || attr
->form
== DW_FORM_sec_offset
);
15531 /* Return non-zero if ATTR's value falls in the 'constant' class, or
15532 zero otherwise. When this function returns true, you can apply
15533 dwarf2_get_attr_constant_value to it.
15535 However, note that for some attributes you must check
15536 attr_form_is_section_offset before using this test. DW_FORM_data4
15537 and DW_FORM_data8 are members of both the constant class, and of
15538 the classes that contain offsets into other debug sections
15539 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
15540 that, if an attribute's can be either a constant or one of the
15541 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
15542 taken as section offsets, not constants. */
15544 attr_form_is_constant (struct attribute
*attr
)
15546 switch (attr
->form
)
15548 case DW_FORM_sdata
:
15549 case DW_FORM_udata
:
15550 case DW_FORM_data1
:
15551 case DW_FORM_data2
:
15552 case DW_FORM_data4
:
15553 case DW_FORM_data8
:
15560 /* A helper function that fills in a dwarf2_loclist_baton. */
15563 fill_in_loclist_baton (struct dwarf2_cu
*cu
,
15564 struct dwarf2_loclist_baton
*baton
,
15565 struct attribute
*attr
)
15567 dwarf2_read_section (dwarf2_per_objfile
->objfile
,
15568 &dwarf2_per_objfile
->loc
);
15570 baton
->per_cu
= cu
->per_cu
;
15571 gdb_assert (baton
->per_cu
);
15572 /* We don't know how long the location list is, but make sure we
15573 don't run off the edge of the section. */
15574 baton
->size
= dwarf2_per_objfile
->loc
.size
- DW_UNSND (attr
);
15575 baton
->data
= dwarf2_per_objfile
->loc
.buffer
+ DW_UNSND (attr
);
15576 baton
->base_address
= cu
->base_address
;
15580 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
15581 struct dwarf2_cu
*cu
)
15583 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
15585 if (attr_form_is_section_offset (attr
)
15586 /* ".debug_loc" may not exist at all, or the offset may be outside
15587 the section. If so, fall through to the complaint in the
15589 && DW_UNSND (attr
) < dwarf2_section_size (objfile
,
15590 &dwarf2_per_objfile
->loc
))
15592 struct dwarf2_loclist_baton
*baton
;
15594 baton
= obstack_alloc (&objfile
->objfile_obstack
,
15595 sizeof (struct dwarf2_loclist_baton
));
15597 fill_in_loclist_baton (cu
, baton
, attr
);
15599 if (cu
->base_known
== 0)
15600 complaint (&symfile_complaints
,
15601 _("Location list used without "
15602 "specifying the CU base address."));
15604 SYMBOL_COMPUTED_OPS (sym
) = &dwarf2_loclist_funcs
;
15605 SYMBOL_LOCATION_BATON (sym
) = baton
;
15609 struct dwarf2_locexpr_baton
*baton
;
15611 baton
= obstack_alloc (&objfile
->objfile_obstack
,
15612 sizeof (struct dwarf2_locexpr_baton
));
15613 baton
->per_cu
= cu
->per_cu
;
15614 gdb_assert (baton
->per_cu
);
15616 if (attr_form_is_block (attr
))
15618 /* Note that we're just copying the block's data pointer
15619 here, not the actual data. We're still pointing into the
15620 info_buffer for SYM's objfile; right now we never release
15621 that buffer, but when we do clean up properly this may
15623 baton
->size
= DW_BLOCK (attr
)->size
;
15624 baton
->data
= DW_BLOCK (attr
)->data
;
15628 dwarf2_invalid_attrib_class_complaint ("location description",
15629 SYMBOL_NATURAL_NAME (sym
));
15633 SYMBOL_COMPUTED_OPS (sym
) = &dwarf2_locexpr_funcs
;
15634 SYMBOL_LOCATION_BATON (sym
) = baton
;
15638 /* Return the OBJFILE associated with the compilation unit CU. If CU
15639 came from a separate debuginfo file, then the master objfile is
15643 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data
*per_cu
)
15645 struct objfile
*objfile
= per_cu
->objfile
;
15647 /* Return the master objfile, so that we can report and look up the
15648 correct file containing this variable. */
15649 if (objfile
->separate_debug_objfile_backlink
)
15650 objfile
= objfile
->separate_debug_objfile_backlink
;
15655 /* Return comp_unit_head for PER_CU, either already available in PER_CU->CU
15656 (CU_HEADERP is unused in such case) or prepare a temporary copy at
15657 CU_HEADERP first. */
15659 static const struct comp_unit_head
*
15660 per_cu_header_read_in (struct comp_unit_head
*cu_headerp
,
15661 struct dwarf2_per_cu_data
*per_cu
)
15663 struct objfile
*objfile
;
15664 struct dwarf2_per_objfile
*per_objfile
;
15665 gdb_byte
*info_ptr
;
15668 return &per_cu
->cu
->header
;
15670 objfile
= per_cu
->objfile
;
15671 per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
15672 info_ptr
= per_objfile
->info
.buffer
+ per_cu
->offset
;
15674 memset (cu_headerp
, 0, sizeof (*cu_headerp
));
15675 read_comp_unit_head (cu_headerp
, info_ptr
, objfile
->obfd
);
15680 /* Return the address size given in the compilation unit header for CU. */
15683 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data
*per_cu
)
15685 struct comp_unit_head cu_header_local
;
15686 const struct comp_unit_head
*cu_headerp
;
15688 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
15690 return cu_headerp
->addr_size
;
15693 /* Return the offset size given in the compilation unit header for CU. */
15696 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data
*per_cu
)
15698 struct comp_unit_head cu_header_local
;
15699 const struct comp_unit_head
*cu_headerp
;
15701 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
15703 return cu_headerp
->offset_size
;
15706 /* See its dwarf2loc.h declaration. */
15709 dwarf2_per_cu_ref_addr_size (struct dwarf2_per_cu_data
*per_cu
)
15711 struct comp_unit_head cu_header_local
;
15712 const struct comp_unit_head
*cu_headerp
;
15714 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
15716 if (cu_headerp
->version
== 2)
15717 return cu_headerp
->addr_size
;
15719 return cu_headerp
->offset_size
;
15722 /* Return the text offset of the CU. The returned offset comes from
15723 this CU's objfile. If this objfile came from a separate debuginfo
15724 file, then the offset may be different from the corresponding
15725 offset in the parent objfile. */
15728 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data
*per_cu
)
15730 struct objfile
*objfile
= per_cu
->objfile
;
15732 return ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
15735 /* Locate the .debug_info compilation unit from CU's objfile which contains
15736 the DIE at OFFSET. Raises an error on failure. */
15738 static struct dwarf2_per_cu_data
*
15739 dwarf2_find_containing_comp_unit (unsigned int offset
,
15740 struct objfile
*objfile
)
15742 struct dwarf2_per_cu_data
*this_cu
;
15746 high
= dwarf2_per_objfile
->n_comp_units
- 1;
15749 int mid
= low
+ (high
- low
) / 2;
15751 if (dwarf2_per_objfile
->all_comp_units
[mid
]->offset
>= offset
)
15756 gdb_assert (low
== high
);
15757 if (dwarf2_per_objfile
->all_comp_units
[low
]->offset
> offset
)
15760 error (_("Dwarf Error: could not find partial DIE containing "
15761 "offset 0x%lx [in module %s]"),
15762 (long) offset
, bfd_get_filename (objfile
->obfd
));
15764 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
<= offset
);
15765 return dwarf2_per_objfile
->all_comp_units
[low
-1];
15769 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
15770 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
15771 && offset
>= this_cu
->offset
+ this_cu
->length
)
15772 error (_("invalid dwarf2 offset %u"), offset
);
15773 gdb_assert (offset
< this_cu
->offset
+ this_cu
->length
);
15778 /* Initialize dwarf2_cu CU, owned by PER_CU. */
15781 init_one_comp_unit (struct dwarf2_cu
*cu
, struct dwarf2_per_cu_data
*per_cu
)
15783 memset (cu
, 0, sizeof (*cu
));
15785 cu
->per_cu
= per_cu
;
15786 cu
->objfile
= per_cu
->objfile
;
15787 obstack_init (&cu
->comp_unit_obstack
);
15790 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
15793 prepare_one_comp_unit (struct dwarf2_cu
*cu
, struct die_info
*comp_unit_die
)
15795 struct attribute
*attr
;
15797 /* Set the language we're debugging. */
15798 attr
= dwarf2_attr (comp_unit_die
, DW_AT_language
, cu
);
15800 set_cu_language (DW_UNSND (attr
), cu
);
15803 cu
->language
= language_minimal
;
15804 cu
->language_defn
= language_def (cu
->language
);
15808 /* Release one cached compilation unit, CU. We unlink it from the tree
15809 of compilation units, but we don't remove it from the read_in_chain;
15810 the caller is responsible for that.
15811 NOTE: DATA is a void * because this function is also used as a
15812 cleanup routine. */
15815 free_heap_comp_unit (void *data
)
15817 struct dwarf2_cu
*cu
= data
;
15819 gdb_assert (cu
->per_cu
!= NULL
);
15820 cu
->per_cu
->cu
= NULL
;
15823 obstack_free (&cu
->comp_unit_obstack
, NULL
);
15828 /* This cleanup function is passed the address of a dwarf2_cu on the stack
15829 when we're finished with it. We can't free the pointer itself, but be
15830 sure to unlink it from the cache. Also release any associated storage
15831 and perform cache maintenance.
15833 Only used during partial symbol parsing. */
15836 free_stack_comp_unit (void *data
)
15838 struct dwarf2_cu
*cu
= data
;
15840 gdb_assert (cu
->per_cu
!= NULL
);
15841 cu
->per_cu
->cu
= NULL
;
15844 obstack_free (&cu
->comp_unit_obstack
, NULL
);
15845 cu
->partial_dies
= NULL
;
15847 /* The previous code only did this if per_cu != NULL.
15848 But that would always succeed, so now we just unconditionally do
15849 the aging. This seems like the wrong place to do such aging,
15850 but cleaning that up is left for later. */
15851 age_cached_comp_units ();
15854 /* Free all cached compilation units. */
15857 free_cached_comp_units (void *data
)
15859 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
15861 per_cu
= dwarf2_per_objfile
->read_in_chain
;
15862 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
15863 while (per_cu
!= NULL
)
15865 struct dwarf2_per_cu_data
*next_cu
;
15867 next_cu
= per_cu
->cu
->read_in_chain
;
15869 free_heap_comp_unit (per_cu
->cu
);
15870 *last_chain
= next_cu
;
15876 /* Increase the age counter on each cached compilation unit, and free
15877 any that are too old. */
15880 age_cached_comp_units (void)
15882 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
15884 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
15885 per_cu
= dwarf2_per_objfile
->read_in_chain
;
15886 while (per_cu
!= NULL
)
15888 per_cu
->cu
->last_used
++;
15889 if (per_cu
->cu
->last_used
<= dwarf2_max_cache_age
)
15890 dwarf2_mark (per_cu
->cu
);
15891 per_cu
= per_cu
->cu
->read_in_chain
;
15894 per_cu
= dwarf2_per_objfile
->read_in_chain
;
15895 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
15896 while (per_cu
!= NULL
)
15898 struct dwarf2_per_cu_data
*next_cu
;
15900 next_cu
= per_cu
->cu
->read_in_chain
;
15902 if (!per_cu
->cu
->mark
)
15904 free_heap_comp_unit (per_cu
->cu
);
15905 *last_chain
= next_cu
;
15908 last_chain
= &per_cu
->cu
->read_in_chain
;
15914 /* Remove a single compilation unit from the cache. */
15917 free_one_cached_comp_unit (void *target_cu
)
15919 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
15921 per_cu
= dwarf2_per_objfile
->read_in_chain
;
15922 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
15923 while (per_cu
!= NULL
)
15925 struct dwarf2_per_cu_data
*next_cu
;
15927 next_cu
= per_cu
->cu
->read_in_chain
;
15929 if (per_cu
->cu
== target_cu
)
15931 free_heap_comp_unit (per_cu
->cu
);
15932 *last_chain
= next_cu
;
15936 last_chain
= &per_cu
->cu
->read_in_chain
;
15942 /* Release all extra memory associated with OBJFILE. */
15945 dwarf2_free_objfile (struct objfile
*objfile
)
15947 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
15949 if (dwarf2_per_objfile
== NULL
)
15952 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
15953 free_cached_comp_units (NULL
);
15955 if (dwarf2_per_objfile
->quick_file_names_table
)
15956 htab_delete (dwarf2_per_objfile
->quick_file_names_table
);
15958 /* Everything else should be on the objfile obstack. */
15961 /* A pair of DIE offset and GDB type pointer. We store these
15962 in a hash table separate from the DIEs, and preserve them
15963 when the DIEs are flushed out of cache. */
15965 struct dwarf2_offset_and_type
15967 unsigned int offset
;
15971 /* Hash function for a dwarf2_offset_and_type. */
15974 offset_and_type_hash (const void *item
)
15976 const struct dwarf2_offset_and_type
*ofs
= item
;
15978 return ofs
->offset
;
15981 /* Equality function for a dwarf2_offset_and_type. */
15984 offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
15986 const struct dwarf2_offset_and_type
*ofs_lhs
= item_lhs
;
15987 const struct dwarf2_offset_and_type
*ofs_rhs
= item_rhs
;
15989 return ofs_lhs
->offset
== ofs_rhs
->offset
;
15992 /* Set the type associated with DIE to TYPE. Save it in CU's hash
15993 table if necessary. For convenience, return TYPE.
15995 The DIEs reading must have careful ordering to:
15996 * Not cause infite loops trying to read in DIEs as a prerequisite for
15997 reading current DIE.
15998 * Not trying to dereference contents of still incompletely read in types
15999 while reading in other DIEs.
16000 * Enable referencing still incompletely read in types just by a pointer to
16001 the type without accessing its fields.
16003 Therefore caller should follow these rules:
16004 * Try to fetch any prerequisite types we may need to build this DIE type
16005 before building the type and calling set_die_type.
16006 * After building type call set_die_type for current DIE as soon as
16007 possible before fetching more types to complete the current type.
16008 * Make the type as complete as possible before fetching more types. */
16010 static struct type
*
16011 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
16013 struct dwarf2_offset_and_type
**slot
, ofs
;
16014 struct objfile
*objfile
= cu
->objfile
;
16015 htab_t
*type_hash_ptr
;
16017 /* For Ada types, make sure that the gnat-specific data is always
16018 initialized (if not already set). There are a few types where
16019 we should not be doing so, because the type-specific area is
16020 already used to hold some other piece of info (eg: TYPE_CODE_FLT
16021 where the type-specific area is used to store the floatformat).
16022 But this is not a problem, because the gnat-specific information
16023 is actually not needed for these types. */
16024 if (need_gnat_info (cu
)
16025 && TYPE_CODE (type
) != TYPE_CODE_FUNC
16026 && TYPE_CODE (type
) != TYPE_CODE_FLT
16027 && !HAVE_GNAT_AUX_INFO (type
))
16028 INIT_GNAT_SPECIFIC (type
);
16030 if (cu
->per_cu
->debug_types_section
)
16031 type_hash_ptr
= &dwarf2_per_objfile
->debug_types_type_hash
;
16033 type_hash_ptr
= &dwarf2_per_objfile
->debug_info_type_hash
;
16035 if (*type_hash_ptr
== NULL
)
16038 = htab_create_alloc_ex (127,
16039 offset_and_type_hash
,
16040 offset_and_type_eq
,
16042 &objfile
->objfile_obstack
,
16043 hashtab_obstack_allocate
,
16044 dummy_obstack_deallocate
);
16047 ofs
.offset
= die
->offset
;
16049 slot
= (struct dwarf2_offset_and_type
**)
16050 htab_find_slot_with_hash (*type_hash_ptr
, &ofs
, ofs
.offset
, INSERT
);
16052 complaint (&symfile_complaints
,
16053 _("A problem internal to GDB: DIE 0x%x has type already set"),
16055 *slot
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (**slot
));
16060 /* Look up the type for the die at DIE_OFFSET in the appropriate type_hash
16061 table, or return NULL if the die does not have a saved type. */
16063 static struct type
*
16064 get_die_type_at_offset (unsigned int offset
,
16065 struct dwarf2_per_cu_data
*per_cu
)
16067 struct dwarf2_offset_and_type
*slot
, ofs
;
16070 if (per_cu
->debug_types_section
)
16071 type_hash
= dwarf2_per_objfile
->debug_types_type_hash
;
16073 type_hash
= dwarf2_per_objfile
->debug_info_type_hash
;
16074 if (type_hash
== NULL
)
16077 ofs
.offset
= offset
;
16078 slot
= htab_find_with_hash (type_hash
, &ofs
, ofs
.offset
);
16085 /* Look up the type for DIE in the appropriate type_hash table,
16086 or return NULL if DIE does not have a saved type. */
16088 static struct type
*
16089 get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16091 return get_die_type_at_offset (die
->offset
, cu
->per_cu
);
16094 /* Add a dependence relationship from CU to REF_PER_CU. */
16097 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
16098 struct dwarf2_per_cu_data
*ref_per_cu
)
16102 if (cu
->dependencies
== NULL
)
16104 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
16105 NULL
, &cu
->comp_unit_obstack
,
16106 hashtab_obstack_allocate
,
16107 dummy_obstack_deallocate
);
16109 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
16111 *slot
= ref_per_cu
;
16114 /* Subroutine of dwarf2_mark to pass to htab_traverse.
16115 Set the mark field in every compilation unit in the
16116 cache that we must keep because we are keeping CU. */
16119 dwarf2_mark_helper (void **slot
, void *data
)
16121 struct dwarf2_per_cu_data
*per_cu
;
16123 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
16125 /* cu->dependencies references may not yet have been ever read if QUIT aborts
16126 reading of the chain. As such dependencies remain valid it is not much
16127 useful to track and undo them during QUIT cleanups. */
16128 if (per_cu
->cu
== NULL
)
16131 if (per_cu
->cu
->mark
)
16133 per_cu
->cu
->mark
= 1;
16135 if (per_cu
->cu
->dependencies
!= NULL
)
16136 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
16141 /* Set the mark field in CU and in every other compilation unit in the
16142 cache that we must keep because we are keeping CU. */
16145 dwarf2_mark (struct dwarf2_cu
*cu
)
16150 if (cu
->dependencies
!= NULL
)
16151 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
16155 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
16159 per_cu
->cu
->mark
= 0;
16160 per_cu
= per_cu
->cu
->read_in_chain
;
16164 /* Trivial hash function for partial_die_info: the hash value of a DIE
16165 is its offset in .debug_info for this objfile. */
16168 partial_die_hash (const void *item
)
16170 const struct partial_die_info
*part_die
= item
;
16172 return part_die
->offset
;
16175 /* Trivial comparison function for partial_die_info structures: two DIEs
16176 are equal if they have the same offset. */
16179 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
16181 const struct partial_die_info
*part_die_lhs
= item_lhs
;
16182 const struct partial_die_info
*part_die_rhs
= item_rhs
;
16184 return part_die_lhs
->offset
== part_die_rhs
->offset
;
16187 static struct cmd_list_element
*set_dwarf2_cmdlist
;
16188 static struct cmd_list_element
*show_dwarf2_cmdlist
;
16191 set_dwarf2_cmd (char *args
, int from_tty
)
16193 help_list (set_dwarf2_cmdlist
, "maintenance set dwarf2 ", -1, gdb_stdout
);
16197 show_dwarf2_cmd (char *args
, int from_tty
)
16199 cmd_show_list (show_dwarf2_cmdlist
, from_tty
, "");
16202 /* If section described by INFO was mmapped, munmap it now. */
16205 munmap_section_buffer (struct dwarf2_section_info
*info
)
16207 if (info
->map_addr
!= NULL
)
16212 res
= munmap (info
->map_addr
, info
->map_len
);
16213 gdb_assert (res
== 0);
16215 /* Without HAVE_MMAP, we should never be here to begin with. */
16216 gdb_assert_not_reached ("no mmap support");
16221 /* munmap debug sections for OBJFILE, if necessary. */
16224 dwarf2_per_objfile_free (struct objfile
*objfile
, void *d
)
16226 struct dwarf2_per_objfile
*data
= d
;
16228 struct dwarf2_section_info
*section
;
16230 /* This is sorted according to the order they're defined in to make it easier
16231 to keep in sync. */
16232 munmap_section_buffer (&data
->info
);
16233 munmap_section_buffer (&data
->abbrev
);
16234 munmap_section_buffer (&data
->line
);
16235 munmap_section_buffer (&data
->loc
);
16236 munmap_section_buffer (&data
->macinfo
);
16237 munmap_section_buffer (&data
->macro
);
16238 munmap_section_buffer (&data
->str
);
16239 munmap_section_buffer (&data
->ranges
);
16240 munmap_section_buffer (&data
->frame
);
16241 munmap_section_buffer (&data
->eh_frame
);
16242 munmap_section_buffer (&data
->gdb_index
);
16245 VEC_iterate (dwarf2_section_info_def
, data
->types
, ix
, section
);
16247 munmap_section_buffer (section
);
16249 VEC_free (dwarf2_section_info_def
, data
->types
);
16253 /* The "save gdb-index" command. */
16255 /* The contents of the hash table we create when building the string
16257 struct strtab_entry
16259 offset_type offset
;
16263 /* Hash function for a strtab_entry.
16265 Function is used only during write_hash_table so no index format backward
16266 compatibility is needed. */
16269 hash_strtab_entry (const void *e
)
16271 const struct strtab_entry
*entry
= e
;
16272 return mapped_index_string_hash (INT_MAX
, entry
->str
);
16275 /* Equality function for a strtab_entry. */
16278 eq_strtab_entry (const void *a
, const void *b
)
16280 const struct strtab_entry
*ea
= a
;
16281 const struct strtab_entry
*eb
= b
;
16282 return !strcmp (ea
->str
, eb
->str
);
16285 /* Create a strtab_entry hash table. */
16288 create_strtab (void)
16290 return htab_create_alloc (100, hash_strtab_entry
, eq_strtab_entry
,
16291 xfree
, xcalloc
, xfree
);
16294 /* Add a string to the constant pool. Return the string's offset in
16298 add_string (htab_t table
, struct obstack
*cpool
, const char *str
)
16301 struct strtab_entry entry
;
16302 struct strtab_entry
*result
;
16305 slot
= htab_find_slot (table
, &entry
, INSERT
);
16310 result
= XNEW (struct strtab_entry
);
16311 result
->offset
= obstack_object_size (cpool
);
16313 obstack_grow_str0 (cpool
, str
);
16316 return result
->offset
;
16319 /* An entry in the symbol table. */
16320 struct symtab_index_entry
16322 /* The name of the symbol. */
16324 /* The offset of the name in the constant pool. */
16325 offset_type index_offset
;
16326 /* A sorted vector of the indices of all the CUs that hold an object
16328 VEC (offset_type
) *cu_indices
;
16331 /* The symbol table. This is a power-of-2-sized hash table. */
16332 struct mapped_symtab
16334 offset_type n_elements
;
16336 struct symtab_index_entry
**data
;
16339 /* Hash function for a symtab_index_entry. */
16342 hash_symtab_entry (const void *e
)
16344 const struct symtab_index_entry
*entry
= e
;
16345 return iterative_hash (VEC_address (offset_type
, entry
->cu_indices
),
16346 sizeof (offset_type
) * VEC_length (offset_type
,
16347 entry
->cu_indices
),
16351 /* Equality function for a symtab_index_entry. */
16354 eq_symtab_entry (const void *a
, const void *b
)
16356 const struct symtab_index_entry
*ea
= a
;
16357 const struct symtab_index_entry
*eb
= b
;
16358 int len
= VEC_length (offset_type
, ea
->cu_indices
);
16359 if (len
!= VEC_length (offset_type
, eb
->cu_indices
))
16361 return !memcmp (VEC_address (offset_type
, ea
->cu_indices
),
16362 VEC_address (offset_type
, eb
->cu_indices
),
16363 sizeof (offset_type
) * len
);
16366 /* Destroy a symtab_index_entry. */
16369 delete_symtab_entry (void *p
)
16371 struct symtab_index_entry
*entry
= p
;
16372 VEC_free (offset_type
, entry
->cu_indices
);
16376 /* Create a hash table holding symtab_index_entry objects. */
16379 create_symbol_hash_table (void)
16381 return htab_create_alloc (100, hash_symtab_entry
, eq_symtab_entry
,
16382 delete_symtab_entry
, xcalloc
, xfree
);
16385 /* Create a new mapped symtab object. */
16387 static struct mapped_symtab
*
16388 create_mapped_symtab (void)
16390 struct mapped_symtab
*symtab
= XNEW (struct mapped_symtab
);
16391 symtab
->n_elements
= 0;
16392 symtab
->size
= 1024;
16393 symtab
->data
= XCNEWVEC (struct symtab_index_entry
*, symtab
->size
);
16397 /* Destroy a mapped_symtab. */
16400 cleanup_mapped_symtab (void *p
)
16402 struct mapped_symtab
*symtab
= p
;
16403 /* The contents of the array are freed when the other hash table is
16405 xfree (symtab
->data
);
16409 /* Find a slot in SYMTAB for the symbol NAME. Returns a pointer to
16412 Function is used only during write_hash_table so no index format backward
16413 compatibility is needed. */
16415 static struct symtab_index_entry
**
16416 find_slot (struct mapped_symtab
*symtab
, const char *name
)
16418 offset_type index
, step
, hash
= mapped_index_string_hash (INT_MAX
, name
);
16420 index
= hash
& (symtab
->size
- 1);
16421 step
= ((hash
* 17) & (symtab
->size
- 1)) | 1;
16425 if (!symtab
->data
[index
] || !strcmp (name
, symtab
->data
[index
]->name
))
16426 return &symtab
->data
[index
];
16427 index
= (index
+ step
) & (symtab
->size
- 1);
16431 /* Expand SYMTAB's hash table. */
16434 hash_expand (struct mapped_symtab
*symtab
)
16436 offset_type old_size
= symtab
->size
;
16438 struct symtab_index_entry
**old_entries
= symtab
->data
;
16441 symtab
->data
= XCNEWVEC (struct symtab_index_entry
*, symtab
->size
);
16443 for (i
= 0; i
< old_size
; ++i
)
16445 if (old_entries
[i
])
16447 struct symtab_index_entry
**slot
= find_slot (symtab
,
16448 old_entries
[i
]->name
);
16449 *slot
= old_entries
[i
];
16453 xfree (old_entries
);
16456 /* Add an entry to SYMTAB. NAME is the name of the symbol. CU_INDEX
16457 is the index of the CU in which the symbol appears. */
16460 add_index_entry (struct mapped_symtab
*symtab
, const char *name
,
16461 offset_type cu_index
)
16463 struct symtab_index_entry
**slot
;
16465 ++symtab
->n_elements
;
16466 if (4 * symtab
->n_elements
/ 3 >= symtab
->size
)
16467 hash_expand (symtab
);
16469 slot
= find_slot (symtab
, name
);
16472 *slot
= XNEW (struct symtab_index_entry
);
16473 (*slot
)->name
= name
;
16474 (*slot
)->cu_indices
= NULL
;
16476 /* Don't push an index twice. Due to how we add entries we only
16477 have to check the last one. */
16478 if (VEC_empty (offset_type
, (*slot
)->cu_indices
)
16479 || VEC_last (offset_type
, (*slot
)->cu_indices
) != cu_index
)
16480 VEC_safe_push (offset_type
, (*slot
)->cu_indices
, cu_index
);
16483 /* Add a vector of indices to the constant pool. */
16486 add_indices_to_cpool (htab_t symbol_hash_table
, struct obstack
*cpool
,
16487 struct symtab_index_entry
*entry
)
16491 slot
= htab_find_slot (symbol_hash_table
, entry
, INSERT
);
16494 offset_type len
= VEC_length (offset_type
, entry
->cu_indices
);
16495 offset_type val
= MAYBE_SWAP (len
);
16500 entry
->index_offset
= obstack_object_size (cpool
);
16502 obstack_grow (cpool
, &val
, sizeof (val
));
16504 VEC_iterate (offset_type
, entry
->cu_indices
, i
, iter
);
16507 val
= MAYBE_SWAP (iter
);
16508 obstack_grow (cpool
, &val
, sizeof (val
));
16513 struct symtab_index_entry
*old_entry
= *slot
;
16514 entry
->index_offset
= old_entry
->index_offset
;
16517 return entry
->index_offset
;
16520 /* Write the mapped hash table SYMTAB to the obstack OUTPUT, with
16521 constant pool entries going into the obstack CPOOL. */
16524 write_hash_table (struct mapped_symtab
*symtab
,
16525 struct obstack
*output
, struct obstack
*cpool
)
16528 htab_t symbol_hash_table
;
16531 symbol_hash_table
= create_symbol_hash_table ();
16532 str_table
= create_strtab ();
16534 /* We add all the index vectors to the constant pool first, to
16535 ensure alignment is ok. */
16536 for (i
= 0; i
< symtab
->size
; ++i
)
16538 if (symtab
->data
[i
])
16539 add_indices_to_cpool (symbol_hash_table
, cpool
, symtab
->data
[i
]);
16542 /* Now write out the hash table. */
16543 for (i
= 0; i
< symtab
->size
; ++i
)
16545 offset_type str_off
, vec_off
;
16547 if (symtab
->data
[i
])
16549 str_off
= add_string (str_table
, cpool
, symtab
->data
[i
]->name
);
16550 vec_off
= symtab
->data
[i
]->index_offset
;
16554 /* While 0 is a valid constant pool index, it is not valid
16555 to have 0 for both offsets. */
16560 str_off
= MAYBE_SWAP (str_off
);
16561 vec_off
= MAYBE_SWAP (vec_off
);
16563 obstack_grow (output
, &str_off
, sizeof (str_off
));
16564 obstack_grow (output
, &vec_off
, sizeof (vec_off
));
16567 htab_delete (str_table
);
16568 htab_delete (symbol_hash_table
);
16571 /* Struct to map psymtab to CU index in the index file. */
16572 struct psymtab_cu_index_map
16574 struct partial_symtab
*psymtab
;
16575 unsigned int cu_index
;
16579 hash_psymtab_cu_index (const void *item
)
16581 const struct psymtab_cu_index_map
*map
= item
;
16583 return htab_hash_pointer (map
->psymtab
);
16587 eq_psymtab_cu_index (const void *item_lhs
, const void *item_rhs
)
16589 const struct psymtab_cu_index_map
*lhs
= item_lhs
;
16590 const struct psymtab_cu_index_map
*rhs
= item_rhs
;
16592 return lhs
->psymtab
== rhs
->psymtab
;
16595 /* Helper struct for building the address table. */
16596 struct addrmap_index_data
16598 struct objfile
*objfile
;
16599 struct obstack
*addr_obstack
;
16600 htab_t cu_index_htab
;
16602 /* Non-zero if the previous_* fields are valid.
16603 We can't write an entry until we see the next entry (since it is only then
16604 that we know the end of the entry). */
16605 int previous_valid
;
16606 /* Index of the CU in the table of all CUs in the index file. */
16607 unsigned int previous_cu_index
;
16608 /* Start address of the CU. */
16609 CORE_ADDR previous_cu_start
;
16612 /* Write an address entry to OBSTACK. */
16615 add_address_entry (struct objfile
*objfile
, struct obstack
*obstack
,
16616 CORE_ADDR start
, CORE_ADDR end
, unsigned int cu_index
)
16618 offset_type cu_index_to_write
;
16620 CORE_ADDR baseaddr
;
16622 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
16624 store_unsigned_integer (addr
, 8, BFD_ENDIAN_LITTLE
, start
- baseaddr
);
16625 obstack_grow (obstack
, addr
, 8);
16626 store_unsigned_integer (addr
, 8, BFD_ENDIAN_LITTLE
, end
- baseaddr
);
16627 obstack_grow (obstack
, addr
, 8);
16628 cu_index_to_write
= MAYBE_SWAP (cu_index
);
16629 obstack_grow (obstack
, &cu_index_to_write
, sizeof (offset_type
));
16632 /* Worker function for traversing an addrmap to build the address table. */
16635 add_address_entry_worker (void *datap
, CORE_ADDR start_addr
, void *obj
)
16637 struct addrmap_index_data
*data
= datap
;
16638 struct partial_symtab
*pst
= obj
;
16639 offset_type cu_index
;
16642 if (data
->previous_valid
)
16643 add_address_entry (data
->objfile
, data
->addr_obstack
,
16644 data
->previous_cu_start
, start_addr
,
16645 data
->previous_cu_index
);
16647 data
->previous_cu_start
= start_addr
;
16650 struct psymtab_cu_index_map find_map
, *map
;
16651 find_map
.psymtab
= pst
;
16652 map
= htab_find (data
->cu_index_htab
, &find_map
);
16653 gdb_assert (map
!= NULL
);
16654 data
->previous_cu_index
= map
->cu_index
;
16655 data
->previous_valid
= 1;
16658 data
->previous_valid
= 0;
16663 /* Write OBJFILE's address map to OBSTACK.
16664 CU_INDEX_HTAB is used to map addrmap entries to their CU indices
16665 in the index file. */
16668 write_address_map (struct objfile
*objfile
, struct obstack
*obstack
,
16669 htab_t cu_index_htab
)
16671 struct addrmap_index_data addrmap_index_data
;
16673 /* When writing the address table, we have to cope with the fact that
16674 the addrmap iterator only provides the start of a region; we have to
16675 wait until the next invocation to get the start of the next region. */
16677 addrmap_index_data
.objfile
= objfile
;
16678 addrmap_index_data
.addr_obstack
= obstack
;
16679 addrmap_index_data
.cu_index_htab
= cu_index_htab
;
16680 addrmap_index_data
.previous_valid
= 0;
16682 addrmap_foreach (objfile
->psymtabs_addrmap
, add_address_entry_worker
,
16683 &addrmap_index_data
);
16685 /* It's highly unlikely the last entry (end address = 0xff...ff)
16686 is valid, but we should still handle it.
16687 The end address is recorded as the start of the next region, but that
16688 doesn't work here. To cope we pass 0xff...ff, this is a rare situation
16690 if (addrmap_index_data
.previous_valid
)
16691 add_address_entry (objfile
, obstack
,
16692 addrmap_index_data
.previous_cu_start
, (CORE_ADDR
) -1,
16693 addrmap_index_data
.previous_cu_index
);
16696 /* Add a list of partial symbols to SYMTAB. */
16699 write_psymbols (struct mapped_symtab
*symtab
,
16701 struct partial_symbol
**psymp
,
16703 offset_type cu_index
,
16706 for (; count
-- > 0; ++psymp
)
16708 void **slot
, *lookup
;
16710 if (SYMBOL_LANGUAGE (*psymp
) == language_ada
)
16711 error (_("Ada is not currently supported by the index"));
16713 /* We only want to add a given psymbol once. However, we also
16714 want to account for whether it is global or static. So, we
16715 may add it twice, using slightly different values. */
16718 uintptr_t val
= 1 | (uintptr_t) *psymp
;
16720 lookup
= (void *) val
;
16725 /* Only add a given psymbol once. */
16726 slot
= htab_find_slot (psyms_seen
, lookup
, INSERT
);
16730 add_index_entry (symtab
, SYMBOL_SEARCH_NAME (*psymp
), cu_index
);
16735 /* Write the contents of an ("unfinished") obstack to FILE. Throw an
16736 exception if there is an error. */
16739 write_obstack (FILE *file
, struct obstack
*obstack
)
16741 if (fwrite (obstack_base (obstack
), 1, obstack_object_size (obstack
),
16743 != obstack_object_size (obstack
))
16744 error (_("couldn't data write to file"));
16747 /* Unlink a file if the argument is not NULL. */
16750 unlink_if_set (void *p
)
16752 char **filename
= p
;
16754 unlink (*filename
);
16757 /* A helper struct used when iterating over debug_types. */
16758 struct signatured_type_index_data
16760 struct objfile
*objfile
;
16761 struct mapped_symtab
*symtab
;
16762 struct obstack
*types_list
;
16767 /* A helper function that writes a single signatured_type to an
16771 write_one_signatured_type (void **slot
, void *d
)
16773 struct signatured_type_index_data
*info
= d
;
16774 struct signatured_type
*entry
= (struct signatured_type
*) *slot
;
16775 struct dwarf2_per_cu_data
*per_cu
= &entry
->per_cu
;
16776 struct partial_symtab
*psymtab
= per_cu
->v
.psymtab
;
16779 write_psymbols (info
->symtab
,
16781 info
->objfile
->global_psymbols
.list
16782 + psymtab
->globals_offset
,
16783 psymtab
->n_global_syms
, info
->cu_index
,
16785 write_psymbols (info
->symtab
,
16787 info
->objfile
->static_psymbols
.list
16788 + psymtab
->statics_offset
,
16789 psymtab
->n_static_syms
, info
->cu_index
,
16792 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, entry
->per_cu
.offset
);
16793 obstack_grow (info
->types_list
, val
, 8);
16794 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, entry
->type_offset
);
16795 obstack_grow (info
->types_list
, val
, 8);
16796 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, entry
->signature
);
16797 obstack_grow (info
->types_list
, val
, 8);
16804 /* Create an index file for OBJFILE in the directory DIR. */
16807 write_psymtabs_to_index (struct objfile
*objfile
, const char *dir
)
16809 struct cleanup
*cleanup
;
16810 char *filename
, *cleanup_filename
;
16811 struct obstack contents
, addr_obstack
, constant_pool
, symtab_obstack
;
16812 struct obstack cu_list
, types_cu_list
;
16815 struct mapped_symtab
*symtab
;
16816 offset_type val
, size_of_contents
, total_len
;
16820 htab_t cu_index_htab
;
16821 struct psymtab_cu_index_map
*psymtab_cu_index_map
;
16823 if (!objfile
->psymtabs
|| !objfile
->psymtabs_addrmap
)
16826 if (dwarf2_per_objfile
->using_index
)
16827 error (_("Cannot use an index to create the index"));
16829 if (VEC_length (dwarf2_section_info_def
, dwarf2_per_objfile
->types
) > 1)
16830 error (_("Cannot make an index when the file has multiple .debug_types sections"));
16832 if (stat (objfile
->name
, &st
) < 0)
16833 perror_with_name (objfile
->name
);
16835 filename
= concat (dir
, SLASH_STRING
, lbasename (objfile
->name
),
16836 INDEX_SUFFIX
, (char *) NULL
);
16837 cleanup
= make_cleanup (xfree
, filename
);
16839 out_file
= fopen (filename
, "wb");
16841 error (_("Can't open `%s' for writing"), filename
);
16843 cleanup_filename
= filename
;
16844 make_cleanup (unlink_if_set
, &cleanup_filename
);
16846 symtab
= create_mapped_symtab ();
16847 make_cleanup (cleanup_mapped_symtab
, symtab
);
16849 obstack_init (&addr_obstack
);
16850 make_cleanup_obstack_free (&addr_obstack
);
16852 obstack_init (&cu_list
);
16853 make_cleanup_obstack_free (&cu_list
);
16855 obstack_init (&types_cu_list
);
16856 make_cleanup_obstack_free (&types_cu_list
);
16858 psyms_seen
= htab_create_alloc (100, htab_hash_pointer
, htab_eq_pointer
,
16859 NULL
, xcalloc
, xfree
);
16860 make_cleanup_htab_delete (psyms_seen
);
16862 /* While we're scanning CU's create a table that maps a psymtab pointer
16863 (which is what addrmap records) to its index (which is what is recorded
16864 in the index file). This will later be needed to write the address
16866 cu_index_htab
= htab_create_alloc (100,
16867 hash_psymtab_cu_index
,
16868 eq_psymtab_cu_index
,
16869 NULL
, xcalloc
, xfree
);
16870 make_cleanup_htab_delete (cu_index_htab
);
16871 psymtab_cu_index_map
= (struct psymtab_cu_index_map
*)
16872 xmalloc (sizeof (struct psymtab_cu_index_map
)
16873 * dwarf2_per_objfile
->n_comp_units
);
16874 make_cleanup (xfree
, psymtab_cu_index_map
);
16876 /* The CU list is already sorted, so we don't need to do additional
16877 work here. Also, the debug_types entries do not appear in
16878 all_comp_units, but only in their own hash table. */
16879 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
16881 struct dwarf2_per_cu_data
*per_cu
16882 = dwarf2_per_objfile
->all_comp_units
[i
];
16883 struct partial_symtab
*psymtab
= per_cu
->v
.psymtab
;
16885 struct psymtab_cu_index_map
*map
;
16888 write_psymbols (symtab
,
16890 objfile
->global_psymbols
.list
+ psymtab
->globals_offset
,
16891 psymtab
->n_global_syms
, i
,
16893 write_psymbols (symtab
,
16895 objfile
->static_psymbols
.list
+ psymtab
->statics_offset
,
16896 psymtab
->n_static_syms
, i
,
16899 map
= &psymtab_cu_index_map
[i
];
16900 map
->psymtab
= psymtab
;
16902 slot
= htab_find_slot (cu_index_htab
, map
, INSERT
);
16903 gdb_assert (slot
!= NULL
);
16904 gdb_assert (*slot
== NULL
);
16907 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, per_cu
->offset
);
16908 obstack_grow (&cu_list
, val
, 8);
16909 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, per_cu
->length
);
16910 obstack_grow (&cu_list
, val
, 8);
16913 /* Dump the address map. */
16914 write_address_map (objfile
, &addr_obstack
, cu_index_htab
);
16916 /* Write out the .debug_type entries, if any. */
16917 if (dwarf2_per_objfile
->signatured_types
)
16919 struct signatured_type_index_data sig_data
;
16921 sig_data
.objfile
= objfile
;
16922 sig_data
.symtab
= symtab
;
16923 sig_data
.types_list
= &types_cu_list
;
16924 sig_data
.psyms_seen
= psyms_seen
;
16925 sig_data
.cu_index
= dwarf2_per_objfile
->n_comp_units
;
16926 htab_traverse_noresize (dwarf2_per_objfile
->signatured_types
,
16927 write_one_signatured_type
, &sig_data
);
16930 obstack_init (&constant_pool
);
16931 make_cleanup_obstack_free (&constant_pool
);
16932 obstack_init (&symtab_obstack
);
16933 make_cleanup_obstack_free (&symtab_obstack
);
16934 write_hash_table (symtab
, &symtab_obstack
, &constant_pool
);
16936 obstack_init (&contents
);
16937 make_cleanup_obstack_free (&contents
);
16938 size_of_contents
= 6 * sizeof (offset_type
);
16939 total_len
= size_of_contents
;
16941 /* The version number. */
16942 val
= MAYBE_SWAP (5);
16943 obstack_grow (&contents
, &val
, sizeof (val
));
16945 /* The offset of the CU list from the start of the file. */
16946 val
= MAYBE_SWAP (total_len
);
16947 obstack_grow (&contents
, &val
, sizeof (val
));
16948 total_len
+= obstack_object_size (&cu_list
);
16950 /* The offset of the types CU list from the start of the file. */
16951 val
= MAYBE_SWAP (total_len
);
16952 obstack_grow (&contents
, &val
, sizeof (val
));
16953 total_len
+= obstack_object_size (&types_cu_list
);
16955 /* The offset of the address table from the start of the file. */
16956 val
= MAYBE_SWAP (total_len
);
16957 obstack_grow (&contents
, &val
, sizeof (val
));
16958 total_len
+= obstack_object_size (&addr_obstack
);
16960 /* The offset of the symbol table from the start of the file. */
16961 val
= MAYBE_SWAP (total_len
);
16962 obstack_grow (&contents
, &val
, sizeof (val
));
16963 total_len
+= obstack_object_size (&symtab_obstack
);
16965 /* The offset of the constant pool from the start of the file. */
16966 val
= MAYBE_SWAP (total_len
);
16967 obstack_grow (&contents
, &val
, sizeof (val
));
16968 total_len
+= obstack_object_size (&constant_pool
);
16970 gdb_assert (obstack_object_size (&contents
) == size_of_contents
);
16972 write_obstack (out_file
, &contents
);
16973 write_obstack (out_file
, &cu_list
);
16974 write_obstack (out_file
, &types_cu_list
);
16975 write_obstack (out_file
, &addr_obstack
);
16976 write_obstack (out_file
, &symtab_obstack
);
16977 write_obstack (out_file
, &constant_pool
);
16981 /* We want to keep the file, so we set cleanup_filename to NULL
16982 here. See unlink_if_set. */
16983 cleanup_filename
= NULL
;
16985 do_cleanups (cleanup
);
16988 /* Implementation of the `save gdb-index' command.
16990 Note that the file format used by this command is documented in the
16991 GDB manual. Any changes here must be documented there. */
16994 save_gdb_index_command (char *arg
, int from_tty
)
16996 struct objfile
*objfile
;
16999 error (_("usage: save gdb-index DIRECTORY"));
17001 ALL_OBJFILES (objfile
)
17005 /* If the objfile does not correspond to an actual file, skip it. */
17006 if (stat (objfile
->name
, &st
) < 0)
17009 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
17010 if (dwarf2_per_objfile
)
17012 volatile struct gdb_exception except
;
17014 TRY_CATCH (except
, RETURN_MASK_ERROR
)
17016 write_psymtabs_to_index (objfile
, arg
);
17018 if (except
.reason
< 0)
17019 exception_fprintf (gdb_stderr
, except
,
17020 _("Error while writing index for `%s': "),
17028 int dwarf2_always_disassemble
;
17031 show_dwarf2_always_disassemble (struct ui_file
*file
, int from_tty
,
17032 struct cmd_list_element
*c
, const char *value
)
17034 fprintf_filtered (file
,
17035 _("Whether to always disassemble "
17036 "DWARF expressions is %s.\n"),
17041 show_check_physname (struct ui_file
*file
, int from_tty
,
17042 struct cmd_list_element
*c
, const char *value
)
17044 fprintf_filtered (file
,
17045 _("Whether to check \"physname\" is %s.\n"),
17049 void _initialize_dwarf2_read (void);
17052 _initialize_dwarf2_read (void)
17054 struct cmd_list_element
*c
;
17056 dwarf2_objfile_data_key
17057 = register_objfile_data_with_cleanup (NULL
, dwarf2_per_objfile_free
);
17059 add_prefix_cmd ("dwarf2", class_maintenance
, set_dwarf2_cmd
, _("\
17060 Set DWARF 2 specific variables.\n\
17061 Configure DWARF 2 variables such as the cache size"),
17062 &set_dwarf2_cmdlist
, "maintenance set dwarf2 ",
17063 0/*allow-unknown*/, &maintenance_set_cmdlist
);
17065 add_prefix_cmd ("dwarf2", class_maintenance
, show_dwarf2_cmd
, _("\
17066 Show DWARF 2 specific variables\n\
17067 Show DWARF 2 variables such as the cache size"),
17068 &show_dwarf2_cmdlist
, "maintenance show dwarf2 ",
17069 0/*allow-unknown*/, &maintenance_show_cmdlist
);
17071 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
17072 &dwarf2_max_cache_age
, _("\
17073 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
17074 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
17075 A higher limit means that cached compilation units will be stored\n\
17076 in memory longer, and more total memory will be used. Zero disables\n\
17077 caching, which can slow down startup."),
17079 show_dwarf2_max_cache_age
,
17080 &set_dwarf2_cmdlist
,
17081 &show_dwarf2_cmdlist
);
17083 add_setshow_boolean_cmd ("always-disassemble", class_obscure
,
17084 &dwarf2_always_disassemble
, _("\
17085 Set whether `info address' always disassembles DWARF expressions."), _("\
17086 Show whether `info address' always disassembles DWARF expressions."), _("\
17087 When enabled, DWARF expressions are always printed in an assembly-like\n\
17088 syntax. When disabled, expressions will be printed in a more\n\
17089 conversational style, when possible."),
17091 show_dwarf2_always_disassemble
,
17092 &set_dwarf2_cmdlist
,
17093 &show_dwarf2_cmdlist
);
17095 add_setshow_zinteger_cmd ("dwarf2-die", no_class
, &dwarf2_die_debug
, _("\
17096 Set debugging of the dwarf2 DIE reader."), _("\
17097 Show debugging of the dwarf2 DIE reader."), _("\
17098 When enabled (non-zero), DIEs are dumped after they are read in.\n\
17099 The value is the maximum depth to print."),
17102 &setdebuglist
, &showdebuglist
);
17104 add_setshow_boolean_cmd ("check-physname", no_class
, &check_physname
, _("\
17105 Set cross-checking of \"physname\" code against demangler."), _("\
17106 Show cross-checking of \"physname\" code against demangler."), _("\
17107 When enabled, GDB's internal \"physname\" code is checked against\n\
17109 NULL
, show_check_physname
,
17110 &setdebuglist
, &showdebuglist
);
17112 c
= add_cmd ("gdb-index", class_files
, save_gdb_index_command
,
17114 Save a gdb-index file.\n\
17115 Usage: save gdb-index DIRECTORY"),
17117 set_cmd_completer (c
, filename_completer
);