1 /* DWARF 2 debugging format support for GDB.
3 Copyright (C) 1994-2018 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. */
40 #include "gdb-demangle.h"
41 #include "expression.h"
42 #include "filenames.h" /* for DOSish file names */
45 #include "complaints.h"
47 #include "dwarf2expr.h"
48 #include "dwarf2loc.h"
49 #include "cp-support.h"
55 #include "typeprint.h"
58 #include "completer.h"
63 #include "gdbcore.h" /* for gnutarget */
64 #include "gdb/gdb-index.h"
69 #include "filestuff.h"
71 #include "namespace.h"
72 #include "common/gdb_unlinker.h"
73 #include "common/function-view.h"
74 #include "common/gdb_optional.h"
75 #include "common/underlying.h"
76 #include "common/byte-vector.h"
77 #include "common/hash_enum.h"
78 #include "filename-seen-cache.h"
81 #include <sys/types.h>
83 #include <unordered_set>
84 #include <unordered_map>
88 #include <forward_list>
90 typedef struct symbol
*symbolp
;
93 /* When == 1, print basic high level tracing messages.
94 When > 1, be more verbose.
95 This is in contrast to the low level DIE reading of dwarf_die_debug. */
96 static unsigned int dwarf_read_debug
= 0;
98 /* When non-zero, dump DIEs after they are read in. */
99 static unsigned int dwarf_die_debug
= 0;
101 /* When non-zero, dump line number entries as they are read in. */
102 static unsigned int dwarf_line_debug
= 0;
104 /* When non-zero, cross-check physname against demangler. */
105 static int check_physname
= 0;
107 /* When non-zero, do not reject deprecated .gdb_index sections. */
108 static int use_deprecated_index_sections
= 0;
110 static const struct objfile_data
*dwarf2_objfile_data_key
;
112 /* The "aclass" indices for various kinds of computed DWARF symbols. */
114 static int dwarf2_locexpr_index
;
115 static int dwarf2_loclist_index
;
116 static int dwarf2_locexpr_block_index
;
117 static int dwarf2_loclist_block_index
;
119 /* A descriptor for dwarf sections.
121 S.ASECTION, SIZE are typically initialized when the objfile is first
122 scanned. BUFFER, READIN are filled in later when the section is read.
123 If the section contained compressed data then SIZE is updated to record
124 the uncompressed size of the section.
126 DWP file format V2 introduces a wrinkle that is easiest to handle by
127 creating the concept of virtual sections contained within a real section.
128 In DWP V2 the sections of the input DWO files are concatenated together
129 into one section, but section offsets are kept relative to the original
131 If this is a virtual dwp-v2 section, S.CONTAINING_SECTION is a backlink to
132 the real section this "virtual" section is contained in, and BUFFER,SIZE
133 describe the virtual section. */
135 struct dwarf2_section_info
139 /* If this is a real section, the bfd section. */
141 /* If this is a virtual section, pointer to the containing ("real")
143 struct dwarf2_section_info
*containing_section
;
145 /* Pointer to section data, only valid if readin. */
146 const gdb_byte
*buffer
;
147 /* The size of the section, real or virtual. */
149 /* If this is a virtual section, the offset in the real section.
150 Only valid if is_virtual. */
151 bfd_size_type virtual_offset
;
152 /* True if we have tried to read this section. */
154 /* True if this is a virtual section, False otherwise.
155 This specifies which of s.section and s.containing_section to use. */
159 typedef struct dwarf2_section_info dwarf2_section_info_def
;
160 DEF_VEC_O (dwarf2_section_info_def
);
162 /* All offsets in the index are of this type. It must be
163 architecture-independent. */
164 typedef uint32_t offset_type
;
166 DEF_VEC_I (offset_type
);
168 /* Ensure only legit values are used. */
169 #define DW2_GDB_INDEX_SYMBOL_STATIC_SET_VALUE(cu_index, value) \
171 gdb_assert ((unsigned int) (value) <= 1); \
172 GDB_INDEX_SYMBOL_STATIC_SET_VALUE((cu_index), (value)); \
175 /* Ensure only legit values are used. */
176 #define DW2_GDB_INDEX_SYMBOL_KIND_SET_VALUE(cu_index, value) \
178 gdb_assert ((value) >= GDB_INDEX_SYMBOL_KIND_TYPE \
179 && (value) <= GDB_INDEX_SYMBOL_KIND_OTHER); \
180 GDB_INDEX_SYMBOL_KIND_SET_VALUE((cu_index), (value)); \
183 /* Ensure we don't use more than the alloted nuber of bits for the CU. */
184 #define DW2_GDB_INDEX_CU_SET_VALUE(cu_index, value) \
186 gdb_assert (((value) & ~GDB_INDEX_CU_MASK) == 0); \
187 GDB_INDEX_CU_SET_VALUE((cu_index), (value)); \
192 /* Convert VALUE between big- and little-endian. */
195 byte_swap (offset_type value
)
199 result
= (value
& 0xff) << 24;
200 result
|= (value
& 0xff00) << 8;
201 result
|= (value
& 0xff0000) >> 8;
202 result
|= (value
& 0xff000000) >> 24;
206 #define MAYBE_SWAP(V) byte_swap (V)
209 #define MAYBE_SWAP(V) static_cast<offset_type> (V)
210 #endif /* WORDS_BIGENDIAN */
212 /* An index into a (C++) symbol name component in a symbol name as
213 recorded in the mapped_index's symbol table. For each C++ symbol
214 in the symbol table, we record one entry for the start of each
215 component in the symbol in a table of name components, and then
216 sort the table, in order to be able to binary search symbol names,
217 ignoring leading namespaces, both completion and regular look up.
218 For example, for symbol "A::B::C", we'll have an entry that points
219 to "A::B::C", another that points to "B::C", and another for "C".
220 Note that function symbols in GDB index have no parameter
221 information, just the function/method names. You can convert a
222 name_component to a "const char *" using the
223 'mapped_index::symbol_name_at(offset_type)' method. */
225 struct name_component
227 /* Offset in the symbol name where the component starts. Stored as
228 a (32-bit) offset instead of a pointer to save memory and improve
229 locality on 64-bit architectures. */
230 offset_type name_offset
;
232 /* The symbol's index in the symbol and constant pool tables of a
237 /* Base class containing bits shared by both .gdb_index and
238 .debug_name indexes. */
240 struct mapped_index_base
242 /* The name_component table (a sorted vector). See name_component's
243 description above. */
244 std::vector
<name_component
> name_components
;
246 /* How NAME_COMPONENTS is sorted. */
247 enum case_sensitivity name_components_casing
;
249 /* Return the number of names in the symbol table. */
250 virtual size_t symbol_name_count () const = 0;
252 /* Get the name of the symbol at IDX in the symbol table. */
253 virtual const char *symbol_name_at (offset_type idx
) const = 0;
255 /* Return whether the name at IDX in the symbol table should be
257 virtual bool symbol_name_slot_invalid (offset_type idx
) const
262 /* Build the symbol name component sorted vector, if we haven't
264 void build_name_components ();
266 /* Returns the lower (inclusive) and upper (exclusive) bounds of the
267 possible matches for LN_NO_PARAMS in the name component
269 std::pair
<std::vector
<name_component
>::const_iterator
,
270 std::vector
<name_component
>::const_iterator
>
271 find_name_components_bounds (const lookup_name_info
&ln_no_params
) const;
273 /* Prevent deleting/destroying via a base class pointer. */
275 ~mapped_index_base() = default;
278 /* A description of the mapped index. The file format is described in
279 a comment by the code that writes the index. */
280 struct mapped_index final
: public mapped_index_base
282 /* A slot/bucket in the symbol table hash. */
283 struct symbol_table_slot
285 const offset_type name
;
286 const offset_type vec
;
289 /* Index data format version. */
292 /* The total length of the buffer. */
295 /* The address table data. */
296 gdb::array_view
<const gdb_byte
> address_table
;
298 /* The symbol table, implemented as a hash table. */
299 gdb::array_view
<symbol_table_slot
> symbol_table
;
301 /* A pointer to the constant pool. */
302 const char *constant_pool
;
304 bool symbol_name_slot_invalid (offset_type idx
) const override
306 const auto &bucket
= this->symbol_table
[idx
];
307 return bucket
.name
== 0 && bucket
.vec
;
310 /* Convenience method to get at the name of the symbol at IDX in the
312 const char *symbol_name_at (offset_type idx
) const override
313 { return this->constant_pool
+ MAYBE_SWAP (this->symbol_table
[idx
].name
); }
315 size_t symbol_name_count () const override
316 { return this->symbol_table
.size (); }
319 /* A description of the mapped .debug_names.
320 Uninitialized map has CU_COUNT 0. */
321 struct mapped_debug_names final
: public mapped_index_base
323 mapped_debug_names (struct dwarf2_per_objfile
*dwarf2_per_objfile_
)
324 : dwarf2_per_objfile (dwarf2_per_objfile_
)
327 struct dwarf2_per_objfile
*dwarf2_per_objfile
;
328 bfd_endian dwarf5_byte_order
;
329 bool dwarf5_is_dwarf64
;
330 bool augmentation_is_gdb
;
332 uint32_t cu_count
= 0;
333 uint32_t tu_count
, bucket_count
, name_count
;
334 const gdb_byte
*cu_table_reordered
, *tu_table_reordered
;
335 const uint32_t *bucket_table_reordered
, *hash_table_reordered
;
336 const gdb_byte
*name_table_string_offs_reordered
;
337 const gdb_byte
*name_table_entry_offs_reordered
;
338 const gdb_byte
*entry_pool
;
345 /* Attribute name DW_IDX_*. */
348 /* Attribute form DW_FORM_*. */
351 /* Value if FORM is DW_FORM_implicit_const. */
352 LONGEST implicit_const
;
354 std::vector
<attr
> attr_vec
;
357 std::unordered_map
<ULONGEST
, index_val
> abbrev_map
;
359 const char *namei_to_name (uint32_t namei
) const;
361 /* Implementation of the mapped_index_base virtual interface, for
362 the name_components cache. */
364 const char *symbol_name_at (offset_type idx
) const override
365 { return namei_to_name (idx
); }
367 size_t symbol_name_count () const override
368 { return this->name_count
; }
371 typedef struct dwarf2_per_cu_data
*dwarf2_per_cu_ptr
;
372 DEF_VEC_P (dwarf2_per_cu_ptr
);
376 int nr_uniq_abbrev_tables
;
378 int nr_symtab_sharers
;
379 int nr_stmt_less_type_units
;
380 int nr_all_type_units_reallocs
;
383 /* Collection of data recorded per objfile.
384 This hangs off of dwarf2_objfile_data_key. */
386 struct dwarf2_per_objfile
388 /* Construct a dwarf2_per_objfile for OBJFILE. NAMES points to the
389 dwarf2 section names, or is NULL if the standard ELF names are
391 dwarf2_per_objfile (struct objfile
*objfile
,
392 const dwarf2_debug_sections
*names
);
394 ~dwarf2_per_objfile ();
396 DISABLE_COPY_AND_ASSIGN (dwarf2_per_objfile
);
398 /* Free all cached compilation units. */
399 void free_cached_comp_units ();
401 /* This function is mapped across the sections and remembers the
402 offset and size of each of the debugging sections we are
404 void locate_sections (bfd
*abfd
, asection
*sectp
,
405 const dwarf2_debug_sections
&names
);
408 dwarf2_section_info info
{};
409 dwarf2_section_info abbrev
{};
410 dwarf2_section_info line
{};
411 dwarf2_section_info loc
{};
412 dwarf2_section_info loclists
{};
413 dwarf2_section_info macinfo
{};
414 dwarf2_section_info macro
{};
415 dwarf2_section_info str
{};
416 dwarf2_section_info line_str
{};
417 dwarf2_section_info ranges
{};
418 dwarf2_section_info rnglists
{};
419 dwarf2_section_info addr
{};
420 dwarf2_section_info frame
{};
421 dwarf2_section_info eh_frame
{};
422 dwarf2_section_info gdb_index
{};
423 dwarf2_section_info debug_names
{};
424 dwarf2_section_info debug_aranges
{};
426 VEC (dwarf2_section_info_def
) *types
= NULL
;
429 struct objfile
*objfile
= NULL
;
431 /* Table of all the compilation units. This is used to locate
432 the target compilation unit of a particular reference. */
433 struct dwarf2_per_cu_data
**all_comp_units
= NULL
;
435 /* The number of compilation units in ALL_COMP_UNITS. */
436 int n_comp_units
= 0;
438 /* The number of .debug_types-related CUs. */
439 int n_type_units
= 0;
441 /* The number of elements allocated in all_type_units.
442 If there are skeleton-less TUs, we add them to all_type_units lazily. */
443 int n_allocated_type_units
= 0;
445 /* The .debug_types-related CUs (TUs).
446 This is stored in malloc space because we may realloc it. */
447 struct signatured_type
**all_type_units
= NULL
;
449 /* Table of struct type_unit_group objects.
450 The hash key is the DW_AT_stmt_list value. */
451 htab_t type_unit_groups
{};
453 /* A table mapping .debug_types signatures to its signatured_type entry.
454 This is NULL if the .debug_types section hasn't been read in yet. */
455 htab_t signatured_types
{};
457 /* Type unit statistics, to see how well the scaling improvements
459 struct tu_stats tu_stats
{};
461 /* A chain of compilation units that are currently read in, so that
462 they can be freed later. */
463 dwarf2_per_cu_data
*read_in_chain
= NULL
;
465 /* A table mapping DW_AT_dwo_name values to struct dwo_file objects.
466 This is NULL if the table hasn't been allocated yet. */
469 /* True if we've checked for whether there is a DWP file. */
470 bool dwp_checked
= false;
472 /* The DWP file if there is one, or NULL. */
473 struct dwp_file
*dwp_file
= NULL
;
475 /* The shared '.dwz' file, if one exists. This is used when the
476 original data was compressed using 'dwz -m'. */
477 struct dwz_file
*dwz_file
= NULL
;
479 /* A flag indicating whether this objfile has a section loaded at a
481 bool has_section_at_zero
= false;
483 /* True if we are using the mapped index,
484 or we are faking it for OBJF_READNOW's sake. */
485 bool using_index
= false;
487 /* The mapped index, or NULL if .gdb_index is missing or not being used. */
488 mapped_index
*index_table
= NULL
;
490 /* The mapped index, or NULL if .debug_names is missing or not being used. */
491 std::unique_ptr
<mapped_debug_names
> debug_names_table
;
493 /* When using index_table, this keeps track of all quick_file_names entries.
494 TUs typically share line table entries with a CU, so we maintain a
495 separate table of all line table entries to support the sharing.
496 Note that while there can be way more TUs than CUs, we've already
497 sorted all the TUs into "type unit groups", grouped by their
498 DW_AT_stmt_list value. Therefore the only sharing done here is with a
499 CU and its associated TU group if there is one. */
500 htab_t quick_file_names_table
{};
502 /* Set during partial symbol reading, to prevent queueing of full
504 bool reading_partial_symbols
= false;
506 /* Table mapping type DIEs to their struct type *.
507 This is NULL if not allocated yet.
508 The mapping is done via (CU/TU + DIE offset) -> type. */
509 htab_t die_type_hash
{};
511 /* The CUs we recently read. */
512 VEC (dwarf2_per_cu_ptr
) *just_read_cus
= NULL
;
514 /* Table containing line_header indexed by offset and offset_in_dwz. */
515 htab_t line_header_hash
{};
517 /* Table containing all filenames. This is an optional because the
518 table is lazily constructed on first access. */
519 gdb::optional
<filename_seen_cache
> filenames_cache
;
522 /* Get the dwarf2_per_objfile associated to OBJFILE. */
524 struct dwarf2_per_objfile
*
525 get_dwarf2_per_objfile (struct objfile
*objfile
)
527 return ((struct dwarf2_per_objfile
*)
528 objfile_data (objfile
, dwarf2_objfile_data_key
));
531 /* Set the dwarf2_per_objfile associated to OBJFILE. */
534 set_dwarf2_per_objfile (struct objfile
*objfile
,
535 struct dwarf2_per_objfile
*dwarf2_per_objfile
)
537 gdb_assert (get_dwarf2_per_objfile (objfile
) == NULL
);
538 set_objfile_data (objfile
, dwarf2_objfile_data_key
, dwarf2_per_objfile
);
541 /* Default names of the debugging sections. */
543 /* Note that if the debugging section has been compressed, it might
544 have a name like .zdebug_info. */
546 static const struct dwarf2_debug_sections dwarf2_elf_names
=
548 { ".debug_info", ".zdebug_info" },
549 { ".debug_abbrev", ".zdebug_abbrev" },
550 { ".debug_line", ".zdebug_line" },
551 { ".debug_loc", ".zdebug_loc" },
552 { ".debug_loclists", ".zdebug_loclists" },
553 { ".debug_macinfo", ".zdebug_macinfo" },
554 { ".debug_macro", ".zdebug_macro" },
555 { ".debug_str", ".zdebug_str" },
556 { ".debug_line_str", ".zdebug_line_str" },
557 { ".debug_ranges", ".zdebug_ranges" },
558 { ".debug_rnglists", ".zdebug_rnglists" },
559 { ".debug_types", ".zdebug_types" },
560 { ".debug_addr", ".zdebug_addr" },
561 { ".debug_frame", ".zdebug_frame" },
562 { ".eh_frame", NULL
},
563 { ".gdb_index", ".zgdb_index" },
564 { ".debug_names", ".zdebug_names" },
565 { ".debug_aranges", ".zdebug_aranges" },
569 /* List of DWO/DWP sections. */
571 static const struct dwop_section_names
573 struct dwarf2_section_names abbrev_dwo
;
574 struct dwarf2_section_names info_dwo
;
575 struct dwarf2_section_names line_dwo
;
576 struct dwarf2_section_names loc_dwo
;
577 struct dwarf2_section_names loclists_dwo
;
578 struct dwarf2_section_names macinfo_dwo
;
579 struct dwarf2_section_names macro_dwo
;
580 struct dwarf2_section_names str_dwo
;
581 struct dwarf2_section_names str_offsets_dwo
;
582 struct dwarf2_section_names types_dwo
;
583 struct dwarf2_section_names cu_index
;
584 struct dwarf2_section_names tu_index
;
588 { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo" },
589 { ".debug_info.dwo", ".zdebug_info.dwo" },
590 { ".debug_line.dwo", ".zdebug_line.dwo" },
591 { ".debug_loc.dwo", ".zdebug_loc.dwo" },
592 { ".debug_loclists.dwo", ".zdebug_loclists.dwo" },
593 { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo" },
594 { ".debug_macro.dwo", ".zdebug_macro.dwo" },
595 { ".debug_str.dwo", ".zdebug_str.dwo" },
596 { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo" },
597 { ".debug_types.dwo", ".zdebug_types.dwo" },
598 { ".debug_cu_index", ".zdebug_cu_index" },
599 { ".debug_tu_index", ".zdebug_tu_index" },
602 /* local data types */
604 /* The data in a compilation unit header, after target2host
605 translation, looks like this. */
606 struct comp_unit_head
610 unsigned char addr_size
;
611 unsigned char signed_addr_p
;
612 sect_offset abbrev_sect_off
;
614 /* Size of file offsets; either 4 or 8. */
615 unsigned int offset_size
;
617 /* Size of the length field; either 4 or 12. */
618 unsigned int initial_length_size
;
620 enum dwarf_unit_type unit_type
;
622 /* Offset to the first byte of this compilation unit header in the
623 .debug_info section, for resolving relative reference dies. */
624 sect_offset sect_off
;
626 /* Offset to first die in this cu from the start of the cu.
627 This will be the first byte following the compilation unit header. */
628 cu_offset first_die_cu_offset
;
630 /* 64-bit signature of this type unit - it is valid only for
631 UNIT_TYPE DW_UT_type. */
634 /* For types, offset in the type's DIE of the type defined by this TU. */
635 cu_offset type_cu_offset_in_tu
;
638 /* Type used for delaying computation of method physnames.
639 See comments for compute_delayed_physnames. */
640 struct delayed_method_info
642 /* The type to which the method is attached, i.e., its parent class. */
645 /* The index of the method in the type's function fieldlists. */
648 /* The index of the method in the fieldlist. */
651 /* The name of the DIE. */
654 /* The DIE associated with this method. */
655 struct die_info
*die
;
658 typedef struct delayed_method_info delayed_method_info
;
659 DEF_VEC_O (delayed_method_info
);
661 /* Internal state when decoding a particular compilation unit. */
664 /* The header of the compilation unit. */
665 struct comp_unit_head header
;
667 /* Base address of this compilation unit. */
668 CORE_ADDR base_address
;
670 /* Non-zero if base_address has been set. */
673 /* The language we are debugging. */
674 enum language language
;
675 const struct language_defn
*language_defn
;
677 const char *producer
;
679 /* The generic symbol table building routines have separate lists for
680 file scope symbols and all all other scopes (local scopes). So
681 we need to select the right one to pass to add_symbol_to_list().
682 We do it by keeping a pointer to the correct list in list_in_scope.
684 FIXME: The original dwarf code just treated the file scope as the
685 first local scope, and all other local scopes as nested local
686 scopes, and worked fine. Check to see if we really need to
687 distinguish these in buildsym.c. */
688 struct pending
**list_in_scope
;
690 /* The abbrev table for this CU.
691 Normally this points to the abbrev table in the objfile.
692 But if DWO_UNIT is non-NULL this is the abbrev table in the DWO file. */
693 struct abbrev_table
*abbrev_table
;
695 /* Hash table holding all the loaded partial DIEs
696 with partial_die->offset.SECT_OFF as hash. */
699 /* Storage for things with the same lifetime as this read-in compilation
700 unit, including partial DIEs. */
701 struct obstack comp_unit_obstack
;
703 /* When multiple dwarf2_cu structures are living in memory, this field
704 chains them all together, so that they can be released efficiently.
705 We will probably also want a generation counter so that most-recently-used
706 compilation units are cached... */
707 struct dwarf2_per_cu_data
*read_in_chain
;
709 /* Backlink to our per_cu entry. */
710 struct dwarf2_per_cu_data
*per_cu
;
712 /* How many compilation units ago was this CU last referenced? */
715 /* A hash table of DIE cu_offset for following references with
716 die_info->offset.sect_off as hash. */
719 /* Full DIEs if read in. */
720 struct die_info
*dies
;
722 /* A set of pointers to dwarf2_per_cu_data objects for compilation
723 units referenced by this one. Only set during full symbol processing;
724 partial symbol tables do not have dependencies. */
727 /* Header data from the line table, during full symbol processing. */
728 struct line_header
*line_header
;
729 /* Non-NULL if LINE_HEADER is owned by this DWARF_CU. Otherwise,
730 it's owned by dwarf2_per_objfile::line_header_hash. If non-NULL,
731 this is the DW_TAG_compile_unit die for this CU. We'll hold on
732 to the line header as long as this DIE is being processed. See
733 process_die_scope. */
734 die_info
*line_header_die_owner
;
736 /* A list of methods which need to have physnames computed
737 after all type information has been read. */
738 VEC (delayed_method_info
) *method_list
;
740 /* To be copied to symtab->call_site_htab. */
741 htab_t call_site_htab
;
743 /* Non-NULL if this CU came from a DWO file.
744 There is an invariant here that is important to remember:
745 Except for attributes copied from the top level DIE in the "main"
746 (or "stub") file in preparation for reading the DWO file
747 (e.g., DW_AT_GNU_addr_base), we KISS: there is only *one* CU.
748 Either there isn't a DWO file (in which case this is NULL and the point
749 is moot), or there is and either we're not going to read it (in which
750 case this is NULL) or there is and we are reading it (in which case this
752 struct dwo_unit
*dwo_unit
;
754 /* The DW_AT_addr_base attribute if present, zero otherwise
755 (zero is a valid value though).
756 Note this value comes from the Fission stub CU/TU's DIE. */
759 /* The DW_AT_ranges_base attribute if present, zero otherwise
760 (zero is a valid value though).
761 Note this value comes from the Fission stub CU/TU's DIE.
762 Also note that the value is zero in the non-DWO case so this value can
763 be used without needing to know whether DWO files are in use or not.
764 N.B. This does not apply to DW_AT_ranges appearing in
765 DW_TAG_compile_unit dies. This is a bit of a wart, consider if ever
766 DW_AT_ranges appeared in the DW_TAG_compile_unit of DWO DIEs: then
767 DW_AT_ranges_base *would* have to be applied, and we'd have to care
768 whether the DW_AT_ranges attribute came from the skeleton or DWO. */
769 ULONGEST ranges_base
;
771 /* Mark used when releasing cached dies. */
772 unsigned int mark
: 1;
774 /* This CU references .debug_loc. See the symtab->locations_valid field.
775 This test is imperfect as there may exist optimized debug code not using
776 any location list and still facing inlining issues if handled as
777 unoptimized code. For a future better test see GCC PR other/32998. */
778 unsigned int has_loclist
: 1;
780 /* These cache the results for producer_is_* fields. CHECKED_PRODUCER is set
781 if all the producer_is_* fields are valid. This information is cached
782 because profiling CU expansion showed excessive time spent in
783 producer_is_gxx_lt_4_6. */
784 unsigned int checked_producer
: 1;
785 unsigned int producer_is_gxx_lt_4_6
: 1;
786 unsigned int producer_is_gcc_lt_4_3
: 1;
787 unsigned int producer_is_icc_lt_14
: 1;
789 /* When set, the file that we're processing is known to have
790 debugging info for C++ namespaces. GCC 3.3.x did not produce
791 this information, but later versions do. */
793 unsigned int processing_has_namespace_info
: 1;
796 /* Persistent data held for a compilation unit, even when not
797 processing it. We put a pointer to this structure in the
798 read_symtab_private field of the psymtab. */
800 struct dwarf2_per_cu_data
802 /* The start offset and length of this compilation unit.
803 NOTE: Unlike comp_unit_head.length, this length includes
805 If the DIE refers to a DWO file, this is always of the original die,
807 sect_offset sect_off
;
810 /* DWARF standard version this data has been read from (such as 4 or 5). */
813 /* Flag indicating this compilation unit will be read in before
814 any of the current compilation units are processed. */
815 unsigned int queued
: 1;
817 /* This flag will be set when reading partial DIEs if we need to load
818 absolutely all DIEs for this compilation unit, instead of just the ones
819 we think are interesting. It gets set if we look for a DIE in the
820 hash table and don't find it. */
821 unsigned int load_all_dies
: 1;
823 /* Non-zero if this CU is from .debug_types.
824 Struct dwarf2_per_cu_data is contained in struct signatured_type iff
826 unsigned int is_debug_types
: 1;
828 /* Non-zero if this CU is from the .dwz file. */
829 unsigned int is_dwz
: 1;
831 /* Non-zero if reading a TU directly from a DWO file, bypassing the stub.
832 This flag is only valid if is_debug_types is true.
833 We can't read a CU directly from a DWO file: There are required
834 attributes in the stub. */
835 unsigned int reading_dwo_directly
: 1;
837 /* Non-zero if the TU has been read.
838 This is used to assist the "Stay in DWO Optimization" for Fission:
839 When reading a DWO, it's faster to read TUs from the DWO instead of
840 fetching them from random other DWOs (due to comdat folding).
841 If the TU has already been read, the optimization is unnecessary
842 (and unwise - we don't want to change where gdb thinks the TU lives
844 This flag is only valid if is_debug_types is true. */
845 unsigned int tu_read
: 1;
847 /* The section this CU/TU lives in.
848 If the DIE refers to a DWO file, this is always the original die,
850 struct dwarf2_section_info
*section
;
852 /* Set to non-NULL iff this CU is currently loaded. When it gets freed out
853 of the CU cache it gets reset to NULL again. This is left as NULL for
854 dummy CUs (a CU header, but nothing else). */
855 struct dwarf2_cu
*cu
;
857 /* The corresponding dwarf2_per_objfile. */
858 struct dwarf2_per_objfile
*dwarf2_per_objfile
;
860 /* When dwarf2_per_objfile->using_index is true, the 'quick' field
861 is active. Otherwise, the 'psymtab' field is active. */
864 /* The partial symbol table associated with this compilation unit,
865 or NULL for unread partial units. */
866 struct partial_symtab
*psymtab
;
868 /* Data needed by the "quick" functions. */
869 struct dwarf2_per_cu_quick_data
*quick
;
872 /* The CUs we import using DW_TAG_imported_unit. This is filled in
873 while reading psymtabs, used to compute the psymtab dependencies,
874 and then cleared. Then it is filled in again while reading full
875 symbols, and only deleted when the objfile is destroyed.
877 This is also used to work around a difference between the way gold
878 generates .gdb_index version <=7 and the way gdb does. Arguably this
879 is a gold bug. For symbols coming from TUs, gold records in the index
880 the CU that includes the TU instead of the TU itself. This breaks
881 dw2_lookup_symbol: It assumes that if the index says symbol X lives
882 in CU/TU Y, then one need only expand Y and a subsequent lookup in Y
883 will find X. Alas TUs live in their own symtab, so after expanding CU Y
884 we need to look in TU Z to find X. Fortunately, this is akin to
885 DW_TAG_imported_unit, so we just use the same mechanism: For
886 .gdb_index version <=7 this also records the TUs that the CU referred
887 to. Concurrently with this change gdb was modified to emit version 8
888 indices so we only pay a price for gold generated indices.
889 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
890 VEC (dwarf2_per_cu_ptr
) *imported_symtabs
;
893 /* Entry in the signatured_types hash table. */
895 struct signatured_type
897 /* The "per_cu" object of this type.
898 This struct is used iff per_cu.is_debug_types.
899 N.B.: This is the first member so that it's easy to convert pointers
901 struct dwarf2_per_cu_data per_cu
;
903 /* The type's signature. */
906 /* Offset in the TU of the type's DIE, as read from the TU header.
907 If this TU is a DWO stub and the definition lives in a DWO file
908 (specified by DW_AT_GNU_dwo_name), this value is unusable. */
909 cu_offset type_offset_in_tu
;
911 /* Offset in the section of the type's DIE.
912 If the definition lives in a DWO file, this is the offset in the
913 .debug_types.dwo section.
914 The value is zero until the actual value is known.
915 Zero is otherwise not a valid section offset. */
916 sect_offset type_offset_in_section
;
918 /* Type units are grouped by their DW_AT_stmt_list entry so that they
919 can share them. This points to the containing symtab. */
920 struct type_unit_group
*type_unit_group
;
923 The first time we encounter this type we fully read it in and install it
924 in the symbol tables. Subsequent times we only need the type. */
927 /* Containing DWO unit.
928 This field is valid iff per_cu.reading_dwo_directly. */
929 struct dwo_unit
*dwo_unit
;
932 typedef struct signatured_type
*sig_type_ptr
;
933 DEF_VEC_P (sig_type_ptr
);
935 /* A struct that can be used as a hash key for tables based on DW_AT_stmt_list.
936 This includes type_unit_group and quick_file_names. */
938 struct stmt_list_hash
940 /* The DWO unit this table is from or NULL if there is none. */
941 struct dwo_unit
*dwo_unit
;
943 /* Offset in .debug_line or .debug_line.dwo. */
944 sect_offset line_sect_off
;
947 /* Each element of dwarf2_per_objfile->type_unit_groups is a pointer to
948 an object of this type. */
950 struct type_unit_group
952 /* dwarf2read.c's main "handle" on a TU symtab.
953 To simplify things we create an artificial CU that "includes" all the
954 type units using this stmt_list so that the rest of the code still has
955 a "per_cu" handle on the symtab.
956 This PER_CU is recognized by having no section. */
957 #define IS_TYPE_UNIT_GROUP(per_cu) ((per_cu)->section == NULL)
958 struct dwarf2_per_cu_data per_cu
;
960 /* The TUs that share this DW_AT_stmt_list entry.
961 This is added to while parsing type units to build partial symtabs,
962 and is deleted afterwards and not used again. */
963 VEC (sig_type_ptr
) *tus
;
965 /* The compunit symtab.
966 Type units in a group needn't all be defined in the same source file,
967 so we create an essentially anonymous symtab as the compunit symtab. */
968 struct compunit_symtab
*compunit_symtab
;
970 /* The data used to construct the hash key. */
971 struct stmt_list_hash hash
;
973 /* The number of symtabs from the line header.
974 The value here must match line_header.num_file_names. */
975 unsigned int num_symtabs
;
977 /* The symbol tables for this TU (obtained from the files listed in
979 WARNING: The order of entries here must match the order of entries
980 in the line header. After the first TU using this type_unit_group, the
981 line header for the subsequent TUs is recreated from this. This is done
982 because we need to use the same symtabs for each TU using the same
983 DW_AT_stmt_list value. Also note that symtabs may be repeated here,
984 there's no guarantee the line header doesn't have duplicate entries. */
985 struct symtab
**symtabs
;
988 /* These sections are what may appear in a (real or virtual) DWO file. */
992 struct dwarf2_section_info abbrev
;
993 struct dwarf2_section_info line
;
994 struct dwarf2_section_info loc
;
995 struct dwarf2_section_info loclists
;
996 struct dwarf2_section_info macinfo
;
997 struct dwarf2_section_info macro
;
998 struct dwarf2_section_info str
;
999 struct dwarf2_section_info str_offsets
;
1000 /* In the case of a virtual DWO file, these two are unused. */
1001 struct dwarf2_section_info info
;
1002 VEC (dwarf2_section_info_def
) *types
;
1005 /* CUs/TUs in DWP/DWO files. */
1009 /* Backlink to the containing struct dwo_file. */
1010 struct dwo_file
*dwo_file
;
1012 /* The "id" that distinguishes this CU/TU.
1013 .debug_info calls this "dwo_id", .debug_types calls this "signature".
1014 Since signatures came first, we stick with it for consistency. */
1017 /* The section this CU/TU lives in, in the DWO file. */
1018 struct dwarf2_section_info
*section
;
1020 /* Same as dwarf2_per_cu_data:{sect_off,length} but in the DWO section. */
1021 sect_offset sect_off
;
1022 unsigned int length
;
1024 /* For types, offset in the type's DIE of the type defined by this TU. */
1025 cu_offset type_offset_in_tu
;
1028 /* include/dwarf2.h defines the DWP section codes.
1029 It defines a max value but it doesn't define a min value, which we
1030 use for error checking, so provide one. */
1032 enum dwp_v2_section_ids
1037 /* Data for one DWO file.
1039 This includes virtual DWO files (a virtual DWO file is a DWO file as it
1040 appears in a DWP file). DWP files don't really have DWO files per se -
1041 comdat folding of types "loses" the DWO file they came from, and from
1042 a high level view DWP files appear to contain a mass of random types.
1043 However, to maintain consistency with the non-DWP case we pretend DWP
1044 files contain virtual DWO files, and we assign each TU with one virtual
1045 DWO file (generally based on the line and abbrev section offsets -
1046 a heuristic that seems to work in practice). */
1050 /* The DW_AT_GNU_dwo_name attribute.
1051 For virtual DWO files the name is constructed from the section offsets
1052 of abbrev,line,loc,str_offsets so that we combine virtual DWO files
1053 from related CU+TUs. */
1054 const char *dwo_name
;
1056 /* The DW_AT_comp_dir attribute. */
1057 const char *comp_dir
;
1059 /* The bfd, when the file is open. Otherwise this is NULL.
1060 This is unused(NULL) for virtual DWO files where we use dwp_file.dbfd. */
1063 /* The sections that make up this DWO file.
1064 Remember that for virtual DWO files in DWP V2, these are virtual
1065 sections (for lack of a better name). */
1066 struct dwo_sections sections
;
1068 /* The CUs in the file.
1069 Each element is a struct dwo_unit. Multiple CUs per DWO are supported as
1070 an extension to handle LLVM's Link Time Optimization output (where
1071 multiple source files may be compiled into a single object/dwo pair). */
1074 /* Table of TUs in the file.
1075 Each element is a struct dwo_unit. */
1079 /* These sections are what may appear in a DWP file. */
1083 /* These are used by both DWP version 1 and 2. */
1084 struct dwarf2_section_info str
;
1085 struct dwarf2_section_info cu_index
;
1086 struct dwarf2_section_info tu_index
;
1088 /* These are only used by DWP version 2 files.
1089 In DWP version 1 the .debug_info.dwo, .debug_types.dwo, and other
1090 sections are referenced by section number, and are not recorded here.
1091 In DWP version 2 there is at most one copy of all these sections, each
1092 section being (effectively) comprised of the concatenation of all of the
1093 individual sections that exist in the version 1 format.
1094 To keep the code simple we treat each of these concatenated pieces as a
1095 section itself (a virtual section?). */
1096 struct dwarf2_section_info abbrev
;
1097 struct dwarf2_section_info info
;
1098 struct dwarf2_section_info line
;
1099 struct dwarf2_section_info loc
;
1100 struct dwarf2_section_info macinfo
;
1101 struct dwarf2_section_info macro
;
1102 struct dwarf2_section_info str_offsets
;
1103 struct dwarf2_section_info types
;
1106 /* These sections are what may appear in a virtual DWO file in DWP version 1.
1107 A virtual DWO file is a DWO file as it appears in a DWP file. */
1109 struct virtual_v1_dwo_sections
1111 struct dwarf2_section_info abbrev
;
1112 struct dwarf2_section_info line
;
1113 struct dwarf2_section_info loc
;
1114 struct dwarf2_section_info macinfo
;
1115 struct dwarf2_section_info macro
;
1116 struct dwarf2_section_info str_offsets
;
1117 /* Each DWP hash table entry records one CU or one TU.
1118 That is recorded here, and copied to dwo_unit.section. */
1119 struct dwarf2_section_info info_or_types
;
1122 /* Similar to virtual_v1_dwo_sections, but for DWP version 2.
1123 In version 2, the sections of the DWO files are concatenated together
1124 and stored in one section of that name. Thus each ELF section contains
1125 several "virtual" sections. */
1127 struct virtual_v2_dwo_sections
1129 bfd_size_type abbrev_offset
;
1130 bfd_size_type abbrev_size
;
1132 bfd_size_type line_offset
;
1133 bfd_size_type line_size
;
1135 bfd_size_type loc_offset
;
1136 bfd_size_type loc_size
;
1138 bfd_size_type macinfo_offset
;
1139 bfd_size_type macinfo_size
;
1141 bfd_size_type macro_offset
;
1142 bfd_size_type macro_size
;
1144 bfd_size_type str_offsets_offset
;
1145 bfd_size_type str_offsets_size
;
1147 /* Each DWP hash table entry records one CU or one TU.
1148 That is recorded here, and copied to dwo_unit.section. */
1149 bfd_size_type info_or_types_offset
;
1150 bfd_size_type info_or_types_size
;
1153 /* Contents of DWP hash tables. */
1155 struct dwp_hash_table
1157 uint32_t version
, nr_columns
;
1158 uint32_t nr_units
, nr_slots
;
1159 const gdb_byte
*hash_table
, *unit_table
;
1164 const gdb_byte
*indices
;
1168 /* This is indexed by column number and gives the id of the section
1170 #define MAX_NR_V2_DWO_SECTIONS \
1171 (1 /* .debug_info or .debug_types */ \
1172 + 1 /* .debug_abbrev */ \
1173 + 1 /* .debug_line */ \
1174 + 1 /* .debug_loc */ \
1175 + 1 /* .debug_str_offsets */ \
1176 + 1 /* .debug_macro or .debug_macinfo */)
1177 int section_ids
[MAX_NR_V2_DWO_SECTIONS
];
1178 const gdb_byte
*offsets
;
1179 const gdb_byte
*sizes
;
1184 /* Data for one DWP file. */
1188 /* Name of the file. */
1191 /* File format version. */
1197 /* Section info for this file. */
1198 struct dwp_sections sections
;
1200 /* Table of CUs in the file. */
1201 const struct dwp_hash_table
*cus
;
1203 /* Table of TUs in the file. */
1204 const struct dwp_hash_table
*tus
;
1206 /* Tables of loaded CUs/TUs. Each entry is a struct dwo_unit *. */
1210 /* Table to map ELF section numbers to their sections.
1211 This is only needed for the DWP V1 file format. */
1212 unsigned int num_sections
;
1213 asection
**elf_sections
;
1216 /* This represents a '.dwz' file. */
1220 /* A dwz file can only contain a few sections. */
1221 struct dwarf2_section_info abbrev
;
1222 struct dwarf2_section_info info
;
1223 struct dwarf2_section_info str
;
1224 struct dwarf2_section_info line
;
1225 struct dwarf2_section_info macro
;
1226 struct dwarf2_section_info gdb_index
;
1227 struct dwarf2_section_info debug_names
;
1229 /* The dwz's BFD. */
1233 /* Struct used to pass misc. parameters to read_die_and_children, et
1234 al. which are used for both .debug_info and .debug_types dies.
1235 All parameters here are unchanging for the life of the call. This
1236 struct exists to abstract away the constant parameters of die reading. */
1238 struct die_reader_specs
1240 /* The bfd of die_section. */
1243 /* The CU of the DIE we are parsing. */
1244 struct dwarf2_cu
*cu
;
1246 /* Non-NULL if reading a DWO file (including one packaged into a DWP). */
1247 struct dwo_file
*dwo_file
;
1249 /* The section the die comes from.
1250 This is either .debug_info or .debug_types, or the .dwo variants. */
1251 struct dwarf2_section_info
*die_section
;
1253 /* die_section->buffer. */
1254 const gdb_byte
*buffer
;
1256 /* The end of the buffer. */
1257 const gdb_byte
*buffer_end
;
1259 /* The value of the DW_AT_comp_dir attribute. */
1260 const char *comp_dir
;
1263 /* Type of function passed to init_cutu_and_read_dies, et.al. */
1264 typedef void (die_reader_func_ftype
) (const struct die_reader_specs
*reader
,
1265 const gdb_byte
*info_ptr
,
1266 struct die_info
*comp_unit_die
,
1270 /* A 1-based directory index. This is a strong typedef to prevent
1271 accidentally using a directory index as a 0-based index into an
1273 enum class dir_index
: unsigned int {};
1275 /* Likewise, a 1-based file name index. */
1276 enum class file_name_index
: unsigned int {};
1280 file_entry () = default;
1282 file_entry (const char *name_
, dir_index d_index_
,
1283 unsigned int mod_time_
, unsigned int length_
)
1286 mod_time (mod_time_
),
1290 /* Return the include directory at D_INDEX stored in LH. Returns
1291 NULL if D_INDEX is out of bounds. */
1292 const char *include_dir (const line_header
*lh
) const;
1294 /* The file name. Note this is an observing pointer. The memory is
1295 owned by debug_line_buffer. */
1296 const char *name
{};
1298 /* The directory index (1-based). */
1299 dir_index d_index
{};
1301 unsigned int mod_time
{};
1303 unsigned int length
{};
1305 /* True if referenced by the Line Number Program. */
1308 /* The associated symbol table, if any. */
1309 struct symtab
*symtab
{};
1312 /* The line number information for a compilation unit (found in the
1313 .debug_line section) begins with a "statement program header",
1314 which contains the following information. */
1321 /* Add an entry to the include directory table. */
1322 void add_include_dir (const char *include_dir
);
1324 /* Add an entry to the file name table. */
1325 void add_file_name (const char *name
, dir_index d_index
,
1326 unsigned int mod_time
, unsigned int length
);
1328 /* Return the include dir at INDEX (1-based). Returns NULL if INDEX
1329 is out of bounds. */
1330 const char *include_dir_at (dir_index index
) const
1332 /* Convert directory index number (1-based) to vector index
1334 size_t vec_index
= to_underlying (index
) - 1;
1336 if (vec_index
>= include_dirs
.size ())
1338 return include_dirs
[vec_index
];
1341 /* Return the file name at INDEX (1-based). Returns NULL if INDEX
1342 is out of bounds. */
1343 file_entry
*file_name_at (file_name_index index
)
1345 /* Convert file name index number (1-based) to vector index
1347 size_t vec_index
= to_underlying (index
) - 1;
1349 if (vec_index
>= file_names
.size ())
1351 return &file_names
[vec_index
];
1354 /* Const version of the above. */
1355 const file_entry
*file_name_at (unsigned int index
) const
1357 if (index
>= file_names
.size ())
1359 return &file_names
[index
];
1362 /* Offset of line number information in .debug_line section. */
1363 sect_offset sect_off
{};
1365 /* OFFSET is for struct dwz_file associated with dwarf2_per_objfile. */
1366 unsigned offset_in_dwz
: 1; /* Can't initialize bitfields in-class. */
1368 unsigned int total_length
{};
1369 unsigned short version
{};
1370 unsigned int header_length
{};
1371 unsigned char minimum_instruction_length
{};
1372 unsigned char maximum_ops_per_instruction
{};
1373 unsigned char default_is_stmt
{};
1375 unsigned char line_range
{};
1376 unsigned char opcode_base
{};
1378 /* standard_opcode_lengths[i] is the number of operands for the
1379 standard opcode whose value is i. This means that
1380 standard_opcode_lengths[0] is unused, and the last meaningful
1381 element is standard_opcode_lengths[opcode_base - 1]. */
1382 std::unique_ptr
<unsigned char[]> standard_opcode_lengths
;
1384 /* The include_directories table. Note these are observing
1385 pointers. The memory is owned by debug_line_buffer. */
1386 std::vector
<const char *> include_dirs
;
1388 /* The file_names table. */
1389 std::vector
<file_entry
> file_names
;
1391 /* The start and end of the statement program following this
1392 header. These point into dwarf2_per_objfile->line_buffer. */
1393 const gdb_byte
*statement_program_start
{}, *statement_program_end
{};
1396 typedef std::unique_ptr
<line_header
> line_header_up
;
1399 file_entry::include_dir (const line_header
*lh
) const
1401 return lh
->include_dir_at (d_index
);
1404 /* When we construct a partial symbol table entry we only
1405 need this much information. */
1406 struct partial_die_info
1408 /* Offset of this DIE. */
1409 sect_offset sect_off
;
1411 /* DWARF-2 tag for this DIE. */
1412 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
1414 /* Assorted flags describing the data found in this DIE. */
1415 unsigned int has_children
: 1;
1416 unsigned int is_external
: 1;
1417 unsigned int is_declaration
: 1;
1418 unsigned int has_type
: 1;
1419 unsigned int has_specification
: 1;
1420 unsigned int has_pc_info
: 1;
1421 unsigned int may_be_inlined
: 1;
1423 /* This DIE has been marked DW_AT_main_subprogram. */
1424 unsigned int main_subprogram
: 1;
1426 /* Flag set if the SCOPE field of this structure has been
1428 unsigned int scope_set
: 1;
1430 /* Flag set if the DIE has a byte_size attribute. */
1431 unsigned int has_byte_size
: 1;
1433 /* Flag set if the DIE has a DW_AT_const_value attribute. */
1434 unsigned int has_const_value
: 1;
1436 /* Flag set if any of the DIE's children are template arguments. */
1437 unsigned int has_template_arguments
: 1;
1439 /* Flag set if fixup_partial_die has been called on this die. */
1440 unsigned int fixup_called
: 1;
1442 /* Flag set if DW_TAG_imported_unit uses DW_FORM_GNU_ref_alt. */
1443 unsigned int is_dwz
: 1;
1445 /* Flag set if spec_offset uses DW_FORM_GNU_ref_alt. */
1446 unsigned int spec_is_dwz
: 1;
1448 /* The name of this DIE. Normally the value of DW_AT_name, but
1449 sometimes a default name for unnamed DIEs. */
1452 /* The linkage name, if present. */
1453 const char *linkage_name
;
1455 /* The scope to prepend to our children. This is generally
1456 allocated on the comp_unit_obstack, so will disappear
1457 when this compilation unit leaves the cache. */
1460 /* Some data associated with the partial DIE. The tag determines
1461 which field is live. */
1464 /* The location description associated with this DIE, if any. */
1465 struct dwarf_block
*locdesc
;
1466 /* The offset of an import, for DW_TAG_imported_unit. */
1467 sect_offset sect_off
;
1470 /* If HAS_PC_INFO, the PC range associated with this DIE. */
1474 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
1475 DW_AT_sibling, if any. */
1476 /* NOTE: This member isn't strictly necessary, read_partial_die could
1477 return DW_AT_sibling values to its caller load_partial_dies. */
1478 const gdb_byte
*sibling
;
1480 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
1481 DW_AT_specification (or DW_AT_abstract_origin or
1482 DW_AT_extension). */
1483 sect_offset spec_offset
;
1485 /* Pointers to this DIE's parent, first child, and next sibling,
1487 struct partial_die_info
*die_parent
, *die_child
, *die_sibling
;
1490 /* This data structure holds the information of an abbrev. */
1493 unsigned int number
; /* number identifying abbrev */
1494 enum dwarf_tag tag
; /* dwarf tag */
1495 unsigned short has_children
; /* boolean */
1496 unsigned short num_attrs
; /* number of attributes */
1497 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
1498 struct abbrev_info
*next
; /* next in chain */
1503 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
1504 ENUM_BITFIELD(dwarf_form
) form
: 16;
1506 /* It is valid only if FORM is DW_FORM_implicit_const. */
1507 LONGEST implicit_const
;
1510 /* Size of abbrev_table.abbrev_hash_table. */
1511 #define ABBREV_HASH_SIZE 121
1513 /* Top level data structure to contain an abbreviation table. */
1517 /* Where the abbrev table came from.
1518 This is used as a sanity check when the table is used. */
1519 sect_offset sect_off
;
1521 /* Storage for the abbrev table. */
1522 struct obstack abbrev_obstack
;
1524 /* Hash table of abbrevs.
1525 This is an array of size ABBREV_HASH_SIZE allocated in abbrev_obstack.
1526 It could be statically allocated, but the previous code didn't so we
1528 struct abbrev_info
**abbrevs
;
1531 /* Attributes have a name and a value. */
1534 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
1535 ENUM_BITFIELD(dwarf_form
) form
: 15;
1537 /* Has DW_STRING already been updated by dwarf2_canonicalize_name? This
1538 field should be in u.str (existing only for DW_STRING) but it is kept
1539 here for better struct attribute alignment. */
1540 unsigned int string_is_canonical
: 1;
1545 struct dwarf_block
*blk
;
1554 /* This data structure holds a complete die structure. */
1557 /* DWARF-2 tag for this DIE. */
1558 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
1560 /* Number of attributes */
1561 unsigned char num_attrs
;
1563 /* True if we're presently building the full type name for the
1564 type derived from this DIE. */
1565 unsigned char building_fullname
: 1;
1567 /* True if this die is in process. PR 16581. */
1568 unsigned char in_process
: 1;
1571 unsigned int abbrev
;
1573 /* Offset in .debug_info or .debug_types section. */
1574 sect_offset sect_off
;
1576 /* The dies in a compilation unit form an n-ary tree. PARENT
1577 points to this die's parent; CHILD points to the first child of
1578 this node; and all the children of a given node are chained
1579 together via their SIBLING fields. */
1580 struct die_info
*child
; /* Its first child, if any. */
1581 struct die_info
*sibling
; /* Its next sibling, if any. */
1582 struct die_info
*parent
; /* Its parent, if any. */
1584 /* An array of attributes, with NUM_ATTRS elements. There may be
1585 zero, but it's not common and zero-sized arrays are not
1586 sufficiently portable C. */
1587 struct attribute attrs
[1];
1590 /* Get at parts of an attribute structure. */
1592 #define DW_STRING(attr) ((attr)->u.str)
1593 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
1594 #define DW_UNSND(attr) ((attr)->u.unsnd)
1595 #define DW_BLOCK(attr) ((attr)->u.blk)
1596 #define DW_SND(attr) ((attr)->u.snd)
1597 #define DW_ADDR(attr) ((attr)->u.addr)
1598 #define DW_SIGNATURE(attr) ((attr)->u.signature)
1600 /* Blocks are a bunch of untyped bytes. */
1605 /* Valid only if SIZE is not zero. */
1606 const gdb_byte
*data
;
1609 #ifndef ATTR_ALLOC_CHUNK
1610 #define ATTR_ALLOC_CHUNK 4
1613 /* Allocate fields for structs, unions and enums in this size. */
1614 #ifndef DW_FIELD_ALLOC_CHUNK
1615 #define DW_FIELD_ALLOC_CHUNK 4
1618 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
1619 but this would require a corresponding change in unpack_field_as_long
1621 static int bits_per_byte
= 8;
1625 struct nextfield
*next
;
1633 struct nextfnfield
*next
;
1634 struct fn_field fnfield
;
1641 struct nextfnfield
*head
;
1644 struct decl_field_list
1646 struct decl_field field
;
1647 struct decl_field_list
*next
;
1650 /* The routines that read and process dies for a C struct or C++ class
1651 pass lists of data member fields and lists of member function fields
1652 in an instance of a field_info structure, as defined below. */
1655 /* List of data member and baseclasses fields. */
1656 struct nextfield
*fields
, *baseclasses
;
1658 /* Number of fields (including baseclasses). */
1661 /* Number of baseclasses. */
1664 /* Set if the accesibility of one of the fields is not public. */
1665 int non_public_fields
;
1667 /* Member function fieldlist array, contains name of possibly overloaded
1668 member function, number of overloaded member functions and a pointer
1669 to the head of the member function field chain. */
1670 struct fnfieldlist
*fnfieldlists
;
1672 /* Number of entries in the fnfieldlists array. */
1675 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
1676 a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
1677 struct decl_field_list
*typedef_field_list
;
1678 unsigned typedef_field_list_count
;
1680 /* Nested types defined by this class and the number of elements in this
1682 struct decl_field_list
*nested_types_list
;
1683 unsigned nested_types_list_count
;
1686 /* One item on the queue of compilation units to read in full symbols
1688 struct dwarf2_queue_item
1690 struct dwarf2_per_cu_data
*per_cu
;
1691 enum language pretend_language
;
1692 struct dwarf2_queue_item
*next
;
1695 /* The current queue. */
1696 static struct dwarf2_queue_item
*dwarf2_queue
, *dwarf2_queue_tail
;
1698 /* Loaded secondary compilation units are kept in memory until they
1699 have not been referenced for the processing of this many
1700 compilation units. Set this to zero to disable caching. Cache
1701 sizes of up to at least twenty will improve startup time for
1702 typical inter-CU-reference binaries, at an obvious memory cost. */
1703 static int dwarf_max_cache_age
= 5;
1705 show_dwarf_max_cache_age (struct ui_file
*file
, int from_tty
,
1706 struct cmd_list_element
*c
, const char *value
)
1708 fprintf_filtered (file
, _("The upper bound on the age of cached "
1709 "DWARF compilation units is %s.\n"),
1713 /* local function prototypes */
1715 static const char *get_section_name (const struct dwarf2_section_info
*);
1717 static const char *get_section_file_name (const struct dwarf2_section_info
*);
1719 static void dwarf2_find_base_address (struct die_info
*die
,
1720 struct dwarf2_cu
*cu
);
1722 static struct partial_symtab
*create_partial_symtab
1723 (struct dwarf2_per_cu_data
*per_cu
, const char *name
);
1725 static void build_type_psymtabs_reader (const struct die_reader_specs
*reader
,
1726 const gdb_byte
*info_ptr
,
1727 struct die_info
*type_unit_die
,
1728 int has_children
, void *data
);
1730 static void dwarf2_build_psymtabs_hard
1731 (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
1733 static void scan_partial_symbols (struct partial_die_info
*,
1734 CORE_ADDR
*, CORE_ADDR
*,
1735 int, struct dwarf2_cu
*);
1737 static void add_partial_symbol (struct partial_die_info
*,
1738 struct dwarf2_cu
*);
1740 static void add_partial_namespace (struct partial_die_info
*pdi
,
1741 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1742 int set_addrmap
, struct dwarf2_cu
*cu
);
1744 static void add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
1745 CORE_ADDR
*highpc
, int set_addrmap
,
1746 struct dwarf2_cu
*cu
);
1748 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
1749 struct dwarf2_cu
*cu
);
1751 static void add_partial_subprogram (struct partial_die_info
*pdi
,
1752 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1753 int need_pc
, struct dwarf2_cu
*cu
);
1755 static void dwarf2_read_symtab (struct partial_symtab
*,
1758 static void psymtab_to_symtab_1 (struct partial_symtab
*);
1760 static struct abbrev_info
*abbrev_table_lookup_abbrev
1761 (const struct abbrev_table
*, unsigned int);
1763 static struct abbrev_table
*abbrev_table_read_table
1764 (struct dwarf2_per_objfile
*dwarf2_per_objfile
, struct dwarf2_section_info
*,
1767 static void abbrev_table_free (struct abbrev_table
*);
1769 static void abbrev_table_free_cleanup (void *);
1771 static void dwarf2_read_abbrevs (struct dwarf2_cu
*,
1772 struct dwarf2_section_info
*);
1774 static void dwarf2_free_abbrev_table (void *);
1776 static unsigned int peek_abbrev_code (bfd
*, const gdb_byte
*);
1778 static struct partial_die_info
*load_partial_dies
1779 (const struct die_reader_specs
*, const gdb_byte
*, int);
1781 static const gdb_byte
*read_partial_die (const struct die_reader_specs
*,
1782 struct partial_die_info
*,
1783 struct abbrev_info
*,
1787 static struct partial_die_info
*find_partial_die (sect_offset
, int,
1788 struct dwarf2_cu
*);
1790 static void fixup_partial_die (struct partial_die_info
*,
1791 struct dwarf2_cu
*);
1793 static const gdb_byte
*read_attribute (const struct die_reader_specs
*,
1794 struct attribute
*, struct attr_abbrev
*,
1797 static unsigned int read_1_byte (bfd
*, const gdb_byte
*);
1799 static int read_1_signed_byte (bfd
*, const gdb_byte
*);
1801 static unsigned int read_2_bytes (bfd
*, const gdb_byte
*);
1803 static unsigned int read_4_bytes (bfd
*, const gdb_byte
*);
1805 static ULONGEST
read_8_bytes (bfd
*, const gdb_byte
*);
1807 static CORE_ADDR
read_address (bfd
*, const gdb_byte
*ptr
, struct dwarf2_cu
*,
1810 static LONGEST
read_initial_length (bfd
*, const gdb_byte
*, unsigned int *);
1812 static LONGEST read_checked_initial_length_and_offset
1813 (bfd
*, const gdb_byte
*, const struct comp_unit_head
*,
1814 unsigned int *, unsigned int *);
1816 static LONGEST
read_offset (bfd
*, const gdb_byte
*,
1817 const struct comp_unit_head
*,
1820 static LONGEST
read_offset_1 (bfd
*, const gdb_byte
*, unsigned int);
1822 static sect_offset read_abbrev_offset
1823 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
1824 struct dwarf2_section_info
*, sect_offset
);
1826 static const gdb_byte
*read_n_bytes (bfd
*, const gdb_byte
*, unsigned int);
1828 static const char *read_direct_string (bfd
*, const gdb_byte
*, unsigned int *);
1830 static const char *read_indirect_string
1831 (struct dwarf2_per_objfile
*dwarf2_per_objfile
, bfd
*, const gdb_byte
*,
1832 const struct comp_unit_head
*, unsigned int *);
1834 static const char *read_indirect_line_string
1835 (struct dwarf2_per_objfile
*dwarf2_per_objfile
, bfd
*, const gdb_byte
*,
1836 const struct comp_unit_head
*, unsigned int *);
1838 static const char *read_indirect_string_at_offset
1839 (struct dwarf2_per_objfile
*dwarf2_per_objfile
, bfd
*abfd
,
1840 LONGEST str_offset
);
1842 static const char *read_indirect_string_from_dwz
1843 (struct objfile
*objfile
, struct dwz_file
*, LONGEST
);
1845 static LONGEST
read_signed_leb128 (bfd
*, const gdb_byte
*, unsigned int *);
1847 static CORE_ADDR
read_addr_index_from_leb128 (struct dwarf2_cu
*,
1851 static const char *read_str_index (const struct die_reader_specs
*reader
,
1852 ULONGEST str_index
);
1854 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
1856 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
1857 struct dwarf2_cu
*);
1859 static struct attribute
*dwarf2_attr_no_follow (struct die_info
*,
1862 static const char *dwarf2_string_attr (struct die_info
*die
, unsigned int name
,
1863 struct dwarf2_cu
*cu
);
1865 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
1866 struct dwarf2_cu
*cu
);
1868 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
1870 static struct die_info
*die_specification (struct die_info
*die
,
1871 struct dwarf2_cu
**);
1873 static line_header_up
dwarf_decode_line_header (sect_offset sect_off
,
1874 struct dwarf2_cu
*cu
);
1876 static void dwarf_decode_lines (struct line_header
*, const char *,
1877 struct dwarf2_cu
*, struct partial_symtab
*,
1878 CORE_ADDR
, int decode_mapping
);
1880 static void dwarf2_start_subfile (const char *, const char *);
1882 static struct compunit_symtab
*dwarf2_start_symtab (struct dwarf2_cu
*,
1883 const char *, const char *,
1886 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
1887 struct dwarf2_cu
*);
1889 static struct symbol
*new_symbol_full (struct die_info
*, struct type
*,
1890 struct dwarf2_cu
*, struct symbol
*);
1892 static void dwarf2_const_value (const struct attribute
*, struct symbol
*,
1893 struct dwarf2_cu
*);
1895 static void dwarf2_const_value_attr (const struct attribute
*attr
,
1898 struct obstack
*obstack
,
1899 struct dwarf2_cu
*cu
, LONGEST
*value
,
1900 const gdb_byte
**bytes
,
1901 struct dwarf2_locexpr_baton
**baton
);
1903 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
1905 static int need_gnat_info (struct dwarf2_cu
*);
1907 static struct type
*die_descriptive_type (struct die_info
*,
1908 struct dwarf2_cu
*);
1910 static void set_descriptive_type (struct type
*, struct die_info
*,
1911 struct dwarf2_cu
*);
1913 static struct type
*die_containing_type (struct die_info
*,
1914 struct dwarf2_cu
*);
1916 static struct type
*lookup_die_type (struct die_info
*, const struct attribute
*,
1917 struct dwarf2_cu
*);
1919 static struct type
*read_type_die (struct die_info
*, struct dwarf2_cu
*);
1921 static struct type
*read_type_die_1 (struct die_info
*, struct dwarf2_cu
*);
1923 static const char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
1925 static char *typename_concat (struct obstack
*obs
, const char *prefix
,
1926 const char *suffix
, int physname
,
1927 struct dwarf2_cu
*cu
);
1929 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
1931 static void read_type_unit_scope (struct die_info
*, struct dwarf2_cu
*);
1933 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
1935 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
1937 static void read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
);
1939 static void read_variable (struct die_info
*die
, struct dwarf2_cu
*cu
);
1941 static int dwarf2_ranges_read (unsigned, CORE_ADDR
*, CORE_ADDR
*,
1942 struct dwarf2_cu
*, struct partial_symtab
*);
1944 /* How dwarf2_get_pc_bounds constructed its *LOWPC and *HIGHPC return
1945 values. Keep the items ordered with increasing constraints compliance. */
1948 /* No attribute DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges was found. */
1949 PC_BOUNDS_NOT_PRESENT
,
1951 /* Some of the attributes DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges
1952 were present but they do not form a valid range of PC addresses. */
1955 /* Discontiguous range was found - that is DW_AT_ranges was found. */
1958 /* Contiguous range was found - DW_AT_low_pc and DW_AT_high_pc were found. */
1962 static enum pc_bounds_kind
dwarf2_get_pc_bounds (struct die_info
*,
1963 CORE_ADDR
*, CORE_ADDR
*,
1965 struct partial_symtab
*);
1967 static void get_scope_pc_bounds (struct die_info
*,
1968 CORE_ADDR
*, CORE_ADDR
*,
1969 struct dwarf2_cu
*);
1971 static void dwarf2_record_block_ranges (struct die_info
*, struct block
*,
1972 CORE_ADDR
, struct dwarf2_cu
*);
1974 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
1975 struct dwarf2_cu
*);
1977 static void dwarf2_attach_fields_to_type (struct field_info
*,
1978 struct type
*, struct dwarf2_cu
*);
1980 static void dwarf2_add_member_fn (struct field_info
*,
1981 struct die_info
*, struct type
*,
1982 struct dwarf2_cu
*);
1984 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
1986 struct dwarf2_cu
*);
1988 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
1990 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
1992 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
1994 static void read_module (struct die_info
*die
, struct dwarf2_cu
*cu
);
1996 static struct using_direct
**using_directives (enum language
);
1998 static void read_import_statement (struct die_info
*die
, struct dwarf2_cu
*);
2000 static int read_namespace_alias (struct die_info
*die
, struct dwarf2_cu
*cu
);
2002 static struct type
*read_module_type (struct die_info
*die
,
2003 struct dwarf2_cu
*cu
);
2005 static const char *namespace_name (struct die_info
*die
,
2006 int *is_anonymous
, struct dwarf2_cu
*);
2008 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
2010 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
2012 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
2013 struct dwarf2_cu
*);
2015 static struct die_info
*read_die_and_siblings_1
2016 (const struct die_reader_specs
*, const gdb_byte
*, const gdb_byte
**,
2019 static struct die_info
*read_die_and_siblings (const struct die_reader_specs
*,
2020 const gdb_byte
*info_ptr
,
2021 const gdb_byte
**new_info_ptr
,
2022 struct die_info
*parent
);
2024 static const gdb_byte
*read_full_die_1 (const struct die_reader_specs
*,
2025 struct die_info
**, const gdb_byte
*,
2028 static const gdb_byte
*read_full_die (const struct die_reader_specs
*,
2029 struct die_info
**, const gdb_byte
*,
2032 static void process_die (struct die_info
*, struct dwarf2_cu
*);
2034 static const char *dwarf2_canonicalize_name (const char *, struct dwarf2_cu
*,
2037 static const char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
2039 static const char *dwarf2_full_name (const char *name
,
2040 struct die_info
*die
,
2041 struct dwarf2_cu
*cu
);
2043 static const char *dwarf2_physname (const char *name
, struct die_info
*die
,
2044 struct dwarf2_cu
*cu
);
2046 static struct die_info
*dwarf2_extension (struct die_info
*die
,
2047 struct dwarf2_cu
**);
2049 static const char *dwarf_tag_name (unsigned int);
2051 static const char *dwarf_attr_name (unsigned int);
2053 static const char *dwarf_form_name (unsigned int);
2055 static const char *dwarf_bool_name (unsigned int);
2057 static const char *dwarf_type_encoding_name (unsigned int);
2059 static struct die_info
*sibling_die (struct die_info
*);
2061 static void dump_die_shallow (struct ui_file
*, int indent
, struct die_info
*);
2063 static void dump_die_for_error (struct die_info
*);
2065 static void dump_die_1 (struct ui_file
*, int level
, int max_level
,
2068 /*static*/ void dump_die (struct die_info
*, int max_level
);
2070 static void store_in_ref_table (struct die_info
*,
2071 struct dwarf2_cu
*);
2073 static sect_offset
dwarf2_get_ref_die_offset (const struct attribute
*);
2075 static LONGEST
dwarf2_get_attr_constant_value (const struct attribute
*, int);
2077 static struct die_info
*follow_die_ref_or_sig (struct die_info
*,
2078 const struct attribute
*,
2079 struct dwarf2_cu
**);
2081 static struct die_info
*follow_die_ref (struct die_info
*,
2082 const struct attribute
*,
2083 struct dwarf2_cu
**);
2085 static struct die_info
*follow_die_sig (struct die_info
*,
2086 const struct attribute
*,
2087 struct dwarf2_cu
**);
2089 static struct type
*get_signatured_type (struct die_info
*, ULONGEST
,
2090 struct dwarf2_cu
*);
2092 static struct type
*get_DW_AT_signature_type (struct die_info
*,
2093 const struct attribute
*,
2094 struct dwarf2_cu
*);
2096 static void load_full_type_unit (struct dwarf2_per_cu_data
*per_cu
);
2098 static void read_signatured_type (struct signatured_type
*);
2100 static int attr_to_dynamic_prop (const struct attribute
*attr
,
2101 struct die_info
*die
, struct dwarf2_cu
*cu
,
2102 struct dynamic_prop
*prop
);
2104 /* memory allocation interface */
2106 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
2108 static struct die_info
*dwarf_alloc_die (struct dwarf2_cu
*, int);
2110 static void dwarf_decode_macros (struct dwarf2_cu
*, unsigned int, int);
2112 static int attr_form_is_block (const struct attribute
*);
2114 static int attr_form_is_section_offset (const struct attribute
*);
2116 static int attr_form_is_constant (const struct attribute
*);
2118 static int attr_form_is_ref (const struct attribute
*);
2120 static void fill_in_loclist_baton (struct dwarf2_cu
*cu
,
2121 struct dwarf2_loclist_baton
*baton
,
2122 const struct attribute
*attr
);
2124 static void dwarf2_symbol_mark_computed (const struct attribute
*attr
,
2126 struct dwarf2_cu
*cu
,
2129 static const gdb_byte
*skip_one_die (const struct die_reader_specs
*reader
,
2130 const gdb_byte
*info_ptr
,
2131 struct abbrev_info
*abbrev
);
2133 static void free_stack_comp_unit (void *);
2135 static hashval_t
partial_die_hash (const void *item
);
2137 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
2139 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
2140 (sect_offset sect_off
, unsigned int offset_in_dwz
,
2141 struct dwarf2_per_objfile
*dwarf2_per_objfile
);
2143 static void init_one_comp_unit (struct dwarf2_cu
*cu
,
2144 struct dwarf2_per_cu_data
*per_cu
);
2146 static void prepare_one_comp_unit (struct dwarf2_cu
*cu
,
2147 struct die_info
*comp_unit_die
,
2148 enum language pretend_language
);
2150 static void free_heap_comp_unit (void *);
2152 static void free_cached_comp_units (void *);
2154 static void age_cached_comp_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
2156 static void free_one_cached_comp_unit (struct dwarf2_per_cu_data
*);
2158 static struct type
*set_die_type (struct die_info
*, struct type
*,
2159 struct dwarf2_cu
*);
2161 static void create_all_comp_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
2163 static int create_all_type_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
2165 static void load_full_comp_unit (struct dwarf2_per_cu_data
*,
2168 static void process_full_comp_unit (struct dwarf2_per_cu_data
*,
2171 static void process_full_type_unit (struct dwarf2_per_cu_data
*,
2174 static void dwarf2_add_dependence (struct dwarf2_cu
*,
2175 struct dwarf2_per_cu_data
*);
2177 static void dwarf2_mark (struct dwarf2_cu
*);
2179 static void dwarf2_clear_marks (struct dwarf2_per_cu_data
*);
2181 static struct type
*get_die_type_at_offset (sect_offset
,
2182 struct dwarf2_per_cu_data
*);
2184 static struct type
*get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
2186 static void dwarf2_release_queue (void *dummy
);
2188 static void queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
2189 enum language pretend_language
);
2191 static void process_queue (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
2193 /* The return type of find_file_and_directory. Note, the enclosed
2194 string pointers are only valid while this object is valid. */
2196 struct file_and_directory
2198 /* The filename. This is never NULL. */
2201 /* The compilation directory. NULL if not known. If we needed to
2202 compute a new string, this points to COMP_DIR_STORAGE, otherwise,
2203 points directly to the DW_AT_comp_dir string attribute owned by
2204 the obstack that owns the DIE. */
2205 const char *comp_dir
;
2207 /* If we needed to build a new string for comp_dir, this is what
2208 owns the storage. */
2209 std::string comp_dir_storage
;
2212 static file_and_directory
find_file_and_directory (struct die_info
*die
,
2213 struct dwarf2_cu
*cu
);
2215 static char *file_full_name (int file
, struct line_header
*lh
,
2216 const char *comp_dir
);
2218 /* Expected enum dwarf_unit_type for read_comp_unit_head. */
2219 enum class rcuh_kind
{ COMPILE
, TYPE
};
2221 static const gdb_byte
*read_and_check_comp_unit_head
2222 (struct dwarf2_per_objfile
* dwarf2_per_objfile
,
2223 struct comp_unit_head
*header
,
2224 struct dwarf2_section_info
*section
,
2225 struct dwarf2_section_info
*abbrev_section
, const gdb_byte
*info_ptr
,
2226 rcuh_kind section_kind
);
2228 static void init_cutu_and_read_dies
2229 (struct dwarf2_per_cu_data
*this_cu
, struct abbrev_table
*abbrev_table
,
2230 int use_existing_cu
, int keep
,
2231 die_reader_func_ftype
*die_reader_func
, void *data
);
2233 static void init_cutu_and_read_dies_simple
2234 (struct dwarf2_per_cu_data
*this_cu
,
2235 die_reader_func_ftype
*die_reader_func
, void *data
);
2237 static htab_t
allocate_signatured_type_table (struct objfile
*objfile
);
2239 static htab_t
allocate_dwo_unit_table (struct objfile
*objfile
);
2241 static struct dwo_unit
*lookup_dwo_unit_in_dwp
2242 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
2243 struct dwp_file
*dwp_file
, const char *comp_dir
,
2244 ULONGEST signature
, int is_debug_types
);
2246 static struct dwp_file
*get_dwp_file
2247 (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
2249 static struct dwo_unit
*lookup_dwo_comp_unit
2250 (struct dwarf2_per_cu_data
*, const char *, const char *, ULONGEST
);
2252 static struct dwo_unit
*lookup_dwo_type_unit
2253 (struct signatured_type
*, const char *, const char *);
2255 static void queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data
*);
2257 static void free_dwo_file_cleanup (void *);
2259 struct free_dwo_file_cleanup_data
2261 struct dwo_file
*dwo_file
;
2262 struct dwarf2_per_objfile
*dwarf2_per_objfile
;
2265 static void process_cu_includes (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
2267 static void check_producer (struct dwarf2_cu
*cu
);
2269 static void free_line_header_voidp (void *arg
);
2271 /* Various complaints about symbol reading that don't abort the process. */
2274 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
2276 complaint (&symfile_complaints
,
2277 _("statement list doesn't fit in .debug_line section"));
2281 dwarf2_debug_line_missing_file_complaint (void)
2283 complaint (&symfile_complaints
,
2284 _(".debug_line section has line data without a file"));
2288 dwarf2_debug_line_missing_end_sequence_complaint (void)
2290 complaint (&symfile_complaints
,
2291 _(".debug_line section has line "
2292 "program sequence without an end"));
2296 dwarf2_complex_location_expr_complaint (void)
2298 complaint (&symfile_complaints
, _("location expression too complex"));
2302 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
2305 complaint (&symfile_complaints
,
2306 _("const value length mismatch for '%s', got %d, expected %d"),
2311 dwarf2_section_buffer_overflow_complaint (struct dwarf2_section_info
*section
)
2313 complaint (&symfile_complaints
,
2314 _("debug info runs off end of %s section"
2316 get_section_name (section
),
2317 get_section_file_name (section
));
2321 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
2323 complaint (&symfile_complaints
,
2324 _("macro debug info contains a "
2325 "malformed macro definition:\n`%s'"),
2330 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
2332 complaint (&symfile_complaints
,
2333 _("invalid attribute class or form for '%s' in '%s'"),
2337 /* Hash function for line_header_hash. */
2340 line_header_hash (const struct line_header
*ofs
)
2342 return to_underlying (ofs
->sect_off
) ^ ofs
->offset_in_dwz
;
2345 /* Hash function for htab_create_alloc_ex for line_header_hash. */
2348 line_header_hash_voidp (const void *item
)
2350 const struct line_header
*ofs
= (const struct line_header
*) item
;
2352 return line_header_hash (ofs
);
2355 /* Equality function for line_header_hash. */
2358 line_header_eq_voidp (const void *item_lhs
, const void *item_rhs
)
2360 const struct line_header
*ofs_lhs
= (const struct line_header
*) item_lhs
;
2361 const struct line_header
*ofs_rhs
= (const struct line_header
*) item_rhs
;
2363 return (ofs_lhs
->sect_off
== ofs_rhs
->sect_off
2364 && ofs_lhs
->offset_in_dwz
== ofs_rhs
->offset_in_dwz
);
2369 /* Read the given attribute value as an address, taking the attribute's
2370 form into account. */
2373 attr_value_as_address (struct attribute
*attr
)
2377 if (attr
->form
!= DW_FORM_addr
&& attr
->form
!= DW_FORM_GNU_addr_index
)
2379 /* Aside from a few clearly defined exceptions, attributes that
2380 contain an address must always be in DW_FORM_addr form.
2381 Unfortunately, some compilers happen to be violating this
2382 requirement by encoding addresses using other forms, such
2383 as DW_FORM_data4 for example. For those broken compilers,
2384 we try to do our best, without any guarantee of success,
2385 to interpret the address correctly. It would also be nice
2386 to generate a complaint, but that would require us to maintain
2387 a list of legitimate cases where a non-address form is allowed,
2388 as well as update callers to pass in at least the CU's DWARF
2389 version. This is more overhead than what we're willing to
2390 expand for a pretty rare case. */
2391 addr
= DW_UNSND (attr
);
2394 addr
= DW_ADDR (attr
);
2399 /* The suffix for an index file. */
2400 #define INDEX4_SUFFIX ".gdb-index"
2401 #define INDEX5_SUFFIX ".debug_names"
2402 #define DEBUG_STR_SUFFIX ".debug_str"
2404 /* See declaration. */
2406 dwarf2_per_objfile::dwarf2_per_objfile (struct objfile
*objfile_
,
2407 const dwarf2_debug_sections
*names
)
2408 : objfile (objfile_
)
2411 names
= &dwarf2_elf_names
;
2413 bfd
*obfd
= objfile
->obfd
;
2415 for (asection
*sec
= obfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2416 locate_sections (obfd
, sec
, *names
);
2419 dwarf2_per_objfile::~dwarf2_per_objfile ()
2421 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
2422 free_cached_comp_units ();
2424 if (quick_file_names_table
)
2425 htab_delete (quick_file_names_table
);
2427 if (line_header_hash
)
2428 htab_delete (line_header_hash
);
2430 /* Everything else should be on the objfile obstack. */
2433 /* See declaration. */
2436 dwarf2_per_objfile::free_cached_comp_units ()
2438 dwarf2_per_cu_data
*per_cu
= read_in_chain
;
2439 dwarf2_per_cu_data
**last_chain
= &read_in_chain
;
2440 while (per_cu
!= NULL
)
2442 dwarf2_per_cu_data
*next_cu
= per_cu
->cu
->read_in_chain
;
2444 free_heap_comp_unit (per_cu
->cu
);
2445 *last_chain
= next_cu
;
2450 /* Try to locate the sections we need for DWARF 2 debugging
2451 information and return true if we have enough to do something.
2452 NAMES points to the dwarf2 section names, or is NULL if the standard
2453 ELF names are used. */
2456 dwarf2_has_info (struct objfile
*objfile
,
2457 const struct dwarf2_debug_sections
*names
)
2459 if (objfile
->flags
& OBJF_READNEVER
)
2462 struct dwarf2_per_objfile
*dwarf2_per_objfile
2463 = get_dwarf2_per_objfile (objfile
);
2465 if (dwarf2_per_objfile
== NULL
)
2467 /* Initialize per-objfile state. */
2468 struct dwarf2_per_objfile
*data
2469 = XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_per_objfile
);
2471 dwarf2_per_objfile
= new (data
) struct dwarf2_per_objfile (objfile
, names
);
2472 set_dwarf2_per_objfile (objfile
, dwarf2_per_objfile
);
2474 return (!dwarf2_per_objfile
->info
.is_virtual
2475 && dwarf2_per_objfile
->info
.s
.section
!= NULL
2476 && !dwarf2_per_objfile
->abbrev
.is_virtual
2477 && dwarf2_per_objfile
->abbrev
.s
.section
!= NULL
);
2480 /* Return the containing section of virtual section SECTION. */
2482 static struct dwarf2_section_info
*
2483 get_containing_section (const struct dwarf2_section_info
*section
)
2485 gdb_assert (section
->is_virtual
);
2486 return section
->s
.containing_section
;
2489 /* Return the bfd owner of SECTION. */
2492 get_section_bfd_owner (const struct dwarf2_section_info
*section
)
2494 if (section
->is_virtual
)
2496 section
= get_containing_section (section
);
2497 gdb_assert (!section
->is_virtual
);
2499 return section
->s
.section
->owner
;
2502 /* Return the bfd section of SECTION.
2503 Returns NULL if the section is not present. */
2506 get_section_bfd_section (const struct dwarf2_section_info
*section
)
2508 if (section
->is_virtual
)
2510 section
= get_containing_section (section
);
2511 gdb_assert (!section
->is_virtual
);
2513 return section
->s
.section
;
2516 /* Return the name of SECTION. */
2519 get_section_name (const struct dwarf2_section_info
*section
)
2521 asection
*sectp
= get_section_bfd_section (section
);
2523 gdb_assert (sectp
!= NULL
);
2524 return bfd_section_name (get_section_bfd_owner (section
), sectp
);
2527 /* Return the name of the file SECTION is in. */
2530 get_section_file_name (const struct dwarf2_section_info
*section
)
2532 bfd
*abfd
= get_section_bfd_owner (section
);
2534 return bfd_get_filename (abfd
);
2537 /* Return the id of SECTION.
2538 Returns 0 if SECTION doesn't exist. */
2541 get_section_id (const struct dwarf2_section_info
*section
)
2543 asection
*sectp
= get_section_bfd_section (section
);
2550 /* Return the flags of SECTION.
2551 SECTION (or containing section if this is a virtual section) must exist. */
2554 get_section_flags (const struct dwarf2_section_info
*section
)
2556 asection
*sectp
= get_section_bfd_section (section
);
2558 gdb_assert (sectp
!= NULL
);
2559 return bfd_get_section_flags (sectp
->owner
, sectp
);
2562 /* When loading sections, we look either for uncompressed section or for
2563 compressed section names. */
2566 section_is_p (const char *section_name
,
2567 const struct dwarf2_section_names
*names
)
2569 if (names
->normal
!= NULL
2570 && strcmp (section_name
, names
->normal
) == 0)
2572 if (names
->compressed
!= NULL
2573 && strcmp (section_name
, names
->compressed
) == 0)
2578 /* See declaration. */
2581 dwarf2_per_objfile::locate_sections (bfd
*abfd
, asection
*sectp
,
2582 const dwarf2_debug_sections
&names
)
2584 flagword aflag
= bfd_get_section_flags (abfd
, sectp
);
2586 if ((aflag
& SEC_HAS_CONTENTS
) == 0)
2589 else if (section_is_p (sectp
->name
, &names
.info
))
2591 this->info
.s
.section
= sectp
;
2592 this->info
.size
= bfd_get_section_size (sectp
);
2594 else if (section_is_p (sectp
->name
, &names
.abbrev
))
2596 this->abbrev
.s
.section
= sectp
;
2597 this->abbrev
.size
= bfd_get_section_size (sectp
);
2599 else if (section_is_p (sectp
->name
, &names
.line
))
2601 this->line
.s
.section
= sectp
;
2602 this->line
.size
= bfd_get_section_size (sectp
);
2604 else if (section_is_p (sectp
->name
, &names
.loc
))
2606 this->loc
.s
.section
= sectp
;
2607 this->loc
.size
= bfd_get_section_size (sectp
);
2609 else if (section_is_p (sectp
->name
, &names
.loclists
))
2611 this->loclists
.s
.section
= sectp
;
2612 this->loclists
.size
= bfd_get_section_size (sectp
);
2614 else if (section_is_p (sectp
->name
, &names
.macinfo
))
2616 this->macinfo
.s
.section
= sectp
;
2617 this->macinfo
.size
= bfd_get_section_size (sectp
);
2619 else if (section_is_p (sectp
->name
, &names
.macro
))
2621 this->macro
.s
.section
= sectp
;
2622 this->macro
.size
= bfd_get_section_size (sectp
);
2624 else if (section_is_p (sectp
->name
, &names
.str
))
2626 this->str
.s
.section
= sectp
;
2627 this->str
.size
= bfd_get_section_size (sectp
);
2629 else if (section_is_p (sectp
->name
, &names
.line_str
))
2631 this->line_str
.s
.section
= sectp
;
2632 this->line_str
.size
= bfd_get_section_size (sectp
);
2634 else if (section_is_p (sectp
->name
, &names
.addr
))
2636 this->addr
.s
.section
= sectp
;
2637 this->addr
.size
= bfd_get_section_size (sectp
);
2639 else if (section_is_p (sectp
->name
, &names
.frame
))
2641 this->frame
.s
.section
= sectp
;
2642 this->frame
.size
= bfd_get_section_size (sectp
);
2644 else if (section_is_p (sectp
->name
, &names
.eh_frame
))
2646 this->eh_frame
.s
.section
= sectp
;
2647 this->eh_frame
.size
= bfd_get_section_size (sectp
);
2649 else if (section_is_p (sectp
->name
, &names
.ranges
))
2651 this->ranges
.s
.section
= sectp
;
2652 this->ranges
.size
= bfd_get_section_size (sectp
);
2654 else if (section_is_p (sectp
->name
, &names
.rnglists
))
2656 this->rnglists
.s
.section
= sectp
;
2657 this->rnglists
.size
= bfd_get_section_size (sectp
);
2659 else if (section_is_p (sectp
->name
, &names
.types
))
2661 struct dwarf2_section_info type_section
;
2663 memset (&type_section
, 0, sizeof (type_section
));
2664 type_section
.s
.section
= sectp
;
2665 type_section
.size
= bfd_get_section_size (sectp
);
2667 VEC_safe_push (dwarf2_section_info_def
, this->types
,
2670 else if (section_is_p (sectp
->name
, &names
.gdb_index
))
2672 this->gdb_index
.s
.section
= sectp
;
2673 this->gdb_index
.size
= bfd_get_section_size (sectp
);
2675 else if (section_is_p (sectp
->name
, &names
.debug_names
))
2677 this->debug_names
.s
.section
= sectp
;
2678 this->debug_names
.size
= bfd_get_section_size (sectp
);
2680 else if (section_is_p (sectp
->name
, &names
.debug_aranges
))
2682 this->debug_aranges
.s
.section
= sectp
;
2683 this->debug_aranges
.size
= bfd_get_section_size (sectp
);
2686 if ((bfd_get_section_flags (abfd
, sectp
) & (SEC_LOAD
| SEC_ALLOC
))
2687 && bfd_section_vma (abfd
, sectp
) == 0)
2688 this->has_section_at_zero
= true;
2691 /* A helper function that decides whether a section is empty,
2695 dwarf2_section_empty_p (const struct dwarf2_section_info
*section
)
2697 if (section
->is_virtual
)
2698 return section
->size
== 0;
2699 return section
->s
.section
== NULL
|| section
->size
== 0;
2702 /* Read the contents of the section INFO.
2703 OBJFILE is the main object file, but not necessarily the file where
2704 the section comes from. E.g., for DWO files the bfd of INFO is the bfd
2706 If the section is compressed, uncompress it before returning. */
2709 dwarf2_read_section (struct objfile
*objfile
, struct dwarf2_section_info
*info
)
2713 gdb_byte
*buf
, *retbuf
;
2717 info
->buffer
= NULL
;
2720 if (dwarf2_section_empty_p (info
))
2723 sectp
= get_section_bfd_section (info
);
2725 /* If this is a virtual section we need to read in the real one first. */
2726 if (info
->is_virtual
)
2728 struct dwarf2_section_info
*containing_section
=
2729 get_containing_section (info
);
2731 gdb_assert (sectp
!= NULL
);
2732 if ((sectp
->flags
& SEC_RELOC
) != 0)
2734 error (_("Dwarf Error: DWP format V2 with relocations is not"
2735 " supported in section %s [in module %s]"),
2736 get_section_name (info
), get_section_file_name (info
));
2738 dwarf2_read_section (objfile
, containing_section
);
2739 /* Other code should have already caught virtual sections that don't
2741 gdb_assert (info
->virtual_offset
+ info
->size
2742 <= containing_section
->size
);
2743 /* If the real section is empty or there was a problem reading the
2744 section we shouldn't get here. */
2745 gdb_assert (containing_section
->buffer
!= NULL
);
2746 info
->buffer
= containing_section
->buffer
+ info
->virtual_offset
;
2750 /* If the section has relocations, we must read it ourselves.
2751 Otherwise we attach it to the BFD. */
2752 if ((sectp
->flags
& SEC_RELOC
) == 0)
2754 info
->buffer
= gdb_bfd_map_section (sectp
, &info
->size
);
2758 buf
= (gdb_byte
*) obstack_alloc (&objfile
->objfile_obstack
, info
->size
);
2761 /* When debugging .o files, we may need to apply relocations; see
2762 http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
2763 We never compress sections in .o files, so we only need to
2764 try this when the section is not compressed. */
2765 retbuf
= symfile_relocate_debug_section (objfile
, sectp
, buf
);
2768 info
->buffer
= retbuf
;
2772 abfd
= get_section_bfd_owner (info
);
2773 gdb_assert (abfd
!= NULL
);
2775 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
2776 || bfd_bread (buf
, info
->size
, abfd
) != info
->size
)
2778 error (_("Dwarf Error: Can't read DWARF data"
2779 " in section %s [in module %s]"),
2780 bfd_section_name (abfd
, sectp
), bfd_get_filename (abfd
));
2784 /* A helper function that returns the size of a section in a safe way.
2785 If you are positive that the section has been read before using the
2786 size, then it is safe to refer to the dwarf2_section_info object's
2787 "size" field directly. In other cases, you must call this
2788 function, because for compressed sections the size field is not set
2789 correctly until the section has been read. */
2791 static bfd_size_type
2792 dwarf2_section_size (struct objfile
*objfile
,
2793 struct dwarf2_section_info
*info
)
2796 dwarf2_read_section (objfile
, info
);
2800 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
2804 dwarf2_get_section_info (struct objfile
*objfile
,
2805 enum dwarf2_section_enum sect
,
2806 asection
**sectp
, const gdb_byte
**bufp
,
2807 bfd_size_type
*sizep
)
2809 struct dwarf2_per_objfile
*data
2810 = (struct dwarf2_per_objfile
*) objfile_data (objfile
,
2811 dwarf2_objfile_data_key
);
2812 struct dwarf2_section_info
*info
;
2814 /* We may see an objfile without any DWARF, in which case we just
2825 case DWARF2_DEBUG_FRAME
:
2826 info
= &data
->frame
;
2828 case DWARF2_EH_FRAME
:
2829 info
= &data
->eh_frame
;
2832 gdb_assert_not_reached ("unexpected section");
2835 dwarf2_read_section (objfile
, info
);
2837 *sectp
= get_section_bfd_section (info
);
2838 *bufp
= info
->buffer
;
2839 *sizep
= info
->size
;
2842 /* A helper function to find the sections for a .dwz file. */
2845 locate_dwz_sections (bfd
*abfd
, asection
*sectp
, void *arg
)
2847 struct dwz_file
*dwz_file
= (struct dwz_file
*) arg
;
2849 /* Note that we only support the standard ELF names, because .dwz
2850 is ELF-only (at the time of writing). */
2851 if (section_is_p (sectp
->name
, &dwarf2_elf_names
.abbrev
))
2853 dwz_file
->abbrev
.s
.section
= sectp
;
2854 dwz_file
->abbrev
.size
= bfd_get_section_size (sectp
);
2856 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.info
))
2858 dwz_file
->info
.s
.section
= sectp
;
2859 dwz_file
->info
.size
= bfd_get_section_size (sectp
);
2861 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.str
))
2863 dwz_file
->str
.s
.section
= sectp
;
2864 dwz_file
->str
.size
= bfd_get_section_size (sectp
);
2866 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.line
))
2868 dwz_file
->line
.s
.section
= sectp
;
2869 dwz_file
->line
.size
= bfd_get_section_size (sectp
);
2871 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.macro
))
2873 dwz_file
->macro
.s
.section
= sectp
;
2874 dwz_file
->macro
.size
= bfd_get_section_size (sectp
);
2876 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.gdb_index
))
2878 dwz_file
->gdb_index
.s
.section
= sectp
;
2879 dwz_file
->gdb_index
.size
= bfd_get_section_size (sectp
);
2881 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.debug_names
))
2883 dwz_file
->debug_names
.s
.section
= sectp
;
2884 dwz_file
->debug_names
.size
= bfd_get_section_size (sectp
);
2888 /* Open the separate '.dwz' debug file, if needed. Return NULL if
2889 there is no .gnu_debugaltlink section in the file. Error if there
2890 is such a section but the file cannot be found. */
2892 static struct dwz_file
*
2893 dwarf2_get_dwz_file (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
2895 const char *filename
;
2896 struct dwz_file
*result
;
2897 bfd_size_type buildid_len_arg
;
2901 if (dwarf2_per_objfile
->dwz_file
!= NULL
)
2902 return dwarf2_per_objfile
->dwz_file
;
2904 bfd_set_error (bfd_error_no_error
);
2905 gdb::unique_xmalloc_ptr
<char> data
2906 (bfd_get_alt_debug_link_info (dwarf2_per_objfile
->objfile
->obfd
,
2907 &buildid_len_arg
, &buildid
));
2910 if (bfd_get_error () == bfd_error_no_error
)
2912 error (_("could not read '.gnu_debugaltlink' section: %s"),
2913 bfd_errmsg (bfd_get_error ()));
2916 gdb::unique_xmalloc_ptr
<bfd_byte
> buildid_holder (buildid
);
2918 buildid_len
= (size_t) buildid_len_arg
;
2920 filename
= data
.get ();
2922 std::string abs_storage
;
2923 if (!IS_ABSOLUTE_PATH (filename
))
2925 gdb::unique_xmalloc_ptr
<char> abs
2926 = gdb_realpath (objfile_name (dwarf2_per_objfile
->objfile
));
2928 abs_storage
= ldirname (abs
.get ()) + SLASH_STRING
+ filename
;
2929 filename
= abs_storage
.c_str ();
2932 /* First try the file name given in the section. If that doesn't
2933 work, try to use the build-id instead. */
2934 gdb_bfd_ref_ptr
dwz_bfd (gdb_bfd_open (filename
, gnutarget
, -1));
2935 if (dwz_bfd
!= NULL
)
2937 if (!build_id_verify (dwz_bfd
.get (), buildid_len
, buildid
))
2941 if (dwz_bfd
== NULL
)
2942 dwz_bfd
= build_id_to_debug_bfd (buildid_len
, buildid
);
2944 if (dwz_bfd
== NULL
)
2945 error (_("could not find '.gnu_debugaltlink' file for %s"),
2946 objfile_name (dwarf2_per_objfile
->objfile
));
2948 result
= OBSTACK_ZALLOC (&dwarf2_per_objfile
->objfile
->objfile_obstack
,
2950 result
->dwz_bfd
= dwz_bfd
.release ();
2952 bfd_map_over_sections (result
->dwz_bfd
, locate_dwz_sections
, result
);
2954 gdb_bfd_record_inclusion (dwarf2_per_objfile
->objfile
->obfd
, result
->dwz_bfd
);
2955 dwarf2_per_objfile
->dwz_file
= result
;
2959 /* DWARF quick_symbols_functions support. */
2961 /* TUs can share .debug_line entries, and there can be a lot more TUs than
2962 unique line tables, so we maintain a separate table of all .debug_line
2963 derived entries to support the sharing.
2964 All the quick functions need is the list of file names. We discard the
2965 line_header when we're done and don't need to record it here. */
2966 struct quick_file_names
2968 /* The data used to construct the hash key. */
2969 struct stmt_list_hash hash
;
2971 /* The number of entries in file_names, real_names. */
2972 unsigned int num_file_names
;
2974 /* The file names from the line table, after being run through
2976 const char **file_names
;
2978 /* The file names from the line table after being run through
2979 gdb_realpath. These are computed lazily. */
2980 const char **real_names
;
2983 /* When using the index (and thus not using psymtabs), each CU has an
2984 object of this type. This is used to hold information needed by
2985 the various "quick" methods. */
2986 struct dwarf2_per_cu_quick_data
2988 /* The file table. This can be NULL if there was no file table
2989 or it's currently not read in.
2990 NOTE: This points into dwarf2_per_objfile->quick_file_names_table. */
2991 struct quick_file_names
*file_names
;
2993 /* The corresponding symbol table. This is NULL if symbols for this
2994 CU have not yet been read. */
2995 struct compunit_symtab
*compunit_symtab
;
2997 /* A temporary mark bit used when iterating over all CUs in
2998 expand_symtabs_matching. */
2999 unsigned int mark
: 1;
3001 /* True if we've tried to read the file table and found there isn't one.
3002 There will be no point in trying to read it again next time. */
3003 unsigned int no_file_data
: 1;
3006 /* Utility hash function for a stmt_list_hash. */
3009 hash_stmt_list_entry (const struct stmt_list_hash
*stmt_list_hash
)
3013 if (stmt_list_hash
->dwo_unit
!= NULL
)
3014 v
+= (uintptr_t) stmt_list_hash
->dwo_unit
->dwo_file
;
3015 v
+= to_underlying (stmt_list_hash
->line_sect_off
);
3019 /* Utility equality function for a stmt_list_hash. */
3022 eq_stmt_list_entry (const struct stmt_list_hash
*lhs
,
3023 const struct stmt_list_hash
*rhs
)
3025 if ((lhs
->dwo_unit
!= NULL
) != (rhs
->dwo_unit
!= NULL
))
3027 if (lhs
->dwo_unit
!= NULL
3028 && lhs
->dwo_unit
->dwo_file
!= rhs
->dwo_unit
->dwo_file
)
3031 return lhs
->line_sect_off
== rhs
->line_sect_off
;
3034 /* Hash function for a quick_file_names. */
3037 hash_file_name_entry (const void *e
)
3039 const struct quick_file_names
*file_data
3040 = (const struct quick_file_names
*) e
;
3042 return hash_stmt_list_entry (&file_data
->hash
);
3045 /* Equality function for a quick_file_names. */
3048 eq_file_name_entry (const void *a
, const void *b
)
3050 const struct quick_file_names
*ea
= (const struct quick_file_names
*) a
;
3051 const struct quick_file_names
*eb
= (const struct quick_file_names
*) b
;
3053 return eq_stmt_list_entry (&ea
->hash
, &eb
->hash
);
3056 /* Delete function for a quick_file_names. */
3059 delete_file_name_entry (void *e
)
3061 struct quick_file_names
*file_data
= (struct quick_file_names
*) e
;
3064 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
3066 xfree ((void*) file_data
->file_names
[i
]);
3067 if (file_data
->real_names
)
3068 xfree ((void*) file_data
->real_names
[i
]);
3071 /* The space for the struct itself lives on objfile_obstack,
3072 so we don't free it here. */
3075 /* Create a quick_file_names hash table. */
3078 create_quick_file_names_table (unsigned int nr_initial_entries
)
3080 return htab_create_alloc (nr_initial_entries
,
3081 hash_file_name_entry
, eq_file_name_entry
,
3082 delete_file_name_entry
, xcalloc
, xfree
);
3085 /* Read in PER_CU->CU. This function is unrelated to symtabs, symtab would
3086 have to be created afterwards. You should call age_cached_comp_units after
3087 processing PER_CU->CU. dw2_setup must have been already called. */
3090 load_cu (struct dwarf2_per_cu_data
*per_cu
)
3092 if (per_cu
->is_debug_types
)
3093 load_full_type_unit (per_cu
);
3095 load_full_comp_unit (per_cu
, language_minimal
);
3097 if (per_cu
->cu
== NULL
)
3098 return; /* Dummy CU. */
3100 dwarf2_find_base_address (per_cu
->cu
->dies
, per_cu
->cu
);
3103 /* Read in the symbols for PER_CU. */
3106 dw2_do_instantiate_symtab (struct dwarf2_per_cu_data
*per_cu
)
3108 struct cleanup
*back_to
;
3109 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
3111 /* Skip type_unit_groups, reading the type units they contain
3112 is handled elsewhere. */
3113 if (IS_TYPE_UNIT_GROUP (per_cu
))
3116 back_to
= make_cleanup (dwarf2_release_queue
, NULL
);
3118 if (dwarf2_per_objfile
->using_index
3119 ? per_cu
->v
.quick
->compunit_symtab
== NULL
3120 : (per_cu
->v
.psymtab
== NULL
|| !per_cu
->v
.psymtab
->readin
))
3122 queue_comp_unit (per_cu
, language_minimal
);
3125 /* If we just loaded a CU from a DWO, and we're working with an index
3126 that may badly handle TUs, load all the TUs in that DWO as well.
3127 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
3128 if (!per_cu
->is_debug_types
3129 && per_cu
->cu
!= NULL
3130 && per_cu
->cu
->dwo_unit
!= NULL
3131 && dwarf2_per_objfile
->index_table
!= NULL
3132 && dwarf2_per_objfile
->index_table
->version
<= 7
3133 /* DWP files aren't supported yet. */
3134 && get_dwp_file (dwarf2_per_objfile
) == NULL
)
3135 queue_and_load_all_dwo_tus (per_cu
);
3138 process_queue (dwarf2_per_objfile
);
3140 /* Age the cache, releasing compilation units that have not
3141 been used recently. */
3142 age_cached_comp_units (dwarf2_per_objfile
);
3144 do_cleanups (back_to
);
3147 /* Ensure that the symbols for PER_CU have been read in. OBJFILE is
3148 the objfile from which this CU came. Returns the resulting symbol
3151 static struct compunit_symtab
*
3152 dw2_instantiate_symtab (struct dwarf2_per_cu_data
*per_cu
)
3154 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
3156 gdb_assert (dwarf2_per_objfile
->using_index
);
3157 if (!per_cu
->v
.quick
->compunit_symtab
)
3159 struct cleanup
*back_to
= make_cleanup (free_cached_comp_units
,
3160 dwarf2_per_objfile
);
3161 scoped_restore decrementer
= increment_reading_symtab ();
3162 dw2_do_instantiate_symtab (per_cu
);
3163 process_cu_includes (dwarf2_per_objfile
);
3164 do_cleanups (back_to
);
3167 return per_cu
->v
.quick
->compunit_symtab
;
3170 /* Return the CU/TU given its index.
3172 This is intended for loops like:
3174 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
3175 + dwarf2_per_objfile->n_type_units); ++i)
3177 struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (i);
3183 static struct dwarf2_per_cu_data
*
3184 dw2_get_cutu (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
3187 if (index
>= dwarf2_per_objfile
->n_comp_units
)
3189 index
-= dwarf2_per_objfile
->n_comp_units
;
3190 gdb_assert (index
< dwarf2_per_objfile
->n_type_units
);
3191 return &dwarf2_per_objfile
->all_type_units
[index
]->per_cu
;
3194 return dwarf2_per_objfile
->all_comp_units
[index
];
3197 /* Return the CU given its index.
3198 This differs from dw2_get_cutu in that it's for when you know INDEX
3201 static struct dwarf2_per_cu_data
*
3202 dw2_get_cu (struct dwarf2_per_objfile
*dwarf2_per_objfile
, int index
)
3204 gdb_assert (index
>= 0 && index
< dwarf2_per_objfile
->n_comp_units
);
3206 return dwarf2_per_objfile
->all_comp_units
[index
];
3209 /* Return a new dwarf2_per_cu_data allocated on OBJFILE's
3210 objfile_obstack, and constructed with the specified field
3213 static dwarf2_per_cu_data
*
3214 create_cu_from_index_list (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
3215 struct dwarf2_section_info
*section
,
3217 sect_offset sect_off
, ULONGEST length
)
3219 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
3220 dwarf2_per_cu_data
*the_cu
3221 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
3222 struct dwarf2_per_cu_data
);
3223 the_cu
->sect_off
= sect_off
;
3224 the_cu
->length
= length
;
3225 the_cu
->dwarf2_per_objfile
= dwarf2_per_objfile
;
3226 the_cu
->section
= section
;
3227 the_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
3228 struct dwarf2_per_cu_quick_data
);
3229 the_cu
->is_dwz
= is_dwz
;
3233 /* A helper for create_cus_from_index that handles a given list of
3237 create_cus_from_index_list (struct objfile
*objfile
,
3238 const gdb_byte
*cu_list
, offset_type n_elements
,
3239 struct dwarf2_section_info
*section
,
3244 struct dwarf2_per_objfile
*dwarf2_per_objfile
3245 = get_dwarf2_per_objfile (objfile
);
3247 for (i
= 0; i
< n_elements
; i
+= 2)
3249 gdb_static_assert (sizeof (ULONGEST
) >= 8);
3251 sect_offset sect_off
3252 = (sect_offset
) extract_unsigned_integer (cu_list
, 8, BFD_ENDIAN_LITTLE
);
3253 ULONGEST length
= extract_unsigned_integer (cu_list
+ 8, 8, BFD_ENDIAN_LITTLE
);
3256 dwarf2_per_objfile
->all_comp_units
[base_offset
+ i
/ 2]
3257 = create_cu_from_index_list (dwarf2_per_objfile
, section
, is_dwz
,
3262 /* Read the CU list from the mapped index, and use it to create all
3263 the CU objects for this objfile. */
3266 create_cus_from_index (struct objfile
*objfile
,
3267 const gdb_byte
*cu_list
, offset_type cu_list_elements
,
3268 const gdb_byte
*dwz_list
, offset_type dwz_elements
)
3270 struct dwz_file
*dwz
;
3271 struct dwarf2_per_objfile
*dwarf2_per_objfile
3272 = get_dwarf2_per_objfile (objfile
);
3274 dwarf2_per_objfile
->n_comp_units
= (cu_list_elements
+ dwz_elements
) / 2;
3275 dwarf2_per_objfile
->all_comp_units
=
3276 XOBNEWVEC (&objfile
->objfile_obstack
, struct dwarf2_per_cu_data
*,
3277 dwarf2_per_objfile
->n_comp_units
);
3279 create_cus_from_index_list (objfile
, cu_list
, cu_list_elements
,
3280 &dwarf2_per_objfile
->info
, 0, 0);
3282 if (dwz_elements
== 0)
3285 dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
3286 create_cus_from_index_list (objfile
, dwz_list
, dwz_elements
, &dwz
->info
, 1,
3287 cu_list_elements
/ 2);
3290 /* Create the signatured type hash table from the index. */
3293 create_signatured_type_table_from_index (struct objfile
*objfile
,
3294 struct dwarf2_section_info
*section
,
3295 const gdb_byte
*bytes
,
3296 offset_type elements
)
3299 htab_t sig_types_hash
;
3300 struct dwarf2_per_objfile
*dwarf2_per_objfile
3301 = get_dwarf2_per_objfile (objfile
);
3303 dwarf2_per_objfile
->n_type_units
3304 = dwarf2_per_objfile
->n_allocated_type_units
3306 dwarf2_per_objfile
->all_type_units
=
3307 XNEWVEC (struct signatured_type
*, dwarf2_per_objfile
->n_type_units
);
3309 sig_types_hash
= allocate_signatured_type_table (objfile
);
3311 for (i
= 0; i
< elements
; i
+= 3)
3313 struct signatured_type
*sig_type
;
3316 cu_offset type_offset_in_tu
;
3318 gdb_static_assert (sizeof (ULONGEST
) >= 8);
3319 sect_offset sect_off
3320 = (sect_offset
) extract_unsigned_integer (bytes
, 8, BFD_ENDIAN_LITTLE
);
3322 = (cu_offset
) extract_unsigned_integer (bytes
+ 8, 8,
3324 signature
= extract_unsigned_integer (bytes
+ 16, 8, BFD_ENDIAN_LITTLE
);
3327 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
3328 struct signatured_type
);
3329 sig_type
->signature
= signature
;
3330 sig_type
->type_offset_in_tu
= type_offset_in_tu
;
3331 sig_type
->per_cu
.is_debug_types
= 1;
3332 sig_type
->per_cu
.section
= section
;
3333 sig_type
->per_cu
.sect_off
= sect_off
;
3334 sig_type
->per_cu
.dwarf2_per_objfile
= dwarf2_per_objfile
;
3335 sig_type
->per_cu
.v
.quick
3336 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
3337 struct dwarf2_per_cu_quick_data
);
3339 slot
= htab_find_slot (sig_types_hash
, sig_type
, INSERT
);
3342 dwarf2_per_objfile
->all_type_units
[i
/ 3] = sig_type
;
3345 dwarf2_per_objfile
->signatured_types
= sig_types_hash
;
3348 /* Create the signatured type hash table from .debug_names. */
3351 create_signatured_type_table_from_debug_names
3352 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
3353 const mapped_debug_names
&map
,
3354 struct dwarf2_section_info
*section
,
3355 struct dwarf2_section_info
*abbrev_section
)
3357 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
3359 dwarf2_read_section (objfile
, section
);
3360 dwarf2_read_section (objfile
, abbrev_section
);
3362 dwarf2_per_objfile
->n_type_units
3363 = dwarf2_per_objfile
->n_allocated_type_units
3365 dwarf2_per_objfile
->all_type_units
3366 = XNEWVEC (struct signatured_type
*, dwarf2_per_objfile
->n_type_units
);
3368 htab_t sig_types_hash
= allocate_signatured_type_table (objfile
);
3370 for (uint32_t i
= 0; i
< map
.tu_count
; ++i
)
3372 struct signatured_type
*sig_type
;
3375 cu_offset type_offset_in_tu
;
3377 sect_offset sect_off
3378 = (sect_offset
) (extract_unsigned_integer
3379 (map
.tu_table_reordered
+ i
* map
.offset_size
,
3381 map
.dwarf5_byte_order
));
3383 comp_unit_head cu_header
;
3384 read_and_check_comp_unit_head (dwarf2_per_objfile
, &cu_header
, section
,
3386 section
->buffer
+ to_underlying (sect_off
),
3389 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
3390 struct signatured_type
);
3391 sig_type
->signature
= cu_header
.signature
;
3392 sig_type
->type_offset_in_tu
= cu_header
.type_cu_offset_in_tu
;
3393 sig_type
->per_cu
.is_debug_types
= 1;
3394 sig_type
->per_cu
.section
= section
;
3395 sig_type
->per_cu
.sect_off
= sect_off
;
3396 sig_type
->per_cu
.dwarf2_per_objfile
= dwarf2_per_objfile
;
3397 sig_type
->per_cu
.v
.quick
3398 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
3399 struct dwarf2_per_cu_quick_data
);
3401 slot
= htab_find_slot (sig_types_hash
, sig_type
, INSERT
);
3404 dwarf2_per_objfile
->all_type_units
[i
] = sig_type
;
3407 dwarf2_per_objfile
->signatured_types
= sig_types_hash
;
3410 /* Read the address map data from the mapped index, and use it to
3411 populate the objfile's psymtabs_addrmap. */
3414 create_addrmap_from_index (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
3415 struct mapped_index
*index
)
3417 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
3418 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3419 const gdb_byte
*iter
, *end
;
3420 struct addrmap
*mutable_map
;
3423 auto_obstack temp_obstack
;
3425 mutable_map
= addrmap_create_mutable (&temp_obstack
);
3427 iter
= index
->address_table
.data ();
3428 end
= iter
+ index
->address_table
.size ();
3430 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3434 ULONGEST hi
, lo
, cu_index
;
3435 lo
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
3437 hi
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
3439 cu_index
= extract_unsigned_integer (iter
, 4, BFD_ENDIAN_LITTLE
);
3444 complaint (&symfile_complaints
,
3445 _(".gdb_index address table has invalid range (%s - %s)"),
3446 hex_string (lo
), hex_string (hi
));
3450 if (cu_index
>= dwarf2_per_objfile
->n_comp_units
)
3452 complaint (&symfile_complaints
,
3453 _(".gdb_index address table has invalid CU number %u"),
3454 (unsigned) cu_index
);
3458 lo
= gdbarch_adjust_dwarf2_addr (gdbarch
, lo
+ baseaddr
);
3459 hi
= gdbarch_adjust_dwarf2_addr (gdbarch
, hi
+ baseaddr
);
3460 addrmap_set_empty (mutable_map
, lo
, hi
- 1,
3461 dw2_get_cutu (dwarf2_per_objfile
, cu_index
));
3464 objfile
->psymtabs_addrmap
= addrmap_create_fixed (mutable_map
,
3465 &objfile
->objfile_obstack
);
3468 /* Read the address map data from DWARF-5 .debug_aranges, and use it to
3469 populate the objfile's psymtabs_addrmap. */
3472 create_addrmap_from_aranges (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
3473 struct dwarf2_section_info
*section
)
3475 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
3476 bfd
*abfd
= objfile
->obfd
;
3477 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3478 const CORE_ADDR baseaddr
= ANOFFSET (objfile
->section_offsets
,
3479 SECT_OFF_TEXT (objfile
));
3481 auto_obstack temp_obstack
;
3482 addrmap
*mutable_map
= addrmap_create_mutable (&temp_obstack
);
3484 std::unordered_map
<sect_offset
,
3485 dwarf2_per_cu_data
*,
3486 gdb::hash_enum
<sect_offset
>>
3487 debug_info_offset_to_per_cu
;
3488 for (int cui
= 0; cui
< dwarf2_per_objfile
->n_comp_units
; ++cui
)
3490 dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (dwarf2_per_objfile
, cui
);
3491 const auto insertpair
3492 = debug_info_offset_to_per_cu
.emplace (per_cu
->sect_off
, per_cu
);
3493 if (!insertpair
.second
)
3495 warning (_("Section .debug_aranges in %s has duplicate "
3496 "debug_info_offset %u, ignoring .debug_aranges."),
3497 objfile_name (objfile
), to_underlying (per_cu
->sect_off
));
3502 dwarf2_read_section (objfile
, section
);
3504 const bfd_endian dwarf5_byte_order
= gdbarch_byte_order (gdbarch
);
3506 const gdb_byte
*addr
= section
->buffer
;
3508 while (addr
< section
->buffer
+ section
->size
)
3510 const gdb_byte
*const entry_addr
= addr
;
3511 unsigned int bytes_read
;
3513 const LONGEST entry_length
= read_initial_length (abfd
, addr
,
3517 const gdb_byte
*const entry_end
= addr
+ entry_length
;
3518 const bool dwarf5_is_dwarf64
= bytes_read
!= 4;
3519 const uint8_t offset_size
= dwarf5_is_dwarf64
? 8 : 4;
3520 if (addr
+ entry_length
> section
->buffer
+ section
->size
)
3522 warning (_("Section .debug_aranges in %s entry at offset %zu "
3523 "length %s exceeds section length %s, "
3524 "ignoring .debug_aranges."),
3525 objfile_name (objfile
), entry_addr
- section
->buffer
,
3526 plongest (bytes_read
+ entry_length
),
3527 pulongest (section
->size
));
3531 /* The version number. */
3532 const uint16_t version
= read_2_bytes (abfd
, addr
);
3536 warning (_("Section .debug_aranges in %s entry at offset %zu "
3537 "has unsupported version %d, ignoring .debug_aranges."),
3538 objfile_name (objfile
), entry_addr
- section
->buffer
,
3543 const uint64_t debug_info_offset
3544 = extract_unsigned_integer (addr
, offset_size
, dwarf5_byte_order
);
3545 addr
+= offset_size
;
3546 const auto per_cu_it
3547 = debug_info_offset_to_per_cu
.find (sect_offset (debug_info_offset
));
3548 if (per_cu_it
== debug_info_offset_to_per_cu
.cend ())
3550 warning (_("Section .debug_aranges in %s entry at offset %zu "
3551 "debug_info_offset %s does not exists, "
3552 "ignoring .debug_aranges."),
3553 objfile_name (objfile
), entry_addr
- section
->buffer
,
3554 pulongest (debug_info_offset
));
3557 dwarf2_per_cu_data
*const per_cu
= per_cu_it
->second
;
3559 const uint8_t address_size
= *addr
++;
3560 if (address_size
< 1 || address_size
> 8)
3562 warning (_("Section .debug_aranges in %s entry at offset %zu "
3563 "address_size %u is invalid, ignoring .debug_aranges."),
3564 objfile_name (objfile
), entry_addr
- section
->buffer
,
3569 const uint8_t segment_selector_size
= *addr
++;
3570 if (segment_selector_size
!= 0)
3572 warning (_("Section .debug_aranges in %s entry at offset %zu "
3573 "segment_selector_size %u is not supported, "
3574 "ignoring .debug_aranges."),
3575 objfile_name (objfile
), entry_addr
- section
->buffer
,
3576 segment_selector_size
);
3580 /* Must pad to an alignment boundary that is twice the address
3581 size. It is undocumented by the DWARF standard but GCC does
3583 for (size_t padding
= ((-(addr
- section
->buffer
))
3584 & (2 * address_size
- 1));
3585 padding
> 0; padding
--)
3588 warning (_("Section .debug_aranges in %s entry at offset %zu "
3589 "padding is not zero, ignoring .debug_aranges."),
3590 objfile_name (objfile
), entry_addr
- section
->buffer
);
3596 if (addr
+ 2 * address_size
> entry_end
)
3598 warning (_("Section .debug_aranges in %s entry at offset %zu "
3599 "address list is not properly terminated, "
3600 "ignoring .debug_aranges."),
3601 objfile_name (objfile
), entry_addr
- section
->buffer
);
3604 ULONGEST start
= extract_unsigned_integer (addr
, address_size
,
3606 addr
+= address_size
;
3607 ULONGEST length
= extract_unsigned_integer (addr
, address_size
,
3609 addr
+= address_size
;
3610 if (start
== 0 && length
== 0)
3612 if (start
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
3614 /* Symbol was eliminated due to a COMDAT group. */
3617 ULONGEST end
= start
+ length
;
3618 start
= gdbarch_adjust_dwarf2_addr (gdbarch
, start
+ baseaddr
);
3619 end
= gdbarch_adjust_dwarf2_addr (gdbarch
, end
+ baseaddr
);
3620 addrmap_set_empty (mutable_map
, start
, end
- 1, per_cu
);
3624 objfile
->psymtabs_addrmap
= addrmap_create_fixed (mutable_map
,
3625 &objfile
->objfile_obstack
);
3628 /* The hash function for strings in the mapped index. This is the same as
3629 SYMBOL_HASH_NEXT, but we keep a separate copy to maintain control over the
3630 implementation. This is necessary because the hash function is tied to the
3631 format of the mapped index file. The hash values do not have to match with
3634 Use INT_MAX for INDEX_VERSION if you generate the current index format. */
3637 mapped_index_string_hash (int index_version
, const void *p
)
3639 const unsigned char *str
= (const unsigned char *) p
;
3643 while ((c
= *str
++) != 0)
3645 if (index_version
>= 5)
3647 r
= r
* 67 + c
- 113;
3653 /* Find a slot in the mapped index INDEX for the object named NAME.
3654 If NAME is found, set *VEC_OUT to point to the CU vector in the
3655 constant pool and return true. If NAME cannot be found, return
3659 find_slot_in_mapped_hash (struct mapped_index
*index
, const char *name
,
3660 offset_type
**vec_out
)
3663 offset_type slot
, step
;
3664 int (*cmp
) (const char *, const char *);
3666 gdb::unique_xmalloc_ptr
<char> without_params
;
3667 if (current_language
->la_language
== language_cplus
3668 || current_language
->la_language
== language_fortran
3669 || current_language
->la_language
== language_d
)
3671 /* NAME is already canonical. Drop any qualifiers as .gdb_index does
3674 if (strchr (name
, '(') != NULL
)
3676 without_params
= cp_remove_params (name
);
3678 if (without_params
!= NULL
)
3679 name
= without_params
.get ();
3683 /* Index version 4 did not support case insensitive searches. But the
3684 indices for case insensitive languages are built in lowercase, therefore
3685 simulate our NAME being searched is also lowercased. */
3686 hash
= mapped_index_string_hash ((index
->version
== 4
3687 && case_sensitivity
== case_sensitive_off
3688 ? 5 : index
->version
),
3691 slot
= hash
& (index
->symbol_table
.size () - 1);
3692 step
= ((hash
* 17) & (index
->symbol_table
.size () - 1)) | 1;
3693 cmp
= (case_sensitivity
== case_sensitive_on
? strcmp
: strcasecmp
);
3699 const auto &bucket
= index
->symbol_table
[slot
];
3700 if (bucket
.name
== 0 && bucket
.vec
== 0)
3703 str
= index
->constant_pool
+ MAYBE_SWAP (bucket
.name
);
3704 if (!cmp (name
, str
))
3706 *vec_out
= (offset_type
*) (index
->constant_pool
3707 + MAYBE_SWAP (bucket
.vec
));
3711 slot
= (slot
+ step
) & (index
->symbol_table
.size () - 1);
3715 /* A helper function that reads the .gdb_index from SECTION and fills
3716 in MAP. FILENAME is the name of the file containing the section;
3717 it is used for error reporting. DEPRECATED_OK is nonzero if it is
3718 ok to use deprecated sections.
3720 CU_LIST, CU_LIST_ELEMENTS, TYPES_LIST, and TYPES_LIST_ELEMENTS are
3721 out parameters that are filled in with information about the CU and
3722 TU lists in the section.
3724 Returns 1 if all went well, 0 otherwise. */
3727 read_index_from_section (struct objfile
*objfile
,
3728 const char *filename
,
3730 struct dwarf2_section_info
*section
,
3731 struct mapped_index
*map
,
3732 const gdb_byte
**cu_list
,
3733 offset_type
*cu_list_elements
,
3734 const gdb_byte
**types_list
,
3735 offset_type
*types_list_elements
)
3737 const gdb_byte
*addr
;
3738 offset_type version
;
3739 offset_type
*metadata
;
3742 if (dwarf2_section_empty_p (section
))
3745 /* Older elfutils strip versions could keep the section in the main
3746 executable while splitting it for the separate debug info file. */
3747 if ((get_section_flags (section
) & SEC_HAS_CONTENTS
) == 0)
3750 dwarf2_read_section (objfile
, section
);
3752 addr
= section
->buffer
;
3753 /* Version check. */
3754 version
= MAYBE_SWAP (*(offset_type
*) addr
);
3755 /* Versions earlier than 3 emitted every copy of a psymbol. This
3756 causes the index to behave very poorly for certain requests. Version 3
3757 contained incomplete addrmap. So, it seems better to just ignore such
3761 static int warning_printed
= 0;
3762 if (!warning_printed
)
3764 warning (_("Skipping obsolete .gdb_index section in %s."),
3766 warning_printed
= 1;
3770 /* Index version 4 uses a different hash function than index version
3773 Versions earlier than 6 did not emit psymbols for inlined
3774 functions. Using these files will cause GDB not to be able to
3775 set breakpoints on inlined functions by name, so we ignore these
3776 indices unless the user has done
3777 "set use-deprecated-index-sections on". */
3778 if (version
< 6 && !deprecated_ok
)
3780 static int warning_printed
= 0;
3781 if (!warning_printed
)
3784 Skipping deprecated .gdb_index section in %s.\n\
3785 Do \"set use-deprecated-index-sections on\" before the file is read\n\
3786 to use the section anyway."),
3788 warning_printed
= 1;
3792 /* Version 7 indices generated by gold refer to the CU for a symbol instead
3793 of the TU (for symbols coming from TUs),
3794 http://sourceware.org/bugzilla/show_bug.cgi?id=15021.
3795 Plus gold-generated indices can have duplicate entries for global symbols,
3796 http://sourceware.org/bugzilla/show_bug.cgi?id=15646.
3797 These are just performance bugs, and we can't distinguish gdb-generated
3798 indices from gold-generated ones, so issue no warning here. */
3800 /* Indexes with higher version than the one supported by GDB may be no
3801 longer backward compatible. */
3805 map
->version
= version
;
3806 map
->total_size
= section
->size
;
3808 metadata
= (offset_type
*) (addr
+ sizeof (offset_type
));
3811 *cu_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
3812 *cu_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1]) - MAYBE_SWAP (metadata
[i
]))
3816 *types_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
3817 *types_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1])
3818 - MAYBE_SWAP (metadata
[i
]))
3822 const gdb_byte
*address_table
= addr
+ MAYBE_SWAP (metadata
[i
]);
3823 const gdb_byte
*address_table_end
= addr
+ MAYBE_SWAP (metadata
[i
+ 1]);
3825 = gdb::array_view
<const gdb_byte
> (address_table
, address_table_end
);
3828 const gdb_byte
*symbol_table
= addr
+ MAYBE_SWAP (metadata
[i
]);
3829 const gdb_byte
*symbol_table_end
= addr
+ MAYBE_SWAP (metadata
[i
+ 1]);
3831 = gdb::array_view
<mapped_index::symbol_table_slot
>
3832 ((mapped_index::symbol_table_slot
*) symbol_table
,
3833 (mapped_index::symbol_table_slot
*) symbol_table_end
);
3836 map
->constant_pool
= (char *) (addr
+ MAYBE_SWAP (metadata
[i
]));
3841 /* Read .gdb_index. If everything went ok, initialize the "quick"
3842 elements of all the CUs and return 1. Otherwise, return 0. */
3845 dwarf2_read_index (struct objfile
*objfile
)
3847 struct mapped_index local_map
, *map
;
3848 const gdb_byte
*cu_list
, *types_list
, *dwz_list
= NULL
;
3849 offset_type cu_list_elements
, types_list_elements
, dwz_list_elements
= 0;
3850 struct dwz_file
*dwz
;
3851 struct dwarf2_per_objfile
*dwarf2_per_objfile
3852 = get_dwarf2_per_objfile (objfile
);
3854 if (!read_index_from_section (objfile
, objfile_name (objfile
),
3855 use_deprecated_index_sections
,
3856 &dwarf2_per_objfile
->gdb_index
, &local_map
,
3857 &cu_list
, &cu_list_elements
,
3858 &types_list
, &types_list_elements
))
3861 /* Don't use the index if it's empty. */
3862 if (local_map
.symbol_table
.empty ())
3865 /* If there is a .dwz file, read it so we can get its CU list as
3867 dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
3870 struct mapped_index dwz_map
;
3871 const gdb_byte
*dwz_types_ignore
;
3872 offset_type dwz_types_elements_ignore
;
3874 if (!read_index_from_section (objfile
, bfd_get_filename (dwz
->dwz_bfd
),
3876 &dwz
->gdb_index
, &dwz_map
,
3877 &dwz_list
, &dwz_list_elements
,
3879 &dwz_types_elements_ignore
))
3881 warning (_("could not read '.gdb_index' section from %s; skipping"),
3882 bfd_get_filename (dwz
->dwz_bfd
));
3887 create_cus_from_index (objfile
, cu_list
, cu_list_elements
, dwz_list
,
3890 if (types_list_elements
)
3892 struct dwarf2_section_info
*section
;
3894 /* We can only handle a single .debug_types when we have an
3896 if (VEC_length (dwarf2_section_info_def
, dwarf2_per_objfile
->types
) != 1)
3899 section
= VEC_index (dwarf2_section_info_def
,
3900 dwarf2_per_objfile
->types
, 0);
3902 create_signatured_type_table_from_index (objfile
, section
, types_list
,
3903 types_list_elements
);
3906 create_addrmap_from_index (dwarf2_per_objfile
, &local_map
);
3908 map
= XOBNEW (&objfile
->objfile_obstack
, struct mapped_index
);
3909 map
= new (map
) mapped_index ();
3912 dwarf2_per_objfile
->index_table
= map
;
3913 dwarf2_per_objfile
->using_index
= 1;
3914 dwarf2_per_objfile
->quick_file_names_table
=
3915 create_quick_file_names_table (dwarf2_per_objfile
->n_comp_units
);
3920 /* die_reader_func for dw2_get_file_names. */
3923 dw2_get_file_names_reader (const struct die_reader_specs
*reader
,
3924 const gdb_byte
*info_ptr
,
3925 struct die_info
*comp_unit_die
,
3929 struct dwarf2_cu
*cu
= reader
->cu
;
3930 struct dwarf2_per_cu_data
*this_cu
= cu
->per_cu
;
3931 struct dwarf2_per_objfile
*dwarf2_per_objfile
3932 = cu
->per_cu
->dwarf2_per_objfile
;
3933 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
3934 struct dwarf2_per_cu_data
*lh_cu
;
3935 struct attribute
*attr
;
3938 struct quick_file_names
*qfn
;
3940 gdb_assert (! this_cu
->is_debug_types
);
3942 /* Our callers never want to match partial units -- instead they
3943 will match the enclosing full CU. */
3944 if (comp_unit_die
->tag
== DW_TAG_partial_unit
)
3946 this_cu
->v
.quick
->no_file_data
= 1;
3954 sect_offset line_offset
{};
3956 attr
= dwarf2_attr (comp_unit_die
, DW_AT_stmt_list
, cu
);
3959 struct quick_file_names find_entry
;
3961 line_offset
= (sect_offset
) DW_UNSND (attr
);
3963 /* We may have already read in this line header (TU line header sharing).
3964 If we have we're done. */
3965 find_entry
.hash
.dwo_unit
= cu
->dwo_unit
;
3966 find_entry
.hash
.line_sect_off
= line_offset
;
3967 slot
= htab_find_slot (dwarf2_per_objfile
->quick_file_names_table
,
3968 &find_entry
, INSERT
);
3971 lh_cu
->v
.quick
->file_names
= (struct quick_file_names
*) *slot
;
3975 lh
= dwarf_decode_line_header (line_offset
, cu
);
3979 lh_cu
->v
.quick
->no_file_data
= 1;
3983 qfn
= XOBNEW (&objfile
->objfile_obstack
, struct quick_file_names
);
3984 qfn
->hash
.dwo_unit
= cu
->dwo_unit
;
3985 qfn
->hash
.line_sect_off
= line_offset
;
3986 gdb_assert (slot
!= NULL
);
3989 file_and_directory fnd
= find_file_and_directory (comp_unit_die
, cu
);
3991 qfn
->num_file_names
= lh
->file_names
.size ();
3993 XOBNEWVEC (&objfile
->objfile_obstack
, const char *, lh
->file_names
.size ());
3994 for (i
= 0; i
< lh
->file_names
.size (); ++i
)
3995 qfn
->file_names
[i
] = file_full_name (i
+ 1, lh
.get (), fnd
.comp_dir
);
3996 qfn
->real_names
= NULL
;
3998 lh_cu
->v
.quick
->file_names
= qfn
;
4001 /* A helper for the "quick" functions which attempts to read the line
4002 table for THIS_CU. */
4004 static struct quick_file_names
*
4005 dw2_get_file_names (struct dwarf2_per_cu_data
*this_cu
)
4007 /* This should never be called for TUs. */
4008 gdb_assert (! this_cu
->is_debug_types
);
4009 /* Nor type unit groups. */
4010 gdb_assert (! IS_TYPE_UNIT_GROUP (this_cu
));
4012 if (this_cu
->v
.quick
->file_names
!= NULL
)
4013 return this_cu
->v
.quick
->file_names
;
4014 /* If we know there is no line data, no point in looking again. */
4015 if (this_cu
->v
.quick
->no_file_data
)
4018 init_cutu_and_read_dies_simple (this_cu
, dw2_get_file_names_reader
, NULL
);
4020 if (this_cu
->v
.quick
->no_file_data
)
4022 return this_cu
->v
.quick
->file_names
;
4025 /* A helper for the "quick" functions which computes and caches the
4026 real path for a given file name from the line table. */
4029 dw2_get_real_path (struct objfile
*objfile
,
4030 struct quick_file_names
*qfn
, int index
)
4032 if (qfn
->real_names
== NULL
)
4033 qfn
->real_names
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
4034 qfn
->num_file_names
, const char *);
4036 if (qfn
->real_names
[index
] == NULL
)
4037 qfn
->real_names
[index
] = gdb_realpath (qfn
->file_names
[index
]).release ();
4039 return qfn
->real_names
[index
];
4042 static struct symtab
*
4043 dw2_find_last_source_symtab (struct objfile
*objfile
)
4045 struct dwarf2_per_objfile
*dwarf2_per_objfile
4046 = get_dwarf2_per_objfile (objfile
);
4047 int index
= dwarf2_per_objfile
->n_comp_units
- 1;
4048 dwarf2_per_cu_data
*dwarf_cu
= dw2_get_cutu (dwarf2_per_objfile
, index
);
4049 compunit_symtab
*cust
= dw2_instantiate_symtab (dwarf_cu
);
4054 return compunit_primary_filetab (cust
);
4057 /* Traversal function for dw2_forget_cached_source_info. */
4060 dw2_free_cached_file_names (void **slot
, void *info
)
4062 struct quick_file_names
*file_data
= (struct quick_file_names
*) *slot
;
4064 if (file_data
->real_names
)
4068 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
4070 xfree ((void*) file_data
->real_names
[i
]);
4071 file_data
->real_names
[i
] = NULL
;
4079 dw2_forget_cached_source_info (struct objfile
*objfile
)
4081 struct dwarf2_per_objfile
*dwarf2_per_objfile
4082 = get_dwarf2_per_objfile (objfile
);
4084 htab_traverse_noresize (dwarf2_per_objfile
->quick_file_names_table
,
4085 dw2_free_cached_file_names
, NULL
);
4088 /* Helper function for dw2_map_symtabs_matching_filename that expands
4089 the symtabs and calls the iterator. */
4092 dw2_map_expand_apply (struct objfile
*objfile
,
4093 struct dwarf2_per_cu_data
*per_cu
,
4094 const char *name
, const char *real_path
,
4095 gdb::function_view
<bool (symtab
*)> callback
)
4097 struct compunit_symtab
*last_made
= objfile
->compunit_symtabs
;
4099 /* Don't visit already-expanded CUs. */
4100 if (per_cu
->v
.quick
->compunit_symtab
)
4103 /* This may expand more than one symtab, and we want to iterate over
4105 dw2_instantiate_symtab (per_cu
);
4107 return iterate_over_some_symtabs (name
, real_path
, objfile
->compunit_symtabs
,
4108 last_made
, callback
);
4111 /* Implementation of the map_symtabs_matching_filename method. */
4114 dw2_map_symtabs_matching_filename
4115 (struct objfile
*objfile
, const char *name
, const char *real_path
,
4116 gdb::function_view
<bool (symtab
*)> callback
)
4119 const char *name_basename
= lbasename (name
);
4120 struct dwarf2_per_objfile
*dwarf2_per_objfile
4121 = get_dwarf2_per_objfile (objfile
);
4123 /* The rule is CUs specify all the files, including those used by
4124 any TU, so there's no need to scan TUs here. */
4126 for (int i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
4129 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (dwarf2_per_objfile
, i
);
4130 struct quick_file_names
*file_data
;
4132 /* We only need to look at symtabs not already expanded. */
4133 if (per_cu
->v
.quick
->compunit_symtab
)
4136 file_data
= dw2_get_file_names (per_cu
);
4137 if (file_data
== NULL
)
4140 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
4142 const char *this_name
= file_data
->file_names
[j
];
4143 const char *this_real_name
;
4145 if (compare_filenames_for_search (this_name
, name
))
4147 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
4153 /* Before we invoke realpath, which can get expensive when many
4154 files are involved, do a quick comparison of the basenames. */
4155 if (! basenames_may_differ
4156 && FILENAME_CMP (lbasename (this_name
), name_basename
) != 0)
4159 this_real_name
= dw2_get_real_path (objfile
, file_data
, j
);
4160 if (compare_filenames_for_search (this_real_name
, name
))
4162 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
4168 if (real_path
!= NULL
)
4170 gdb_assert (IS_ABSOLUTE_PATH (real_path
));
4171 gdb_assert (IS_ABSOLUTE_PATH (name
));
4172 if (this_real_name
!= NULL
4173 && FILENAME_CMP (real_path
, this_real_name
) == 0)
4175 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
4187 /* Struct used to manage iterating over all CUs looking for a symbol. */
4189 struct dw2_symtab_iterator
4191 /* The dwarf2_per_objfile owning the CUs we are iterating on. */
4192 struct dwarf2_per_objfile
*dwarf2_per_objfile
;
4193 /* If non-zero, only look for symbols that match BLOCK_INDEX. */
4194 int want_specific_block
;
4195 /* One of GLOBAL_BLOCK or STATIC_BLOCK.
4196 Unused if !WANT_SPECIFIC_BLOCK. */
4198 /* The kind of symbol we're looking for. */
4200 /* The list of CUs from the index entry of the symbol,
4201 or NULL if not found. */
4203 /* The next element in VEC to look at. */
4205 /* The number of elements in VEC, or zero if there is no match. */
4207 /* Have we seen a global version of the symbol?
4208 If so we can ignore all further global instances.
4209 This is to work around gold/15646, inefficient gold-generated
4214 /* Initialize the index symtab iterator ITER.
4215 If WANT_SPECIFIC_BLOCK is non-zero, only look for symbols
4216 in block BLOCK_INDEX. Otherwise BLOCK_INDEX is ignored. */
4219 dw2_symtab_iter_init (struct dw2_symtab_iterator
*iter
,
4220 struct dwarf2_per_objfile
*dwarf2_per_objfile
,
4221 int want_specific_block
,
4226 iter
->dwarf2_per_objfile
= dwarf2_per_objfile
;
4227 iter
->want_specific_block
= want_specific_block
;
4228 iter
->block_index
= block_index
;
4229 iter
->domain
= domain
;
4231 iter
->global_seen
= 0;
4233 mapped_index
*index
= dwarf2_per_objfile
->index_table
;
4235 /* index is NULL if OBJF_READNOW. */
4236 if (index
!= NULL
&& find_slot_in_mapped_hash (index
, name
, &iter
->vec
))
4237 iter
->length
= MAYBE_SWAP (*iter
->vec
);
4245 /* Return the next matching CU or NULL if there are no more. */
4247 static struct dwarf2_per_cu_data
*
4248 dw2_symtab_iter_next (struct dw2_symtab_iterator
*iter
)
4250 struct dwarf2_per_objfile
*dwarf2_per_objfile
= iter
->dwarf2_per_objfile
;
4252 for ( ; iter
->next
< iter
->length
; ++iter
->next
)
4254 offset_type cu_index_and_attrs
=
4255 MAYBE_SWAP (iter
->vec
[iter
->next
+ 1]);
4256 offset_type cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
4257 struct dwarf2_per_cu_data
*per_cu
;
4258 int want_static
= iter
->block_index
!= GLOBAL_BLOCK
;
4259 /* This value is only valid for index versions >= 7. */
4260 int is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs
);
4261 gdb_index_symbol_kind symbol_kind
=
4262 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
4263 /* Only check the symbol attributes if they're present.
4264 Indices prior to version 7 don't record them,
4265 and indices >= 7 may elide them for certain symbols
4266 (gold does this). */
4268 (dwarf2_per_objfile
->index_table
->version
>= 7
4269 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_NONE
);
4271 /* Don't crash on bad data. */
4272 if (cu_index
>= (dwarf2_per_objfile
->n_comp_units
4273 + dwarf2_per_objfile
->n_type_units
))
4275 complaint (&symfile_complaints
,
4276 _(".gdb_index entry has bad CU index"
4278 objfile_name (dwarf2_per_objfile
->objfile
));
4282 per_cu
= dw2_get_cutu (dwarf2_per_objfile
, cu_index
);
4284 /* Skip if already read in. */
4285 if (per_cu
->v
.quick
->compunit_symtab
)
4288 /* Check static vs global. */
4291 if (iter
->want_specific_block
4292 && want_static
!= is_static
)
4294 /* Work around gold/15646. */
4295 if (!is_static
&& iter
->global_seen
)
4298 iter
->global_seen
= 1;
4301 /* Only check the symbol's kind if it has one. */
4304 switch (iter
->domain
)
4307 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
4308 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
4309 /* Some types are also in VAR_DOMAIN. */
4310 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
4314 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
4318 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_OTHER
)
4333 static struct compunit_symtab
*
4334 dw2_lookup_symbol (struct objfile
*objfile
, int block_index
,
4335 const char *name
, domain_enum domain
)
4337 struct compunit_symtab
*stab_best
= NULL
;
4338 struct dwarf2_per_objfile
*dwarf2_per_objfile
4339 = get_dwarf2_per_objfile (objfile
);
4341 lookup_name_info
lookup_name (name
, symbol_name_match_type::FULL
);
4343 struct dw2_symtab_iterator iter
;
4344 struct dwarf2_per_cu_data
*per_cu
;
4346 dw2_symtab_iter_init (&iter
, dwarf2_per_objfile
, 1, block_index
, domain
, name
);
4348 while ((per_cu
= dw2_symtab_iter_next (&iter
)) != NULL
)
4350 struct symbol
*sym
, *with_opaque
= NULL
;
4351 struct compunit_symtab
*stab
= dw2_instantiate_symtab (per_cu
);
4352 const struct blockvector
*bv
= COMPUNIT_BLOCKVECTOR (stab
);
4353 struct block
*block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
4355 sym
= block_find_symbol (block
, name
, domain
,
4356 block_find_non_opaque_type_preferred
,
4359 /* Some caution must be observed with overloaded functions
4360 and methods, since the index will not contain any overload
4361 information (but NAME might contain it). */
4364 && SYMBOL_MATCHES_SEARCH_NAME (sym
, lookup_name
))
4366 if (with_opaque
!= NULL
4367 && SYMBOL_MATCHES_SEARCH_NAME (with_opaque
, lookup_name
))
4370 /* Keep looking through other CUs. */
4377 dw2_print_stats (struct objfile
*objfile
)
4379 struct dwarf2_per_objfile
*dwarf2_per_objfile
4380 = get_dwarf2_per_objfile (objfile
);
4381 int total
= dwarf2_per_objfile
->n_comp_units
+ dwarf2_per_objfile
->n_type_units
;
4384 for (int i
= 0; i
< total
; ++i
)
4386 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (dwarf2_per_objfile
, i
);
4388 if (!per_cu
->v
.quick
->compunit_symtab
)
4391 printf_filtered (_(" Number of read CUs: %d\n"), total
- count
);
4392 printf_filtered (_(" Number of unread CUs: %d\n"), count
);
4395 /* This dumps minimal information about the index.
4396 It is called via "mt print objfiles".
4397 One use is to verify .gdb_index has been loaded by the
4398 gdb.dwarf2/gdb-index.exp testcase. */
4401 dw2_dump (struct objfile
*objfile
)
4403 struct dwarf2_per_objfile
*dwarf2_per_objfile
4404 = get_dwarf2_per_objfile (objfile
);
4406 gdb_assert (dwarf2_per_objfile
->using_index
);
4407 printf_filtered (".gdb_index:");
4408 if (dwarf2_per_objfile
->index_table
!= NULL
)
4410 printf_filtered (" version %d\n",
4411 dwarf2_per_objfile
->index_table
->version
);
4414 printf_filtered (" faked for \"readnow\"\n");
4415 printf_filtered ("\n");
4419 dw2_relocate (struct objfile
*objfile
,
4420 const struct section_offsets
*new_offsets
,
4421 const struct section_offsets
*delta
)
4423 /* There's nothing to relocate here. */
4427 dw2_expand_symtabs_for_function (struct objfile
*objfile
,
4428 const char *func_name
)
4430 struct dwarf2_per_objfile
*dwarf2_per_objfile
4431 = get_dwarf2_per_objfile (objfile
);
4433 struct dw2_symtab_iterator iter
;
4434 struct dwarf2_per_cu_data
*per_cu
;
4436 /* Note: It doesn't matter what we pass for block_index here. */
4437 dw2_symtab_iter_init (&iter
, dwarf2_per_objfile
, 0, GLOBAL_BLOCK
, VAR_DOMAIN
,
4440 while ((per_cu
= dw2_symtab_iter_next (&iter
)) != NULL
)
4441 dw2_instantiate_symtab (per_cu
);
4446 dw2_expand_all_symtabs (struct objfile
*objfile
)
4448 struct dwarf2_per_objfile
*dwarf2_per_objfile
4449 = get_dwarf2_per_objfile (objfile
);
4450 int total_units
= (dwarf2_per_objfile
->n_comp_units
4451 + dwarf2_per_objfile
->n_type_units
);
4453 for (int i
= 0; i
< total_units
; ++i
)
4455 struct dwarf2_per_cu_data
*per_cu
4456 = dw2_get_cutu (dwarf2_per_objfile
, i
);
4458 dw2_instantiate_symtab (per_cu
);
4463 dw2_expand_symtabs_with_fullname (struct objfile
*objfile
,
4464 const char *fullname
)
4466 struct dwarf2_per_objfile
*dwarf2_per_objfile
4467 = get_dwarf2_per_objfile (objfile
);
4469 /* We don't need to consider type units here.
4470 This is only called for examining code, e.g. expand_line_sal.
4471 There can be an order of magnitude (or more) more type units
4472 than comp units, and we avoid them if we can. */
4474 for (int i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
4477 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (dwarf2_per_objfile
, i
);
4478 struct quick_file_names
*file_data
;
4480 /* We only need to look at symtabs not already expanded. */
4481 if (per_cu
->v
.quick
->compunit_symtab
)
4484 file_data
= dw2_get_file_names (per_cu
);
4485 if (file_data
== NULL
)
4488 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
4490 const char *this_fullname
= file_data
->file_names
[j
];
4492 if (filename_cmp (this_fullname
, fullname
) == 0)
4494 dw2_instantiate_symtab (per_cu
);
4502 dw2_map_matching_symbols (struct objfile
*objfile
,
4503 const char * name
, domain_enum domain
,
4505 int (*callback
) (struct block
*,
4506 struct symbol
*, void *),
4507 void *data
, symbol_name_match_type match
,
4508 symbol_compare_ftype
*ordered_compare
)
4510 /* Currently unimplemented; used for Ada. The function can be called if the
4511 current language is Ada for a non-Ada objfile using GNU index. As Ada
4512 does not look for non-Ada symbols this function should just return. */
4515 /* Symbol name matcher for .gdb_index names.
4517 Symbol names in .gdb_index have a few particularities:
4519 - There's no indication of which is the language of each symbol.
4521 Since each language has its own symbol name matching algorithm,
4522 and we don't know which language is the right one, we must match
4523 each symbol against all languages. This would be a potential
4524 performance problem if it were not mitigated by the
4525 mapped_index::name_components lookup table, which significantly
4526 reduces the number of times we need to call into this matcher,
4527 making it a non-issue.
4529 - Symbol names in the index have no overload (parameter)
4530 information. I.e., in C++, "foo(int)" and "foo(long)" both
4531 appear as "foo" in the index, for example.
4533 This means that the lookup names passed to the symbol name
4534 matcher functions must have no parameter information either
4535 because (e.g.) symbol search name "foo" does not match
4536 lookup-name "foo(int)" [while swapping search name for lookup
4539 class gdb_index_symbol_name_matcher
4542 /* Prepares the vector of comparison functions for LOOKUP_NAME. */
4543 gdb_index_symbol_name_matcher (const lookup_name_info
&lookup_name
);
4545 /* Walk all the matcher routines and match SYMBOL_NAME against them.
4546 Returns true if any matcher matches. */
4547 bool matches (const char *symbol_name
);
4550 /* A reference to the lookup name we're matching against. */
4551 const lookup_name_info
&m_lookup_name
;
4553 /* A vector holding all the different symbol name matchers, for all
4555 std::vector
<symbol_name_matcher_ftype
*> m_symbol_name_matcher_funcs
;
4558 gdb_index_symbol_name_matcher::gdb_index_symbol_name_matcher
4559 (const lookup_name_info
&lookup_name
)
4560 : m_lookup_name (lookup_name
)
4562 /* Prepare the vector of comparison functions upfront, to avoid
4563 doing the same work for each symbol. Care is taken to avoid
4564 matching with the same matcher more than once if/when multiple
4565 languages use the same matcher function. */
4566 auto &matchers
= m_symbol_name_matcher_funcs
;
4567 matchers
.reserve (nr_languages
);
4569 matchers
.push_back (default_symbol_name_matcher
);
4571 for (int i
= 0; i
< nr_languages
; i
++)
4573 const language_defn
*lang
= language_def ((enum language
) i
);
4574 symbol_name_matcher_ftype
*name_matcher
4575 = get_symbol_name_matcher (lang
, m_lookup_name
);
4577 /* Don't insert the same comparison routine more than once.
4578 Note that we do this linear walk instead of a seemingly
4579 cheaper sorted insert, or use a std::set or something like
4580 that, because relative order of function addresses is not
4581 stable. This is not a problem in practice because the number
4582 of supported languages is low, and the cost here is tiny
4583 compared to the number of searches we'll do afterwards using
4585 if (name_matcher
!= default_symbol_name_matcher
4586 && (std::find (matchers
.begin (), matchers
.end (), name_matcher
)
4587 == matchers
.end ()))
4588 matchers
.push_back (name_matcher
);
4593 gdb_index_symbol_name_matcher::matches (const char *symbol_name
)
4595 for (auto matches_name
: m_symbol_name_matcher_funcs
)
4596 if (matches_name (symbol_name
, m_lookup_name
, NULL
))
4602 /* Starting from a search name, return the string that finds the upper
4603 bound of all strings that start with SEARCH_NAME in a sorted name
4604 list. Returns the empty string to indicate that the upper bound is
4605 the end of the list. */
4608 make_sort_after_prefix_name (const char *search_name
)
4610 /* When looking to complete "func", we find the upper bound of all
4611 symbols that start with "func" by looking for where we'd insert
4612 the closest string that would follow "func" in lexicographical
4613 order. Usually, that's "func"-with-last-character-incremented,
4614 i.e. "fund". Mind non-ASCII characters, though. Usually those
4615 will be UTF-8 multi-byte sequences, but we can't be certain.
4616 Especially mind the 0xff character, which is a valid character in
4617 non-UTF-8 source character sets (e.g. Latin1 'ÿ'), and we can't
4618 rule out compilers allowing it in identifiers. Note that
4619 conveniently, strcmp/strcasecmp are specified to compare
4620 characters interpreted as unsigned char. So what we do is treat
4621 the whole string as a base 256 number composed of a sequence of
4622 base 256 "digits" and add 1 to it. I.e., adding 1 to 0xff wraps
4623 to 0, and carries 1 to the following more-significant position.
4624 If the very first character in SEARCH_NAME ends up incremented
4625 and carries/overflows, then the upper bound is the end of the
4626 list. The string after the empty string is also the empty
4629 Some examples of this operation:
4631 SEARCH_NAME => "+1" RESULT
4635 "\xff" "a" "\xff" => "\xff" "b"
4640 Then, with these symbols for example:
4646 completing "func" looks for symbols between "func" and
4647 "func"-with-last-character-incremented, i.e. "fund" (exclusive),
4648 which finds "func" and "func1", but not "fund".
4652 funcÿ (Latin1 'ÿ' [0xff])
4656 completing "funcÿ" looks for symbols between "funcÿ" and "fund"
4657 (exclusive), which finds "funcÿ" and "funcÿ1", but not "fund".
4661 ÿÿ (Latin1 'ÿ' [0xff])
4664 completing "ÿ" or "ÿÿ" looks for symbols between between "ÿÿ" and
4665 the end of the list.
4667 std::string after
= search_name
;
4668 while (!after
.empty () && (unsigned char) after
.back () == 0xff)
4670 if (!after
.empty ())
4671 after
.back () = (unsigned char) after
.back () + 1;
4675 /* See declaration. */
4677 std::pair
<std::vector
<name_component
>::const_iterator
,
4678 std::vector
<name_component
>::const_iterator
>
4679 mapped_index_base::find_name_components_bounds
4680 (const lookup_name_info
&lookup_name_without_params
) const
4683 = this->name_components_casing
== case_sensitive_on
? strcmp
: strcasecmp
;
4686 = lookup_name_without_params
.cplus ().lookup_name ().c_str ();
4688 /* Comparison function object for lower_bound that matches against a
4689 given symbol name. */
4690 auto lookup_compare_lower
= [&] (const name_component
&elem
,
4693 const char *elem_qualified
= this->symbol_name_at (elem
.idx
);
4694 const char *elem_name
= elem_qualified
+ elem
.name_offset
;
4695 return name_cmp (elem_name
, name
) < 0;
4698 /* Comparison function object for upper_bound that matches against a
4699 given symbol name. */
4700 auto lookup_compare_upper
= [&] (const char *name
,
4701 const name_component
&elem
)
4703 const char *elem_qualified
= this->symbol_name_at (elem
.idx
);
4704 const char *elem_name
= elem_qualified
+ elem
.name_offset
;
4705 return name_cmp (name
, elem_name
) < 0;
4708 auto begin
= this->name_components
.begin ();
4709 auto end
= this->name_components
.end ();
4711 /* Find the lower bound. */
4714 if (lookup_name_without_params
.completion_mode () && cplus
[0] == '\0')
4717 return std::lower_bound (begin
, end
, cplus
, lookup_compare_lower
);
4720 /* Find the upper bound. */
4723 if (lookup_name_without_params
.completion_mode ())
4725 /* In completion mode, we want UPPER to point past all
4726 symbols names that have the same prefix. I.e., with
4727 these symbols, and completing "func":
4729 function << lower bound
4731 other_function << upper bound
4733 We find the upper bound by looking for the insertion
4734 point of "func"-with-last-character-incremented,
4736 std::string after
= make_sort_after_prefix_name (cplus
);
4739 return std::lower_bound (lower
, end
, after
.c_str (),
4740 lookup_compare_lower
);
4743 return std::upper_bound (lower
, end
, cplus
, lookup_compare_upper
);
4746 return {lower
, upper
};
4749 /* See declaration. */
4752 mapped_index_base::build_name_components ()
4754 if (!this->name_components
.empty ())
4757 this->name_components_casing
= case_sensitivity
;
4759 = this->name_components_casing
== case_sensitive_on
? strcmp
: strcasecmp
;
4761 /* The code below only knows how to break apart components of C++
4762 symbol names (and other languages that use '::' as
4763 namespace/module separator). If we add support for wild matching
4764 to some language that uses some other operator (E.g., Ada, Go and
4765 D use '.'), then we'll need to try splitting the symbol name
4766 according to that language too. Note that Ada does support wild
4767 matching, but doesn't currently support .gdb_index. */
4768 auto count
= this->symbol_name_count ();
4769 for (offset_type idx
= 0; idx
< count
; idx
++)
4771 if (this->symbol_name_slot_invalid (idx
))
4774 const char *name
= this->symbol_name_at (idx
);
4776 /* Add each name component to the name component table. */
4777 unsigned int previous_len
= 0;
4778 for (unsigned int current_len
= cp_find_first_component (name
);
4779 name
[current_len
] != '\0';
4780 current_len
+= cp_find_first_component (name
+ current_len
))
4782 gdb_assert (name
[current_len
] == ':');
4783 this->name_components
.push_back ({previous_len
, idx
});
4784 /* Skip the '::'. */
4786 previous_len
= current_len
;
4788 this->name_components
.push_back ({previous_len
, idx
});
4791 /* Sort name_components elements by name. */
4792 auto name_comp_compare
= [&] (const name_component
&left
,
4793 const name_component
&right
)
4795 const char *left_qualified
= this->symbol_name_at (left
.idx
);
4796 const char *right_qualified
= this->symbol_name_at (right
.idx
);
4798 const char *left_name
= left_qualified
+ left
.name_offset
;
4799 const char *right_name
= right_qualified
+ right
.name_offset
;
4801 return name_cmp (left_name
, right_name
) < 0;
4804 std::sort (this->name_components
.begin (),
4805 this->name_components
.end (),
4809 /* Helper for dw2_expand_symtabs_matching that works with a
4810 mapped_index_base instead of the containing objfile. This is split
4811 to a separate function in order to be able to unit test the
4812 name_components matching using a mock mapped_index_base. For each
4813 symbol name that matches, calls MATCH_CALLBACK, passing it the
4814 symbol's index in the mapped_index_base symbol table. */
4817 dw2_expand_symtabs_matching_symbol
4818 (mapped_index_base
&index
,
4819 const lookup_name_info
&lookup_name_in
,
4820 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
4821 enum search_domain kind
,
4822 gdb::function_view
<void (offset_type
)> match_callback
)
4824 lookup_name_info lookup_name_without_params
4825 = lookup_name_in
.make_ignore_params ();
4826 gdb_index_symbol_name_matcher lookup_name_matcher
4827 (lookup_name_without_params
);
4829 /* Build the symbol name component sorted vector, if we haven't
4831 index
.build_name_components ();
4833 auto bounds
= index
.find_name_components_bounds (lookup_name_without_params
);
4835 /* Now for each symbol name in range, check to see if we have a name
4836 match, and if so, call the MATCH_CALLBACK callback. */
4838 /* The same symbol may appear more than once in the range though.
4839 E.g., if we're looking for symbols that complete "w", and we have
4840 a symbol named "w1::w2", we'll find the two name components for
4841 that same symbol in the range. To be sure we only call the
4842 callback once per symbol, we first collect the symbol name
4843 indexes that matched in a temporary vector and ignore
4845 std::vector
<offset_type
> matches
;
4846 matches
.reserve (std::distance (bounds
.first
, bounds
.second
));
4848 for (; bounds
.first
!= bounds
.second
; ++bounds
.first
)
4850 const char *qualified
= index
.symbol_name_at (bounds
.first
->idx
);
4852 if (!lookup_name_matcher
.matches (qualified
)
4853 || (symbol_matcher
!= NULL
&& !symbol_matcher (qualified
)))
4856 matches
.push_back (bounds
.first
->idx
);
4859 std::sort (matches
.begin (), matches
.end ());
4861 /* Finally call the callback, once per match. */
4863 for (offset_type idx
: matches
)
4867 match_callback (idx
);
4872 /* Above we use a type wider than idx's for 'prev', since 0 and
4873 (offset_type)-1 are both possible values. */
4874 static_assert (sizeof (prev
) > sizeof (offset_type
), "");
4879 namespace selftests
{ namespace dw2_expand_symtabs_matching
{
4881 /* A mock .gdb_index/.debug_names-like name index table, enough to
4882 exercise dw2_expand_symtabs_matching_symbol, which works with the
4883 mapped_index_base interface. Builds an index from the symbol list
4884 passed as parameter to the constructor. */
4885 class mock_mapped_index
: public mapped_index_base
4888 mock_mapped_index (gdb::array_view
<const char *> symbols
)
4889 : m_symbol_table (symbols
)
4892 DISABLE_COPY_AND_ASSIGN (mock_mapped_index
);
4894 /* Return the number of names in the symbol table. */
4895 virtual size_t symbol_name_count () const
4897 return m_symbol_table
.size ();
4900 /* Get the name of the symbol at IDX in the symbol table. */
4901 virtual const char *symbol_name_at (offset_type idx
) const
4903 return m_symbol_table
[idx
];
4907 gdb::array_view
<const char *> m_symbol_table
;
4910 /* Convenience function that converts a NULL pointer to a "<null>"
4911 string, to pass to print routines. */
4914 string_or_null (const char *str
)
4916 return str
!= NULL
? str
: "<null>";
4919 /* Check if a lookup_name_info built from
4920 NAME/MATCH_TYPE/COMPLETION_MODE matches the symbols in the mock
4921 index. EXPECTED_LIST is the list of expected matches, in expected
4922 matching order. If no match expected, then an empty list is
4923 specified. Returns true on success. On failure prints a warning
4924 indicating the file:line that failed, and returns false. */
4927 check_match (const char *file
, int line
,
4928 mock_mapped_index
&mock_index
,
4929 const char *name
, symbol_name_match_type match_type
,
4930 bool completion_mode
,
4931 std::initializer_list
<const char *> expected_list
)
4933 lookup_name_info
lookup_name (name
, match_type
, completion_mode
);
4935 bool matched
= true;
4937 auto mismatch
= [&] (const char *expected_str
,
4940 warning (_("%s:%d: match_type=%s, looking-for=\"%s\", "
4941 "expected=\"%s\", got=\"%s\"\n"),
4943 (match_type
== symbol_name_match_type::FULL
4945 name
, string_or_null (expected_str
), string_or_null (got
));
4949 auto expected_it
= expected_list
.begin ();
4950 auto expected_end
= expected_list
.end ();
4952 dw2_expand_symtabs_matching_symbol (mock_index
, lookup_name
,
4954 [&] (offset_type idx
)
4956 const char *matched_name
= mock_index
.symbol_name_at (idx
);
4957 const char *expected_str
4958 = expected_it
== expected_end
? NULL
: *expected_it
++;
4960 if (expected_str
== NULL
|| strcmp (expected_str
, matched_name
) != 0)
4961 mismatch (expected_str
, matched_name
);
4964 const char *expected_str
4965 = expected_it
== expected_end
? NULL
: *expected_it
++;
4966 if (expected_str
!= NULL
)
4967 mismatch (expected_str
, NULL
);
4972 /* The symbols added to the mock mapped_index for testing (in
4974 static const char *test_symbols
[] = {
4983 "ns2::tmpl<int>::foo2",
4984 "(anonymous namespace)::A::B::C",
4986 /* These are used to check that the increment-last-char in the
4987 matching algorithm for completion doesn't match "t1_fund" when
4988 completing "t1_func". */
4994 /* A UTF-8 name with multi-byte sequences to make sure that
4995 cp-name-parser understands this as a single identifier ("função"
4996 is "function" in PT). */
4999 /* \377 (0xff) is Latin1 'ÿ'. */
5002 /* \377 (0xff) is Latin1 'ÿ'. */
5006 /* A name with all sorts of complications. Starts with "z" to make
5007 it easier for the completion tests below. */
5008 #define Z_SYM_NAME \
5009 "z::std::tuple<(anonymous namespace)::ui*, std::bar<(anonymous namespace)::ui> >" \
5010 "::tuple<(anonymous namespace)::ui*, " \
5011 "std::default_delete<(anonymous namespace)::ui>, void>"
5016 /* Returns true if the mapped_index_base::find_name_component_bounds
5017 method finds EXPECTED_SYMS in INDEX when looking for SEARCH_NAME,
5018 in completion mode. */
5021 check_find_bounds_finds (mapped_index_base
&index
,
5022 const char *search_name
,
5023 gdb::array_view
<const char *> expected_syms
)
5025 lookup_name_info
lookup_name (search_name
,
5026 symbol_name_match_type::FULL
, true);
5028 auto bounds
= index
.find_name_components_bounds (lookup_name
);
5030 size_t distance
= std::distance (bounds
.first
, bounds
.second
);
5031 if (distance
!= expected_syms
.size ())
5034 for (size_t exp_elem
= 0; exp_elem
< distance
; exp_elem
++)
5036 auto nc_elem
= bounds
.first
+ exp_elem
;
5037 const char *qualified
= index
.symbol_name_at (nc_elem
->idx
);
5038 if (strcmp (qualified
, expected_syms
[exp_elem
]) != 0)
5045 /* Test the lower-level mapped_index::find_name_component_bounds
5049 test_mapped_index_find_name_component_bounds ()
5051 mock_mapped_index
mock_index (test_symbols
);
5053 mock_index
.build_name_components ();
5055 /* Test the lower-level mapped_index::find_name_component_bounds
5056 method in completion mode. */
5058 static const char *expected_syms
[] = {
5063 SELF_CHECK (check_find_bounds_finds (mock_index
,
5064 "t1_func", expected_syms
));
5067 /* Check that the increment-last-char in the name matching algorithm
5068 for completion doesn't get confused with Ansi1 'ÿ' / 0xff. */
5070 static const char *expected_syms1
[] = {
5074 SELF_CHECK (check_find_bounds_finds (mock_index
,
5075 "\377", expected_syms1
));
5077 static const char *expected_syms2
[] = {
5080 SELF_CHECK (check_find_bounds_finds (mock_index
,
5081 "\377\377", expected_syms2
));
5085 /* Test dw2_expand_symtabs_matching_symbol. */
5088 test_dw2_expand_symtabs_matching_symbol ()
5090 mock_mapped_index
mock_index (test_symbols
);
5092 /* We let all tests run until the end even if some fails, for debug
5094 bool any_mismatch
= false;
5096 /* Create the expected symbols list (an initializer_list). Needed
5097 because lists have commas, and we need to pass them to CHECK,
5098 which is a macro. */
5099 #define EXPECT(...) { __VA_ARGS__ }
5101 /* Wrapper for check_match that passes down the current
5102 __FILE__/__LINE__. */
5103 #define CHECK_MATCH(NAME, MATCH_TYPE, COMPLETION_MODE, EXPECTED_LIST) \
5104 any_mismatch |= !check_match (__FILE__, __LINE__, \
5106 NAME, MATCH_TYPE, COMPLETION_MODE, \
5109 /* Identity checks. */
5110 for (const char *sym
: test_symbols
)
5112 /* Should be able to match all existing symbols. */
5113 CHECK_MATCH (sym
, symbol_name_match_type::FULL
, false,
5116 /* Should be able to match all existing symbols with
5118 std::string with_params
= std::string (sym
) + "(int)";
5119 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
5122 /* Should be able to match all existing symbols with
5123 parameters and qualifiers. */
5124 with_params
= std::string (sym
) + " ( int ) const";
5125 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
5128 /* This should really find sym, but cp-name-parser.y doesn't
5129 know about lvalue/rvalue qualifiers yet. */
5130 with_params
= std::string (sym
) + " ( int ) &&";
5131 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
5135 /* Check that the name matching algorithm for completion doesn't get
5136 confused with Latin1 'ÿ' / 0xff. */
5138 static const char str
[] = "\377";
5139 CHECK_MATCH (str
, symbol_name_match_type::FULL
, true,
5140 EXPECT ("\377", "\377\377123"));
5143 /* Check that the increment-last-char in the matching algorithm for
5144 completion doesn't match "t1_fund" when completing "t1_func". */
5146 static const char str
[] = "t1_func";
5147 CHECK_MATCH (str
, symbol_name_match_type::FULL
, true,
5148 EXPECT ("t1_func", "t1_func1"));
5151 /* Check that completion mode works at each prefix of the expected
5154 static const char str
[] = "function(int)";
5155 size_t len
= strlen (str
);
5158 for (size_t i
= 1; i
< len
; i
++)
5160 lookup
.assign (str
, i
);
5161 CHECK_MATCH (lookup
.c_str (), symbol_name_match_type::FULL
, true,
5162 EXPECT ("function"));
5166 /* While "w" is a prefix of both components, the match function
5167 should still only be called once. */
5169 CHECK_MATCH ("w", symbol_name_match_type::FULL
, true,
5171 CHECK_MATCH ("w", symbol_name_match_type::WILD
, true,
5175 /* Same, with a "complicated" symbol. */
5177 static const char str
[] = Z_SYM_NAME
;
5178 size_t len
= strlen (str
);
5181 for (size_t i
= 1; i
< len
; i
++)
5183 lookup
.assign (str
, i
);
5184 CHECK_MATCH (lookup
.c_str (), symbol_name_match_type::FULL
, true,
5185 EXPECT (Z_SYM_NAME
));
5189 /* In FULL mode, an incomplete symbol doesn't match. */
5191 CHECK_MATCH ("std::zfunction(int", symbol_name_match_type::FULL
, false,
5195 /* A complete symbol with parameters matches any overload, since the
5196 index has no overload info. */
5198 CHECK_MATCH ("std::zfunction(int)", symbol_name_match_type::FULL
, true,
5199 EXPECT ("std::zfunction", "std::zfunction2"));
5200 CHECK_MATCH ("zfunction(int)", symbol_name_match_type::WILD
, true,
5201 EXPECT ("std::zfunction", "std::zfunction2"));
5202 CHECK_MATCH ("zfunc", symbol_name_match_type::WILD
, true,
5203 EXPECT ("std::zfunction", "std::zfunction2"));
5206 /* Check that whitespace is ignored appropriately. A symbol with a
5207 template argument list. */
5209 static const char expected
[] = "ns::foo<int>";
5210 CHECK_MATCH ("ns :: foo < int > ", symbol_name_match_type::FULL
, false,
5212 CHECK_MATCH ("foo < int > ", symbol_name_match_type::WILD
, false,
5216 /* Check that whitespace is ignored appropriately. A symbol with a
5217 template argument list that includes a pointer. */
5219 static const char expected
[] = "ns::foo<char*>";
5220 /* Try both completion and non-completion modes. */
5221 static const bool completion_mode
[2] = {false, true};
5222 for (size_t i
= 0; i
< 2; i
++)
5224 CHECK_MATCH ("ns :: foo < char * >", symbol_name_match_type::FULL
,
5225 completion_mode
[i
], EXPECT (expected
));
5226 CHECK_MATCH ("foo < char * >", symbol_name_match_type::WILD
,
5227 completion_mode
[i
], EXPECT (expected
));
5229 CHECK_MATCH ("ns :: foo < char * > (int)", symbol_name_match_type::FULL
,
5230 completion_mode
[i
], EXPECT (expected
));
5231 CHECK_MATCH ("foo < char * > (int)", symbol_name_match_type::WILD
,
5232 completion_mode
[i
], EXPECT (expected
));
5237 /* Check method qualifiers are ignored. */
5238 static const char expected
[] = "ns::foo<char*>";
5239 CHECK_MATCH ("ns :: foo < char * > ( int ) const",
5240 symbol_name_match_type::FULL
, true, EXPECT (expected
));
5241 CHECK_MATCH ("ns :: foo < char * > ( int ) &&",
5242 symbol_name_match_type::FULL
, true, EXPECT (expected
));
5243 CHECK_MATCH ("foo < char * > ( int ) const",
5244 symbol_name_match_type::WILD
, true, EXPECT (expected
));
5245 CHECK_MATCH ("foo < char * > ( int ) &&",
5246 symbol_name_match_type::WILD
, true, EXPECT (expected
));
5249 /* Test lookup names that don't match anything. */
5251 CHECK_MATCH ("bar2", symbol_name_match_type::WILD
, false,
5254 CHECK_MATCH ("doesntexist", symbol_name_match_type::FULL
, false,
5258 /* Some wild matching tests, exercising "(anonymous namespace)",
5259 which should not be confused with a parameter list. */
5261 static const char *syms
[] = {
5265 "A :: B :: C ( int )",
5270 for (const char *s
: syms
)
5272 CHECK_MATCH (s
, symbol_name_match_type::WILD
, false,
5273 EXPECT ("(anonymous namespace)::A::B::C"));
5278 static const char expected
[] = "ns2::tmpl<int>::foo2";
5279 CHECK_MATCH ("tmp", symbol_name_match_type::WILD
, true,
5281 CHECK_MATCH ("tmpl<", symbol_name_match_type::WILD
, true,
5285 SELF_CHECK (!any_mismatch
);
5294 test_mapped_index_find_name_component_bounds ();
5295 test_dw2_expand_symtabs_matching_symbol ();
5298 }} // namespace selftests::dw2_expand_symtabs_matching
5300 #endif /* GDB_SELF_TEST */
5302 /* If FILE_MATCHER is NULL or if PER_CU has
5303 dwarf2_per_cu_quick_data::MARK set (see
5304 dw_expand_symtabs_matching_file_matcher), expand the CU and call
5305 EXPANSION_NOTIFY on it. */
5308 dw2_expand_symtabs_matching_one
5309 (struct dwarf2_per_cu_data
*per_cu
,
5310 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
5311 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
)
5313 if (file_matcher
== NULL
|| per_cu
->v
.quick
->mark
)
5315 bool symtab_was_null
5316 = (per_cu
->v
.quick
->compunit_symtab
== NULL
);
5318 dw2_instantiate_symtab (per_cu
);
5320 if (expansion_notify
!= NULL
5322 && per_cu
->v
.quick
->compunit_symtab
!= NULL
)
5323 expansion_notify (per_cu
->v
.quick
->compunit_symtab
);
5327 /* Helper for dw2_expand_matching symtabs. Called on each symbol
5328 matched, to expand corresponding CUs that were marked. IDX is the
5329 index of the symbol name that matched. */
5332 dw2_expand_marked_cus
5333 (struct dwarf2_per_objfile
*dwarf2_per_objfile
, offset_type idx
,
5334 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
5335 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
5338 offset_type
*vec
, vec_len
, vec_idx
;
5339 bool global_seen
= false;
5340 mapped_index
&index
= *dwarf2_per_objfile
->index_table
;
5342 vec
= (offset_type
*) (index
.constant_pool
5343 + MAYBE_SWAP (index
.symbol_table
[idx
].vec
));
5344 vec_len
= MAYBE_SWAP (vec
[0]);
5345 for (vec_idx
= 0; vec_idx
< vec_len
; ++vec_idx
)
5347 struct dwarf2_per_cu_data
*per_cu
;
5348 offset_type cu_index_and_attrs
= MAYBE_SWAP (vec
[vec_idx
+ 1]);
5349 /* This value is only valid for index versions >= 7. */
5350 int is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs
);
5351 gdb_index_symbol_kind symbol_kind
=
5352 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
5353 int cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
5354 /* Only check the symbol attributes if they're present.
5355 Indices prior to version 7 don't record them,
5356 and indices >= 7 may elide them for certain symbols
5357 (gold does this). */
5360 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_NONE
);
5362 /* Work around gold/15646. */
5365 if (!is_static
&& global_seen
)
5371 /* Only check the symbol's kind if it has one. */
5376 case VARIABLES_DOMAIN
:
5377 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
)
5380 case FUNCTIONS_DOMAIN
:
5381 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
)
5385 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
5393 /* Don't crash on bad data. */
5394 if (cu_index
>= (dwarf2_per_objfile
->n_comp_units
5395 + dwarf2_per_objfile
->n_type_units
))
5397 complaint (&symfile_complaints
,
5398 _(".gdb_index entry has bad CU index"
5400 objfile_name (dwarf2_per_objfile
->objfile
));
5404 per_cu
= dw2_get_cutu (dwarf2_per_objfile
, cu_index
);
5405 dw2_expand_symtabs_matching_one (per_cu
, file_matcher
,
5410 /* If FILE_MATCHER is non-NULL, set all the
5411 dwarf2_per_cu_quick_data::MARK of the current DWARF2_PER_OBJFILE
5412 that match FILE_MATCHER. */
5415 dw_expand_symtabs_matching_file_matcher
5416 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
5417 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
)
5419 if (file_matcher
== NULL
)
5422 objfile
*const objfile
= dwarf2_per_objfile
->objfile
;
5424 htab_up
visited_found (htab_create_alloc (10, htab_hash_pointer
,
5426 NULL
, xcalloc
, xfree
));
5427 htab_up
visited_not_found (htab_create_alloc (10, htab_hash_pointer
,
5429 NULL
, xcalloc
, xfree
));
5431 /* The rule is CUs specify all the files, including those used by
5432 any TU, so there's no need to scan TUs here. */
5434 for (int i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
5437 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (dwarf2_per_objfile
, i
);
5438 struct quick_file_names
*file_data
;
5443 per_cu
->v
.quick
->mark
= 0;
5445 /* We only need to look at symtabs not already expanded. */
5446 if (per_cu
->v
.quick
->compunit_symtab
)
5449 file_data
= dw2_get_file_names (per_cu
);
5450 if (file_data
== NULL
)
5453 if (htab_find (visited_not_found
.get (), file_data
) != NULL
)
5455 else if (htab_find (visited_found
.get (), file_data
) != NULL
)
5457 per_cu
->v
.quick
->mark
= 1;
5461 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
5463 const char *this_real_name
;
5465 if (file_matcher (file_data
->file_names
[j
], false))
5467 per_cu
->v
.quick
->mark
= 1;
5471 /* Before we invoke realpath, which can get expensive when many
5472 files are involved, do a quick comparison of the basenames. */
5473 if (!basenames_may_differ
5474 && !file_matcher (lbasename (file_data
->file_names
[j
]),
5478 this_real_name
= dw2_get_real_path (objfile
, file_data
, j
);
5479 if (file_matcher (this_real_name
, false))
5481 per_cu
->v
.quick
->mark
= 1;
5486 slot
= htab_find_slot (per_cu
->v
.quick
->mark
5487 ? visited_found
.get ()
5488 : visited_not_found
.get (),
5495 dw2_expand_symtabs_matching
5496 (struct objfile
*objfile
,
5497 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
5498 const lookup_name_info
&lookup_name
,
5499 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
5500 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
5501 enum search_domain kind
)
5503 struct dwarf2_per_objfile
*dwarf2_per_objfile
5504 = get_dwarf2_per_objfile (objfile
);
5506 /* index_table is NULL if OBJF_READNOW. */
5507 if (!dwarf2_per_objfile
->index_table
)
5510 dw_expand_symtabs_matching_file_matcher (dwarf2_per_objfile
, file_matcher
);
5512 mapped_index
&index
= *dwarf2_per_objfile
->index_table
;
5514 dw2_expand_symtabs_matching_symbol (index
, lookup_name
,
5516 kind
, [&] (offset_type idx
)
5518 dw2_expand_marked_cus (dwarf2_per_objfile
, idx
, file_matcher
,
5519 expansion_notify
, kind
);
5523 /* A helper for dw2_find_pc_sect_compunit_symtab which finds the most specific
5526 static struct compunit_symtab
*
5527 recursively_find_pc_sect_compunit_symtab (struct compunit_symtab
*cust
,
5532 if (COMPUNIT_BLOCKVECTOR (cust
) != NULL
5533 && blockvector_contains_pc (COMPUNIT_BLOCKVECTOR (cust
), pc
))
5536 if (cust
->includes
== NULL
)
5539 for (i
= 0; cust
->includes
[i
]; ++i
)
5541 struct compunit_symtab
*s
= cust
->includes
[i
];
5543 s
= recursively_find_pc_sect_compunit_symtab (s
, pc
);
5551 static struct compunit_symtab
*
5552 dw2_find_pc_sect_compunit_symtab (struct objfile
*objfile
,
5553 struct bound_minimal_symbol msymbol
,
5555 struct obj_section
*section
,
5558 struct dwarf2_per_cu_data
*data
;
5559 struct compunit_symtab
*result
;
5561 if (!objfile
->psymtabs_addrmap
)
5564 data
= (struct dwarf2_per_cu_data
*) addrmap_find (objfile
->psymtabs_addrmap
,
5569 if (warn_if_readin
&& data
->v
.quick
->compunit_symtab
)
5570 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
5571 paddress (get_objfile_arch (objfile
), pc
));
5574 = recursively_find_pc_sect_compunit_symtab (dw2_instantiate_symtab (data
),
5576 gdb_assert (result
!= NULL
);
5581 dw2_map_symbol_filenames (struct objfile
*objfile
, symbol_filename_ftype
*fun
,
5582 void *data
, int need_fullname
)
5584 struct dwarf2_per_objfile
*dwarf2_per_objfile
5585 = get_dwarf2_per_objfile (objfile
);
5587 if (!dwarf2_per_objfile
->filenames_cache
)
5589 dwarf2_per_objfile
->filenames_cache
.emplace ();
5591 htab_up
visited (htab_create_alloc (10,
5592 htab_hash_pointer
, htab_eq_pointer
,
5593 NULL
, xcalloc
, xfree
));
5595 /* The rule is CUs specify all the files, including those used
5596 by any TU, so there's no need to scan TUs here. We can
5597 ignore file names coming from already-expanded CUs. */
5599 for (int i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
5601 dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (dwarf2_per_objfile
, i
);
5603 if (per_cu
->v
.quick
->compunit_symtab
)
5605 void **slot
= htab_find_slot (visited
.get (),
5606 per_cu
->v
.quick
->file_names
,
5609 *slot
= per_cu
->v
.quick
->file_names
;
5613 for (int i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
5615 dwarf2_per_cu_data
*per_cu
= dw2_get_cu (dwarf2_per_objfile
, i
);
5616 struct quick_file_names
*file_data
;
5619 /* We only need to look at symtabs not already expanded. */
5620 if (per_cu
->v
.quick
->compunit_symtab
)
5623 file_data
= dw2_get_file_names (per_cu
);
5624 if (file_data
== NULL
)
5627 slot
= htab_find_slot (visited
.get (), file_data
, INSERT
);
5630 /* Already visited. */
5635 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
5637 const char *filename
= file_data
->file_names
[j
];
5638 dwarf2_per_objfile
->filenames_cache
->seen (filename
);
5643 dwarf2_per_objfile
->filenames_cache
->traverse ([&] (const char *filename
)
5645 gdb::unique_xmalloc_ptr
<char> this_real_name
;
5648 this_real_name
= gdb_realpath (filename
);
5649 (*fun
) (filename
, this_real_name
.get (), data
);
5654 dw2_has_symbols (struct objfile
*objfile
)
5659 const struct quick_symbol_functions dwarf2_gdb_index_functions
=
5662 dw2_find_last_source_symtab
,
5663 dw2_forget_cached_source_info
,
5664 dw2_map_symtabs_matching_filename
,
5669 dw2_expand_symtabs_for_function
,
5670 dw2_expand_all_symtabs
,
5671 dw2_expand_symtabs_with_fullname
,
5672 dw2_map_matching_symbols
,
5673 dw2_expand_symtabs_matching
,
5674 dw2_find_pc_sect_compunit_symtab
,
5676 dw2_map_symbol_filenames
5679 /* DWARF-5 debug_names reader. */
5681 /* DWARF-5 augmentation string for GDB's DW_IDX_GNU_* extension. */
5682 static const gdb_byte dwarf5_augmentation
[] = { 'G', 'D', 'B', 0 };
5684 /* A helper function that reads the .debug_names section in SECTION
5685 and fills in MAP. FILENAME is the name of the file containing the
5686 section; it is used for error reporting.
5688 Returns true if all went well, false otherwise. */
5691 read_debug_names_from_section (struct objfile
*objfile
,
5692 const char *filename
,
5693 struct dwarf2_section_info
*section
,
5694 mapped_debug_names
&map
)
5696 if (dwarf2_section_empty_p (section
))
5699 /* Older elfutils strip versions could keep the section in the main
5700 executable while splitting it for the separate debug info file. */
5701 if ((get_section_flags (section
) & SEC_HAS_CONTENTS
) == 0)
5704 dwarf2_read_section (objfile
, section
);
5706 map
.dwarf5_byte_order
= gdbarch_byte_order (get_objfile_arch (objfile
));
5708 const gdb_byte
*addr
= section
->buffer
;
5710 bfd
*const abfd
= get_section_bfd_owner (section
);
5712 unsigned int bytes_read
;
5713 LONGEST length
= read_initial_length (abfd
, addr
, &bytes_read
);
5716 map
.dwarf5_is_dwarf64
= bytes_read
!= 4;
5717 map
.offset_size
= map
.dwarf5_is_dwarf64
? 8 : 4;
5718 if (bytes_read
+ length
!= section
->size
)
5720 /* There may be multiple per-CU indices. */
5721 warning (_("Section .debug_names in %s length %s does not match "
5722 "section length %s, ignoring .debug_names."),
5723 filename
, plongest (bytes_read
+ length
),
5724 pulongest (section
->size
));
5728 /* The version number. */
5729 uint16_t version
= read_2_bytes (abfd
, addr
);
5733 warning (_("Section .debug_names in %s has unsupported version %d, "
5734 "ignoring .debug_names."),
5740 uint16_t padding
= read_2_bytes (abfd
, addr
);
5744 warning (_("Section .debug_names in %s has unsupported padding %d, "
5745 "ignoring .debug_names."),
5750 /* comp_unit_count - The number of CUs in the CU list. */
5751 map
.cu_count
= read_4_bytes (abfd
, addr
);
5754 /* local_type_unit_count - The number of TUs in the local TU
5756 map
.tu_count
= read_4_bytes (abfd
, addr
);
5759 /* foreign_type_unit_count - The number of TUs in the foreign TU
5761 uint32_t foreign_tu_count
= read_4_bytes (abfd
, addr
);
5763 if (foreign_tu_count
!= 0)
5765 warning (_("Section .debug_names in %s has unsupported %lu foreign TUs, "
5766 "ignoring .debug_names."),
5767 filename
, static_cast<unsigned long> (foreign_tu_count
));
5771 /* bucket_count - The number of hash buckets in the hash lookup
5773 map
.bucket_count
= read_4_bytes (abfd
, addr
);
5776 /* name_count - The number of unique names in the index. */
5777 map
.name_count
= read_4_bytes (abfd
, addr
);
5780 /* abbrev_table_size - The size in bytes of the abbreviations
5782 uint32_t abbrev_table_size
= read_4_bytes (abfd
, addr
);
5785 /* augmentation_string_size - The size in bytes of the augmentation
5786 string. This value is rounded up to a multiple of 4. */
5787 uint32_t augmentation_string_size
= read_4_bytes (abfd
, addr
);
5789 map
.augmentation_is_gdb
= ((augmentation_string_size
5790 == sizeof (dwarf5_augmentation
))
5791 && memcmp (addr
, dwarf5_augmentation
,
5792 sizeof (dwarf5_augmentation
)) == 0);
5793 augmentation_string_size
+= (-augmentation_string_size
) & 3;
5794 addr
+= augmentation_string_size
;
5797 map
.cu_table_reordered
= addr
;
5798 addr
+= map
.cu_count
* map
.offset_size
;
5800 /* List of Local TUs */
5801 map
.tu_table_reordered
= addr
;
5802 addr
+= map
.tu_count
* map
.offset_size
;
5804 /* Hash Lookup Table */
5805 map
.bucket_table_reordered
= reinterpret_cast<const uint32_t *> (addr
);
5806 addr
+= map
.bucket_count
* 4;
5807 map
.hash_table_reordered
= reinterpret_cast<const uint32_t *> (addr
);
5808 addr
+= map
.name_count
* 4;
5811 map
.name_table_string_offs_reordered
= addr
;
5812 addr
+= map
.name_count
* map
.offset_size
;
5813 map
.name_table_entry_offs_reordered
= addr
;
5814 addr
+= map
.name_count
* map
.offset_size
;
5816 const gdb_byte
*abbrev_table_start
= addr
;
5819 unsigned int bytes_read
;
5820 const ULONGEST index_num
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
5825 const auto insertpair
5826 = map
.abbrev_map
.emplace (index_num
, mapped_debug_names::index_val ());
5827 if (!insertpair
.second
)
5829 warning (_("Section .debug_names in %s has duplicate index %s, "
5830 "ignoring .debug_names."),
5831 filename
, pulongest (index_num
));
5834 mapped_debug_names::index_val
&indexval
= insertpair
.first
->second
;
5835 indexval
.dwarf_tag
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
5840 mapped_debug_names::index_val::attr attr
;
5841 attr
.dw_idx
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
5843 attr
.form
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
5845 if (attr
.form
== DW_FORM_implicit_const
)
5847 attr
.implicit_const
= read_signed_leb128 (abfd
, addr
,
5851 if (attr
.dw_idx
== 0 && attr
.form
== 0)
5853 indexval
.attr_vec
.push_back (std::move (attr
));
5856 if (addr
!= abbrev_table_start
+ abbrev_table_size
)
5858 warning (_("Section .debug_names in %s has abbreviation_table "
5859 "of size %zu vs. written as %u, ignoring .debug_names."),
5860 filename
, addr
- abbrev_table_start
, abbrev_table_size
);
5863 map
.entry_pool
= addr
;
5868 /* A helper for create_cus_from_debug_names that handles the MAP's CU
5872 create_cus_from_debug_names_list (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
5873 const mapped_debug_names
&map
,
5874 dwarf2_section_info
§ion
,
5875 bool is_dwz
, int base_offset
)
5877 sect_offset sect_off_prev
;
5878 for (uint32_t i
= 0; i
<= map
.cu_count
; ++i
)
5880 sect_offset sect_off_next
;
5881 if (i
< map
.cu_count
)
5884 = (sect_offset
) (extract_unsigned_integer
5885 (map
.cu_table_reordered
+ i
* map
.offset_size
,
5887 map
.dwarf5_byte_order
));
5890 sect_off_next
= (sect_offset
) section
.size
;
5893 const ULONGEST length
= sect_off_next
- sect_off_prev
;
5894 dwarf2_per_objfile
->all_comp_units
[base_offset
+ (i
- 1)]
5895 = create_cu_from_index_list (dwarf2_per_objfile
, §ion
, is_dwz
,
5896 sect_off_prev
, length
);
5898 sect_off_prev
= sect_off_next
;
5902 /* Read the CU list from the mapped index, and use it to create all
5903 the CU objects for this dwarf2_per_objfile. */
5906 create_cus_from_debug_names (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
5907 const mapped_debug_names
&map
,
5908 const mapped_debug_names
&dwz_map
)
5910 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
5912 dwarf2_per_objfile
->n_comp_units
= map
.cu_count
+ dwz_map
.cu_count
;
5913 dwarf2_per_objfile
->all_comp_units
5914 = XOBNEWVEC (&objfile
->objfile_obstack
, struct dwarf2_per_cu_data
*,
5915 dwarf2_per_objfile
->n_comp_units
);
5917 create_cus_from_debug_names_list (dwarf2_per_objfile
, map
,
5918 dwarf2_per_objfile
->info
,
5920 0 /* base_offset */);
5922 if (dwz_map
.cu_count
== 0)
5925 dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
5926 create_cus_from_debug_names_list (dwarf2_per_objfile
, dwz_map
, dwz
->info
,
5928 map
.cu_count
/* base_offset */);
5931 /* Read .debug_names. If everything went ok, initialize the "quick"
5932 elements of all the CUs and return true. Otherwise, return false. */
5935 dwarf2_read_debug_names (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
5937 mapped_debug_names
local_map (dwarf2_per_objfile
);
5938 mapped_debug_names
dwz_map (dwarf2_per_objfile
);
5939 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
5941 if (!read_debug_names_from_section (objfile
, objfile_name (objfile
),
5942 &dwarf2_per_objfile
->debug_names
,
5946 /* Don't use the index if it's empty. */
5947 if (local_map
.name_count
== 0)
5950 /* If there is a .dwz file, read it so we can get its CU list as
5952 dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
5955 if (!read_debug_names_from_section (objfile
,
5956 bfd_get_filename (dwz
->dwz_bfd
),
5957 &dwz
->debug_names
, dwz_map
))
5959 warning (_("could not read '.debug_names' section from %s; skipping"),
5960 bfd_get_filename (dwz
->dwz_bfd
));
5965 create_cus_from_debug_names (dwarf2_per_objfile
, local_map
, dwz_map
);
5967 if (local_map
.tu_count
!= 0)
5969 /* We can only handle a single .debug_types when we have an
5971 if (VEC_length (dwarf2_section_info_def
, dwarf2_per_objfile
->types
) != 1)
5974 dwarf2_section_info
*section
= VEC_index (dwarf2_section_info_def
,
5975 dwarf2_per_objfile
->types
, 0);
5977 create_signatured_type_table_from_debug_names
5978 (dwarf2_per_objfile
, local_map
, section
, &dwarf2_per_objfile
->abbrev
);
5981 create_addrmap_from_aranges (dwarf2_per_objfile
,
5982 &dwarf2_per_objfile
->debug_aranges
);
5984 dwarf2_per_objfile
->debug_names_table
.reset
5985 (new mapped_debug_names (dwarf2_per_objfile
));
5986 *dwarf2_per_objfile
->debug_names_table
= std::move (local_map
);
5987 dwarf2_per_objfile
->using_index
= 1;
5988 dwarf2_per_objfile
->quick_file_names_table
=
5989 create_quick_file_names_table (dwarf2_per_objfile
->n_comp_units
);
5994 /* Symbol name hashing function as specified by DWARF-5. */
5997 dwarf5_djb_hash (const char *str_
)
5999 const unsigned char *str
= (const unsigned char *) str_
;
6001 /* Note: tolower here ignores UTF-8, which isn't fully compliant.
6002 See http://dwarfstd.org/ShowIssue.php?issue=161027.1. */
6004 uint32_t hash
= 5381;
6005 while (int c
= *str
++)
6006 hash
= hash
* 33 + tolower (c
);
6010 /* Type used to manage iterating over all CUs looking for a symbol for
6013 class dw2_debug_names_iterator
6016 /* If WANT_SPECIFIC_BLOCK is true, only look for symbols in block
6017 BLOCK_INDEX. Otherwise BLOCK_INDEX is ignored. */
6018 dw2_debug_names_iterator (const mapped_debug_names
&map
,
6019 bool want_specific_block
,
6020 block_enum block_index
, domain_enum domain
,
6022 : m_map (map
), m_want_specific_block (want_specific_block
),
6023 m_block_index (block_index
), m_domain (domain
),
6024 m_addr (find_vec_in_debug_names (map
, name
))
6027 dw2_debug_names_iterator (const mapped_debug_names
&map
,
6028 search_domain search
, uint32_t namei
)
6031 m_addr (find_vec_in_debug_names (map
, namei
))
6034 /* Return the next matching CU or NULL if there are no more. */
6035 dwarf2_per_cu_data
*next ();
6038 static const gdb_byte
*find_vec_in_debug_names (const mapped_debug_names
&map
,
6040 static const gdb_byte
*find_vec_in_debug_names (const mapped_debug_names
&map
,
6043 /* The internalized form of .debug_names. */
6044 const mapped_debug_names
&m_map
;
6046 /* If true, only look for symbols that match BLOCK_INDEX. */
6047 const bool m_want_specific_block
= false;
6049 /* One of GLOBAL_BLOCK or STATIC_BLOCK.
6050 Unused if !WANT_SPECIFIC_BLOCK - FIRST_LOCAL_BLOCK is an invalid
6052 const block_enum m_block_index
= FIRST_LOCAL_BLOCK
;
6054 /* The kind of symbol we're looking for. */
6055 const domain_enum m_domain
= UNDEF_DOMAIN
;
6056 const search_domain m_search
= ALL_DOMAIN
;
6058 /* The list of CUs from the index entry of the symbol, or NULL if
6060 const gdb_byte
*m_addr
;
6064 mapped_debug_names::namei_to_name (uint32_t namei
) const
6066 const ULONGEST namei_string_offs
6067 = extract_unsigned_integer ((name_table_string_offs_reordered
6068 + namei
* offset_size
),
6071 return read_indirect_string_at_offset
6072 (dwarf2_per_objfile
, dwarf2_per_objfile
->objfile
->obfd
, namei_string_offs
);
6075 /* Find a slot in .debug_names for the object named NAME. If NAME is
6076 found, return pointer to its pool data. If NAME cannot be found,
6080 dw2_debug_names_iterator::find_vec_in_debug_names
6081 (const mapped_debug_names
&map
, const char *name
)
6083 int (*cmp
) (const char *, const char *);
6085 if (current_language
->la_language
== language_cplus
6086 || current_language
->la_language
== language_fortran
6087 || current_language
->la_language
== language_d
)
6089 /* NAME is already canonical. Drop any qualifiers as
6090 .debug_names does not contain any. */
6092 if (strchr (name
, '(') != NULL
)
6094 gdb::unique_xmalloc_ptr
<char> without_params
6095 = cp_remove_params (name
);
6097 if (without_params
!= NULL
)
6099 name
= without_params
.get();
6104 cmp
= (case_sensitivity
== case_sensitive_on
? strcmp
: strcasecmp
);
6106 const uint32_t full_hash
= dwarf5_djb_hash (name
);
6108 = extract_unsigned_integer (reinterpret_cast<const gdb_byte
*>
6109 (map
.bucket_table_reordered
6110 + (full_hash
% map
.bucket_count
)), 4,
6111 map
.dwarf5_byte_order
);
6115 if (namei
>= map
.name_count
)
6117 complaint (&symfile_complaints
,
6118 _("Wrong .debug_names with name index %u but name_count=%u "
6120 namei
, map
.name_count
,
6121 objfile_name (map
.dwarf2_per_objfile
->objfile
));
6127 const uint32_t namei_full_hash
6128 = extract_unsigned_integer (reinterpret_cast<const gdb_byte
*>
6129 (map
.hash_table_reordered
+ namei
), 4,
6130 map
.dwarf5_byte_order
);
6131 if (full_hash
% map
.bucket_count
!= namei_full_hash
% map
.bucket_count
)
6134 if (full_hash
== namei_full_hash
)
6136 const char *const namei_string
= map
.namei_to_name (namei
);
6138 #if 0 /* An expensive sanity check. */
6139 if (namei_full_hash
!= dwarf5_djb_hash (namei_string
))
6141 complaint (&symfile_complaints
,
6142 _("Wrong .debug_names hash for string at index %u "
6144 namei
, objfile_name (dwarf2_per_objfile
->objfile
));
6149 if (cmp (namei_string
, name
) == 0)
6151 const ULONGEST namei_entry_offs
6152 = extract_unsigned_integer ((map
.name_table_entry_offs_reordered
6153 + namei
* map
.offset_size
),
6154 map
.offset_size
, map
.dwarf5_byte_order
);
6155 return map
.entry_pool
+ namei_entry_offs
;
6160 if (namei
>= map
.name_count
)
6166 dw2_debug_names_iterator::find_vec_in_debug_names
6167 (const mapped_debug_names
&map
, uint32_t namei
)
6169 if (namei
>= map
.name_count
)
6171 complaint (&symfile_complaints
,
6172 _("Wrong .debug_names with name index %u but name_count=%u "
6174 namei
, map
.name_count
,
6175 objfile_name (map
.dwarf2_per_objfile
->objfile
));
6179 const ULONGEST namei_entry_offs
6180 = extract_unsigned_integer ((map
.name_table_entry_offs_reordered
6181 + namei
* map
.offset_size
),
6182 map
.offset_size
, map
.dwarf5_byte_order
);
6183 return map
.entry_pool
+ namei_entry_offs
;
6186 /* See dw2_debug_names_iterator. */
6188 dwarf2_per_cu_data
*
6189 dw2_debug_names_iterator::next ()
6194 struct dwarf2_per_objfile
*dwarf2_per_objfile
= m_map
.dwarf2_per_objfile
;
6195 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
6196 bfd
*const abfd
= objfile
->obfd
;
6200 unsigned int bytes_read
;
6201 const ULONGEST abbrev
= read_unsigned_leb128 (abfd
, m_addr
, &bytes_read
);
6202 m_addr
+= bytes_read
;
6206 const auto indexval_it
= m_map
.abbrev_map
.find (abbrev
);
6207 if (indexval_it
== m_map
.abbrev_map
.cend ())
6209 complaint (&symfile_complaints
,
6210 _("Wrong .debug_names undefined abbrev code %s "
6212 pulongest (abbrev
), objfile_name (objfile
));
6215 const mapped_debug_names::index_val
&indexval
= indexval_it
->second
;
6216 bool have_is_static
= false;
6218 dwarf2_per_cu_data
*per_cu
= NULL
;
6219 for (const mapped_debug_names::index_val::attr
&attr
: indexval
.attr_vec
)
6224 case DW_FORM_implicit_const
:
6225 ull
= attr
.implicit_const
;
6227 case DW_FORM_flag_present
:
6231 ull
= read_unsigned_leb128 (abfd
, m_addr
, &bytes_read
);
6232 m_addr
+= bytes_read
;
6235 complaint (&symfile_complaints
,
6236 _("Unsupported .debug_names form %s [in module %s]"),
6237 dwarf_form_name (attr
.form
),
6238 objfile_name (objfile
));
6241 switch (attr
.dw_idx
)
6243 case DW_IDX_compile_unit
:
6244 /* Don't crash on bad data. */
6245 if (ull
>= dwarf2_per_objfile
->n_comp_units
)
6247 complaint (&symfile_complaints
,
6248 _(".debug_names entry has bad CU index %s"
6251 objfile_name (dwarf2_per_objfile
->objfile
));
6254 per_cu
= dw2_get_cutu (dwarf2_per_objfile
, ull
);
6256 case DW_IDX_type_unit
:
6257 /* Don't crash on bad data. */
6258 if (ull
>= dwarf2_per_objfile
->n_type_units
)
6260 complaint (&symfile_complaints
,
6261 _(".debug_names entry has bad TU index %s"
6264 objfile_name (dwarf2_per_objfile
->objfile
));
6267 per_cu
= dw2_get_cutu (dwarf2_per_objfile
,
6268 dwarf2_per_objfile
->n_comp_units
+ ull
);
6270 case DW_IDX_GNU_internal
:
6271 if (!m_map
.augmentation_is_gdb
)
6273 have_is_static
= true;
6276 case DW_IDX_GNU_external
:
6277 if (!m_map
.augmentation_is_gdb
)
6279 have_is_static
= true;
6285 /* Skip if already read in. */
6286 if (per_cu
->v
.quick
->compunit_symtab
)
6289 /* Check static vs global. */
6292 const bool want_static
= m_block_index
!= GLOBAL_BLOCK
;
6293 if (m_want_specific_block
&& want_static
!= is_static
)
6297 /* Match dw2_symtab_iter_next, symbol_kind
6298 and debug_names::psymbol_tag. */
6302 switch (indexval
.dwarf_tag
)
6304 case DW_TAG_variable
:
6305 case DW_TAG_subprogram
:
6306 /* Some types are also in VAR_DOMAIN. */
6307 case DW_TAG_typedef
:
6308 case DW_TAG_structure_type
:
6315 switch (indexval
.dwarf_tag
)
6317 case DW_TAG_typedef
:
6318 case DW_TAG_structure_type
:
6325 switch (indexval
.dwarf_tag
)
6328 case DW_TAG_variable
:
6338 /* Match dw2_expand_symtabs_matching, symbol_kind and
6339 debug_names::psymbol_tag. */
6342 case VARIABLES_DOMAIN
:
6343 switch (indexval
.dwarf_tag
)
6345 case DW_TAG_variable
:
6351 case FUNCTIONS_DOMAIN
:
6352 switch (indexval
.dwarf_tag
)
6354 case DW_TAG_subprogram
:
6361 switch (indexval
.dwarf_tag
)
6363 case DW_TAG_typedef
:
6364 case DW_TAG_structure_type
:
6377 static struct compunit_symtab
*
6378 dw2_debug_names_lookup_symbol (struct objfile
*objfile
, int block_index_int
,
6379 const char *name
, domain_enum domain
)
6381 const block_enum block_index
= static_cast<block_enum
> (block_index_int
);
6382 struct dwarf2_per_objfile
*dwarf2_per_objfile
6383 = get_dwarf2_per_objfile (objfile
);
6385 const auto &mapp
= dwarf2_per_objfile
->debug_names_table
;
6388 /* index is NULL if OBJF_READNOW. */
6391 const auto &map
= *mapp
;
6393 dw2_debug_names_iterator
iter (map
, true /* want_specific_block */,
6394 block_index
, domain
, name
);
6396 struct compunit_symtab
*stab_best
= NULL
;
6397 struct dwarf2_per_cu_data
*per_cu
;
6398 while ((per_cu
= iter
.next ()) != NULL
)
6400 struct symbol
*sym
, *with_opaque
= NULL
;
6401 struct compunit_symtab
*stab
= dw2_instantiate_symtab (per_cu
);
6402 const struct blockvector
*bv
= COMPUNIT_BLOCKVECTOR (stab
);
6403 struct block
*block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
6405 sym
= block_find_symbol (block
, name
, domain
,
6406 block_find_non_opaque_type_preferred
,
6409 /* Some caution must be observed with overloaded functions and
6410 methods, since the index will not contain any overload
6411 information (but NAME might contain it). */
6414 && strcmp_iw (SYMBOL_SEARCH_NAME (sym
), name
) == 0)
6416 if (with_opaque
!= NULL
6417 && strcmp_iw (SYMBOL_SEARCH_NAME (with_opaque
), name
) == 0)
6420 /* Keep looking through other CUs. */
6426 /* This dumps minimal information about .debug_names. It is called
6427 via "mt print objfiles". The gdb.dwarf2/gdb-index.exp testcase
6428 uses this to verify that .debug_names has been loaded. */
6431 dw2_debug_names_dump (struct objfile
*objfile
)
6433 struct dwarf2_per_objfile
*dwarf2_per_objfile
6434 = get_dwarf2_per_objfile (objfile
);
6436 gdb_assert (dwarf2_per_objfile
->using_index
);
6437 printf_filtered (".debug_names:");
6438 if (dwarf2_per_objfile
->debug_names_table
)
6439 printf_filtered (" exists\n");
6441 printf_filtered (" faked for \"readnow\"\n");
6442 printf_filtered ("\n");
6446 dw2_debug_names_expand_symtabs_for_function (struct objfile
*objfile
,
6447 const char *func_name
)
6449 struct dwarf2_per_objfile
*dwarf2_per_objfile
6450 = get_dwarf2_per_objfile (objfile
);
6452 /* dwarf2_per_objfile->debug_names_table is NULL if OBJF_READNOW. */
6453 if (dwarf2_per_objfile
->debug_names_table
)
6455 const mapped_debug_names
&map
= *dwarf2_per_objfile
->debug_names_table
;
6457 /* Note: It doesn't matter what we pass for block_index here. */
6458 dw2_debug_names_iterator
iter (map
, false /* want_specific_block */,
6459 GLOBAL_BLOCK
, VAR_DOMAIN
, func_name
);
6461 struct dwarf2_per_cu_data
*per_cu
;
6462 while ((per_cu
= iter
.next ()) != NULL
)
6463 dw2_instantiate_symtab (per_cu
);
6468 dw2_debug_names_expand_symtabs_matching
6469 (struct objfile
*objfile
,
6470 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
6471 const lookup_name_info
&lookup_name
,
6472 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
6473 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
6474 enum search_domain kind
)
6476 struct dwarf2_per_objfile
*dwarf2_per_objfile
6477 = get_dwarf2_per_objfile (objfile
);
6479 /* debug_names_table is NULL if OBJF_READNOW. */
6480 if (!dwarf2_per_objfile
->debug_names_table
)
6483 dw_expand_symtabs_matching_file_matcher (dwarf2_per_objfile
, file_matcher
);
6485 mapped_debug_names
&map
= *dwarf2_per_objfile
->debug_names_table
;
6487 dw2_expand_symtabs_matching_symbol (map
, lookup_name
,
6489 kind
, [&] (offset_type namei
)
6491 /* The name was matched, now expand corresponding CUs that were
6493 dw2_debug_names_iterator
iter (map
, kind
, namei
);
6495 struct dwarf2_per_cu_data
*per_cu
;
6496 while ((per_cu
= iter
.next ()) != NULL
)
6497 dw2_expand_symtabs_matching_one (per_cu
, file_matcher
,
6502 const struct quick_symbol_functions dwarf2_debug_names_functions
=
6505 dw2_find_last_source_symtab
,
6506 dw2_forget_cached_source_info
,
6507 dw2_map_symtabs_matching_filename
,
6508 dw2_debug_names_lookup_symbol
,
6510 dw2_debug_names_dump
,
6512 dw2_debug_names_expand_symtabs_for_function
,
6513 dw2_expand_all_symtabs
,
6514 dw2_expand_symtabs_with_fullname
,
6515 dw2_map_matching_symbols
,
6516 dw2_debug_names_expand_symtabs_matching
,
6517 dw2_find_pc_sect_compunit_symtab
,
6519 dw2_map_symbol_filenames
6522 /* See symfile.h. */
6525 dwarf2_initialize_objfile (struct objfile
*objfile
, dw_index_kind
*index_kind
)
6527 struct dwarf2_per_objfile
*dwarf2_per_objfile
6528 = get_dwarf2_per_objfile (objfile
);
6530 /* If we're about to read full symbols, don't bother with the
6531 indices. In this case we also don't care if some other debug
6532 format is making psymtabs, because they are all about to be
6534 if ((objfile
->flags
& OBJF_READNOW
))
6538 dwarf2_per_objfile
->using_index
= 1;
6539 create_all_comp_units (dwarf2_per_objfile
);
6540 create_all_type_units (dwarf2_per_objfile
);
6541 dwarf2_per_objfile
->quick_file_names_table
=
6542 create_quick_file_names_table (dwarf2_per_objfile
->n_comp_units
);
6544 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
6545 + dwarf2_per_objfile
->n_type_units
); ++i
)
6547 dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (dwarf2_per_objfile
, i
);
6549 per_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
6550 struct dwarf2_per_cu_quick_data
);
6553 /* Return 1 so that gdb sees the "quick" functions. However,
6554 these functions will be no-ops because we will have expanded
6556 *index_kind
= dw_index_kind::GDB_INDEX
;
6560 if (dwarf2_read_debug_names (dwarf2_per_objfile
))
6562 *index_kind
= dw_index_kind::DEBUG_NAMES
;
6566 if (dwarf2_read_index (objfile
))
6568 *index_kind
= dw_index_kind::GDB_INDEX
;
6577 /* Build a partial symbol table. */
6580 dwarf2_build_psymtabs (struct objfile
*objfile
)
6582 struct dwarf2_per_objfile
*dwarf2_per_objfile
6583 = get_dwarf2_per_objfile (objfile
);
6585 if (objfile
->global_psymbols
.capacity () == 0
6586 && objfile
->static_psymbols
.capacity () == 0)
6587 init_psymbol_list (objfile
, 1024);
6591 /* This isn't really ideal: all the data we allocate on the
6592 objfile's obstack is still uselessly kept around. However,
6593 freeing it seems unsafe. */
6594 psymtab_discarder
psymtabs (objfile
);
6595 dwarf2_build_psymtabs_hard (dwarf2_per_objfile
);
6598 CATCH (except
, RETURN_MASK_ERROR
)
6600 exception_print (gdb_stderr
, except
);
6605 /* Return the total length of the CU described by HEADER. */
6608 get_cu_length (const struct comp_unit_head
*header
)
6610 return header
->initial_length_size
+ header
->length
;
6613 /* Return TRUE if SECT_OFF is within CU_HEADER. */
6616 offset_in_cu_p (const comp_unit_head
*cu_header
, sect_offset sect_off
)
6618 sect_offset bottom
= cu_header
->sect_off
;
6619 sect_offset top
= cu_header
->sect_off
+ get_cu_length (cu_header
);
6621 return sect_off
>= bottom
&& sect_off
< top
;
6624 /* Find the base address of the compilation unit for range lists and
6625 location lists. It will normally be specified by DW_AT_low_pc.
6626 In DWARF-3 draft 4, the base address could be overridden by
6627 DW_AT_entry_pc. It's been removed, but GCC still uses this for
6628 compilation units with discontinuous ranges. */
6631 dwarf2_find_base_address (struct die_info
*die
, struct dwarf2_cu
*cu
)
6633 struct attribute
*attr
;
6636 cu
->base_address
= 0;
6638 attr
= dwarf2_attr (die
, DW_AT_entry_pc
, cu
);
6641 cu
->base_address
= attr_value_as_address (attr
);
6646 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
6649 cu
->base_address
= attr_value_as_address (attr
);
6655 /* Read in the comp unit header information from the debug_info at info_ptr.
6656 Use rcuh_kind::COMPILE as the default type if not known by the caller.
6657 NOTE: This leaves members offset, first_die_offset to be filled in
6660 static const gdb_byte
*
6661 read_comp_unit_head (struct comp_unit_head
*cu_header
,
6662 const gdb_byte
*info_ptr
,
6663 struct dwarf2_section_info
*section
,
6664 rcuh_kind section_kind
)
6667 unsigned int bytes_read
;
6668 const char *filename
= get_section_file_name (section
);
6669 bfd
*abfd
= get_section_bfd_owner (section
);
6671 cu_header
->length
= read_initial_length (abfd
, info_ptr
, &bytes_read
);
6672 cu_header
->initial_length_size
= bytes_read
;
6673 cu_header
->offset_size
= (bytes_read
== 4) ? 4 : 8;
6674 info_ptr
+= bytes_read
;
6675 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
6677 if (cu_header
->version
< 5)
6678 switch (section_kind
)
6680 case rcuh_kind::COMPILE
:
6681 cu_header
->unit_type
= DW_UT_compile
;
6683 case rcuh_kind::TYPE
:
6684 cu_header
->unit_type
= DW_UT_type
;
6687 internal_error (__FILE__
, __LINE__
,
6688 _("read_comp_unit_head: invalid section_kind"));
6692 cu_header
->unit_type
= static_cast<enum dwarf_unit_type
>
6693 (read_1_byte (abfd
, info_ptr
));
6695 switch (cu_header
->unit_type
)
6698 if (section_kind
!= rcuh_kind::COMPILE
)
6699 error (_("Dwarf Error: wrong unit_type in compilation unit header "
6700 "(is DW_UT_compile, should be DW_UT_type) [in module %s]"),
6704 section_kind
= rcuh_kind::TYPE
;
6707 error (_("Dwarf Error: wrong unit_type in compilation unit header "
6708 "(is %d, should be %d or %d) [in module %s]"),
6709 cu_header
->unit_type
, DW_UT_compile
, DW_UT_type
, filename
);
6712 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
6715 cu_header
->abbrev_sect_off
= (sect_offset
) read_offset (abfd
, info_ptr
,
6718 info_ptr
+= bytes_read
;
6719 if (cu_header
->version
< 5)
6721 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
6724 signed_addr
= bfd_get_sign_extend_vma (abfd
);
6725 if (signed_addr
< 0)
6726 internal_error (__FILE__
, __LINE__
,
6727 _("read_comp_unit_head: dwarf from non elf file"));
6728 cu_header
->signed_addr_p
= signed_addr
;
6730 if (section_kind
== rcuh_kind::TYPE
)
6732 LONGEST type_offset
;
6734 cu_header
->signature
= read_8_bytes (abfd
, info_ptr
);
6737 type_offset
= read_offset (abfd
, info_ptr
, cu_header
, &bytes_read
);
6738 info_ptr
+= bytes_read
;
6739 cu_header
->type_cu_offset_in_tu
= (cu_offset
) type_offset
;
6740 if (to_underlying (cu_header
->type_cu_offset_in_tu
) != type_offset
)
6741 error (_("Dwarf Error: Too big type_offset in compilation unit "
6742 "header (is %s) [in module %s]"), plongest (type_offset
),
6749 /* Helper function that returns the proper abbrev section for
6752 static struct dwarf2_section_info
*
6753 get_abbrev_section_for_cu (struct dwarf2_per_cu_data
*this_cu
)
6755 struct dwarf2_section_info
*abbrev
;
6756 struct dwarf2_per_objfile
*dwarf2_per_objfile
= this_cu
->dwarf2_per_objfile
;
6758 if (this_cu
->is_dwz
)
6759 abbrev
= &dwarf2_get_dwz_file (dwarf2_per_objfile
)->abbrev
;
6761 abbrev
= &dwarf2_per_objfile
->abbrev
;
6766 /* Subroutine of read_and_check_comp_unit_head and
6767 read_and_check_type_unit_head to simplify them.
6768 Perform various error checking on the header. */
6771 error_check_comp_unit_head (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
6772 struct comp_unit_head
*header
,
6773 struct dwarf2_section_info
*section
,
6774 struct dwarf2_section_info
*abbrev_section
)
6776 const char *filename
= get_section_file_name (section
);
6778 if (header
->version
< 2 || header
->version
> 5)
6779 error (_("Dwarf Error: wrong version in compilation unit header "
6780 "(is %d, should be 2, 3, 4 or 5) [in module %s]"), header
->version
,
6783 if (to_underlying (header
->abbrev_sect_off
)
6784 >= dwarf2_section_size (dwarf2_per_objfile
->objfile
, abbrev_section
))
6785 error (_("Dwarf Error: bad offset (0x%x) in compilation unit header "
6786 "(offset 0x%x + 6) [in module %s]"),
6787 to_underlying (header
->abbrev_sect_off
),
6788 to_underlying (header
->sect_off
),
6791 /* Cast to ULONGEST to use 64-bit arithmetic when possible to
6792 avoid potential 32-bit overflow. */
6793 if (((ULONGEST
) header
->sect_off
+ get_cu_length (header
))
6795 error (_("Dwarf Error: bad length (0x%x) in compilation unit header "
6796 "(offset 0x%x + 0) [in module %s]"),
6797 header
->length
, to_underlying (header
->sect_off
),
6801 /* Read in a CU/TU header and perform some basic error checking.
6802 The contents of the header are stored in HEADER.
6803 The result is a pointer to the start of the first DIE. */
6805 static const gdb_byte
*
6806 read_and_check_comp_unit_head (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
6807 struct comp_unit_head
*header
,
6808 struct dwarf2_section_info
*section
,
6809 struct dwarf2_section_info
*abbrev_section
,
6810 const gdb_byte
*info_ptr
,
6811 rcuh_kind section_kind
)
6813 const gdb_byte
*beg_of_comp_unit
= info_ptr
;
6815 header
->sect_off
= (sect_offset
) (beg_of_comp_unit
- section
->buffer
);
6817 info_ptr
= read_comp_unit_head (header
, info_ptr
, section
, section_kind
);
6819 header
->first_die_cu_offset
= (cu_offset
) (info_ptr
- beg_of_comp_unit
);
6821 error_check_comp_unit_head (dwarf2_per_objfile
, header
, section
,
6827 /* Fetch the abbreviation table offset from a comp or type unit header. */
6830 read_abbrev_offset (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
6831 struct dwarf2_section_info
*section
,
6832 sect_offset sect_off
)
6834 bfd
*abfd
= get_section_bfd_owner (section
);
6835 const gdb_byte
*info_ptr
;
6836 unsigned int initial_length_size
, offset_size
;
6839 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
6840 info_ptr
= section
->buffer
+ to_underlying (sect_off
);
6841 read_initial_length (abfd
, info_ptr
, &initial_length_size
);
6842 offset_size
= initial_length_size
== 4 ? 4 : 8;
6843 info_ptr
+= initial_length_size
;
6845 version
= read_2_bytes (abfd
, info_ptr
);
6849 /* Skip unit type and address size. */
6853 return (sect_offset
) read_offset_1 (abfd
, info_ptr
, offset_size
);
6856 /* Allocate a new partial symtab for file named NAME and mark this new
6857 partial symtab as being an include of PST. */
6860 dwarf2_create_include_psymtab (const char *name
, struct partial_symtab
*pst
,
6861 struct objfile
*objfile
)
6863 struct partial_symtab
*subpst
= allocate_psymtab (name
, objfile
);
6865 if (!IS_ABSOLUTE_PATH (subpst
->filename
))
6867 /* It shares objfile->objfile_obstack. */
6868 subpst
->dirname
= pst
->dirname
;
6871 subpst
->textlow
= 0;
6872 subpst
->texthigh
= 0;
6874 subpst
->dependencies
6875 = XOBNEW (&objfile
->objfile_obstack
, struct partial_symtab
*);
6876 subpst
->dependencies
[0] = pst
;
6877 subpst
->number_of_dependencies
= 1;
6879 subpst
->globals_offset
= 0;
6880 subpst
->n_global_syms
= 0;
6881 subpst
->statics_offset
= 0;
6882 subpst
->n_static_syms
= 0;
6883 subpst
->compunit_symtab
= NULL
;
6884 subpst
->read_symtab
= pst
->read_symtab
;
6887 /* No private part is necessary for include psymtabs. This property
6888 can be used to differentiate between such include psymtabs and
6889 the regular ones. */
6890 subpst
->read_symtab_private
= NULL
;
6893 /* Read the Line Number Program data and extract the list of files
6894 included by the source file represented by PST. Build an include
6895 partial symtab for each of these included files. */
6898 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
6899 struct die_info
*die
,
6900 struct partial_symtab
*pst
)
6903 struct attribute
*attr
;
6905 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
6907 lh
= dwarf_decode_line_header ((sect_offset
) DW_UNSND (attr
), cu
);
6909 return; /* No linetable, so no includes. */
6911 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). */
6912 dwarf_decode_lines (lh
.get (), pst
->dirname
, cu
, pst
, pst
->textlow
, 1);
6916 hash_signatured_type (const void *item
)
6918 const struct signatured_type
*sig_type
6919 = (const struct signatured_type
*) item
;
6921 /* This drops the top 32 bits of the signature, but is ok for a hash. */
6922 return sig_type
->signature
;
6926 eq_signatured_type (const void *item_lhs
, const void *item_rhs
)
6928 const struct signatured_type
*lhs
= (const struct signatured_type
*) item_lhs
;
6929 const struct signatured_type
*rhs
= (const struct signatured_type
*) item_rhs
;
6931 return lhs
->signature
== rhs
->signature
;
6934 /* Allocate a hash table for signatured types. */
6937 allocate_signatured_type_table (struct objfile
*objfile
)
6939 return htab_create_alloc_ex (41,
6940 hash_signatured_type
,
6943 &objfile
->objfile_obstack
,
6944 hashtab_obstack_allocate
,
6945 dummy_obstack_deallocate
);
6948 /* A helper function to add a signatured type CU to a table. */
6951 add_signatured_type_cu_to_table (void **slot
, void *datum
)
6953 struct signatured_type
*sigt
= (struct signatured_type
*) *slot
;
6954 struct signatured_type
***datap
= (struct signatured_type
***) datum
;
6962 /* A helper for create_debug_types_hash_table. Read types from SECTION
6963 and fill them into TYPES_HTAB. It will process only type units,
6964 therefore DW_UT_type. */
6967 create_debug_type_hash_table (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
6968 struct dwo_file
*dwo_file
,
6969 dwarf2_section_info
*section
, htab_t
&types_htab
,
6970 rcuh_kind section_kind
)
6972 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
6973 struct dwarf2_section_info
*abbrev_section
;
6975 const gdb_byte
*info_ptr
, *end_ptr
;
6977 abbrev_section
= (dwo_file
!= NULL
6978 ? &dwo_file
->sections
.abbrev
6979 : &dwarf2_per_objfile
->abbrev
);
6981 if (dwarf_read_debug
)
6982 fprintf_unfiltered (gdb_stdlog
, "Reading %s for %s:\n",
6983 get_section_name (section
),
6984 get_section_file_name (abbrev_section
));
6986 dwarf2_read_section (objfile
, section
);
6987 info_ptr
= section
->buffer
;
6989 if (info_ptr
== NULL
)
6992 /* We can't set abfd until now because the section may be empty or
6993 not present, in which case the bfd is unknown. */
6994 abfd
= get_section_bfd_owner (section
);
6996 /* We don't use init_cutu_and_read_dies_simple, or some such, here
6997 because we don't need to read any dies: the signature is in the
7000 end_ptr
= info_ptr
+ section
->size
;
7001 while (info_ptr
< end_ptr
)
7003 struct signatured_type
*sig_type
;
7004 struct dwo_unit
*dwo_tu
;
7006 const gdb_byte
*ptr
= info_ptr
;
7007 struct comp_unit_head header
;
7008 unsigned int length
;
7010 sect_offset sect_off
= (sect_offset
) (ptr
- section
->buffer
);
7012 /* Initialize it due to a false compiler warning. */
7013 header
.signature
= -1;
7014 header
.type_cu_offset_in_tu
= (cu_offset
) -1;
7016 /* We need to read the type's signature in order to build the hash
7017 table, but we don't need anything else just yet. */
7019 ptr
= read_and_check_comp_unit_head (dwarf2_per_objfile
, &header
, section
,
7020 abbrev_section
, ptr
, section_kind
);
7022 length
= get_cu_length (&header
);
7024 /* Skip dummy type units. */
7025 if (ptr
>= info_ptr
+ length
7026 || peek_abbrev_code (abfd
, ptr
) == 0
7027 || header
.unit_type
!= DW_UT_type
)
7033 if (types_htab
== NULL
)
7036 types_htab
= allocate_dwo_unit_table (objfile
);
7038 types_htab
= allocate_signatured_type_table (objfile
);
7044 dwo_tu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
7046 dwo_tu
->dwo_file
= dwo_file
;
7047 dwo_tu
->signature
= header
.signature
;
7048 dwo_tu
->type_offset_in_tu
= header
.type_cu_offset_in_tu
;
7049 dwo_tu
->section
= section
;
7050 dwo_tu
->sect_off
= sect_off
;
7051 dwo_tu
->length
= length
;
7055 /* N.B.: type_offset is not usable if this type uses a DWO file.
7056 The real type_offset is in the DWO file. */
7058 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
7059 struct signatured_type
);
7060 sig_type
->signature
= header
.signature
;
7061 sig_type
->type_offset_in_tu
= header
.type_cu_offset_in_tu
;
7062 sig_type
->per_cu
.dwarf2_per_objfile
= dwarf2_per_objfile
;
7063 sig_type
->per_cu
.is_debug_types
= 1;
7064 sig_type
->per_cu
.section
= section
;
7065 sig_type
->per_cu
.sect_off
= sect_off
;
7066 sig_type
->per_cu
.length
= length
;
7069 slot
= htab_find_slot (types_htab
,
7070 dwo_file
? (void*) dwo_tu
: (void *) sig_type
,
7072 gdb_assert (slot
!= NULL
);
7075 sect_offset dup_sect_off
;
7079 const struct dwo_unit
*dup_tu
7080 = (const struct dwo_unit
*) *slot
;
7082 dup_sect_off
= dup_tu
->sect_off
;
7086 const struct signatured_type
*dup_tu
7087 = (const struct signatured_type
*) *slot
;
7089 dup_sect_off
= dup_tu
->per_cu
.sect_off
;
7092 complaint (&symfile_complaints
,
7093 _("debug type entry at offset 0x%x is duplicate to"
7094 " the entry at offset 0x%x, signature %s"),
7095 to_underlying (sect_off
), to_underlying (dup_sect_off
),
7096 hex_string (header
.signature
));
7098 *slot
= dwo_file
? (void *) dwo_tu
: (void *) sig_type
;
7100 if (dwarf_read_debug
> 1)
7101 fprintf_unfiltered (gdb_stdlog
, " offset 0x%x, signature %s\n",
7102 to_underlying (sect_off
),
7103 hex_string (header
.signature
));
7109 /* Create the hash table of all entries in the .debug_types
7110 (or .debug_types.dwo) section(s).
7111 If reading a DWO file, then DWO_FILE is a pointer to the DWO file object,
7112 otherwise it is NULL.
7114 The result is a pointer to the hash table or NULL if there are no types.
7116 Note: This function processes DWO files only, not DWP files. */
7119 create_debug_types_hash_table (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
7120 struct dwo_file
*dwo_file
,
7121 VEC (dwarf2_section_info_def
) *types
,
7125 struct dwarf2_section_info
*section
;
7127 if (VEC_empty (dwarf2_section_info_def
, types
))
7131 VEC_iterate (dwarf2_section_info_def
, types
, ix
, section
);
7133 create_debug_type_hash_table (dwarf2_per_objfile
, dwo_file
, section
,
7134 types_htab
, rcuh_kind::TYPE
);
7137 /* Create the hash table of all entries in the .debug_types section,
7138 and initialize all_type_units.
7139 The result is zero if there is an error (e.g. missing .debug_types section),
7140 otherwise non-zero. */
7143 create_all_type_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
7145 htab_t types_htab
= NULL
;
7146 struct signatured_type
**iter
;
7148 create_debug_type_hash_table (dwarf2_per_objfile
, NULL
,
7149 &dwarf2_per_objfile
->info
, types_htab
,
7150 rcuh_kind::COMPILE
);
7151 create_debug_types_hash_table (dwarf2_per_objfile
, NULL
,
7152 dwarf2_per_objfile
->types
, types_htab
);
7153 if (types_htab
== NULL
)
7155 dwarf2_per_objfile
->signatured_types
= NULL
;
7159 dwarf2_per_objfile
->signatured_types
= types_htab
;
7161 dwarf2_per_objfile
->n_type_units
7162 = dwarf2_per_objfile
->n_allocated_type_units
7163 = htab_elements (types_htab
);
7164 dwarf2_per_objfile
->all_type_units
=
7165 XNEWVEC (struct signatured_type
*, dwarf2_per_objfile
->n_type_units
);
7166 iter
= &dwarf2_per_objfile
->all_type_units
[0];
7167 htab_traverse_noresize (types_htab
, add_signatured_type_cu_to_table
, &iter
);
7168 gdb_assert (iter
- &dwarf2_per_objfile
->all_type_units
[0]
7169 == dwarf2_per_objfile
->n_type_units
);
7174 /* Add an entry for signature SIG to dwarf2_per_objfile->signatured_types.
7175 If SLOT is non-NULL, it is the entry to use in the hash table.
7176 Otherwise we find one. */
7178 static struct signatured_type
*
7179 add_type_unit (struct dwarf2_per_objfile
*dwarf2_per_objfile
, ULONGEST sig
,
7182 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
7183 int n_type_units
= dwarf2_per_objfile
->n_type_units
;
7184 struct signatured_type
*sig_type
;
7186 gdb_assert (n_type_units
<= dwarf2_per_objfile
->n_allocated_type_units
);
7188 if (n_type_units
> dwarf2_per_objfile
->n_allocated_type_units
)
7190 if (dwarf2_per_objfile
->n_allocated_type_units
== 0)
7191 dwarf2_per_objfile
->n_allocated_type_units
= 1;
7192 dwarf2_per_objfile
->n_allocated_type_units
*= 2;
7193 dwarf2_per_objfile
->all_type_units
7194 = XRESIZEVEC (struct signatured_type
*,
7195 dwarf2_per_objfile
->all_type_units
,
7196 dwarf2_per_objfile
->n_allocated_type_units
);
7197 ++dwarf2_per_objfile
->tu_stats
.nr_all_type_units_reallocs
;
7199 dwarf2_per_objfile
->n_type_units
= n_type_units
;
7201 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
7202 struct signatured_type
);
7203 dwarf2_per_objfile
->all_type_units
[n_type_units
- 1] = sig_type
;
7204 sig_type
->signature
= sig
;
7205 sig_type
->per_cu
.is_debug_types
= 1;
7206 if (dwarf2_per_objfile
->using_index
)
7208 sig_type
->per_cu
.v
.quick
=
7209 OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
7210 struct dwarf2_per_cu_quick_data
);
7215 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
,
7218 gdb_assert (*slot
== NULL
);
7220 /* The rest of sig_type must be filled in by the caller. */
7224 /* Subroutine of lookup_dwo_signatured_type and lookup_dwp_signatured_type.
7225 Fill in SIG_ENTRY with DWO_ENTRY. */
7228 fill_in_sig_entry_from_dwo_entry (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
7229 struct signatured_type
*sig_entry
,
7230 struct dwo_unit
*dwo_entry
)
7232 /* Make sure we're not clobbering something we don't expect to. */
7233 gdb_assert (! sig_entry
->per_cu
.queued
);
7234 gdb_assert (sig_entry
->per_cu
.cu
== NULL
);
7235 if (dwarf2_per_objfile
->using_index
)
7237 gdb_assert (sig_entry
->per_cu
.v
.quick
!= NULL
);
7238 gdb_assert (sig_entry
->per_cu
.v
.quick
->compunit_symtab
== NULL
);
7241 gdb_assert (sig_entry
->per_cu
.v
.psymtab
== NULL
);
7242 gdb_assert (sig_entry
->signature
== dwo_entry
->signature
);
7243 gdb_assert (to_underlying (sig_entry
->type_offset_in_section
) == 0);
7244 gdb_assert (sig_entry
->type_unit_group
== NULL
);
7245 gdb_assert (sig_entry
->dwo_unit
== NULL
);
7247 sig_entry
->per_cu
.section
= dwo_entry
->section
;
7248 sig_entry
->per_cu
.sect_off
= dwo_entry
->sect_off
;
7249 sig_entry
->per_cu
.length
= dwo_entry
->length
;
7250 sig_entry
->per_cu
.reading_dwo_directly
= 1;
7251 sig_entry
->per_cu
.dwarf2_per_objfile
= dwarf2_per_objfile
;
7252 sig_entry
->type_offset_in_tu
= dwo_entry
->type_offset_in_tu
;
7253 sig_entry
->dwo_unit
= dwo_entry
;
7256 /* Subroutine of lookup_signatured_type.
7257 If we haven't read the TU yet, create the signatured_type data structure
7258 for a TU to be read in directly from a DWO file, bypassing the stub.
7259 This is the "Stay in DWO Optimization": When there is no DWP file and we're
7260 using .gdb_index, then when reading a CU we want to stay in the DWO file
7261 containing that CU. Otherwise we could end up reading several other DWO
7262 files (due to comdat folding) to process the transitive closure of all the
7263 mentioned TUs, and that can be slow. The current DWO file will have every
7264 type signature that it needs.
7265 We only do this for .gdb_index because in the psymtab case we already have
7266 to read all the DWOs to build the type unit groups. */
7268 static struct signatured_type
*
7269 lookup_dwo_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
7271 struct dwarf2_per_objfile
*dwarf2_per_objfile
7272 = cu
->per_cu
->dwarf2_per_objfile
;
7273 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
7274 struct dwo_file
*dwo_file
;
7275 struct dwo_unit find_dwo_entry
, *dwo_entry
;
7276 struct signatured_type find_sig_entry
, *sig_entry
;
7279 gdb_assert (cu
->dwo_unit
&& dwarf2_per_objfile
->using_index
);
7281 /* If TU skeletons have been removed then we may not have read in any
7283 if (dwarf2_per_objfile
->signatured_types
== NULL
)
7285 dwarf2_per_objfile
->signatured_types
7286 = allocate_signatured_type_table (objfile
);
7289 /* We only ever need to read in one copy of a signatured type.
7290 Use the global signatured_types array to do our own comdat-folding
7291 of types. If this is the first time we're reading this TU, and
7292 the TU has an entry in .gdb_index, replace the recorded data from
7293 .gdb_index with this TU. */
7295 find_sig_entry
.signature
= sig
;
7296 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
,
7297 &find_sig_entry
, INSERT
);
7298 sig_entry
= (struct signatured_type
*) *slot
;
7300 /* We can get here with the TU already read, *or* in the process of being
7301 read. Don't reassign the global entry to point to this DWO if that's
7302 the case. Also note that if the TU is already being read, it may not
7303 have come from a DWO, the program may be a mix of Fission-compiled
7304 code and non-Fission-compiled code. */
7306 /* Have we already tried to read this TU?
7307 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
7308 needn't exist in the global table yet). */
7309 if (sig_entry
!= NULL
&& sig_entry
->per_cu
.tu_read
)
7312 /* Note: cu->dwo_unit is the dwo_unit that references this TU, not the
7313 dwo_unit of the TU itself. */
7314 dwo_file
= cu
->dwo_unit
->dwo_file
;
7316 /* Ok, this is the first time we're reading this TU. */
7317 if (dwo_file
->tus
== NULL
)
7319 find_dwo_entry
.signature
= sig
;
7320 dwo_entry
= (struct dwo_unit
*) htab_find (dwo_file
->tus
, &find_dwo_entry
);
7321 if (dwo_entry
== NULL
)
7324 /* If the global table doesn't have an entry for this TU, add one. */
7325 if (sig_entry
== NULL
)
7326 sig_entry
= add_type_unit (dwarf2_per_objfile
, sig
, slot
);
7328 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile
, sig_entry
, dwo_entry
);
7329 sig_entry
->per_cu
.tu_read
= 1;
7333 /* Subroutine of lookup_signatured_type.
7334 Look up the type for signature SIG, and if we can't find SIG in .gdb_index
7335 then try the DWP file. If the TU stub (skeleton) has been removed then
7336 it won't be in .gdb_index. */
7338 static struct signatured_type
*
7339 lookup_dwp_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
7341 struct dwarf2_per_objfile
*dwarf2_per_objfile
7342 = cu
->per_cu
->dwarf2_per_objfile
;
7343 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
7344 struct dwp_file
*dwp_file
= get_dwp_file (dwarf2_per_objfile
);
7345 struct dwo_unit
*dwo_entry
;
7346 struct signatured_type find_sig_entry
, *sig_entry
;
7349 gdb_assert (cu
->dwo_unit
&& dwarf2_per_objfile
->using_index
);
7350 gdb_assert (dwp_file
!= NULL
);
7352 /* If TU skeletons have been removed then we may not have read in any
7354 if (dwarf2_per_objfile
->signatured_types
== NULL
)
7356 dwarf2_per_objfile
->signatured_types
7357 = allocate_signatured_type_table (objfile
);
7360 find_sig_entry
.signature
= sig
;
7361 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
,
7362 &find_sig_entry
, INSERT
);
7363 sig_entry
= (struct signatured_type
*) *slot
;
7365 /* Have we already tried to read this TU?
7366 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
7367 needn't exist in the global table yet). */
7368 if (sig_entry
!= NULL
)
7371 if (dwp_file
->tus
== NULL
)
7373 dwo_entry
= lookup_dwo_unit_in_dwp (dwarf2_per_objfile
, dwp_file
, NULL
,
7374 sig
, 1 /* is_debug_types */);
7375 if (dwo_entry
== NULL
)
7378 sig_entry
= add_type_unit (dwarf2_per_objfile
, sig
, slot
);
7379 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile
, sig_entry
, dwo_entry
);
7384 /* Lookup a signature based type for DW_FORM_ref_sig8.
7385 Returns NULL if signature SIG is not present in the table.
7386 It is up to the caller to complain about this. */
7388 static struct signatured_type
*
7389 lookup_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
7391 struct dwarf2_per_objfile
*dwarf2_per_objfile
7392 = cu
->per_cu
->dwarf2_per_objfile
;
7395 && dwarf2_per_objfile
->using_index
)
7397 /* We're in a DWO/DWP file, and we're using .gdb_index.
7398 These cases require special processing. */
7399 if (get_dwp_file (dwarf2_per_objfile
) == NULL
)
7400 return lookup_dwo_signatured_type (cu
, sig
);
7402 return lookup_dwp_signatured_type (cu
, sig
);
7406 struct signatured_type find_entry
, *entry
;
7408 if (dwarf2_per_objfile
->signatured_types
== NULL
)
7410 find_entry
.signature
= sig
;
7411 entry
= ((struct signatured_type
*)
7412 htab_find (dwarf2_per_objfile
->signatured_types
, &find_entry
));
7417 /* Low level DIE reading support. */
7419 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
7422 init_cu_die_reader (struct die_reader_specs
*reader
,
7423 struct dwarf2_cu
*cu
,
7424 struct dwarf2_section_info
*section
,
7425 struct dwo_file
*dwo_file
)
7427 gdb_assert (section
->readin
&& section
->buffer
!= NULL
);
7428 reader
->abfd
= get_section_bfd_owner (section
);
7430 reader
->dwo_file
= dwo_file
;
7431 reader
->die_section
= section
;
7432 reader
->buffer
= section
->buffer
;
7433 reader
->buffer_end
= section
->buffer
+ section
->size
;
7434 reader
->comp_dir
= NULL
;
7437 /* Subroutine of init_cutu_and_read_dies to simplify it.
7438 Read in the rest of a CU/TU top level DIE from DWO_UNIT.
7439 There's just a lot of work to do, and init_cutu_and_read_dies is big enough
7442 STUB_COMP_UNIT_DIE is for the stub DIE, we copy over certain attributes
7443 from it to the DIE in the DWO. If NULL we are skipping the stub.
7444 STUB_COMP_DIR is similar to STUB_COMP_UNIT_DIE: When reading a TU directly
7445 from the DWO file, bypassing the stub, it contains the DW_AT_comp_dir
7446 attribute of the referencing CU. At most one of STUB_COMP_UNIT_DIE and
7447 STUB_COMP_DIR may be non-NULL.
7448 *RESULT_READER,*RESULT_INFO_PTR,*RESULT_COMP_UNIT_DIE,*RESULT_HAS_CHILDREN
7449 are filled in with the info of the DIE from the DWO file.
7450 ABBREV_TABLE_PROVIDED is non-zero if the caller of init_cutu_and_read_dies
7451 provided an abbrev table to use.
7452 The result is non-zero if a valid (non-dummy) DIE was found. */
7455 read_cutu_die_from_dwo (struct dwarf2_per_cu_data
*this_cu
,
7456 struct dwo_unit
*dwo_unit
,
7457 int abbrev_table_provided
,
7458 struct die_info
*stub_comp_unit_die
,
7459 const char *stub_comp_dir
,
7460 struct die_reader_specs
*result_reader
,
7461 const gdb_byte
**result_info_ptr
,
7462 struct die_info
**result_comp_unit_die
,
7463 int *result_has_children
)
7465 struct dwarf2_per_objfile
*dwarf2_per_objfile
= this_cu
->dwarf2_per_objfile
;
7466 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
7467 struct dwarf2_cu
*cu
= this_cu
->cu
;
7468 struct dwarf2_section_info
*section
;
7470 const gdb_byte
*begin_info_ptr
, *info_ptr
;
7471 struct attribute
*comp_dir
, *stmt_list
, *low_pc
, *high_pc
, *ranges
;
7472 int i
,num_extra_attrs
;
7473 struct dwarf2_section_info
*dwo_abbrev_section
;
7474 struct attribute
*attr
;
7475 struct die_info
*comp_unit_die
;
7477 /* At most one of these may be provided. */
7478 gdb_assert ((stub_comp_unit_die
!= NULL
) + (stub_comp_dir
!= NULL
) <= 1);
7480 /* These attributes aren't processed until later:
7481 DW_AT_stmt_list, DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges.
7482 DW_AT_comp_dir is used now, to find the DWO file, but it is also
7483 referenced later. However, these attributes are found in the stub
7484 which we won't have later. In order to not impose this complication
7485 on the rest of the code, we read them here and copy them to the
7494 if (stub_comp_unit_die
!= NULL
)
7496 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
7498 if (! this_cu
->is_debug_types
)
7499 stmt_list
= dwarf2_attr (stub_comp_unit_die
, DW_AT_stmt_list
, cu
);
7500 low_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_low_pc
, cu
);
7501 high_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_high_pc
, cu
);
7502 ranges
= dwarf2_attr (stub_comp_unit_die
, DW_AT_ranges
, cu
);
7503 comp_dir
= dwarf2_attr (stub_comp_unit_die
, DW_AT_comp_dir
, cu
);
7505 /* There should be a DW_AT_addr_base attribute here (if needed).
7506 We need the value before we can process DW_FORM_GNU_addr_index. */
7508 attr
= dwarf2_attr (stub_comp_unit_die
, DW_AT_GNU_addr_base
, cu
);
7510 cu
->addr_base
= DW_UNSND (attr
);
7512 /* There should be a DW_AT_ranges_base attribute here (if needed).
7513 We need the value before we can process DW_AT_ranges. */
7514 cu
->ranges_base
= 0;
7515 attr
= dwarf2_attr (stub_comp_unit_die
, DW_AT_GNU_ranges_base
, cu
);
7517 cu
->ranges_base
= DW_UNSND (attr
);
7519 else if (stub_comp_dir
!= NULL
)
7521 /* Reconstruct the comp_dir attribute to simplify the code below. */
7522 comp_dir
= XOBNEW (&cu
->comp_unit_obstack
, struct attribute
);
7523 comp_dir
->name
= DW_AT_comp_dir
;
7524 comp_dir
->form
= DW_FORM_string
;
7525 DW_STRING_IS_CANONICAL (comp_dir
) = 0;
7526 DW_STRING (comp_dir
) = stub_comp_dir
;
7529 /* Set up for reading the DWO CU/TU. */
7530 cu
->dwo_unit
= dwo_unit
;
7531 section
= dwo_unit
->section
;
7532 dwarf2_read_section (objfile
, section
);
7533 abfd
= get_section_bfd_owner (section
);
7534 begin_info_ptr
= info_ptr
= (section
->buffer
7535 + to_underlying (dwo_unit
->sect_off
));
7536 dwo_abbrev_section
= &dwo_unit
->dwo_file
->sections
.abbrev
;
7537 init_cu_die_reader (result_reader
, cu
, section
, dwo_unit
->dwo_file
);
7539 if (this_cu
->is_debug_types
)
7541 struct signatured_type
*sig_type
= (struct signatured_type
*) this_cu
;
7543 info_ptr
= read_and_check_comp_unit_head (dwarf2_per_objfile
,
7544 &cu
->header
, section
,
7546 info_ptr
, rcuh_kind::TYPE
);
7547 /* This is not an assert because it can be caused by bad debug info. */
7548 if (sig_type
->signature
!= cu
->header
.signature
)
7550 error (_("Dwarf Error: signature mismatch %s vs %s while reading"
7551 " TU at offset 0x%x [in module %s]"),
7552 hex_string (sig_type
->signature
),
7553 hex_string (cu
->header
.signature
),
7554 to_underlying (dwo_unit
->sect_off
),
7555 bfd_get_filename (abfd
));
7557 gdb_assert (dwo_unit
->sect_off
== cu
->header
.sect_off
);
7558 /* For DWOs coming from DWP files, we don't know the CU length
7559 nor the type's offset in the TU until now. */
7560 dwo_unit
->length
= get_cu_length (&cu
->header
);
7561 dwo_unit
->type_offset_in_tu
= cu
->header
.type_cu_offset_in_tu
;
7563 /* Establish the type offset that can be used to lookup the type.
7564 For DWO files, we don't know it until now. */
7565 sig_type
->type_offset_in_section
7566 = dwo_unit
->sect_off
+ to_underlying (dwo_unit
->type_offset_in_tu
);
7570 info_ptr
= read_and_check_comp_unit_head (dwarf2_per_objfile
,
7571 &cu
->header
, section
,
7573 info_ptr
, rcuh_kind::COMPILE
);
7574 gdb_assert (dwo_unit
->sect_off
== cu
->header
.sect_off
);
7575 /* For DWOs coming from DWP files, we don't know the CU length
7577 dwo_unit
->length
= get_cu_length (&cu
->header
);
7580 /* Replace the CU's original abbrev table with the DWO's.
7581 Reminder: We can't read the abbrev table until we've read the header. */
7582 if (abbrev_table_provided
)
7584 /* Don't free the provided abbrev table, the caller of
7585 init_cutu_and_read_dies owns it. */
7586 dwarf2_read_abbrevs (cu
, dwo_abbrev_section
);
7587 /* Ensure the DWO abbrev table gets freed. */
7588 make_cleanup (dwarf2_free_abbrev_table
, cu
);
7592 dwarf2_free_abbrev_table (cu
);
7593 dwarf2_read_abbrevs (cu
, dwo_abbrev_section
);
7594 /* Leave any existing abbrev table cleanup as is. */
7597 /* Read in the die, but leave space to copy over the attributes
7598 from the stub. This has the benefit of simplifying the rest of
7599 the code - all the work to maintain the illusion of a single
7600 DW_TAG_{compile,type}_unit DIE is done here. */
7601 num_extra_attrs
= ((stmt_list
!= NULL
)
7605 + (comp_dir
!= NULL
));
7606 info_ptr
= read_full_die_1 (result_reader
, result_comp_unit_die
, info_ptr
,
7607 result_has_children
, num_extra_attrs
);
7609 /* Copy over the attributes from the stub to the DIE we just read in. */
7610 comp_unit_die
= *result_comp_unit_die
;
7611 i
= comp_unit_die
->num_attrs
;
7612 if (stmt_list
!= NULL
)
7613 comp_unit_die
->attrs
[i
++] = *stmt_list
;
7615 comp_unit_die
->attrs
[i
++] = *low_pc
;
7616 if (high_pc
!= NULL
)
7617 comp_unit_die
->attrs
[i
++] = *high_pc
;
7619 comp_unit_die
->attrs
[i
++] = *ranges
;
7620 if (comp_dir
!= NULL
)
7621 comp_unit_die
->attrs
[i
++] = *comp_dir
;
7622 comp_unit_die
->num_attrs
+= num_extra_attrs
;
7624 if (dwarf_die_debug
)
7626 fprintf_unfiltered (gdb_stdlog
,
7627 "Read die from %s@0x%x of %s:\n",
7628 get_section_name (section
),
7629 (unsigned) (begin_info_ptr
- section
->buffer
),
7630 bfd_get_filename (abfd
));
7631 dump_die (comp_unit_die
, dwarf_die_debug
);
7634 /* Save the comp_dir attribute. If there is no DWP file then we'll read
7635 TUs by skipping the stub and going directly to the entry in the DWO file.
7636 However, skipping the stub means we won't get DW_AT_comp_dir, so we have
7637 to get it via circuitous means. Blech. */
7638 if (comp_dir
!= NULL
)
7639 result_reader
->comp_dir
= DW_STRING (comp_dir
);
7641 /* Skip dummy compilation units. */
7642 if (info_ptr
>= begin_info_ptr
+ dwo_unit
->length
7643 || peek_abbrev_code (abfd
, info_ptr
) == 0)
7646 *result_info_ptr
= info_ptr
;
7650 /* Subroutine of init_cutu_and_read_dies to simplify it.
7651 Look up the DWO unit specified by COMP_UNIT_DIE of THIS_CU.
7652 Returns NULL if the specified DWO unit cannot be found. */
7654 static struct dwo_unit
*
7655 lookup_dwo_unit (struct dwarf2_per_cu_data
*this_cu
,
7656 struct die_info
*comp_unit_die
)
7658 struct dwarf2_cu
*cu
= this_cu
->cu
;
7660 struct dwo_unit
*dwo_unit
;
7661 const char *comp_dir
, *dwo_name
;
7663 gdb_assert (cu
!= NULL
);
7665 /* Yeah, we look dwo_name up again, but it simplifies the code. */
7666 dwo_name
= dwarf2_string_attr (comp_unit_die
, DW_AT_GNU_dwo_name
, cu
);
7667 comp_dir
= dwarf2_string_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
7669 if (this_cu
->is_debug_types
)
7671 struct signatured_type
*sig_type
;
7673 /* Since this_cu is the first member of struct signatured_type,
7674 we can go from a pointer to one to a pointer to the other. */
7675 sig_type
= (struct signatured_type
*) this_cu
;
7676 signature
= sig_type
->signature
;
7677 dwo_unit
= lookup_dwo_type_unit (sig_type
, dwo_name
, comp_dir
);
7681 struct attribute
*attr
;
7683 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_id
, cu
);
7685 error (_("Dwarf Error: missing dwo_id for dwo_name %s"
7687 dwo_name
, objfile_name (this_cu
->dwarf2_per_objfile
->objfile
));
7688 signature
= DW_UNSND (attr
);
7689 dwo_unit
= lookup_dwo_comp_unit (this_cu
, dwo_name
, comp_dir
,
7696 /* Subroutine of init_cutu_and_read_dies to simplify it.
7697 See it for a description of the parameters.
7698 Read a TU directly from a DWO file, bypassing the stub.
7700 Note: This function could be a little bit simpler if we shared cleanups
7701 with our caller, init_cutu_and_read_dies. That's generally a fragile thing
7702 to do, so we keep this function self-contained. Or we could move this
7703 into our caller, but it's complex enough already. */
7706 init_tu_and_read_dwo_dies (struct dwarf2_per_cu_data
*this_cu
,
7707 int use_existing_cu
, int keep
,
7708 die_reader_func_ftype
*die_reader_func
,
7711 struct dwarf2_cu
*cu
;
7712 struct signatured_type
*sig_type
;
7713 struct cleanup
*cleanups
, *free_cu_cleanup
= NULL
;
7714 struct die_reader_specs reader
;
7715 const gdb_byte
*info_ptr
;
7716 struct die_info
*comp_unit_die
;
7718 struct dwarf2_per_objfile
*dwarf2_per_objfile
= this_cu
->dwarf2_per_objfile
;
7720 /* Verify we can do the following downcast, and that we have the
7722 gdb_assert (this_cu
->is_debug_types
&& this_cu
->reading_dwo_directly
);
7723 sig_type
= (struct signatured_type
*) this_cu
;
7724 gdb_assert (sig_type
->dwo_unit
!= NULL
);
7726 cleanups
= make_cleanup (null_cleanup
, NULL
);
7728 if (use_existing_cu
&& this_cu
->cu
!= NULL
)
7730 gdb_assert (this_cu
->cu
->dwo_unit
== sig_type
->dwo_unit
);
7732 /* There's no need to do the rereading_dwo_cu handling that
7733 init_cutu_and_read_dies does since we don't read the stub. */
7737 /* If !use_existing_cu, this_cu->cu must be NULL. */
7738 gdb_assert (this_cu
->cu
== NULL
);
7739 cu
= XNEW (struct dwarf2_cu
);
7740 init_one_comp_unit (cu
, this_cu
);
7741 /* If an error occurs while loading, release our storage. */
7742 free_cu_cleanup
= make_cleanup (free_heap_comp_unit
, cu
);
7745 /* A future optimization, if needed, would be to use an existing
7746 abbrev table. When reading DWOs with skeletonless TUs, all the TUs
7747 could share abbrev tables. */
7749 if (read_cutu_die_from_dwo (this_cu
, sig_type
->dwo_unit
,
7750 0 /* abbrev_table_provided */,
7751 NULL
/* stub_comp_unit_die */,
7752 sig_type
->dwo_unit
->dwo_file
->comp_dir
,
7754 &comp_unit_die
, &has_children
) == 0)
7757 do_cleanups (cleanups
);
7761 /* All the "real" work is done here. */
7762 die_reader_func (&reader
, info_ptr
, comp_unit_die
, has_children
, data
);
7764 /* This duplicates the code in init_cutu_and_read_dies,
7765 but the alternative is making the latter more complex.
7766 This function is only for the special case of using DWO files directly:
7767 no point in overly complicating the general case just to handle this. */
7768 if (free_cu_cleanup
!= NULL
)
7772 /* We've successfully allocated this compilation unit. Let our
7773 caller clean it up when finished with it. */
7774 discard_cleanups (free_cu_cleanup
);
7776 /* We can only discard free_cu_cleanup and all subsequent cleanups.
7777 So we have to manually free the abbrev table. */
7778 dwarf2_free_abbrev_table (cu
);
7780 /* Link this CU into read_in_chain. */
7781 this_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
7782 dwarf2_per_objfile
->read_in_chain
= this_cu
;
7785 do_cleanups (free_cu_cleanup
);
7788 do_cleanups (cleanups
);
7791 /* Initialize a CU (or TU) and read its DIEs.
7792 If the CU defers to a DWO file, read the DWO file as well.
7794 ABBREV_TABLE, if non-NULL, is the abbreviation table to use.
7795 Otherwise the table specified in the comp unit header is read in and used.
7796 This is an optimization for when we already have the abbrev table.
7798 If USE_EXISTING_CU is non-zero, and THIS_CU->cu is non-NULL, then use it.
7799 Otherwise, a new CU is allocated with xmalloc.
7801 If KEEP is non-zero, then if we allocated a dwarf2_cu we add it to
7802 read_in_chain. Otherwise the dwarf2_cu data is freed at the end.
7804 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
7805 linker) then DIE_READER_FUNC will not get called. */
7808 init_cutu_and_read_dies (struct dwarf2_per_cu_data
*this_cu
,
7809 struct abbrev_table
*abbrev_table
,
7810 int use_existing_cu
, int keep
,
7811 die_reader_func_ftype
*die_reader_func
,
7814 struct dwarf2_per_objfile
*dwarf2_per_objfile
= this_cu
->dwarf2_per_objfile
;
7815 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
7816 struct dwarf2_section_info
*section
= this_cu
->section
;
7817 bfd
*abfd
= get_section_bfd_owner (section
);
7818 struct dwarf2_cu
*cu
;
7819 const gdb_byte
*begin_info_ptr
, *info_ptr
;
7820 struct die_reader_specs reader
;
7821 struct die_info
*comp_unit_die
;
7823 struct attribute
*attr
;
7824 struct cleanup
*cleanups
, *free_cu_cleanup
= NULL
;
7825 struct signatured_type
*sig_type
= NULL
;
7826 struct dwarf2_section_info
*abbrev_section
;
7827 /* Non-zero if CU currently points to a DWO file and we need to
7828 reread it. When this happens we need to reread the skeleton die
7829 before we can reread the DWO file (this only applies to CUs, not TUs). */
7830 int rereading_dwo_cu
= 0;
7832 if (dwarf_die_debug
)
7833 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset 0x%x\n",
7834 this_cu
->is_debug_types
? "type" : "comp",
7835 to_underlying (this_cu
->sect_off
));
7837 if (use_existing_cu
)
7840 /* If we're reading a TU directly from a DWO file, including a virtual DWO
7841 file (instead of going through the stub), short-circuit all of this. */
7842 if (this_cu
->reading_dwo_directly
)
7844 /* Narrow down the scope of possibilities to have to understand. */
7845 gdb_assert (this_cu
->is_debug_types
);
7846 gdb_assert (abbrev_table
== NULL
);
7847 init_tu_and_read_dwo_dies (this_cu
, use_existing_cu
, keep
,
7848 die_reader_func
, data
);
7852 cleanups
= make_cleanup (null_cleanup
, NULL
);
7854 /* This is cheap if the section is already read in. */
7855 dwarf2_read_section (objfile
, section
);
7857 begin_info_ptr
= info_ptr
= section
->buffer
+ to_underlying (this_cu
->sect_off
);
7859 abbrev_section
= get_abbrev_section_for_cu (this_cu
);
7861 if (use_existing_cu
&& this_cu
->cu
!= NULL
)
7864 /* If this CU is from a DWO file we need to start over, we need to
7865 refetch the attributes from the skeleton CU.
7866 This could be optimized by retrieving those attributes from when we
7867 were here the first time: the previous comp_unit_die was stored in
7868 comp_unit_obstack. But there's no data yet that we need this
7870 if (cu
->dwo_unit
!= NULL
)
7871 rereading_dwo_cu
= 1;
7875 /* If !use_existing_cu, this_cu->cu must be NULL. */
7876 gdb_assert (this_cu
->cu
== NULL
);
7877 cu
= XNEW (struct dwarf2_cu
);
7878 init_one_comp_unit (cu
, this_cu
);
7879 /* If an error occurs while loading, release our storage. */
7880 free_cu_cleanup
= make_cleanup (free_heap_comp_unit
, cu
);
7883 /* Get the header. */
7884 if (to_underlying (cu
->header
.first_die_cu_offset
) != 0 && !rereading_dwo_cu
)
7886 /* We already have the header, there's no need to read it in again. */
7887 info_ptr
+= to_underlying (cu
->header
.first_die_cu_offset
);
7891 if (this_cu
->is_debug_types
)
7893 info_ptr
= read_and_check_comp_unit_head (dwarf2_per_objfile
,
7894 &cu
->header
, section
,
7895 abbrev_section
, info_ptr
,
7898 /* Since per_cu is the first member of struct signatured_type,
7899 we can go from a pointer to one to a pointer to the other. */
7900 sig_type
= (struct signatured_type
*) this_cu
;
7901 gdb_assert (sig_type
->signature
== cu
->header
.signature
);
7902 gdb_assert (sig_type
->type_offset_in_tu
7903 == cu
->header
.type_cu_offset_in_tu
);
7904 gdb_assert (this_cu
->sect_off
== cu
->header
.sect_off
);
7906 /* LENGTH has not been set yet for type units if we're
7907 using .gdb_index. */
7908 this_cu
->length
= get_cu_length (&cu
->header
);
7910 /* Establish the type offset that can be used to lookup the type. */
7911 sig_type
->type_offset_in_section
=
7912 this_cu
->sect_off
+ to_underlying (sig_type
->type_offset_in_tu
);
7914 this_cu
->dwarf_version
= cu
->header
.version
;
7918 info_ptr
= read_and_check_comp_unit_head (dwarf2_per_objfile
,
7919 &cu
->header
, section
,
7922 rcuh_kind::COMPILE
);
7924 gdb_assert (this_cu
->sect_off
== cu
->header
.sect_off
);
7925 gdb_assert (this_cu
->length
== get_cu_length (&cu
->header
));
7926 this_cu
->dwarf_version
= cu
->header
.version
;
7930 /* Skip dummy compilation units. */
7931 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
7932 || peek_abbrev_code (abfd
, info_ptr
) == 0)
7934 do_cleanups (cleanups
);
7938 /* If we don't have them yet, read the abbrevs for this compilation unit.
7939 And if we need to read them now, make sure they're freed when we're
7940 done. Note that it's important that if the CU had an abbrev table
7941 on entry we don't free it when we're done: Somewhere up the call stack
7942 it may be in use. */
7943 if (abbrev_table
!= NULL
)
7945 gdb_assert (cu
->abbrev_table
== NULL
);
7946 gdb_assert (cu
->header
.abbrev_sect_off
== abbrev_table
->sect_off
);
7947 cu
->abbrev_table
= abbrev_table
;
7949 else if (cu
->abbrev_table
== NULL
)
7951 dwarf2_read_abbrevs (cu
, abbrev_section
);
7952 make_cleanup (dwarf2_free_abbrev_table
, cu
);
7954 else if (rereading_dwo_cu
)
7956 dwarf2_free_abbrev_table (cu
);
7957 dwarf2_read_abbrevs (cu
, abbrev_section
);
7960 /* Read the top level CU/TU die. */
7961 init_cu_die_reader (&reader
, cu
, section
, NULL
);
7962 info_ptr
= read_full_die (&reader
, &comp_unit_die
, info_ptr
, &has_children
);
7964 /* If we are in a DWO stub, process it and then read in the "real" CU/TU
7966 Note that if USE_EXISTING_OK != 0, and THIS_CU->cu already contains a
7967 DWO CU, that this test will fail (the attribute will not be present). */
7968 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_name
, cu
);
7971 struct dwo_unit
*dwo_unit
;
7972 struct die_info
*dwo_comp_unit_die
;
7976 complaint (&symfile_complaints
,
7977 _("compilation unit with DW_AT_GNU_dwo_name"
7978 " has children (offset 0x%x) [in module %s]"),
7979 to_underlying (this_cu
->sect_off
), bfd_get_filename (abfd
));
7981 dwo_unit
= lookup_dwo_unit (this_cu
, comp_unit_die
);
7982 if (dwo_unit
!= NULL
)
7984 if (read_cutu_die_from_dwo (this_cu
, dwo_unit
,
7985 abbrev_table
!= NULL
,
7986 comp_unit_die
, NULL
,
7988 &dwo_comp_unit_die
, &has_children
) == 0)
7991 do_cleanups (cleanups
);
7994 comp_unit_die
= dwo_comp_unit_die
;
7998 /* Yikes, we couldn't find the rest of the DIE, we only have
7999 the stub. A complaint has already been logged. There's
8000 not much more we can do except pass on the stub DIE to
8001 die_reader_func. We don't want to throw an error on bad
8006 /* All of the above is setup for this call. Yikes. */
8007 die_reader_func (&reader
, info_ptr
, comp_unit_die
, has_children
, data
);
8009 /* Done, clean up. */
8010 if (free_cu_cleanup
!= NULL
)
8014 /* We've successfully allocated this compilation unit. Let our
8015 caller clean it up when finished with it. */
8016 discard_cleanups (free_cu_cleanup
);
8018 /* We can only discard free_cu_cleanup and all subsequent cleanups.
8019 So we have to manually free the abbrev table. */
8020 dwarf2_free_abbrev_table (cu
);
8022 /* Link this CU into read_in_chain. */
8023 this_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
8024 dwarf2_per_objfile
->read_in_chain
= this_cu
;
8027 do_cleanups (free_cu_cleanup
);
8030 do_cleanups (cleanups
);
8033 /* Read CU/TU THIS_CU but do not follow DW_AT_GNU_dwo_name if present.
8034 DWO_FILE, if non-NULL, is the DWO file to read (the caller is assumed
8035 to have already done the lookup to find the DWO file).
8037 The caller is required to fill in THIS_CU->section, THIS_CU->offset, and
8038 THIS_CU->is_debug_types, but nothing else.
8040 We fill in THIS_CU->length.
8042 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
8043 linker) then DIE_READER_FUNC will not get called.
8045 THIS_CU->cu is always freed when done.
8046 This is done in order to not leave THIS_CU->cu in a state where we have
8047 to care whether it refers to the "main" CU or the DWO CU. */
8050 init_cutu_and_read_dies_no_follow (struct dwarf2_per_cu_data
*this_cu
,
8051 struct dwo_file
*dwo_file
,
8052 die_reader_func_ftype
*die_reader_func
,
8055 struct dwarf2_per_objfile
*dwarf2_per_objfile
= this_cu
->dwarf2_per_objfile
;
8056 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8057 struct dwarf2_section_info
*section
= this_cu
->section
;
8058 bfd
*abfd
= get_section_bfd_owner (section
);
8059 struct dwarf2_section_info
*abbrev_section
;
8060 struct dwarf2_cu cu
;
8061 const gdb_byte
*begin_info_ptr
, *info_ptr
;
8062 struct die_reader_specs reader
;
8063 struct cleanup
*cleanups
;
8064 struct die_info
*comp_unit_die
;
8067 if (dwarf_die_debug
)
8068 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset 0x%x\n",
8069 this_cu
->is_debug_types
? "type" : "comp",
8070 to_underlying (this_cu
->sect_off
));
8072 gdb_assert (this_cu
->cu
== NULL
);
8074 abbrev_section
= (dwo_file
!= NULL
8075 ? &dwo_file
->sections
.abbrev
8076 : get_abbrev_section_for_cu (this_cu
));
8078 /* This is cheap if the section is already read in. */
8079 dwarf2_read_section (objfile
, section
);
8081 init_one_comp_unit (&cu
, this_cu
);
8083 cleanups
= make_cleanup (free_stack_comp_unit
, &cu
);
8085 begin_info_ptr
= info_ptr
= section
->buffer
+ to_underlying (this_cu
->sect_off
);
8086 info_ptr
= read_and_check_comp_unit_head (dwarf2_per_objfile
,
8087 &cu
.header
, section
,
8088 abbrev_section
, info_ptr
,
8089 (this_cu
->is_debug_types
8091 : rcuh_kind::COMPILE
));
8093 this_cu
->length
= get_cu_length (&cu
.header
);
8095 /* Skip dummy compilation units. */
8096 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
8097 || peek_abbrev_code (abfd
, info_ptr
) == 0)
8099 do_cleanups (cleanups
);
8103 dwarf2_read_abbrevs (&cu
, abbrev_section
);
8104 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
8106 init_cu_die_reader (&reader
, &cu
, section
, dwo_file
);
8107 info_ptr
= read_full_die (&reader
, &comp_unit_die
, info_ptr
, &has_children
);
8109 die_reader_func (&reader
, info_ptr
, comp_unit_die
, has_children
, data
);
8111 do_cleanups (cleanups
);
8114 /* Read a CU/TU, except that this does not look for DW_AT_GNU_dwo_name and
8115 does not lookup the specified DWO file.
8116 This cannot be used to read DWO files.
8118 THIS_CU->cu is always freed when done.
8119 This is done in order to not leave THIS_CU->cu in a state where we have
8120 to care whether it refers to the "main" CU or the DWO CU.
8121 We can revisit this if the data shows there's a performance issue. */
8124 init_cutu_and_read_dies_simple (struct dwarf2_per_cu_data
*this_cu
,
8125 die_reader_func_ftype
*die_reader_func
,
8128 init_cutu_and_read_dies_no_follow (this_cu
, NULL
, die_reader_func
, data
);
8131 /* Type Unit Groups.
8133 Type Unit Groups are a way to collapse the set of all TUs (type units) into
8134 a more manageable set. The grouping is done by DW_AT_stmt_list entry
8135 so that all types coming from the same compilation (.o file) are grouped
8136 together. A future step could be to put the types in the same symtab as
8137 the CU the types ultimately came from. */
8140 hash_type_unit_group (const void *item
)
8142 const struct type_unit_group
*tu_group
8143 = (const struct type_unit_group
*) item
;
8145 return hash_stmt_list_entry (&tu_group
->hash
);
8149 eq_type_unit_group (const void *item_lhs
, const void *item_rhs
)
8151 const struct type_unit_group
*lhs
= (const struct type_unit_group
*) item_lhs
;
8152 const struct type_unit_group
*rhs
= (const struct type_unit_group
*) item_rhs
;
8154 return eq_stmt_list_entry (&lhs
->hash
, &rhs
->hash
);
8157 /* Allocate a hash table for type unit groups. */
8160 allocate_type_unit_groups_table (struct objfile
*objfile
)
8162 return htab_create_alloc_ex (3,
8163 hash_type_unit_group
,
8166 &objfile
->objfile_obstack
,
8167 hashtab_obstack_allocate
,
8168 dummy_obstack_deallocate
);
8171 /* Type units that don't have DW_AT_stmt_list are grouped into their own
8172 partial symtabs. We combine several TUs per psymtab to not let the size
8173 of any one psymtab grow too big. */
8174 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB (1 << 31)
8175 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE 10
8177 /* Helper routine for get_type_unit_group.
8178 Create the type_unit_group object used to hold one or more TUs. */
8180 static struct type_unit_group
*
8181 create_type_unit_group (struct dwarf2_cu
*cu
, sect_offset line_offset_struct
)
8183 struct dwarf2_per_objfile
*dwarf2_per_objfile
8184 = cu
->per_cu
->dwarf2_per_objfile
;
8185 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8186 struct dwarf2_per_cu_data
*per_cu
;
8187 struct type_unit_group
*tu_group
;
8189 tu_group
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
8190 struct type_unit_group
);
8191 per_cu
= &tu_group
->per_cu
;
8192 per_cu
->dwarf2_per_objfile
= dwarf2_per_objfile
;
8194 if (dwarf2_per_objfile
->using_index
)
8196 per_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
8197 struct dwarf2_per_cu_quick_data
);
8201 unsigned int line_offset
= to_underlying (line_offset_struct
);
8202 struct partial_symtab
*pst
;
8205 /* Give the symtab a useful name for debug purposes. */
8206 if ((line_offset
& NO_STMT_LIST_TYPE_UNIT_PSYMTAB
) != 0)
8207 name
= xstrprintf ("<type_units_%d>",
8208 (line_offset
& ~NO_STMT_LIST_TYPE_UNIT_PSYMTAB
));
8210 name
= xstrprintf ("<type_units_at_0x%x>", line_offset
);
8212 pst
= create_partial_symtab (per_cu
, name
);
8218 tu_group
->hash
.dwo_unit
= cu
->dwo_unit
;
8219 tu_group
->hash
.line_sect_off
= line_offset_struct
;
8224 /* Look up the type_unit_group for type unit CU, and create it if necessary.
8225 STMT_LIST is a DW_AT_stmt_list attribute. */
8227 static struct type_unit_group
*
8228 get_type_unit_group (struct dwarf2_cu
*cu
, const struct attribute
*stmt_list
)
8230 struct dwarf2_per_objfile
*dwarf2_per_objfile
8231 = cu
->per_cu
->dwarf2_per_objfile
;
8232 struct tu_stats
*tu_stats
= &dwarf2_per_objfile
->tu_stats
;
8233 struct type_unit_group
*tu_group
;
8235 unsigned int line_offset
;
8236 struct type_unit_group type_unit_group_for_lookup
;
8238 if (dwarf2_per_objfile
->type_unit_groups
== NULL
)
8240 dwarf2_per_objfile
->type_unit_groups
=
8241 allocate_type_unit_groups_table (dwarf2_per_objfile
->objfile
);
8244 /* Do we need to create a new group, or can we use an existing one? */
8248 line_offset
= DW_UNSND (stmt_list
);
8249 ++tu_stats
->nr_symtab_sharers
;
8253 /* Ugh, no stmt_list. Rare, but we have to handle it.
8254 We can do various things here like create one group per TU or
8255 spread them over multiple groups to split up the expansion work.
8256 To avoid worst case scenarios (too many groups or too large groups)
8257 we, umm, group them in bunches. */
8258 line_offset
= (NO_STMT_LIST_TYPE_UNIT_PSYMTAB
8259 | (tu_stats
->nr_stmt_less_type_units
8260 / NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE
));
8261 ++tu_stats
->nr_stmt_less_type_units
;
8264 type_unit_group_for_lookup
.hash
.dwo_unit
= cu
->dwo_unit
;
8265 type_unit_group_for_lookup
.hash
.line_sect_off
= (sect_offset
) line_offset
;
8266 slot
= htab_find_slot (dwarf2_per_objfile
->type_unit_groups
,
8267 &type_unit_group_for_lookup
, INSERT
);
8270 tu_group
= (struct type_unit_group
*) *slot
;
8271 gdb_assert (tu_group
!= NULL
);
8275 sect_offset line_offset_struct
= (sect_offset
) line_offset
;
8276 tu_group
= create_type_unit_group (cu
, line_offset_struct
);
8278 ++tu_stats
->nr_symtabs
;
8284 /* Partial symbol tables. */
8286 /* Create a psymtab named NAME and assign it to PER_CU.
8288 The caller must fill in the following details:
8289 dirname, textlow, texthigh. */
8291 static struct partial_symtab
*
8292 create_partial_symtab (struct dwarf2_per_cu_data
*per_cu
, const char *name
)
8294 struct objfile
*objfile
= per_cu
->dwarf2_per_objfile
->objfile
;
8295 struct partial_symtab
*pst
;
8297 pst
= start_psymtab_common (objfile
, name
, 0,
8298 objfile
->global_psymbols
,
8299 objfile
->static_psymbols
);
8301 pst
->psymtabs_addrmap_supported
= 1;
8303 /* This is the glue that links PST into GDB's symbol API. */
8304 pst
->read_symtab_private
= per_cu
;
8305 pst
->read_symtab
= dwarf2_read_symtab
;
8306 per_cu
->v
.psymtab
= pst
;
8311 /* The DATA object passed to process_psymtab_comp_unit_reader has this
8314 struct process_psymtab_comp_unit_data
8316 /* True if we are reading a DW_TAG_partial_unit. */
8318 int want_partial_unit
;
8320 /* The "pretend" language that is used if the CU doesn't declare a
8323 enum language pretend_language
;
8326 /* die_reader_func for process_psymtab_comp_unit. */
8329 process_psymtab_comp_unit_reader (const struct die_reader_specs
*reader
,
8330 const gdb_byte
*info_ptr
,
8331 struct die_info
*comp_unit_die
,
8335 struct dwarf2_cu
*cu
= reader
->cu
;
8336 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
8337 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
8338 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
8340 CORE_ADDR best_lowpc
= 0, best_highpc
= 0;
8341 struct partial_symtab
*pst
;
8342 enum pc_bounds_kind cu_bounds_kind
;
8343 const char *filename
;
8344 struct process_psymtab_comp_unit_data
*info
8345 = (struct process_psymtab_comp_unit_data
*) data
;
8347 if (comp_unit_die
->tag
== DW_TAG_partial_unit
&& !info
->want_partial_unit
)
8350 gdb_assert (! per_cu
->is_debug_types
);
8352 prepare_one_comp_unit (cu
, comp_unit_die
, info
->pretend_language
);
8354 cu
->list_in_scope
= &file_symbols
;
8356 /* Allocate a new partial symbol table structure. */
8357 filename
= dwarf2_string_attr (comp_unit_die
, DW_AT_name
, cu
);
8358 if (filename
== NULL
)
8361 pst
= create_partial_symtab (per_cu
, filename
);
8363 /* This must be done before calling dwarf2_build_include_psymtabs. */
8364 pst
->dirname
= dwarf2_string_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
8366 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
8368 dwarf2_find_base_address (comp_unit_die
, cu
);
8370 /* Possibly set the default values of LOWPC and HIGHPC from
8372 cu_bounds_kind
= dwarf2_get_pc_bounds (comp_unit_die
, &best_lowpc
,
8373 &best_highpc
, cu
, pst
);
8374 if (cu_bounds_kind
== PC_BOUNDS_HIGH_LOW
&& best_lowpc
< best_highpc
)
8375 /* Store the contiguous range if it is not empty; it can be empty for
8376 CUs with no code. */
8377 addrmap_set_empty (objfile
->psymtabs_addrmap
,
8378 gdbarch_adjust_dwarf2_addr (gdbarch
,
8379 best_lowpc
+ baseaddr
),
8380 gdbarch_adjust_dwarf2_addr (gdbarch
,
8381 best_highpc
+ baseaddr
) - 1,
8384 /* Check if comp unit has_children.
8385 If so, read the rest of the partial symbols from this comp unit.
8386 If not, there's no more debug_info for this comp unit. */
8389 struct partial_die_info
*first_die
;
8390 CORE_ADDR lowpc
, highpc
;
8392 lowpc
= ((CORE_ADDR
) -1);
8393 highpc
= ((CORE_ADDR
) 0);
8395 first_die
= load_partial_dies (reader
, info_ptr
, 1);
8397 scan_partial_symbols (first_die
, &lowpc
, &highpc
,
8398 cu_bounds_kind
<= PC_BOUNDS_INVALID
, cu
);
8400 /* If we didn't find a lowpc, set it to highpc to avoid
8401 complaints from `maint check'. */
8402 if (lowpc
== ((CORE_ADDR
) -1))
8405 /* If the compilation unit didn't have an explicit address range,
8406 then use the information extracted from its child dies. */
8407 if (cu_bounds_kind
<= PC_BOUNDS_INVALID
)
8410 best_highpc
= highpc
;
8413 pst
->textlow
= gdbarch_adjust_dwarf2_addr (gdbarch
, best_lowpc
+ baseaddr
);
8414 pst
->texthigh
= gdbarch_adjust_dwarf2_addr (gdbarch
, best_highpc
+ baseaddr
);
8416 end_psymtab_common (objfile
, pst
);
8418 if (!VEC_empty (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
))
8421 int len
= VEC_length (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
);
8422 struct dwarf2_per_cu_data
*iter
;
8424 /* Fill in 'dependencies' here; we fill in 'users' in a
8426 pst
->number_of_dependencies
= len
;
8428 XOBNEWVEC (&objfile
->objfile_obstack
, struct partial_symtab
*, len
);
8430 VEC_iterate (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
,
8433 pst
->dependencies
[i
] = iter
->v
.psymtab
;
8435 VEC_free (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
);
8438 /* Get the list of files included in the current compilation unit,
8439 and build a psymtab for each of them. */
8440 dwarf2_build_include_psymtabs (cu
, comp_unit_die
, pst
);
8442 if (dwarf_read_debug
)
8444 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
8446 fprintf_unfiltered (gdb_stdlog
,
8447 "Psymtab for %s unit @0x%x: %s - %s"
8448 ", %d global, %d static syms\n",
8449 per_cu
->is_debug_types
? "type" : "comp",
8450 to_underlying (per_cu
->sect_off
),
8451 paddress (gdbarch
, pst
->textlow
),
8452 paddress (gdbarch
, pst
->texthigh
),
8453 pst
->n_global_syms
, pst
->n_static_syms
);
8457 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
8458 Process compilation unit THIS_CU for a psymtab. */
8461 process_psymtab_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
8462 int want_partial_unit
,
8463 enum language pretend_language
)
8465 /* If this compilation unit was already read in, free the
8466 cached copy in order to read it in again. This is
8467 necessary because we skipped some symbols when we first
8468 read in the compilation unit (see load_partial_dies).
8469 This problem could be avoided, but the benefit is unclear. */
8470 if (this_cu
->cu
!= NULL
)
8471 free_one_cached_comp_unit (this_cu
);
8473 if (this_cu
->is_debug_types
)
8474 init_cutu_and_read_dies (this_cu
, NULL
, 0, 0, build_type_psymtabs_reader
,
8478 process_psymtab_comp_unit_data info
;
8479 info
.want_partial_unit
= want_partial_unit
;
8480 info
.pretend_language
= pretend_language
;
8481 init_cutu_and_read_dies (this_cu
, NULL
, 0, 0,
8482 process_psymtab_comp_unit_reader
, &info
);
8485 /* Age out any secondary CUs. */
8486 age_cached_comp_units (this_cu
->dwarf2_per_objfile
);
8489 /* Reader function for build_type_psymtabs. */
8492 build_type_psymtabs_reader (const struct die_reader_specs
*reader
,
8493 const gdb_byte
*info_ptr
,
8494 struct die_info
*type_unit_die
,
8498 struct dwarf2_per_objfile
*dwarf2_per_objfile
8499 = reader
->cu
->per_cu
->dwarf2_per_objfile
;
8500 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8501 struct dwarf2_cu
*cu
= reader
->cu
;
8502 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
8503 struct signatured_type
*sig_type
;
8504 struct type_unit_group
*tu_group
;
8505 struct attribute
*attr
;
8506 struct partial_die_info
*first_die
;
8507 CORE_ADDR lowpc
, highpc
;
8508 struct partial_symtab
*pst
;
8510 gdb_assert (data
== NULL
);
8511 gdb_assert (per_cu
->is_debug_types
);
8512 sig_type
= (struct signatured_type
*) per_cu
;
8517 attr
= dwarf2_attr_no_follow (type_unit_die
, DW_AT_stmt_list
);
8518 tu_group
= get_type_unit_group (cu
, attr
);
8520 VEC_safe_push (sig_type_ptr
, tu_group
->tus
, sig_type
);
8522 prepare_one_comp_unit (cu
, type_unit_die
, language_minimal
);
8523 cu
->list_in_scope
= &file_symbols
;
8524 pst
= create_partial_symtab (per_cu
, "");
8527 first_die
= load_partial_dies (reader
, info_ptr
, 1);
8529 lowpc
= (CORE_ADDR
) -1;
8530 highpc
= (CORE_ADDR
) 0;
8531 scan_partial_symbols (first_die
, &lowpc
, &highpc
, 0, cu
);
8533 end_psymtab_common (objfile
, pst
);
8536 /* Struct used to sort TUs by their abbreviation table offset. */
8538 struct tu_abbrev_offset
8540 struct signatured_type
*sig_type
;
8541 sect_offset abbrev_offset
;
8544 /* Helper routine for build_type_psymtabs_1, passed to qsort. */
8547 sort_tu_by_abbrev_offset (const void *ap
, const void *bp
)
8549 const struct tu_abbrev_offset
* const *a
8550 = (const struct tu_abbrev_offset
* const*) ap
;
8551 const struct tu_abbrev_offset
* const *b
8552 = (const struct tu_abbrev_offset
* const*) bp
;
8553 sect_offset aoff
= (*a
)->abbrev_offset
;
8554 sect_offset boff
= (*b
)->abbrev_offset
;
8556 return (aoff
> boff
) - (aoff
< boff
);
8559 /* Efficiently read all the type units.
8560 This does the bulk of the work for build_type_psymtabs.
8562 The efficiency is because we sort TUs by the abbrev table they use and
8563 only read each abbrev table once. In one program there are 200K TUs
8564 sharing 8K abbrev tables.
8566 The main purpose of this function is to support building the
8567 dwarf2_per_objfile->type_unit_groups table.
8568 TUs typically share the DW_AT_stmt_list of the CU they came from, so we
8569 can collapse the search space by grouping them by stmt_list.
8570 The savings can be significant, in the same program from above the 200K TUs
8571 share 8K stmt_list tables.
8573 FUNC is expected to call get_type_unit_group, which will create the
8574 struct type_unit_group if necessary and add it to
8575 dwarf2_per_objfile->type_unit_groups. */
8578 build_type_psymtabs_1 (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
8580 struct tu_stats
*tu_stats
= &dwarf2_per_objfile
->tu_stats
;
8581 struct cleanup
*cleanups
;
8582 struct abbrev_table
*abbrev_table
;
8583 sect_offset abbrev_offset
;
8584 struct tu_abbrev_offset
*sorted_by_abbrev
;
8587 /* It's up to the caller to not call us multiple times. */
8588 gdb_assert (dwarf2_per_objfile
->type_unit_groups
== NULL
);
8590 if (dwarf2_per_objfile
->n_type_units
== 0)
8593 /* TUs typically share abbrev tables, and there can be way more TUs than
8594 abbrev tables. Sort by abbrev table to reduce the number of times we
8595 read each abbrev table in.
8596 Alternatives are to punt or to maintain a cache of abbrev tables.
8597 This is simpler and efficient enough for now.
8599 Later we group TUs by their DW_AT_stmt_list value (as this defines the
8600 symtab to use). Typically TUs with the same abbrev offset have the same
8601 stmt_list value too so in practice this should work well.
8603 The basic algorithm here is:
8605 sort TUs by abbrev table
8606 for each TU with same abbrev table:
8607 read abbrev table if first user
8608 read TU top level DIE
8609 [IWBN if DWO skeletons had DW_AT_stmt_list]
8612 if (dwarf_read_debug
)
8613 fprintf_unfiltered (gdb_stdlog
, "Building type unit groups ...\n");
8615 /* Sort in a separate table to maintain the order of all_type_units
8616 for .gdb_index: TU indices directly index all_type_units. */
8617 sorted_by_abbrev
= XNEWVEC (struct tu_abbrev_offset
,
8618 dwarf2_per_objfile
->n_type_units
);
8619 for (i
= 0; i
< dwarf2_per_objfile
->n_type_units
; ++i
)
8621 struct signatured_type
*sig_type
= dwarf2_per_objfile
->all_type_units
[i
];
8623 sorted_by_abbrev
[i
].sig_type
= sig_type
;
8624 sorted_by_abbrev
[i
].abbrev_offset
=
8625 read_abbrev_offset (dwarf2_per_objfile
,
8626 sig_type
->per_cu
.section
,
8627 sig_type
->per_cu
.sect_off
);
8629 cleanups
= make_cleanup (xfree
, sorted_by_abbrev
);
8630 qsort (sorted_by_abbrev
, dwarf2_per_objfile
->n_type_units
,
8631 sizeof (struct tu_abbrev_offset
), sort_tu_by_abbrev_offset
);
8633 abbrev_offset
= (sect_offset
) ~(unsigned) 0;
8634 abbrev_table
= NULL
;
8635 make_cleanup (abbrev_table_free_cleanup
, &abbrev_table
);
8637 for (i
= 0; i
< dwarf2_per_objfile
->n_type_units
; ++i
)
8639 const struct tu_abbrev_offset
*tu
= &sorted_by_abbrev
[i
];
8641 /* Switch to the next abbrev table if necessary. */
8642 if (abbrev_table
== NULL
8643 || tu
->abbrev_offset
!= abbrev_offset
)
8645 if (abbrev_table
!= NULL
)
8647 abbrev_table_free (abbrev_table
);
8648 /* Reset to NULL in case abbrev_table_read_table throws
8649 an error: abbrev_table_free_cleanup will get called. */
8650 abbrev_table
= NULL
;
8652 abbrev_offset
= tu
->abbrev_offset
;
8654 abbrev_table_read_table (dwarf2_per_objfile
,
8655 &dwarf2_per_objfile
->abbrev
,
8657 ++tu_stats
->nr_uniq_abbrev_tables
;
8660 init_cutu_and_read_dies (&tu
->sig_type
->per_cu
, abbrev_table
, 0, 0,
8661 build_type_psymtabs_reader
, NULL
);
8664 do_cleanups (cleanups
);
8667 /* Print collected type unit statistics. */
8670 print_tu_stats (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
8672 struct tu_stats
*tu_stats
= &dwarf2_per_objfile
->tu_stats
;
8674 fprintf_unfiltered (gdb_stdlog
, "Type unit statistics:\n");
8675 fprintf_unfiltered (gdb_stdlog
, " %d TUs\n",
8676 dwarf2_per_objfile
->n_type_units
);
8677 fprintf_unfiltered (gdb_stdlog
, " %d uniq abbrev tables\n",
8678 tu_stats
->nr_uniq_abbrev_tables
);
8679 fprintf_unfiltered (gdb_stdlog
, " %d symtabs from stmt_list entries\n",
8680 tu_stats
->nr_symtabs
);
8681 fprintf_unfiltered (gdb_stdlog
, " %d symtab sharers\n",
8682 tu_stats
->nr_symtab_sharers
);
8683 fprintf_unfiltered (gdb_stdlog
, " %d type units without a stmt_list\n",
8684 tu_stats
->nr_stmt_less_type_units
);
8685 fprintf_unfiltered (gdb_stdlog
, " %d all_type_units reallocs\n",
8686 tu_stats
->nr_all_type_units_reallocs
);
8689 /* Traversal function for build_type_psymtabs. */
8692 build_type_psymtab_dependencies (void **slot
, void *info
)
8694 struct dwarf2_per_objfile
*dwarf2_per_objfile
8695 = (struct dwarf2_per_objfile
*) info
;
8696 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8697 struct type_unit_group
*tu_group
= (struct type_unit_group
*) *slot
;
8698 struct dwarf2_per_cu_data
*per_cu
= &tu_group
->per_cu
;
8699 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
8700 int len
= VEC_length (sig_type_ptr
, tu_group
->tus
);
8701 struct signatured_type
*iter
;
8704 gdb_assert (len
> 0);
8705 gdb_assert (IS_TYPE_UNIT_GROUP (per_cu
));
8707 pst
->number_of_dependencies
= len
;
8709 XOBNEWVEC (&objfile
->objfile_obstack
, struct partial_symtab
*, len
);
8711 VEC_iterate (sig_type_ptr
, tu_group
->tus
, i
, iter
);
8714 gdb_assert (iter
->per_cu
.is_debug_types
);
8715 pst
->dependencies
[i
] = iter
->per_cu
.v
.psymtab
;
8716 iter
->type_unit_group
= tu_group
;
8719 VEC_free (sig_type_ptr
, tu_group
->tus
);
8724 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
8725 Build partial symbol tables for the .debug_types comp-units. */
8728 build_type_psymtabs (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
8730 if (! create_all_type_units (dwarf2_per_objfile
))
8733 build_type_psymtabs_1 (dwarf2_per_objfile
);
8736 /* Traversal function for process_skeletonless_type_unit.
8737 Read a TU in a DWO file and build partial symbols for it. */
8740 process_skeletonless_type_unit (void **slot
, void *info
)
8742 struct dwo_unit
*dwo_unit
= (struct dwo_unit
*) *slot
;
8743 struct dwarf2_per_objfile
*dwarf2_per_objfile
8744 = (struct dwarf2_per_objfile
*) info
;
8745 struct signatured_type find_entry
, *entry
;
8747 /* If this TU doesn't exist in the global table, add it and read it in. */
8749 if (dwarf2_per_objfile
->signatured_types
== NULL
)
8751 dwarf2_per_objfile
->signatured_types
8752 = allocate_signatured_type_table (dwarf2_per_objfile
->objfile
);
8755 find_entry
.signature
= dwo_unit
->signature
;
8756 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
, &find_entry
,
8758 /* If we've already seen this type there's nothing to do. What's happening
8759 is we're doing our own version of comdat-folding here. */
8763 /* This does the job that create_all_type_units would have done for
8765 entry
= add_type_unit (dwarf2_per_objfile
, dwo_unit
->signature
, slot
);
8766 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile
, entry
, dwo_unit
);
8769 /* This does the job that build_type_psymtabs_1 would have done. */
8770 init_cutu_and_read_dies (&entry
->per_cu
, NULL
, 0, 0,
8771 build_type_psymtabs_reader
, NULL
);
8776 /* Traversal function for process_skeletonless_type_units. */
8779 process_dwo_file_for_skeletonless_type_units (void **slot
, void *info
)
8781 struct dwo_file
*dwo_file
= (struct dwo_file
*) *slot
;
8783 if (dwo_file
->tus
!= NULL
)
8785 htab_traverse_noresize (dwo_file
->tus
,
8786 process_skeletonless_type_unit
, info
);
8792 /* Scan all TUs of DWO files, verifying we've processed them.
8793 This is needed in case a TU was emitted without its skeleton.
8794 Note: This can't be done until we know what all the DWO files are. */
8797 process_skeletonless_type_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
8799 /* Skeletonless TUs in DWP files without .gdb_index is not supported yet. */
8800 if (get_dwp_file (dwarf2_per_objfile
) == NULL
8801 && dwarf2_per_objfile
->dwo_files
!= NULL
)
8803 htab_traverse_noresize (dwarf2_per_objfile
->dwo_files
,
8804 process_dwo_file_for_skeletonless_type_units
,
8805 dwarf2_per_objfile
);
8809 /* Compute the 'user' field for each psymtab in DWARF2_PER_OBJFILE. */
8812 set_partial_user (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
8816 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
8818 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (dwarf2_per_objfile
, i
);
8819 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
8825 for (j
= 0; j
< pst
->number_of_dependencies
; ++j
)
8827 /* Set the 'user' field only if it is not already set. */
8828 if (pst
->dependencies
[j
]->user
== NULL
)
8829 pst
->dependencies
[j
]->user
= pst
;
8834 /* Build the partial symbol table by doing a quick pass through the
8835 .debug_info and .debug_abbrev sections. */
8838 dwarf2_build_psymtabs_hard (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
8840 struct cleanup
*back_to
;
8842 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8844 if (dwarf_read_debug
)
8846 fprintf_unfiltered (gdb_stdlog
, "Building psymtabs of objfile %s ...\n",
8847 objfile_name (objfile
));
8850 dwarf2_per_objfile
->reading_partial_symbols
= 1;
8852 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
8854 /* Any cached compilation units will be linked by the per-objfile
8855 read_in_chain. Make sure to free them when we're done. */
8856 back_to
= make_cleanup (free_cached_comp_units
, dwarf2_per_objfile
);
8858 build_type_psymtabs (dwarf2_per_objfile
);
8860 create_all_comp_units (dwarf2_per_objfile
);
8862 /* Create a temporary address map on a temporary obstack. We later
8863 copy this to the final obstack. */
8864 auto_obstack temp_obstack
;
8866 scoped_restore save_psymtabs_addrmap
8867 = make_scoped_restore (&objfile
->psymtabs_addrmap
,
8868 addrmap_create_mutable (&temp_obstack
));
8870 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
8872 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (dwarf2_per_objfile
, i
);
8874 process_psymtab_comp_unit (per_cu
, 0, language_minimal
);
8877 /* This has to wait until we read the CUs, we need the list of DWOs. */
8878 process_skeletonless_type_units (dwarf2_per_objfile
);
8880 /* Now that all TUs have been processed we can fill in the dependencies. */
8881 if (dwarf2_per_objfile
->type_unit_groups
!= NULL
)
8883 htab_traverse_noresize (dwarf2_per_objfile
->type_unit_groups
,
8884 build_type_psymtab_dependencies
, dwarf2_per_objfile
);
8887 if (dwarf_read_debug
)
8888 print_tu_stats (dwarf2_per_objfile
);
8890 set_partial_user (dwarf2_per_objfile
);
8892 objfile
->psymtabs_addrmap
= addrmap_create_fixed (objfile
->psymtabs_addrmap
,
8893 &objfile
->objfile_obstack
);
8894 /* At this point we want to keep the address map. */
8895 save_psymtabs_addrmap
.release ();
8897 do_cleanups (back_to
);
8899 if (dwarf_read_debug
)
8900 fprintf_unfiltered (gdb_stdlog
, "Done building psymtabs of %s\n",
8901 objfile_name (objfile
));
8904 /* die_reader_func for load_partial_comp_unit. */
8907 load_partial_comp_unit_reader (const struct die_reader_specs
*reader
,
8908 const gdb_byte
*info_ptr
,
8909 struct die_info
*comp_unit_die
,
8913 struct dwarf2_cu
*cu
= reader
->cu
;
8915 prepare_one_comp_unit (cu
, comp_unit_die
, language_minimal
);
8917 /* Check if comp unit has_children.
8918 If so, read the rest of the partial symbols from this comp unit.
8919 If not, there's no more debug_info for this comp unit. */
8921 load_partial_dies (reader
, info_ptr
, 0);
8924 /* Load the partial DIEs for a secondary CU into memory.
8925 This is also used when rereading a primary CU with load_all_dies. */
8928 load_partial_comp_unit (struct dwarf2_per_cu_data
*this_cu
)
8930 init_cutu_and_read_dies (this_cu
, NULL
, 1, 1,
8931 load_partial_comp_unit_reader
, NULL
);
8935 read_comp_units_from_section (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
8936 struct dwarf2_section_info
*section
,
8937 struct dwarf2_section_info
*abbrev_section
,
8938 unsigned int is_dwz
,
8941 struct dwarf2_per_cu_data
***all_comp_units
)
8943 const gdb_byte
*info_ptr
;
8944 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8946 if (dwarf_read_debug
)
8947 fprintf_unfiltered (gdb_stdlog
, "Reading %s for %s\n",
8948 get_section_name (section
),
8949 get_section_file_name (section
));
8951 dwarf2_read_section (objfile
, section
);
8953 info_ptr
= section
->buffer
;
8955 while (info_ptr
< section
->buffer
+ section
->size
)
8957 struct dwarf2_per_cu_data
*this_cu
;
8959 sect_offset sect_off
= (sect_offset
) (info_ptr
- section
->buffer
);
8961 comp_unit_head cu_header
;
8962 read_and_check_comp_unit_head (dwarf2_per_objfile
, &cu_header
, section
,
8963 abbrev_section
, info_ptr
,
8964 rcuh_kind::COMPILE
);
8966 /* Save the compilation unit for later lookup. */
8967 if (cu_header
.unit_type
!= DW_UT_type
)
8969 this_cu
= XOBNEW (&objfile
->objfile_obstack
,
8970 struct dwarf2_per_cu_data
);
8971 memset (this_cu
, 0, sizeof (*this_cu
));
8975 auto sig_type
= XOBNEW (&objfile
->objfile_obstack
,
8976 struct signatured_type
);
8977 memset (sig_type
, 0, sizeof (*sig_type
));
8978 sig_type
->signature
= cu_header
.signature
;
8979 sig_type
->type_offset_in_tu
= cu_header
.type_cu_offset_in_tu
;
8980 this_cu
= &sig_type
->per_cu
;
8982 this_cu
->is_debug_types
= (cu_header
.unit_type
== DW_UT_type
);
8983 this_cu
->sect_off
= sect_off
;
8984 this_cu
->length
= cu_header
.length
+ cu_header
.initial_length_size
;
8985 this_cu
->is_dwz
= is_dwz
;
8986 this_cu
->dwarf2_per_objfile
= dwarf2_per_objfile
;
8987 this_cu
->section
= section
;
8989 if (*n_comp_units
== *n_allocated
)
8992 *all_comp_units
= XRESIZEVEC (struct dwarf2_per_cu_data
*,
8993 *all_comp_units
, *n_allocated
);
8995 (*all_comp_units
)[*n_comp_units
] = this_cu
;
8998 info_ptr
= info_ptr
+ this_cu
->length
;
9002 /* Create a list of all compilation units in OBJFILE.
9003 This is only done for -readnow and building partial symtabs. */
9006 create_all_comp_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
9010 struct dwarf2_per_cu_data
**all_comp_units
;
9011 struct dwz_file
*dwz
;
9012 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
9016 all_comp_units
= XNEWVEC (struct dwarf2_per_cu_data
*, n_allocated
);
9018 read_comp_units_from_section (dwarf2_per_objfile
, &dwarf2_per_objfile
->info
,
9019 &dwarf2_per_objfile
->abbrev
, 0,
9020 &n_allocated
, &n_comp_units
, &all_comp_units
);
9022 dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
9024 read_comp_units_from_section (dwarf2_per_objfile
, &dwz
->info
, &dwz
->abbrev
,
9025 1, &n_allocated
, &n_comp_units
,
9028 dwarf2_per_objfile
->all_comp_units
= XOBNEWVEC (&objfile
->objfile_obstack
,
9029 struct dwarf2_per_cu_data
*,
9031 memcpy (dwarf2_per_objfile
->all_comp_units
, all_comp_units
,
9032 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
9033 xfree (all_comp_units
);
9034 dwarf2_per_objfile
->n_comp_units
= n_comp_units
;
9037 /* Process all loaded DIEs for compilation unit CU, starting at
9038 FIRST_DIE. The caller should pass SET_ADDRMAP == 1 if the compilation
9039 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
9040 DW_AT_ranges). See the comments of add_partial_subprogram on how
9041 SET_ADDRMAP is used and how *LOWPC and *HIGHPC are updated. */
9044 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
9045 CORE_ADDR
*highpc
, int set_addrmap
,
9046 struct dwarf2_cu
*cu
)
9048 struct partial_die_info
*pdi
;
9050 /* Now, march along the PDI's, descending into ones which have
9051 interesting children but skipping the children of the other ones,
9052 until we reach the end of the compilation unit. */
9058 fixup_partial_die (pdi
, cu
);
9060 /* Anonymous namespaces or modules have no name but have interesting
9061 children, so we need to look at them. Ditto for anonymous
9064 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
9065 || pdi
->tag
== DW_TAG_module
|| pdi
->tag
== DW_TAG_enumeration_type
9066 || pdi
->tag
== DW_TAG_imported_unit
9067 || pdi
->tag
== DW_TAG_inlined_subroutine
)
9071 case DW_TAG_subprogram
:
9072 case DW_TAG_inlined_subroutine
:
9073 add_partial_subprogram (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
9075 case DW_TAG_constant
:
9076 case DW_TAG_variable
:
9077 case DW_TAG_typedef
:
9078 case DW_TAG_union_type
:
9079 if (!pdi
->is_declaration
)
9081 add_partial_symbol (pdi
, cu
);
9084 case DW_TAG_class_type
:
9085 case DW_TAG_interface_type
:
9086 case DW_TAG_structure_type
:
9087 if (!pdi
->is_declaration
)
9089 add_partial_symbol (pdi
, cu
);
9091 if (cu
->language
== language_rust
&& pdi
->has_children
)
9092 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
,
9095 case DW_TAG_enumeration_type
:
9096 if (!pdi
->is_declaration
)
9097 add_partial_enumeration (pdi
, cu
);
9099 case DW_TAG_base_type
:
9100 case DW_TAG_subrange_type
:
9101 /* File scope base type definitions are added to the partial
9103 add_partial_symbol (pdi
, cu
);
9105 case DW_TAG_namespace
:
9106 add_partial_namespace (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
9109 add_partial_module (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
9111 case DW_TAG_imported_unit
:
9113 struct dwarf2_per_cu_data
*per_cu
;
9115 /* For now we don't handle imported units in type units. */
9116 if (cu
->per_cu
->is_debug_types
)
9118 error (_("Dwarf Error: DW_TAG_imported_unit is not"
9119 " supported in type units [in module %s]"),
9120 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
9123 per_cu
= dwarf2_find_containing_comp_unit
9124 (pdi
->d
.sect_off
, pdi
->is_dwz
,
9125 cu
->per_cu
->dwarf2_per_objfile
);
9127 /* Go read the partial unit, if needed. */
9128 if (per_cu
->v
.psymtab
== NULL
)
9129 process_psymtab_comp_unit (per_cu
, 1, cu
->language
);
9131 VEC_safe_push (dwarf2_per_cu_ptr
,
9132 cu
->per_cu
->imported_symtabs
, per_cu
);
9135 case DW_TAG_imported_declaration
:
9136 add_partial_symbol (pdi
, cu
);
9143 /* If the die has a sibling, skip to the sibling. */
9145 pdi
= pdi
->die_sibling
;
9149 /* Functions used to compute the fully scoped name of a partial DIE.
9151 Normally, this is simple. For C++, the parent DIE's fully scoped
9152 name is concatenated with "::" and the partial DIE's name.
9153 Enumerators are an exception; they use the scope of their parent
9154 enumeration type, i.e. the name of the enumeration type is not
9155 prepended to the enumerator.
9157 There are two complexities. One is DW_AT_specification; in this
9158 case "parent" means the parent of the target of the specification,
9159 instead of the direct parent of the DIE. The other is compilers
9160 which do not emit DW_TAG_namespace; in this case we try to guess
9161 the fully qualified name of structure types from their members'
9162 linkage names. This must be done using the DIE's children rather
9163 than the children of any DW_AT_specification target. We only need
9164 to do this for structures at the top level, i.e. if the target of
9165 any DW_AT_specification (if any; otherwise the DIE itself) does not
9168 /* Compute the scope prefix associated with PDI's parent, in
9169 compilation unit CU. The result will be allocated on CU's
9170 comp_unit_obstack, or a copy of the already allocated PDI->NAME
9171 field. NULL is returned if no prefix is necessary. */
9173 partial_die_parent_scope (struct partial_die_info
*pdi
,
9174 struct dwarf2_cu
*cu
)
9176 const char *grandparent_scope
;
9177 struct partial_die_info
*parent
, *real_pdi
;
9179 /* We need to look at our parent DIE; if we have a DW_AT_specification,
9180 then this means the parent of the specification DIE. */
9183 while (real_pdi
->has_specification
)
9184 real_pdi
= find_partial_die (real_pdi
->spec_offset
,
9185 real_pdi
->spec_is_dwz
, cu
);
9187 parent
= real_pdi
->die_parent
;
9191 if (parent
->scope_set
)
9192 return parent
->scope
;
9194 fixup_partial_die (parent
, cu
);
9196 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
9198 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
9199 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
9200 Work around this problem here. */
9201 if (cu
->language
== language_cplus
9202 && parent
->tag
== DW_TAG_namespace
9203 && strcmp (parent
->name
, "::") == 0
9204 && grandparent_scope
== NULL
)
9206 parent
->scope
= NULL
;
9207 parent
->scope_set
= 1;
9211 if (pdi
->tag
== DW_TAG_enumerator
)
9212 /* Enumerators should not get the name of the enumeration as a prefix. */
9213 parent
->scope
= grandparent_scope
;
9214 else if (parent
->tag
== DW_TAG_namespace
9215 || parent
->tag
== DW_TAG_module
9216 || parent
->tag
== DW_TAG_structure_type
9217 || parent
->tag
== DW_TAG_class_type
9218 || parent
->tag
== DW_TAG_interface_type
9219 || parent
->tag
== DW_TAG_union_type
9220 || parent
->tag
== DW_TAG_enumeration_type
)
9222 if (grandparent_scope
== NULL
)
9223 parent
->scope
= parent
->name
;
9225 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
,
9227 parent
->name
, 0, cu
);
9231 /* FIXME drow/2004-04-01: What should we be doing with
9232 function-local names? For partial symbols, we should probably be
9234 complaint (&symfile_complaints
,
9235 _("unhandled containing DIE tag %d for DIE at %d"),
9236 parent
->tag
, to_underlying (pdi
->sect_off
));
9237 parent
->scope
= grandparent_scope
;
9240 parent
->scope_set
= 1;
9241 return parent
->scope
;
9244 /* Return the fully scoped name associated with PDI, from compilation unit
9245 CU. The result will be allocated with malloc. */
9248 partial_die_full_name (struct partial_die_info
*pdi
,
9249 struct dwarf2_cu
*cu
)
9251 const char *parent_scope
;
9253 /* If this is a template instantiation, we can not work out the
9254 template arguments from partial DIEs. So, unfortunately, we have
9255 to go through the full DIEs. At least any work we do building
9256 types here will be reused if full symbols are loaded later. */
9257 if (pdi
->has_template_arguments
)
9259 fixup_partial_die (pdi
, cu
);
9261 if (pdi
->name
!= NULL
&& strchr (pdi
->name
, '<') == NULL
)
9263 struct die_info
*die
;
9264 struct attribute attr
;
9265 struct dwarf2_cu
*ref_cu
= cu
;
9267 /* DW_FORM_ref_addr is using section offset. */
9268 attr
.name
= (enum dwarf_attribute
) 0;
9269 attr
.form
= DW_FORM_ref_addr
;
9270 attr
.u
.unsnd
= to_underlying (pdi
->sect_off
);
9271 die
= follow_die_ref (NULL
, &attr
, &ref_cu
);
9273 return xstrdup (dwarf2_full_name (NULL
, die
, ref_cu
));
9277 parent_scope
= partial_die_parent_scope (pdi
, cu
);
9278 if (parent_scope
== NULL
)
9281 return typename_concat (NULL
, parent_scope
, pdi
->name
, 0, cu
);
9285 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
9287 struct dwarf2_per_objfile
*dwarf2_per_objfile
9288 = cu
->per_cu
->dwarf2_per_objfile
;
9289 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
9290 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
9292 const char *actual_name
= NULL
;
9294 char *built_actual_name
;
9296 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
9298 built_actual_name
= partial_die_full_name (pdi
, cu
);
9299 if (built_actual_name
!= NULL
)
9300 actual_name
= built_actual_name
;
9302 if (actual_name
== NULL
)
9303 actual_name
= pdi
->name
;
9307 case DW_TAG_inlined_subroutine
:
9308 case DW_TAG_subprogram
:
9309 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, pdi
->lowpc
+ baseaddr
);
9310 if (pdi
->is_external
|| cu
->language
== language_ada
)
9312 /* brobecker/2007-12-26: Normally, only "external" DIEs are part
9313 of the global scope. But in Ada, we want to be able to access
9314 nested procedures globally. So all Ada subprograms are stored
9315 in the global scope. */
9316 add_psymbol_to_list (actual_name
, strlen (actual_name
),
9317 built_actual_name
!= NULL
,
9318 VAR_DOMAIN
, LOC_BLOCK
,
9319 &objfile
->global_psymbols
,
9320 addr
, cu
->language
, objfile
);
9324 add_psymbol_to_list (actual_name
, strlen (actual_name
),
9325 built_actual_name
!= NULL
,
9326 VAR_DOMAIN
, LOC_BLOCK
,
9327 &objfile
->static_psymbols
,
9328 addr
, cu
->language
, objfile
);
9331 if (pdi
->main_subprogram
&& actual_name
!= NULL
)
9332 set_objfile_main_name (objfile
, actual_name
, cu
->language
);
9334 case DW_TAG_constant
:
9336 std::vector
<partial_symbol
*> *list
;
9338 if (pdi
->is_external
)
9339 list
= &objfile
->global_psymbols
;
9341 list
= &objfile
->static_psymbols
;
9342 add_psymbol_to_list (actual_name
, strlen (actual_name
),
9343 built_actual_name
!= NULL
, VAR_DOMAIN
, LOC_STATIC
,
9344 list
, 0, cu
->language
, objfile
);
9347 case DW_TAG_variable
:
9349 addr
= decode_locdesc (pdi
->d
.locdesc
, cu
);
9353 && !dwarf2_per_objfile
->has_section_at_zero
)
9355 /* A global or static variable may also have been stripped
9356 out by the linker if unused, in which case its address
9357 will be nullified; do not add such variables into partial
9358 symbol table then. */
9360 else if (pdi
->is_external
)
9363 Don't enter into the minimal symbol tables as there is
9364 a minimal symbol table entry from the ELF symbols already.
9365 Enter into partial symbol table if it has a location
9366 descriptor or a type.
9367 If the location descriptor is missing, new_symbol will create
9368 a LOC_UNRESOLVED symbol, the address of the variable will then
9369 be determined from the minimal symbol table whenever the variable
9371 The address for the partial symbol table entry is not
9372 used by GDB, but it comes in handy for debugging partial symbol
9375 if (pdi
->d
.locdesc
|| pdi
->has_type
)
9376 add_psymbol_to_list (actual_name
, strlen (actual_name
),
9377 built_actual_name
!= NULL
,
9378 VAR_DOMAIN
, LOC_STATIC
,
9379 &objfile
->global_psymbols
,
9381 cu
->language
, objfile
);
9385 int has_loc
= pdi
->d
.locdesc
!= NULL
;
9387 /* Static Variable. Skip symbols whose value we cannot know (those
9388 without location descriptors or constant values). */
9389 if (!has_loc
&& !pdi
->has_const_value
)
9391 xfree (built_actual_name
);
9395 add_psymbol_to_list (actual_name
, strlen (actual_name
),
9396 built_actual_name
!= NULL
,
9397 VAR_DOMAIN
, LOC_STATIC
,
9398 &objfile
->static_psymbols
,
9399 has_loc
? addr
+ baseaddr
: (CORE_ADDR
) 0,
9400 cu
->language
, objfile
);
9403 case DW_TAG_typedef
:
9404 case DW_TAG_base_type
:
9405 case DW_TAG_subrange_type
:
9406 add_psymbol_to_list (actual_name
, strlen (actual_name
),
9407 built_actual_name
!= NULL
,
9408 VAR_DOMAIN
, LOC_TYPEDEF
,
9409 &objfile
->static_psymbols
,
9410 0, cu
->language
, objfile
);
9412 case DW_TAG_imported_declaration
:
9413 case DW_TAG_namespace
:
9414 add_psymbol_to_list (actual_name
, strlen (actual_name
),
9415 built_actual_name
!= NULL
,
9416 VAR_DOMAIN
, LOC_TYPEDEF
,
9417 &objfile
->global_psymbols
,
9418 0, cu
->language
, objfile
);
9421 add_psymbol_to_list (actual_name
, strlen (actual_name
),
9422 built_actual_name
!= NULL
,
9423 MODULE_DOMAIN
, LOC_TYPEDEF
,
9424 &objfile
->global_psymbols
,
9425 0, cu
->language
, objfile
);
9427 case DW_TAG_class_type
:
9428 case DW_TAG_interface_type
:
9429 case DW_TAG_structure_type
:
9430 case DW_TAG_union_type
:
9431 case DW_TAG_enumeration_type
:
9432 /* Skip external references. The DWARF standard says in the section
9433 about "Structure, Union, and Class Type Entries": "An incomplete
9434 structure, union or class type is represented by a structure,
9435 union or class entry that does not have a byte size attribute
9436 and that has a DW_AT_declaration attribute." */
9437 if (!pdi
->has_byte_size
&& pdi
->is_declaration
)
9439 xfree (built_actual_name
);
9443 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
9444 static vs. global. */
9445 add_psymbol_to_list (actual_name
, strlen (actual_name
),
9446 built_actual_name
!= NULL
,
9447 STRUCT_DOMAIN
, LOC_TYPEDEF
,
9448 cu
->language
== language_cplus
9449 ? &objfile
->global_psymbols
9450 : &objfile
->static_psymbols
,
9451 0, cu
->language
, objfile
);
9454 case DW_TAG_enumerator
:
9455 add_psymbol_to_list (actual_name
, strlen (actual_name
),
9456 built_actual_name
!= NULL
,
9457 VAR_DOMAIN
, LOC_CONST
,
9458 cu
->language
== language_cplus
9459 ? &objfile
->global_psymbols
9460 : &objfile
->static_psymbols
,
9461 0, cu
->language
, objfile
);
9467 xfree (built_actual_name
);
9470 /* Read a partial die corresponding to a namespace; also, add a symbol
9471 corresponding to that namespace to the symbol table. NAMESPACE is
9472 the name of the enclosing namespace. */
9475 add_partial_namespace (struct partial_die_info
*pdi
,
9476 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
9477 int set_addrmap
, struct dwarf2_cu
*cu
)
9479 /* Add a symbol for the namespace. */
9481 add_partial_symbol (pdi
, cu
);
9483 /* Now scan partial symbols in that namespace. */
9485 if (pdi
->has_children
)
9486 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, set_addrmap
, cu
);
9489 /* Read a partial die corresponding to a Fortran module. */
9492 add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
9493 CORE_ADDR
*highpc
, int set_addrmap
, struct dwarf2_cu
*cu
)
9495 /* Add a symbol for the namespace. */
9497 add_partial_symbol (pdi
, cu
);
9499 /* Now scan partial symbols in that module. */
9501 if (pdi
->has_children
)
9502 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, set_addrmap
, cu
);
9505 /* Read a partial die corresponding to a subprogram or an inlined
9506 subprogram and create a partial symbol for that subprogram.
9507 When the CU language allows it, this routine also defines a partial
9508 symbol for each nested subprogram that this subprogram contains.
9509 If SET_ADDRMAP is true, record the covered ranges in the addrmap.
9510 Set *LOWPC and *HIGHPC to the lowest and highest PC values found in PDI.
9512 PDI may also be a lexical block, in which case we simply search
9513 recursively for subprograms defined inside that lexical block.
9514 Again, this is only performed when the CU language allows this
9515 type of definitions. */
9518 add_partial_subprogram (struct partial_die_info
*pdi
,
9519 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
9520 int set_addrmap
, struct dwarf2_cu
*cu
)
9522 if (pdi
->tag
== DW_TAG_subprogram
|| pdi
->tag
== DW_TAG_inlined_subroutine
)
9524 if (pdi
->has_pc_info
)
9526 if (pdi
->lowpc
< *lowpc
)
9527 *lowpc
= pdi
->lowpc
;
9528 if (pdi
->highpc
> *highpc
)
9529 *highpc
= pdi
->highpc
;
9532 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
9533 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
9538 baseaddr
= ANOFFSET (objfile
->section_offsets
,
9539 SECT_OFF_TEXT (objfile
));
9540 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
,
9541 pdi
->lowpc
+ baseaddr
);
9542 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
,
9543 pdi
->highpc
+ baseaddr
);
9544 addrmap_set_empty (objfile
->psymtabs_addrmap
, lowpc
, highpc
- 1,
9545 cu
->per_cu
->v
.psymtab
);
9549 if (pdi
->has_pc_info
|| (!pdi
->is_external
&& pdi
->may_be_inlined
))
9551 if (!pdi
->is_declaration
)
9552 /* Ignore subprogram DIEs that do not have a name, they are
9553 illegal. Do not emit a complaint at this point, we will
9554 do so when we convert this psymtab into a symtab. */
9556 add_partial_symbol (pdi
, cu
);
9560 if (! pdi
->has_children
)
9563 if (cu
->language
== language_ada
)
9565 pdi
= pdi
->die_child
;
9568 fixup_partial_die (pdi
, cu
);
9569 if (pdi
->tag
== DW_TAG_subprogram
9570 || pdi
->tag
== DW_TAG_inlined_subroutine
9571 || pdi
->tag
== DW_TAG_lexical_block
)
9572 add_partial_subprogram (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
9573 pdi
= pdi
->die_sibling
;
9578 /* Read a partial die corresponding to an enumeration type. */
9581 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
9582 struct dwarf2_cu
*cu
)
9584 struct partial_die_info
*pdi
;
9586 if (enum_pdi
->name
!= NULL
)
9587 add_partial_symbol (enum_pdi
, cu
);
9589 pdi
= enum_pdi
->die_child
;
9592 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
9593 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
9595 add_partial_symbol (pdi
, cu
);
9596 pdi
= pdi
->die_sibling
;
9600 /* Return the initial uleb128 in the die at INFO_PTR. */
9603 peek_abbrev_code (bfd
*abfd
, const gdb_byte
*info_ptr
)
9605 unsigned int bytes_read
;
9607 return read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
9610 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
9611 Return the corresponding abbrev, or NULL if the number is zero (indicating
9612 an empty DIE). In either case *BYTES_READ will be set to the length of
9613 the initial number. */
9615 static struct abbrev_info
*
9616 peek_die_abbrev (const gdb_byte
*info_ptr
, unsigned int *bytes_read
,
9617 struct dwarf2_cu
*cu
)
9619 bfd
*abfd
= cu
->per_cu
->dwarf2_per_objfile
->objfile
->obfd
;
9620 unsigned int abbrev_number
;
9621 struct abbrev_info
*abbrev
;
9623 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
9625 if (abbrev_number
== 0)
9628 abbrev
= abbrev_table_lookup_abbrev (cu
->abbrev_table
, abbrev_number
);
9631 error (_("Dwarf Error: Could not find abbrev number %d in %s"
9632 " at offset 0x%x [in module %s]"),
9633 abbrev_number
, cu
->per_cu
->is_debug_types
? "TU" : "CU",
9634 to_underlying (cu
->header
.sect_off
), bfd_get_filename (abfd
));
9640 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
9641 Returns a pointer to the end of a series of DIEs, terminated by an empty
9642 DIE. Any children of the skipped DIEs will also be skipped. */
9644 static const gdb_byte
*
9645 skip_children (const struct die_reader_specs
*reader
, const gdb_byte
*info_ptr
)
9647 struct dwarf2_cu
*cu
= reader
->cu
;
9648 struct abbrev_info
*abbrev
;
9649 unsigned int bytes_read
;
9653 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
9655 return info_ptr
+ bytes_read
;
9657 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
9661 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
9662 INFO_PTR should point just after the initial uleb128 of a DIE, and the
9663 abbrev corresponding to that skipped uleb128 should be passed in
9664 ABBREV. Returns a pointer to this DIE's sibling, skipping any
9667 static const gdb_byte
*
9668 skip_one_die (const struct die_reader_specs
*reader
, const gdb_byte
*info_ptr
,
9669 struct abbrev_info
*abbrev
)
9671 unsigned int bytes_read
;
9672 struct attribute attr
;
9673 bfd
*abfd
= reader
->abfd
;
9674 struct dwarf2_cu
*cu
= reader
->cu
;
9675 const gdb_byte
*buffer
= reader
->buffer
;
9676 const gdb_byte
*buffer_end
= reader
->buffer_end
;
9677 unsigned int form
, i
;
9679 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
9681 /* The only abbrev we care about is DW_AT_sibling. */
9682 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
9684 read_attribute (reader
, &attr
, &abbrev
->attrs
[i
], info_ptr
);
9685 if (attr
.form
== DW_FORM_ref_addr
)
9686 complaint (&symfile_complaints
,
9687 _("ignoring absolute DW_AT_sibling"));
9690 sect_offset off
= dwarf2_get_ref_die_offset (&attr
);
9691 const gdb_byte
*sibling_ptr
= buffer
+ to_underlying (off
);
9693 if (sibling_ptr
< info_ptr
)
9694 complaint (&symfile_complaints
,
9695 _("DW_AT_sibling points backwards"));
9696 else if (sibling_ptr
> reader
->buffer_end
)
9697 dwarf2_section_buffer_overflow_complaint (reader
->die_section
);
9703 /* If it isn't DW_AT_sibling, skip this attribute. */
9704 form
= abbrev
->attrs
[i
].form
;
9708 case DW_FORM_ref_addr
:
9709 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
9710 and later it is offset sized. */
9711 if (cu
->header
.version
== 2)
9712 info_ptr
+= cu
->header
.addr_size
;
9714 info_ptr
+= cu
->header
.offset_size
;
9716 case DW_FORM_GNU_ref_alt
:
9717 info_ptr
+= cu
->header
.offset_size
;
9720 info_ptr
+= cu
->header
.addr_size
;
9727 case DW_FORM_flag_present
:
9728 case DW_FORM_implicit_const
:
9740 case DW_FORM_ref_sig8
:
9743 case DW_FORM_data16
:
9746 case DW_FORM_string
:
9747 read_direct_string (abfd
, info_ptr
, &bytes_read
);
9748 info_ptr
+= bytes_read
;
9750 case DW_FORM_sec_offset
:
9752 case DW_FORM_GNU_strp_alt
:
9753 info_ptr
+= cu
->header
.offset_size
;
9755 case DW_FORM_exprloc
:
9757 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
9758 info_ptr
+= bytes_read
;
9760 case DW_FORM_block1
:
9761 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
9763 case DW_FORM_block2
:
9764 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
9766 case DW_FORM_block4
:
9767 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
9771 case DW_FORM_ref_udata
:
9772 case DW_FORM_GNU_addr_index
:
9773 case DW_FORM_GNU_str_index
:
9774 info_ptr
= safe_skip_leb128 (info_ptr
, buffer_end
);
9776 case DW_FORM_indirect
:
9777 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
9778 info_ptr
+= bytes_read
;
9779 /* We need to continue parsing from here, so just go back to
9781 goto skip_attribute
;
9784 error (_("Dwarf Error: Cannot handle %s "
9785 "in DWARF reader [in module %s]"),
9786 dwarf_form_name (form
),
9787 bfd_get_filename (abfd
));
9791 if (abbrev
->has_children
)
9792 return skip_children (reader
, info_ptr
);
9797 /* Locate ORIG_PDI's sibling.
9798 INFO_PTR should point to the start of the next DIE after ORIG_PDI. */
9800 static const gdb_byte
*
9801 locate_pdi_sibling (const struct die_reader_specs
*reader
,
9802 struct partial_die_info
*orig_pdi
,
9803 const gdb_byte
*info_ptr
)
9805 /* Do we know the sibling already? */
9807 if (orig_pdi
->sibling
)
9808 return orig_pdi
->sibling
;
9810 /* Are there any children to deal with? */
9812 if (!orig_pdi
->has_children
)
9815 /* Skip the children the long way. */
9817 return skip_children (reader
, info_ptr
);
9820 /* Expand this partial symbol table into a full symbol table. SELF is
9824 dwarf2_read_symtab (struct partial_symtab
*self
,
9825 struct objfile
*objfile
)
9827 struct dwarf2_per_objfile
*dwarf2_per_objfile
9828 = get_dwarf2_per_objfile (objfile
);
9832 warning (_("bug: psymtab for %s is already read in."),
9839 printf_filtered (_("Reading in symbols for %s..."),
9841 gdb_flush (gdb_stdout
);
9844 /* If this psymtab is constructed from a debug-only objfile, the
9845 has_section_at_zero flag will not necessarily be correct. We
9846 can get the correct value for this flag by looking at the data
9847 associated with the (presumably stripped) associated objfile. */
9848 if (objfile
->separate_debug_objfile_backlink
)
9850 struct dwarf2_per_objfile
*dpo_backlink
9851 = get_dwarf2_per_objfile (objfile
->separate_debug_objfile_backlink
);
9853 dwarf2_per_objfile
->has_section_at_zero
9854 = dpo_backlink
->has_section_at_zero
;
9857 dwarf2_per_objfile
->reading_partial_symbols
= 0;
9859 psymtab_to_symtab_1 (self
);
9861 /* Finish up the debug error message. */
9863 printf_filtered (_("done.\n"));
9866 process_cu_includes (dwarf2_per_objfile
);
9869 /* Reading in full CUs. */
9871 /* Add PER_CU to the queue. */
9874 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
9875 enum language pretend_language
)
9877 struct dwarf2_queue_item
*item
;
9880 item
= XNEW (struct dwarf2_queue_item
);
9881 item
->per_cu
= per_cu
;
9882 item
->pretend_language
= pretend_language
;
9885 if (dwarf2_queue
== NULL
)
9886 dwarf2_queue
= item
;
9888 dwarf2_queue_tail
->next
= item
;
9890 dwarf2_queue_tail
= item
;
9893 /* If PER_CU is not yet queued, add it to the queue.
9894 If DEPENDENT_CU is non-NULL, it has a reference to PER_CU so add a
9896 The result is non-zero if PER_CU was queued, otherwise the result is zero
9897 meaning either PER_CU is already queued or it is already loaded.
9899 N.B. There is an invariant here that if a CU is queued then it is loaded.
9900 The caller is required to load PER_CU if we return non-zero. */
9903 maybe_queue_comp_unit (struct dwarf2_cu
*dependent_cu
,
9904 struct dwarf2_per_cu_data
*per_cu
,
9905 enum language pretend_language
)
9907 /* We may arrive here during partial symbol reading, if we need full
9908 DIEs to process an unusual case (e.g. template arguments). Do
9909 not queue PER_CU, just tell our caller to load its DIEs. */
9910 if (per_cu
->dwarf2_per_objfile
->reading_partial_symbols
)
9912 if (per_cu
->cu
== NULL
|| per_cu
->cu
->dies
== NULL
)
9917 /* Mark the dependence relation so that we don't flush PER_CU
9919 if (dependent_cu
!= NULL
)
9920 dwarf2_add_dependence (dependent_cu
, per_cu
);
9922 /* If it's already on the queue, we have nothing to do. */
9926 /* If the compilation unit is already loaded, just mark it as
9928 if (per_cu
->cu
!= NULL
)
9930 per_cu
->cu
->last_used
= 0;
9934 /* Add it to the queue. */
9935 queue_comp_unit (per_cu
, pretend_language
);
9940 /* Process the queue. */
9943 process_queue (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
9945 struct dwarf2_queue_item
*item
, *next_item
;
9947 if (dwarf_read_debug
)
9949 fprintf_unfiltered (gdb_stdlog
,
9950 "Expanding one or more symtabs of objfile %s ...\n",
9951 objfile_name (dwarf2_per_objfile
->objfile
));
9954 /* The queue starts out with one item, but following a DIE reference
9955 may load a new CU, adding it to the end of the queue. */
9956 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
9958 if ((dwarf2_per_objfile
->using_index
9959 ? !item
->per_cu
->v
.quick
->compunit_symtab
9960 : (item
->per_cu
->v
.psymtab
&& !item
->per_cu
->v
.psymtab
->readin
))
9961 /* Skip dummy CUs. */
9962 && item
->per_cu
->cu
!= NULL
)
9964 struct dwarf2_per_cu_data
*per_cu
= item
->per_cu
;
9965 unsigned int debug_print_threshold
;
9968 if (per_cu
->is_debug_types
)
9970 struct signatured_type
*sig_type
=
9971 (struct signatured_type
*) per_cu
;
9973 sprintf (buf
, "TU %s at offset 0x%x",
9974 hex_string (sig_type
->signature
),
9975 to_underlying (per_cu
->sect_off
));
9976 /* There can be 100s of TUs.
9977 Only print them in verbose mode. */
9978 debug_print_threshold
= 2;
9982 sprintf (buf
, "CU at offset 0x%x",
9983 to_underlying (per_cu
->sect_off
));
9984 debug_print_threshold
= 1;
9987 if (dwarf_read_debug
>= debug_print_threshold
)
9988 fprintf_unfiltered (gdb_stdlog
, "Expanding symtab of %s\n", buf
);
9990 if (per_cu
->is_debug_types
)
9991 process_full_type_unit (per_cu
, item
->pretend_language
);
9993 process_full_comp_unit (per_cu
, item
->pretend_language
);
9995 if (dwarf_read_debug
>= debug_print_threshold
)
9996 fprintf_unfiltered (gdb_stdlog
, "Done expanding %s\n", buf
);
9999 item
->per_cu
->queued
= 0;
10000 next_item
= item
->next
;
10004 dwarf2_queue_tail
= NULL
;
10006 if (dwarf_read_debug
)
10008 fprintf_unfiltered (gdb_stdlog
, "Done expanding symtabs of %s.\n",
10009 objfile_name (dwarf2_per_objfile
->objfile
));
10013 /* Free all allocated queue entries. This function only releases anything if
10014 an error was thrown; if the queue was processed then it would have been
10015 freed as we went along. */
10018 dwarf2_release_queue (void *dummy
)
10020 struct dwarf2_queue_item
*item
, *last
;
10022 item
= dwarf2_queue
;
10025 /* Anything still marked queued is likely to be in an
10026 inconsistent state, so discard it. */
10027 if (item
->per_cu
->queued
)
10029 if (item
->per_cu
->cu
!= NULL
)
10030 free_one_cached_comp_unit (item
->per_cu
);
10031 item
->per_cu
->queued
= 0;
10039 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
10042 /* Read in full symbols for PST, and anything it depends on. */
10045 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
10047 struct dwarf2_per_cu_data
*per_cu
;
10053 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
10054 if (!pst
->dependencies
[i
]->readin
10055 && pst
->dependencies
[i
]->user
== NULL
)
10057 /* Inform about additional files that need to be read in. */
10060 /* FIXME: i18n: Need to make this a single string. */
10061 fputs_filtered (" ", gdb_stdout
);
10063 fputs_filtered ("and ", gdb_stdout
);
10065 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
10066 wrap_here (""); /* Flush output. */
10067 gdb_flush (gdb_stdout
);
10069 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
10072 per_cu
= (struct dwarf2_per_cu_data
*) pst
->read_symtab_private
;
10074 if (per_cu
== NULL
)
10076 /* It's an include file, no symbols to read for it.
10077 Everything is in the parent symtab. */
10082 dw2_do_instantiate_symtab (per_cu
);
10085 /* Trivial hash function for die_info: the hash value of a DIE
10086 is its offset in .debug_info for this objfile. */
10089 die_hash (const void *item
)
10091 const struct die_info
*die
= (const struct die_info
*) item
;
10093 return to_underlying (die
->sect_off
);
10096 /* Trivial comparison function for die_info structures: two DIEs
10097 are equal if they have the same offset. */
10100 die_eq (const void *item_lhs
, const void *item_rhs
)
10102 const struct die_info
*die_lhs
= (const struct die_info
*) item_lhs
;
10103 const struct die_info
*die_rhs
= (const struct die_info
*) item_rhs
;
10105 return die_lhs
->sect_off
== die_rhs
->sect_off
;
10108 /* die_reader_func for load_full_comp_unit.
10109 This is identical to read_signatured_type_reader,
10110 but is kept separate for now. */
10113 load_full_comp_unit_reader (const struct die_reader_specs
*reader
,
10114 const gdb_byte
*info_ptr
,
10115 struct die_info
*comp_unit_die
,
10119 struct dwarf2_cu
*cu
= reader
->cu
;
10120 enum language
*language_ptr
= (enum language
*) data
;
10122 gdb_assert (cu
->die_hash
== NULL
);
10124 htab_create_alloc_ex (cu
->header
.length
/ 12,
10128 &cu
->comp_unit_obstack
,
10129 hashtab_obstack_allocate
,
10130 dummy_obstack_deallocate
);
10133 comp_unit_die
->child
= read_die_and_siblings (reader
, info_ptr
,
10134 &info_ptr
, comp_unit_die
);
10135 cu
->dies
= comp_unit_die
;
10136 /* comp_unit_die is not stored in die_hash, no need. */
10138 /* We try not to read any attributes in this function, because not
10139 all CUs needed for references have been loaded yet, and symbol
10140 table processing isn't initialized. But we have to set the CU language,
10141 or we won't be able to build types correctly.
10142 Similarly, if we do not read the producer, we can not apply
10143 producer-specific interpretation. */
10144 prepare_one_comp_unit (cu
, cu
->dies
, *language_ptr
);
10147 /* Load the DIEs associated with PER_CU into memory. */
10150 load_full_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
10151 enum language pretend_language
)
10153 gdb_assert (! this_cu
->is_debug_types
);
10155 init_cutu_and_read_dies (this_cu
, NULL
, 1, 1,
10156 load_full_comp_unit_reader
, &pretend_language
);
10159 /* Add a DIE to the delayed physname list. */
10162 add_to_method_list (struct type
*type
, int fnfield_index
, int index
,
10163 const char *name
, struct die_info
*die
,
10164 struct dwarf2_cu
*cu
)
10166 struct delayed_method_info mi
;
10168 mi
.fnfield_index
= fnfield_index
;
10172 VEC_safe_push (delayed_method_info
, cu
->method_list
, &mi
);
10175 /* A cleanup for freeing the delayed method list. */
10178 free_delayed_list (void *ptr
)
10180 struct dwarf2_cu
*cu
= (struct dwarf2_cu
*) ptr
;
10181 if (cu
->method_list
!= NULL
)
10183 VEC_free (delayed_method_info
, cu
->method_list
);
10184 cu
->method_list
= NULL
;
10188 /* Check whether [PHYSNAME, PHYSNAME+LEN) ends with a modifier like
10189 "const" / "volatile". If so, decrements LEN by the length of the
10190 modifier and return true. Otherwise return false. */
10194 check_modifier (const char *physname
, size_t &len
, const char (&mod
)[N
])
10196 size_t mod_len
= sizeof (mod
) - 1;
10197 if (len
> mod_len
&& startswith (physname
+ (len
- mod_len
), mod
))
10205 /* Compute the physnames of any methods on the CU's method list.
10207 The computation of method physnames is delayed in order to avoid the
10208 (bad) condition that one of the method's formal parameters is of an as yet
10209 incomplete type. */
10212 compute_delayed_physnames (struct dwarf2_cu
*cu
)
10215 struct delayed_method_info
*mi
;
10217 /* Only C++ delays computing physnames. */
10218 if (VEC_empty (delayed_method_info
, cu
->method_list
))
10220 gdb_assert (cu
->language
== language_cplus
);
10222 for (i
= 0; VEC_iterate (delayed_method_info
, cu
->method_list
, i
, mi
) ; ++i
)
10224 const char *physname
;
10225 struct fn_fieldlist
*fn_flp
10226 = &TYPE_FN_FIELDLIST (mi
->type
, mi
->fnfield_index
);
10227 physname
= dwarf2_physname (mi
->name
, mi
->die
, cu
);
10228 TYPE_FN_FIELD_PHYSNAME (fn_flp
->fn_fields
, mi
->index
)
10229 = physname
? physname
: "";
10231 /* Since there's no tag to indicate whether a method is a
10232 const/volatile overload, extract that information out of the
10234 if (physname
!= NULL
)
10236 size_t len
= strlen (physname
);
10240 if (physname
[len
] == ')') /* shortcut */
10242 else if (check_modifier (physname
, len
, " const"))
10243 TYPE_FN_FIELD_CONST (fn_flp
->fn_fields
, mi
->index
) = 1;
10244 else if (check_modifier (physname
, len
, " volatile"))
10245 TYPE_FN_FIELD_VOLATILE (fn_flp
->fn_fields
, mi
->index
) = 1;
10253 /* Go objects should be embedded in a DW_TAG_module DIE,
10254 and it's not clear if/how imported objects will appear.
10255 To keep Go support simple until that's worked out,
10256 go back through what we've read and create something usable.
10257 We could do this while processing each DIE, and feels kinda cleaner,
10258 but that way is more invasive.
10259 This is to, for example, allow the user to type "p var" or "b main"
10260 without having to specify the package name, and allow lookups
10261 of module.object to work in contexts that use the expression
10265 fixup_go_packaging (struct dwarf2_cu
*cu
)
10267 char *package_name
= NULL
;
10268 struct pending
*list
;
10271 for (list
= global_symbols
; list
!= NULL
; list
= list
->next
)
10273 for (i
= 0; i
< list
->nsyms
; ++i
)
10275 struct symbol
*sym
= list
->symbol
[i
];
10277 if (SYMBOL_LANGUAGE (sym
) == language_go
10278 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
10280 char *this_package_name
= go_symbol_package_name (sym
);
10282 if (this_package_name
== NULL
)
10284 if (package_name
== NULL
)
10285 package_name
= this_package_name
;
10288 struct objfile
*objfile
10289 = cu
->per_cu
->dwarf2_per_objfile
->objfile
;
10290 if (strcmp (package_name
, this_package_name
) != 0)
10291 complaint (&symfile_complaints
,
10292 _("Symtab %s has objects from two different Go packages: %s and %s"),
10293 (symbol_symtab (sym
) != NULL
10294 ? symtab_to_filename_for_display
10295 (symbol_symtab (sym
))
10296 : objfile_name (objfile
)),
10297 this_package_name
, package_name
);
10298 xfree (this_package_name
);
10304 if (package_name
!= NULL
)
10306 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
10307 const char *saved_package_name
10308 = (const char *) obstack_copy0 (&objfile
->per_bfd
->storage_obstack
,
10310 strlen (package_name
));
10311 struct type
*type
= init_type (objfile
, TYPE_CODE_MODULE
, 0,
10312 saved_package_name
);
10313 struct symbol
*sym
;
10315 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
10317 sym
= allocate_symbol (objfile
);
10318 SYMBOL_SET_LANGUAGE (sym
, language_go
, &objfile
->objfile_obstack
);
10319 SYMBOL_SET_NAMES (sym
, saved_package_name
,
10320 strlen (saved_package_name
), 0, objfile
);
10321 /* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
10322 e.g., "main" finds the "main" module and not C's main(). */
10323 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
10324 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
10325 SYMBOL_TYPE (sym
) = type
;
10327 add_symbol_to_list (sym
, &global_symbols
);
10329 xfree (package_name
);
10333 /* Return the symtab for PER_CU. This works properly regardless of
10334 whether we're using the index or psymtabs. */
10336 static struct compunit_symtab
*
10337 get_compunit_symtab (struct dwarf2_per_cu_data
*per_cu
)
10339 return (per_cu
->dwarf2_per_objfile
->using_index
10340 ? per_cu
->v
.quick
->compunit_symtab
10341 : per_cu
->v
.psymtab
->compunit_symtab
);
10344 /* A helper function for computing the list of all symbol tables
10345 included by PER_CU. */
10348 recursively_compute_inclusions (VEC (compunit_symtab_ptr
) **result
,
10349 htab_t all_children
, htab_t all_type_symtabs
,
10350 struct dwarf2_per_cu_data
*per_cu
,
10351 struct compunit_symtab
*immediate_parent
)
10355 struct compunit_symtab
*cust
;
10356 struct dwarf2_per_cu_data
*iter
;
10358 slot
= htab_find_slot (all_children
, per_cu
, INSERT
);
10361 /* This inclusion and its children have been processed. */
10366 /* Only add a CU if it has a symbol table. */
10367 cust
= get_compunit_symtab (per_cu
);
10370 /* If this is a type unit only add its symbol table if we haven't
10371 seen it yet (type unit per_cu's can share symtabs). */
10372 if (per_cu
->is_debug_types
)
10374 slot
= htab_find_slot (all_type_symtabs
, cust
, INSERT
);
10378 VEC_safe_push (compunit_symtab_ptr
, *result
, cust
);
10379 if (cust
->user
== NULL
)
10380 cust
->user
= immediate_parent
;
10385 VEC_safe_push (compunit_symtab_ptr
, *result
, cust
);
10386 if (cust
->user
== NULL
)
10387 cust
->user
= immediate_parent
;
10392 VEC_iterate (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
, ix
, iter
);
10395 recursively_compute_inclusions (result
, all_children
,
10396 all_type_symtabs
, iter
, cust
);
10400 /* Compute the compunit_symtab 'includes' fields for the compunit_symtab of
10404 compute_compunit_symtab_includes (struct dwarf2_per_cu_data
*per_cu
)
10406 gdb_assert (! per_cu
->is_debug_types
);
10408 if (!VEC_empty (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
))
10411 struct dwarf2_per_cu_data
*per_cu_iter
;
10412 struct compunit_symtab
*compunit_symtab_iter
;
10413 VEC (compunit_symtab_ptr
) *result_symtabs
= NULL
;
10414 htab_t all_children
, all_type_symtabs
;
10415 struct compunit_symtab
*cust
= get_compunit_symtab (per_cu
);
10417 /* If we don't have a symtab, we can just skip this case. */
10421 all_children
= htab_create_alloc (1, htab_hash_pointer
, htab_eq_pointer
,
10422 NULL
, xcalloc
, xfree
);
10423 all_type_symtabs
= htab_create_alloc (1, htab_hash_pointer
, htab_eq_pointer
,
10424 NULL
, xcalloc
, xfree
);
10427 VEC_iterate (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
,
10431 recursively_compute_inclusions (&result_symtabs
, all_children
,
10432 all_type_symtabs
, per_cu_iter
,
10436 /* Now we have a transitive closure of all the included symtabs. */
10437 len
= VEC_length (compunit_symtab_ptr
, result_symtabs
);
10439 = XOBNEWVEC (&per_cu
->dwarf2_per_objfile
->objfile
->objfile_obstack
,
10440 struct compunit_symtab
*, len
+ 1);
10442 VEC_iterate (compunit_symtab_ptr
, result_symtabs
, ix
,
10443 compunit_symtab_iter
);
10445 cust
->includes
[ix
] = compunit_symtab_iter
;
10446 cust
->includes
[len
] = NULL
;
10448 VEC_free (compunit_symtab_ptr
, result_symtabs
);
10449 htab_delete (all_children
);
10450 htab_delete (all_type_symtabs
);
10454 /* Compute the 'includes' field for the symtabs of all the CUs we just
10458 process_cu_includes (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
10461 struct dwarf2_per_cu_data
*iter
;
10464 VEC_iterate (dwarf2_per_cu_ptr
, dwarf2_per_objfile
->just_read_cus
,
10468 if (! iter
->is_debug_types
)
10469 compute_compunit_symtab_includes (iter
);
10472 VEC_free (dwarf2_per_cu_ptr
, dwarf2_per_objfile
->just_read_cus
);
10475 /* Generate full symbol information for PER_CU, whose DIEs have
10476 already been loaded into memory. */
10479 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
10480 enum language pretend_language
)
10482 struct dwarf2_cu
*cu
= per_cu
->cu
;
10483 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
10484 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
10485 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
10486 CORE_ADDR lowpc
, highpc
;
10487 struct compunit_symtab
*cust
;
10488 struct cleanup
*delayed_list_cleanup
;
10489 CORE_ADDR baseaddr
;
10490 struct block
*static_block
;
10493 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
10496 scoped_free_pendings free_pending
;
10497 delayed_list_cleanup
= make_cleanup (free_delayed_list
, cu
);
10499 cu
->list_in_scope
= &file_symbols
;
10501 cu
->language
= pretend_language
;
10502 cu
->language_defn
= language_def (cu
->language
);
10504 /* Do line number decoding in read_file_scope () */
10505 process_die (cu
->dies
, cu
);
10507 /* For now fudge the Go package. */
10508 if (cu
->language
== language_go
)
10509 fixup_go_packaging (cu
);
10511 /* Now that we have processed all the DIEs in the CU, all the types
10512 should be complete, and it should now be safe to compute all of the
10514 compute_delayed_physnames (cu
);
10515 do_cleanups (delayed_list_cleanup
);
10517 /* Some compilers don't define a DW_AT_high_pc attribute for the
10518 compilation unit. If the DW_AT_high_pc is missing, synthesize
10519 it, by scanning the DIE's below the compilation unit. */
10520 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
10522 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
10523 static_block
= end_symtab_get_static_block (addr
, 0, 1);
10525 /* If the comp unit has DW_AT_ranges, it may have discontiguous ranges.
10526 Also, DW_AT_ranges may record ranges not belonging to any child DIEs
10527 (such as virtual method tables). Record the ranges in STATIC_BLOCK's
10528 addrmap to help ensure it has an accurate map of pc values belonging to
10530 dwarf2_record_block_ranges (cu
->dies
, static_block
, baseaddr
, cu
);
10532 cust
= end_symtab_from_static_block (static_block
,
10533 SECT_OFF_TEXT (objfile
), 0);
10537 int gcc_4_minor
= producer_is_gcc_ge_4 (cu
->producer
);
10539 /* Set symtab language to language from DW_AT_language. If the
10540 compilation is from a C file generated by language preprocessors, do
10541 not set the language if it was already deduced by start_subfile. */
10542 if (!(cu
->language
== language_c
10543 && COMPUNIT_FILETABS (cust
)->language
!= language_unknown
))
10544 COMPUNIT_FILETABS (cust
)->language
= cu
->language
;
10546 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
10547 produce DW_AT_location with location lists but it can be possibly
10548 invalid without -fvar-tracking. Still up to GCC-4.4.x incl. 4.4.0
10549 there were bugs in prologue debug info, fixed later in GCC-4.5
10550 by "unwind info for epilogues" patch (which is not directly related).
10552 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
10553 needed, it would be wrong due to missing DW_AT_producer there.
10555 Still one can confuse GDB by using non-standard GCC compilation
10556 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
10558 if (cu
->has_loclist
&& gcc_4_minor
>= 5)
10559 cust
->locations_valid
= 1;
10561 if (gcc_4_minor
>= 5)
10562 cust
->epilogue_unwind_valid
= 1;
10564 cust
->call_site_htab
= cu
->call_site_htab
;
10567 if (dwarf2_per_objfile
->using_index
)
10568 per_cu
->v
.quick
->compunit_symtab
= cust
;
10571 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
10572 pst
->compunit_symtab
= cust
;
10576 /* Push it for inclusion processing later. */
10577 VEC_safe_push (dwarf2_per_cu_ptr
, dwarf2_per_objfile
->just_read_cus
, per_cu
);
10580 /* Generate full symbol information for type unit PER_CU, whose DIEs have
10581 already been loaded into memory. */
10584 process_full_type_unit (struct dwarf2_per_cu_data
*per_cu
,
10585 enum language pretend_language
)
10587 struct dwarf2_cu
*cu
= per_cu
->cu
;
10588 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
10589 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
10590 struct compunit_symtab
*cust
;
10591 struct cleanup
*delayed_list_cleanup
;
10592 struct signatured_type
*sig_type
;
10594 gdb_assert (per_cu
->is_debug_types
);
10595 sig_type
= (struct signatured_type
*) per_cu
;
10598 scoped_free_pendings free_pending
;
10599 delayed_list_cleanup
= make_cleanup (free_delayed_list
, cu
);
10601 cu
->list_in_scope
= &file_symbols
;
10603 cu
->language
= pretend_language
;
10604 cu
->language_defn
= language_def (cu
->language
);
10606 /* The symbol tables are set up in read_type_unit_scope. */
10607 process_die (cu
->dies
, cu
);
10609 /* For now fudge the Go package. */
10610 if (cu
->language
== language_go
)
10611 fixup_go_packaging (cu
);
10613 /* Now that we have processed all the DIEs in the CU, all the types
10614 should be complete, and it should now be safe to compute all of the
10616 compute_delayed_physnames (cu
);
10617 do_cleanups (delayed_list_cleanup
);
10619 /* TUs share symbol tables.
10620 If this is the first TU to use this symtab, complete the construction
10621 of it with end_expandable_symtab. Otherwise, complete the addition of
10622 this TU's symbols to the existing symtab. */
10623 if (sig_type
->type_unit_group
->compunit_symtab
== NULL
)
10625 cust
= end_expandable_symtab (0, SECT_OFF_TEXT (objfile
));
10626 sig_type
->type_unit_group
->compunit_symtab
= cust
;
10630 /* Set symtab language to language from DW_AT_language. If the
10631 compilation is from a C file generated by language preprocessors,
10632 do not set the language if it was already deduced by
10634 if (!(cu
->language
== language_c
10635 && COMPUNIT_FILETABS (cust
)->language
!= language_c
))
10636 COMPUNIT_FILETABS (cust
)->language
= cu
->language
;
10641 augment_type_symtab ();
10642 cust
= sig_type
->type_unit_group
->compunit_symtab
;
10645 if (dwarf2_per_objfile
->using_index
)
10646 per_cu
->v
.quick
->compunit_symtab
= cust
;
10649 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
10650 pst
->compunit_symtab
= cust
;
10655 /* Process an imported unit DIE. */
10658 process_imported_unit_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
10660 struct attribute
*attr
;
10662 /* For now we don't handle imported units in type units. */
10663 if (cu
->per_cu
->is_debug_types
)
10665 error (_("Dwarf Error: DW_TAG_imported_unit is not"
10666 " supported in type units [in module %s]"),
10667 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
10670 attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
10673 sect_offset sect_off
= dwarf2_get_ref_die_offset (attr
);
10674 bool is_dwz
= (attr
->form
== DW_FORM_GNU_ref_alt
|| cu
->per_cu
->is_dwz
);
10675 dwarf2_per_cu_data
*per_cu
10676 = dwarf2_find_containing_comp_unit (sect_off
, is_dwz
,
10677 cu
->per_cu
->dwarf2_per_objfile
);
10679 /* If necessary, add it to the queue and load its DIEs. */
10680 if (maybe_queue_comp_unit (cu
, per_cu
, cu
->language
))
10681 load_full_comp_unit (per_cu
, cu
->language
);
10683 VEC_safe_push (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
,
10688 /* RAII object that represents a process_die scope: i.e.,
10689 starts/finishes processing a DIE. */
10690 class process_die_scope
10693 process_die_scope (die_info
*die
, dwarf2_cu
*cu
)
10694 : m_die (die
), m_cu (cu
)
10696 /* We should only be processing DIEs not already in process. */
10697 gdb_assert (!m_die
->in_process
);
10698 m_die
->in_process
= true;
10701 ~process_die_scope ()
10703 m_die
->in_process
= false;
10705 /* If we're done processing the DIE for the CU that owns the line
10706 header, we don't need the line header anymore. */
10707 if (m_cu
->line_header_die_owner
== m_die
)
10709 delete m_cu
->line_header
;
10710 m_cu
->line_header
= NULL
;
10711 m_cu
->line_header_die_owner
= NULL
;
10720 /* Process a die and its children. */
10723 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
10725 process_die_scope
scope (die
, cu
);
10729 case DW_TAG_padding
:
10731 case DW_TAG_compile_unit
:
10732 case DW_TAG_partial_unit
:
10733 read_file_scope (die
, cu
);
10735 case DW_TAG_type_unit
:
10736 read_type_unit_scope (die
, cu
);
10738 case DW_TAG_subprogram
:
10739 case DW_TAG_inlined_subroutine
:
10740 read_func_scope (die
, cu
);
10742 case DW_TAG_lexical_block
:
10743 case DW_TAG_try_block
:
10744 case DW_TAG_catch_block
:
10745 read_lexical_block_scope (die
, cu
);
10747 case DW_TAG_call_site
:
10748 case DW_TAG_GNU_call_site
:
10749 read_call_site_scope (die
, cu
);
10751 case DW_TAG_class_type
:
10752 case DW_TAG_interface_type
:
10753 case DW_TAG_structure_type
:
10754 case DW_TAG_union_type
:
10755 process_structure_scope (die
, cu
);
10757 case DW_TAG_enumeration_type
:
10758 process_enumeration_scope (die
, cu
);
10761 /* These dies have a type, but processing them does not create
10762 a symbol or recurse to process the children. Therefore we can
10763 read them on-demand through read_type_die. */
10764 case DW_TAG_subroutine_type
:
10765 case DW_TAG_set_type
:
10766 case DW_TAG_array_type
:
10767 case DW_TAG_pointer_type
:
10768 case DW_TAG_ptr_to_member_type
:
10769 case DW_TAG_reference_type
:
10770 case DW_TAG_rvalue_reference_type
:
10771 case DW_TAG_string_type
:
10774 case DW_TAG_base_type
:
10775 case DW_TAG_subrange_type
:
10776 case DW_TAG_typedef
:
10777 /* Add a typedef symbol for the type definition, if it has a
10779 new_symbol (die
, read_type_die (die
, cu
), cu
);
10781 case DW_TAG_common_block
:
10782 read_common_block (die
, cu
);
10784 case DW_TAG_common_inclusion
:
10786 case DW_TAG_namespace
:
10787 cu
->processing_has_namespace_info
= 1;
10788 read_namespace (die
, cu
);
10790 case DW_TAG_module
:
10791 cu
->processing_has_namespace_info
= 1;
10792 read_module (die
, cu
);
10794 case DW_TAG_imported_declaration
:
10795 cu
->processing_has_namespace_info
= 1;
10796 if (read_namespace_alias (die
, cu
))
10798 /* The declaration is not a global namespace alias: fall through. */
10799 case DW_TAG_imported_module
:
10800 cu
->processing_has_namespace_info
= 1;
10801 if (die
->child
!= NULL
&& (die
->tag
== DW_TAG_imported_declaration
10802 || cu
->language
!= language_fortran
))
10803 complaint (&symfile_complaints
, _("Tag '%s' has unexpected children"),
10804 dwarf_tag_name (die
->tag
));
10805 read_import_statement (die
, cu
);
10808 case DW_TAG_imported_unit
:
10809 process_imported_unit_die (die
, cu
);
10812 case DW_TAG_variable
:
10813 read_variable (die
, cu
);
10817 new_symbol (die
, NULL
, cu
);
10822 /* DWARF name computation. */
10824 /* A helper function for dwarf2_compute_name which determines whether DIE
10825 needs to have the name of the scope prepended to the name listed in the
10829 die_needs_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
10831 struct attribute
*attr
;
10835 case DW_TAG_namespace
:
10836 case DW_TAG_typedef
:
10837 case DW_TAG_class_type
:
10838 case DW_TAG_interface_type
:
10839 case DW_TAG_structure_type
:
10840 case DW_TAG_union_type
:
10841 case DW_TAG_enumeration_type
:
10842 case DW_TAG_enumerator
:
10843 case DW_TAG_subprogram
:
10844 case DW_TAG_inlined_subroutine
:
10845 case DW_TAG_member
:
10846 case DW_TAG_imported_declaration
:
10849 case DW_TAG_variable
:
10850 case DW_TAG_constant
:
10851 /* We only need to prefix "globally" visible variables. These include
10852 any variable marked with DW_AT_external or any variable that
10853 lives in a namespace. [Variables in anonymous namespaces
10854 require prefixing, but they are not DW_AT_external.] */
10856 if (dwarf2_attr (die
, DW_AT_specification
, cu
))
10858 struct dwarf2_cu
*spec_cu
= cu
;
10860 return die_needs_namespace (die_specification (die
, &spec_cu
),
10864 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
10865 if (attr
== NULL
&& die
->parent
->tag
!= DW_TAG_namespace
10866 && die
->parent
->tag
!= DW_TAG_module
)
10868 /* A variable in a lexical block of some kind does not need a
10869 namespace, even though in C++ such variables may be external
10870 and have a mangled name. */
10871 if (die
->parent
->tag
== DW_TAG_lexical_block
10872 || die
->parent
->tag
== DW_TAG_try_block
10873 || die
->parent
->tag
== DW_TAG_catch_block
10874 || die
->parent
->tag
== DW_TAG_subprogram
)
10883 /* Return the DIE's linkage name attribute, either DW_AT_linkage_name
10884 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
10885 defined for the given DIE. */
10887 static struct attribute
*
10888 dw2_linkage_name_attr (struct die_info
*die
, struct dwarf2_cu
*cu
)
10890 struct attribute
*attr
;
10892 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
10894 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
10899 /* Return the DIE's linkage name as a string, either DW_AT_linkage_name
10900 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
10901 defined for the given DIE. */
10903 static const char *
10904 dw2_linkage_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
10906 const char *linkage_name
;
10908 linkage_name
= dwarf2_string_attr (die
, DW_AT_linkage_name
, cu
);
10909 if (linkage_name
== NULL
)
10910 linkage_name
= dwarf2_string_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
10912 return linkage_name
;
10915 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
10916 compute the physname for the object, which include a method's:
10917 - formal parameters (C++),
10918 - receiver type (Go),
10920 The term "physname" is a bit confusing.
10921 For C++, for example, it is the demangled name.
10922 For Go, for example, it's the mangled name.
10924 For Ada, return the DIE's linkage name rather than the fully qualified
10925 name. PHYSNAME is ignored..
10927 The result is allocated on the objfile_obstack and canonicalized. */
10929 static const char *
10930 dwarf2_compute_name (const char *name
,
10931 struct die_info
*die
, struct dwarf2_cu
*cu
,
10934 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
10937 name
= dwarf2_name (die
, cu
);
10939 /* For Fortran GDB prefers DW_AT_*linkage_name for the physname if present
10940 but otherwise compute it by typename_concat inside GDB.
10941 FIXME: Actually this is not really true, or at least not always true.
10942 It's all very confusing. SYMBOL_SET_NAMES doesn't try to demangle
10943 Fortran names because there is no mangling standard. So new_symbol_full
10944 will set the demangled name to the result of dwarf2_full_name, and it is
10945 the demangled name that GDB uses if it exists. */
10946 if (cu
->language
== language_ada
10947 || (cu
->language
== language_fortran
&& physname
))
10949 /* For Ada unit, we prefer the linkage name over the name, as
10950 the former contains the exported name, which the user expects
10951 to be able to reference. Ideally, we want the user to be able
10952 to reference this entity using either natural or linkage name,
10953 but we haven't started looking at this enhancement yet. */
10954 const char *linkage_name
= dw2_linkage_name (die
, cu
);
10956 if (linkage_name
!= NULL
)
10957 return linkage_name
;
10960 /* These are the only languages we know how to qualify names in. */
10962 && (cu
->language
== language_cplus
10963 || cu
->language
== language_fortran
|| cu
->language
== language_d
10964 || cu
->language
== language_rust
))
10966 if (die_needs_namespace (die
, cu
))
10968 const char *prefix
;
10969 const char *canonical_name
= NULL
;
10973 prefix
= determine_prefix (die
, cu
);
10974 if (*prefix
!= '\0')
10976 char *prefixed_name
= typename_concat (NULL
, prefix
, name
,
10979 buf
.puts (prefixed_name
);
10980 xfree (prefixed_name
);
10985 /* Template parameters may be specified in the DIE's DW_AT_name, or
10986 as children with DW_TAG_template_type_param or
10987 DW_TAG_value_type_param. If the latter, add them to the name
10988 here. If the name already has template parameters, then
10989 skip this step; some versions of GCC emit both, and
10990 it is more efficient to use the pre-computed name.
10992 Something to keep in mind about this process: it is very
10993 unlikely, or in some cases downright impossible, to produce
10994 something that will match the mangled name of a function.
10995 If the definition of the function has the same debug info,
10996 we should be able to match up with it anyway. But fallbacks
10997 using the minimal symbol, for instance to find a method
10998 implemented in a stripped copy of libstdc++, will not work.
10999 If we do not have debug info for the definition, we will have to
11000 match them up some other way.
11002 When we do name matching there is a related problem with function
11003 templates; two instantiated function templates are allowed to
11004 differ only by their return types, which we do not add here. */
11006 if (cu
->language
== language_cplus
&& strchr (name
, '<') == NULL
)
11008 struct attribute
*attr
;
11009 struct die_info
*child
;
11012 die
->building_fullname
= 1;
11014 for (child
= die
->child
; child
!= NULL
; child
= child
->sibling
)
11018 const gdb_byte
*bytes
;
11019 struct dwarf2_locexpr_baton
*baton
;
11022 if (child
->tag
!= DW_TAG_template_type_param
11023 && child
->tag
!= DW_TAG_template_value_param
)
11034 attr
= dwarf2_attr (child
, DW_AT_type
, cu
);
11037 complaint (&symfile_complaints
,
11038 _("template parameter missing DW_AT_type"));
11039 buf
.puts ("UNKNOWN_TYPE");
11042 type
= die_type (child
, cu
);
11044 if (child
->tag
== DW_TAG_template_type_param
)
11046 c_print_type (type
, "", &buf
, -1, 0, &type_print_raw_options
);
11050 attr
= dwarf2_attr (child
, DW_AT_const_value
, cu
);
11053 complaint (&symfile_complaints
,
11054 _("template parameter missing "
11055 "DW_AT_const_value"));
11056 buf
.puts ("UNKNOWN_VALUE");
11060 dwarf2_const_value_attr (attr
, type
, name
,
11061 &cu
->comp_unit_obstack
, cu
,
11062 &value
, &bytes
, &baton
);
11064 if (TYPE_NOSIGN (type
))
11065 /* GDB prints characters as NUMBER 'CHAR'. If that's
11066 changed, this can use value_print instead. */
11067 c_printchar (value
, type
, &buf
);
11070 struct value_print_options opts
;
11073 v
= dwarf2_evaluate_loc_desc (type
, NULL
,
11077 else if (bytes
!= NULL
)
11079 v
= allocate_value (type
);
11080 memcpy (value_contents_writeable (v
), bytes
,
11081 TYPE_LENGTH (type
));
11084 v
= value_from_longest (type
, value
);
11086 /* Specify decimal so that we do not depend on
11088 get_formatted_print_options (&opts
, 'd');
11090 value_print (v
, &buf
, &opts
);
11096 die
->building_fullname
= 0;
11100 /* Close the argument list, with a space if necessary
11101 (nested templates). */
11102 if (!buf
.empty () && buf
.string ().back () == '>')
11109 /* For C++ methods, append formal parameter type
11110 information, if PHYSNAME. */
11112 if (physname
&& die
->tag
== DW_TAG_subprogram
11113 && cu
->language
== language_cplus
)
11115 struct type
*type
= read_type_die (die
, cu
);
11117 c_type_print_args (type
, &buf
, 1, cu
->language
,
11118 &type_print_raw_options
);
11120 if (cu
->language
== language_cplus
)
11122 /* Assume that an artificial first parameter is
11123 "this", but do not crash if it is not. RealView
11124 marks unnamed (and thus unused) parameters as
11125 artificial; there is no way to differentiate
11127 if (TYPE_NFIELDS (type
) > 0
11128 && TYPE_FIELD_ARTIFICIAL (type
, 0)
11129 && TYPE_CODE (TYPE_FIELD_TYPE (type
, 0)) == TYPE_CODE_PTR
11130 && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type
,
11132 buf
.puts (" const");
11136 const std::string
&intermediate_name
= buf
.string ();
11138 if (cu
->language
== language_cplus
)
11140 = dwarf2_canonicalize_name (intermediate_name
.c_str (), cu
,
11141 &objfile
->per_bfd
->storage_obstack
);
11143 /* If we only computed INTERMEDIATE_NAME, or if
11144 INTERMEDIATE_NAME is already canonical, then we need to
11145 copy it to the appropriate obstack. */
11146 if (canonical_name
== NULL
|| canonical_name
== intermediate_name
.c_str ())
11147 name
= ((const char *)
11148 obstack_copy0 (&objfile
->per_bfd
->storage_obstack
,
11149 intermediate_name
.c_str (),
11150 intermediate_name
.length ()));
11152 name
= canonical_name
;
11159 /* Return the fully qualified name of DIE, based on its DW_AT_name.
11160 If scope qualifiers are appropriate they will be added. The result
11161 will be allocated on the storage_obstack, or NULL if the DIE does
11162 not have a name. NAME may either be from a previous call to
11163 dwarf2_name or NULL.
11165 The output string will be canonicalized (if C++). */
11167 static const char *
11168 dwarf2_full_name (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
11170 return dwarf2_compute_name (name
, die
, cu
, 0);
11173 /* Construct a physname for the given DIE in CU. NAME may either be
11174 from a previous call to dwarf2_name or NULL. The result will be
11175 allocated on the objfile_objstack or NULL if the DIE does not have a
11178 The output string will be canonicalized (if C++). */
11180 static const char *
11181 dwarf2_physname (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
11183 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
11184 const char *retval
, *mangled
= NULL
, *canon
= NULL
;
11187 /* In this case dwarf2_compute_name is just a shortcut not building anything
11189 if (!die_needs_namespace (die
, cu
))
11190 return dwarf2_compute_name (name
, die
, cu
, 1);
11192 mangled
= dw2_linkage_name (die
, cu
);
11194 /* rustc emits invalid values for DW_AT_linkage_name. Ignore these.
11195 See https://github.com/rust-lang/rust/issues/32925. */
11196 if (cu
->language
== language_rust
&& mangled
!= NULL
11197 && strchr (mangled
, '{') != NULL
)
11200 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
11202 gdb::unique_xmalloc_ptr
<char> demangled
;
11203 if (mangled
!= NULL
)
11205 /* Use DMGL_RET_DROP for C++ template functions to suppress their return
11206 type. It is easier for GDB users to search for such functions as
11207 `name(params)' than `long name(params)'. In such case the minimal
11208 symbol names do not match the full symbol names but for template
11209 functions there is never a need to look up their definition from their
11210 declaration so the only disadvantage remains the minimal symbol
11211 variant `long name(params)' does not have the proper inferior type.
11214 if (cu
->language
== language_go
)
11216 /* This is a lie, but we already lie to the caller new_symbol_full.
11217 new_symbol_full assumes we return the mangled name.
11218 This just undoes that lie until things are cleaned up. */
11222 demangled
.reset (gdb_demangle (mangled
,
11223 (DMGL_PARAMS
| DMGL_ANSI
11224 | DMGL_RET_DROP
)));
11227 canon
= demangled
.get ();
11235 if (canon
== NULL
|| check_physname
)
11237 const char *physname
= dwarf2_compute_name (name
, die
, cu
, 1);
11239 if (canon
!= NULL
&& strcmp (physname
, canon
) != 0)
11241 /* It may not mean a bug in GDB. The compiler could also
11242 compute DW_AT_linkage_name incorrectly. But in such case
11243 GDB would need to be bug-to-bug compatible. */
11245 complaint (&symfile_complaints
,
11246 _("Computed physname <%s> does not match demangled <%s> "
11247 "(from linkage <%s>) - DIE at 0x%x [in module %s]"),
11248 physname
, canon
, mangled
, to_underlying (die
->sect_off
),
11249 objfile_name (objfile
));
11251 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
11252 is available here - over computed PHYSNAME. It is safer
11253 against both buggy GDB and buggy compilers. */
11267 retval
= ((const char *)
11268 obstack_copy0 (&objfile
->per_bfd
->storage_obstack
,
11269 retval
, strlen (retval
)));
11274 /* Inspect DIE in CU for a namespace alias. If one exists, record
11275 a new symbol for it.
11277 Returns 1 if a namespace alias was recorded, 0 otherwise. */
11280 read_namespace_alias (struct die_info
*die
, struct dwarf2_cu
*cu
)
11282 struct attribute
*attr
;
11284 /* If the die does not have a name, this is not a namespace
11286 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
11290 struct die_info
*d
= die
;
11291 struct dwarf2_cu
*imported_cu
= cu
;
11293 /* If the compiler has nested DW_AT_imported_declaration DIEs,
11294 keep inspecting DIEs until we hit the underlying import. */
11295 #define MAX_NESTED_IMPORTED_DECLARATIONS 100
11296 for (num
= 0; num
< MAX_NESTED_IMPORTED_DECLARATIONS
; ++num
)
11298 attr
= dwarf2_attr (d
, DW_AT_import
, cu
);
11302 d
= follow_die_ref (d
, attr
, &imported_cu
);
11303 if (d
->tag
!= DW_TAG_imported_declaration
)
11307 if (num
== MAX_NESTED_IMPORTED_DECLARATIONS
)
11309 complaint (&symfile_complaints
,
11310 _("DIE at 0x%x has too many recursively imported "
11311 "declarations"), to_underlying (d
->sect_off
));
11318 sect_offset sect_off
= dwarf2_get_ref_die_offset (attr
);
11320 type
= get_die_type_at_offset (sect_off
, cu
->per_cu
);
11321 if (type
!= NULL
&& TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
11323 /* This declaration is a global namespace alias. Add
11324 a symbol for it whose type is the aliased namespace. */
11325 new_symbol (die
, type
, cu
);
11334 /* Return the using directives repository (global or local?) to use in the
11335 current context for LANGUAGE.
11337 For Ada, imported declarations can materialize renamings, which *may* be
11338 global. However it is impossible (for now?) in DWARF to distinguish
11339 "external" imported declarations and "static" ones. As all imported
11340 declarations seem to be static in all other languages, make them all CU-wide
11341 global only in Ada. */
11343 static struct using_direct
**
11344 using_directives (enum language language
)
11346 if (language
== language_ada
&& context_stack_depth
== 0)
11347 return &global_using_directives
;
11349 return &local_using_directives
;
11352 /* Read the import statement specified by the given die and record it. */
11355 read_import_statement (struct die_info
*die
, struct dwarf2_cu
*cu
)
11357 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
11358 struct attribute
*import_attr
;
11359 struct die_info
*imported_die
, *child_die
;
11360 struct dwarf2_cu
*imported_cu
;
11361 const char *imported_name
;
11362 const char *imported_name_prefix
;
11363 const char *canonical_name
;
11364 const char *import_alias
;
11365 const char *imported_declaration
= NULL
;
11366 const char *import_prefix
;
11367 std::vector
<const char *> excludes
;
11369 import_attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
11370 if (import_attr
== NULL
)
11372 complaint (&symfile_complaints
, _("Tag '%s' has no DW_AT_import"),
11373 dwarf_tag_name (die
->tag
));
11378 imported_die
= follow_die_ref_or_sig (die
, import_attr
, &imported_cu
);
11379 imported_name
= dwarf2_name (imported_die
, imported_cu
);
11380 if (imported_name
== NULL
)
11382 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
11384 The import in the following code:
11398 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
11399 <52> DW_AT_decl_file : 1
11400 <53> DW_AT_decl_line : 6
11401 <54> DW_AT_import : <0x75>
11402 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
11403 <59> DW_AT_name : B
11404 <5b> DW_AT_decl_file : 1
11405 <5c> DW_AT_decl_line : 2
11406 <5d> DW_AT_type : <0x6e>
11408 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
11409 <76> DW_AT_byte_size : 4
11410 <77> DW_AT_encoding : 5 (signed)
11412 imports the wrong die ( 0x75 instead of 0x58 ).
11413 This case will be ignored until the gcc bug is fixed. */
11417 /* Figure out the local name after import. */
11418 import_alias
= dwarf2_name (die
, cu
);
11420 /* Figure out where the statement is being imported to. */
11421 import_prefix
= determine_prefix (die
, cu
);
11423 /* Figure out what the scope of the imported die is and prepend it
11424 to the name of the imported die. */
11425 imported_name_prefix
= determine_prefix (imported_die
, imported_cu
);
11427 if (imported_die
->tag
!= DW_TAG_namespace
11428 && imported_die
->tag
!= DW_TAG_module
)
11430 imported_declaration
= imported_name
;
11431 canonical_name
= imported_name_prefix
;
11433 else if (strlen (imported_name_prefix
) > 0)
11434 canonical_name
= obconcat (&objfile
->objfile_obstack
,
11435 imported_name_prefix
,
11436 (cu
->language
== language_d
? "." : "::"),
11437 imported_name
, (char *) NULL
);
11439 canonical_name
= imported_name
;
11441 if (die
->tag
== DW_TAG_imported_module
&& cu
->language
== language_fortran
)
11442 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
11443 child_die
= sibling_die (child_die
))
11445 /* DWARF-4: A Fortran use statement with a “rename list” may be
11446 represented by an imported module entry with an import attribute
11447 referring to the module and owned entries corresponding to those
11448 entities that are renamed as part of being imported. */
11450 if (child_die
->tag
!= DW_TAG_imported_declaration
)
11452 complaint (&symfile_complaints
,
11453 _("child DW_TAG_imported_declaration expected "
11454 "- DIE at 0x%x [in module %s]"),
11455 to_underlying (child_die
->sect_off
), objfile_name (objfile
));
11459 import_attr
= dwarf2_attr (child_die
, DW_AT_import
, cu
);
11460 if (import_attr
== NULL
)
11462 complaint (&symfile_complaints
, _("Tag '%s' has no DW_AT_import"),
11463 dwarf_tag_name (child_die
->tag
));
11468 imported_die
= follow_die_ref_or_sig (child_die
, import_attr
,
11470 imported_name
= dwarf2_name (imported_die
, imported_cu
);
11471 if (imported_name
== NULL
)
11473 complaint (&symfile_complaints
,
11474 _("child DW_TAG_imported_declaration has unknown "
11475 "imported name - DIE at 0x%x [in module %s]"),
11476 to_underlying (child_die
->sect_off
), objfile_name (objfile
));
11480 excludes
.push_back (imported_name
);
11482 process_die (child_die
, cu
);
11485 add_using_directive (using_directives (cu
->language
),
11489 imported_declaration
,
11492 &objfile
->objfile_obstack
);
11495 /* ICC<14 does not output the required DW_AT_declaration on incomplete
11496 types, but gives them a size of zero. Starting with version 14,
11497 ICC is compatible with GCC. */
11500 producer_is_icc_lt_14 (struct dwarf2_cu
*cu
)
11502 if (!cu
->checked_producer
)
11503 check_producer (cu
);
11505 return cu
->producer_is_icc_lt_14
;
11508 /* Check for possibly missing DW_AT_comp_dir with relative .debug_line
11509 directory paths. GCC SVN r127613 (new option -fdebug-prefix-map) fixed
11510 this, it was first present in GCC release 4.3.0. */
11513 producer_is_gcc_lt_4_3 (struct dwarf2_cu
*cu
)
11515 if (!cu
->checked_producer
)
11516 check_producer (cu
);
11518 return cu
->producer_is_gcc_lt_4_3
;
11521 static file_and_directory
11522 find_file_and_directory (struct die_info
*die
, struct dwarf2_cu
*cu
)
11524 file_and_directory res
;
11526 /* Find the filename. Do not use dwarf2_name here, since the filename
11527 is not a source language identifier. */
11528 res
.name
= dwarf2_string_attr (die
, DW_AT_name
, cu
);
11529 res
.comp_dir
= dwarf2_string_attr (die
, DW_AT_comp_dir
, cu
);
11531 if (res
.comp_dir
== NULL
11532 && producer_is_gcc_lt_4_3 (cu
) && res
.name
!= NULL
11533 && IS_ABSOLUTE_PATH (res
.name
))
11535 res
.comp_dir_storage
= ldirname (res
.name
);
11536 if (!res
.comp_dir_storage
.empty ())
11537 res
.comp_dir
= res
.comp_dir_storage
.c_str ();
11539 if (res
.comp_dir
!= NULL
)
11541 /* Irix 6.2 native cc prepends <machine>.: to the compilation
11542 directory, get rid of it. */
11543 const char *cp
= strchr (res
.comp_dir
, ':');
11545 if (cp
&& cp
!= res
.comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
11546 res
.comp_dir
= cp
+ 1;
11549 if (res
.name
== NULL
)
11550 res
.name
= "<unknown>";
11555 /* Handle DW_AT_stmt_list for a compilation unit.
11556 DIE is the DW_TAG_compile_unit die for CU.
11557 COMP_DIR is the compilation directory. LOWPC is passed to
11558 dwarf_decode_lines. See dwarf_decode_lines comments about it. */
11561 handle_DW_AT_stmt_list (struct die_info
*die
, struct dwarf2_cu
*cu
,
11562 const char *comp_dir
, CORE_ADDR lowpc
) /* ARI: editCase function */
11564 struct dwarf2_per_objfile
*dwarf2_per_objfile
11565 = cu
->per_cu
->dwarf2_per_objfile
;
11566 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
11567 struct attribute
*attr
;
11568 struct line_header line_header_local
;
11569 hashval_t line_header_local_hash
;
11571 int decode_mapping
;
11573 gdb_assert (! cu
->per_cu
->is_debug_types
);
11575 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
11579 sect_offset line_offset
= (sect_offset
) DW_UNSND (attr
);
11581 /* The line header hash table is only created if needed (it exists to
11582 prevent redundant reading of the line table for partial_units).
11583 If we're given a partial_unit, we'll need it. If we're given a
11584 compile_unit, then use the line header hash table if it's already
11585 created, but don't create one just yet. */
11587 if (dwarf2_per_objfile
->line_header_hash
== NULL
11588 && die
->tag
== DW_TAG_partial_unit
)
11590 dwarf2_per_objfile
->line_header_hash
11591 = htab_create_alloc_ex (127, line_header_hash_voidp
,
11592 line_header_eq_voidp
,
11593 free_line_header_voidp
,
11594 &objfile
->objfile_obstack
,
11595 hashtab_obstack_allocate
,
11596 dummy_obstack_deallocate
);
11599 line_header_local
.sect_off
= line_offset
;
11600 line_header_local
.offset_in_dwz
= cu
->per_cu
->is_dwz
;
11601 line_header_local_hash
= line_header_hash (&line_header_local
);
11602 if (dwarf2_per_objfile
->line_header_hash
!= NULL
)
11604 slot
= htab_find_slot_with_hash (dwarf2_per_objfile
->line_header_hash
,
11605 &line_header_local
,
11606 line_header_local_hash
, NO_INSERT
);
11608 /* For DW_TAG_compile_unit we need info like symtab::linetable which
11609 is not present in *SLOT (since if there is something in *SLOT then
11610 it will be for a partial_unit). */
11611 if (die
->tag
== DW_TAG_partial_unit
&& slot
!= NULL
)
11613 gdb_assert (*slot
!= NULL
);
11614 cu
->line_header
= (struct line_header
*) *slot
;
11619 /* dwarf_decode_line_header does not yet provide sufficient information.
11620 We always have to call also dwarf_decode_lines for it. */
11621 line_header_up lh
= dwarf_decode_line_header (line_offset
, cu
);
11625 cu
->line_header
= lh
.release ();
11626 cu
->line_header_die_owner
= die
;
11628 if (dwarf2_per_objfile
->line_header_hash
== NULL
)
11632 slot
= htab_find_slot_with_hash (dwarf2_per_objfile
->line_header_hash
,
11633 &line_header_local
,
11634 line_header_local_hash
, INSERT
);
11635 gdb_assert (slot
!= NULL
);
11637 if (slot
!= NULL
&& *slot
== NULL
)
11639 /* This newly decoded line number information unit will be owned
11640 by line_header_hash hash table. */
11641 *slot
= cu
->line_header
;
11642 cu
->line_header_die_owner
= NULL
;
11646 /* We cannot free any current entry in (*slot) as that struct line_header
11647 may be already used by multiple CUs. Create only temporary decoded
11648 line_header for this CU - it may happen at most once for each line
11649 number information unit. And if we're not using line_header_hash
11650 then this is what we want as well. */
11651 gdb_assert (die
->tag
!= DW_TAG_partial_unit
);
11653 decode_mapping
= (die
->tag
!= DW_TAG_partial_unit
);
11654 dwarf_decode_lines (cu
->line_header
, comp_dir
, cu
, NULL
, lowpc
,
11659 /* Process DW_TAG_compile_unit or DW_TAG_partial_unit. */
11662 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
11664 struct dwarf2_per_objfile
*dwarf2_per_objfile
11665 = cu
->per_cu
->dwarf2_per_objfile
;
11666 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
11667 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
11668 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
11669 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
11670 struct attribute
*attr
;
11671 struct die_info
*child_die
;
11672 CORE_ADDR baseaddr
;
11674 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
11676 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
11678 /* If we didn't find a lowpc, set it to highpc to avoid complaints
11679 from finish_block. */
11680 if (lowpc
== ((CORE_ADDR
) -1))
11682 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
11684 file_and_directory fnd
= find_file_and_directory (die
, cu
);
11686 prepare_one_comp_unit (cu
, die
, cu
->language
);
11688 /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
11689 standardised yet. As a workaround for the language detection we fall
11690 back to the DW_AT_producer string. */
11691 if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL") != NULL
)
11692 cu
->language
= language_opencl
;
11694 /* Similar hack for Go. */
11695 if (cu
->producer
&& strstr (cu
->producer
, "GNU Go ") != NULL
)
11696 set_cu_language (DW_LANG_Go
, cu
);
11698 dwarf2_start_symtab (cu
, fnd
.name
, fnd
.comp_dir
, lowpc
);
11700 /* Decode line number information if present. We do this before
11701 processing child DIEs, so that the line header table is available
11702 for DW_AT_decl_file. */
11703 handle_DW_AT_stmt_list (die
, cu
, fnd
.comp_dir
, lowpc
);
11705 /* Process all dies in compilation unit. */
11706 if (die
->child
!= NULL
)
11708 child_die
= die
->child
;
11709 while (child_die
&& child_die
->tag
)
11711 process_die (child_die
, cu
);
11712 child_die
= sibling_die (child_die
);
11716 /* Decode macro information, if present. Dwarf 2 macro information
11717 refers to information in the line number info statement program
11718 header, so we can only read it if we've read the header
11720 attr
= dwarf2_attr (die
, DW_AT_macros
, cu
);
11722 attr
= dwarf2_attr (die
, DW_AT_GNU_macros
, cu
);
11723 if (attr
&& cu
->line_header
)
11725 if (dwarf2_attr (die
, DW_AT_macro_info
, cu
))
11726 complaint (&symfile_complaints
,
11727 _("CU refers to both DW_AT_macros and DW_AT_macro_info"));
11729 dwarf_decode_macros (cu
, DW_UNSND (attr
), 1);
11733 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
11734 if (attr
&& cu
->line_header
)
11736 unsigned int macro_offset
= DW_UNSND (attr
);
11738 dwarf_decode_macros (cu
, macro_offset
, 0);
11743 /* TU version of handle_DW_AT_stmt_list for read_type_unit_scope.
11744 Create the set of symtabs used by this TU, or if this TU is sharing
11745 symtabs with another TU and the symtabs have already been created
11746 then restore those symtabs in the line header.
11747 We don't need the pc/line-number mapping for type units. */
11750 setup_type_unit_groups (struct die_info
*die
, struct dwarf2_cu
*cu
)
11752 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
11753 struct type_unit_group
*tu_group
;
11755 struct attribute
*attr
;
11757 struct signatured_type
*sig_type
;
11759 gdb_assert (per_cu
->is_debug_types
);
11760 sig_type
= (struct signatured_type
*) per_cu
;
11762 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
11764 /* If we're using .gdb_index (includes -readnow) then
11765 per_cu->type_unit_group may not have been set up yet. */
11766 if (sig_type
->type_unit_group
== NULL
)
11767 sig_type
->type_unit_group
= get_type_unit_group (cu
, attr
);
11768 tu_group
= sig_type
->type_unit_group
;
11770 /* If we've already processed this stmt_list there's no real need to
11771 do it again, we could fake it and just recreate the part we need
11772 (file name,index -> symtab mapping). If data shows this optimization
11773 is useful we can do it then. */
11774 first_time
= tu_group
->compunit_symtab
== NULL
;
11776 /* We have to handle the case of both a missing DW_AT_stmt_list or bad
11781 sect_offset line_offset
= (sect_offset
) DW_UNSND (attr
);
11782 lh
= dwarf_decode_line_header (line_offset
, cu
);
11787 dwarf2_start_symtab (cu
, "", NULL
, 0);
11790 gdb_assert (tu_group
->symtabs
== NULL
);
11791 restart_symtab (tu_group
->compunit_symtab
, "", 0);
11796 cu
->line_header
= lh
.release ();
11797 cu
->line_header_die_owner
= die
;
11801 struct compunit_symtab
*cust
= dwarf2_start_symtab (cu
, "", NULL
, 0);
11803 /* Note: We don't assign tu_group->compunit_symtab yet because we're
11804 still initializing it, and our caller (a few levels up)
11805 process_full_type_unit still needs to know if this is the first
11808 tu_group
->num_symtabs
= cu
->line_header
->file_names
.size ();
11809 tu_group
->symtabs
= XNEWVEC (struct symtab
*,
11810 cu
->line_header
->file_names
.size ());
11812 for (i
= 0; i
< cu
->line_header
->file_names
.size (); ++i
)
11814 file_entry
&fe
= cu
->line_header
->file_names
[i
];
11816 dwarf2_start_subfile (fe
.name
, fe
.include_dir (cu
->line_header
));
11818 if (current_subfile
->symtab
== NULL
)
11820 /* NOTE: start_subfile will recognize when it's been
11821 passed a file it has already seen. So we can't
11822 assume there's a simple mapping from
11823 cu->line_header->file_names to subfiles, plus
11824 cu->line_header->file_names may contain dups. */
11825 current_subfile
->symtab
11826 = allocate_symtab (cust
, current_subfile
->name
);
11829 fe
.symtab
= current_subfile
->symtab
;
11830 tu_group
->symtabs
[i
] = fe
.symtab
;
11835 restart_symtab (tu_group
->compunit_symtab
, "", 0);
11837 for (i
= 0; i
< cu
->line_header
->file_names
.size (); ++i
)
11839 file_entry
&fe
= cu
->line_header
->file_names
[i
];
11841 fe
.symtab
= tu_group
->symtabs
[i
];
11845 /* The main symtab is allocated last. Type units don't have DW_AT_name
11846 so they don't have a "real" (so to speak) symtab anyway.
11847 There is later code that will assign the main symtab to all symbols
11848 that don't have one. We need to handle the case of a symbol with a
11849 missing symtab (DW_AT_decl_file) anyway. */
11852 /* Process DW_TAG_type_unit.
11853 For TUs we want to skip the first top level sibling if it's not the
11854 actual type being defined by this TU. In this case the first top
11855 level sibling is there to provide context only. */
11858 read_type_unit_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
11860 struct die_info
*child_die
;
11862 prepare_one_comp_unit (cu
, die
, language_minimal
);
11864 /* Initialize (or reinitialize) the machinery for building symtabs.
11865 We do this before processing child DIEs, so that the line header table
11866 is available for DW_AT_decl_file. */
11867 setup_type_unit_groups (die
, cu
);
11869 if (die
->child
!= NULL
)
11871 child_die
= die
->child
;
11872 while (child_die
&& child_die
->tag
)
11874 process_die (child_die
, cu
);
11875 child_die
= sibling_die (child_die
);
11882 http://gcc.gnu.org/wiki/DebugFission
11883 http://gcc.gnu.org/wiki/DebugFissionDWP
11885 To simplify handling of both DWO files ("object" files with the DWARF info)
11886 and DWP files (a file with the DWOs packaged up into one file), we treat
11887 DWP files as having a collection of virtual DWO files. */
11890 hash_dwo_file (const void *item
)
11892 const struct dwo_file
*dwo_file
= (const struct dwo_file
*) item
;
11895 hash
= htab_hash_string (dwo_file
->dwo_name
);
11896 if (dwo_file
->comp_dir
!= NULL
)
11897 hash
+= htab_hash_string (dwo_file
->comp_dir
);
11902 eq_dwo_file (const void *item_lhs
, const void *item_rhs
)
11904 const struct dwo_file
*lhs
= (const struct dwo_file
*) item_lhs
;
11905 const struct dwo_file
*rhs
= (const struct dwo_file
*) item_rhs
;
11907 if (strcmp (lhs
->dwo_name
, rhs
->dwo_name
) != 0)
11909 if (lhs
->comp_dir
== NULL
|| rhs
->comp_dir
== NULL
)
11910 return lhs
->comp_dir
== rhs
->comp_dir
;
11911 return strcmp (lhs
->comp_dir
, rhs
->comp_dir
) == 0;
11914 /* Allocate a hash table for DWO files. */
11917 allocate_dwo_file_hash_table (struct objfile
*objfile
)
11919 return htab_create_alloc_ex (41,
11923 &objfile
->objfile_obstack
,
11924 hashtab_obstack_allocate
,
11925 dummy_obstack_deallocate
);
11928 /* Lookup DWO file DWO_NAME. */
11931 lookup_dwo_file_slot (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
11932 const char *dwo_name
,
11933 const char *comp_dir
)
11935 struct dwo_file find_entry
;
11938 if (dwarf2_per_objfile
->dwo_files
== NULL
)
11939 dwarf2_per_objfile
->dwo_files
11940 = allocate_dwo_file_hash_table (dwarf2_per_objfile
->objfile
);
11942 memset (&find_entry
, 0, sizeof (find_entry
));
11943 find_entry
.dwo_name
= dwo_name
;
11944 find_entry
.comp_dir
= comp_dir
;
11945 slot
= htab_find_slot (dwarf2_per_objfile
->dwo_files
, &find_entry
, INSERT
);
11951 hash_dwo_unit (const void *item
)
11953 const struct dwo_unit
*dwo_unit
= (const struct dwo_unit
*) item
;
11955 /* This drops the top 32 bits of the id, but is ok for a hash. */
11956 return dwo_unit
->signature
;
11960 eq_dwo_unit (const void *item_lhs
, const void *item_rhs
)
11962 const struct dwo_unit
*lhs
= (const struct dwo_unit
*) item_lhs
;
11963 const struct dwo_unit
*rhs
= (const struct dwo_unit
*) item_rhs
;
11965 /* The signature is assumed to be unique within the DWO file.
11966 So while object file CU dwo_id's always have the value zero,
11967 that's OK, assuming each object file DWO file has only one CU,
11968 and that's the rule for now. */
11969 return lhs
->signature
== rhs
->signature
;
11972 /* Allocate a hash table for DWO CUs,TUs.
11973 There is one of these tables for each of CUs,TUs for each DWO file. */
11976 allocate_dwo_unit_table (struct objfile
*objfile
)
11978 /* Start out with a pretty small number.
11979 Generally DWO files contain only one CU and maybe some TUs. */
11980 return htab_create_alloc_ex (3,
11984 &objfile
->objfile_obstack
,
11985 hashtab_obstack_allocate
,
11986 dummy_obstack_deallocate
);
11989 /* Structure used to pass data to create_dwo_debug_info_hash_table_reader. */
11991 struct create_dwo_cu_data
11993 struct dwo_file
*dwo_file
;
11994 struct dwo_unit dwo_unit
;
11997 /* die_reader_func for create_dwo_cu. */
12000 create_dwo_cu_reader (const struct die_reader_specs
*reader
,
12001 const gdb_byte
*info_ptr
,
12002 struct die_info
*comp_unit_die
,
12006 struct dwarf2_cu
*cu
= reader
->cu
;
12007 sect_offset sect_off
= cu
->per_cu
->sect_off
;
12008 struct dwarf2_section_info
*section
= cu
->per_cu
->section
;
12009 struct create_dwo_cu_data
*data
= (struct create_dwo_cu_data
*) datap
;
12010 struct dwo_file
*dwo_file
= data
->dwo_file
;
12011 struct dwo_unit
*dwo_unit
= &data
->dwo_unit
;
12012 struct attribute
*attr
;
12014 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_id
, cu
);
12017 complaint (&symfile_complaints
,
12018 _("Dwarf Error: debug entry at offset 0x%x is missing"
12019 " its dwo_id [in module %s]"),
12020 to_underlying (sect_off
), dwo_file
->dwo_name
);
12024 dwo_unit
->dwo_file
= dwo_file
;
12025 dwo_unit
->signature
= DW_UNSND (attr
);
12026 dwo_unit
->section
= section
;
12027 dwo_unit
->sect_off
= sect_off
;
12028 dwo_unit
->length
= cu
->per_cu
->length
;
12030 if (dwarf_read_debug
)
12031 fprintf_unfiltered (gdb_stdlog
, " offset 0x%x, dwo_id %s\n",
12032 to_underlying (sect_off
),
12033 hex_string (dwo_unit
->signature
));
12036 /* Create the dwo_units for the CUs in a DWO_FILE.
12037 Note: This function processes DWO files only, not DWP files. */
12040 create_cus_hash_table (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
12041 struct dwo_file
&dwo_file
, dwarf2_section_info
§ion
,
12044 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
12045 const gdb_byte
*info_ptr
, *end_ptr
;
12047 dwarf2_read_section (objfile
, §ion
);
12048 info_ptr
= section
.buffer
;
12050 if (info_ptr
== NULL
)
12053 if (dwarf_read_debug
)
12055 fprintf_unfiltered (gdb_stdlog
, "Reading %s for %s:\n",
12056 get_section_name (§ion
),
12057 get_section_file_name (§ion
));
12060 end_ptr
= info_ptr
+ section
.size
;
12061 while (info_ptr
< end_ptr
)
12063 struct dwarf2_per_cu_data per_cu
;
12064 struct create_dwo_cu_data create_dwo_cu_data
;
12065 struct dwo_unit
*dwo_unit
;
12067 sect_offset sect_off
= (sect_offset
) (info_ptr
- section
.buffer
);
12069 memset (&create_dwo_cu_data
.dwo_unit
, 0,
12070 sizeof (create_dwo_cu_data
.dwo_unit
));
12071 memset (&per_cu
, 0, sizeof (per_cu
));
12072 per_cu
.dwarf2_per_objfile
= dwarf2_per_objfile
;
12073 per_cu
.is_debug_types
= 0;
12074 per_cu
.sect_off
= sect_offset (info_ptr
- section
.buffer
);
12075 per_cu
.section
= §ion
;
12076 create_dwo_cu_data
.dwo_file
= &dwo_file
;
12078 init_cutu_and_read_dies_no_follow (
12079 &per_cu
, &dwo_file
, create_dwo_cu_reader
, &create_dwo_cu_data
);
12080 info_ptr
+= per_cu
.length
;
12082 // If the unit could not be parsed, skip it.
12083 if (create_dwo_cu_data
.dwo_unit
.dwo_file
== NULL
)
12086 if (cus_htab
== NULL
)
12087 cus_htab
= allocate_dwo_unit_table (objfile
);
12089 dwo_unit
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_unit
);
12090 *dwo_unit
= create_dwo_cu_data
.dwo_unit
;
12091 slot
= htab_find_slot (cus_htab
, dwo_unit
, INSERT
);
12092 gdb_assert (slot
!= NULL
);
12095 const struct dwo_unit
*dup_cu
= (const struct dwo_unit
*)*slot
;
12096 sect_offset dup_sect_off
= dup_cu
->sect_off
;
12098 complaint (&symfile_complaints
,
12099 _("debug cu entry at offset 0x%x is duplicate to"
12100 " the entry at offset 0x%x, signature %s"),
12101 to_underlying (sect_off
), to_underlying (dup_sect_off
),
12102 hex_string (dwo_unit
->signature
));
12104 *slot
= (void *)dwo_unit
;
12108 /* DWP file .debug_{cu,tu}_index section format:
12109 [ref: http://gcc.gnu.org/wiki/DebugFissionDWP]
12113 Both index sections have the same format, and serve to map a 64-bit
12114 signature to a set of section numbers. Each section begins with a header,
12115 followed by a hash table of 64-bit signatures, a parallel table of 32-bit
12116 indexes, and a pool of 32-bit section numbers. The index sections will be
12117 aligned at 8-byte boundaries in the file.
12119 The index section header consists of:
12121 V, 32 bit version number
12123 N, 32 bit number of compilation units or type units in the index
12124 M, 32 bit number of slots in the hash table
12126 Numbers are recorded using the byte order of the application binary.
12128 The hash table begins at offset 16 in the section, and consists of an array
12129 of M 64-bit slots. Each slot contains a 64-bit signature (using the byte
12130 order of the application binary). Unused slots in the hash table are 0.
12131 (We rely on the extreme unlikeliness of a signature being exactly 0.)
12133 The parallel table begins immediately after the hash table
12134 (at offset 16 + 8 * M from the beginning of the section), and consists of an
12135 array of 32-bit indexes (using the byte order of the application binary),
12136 corresponding 1-1 with slots in the hash table. Each entry in the parallel
12137 table contains a 32-bit index into the pool of section numbers. For unused
12138 hash table slots, the corresponding entry in the parallel table will be 0.
12140 The pool of section numbers begins immediately following the hash table
12141 (at offset 16 + 12 * M from the beginning of the section). The pool of
12142 section numbers consists of an array of 32-bit words (using the byte order
12143 of the application binary). Each item in the array is indexed starting
12144 from 0. The hash table entry provides the index of the first section
12145 number in the set. Additional section numbers in the set follow, and the
12146 set is terminated by a 0 entry (section number 0 is not used in ELF).
12148 In each set of section numbers, the .debug_info.dwo or .debug_types.dwo
12149 section must be the first entry in the set, and the .debug_abbrev.dwo must
12150 be the second entry. Other members of the set may follow in any order.
12156 DWP Version 2 combines all the .debug_info, etc. sections into one,
12157 and the entries in the index tables are now offsets into these sections.
12158 CU offsets begin at 0. TU offsets begin at the size of the .debug_info
12161 Index Section Contents:
12163 Hash Table of Signatures dwp_hash_table.hash_table
12164 Parallel Table of Indices dwp_hash_table.unit_table
12165 Table of Section Offsets dwp_hash_table.v2.{section_ids,offsets}
12166 Table of Section Sizes dwp_hash_table.v2.sizes
12168 The index section header consists of:
12170 V, 32 bit version number
12171 L, 32 bit number of columns in the table of section offsets
12172 N, 32 bit number of compilation units or type units in the index
12173 M, 32 bit number of slots in the hash table
12175 Numbers are recorded using the byte order of the application binary.
12177 The hash table has the same format as version 1.
12178 The parallel table of indices has the same format as version 1,
12179 except that the entries are origin-1 indices into the table of sections
12180 offsets and the table of section sizes.
12182 The table of offsets begins immediately following the parallel table
12183 (at offset 16 + 12 * M from the beginning of the section). The table is
12184 a two-dimensional array of 32-bit words (using the byte order of the
12185 application binary), with L columns and N+1 rows, in row-major order.
12186 Each row in the array is indexed starting from 0. The first row provides
12187 a key to the remaining rows: each column in this row provides an identifier
12188 for a debug section, and the offsets in the same column of subsequent rows
12189 refer to that section. The section identifiers are:
12191 DW_SECT_INFO 1 .debug_info.dwo
12192 DW_SECT_TYPES 2 .debug_types.dwo
12193 DW_SECT_ABBREV 3 .debug_abbrev.dwo
12194 DW_SECT_LINE 4 .debug_line.dwo
12195 DW_SECT_LOC 5 .debug_loc.dwo
12196 DW_SECT_STR_OFFSETS 6 .debug_str_offsets.dwo
12197 DW_SECT_MACINFO 7 .debug_macinfo.dwo
12198 DW_SECT_MACRO 8 .debug_macro.dwo
12200 The offsets provided by the CU and TU index sections are the base offsets
12201 for the contributions made by each CU or TU to the corresponding section
12202 in the package file. Each CU and TU header contains an abbrev_offset
12203 field, used to find the abbreviations table for that CU or TU within the
12204 contribution to the .debug_abbrev.dwo section for that CU or TU, and should
12205 be interpreted as relative to the base offset given in the index section.
12206 Likewise, offsets into .debug_line.dwo from DW_AT_stmt_list attributes
12207 should be interpreted as relative to the base offset for .debug_line.dwo,
12208 and offsets into other debug sections obtained from DWARF attributes should
12209 also be interpreted as relative to the corresponding base offset.
12211 The table of sizes begins immediately following the table of offsets.
12212 Like the table of offsets, it is a two-dimensional array of 32-bit words,
12213 with L columns and N rows, in row-major order. Each row in the array is
12214 indexed starting from 1 (row 0 is shared by the two tables).
12218 Hash table lookup is handled the same in version 1 and 2:
12220 We assume that N and M will not exceed 2^32 - 1.
12221 The size of the hash table, M, must be 2^k such that 2^k > 3*N/2.
12223 Given a 64-bit compilation unit signature or a type signature S, an entry
12224 in the hash table is located as follows:
12226 1) Calculate a primary hash H = S & MASK(k), where MASK(k) is a mask with
12227 the low-order k bits all set to 1.
12229 2) Calculate a secondary hash H' = (((S >> 32) & MASK(k)) | 1).
12231 3) If the hash table entry at index H matches the signature, use that
12232 entry. If the hash table entry at index H is unused (all zeroes),
12233 terminate the search: the signature is not present in the table.
12235 4) Let H = (H + H') modulo M. Repeat at Step 3.
12237 Because M > N and H' and M are relatively prime, the search is guaranteed
12238 to stop at an unused slot or find the match. */
12240 /* Create a hash table to map DWO IDs to their CU/TU entry in
12241 .debug_{info,types}.dwo in DWP_FILE.
12242 Returns NULL if there isn't one.
12243 Note: This function processes DWP files only, not DWO files. */
12245 static struct dwp_hash_table
*
12246 create_dwp_hash_table (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
12247 struct dwp_file
*dwp_file
, int is_debug_types
)
12249 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
12250 bfd
*dbfd
= dwp_file
->dbfd
;
12251 const gdb_byte
*index_ptr
, *index_end
;
12252 struct dwarf2_section_info
*index
;
12253 uint32_t version
, nr_columns
, nr_units
, nr_slots
;
12254 struct dwp_hash_table
*htab
;
12256 if (is_debug_types
)
12257 index
= &dwp_file
->sections
.tu_index
;
12259 index
= &dwp_file
->sections
.cu_index
;
12261 if (dwarf2_section_empty_p (index
))
12263 dwarf2_read_section (objfile
, index
);
12265 index_ptr
= index
->buffer
;
12266 index_end
= index_ptr
+ index
->size
;
12268 version
= read_4_bytes (dbfd
, index_ptr
);
12271 nr_columns
= read_4_bytes (dbfd
, index_ptr
);
12275 nr_units
= read_4_bytes (dbfd
, index_ptr
);
12277 nr_slots
= read_4_bytes (dbfd
, index_ptr
);
12280 if (version
!= 1 && version
!= 2)
12282 error (_("Dwarf Error: unsupported DWP file version (%s)"
12283 " [in module %s]"),
12284 pulongest (version
), dwp_file
->name
);
12286 if (nr_slots
!= (nr_slots
& -nr_slots
))
12288 error (_("Dwarf Error: number of slots in DWP hash table (%s)"
12289 " is not power of 2 [in module %s]"),
12290 pulongest (nr_slots
), dwp_file
->name
);
12293 htab
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwp_hash_table
);
12294 htab
->version
= version
;
12295 htab
->nr_columns
= nr_columns
;
12296 htab
->nr_units
= nr_units
;
12297 htab
->nr_slots
= nr_slots
;
12298 htab
->hash_table
= index_ptr
;
12299 htab
->unit_table
= htab
->hash_table
+ sizeof (uint64_t) * nr_slots
;
12301 /* Exit early if the table is empty. */
12302 if (nr_slots
== 0 || nr_units
== 0
12303 || (version
== 2 && nr_columns
== 0))
12305 /* All must be zero. */
12306 if (nr_slots
!= 0 || nr_units
!= 0
12307 || (version
== 2 && nr_columns
!= 0))
12309 complaint (&symfile_complaints
,
12310 _("Empty DWP but nr_slots,nr_units,nr_columns not"
12311 " all zero [in modules %s]"),
12319 htab
->section_pool
.v1
.indices
=
12320 htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
12321 /* It's harder to decide whether the section is too small in v1.
12322 V1 is deprecated anyway so we punt. */
12326 const gdb_byte
*ids_ptr
= htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
12327 int *ids
= htab
->section_pool
.v2
.section_ids
;
12328 /* Reverse map for error checking. */
12329 int ids_seen
[DW_SECT_MAX
+ 1];
12332 if (nr_columns
< 2)
12334 error (_("Dwarf Error: bad DWP hash table, too few columns"
12335 " in section table [in module %s]"),
12338 if (nr_columns
> MAX_NR_V2_DWO_SECTIONS
)
12340 error (_("Dwarf Error: bad DWP hash table, too many columns"
12341 " in section table [in module %s]"),
12344 memset (ids
, 255, (DW_SECT_MAX
+ 1) * sizeof (int32_t));
12345 memset (ids_seen
, 255, (DW_SECT_MAX
+ 1) * sizeof (int32_t));
12346 for (i
= 0; i
< nr_columns
; ++i
)
12348 int id
= read_4_bytes (dbfd
, ids_ptr
+ i
* sizeof (uint32_t));
12350 if (id
< DW_SECT_MIN
|| id
> DW_SECT_MAX
)
12352 error (_("Dwarf Error: bad DWP hash table, bad section id %d"
12353 " in section table [in module %s]"),
12354 id
, dwp_file
->name
);
12356 if (ids_seen
[id
] != -1)
12358 error (_("Dwarf Error: bad DWP hash table, duplicate section"
12359 " id %d in section table [in module %s]"),
12360 id
, dwp_file
->name
);
12365 /* Must have exactly one info or types section. */
12366 if (((ids_seen
[DW_SECT_INFO
] != -1)
12367 + (ids_seen
[DW_SECT_TYPES
] != -1))
12370 error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
12371 " DWO info/types section [in module %s]"),
12374 /* Must have an abbrev section. */
12375 if (ids_seen
[DW_SECT_ABBREV
] == -1)
12377 error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
12378 " section [in module %s]"),
12381 htab
->section_pool
.v2
.offsets
= ids_ptr
+ sizeof (uint32_t) * nr_columns
;
12382 htab
->section_pool
.v2
.sizes
=
12383 htab
->section_pool
.v2
.offsets
+ (sizeof (uint32_t)
12384 * nr_units
* nr_columns
);
12385 if ((htab
->section_pool
.v2
.sizes
+ (sizeof (uint32_t)
12386 * nr_units
* nr_columns
))
12389 error (_("Dwarf Error: DWP index section is corrupt (too small)"
12390 " [in module %s]"),
12398 /* Update SECTIONS with the data from SECTP.
12400 This function is like the other "locate" section routines that are
12401 passed to bfd_map_over_sections, but in this context the sections to
12402 read comes from the DWP V1 hash table, not the full ELF section table.
12404 The result is non-zero for success, or zero if an error was found. */
12407 locate_v1_virtual_dwo_sections (asection
*sectp
,
12408 struct virtual_v1_dwo_sections
*sections
)
12410 const struct dwop_section_names
*names
= &dwop_section_names
;
12412 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
12414 /* There can be only one. */
12415 if (sections
->abbrev
.s
.section
!= NULL
)
12417 sections
->abbrev
.s
.section
= sectp
;
12418 sections
->abbrev
.size
= bfd_get_section_size (sectp
);
12420 else if (section_is_p (sectp
->name
, &names
->info_dwo
)
12421 || section_is_p (sectp
->name
, &names
->types_dwo
))
12423 /* There can be only one. */
12424 if (sections
->info_or_types
.s
.section
!= NULL
)
12426 sections
->info_or_types
.s
.section
= sectp
;
12427 sections
->info_or_types
.size
= bfd_get_section_size (sectp
);
12429 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
12431 /* There can be only one. */
12432 if (sections
->line
.s
.section
!= NULL
)
12434 sections
->line
.s
.section
= sectp
;
12435 sections
->line
.size
= bfd_get_section_size (sectp
);
12437 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
12439 /* There can be only one. */
12440 if (sections
->loc
.s
.section
!= NULL
)
12442 sections
->loc
.s
.section
= sectp
;
12443 sections
->loc
.size
= bfd_get_section_size (sectp
);
12445 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
12447 /* There can be only one. */
12448 if (sections
->macinfo
.s
.section
!= NULL
)
12450 sections
->macinfo
.s
.section
= sectp
;
12451 sections
->macinfo
.size
= bfd_get_section_size (sectp
);
12453 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
12455 /* There can be only one. */
12456 if (sections
->macro
.s
.section
!= NULL
)
12458 sections
->macro
.s
.section
= sectp
;
12459 sections
->macro
.size
= bfd_get_section_size (sectp
);
12461 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
12463 /* There can be only one. */
12464 if (sections
->str_offsets
.s
.section
!= NULL
)
12466 sections
->str_offsets
.s
.section
= sectp
;
12467 sections
->str_offsets
.size
= bfd_get_section_size (sectp
);
12471 /* No other kind of section is valid. */
12478 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12479 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12480 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12481 This is for DWP version 1 files. */
12483 static struct dwo_unit
*
12484 create_dwo_unit_in_dwp_v1 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
12485 struct dwp_file
*dwp_file
,
12486 uint32_t unit_index
,
12487 const char *comp_dir
,
12488 ULONGEST signature
, int is_debug_types
)
12490 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
12491 const struct dwp_hash_table
*dwp_htab
=
12492 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12493 bfd
*dbfd
= dwp_file
->dbfd
;
12494 const char *kind
= is_debug_types
? "TU" : "CU";
12495 struct dwo_file
*dwo_file
;
12496 struct dwo_unit
*dwo_unit
;
12497 struct virtual_v1_dwo_sections sections
;
12498 void **dwo_file_slot
;
12501 gdb_assert (dwp_file
->version
== 1);
12503 if (dwarf_read_debug
)
12505 fprintf_unfiltered (gdb_stdlog
, "Reading %s %s/%s in DWP V1 file: %s\n",
12507 pulongest (unit_index
), hex_string (signature
),
12511 /* Fetch the sections of this DWO unit.
12512 Put a limit on the number of sections we look for so that bad data
12513 doesn't cause us to loop forever. */
12515 #define MAX_NR_V1_DWO_SECTIONS \
12516 (1 /* .debug_info or .debug_types */ \
12517 + 1 /* .debug_abbrev */ \
12518 + 1 /* .debug_line */ \
12519 + 1 /* .debug_loc */ \
12520 + 1 /* .debug_str_offsets */ \
12521 + 1 /* .debug_macro or .debug_macinfo */ \
12522 + 1 /* trailing zero */)
12524 memset (§ions
, 0, sizeof (sections
));
12526 for (i
= 0; i
< MAX_NR_V1_DWO_SECTIONS
; ++i
)
12529 uint32_t section_nr
=
12530 read_4_bytes (dbfd
,
12531 dwp_htab
->section_pool
.v1
.indices
12532 + (unit_index
+ i
) * sizeof (uint32_t));
12534 if (section_nr
== 0)
12536 if (section_nr
>= dwp_file
->num_sections
)
12538 error (_("Dwarf Error: bad DWP hash table, section number too large"
12539 " [in module %s]"),
12543 sectp
= dwp_file
->elf_sections
[section_nr
];
12544 if (! locate_v1_virtual_dwo_sections (sectp
, §ions
))
12546 error (_("Dwarf Error: bad DWP hash table, invalid section found"
12547 " [in module %s]"),
12553 || dwarf2_section_empty_p (§ions
.info_or_types
)
12554 || dwarf2_section_empty_p (§ions
.abbrev
))
12556 error (_("Dwarf Error: bad DWP hash table, missing DWO sections"
12557 " [in module %s]"),
12560 if (i
== MAX_NR_V1_DWO_SECTIONS
)
12562 error (_("Dwarf Error: bad DWP hash table, too many DWO sections"
12563 " [in module %s]"),
12567 /* It's easier for the rest of the code if we fake a struct dwo_file and
12568 have dwo_unit "live" in that. At least for now.
12570 The DWP file can be made up of a random collection of CUs and TUs.
12571 However, for each CU + set of TUs that came from the same original DWO
12572 file, we can combine them back into a virtual DWO file to save space
12573 (fewer struct dwo_file objects to allocate). Remember that for really
12574 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
12576 std::string virtual_dwo_name
=
12577 string_printf ("virtual-dwo/%d-%d-%d-%d",
12578 get_section_id (§ions
.abbrev
),
12579 get_section_id (§ions
.line
),
12580 get_section_id (§ions
.loc
),
12581 get_section_id (§ions
.str_offsets
));
12582 /* Can we use an existing virtual DWO file? */
12583 dwo_file_slot
= lookup_dwo_file_slot (dwarf2_per_objfile
,
12584 virtual_dwo_name
.c_str (),
12586 /* Create one if necessary. */
12587 if (*dwo_file_slot
== NULL
)
12589 if (dwarf_read_debug
)
12591 fprintf_unfiltered (gdb_stdlog
, "Creating virtual DWO: %s\n",
12592 virtual_dwo_name
.c_str ());
12594 dwo_file
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_file
);
12596 = (const char *) obstack_copy0 (&objfile
->objfile_obstack
,
12597 virtual_dwo_name
.c_str (),
12598 virtual_dwo_name
.size ());
12599 dwo_file
->comp_dir
= comp_dir
;
12600 dwo_file
->sections
.abbrev
= sections
.abbrev
;
12601 dwo_file
->sections
.line
= sections
.line
;
12602 dwo_file
->sections
.loc
= sections
.loc
;
12603 dwo_file
->sections
.macinfo
= sections
.macinfo
;
12604 dwo_file
->sections
.macro
= sections
.macro
;
12605 dwo_file
->sections
.str_offsets
= sections
.str_offsets
;
12606 /* The "str" section is global to the entire DWP file. */
12607 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
12608 /* The info or types section is assigned below to dwo_unit,
12609 there's no need to record it in dwo_file.
12610 Also, we can't simply record type sections in dwo_file because
12611 we record a pointer into the vector in dwo_unit. As we collect more
12612 types we'll grow the vector and eventually have to reallocate space
12613 for it, invalidating all copies of pointers into the previous
12615 *dwo_file_slot
= dwo_file
;
12619 if (dwarf_read_debug
)
12621 fprintf_unfiltered (gdb_stdlog
, "Using existing virtual DWO: %s\n",
12622 virtual_dwo_name
.c_str ());
12624 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
12627 dwo_unit
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_unit
);
12628 dwo_unit
->dwo_file
= dwo_file
;
12629 dwo_unit
->signature
= signature
;
12630 dwo_unit
->section
=
12631 XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_section_info
);
12632 *dwo_unit
->section
= sections
.info_or_types
;
12633 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12638 /* Subroutine of create_dwo_unit_in_dwp_v2 to simplify it.
12639 Given a pointer to the containing section SECTION, and OFFSET,SIZE of the
12640 piece within that section used by a TU/CU, return a virtual section
12641 of just that piece. */
12643 static struct dwarf2_section_info
12644 create_dwp_v2_section (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
12645 struct dwarf2_section_info
*section
,
12646 bfd_size_type offset
, bfd_size_type size
)
12648 struct dwarf2_section_info result
;
12651 gdb_assert (section
!= NULL
);
12652 gdb_assert (!section
->is_virtual
);
12654 memset (&result
, 0, sizeof (result
));
12655 result
.s
.containing_section
= section
;
12656 result
.is_virtual
= 1;
12661 sectp
= get_section_bfd_section (section
);
12663 /* Flag an error if the piece denoted by OFFSET,SIZE is outside the
12664 bounds of the real section. This is a pretty-rare event, so just
12665 flag an error (easier) instead of a warning and trying to cope. */
12667 || offset
+ size
> bfd_get_section_size (sectp
))
12669 error (_("Dwarf Error: Bad DWP V2 section info, doesn't fit"
12670 " in section %s [in module %s]"),
12671 sectp
? bfd_section_name (abfd
, sectp
) : "<unknown>",
12672 objfile_name (dwarf2_per_objfile
->objfile
));
12675 result
.virtual_offset
= offset
;
12676 result
.size
= size
;
12680 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12681 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12682 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12683 This is for DWP version 2 files. */
12685 static struct dwo_unit
*
12686 create_dwo_unit_in_dwp_v2 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
12687 struct dwp_file
*dwp_file
,
12688 uint32_t unit_index
,
12689 const char *comp_dir
,
12690 ULONGEST signature
, int is_debug_types
)
12692 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
12693 const struct dwp_hash_table
*dwp_htab
=
12694 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12695 bfd
*dbfd
= dwp_file
->dbfd
;
12696 const char *kind
= is_debug_types
? "TU" : "CU";
12697 struct dwo_file
*dwo_file
;
12698 struct dwo_unit
*dwo_unit
;
12699 struct virtual_v2_dwo_sections sections
;
12700 void **dwo_file_slot
;
12703 gdb_assert (dwp_file
->version
== 2);
12705 if (dwarf_read_debug
)
12707 fprintf_unfiltered (gdb_stdlog
, "Reading %s %s/%s in DWP V2 file: %s\n",
12709 pulongest (unit_index
), hex_string (signature
),
12713 /* Fetch the section offsets of this DWO unit. */
12715 memset (§ions
, 0, sizeof (sections
));
12717 for (i
= 0; i
< dwp_htab
->nr_columns
; ++i
)
12719 uint32_t offset
= read_4_bytes (dbfd
,
12720 dwp_htab
->section_pool
.v2
.offsets
12721 + (((unit_index
- 1) * dwp_htab
->nr_columns
12723 * sizeof (uint32_t)));
12724 uint32_t size
= read_4_bytes (dbfd
,
12725 dwp_htab
->section_pool
.v2
.sizes
12726 + (((unit_index
- 1) * dwp_htab
->nr_columns
12728 * sizeof (uint32_t)));
12730 switch (dwp_htab
->section_pool
.v2
.section_ids
[i
])
12733 case DW_SECT_TYPES
:
12734 sections
.info_or_types_offset
= offset
;
12735 sections
.info_or_types_size
= size
;
12737 case DW_SECT_ABBREV
:
12738 sections
.abbrev_offset
= offset
;
12739 sections
.abbrev_size
= size
;
12742 sections
.line_offset
= offset
;
12743 sections
.line_size
= size
;
12746 sections
.loc_offset
= offset
;
12747 sections
.loc_size
= size
;
12749 case DW_SECT_STR_OFFSETS
:
12750 sections
.str_offsets_offset
= offset
;
12751 sections
.str_offsets_size
= size
;
12753 case DW_SECT_MACINFO
:
12754 sections
.macinfo_offset
= offset
;
12755 sections
.macinfo_size
= size
;
12757 case DW_SECT_MACRO
:
12758 sections
.macro_offset
= offset
;
12759 sections
.macro_size
= size
;
12764 /* It's easier for the rest of the code if we fake a struct dwo_file and
12765 have dwo_unit "live" in that. At least for now.
12767 The DWP file can be made up of a random collection of CUs and TUs.
12768 However, for each CU + set of TUs that came from the same original DWO
12769 file, we can combine them back into a virtual DWO file to save space
12770 (fewer struct dwo_file objects to allocate). Remember that for really
12771 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
12773 std::string virtual_dwo_name
=
12774 string_printf ("virtual-dwo/%ld-%ld-%ld-%ld",
12775 (long) (sections
.abbrev_size
? sections
.abbrev_offset
: 0),
12776 (long) (sections
.line_size
? sections
.line_offset
: 0),
12777 (long) (sections
.loc_size
? sections
.loc_offset
: 0),
12778 (long) (sections
.str_offsets_size
12779 ? sections
.str_offsets_offset
: 0));
12780 /* Can we use an existing virtual DWO file? */
12781 dwo_file_slot
= lookup_dwo_file_slot (dwarf2_per_objfile
,
12782 virtual_dwo_name
.c_str (),
12784 /* Create one if necessary. */
12785 if (*dwo_file_slot
== NULL
)
12787 if (dwarf_read_debug
)
12789 fprintf_unfiltered (gdb_stdlog
, "Creating virtual DWO: %s\n",
12790 virtual_dwo_name
.c_str ());
12792 dwo_file
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_file
);
12794 = (const char *) obstack_copy0 (&objfile
->objfile_obstack
,
12795 virtual_dwo_name
.c_str (),
12796 virtual_dwo_name
.size ());
12797 dwo_file
->comp_dir
= comp_dir
;
12798 dwo_file
->sections
.abbrev
=
12799 create_dwp_v2_section (dwarf2_per_objfile
, &dwp_file
->sections
.abbrev
,
12800 sections
.abbrev_offset
, sections
.abbrev_size
);
12801 dwo_file
->sections
.line
=
12802 create_dwp_v2_section (dwarf2_per_objfile
, &dwp_file
->sections
.line
,
12803 sections
.line_offset
, sections
.line_size
);
12804 dwo_file
->sections
.loc
=
12805 create_dwp_v2_section (dwarf2_per_objfile
, &dwp_file
->sections
.loc
,
12806 sections
.loc_offset
, sections
.loc_size
);
12807 dwo_file
->sections
.macinfo
=
12808 create_dwp_v2_section (dwarf2_per_objfile
, &dwp_file
->sections
.macinfo
,
12809 sections
.macinfo_offset
, sections
.macinfo_size
);
12810 dwo_file
->sections
.macro
=
12811 create_dwp_v2_section (dwarf2_per_objfile
, &dwp_file
->sections
.macro
,
12812 sections
.macro_offset
, sections
.macro_size
);
12813 dwo_file
->sections
.str_offsets
=
12814 create_dwp_v2_section (dwarf2_per_objfile
,
12815 &dwp_file
->sections
.str_offsets
,
12816 sections
.str_offsets_offset
,
12817 sections
.str_offsets_size
);
12818 /* The "str" section is global to the entire DWP file. */
12819 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
12820 /* The info or types section is assigned below to dwo_unit,
12821 there's no need to record it in dwo_file.
12822 Also, we can't simply record type sections in dwo_file because
12823 we record a pointer into the vector in dwo_unit. As we collect more
12824 types we'll grow the vector and eventually have to reallocate space
12825 for it, invalidating all copies of pointers into the previous
12827 *dwo_file_slot
= dwo_file
;
12831 if (dwarf_read_debug
)
12833 fprintf_unfiltered (gdb_stdlog
, "Using existing virtual DWO: %s\n",
12834 virtual_dwo_name
.c_str ());
12836 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
12839 dwo_unit
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_unit
);
12840 dwo_unit
->dwo_file
= dwo_file
;
12841 dwo_unit
->signature
= signature
;
12842 dwo_unit
->section
=
12843 XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_section_info
);
12844 *dwo_unit
->section
= create_dwp_v2_section (dwarf2_per_objfile
,
12846 ? &dwp_file
->sections
.types
12847 : &dwp_file
->sections
.info
,
12848 sections
.info_or_types_offset
,
12849 sections
.info_or_types_size
);
12850 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12855 /* Lookup the DWO unit with SIGNATURE in DWP_FILE.
12856 Returns NULL if the signature isn't found. */
12858 static struct dwo_unit
*
12859 lookup_dwo_unit_in_dwp (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
12860 struct dwp_file
*dwp_file
, const char *comp_dir
,
12861 ULONGEST signature
, int is_debug_types
)
12863 const struct dwp_hash_table
*dwp_htab
=
12864 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12865 bfd
*dbfd
= dwp_file
->dbfd
;
12866 uint32_t mask
= dwp_htab
->nr_slots
- 1;
12867 uint32_t hash
= signature
& mask
;
12868 uint32_t hash2
= ((signature
>> 32) & mask
) | 1;
12871 struct dwo_unit find_dwo_cu
;
12873 memset (&find_dwo_cu
, 0, sizeof (find_dwo_cu
));
12874 find_dwo_cu
.signature
= signature
;
12875 slot
= htab_find_slot (is_debug_types
12876 ? dwp_file
->loaded_tus
12877 : dwp_file
->loaded_cus
,
12878 &find_dwo_cu
, INSERT
);
12881 return (struct dwo_unit
*) *slot
;
12883 /* Use a for loop so that we don't loop forever on bad debug info. */
12884 for (i
= 0; i
< dwp_htab
->nr_slots
; ++i
)
12886 ULONGEST signature_in_table
;
12888 signature_in_table
=
12889 read_8_bytes (dbfd
, dwp_htab
->hash_table
+ hash
* sizeof (uint64_t));
12890 if (signature_in_table
== signature
)
12892 uint32_t unit_index
=
12893 read_4_bytes (dbfd
,
12894 dwp_htab
->unit_table
+ hash
* sizeof (uint32_t));
12896 if (dwp_file
->version
== 1)
12898 *slot
= create_dwo_unit_in_dwp_v1 (dwarf2_per_objfile
,
12899 dwp_file
, unit_index
,
12900 comp_dir
, signature
,
12905 *slot
= create_dwo_unit_in_dwp_v2 (dwarf2_per_objfile
,
12906 dwp_file
, unit_index
,
12907 comp_dir
, signature
,
12910 return (struct dwo_unit
*) *slot
;
12912 if (signature_in_table
== 0)
12914 hash
= (hash
+ hash2
) & mask
;
12917 error (_("Dwarf Error: bad DWP hash table, lookup didn't terminate"
12918 " [in module %s]"),
12922 /* Subroutine of open_dwo_file,open_dwp_file to simplify them.
12923 Open the file specified by FILE_NAME and hand it off to BFD for
12924 preliminary analysis. Return a newly initialized bfd *, which
12925 includes a canonicalized copy of FILE_NAME.
12926 If IS_DWP is TRUE, we're opening a DWP file, otherwise a DWO file.
12927 SEARCH_CWD is true if the current directory is to be searched.
12928 It will be searched before debug-file-directory.
12929 If successful, the file is added to the bfd include table of the
12930 objfile's bfd (see gdb_bfd_record_inclusion).
12931 If unable to find/open the file, return NULL.
12932 NOTE: This function is derived from symfile_bfd_open. */
12934 static gdb_bfd_ref_ptr
12935 try_open_dwop_file (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
12936 const char *file_name
, int is_dwp
, int search_cwd
)
12939 char *absolute_name
;
12940 /* Blech. OPF_TRY_CWD_FIRST also disables searching the path list if
12941 FILE_NAME contains a '/'. So we can't use it. Instead prepend "."
12942 to debug_file_directory. */
12944 static const char dirname_separator_string
[] = { DIRNAME_SEPARATOR
, '\0' };
12948 if (*debug_file_directory
!= '\0')
12949 search_path
= concat (".", dirname_separator_string
,
12950 debug_file_directory
, (char *) NULL
);
12952 search_path
= xstrdup (".");
12955 search_path
= xstrdup (debug_file_directory
);
12957 flags
= OPF_RETURN_REALPATH
;
12959 flags
|= OPF_SEARCH_IN_PATH
;
12960 desc
= openp (search_path
, flags
, file_name
,
12961 O_RDONLY
| O_BINARY
, &absolute_name
);
12962 xfree (search_path
);
12966 gdb_bfd_ref_ptr
sym_bfd (gdb_bfd_open (absolute_name
, gnutarget
, desc
));
12967 xfree (absolute_name
);
12968 if (sym_bfd
== NULL
)
12970 bfd_set_cacheable (sym_bfd
.get (), 1);
12972 if (!bfd_check_format (sym_bfd
.get (), bfd_object
))
12975 /* Success. Record the bfd as having been included by the objfile's bfd.
12976 This is important because things like demangled_names_hash lives in the
12977 objfile's per_bfd space and may have references to things like symbol
12978 names that live in the DWO/DWP file's per_bfd space. PR 16426. */
12979 gdb_bfd_record_inclusion (dwarf2_per_objfile
->objfile
->obfd
, sym_bfd
.get ());
12984 /* Try to open DWO file FILE_NAME.
12985 COMP_DIR is the DW_AT_comp_dir attribute.
12986 The result is the bfd handle of the file.
12987 If there is a problem finding or opening the file, return NULL.
12988 Upon success, the canonicalized path of the file is stored in the bfd,
12989 same as symfile_bfd_open. */
12991 static gdb_bfd_ref_ptr
12992 open_dwo_file (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
12993 const char *file_name
, const char *comp_dir
)
12995 if (IS_ABSOLUTE_PATH (file_name
))
12996 return try_open_dwop_file (dwarf2_per_objfile
, file_name
,
12997 0 /*is_dwp*/, 0 /*search_cwd*/);
12999 /* Before trying the search path, try DWO_NAME in COMP_DIR. */
13001 if (comp_dir
!= NULL
)
13003 char *path_to_try
= concat (comp_dir
, SLASH_STRING
,
13004 file_name
, (char *) NULL
);
13006 /* NOTE: If comp_dir is a relative path, this will also try the
13007 search path, which seems useful. */
13008 gdb_bfd_ref_ptr
abfd (try_open_dwop_file (dwarf2_per_objfile
,
13011 1 /*search_cwd*/));
13012 xfree (path_to_try
);
13017 /* That didn't work, try debug-file-directory, which, despite its name,
13018 is a list of paths. */
13020 if (*debug_file_directory
== '\0')
13023 return try_open_dwop_file (dwarf2_per_objfile
, file_name
,
13024 0 /*is_dwp*/, 1 /*search_cwd*/);
13027 /* This function is mapped across the sections and remembers the offset and
13028 size of each of the DWO debugging sections we are interested in. */
13031 dwarf2_locate_dwo_sections (bfd
*abfd
, asection
*sectp
, void *dwo_sections_ptr
)
13033 struct dwo_sections
*dwo_sections
= (struct dwo_sections
*) dwo_sections_ptr
;
13034 const struct dwop_section_names
*names
= &dwop_section_names
;
13036 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
13038 dwo_sections
->abbrev
.s
.section
= sectp
;
13039 dwo_sections
->abbrev
.size
= bfd_get_section_size (sectp
);
13041 else if (section_is_p (sectp
->name
, &names
->info_dwo
))
13043 dwo_sections
->info
.s
.section
= sectp
;
13044 dwo_sections
->info
.size
= bfd_get_section_size (sectp
);
13046 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
13048 dwo_sections
->line
.s
.section
= sectp
;
13049 dwo_sections
->line
.size
= bfd_get_section_size (sectp
);
13051 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
13053 dwo_sections
->loc
.s
.section
= sectp
;
13054 dwo_sections
->loc
.size
= bfd_get_section_size (sectp
);
13056 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
13058 dwo_sections
->macinfo
.s
.section
= sectp
;
13059 dwo_sections
->macinfo
.size
= bfd_get_section_size (sectp
);
13061 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
13063 dwo_sections
->macro
.s
.section
= sectp
;
13064 dwo_sections
->macro
.size
= bfd_get_section_size (sectp
);
13066 else if (section_is_p (sectp
->name
, &names
->str_dwo
))
13068 dwo_sections
->str
.s
.section
= sectp
;
13069 dwo_sections
->str
.size
= bfd_get_section_size (sectp
);
13071 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
13073 dwo_sections
->str_offsets
.s
.section
= sectp
;
13074 dwo_sections
->str_offsets
.size
= bfd_get_section_size (sectp
);
13076 else if (section_is_p (sectp
->name
, &names
->types_dwo
))
13078 struct dwarf2_section_info type_section
;
13080 memset (&type_section
, 0, sizeof (type_section
));
13081 type_section
.s
.section
= sectp
;
13082 type_section
.size
= bfd_get_section_size (sectp
);
13083 VEC_safe_push (dwarf2_section_info_def
, dwo_sections
->types
,
13088 /* Initialize the use of the DWO file specified by DWO_NAME and referenced
13089 by PER_CU. This is for the non-DWP case.
13090 The result is NULL if DWO_NAME can't be found. */
13092 static struct dwo_file
*
13093 open_and_init_dwo_file (struct dwarf2_per_cu_data
*per_cu
,
13094 const char *dwo_name
, const char *comp_dir
)
13096 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
13097 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
13098 struct dwo_file
*dwo_file
;
13099 struct cleanup
*cleanups
;
13101 gdb_bfd_ref_ptr
dbfd (open_dwo_file (dwarf2_per_objfile
, dwo_name
, comp_dir
));
13104 if (dwarf_read_debug
)
13105 fprintf_unfiltered (gdb_stdlog
, "DWO file not found: %s\n", dwo_name
);
13108 dwo_file
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_file
);
13109 dwo_file
->dwo_name
= dwo_name
;
13110 dwo_file
->comp_dir
= comp_dir
;
13111 dwo_file
->dbfd
= dbfd
.release ();
13113 free_dwo_file_cleanup_data
*cleanup_data
= XNEW (free_dwo_file_cleanup_data
);
13114 cleanup_data
->dwo_file
= dwo_file
;
13115 cleanup_data
->dwarf2_per_objfile
= dwarf2_per_objfile
;
13117 cleanups
= make_cleanup (free_dwo_file_cleanup
, cleanup_data
);
13119 bfd_map_over_sections (dwo_file
->dbfd
, dwarf2_locate_dwo_sections
,
13120 &dwo_file
->sections
);
13122 create_cus_hash_table (dwarf2_per_objfile
, *dwo_file
, dwo_file
->sections
.info
,
13125 create_debug_types_hash_table (dwarf2_per_objfile
, dwo_file
,
13126 dwo_file
->sections
.types
, dwo_file
->tus
);
13128 discard_cleanups (cleanups
);
13130 if (dwarf_read_debug
)
13131 fprintf_unfiltered (gdb_stdlog
, "DWO file found: %s\n", dwo_name
);
13136 /* This function is mapped across the sections and remembers the offset and
13137 size of each of the DWP debugging sections common to version 1 and 2 that
13138 we are interested in. */
13141 dwarf2_locate_common_dwp_sections (bfd
*abfd
, asection
*sectp
,
13142 void *dwp_file_ptr
)
13144 struct dwp_file
*dwp_file
= (struct dwp_file
*) dwp_file_ptr
;
13145 const struct dwop_section_names
*names
= &dwop_section_names
;
13146 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
13148 /* Record the ELF section number for later lookup: this is what the
13149 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
13150 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
13151 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
13153 /* Look for specific sections that we need. */
13154 if (section_is_p (sectp
->name
, &names
->str_dwo
))
13156 dwp_file
->sections
.str
.s
.section
= sectp
;
13157 dwp_file
->sections
.str
.size
= bfd_get_section_size (sectp
);
13159 else if (section_is_p (sectp
->name
, &names
->cu_index
))
13161 dwp_file
->sections
.cu_index
.s
.section
= sectp
;
13162 dwp_file
->sections
.cu_index
.size
= bfd_get_section_size (sectp
);
13164 else if (section_is_p (sectp
->name
, &names
->tu_index
))
13166 dwp_file
->sections
.tu_index
.s
.section
= sectp
;
13167 dwp_file
->sections
.tu_index
.size
= bfd_get_section_size (sectp
);
13171 /* This function is mapped across the sections and remembers the offset and
13172 size of each of the DWP version 2 debugging sections that we are interested
13173 in. This is split into a separate function because we don't know if we
13174 have version 1 or 2 until we parse the cu_index/tu_index sections. */
13177 dwarf2_locate_v2_dwp_sections (bfd
*abfd
, asection
*sectp
, void *dwp_file_ptr
)
13179 struct dwp_file
*dwp_file
= (struct dwp_file
*) dwp_file_ptr
;
13180 const struct dwop_section_names
*names
= &dwop_section_names
;
13181 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
13183 /* Record the ELF section number for later lookup: this is what the
13184 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
13185 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
13186 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
13188 /* Look for specific sections that we need. */
13189 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
13191 dwp_file
->sections
.abbrev
.s
.section
= sectp
;
13192 dwp_file
->sections
.abbrev
.size
= bfd_get_section_size (sectp
);
13194 else if (section_is_p (sectp
->name
, &names
->info_dwo
))
13196 dwp_file
->sections
.info
.s
.section
= sectp
;
13197 dwp_file
->sections
.info
.size
= bfd_get_section_size (sectp
);
13199 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
13201 dwp_file
->sections
.line
.s
.section
= sectp
;
13202 dwp_file
->sections
.line
.size
= bfd_get_section_size (sectp
);
13204 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
13206 dwp_file
->sections
.loc
.s
.section
= sectp
;
13207 dwp_file
->sections
.loc
.size
= bfd_get_section_size (sectp
);
13209 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
13211 dwp_file
->sections
.macinfo
.s
.section
= sectp
;
13212 dwp_file
->sections
.macinfo
.size
= bfd_get_section_size (sectp
);
13214 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
13216 dwp_file
->sections
.macro
.s
.section
= sectp
;
13217 dwp_file
->sections
.macro
.size
= bfd_get_section_size (sectp
);
13219 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
13221 dwp_file
->sections
.str_offsets
.s
.section
= sectp
;
13222 dwp_file
->sections
.str_offsets
.size
= bfd_get_section_size (sectp
);
13224 else if (section_is_p (sectp
->name
, &names
->types_dwo
))
13226 dwp_file
->sections
.types
.s
.section
= sectp
;
13227 dwp_file
->sections
.types
.size
= bfd_get_section_size (sectp
);
13231 /* Hash function for dwp_file loaded CUs/TUs. */
13234 hash_dwp_loaded_cutus (const void *item
)
13236 const struct dwo_unit
*dwo_unit
= (const struct dwo_unit
*) item
;
13238 /* This drops the top 32 bits of the signature, but is ok for a hash. */
13239 return dwo_unit
->signature
;
13242 /* Equality function for dwp_file loaded CUs/TUs. */
13245 eq_dwp_loaded_cutus (const void *a
, const void *b
)
13247 const struct dwo_unit
*dua
= (const struct dwo_unit
*) a
;
13248 const struct dwo_unit
*dub
= (const struct dwo_unit
*) b
;
13250 return dua
->signature
== dub
->signature
;
13253 /* Allocate a hash table for dwp_file loaded CUs/TUs. */
13256 allocate_dwp_loaded_cutus_table (struct objfile
*objfile
)
13258 return htab_create_alloc_ex (3,
13259 hash_dwp_loaded_cutus
,
13260 eq_dwp_loaded_cutus
,
13262 &objfile
->objfile_obstack
,
13263 hashtab_obstack_allocate
,
13264 dummy_obstack_deallocate
);
13267 /* Try to open DWP file FILE_NAME.
13268 The result is the bfd handle of the file.
13269 If there is a problem finding or opening the file, return NULL.
13270 Upon success, the canonicalized path of the file is stored in the bfd,
13271 same as symfile_bfd_open. */
13273 static gdb_bfd_ref_ptr
13274 open_dwp_file (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
13275 const char *file_name
)
13277 gdb_bfd_ref_ptr
abfd (try_open_dwop_file (dwarf2_per_objfile
, file_name
,
13279 1 /*search_cwd*/));
13283 /* Work around upstream bug 15652.
13284 http://sourceware.org/bugzilla/show_bug.cgi?id=15652
13285 [Whether that's a "bug" is debatable, but it is getting in our way.]
13286 We have no real idea where the dwp file is, because gdb's realpath-ing
13287 of the executable's path may have discarded the needed info.
13288 [IWBN if the dwp file name was recorded in the executable, akin to
13289 .gnu_debuglink, but that doesn't exist yet.]
13290 Strip the directory from FILE_NAME and search again. */
13291 if (*debug_file_directory
!= '\0')
13293 /* Don't implicitly search the current directory here.
13294 If the user wants to search "." to handle this case,
13295 it must be added to debug-file-directory. */
13296 return try_open_dwop_file (dwarf2_per_objfile
,
13297 lbasename (file_name
), 1 /*is_dwp*/,
13304 /* Initialize the use of the DWP file for the current objfile.
13305 By convention the name of the DWP file is ${objfile}.dwp.
13306 The result is NULL if it can't be found. */
13308 static struct dwp_file
*
13309 open_and_init_dwp_file (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
13311 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
13312 struct dwp_file
*dwp_file
;
13314 /* Try to find first .dwp for the binary file before any symbolic links
13317 /* If the objfile is a debug file, find the name of the real binary
13318 file and get the name of dwp file from there. */
13319 std::string dwp_name
;
13320 if (objfile
->separate_debug_objfile_backlink
!= NULL
)
13322 struct objfile
*backlink
= objfile
->separate_debug_objfile_backlink
;
13323 const char *backlink_basename
= lbasename (backlink
->original_name
);
13325 dwp_name
= ldirname (objfile
->original_name
) + SLASH_STRING
+ backlink_basename
;
13328 dwp_name
= objfile
->original_name
;
13330 dwp_name
+= ".dwp";
13332 gdb_bfd_ref_ptr
dbfd (open_dwp_file (dwarf2_per_objfile
, dwp_name
.c_str ()));
13334 && strcmp (objfile
->original_name
, objfile_name (objfile
)) != 0)
13336 /* Try to find .dwp for the binary file after gdb_realpath resolving. */
13337 dwp_name
= objfile_name (objfile
);
13338 dwp_name
+= ".dwp";
13339 dbfd
= open_dwp_file (dwarf2_per_objfile
, dwp_name
.c_str ());
13344 if (dwarf_read_debug
)
13345 fprintf_unfiltered (gdb_stdlog
, "DWP file not found: %s\n", dwp_name
.c_str ());
13348 dwp_file
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwp_file
);
13349 dwp_file
->name
= bfd_get_filename (dbfd
.get ());
13350 dwp_file
->dbfd
= dbfd
.release ();
13352 /* +1: section 0 is unused */
13353 dwp_file
->num_sections
= bfd_count_sections (dwp_file
->dbfd
) + 1;
13354 dwp_file
->elf_sections
=
13355 OBSTACK_CALLOC (&objfile
->objfile_obstack
,
13356 dwp_file
->num_sections
, asection
*);
13358 bfd_map_over_sections (dwp_file
->dbfd
, dwarf2_locate_common_dwp_sections
,
13361 dwp_file
->cus
= create_dwp_hash_table (dwarf2_per_objfile
, dwp_file
, 0);
13363 dwp_file
->tus
= create_dwp_hash_table (dwarf2_per_objfile
, dwp_file
, 1);
13365 /* The DWP file version is stored in the hash table. Oh well. */
13366 if (dwp_file
->cus
&& dwp_file
->tus
13367 && dwp_file
->cus
->version
!= dwp_file
->tus
->version
)
13369 /* Technically speaking, we should try to limp along, but this is
13370 pretty bizarre. We use pulongest here because that's the established
13371 portability solution (e.g, we cannot use %u for uint32_t). */
13372 error (_("Dwarf Error: DWP file CU version %s doesn't match"
13373 " TU version %s [in DWP file %s]"),
13374 pulongest (dwp_file
->cus
->version
),
13375 pulongest (dwp_file
->tus
->version
), dwp_name
.c_str ());
13379 dwp_file
->version
= dwp_file
->cus
->version
;
13380 else if (dwp_file
->tus
)
13381 dwp_file
->version
= dwp_file
->tus
->version
;
13383 dwp_file
->version
= 2;
13385 if (dwp_file
->version
== 2)
13386 bfd_map_over_sections (dwp_file
->dbfd
, dwarf2_locate_v2_dwp_sections
,
13389 dwp_file
->loaded_cus
= allocate_dwp_loaded_cutus_table (objfile
);
13390 dwp_file
->loaded_tus
= allocate_dwp_loaded_cutus_table (objfile
);
13392 if (dwarf_read_debug
)
13394 fprintf_unfiltered (gdb_stdlog
, "DWP file found: %s\n", dwp_file
->name
);
13395 fprintf_unfiltered (gdb_stdlog
,
13396 " %s CUs, %s TUs\n",
13397 pulongest (dwp_file
->cus
? dwp_file
->cus
->nr_units
: 0),
13398 pulongest (dwp_file
->tus
? dwp_file
->tus
->nr_units
: 0));
13404 /* Wrapper around open_and_init_dwp_file, only open it once. */
13406 static struct dwp_file
*
13407 get_dwp_file (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
13409 if (! dwarf2_per_objfile
->dwp_checked
)
13411 dwarf2_per_objfile
->dwp_file
13412 = open_and_init_dwp_file (dwarf2_per_objfile
);
13413 dwarf2_per_objfile
->dwp_checked
= 1;
13415 return dwarf2_per_objfile
->dwp_file
;
13418 /* Subroutine of lookup_dwo_comp_unit, lookup_dwo_type_unit.
13419 Look up the CU/TU with signature SIGNATURE, either in DWO file DWO_NAME
13420 or in the DWP file for the objfile, referenced by THIS_UNIT.
13421 If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
13422 IS_DEBUG_TYPES is non-zero if reading a TU, otherwise read a CU.
13424 This is called, for example, when wanting to read a variable with a
13425 complex location. Therefore we don't want to do file i/o for every call.
13426 Therefore we don't want to look for a DWO file on every call.
13427 Therefore we first see if we've already seen SIGNATURE in a DWP file,
13428 then we check if we've already seen DWO_NAME, and only THEN do we check
13431 The result is a pointer to the dwo_unit object or NULL if we didn't find it
13432 (dwo_id mismatch or couldn't find the DWO/DWP file). */
13434 static struct dwo_unit
*
13435 lookup_dwo_cutu (struct dwarf2_per_cu_data
*this_unit
,
13436 const char *dwo_name
, const char *comp_dir
,
13437 ULONGEST signature
, int is_debug_types
)
13439 struct dwarf2_per_objfile
*dwarf2_per_objfile
= this_unit
->dwarf2_per_objfile
;
13440 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
13441 const char *kind
= is_debug_types
? "TU" : "CU";
13442 void **dwo_file_slot
;
13443 struct dwo_file
*dwo_file
;
13444 struct dwp_file
*dwp_file
;
13446 /* First see if there's a DWP file.
13447 If we have a DWP file but didn't find the DWO inside it, don't
13448 look for the original DWO file. It makes gdb behave differently
13449 depending on whether one is debugging in the build tree. */
13451 dwp_file
= get_dwp_file (dwarf2_per_objfile
);
13452 if (dwp_file
!= NULL
)
13454 const struct dwp_hash_table
*dwp_htab
=
13455 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
13457 if (dwp_htab
!= NULL
)
13459 struct dwo_unit
*dwo_cutu
=
13460 lookup_dwo_unit_in_dwp (dwarf2_per_objfile
, dwp_file
, comp_dir
,
13461 signature
, is_debug_types
);
13463 if (dwo_cutu
!= NULL
)
13465 if (dwarf_read_debug
)
13467 fprintf_unfiltered (gdb_stdlog
,
13468 "Virtual DWO %s %s found: @%s\n",
13469 kind
, hex_string (signature
),
13470 host_address_to_string (dwo_cutu
));
13478 /* No DWP file, look for the DWO file. */
13480 dwo_file_slot
= lookup_dwo_file_slot (dwarf2_per_objfile
,
13481 dwo_name
, comp_dir
);
13482 if (*dwo_file_slot
== NULL
)
13484 /* Read in the file and build a table of the CUs/TUs it contains. */
13485 *dwo_file_slot
= open_and_init_dwo_file (this_unit
, dwo_name
, comp_dir
);
13487 /* NOTE: This will be NULL if unable to open the file. */
13488 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
13490 if (dwo_file
!= NULL
)
13492 struct dwo_unit
*dwo_cutu
= NULL
;
13494 if (is_debug_types
&& dwo_file
->tus
)
13496 struct dwo_unit find_dwo_cutu
;
13498 memset (&find_dwo_cutu
, 0, sizeof (find_dwo_cutu
));
13499 find_dwo_cutu
.signature
= signature
;
13501 = (struct dwo_unit
*) htab_find (dwo_file
->tus
, &find_dwo_cutu
);
13503 else if (!is_debug_types
&& dwo_file
->cus
)
13505 struct dwo_unit find_dwo_cutu
;
13507 memset (&find_dwo_cutu
, 0, sizeof (find_dwo_cutu
));
13508 find_dwo_cutu
.signature
= signature
;
13509 dwo_cutu
= (struct dwo_unit
*)htab_find (dwo_file
->cus
,
13513 if (dwo_cutu
!= NULL
)
13515 if (dwarf_read_debug
)
13517 fprintf_unfiltered (gdb_stdlog
, "DWO %s %s(%s) found: @%s\n",
13518 kind
, dwo_name
, hex_string (signature
),
13519 host_address_to_string (dwo_cutu
));
13526 /* We didn't find it. This could mean a dwo_id mismatch, or
13527 someone deleted the DWO/DWP file, or the search path isn't set up
13528 correctly to find the file. */
13530 if (dwarf_read_debug
)
13532 fprintf_unfiltered (gdb_stdlog
, "DWO %s %s(%s) not found\n",
13533 kind
, dwo_name
, hex_string (signature
));
13536 /* This is a warning and not a complaint because it can be caused by
13537 pilot error (e.g., user accidentally deleting the DWO). */
13539 /* Print the name of the DWP file if we looked there, helps the user
13540 better diagnose the problem. */
13541 std::string dwp_text
;
13543 if (dwp_file
!= NULL
)
13544 dwp_text
= string_printf (" [in DWP file %s]",
13545 lbasename (dwp_file
->name
));
13547 warning (_("Could not find DWO %s %s(%s)%s referenced by %s at offset 0x%x"
13548 " [in module %s]"),
13549 kind
, dwo_name
, hex_string (signature
),
13551 this_unit
->is_debug_types
? "TU" : "CU",
13552 to_underlying (this_unit
->sect_off
), objfile_name (objfile
));
13557 /* Lookup the DWO CU DWO_NAME/SIGNATURE referenced from THIS_CU.
13558 See lookup_dwo_cutu_unit for details. */
13560 static struct dwo_unit
*
13561 lookup_dwo_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
13562 const char *dwo_name
, const char *comp_dir
,
13563 ULONGEST signature
)
13565 return lookup_dwo_cutu (this_cu
, dwo_name
, comp_dir
, signature
, 0);
13568 /* Lookup the DWO TU DWO_NAME/SIGNATURE referenced from THIS_TU.
13569 See lookup_dwo_cutu_unit for details. */
13571 static struct dwo_unit
*
13572 lookup_dwo_type_unit (struct signatured_type
*this_tu
,
13573 const char *dwo_name
, const char *comp_dir
)
13575 return lookup_dwo_cutu (&this_tu
->per_cu
, dwo_name
, comp_dir
, this_tu
->signature
, 1);
13578 /* Traversal function for queue_and_load_all_dwo_tus. */
13581 queue_and_load_dwo_tu (void **slot
, void *info
)
13583 struct dwo_unit
*dwo_unit
= (struct dwo_unit
*) *slot
;
13584 struct dwarf2_per_cu_data
*per_cu
= (struct dwarf2_per_cu_data
*) info
;
13585 ULONGEST signature
= dwo_unit
->signature
;
13586 struct signatured_type
*sig_type
=
13587 lookup_dwo_signatured_type (per_cu
->cu
, signature
);
13589 if (sig_type
!= NULL
)
13591 struct dwarf2_per_cu_data
*sig_cu
= &sig_type
->per_cu
;
13593 /* We pass NULL for DEPENDENT_CU because we don't yet know if there's
13594 a real dependency of PER_CU on SIG_TYPE. That is detected later
13595 while processing PER_CU. */
13596 if (maybe_queue_comp_unit (NULL
, sig_cu
, per_cu
->cu
->language
))
13597 load_full_type_unit (sig_cu
);
13598 VEC_safe_push (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
, sig_cu
);
13604 /* Queue all TUs contained in the DWO of PER_CU to be read in.
13605 The DWO may have the only definition of the type, though it may not be
13606 referenced anywhere in PER_CU. Thus we have to load *all* its TUs.
13607 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
13610 queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data
*per_cu
)
13612 struct dwo_unit
*dwo_unit
;
13613 struct dwo_file
*dwo_file
;
13615 gdb_assert (!per_cu
->is_debug_types
);
13616 gdb_assert (get_dwp_file (per_cu
->dwarf2_per_objfile
) == NULL
);
13617 gdb_assert (per_cu
->cu
!= NULL
);
13619 dwo_unit
= per_cu
->cu
->dwo_unit
;
13620 gdb_assert (dwo_unit
!= NULL
);
13622 dwo_file
= dwo_unit
->dwo_file
;
13623 if (dwo_file
->tus
!= NULL
)
13624 htab_traverse_noresize (dwo_file
->tus
, queue_and_load_dwo_tu
, per_cu
);
13627 /* Free all resources associated with DWO_FILE.
13628 Close the DWO file and munmap the sections.
13629 All memory should be on the objfile obstack. */
13632 free_dwo_file (struct dwo_file
*dwo_file
, struct objfile
*objfile
)
13635 /* Note: dbfd is NULL for virtual DWO files. */
13636 gdb_bfd_unref (dwo_file
->dbfd
);
13638 VEC_free (dwarf2_section_info_def
, dwo_file
->sections
.types
);
13641 /* Wrapper for free_dwo_file for use in cleanups. */
13644 free_dwo_file_cleanup (void *arg
)
13646 struct free_dwo_file_cleanup_data
*data
13647 = (struct free_dwo_file_cleanup_data
*) arg
;
13648 struct objfile
*objfile
= data
->dwarf2_per_objfile
->objfile
;
13650 free_dwo_file (data
->dwo_file
, objfile
);
13655 /* Traversal function for free_dwo_files. */
13658 free_dwo_file_from_slot (void **slot
, void *info
)
13660 struct dwo_file
*dwo_file
= (struct dwo_file
*) *slot
;
13661 struct objfile
*objfile
= (struct objfile
*) info
;
13663 free_dwo_file (dwo_file
, objfile
);
13668 /* Free all resources associated with DWO_FILES. */
13671 free_dwo_files (htab_t dwo_files
, struct objfile
*objfile
)
13673 htab_traverse_noresize (dwo_files
, free_dwo_file_from_slot
, objfile
);
13676 /* Read in various DIEs. */
13678 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
13679 Inherit only the children of the DW_AT_abstract_origin DIE not being
13680 already referenced by DW_AT_abstract_origin from the children of the
13684 inherit_abstract_dies (struct die_info
*die
, struct dwarf2_cu
*cu
)
13686 struct die_info
*child_die
;
13687 sect_offset
*offsetp
;
13688 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
13689 struct die_info
*origin_die
;
13690 /* Iterator of the ORIGIN_DIE children. */
13691 struct die_info
*origin_child_die
;
13692 struct attribute
*attr
;
13693 struct dwarf2_cu
*origin_cu
;
13694 struct pending
**origin_previous_list_in_scope
;
13696 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
13700 /* Note that following die references may follow to a die in a
13704 origin_die
= follow_die_ref (die
, attr
, &origin_cu
);
13706 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
13708 origin_previous_list_in_scope
= origin_cu
->list_in_scope
;
13709 origin_cu
->list_in_scope
= cu
->list_in_scope
;
13711 if (die
->tag
!= origin_die
->tag
13712 && !(die
->tag
== DW_TAG_inlined_subroutine
13713 && origin_die
->tag
== DW_TAG_subprogram
))
13714 complaint (&symfile_complaints
,
13715 _("DIE 0x%x and its abstract origin 0x%x have different tags"),
13716 to_underlying (die
->sect_off
),
13717 to_underlying (origin_die
->sect_off
));
13719 std::vector
<sect_offset
> offsets
;
13721 for (child_die
= die
->child
;
13722 child_die
&& child_die
->tag
;
13723 child_die
= sibling_die (child_die
))
13725 struct die_info
*child_origin_die
;
13726 struct dwarf2_cu
*child_origin_cu
;
13728 /* We are trying to process concrete instance entries:
13729 DW_TAG_call_site DIEs indeed have a DW_AT_abstract_origin tag, but
13730 it's not relevant to our analysis here. i.e. detecting DIEs that are
13731 present in the abstract instance but not referenced in the concrete
13733 if (child_die
->tag
== DW_TAG_call_site
13734 || child_die
->tag
== DW_TAG_GNU_call_site
)
13737 /* For each CHILD_DIE, find the corresponding child of
13738 ORIGIN_DIE. If there is more than one layer of
13739 DW_AT_abstract_origin, follow them all; there shouldn't be,
13740 but GCC versions at least through 4.4 generate this (GCC PR
13742 child_origin_die
= child_die
;
13743 child_origin_cu
= cu
;
13746 attr
= dwarf2_attr (child_origin_die
, DW_AT_abstract_origin
,
13750 child_origin_die
= follow_die_ref (child_origin_die
, attr
,
13754 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
13755 counterpart may exist. */
13756 if (child_origin_die
!= child_die
)
13758 if (child_die
->tag
!= child_origin_die
->tag
13759 && !(child_die
->tag
== DW_TAG_inlined_subroutine
13760 && child_origin_die
->tag
== DW_TAG_subprogram
))
13761 complaint (&symfile_complaints
,
13762 _("Child DIE 0x%x and its abstract origin 0x%x have "
13764 to_underlying (child_die
->sect_off
),
13765 to_underlying (child_origin_die
->sect_off
));
13766 if (child_origin_die
->parent
!= origin_die
)
13767 complaint (&symfile_complaints
,
13768 _("Child DIE 0x%x and its abstract origin 0x%x have "
13769 "different parents"),
13770 to_underlying (child_die
->sect_off
),
13771 to_underlying (child_origin_die
->sect_off
));
13773 offsets
.push_back (child_origin_die
->sect_off
);
13776 std::sort (offsets
.begin (), offsets
.end ());
13777 sect_offset
*offsets_end
= offsets
.data () + offsets
.size ();
13778 for (offsetp
= offsets
.data () + 1; offsetp
< offsets_end
; offsetp
++)
13779 if (offsetp
[-1] == *offsetp
)
13780 complaint (&symfile_complaints
,
13781 _("Multiple children of DIE 0x%x refer "
13782 "to DIE 0x%x as their abstract origin"),
13783 to_underlying (die
->sect_off
), to_underlying (*offsetp
));
13785 offsetp
= offsets
.data ();
13786 origin_child_die
= origin_die
->child
;
13787 while (origin_child_die
&& origin_child_die
->tag
)
13789 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
13790 while (offsetp
< offsets_end
13791 && *offsetp
< origin_child_die
->sect_off
)
13793 if (offsetp
>= offsets_end
13794 || *offsetp
> origin_child_die
->sect_off
)
13796 /* Found that ORIGIN_CHILD_DIE is really not referenced.
13797 Check whether we're already processing ORIGIN_CHILD_DIE.
13798 This can happen with mutually referenced abstract_origins.
13800 if (!origin_child_die
->in_process
)
13801 process_die (origin_child_die
, origin_cu
);
13803 origin_child_die
= sibling_die (origin_child_die
);
13805 origin_cu
->list_in_scope
= origin_previous_list_in_scope
;
13809 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13811 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
13812 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
13813 struct context_stack
*newobj
;
13816 struct die_info
*child_die
;
13817 struct attribute
*attr
, *call_line
, *call_file
;
13819 CORE_ADDR baseaddr
;
13820 struct block
*block
;
13821 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
13822 std::vector
<struct symbol
*> template_args
;
13823 struct template_symbol
*templ_func
= NULL
;
13827 /* If we do not have call site information, we can't show the
13828 caller of this inlined function. That's too confusing, so
13829 only use the scope for local variables. */
13830 call_line
= dwarf2_attr (die
, DW_AT_call_line
, cu
);
13831 call_file
= dwarf2_attr (die
, DW_AT_call_file
, cu
);
13832 if (call_line
== NULL
|| call_file
== NULL
)
13834 read_lexical_block_scope (die
, cu
);
13839 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
13841 name
= dwarf2_name (die
, cu
);
13843 /* Ignore functions with missing or empty names. These are actually
13844 illegal according to the DWARF standard. */
13847 complaint (&symfile_complaints
,
13848 _("missing name for subprogram DIE at %d"),
13849 to_underlying (die
->sect_off
));
13853 /* Ignore functions with missing or invalid low and high pc attributes. */
13854 if (dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
)
13855 <= PC_BOUNDS_INVALID
)
13857 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
13858 if (!attr
|| !DW_UNSND (attr
))
13859 complaint (&symfile_complaints
,
13860 _("cannot get low and high bounds "
13861 "for subprogram DIE at %d"),
13862 to_underlying (die
->sect_off
));
13866 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
13867 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
13869 /* If we have any template arguments, then we must allocate a
13870 different sort of symbol. */
13871 for (child_die
= die
->child
; child_die
; child_die
= sibling_die (child_die
))
13873 if (child_die
->tag
== DW_TAG_template_type_param
13874 || child_die
->tag
== DW_TAG_template_value_param
)
13876 templ_func
= allocate_template_symbol (objfile
);
13877 templ_func
->subclass
= SYMBOL_TEMPLATE
;
13882 newobj
= push_context (0, lowpc
);
13883 newobj
->name
= new_symbol_full (die
, read_type_die (die
, cu
), cu
,
13884 (struct symbol
*) templ_func
);
13886 /* If there is a location expression for DW_AT_frame_base, record
13888 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
13890 dwarf2_symbol_mark_computed (attr
, newobj
->name
, cu
, 1);
13892 /* If there is a location for the static link, record it. */
13893 newobj
->static_link
= NULL
;
13894 attr
= dwarf2_attr (die
, DW_AT_static_link
, cu
);
13897 newobj
->static_link
13898 = XOBNEW (&objfile
->objfile_obstack
, struct dynamic_prop
);
13899 attr_to_dynamic_prop (attr
, die
, cu
, newobj
->static_link
);
13902 cu
->list_in_scope
= &local_symbols
;
13904 if (die
->child
!= NULL
)
13906 child_die
= die
->child
;
13907 while (child_die
&& child_die
->tag
)
13909 if (child_die
->tag
== DW_TAG_template_type_param
13910 || child_die
->tag
== DW_TAG_template_value_param
)
13912 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
13915 template_args
.push_back (arg
);
13918 process_die (child_die
, cu
);
13919 child_die
= sibling_die (child_die
);
13923 inherit_abstract_dies (die
, cu
);
13925 /* If we have a DW_AT_specification, we might need to import using
13926 directives from the context of the specification DIE. See the
13927 comment in determine_prefix. */
13928 if (cu
->language
== language_cplus
13929 && dwarf2_attr (die
, DW_AT_specification
, cu
))
13931 struct dwarf2_cu
*spec_cu
= cu
;
13932 struct die_info
*spec_die
= die_specification (die
, &spec_cu
);
13936 child_die
= spec_die
->child
;
13937 while (child_die
&& child_die
->tag
)
13939 if (child_die
->tag
== DW_TAG_imported_module
)
13940 process_die (child_die
, spec_cu
);
13941 child_die
= sibling_die (child_die
);
13944 /* In some cases, GCC generates specification DIEs that
13945 themselves contain DW_AT_specification attributes. */
13946 spec_die
= die_specification (spec_die
, &spec_cu
);
13950 newobj
= pop_context ();
13951 /* Make a block for the local symbols within. */
13952 block
= finish_block (newobj
->name
, &local_symbols
, newobj
->old_blocks
,
13953 newobj
->static_link
, lowpc
, highpc
);
13955 /* For C++, set the block's scope. */
13956 if ((cu
->language
== language_cplus
13957 || cu
->language
== language_fortran
13958 || cu
->language
== language_d
13959 || cu
->language
== language_rust
)
13960 && cu
->processing_has_namespace_info
)
13961 block_set_scope (block
, determine_prefix (die
, cu
),
13962 &objfile
->objfile_obstack
);
13964 /* If we have address ranges, record them. */
13965 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
13967 gdbarch_make_symbol_special (gdbarch
, newobj
->name
, objfile
);
13969 /* Attach template arguments to function. */
13970 if (!template_args
.empty ())
13972 gdb_assert (templ_func
!= NULL
);
13974 templ_func
->n_template_arguments
= template_args
.size ();
13975 templ_func
->template_arguments
13976 = XOBNEWVEC (&objfile
->objfile_obstack
, struct symbol
*,
13977 templ_func
->n_template_arguments
);
13978 memcpy (templ_func
->template_arguments
,
13979 template_args
.data (),
13980 (templ_func
->n_template_arguments
* sizeof (struct symbol
*)));
13983 /* In C++, we can have functions nested inside functions (e.g., when
13984 a function declares a class that has methods). This means that
13985 when we finish processing a function scope, we may need to go
13986 back to building a containing block's symbol lists. */
13987 local_symbols
= newobj
->locals
;
13988 local_using_directives
= newobj
->local_using_directives
;
13990 /* If we've finished processing a top-level function, subsequent
13991 symbols go in the file symbol list. */
13992 if (outermost_context_p ())
13993 cu
->list_in_scope
= &file_symbols
;
13996 /* Process all the DIES contained within a lexical block scope. Start
13997 a new scope, process the dies, and then close the scope. */
14000 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
14002 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
14003 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
14004 struct context_stack
*newobj
;
14005 CORE_ADDR lowpc
, highpc
;
14006 struct die_info
*child_die
;
14007 CORE_ADDR baseaddr
;
14009 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
14011 /* Ignore blocks with missing or invalid low and high pc attributes. */
14012 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
14013 as multiple lexical blocks? Handling children in a sane way would
14014 be nasty. Might be easier to properly extend generic blocks to
14015 describe ranges. */
14016 switch (dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
14018 case PC_BOUNDS_NOT_PRESENT
:
14019 /* DW_TAG_lexical_block has no attributes, process its children as if
14020 there was no wrapping by that DW_TAG_lexical_block.
14021 GCC does no longer produces such DWARF since GCC r224161. */
14022 for (child_die
= die
->child
;
14023 child_die
!= NULL
&& child_die
->tag
;
14024 child_die
= sibling_die (child_die
))
14025 process_die (child_die
, cu
);
14027 case PC_BOUNDS_INVALID
:
14030 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
14031 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
14033 push_context (0, lowpc
);
14034 if (die
->child
!= NULL
)
14036 child_die
= die
->child
;
14037 while (child_die
&& child_die
->tag
)
14039 process_die (child_die
, cu
);
14040 child_die
= sibling_die (child_die
);
14043 inherit_abstract_dies (die
, cu
);
14044 newobj
= pop_context ();
14046 if (local_symbols
!= NULL
|| local_using_directives
!= NULL
)
14048 struct block
*block
14049 = finish_block (0, &local_symbols
, newobj
->old_blocks
, NULL
,
14050 newobj
->start_addr
, highpc
);
14052 /* Note that recording ranges after traversing children, as we
14053 do here, means that recording a parent's ranges entails
14054 walking across all its children's ranges as they appear in
14055 the address map, which is quadratic behavior.
14057 It would be nicer to record the parent's ranges before
14058 traversing its children, simply overriding whatever you find
14059 there. But since we don't even decide whether to create a
14060 block until after we've traversed its children, that's hard
14062 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
14064 local_symbols
= newobj
->locals
;
14065 local_using_directives
= newobj
->local_using_directives
;
14068 /* Read in DW_TAG_call_site and insert it to CU->call_site_htab. */
14071 read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
14073 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
14074 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
14075 CORE_ADDR pc
, baseaddr
;
14076 struct attribute
*attr
;
14077 struct call_site
*call_site
, call_site_local
;
14080 struct die_info
*child_die
;
14082 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
14084 attr
= dwarf2_attr (die
, DW_AT_call_return_pc
, cu
);
14087 /* This was a pre-DWARF-5 GNU extension alias
14088 for DW_AT_call_return_pc. */
14089 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
14093 complaint (&symfile_complaints
,
14094 _("missing DW_AT_call_return_pc for DW_TAG_call_site "
14095 "DIE 0x%x [in module %s]"),
14096 to_underlying (die
->sect_off
), objfile_name (objfile
));
14099 pc
= attr_value_as_address (attr
) + baseaddr
;
14100 pc
= gdbarch_adjust_dwarf2_addr (gdbarch
, pc
);
14102 if (cu
->call_site_htab
== NULL
)
14103 cu
->call_site_htab
= htab_create_alloc_ex (16, core_addr_hash
, core_addr_eq
,
14104 NULL
, &objfile
->objfile_obstack
,
14105 hashtab_obstack_allocate
, NULL
);
14106 call_site_local
.pc
= pc
;
14107 slot
= htab_find_slot (cu
->call_site_htab
, &call_site_local
, INSERT
);
14110 complaint (&symfile_complaints
,
14111 _("Duplicate PC %s for DW_TAG_call_site "
14112 "DIE 0x%x [in module %s]"),
14113 paddress (gdbarch
, pc
), to_underlying (die
->sect_off
),
14114 objfile_name (objfile
));
14118 /* Count parameters at the caller. */
14121 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
14122 child_die
= sibling_die (child_die
))
14124 if (child_die
->tag
!= DW_TAG_call_site_parameter
14125 && child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
14127 complaint (&symfile_complaints
,
14128 _("Tag %d is not DW_TAG_call_site_parameter in "
14129 "DW_TAG_call_site child DIE 0x%x [in module %s]"),
14130 child_die
->tag
, to_underlying (child_die
->sect_off
),
14131 objfile_name (objfile
));
14139 = ((struct call_site
*)
14140 obstack_alloc (&objfile
->objfile_obstack
,
14141 sizeof (*call_site
)
14142 + (sizeof (*call_site
->parameter
) * (nparams
- 1))));
14144 memset (call_site
, 0, sizeof (*call_site
) - sizeof (*call_site
->parameter
));
14145 call_site
->pc
= pc
;
14147 if (dwarf2_flag_true_p (die
, DW_AT_call_tail_call
, cu
)
14148 || dwarf2_flag_true_p (die
, DW_AT_GNU_tail_call
, cu
))
14150 struct die_info
*func_die
;
14152 /* Skip also over DW_TAG_inlined_subroutine. */
14153 for (func_die
= die
->parent
;
14154 func_die
&& func_die
->tag
!= DW_TAG_subprogram
14155 && func_die
->tag
!= DW_TAG_subroutine_type
;
14156 func_die
= func_die
->parent
);
14158 /* DW_AT_call_all_calls is a superset
14159 of DW_AT_call_all_tail_calls. */
14161 && !dwarf2_flag_true_p (func_die
, DW_AT_call_all_calls
, cu
)
14162 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_call_sites
, cu
)
14163 && !dwarf2_flag_true_p (func_die
, DW_AT_call_all_tail_calls
, cu
)
14164 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_tail_call_sites
, cu
))
14166 /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
14167 not complete. But keep CALL_SITE for look ups via call_site_htab,
14168 both the initial caller containing the real return address PC and
14169 the final callee containing the current PC of a chain of tail
14170 calls do not need to have the tail call list complete. But any
14171 function candidate for a virtual tail call frame searched via
14172 TYPE_TAIL_CALL_LIST must have the tail call list complete to be
14173 determined unambiguously. */
14177 struct type
*func_type
= NULL
;
14180 func_type
= get_die_type (func_die
, cu
);
14181 if (func_type
!= NULL
)
14183 gdb_assert (TYPE_CODE (func_type
) == TYPE_CODE_FUNC
);
14185 /* Enlist this call site to the function. */
14186 call_site
->tail_call_next
= TYPE_TAIL_CALL_LIST (func_type
);
14187 TYPE_TAIL_CALL_LIST (func_type
) = call_site
;
14190 complaint (&symfile_complaints
,
14191 _("Cannot find function owning DW_TAG_call_site "
14192 "DIE 0x%x [in module %s]"),
14193 to_underlying (die
->sect_off
), objfile_name (objfile
));
14197 attr
= dwarf2_attr (die
, DW_AT_call_target
, cu
);
14199 attr
= dwarf2_attr (die
, DW_AT_GNU_call_site_target
, cu
);
14201 attr
= dwarf2_attr (die
, DW_AT_call_origin
, cu
);
14204 /* This was a pre-DWARF-5 GNU extension alias for DW_AT_call_origin. */
14205 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
14207 SET_FIELD_DWARF_BLOCK (call_site
->target
, NULL
);
14208 if (!attr
|| (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0))
14209 /* Keep NULL DWARF_BLOCK. */;
14210 else if (attr_form_is_block (attr
))
14212 struct dwarf2_locexpr_baton
*dlbaton
;
14214 dlbaton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
14215 dlbaton
->data
= DW_BLOCK (attr
)->data
;
14216 dlbaton
->size
= DW_BLOCK (attr
)->size
;
14217 dlbaton
->per_cu
= cu
->per_cu
;
14219 SET_FIELD_DWARF_BLOCK (call_site
->target
, dlbaton
);
14221 else if (attr_form_is_ref (attr
))
14223 struct dwarf2_cu
*target_cu
= cu
;
14224 struct die_info
*target_die
;
14226 target_die
= follow_die_ref (die
, attr
, &target_cu
);
14227 gdb_assert (target_cu
->per_cu
->dwarf2_per_objfile
->objfile
== objfile
);
14228 if (die_is_declaration (target_die
, target_cu
))
14230 const char *target_physname
;
14232 /* Prefer the mangled name; otherwise compute the demangled one. */
14233 target_physname
= dw2_linkage_name (target_die
, target_cu
);
14234 if (target_physname
== NULL
)
14235 target_physname
= dwarf2_physname (NULL
, target_die
, target_cu
);
14236 if (target_physname
== NULL
)
14237 complaint (&symfile_complaints
,
14238 _("DW_AT_call_target target DIE has invalid "
14239 "physname, for referencing DIE 0x%x [in module %s]"),
14240 to_underlying (die
->sect_off
), objfile_name (objfile
));
14242 SET_FIELD_PHYSNAME (call_site
->target
, target_physname
);
14248 /* DW_AT_entry_pc should be preferred. */
14249 if (dwarf2_get_pc_bounds (target_die
, &lowpc
, NULL
, target_cu
, NULL
)
14250 <= PC_BOUNDS_INVALID
)
14251 complaint (&symfile_complaints
,
14252 _("DW_AT_call_target target DIE has invalid "
14253 "low pc, for referencing DIE 0x%x [in module %s]"),
14254 to_underlying (die
->sect_off
), objfile_name (objfile
));
14257 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
14258 SET_FIELD_PHYSADDR (call_site
->target
, lowpc
);
14263 complaint (&symfile_complaints
,
14264 _("DW_TAG_call_site DW_AT_call_target is neither "
14265 "block nor reference, for DIE 0x%x [in module %s]"),
14266 to_underlying (die
->sect_off
), objfile_name (objfile
));
14268 call_site
->per_cu
= cu
->per_cu
;
14270 for (child_die
= die
->child
;
14271 child_die
&& child_die
->tag
;
14272 child_die
= sibling_die (child_die
))
14274 struct call_site_parameter
*parameter
;
14275 struct attribute
*loc
, *origin
;
14277 if (child_die
->tag
!= DW_TAG_call_site_parameter
14278 && child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
14280 /* Already printed the complaint above. */
14284 gdb_assert (call_site
->parameter_count
< nparams
);
14285 parameter
= &call_site
->parameter
[call_site
->parameter_count
];
14287 /* DW_AT_location specifies the register number or DW_AT_abstract_origin
14288 specifies DW_TAG_formal_parameter. Value of the data assumed for the
14289 register is contained in DW_AT_call_value. */
14291 loc
= dwarf2_attr (child_die
, DW_AT_location
, cu
);
14292 origin
= dwarf2_attr (child_die
, DW_AT_call_parameter
, cu
);
14293 if (origin
== NULL
)
14295 /* This was a pre-DWARF-5 GNU extension alias
14296 for DW_AT_call_parameter. */
14297 origin
= dwarf2_attr (child_die
, DW_AT_abstract_origin
, cu
);
14299 if (loc
== NULL
&& origin
!= NULL
&& attr_form_is_ref (origin
))
14301 parameter
->kind
= CALL_SITE_PARAMETER_PARAM_OFFSET
;
14303 sect_offset sect_off
14304 = (sect_offset
) dwarf2_get_ref_die_offset (origin
);
14305 if (!offset_in_cu_p (&cu
->header
, sect_off
))
14307 /* As DW_OP_GNU_parameter_ref uses CU-relative offset this
14308 binding can be done only inside one CU. Such referenced DIE
14309 therefore cannot be even moved to DW_TAG_partial_unit. */
14310 complaint (&symfile_complaints
,
14311 _("DW_AT_call_parameter offset is not in CU for "
14312 "DW_TAG_call_site child DIE 0x%x [in module %s]"),
14313 to_underlying (child_die
->sect_off
),
14314 objfile_name (objfile
));
14317 parameter
->u
.param_cu_off
14318 = (cu_offset
) (sect_off
- cu
->header
.sect_off
);
14320 else if (loc
== NULL
|| origin
!= NULL
|| !attr_form_is_block (loc
))
14322 complaint (&symfile_complaints
,
14323 _("No DW_FORM_block* DW_AT_location for "
14324 "DW_TAG_call_site child DIE 0x%x [in module %s]"),
14325 to_underlying (child_die
->sect_off
), objfile_name (objfile
));
14330 parameter
->u
.dwarf_reg
= dwarf_block_to_dwarf_reg
14331 (DW_BLOCK (loc
)->data
, &DW_BLOCK (loc
)->data
[DW_BLOCK (loc
)->size
]);
14332 if (parameter
->u
.dwarf_reg
!= -1)
14333 parameter
->kind
= CALL_SITE_PARAMETER_DWARF_REG
;
14334 else if (dwarf_block_to_sp_offset (gdbarch
, DW_BLOCK (loc
)->data
,
14335 &DW_BLOCK (loc
)->data
[DW_BLOCK (loc
)->size
],
14336 ¶meter
->u
.fb_offset
))
14337 parameter
->kind
= CALL_SITE_PARAMETER_FB_OFFSET
;
14340 complaint (&symfile_complaints
,
14341 _("Only single DW_OP_reg or DW_OP_fbreg is supported "
14342 "for DW_FORM_block* DW_AT_location is supported for "
14343 "DW_TAG_call_site child DIE 0x%x "
14345 to_underlying (child_die
->sect_off
),
14346 objfile_name (objfile
));
14351 attr
= dwarf2_attr (child_die
, DW_AT_call_value
, cu
);
14353 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_value
, cu
);
14354 if (!attr_form_is_block (attr
))
14356 complaint (&symfile_complaints
,
14357 _("No DW_FORM_block* DW_AT_call_value for "
14358 "DW_TAG_call_site child DIE 0x%x [in module %s]"),
14359 to_underlying (child_die
->sect_off
),
14360 objfile_name (objfile
));
14363 parameter
->value
= DW_BLOCK (attr
)->data
;
14364 parameter
->value_size
= DW_BLOCK (attr
)->size
;
14366 /* Parameters are not pre-cleared by memset above. */
14367 parameter
->data_value
= NULL
;
14368 parameter
->data_value_size
= 0;
14369 call_site
->parameter_count
++;
14371 attr
= dwarf2_attr (child_die
, DW_AT_call_data_value
, cu
);
14373 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_data_value
, cu
);
14376 if (!attr_form_is_block (attr
))
14377 complaint (&symfile_complaints
,
14378 _("No DW_FORM_block* DW_AT_call_data_value for "
14379 "DW_TAG_call_site child DIE 0x%x [in module %s]"),
14380 to_underlying (child_die
->sect_off
),
14381 objfile_name (objfile
));
14384 parameter
->data_value
= DW_BLOCK (attr
)->data
;
14385 parameter
->data_value_size
= DW_BLOCK (attr
)->size
;
14391 /* Helper function for read_variable. If DIE represents a virtual
14392 table, then return the type of the concrete object that is
14393 associated with the virtual table. Otherwise, return NULL. */
14395 static struct type
*
14396 rust_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14398 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
14402 /* Find the type DIE. */
14403 struct die_info
*type_die
= NULL
;
14404 struct dwarf2_cu
*type_cu
= cu
;
14406 if (attr_form_is_ref (attr
))
14407 type_die
= follow_die_ref (die
, attr
, &type_cu
);
14408 if (type_die
== NULL
)
14411 if (dwarf2_attr (type_die
, DW_AT_containing_type
, type_cu
) == NULL
)
14413 return die_containing_type (type_die
, type_cu
);
14416 /* Read a variable (DW_TAG_variable) DIE and create a new symbol. */
14419 read_variable (struct die_info
*die
, struct dwarf2_cu
*cu
)
14421 struct rust_vtable_symbol
*storage
= NULL
;
14423 if (cu
->language
== language_rust
)
14425 struct type
*containing_type
= rust_containing_type (die
, cu
);
14427 if (containing_type
!= NULL
)
14429 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
14431 storage
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
14432 struct rust_vtable_symbol
);
14433 initialize_objfile_symbol (storage
);
14434 storage
->concrete_type
= containing_type
;
14435 storage
->subclass
= SYMBOL_RUST_VTABLE
;
14439 new_symbol_full (die
, NULL
, cu
, storage
);
14442 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET
14443 reading .debug_rnglists.
14444 Callback's type should be:
14445 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14446 Return true if the attributes are present and valid, otherwise,
14449 template <typename Callback
>
14451 dwarf2_rnglists_process (unsigned offset
, struct dwarf2_cu
*cu
,
14452 Callback
&&callback
)
14454 struct dwarf2_per_objfile
*dwarf2_per_objfile
14455 = cu
->per_cu
->dwarf2_per_objfile
;
14456 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
14457 bfd
*obfd
= objfile
->obfd
;
14458 /* Base address selection entry. */
14461 const gdb_byte
*buffer
;
14462 CORE_ADDR baseaddr
;
14463 bool overflow
= false;
14465 found_base
= cu
->base_known
;
14466 base
= cu
->base_address
;
14468 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->rnglists
);
14469 if (offset
>= dwarf2_per_objfile
->rnglists
.size
)
14471 complaint (&symfile_complaints
,
14472 _("Offset %d out of bounds for DW_AT_ranges attribute"),
14476 buffer
= dwarf2_per_objfile
->rnglists
.buffer
+ offset
;
14478 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
14482 /* Initialize it due to a false compiler warning. */
14483 CORE_ADDR range_beginning
= 0, range_end
= 0;
14484 const gdb_byte
*buf_end
= (dwarf2_per_objfile
->rnglists
.buffer
14485 + dwarf2_per_objfile
->rnglists
.size
);
14486 unsigned int bytes_read
;
14488 if (buffer
== buf_end
)
14493 const auto rlet
= static_cast<enum dwarf_range_list_entry
>(*buffer
++);
14496 case DW_RLE_end_of_list
:
14498 case DW_RLE_base_address
:
14499 if (buffer
+ cu
->header
.addr_size
> buf_end
)
14504 base
= read_address (obfd
, buffer
, cu
, &bytes_read
);
14506 buffer
+= bytes_read
;
14508 case DW_RLE_start_length
:
14509 if (buffer
+ cu
->header
.addr_size
> buf_end
)
14514 range_beginning
= read_address (obfd
, buffer
, cu
, &bytes_read
);
14515 buffer
+= bytes_read
;
14516 range_end
= (range_beginning
14517 + read_unsigned_leb128 (obfd
, buffer
, &bytes_read
));
14518 buffer
+= bytes_read
;
14519 if (buffer
> buf_end
)
14525 case DW_RLE_offset_pair
:
14526 range_beginning
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14527 buffer
+= bytes_read
;
14528 if (buffer
> buf_end
)
14533 range_end
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14534 buffer
+= bytes_read
;
14535 if (buffer
> buf_end
)
14541 case DW_RLE_start_end
:
14542 if (buffer
+ 2 * cu
->header
.addr_size
> buf_end
)
14547 range_beginning
= read_address (obfd
, buffer
, cu
, &bytes_read
);
14548 buffer
+= bytes_read
;
14549 range_end
= read_address (obfd
, buffer
, cu
, &bytes_read
);
14550 buffer
+= bytes_read
;
14553 complaint (&symfile_complaints
,
14554 _("Invalid .debug_rnglists data (no base address)"));
14557 if (rlet
== DW_RLE_end_of_list
|| overflow
)
14559 if (rlet
== DW_RLE_base_address
)
14564 /* We have no valid base address for the ranges
14566 complaint (&symfile_complaints
,
14567 _("Invalid .debug_rnglists data (no base address)"));
14571 if (range_beginning
> range_end
)
14573 /* Inverted range entries are invalid. */
14574 complaint (&symfile_complaints
,
14575 _("Invalid .debug_rnglists data (inverted range)"));
14579 /* Empty range entries have no effect. */
14580 if (range_beginning
== range_end
)
14583 range_beginning
+= base
;
14586 /* A not-uncommon case of bad debug info.
14587 Don't pollute the addrmap with bad data. */
14588 if (range_beginning
+ baseaddr
== 0
14589 && !dwarf2_per_objfile
->has_section_at_zero
)
14591 complaint (&symfile_complaints
,
14592 _(".debug_rnglists entry has start address of zero"
14593 " [in module %s]"), objfile_name (objfile
));
14597 callback (range_beginning
, range_end
);
14602 complaint (&symfile_complaints
,
14603 _("Offset %d is not terminated "
14604 "for DW_AT_ranges attribute"),
14612 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET reading .debug_ranges.
14613 Callback's type should be:
14614 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14615 Return 1 if the attributes are present and valid, otherwise, return 0. */
14617 template <typename Callback
>
14619 dwarf2_ranges_process (unsigned offset
, struct dwarf2_cu
*cu
,
14620 Callback
&&callback
)
14622 struct dwarf2_per_objfile
*dwarf2_per_objfile
14623 = cu
->per_cu
->dwarf2_per_objfile
;
14624 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
14625 struct comp_unit_head
*cu_header
= &cu
->header
;
14626 bfd
*obfd
= objfile
->obfd
;
14627 unsigned int addr_size
= cu_header
->addr_size
;
14628 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
14629 /* Base address selection entry. */
14632 unsigned int dummy
;
14633 const gdb_byte
*buffer
;
14634 CORE_ADDR baseaddr
;
14636 if (cu_header
->version
>= 5)
14637 return dwarf2_rnglists_process (offset
, cu
, callback
);
14639 found_base
= cu
->base_known
;
14640 base
= cu
->base_address
;
14642 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->ranges
);
14643 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
14645 complaint (&symfile_complaints
,
14646 _("Offset %d out of bounds for DW_AT_ranges attribute"),
14650 buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
14652 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
14656 CORE_ADDR range_beginning
, range_end
;
14658 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
14659 buffer
+= addr_size
;
14660 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
14661 buffer
+= addr_size
;
14662 offset
+= 2 * addr_size
;
14664 /* An end of list marker is a pair of zero addresses. */
14665 if (range_beginning
== 0 && range_end
== 0)
14666 /* Found the end of list entry. */
14669 /* Each base address selection entry is a pair of 2 values.
14670 The first is the largest possible address, the second is
14671 the base address. Check for a base address here. */
14672 if ((range_beginning
& mask
) == mask
)
14674 /* If we found the largest possible address, then we already
14675 have the base address in range_end. */
14683 /* We have no valid base address for the ranges
14685 complaint (&symfile_complaints
,
14686 _("Invalid .debug_ranges data (no base address)"));
14690 if (range_beginning
> range_end
)
14692 /* Inverted range entries are invalid. */
14693 complaint (&symfile_complaints
,
14694 _("Invalid .debug_ranges data (inverted range)"));
14698 /* Empty range entries have no effect. */
14699 if (range_beginning
== range_end
)
14702 range_beginning
+= base
;
14705 /* A not-uncommon case of bad debug info.
14706 Don't pollute the addrmap with bad data. */
14707 if (range_beginning
+ baseaddr
== 0
14708 && !dwarf2_per_objfile
->has_section_at_zero
)
14710 complaint (&symfile_complaints
,
14711 _(".debug_ranges entry has start address of zero"
14712 " [in module %s]"), objfile_name (objfile
));
14716 callback (range_beginning
, range_end
);
14722 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
14723 Return 1 if the attributes are present and valid, otherwise, return 0.
14724 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
14727 dwarf2_ranges_read (unsigned offset
, CORE_ADDR
*low_return
,
14728 CORE_ADDR
*high_return
, struct dwarf2_cu
*cu
,
14729 struct partial_symtab
*ranges_pst
)
14731 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
14732 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
14733 const CORE_ADDR baseaddr
= ANOFFSET (objfile
->section_offsets
,
14734 SECT_OFF_TEXT (objfile
));
14737 CORE_ADDR high
= 0;
14740 retval
= dwarf2_ranges_process (offset
, cu
,
14741 [&] (CORE_ADDR range_beginning
, CORE_ADDR range_end
)
14743 if (ranges_pst
!= NULL
)
14748 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
,
14749 range_beginning
+ baseaddr
);
14750 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
,
14751 range_end
+ baseaddr
);
14752 addrmap_set_empty (objfile
->psymtabs_addrmap
, lowpc
, highpc
- 1,
14756 /* FIXME: This is recording everything as a low-high
14757 segment of consecutive addresses. We should have a
14758 data structure for discontiguous block ranges
14762 low
= range_beginning
;
14768 if (range_beginning
< low
)
14769 low
= range_beginning
;
14770 if (range_end
> high
)
14778 /* If the first entry is an end-of-list marker, the range
14779 describes an empty scope, i.e. no instructions. */
14785 *high_return
= high
;
14789 /* Get low and high pc attributes from a die. See enum pc_bounds_kind
14790 definition for the return value. *LOWPC and *HIGHPC are set iff
14791 neither PC_BOUNDS_NOT_PRESENT nor PC_BOUNDS_INVALID are returned. */
14793 static enum pc_bounds_kind
14794 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
14795 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
,
14796 struct partial_symtab
*pst
)
14798 struct dwarf2_per_objfile
*dwarf2_per_objfile
14799 = cu
->per_cu
->dwarf2_per_objfile
;
14800 struct attribute
*attr
;
14801 struct attribute
*attr_high
;
14803 CORE_ADDR high
= 0;
14804 enum pc_bounds_kind ret
;
14806 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
14809 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
14812 low
= attr_value_as_address (attr
);
14813 high
= attr_value_as_address (attr_high
);
14814 if (cu
->header
.version
>= 4 && attr_form_is_constant (attr_high
))
14818 /* Found high w/o low attribute. */
14819 return PC_BOUNDS_INVALID
;
14821 /* Found consecutive range of addresses. */
14822 ret
= PC_BOUNDS_HIGH_LOW
;
14826 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
14829 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
14830 We take advantage of the fact that DW_AT_ranges does not appear
14831 in DW_TAG_compile_unit of DWO files. */
14832 int need_ranges_base
= die
->tag
!= DW_TAG_compile_unit
;
14833 unsigned int ranges_offset
= (DW_UNSND (attr
)
14834 + (need_ranges_base
14838 /* Value of the DW_AT_ranges attribute is the offset in the
14839 .debug_ranges section. */
14840 if (!dwarf2_ranges_read (ranges_offset
, &low
, &high
, cu
, pst
))
14841 return PC_BOUNDS_INVALID
;
14842 /* Found discontinuous range of addresses. */
14843 ret
= PC_BOUNDS_RANGES
;
14846 return PC_BOUNDS_NOT_PRESENT
;
14849 /* read_partial_die has also the strict LOW < HIGH requirement. */
14851 return PC_BOUNDS_INVALID
;
14853 /* When using the GNU linker, .gnu.linkonce. sections are used to
14854 eliminate duplicate copies of functions and vtables and such.
14855 The linker will arbitrarily choose one and discard the others.
14856 The AT_*_pc values for such functions refer to local labels in
14857 these sections. If the section from that file was discarded, the
14858 labels are not in the output, so the relocs get a value of 0.
14859 If this is a discarded function, mark the pc bounds as invalid,
14860 so that GDB will ignore it. */
14861 if (low
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
14862 return PC_BOUNDS_INVALID
;
14870 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
14871 its low and high PC addresses. Do nothing if these addresses could not
14872 be determined. Otherwise, set LOWPC to the low address if it is smaller,
14873 and HIGHPC to the high address if greater than HIGHPC. */
14876 dwarf2_get_subprogram_pc_bounds (struct die_info
*die
,
14877 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
14878 struct dwarf2_cu
*cu
)
14880 CORE_ADDR low
, high
;
14881 struct die_info
*child
= die
->child
;
14883 if (dwarf2_get_pc_bounds (die
, &low
, &high
, cu
, NULL
) >= PC_BOUNDS_RANGES
)
14885 *lowpc
= std::min (*lowpc
, low
);
14886 *highpc
= std::max (*highpc
, high
);
14889 /* If the language does not allow nested subprograms (either inside
14890 subprograms or lexical blocks), we're done. */
14891 if (cu
->language
!= language_ada
)
14894 /* Check all the children of the given DIE. If it contains nested
14895 subprograms, then check their pc bounds. Likewise, we need to
14896 check lexical blocks as well, as they may also contain subprogram
14898 while (child
&& child
->tag
)
14900 if (child
->tag
== DW_TAG_subprogram
14901 || child
->tag
== DW_TAG_lexical_block
)
14902 dwarf2_get_subprogram_pc_bounds (child
, lowpc
, highpc
, cu
);
14903 child
= sibling_die (child
);
14907 /* Get the low and high pc's represented by the scope DIE, and store
14908 them in *LOWPC and *HIGHPC. If the correct values can't be
14909 determined, set *LOWPC to -1 and *HIGHPC to 0. */
14912 get_scope_pc_bounds (struct die_info
*die
,
14913 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
14914 struct dwarf2_cu
*cu
)
14916 CORE_ADDR best_low
= (CORE_ADDR
) -1;
14917 CORE_ADDR best_high
= (CORE_ADDR
) 0;
14918 CORE_ADDR current_low
, current_high
;
14920 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
, NULL
)
14921 >= PC_BOUNDS_RANGES
)
14923 best_low
= current_low
;
14924 best_high
= current_high
;
14928 struct die_info
*child
= die
->child
;
14930 while (child
&& child
->tag
)
14932 switch (child
->tag
) {
14933 case DW_TAG_subprogram
:
14934 dwarf2_get_subprogram_pc_bounds (child
, &best_low
, &best_high
, cu
);
14936 case DW_TAG_namespace
:
14937 case DW_TAG_module
:
14938 /* FIXME: carlton/2004-01-16: Should we do this for
14939 DW_TAG_class_type/DW_TAG_structure_type, too? I think
14940 that current GCC's always emit the DIEs corresponding
14941 to definitions of methods of classes as children of a
14942 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
14943 the DIEs giving the declarations, which could be
14944 anywhere). But I don't see any reason why the
14945 standards says that they have to be there. */
14946 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
14948 if (current_low
!= ((CORE_ADDR
) -1))
14950 best_low
= std::min (best_low
, current_low
);
14951 best_high
= std::max (best_high
, current_high
);
14959 child
= sibling_die (child
);
14964 *highpc
= best_high
;
14967 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
14971 dwarf2_record_block_ranges (struct die_info
*die
, struct block
*block
,
14972 CORE_ADDR baseaddr
, struct dwarf2_cu
*cu
)
14974 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
14975 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
14976 struct attribute
*attr
;
14977 struct attribute
*attr_high
;
14979 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
14982 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
14985 CORE_ADDR low
= attr_value_as_address (attr
);
14986 CORE_ADDR high
= attr_value_as_address (attr_high
);
14988 if (cu
->header
.version
>= 4 && attr_form_is_constant (attr_high
))
14991 low
= gdbarch_adjust_dwarf2_addr (gdbarch
, low
+ baseaddr
);
14992 high
= gdbarch_adjust_dwarf2_addr (gdbarch
, high
+ baseaddr
);
14993 record_block_range (block
, low
, high
- 1);
14997 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
15000 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
15001 We take advantage of the fact that DW_AT_ranges does not appear
15002 in DW_TAG_compile_unit of DWO files. */
15003 int need_ranges_base
= die
->tag
!= DW_TAG_compile_unit
;
15005 /* The value of the DW_AT_ranges attribute is the offset of the
15006 address range list in the .debug_ranges section. */
15007 unsigned long offset
= (DW_UNSND (attr
)
15008 + (need_ranges_base
? cu
->ranges_base
: 0));
15009 const gdb_byte
*buffer
;
15011 /* For some target architectures, but not others, the
15012 read_address function sign-extends the addresses it returns.
15013 To recognize base address selection entries, we need a
15015 unsigned int addr_size
= cu
->header
.addr_size
;
15016 CORE_ADDR base_select_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
15018 /* The base address, to which the next pair is relative. Note
15019 that this 'base' is a DWARF concept: most entries in a range
15020 list are relative, to reduce the number of relocs against the
15021 debugging information. This is separate from this function's
15022 'baseaddr' argument, which GDB uses to relocate debugging
15023 information from a shared library based on the address at
15024 which the library was loaded. */
15025 CORE_ADDR base
= cu
->base_address
;
15026 int base_known
= cu
->base_known
;
15028 dwarf2_ranges_process (offset
, cu
,
15029 [&] (CORE_ADDR start
, CORE_ADDR end
)
15033 start
= gdbarch_adjust_dwarf2_addr (gdbarch
, start
);
15034 end
= gdbarch_adjust_dwarf2_addr (gdbarch
, end
);
15035 record_block_range (block
, start
, end
- 1);
15040 /* Check whether the producer field indicates either of GCC < 4.6, or the
15041 Intel C/C++ compiler, and cache the result in CU. */
15044 check_producer (struct dwarf2_cu
*cu
)
15048 if (cu
->producer
== NULL
)
15050 /* For unknown compilers expect their behavior is DWARF version
15053 GCC started to support .debug_types sections by -gdwarf-4 since
15054 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
15055 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
15056 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
15057 interpreted incorrectly by GDB now - GCC PR debug/48229. */
15059 else if (producer_is_gcc (cu
->producer
, &major
, &minor
))
15061 cu
->producer_is_gxx_lt_4_6
= major
< 4 || (major
== 4 && minor
< 6);
15062 cu
->producer_is_gcc_lt_4_3
= major
< 4 || (major
== 4 && minor
< 3);
15064 else if (producer_is_icc (cu
->producer
, &major
, &minor
))
15065 cu
->producer_is_icc_lt_14
= major
< 14;
15068 /* For other non-GCC compilers, expect their behavior is DWARF version
15072 cu
->checked_producer
= 1;
15075 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
15076 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
15077 during 4.6.0 experimental. */
15080 producer_is_gxx_lt_4_6 (struct dwarf2_cu
*cu
)
15082 if (!cu
->checked_producer
)
15083 check_producer (cu
);
15085 return cu
->producer_is_gxx_lt_4_6
;
15088 /* Return the default accessibility type if it is not overriden by
15089 DW_AT_accessibility. */
15091 static enum dwarf_access_attribute
15092 dwarf2_default_access_attribute (struct die_info
*die
, struct dwarf2_cu
*cu
)
15094 if (cu
->header
.version
< 3 || producer_is_gxx_lt_4_6 (cu
))
15096 /* The default DWARF 2 accessibility for members is public, the default
15097 accessibility for inheritance is private. */
15099 if (die
->tag
!= DW_TAG_inheritance
)
15100 return DW_ACCESS_public
;
15102 return DW_ACCESS_private
;
15106 /* DWARF 3+ defines the default accessibility a different way. The same
15107 rules apply now for DW_TAG_inheritance as for the members and it only
15108 depends on the container kind. */
15110 if (die
->parent
->tag
== DW_TAG_class_type
)
15111 return DW_ACCESS_private
;
15113 return DW_ACCESS_public
;
15117 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
15118 offset. If the attribute was not found return 0, otherwise return
15119 1. If it was found but could not properly be handled, set *OFFSET
15123 handle_data_member_location (struct die_info
*die
, struct dwarf2_cu
*cu
,
15126 struct attribute
*attr
;
15128 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
15133 /* Note that we do not check for a section offset first here.
15134 This is because DW_AT_data_member_location is new in DWARF 4,
15135 so if we see it, we can assume that a constant form is really
15136 a constant and not a section offset. */
15137 if (attr_form_is_constant (attr
))
15138 *offset
= dwarf2_get_attr_constant_value (attr
, 0);
15139 else if (attr_form_is_section_offset (attr
))
15140 dwarf2_complex_location_expr_complaint ();
15141 else if (attr_form_is_block (attr
))
15142 *offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
15144 dwarf2_complex_location_expr_complaint ();
15152 /* Add an aggregate field to the field list. */
15155 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
15156 struct dwarf2_cu
*cu
)
15158 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
15159 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
15160 struct nextfield
*new_field
;
15161 struct attribute
*attr
;
15163 const char *fieldname
= "";
15165 /* Allocate a new field list entry and link it in. */
15166 new_field
= XNEW (struct nextfield
);
15167 make_cleanup (xfree
, new_field
);
15168 memset (new_field
, 0, sizeof (struct nextfield
));
15170 if (die
->tag
== DW_TAG_inheritance
)
15172 new_field
->next
= fip
->baseclasses
;
15173 fip
->baseclasses
= new_field
;
15177 new_field
->next
= fip
->fields
;
15178 fip
->fields
= new_field
;
15182 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
15184 new_field
->accessibility
= DW_UNSND (attr
);
15186 new_field
->accessibility
= dwarf2_default_access_attribute (die
, cu
);
15187 if (new_field
->accessibility
!= DW_ACCESS_public
)
15188 fip
->non_public_fields
= 1;
15190 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
15192 new_field
->virtuality
= DW_UNSND (attr
);
15194 new_field
->virtuality
= DW_VIRTUALITY_none
;
15196 fp
= &new_field
->field
;
15198 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
15202 /* Data member other than a C++ static data member. */
15204 /* Get type of field. */
15205 fp
->type
= die_type (die
, cu
);
15207 SET_FIELD_BITPOS (*fp
, 0);
15209 /* Get bit size of field (zero if none). */
15210 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
15213 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
15217 FIELD_BITSIZE (*fp
) = 0;
15220 /* Get bit offset of field. */
15221 if (handle_data_member_location (die
, cu
, &offset
))
15222 SET_FIELD_BITPOS (*fp
, offset
* bits_per_byte
);
15223 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
15226 if (gdbarch_bits_big_endian (gdbarch
))
15228 /* For big endian bits, the DW_AT_bit_offset gives the
15229 additional bit offset from the MSB of the containing
15230 anonymous object to the MSB of the field. We don't
15231 have to do anything special since we don't need to
15232 know the size of the anonymous object. */
15233 SET_FIELD_BITPOS (*fp
, FIELD_BITPOS (*fp
) + DW_UNSND (attr
));
15237 /* For little endian bits, compute the bit offset to the
15238 MSB of the anonymous object, subtract off the number of
15239 bits from the MSB of the field to the MSB of the
15240 object, and then subtract off the number of bits of
15241 the field itself. The result is the bit offset of
15242 the LSB of the field. */
15243 int anonymous_size
;
15244 int bit_offset
= DW_UNSND (attr
);
15246 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
15249 /* The size of the anonymous object containing
15250 the bit field is explicit, so use the
15251 indicated size (in bytes). */
15252 anonymous_size
= DW_UNSND (attr
);
15256 /* The size of the anonymous object containing
15257 the bit field must be inferred from the type
15258 attribute of the data member containing the
15260 anonymous_size
= TYPE_LENGTH (fp
->type
);
15262 SET_FIELD_BITPOS (*fp
,
15263 (FIELD_BITPOS (*fp
)
15264 + anonymous_size
* bits_per_byte
15265 - bit_offset
- FIELD_BITSIZE (*fp
)));
15268 attr
= dwarf2_attr (die
, DW_AT_data_bit_offset
, cu
);
15270 SET_FIELD_BITPOS (*fp
, (FIELD_BITPOS (*fp
)
15271 + dwarf2_get_attr_constant_value (attr
, 0)));
15273 /* Get name of field. */
15274 fieldname
= dwarf2_name (die
, cu
);
15275 if (fieldname
== NULL
)
15278 /* The name is already allocated along with this objfile, so we don't
15279 need to duplicate it for the type. */
15280 fp
->name
= fieldname
;
15282 /* Change accessibility for artificial fields (e.g. virtual table
15283 pointer or virtual base class pointer) to private. */
15284 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
15286 FIELD_ARTIFICIAL (*fp
) = 1;
15287 new_field
->accessibility
= DW_ACCESS_private
;
15288 fip
->non_public_fields
= 1;
15291 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
15293 /* C++ static member. */
15295 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
15296 is a declaration, but all versions of G++ as of this writing
15297 (so through at least 3.2.1) incorrectly generate
15298 DW_TAG_variable tags. */
15300 const char *physname
;
15302 /* Get name of field. */
15303 fieldname
= dwarf2_name (die
, cu
);
15304 if (fieldname
== NULL
)
15307 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
15309 /* Only create a symbol if this is an external value.
15310 new_symbol checks this and puts the value in the global symbol
15311 table, which we want. If it is not external, new_symbol
15312 will try to put the value in cu->list_in_scope which is wrong. */
15313 && dwarf2_flag_true_p (die
, DW_AT_external
, cu
))
15315 /* A static const member, not much different than an enum as far as
15316 we're concerned, except that we can support more types. */
15317 new_symbol (die
, NULL
, cu
);
15320 /* Get physical name. */
15321 physname
= dwarf2_physname (fieldname
, die
, cu
);
15323 /* The name is already allocated along with this objfile, so we don't
15324 need to duplicate it for the type. */
15325 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
15326 FIELD_TYPE (*fp
) = die_type (die
, cu
);
15327 FIELD_NAME (*fp
) = fieldname
;
15329 else if (die
->tag
== DW_TAG_inheritance
)
15333 /* C++ base class field. */
15334 if (handle_data_member_location (die
, cu
, &offset
))
15335 SET_FIELD_BITPOS (*fp
, offset
* bits_per_byte
);
15336 FIELD_BITSIZE (*fp
) = 0;
15337 FIELD_TYPE (*fp
) = die_type (die
, cu
);
15338 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
15339 fip
->nbaseclasses
++;
15343 /* Can the type given by DIE define another type? */
15346 type_can_define_types (const struct die_info
*die
)
15350 case DW_TAG_typedef
:
15351 case DW_TAG_class_type
:
15352 case DW_TAG_structure_type
:
15353 case DW_TAG_union_type
:
15354 case DW_TAG_enumeration_type
:
15362 /* Add a type definition defined in the scope of the FIP's class. */
15365 dwarf2_add_type_defn (struct field_info
*fip
, struct die_info
*die
,
15366 struct dwarf2_cu
*cu
)
15368 struct decl_field_list
*new_field
;
15369 struct decl_field
*fp
;
15371 /* Allocate a new field list entry and link it in. */
15372 new_field
= XCNEW (struct decl_field_list
);
15373 make_cleanup (xfree
, new_field
);
15375 gdb_assert (type_can_define_types (die
));
15377 fp
= &new_field
->field
;
15379 /* Get name of field. NULL is okay here, meaning an anonymous type. */
15380 fp
->name
= dwarf2_name (die
, cu
);
15381 fp
->type
= read_type_die (die
, cu
);
15383 /* Save accessibility. */
15384 enum dwarf_access_attribute accessibility
;
15385 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
15387 accessibility
= (enum dwarf_access_attribute
) DW_UNSND (attr
);
15389 accessibility
= dwarf2_default_access_attribute (die
, cu
);
15390 switch (accessibility
)
15392 case DW_ACCESS_public
:
15393 /* The assumed value if neither private nor protected. */
15395 case DW_ACCESS_private
:
15396 fp
->is_private
= 1;
15398 case DW_ACCESS_protected
:
15399 fp
->is_protected
= 1;
15402 complaint (&symfile_complaints
,
15403 _("Unhandled DW_AT_accessibility value (%x)"), accessibility
);
15406 if (die
->tag
== DW_TAG_typedef
)
15408 new_field
->next
= fip
->typedef_field_list
;
15409 fip
->typedef_field_list
= new_field
;
15410 fip
->typedef_field_list_count
++;
15414 new_field
->next
= fip
->nested_types_list
;
15415 fip
->nested_types_list
= new_field
;
15416 fip
->nested_types_list_count
++;
15420 /* Create the vector of fields, and attach it to the type. */
15423 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
15424 struct dwarf2_cu
*cu
)
15426 int nfields
= fip
->nfields
;
15428 /* Record the field count, allocate space for the array of fields,
15429 and create blank accessibility bitfields if necessary. */
15430 TYPE_NFIELDS (type
) = nfields
;
15431 TYPE_FIELDS (type
) = (struct field
*)
15432 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
15433 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
15435 if (fip
->non_public_fields
&& cu
->language
!= language_ada
)
15437 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15439 TYPE_FIELD_PRIVATE_BITS (type
) =
15440 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
15441 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
15443 TYPE_FIELD_PROTECTED_BITS (type
) =
15444 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
15445 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
15447 TYPE_FIELD_IGNORE_BITS (type
) =
15448 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
15449 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
15452 /* If the type has baseclasses, allocate and clear a bit vector for
15453 TYPE_FIELD_VIRTUAL_BITS. */
15454 if (fip
->nbaseclasses
&& cu
->language
!= language_ada
)
15456 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
15457 unsigned char *pointer
;
15459 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15460 pointer
= (unsigned char *) TYPE_ALLOC (type
, num_bytes
);
15461 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
15462 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
15463 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
15466 /* Copy the saved-up fields into the field vector. Start from the head of
15467 the list, adding to the tail of the field array, so that they end up in
15468 the same order in the array in which they were added to the list. */
15469 while (nfields
-- > 0)
15471 struct nextfield
*fieldp
;
15475 fieldp
= fip
->fields
;
15476 fip
->fields
= fieldp
->next
;
15480 fieldp
= fip
->baseclasses
;
15481 fip
->baseclasses
= fieldp
->next
;
15484 TYPE_FIELD (type
, nfields
) = fieldp
->field
;
15485 switch (fieldp
->accessibility
)
15487 case DW_ACCESS_private
:
15488 if (cu
->language
!= language_ada
)
15489 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
15492 case DW_ACCESS_protected
:
15493 if (cu
->language
!= language_ada
)
15494 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
15497 case DW_ACCESS_public
:
15501 /* Unknown accessibility. Complain and treat it as public. */
15503 complaint (&symfile_complaints
, _("unsupported accessibility %d"),
15504 fieldp
->accessibility
);
15508 if (nfields
< fip
->nbaseclasses
)
15510 switch (fieldp
->virtuality
)
15512 case DW_VIRTUALITY_virtual
:
15513 case DW_VIRTUALITY_pure_virtual
:
15514 if (cu
->language
== language_ada
)
15515 error (_("unexpected virtuality in component of Ada type"));
15516 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
15523 /* Return true if this member function is a constructor, false
15527 dwarf2_is_constructor (struct die_info
*die
, struct dwarf2_cu
*cu
)
15529 const char *fieldname
;
15530 const char *type_name
;
15533 if (die
->parent
== NULL
)
15536 if (die
->parent
->tag
!= DW_TAG_structure_type
15537 && die
->parent
->tag
!= DW_TAG_union_type
15538 && die
->parent
->tag
!= DW_TAG_class_type
)
15541 fieldname
= dwarf2_name (die
, cu
);
15542 type_name
= dwarf2_name (die
->parent
, cu
);
15543 if (fieldname
== NULL
|| type_name
== NULL
)
15546 len
= strlen (fieldname
);
15547 return (strncmp (fieldname
, type_name
, len
) == 0
15548 && (type_name
[len
] == '\0' || type_name
[len
] == '<'));
15551 /* Add a member function to the proper fieldlist. */
15554 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
15555 struct type
*type
, struct dwarf2_cu
*cu
)
15557 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
15558 struct attribute
*attr
;
15559 struct fnfieldlist
*flp
;
15561 struct fn_field
*fnp
;
15562 const char *fieldname
;
15563 struct nextfnfield
*new_fnfield
;
15564 struct type
*this_type
;
15565 enum dwarf_access_attribute accessibility
;
15567 if (cu
->language
== language_ada
)
15568 error (_("unexpected member function in Ada type"));
15570 /* Get name of member function. */
15571 fieldname
= dwarf2_name (die
, cu
);
15572 if (fieldname
== NULL
)
15575 /* Look up member function name in fieldlist. */
15576 for (i
= 0; i
< fip
->nfnfields
; i
++)
15578 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
15582 /* Create new list element if necessary. */
15583 if (i
< fip
->nfnfields
)
15584 flp
= &fip
->fnfieldlists
[i
];
15587 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
15589 fip
->fnfieldlists
= (struct fnfieldlist
*)
15590 xrealloc (fip
->fnfieldlists
,
15591 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
15592 * sizeof (struct fnfieldlist
));
15593 if (fip
->nfnfields
== 0)
15594 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
15596 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
15597 flp
->name
= fieldname
;
15600 i
= fip
->nfnfields
++;
15603 /* Create a new member function field and chain it to the field list
15605 new_fnfield
= XNEW (struct nextfnfield
);
15606 make_cleanup (xfree
, new_fnfield
);
15607 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
15608 new_fnfield
->next
= flp
->head
;
15609 flp
->head
= new_fnfield
;
15612 /* Fill in the member function field info. */
15613 fnp
= &new_fnfield
->fnfield
;
15615 /* Delay processing of the physname until later. */
15616 if (cu
->language
== language_cplus
)
15618 add_to_method_list (type
, i
, flp
->length
- 1, fieldname
,
15623 const char *physname
= dwarf2_physname (fieldname
, die
, cu
);
15624 fnp
->physname
= physname
? physname
: "";
15627 fnp
->type
= alloc_type (objfile
);
15628 this_type
= read_type_die (die
, cu
);
15629 if (this_type
&& TYPE_CODE (this_type
) == TYPE_CODE_FUNC
)
15631 int nparams
= TYPE_NFIELDS (this_type
);
15633 /* TYPE is the domain of this method, and THIS_TYPE is the type
15634 of the method itself (TYPE_CODE_METHOD). */
15635 smash_to_method_type (fnp
->type
, type
,
15636 TYPE_TARGET_TYPE (this_type
),
15637 TYPE_FIELDS (this_type
),
15638 TYPE_NFIELDS (this_type
),
15639 TYPE_VARARGS (this_type
));
15641 /* Handle static member functions.
15642 Dwarf2 has no clean way to discern C++ static and non-static
15643 member functions. G++ helps GDB by marking the first
15644 parameter for non-static member functions (which is the this
15645 pointer) as artificial. We obtain this information from
15646 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
15647 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (this_type
, 0) == 0)
15648 fnp
->voffset
= VOFFSET_STATIC
;
15651 complaint (&symfile_complaints
, _("member function type missing for '%s'"),
15652 dwarf2_full_name (fieldname
, die
, cu
));
15654 /* Get fcontext from DW_AT_containing_type if present. */
15655 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
15656 fnp
->fcontext
= die_containing_type (die
, cu
);
15658 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
15659 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
15661 /* Get accessibility. */
15662 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
15664 accessibility
= (enum dwarf_access_attribute
) DW_UNSND (attr
);
15666 accessibility
= dwarf2_default_access_attribute (die
, cu
);
15667 switch (accessibility
)
15669 case DW_ACCESS_private
:
15670 fnp
->is_private
= 1;
15672 case DW_ACCESS_protected
:
15673 fnp
->is_protected
= 1;
15677 /* Check for artificial methods. */
15678 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
15679 if (attr
&& DW_UNSND (attr
) != 0)
15680 fnp
->is_artificial
= 1;
15682 fnp
->is_constructor
= dwarf2_is_constructor (die
, cu
);
15684 /* Get index in virtual function table if it is a virtual member
15685 function. For older versions of GCC, this is an offset in the
15686 appropriate virtual table, as specified by DW_AT_containing_type.
15687 For everyone else, it is an expression to be evaluated relative
15688 to the object address. */
15690 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
15693 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
> 0)
15695 if (DW_BLOCK (attr
)->data
[0] == DW_OP_constu
)
15697 /* Old-style GCC. */
15698 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
15700 else if (DW_BLOCK (attr
)->data
[0] == DW_OP_deref
15701 || (DW_BLOCK (attr
)->size
> 1
15702 && DW_BLOCK (attr
)->data
[0] == DW_OP_deref_size
15703 && DW_BLOCK (attr
)->data
[1] == cu
->header
.addr_size
))
15705 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
);
15706 if ((fnp
->voffset
% cu
->header
.addr_size
) != 0)
15707 dwarf2_complex_location_expr_complaint ();
15709 fnp
->voffset
/= cu
->header
.addr_size
;
15713 dwarf2_complex_location_expr_complaint ();
15715 if (!fnp
->fcontext
)
15717 /* If there is no `this' field and no DW_AT_containing_type,
15718 we cannot actually find a base class context for the
15720 if (TYPE_NFIELDS (this_type
) == 0
15721 || !TYPE_FIELD_ARTIFICIAL (this_type
, 0))
15723 complaint (&symfile_complaints
,
15724 _("cannot determine context for virtual member "
15725 "function \"%s\" (offset %d)"),
15726 fieldname
, to_underlying (die
->sect_off
));
15731 = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type
, 0));
15735 else if (attr_form_is_section_offset (attr
))
15737 dwarf2_complex_location_expr_complaint ();
15741 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
15747 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
15748 if (attr
&& DW_UNSND (attr
))
15750 /* GCC does this, as of 2008-08-25; PR debug/37237. */
15751 complaint (&symfile_complaints
,
15752 _("Member function \"%s\" (offset %d) is virtual "
15753 "but the vtable offset is not specified"),
15754 fieldname
, to_underlying (die
->sect_off
));
15755 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15756 TYPE_CPLUS_DYNAMIC (type
) = 1;
15761 /* Create the vector of member function fields, and attach it to the type. */
15764 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
15765 struct dwarf2_cu
*cu
)
15767 struct fnfieldlist
*flp
;
15770 if (cu
->language
== language_ada
)
15771 error (_("unexpected member functions in Ada type"));
15773 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15774 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
15775 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
15777 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
15779 struct nextfnfield
*nfp
= flp
->head
;
15780 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
15783 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
15784 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
15785 fn_flp
->fn_fields
= (struct fn_field
*)
15786 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
15787 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
15788 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
15791 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
15794 /* Returns non-zero if NAME is the name of a vtable member in CU's
15795 language, zero otherwise. */
15797 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
15799 static const char vptr
[] = "_vptr";
15801 /* Look for the C++ form of the vtable. */
15802 if (startswith (name
, vptr
) && is_cplus_marker (name
[sizeof (vptr
) - 1]))
15808 /* GCC outputs unnamed structures that are really pointers to member
15809 functions, with the ABI-specified layout. If TYPE describes
15810 such a structure, smash it into a member function type.
15812 GCC shouldn't do this; it should just output pointer to member DIEs.
15813 This is GCC PR debug/28767. */
15816 quirk_gcc_member_function_pointer (struct type
*type
, struct objfile
*objfile
)
15818 struct type
*pfn_type
, *self_type
, *new_type
;
15820 /* Check for a structure with no name and two children. */
15821 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
|| TYPE_NFIELDS (type
) != 2)
15824 /* Check for __pfn and __delta members. */
15825 if (TYPE_FIELD_NAME (type
, 0) == NULL
15826 || strcmp (TYPE_FIELD_NAME (type
, 0), "__pfn") != 0
15827 || TYPE_FIELD_NAME (type
, 1) == NULL
15828 || strcmp (TYPE_FIELD_NAME (type
, 1), "__delta") != 0)
15831 /* Find the type of the method. */
15832 pfn_type
= TYPE_FIELD_TYPE (type
, 0);
15833 if (pfn_type
== NULL
15834 || TYPE_CODE (pfn_type
) != TYPE_CODE_PTR
15835 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type
)) != TYPE_CODE_FUNC
)
15838 /* Look for the "this" argument. */
15839 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
15840 if (TYPE_NFIELDS (pfn_type
) == 0
15841 /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
15842 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type
, 0)) != TYPE_CODE_PTR
)
15845 self_type
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type
, 0));
15846 new_type
= alloc_type (objfile
);
15847 smash_to_method_type (new_type
, self_type
, TYPE_TARGET_TYPE (pfn_type
),
15848 TYPE_FIELDS (pfn_type
), TYPE_NFIELDS (pfn_type
),
15849 TYPE_VARARGS (pfn_type
));
15850 smash_to_methodptr_type (type
, new_type
);
15854 /* Called when we find the DIE that starts a structure or union scope
15855 (definition) to create a type for the structure or union. Fill in
15856 the type's name and general properties; the members will not be
15857 processed until process_structure_scope. A symbol table entry for
15858 the type will also not be done until process_structure_scope (assuming
15859 the type has a name).
15861 NOTE: we need to call these functions regardless of whether or not the
15862 DIE has a DW_AT_name attribute, since it might be an anonymous
15863 structure or union. This gets the type entered into our set of
15864 user defined types. */
15866 static struct type
*
15867 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
15869 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
15871 struct attribute
*attr
;
15874 /* If the definition of this type lives in .debug_types, read that type.
15875 Don't follow DW_AT_specification though, that will take us back up
15876 the chain and we want to go down. */
15877 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
);
15880 type
= get_DW_AT_signature_type (die
, attr
, cu
);
15882 /* The type's CU may not be the same as CU.
15883 Ensure TYPE is recorded with CU in die_type_hash. */
15884 return set_die_type (die
, type
, cu
);
15887 type
= alloc_type (objfile
);
15888 INIT_CPLUS_SPECIFIC (type
);
15890 name
= dwarf2_name (die
, cu
);
15893 if (cu
->language
== language_cplus
15894 || cu
->language
== language_d
15895 || cu
->language
== language_rust
)
15897 const char *full_name
= dwarf2_full_name (name
, die
, cu
);
15899 /* dwarf2_full_name might have already finished building the DIE's
15900 type. If so, there is no need to continue. */
15901 if (get_die_type (die
, cu
) != NULL
)
15902 return get_die_type (die
, cu
);
15904 TYPE_TAG_NAME (type
) = full_name
;
15905 if (die
->tag
== DW_TAG_structure_type
15906 || die
->tag
== DW_TAG_class_type
)
15907 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
15911 /* The name is already allocated along with this objfile, so
15912 we don't need to duplicate it for the type. */
15913 TYPE_TAG_NAME (type
) = name
;
15914 if (die
->tag
== DW_TAG_class_type
)
15915 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
15919 if (die
->tag
== DW_TAG_structure_type
)
15921 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
15923 else if (die
->tag
== DW_TAG_union_type
)
15925 TYPE_CODE (type
) = TYPE_CODE_UNION
;
15929 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
15932 if (cu
->language
== language_cplus
&& die
->tag
== DW_TAG_class_type
)
15933 TYPE_DECLARED_CLASS (type
) = 1;
15935 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
15938 if (attr_form_is_constant (attr
))
15939 TYPE_LENGTH (type
) = DW_UNSND (attr
);
15942 /* For the moment, dynamic type sizes are not supported
15943 by GDB's struct type. The actual size is determined
15944 on-demand when resolving the type of a given object,
15945 so set the type's length to zero for now. Otherwise,
15946 we record an expression as the length, and that expression
15947 could lead to a very large value, which could eventually
15948 lead to us trying to allocate that much memory when creating
15949 a value of that type. */
15950 TYPE_LENGTH (type
) = 0;
15955 TYPE_LENGTH (type
) = 0;
15958 if (producer_is_icc_lt_14 (cu
) && (TYPE_LENGTH (type
) == 0))
15960 /* ICC<14 does not output the required DW_AT_declaration on
15961 incomplete types, but gives them a size of zero. */
15962 TYPE_STUB (type
) = 1;
15965 TYPE_STUB_SUPPORTED (type
) = 1;
15967 if (die_is_declaration (die
, cu
))
15968 TYPE_STUB (type
) = 1;
15969 else if (attr
== NULL
&& die
->child
== NULL
15970 && producer_is_realview (cu
->producer
))
15971 /* RealView does not output the required DW_AT_declaration
15972 on incomplete types. */
15973 TYPE_STUB (type
) = 1;
15975 /* We need to add the type field to the die immediately so we don't
15976 infinitely recurse when dealing with pointers to the structure
15977 type within the structure itself. */
15978 set_die_type (die
, type
, cu
);
15980 /* set_die_type should be already done. */
15981 set_descriptive_type (type
, die
, cu
);
15986 /* Finish creating a structure or union type, including filling in
15987 its members and creating a symbol for it. */
15990 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
15992 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
15993 struct die_info
*child_die
;
15996 type
= get_die_type (die
, cu
);
15998 type
= read_structure_type (die
, cu
);
16000 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
16002 struct field_info fi
;
16003 std::vector
<struct symbol
*> template_args
;
16004 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
16006 memset (&fi
, 0, sizeof (struct field_info
));
16008 child_die
= die
->child
;
16010 while (child_die
&& child_die
->tag
)
16012 if (child_die
->tag
== DW_TAG_member
16013 || child_die
->tag
== DW_TAG_variable
)
16015 /* NOTE: carlton/2002-11-05: A C++ static data member
16016 should be a DW_TAG_member that is a declaration, but
16017 all versions of G++ as of this writing (so through at
16018 least 3.2.1) incorrectly generate DW_TAG_variable
16019 tags for them instead. */
16020 dwarf2_add_field (&fi
, child_die
, cu
);
16022 else if (child_die
->tag
== DW_TAG_subprogram
)
16024 /* Rust doesn't have member functions in the C++ sense.
16025 However, it does emit ordinary functions as children
16026 of a struct DIE. */
16027 if (cu
->language
== language_rust
)
16028 read_func_scope (child_die
, cu
);
16031 /* C++ member function. */
16032 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
16035 else if (child_die
->tag
== DW_TAG_inheritance
)
16037 /* C++ base class field. */
16038 dwarf2_add_field (&fi
, child_die
, cu
);
16040 else if (type_can_define_types (child_die
))
16041 dwarf2_add_type_defn (&fi
, child_die
, cu
);
16042 else if (child_die
->tag
== DW_TAG_template_type_param
16043 || child_die
->tag
== DW_TAG_template_value_param
)
16045 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
16048 template_args
.push_back (arg
);
16051 child_die
= sibling_die (child_die
);
16054 /* Attach template arguments to type. */
16055 if (!template_args
.empty ())
16057 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
16058 TYPE_N_TEMPLATE_ARGUMENTS (type
) = template_args
.size ();
16059 TYPE_TEMPLATE_ARGUMENTS (type
)
16060 = XOBNEWVEC (&objfile
->objfile_obstack
,
16062 TYPE_N_TEMPLATE_ARGUMENTS (type
));
16063 memcpy (TYPE_TEMPLATE_ARGUMENTS (type
),
16064 template_args
.data (),
16065 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
16066 * sizeof (struct symbol
*)));
16069 /* Attach fields and member functions to the type. */
16071 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
16074 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
16076 /* Get the type which refers to the base class (possibly this
16077 class itself) which contains the vtable pointer for the current
16078 class from the DW_AT_containing_type attribute. This use of
16079 DW_AT_containing_type is a GNU extension. */
16081 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
16083 struct type
*t
= die_containing_type (die
, cu
);
16085 set_type_vptr_basetype (type
, t
);
16090 /* Our own class provides vtbl ptr. */
16091 for (i
= TYPE_NFIELDS (t
) - 1;
16092 i
>= TYPE_N_BASECLASSES (t
);
16095 const char *fieldname
= TYPE_FIELD_NAME (t
, i
);
16097 if (is_vtable_name (fieldname
, cu
))
16099 set_type_vptr_fieldno (type
, i
);
16104 /* Complain if virtual function table field not found. */
16105 if (i
< TYPE_N_BASECLASSES (t
))
16106 complaint (&symfile_complaints
,
16107 _("virtual function table pointer "
16108 "not found when defining class '%s'"),
16109 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
16114 set_type_vptr_fieldno (type
, TYPE_VPTR_FIELDNO (t
));
16117 else if (cu
->producer
16118 && startswith (cu
->producer
, "IBM(R) XL C/C++ Advanced Edition"))
16120 /* The IBM XLC compiler does not provide direct indication
16121 of the containing type, but the vtable pointer is
16122 always named __vfp. */
16126 for (i
= TYPE_NFIELDS (type
) - 1;
16127 i
>= TYPE_N_BASECLASSES (type
);
16130 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
16132 set_type_vptr_fieldno (type
, i
);
16133 set_type_vptr_basetype (type
, type
);
16140 /* Copy fi.typedef_field_list linked list elements content into the
16141 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
16142 if (fi
.typedef_field_list
)
16144 int i
= fi
.typedef_field_list_count
;
16146 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
16147 TYPE_TYPEDEF_FIELD_ARRAY (type
)
16148 = ((struct decl_field
*)
16149 TYPE_ALLOC (type
, sizeof (TYPE_TYPEDEF_FIELD (type
, 0)) * i
));
16150 TYPE_TYPEDEF_FIELD_COUNT (type
) = i
;
16152 /* Reverse the list order to keep the debug info elements order. */
16155 struct decl_field
*dest
, *src
;
16157 dest
= &TYPE_TYPEDEF_FIELD (type
, i
);
16158 src
= &fi
.typedef_field_list
->field
;
16159 fi
.typedef_field_list
= fi
.typedef_field_list
->next
;
16164 /* Copy fi.nested_types_list linked list elements content into the
16165 allocated array TYPE_NESTED_TYPES_ARRAY (type). */
16166 if (fi
.nested_types_list
!= NULL
&& cu
->language
!= language_ada
)
16168 int i
= fi
.nested_types_list_count
;
16170 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
16171 TYPE_NESTED_TYPES_ARRAY (type
)
16172 = ((struct decl_field
*)
16173 TYPE_ALLOC (type
, sizeof (struct decl_field
) * i
));
16174 TYPE_NESTED_TYPES_COUNT (type
) = i
;
16176 /* Reverse the list order to keep the debug info elements order. */
16179 struct decl_field
*dest
, *src
;
16181 dest
= &TYPE_NESTED_TYPES_FIELD (type
, i
);
16182 src
= &fi
.nested_types_list
->field
;
16183 fi
.nested_types_list
= fi
.nested_types_list
->next
;
16188 do_cleanups (back_to
);
16191 quirk_gcc_member_function_pointer (type
, objfile
);
16193 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
16194 snapshots) has been known to create a die giving a declaration
16195 for a class that has, as a child, a die giving a definition for a
16196 nested class. So we have to process our children even if the
16197 current die is a declaration. Normally, of course, a declaration
16198 won't have any children at all. */
16200 child_die
= die
->child
;
16202 while (child_die
!= NULL
&& child_die
->tag
)
16204 if (child_die
->tag
== DW_TAG_member
16205 || child_die
->tag
== DW_TAG_variable
16206 || child_die
->tag
== DW_TAG_inheritance
16207 || child_die
->tag
== DW_TAG_template_value_param
16208 || child_die
->tag
== DW_TAG_template_type_param
)
16213 process_die (child_die
, cu
);
16215 child_die
= sibling_die (child_die
);
16218 /* Do not consider external references. According to the DWARF standard,
16219 these DIEs are identified by the fact that they have no byte_size
16220 attribute, and a declaration attribute. */
16221 if (dwarf2_attr (die
, DW_AT_byte_size
, cu
) != NULL
16222 || !die_is_declaration (die
, cu
))
16223 new_symbol (die
, type
, cu
);
16226 /* Assuming DIE is an enumeration type, and TYPE is its associated type,
16227 update TYPE using some information only available in DIE's children. */
16230 update_enumeration_type_from_children (struct die_info
*die
,
16232 struct dwarf2_cu
*cu
)
16234 struct die_info
*child_die
;
16235 int unsigned_enum
= 1;
16239 auto_obstack obstack
;
16241 for (child_die
= die
->child
;
16242 child_die
!= NULL
&& child_die
->tag
;
16243 child_die
= sibling_die (child_die
))
16245 struct attribute
*attr
;
16247 const gdb_byte
*bytes
;
16248 struct dwarf2_locexpr_baton
*baton
;
16251 if (child_die
->tag
!= DW_TAG_enumerator
)
16254 attr
= dwarf2_attr (child_die
, DW_AT_const_value
, cu
);
16258 name
= dwarf2_name (child_die
, cu
);
16260 name
= "<anonymous enumerator>";
16262 dwarf2_const_value_attr (attr
, type
, name
, &obstack
, cu
,
16263 &value
, &bytes
, &baton
);
16269 else if ((mask
& value
) != 0)
16274 /* If we already know that the enum type is neither unsigned, nor
16275 a flag type, no need to look at the rest of the enumerates. */
16276 if (!unsigned_enum
&& !flag_enum
)
16281 TYPE_UNSIGNED (type
) = 1;
16283 TYPE_FLAG_ENUM (type
) = 1;
16286 /* Given a DW_AT_enumeration_type die, set its type. We do not
16287 complete the type's fields yet, or create any symbols. */
16289 static struct type
*
16290 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16292 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
16294 struct attribute
*attr
;
16297 /* If the definition of this type lives in .debug_types, read that type.
16298 Don't follow DW_AT_specification though, that will take us back up
16299 the chain and we want to go down. */
16300 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
);
16303 type
= get_DW_AT_signature_type (die
, attr
, cu
);
16305 /* The type's CU may not be the same as CU.
16306 Ensure TYPE is recorded with CU in die_type_hash. */
16307 return set_die_type (die
, type
, cu
);
16310 type
= alloc_type (objfile
);
16312 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
16313 name
= dwarf2_full_name (NULL
, die
, cu
);
16315 TYPE_TAG_NAME (type
) = name
;
16317 attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
16320 struct type
*underlying_type
= die_type (die
, cu
);
16322 TYPE_TARGET_TYPE (type
) = underlying_type
;
16325 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16328 TYPE_LENGTH (type
) = DW_UNSND (attr
);
16332 TYPE_LENGTH (type
) = 0;
16335 /* The enumeration DIE can be incomplete. In Ada, any type can be
16336 declared as private in the package spec, and then defined only
16337 inside the package body. Such types are known as Taft Amendment
16338 Types. When another package uses such a type, an incomplete DIE
16339 may be generated by the compiler. */
16340 if (die_is_declaration (die
, cu
))
16341 TYPE_STUB (type
) = 1;
16343 /* Finish the creation of this type by using the enum's children.
16344 We must call this even when the underlying type has been provided
16345 so that we can determine if we're looking at a "flag" enum. */
16346 update_enumeration_type_from_children (die
, type
, cu
);
16348 /* If this type has an underlying type that is not a stub, then we
16349 may use its attributes. We always use the "unsigned" attribute
16350 in this situation, because ordinarily we guess whether the type
16351 is unsigned -- but the guess can be wrong and the underlying type
16352 can tell us the reality. However, we defer to a local size
16353 attribute if one exists, because this lets the compiler override
16354 the underlying type if needed. */
16355 if (TYPE_TARGET_TYPE (type
) != NULL
&& !TYPE_STUB (TYPE_TARGET_TYPE (type
)))
16357 TYPE_UNSIGNED (type
) = TYPE_UNSIGNED (TYPE_TARGET_TYPE (type
));
16358 if (TYPE_LENGTH (type
) == 0)
16359 TYPE_LENGTH (type
) = TYPE_LENGTH (TYPE_TARGET_TYPE (type
));
16362 TYPE_DECLARED_CLASS (type
) = dwarf2_flag_true_p (die
, DW_AT_enum_class
, cu
);
16364 return set_die_type (die
, type
, cu
);
16367 /* Given a pointer to a die which begins an enumeration, process all
16368 the dies that define the members of the enumeration, and create the
16369 symbol for the enumeration type.
16371 NOTE: We reverse the order of the element list. */
16374 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
16376 struct type
*this_type
;
16378 this_type
= get_die_type (die
, cu
);
16379 if (this_type
== NULL
)
16380 this_type
= read_enumeration_type (die
, cu
);
16382 if (die
->child
!= NULL
)
16384 struct die_info
*child_die
;
16385 struct symbol
*sym
;
16386 struct field
*fields
= NULL
;
16387 int num_fields
= 0;
16390 child_die
= die
->child
;
16391 while (child_die
&& child_die
->tag
)
16393 if (child_die
->tag
!= DW_TAG_enumerator
)
16395 process_die (child_die
, cu
);
16399 name
= dwarf2_name (child_die
, cu
);
16402 sym
= new_symbol (child_die
, this_type
, cu
);
16404 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
16406 fields
= (struct field
*)
16408 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
16409 * sizeof (struct field
));
16412 FIELD_NAME (fields
[num_fields
]) = SYMBOL_LINKAGE_NAME (sym
);
16413 FIELD_TYPE (fields
[num_fields
]) = NULL
;
16414 SET_FIELD_ENUMVAL (fields
[num_fields
], SYMBOL_VALUE (sym
));
16415 FIELD_BITSIZE (fields
[num_fields
]) = 0;
16421 child_die
= sibling_die (child_die
);
16426 TYPE_NFIELDS (this_type
) = num_fields
;
16427 TYPE_FIELDS (this_type
) = (struct field
*)
16428 TYPE_ALLOC (this_type
, sizeof (struct field
) * num_fields
);
16429 memcpy (TYPE_FIELDS (this_type
), fields
,
16430 sizeof (struct field
) * num_fields
);
16435 /* If we are reading an enum from a .debug_types unit, and the enum
16436 is a declaration, and the enum is not the signatured type in the
16437 unit, then we do not want to add a symbol for it. Adding a
16438 symbol would in some cases obscure the true definition of the
16439 enum, giving users an incomplete type when the definition is
16440 actually available. Note that we do not want to do this for all
16441 enums which are just declarations, because C++0x allows forward
16442 enum declarations. */
16443 if (cu
->per_cu
->is_debug_types
16444 && die_is_declaration (die
, cu
))
16446 struct signatured_type
*sig_type
;
16448 sig_type
= (struct signatured_type
*) cu
->per_cu
;
16449 gdb_assert (to_underlying (sig_type
->type_offset_in_section
) != 0);
16450 if (sig_type
->type_offset_in_section
!= die
->sect_off
)
16454 new_symbol (die
, this_type
, cu
);
16457 /* Extract all information from a DW_TAG_array_type DIE and put it in
16458 the DIE's type field. For now, this only handles one dimensional
16461 static struct type
*
16462 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16464 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
16465 struct die_info
*child_die
;
16467 struct type
*element_type
, *range_type
, *index_type
;
16468 struct attribute
*attr
;
16470 struct dynamic_prop
*byte_stride_prop
= NULL
;
16471 unsigned int bit_stride
= 0;
16473 element_type
= die_type (die
, cu
);
16475 /* The die_type call above may have already set the type for this DIE. */
16476 type
= get_die_type (die
, cu
);
16480 attr
= dwarf2_attr (die
, DW_AT_byte_stride
, cu
);
16486 = (struct dynamic_prop
*) alloca (sizeof (struct dynamic_prop
));
16487 stride_ok
= attr_to_dynamic_prop (attr
, die
, cu
, byte_stride_prop
);
16490 complaint (&symfile_complaints
,
16491 _("unable to read array DW_AT_byte_stride "
16492 " - DIE at 0x%x [in module %s]"),
16493 to_underlying (die
->sect_off
),
16494 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
16495 /* Ignore this attribute. We will likely not be able to print
16496 arrays of this type correctly, but there is little we can do
16497 to help if we cannot read the attribute's value. */
16498 byte_stride_prop
= NULL
;
16502 attr
= dwarf2_attr (die
, DW_AT_bit_stride
, cu
);
16504 bit_stride
= DW_UNSND (attr
);
16506 /* Irix 6.2 native cc creates array types without children for
16507 arrays with unspecified length. */
16508 if (die
->child
== NULL
)
16510 index_type
= objfile_type (objfile
)->builtin_int
;
16511 range_type
= create_static_range_type (NULL
, index_type
, 0, -1);
16512 type
= create_array_type_with_stride (NULL
, element_type
, range_type
,
16513 byte_stride_prop
, bit_stride
);
16514 return set_die_type (die
, type
, cu
);
16517 std::vector
<struct type
*> range_types
;
16518 child_die
= die
->child
;
16519 while (child_die
&& child_die
->tag
)
16521 if (child_die
->tag
== DW_TAG_subrange_type
)
16523 struct type
*child_type
= read_type_die (child_die
, cu
);
16525 if (child_type
!= NULL
)
16527 /* The range type was succesfully read. Save it for the
16528 array type creation. */
16529 range_types
.push_back (child_type
);
16532 child_die
= sibling_die (child_die
);
16535 /* Dwarf2 dimensions are output from left to right, create the
16536 necessary array types in backwards order. */
16538 type
= element_type
;
16540 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
16544 while (i
< range_types
.size ())
16545 type
= create_array_type_with_stride (NULL
, type
, range_types
[i
++],
16546 byte_stride_prop
, bit_stride
);
16550 size_t ndim
= range_types
.size ();
16552 type
= create_array_type_with_stride (NULL
, type
, range_types
[ndim
],
16553 byte_stride_prop
, bit_stride
);
16556 /* Understand Dwarf2 support for vector types (like they occur on
16557 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
16558 array type. This is not part of the Dwarf2/3 standard yet, but a
16559 custom vendor extension. The main difference between a regular
16560 array and the vector variant is that vectors are passed by value
16562 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
16564 make_vector_type (type
);
16566 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
16567 implementation may choose to implement triple vectors using this
16569 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16572 if (DW_UNSND (attr
) >= TYPE_LENGTH (type
))
16573 TYPE_LENGTH (type
) = DW_UNSND (attr
);
16575 complaint (&symfile_complaints
,
16576 _("DW_AT_byte_size for array type smaller "
16577 "than the total size of elements"));
16580 name
= dwarf2_name (die
, cu
);
16582 TYPE_NAME (type
) = name
;
16584 /* Install the type in the die. */
16585 set_die_type (die
, type
, cu
);
16587 /* set_die_type should be already done. */
16588 set_descriptive_type (type
, die
, cu
);
16593 static enum dwarf_array_dim_ordering
16594 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
16596 struct attribute
*attr
;
16598 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
16601 return (enum dwarf_array_dim_ordering
) DW_SND (attr
);
16603 /* GNU F77 is a special case, as at 08/2004 array type info is the
16604 opposite order to the dwarf2 specification, but data is still
16605 laid out as per normal fortran.
16607 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
16608 version checking. */
16610 if (cu
->language
== language_fortran
16611 && cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
16613 return DW_ORD_row_major
;
16616 switch (cu
->language_defn
->la_array_ordering
)
16618 case array_column_major
:
16619 return DW_ORD_col_major
;
16620 case array_row_major
:
16622 return DW_ORD_row_major
;
16626 /* Extract all information from a DW_TAG_set_type DIE and put it in
16627 the DIE's type field. */
16629 static struct type
*
16630 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16632 struct type
*domain_type
, *set_type
;
16633 struct attribute
*attr
;
16635 domain_type
= die_type (die
, cu
);
16637 /* The die_type call above may have already set the type for this DIE. */
16638 set_type
= get_die_type (die
, cu
);
16642 set_type
= create_set_type (NULL
, domain_type
);
16644 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16646 TYPE_LENGTH (set_type
) = DW_UNSND (attr
);
16648 return set_die_type (die
, set_type
, cu
);
16651 /* A helper for read_common_block that creates a locexpr baton.
16652 SYM is the symbol which we are marking as computed.
16653 COMMON_DIE is the DIE for the common block.
16654 COMMON_LOC is the location expression attribute for the common
16656 MEMBER_LOC is the location expression attribute for the particular
16657 member of the common block that we are processing.
16658 CU is the CU from which the above come. */
16661 mark_common_block_symbol_computed (struct symbol
*sym
,
16662 struct die_info
*common_die
,
16663 struct attribute
*common_loc
,
16664 struct attribute
*member_loc
,
16665 struct dwarf2_cu
*cu
)
16667 struct dwarf2_per_objfile
*dwarf2_per_objfile
16668 = cu
->per_cu
->dwarf2_per_objfile
;
16669 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
16670 struct dwarf2_locexpr_baton
*baton
;
16672 unsigned int cu_off
;
16673 enum bfd_endian byte_order
= gdbarch_byte_order (get_objfile_arch (objfile
));
16674 LONGEST offset
= 0;
16676 gdb_assert (common_loc
&& member_loc
);
16677 gdb_assert (attr_form_is_block (common_loc
));
16678 gdb_assert (attr_form_is_block (member_loc
)
16679 || attr_form_is_constant (member_loc
));
16681 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
16682 baton
->per_cu
= cu
->per_cu
;
16683 gdb_assert (baton
->per_cu
);
16685 baton
->size
= 5 /* DW_OP_call4 */ + 1 /* DW_OP_plus */;
16687 if (attr_form_is_constant (member_loc
))
16689 offset
= dwarf2_get_attr_constant_value (member_loc
, 0);
16690 baton
->size
+= 1 /* DW_OP_addr */ + cu
->header
.addr_size
;
16693 baton
->size
+= DW_BLOCK (member_loc
)->size
;
16695 ptr
= (gdb_byte
*) obstack_alloc (&objfile
->objfile_obstack
, baton
->size
);
16698 *ptr
++ = DW_OP_call4
;
16699 cu_off
= common_die
->sect_off
- cu
->per_cu
->sect_off
;
16700 store_unsigned_integer (ptr
, 4, byte_order
, cu_off
);
16703 if (attr_form_is_constant (member_loc
))
16705 *ptr
++ = DW_OP_addr
;
16706 store_unsigned_integer (ptr
, cu
->header
.addr_size
, byte_order
, offset
);
16707 ptr
+= cu
->header
.addr_size
;
16711 /* We have to copy the data here, because DW_OP_call4 will only
16712 use a DW_AT_location attribute. */
16713 memcpy (ptr
, DW_BLOCK (member_loc
)->data
, DW_BLOCK (member_loc
)->size
);
16714 ptr
+= DW_BLOCK (member_loc
)->size
;
16717 *ptr
++ = DW_OP_plus
;
16718 gdb_assert (ptr
- baton
->data
== baton
->size
);
16720 SYMBOL_LOCATION_BATON (sym
) = baton
;
16721 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
16724 /* Create appropriate locally-scoped variables for all the
16725 DW_TAG_common_block entries. Also create a struct common_block
16726 listing all such variables for `info common'. COMMON_BLOCK_DOMAIN
16727 is used to sepate the common blocks name namespace from regular
16731 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
16733 struct attribute
*attr
;
16735 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
16738 /* Support the .debug_loc offsets. */
16739 if (attr_form_is_block (attr
))
16743 else if (attr_form_is_section_offset (attr
))
16745 dwarf2_complex_location_expr_complaint ();
16750 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
16751 "common block member");
16756 if (die
->child
!= NULL
)
16758 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
16759 struct die_info
*child_die
;
16760 size_t n_entries
= 0, size
;
16761 struct common_block
*common_block
;
16762 struct symbol
*sym
;
16764 for (child_die
= die
->child
;
16765 child_die
&& child_die
->tag
;
16766 child_die
= sibling_die (child_die
))
16769 size
= (sizeof (struct common_block
)
16770 + (n_entries
- 1) * sizeof (struct symbol
*));
16772 = (struct common_block
*) obstack_alloc (&objfile
->objfile_obstack
,
16774 memset (common_block
->contents
, 0, n_entries
* sizeof (struct symbol
*));
16775 common_block
->n_entries
= 0;
16777 for (child_die
= die
->child
;
16778 child_die
&& child_die
->tag
;
16779 child_die
= sibling_die (child_die
))
16781 /* Create the symbol in the DW_TAG_common_block block in the current
16783 sym
= new_symbol (child_die
, NULL
, cu
);
16786 struct attribute
*member_loc
;
16788 common_block
->contents
[common_block
->n_entries
++] = sym
;
16790 member_loc
= dwarf2_attr (child_die
, DW_AT_data_member_location
,
16794 /* GDB has handled this for a long time, but it is
16795 not specified by DWARF. It seems to have been
16796 emitted by gfortran at least as recently as:
16797 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=23057. */
16798 complaint (&symfile_complaints
,
16799 _("Variable in common block has "
16800 "DW_AT_data_member_location "
16801 "- DIE at 0x%x [in module %s]"),
16802 to_underlying (child_die
->sect_off
),
16803 objfile_name (objfile
));
16805 if (attr_form_is_section_offset (member_loc
))
16806 dwarf2_complex_location_expr_complaint ();
16807 else if (attr_form_is_constant (member_loc
)
16808 || attr_form_is_block (member_loc
))
16811 mark_common_block_symbol_computed (sym
, die
, attr
,
16815 dwarf2_complex_location_expr_complaint ();
16820 sym
= new_symbol (die
, objfile_type (objfile
)->builtin_void
, cu
);
16821 SYMBOL_VALUE_COMMON_BLOCK (sym
) = common_block
;
16825 /* Create a type for a C++ namespace. */
16827 static struct type
*
16828 read_namespace_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16830 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
16831 const char *previous_prefix
, *name
;
16835 /* For extensions, reuse the type of the original namespace. */
16836 if (dwarf2_attr (die
, DW_AT_extension
, cu
) != NULL
)
16838 struct die_info
*ext_die
;
16839 struct dwarf2_cu
*ext_cu
= cu
;
16841 ext_die
= dwarf2_extension (die
, &ext_cu
);
16842 type
= read_type_die (ext_die
, ext_cu
);
16844 /* EXT_CU may not be the same as CU.
16845 Ensure TYPE is recorded with CU in die_type_hash. */
16846 return set_die_type (die
, type
, cu
);
16849 name
= namespace_name (die
, &is_anonymous
, cu
);
16851 /* Now build the name of the current namespace. */
16853 previous_prefix
= determine_prefix (die
, cu
);
16854 if (previous_prefix
[0] != '\0')
16855 name
= typename_concat (&objfile
->objfile_obstack
,
16856 previous_prefix
, name
, 0, cu
);
16858 /* Create the type. */
16859 type
= init_type (objfile
, TYPE_CODE_NAMESPACE
, 0, name
);
16860 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
16862 return set_die_type (die
, type
, cu
);
16865 /* Read a namespace scope. */
16868 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
16870 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
16873 /* Add a symbol associated to this if we haven't seen the namespace
16874 before. Also, add a using directive if it's an anonymous
16877 if (dwarf2_attr (die
, DW_AT_extension
, cu
) == NULL
)
16881 type
= read_type_die (die
, cu
);
16882 new_symbol (die
, type
, cu
);
16884 namespace_name (die
, &is_anonymous
, cu
);
16887 const char *previous_prefix
= determine_prefix (die
, cu
);
16889 std::vector
<const char *> excludes
;
16890 add_using_directive (using_directives (cu
->language
),
16891 previous_prefix
, TYPE_NAME (type
), NULL
,
16892 NULL
, excludes
, 0, &objfile
->objfile_obstack
);
16896 if (die
->child
!= NULL
)
16898 struct die_info
*child_die
= die
->child
;
16900 while (child_die
&& child_die
->tag
)
16902 process_die (child_die
, cu
);
16903 child_die
= sibling_die (child_die
);
16908 /* Read a Fortran module as type. This DIE can be only a declaration used for
16909 imported module. Still we need that type as local Fortran "use ... only"
16910 declaration imports depend on the created type in determine_prefix. */
16912 static struct type
*
16913 read_module_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16915 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
16916 const char *module_name
;
16919 module_name
= dwarf2_name (die
, cu
);
16921 complaint (&symfile_complaints
,
16922 _("DW_TAG_module has no name, offset 0x%x"),
16923 to_underlying (die
->sect_off
));
16924 type
= init_type (objfile
, TYPE_CODE_MODULE
, 0, module_name
);
16926 /* determine_prefix uses TYPE_TAG_NAME. */
16927 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
16929 return set_die_type (die
, type
, cu
);
16932 /* Read a Fortran module. */
16935 read_module (struct die_info
*die
, struct dwarf2_cu
*cu
)
16937 struct die_info
*child_die
= die
->child
;
16940 type
= read_type_die (die
, cu
);
16941 new_symbol (die
, type
, cu
);
16943 while (child_die
&& child_die
->tag
)
16945 process_die (child_die
, cu
);
16946 child_die
= sibling_die (child_die
);
16950 /* Return the name of the namespace represented by DIE. Set
16951 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
16954 static const char *
16955 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
16957 struct die_info
*current_die
;
16958 const char *name
= NULL
;
16960 /* Loop through the extensions until we find a name. */
16962 for (current_die
= die
;
16963 current_die
!= NULL
;
16964 current_die
= dwarf2_extension (die
, &cu
))
16966 /* We don't use dwarf2_name here so that we can detect the absence
16967 of a name -> anonymous namespace. */
16968 name
= dwarf2_string_attr (die
, DW_AT_name
, cu
);
16974 /* Is it an anonymous namespace? */
16976 *is_anonymous
= (name
== NULL
);
16978 name
= CP_ANONYMOUS_NAMESPACE_STR
;
16983 /* Extract all information from a DW_TAG_pointer_type DIE and add to
16984 the user defined type vector. */
16986 static struct type
*
16987 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16989 struct gdbarch
*gdbarch
16990 = get_objfile_arch (cu
->per_cu
->dwarf2_per_objfile
->objfile
);
16991 struct comp_unit_head
*cu_header
= &cu
->header
;
16993 struct attribute
*attr_byte_size
;
16994 struct attribute
*attr_address_class
;
16995 int byte_size
, addr_class
;
16996 struct type
*target_type
;
16998 target_type
= die_type (die
, cu
);
17000 /* The die_type call above may have already set the type for this DIE. */
17001 type
= get_die_type (die
, cu
);
17005 type
= lookup_pointer_type (target_type
);
17007 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17008 if (attr_byte_size
)
17009 byte_size
= DW_UNSND (attr_byte_size
);
17011 byte_size
= cu_header
->addr_size
;
17013 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
17014 if (attr_address_class
)
17015 addr_class
= DW_UNSND (attr_address_class
);
17017 addr_class
= DW_ADDR_none
;
17019 /* If the pointer size or address class is different than the
17020 default, create a type variant marked as such and set the
17021 length accordingly. */
17022 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
17024 if (gdbarch_address_class_type_flags_p (gdbarch
))
17028 type_flags
= gdbarch_address_class_type_flags
17029 (gdbarch
, byte_size
, addr_class
);
17030 gdb_assert ((type_flags
& ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
17032 type
= make_type_with_address_space (type
, type_flags
);
17034 else if (TYPE_LENGTH (type
) != byte_size
)
17036 complaint (&symfile_complaints
,
17037 _("invalid pointer size %d"), byte_size
);
17041 /* Should we also complain about unhandled address classes? */
17045 TYPE_LENGTH (type
) = byte_size
;
17046 return set_die_type (die
, type
, cu
);
17049 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
17050 the user defined type vector. */
17052 static struct type
*
17053 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17056 struct type
*to_type
;
17057 struct type
*domain
;
17059 to_type
= die_type (die
, cu
);
17060 domain
= die_containing_type (die
, cu
);
17062 /* The calls above may have already set the type for this DIE. */
17063 type
= get_die_type (die
, cu
);
17067 if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_METHOD
)
17068 type
= lookup_methodptr_type (to_type
);
17069 else if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_FUNC
)
17071 struct type
*new_type
17072 = alloc_type (cu
->per_cu
->dwarf2_per_objfile
->objfile
);
17074 smash_to_method_type (new_type
, domain
, TYPE_TARGET_TYPE (to_type
),
17075 TYPE_FIELDS (to_type
), TYPE_NFIELDS (to_type
),
17076 TYPE_VARARGS (to_type
));
17077 type
= lookup_methodptr_type (new_type
);
17080 type
= lookup_memberptr_type (to_type
, domain
);
17082 return set_die_type (die
, type
, cu
);
17085 /* Extract all information from a DW_TAG_{rvalue_,}reference_type DIE and add to
17086 the user defined type vector. */
17088 static struct type
*
17089 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
,
17090 enum type_code refcode
)
17092 struct comp_unit_head
*cu_header
= &cu
->header
;
17093 struct type
*type
, *target_type
;
17094 struct attribute
*attr
;
17096 gdb_assert (refcode
== TYPE_CODE_REF
|| refcode
== TYPE_CODE_RVALUE_REF
);
17098 target_type
= die_type (die
, cu
);
17100 /* The die_type call above may have already set the type for this DIE. */
17101 type
= get_die_type (die
, cu
);
17105 type
= lookup_reference_type (target_type
, refcode
);
17106 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17109 TYPE_LENGTH (type
) = DW_UNSND (attr
);
17113 TYPE_LENGTH (type
) = cu_header
->addr_size
;
17115 return set_die_type (die
, type
, cu
);
17118 /* Add the given cv-qualifiers to the element type of the array. GCC
17119 outputs DWARF type qualifiers that apply to an array, not the
17120 element type. But GDB relies on the array element type to carry
17121 the cv-qualifiers. This mimics section 6.7.3 of the C99
17124 static struct type
*
17125 add_array_cv_type (struct die_info
*die
, struct dwarf2_cu
*cu
,
17126 struct type
*base_type
, int cnst
, int voltl
)
17128 struct type
*el_type
, *inner_array
;
17130 base_type
= copy_type (base_type
);
17131 inner_array
= base_type
;
17133 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array
)) == TYPE_CODE_ARRAY
)
17135 TYPE_TARGET_TYPE (inner_array
) =
17136 copy_type (TYPE_TARGET_TYPE (inner_array
));
17137 inner_array
= TYPE_TARGET_TYPE (inner_array
);
17140 el_type
= TYPE_TARGET_TYPE (inner_array
);
17141 cnst
|= TYPE_CONST (el_type
);
17142 voltl
|= TYPE_VOLATILE (el_type
);
17143 TYPE_TARGET_TYPE (inner_array
) = make_cv_type (cnst
, voltl
, el_type
, NULL
);
17145 return set_die_type (die
, base_type
, cu
);
17148 static struct type
*
17149 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17151 struct type
*base_type
, *cv_type
;
17153 base_type
= die_type (die
, cu
);
17155 /* The die_type call above may have already set the type for this DIE. */
17156 cv_type
= get_die_type (die
, cu
);
17160 /* In case the const qualifier is applied to an array type, the element type
17161 is so qualified, not the array type (section 6.7.3 of C99). */
17162 if (TYPE_CODE (base_type
) == TYPE_CODE_ARRAY
)
17163 return add_array_cv_type (die
, cu
, base_type
, 1, 0);
17165 cv_type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
17166 return set_die_type (die
, cv_type
, cu
);
17169 static struct type
*
17170 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17172 struct type
*base_type
, *cv_type
;
17174 base_type
= die_type (die
, cu
);
17176 /* The die_type call above may have already set the type for this DIE. */
17177 cv_type
= get_die_type (die
, cu
);
17181 /* In case the volatile qualifier is applied to an array type, the
17182 element type is so qualified, not the array type (section 6.7.3
17184 if (TYPE_CODE (base_type
) == TYPE_CODE_ARRAY
)
17185 return add_array_cv_type (die
, cu
, base_type
, 0, 1);
17187 cv_type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
17188 return set_die_type (die
, cv_type
, cu
);
17191 /* Handle DW_TAG_restrict_type. */
17193 static struct type
*
17194 read_tag_restrict_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17196 struct type
*base_type
, *cv_type
;
17198 base_type
= die_type (die
, cu
);
17200 /* The die_type call above may have already set the type for this DIE. */
17201 cv_type
= get_die_type (die
, cu
);
17205 cv_type
= make_restrict_type (base_type
);
17206 return set_die_type (die
, cv_type
, cu
);
17209 /* Handle DW_TAG_atomic_type. */
17211 static struct type
*
17212 read_tag_atomic_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17214 struct type
*base_type
, *cv_type
;
17216 base_type
= die_type (die
, cu
);
17218 /* The die_type call above may have already set the type for this DIE. */
17219 cv_type
= get_die_type (die
, cu
);
17223 cv_type
= make_atomic_type (base_type
);
17224 return set_die_type (die
, cv_type
, cu
);
17227 /* Extract all information from a DW_TAG_string_type DIE and add to
17228 the user defined type vector. It isn't really a user defined type,
17229 but it behaves like one, with other DIE's using an AT_user_def_type
17230 attribute to reference it. */
17232 static struct type
*
17233 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17235 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
17236 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
17237 struct type
*type
, *range_type
, *index_type
, *char_type
;
17238 struct attribute
*attr
;
17239 unsigned int length
;
17241 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
17244 length
= DW_UNSND (attr
);
17248 /* Check for the DW_AT_byte_size attribute. */
17249 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17252 length
= DW_UNSND (attr
);
17260 index_type
= objfile_type (objfile
)->builtin_int
;
17261 range_type
= create_static_range_type (NULL
, index_type
, 1, length
);
17262 char_type
= language_string_char_type (cu
->language_defn
, gdbarch
);
17263 type
= create_string_type (NULL
, char_type
, range_type
);
17265 return set_die_type (die
, type
, cu
);
17268 /* Assuming that DIE corresponds to a function, returns nonzero
17269 if the function is prototyped. */
17272 prototyped_function_p (struct die_info
*die
, struct dwarf2_cu
*cu
)
17274 struct attribute
*attr
;
17276 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
17277 if (attr
&& (DW_UNSND (attr
) != 0))
17280 /* The DWARF standard implies that the DW_AT_prototyped attribute
17281 is only meaninful for C, but the concept also extends to other
17282 languages that allow unprototyped functions (Eg: Objective C).
17283 For all other languages, assume that functions are always
17285 if (cu
->language
!= language_c
17286 && cu
->language
!= language_objc
17287 && cu
->language
!= language_opencl
)
17290 /* RealView does not emit DW_AT_prototyped. We can not distinguish
17291 prototyped and unprototyped functions; default to prototyped,
17292 since that is more common in modern code (and RealView warns
17293 about unprototyped functions). */
17294 if (producer_is_realview (cu
->producer
))
17300 /* Handle DIES due to C code like:
17304 int (*funcp)(int a, long l);
17308 ('funcp' generates a DW_TAG_subroutine_type DIE). */
17310 static struct type
*
17311 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17313 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
17314 struct type
*type
; /* Type that this function returns. */
17315 struct type
*ftype
; /* Function that returns above type. */
17316 struct attribute
*attr
;
17318 type
= die_type (die
, cu
);
17320 /* The die_type call above may have already set the type for this DIE. */
17321 ftype
= get_die_type (die
, cu
);
17325 ftype
= lookup_function_type (type
);
17327 if (prototyped_function_p (die
, cu
))
17328 TYPE_PROTOTYPED (ftype
) = 1;
17330 /* Store the calling convention in the type if it's available in
17331 the subroutine die. Otherwise set the calling convention to
17332 the default value DW_CC_normal. */
17333 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
17335 TYPE_CALLING_CONVENTION (ftype
) = DW_UNSND (attr
);
17336 else if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL"))
17337 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_GDB_IBM_OpenCL
;
17339 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_normal
;
17341 /* Record whether the function returns normally to its caller or not
17342 if the DWARF producer set that information. */
17343 attr
= dwarf2_attr (die
, DW_AT_noreturn
, cu
);
17344 if (attr
&& (DW_UNSND (attr
) != 0))
17345 TYPE_NO_RETURN (ftype
) = 1;
17347 /* We need to add the subroutine type to the die immediately so
17348 we don't infinitely recurse when dealing with parameters
17349 declared as the same subroutine type. */
17350 set_die_type (die
, ftype
, cu
);
17352 if (die
->child
!= NULL
)
17354 struct type
*void_type
= objfile_type (objfile
)->builtin_void
;
17355 struct die_info
*child_die
;
17356 int nparams
, iparams
;
17358 /* Count the number of parameters.
17359 FIXME: GDB currently ignores vararg functions, but knows about
17360 vararg member functions. */
17362 child_die
= die
->child
;
17363 while (child_die
&& child_die
->tag
)
17365 if (child_die
->tag
== DW_TAG_formal_parameter
)
17367 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
17368 TYPE_VARARGS (ftype
) = 1;
17369 child_die
= sibling_die (child_die
);
17372 /* Allocate storage for parameters and fill them in. */
17373 TYPE_NFIELDS (ftype
) = nparams
;
17374 TYPE_FIELDS (ftype
) = (struct field
*)
17375 TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
));
17377 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
17378 even if we error out during the parameters reading below. */
17379 for (iparams
= 0; iparams
< nparams
; iparams
++)
17380 TYPE_FIELD_TYPE (ftype
, iparams
) = void_type
;
17383 child_die
= die
->child
;
17384 while (child_die
&& child_die
->tag
)
17386 if (child_die
->tag
== DW_TAG_formal_parameter
)
17388 struct type
*arg_type
;
17390 /* DWARF version 2 has no clean way to discern C++
17391 static and non-static member functions. G++ helps
17392 GDB by marking the first parameter for non-static
17393 member functions (which is the this pointer) as
17394 artificial. We pass this information to
17395 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
17397 DWARF version 3 added DW_AT_object_pointer, which GCC
17398 4.5 does not yet generate. */
17399 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
17401 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
17403 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
17404 arg_type
= die_type (child_die
, cu
);
17406 /* RealView does not mark THIS as const, which the testsuite
17407 expects. GCC marks THIS as const in method definitions,
17408 but not in the class specifications (GCC PR 43053). */
17409 if (cu
->language
== language_cplus
&& !TYPE_CONST (arg_type
)
17410 && TYPE_FIELD_ARTIFICIAL (ftype
, iparams
))
17413 struct dwarf2_cu
*arg_cu
= cu
;
17414 const char *name
= dwarf2_name (child_die
, cu
);
17416 attr
= dwarf2_attr (die
, DW_AT_object_pointer
, cu
);
17419 /* If the compiler emits this, use it. */
17420 if (follow_die_ref (die
, attr
, &arg_cu
) == child_die
)
17423 else if (name
&& strcmp (name
, "this") == 0)
17424 /* Function definitions will have the argument names. */
17426 else if (name
== NULL
&& iparams
== 0)
17427 /* Declarations may not have the names, so like
17428 elsewhere in GDB, assume an artificial first
17429 argument is "this". */
17433 arg_type
= make_cv_type (1, TYPE_VOLATILE (arg_type
),
17437 TYPE_FIELD_TYPE (ftype
, iparams
) = arg_type
;
17440 child_die
= sibling_die (child_die
);
17447 static struct type
*
17448 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
17450 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
17451 const char *name
= NULL
;
17452 struct type
*this_type
, *target_type
;
17454 name
= dwarf2_full_name (NULL
, die
, cu
);
17455 this_type
= init_type (objfile
, TYPE_CODE_TYPEDEF
, 0, name
);
17456 TYPE_TARGET_STUB (this_type
) = 1;
17457 set_die_type (die
, this_type
, cu
);
17458 target_type
= die_type (die
, cu
);
17459 if (target_type
!= this_type
)
17460 TYPE_TARGET_TYPE (this_type
) = target_type
;
17463 /* Self-referential typedefs are, it seems, not allowed by the DWARF
17464 spec and cause infinite loops in GDB. */
17465 complaint (&symfile_complaints
,
17466 _("Self-referential DW_TAG_typedef "
17467 "- DIE at 0x%x [in module %s]"),
17468 to_underlying (die
->sect_off
), objfile_name (objfile
));
17469 TYPE_TARGET_TYPE (this_type
) = NULL
;
17474 /* Allocate a floating-point type of size BITS and name NAME. Pass NAME_HINT
17475 (which may be different from NAME) to the architecture back-end to allow
17476 it to guess the correct format if necessary. */
17478 static struct type
*
17479 dwarf2_init_float_type (struct objfile
*objfile
, int bits
, const char *name
,
17480 const char *name_hint
)
17482 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
17483 const struct floatformat
**format
;
17486 format
= gdbarch_floatformat_for_type (gdbarch
, name_hint
, bits
);
17488 type
= init_float_type (objfile
, bits
, name
, format
);
17490 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
, name
);
17495 /* Find a representation of a given base type and install
17496 it in the TYPE field of the die. */
17498 static struct type
*
17499 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17501 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
17503 struct attribute
*attr
;
17504 int encoding
= 0, bits
= 0;
17507 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
17510 encoding
= DW_UNSND (attr
);
17512 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17515 bits
= DW_UNSND (attr
) * TARGET_CHAR_BIT
;
17517 name
= dwarf2_name (die
, cu
);
17520 complaint (&symfile_complaints
,
17521 _("DW_AT_name missing from DW_TAG_base_type"));
17526 case DW_ATE_address
:
17527 /* Turn DW_ATE_address into a void * pointer. */
17528 type
= init_type (objfile
, TYPE_CODE_VOID
, TARGET_CHAR_BIT
, NULL
);
17529 type
= init_pointer_type (objfile
, bits
, name
, type
);
17531 case DW_ATE_boolean
:
17532 type
= init_boolean_type (objfile
, bits
, 1, name
);
17534 case DW_ATE_complex_float
:
17535 type
= dwarf2_init_float_type (objfile
, bits
/ 2, NULL
, name
);
17536 type
= init_complex_type (objfile
, name
, type
);
17538 case DW_ATE_decimal_float
:
17539 type
= init_decfloat_type (objfile
, bits
, name
);
17542 type
= dwarf2_init_float_type (objfile
, bits
, name
, name
);
17544 case DW_ATE_signed
:
17545 type
= init_integer_type (objfile
, bits
, 0, name
);
17547 case DW_ATE_unsigned
:
17548 if (cu
->language
== language_fortran
17550 && startswith (name
, "character("))
17551 type
= init_character_type (objfile
, bits
, 1, name
);
17553 type
= init_integer_type (objfile
, bits
, 1, name
);
17555 case DW_ATE_signed_char
:
17556 if (cu
->language
== language_ada
|| cu
->language
== language_m2
17557 || cu
->language
== language_pascal
17558 || cu
->language
== language_fortran
)
17559 type
= init_character_type (objfile
, bits
, 0, name
);
17561 type
= init_integer_type (objfile
, bits
, 0, name
);
17563 case DW_ATE_unsigned_char
:
17564 if (cu
->language
== language_ada
|| cu
->language
== language_m2
17565 || cu
->language
== language_pascal
17566 || cu
->language
== language_fortran
17567 || cu
->language
== language_rust
)
17568 type
= init_character_type (objfile
, bits
, 1, name
);
17570 type
= init_integer_type (objfile
, bits
, 1, name
);
17574 gdbarch
*arch
= get_objfile_arch (objfile
);
17577 type
= builtin_type (arch
)->builtin_char16
;
17578 else if (bits
== 32)
17579 type
= builtin_type (arch
)->builtin_char32
;
17582 complaint (&symfile_complaints
,
17583 _("unsupported DW_ATE_UTF bit size: '%d'"),
17585 type
= init_integer_type (objfile
, bits
, 1, name
);
17587 return set_die_type (die
, type
, cu
);
17592 complaint (&symfile_complaints
, _("unsupported DW_AT_encoding: '%s'"),
17593 dwarf_type_encoding_name (encoding
));
17594 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
, name
);
17598 if (name
&& strcmp (name
, "char") == 0)
17599 TYPE_NOSIGN (type
) = 1;
17601 return set_die_type (die
, type
, cu
);
17604 /* Parse dwarf attribute if it's a block, reference or constant and put the
17605 resulting value of the attribute into struct bound_prop.
17606 Returns 1 if ATTR could be resolved into PROP, 0 otherwise. */
17609 attr_to_dynamic_prop (const struct attribute
*attr
, struct die_info
*die
,
17610 struct dwarf2_cu
*cu
, struct dynamic_prop
*prop
)
17612 struct dwarf2_property_baton
*baton
;
17613 struct obstack
*obstack
17614 = &cu
->per_cu
->dwarf2_per_objfile
->objfile
->objfile_obstack
;
17616 if (attr
== NULL
|| prop
== NULL
)
17619 if (attr_form_is_block (attr
))
17621 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
17622 baton
->referenced_type
= NULL
;
17623 baton
->locexpr
.per_cu
= cu
->per_cu
;
17624 baton
->locexpr
.size
= DW_BLOCK (attr
)->size
;
17625 baton
->locexpr
.data
= DW_BLOCK (attr
)->data
;
17626 prop
->data
.baton
= baton
;
17627 prop
->kind
= PROP_LOCEXPR
;
17628 gdb_assert (prop
->data
.baton
!= NULL
);
17630 else if (attr_form_is_ref (attr
))
17632 struct dwarf2_cu
*target_cu
= cu
;
17633 struct die_info
*target_die
;
17634 struct attribute
*target_attr
;
17636 target_die
= follow_die_ref (die
, attr
, &target_cu
);
17637 target_attr
= dwarf2_attr (target_die
, DW_AT_location
, target_cu
);
17638 if (target_attr
== NULL
)
17639 target_attr
= dwarf2_attr (target_die
, DW_AT_data_member_location
,
17641 if (target_attr
== NULL
)
17644 switch (target_attr
->name
)
17646 case DW_AT_location
:
17647 if (attr_form_is_section_offset (target_attr
))
17649 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
17650 baton
->referenced_type
= die_type (target_die
, target_cu
);
17651 fill_in_loclist_baton (cu
, &baton
->loclist
, target_attr
);
17652 prop
->data
.baton
= baton
;
17653 prop
->kind
= PROP_LOCLIST
;
17654 gdb_assert (prop
->data
.baton
!= NULL
);
17656 else if (attr_form_is_block (target_attr
))
17658 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
17659 baton
->referenced_type
= die_type (target_die
, target_cu
);
17660 baton
->locexpr
.per_cu
= cu
->per_cu
;
17661 baton
->locexpr
.size
= DW_BLOCK (target_attr
)->size
;
17662 baton
->locexpr
.data
= DW_BLOCK (target_attr
)->data
;
17663 prop
->data
.baton
= baton
;
17664 prop
->kind
= PROP_LOCEXPR
;
17665 gdb_assert (prop
->data
.baton
!= NULL
);
17669 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
17670 "dynamic property");
17674 case DW_AT_data_member_location
:
17678 if (!handle_data_member_location (target_die
, target_cu
,
17682 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
17683 baton
->referenced_type
= read_type_die (target_die
->parent
,
17685 baton
->offset_info
.offset
= offset
;
17686 baton
->offset_info
.type
= die_type (target_die
, target_cu
);
17687 prop
->data
.baton
= baton
;
17688 prop
->kind
= PROP_ADDR_OFFSET
;
17693 else if (attr_form_is_constant (attr
))
17695 prop
->data
.const_val
= dwarf2_get_attr_constant_value (attr
, 0);
17696 prop
->kind
= PROP_CONST
;
17700 dwarf2_invalid_attrib_class_complaint (dwarf_form_name (attr
->form
),
17701 dwarf2_name (die
, cu
));
17708 /* Read the given DW_AT_subrange DIE. */
17710 static struct type
*
17711 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17713 struct type
*base_type
, *orig_base_type
;
17714 struct type
*range_type
;
17715 struct attribute
*attr
;
17716 struct dynamic_prop low
, high
;
17717 int low_default_is_valid
;
17718 int high_bound_is_count
= 0;
17720 LONGEST negative_mask
;
17722 orig_base_type
= die_type (die
, cu
);
17723 /* If ORIG_BASE_TYPE is a typedef, it will not be TYPE_UNSIGNED,
17724 whereas the real type might be. So, we use ORIG_BASE_TYPE when
17725 creating the range type, but we use the result of check_typedef
17726 when examining properties of the type. */
17727 base_type
= check_typedef (orig_base_type
);
17729 /* The die_type call above may have already set the type for this DIE. */
17730 range_type
= get_die_type (die
, cu
);
17734 low
.kind
= PROP_CONST
;
17735 high
.kind
= PROP_CONST
;
17736 high
.data
.const_val
= 0;
17738 /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
17739 omitting DW_AT_lower_bound. */
17740 switch (cu
->language
)
17743 case language_cplus
:
17744 low
.data
.const_val
= 0;
17745 low_default_is_valid
= 1;
17747 case language_fortran
:
17748 low
.data
.const_val
= 1;
17749 low_default_is_valid
= 1;
17752 case language_objc
:
17753 case language_rust
:
17754 low
.data
.const_val
= 0;
17755 low_default_is_valid
= (cu
->header
.version
>= 4);
17759 case language_pascal
:
17760 low
.data
.const_val
= 1;
17761 low_default_is_valid
= (cu
->header
.version
>= 4);
17764 low
.data
.const_val
= 0;
17765 low_default_is_valid
= 0;
17769 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
17771 attr_to_dynamic_prop (attr
, die
, cu
, &low
);
17772 else if (!low_default_is_valid
)
17773 complaint (&symfile_complaints
, _("Missing DW_AT_lower_bound "
17774 "- DIE at 0x%x [in module %s]"),
17775 to_underlying (die
->sect_off
),
17776 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
17778 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
17779 if (!attr_to_dynamic_prop (attr
, die
, cu
, &high
))
17781 attr
= dwarf2_attr (die
, DW_AT_count
, cu
);
17782 if (attr_to_dynamic_prop (attr
, die
, cu
, &high
))
17784 /* If bounds are constant do the final calculation here. */
17785 if (low
.kind
== PROP_CONST
&& high
.kind
== PROP_CONST
)
17786 high
.data
.const_val
= low
.data
.const_val
+ high
.data
.const_val
- 1;
17788 high_bound_is_count
= 1;
17792 /* Dwarf-2 specifications explicitly allows to create subrange types
17793 without specifying a base type.
17794 In that case, the base type must be set to the type of
17795 the lower bound, upper bound or count, in that order, if any of these
17796 three attributes references an object that has a type.
17797 If no base type is found, the Dwarf-2 specifications say that
17798 a signed integer type of size equal to the size of an address should
17800 For the following C code: `extern char gdb_int [];'
17801 GCC produces an empty range DIE.
17802 FIXME: muller/2010-05-28: Possible references to object for low bound,
17803 high bound or count are not yet handled by this code. */
17804 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
17806 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
17807 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
17808 int addr_size
= gdbarch_addr_bit (gdbarch
) /8;
17809 struct type
*int_type
= objfile_type (objfile
)->builtin_int
;
17811 /* Test "int", "long int", and "long long int" objfile types,
17812 and select the first one having a size above or equal to the
17813 architecture address size. */
17814 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
17815 base_type
= int_type
;
17818 int_type
= objfile_type (objfile
)->builtin_long
;
17819 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
17820 base_type
= int_type
;
17823 int_type
= objfile_type (objfile
)->builtin_long_long
;
17824 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
17825 base_type
= int_type
;
17830 /* Normally, the DWARF producers are expected to use a signed
17831 constant form (Eg. DW_FORM_sdata) to express negative bounds.
17832 But this is unfortunately not always the case, as witnessed
17833 with GCC, for instance, where the ambiguous DW_FORM_dataN form
17834 is used instead. To work around that ambiguity, we treat
17835 the bounds as signed, and thus sign-extend their values, when
17836 the base type is signed. */
17838 -((LONGEST
) 1 << (TYPE_LENGTH (base_type
) * TARGET_CHAR_BIT
- 1));
17839 if (low
.kind
== PROP_CONST
17840 && !TYPE_UNSIGNED (base_type
) && (low
.data
.const_val
& negative_mask
))
17841 low
.data
.const_val
|= negative_mask
;
17842 if (high
.kind
== PROP_CONST
17843 && !TYPE_UNSIGNED (base_type
) && (high
.data
.const_val
& negative_mask
))
17844 high
.data
.const_val
|= negative_mask
;
17846 range_type
= create_range_type (NULL
, orig_base_type
, &low
, &high
);
17848 if (high_bound_is_count
)
17849 TYPE_RANGE_DATA (range_type
)->flag_upper_bound_is_count
= 1;
17851 /* Ada expects an empty array on no boundary attributes. */
17852 if (attr
== NULL
&& cu
->language
!= language_ada
)
17853 TYPE_HIGH_BOUND_KIND (range_type
) = PROP_UNDEFINED
;
17855 name
= dwarf2_name (die
, cu
);
17857 TYPE_NAME (range_type
) = name
;
17859 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17861 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
17863 set_die_type (die
, range_type
, cu
);
17865 /* set_die_type should be already done. */
17866 set_descriptive_type (range_type
, die
, cu
);
17871 static struct type
*
17872 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17876 type
= init_type (cu
->per_cu
->dwarf2_per_objfile
->objfile
, TYPE_CODE_VOID
,0,
17878 TYPE_NAME (type
) = dwarf2_name (die
, cu
);
17880 /* In Ada, an unspecified type is typically used when the description
17881 of the type is defered to a different unit. When encountering
17882 such a type, we treat it as a stub, and try to resolve it later on,
17884 if (cu
->language
== language_ada
)
17885 TYPE_STUB (type
) = 1;
17887 return set_die_type (die
, type
, cu
);
17890 /* Read a single die and all its descendents. Set the die's sibling
17891 field to NULL; set other fields in the die correctly, and set all
17892 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
17893 location of the info_ptr after reading all of those dies. PARENT
17894 is the parent of the die in question. */
17896 static struct die_info
*
17897 read_die_and_children (const struct die_reader_specs
*reader
,
17898 const gdb_byte
*info_ptr
,
17899 const gdb_byte
**new_info_ptr
,
17900 struct die_info
*parent
)
17902 struct die_info
*die
;
17903 const gdb_byte
*cur_ptr
;
17906 cur_ptr
= read_full_die_1 (reader
, &die
, info_ptr
, &has_children
, 0);
17909 *new_info_ptr
= cur_ptr
;
17912 store_in_ref_table (die
, reader
->cu
);
17915 die
->child
= read_die_and_siblings_1 (reader
, cur_ptr
, new_info_ptr
, die
);
17919 *new_info_ptr
= cur_ptr
;
17922 die
->sibling
= NULL
;
17923 die
->parent
= parent
;
17927 /* Read a die, all of its descendents, and all of its siblings; set
17928 all of the fields of all of the dies correctly. Arguments are as
17929 in read_die_and_children. */
17931 static struct die_info
*
17932 read_die_and_siblings_1 (const struct die_reader_specs
*reader
,
17933 const gdb_byte
*info_ptr
,
17934 const gdb_byte
**new_info_ptr
,
17935 struct die_info
*parent
)
17937 struct die_info
*first_die
, *last_sibling
;
17938 const gdb_byte
*cur_ptr
;
17940 cur_ptr
= info_ptr
;
17941 first_die
= last_sibling
= NULL
;
17945 struct die_info
*die
17946 = read_die_and_children (reader
, cur_ptr
, &cur_ptr
, parent
);
17950 *new_info_ptr
= cur_ptr
;
17957 last_sibling
->sibling
= die
;
17959 last_sibling
= die
;
17963 /* Read a die, all of its descendents, and all of its siblings; set
17964 all of the fields of all of the dies correctly. Arguments are as
17965 in read_die_and_children.
17966 This the main entry point for reading a DIE and all its children. */
17968 static struct die_info
*
17969 read_die_and_siblings (const struct die_reader_specs
*reader
,
17970 const gdb_byte
*info_ptr
,
17971 const gdb_byte
**new_info_ptr
,
17972 struct die_info
*parent
)
17974 struct die_info
*die
= read_die_and_siblings_1 (reader
, info_ptr
,
17975 new_info_ptr
, parent
);
17977 if (dwarf_die_debug
)
17979 fprintf_unfiltered (gdb_stdlog
,
17980 "Read die from %s@0x%x of %s:\n",
17981 get_section_name (reader
->die_section
),
17982 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
17983 bfd_get_filename (reader
->abfd
));
17984 dump_die (die
, dwarf_die_debug
);
17990 /* Read a die and all its attributes, leave space for NUM_EXTRA_ATTRS
17992 The caller is responsible for filling in the extra attributes
17993 and updating (*DIEP)->num_attrs.
17994 Set DIEP to point to a newly allocated die with its information,
17995 except for its child, sibling, and parent fields.
17996 Set HAS_CHILDREN to tell whether the die has children or not. */
17998 static const gdb_byte
*
17999 read_full_die_1 (const struct die_reader_specs
*reader
,
18000 struct die_info
**diep
, const gdb_byte
*info_ptr
,
18001 int *has_children
, int num_extra_attrs
)
18003 unsigned int abbrev_number
, bytes_read
, i
;
18004 struct abbrev_info
*abbrev
;
18005 struct die_info
*die
;
18006 struct dwarf2_cu
*cu
= reader
->cu
;
18007 bfd
*abfd
= reader
->abfd
;
18009 sect_offset sect_off
= (sect_offset
) (info_ptr
- reader
->buffer
);
18010 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
18011 info_ptr
+= bytes_read
;
18012 if (!abbrev_number
)
18019 abbrev
= abbrev_table_lookup_abbrev (cu
->abbrev_table
, abbrev_number
);
18021 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
18023 bfd_get_filename (abfd
));
18025 die
= dwarf_alloc_die (cu
, abbrev
->num_attrs
+ num_extra_attrs
);
18026 die
->sect_off
= sect_off
;
18027 die
->tag
= abbrev
->tag
;
18028 die
->abbrev
= abbrev_number
;
18030 /* Make the result usable.
18031 The caller needs to update num_attrs after adding the extra
18033 die
->num_attrs
= abbrev
->num_attrs
;
18035 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
18036 info_ptr
= read_attribute (reader
, &die
->attrs
[i
], &abbrev
->attrs
[i
],
18040 *has_children
= abbrev
->has_children
;
18044 /* Read a die and all its attributes.
18045 Set DIEP to point to a newly allocated die with its information,
18046 except for its child, sibling, and parent fields.
18047 Set HAS_CHILDREN to tell whether the die has children or not. */
18049 static const gdb_byte
*
18050 read_full_die (const struct die_reader_specs
*reader
,
18051 struct die_info
**diep
, const gdb_byte
*info_ptr
,
18054 const gdb_byte
*result
;
18056 result
= read_full_die_1 (reader
, diep
, info_ptr
, has_children
, 0);
18058 if (dwarf_die_debug
)
18060 fprintf_unfiltered (gdb_stdlog
,
18061 "Read die from %s@0x%x of %s:\n",
18062 get_section_name (reader
->die_section
),
18063 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
18064 bfd_get_filename (reader
->abfd
));
18065 dump_die (*diep
, dwarf_die_debug
);
18071 /* Abbreviation tables.
18073 In DWARF version 2, the description of the debugging information is
18074 stored in a separate .debug_abbrev section. Before we read any
18075 dies from a section we read in all abbreviations and install them
18076 in a hash table. */
18078 /* Allocate space for a struct abbrev_info object in ABBREV_TABLE. */
18080 static struct abbrev_info
*
18081 abbrev_table_alloc_abbrev (struct abbrev_table
*abbrev_table
)
18083 struct abbrev_info
*abbrev
;
18085 abbrev
= XOBNEW (&abbrev_table
->abbrev_obstack
, struct abbrev_info
);
18086 memset (abbrev
, 0, sizeof (struct abbrev_info
));
18091 /* Add an abbreviation to the table. */
18094 abbrev_table_add_abbrev (struct abbrev_table
*abbrev_table
,
18095 unsigned int abbrev_number
,
18096 struct abbrev_info
*abbrev
)
18098 unsigned int hash_number
;
18100 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
18101 abbrev
->next
= abbrev_table
->abbrevs
[hash_number
];
18102 abbrev_table
->abbrevs
[hash_number
] = abbrev
;
18105 /* Look up an abbrev in the table.
18106 Returns NULL if the abbrev is not found. */
18108 static struct abbrev_info
*
18109 abbrev_table_lookup_abbrev (const struct abbrev_table
*abbrev_table
,
18110 unsigned int abbrev_number
)
18112 unsigned int hash_number
;
18113 struct abbrev_info
*abbrev
;
18115 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
18116 abbrev
= abbrev_table
->abbrevs
[hash_number
];
18120 if (abbrev
->number
== abbrev_number
)
18122 abbrev
= abbrev
->next
;
18127 /* Read in an abbrev table. */
18129 static struct abbrev_table
*
18130 abbrev_table_read_table (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
18131 struct dwarf2_section_info
*section
,
18132 sect_offset sect_off
)
18134 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
18135 bfd
*abfd
= get_section_bfd_owner (section
);
18136 struct abbrev_table
*abbrev_table
;
18137 const gdb_byte
*abbrev_ptr
;
18138 struct abbrev_info
*cur_abbrev
;
18139 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
18140 unsigned int abbrev_form
;
18141 struct attr_abbrev
*cur_attrs
;
18142 unsigned int allocated_attrs
;
18144 abbrev_table
= XNEW (struct abbrev_table
);
18145 abbrev_table
->sect_off
= sect_off
;
18146 obstack_init (&abbrev_table
->abbrev_obstack
);
18147 abbrev_table
->abbrevs
=
18148 XOBNEWVEC (&abbrev_table
->abbrev_obstack
, struct abbrev_info
*,
18150 memset (abbrev_table
->abbrevs
, 0,
18151 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
18153 dwarf2_read_section (objfile
, section
);
18154 abbrev_ptr
= section
->buffer
+ to_underlying (sect_off
);
18155 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
18156 abbrev_ptr
+= bytes_read
;
18158 allocated_attrs
= ATTR_ALLOC_CHUNK
;
18159 cur_attrs
= XNEWVEC (struct attr_abbrev
, allocated_attrs
);
18161 /* Loop until we reach an abbrev number of 0. */
18162 while (abbrev_number
)
18164 cur_abbrev
= abbrev_table_alloc_abbrev (abbrev_table
);
18166 /* read in abbrev header */
18167 cur_abbrev
->number
= abbrev_number
;
18169 = (enum dwarf_tag
) read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
18170 abbrev_ptr
+= bytes_read
;
18171 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
18174 /* now read in declarations */
18177 LONGEST implicit_const
;
18179 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
18180 abbrev_ptr
+= bytes_read
;
18181 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
18182 abbrev_ptr
+= bytes_read
;
18183 if (abbrev_form
== DW_FORM_implicit_const
)
18185 implicit_const
= read_signed_leb128 (abfd
, abbrev_ptr
,
18187 abbrev_ptr
+= bytes_read
;
18191 /* Initialize it due to a false compiler warning. */
18192 implicit_const
= -1;
18195 if (abbrev_name
== 0)
18198 if (cur_abbrev
->num_attrs
== allocated_attrs
)
18200 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
18202 = XRESIZEVEC (struct attr_abbrev
, cur_attrs
, allocated_attrs
);
18205 cur_attrs
[cur_abbrev
->num_attrs
].name
18206 = (enum dwarf_attribute
) abbrev_name
;
18207 cur_attrs
[cur_abbrev
->num_attrs
].form
18208 = (enum dwarf_form
) abbrev_form
;
18209 cur_attrs
[cur_abbrev
->num_attrs
].implicit_const
= implicit_const
;
18210 ++cur_abbrev
->num_attrs
;
18213 cur_abbrev
->attrs
=
18214 XOBNEWVEC (&abbrev_table
->abbrev_obstack
, struct attr_abbrev
,
18215 cur_abbrev
->num_attrs
);
18216 memcpy (cur_abbrev
->attrs
, cur_attrs
,
18217 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
18219 abbrev_table_add_abbrev (abbrev_table
, abbrev_number
, cur_abbrev
);
18221 /* Get next abbreviation.
18222 Under Irix6 the abbreviations for a compilation unit are not
18223 always properly terminated with an abbrev number of 0.
18224 Exit loop if we encounter an abbreviation which we have
18225 already read (which means we are about to read the abbreviations
18226 for the next compile unit) or if the end of the abbreviation
18227 table is reached. */
18228 if ((unsigned int) (abbrev_ptr
- section
->buffer
) >= section
->size
)
18230 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
18231 abbrev_ptr
+= bytes_read
;
18232 if (abbrev_table_lookup_abbrev (abbrev_table
, abbrev_number
) != NULL
)
18237 return abbrev_table
;
18240 /* Free the resources held by ABBREV_TABLE. */
18243 abbrev_table_free (struct abbrev_table
*abbrev_table
)
18245 obstack_free (&abbrev_table
->abbrev_obstack
, NULL
);
18246 xfree (abbrev_table
);
18249 /* Same as abbrev_table_free but as a cleanup.
18250 We pass in a pointer to the pointer to the table so that we can
18251 set the pointer to NULL when we're done. It also simplifies
18252 build_type_psymtabs_1. */
18255 abbrev_table_free_cleanup (void *table_ptr
)
18257 struct abbrev_table
**abbrev_table_ptr
= (struct abbrev_table
**) table_ptr
;
18259 if (*abbrev_table_ptr
!= NULL
)
18260 abbrev_table_free (*abbrev_table_ptr
);
18261 *abbrev_table_ptr
= NULL
;
18264 /* Read the abbrev table for CU from ABBREV_SECTION. */
18267 dwarf2_read_abbrevs (struct dwarf2_cu
*cu
,
18268 struct dwarf2_section_info
*abbrev_section
)
18271 abbrev_table_read_table (cu
->per_cu
->dwarf2_per_objfile
, abbrev_section
,
18272 cu
->header
.abbrev_sect_off
);
18275 /* Release the memory used by the abbrev table for a compilation unit. */
18278 dwarf2_free_abbrev_table (void *ptr_to_cu
)
18280 struct dwarf2_cu
*cu
= (struct dwarf2_cu
*) ptr_to_cu
;
18282 if (cu
->abbrev_table
!= NULL
)
18283 abbrev_table_free (cu
->abbrev_table
);
18284 /* Set this to NULL so that we SEGV if we try to read it later,
18285 and also because free_comp_unit verifies this is NULL. */
18286 cu
->abbrev_table
= NULL
;
18289 /* Returns nonzero if TAG represents a type that we might generate a partial
18293 is_type_tag_for_partial (int tag
)
18298 /* Some types that would be reasonable to generate partial symbols for,
18299 that we don't at present. */
18300 case DW_TAG_array_type
:
18301 case DW_TAG_file_type
:
18302 case DW_TAG_ptr_to_member_type
:
18303 case DW_TAG_set_type
:
18304 case DW_TAG_string_type
:
18305 case DW_TAG_subroutine_type
:
18307 case DW_TAG_base_type
:
18308 case DW_TAG_class_type
:
18309 case DW_TAG_interface_type
:
18310 case DW_TAG_enumeration_type
:
18311 case DW_TAG_structure_type
:
18312 case DW_TAG_subrange_type
:
18313 case DW_TAG_typedef
:
18314 case DW_TAG_union_type
:
18321 /* Load all DIEs that are interesting for partial symbols into memory. */
18323 static struct partial_die_info
*
18324 load_partial_dies (const struct die_reader_specs
*reader
,
18325 const gdb_byte
*info_ptr
, int building_psymtab
)
18327 struct dwarf2_cu
*cu
= reader
->cu
;
18328 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
18329 struct partial_die_info
*part_die
;
18330 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
18331 struct abbrev_info
*abbrev
;
18332 unsigned int bytes_read
;
18333 unsigned int load_all
= 0;
18334 int nesting_level
= 1;
18339 gdb_assert (cu
->per_cu
!= NULL
);
18340 if (cu
->per_cu
->load_all_dies
)
18344 = htab_create_alloc_ex (cu
->header
.length
/ 12,
18348 &cu
->comp_unit_obstack
,
18349 hashtab_obstack_allocate
,
18350 dummy_obstack_deallocate
);
18352 part_die
= XOBNEW (&cu
->comp_unit_obstack
, struct partial_die_info
);
18356 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
18358 /* A NULL abbrev means the end of a series of children. */
18359 if (abbrev
== NULL
)
18361 if (--nesting_level
== 0)
18363 /* PART_DIE was probably the last thing allocated on the
18364 comp_unit_obstack, so we could call obstack_free
18365 here. We don't do that because the waste is small,
18366 and will be cleaned up when we're done with this
18367 compilation unit. This way, we're also more robust
18368 against other users of the comp_unit_obstack. */
18371 info_ptr
+= bytes_read
;
18372 last_die
= parent_die
;
18373 parent_die
= parent_die
->die_parent
;
18377 /* Check for template arguments. We never save these; if
18378 they're seen, we just mark the parent, and go on our way. */
18379 if (parent_die
!= NULL
18380 && cu
->language
== language_cplus
18381 && (abbrev
->tag
== DW_TAG_template_type_param
18382 || abbrev
->tag
== DW_TAG_template_value_param
))
18384 parent_die
->has_template_arguments
= 1;
18388 /* We don't need a partial DIE for the template argument. */
18389 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
18394 /* We only recurse into c++ subprograms looking for template arguments.
18395 Skip their other children. */
18397 && cu
->language
== language_cplus
18398 && parent_die
!= NULL
18399 && parent_die
->tag
== DW_TAG_subprogram
)
18401 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
18405 /* Check whether this DIE is interesting enough to save. Normally
18406 we would not be interested in members here, but there may be
18407 later variables referencing them via DW_AT_specification (for
18408 static members). */
18410 && !is_type_tag_for_partial (abbrev
->tag
)
18411 && abbrev
->tag
!= DW_TAG_constant
18412 && abbrev
->tag
!= DW_TAG_enumerator
18413 && abbrev
->tag
!= DW_TAG_subprogram
18414 && abbrev
->tag
!= DW_TAG_inlined_subroutine
18415 && abbrev
->tag
!= DW_TAG_lexical_block
18416 && abbrev
->tag
!= DW_TAG_variable
18417 && abbrev
->tag
!= DW_TAG_namespace
18418 && abbrev
->tag
!= DW_TAG_module
18419 && abbrev
->tag
!= DW_TAG_member
18420 && abbrev
->tag
!= DW_TAG_imported_unit
18421 && abbrev
->tag
!= DW_TAG_imported_declaration
)
18423 /* Otherwise we skip to the next sibling, if any. */
18424 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
18428 info_ptr
= read_partial_die (reader
, part_die
, abbrev
, bytes_read
,
18431 /* This two-pass algorithm for processing partial symbols has a
18432 high cost in cache pressure. Thus, handle some simple cases
18433 here which cover the majority of C partial symbols. DIEs
18434 which neither have specification tags in them, nor could have
18435 specification tags elsewhere pointing at them, can simply be
18436 processed and discarded.
18438 This segment is also optional; scan_partial_symbols and
18439 add_partial_symbol will handle these DIEs if we chain
18440 them in normally. When compilers which do not emit large
18441 quantities of duplicate debug information are more common,
18442 this code can probably be removed. */
18444 /* Any complete simple types at the top level (pretty much all
18445 of them, for a language without namespaces), can be processed
18447 if (parent_die
== NULL
18448 && part_die
->has_specification
== 0
18449 && part_die
->is_declaration
== 0
18450 && ((part_die
->tag
== DW_TAG_typedef
&& !part_die
->has_children
)
18451 || part_die
->tag
== DW_TAG_base_type
18452 || part_die
->tag
== DW_TAG_subrange_type
))
18454 if (building_psymtab
&& part_die
->name
!= NULL
)
18455 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
18456 VAR_DOMAIN
, LOC_TYPEDEF
,
18457 &objfile
->static_psymbols
,
18458 0, cu
->language
, objfile
);
18459 info_ptr
= locate_pdi_sibling (reader
, part_die
, info_ptr
);
18463 /* The exception for DW_TAG_typedef with has_children above is
18464 a workaround of GCC PR debug/47510. In the case of this complaint
18465 type_name_no_tag_or_error will error on such types later.
18467 GDB skipped children of DW_TAG_typedef by the shortcut above and then
18468 it could not find the child DIEs referenced later, this is checked
18469 above. In correct DWARF DW_TAG_typedef should have no children. */
18471 if (part_die
->tag
== DW_TAG_typedef
&& part_die
->has_children
)
18472 complaint (&symfile_complaints
,
18473 _("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
18474 "- DIE at 0x%x [in module %s]"),
18475 to_underlying (part_die
->sect_off
), objfile_name (objfile
));
18477 /* If we're at the second level, and we're an enumerator, and
18478 our parent has no specification (meaning possibly lives in a
18479 namespace elsewhere), then we can add the partial symbol now
18480 instead of queueing it. */
18481 if (part_die
->tag
== DW_TAG_enumerator
18482 && parent_die
!= NULL
18483 && parent_die
->die_parent
== NULL
18484 && parent_die
->tag
== DW_TAG_enumeration_type
18485 && parent_die
->has_specification
== 0)
18487 if (part_die
->name
== NULL
)
18488 complaint (&symfile_complaints
,
18489 _("malformed enumerator DIE ignored"));
18490 else if (building_psymtab
)
18491 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
18492 VAR_DOMAIN
, LOC_CONST
,
18493 cu
->language
== language_cplus
18494 ? &objfile
->global_psymbols
18495 : &objfile
->static_psymbols
,
18496 0, cu
->language
, objfile
);
18498 info_ptr
= locate_pdi_sibling (reader
, part_die
, info_ptr
);
18502 /* We'll save this DIE so link it in. */
18503 part_die
->die_parent
= parent_die
;
18504 part_die
->die_sibling
= NULL
;
18505 part_die
->die_child
= NULL
;
18507 if (last_die
&& last_die
== parent_die
)
18508 last_die
->die_child
= part_die
;
18510 last_die
->die_sibling
= part_die
;
18512 last_die
= part_die
;
18514 if (first_die
== NULL
)
18515 first_die
= part_die
;
18517 /* Maybe add the DIE to the hash table. Not all DIEs that we
18518 find interesting need to be in the hash table, because we
18519 also have the parent/sibling/child chains; only those that we
18520 might refer to by offset later during partial symbol reading.
18522 For now this means things that might have be the target of a
18523 DW_AT_specification, DW_AT_abstract_origin, or
18524 DW_AT_extension. DW_AT_extension will refer only to
18525 namespaces; DW_AT_abstract_origin refers to functions (and
18526 many things under the function DIE, but we do not recurse
18527 into function DIEs during partial symbol reading) and
18528 possibly variables as well; DW_AT_specification refers to
18529 declarations. Declarations ought to have the DW_AT_declaration
18530 flag. It happens that GCC forgets to put it in sometimes, but
18531 only for functions, not for types.
18533 Adding more things than necessary to the hash table is harmless
18534 except for the performance cost. Adding too few will result in
18535 wasted time in find_partial_die, when we reread the compilation
18536 unit with load_all_dies set. */
18539 || abbrev
->tag
== DW_TAG_constant
18540 || abbrev
->tag
== DW_TAG_subprogram
18541 || abbrev
->tag
== DW_TAG_variable
18542 || abbrev
->tag
== DW_TAG_namespace
18543 || part_die
->is_declaration
)
18547 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
18548 to_underlying (part_die
->sect_off
),
18553 part_die
= XOBNEW (&cu
->comp_unit_obstack
, struct partial_die_info
);
18555 /* For some DIEs we want to follow their children (if any). For C
18556 we have no reason to follow the children of structures; for other
18557 languages we have to, so that we can get at method physnames
18558 to infer fully qualified class names, for DW_AT_specification,
18559 and for C++ template arguments. For C++, we also look one level
18560 inside functions to find template arguments (if the name of the
18561 function does not already contain the template arguments).
18563 For Ada, we need to scan the children of subprograms and lexical
18564 blocks as well because Ada allows the definition of nested
18565 entities that could be interesting for the debugger, such as
18566 nested subprograms for instance. */
18567 if (last_die
->has_children
18569 || last_die
->tag
== DW_TAG_namespace
18570 || last_die
->tag
== DW_TAG_module
18571 || last_die
->tag
== DW_TAG_enumeration_type
18572 || (cu
->language
== language_cplus
18573 && last_die
->tag
== DW_TAG_subprogram
18574 && (last_die
->name
== NULL
18575 || strchr (last_die
->name
, '<') == NULL
))
18576 || (cu
->language
!= language_c
18577 && (last_die
->tag
== DW_TAG_class_type
18578 || last_die
->tag
== DW_TAG_interface_type
18579 || last_die
->tag
== DW_TAG_structure_type
18580 || last_die
->tag
== DW_TAG_union_type
))
18581 || (cu
->language
== language_ada
18582 && (last_die
->tag
== DW_TAG_subprogram
18583 || last_die
->tag
== DW_TAG_lexical_block
))))
18586 parent_die
= last_die
;
18590 /* Otherwise we skip to the next sibling, if any. */
18591 info_ptr
= locate_pdi_sibling (reader
, last_die
, info_ptr
);
18593 /* Back to the top, do it again. */
18597 /* Read a minimal amount of information into the minimal die structure. */
18599 static const gdb_byte
*
18600 read_partial_die (const struct die_reader_specs
*reader
,
18601 struct partial_die_info
*part_die
,
18602 struct abbrev_info
*abbrev
, unsigned int abbrev_len
,
18603 const gdb_byte
*info_ptr
)
18605 struct dwarf2_cu
*cu
= reader
->cu
;
18606 struct dwarf2_per_objfile
*dwarf2_per_objfile
18607 = cu
->per_cu
->dwarf2_per_objfile
;
18608 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
18609 const gdb_byte
*buffer
= reader
->buffer
;
18611 struct attribute attr
;
18612 int has_low_pc_attr
= 0;
18613 int has_high_pc_attr
= 0;
18614 int high_pc_relative
= 0;
18616 memset (part_die
, 0, sizeof (struct partial_die_info
));
18618 part_die
->sect_off
= (sect_offset
) (info_ptr
- buffer
);
18620 info_ptr
+= abbrev_len
;
18622 if (abbrev
== NULL
)
18625 part_die
->tag
= abbrev
->tag
;
18626 part_die
->has_children
= abbrev
->has_children
;
18628 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
18630 info_ptr
= read_attribute (reader
, &attr
, &abbrev
->attrs
[i
], info_ptr
);
18632 /* Store the data if it is of an attribute we want to keep in a
18633 partial symbol table. */
18637 switch (part_die
->tag
)
18639 case DW_TAG_compile_unit
:
18640 case DW_TAG_partial_unit
:
18641 case DW_TAG_type_unit
:
18642 /* Compilation units have a DW_AT_name that is a filename, not
18643 a source language identifier. */
18644 case DW_TAG_enumeration_type
:
18645 case DW_TAG_enumerator
:
18646 /* These tags always have simple identifiers already; no need
18647 to canonicalize them. */
18648 part_die
->name
= DW_STRING (&attr
);
18652 = dwarf2_canonicalize_name (DW_STRING (&attr
), cu
,
18653 &objfile
->per_bfd
->storage_obstack
);
18657 case DW_AT_linkage_name
:
18658 case DW_AT_MIPS_linkage_name
:
18659 /* Note that both forms of linkage name might appear. We
18660 assume they will be the same, and we only store the last
18662 if (cu
->language
== language_ada
)
18663 part_die
->name
= DW_STRING (&attr
);
18664 part_die
->linkage_name
= DW_STRING (&attr
);
18667 has_low_pc_attr
= 1;
18668 part_die
->lowpc
= attr_value_as_address (&attr
);
18670 case DW_AT_high_pc
:
18671 has_high_pc_attr
= 1;
18672 part_die
->highpc
= attr_value_as_address (&attr
);
18673 if (cu
->header
.version
>= 4 && attr_form_is_constant (&attr
))
18674 high_pc_relative
= 1;
18676 case DW_AT_location
:
18677 /* Support the .debug_loc offsets. */
18678 if (attr_form_is_block (&attr
))
18680 part_die
->d
.locdesc
= DW_BLOCK (&attr
);
18682 else if (attr_form_is_section_offset (&attr
))
18684 dwarf2_complex_location_expr_complaint ();
18688 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
18689 "partial symbol information");
18692 case DW_AT_external
:
18693 part_die
->is_external
= DW_UNSND (&attr
);
18695 case DW_AT_declaration
:
18696 part_die
->is_declaration
= DW_UNSND (&attr
);
18699 part_die
->has_type
= 1;
18701 case DW_AT_abstract_origin
:
18702 case DW_AT_specification
:
18703 case DW_AT_extension
:
18704 part_die
->has_specification
= 1;
18705 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
);
18706 part_die
->spec_is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
18707 || cu
->per_cu
->is_dwz
);
18709 case DW_AT_sibling
:
18710 /* Ignore absolute siblings, they might point outside of
18711 the current compile unit. */
18712 if (attr
.form
== DW_FORM_ref_addr
)
18713 complaint (&symfile_complaints
,
18714 _("ignoring absolute DW_AT_sibling"));
18717 sect_offset off
= dwarf2_get_ref_die_offset (&attr
);
18718 const gdb_byte
*sibling_ptr
= buffer
+ to_underlying (off
);
18720 if (sibling_ptr
< info_ptr
)
18721 complaint (&symfile_complaints
,
18722 _("DW_AT_sibling points backwards"));
18723 else if (sibling_ptr
> reader
->buffer_end
)
18724 dwarf2_section_buffer_overflow_complaint (reader
->die_section
);
18726 part_die
->sibling
= sibling_ptr
;
18729 case DW_AT_byte_size
:
18730 part_die
->has_byte_size
= 1;
18732 case DW_AT_const_value
:
18733 part_die
->has_const_value
= 1;
18735 case DW_AT_calling_convention
:
18736 /* DWARF doesn't provide a way to identify a program's source-level
18737 entry point. DW_AT_calling_convention attributes are only meant
18738 to describe functions' calling conventions.
18740 However, because it's a necessary piece of information in
18741 Fortran, and before DWARF 4 DW_CC_program was the only
18742 piece of debugging information whose definition refers to
18743 a 'main program' at all, several compilers marked Fortran
18744 main programs with DW_CC_program --- even when those
18745 functions use the standard calling conventions.
18747 Although DWARF now specifies a way to provide this
18748 information, we support this practice for backward
18750 if (DW_UNSND (&attr
) == DW_CC_program
18751 && cu
->language
== language_fortran
)
18752 part_die
->main_subprogram
= 1;
18755 if (DW_UNSND (&attr
) == DW_INL_inlined
18756 || DW_UNSND (&attr
) == DW_INL_declared_inlined
)
18757 part_die
->may_be_inlined
= 1;
18761 if (part_die
->tag
== DW_TAG_imported_unit
)
18763 part_die
->d
.sect_off
= dwarf2_get_ref_die_offset (&attr
);
18764 part_die
->is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
18765 || cu
->per_cu
->is_dwz
);
18769 case DW_AT_main_subprogram
:
18770 part_die
->main_subprogram
= DW_UNSND (&attr
);
18778 if (high_pc_relative
)
18779 part_die
->highpc
+= part_die
->lowpc
;
18781 if (has_low_pc_attr
&& has_high_pc_attr
)
18783 /* When using the GNU linker, .gnu.linkonce. sections are used to
18784 eliminate duplicate copies of functions and vtables and such.
18785 The linker will arbitrarily choose one and discard the others.
18786 The AT_*_pc values for such functions refer to local labels in
18787 these sections. If the section from that file was discarded, the
18788 labels are not in the output, so the relocs get a value of 0.
18789 If this is a discarded function, mark the pc bounds as invalid,
18790 so that GDB will ignore it. */
18791 if (part_die
->lowpc
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
18793 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
18795 complaint (&symfile_complaints
,
18796 _("DW_AT_low_pc %s is zero "
18797 "for DIE at 0x%x [in module %s]"),
18798 paddress (gdbarch
, part_die
->lowpc
),
18799 to_underlying (part_die
->sect_off
), objfile_name (objfile
));
18801 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
18802 else if (part_die
->lowpc
>= part_die
->highpc
)
18804 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
18806 complaint (&symfile_complaints
,
18807 _("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
18808 "for DIE at 0x%x [in module %s]"),
18809 paddress (gdbarch
, part_die
->lowpc
),
18810 paddress (gdbarch
, part_die
->highpc
),
18811 to_underlying (part_die
->sect_off
),
18812 objfile_name (objfile
));
18815 part_die
->has_pc_info
= 1;
18821 /* Find a cached partial DIE at OFFSET in CU. */
18823 static struct partial_die_info
*
18824 find_partial_die_in_comp_unit (sect_offset sect_off
, struct dwarf2_cu
*cu
)
18826 struct partial_die_info
*lookup_die
= NULL
;
18827 struct partial_die_info part_die
;
18829 part_die
.sect_off
= sect_off
;
18830 lookup_die
= ((struct partial_die_info
*)
18831 htab_find_with_hash (cu
->partial_dies
, &part_die
,
18832 to_underlying (sect_off
)));
18837 /* Find a partial DIE at OFFSET, which may or may not be in CU,
18838 except in the case of .debug_types DIEs which do not reference
18839 outside their CU (they do however referencing other types via
18840 DW_FORM_ref_sig8). */
18842 static struct partial_die_info
*
18843 find_partial_die (sect_offset sect_off
, int offset_in_dwz
, struct dwarf2_cu
*cu
)
18845 struct dwarf2_per_objfile
*dwarf2_per_objfile
18846 = cu
->per_cu
->dwarf2_per_objfile
;
18847 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
18848 struct dwarf2_per_cu_data
*per_cu
= NULL
;
18849 struct partial_die_info
*pd
= NULL
;
18851 if (offset_in_dwz
== cu
->per_cu
->is_dwz
18852 && offset_in_cu_p (&cu
->header
, sect_off
))
18854 pd
= find_partial_die_in_comp_unit (sect_off
, cu
);
18857 /* We missed recording what we needed.
18858 Load all dies and try again. */
18859 per_cu
= cu
->per_cu
;
18863 /* TUs don't reference other CUs/TUs (except via type signatures). */
18864 if (cu
->per_cu
->is_debug_types
)
18866 error (_("Dwarf Error: Type Unit at offset 0x%x contains"
18867 " external reference to offset 0x%x [in module %s].\n"),
18868 to_underlying (cu
->header
.sect_off
), to_underlying (sect_off
),
18869 bfd_get_filename (objfile
->obfd
));
18871 per_cu
= dwarf2_find_containing_comp_unit (sect_off
, offset_in_dwz
,
18872 dwarf2_per_objfile
);
18874 if (per_cu
->cu
== NULL
|| per_cu
->cu
->partial_dies
== NULL
)
18875 load_partial_comp_unit (per_cu
);
18877 per_cu
->cu
->last_used
= 0;
18878 pd
= find_partial_die_in_comp_unit (sect_off
, per_cu
->cu
);
18881 /* If we didn't find it, and not all dies have been loaded,
18882 load them all and try again. */
18884 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
18886 per_cu
->load_all_dies
= 1;
18888 /* This is nasty. When we reread the DIEs, somewhere up the call chain
18889 THIS_CU->cu may already be in use. So we can't just free it and
18890 replace its DIEs with the ones we read in. Instead, we leave those
18891 DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
18892 and clobber THIS_CU->cu->partial_dies with the hash table for the new
18894 load_partial_comp_unit (per_cu
);
18896 pd
= find_partial_die_in_comp_unit (sect_off
, per_cu
->cu
);
18900 internal_error (__FILE__
, __LINE__
,
18901 _("could not find partial DIE 0x%x "
18902 "in cache [from module %s]\n"),
18903 to_underlying (sect_off
), bfd_get_filename (objfile
->obfd
));
18907 /* See if we can figure out if the class lives in a namespace. We do
18908 this by looking for a member function; its demangled name will
18909 contain namespace info, if there is any. */
18912 guess_partial_die_structure_name (struct partial_die_info
*struct_pdi
,
18913 struct dwarf2_cu
*cu
)
18915 /* NOTE: carlton/2003-10-07: Getting the info this way changes
18916 what template types look like, because the demangler
18917 frequently doesn't give the same name as the debug info. We
18918 could fix this by only using the demangled name to get the
18919 prefix (but see comment in read_structure_type). */
18921 struct partial_die_info
*real_pdi
;
18922 struct partial_die_info
*child_pdi
;
18924 /* If this DIE (this DIE's specification, if any) has a parent, then
18925 we should not do this. We'll prepend the parent's fully qualified
18926 name when we create the partial symbol. */
18928 real_pdi
= struct_pdi
;
18929 while (real_pdi
->has_specification
)
18930 real_pdi
= find_partial_die (real_pdi
->spec_offset
,
18931 real_pdi
->spec_is_dwz
, cu
);
18933 if (real_pdi
->die_parent
!= NULL
)
18936 for (child_pdi
= struct_pdi
->die_child
;
18938 child_pdi
= child_pdi
->die_sibling
)
18940 if (child_pdi
->tag
== DW_TAG_subprogram
18941 && child_pdi
->linkage_name
!= NULL
)
18943 char *actual_class_name
18944 = language_class_name_from_physname (cu
->language_defn
,
18945 child_pdi
->linkage_name
);
18946 if (actual_class_name
!= NULL
)
18948 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
18951 obstack_copy0 (&objfile
->per_bfd
->storage_obstack
,
18953 strlen (actual_class_name
)));
18954 xfree (actual_class_name
);
18961 /* Adjust PART_DIE before generating a symbol for it. This function
18962 may set the is_external flag or change the DIE's name. */
18965 fixup_partial_die (struct partial_die_info
*part_die
,
18966 struct dwarf2_cu
*cu
)
18968 /* Once we've fixed up a die, there's no point in doing so again.
18969 This also avoids a memory leak if we were to call
18970 guess_partial_die_structure_name multiple times. */
18971 if (part_die
->fixup_called
)
18974 /* If we found a reference attribute and the DIE has no name, try
18975 to find a name in the referred to DIE. */
18977 if (part_die
->name
== NULL
&& part_die
->has_specification
)
18979 struct partial_die_info
*spec_die
;
18981 spec_die
= find_partial_die (part_die
->spec_offset
,
18982 part_die
->spec_is_dwz
, cu
);
18984 fixup_partial_die (spec_die
, cu
);
18986 if (spec_die
->name
)
18988 part_die
->name
= spec_die
->name
;
18990 /* Copy DW_AT_external attribute if it is set. */
18991 if (spec_die
->is_external
)
18992 part_die
->is_external
= spec_die
->is_external
;
18996 /* Set default names for some unnamed DIEs. */
18998 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
18999 part_die
->name
= CP_ANONYMOUS_NAMESPACE_STR
;
19001 /* If there is no parent die to provide a namespace, and there are
19002 children, see if we can determine the namespace from their linkage
19004 if (cu
->language
== language_cplus
19005 && !VEC_empty (dwarf2_section_info_def
,
19006 cu
->per_cu
->dwarf2_per_objfile
->types
)
19007 && part_die
->die_parent
== NULL
19008 && part_die
->has_children
19009 && (part_die
->tag
== DW_TAG_class_type
19010 || part_die
->tag
== DW_TAG_structure_type
19011 || part_die
->tag
== DW_TAG_union_type
))
19012 guess_partial_die_structure_name (part_die
, cu
);
19014 /* GCC might emit a nameless struct or union that has a linkage
19015 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
19016 if (part_die
->name
== NULL
19017 && (part_die
->tag
== DW_TAG_class_type
19018 || part_die
->tag
== DW_TAG_interface_type
19019 || part_die
->tag
== DW_TAG_structure_type
19020 || part_die
->tag
== DW_TAG_union_type
)
19021 && part_die
->linkage_name
!= NULL
)
19025 demangled
= gdb_demangle (part_die
->linkage_name
, DMGL_TYPES
);
19030 /* Strip any leading namespaces/classes, keep only the base name.
19031 DW_AT_name for named DIEs does not contain the prefixes. */
19032 base
= strrchr (demangled
, ':');
19033 if (base
&& base
> demangled
&& base
[-1] == ':')
19038 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
19041 obstack_copy0 (&objfile
->per_bfd
->storage_obstack
,
19042 base
, strlen (base
)));
19047 part_die
->fixup_called
= 1;
19050 /* Read an attribute value described by an attribute form. */
19052 static const gdb_byte
*
19053 read_attribute_value (const struct die_reader_specs
*reader
,
19054 struct attribute
*attr
, unsigned form
,
19055 LONGEST implicit_const
, const gdb_byte
*info_ptr
)
19057 struct dwarf2_cu
*cu
= reader
->cu
;
19058 struct dwarf2_per_objfile
*dwarf2_per_objfile
19059 = cu
->per_cu
->dwarf2_per_objfile
;
19060 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
19061 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
19062 bfd
*abfd
= reader
->abfd
;
19063 struct comp_unit_head
*cu_header
= &cu
->header
;
19064 unsigned int bytes_read
;
19065 struct dwarf_block
*blk
;
19067 attr
->form
= (enum dwarf_form
) form
;
19070 case DW_FORM_ref_addr
:
19071 if (cu
->header
.version
== 2)
19072 DW_UNSND (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
19074 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
,
19075 &cu
->header
, &bytes_read
);
19076 info_ptr
+= bytes_read
;
19078 case DW_FORM_GNU_ref_alt
:
19079 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
19080 info_ptr
+= bytes_read
;
19083 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
19084 DW_ADDR (attr
) = gdbarch_adjust_dwarf2_addr (gdbarch
, DW_ADDR (attr
));
19085 info_ptr
+= bytes_read
;
19087 case DW_FORM_block2
:
19088 blk
= dwarf_alloc_block (cu
);
19089 blk
->size
= read_2_bytes (abfd
, info_ptr
);
19091 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
19092 info_ptr
+= blk
->size
;
19093 DW_BLOCK (attr
) = blk
;
19095 case DW_FORM_block4
:
19096 blk
= dwarf_alloc_block (cu
);
19097 blk
->size
= read_4_bytes (abfd
, info_ptr
);
19099 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
19100 info_ptr
+= blk
->size
;
19101 DW_BLOCK (attr
) = blk
;
19103 case DW_FORM_data2
:
19104 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
19107 case DW_FORM_data4
:
19108 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
19111 case DW_FORM_data8
:
19112 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
19115 case DW_FORM_data16
:
19116 blk
= dwarf_alloc_block (cu
);
19118 blk
->data
= read_n_bytes (abfd
, info_ptr
, 16);
19120 DW_BLOCK (attr
) = blk
;
19122 case DW_FORM_sec_offset
:
19123 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
19124 info_ptr
+= bytes_read
;
19126 case DW_FORM_string
:
19127 DW_STRING (attr
) = read_direct_string (abfd
, info_ptr
, &bytes_read
);
19128 DW_STRING_IS_CANONICAL (attr
) = 0;
19129 info_ptr
+= bytes_read
;
19132 if (!cu
->per_cu
->is_dwz
)
19134 DW_STRING (attr
) = read_indirect_string (dwarf2_per_objfile
,
19135 abfd
, info_ptr
, cu_header
,
19137 DW_STRING_IS_CANONICAL (attr
) = 0;
19138 info_ptr
+= bytes_read
;
19142 case DW_FORM_line_strp
:
19143 if (!cu
->per_cu
->is_dwz
)
19145 DW_STRING (attr
) = read_indirect_line_string (dwarf2_per_objfile
,
19147 cu_header
, &bytes_read
);
19148 DW_STRING_IS_CANONICAL (attr
) = 0;
19149 info_ptr
+= bytes_read
;
19153 case DW_FORM_GNU_strp_alt
:
19155 struct dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
19156 LONGEST str_offset
= read_offset (abfd
, info_ptr
, cu_header
,
19159 DW_STRING (attr
) = read_indirect_string_from_dwz (objfile
,
19161 DW_STRING_IS_CANONICAL (attr
) = 0;
19162 info_ptr
+= bytes_read
;
19165 case DW_FORM_exprloc
:
19166 case DW_FORM_block
:
19167 blk
= dwarf_alloc_block (cu
);
19168 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
19169 info_ptr
+= bytes_read
;
19170 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
19171 info_ptr
+= blk
->size
;
19172 DW_BLOCK (attr
) = blk
;
19174 case DW_FORM_block1
:
19175 blk
= dwarf_alloc_block (cu
);
19176 blk
->size
= read_1_byte (abfd
, info_ptr
);
19178 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
19179 info_ptr
+= blk
->size
;
19180 DW_BLOCK (attr
) = blk
;
19182 case DW_FORM_data1
:
19183 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
19187 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
19190 case DW_FORM_flag_present
:
19191 DW_UNSND (attr
) = 1;
19193 case DW_FORM_sdata
:
19194 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
19195 info_ptr
+= bytes_read
;
19197 case DW_FORM_udata
:
19198 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
19199 info_ptr
+= bytes_read
;
19202 DW_UNSND (attr
) = (to_underlying (cu
->header
.sect_off
)
19203 + read_1_byte (abfd
, info_ptr
));
19207 DW_UNSND (attr
) = (to_underlying (cu
->header
.sect_off
)
19208 + read_2_bytes (abfd
, info_ptr
));
19212 DW_UNSND (attr
) = (to_underlying (cu
->header
.sect_off
)
19213 + read_4_bytes (abfd
, info_ptr
));
19217 DW_UNSND (attr
) = (to_underlying (cu
->header
.sect_off
)
19218 + read_8_bytes (abfd
, info_ptr
));
19221 case DW_FORM_ref_sig8
:
19222 DW_SIGNATURE (attr
) = read_8_bytes (abfd
, info_ptr
);
19225 case DW_FORM_ref_udata
:
19226 DW_UNSND (attr
) = (to_underlying (cu
->header
.sect_off
)
19227 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
19228 info_ptr
+= bytes_read
;
19230 case DW_FORM_indirect
:
19231 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
19232 info_ptr
+= bytes_read
;
19233 if (form
== DW_FORM_implicit_const
)
19235 implicit_const
= read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
19236 info_ptr
+= bytes_read
;
19238 info_ptr
= read_attribute_value (reader
, attr
, form
, implicit_const
,
19241 case DW_FORM_implicit_const
:
19242 DW_SND (attr
) = implicit_const
;
19244 case DW_FORM_GNU_addr_index
:
19245 if (reader
->dwo_file
== NULL
)
19247 /* For now flag a hard error.
19248 Later we can turn this into a complaint. */
19249 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
19250 dwarf_form_name (form
),
19251 bfd_get_filename (abfd
));
19253 DW_ADDR (attr
) = read_addr_index_from_leb128 (cu
, info_ptr
, &bytes_read
);
19254 info_ptr
+= bytes_read
;
19256 case DW_FORM_GNU_str_index
:
19257 if (reader
->dwo_file
== NULL
)
19259 /* For now flag a hard error.
19260 Later we can turn this into a complaint if warranted. */
19261 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
19262 dwarf_form_name (form
),
19263 bfd_get_filename (abfd
));
19266 ULONGEST str_index
=
19267 read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
19269 DW_STRING (attr
) = read_str_index (reader
, str_index
);
19270 DW_STRING_IS_CANONICAL (attr
) = 0;
19271 info_ptr
+= bytes_read
;
19275 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
19276 dwarf_form_name (form
),
19277 bfd_get_filename (abfd
));
19281 if (cu
->per_cu
->is_dwz
&& attr_form_is_ref (attr
))
19282 attr
->form
= DW_FORM_GNU_ref_alt
;
19284 /* We have seen instances where the compiler tried to emit a byte
19285 size attribute of -1 which ended up being encoded as an unsigned
19286 0xffffffff. Although 0xffffffff is technically a valid size value,
19287 an object of this size seems pretty unlikely so we can relatively
19288 safely treat these cases as if the size attribute was invalid and
19289 treat them as zero by default. */
19290 if (attr
->name
== DW_AT_byte_size
19291 && form
== DW_FORM_data4
19292 && DW_UNSND (attr
) >= 0xffffffff)
19295 (&symfile_complaints
,
19296 _("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
19297 hex_string (DW_UNSND (attr
)));
19298 DW_UNSND (attr
) = 0;
19304 /* Read an attribute described by an abbreviated attribute. */
19306 static const gdb_byte
*
19307 read_attribute (const struct die_reader_specs
*reader
,
19308 struct attribute
*attr
, struct attr_abbrev
*abbrev
,
19309 const gdb_byte
*info_ptr
)
19311 attr
->name
= abbrev
->name
;
19312 return read_attribute_value (reader
, attr
, abbrev
->form
,
19313 abbrev
->implicit_const
, info_ptr
);
19316 /* Read dwarf information from a buffer. */
19318 static unsigned int
19319 read_1_byte (bfd
*abfd
, const gdb_byte
*buf
)
19321 return bfd_get_8 (abfd
, buf
);
19325 read_1_signed_byte (bfd
*abfd
, const gdb_byte
*buf
)
19327 return bfd_get_signed_8 (abfd
, buf
);
19330 static unsigned int
19331 read_2_bytes (bfd
*abfd
, const gdb_byte
*buf
)
19333 return bfd_get_16 (abfd
, buf
);
19337 read_2_signed_bytes (bfd
*abfd
, const gdb_byte
*buf
)
19339 return bfd_get_signed_16 (abfd
, buf
);
19342 static unsigned int
19343 read_4_bytes (bfd
*abfd
, const gdb_byte
*buf
)
19345 return bfd_get_32 (abfd
, buf
);
19349 read_4_signed_bytes (bfd
*abfd
, const gdb_byte
*buf
)
19351 return bfd_get_signed_32 (abfd
, buf
);
19355 read_8_bytes (bfd
*abfd
, const gdb_byte
*buf
)
19357 return bfd_get_64 (abfd
, buf
);
19361 read_address (bfd
*abfd
, const gdb_byte
*buf
, struct dwarf2_cu
*cu
,
19362 unsigned int *bytes_read
)
19364 struct comp_unit_head
*cu_header
= &cu
->header
;
19365 CORE_ADDR retval
= 0;
19367 if (cu_header
->signed_addr_p
)
19369 switch (cu_header
->addr_size
)
19372 retval
= bfd_get_signed_16 (abfd
, buf
);
19375 retval
= bfd_get_signed_32 (abfd
, buf
);
19378 retval
= bfd_get_signed_64 (abfd
, buf
);
19381 internal_error (__FILE__
, __LINE__
,
19382 _("read_address: bad switch, signed [in module %s]"),
19383 bfd_get_filename (abfd
));
19388 switch (cu_header
->addr_size
)
19391 retval
= bfd_get_16 (abfd
, buf
);
19394 retval
= bfd_get_32 (abfd
, buf
);
19397 retval
= bfd_get_64 (abfd
, buf
);
19400 internal_error (__FILE__
, __LINE__
,
19401 _("read_address: bad switch, "
19402 "unsigned [in module %s]"),
19403 bfd_get_filename (abfd
));
19407 *bytes_read
= cu_header
->addr_size
;
19411 /* Read the initial length from a section. The (draft) DWARF 3
19412 specification allows the initial length to take up either 4 bytes
19413 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
19414 bytes describe the length and all offsets will be 8 bytes in length
19417 An older, non-standard 64-bit format is also handled by this
19418 function. The older format in question stores the initial length
19419 as an 8-byte quantity without an escape value. Lengths greater
19420 than 2^32 aren't very common which means that the initial 4 bytes
19421 is almost always zero. Since a length value of zero doesn't make
19422 sense for the 32-bit format, this initial zero can be considered to
19423 be an escape value which indicates the presence of the older 64-bit
19424 format. As written, the code can't detect (old format) lengths
19425 greater than 4GB. If it becomes necessary to handle lengths
19426 somewhat larger than 4GB, we could allow other small values (such
19427 as the non-sensical values of 1, 2, and 3) to also be used as
19428 escape values indicating the presence of the old format.
19430 The value returned via bytes_read should be used to increment the
19431 relevant pointer after calling read_initial_length().
19433 [ Note: read_initial_length() and read_offset() are based on the
19434 document entitled "DWARF Debugging Information Format", revision
19435 3, draft 8, dated November 19, 2001. This document was obtained
19438 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
19440 This document is only a draft and is subject to change. (So beware.)
19442 Details regarding the older, non-standard 64-bit format were
19443 determined empirically by examining 64-bit ELF files produced by
19444 the SGI toolchain on an IRIX 6.5 machine.
19446 - Kevin, July 16, 2002
19450 read_initial_length (bfd
*abfd
, const gdb_byte
*buf
, unsigned int *bytes_read
)
19452 LONGEST length
= bfd_get_32 (abfd
, buf
);
19454 if (length
== 0xffffffff)
19456 length
= bfd_get_64 (abfd
, buf
+ 4);
19459 else if (length
== 0)
19461 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
19462 length
= bfd_get_64 (abfd
, buf
);
19473 /* Cover function for read_initial_length.
19474 Returns the length of the object at BUF, and stores the size of the
19475 initial length in *BYTES_READ and stores the size that offsets will be in
19477 If the initial length size is not equivalent to that specified in
19478 CU_HEADER then issue a complaint.
19479 This is useful when reading non-comp-unit headers. */
19482 read_checked_initial_length_and_offset (bfd
*abfd
, const gdb_byte
*buf
,
19483 const struct comp_unit_head
*cu_header
,
19484 unsigned int *bytes_read
,
19485 unsigned int *offset_size
)
19487 LONGEST length
= read_initial_length (abfd
, buf
, bytes_read
);
19489 gdb_assert (cu_header
->initial_length_size
== 4
19490 || cu_header
->initial_length_size
== 8
19491 || cu_header
->initial_length_size
== 12);
19493 if (cu_header
->initial_length_size
!= *bytes_read
)
19494 complaint (&symfile_complaints
,
19495 _("intermixed 32-bit and 64-bit DWARF sections"));
19497 *offset_size
= (*bytes_read
== 4) ? 4 : 8;
19501 /* Read an offset from the data stream. The size of the offset is
19502 given by cu_header->offset_size. */
19505 read_offset (bfd
*abfd
, const gdb_byte
*buf
,
19506 const struct comp_unit_head
*cu_header
,
19507 unsigned int *bytes_read
)
19509 LONGEST offset
= read_offset_1 (abfd
, buf
, cu_header
->offset_size
);
19511 *bytes_read
= cu_header
->offset_size
;
19515 /* Read an offset from the data stream. */
19518 read_offset_1 (bfd
*abfd
, const gdb_byte
*buf
, unsigned int offset_size
)
19520 LONGEST retval
= 0;
19522 switch (offset_size
)
19525 retval
= bfd_get_32 (abfd
, buf
);
19528 retval
= bfd_get_64 (abfd
, buf
);
19531 internal_error (__FILE__
, __LINE__
,
19532 _("read_offset_1: bad switch [in module %s]"),
19533 bfd_get_filename (abfd
));
19539 static const gdb_byte
*
19540 read_n_bytes (bfd
*abfd
, const gdb_byte
*buf
, unsigned int size
)
19542 /* If the size of a host char is 8 bits, we can return a pointer
19543 to the buffer, otherwise we have to copy the data to a buffer
19544 allocated on the temporary obstack. */
19545 gdb_assert (HOST_CHAR_BIT
== 8);
19549 static const char *
19550 read_direct_string (bfd
*abfd
, const gdb_byte
*buf
,
19551 unsigned int *bytes_read_ptr
)
19553 /* If the size of a host char is 8 bits, we can return a pointer
19554 to the string, otherwise we have to copy the string to a buffer
19555 allocated on the temporary obstack. */
19556 gdb_assert (HOST_CHAR_BIT
== 8);
19559 *bytes_read_ptr
= 1;
19562 *bytes_read_ptr
= strlen ((const char *) buf
) + 1;
19563 return (const char *) buf
;
19566 /* Return pointer to string at section SECT offset STR_OFFSET with error
19567 reporting strings FORM_NAME and SECT_NAME. */
19569 static const char *
19570 read_indirect_string_at_offset_from (struct objfile
*objfile
,
19571 bfd
*abfd
, LONGEST str_offset
,
19572 struct dwarf2_section_info
*sect
,
19573 const char *form_name
,
19574 const char *sect_name
)
19576 dwarf2_read_section (objfile
, sect
);
19577 if (sect
->buffer
== NULL
)
19578 error (_("%s used without %s section [in module %s]"),
19579 form_name
, sect_name
, bfd_get_filename (abfd
));
19580 if (str_offset
>= sect
->size
)
19581 error (_("%s pointing outside of %s section [in module %s]"),
19582 form_name
, sect_name
, bfd_get_filename (abfd
));
19583 gdb_assert (HOST_CHAR_BIT
== 8);
19584 if (sect
->buffer
[str_offset
] == '\0')
19586 return (const char *) (sect
->buffer
+ str_offset
);
19589 /* Return pointer to string at .debug_str offset STR_OFFSET. */
19591 static const char *
19592 read_indirect_string_at_offset (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
19593 bfd
*abfd
, LONGEST str_offset
)
19595 return read_indirect_string_at_offset_from (dwarf2_per_objfile
->objfile
,
19597 &dwarf2_per_objfile
->str
,
19598 "DW_FORM_strp", ".debug_str");
19601 /* Return pointer to string at .debug_line_str offset STR_OFFSET. */
19603 static const char *
19604 read_indirect_line_string_at_offset (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
19605 bfd
*abfd
, LONGEST str_offset
)
19607 return read_indirect_string_at_offset_from (dwarf2_per_objfile
->objfile
,
19609 &dwarf2_per_objfile
->line_str
,
19610 "DW_FORM_line_strp",
19611 ".debug_line_str");
19614 /* Read a string at offset STR_OFFSET in the .debug_str section from
19615 the .dwz file DWZ. Throw an error if the offset is too large. If
19616 the string consists of a single NUL byte, return NULL; otherwise
19617 return a pointer to the string. */
19619 static const char *
19620 read_indirect_string_from_dwz (struct objfile
*objfile
, struct dwz_file
*dwz
,
19621 LONGEST str_offset
)
19623 dwarf2_read_section (objfile
, &dwz
->str
);
19625 if (dwz
->str
.buffer
== NULL
)
19626 error (_("DW_FORM_GNU_strp_alt used without .debug_str "
19627 "section [in module %s]"),
19628 bfd_get_filename (dwz
->dwz_bfd
));
19629 if (str_offset
>= dwz
->str
.size
)
19630 error (_("DW_FORM_GNU_strp_alt pointing outside of "
19631 ".debug_str section [in module %s]"),
19632 bfd_get_filename (dwz
->dwz_bfd
));
19633 gdb_assert (HOST_CHAR_BIT
== 8);
19634 if (dwz
->str
.buffer
[str_offset
] == '\0')
19636 return (const char *) (dwz
->str
.buffer
+ str_offset
);
19639 /* Return pointer to string at .debug_str offset as read from BUF.
19640 BUF is assumed to be in a compilation unit described by CU_HEADER.
19641 Return *BYTES_READ_PTR count of bytes read from BUF. */
19643 static const char *
19644 read_indirect_string (struct dwarf2_per_objfile
*dwarf2_per_objfile
, bfd
*abfd
,
19645 const gdb_byte
*buf
,
19646 const struct comp_unit_head
*cu_header
,
19647 unsigned int *bytes_read_ptr
)
19649 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
, bytes_read_ptr
);
19651 return read_indirect_string_at_offset (dwarf2_per_objfile
, abfd
, str_offset
);
19654 /* Return pointer to string at .debug_line_str offset as read from BUF.
19655 BUF is assumed to be in a compilation unit described by CU_HEADER.
19656 Return *BYTES_READ_PTR count of bytes read from BUF. */
19658 static const char *
19659 read_indirect_line_string (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
19660 bfd
*abfd
, const gdb_byte
*buf
,
19661 const struct comp_unit_head
*cu_header
,
19662 unsigned int *bytes_read_ptr
)
19664 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
, bytes_read_ptr
);
19666 return read_indirect_line_string_at_offset (dwarf2_per_objfile
, abfd
,
19671 read_unsigned_leb128 (bfd
*abfd
, const gdb_byte
*buf
,
19672 unsigned int *bytes_read_ptr
)
19675 unsigned int num_read
;
19677 unsigned char byte
;
19684 byte
= bfd_get_8 (abfd
, buf
);
19687 result
|= ((ULONGEST
) (byte
& 127) << shift
);
19688 if ((byte
& 128) == 0)
19694 *bytes_read_ptr
= num_read
;
19699 read_signed_leb128 (bfd
*abfd
, const gdb_byte
*buf
,
19700 unsigned int *bytes_read_ptr
)
19703 int shift
, num_read
;
19704 unsigned char byte
;
19711 byte
= bfd_get_8 (abfd
, buf
);
19714 result
|= ((LONGEST
) (byte
& 127) << shift
);
19716 if ((byte
& 128) == 0)
19721 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
19722 result
|= -(((LONGEST
) 1) << shift
);
19723 *bytes_read_ptr
= num_read
;
19727 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
19728 ADDR_BASE is the DW_AT_GNU_addr_base attribute or zero.
19729 ADDR_SIZE is the size of addresses from the CU header. */
19732 read_addr_index_1 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
19733 unsigned int addr_index
, ULONGEST addr_base
, int addr_size
)
19735 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
19736 bfd
*abfd
= objfile
->obfd
;
19737 const gdb_byte
*info_ptr
;
19739 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->addr
);
19740 if (dwarf2_per_objfile
->addr
.buffer
== NULL
)
19741 error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
19742 objfile_name (objfile
));
19743 if (addr_base
+ addr_index
* addr_size
>= dwarf2_per_objfile
->addr
.size
)
19744 error (_("DW_FORM_addr_index pointing outside of "
19745 ".debug_addr section [in module %s]"),
19746 objfile_name (objfile
));
19747 info_ptr
= (dwarf2_per_objfile
->addr
.buffer
19748 + addr_base
+ addr_index
* addr_size
);
19749 if (addr_size
== 4)
19750 return bfd_get_32 (abfd
, info_ptr
);
19752 return bfd_get_64 (abfd
, info_ptr
);
19755 /* Given index ADDR_INDEX in .debug_addr, fetch the value. */
19758 read_addr_index (struct dwarf2_cu
*cu
, unsigned int addr_index
)
19760 return read_addr_index_1 (cu
->per_cu
->dwarf2_per_objfile
, addr_index
,
19761 cu
->addr_base
, cu
->header
.addr_size
);
19764 /* Given a pointer to an leb128 value, fetch the value from .debug_addr. */
19767 read_addr_index_from_leb128 (struct dwarf2_cu
*cu
, const gdb_byte
*info_ptr
,
19768 unsigned int *bytes_read
)
19770 bfd
*abfd
= cu
->per_cu
->dwarf2_per_objfile
->objfile
->obfd
;
19771 unsigned int addr_index
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
19773 return read_addr_index (cu
, addr_index
);
19776 /* Data structure to pass results from dwarf2_read_addr_index_reader
19777 back to dwarf2_read_addr_index. */
19779 struct dwarf2_read_addr_index_data
19781 ULONGEST addr_base
;
19785 /* die_reader_func for dwarf2_read_addr_index. */
19788 dwarf2_read_addr_index_reader (const struct die_reader_specs
*reader
,
19789 const gdb_byte
*info_ptr
,
19790 struct die_info
*comp_unit_die
,
19794 struct dwarf2_cu
*cu
= reader
->cu
;
19795 struct dwarf2_read_addr_index_data
*aidata
=
19796 (struct dwarf2_read_addr_index_data
*) data
;
19798 aidata
->addr_base
= cu
->addr_base
;
19799 aidata
->addr_size
= cu
->header
.addr_size
;
19802 /* Given an index in .debug_addr, fetch the value.
19803 NOTE: This can be called during dwarf expression evaluation,
19804 long after the debug information has been read, and thus per_cu->cu
19805 may no longer exist. */
19808 dwarf2_read_addr_index (struct dwarf2_per_cu_data
*per_cu
,
19809 unsigned int addr_index
)
19811 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
19812 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
19813 struct dwarf2_cu
*cu
= per_cu
->cu
;
19814 ULONGEST addr_base
;
19817 /* We need addr_base and addr_size.
19818 If we don't have PER_CU->cu, we have to get it.
19819 Nasty, but the alternative is storing the needed info in PER_CU,
19820 which at this point doesn't seem justified: it's not clear how frequently
19821 it would get used and it would increase the size of every PER_CU.
19822 Entry points like dwarf2_per_cu_addr_size do a similar thing
19823 so we're not in uncharted territory here.
19824 Alas we need to be a bit more complicated as addr_base is contained
19827 We don't need to read the entire CU(/TU).
19828 We just need the header and top level die.
19830 IWBN to use the aging mechanism to let us lazily later discard the CU.
19831 For now we skip this optimization. */
19835 addr_base
= cu
->addr_base
;
19836 addr_size
= cu
->header
.addr_size
;
19840 struct dwarf2_read_addr_index_data aidata
;
19842 /* Note: We can't use init_cutu_and_read_dies_simple here,
19843 we need addr_base. */
19844 init_cutu_and_read_dies (per_cu
, NULL
, 0, 0,
19845 dwarf2_read_addr_index_reader
, &aidata
);
19846 addr_base
= aidata
.addr_base
;
19847 addr_size
= aidata
.addr_size
;
19850 return read_addr_index_1 (dwarf2_per_objfile
, addr_index
, addr_base
,
19854 /* Given a DW_FORM_GNU_str_index, fetch the string.
19855 This is only used by the Fission support. */
19857 static const char *
19858 read_str_index (const struct die_reader_specs
*reader
, ULONGEST str_index
)
19860 struct dwarf2_cu
*cu
= reader
->cu
;
19861 struct dwarf2_per_objfile
*dwarf2_per_objfile
19862 = cu
->per_cu
->dwarf2_per_objfile
;
19863 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
19864 const char *objf_name
= objfile_name (objfile
);
19865 bfd
*abfd
= objfile
->obfd
;
19866 struct dwarf2_section_info
*str_section
= &reader
->dwo_file
->sections
.str
;
19867 struct dwarf2_section_info
*str_offsets_section
=
19868 &reader
->dwo_file
->sections
.str_offsets
;
19869 const gdb_byte
*info_ptr
;
19870 ULONGEST str_offset
;
19871 static const char form_name
[] = "DW_FORM_GNU_str_index";
19873 dwarf2_read_section (objfile
, str_section
);
19874 dwarf2_read_section (objfile
, str_offsets_section
);
19875 if (str_section
->buffer
== NULL
)
19876 error (_("%s used without .debug_str.dwo section"
19877 " in CU at offset 0x%x [in module %s]"),
19878 form_name
, to_underlying (cu
->header
.sect_off
), objf_name
);
19879 if (str_offsets_section
->buffer
== NULL
)
19880 error (_("%s used without .debug_str_offsets.dwo section"
19881 " in CU at offset 0x%x [in module %s]"),
19882 form_name
, to_underlying (cu
->header
.sect_off
), objf_name
);
19883 if (str_index
* cu
->header
.offset_size
>= str_offsets_section
->size
)
19884 error (_("%s pointing outside of .debug_str_offsets.dwo"
19885 " section in CU at offset 0x%x [in module %s]"),
19886 form_name
, to_underlying (cu
->header
.sect_off
), objf_name
);
19887 info_ptr
= (str_offsets_section
->buffer
19888 + str_index
* cu
->header
.offset_size
);
19889 if (cu
->header
.offset_size
== 4)
19890 str_offset
= bfd_get_32 (abfd
, info_ptr
);
19892 str_offset
= bfd_get_64 (abfd
, info_ptr
);
19893 if (str_offset
>= str_section
->size
)
19894 error (_("Offset from %s pointing outside of"
19895 " .debug_str.dwo section in CU at offset 0x%x [in module %s]"),
19896 form_name
, to_underlying (cu
->header
.sect_off
), objf_name
);
19897 return (const char *) (str_section
->buffer
+ str_offset
);
19900 /* Return the length of an LEB128 number in BUF. */
19903 leb128_size (const gdb_byte
*buf
)
19905 const gdb_byte
*begin
= buf
;
19911 if ((byte
& 128) == 0)
19912 return buf
- begin
;
19917 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
19926 cu
->language
= language_c
;
19929 case DW_LANG_C_plus_plus
:
19930 case DW_LANG_C_plus_plus_11
:
19931 case DW_LANG_C_plus_plus_14
:
19932 cu
->language
= language_cplus
;
19935 cu
->language
= language_d
;
19937 case DW_LANG_Fortran77
:
19938 case DW_LANG_Fortran90
:
19939 case DW_LANG_Fortran95
:
19940 case DW_LANG_Fortran03
:
19941 case DW_LANG_Fortran08
:
19942 cu
->language
= language_fortran
;
19945 cu
->language
= language_go
;
19947 case DW_LANG_Mips_Assembler
:
19948 cu
->language
= language_asm
;
19950 case DW_LANG_Ada83
:
19951 case DW_LANG_Ada95
:
19952 cu
->language
= language_ada
;
19954 case DW_LANG_Modula2
:
19955 cu
->language
= language_m2
;
19957 case DW_LANG_Pascal83
:
19958 cu
->language
= language_pascal
;
19961 cu
->language
= language_objc
;
19964 case DW_LANG_Rust_old
:
19965 cu
->language
= language_rust
;
19967 case DW_LANG_Cobol74
:
19968 case DW_LANG_Cobol85
:
19970 cu
->language
= language_minimal
;
19973 cu
->language_defn
= language_def (cu
->language
);
19976 /* Return the named attribute or NULL if not there. */
19978 static struct attribute
*
19979 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
19984 struct attribute
*spec
= NULL
;
19986 for (i
= 0; i
< die
->num_attrs
; ++i
)
19988 if (die
->attrs
[i
].name
== name
)
19989 return &die
->attrs
[i
];
19990 if (die
->attrs
[i
].name
== DW_AT_specification
19991 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
19992 spec
= &die
->attrs
[i
];
19998 die
= follow_die_ref (die
, spec
, &cu
);
20004 /* Return the named attribute or NULL if not there,
20005 but do not follow DW_AT_specification, etc.
20006 This is for use in contexts where we're reading .debug_types dies.
20007 Following DW_AT_specification, DW_AT_abstract_origin will take us
20008 back up the chain, and we want to go down. */
20010 static struct attribute
*
20011 dwarf2_attr_no_follow (struct die_info
*die
, unsigned int name
)
20015 for (i
= 0; i
< die
->num_attrs
; ++i
)
20016 if (die
->attrs
[i
].name
== name
)
20017 return &die
->attrs
[i
];
20022 /* Return the string associated with a string-typed attribute, or NULL if it
20023 is either not found or is of an incorrect type. */
20025 static const char *
20026 dwarf2_string_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
20028 struct attribute
*attr
;
20029 const char *str
= NULL
;
20031 attr
= dwarf2_attr (die
, name
, cu
);
20035 if (attr
->form
== DW_FORM_strp
|| attr
->form
== DW_FORM_line_strp
20036 || attr
->form
== DW_FORM_string
20037 || attr
->form
== DW_FORM_GNU_str_index
20038 || attr
->form
== DW_FORM_GNU_strp_alt
)
20039 str
= DW_STRING (attr
);
20041 complaint (&symfile_complaints
,
20042 _("string type expected for attribute %s for "
20043 "DIE at 0x%x in module %s"),
20044 dwarf_attr_name (name
), to_underlying (die
->sect_off
),
20045 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
20051 /* Return non-zero iff the attribute NAME is defined for the given DIE,
20052 and holds a non-zero value. This function should only be used for
20053 DW_FORM_flag or DW_FORM_flag_present attributes. */
20056 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
20058 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
20060 return (attr
&& DW_UNSND (attr
));
20064 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
20066 /* A DIE is a declaration if it has a DW_AT_declaration attribute
20067 which value is non-zero. However, we have to be careful with
20068 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
20069 (via dwarf2_flag_true_p) follows this attribute. So we may
20070 end up accidently finding a declaration attribute that belongs
20071 to a different DIE referenced by the specification attribute,
20072 even though the given DIE does not have a declaration attribute. */
20073 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
20074 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
20077 /* Return the die giving the specification for DIE, if there is
20078 one. *SPEC_CU is the CU containing DIE on input, and the CU
20079 containing the return value on output. If there is no
20080 specification, but there is an abstract origin, that is
20083 static struct die_info
*
20084 die_specification (struct die_info
*die
, struct dwarf2_cu
**spec_cu
)
20086 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
,
20089 if (spec_attr
== NULL
)
20090 spec_attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, *spec_cu
);
20092 if (spec_attr
== NULL
)
20095 return follow_die_ref (die
, spec_attr
, spec_cu
);
20098 /* Stub for free_line_header to match void * callback types. */
20101 free_line_header_voidp (void *arg
)
20103 struct line_header
*lh
= (struct line_header
*) arg
;
20109 line_header::add_include_dir (const char *include_dir
)
20111 if (dwarf_line_debug
>= 2)
20112 fprintf_unfiltered (gdb_stdlog
, "Adding dir %zu: %s\n",
20113 include_dirs
.size () + 1, include_dir
);
20115 include_dirs
.push_back (include_dir
);
20119 line_header::add_file_name (const char *name
,
20121 unsigned int mod_time
,
20122 unsigned int length
)
20124 if (dwarf_line_debug
>= 2)
20125 fprintf_unfiltered (gdb_stdlog
, "Adding file %u: %s\n",
20126 (unsigned) file_names
.size () + 1, name
);
20128 file_names
.emplace_back (name
, d_index
, mod_time
, length
);
20131 /* A convenience function to find the proper .debug_line section for a CU. */
20133 static struct dwarf2_section_info
*
20134 get_debug_line_section (struct dwarf2_cu
*cu
)
20136 struct dwarf2_section_info
*section
;
20137 struct dwarf2_per_objfile
*dwarf2_per_objfile
20138 = cu
->per_cu
->dwarf2_per_objfile
;
20140 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
20142 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
20143 section
= &cu
->dwo_unit
->dwo_file
->sections
.line
;
20144 else if (cu
->per_cu
->is_dwz
)
20146 struct dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
20148 section
= &dwz
->line
;
20151 section
= &dwarf2_per_objfile
->line
;
20156 /* Read directory or file name entry format, starting with byte of
20157 format count entries, ULEB128 pairs of entry formats, ULEB128 of
20158 entries count and the entries themselves in the described entry
20162 read_formatted_entries (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
20163 bfd
*abfd
, const gdb_byte
**bufp
,
20164 struct line_header
*lh
,
20165 const struct comp_unit_head
*cu_header
,
20166 void (*callback
) (struct line_header
*lh
,
20169 unsigned int mod_time
,
20170 unsigned int length
))
20172 gdb_byte format_count
, formati
;
20173 ULONGEST data_count
, datai
;
20174 const gdb_byte
*buf
= *bufp
;
20175 const gdb_byte
*format_header_data
;
20176 unsigned int bytes_read
;
20178 format_count
= read_1_byte (abfd
, buf
);
20180 format_header_data
= buf
;
20181 for (formati
= 0; formati
< format_count
; formati
++)
20183 read_unsigned_leb128 (abfd
, buf
, &bytes_read
);
20185 read_unsigned_leb128 (abfd
, buf
, &bytes_read
);
20189 data_count
= read_unsigned_leb128 (abfd
, buf
, &bytes_read
);
20191 for (datai
= 0; datai
< data_count
; datai
++)
20193 const gdb_byte
*format
= format_header_data
;
20194 struct file_entry fe
;
20196 for (formati
= 0; formati
< format_count
; formati
++)
20198 ULONGEST content_type
= read_unsigned_leb128 (abfd
, format
, &bytes_read
);
20199 format
+= bytes_read
;
20201 ULONGEST form
= read_unsigned_leb128 (abfd
, format
, &bytes_read
);
20202 format
+= bytes_read
;
20204 gdb::optional
<const char *> string
;
20205 gdb::optional
<unsigned int> uint
;
20209 case DW_FORM_string
:
20210 string
.emplace (read_direct_string (abfd
, buf
, &bytes_read
));
20214 case DW_FORM_line_strp
:
20215 string
.emplace (read_indirect_line_string (dwarf2_per_objfile
,
20222 case DW_FORM_data1
:
20223 uint
.emplace (read_1_byte (abfd
, buf
));
20227 case DW_FORM_data2
:
20228 uint
.emplace (read_2_bytes (abfd
, buf
));
20232 case DW_FORM_data4
:
20233 uint
.emplace (read_4_bytes (abfd
, buf
));
20237 case DW_FORM_data8
:
20238 uint
.emplace (read_8_bytes (abfd
, buf
));
20242 case DW_FORM_udata
:
20243 uint
.emplace (read_unsigned_leb128 (abfd
, buf
, &bytes_read
));
20247 case DW_FORM_block
:
20248 /* It is valid only for DW_LNCT_timestamp which is ignored by
20253 switch (content_type
)
20256 if (string
.has_value ())
20259 case DW_LNCT_directory_index
:
20260 if (uint
.has_value ())
20261 fe
.d_index
= (dir_index
) *uint
;
20263 case DW_LNCT_timestamp
:
20264 if (uint
.has_value ())
20265 fe
.mod_time
= *uint
;
20268 if (uint
.has_value ())
20274 complaint (&symfile_complaints
,
20275 _("Unknown format content type %s"),
20276 pulongest (content_type
));
20280 callback (lh
, fe
.name
, fe
.d_index
, fe
.mod_time
, fe
.length
);
20286 /* Read the statement program header starting at OFFSET in
20287 .debug_line, or .debug_line.dwo. Return a pointer
20288 to a struct line_header, allocated using xmalloc.
20289 Returns NULL if there is a problem reading the header, e.g., if it
20290 has a version we don't understand.
20292 NOTE: the strings in the include directory and file name tables of
20293 the returned object point into the dwarf line section buffer,
20294 and must not be freed. */
20296 static line_header_up
20297 dwarf_decode_line_header (sect_offset sect_off
, struct dwarf2_cu
*cu
)
20299 const gdb_byte
*line_ptr
;
20300 unsigned int bytes_read
, offset_size
;
20302 const char *cur_dir
, *cur_file
;
20303 struct dwarf2_section_info
*section
;
20305 struct dwarf2_per_objfile
*dwarf2_per_objfile
20306 = cu
->per_cu
->dwarf2_per_objfile
;
20308 section
= get_debug_line_section (cu
);
20309 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
20310 if (section
->buffer
== NULL
)
20312 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
20313 complaint (&symfile_complaints
, _("missing .debug_line.dwo section"));
20315 complaint (&symfile_complaints
, _("missing .debug_line section"));
20319 /* We can't do this until we know the section is non-empty.
20320 Only then do we know we have such a section. */
20321 abfd
= get_section_bfd_owner (section
);
20323 /* Make sure that at least there's room for the total_length field.
20324 That could be 12 bytes long, but we're just going to fudge that. */
20325 if (to_underlying (sect_off
) + 4 >= section
->size
)
20327 dwarf2_statement_list_fits_in_line_number_section_complaint ();
20331 line_header_up
lh (new line_header ());
20333 lh
->sect_off
= sect_off
;
20334 lh
->offset_in_dwz
= cu
->per_cu
->is_dwz
;
20336 line_ptr
= section
->buffer
+ to_underlying (sect_off
);
20338 /* Read in the header. */
20340 read_checked_initial_length_and_offset (abfd
, line_ptr
, &cu
->header
,
20341 &bytes_read
, &offset_size
);
20342 line_ptr
+= bytes_read
;
20343 if (line_ptr
+ lh
->total_length
> (section
->buffer
+ section
->size
))
20345 dwarf2_statement_list_fits_in_line_number_section_complaint ();
20348 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
20349 lh
->version
= read_2_bytes (abfd
, line_ptr
);
20351 if (lh
->version
> 5)
20353 /* This is a version we don't understand. The format could have
20354 changed in ways we don't handle properly so just punt. */
20355 complaint (&symfile_complaints
,
20356 _("unsupported version in .debug_line section"));
20359 if (lh
->version
>= 5)
20361 gdb_byte segment_selector_size
;
20363 /* Skip address size. */
20364 read_1_byte (abfd
, line_ptr
);
20367 segment_selector_size
= read_1_byte (abfd
, line_ptr
);
20369 if (segment_selector_size
!= 0)
20371 complaint (&symfile_complaints
,
20372 _("unsupported segment selector size %u "
20373 "in .debug_line section"),
20374 segment_selector_size
);
20378 lh
->header_length
= read_offset_1 (abfd
, line_ptr
, offset_size
);
20379 line_ptr
+= offset_size
;
20380 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
20382 if (lh
->version
>= 4)
20384 lh
->maximum_ops_per_instruction
= read_1_byte (abfd
, line_ptr
);
20388 lh
->maximum_ops_per_instruction
= 1;
20390 if (lh
->maximum_ops_per_instruction
== 0)
20392 lh
->maximum_ops_per_instruction
= 1;
20393 complaint (&symfile_complaints
,
20394 _("invalid maximum_ops_per_instruction "
20395 "in `.debug_line' section"));
20398 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
20400 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
20402 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
20404 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
20406 lh
->standard_opcode_lengths
.reset (new unsigned char[lh
->opcode_base
]);
20408 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
20409 for (i
= 1; i
< lh
->opcode_base
; ++i
)
20411 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
20415 if (lh
->version
>= 5)
20417 /* Read directory table. */
20418 read_formatted_entries (dwarf2_per_objfile
, abfd
, &line_ptr
, lh
.get (),
20420 [] (struct line_header
*lh
, const char *name
,
20421 dir_index d_index
, unsigned int mod_time
,
20422 unsigned int length
)
20424 lh
->add_include_dir (name
);
20427 /* Read file name table. */
20428 read_formatted_entries (dwarf2_per_objfile
, abfd
, &line_ptr
, lh
.get (),
20430 [] (struct line_header
*lh
, const char *name
,
20431 dir_index d_index
, unsigned int mod_time
,
20432 unsigned int length
)
20434 lh
->add_file_name (name
, d_index
, mod_time
, length
);
20439 /* Read directory table. */
20440 while ((cur_dir
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
20442 line_ptr
+= bytes_read
;
20443 lh
->add_include_dir (cur_dir
);
20445 line_ptr
+= bytes_read
;
20447 /* Read file name table. */
20448 while ((cur_file
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
20450 unsigned int mod_time
, length
;
20453 line_ptr
+= bytes_read
;
20454 d_index
= (dir_index
) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
20455 line_ptr
+= bytes_read
;
20456 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
20457 line_ptr
+= bytes_read
;
20458 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
20459 line_ptr
+= bytes_read
;
20461 lh
->add_file_name (cur_file
, d_index
, mod_time
, length
);
20463 line_ptr
+= bytes_read
;
20465 lh
->statement_program_start
= line_ptr
;
20467 if (line_ptr
> (section
->buffer
+ section
->size
))
20468 complaint (&symfile_complaints
,
20469 _("line number info header doesn't "
20470 "fit in `.debug_line' section"));
20475 /* Subroutine of dwarf_decode_lines to simplify it.
20476 Return the file name of the psymtab for included file FILE_INDEX
20477 in line header LH of PST.
20478 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
20479 If space for the result is malloc'd, it will be freed by a cleanup.
20480 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename.
20482 The function creates dangling cleanup registration. */
20484 static const char *
20485 psymtab_include_file_name (const struct line_header
*lh
, int file_index
,
20486 const struct partial_symtab
*pst
,
20487 const char *comp_dir
)
20489 const file_entry
&fe
= lh
->file_names
[file_index
];
20490 const char *include_name
= fe
.name
;
20491 const char *include_name_to_compare
= include_name
;
20492 const char *pst_filename
;
20493 char *copied_name
= NULL
;
20496 const char *dir_name
= fe
.include_dir (lh
);
20498 if (!IS_ABSOLUTE_PATH (include_name
)
20499 && (dir_name
!= NULL
|| comp_dir
!= NULL
))
20501 /* Avoid creating a duplicate psymtab for PST.
20502 We do this by comparing INCLUDE_NAME and PST_FILENAME.
20503 Before we do the comparison, however, we need to account
20504 for DIR_NAME and COMP_DIR.
20505 First prepend dir_name (if non-NULL). If we still don't
20506 have an absolute path prepend comp_dir (if non-NULL).
20507 However, the directory we record in the include-file's
20508 psymtab does not contain COMP_DIR (to match the
20509 corresponding symtab(s)).
20514 bash$ gcc -g ./hello.c
20515 include_name = "hello.c"
20517 DW_AT_comp_dir = comp_dir = "/tmp"
20518 DW_AT_name = "./hello.c"
20522 if (dir_name
!= NULL
)
20524 char *tem
= concat (dir_name
, SLASH_STRING
,
20525 include_name
, (char *)NULL
);
20527 make_cleanup (xfree
, tem
);
20528 include_name
= tem
;
20529 include_name_to_compare
= include_name
;
20531 if (!IS_ABSOLUTE_PATH (include_name
) && comp_dir
!= NULL
)
20533 char *tem
= concat (comp_dir
, SLASH_STRING
,
20534 include_name
, (char *)NULL
);
20536 make_cleanup (xfree
, tem
);
20537 include_name_to_compare
= tem
;
20541 pst_filename
= pst
->filename
;
20542 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
20544 copied_name
= concat (pst
->dirname
, SLASH_STRING
,
20545 pst_filename
, (char *)NULL
);
20546 pst_filename
= copied_name
;
20549 file_is_pst
= FILENAME_CMP (include_name_to_compare
, pst_filename
) == 0;
20551 if (copied_name
!= NULL
)
20552 xfree (copied_name
);
20556 return include_name
;
20559 /* State machine to track the state of the line number program. */
20561 class lnp_state_machine
20564 /* Initialize a machine state for the start of a line number
20566 lnp_state_machine (gdbarch
*arch
, line_header
*lh
, bool record_lines_p
);
20568 file_entry
*current_file ()
20570 /* lh->file_names is 0-based, but the file name numbers in the
20571 statement program are 1-based. */
20572 return m_line_header
->file_name_at (m_file
);
20575 /* Record the line in the state machine. END_SEQUENCE is true if
20576 we're processing the end of a sequence. */
20577 void record_line (bool end_sequence
);
20579 /* Check address and if invalid nop-out the rest of the lines in this
20581 void check_line_address (struct dwarf2_cu
*cu
,
20582 const gdb_byte
*line_ptr
,
20583 CORE_ADDR lowpc
, CORE_ADDR address
);
20585 void handle_set_discriminator (unsigned int discriminator
)
20587 m_discriminator
= discriminator
;
20588 m_line_has_non_zero_discriminator
|= discriminator
!= 0;
20591 /* Handle DW_LNE_set_address. */
20592 void handle_set_address (CORE_ADDR baseaddr
, CORE_ADDR address
)
20595 address
+= baseaddr
;
20596 m_address
= gdbarch_adjust_dwarf2_line (m_gdbarch
, address
, false);
20599 /* Handle DW_LNS_advance_pc. */
20600 void handle_advance_pc (CORE_ADDR adjust
);
20602 /* Handle a special opcode. */
20603 void handle_special_opcode (unsigned char op_code
);
20605 /* Handle DW_LNS_advance_line. */
20606 void handle_advance_line (int line_delta
)
20608 advance_line (line_delta
);
20611 /* Handle DW_LNS_set_file. */
20612 void handle_set_file (file_name_index file
);
20614 /* Handle DW_LNS_negate_stmt. */
20615 void handle_negate_stmt ()
20617 m_is_stmt
= !m_is_stmt
;
20620 /* Handle DW_LNS_const_add_pc. */
20621 void handle_const_add_pc ();
20623 /* Handle DW_LNS_fixed_advance_pc. */
20624 void handle_fixed_advance_pc (CORE_ADDR addr_adj
)
20626 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
20630 /* Handle DW_LNS_copy. */
20631 void handle_copy ()
20633 record_line (false);
20634 m_discriminator
= 0;
20637 /* Handle DW_LNE_end_sequence. */
20638 void handle_end_sequence ()
20640 m_record_line_callback
= ::record_line
;
20644 /* Advance the line by LINE_DELTA. */
20645 void advance_line (int line_delta
)
20647 m_line
+= line_delta
;
20649 if (line_delta
!= 0)
20650 m_line_has_non_zero_discriminator
= m_discriminator
!= 0;
20653 gdbarch
*m_gdbarch
;
20655 /* True if we're recording lines.
20656 Otherwise we're building partial symtabs and are just interested in
20657 finding include files mentioned by the line number program. */
20658 bool m_record_lines_p
;
20660 /* The line number header. */
20661 line_header
*m_line_header
;
20663 /* These are part of the standard DWARF line number state machine,
20664 and initialized according to the DWARF spec. */
20666 unsigned char m_op_index
= 0;
20667 /* The line table index (1-based) of the current file. */
20668 file_name_index m_file
= (file_name_index
) 1;
20669 unsigned int m_line
= 1;
20671 /* These are initialized in the constructor. */
20673 CORE_ADDR m_address
;
20675 unsigned int m_discriminator
;
20677 /* Additional bits of state we need to track. */
20679 /* The last file that we called dwarf2_start_subfile for.
20680 This is only used for TLLs. */
20681 unsigned int m_last_file
= 0;
20682 /* The last file a line number was recorded for. */
20683 struct subfile
*m_last_subfile
= NULL
;
20685 /* The function to call to record a line. */
20686 record_line_ftype
*m_record_line_callback
= NULL
;
20688 /* The last line number that was recorded, used to coalesce
20689 consecutive entries for the same line. This can happen, for
20690 example, when discriminators are present. PR 17276. */
20691 unsigned int m_last_line
= 0;
20692 bool m_line_has_non_zero_discriminator
= false;
20696 lnp_state_machine::handle_advance_pc (CORE_ADDR adjust
)
20698 CORE_ADDR addr_adj
= (((m_op_index
+ adjust
)
20699 / m_line_header
->maximum_ops_per_instruction
)
20700 * m_line_header
->minimum_instruction_length
);
20701 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
20702 m_op_index
= ((m_op_index
+ adjust
)
20703 % m_line_header
->maximum_ops_per_instruction
);
20707 lnp_state_machine::handle_special_opcode (unsigned char op_code
)
20709 unsigned char adj_opcode
= op_code
- m_line_header
->opcode_base
;
20710 CORE_ADDR addr_adj
= (((m_op_index
20711 + (adj_opcode
/ m_line_header
->line_range
))
20712 / m_line_header
->maximum_ops_per_instruction
)
20713 * m_line_header
->minimum_instruction_length
);
20714 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
20715 m_op_index
= ((m_op_index
+ (adj_opcode
/ m_line_header
->line_range
))
20716 % m_line_header
->maximum_ops_per_instruction
);
20718 int line_delta
= (m_line_header
->line_base
20719 + (adj_opcode
% m_line_header
->line_range
));
20720 advance_line (line_delta
);
20721 record_line (false);
20722 m_discriminator
= 0;
20726 lnp_state_machine::handle_set_file (file_name_index file
)
20730 const file_entry
*fe
= current_file ();
20732 dwarf2_debug_line_missing_file_complaint ();
20733 else if (m_record_lines_p
)
20735 const char *dir
= fe
->include_dir (m_line_header
);
20737 m_last_subfile
= current_subfile
;
20738 m_line_has_non_zero_discriminator
= m_discriminator
!= 0;
20739 dwarf2_start_subfile (fe
->name
, dir
);
20744 lnp_state_machine::handle_const_add_pc ()
20747 = (255 - m_line_header
->opcode_base
) / m_line_header
->line_range
;
20750 = (((m_op_index
+ adjust
)
20751 / m_line_header
->maximum_ops_per_instruction
)
20752 * m_line_header
->minimum_instruction_length
);
20754 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
20755 m_op_index
= ((m_op_index
+ adjust
)
20756 % m_line_header
->maximum_ops_per_instruction
);
20759 /* Ignore this record_line request. */
20762 noop_record_line (struct subfile
*subfile
, int line
, CORE_ADDR pc
)
20767 /* Return non-zero if we should add LINE to the line number table.
20768 LINE is the line to add, LAST_LINE is the last line that was added,
20769 LAST_SUBFILE is the subfile for LAST_LINE.
20770 LINE_HAS_NON_ZERO_DISCRIMINATOR is non-zero if LINE has ever
20771 had a non-zero discriminator.
20773 We have to be careful in the presence of discriminators.
20774 E.g., for this line:
20776 for (i = 0; i < 100000; i++);
20778 clang can emit four line number entries for that one line,
20779 each with a different discriminator.
20780 See gdb.dwarf2/dw2-single-line-discriminators.exp for an example.
20782 However, we want gdb to coalesce all four entries into one.
20783 Otherwise the user could stepi into the middle of the line and
20784 gdb would get confused about whether the pc really was in the
20785 middle of the line.
20787 Things are further complicated by the fact that two consecutive
20788 line number entries for the same line is a heuristic used by gcc
20789 to denote the end of the prologue. So we can't just discard duplicate
20790 entries, we have to be selective about it. The heuristic we use is
20791 that we only collapse consecutive entries for the same line if at least
20792 one of those entries has a non-zero discriminator. PR 17276.
20794 Note: Addresses in the line number state machine can never go backwards
20795 within one sequence, thus this coalescing is ok. */
20798 dwarf_record_line_p (unsigned int line
, unsigned int last_line
,
20799 int line_has_non_zero_discriminator
,
20800 struct subfile
*last_subfile
)
20802 if (current_subfile
!= last_subfile
)
20804 if (line
!= last_line
)
20806 /* Same line for the same file that we've seen already.
20807 As a last check, for pr 17276, only record the line if the line
20808 has never had a non-zero discriminator. */
20809 if (!line_has_non_zero_discriminator
)
20814 /* Use P_RECORD_LINE to record line number LINE beginning at address ADDRESS
20815 in the line table of subfile SUBFILE. */
20818 dwarf_record_line_1 (struct gdbarch
*gdbarch
, struct subfile
*subfile
,
20819 unsigned int line
, CORE_ADDR address
,
20820 record_line_ftype p_record_line
)
20822 CORE_ADDR addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
20824 if (dwarf_line_debug
)
20826 fprintf_unfiltered (gdb_stdlog
,
20827 "Recording line %u, file %s, address %s\n",
20828 line
, lbasename (subfile
->name
),
20829 paddress (gdbarch
, address
));
20832 (*p_record_line
) (subfile
, line
, addr
);
20835 /* Subroutine of dwarf_decode_lines_1 to simplify it.
20836 Mark the end of a set of line number records.
20837 The arguments are the same as for dwarf_record_line_1.
20838 If SUBFILE is NULL the request is ignored. */
20841 dwarf_finish_line (struct gdbarch
*gdbarch
, struct subfile
*subfile
,
20842 CORE_ADDR address
, record_line_ftype p_record_line
)
20844 if (subfile
== NULL
)
20847 if (dwarf_line_debug
)
20849 fprintf_unfiltered (gdb_stdlog
,
20850 "Finishing current line, file %s, address %s\n",
20851 lbasename (subfile
->name
),
20852 paddress (gdbarch
, address
));
20855 dwarf_record_line_1 (gdbarch
, subfile
, 0, address
, p_record_line
);
20859 lnp_state_machine::record_line (bool end_sequence
)
20861 if (dwarf_line_debug
)
20863 fprintf_unfiltered (gdb_stdlog
,
20864 "Processing actual line %u: file %u,"
20865 " address %s, is_stmt %u, discrim %u\n",
20866 m_line
, to_underlying (m_file
),
20867 paddress (m_gdbarch
, m_address
),
20868 m_is_stmt
, m_discriminator
);
20871 file_entry
*fe
= current_file ();
20874 dwarf2_debug_line_missing_file_complaint ();
20875 /* For now we ignore lines not starting on an instruction boundary.
20876 But not when processing end_sequence for compatibility with the
20877 previous version of the code. */
20878 else if (m_op_index
== 0 || end_sequence
)
20880 fe
->included_p
= 1;
20881 if (m_record_lines_p
&& m_is_stmt
)
20883 if (m_last_subfile
!= current_subfile
|| end_sequence
)
20885 dwarf_finish_line (m_gdbarch
, m_last_subfile
,
20886 m_address
, m_record_line_callback
);
20891 if (dwarf_record_line_p (m_line
, m_last_line
,
20892 m_line_has_non_zero_discriminator
,
20895 dwarf_record_line_1 (m_gdbarch
, current_subfile
,
20897 m_record_line_callback
);
20899 m_last_subfile
= current_subfile
;
20900 m_last_line
= m_line
;
20906 lnp_state_machine::lnp_state_machine (gdbarch
*arch
, line_header
*lh
,
20907 bool record_lines_p
)
20910 m_record_lines_p
= record_lines_p
;
20911 m_line_header
= lh
;
20913 m_record_line_callback
= ::record_line
;
20915 /* Call `gdbarch_adjust_dwarf2_line' on the initial 0 address as if there
20916 was a line entry for it so that the backend has a chance to adjust it
20917 and also record it in case it needs it. This is currently used by MIPS
20918 code, cf. `mips_adjust_dwarf2_line'. */
20919 m_address
= gdbarch_adjust_dwarf2_line (arch
, 0, 0);
20920 m_is_stmt
= lh
->default_is_stmt
;
20921 m_discriminator
= 0;
20925 lnp_state_machine::check_line_address (struct dwarf2_cu
*cu
,
20926 const gdb_byte
*line_ptr
,
20927 CORE_ADDR lowpc
, CORE_ADDR address
)
20929 /* If address < lowpc then it's not a usable value, it's outside the
20930 pc range of the CU. However, we restrict the test to only address
20931 values of zero to preserve GDB's previous behaviour which is to
20932 handle the specific case of a function being GC'd by the linker. */
20934 if (address
== 0 && address
< lowpc
)
20936 /* This line table is for a function which has been
20937 GCd by the linker. Ignore it. PR gdb/12528 */
20939 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
20940 long line_offset
= line_ptr
- get_debug_line_section (cu
)->buffer
;
20942 complaint (&symfile_complaints
,
20943 _(".debug_line address at offset 0x%lx is 0 [in module %s]"),
20944 line_offset
, objfile_name (objfile
));
20945 m_record_line_callback
= noop_record_line
;
20946 /* Note: record_line_callback is left as noop_record_line until
20947 we see DW_LNE_end_sequence. */
20951 /* Subroutine of dwarf_decode_lines to simplify it.
20952 Process the line number information in LH.
20953 If DECODE_FOR_PST_P is non-zero, all we do is process the line number
20954 program in order to set included_p for every referenced header. */
20957 dwarf_decode_lines_1 (struct line_header
*lh
, struct dwarf2_cu
*cu
,
20958 const int decode_for_pst_p
, CORE_ADDR lowpc
)
20960 const gdb_byte
*line_ptr
, *extended_end
;
20961 const gdb_byte
*line_end
;
20962 unsigned int bytes_read
, extended_len
;
20963 unsigned char op_code
, extended_op
;
20964 CORE_ADDR baseaddr
;
20965 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
20966 bfd
*abfd
= objfile
->obfd
;
20967 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
20968 /* True if we're recording line info (as opposed to building partial
20969 symtabs and just interested in finding include files mentioned by
20970 the line number program). */
20971 bool record_lines_p
= !decode_for_pst_p
;
20973 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
20975 line_ptr
= lh
->statement_program_start
;
20976 line_end
= lh
->statement_program_end
;
20978 /* Read the statement sequences until there's nothing left. */
20979 while (line_ptr
< line_end
)
20981 /* The DWARF line number program state machine. Reset the state
20982 machine at the start of each sequence. */
20983 lnp_state_machine
state_machine (gdbarch
, lh
, record_lines_p
);
20984 bool end_sequence
= false;
20986 if (record_lines_p
)
20988 /* Start a subfile for the current file of the state
20990 const file_entry
*fe
= state_machine
.current_file ();
20993 dwarf2_start_subfile (fe
->name
, fe
->include_dir (lh
));
20996 /* Decode the table. */
20997 while (line_ptr
< line_end
&& !end_sequence
)
20999 op_code
= read_1_byte (abfd
, line_ptr
);
21002 if (op_code
>= lh
->opcode_base
)
21004 /* Special opcode. */
21005 state_machine
.handle_special_opcode (op_code
);
21007 else switch (op_code
)
21009 case DW_LNS_extended_op
:
21010 extended_len
= read_unsigned_leb128 (abfd
, line_ptr
,
21012 line_ptr
+= bytes_read
;
21013 extended_end
= line_ptr
+ extended_len
;
21014 extended_op
= read_1_byte (abfd
, line_ptr
);
21016 switch (extended_op
)
21018 case DW_LNE_end_sequence
:
21019 state_machine
.handle_end_sequence ();
21020 end_sequence
= true;
21022 case DW_LNE_set_address
:
21025 = read_address (abfd
, line_ptr
, cu
, &bytes_read
);
21026 line_ptr
+= bytes_read
;
21028 state_machine
.check_line_address (cu
, line_ptr
,
21030 state_machine
.handle_set_address (baseaddr
, address
);
21033 case DW_LNE_define_file
:
21035 const char *cur_file
;
21036 unsigned int mod_time
, length
;
21039 cur_file
= read_direct_string (abfd
, line_ptr
,
21041 line_ptr
+= bytes_read
;
21042 dindex
= (dir_index
)
21043 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21044 line_ptr
+= bytes_read
;
21046 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21047 line_ptr
+= bytes_read
;
21049 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21050 line_ptr
+= bytes_read
;
21051 lh
->add_file_name (cur_file
, dindex
, mod_time
, length
);
21054 case DW_LNE_set_discriminator
:
21056 /* The discriminator is not interesting to the
21057 debugger; just ignore it. We still need to
21058 check its value though:
21059 if there are consecutive entries for the same
21060 (non-prologue) line we want to coalesce them.
21063 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21064 line_ptr
+= bytes_read
;
21066 state_machine
.handle_set_discriminator (discr
);
21070 complaint (&symfile_complaints
,
21071 _("mangled .debug_line section"));
21074 /* Make sure that we parsed the extended op correctly. If e.g.
21075 we expected a different address size than the producer used,
21076 we may have read the wrong number of bytes. */
21077 if (line_ptr
!= extended_end
)
21079 complaint (&symfile_complaints
,
21080 _("mangled .debug_line section"));
21085 state_machine
.handle_copy ();
21087 case DW_LNS_advance_pc
:
21090 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21091 line_ptr
+= bytes_read
;
21093 state_machine
.handle_advance_pc (adjust
);
21096 case DW_LNS_advance_line
:
21099 = read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
21100 line_ptr
+= bytes_read
;
21102 state_machine
.handle_advance_line (line_delta
);
21105 case DW_LNS_set_file
:
21107 file_name_index file
21108 = (file_name_index
) read_unsigned_leb128 (abfd
, line_ptr
,
21110 line_ptr
+= bytes_read
;
21112 state_machine
.handle_set_file (file
);
21115 case DW_LNS_set_column
:
21116 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21117 line_ptr
+= bytes_read
;
21119 case DW_LNS_negate_stmt
:
21120 state_machine
.handle_negate_stmt ();
21122 case DW_LNS_set_basic_block
:
21124 /* Add to the address register of the state machine the
21125 address increment value corresponding to special opcode
21126 255. I.e., this value is scaled by the minimum
21127 instruction length since special opcode 255 would have
21128 scaled the increment. */
21129 case DW_LNS_const_add_pc
:
21130 state_machine
.handle_const_add_pc ();
21132 case DW_LNS_fixed_advance_pc
:
21134 CORE_ADDR addr_adj
= read_2_bytes (abfd
, line_ptr
);
21137 state_machine
.handle_fixed_advance_pc (addr_adj
);
21142 /* Unknown standard opcode, ignore it. */
21145 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
21147 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21148 line_ptr
+= bytes_read
;
21155 dwarf2_debug_line_missing_end_sequence_complaint ();
21157 /* We got a DW_LNE_end_sequence (or we ran off the end of the buffer,
21158 in which case we still finish recording the last line). */
21159 state_machine
.record_line (true);
21163 /* Decode the Line Number Program (LNP) for the given line_header
21164 structure and CU. The actual information extracted and the type
21165 of structures created from the LNP depends on the value of PST.
21167 1. If PST is NULL, then this procedure uses the data from the program
21168 to create all necessary symbol tables, and their linetables.
21170 2. If PST is not NULL, this procedure reads the program to determine
21171 the list of files included by the unit represented by PST, and
21172 builds all the associated partial symbol tables.
21174 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
21175 It is used for relative paths in the line table.
21176 NOTE: When processing partial symtabs (pst != NULL),
21177 comp_dir == pst->dirname.
21179 NOTE: It is important that psymtabs have the same file name (via strcmp)
21180 as the corresponding symtab. Since COMP_DIR is not used in the name of the
21181 symtab we don't use it in the name of the psymtabs we create.
21182 E.g. expand_line_sal requires this when finding psymtabs to expand.
21183 A good testcase for this is mb-inline.exp.
21185 LOWPC is the lowest address in CU (or 0 if not known).
21187 Boolean DECODE_MAPPING specifies we need to fully decode .debug_line
21188 for its PC<->lines mapping information. Otherwise only the filename
21189 table is read in. */
21192 dwarf_decode_lines (struct line_header
*lh
, const char *comp_dir
,
21193 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
,
21194 CORE_ADDR lowpc
, int decode_mapping
)
21196 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
21197 const int decode_for_pst_p
= (pst
!= NULL
);
21199 if (decode_mapping
)
21200 dwarf_decode_lines_1 (lh
, cu
, decode_for_pst_p
, lowpc
);
21202 if (decode_for_pst_p
)
21206 /* Now that we're done scanning the Line Header Program, we can
21207 create the psymtab of each included file. */
21208 for (file_index
= 0; file_index
< lh
->file_names
.size (); file_index
++)
21209 if (lh
->file_names
[file_index
].included_p
== 1)
21211 const char *include_name
=
21212 psymtab_include_file_name (lh
, file_index
, pst
, comp_dir
);
21213 if (include_name
!= NULL
)
21214 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
21219 /* Make sure a symtab is created for every file, even files
21220 which contain only variables (i.e. no code with associated
21222 struct compunit_symtab
*cust
= buildsym_compunit_symtab ();
21225 for (i
= 0; i
< lh
->file_names
.size (); i
++)
21227 file_entry
&fe
= lh
->file_names
[i
];
21229 dwarf2_start_subfile (fe
.name
, fe
.include_dir (lh
));
21231 if (current_subfile
->symtab
== NULL
)
21233 current_subfile
->symtab
21234 = allocate_symtab (cust
, current_subfile
->name
);
21236 fe
.symtab
= current_subfile
->symtab
;
21241 /* Start a subfile for DWARF. FILENAME is the name of the file and
21242 DIRNAME the name of the source directory which contains FILENAME
21243 or NULL if not known.
21244 This routine tries to keep line numbers from identical absolute and
21245 relative file names in a common subfile.
21247 Using the `list' example from the GDB testsuite, which resides in
21248 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
21249 of /srcdir/list0.c yields the following debugging information for list0.c:
21251 DW_AT_name: /srcdir/list0.c
21252 DW_AT_comp_dir: /compdir
21253 files.files[0].name: list0.h
21254 files.files[0].dir: /srcdir
21255 files.files[1].name: list0.c
21256 files.files[1].dir: /srcdir
21258 The line number information for list0.c has to end up in a single
21259 subfile, so that `break /srcdir/list0.c:1' works as expected.
21260 start_subfile will ensure that this happens provided that we pass the
21261 concatenation of files.files[1].dir and files.files[1].name as the
21265 dwarf2_start_subfile (const char *filename
, const char *dirname
)
21269 /* In order not to lose the line information directory,
21270 we concatenate it to the filename when it makes sense.
21271 Note that the Dwarf3 standard says (speaking of filenames in line
21272 information): ``The directory index is ignored for file names
21273 that represent full path names''. Thus ignoring dirname in the
21274 `else' branch below isn't an issue. */
21276 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
21278 copy
= concat (dirname
, SLASH_STRING
, filename
, (char *)NULL
);
21282 start_subfile (filename
);
21288 /* Start a symtab for DWARF.
21289 NAME, COMP_DIR, LOW_PC are passed to start_symtab. */
21291 static struct compunit_symtab
*
21292 dwarf2_start_symtab (struct dwarf2_cu
*cu
,
21293 const char *name
, const char *comp_dir
, CORE_ADDR low_pc
)
21295 struct compunit_symtab
*cust
21296 = start_symtab (cu
->per_cu
->dwarf2_per_objfile
->objfile
, name
, comp_dir
,
21297 low_pc
, cu
->language
);
21299 record_debugformat ("DWARF 2");
21300 record_producer (cu
->producer
);
21302 /* We assume that we're processing GCC output. */
21303 processing_gcc_compilation
= 2;
21305 cu
->processing_has_namespace_info
= 0;
21311 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
21312 struct dwarf2_cu
*cu
)
21314 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
21315 struct comp_unit_head
*cu_header
= &cu
->header
;
21317 /* NOTE drow/2003-01-30: There used to be a comment and some special
21318 code here to turn a symbol with DW_AT_external and a
21319 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
21320 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
21321 with some versions of binutils) where shared libraries could have
21322 relocations against symbols in their debug information - the
21323 minimal symbol would have the right address, but the debug info
21324 would not. It's no longer necessary, because we will explicitly
21325 apply relocations when we read in the debug information now. */
21327 /* A DW_AT_location attribute with no contents indicates that a
21328 variable has been optimized away. */
21329 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
21331 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
21335 /* Handle one degenerate form of location expression specially, to
21336 preserve GDB's previous behavior when section offsets are
21337 specified. If this is just a DW_OP_addr or DW_OP_GNU_addr_index
21338 then mark this symbol as LOC_STATIC. */
21340 if (attr_form_is_block (attr
)
21341 && ((DW_BLOCK (attr
)->data
[0] == DW_OP_addr
21342 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
)
21343 || (DW_BLOCK (attr
)->data
[0] == DW_OP_GNU_addr_index
21344 && (DW_BLOCK (attr
)->size
21345 == 1 + leb128_size (&DW_BLOCK (attr
)->data
[1])))))
21347 unsigned int dummy
;
21349 if (DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
21350 SYMBOL_VALUE_ADDRESS (sym
) =
21351 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
21353 SYMBOL_VALUE_ADDRESS (sym
) =
21354 read_addr_index_from_leb128 (cu
, DW_BLOCK (attr
)->data
+ 1, &dummy
);
21355 SYMBOL_ACLASS_INDEX (sym
) = LOC_STATIC
;
21356 fixup_symbol_section (sym
, objfile
);
21357 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
21358 SYMBOL_SECTION (sym
));
21362 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
21363 expression evaluator, and use LOC_COMPUTED only when necessary
21364 (i.e. when the value of a register or memory location is
21365 referenced, or a thread-local block, etc.). Then again, it might
21366 not be worthwhile. I'm assuming that it isn't unless performance
21367 or memory numbers show me otherwise. */
21369 dwarf2_symbol_mark_computed (attr
, sym
, cu
, 0);
21371 if (SYMBOL_COMPUTED_OPS (sym
)->location_has_loclist
)
21372 cu
->has_loclist
= 1;
21375 /* Given a pointer to a DWARF information entry, figure out if we need
21376 to make a symbol table entry for it, and if so, create a new entry
21377 and return a pointer to it.
21378 If TYPE is NULL, determine symbol type from the die, otherwise
21379 used the passed type.
21380 If SPACE is not NULL, use it to hold the new symbol. If it is
21381 NULL, allocate a new symbol on the objfile's obstack. */
21383 static struct symbol
*
21384 new_symbol_full (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
,
21385 struct symbol
*space
)
21387 struct dwarf2_per_objfile
*dwarf2_per_objfile
21388 = cu
->per_cu
->dwarf2_per_objfile
;
21389 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
21390 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
21391 struct symbol
*sym
= NULL
;
21393 struct attribute
*attr
= NULL
;
21394 struct attribute
*attr2
= NULL
;
21395 CORE_ADDR baseaddr
;
21396 struct pending
**list_to_add
= NULL
;
21398 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
21400 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
21402 name
= dwarf2_name (die
, cu
);
21405 const char *linkagename
;
21406 int suppress_add
= 0;
21411 sym
= allocate_symbol (objfile
);
21412 OBJSTAT (objfile
, n_syms
++);
21414 /* Cache this symbol's name and the name's demangled form (if any). */
21415 SYMBOL_SET_LANGUAGE (sym
, cu
->language
, &objfile
->objfile_obstack
);
21416 linkagename
= dwarf2_physname (name
, die
, cu
);
21417 SYMBOL_SET_NAMES (sym
, linkagename
, strlen (linkagename
), 0, objfile
);
21419 /* Fortran does not have mangling standard and the mangling does differ
21420 between gfortran, iFort etc. */
21421 if (cu
->language
== language_fortran
21422 && symbol_get_demangled_name (&(sym
->ginfo
)) == NULL
)
21423 symbol_set_demangled_name (&(sym
->ginfo
),
21424 dwarf2_full_name (name
, die
, cu
),
21427 /* Default assumptions.
21428 Use the passed type or decode it from the die. */
21429 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
21430 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
21432 SYMBOL_TYPE (sym
) = type
;
21434 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
21435 attr
= dwarf2_attr (die
,
21436 inlined_func
? DW_AT_call_line
: DW_AT_decl_line
,
21440 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
21443 attr
= dwarf2_attr (die
,
21444 inlined_func
? DW_AT_call_file
: DW_AT_decl_file
,
21448 file_name_index file_index
= (file_name_index
) DW_UNSND (attr
);
21449 struct file_entry
*fe
;
21451 if (cu
->line_header
!= NULL
)
21452 fe
= cu
->line_header
->file_name_at (file_index
);
21457 complaint (&symfile_complaints
,
21458 _("file index out of range"));
21460 symbol_set_symtab (sym
, fe
->symtab
);
21466 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
21471 addr
= attr_value_as_address (attr
);
21472 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, addr
+ baseaddr
);
21473 SYMBOL_VALUE_ADDRESS (sym
) = addr
;
21475 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_core_addr
;
21476 SYMBOL_DOMAIN (sym
) = LABEL_DOMAIN
;
21477 SYMBOL_ACLASS_INDEX (sym
) = LOC_LABEL
;
21478 add_symbol_to_list (sym
, cu
->list_in_scope
);
21480 case DW_TAG_subprogram
:
21481 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21483 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
21484 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
21485 if ((attr2
&& (DW_UNSND (attr2
) != 0))
21486 || cu
->language
== language_ada
)
21488 /* Subprograms marked external are stored as a global symbol.
21489 Ada subprograms, whether marked external or not, are always
21490 stored as a global symbol, because we want to be able to
21491 access them globally. For instance, we want to be able
21492 to break on a nested subprogram without having to
21493 specify the context. */
21494 list_to_add
= &global_symbols
;
21498 list_to_add
= cu
->list_in_scope
;
21501 case DW_TAG_inlined_subroutine
:
21502 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21504 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
21505 SYMBOL_INLINED (sym
) = 1;
21506 list_to_add
= cu
->list_in_scope
;
21508 case DW_TAG_template_value_param
:
21510 /* Fall through. */
21511 case DW_TAG_constant
:
21512 case DW_TAG_variable
:
21513 case DW_TAG_member
:
21514 /* Compilation with minimal debug info may result in
21515 variables with missing type entries. Change the
21516 misleading `void' type to something sensible. */
21517 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
21518 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_int
;
21520 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
21521 /* In the case of DW_TAG_member, we should only be called for
21522 static const members. */
21523 if (die
->tag
== DW_TAG_member
)
21525 /* dwarf2_add_field uses die_is_declaration,
21526 so we do the same. */
21527 gdb_assert (die_is_declaration (die
, cu
));
21532 dwarf2_const_value (attr
, sym
, cu
);
21533 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
21536 if (attr2
&& (DW_UNSND (attr2
) != 0))
21537 list_to_add
= &global_symbols
;
21539 list_to_add
= cu
->list_in_scope
;
21543 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
21546 var_decode_location (attr
, sym
, cu
);
21547 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
21549 /* Fortran explicitly imports any global symbols to the local
21550 scope by DW_TAG_common_block. */
21551 if (cu
->language
== language_fortran
&& die
->parent
21552 && die
->parent
->tag
== DW_TAG_common_block
)
21555 if (SYMBOL_CLASS (sym
) == LOC_STATIC
21556 && SYMBOL_VALUE_ADDRESS (sym
) == 0
21557 && !dwarf2_per_objfile
->has_section_at_zero
)
21559 /* When a static variable is eliminated by the linker,
21560 the corresponding debug information is not stripped
21561 out, but the variable address is set to null;
21562 do not add such variables into symbol table. */
21564 else if (attr2
&& (DW_UNSND (attr2
) != 0))
21566 /* Workaround gfortran PR debug/40040 - it uses
21567 DW_AT_location for variables in -fPIC libraries which may
21568 get overriden by other libraries/executable and get
21569 a different address. Resolve it by the minimal symbol
21570 which may come from inferior's executable using copy
21571 relocation. Make this workaround only for gfortran as for
21572 other compilers GDB cannot guess the minimal symbol
21573 Fortran mangling kind. */
21574 if (cu
->language
== language_fortran
&& die
->parent
21575 && die
->parent
->tag
== DW_TAG_module
21577 && startswith (cu
->producer
, "GNU Fortran"))
21578 SYMBOL_ACLASS_INDEX (sym
) = LOC_UNRESOLVED
;
21580 /* A variable with DW_AT_external is never static,
21581 but it may be block-scoped. */
21582 list_to_add
= (cu
->list_in_scope
== &file_symbols
21583 ? &global_symbols
: cu
->list_in_scope
);
21586 list_to_add
= cu
->list_in_scope
;
21590 /* We do not know the address of this symbol.
21591 If it is an external symbol and we have type information
21592 for it, enter the symbol as a LOC_UNRESOLVED symbol.
21593 The address of the variable will then be determined from
21594 the minimal symbol table whenever the variable is
21596 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
21598 /* Fortran explicitly imports any global symbols to the local
21599 scope by DW_TAG_common_block. */
21600 if (cu
->language
== language_fortran
&& die
->parent
21601 && die
->parent
->tag
== DW_TAG_common_block
)
21603 /* SYMBOL_CLASS doesn't matter here because
21604 read_common_block is going to reset it. */
21606 list_to_add
= cu
->list_in_scope
;
21608 else if (attr2
&& (DW_UNSND (attr2
) != 0)
21609 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
21611 /* A variable with DW_AT_external is never static, but it
21612 may be block-scoped. */
21613 list_to_add
= (cu
->list_in_scope
== &file_symbols
21614 ? &global_symbols
: cu
->list_in_scope
);
21616 SYMBOL_ACLASS_INDEX (sym
) = LOC_UNRESOLVED
;
21618 else if (!die_is_declaration (die
, cu
))
21620 /* Use the default LOC_OPTIMIZED_OUT class. */
21621 gdb_assert (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
);
21623 list_to_add
= cu
->list_in_scope
;
21627 case DW_TAG_formal_parameter
:
21628 /* If we are inside a function, mark this as an argument. If
21629 not, we might be looking at an argument to an inlined function
21630 when we do not have enough information to show inlined frames;
21631 pretend it's a local variable in that case so that the user can
21633 if (context_stack_depth
> 0
21634 && context_stack
[context_stack_depth
- 1].name
!= NULL
)
21635 SYMBOL_IS_ARGUMENT (sym
) = 1;
21636 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
21639 var_decode_location (attr
, sym
, cu
);
21641 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
21644 dwarf2_const_value (attr
, sym
, cu
);
21647 list_to_add
= cu
->list_in_scope
;
21649 case DW_TAG_unspecified_parameters
:
21650 /* From varargs functions; gdb doesn't seem to have any
21651 interest in this information, so just ignore it for now.
21654 case DW_TAG_template_type_param
:
21656 /* Fall through. */
21657 case DW_TAG_class_type
:
21658 case DW_TAG_interface_type
:
21659 case DW_TAG_structure_type
:
21660 case DW_TAG_union_type
:
21661 case DW_TAG_set_type
:
21662 case DW_TAG_enumeration_type
:
21663 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
21664 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
21667 /* NOTE: carlton/2003-11-10: C++ class symbols shouldn't
21668 really ever be static objects: otherwise, if you try
21669 to, say, break of a class's method and you're in a file
21670 which doesn't mention that class, it won't work unless
21671 the check for all static symbols in lookup_symbol_aux
21672 saves you. See the OtherFileClass tests in
21673 gdb.c++/namespace.exp. */
21677 list_to_add
= (cu
->list_in_scope
== &file_symbols
21678 && cu
->language
== language_cplus
21679 ? &global_symbols
: cu
->list_in_scope
);
21681 /* The semantics of C++ state that "struct foo {
21682 ... }" also defines a typedef for "foo". */
21683 if (cu
->language
== language_cplus
21684 || cu
->language
== language_ada
21685 || cu
->language
== language_d
21686 || cu
->language
== language_rust
)
21688 /* The symbol's name is already allocated along
21689 with this objfile, so we don't need to
21690 duplicate it for the type. */
21691 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
21692 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
21697 case DW_TAG_typedef
:
21698 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
21699 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
21700 list_to_add
= cu
->list_in_scope
;
21702 case DW_TAG_base_type
:
21703 case DW_TAG_subrange_type
:
21704 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
21705 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
21706 list_to_add
= cu
->list_in_scope
;
21708 case DW_TAG_enumerator
:
21709 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
21712 dwarf2_const_value (attr
, sym
, cu
);
21715 /* NOTE: carlton/2003-11-10: See comment above in the
21716 DW_TAG_class_type, etc. block. */
21718 list_to_add
= (cu
->list_in_scope
== &file_symbols
21719 && cu
->language
== language_cplus
21720 ? &global_symbols
: cu
->list_in_scope
);
21723 case DW_TAG_imported_declaration
:
21724 case DW_TAG_namespace
:
21725 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
21726 list_to_add
= &global_symbols
;
21728 case DW_TAG_module
:
21729 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
21730 SYMBOL_DOMAIN (sym
) = MODULE_DOMAIN
;
21731 list_to_add
= &global_symbols
;
21733 case DW_TAG_common_block
:
21734 SYMBOL_ACLASS_INDEX (sym
) = LOC_COMMON_BLOCK
;
21735 SYMBOL_DOMAIN (sym
) = COMMON_BLOCK_DOMAIN
;
21736 add_symbol_to_list (sym
, cu
->list_in_scope
);
21739 /* Not a tag we recognize. Hopefully we aren't processing
21740 trash data, but since we must specifically ignore things
21741 we don't recognize, there is nothing else we should do at
21743 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
21744 dwarf_tag_name (die
->tag
));
21750 sym
->hash_next
= objfile
->template_symbols
;
21751 objfile
->template_symbols
= sym
;
21752 list_to_add
= NULL
;
21755 if (list_to_add
!= NULL
)
21756 add_symbol_to_list (sym
, list_to_add
);
21758 /* For the benefit of old versions of GCC, check for anonymous
21759 namespaces based on the demangled name. */
21760 if (!cu
->processing_has_namespace_info
21761 && cu
->language
== language_cplus
)
21762 cp_scan_for_anonymous_namespaces (sym
, objfile
);
21767 /* A wrapper for new_symbol_full that always allocates a new symbol. */
21769 static struct symbol
*
21770 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
21772 return new_symbol_full (die
, type
, cu
, NULL
);
21775 /* Given an attr with a DW_FORM_dataN value in host byte order,
21776 zero-extend it as appropriate for the symbol's type. The DWARF
21777 standard (v4) is not entirely clear about the meaning of using
21778 DW_FORM_dataN for a constant with a signed type, where the type is
21779 wider than the data. The conclusion of a discussion on the DWARF
21780 list was that this is unspecified. We choose to always zero-extend
21781 because that is the interpretation long in use by GCC. */
21784 dwarf2_const_value_data (const struct attribute
*attr
, struct obstack
*obstack
,
21785 struct dwarf2_cu
*cu
, LONGEST
*value
, int bits
)
21787 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
21788 enum bfd_endian byte_order
= bfd_big_endian (objfile
->obfd
) ?
21789 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
21790 LONGEST l
= DW_UNSND (attr
);
21792 if (bits
< sizeof (*value
) * 8)
21794 l
&= ((LONGEST
) 1 << bits
) - 1;
21797 else if (bits
== sizeof (*value
) * 8)
21801 gdb_byte
*bytes
= (gdb_byte
*) obstack_alloc (obstack
, bits
/ 8);
21802 store_unsigned_integer (bytes
, bits
/ 8, byte_order
, l
);
21809 /* Read a constant value from an attribute. Either set *VALUE, or if
21810 the value does not fit in *VALUE, set *BYTES - either already
21811 allocated on the objfile obstack, or newly allocated on OBSTACK,
21812 or, set *BATON, if we translated the constant to a location
21816 dwarf2_const_value_attr (const struct attribute
*attr
, struct type
*type
,
21817 const char *name
, struct obstack
*obstack
,
21818 struct dwarf2_cu
*cu
,
21819 LONGEST
*value
, const gdb_byte
**bytes
,
21820 struct dwarf2_locexpr_baton
**baton
)
21822 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
21823 struct comp_unit_head
*cu_header
= &cu
->header
;
21824 struct dwarf_block
*blk
;
21825 enum bfd_endian byte_order
= (bfd_big_endian (objfile
->obfd
) ?
21826 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
21832 switch (attr
->form
)
21835 case DW_FORM_GNU_addr_index
:
21839 if (TYPE_LENGTH (type
) != cu_header
->addr_size
)
21840 dwarf2_const_value_length_mismatch_complaint (name
,
21841 cu_header
->addr_size
,
21842 TYPE_LENGTH (type
));
21843 /* Symbols of this form are reasonably rare, so we just
21844 piggyback on the existing location code rather than writing
21845 a new implementation of symbol_computed_ops. */
21846 *baton
= XOBNEW (obstack
, struct dwarf2_locexpr_baton
);
21847 (*baton
)->per_cu
= cu
->per_cu
;
21848 gdb_assert ((*baton
)->per_cu
);
21850 (*baton
)->size
= 2 + cu_header
->addr_size
;
21851 data
= (gdb_byte
*) obstack_alloc (obstack
, (*baton
)->size
);
21852 (*baton
)->data
= data
;
21854 data
[0] = DW_OP_addr
;
21855 store_unsigned_integer (&data
[1], cu_header
->addr_size
,
21856 byte_order
, DW_ADDR (attr
));
21857 data
[cu_header
->addr_size
+ 1] = DW_OP_stack_value
;
21860 case DW_FORM_string
:
21862 case DW_FORM_GNU_str_index
:
21863 case DW_FORM_GNU_strp_alt
:
21864 /* DW_STRING is already allocated on the objfile obstack, point
21866 *bytes
= (const gdb_byte
*) DW_STRING (attr
);
21868 case DW_FORM_block1
:
21869 case DW_FORM_block2
:
21870 case DW_FORM_block4
:
21871 case DW_FORM_block
:
21872 case DW_FORM_exprloc
:
21873 case DW_FORM_data16
:
21874 blk
= DW_BLOCK (attr
);
21875 if (TYPE_LENGTH (type
) != blk
->size
)
21876 dwarf2_const_value_length_mismatch_complaint (name
, blk
->size
,
21877 TYPE_LENGTH (type
));
21878 *bytes
= blk
->data
;
21881 /* The DW_AT_const_value attributes are supposed to carry the
21882 symbol's value "represented as it would be on the target
21883 architecture." By the time we get here, it's already been
21884 converted to host endianness, so we just need to sign- or
21885 zero-extend it as appropriate. */
21886 case DW_FORM_data1
:
21887 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 8);
21889 case DW_FORM_data2
:
21890 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 16);
21892 case DW_FORM_data4
:
21893 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 32);
21895 case DW_FORM_data8
:
21896 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 64);
21899 case DW_FORM_sdata
:
21900 case DW_FORM_implicit_const
:
21901 *value
= DW_SND (attr
);
21904 case DW_FORM_udata
:
21905 *value
= DW_UNSND (attr
);
21909 complaint (&symfile_complaints
,
21910 _("unsupported const value attribute form: '%s'"),
21911 dwarf_form_name (attr
->form
));
21918 /* Copy constant value from an attribute to a symbol. */
21921 dwarf2_const_value (const struct attribute
*attr
, struct symbol
*sym
,
21922 struct dwarf2_cu
*cu
)
21924 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
21926 const gdb_byte
*bytes
;
21927 struct dwarf2_locexpr_baton
*baton
;
21929 dwarf2_const_value_attr (attr
, SYMBOL_TYPE (sym
),
21930 SYMBOL_PRINT_NAME (sym
),
21931 &objfile
->objfile_obstack
, cu
,
21932 &value
, &bytes
, &baton
);
21936 SYMBOL_LOCATION_BATON (sym
) = baton
;
21937 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
21939 else if (bytes
!= NULL
)
21941 SYMBOL_VALUE_BYTES (sym
) = bytes
;
21942 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST_BYTES
;
21946 SYMBOL_VALUE (sym
) = value
;
21947 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST
;
21951 /* Return the type of the die in question using its DW_AT_type attribute. */
21953 static struct type
*
21954 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
21956 struct attribute
*type_attr
;
21958 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
21961 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
21962 /* A missing DW_AT_type represents a void type. */
21963 return objfile_type (objfile
)->builtin_void
;
21966 return lookup_die_type (die
, type_attr
, cu
);
21969 /* True iff CU's producer generates GNAT Ada auxiliary information
21970 that allows to find parallel types through that information instead
21971 of having to do expensive parallel lookups by type name. */
21974 need_gnat_info (struct dwarf2_cu
*cu
)
21976 /* FIXME: brobecker/2010-10-12: As of now, only the AdaCore version
21977 of GNAT produces this auxiliary information, without any indication
21978 that it is produced. Part of enhancing the FSF version of GNAT
21979 to produce that information will be to put in place an indicator
21980 that we can use in order to determine whether the descriptive type
21981 info is available or not. One suggestion that has been made is
21982 to use a new attribute, attached to the CU die. For now, assume
21983 that the descriptive type info is not available. */
21987 /* Return the auxiliary type of the die in question using its
21988 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
21989 attribute is not present. */
21991 static struct type
*
21992 die_descriptive_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
21994 struct attribute
*type_attr
;
21996 type_attr
= dwarf2_attr (die
, DW_AT_GNAT_descriptive_type
, cu
);
22000 return lookup_die_type (die
, type_attr
, cu
);
22003 /* If DIE has a descriptive_type attribute, then set the TYPE's
22004 descriptive type accordingly. */
22007 set_descriptive_type (struct type
*type
, struct die_info
*die
,
22008 struct dwarf2_cu
*cu
)
22010 struct type
*descriptive_type
= die_descriptive_type (die
, cu
);
22012 if (descriptive_type
)
22014 ALLOCATE_GNAT_AUX_TYPE (type
);
22015 TYPE_DESCRIPTIVE_TYPE (type
) = descriptive_type
;
22019 /* Return the containing type of the die in question using its
22020 DW_AT_containing_type attribute. */
22022 static struct type
*
22023 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
22025 struct attribute
*type_attr
;
22026 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
22028 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
22030 error (_("Dwarf Error: Problem turning containing type into gdb type "
22031 "[in module %s]"), objfile_name (objfile
));
22033 return lookup_die_type (die
, type_attr
, cu
);
22036 /* Return an error marker type to use for the ill formed type in DIE/CU. */
22038 static struct type
*
22039 build_error_marker_type (struct dwarf2_cu
*cu
, struct die_info
*die
)
22041 struct dwarf2_per_objfile
*dwarf2_per_objfile
22042 = cu
->per_cu
->dwarf2_per_objfile
;
22043 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
22044 char *message
, *saved
;
22046 message
= xstrprintf (_("<unknown type in %s, CU 0x%x, DIE 0x%x>"),
22047 objfile_name (objfile
),
22048 to_underlying (cu
->header
.sect_off
),
22049 to_underlying (die
->sect_off
));
22050 saved
= (char *) obstack_copy0 (&objfile
->objfile_obstack
,
22051 message
, strlen (message
));
22054 return init_type (objfile
, TYPE_CODE_ERROR
, 0, saved
);
22057 /* Look up the type of DIE in CU using its type attribute ATTR.
22058 ATTR must be one of: DW_AT_type, DW_AT_GNAT_descriptive_type,
22059 DW_AT_containing_type.
22060 If there is no type substitute an error marker. */
22062 static struct type
*
22063 lookup_die_type (struct die_info
*die
, const struct attribute
*attr
,
22064 struct dwarf2_cu
*cu
)
22066 struct dwarf2_per_objfile
*dwarf2_per_objfile
22067 = cu
->per_cu
->dwarf2_per_objfile
;
22068 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
22069 struct type
*this_type
;
22071 gdb_assert (attr
->name
== DW_AT_type
22072 || attr
->name
== DW_AT_GNAT_descriptive_type
22073 || attr
->name
== DW_AT_containing_type
);
22075 /* First see if we have it cached. */
22077 if (attr
->form
== DW_FORM_GNU_ref_alt
)
22079 struct dwarf2_per_cu_data
*per_cu
;
22080 sect_offset sect_off
= dwarf2_get_ref_die_offset (attr
);
22082 per_cu
= dwarf2_find_containing_comp_unit (sect_off
, 1,
22083 dwarf2_per_objfile
);
22084 this_type
= get_die_type_at_offset (sect_off
, per_cu
);
22086 else if (attr_form_is_ref (attr
))
22088 sect_offset sect_off
= dwarf2_get_ref_die_offset (attr
);
22090 this_type
= get_die_type_at_offset (sect_off
, cu
->per_cu
);
22092 else if (attr
->form
== DW_FORM_ref_sig8
)
22094 ULONGEST signature
= DW_SIGNATURE (attr
);
22096 return get_signatured_type (die
, signature
, cu
);
22100 complaint (&symfile_complaints
,
22101 _("Dwarf Error: Bad type attribute %s in DIE"
22102 " at 0x%x [in module %s]"),
22103 dwarf_attr_name (attr
->name
), to_underlying (die
->sect_off
),
22104 objfile_name (objfile
));
22105 return build_error_marker_type (cu
, die
);
22108 /* If not cached we need to read it in. */
22110 if (this_type
== NULL
)
22112 struct die_info
*type_die
= NULL
;
22113 struct dwarf2_cu
*type_cu
= cu
;
22115 if (attr_form_is_ref (attr
))
22116 type_die
= follow_die_ref (die
, attr
, &type_cu
);
22117 if (type_die
== NULL
)
22118 return build_error_marker_type (cu
, die
);
22119 /* If we find the type now, it's probably because the type came
22120 from an inter-CU reference and the type's CU got expanded before
22122 this_type
= read_type_die (type_die
, type_cu
);
22125 /* If we still don't have a type use an error marker. */
22127 if (this_type
== NULL
)
22128 return build_error_marker_type (cu
, die
);
22133 /* Return the type in DIE, CU.
22134 Returns NULL for invalid types.
22136 This first does a lookup in die_type_hash,
22137 and only reads the die in if necessary.
22139 NOTE: This can be called when reading in partial or full symbols. */
22141 static struct type
*
22142 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
22144 struct type
*this_type
;
22146 this_type
= get_die_type (die
, cu
);
22150 return read_type_die_1 (die
, cu
);
22153 /* Read the type in DIE, CU.
22154 Returns NULL for invalid types. */
22156 static struct type
*
22157 read_type_die_1 (struct die_info
*die
, struct dwarf2_cu
*cu
)
22159 struct type
*this_type
= NULL
;
22163 case DW_TAG_class_type
:
22164 case DW_TAG_interface_type
:
22165 case DW_TAG_structure_type
:
22166 case DW_TAG_union_type
:
22167 this_type
= read_structure_type (die
, cu
);
22169 case DW_TAG_enumeration_type
:
22170 this_type
= read_enumeration_type (die
, cu
);
22172 case DW_TAG_subprogram
:
22173 case DW_TAG_subroutine_type
:
22174 case DW_TAG_inlined_subroutine
:
22175 this_type
= read_subroutine_type (die
, cu
);
22177 case DW_TAG_array_type
:
22178 this_type
= read_array_type (die
, cu
);
22180 case DW_TAG_set_type
:
22181 this_type
= read_set_type (die
, cu
);
22183 case DW_TAG_pointer_type
:
22184 this_type
= read_tag_pointer_type (die
, cu
);
22186 case DW_TAG_ptr_to_member_type
:
22187 this_type
= read_tag_ptr_to_member_type (die
, cu
);
22189 case DW_TAG_reference_type
:
22190 this_type
= read_tag_reference_type (die
, cu
, TYPE_CODE_REF
);
22192 case DW_TAG_rvalue_reference_type
:
22193 this_type
= read_tag_reference_type (die
, cu
, TYPE_CODE_RVALUE_REF
);
22195 case DW_TAG_const_type
:
22196 this_type
= read_tag_const_type (die
, cu
);
22198 case DW_TAG_volatile_type
:
22199 this_type
= read_tag_volatile_type (die
, cu
);
22201 case DW_TAG_restrict_type
:
22202 this_type
= read_tag_restrict_type (die
, cu
);
22204 case DW_TAG_string_type
:
22205 this_type
= read_tag_string_type (die
, cu
);
22207 case DW_TAG_typedef
:
22208 this_type
= read_typedef (die
, cu
);
22210 case DW_TAG_subrange_type
:
22211 this_type
= read_subrange_type (die
, cu
);
22213 case DW_TAG_base_type
:
22214 this_type
= read_base_type (die
, cu
);
22216 case DW_TAG_unspecified_type
:
22217 this_type
= read_unspecified_type (die
, cu
);
22219 case DW_TAG_namespace
:
22220 this_type
= read_namespace_type (die
, cu
);
22222 case DW_TAG_module
:
22223 this_type
= read_module_type (die
, cu
);
22225 case DW_TAG_atomic_type
:
22226 this_type
= read_tag_atomic_type (die
, cu
);
22229 complaint (&symfile_complaints
,
22230 _("unexpected tag in read_type_die: '%s'"),
22231 dwarf_tag_name (die
->tag
));
22238 /* See if we can figure out if the class lives in a namespace. We do
22239 this by looking for a member function; its demangled name will
22240 contain namespace info, if there is any.
22241 Return the computed name or NULL.
22242 Space for the result is allocated on the objfile's obstack.
22243 This is the full-die version of guess_partial_die_structure_name.
22244 In this case we know DIE has no useful parent. */
22247 guess_full_die_structure_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
22249 struct die_info
*spec_die
;
22250 struct dwarf2_cu
*spec_cu
;
22251 struct die_info
*child
;
22252 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
22255 spec_die
= die_specification (die
, &spec_cu
);
22256 if (spec_die
!= NULL
)
22262 for (child
= die
->child
;
22264 child
= child
->sibling
)
22266 if (child
->tag
== DW_TAG_subprogram
)
22268 const char *linkage_name
= dw2_linkage_name (child
, cu
);
22270 if (linkage_name
!= NULL
)
22273 = language_class_name_from_physname (cu
->language_defn
,
22277 if (actual_name
!= NULL
)
22279 const char *die_name
= dwarf2_name (die
, cu
);
22281 if (die_name
!= NULL
22282 && strcmp (die_name
, actual_name
) != 0)
22284 /* Strip off the class name from the full name.
22285 We want the prefix. */
22286 int die_name_len
= strlen (die_name
);
22287 int actual_name_len
= strlen (actual_name
);
22289 /* Test for '::' as a sanity check. */
22290 if (actual_name_len
> die_name_len
+ 2
22291 && actual_name
[actual_name_len
22292 - die_name_len
- 1] == ':')
22293 name
= (char *) obstack_copy0 (
22294 &objfile
->per_bfd
->storage_obstack
,
22295 actual_name
, actual_name_len
- die_name_len
- 2);
22298 xfree (actual_name
);
22307 /* GCC might emit a nameless typedef that has a linkage name. Determine the
22308 prefix part in such case. See
22309 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
22311 static const char *
22312 anonymous_struct_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
22314 struct attribute
*attr
;
22317 if (die
->tag
!= DW_TAG_class_type
&& die
->tag
!= DW_TAG_interface_type
22318 && die
->tag
!= DW_TAG_structure_type
&& die
->tag
!= DW_TAG_union_type
)
22321 if (dwarf2_string_attr (die
, DW_AT_name
, cu
) != NULL
)
22324 attr
= dw2_linkage_name_attr (die
, cu
);
22325 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
22328 /* dwarf2_name had to be already called. */
22329 gdb_assert (DW_STRING_IS_CANONICAL (attr
));
22331 /* Strip the base name, keep any leading namespaces/classes. */
22332 base
= strrchr (DW_STRING (attr
), ':');
22333 if (base
== NULL
|| base
== DW_STRING (attr
) || base
[-1] != ':')
22336 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
22337 return (char *) obstack_copy0 (&objfile
->per_bfd
->storage_obstack
,
22339 &base
[-1] - DW_STRING (attr
));
22342 /* Return the name of the namespace/class that DIE is defined within,
22343 or "" if we can't tell. The caller should not xfree the result.
22345 For example, if we're within the method foo() in the following
22355 then determine_prefix on foo's die will return "N::C". */
22357 static const char *
22358 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
22360 struct dwarf2_per_objfile
*dwarf2_per_objfile
22361 = cu
->per_cu
->dwarf2_per_objfile
;
22362 struct die_info
*parent
, *spec_die
;
22363 struct dwarf2_cu
*spec_cu
;
22364 struct type
*parent_type
;
22365 const char *retval
;
22367 if (cu
->language
!= language_cplus
22368 && cu
->language
!= language_fortran
&& cu
->language
!= language_d
22369 && cu
->language
!= language_rust
)
22372 retval
= anonymous_struct_prefix (die
, cu
);
22376 /* We have to be careful in the presence of DW_AT_specification.
22377 For example, with GCC 3.4, given the code
22381 // Definition of N::foo.
22385 then we'll have a tree of DIEs like this:
22387 1: DW_TAG_compile_unit
22388 2: DW_TAG_namespace // N
22389 3: DW_TAG_subprogram // declaration of N::foo
22390 4: DW_TAG_subprogram // definition of N::foo
22391 DW_AT_specification // refers to die #3
22393 Thus, when processing die #4, we have to pretend that we're in
22394 the context of its DW_AT_specification, namely the contex of die
22397 spec_die
= die_specification (die
, &spec_cu
);
22398 if (spec_die
== NULL
)
22399 parent
= die
->parent
;
22402 parent
= spec_die
->parent
;
22406 if (parent
== NULL
)
22408 else if (parent
->building_fullname
)
22411 const char *parent_name
;
22413 /* It has been seen on RealView 2.2 built binaries,
22414 DW_TAG_template_type_param types actually _defined_ as
22415 children of the parent class:
22418 template class <class Enum> Class{};
22419 Class<enum E> class_e;
22421 1: DW_TAG_class_type (Class)
22422 2: DW_TAG_enumeration_type (E)
22423 3: DW_TAG_enumerator (enum1:0)
22424 3: DW_TAG_enumerator (enum2:1)
22426 2: DW_TAG_template_type_param
22427 DW_AT_type DW_FORM_ref_udata (E)
22429 Besides being broken debug info, it can put GDB into an
22430 infinite loop. Consider:
22432 When we're building the full name for Class<E>, we'll start
22433 at Class, and go look over its template type parameters,
22434 finding E. We'll then try to build the full name of E, and
22435 reach here. We're now trying to build the full name of E,
22436 and look over the parent DIE for containing scope. In the
22437 broken case, if we followed the parent DIE of E, we'd again
22438 find Class, and once again go look at its template type
22439 arguments, etc., etc. Simply don't consider such parent die
22440 as source-level parent of this die (it can't be, the language
22441 doesn't allow it), and break the loop here. */
22442 name
= dwarf2_name (die
, cu
);
22443 parent_name
= dwarf2_name (parent
, cu
);
22444 complaint (&symfile_complaints
,
22445 _("template param type '%s' defined within parent '%s'"),
22446 name
? name
: "<unknown>",
22447 parent_name
? parent_name
: "<unknown>");
22451 switch (parent
->tag
)
22453 case DW_TAG_namespace
:
22454 parent_type
= read_type_die (parent
, cu
);
22455 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
22456 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
22457 Work around this problem here. */
22458 if (cu
->language
== language_cplus
22459 && strcmp (TYPE_TAG_NAME (parent_type
), "::") == 0)
22461 /* We give a name to even anonymous namespaces. */
22462 return TYPE_TAG_NAME (parent_type
);
22463 case DW_TAG_class_type
:
22464 case DW_TAG_interface_type
:
22465 case DW_TAG_structure_type
:
22466 case DW_TAG_union_type
:
22467 case DW_TAG_module
:
22468 parent_type
= read_type_die (parent
, cu
);
22469 if (TYPE_TAG_NAME (parent_type
) != NULL
)
22470 return TYPE_TAG_NAME (parent_type
);
22472 /* An anonymous structure is only allowed non-static data
22473 members; no typedefs, no member functions, et cetera.
22474 So it does not need a prefix. */
22476 case DW_TAG_compile_unit
:
22477 case DW_TAG_partial_unit
:
22478 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
22479 if (cu
->language
== language_cplus
22480 && !VEC_empty (dwarf2_section_info_def
, dwarf2_per_objfile
->types
)
22481 && die
->child
!= NULL
22482 && (die
->tag
== DW_TAG_class_type
22483 || die
->tag
== DW_TAG_structure_type
22484 || die
->tag
== DW_TAG_union_type
))
22486 char *name
= guess_full_die_structure_name (die
, cu
);
22491 case DW_TAG_enumeration_type
:
22492 parent_type
= read_type_die (parent
, cu
);
22493 if (TYPE_DECLARED_CLASS (parent_type
))
22495 if (TYPE_TAG_NAME (parent_type
) != NULL
)
22496 return TYPE_TAG_NAME (parent_type
);
22499 /* Fall through. */
22501 return determine_prefix (parent
, cu
);
22505 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
22506 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
22507 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
22508 an obconcat, otherwise allocate storage for the result. The CU argument is
22509 used to determine the language and hence, the appropriate separator. */
22511 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
22514 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
22515 int physname
, struct dwarf2_cu
*cu
)
22517 const char *lead
= "";
22520 if (suffix
== NULL
|| suffix
[0] == '\0'
22521 || prefix
== NULL
|| prefix
[0] == '\0')
22523 else if (cu
->language
== language_d
)
22525 /* For D, the 'main' function could be defined in any module, but it
22526 should never be prefixed. */
22527 if (strcmp (suffix
, "D main") == 0)
22535 else if (cu
->language
== language_fortran
&& physname
)
22537 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
22538 DW_AT_MIPS_linkage_name is preferred and used instead. */
22546 if (prefix
== NULL
)
22548 if (suffix
== NULL
)
22555 xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1));
22557 strcpy (retval
, lead
);
22558 strcat (retval
, prefix
);
22559 strcat (retval
, sep
);
22560 strcat (retval
, suffix
);
22565 /* We have an obstack. */
22566 return obconcat (obs
, lead
, prefix
, sep
, suffix
, (char *) NULL
);
22570 /* Return sibling of die, NULL if no sibling. */
22572 static struct die_info
*
22573 sibling_die (struct die_info
*die
)
22575 return die
->sibling
;
22578 /* Get name of a die, return NULL if not found. */
22580 static const char *
22581 dwarf2_canonicalize_name (const char *name
, struct dwarf2_cu
*cu
,
22582 struct obstack
*obstack
)
22584 if (name
&& cu
->language
== language_cplus
)
22586 std::string canon_name
= cp_canonicalize_string (name
);
22588 if (!canon_name
.empty ())
22590 if (canon_name
!= name
)
22591 name
= (const char *) obstack_copy0 (obstack
,
22592 canon_name
.c_str (),
22593 canon_name
.length ());
22600 /* Get name of a die, return NULL if not found.
22601 Anonymous namespaces are converted to their magic string. */
22603 static const char *
22604 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
22606 struct attribute
*attr
;
22607 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
22609 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
22610 if ((!attr
|| !DW_STRING (attr
))
22611 && die
->tag
!= DW_TAG_namespace
22612 && die
->tag
!= DW_TAG_class_type
22613 && die
->tag
!= DW_TAG_interface_type
22614 && die
->tag
!= DW_TAG_structure_type
22615 && die
->tag
!= DW_TAG_union_type
)
22620 case DW_TAG_compile_unit
:
22621 case DW_TAG_partial_unit
:
22622 /* Compilation units have a DW_AT_name that is a filename, not
22623 a source language identifier. */
22624 case DW_TAG_enumeration_type
:
22625 case DW_TAG_enumerator
:
22626 /* These tags always have simple identifiers already; no need
22627 to canonicalize them. */
22628 return DW_STRING (attr
);
22630 case DW_TAG_namespace
:
22631 if (attr
!= NULL
&& DW_STRING (attr
) != NULL
)
22632 return DW_STRING (attr
);
22633 return CP_ANONYMOUS_NAMESPACE_STR
;
22635 case DW_TAG_class_type
:
22636 case DW_TAG_interface_type
:
22637 case DW_TAG_structure_type
:
22638 case DW_TAG_union_type
:
22639 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
22640 structures or unions. These were of the form "._%d" in GCC 4.1,
22641 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
22642 and GCC 4.4. We work around this problem by ignoring these. */
22643 if (attr
&& DW_STRING (attr
)
22644 && (startswith (DW_STRING (attr
), "._")
22645 || startswith (DW_STRING (attr
), "<anonymous")))
22648 /* GCC might emit a nameless typedef that has a linkage name. See
22649 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
22650 if (!attr
|| DW_STRING (attr
) == NULL
)
22652 char *demangled
= NULL
;
22654 attr
= dw2_linkage_name_attr (die
, cu
);
22655 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
22658 /* Avoid demangling DW_STRING (attr) the second time on a second
22659 call for the same DIE. */
22660 if (!DW_STRING_IS_CANONICAL (attr
))
22661 demangled
= gdb_demangle (DW_STRING (attr
), DMGL_TYPES
);
22667 /* FIXME: we already did this for the partial symbol... */
22670 obstack_copy0 (&objfile
->per_bfd
->storage_obstack
,
22671 demangled
, strlen (demangled
)));
22672 DW_STRING_IS_CANONICAL (attr
) = 1;
22675 /* Strip any leading namespaces/classes, keep only the base name.
22676 DW_AT_name for named DIEs does not contain the prefixes. */
22677 base
= strrchr (DW_STRING (attr
), ':');
22678 if (base
&& base
> DW_STRING (attr
) && base
[-1] == ':')
22681 return DW_STRING (attr
);
22690 if (!DW_STRING_IS_CANONICAL (attr
))
22693 = dwarf2_canonicalize_name (DW_STRING (attr
), cu
,
22694 &objfile
->per_bfd
->storage_obstack
);
22695 DW_STRING_IS_CANONICAL (attr
) = 1;
22697 return DW_STRING (attr
);
22700 /* Return the die that this die in an extension of, or NULL if there
22701 is none. *EXT_CU is the CU containing DIE on input, and the CU
22702 containing the return value on output. */
22704 static struct die_info
*
22705 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
**ext_cu
)
22707 struct attribute
*attr
;
22709 attr
= dwarf2_attr (die
, DW_AT_extension
, *ext_cu
);
22713 return follow_die_ref (die
, attr
, ext_cu
);
22716 /* Convert a DIE tag into its string name. */
22718 static const char *
22719 dwarf_tag_name (unsigned tag
)
22721 const char *name
= get_DW_TAG_name (tag
);
22724 return "DW_TAG_<unknown>";
22729 /* Convert a DWARF attribute code into its string name. */
22731 static const char *
22732 dwarf_attr_name (unsigned attr
)
22736 #ifdef MIPS /* collides with DW_AT_HP_block_index */
22737 if (attr
== DW_AT_MIPS_fde
)
22738 return "DW_AT_MIPS_fde";
22740 if (attr
== DW_AT_HP_block_index
)
22741 return "DW_AT_HP_block_index";
22744 name
= get_DW_AT_name (attr
);
22747 return "DW_AT_<unknown>";
22752 /* Convert a DWARF value form code into its string name. */
22754 static const char *
22755 dwarf_form_name (unsigned form
)
22757 const char *name
= get_DW_FORM_name (form
);
22760 return "DW_FORM_<unknown>";
22765 static const char *
22766 dwarf_bool_name (unsigned mybool
)
22774 /* Convert a DWARF type code into its string name. */
22776 static const char *
22777 dwarf_type_encoding_name (unsigned enc
)
22779 const char *name
= get_DW_ATE_name (enc
);
22782 return "DW_ATE_<unknown>";
22788 dump_die_shallow (struct ui_file
*f
, int indent
, struct die_info
*die
)
22792 print_spaces (indent
, f
);
22793 fprintf_unfiltered (f
, "Die: %s (abbrev %d, offset 0x%x)\n",
22794 dwarf_tag_name (die
->tag
), die
->abbrev
,
22795 to_underlying (die
->sect_off
));
22797 if (die
->parent
!= NULL
)
22799 print_spaces (indent
, f
);
22800 fprintf_unfiltered (f
, " parent at offset: 0x%x\n",
22801 to_underlying (die
->parent
->sect_off
));
22804 print_spaces (indent
, f
);
22805 fprintf_unfiltered (f
, " has children: %s\n",
22806 dwarf_bool_name (die
->child
!= NULL
));
22808 print_spaces (indent
, f
);
22809 fprintf_unfiltered (f
, " attributes:\n");
22811 for (i
= 0; i
< die
->num_attrs
; ++i
)
22813 print_spaces (indent
, f
);
22814 fprintf_unfiltered (f
, " %s (%s) ",
22815 dwarf_attr_name (die
->attrs
[i
].name
),
22816 dwarf_form_name (die
->attrs
[i
].form
));
22818 switch (die
->attrs
[i
].form
)
22821 case DW_FORM_GNU_addr_index
:
22822 fprintf_unfiltered (f
, "address: ");
22823 fputs_filtered (hex_string (DW_ADDR (&die
->attrs
[i
])), f
);
22825 case DW_FORM_block2
:
22826 case DW_FORM_block4
:
22827 case DW_FORM_block
:
22828 case DW_FORM_block1
:
22829 fprintf_unfiltered (f
, "block: size %s",
22830 pulongest (DW_BLOCK (&die
->attrs
[i
])->size
));
22832 case DW_FORM_exprloc
:
22833 fprintf_unfiltered (f
, "expression: size %s",
22834 pulongest (DW_BLOCK (&die
->attrs
[i
])->size
));
22836 case DW_FORM_data16
:
22837 fprintf_unfiltered (f
, "constant of 16 bytes");
22839 case DW_FORM_ref_addr
:
22840 fprintf_unfiltered (f
, "ref address: ");
22841 fputs_filtered (hex_string (DW_UNSND (&die
->attrs
[i
])), f
);
22843 case DW_FORM_GNU_ref_alt
:
22844 fprintf_unfiltered (f
, "alt ref address: ");
22845 fputs_filtered (hex_string (DW_UNSND (&die
->attrs
[i
])), f
);
22851 case DW_FORM_ref_udata
:
22852 fprintf_unfiltered (f
, "constant ref: 0x%lx (adjusted)",
22853 (long) (DW_UNSND (&die
->attrs
[i
])));
22855 case DW_FORM_data1
:
22856 case DW_FORM_data2
:
22857 case DW_FORM_data4
:
22858 case DW_FORM_data8
:
22859 case DW_FORM_udata
:
22860 case DW_FORM_sdata
:
22861 fprintf_unfiltered (f
, "constant: %s",
22862 pulongest (DW_UNSND (&die
->attrs
[i
])));
22864 case DW_FORM_sec_offset
:
22865 fprintf_unfiltered (f
, "section offset: %s",
22866 pulongest (DW_UNSND (&die
->attrs
[i
])));
22868 case DW_FORM_ref_sig8
:
22869 fprintf_unfiltered (f
, "signature: %s",
22870 hex_string (DW_SIGNATURE (&die
->attrs
[i
])));
22872 case DW_FORM_string
:
22874 case DW_FORM_line_strp
:
22875 case DW_FORM_GNU_str_index
:
22876 case DW_FORM_GNU_strp_alt
:
22877 fprintf_unfiltered (f
, "string: \"%s\" (%s canonicalized)",
22878 DW_STRING (&die
->attrs
[i
])
22879 ? DW_STRING (&die
->attrs
[i
]) : "",
22880 DW_STRING_IS_CANONICAL (&die
->attrs
[i
]) ? "is" : "not");
22883 if (DW_UNSND (&die
->attrs
[i
]))
22884 fprintf_unfiltered (f
, "flag: TRUE");
22886 fprintf_unfiltered (f
, "flag: FALSE");
22888 case DW_FORM_flag_present
:
22889 fprintf_unfiltered (f
, "flag: TRUE");
22891 case DW_FORM_indirect
:
22892 /* The reader will have reduced the indirect form to
22893 the "base form" so this form should not occur. */
22894 fprintf_unfiltered (f
,
22895 "unexpected attribute form: DW_FORM_indirect");
22897 case DW_FORM_implicit_const
:
22898 fprintf_unfiltered (f
, "constant: %s",
22899 plongest (DW_SND (&die
->attrs
[i
])));
22902 fprintf_unfiltered (f
, "unsupported attribute form: %d.",
22903 die
->attrs
[i
].form
);
22906 fprintf_unfiltered (f
, "\n");
22911 dump_die_for_error (struct die_info
*die
)
22913 dump_die_shallow (gdb_stderr
, 0, die
);
22917 dump_die_1 (struct ui_file
*f
, int level
, int max_level
, struct die_info
*die
)
22919 int indent
= level
* 4;
22921 gdb_assert (die
!= NULL
);
22923 if (level
>= max_level
)
22926 dump_die_shallow (f
, indent
, die
);
22928 if (die
->child
!= NULL
)
22930 print_spaces (indent
, f
);
22931 fprintf_unfiltered (f
, " Children:");
22932 if (level
+ 1 < max_level
)
22934 fprintf_unfiltered (f
, "\n");
22935 dump_die_1 (f
, level
+ 1, max_level
, die
->child
);
22939 fprintf_unfiltered (f
,
22940 " [not printed, max nesting level reached]\n");
22944 if (die
->sibling
!= NULL
&& level
> 0)
22946 dump_die_1 (f
, level
, max_level
, die
->sibling
);
22950 /* This is called from the pdie macro in gdbinit.in.
22951 It's not static so gcc will keep a copy callable from gdb. */
22954 dump_die (struct die_info
*die
, int max_level
)
22956 dump_die_1 (gdb_stdlog
, 0, max_level
, die
);
22960 store_in_ref_table (struct die_info
*die
, struct dwarf2_cu
*cu
)
22964 slot
= htab_find_slot_with_hash (cu
->die_hash
, die
,
22965 to_underlying (die
->sect_off
),
22971 /* Return DIE offset of ATTR. Return 0 with complaint if ATTR is not of the
22975 dwarf2_get_ref_die_offset (const struct attribute
*attr
)
22977 if (attr_form_is_ref (attr
))
22978 return (sect_offset
) DW_UNSND (attr
);
22980 complaint (&symfile_complaints
,
22981 _("unsupported die ref attribute form: '%s'"),
22982 dwarf_form_name (attr
->form
));
22986 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
22987 * the value held by the attribute is not constant. */
22990 dwarf2_get_attr_constant_value (const struct attribute
*attr
, int default_value
)
22992 if (attr
->form
== DW_FORM_sdata
|| attr
->form
== DW_FORM_implicit_const
)
22993 return DW_SND (attr
);
22994 else if (attr
->form
== DW_FORM_udata
22995 || attr
->form
== DW_FORM_data1
22996 || attr
->form
== DW_FORM_data2
22997 || attr
->form
== DW_FORM_data4
22998 || attr
->form
== DW_FORM_data8
)
22999 return DW_UNSND (attr
);
23002 /* For DW_FORM_data16 see attr_form_is_constant. */
23003 complaint (&symfile_complaints
,
23004 _("Attribute value is not a constant (%s)"),
23005 dwarf_form_name (attr
->form
));
23006 return default_value
;
23010 /* Follow reference or signature attribute ATTR of SRC_DIE.
23011 On entry *REF_CU is the CU of SRC_DIE.
23012 On exit *REF_CU is the CU of the result. */
23014 static struct die_info
*
23015 follow_die_ref_or_sig (struct die_info
*src_die
, const struct attribute
*attr
,
23016 struct dwarf2_cu
**ref_cu
)
23018 struct die_info
*die
;
23020 if (attr_form_is_ref (attr
))
23021 die
= follow_die_ref (src_die
, attr
, ref_cu
);
23022 else if (attr
->form
== DW_FORM_ref_sig8
)
23023 die
= follow_die_sig (src_die
, attr
, ref_cu
);
23026 dump_die_for_error (src_die
);
23027 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
23028 objfile_name ((*ref_cu
)->per_cu
->dwarf2_per_objfile
->objfile
));
23034 /* Follow reference OFFSET.
23035 On entry *REF_CU is the CU of the source die referencing OFFSET.
23036 On exit *REF_CU is the CU of the result.
23037 Returns NULL if OFFSET is invalid. */
23039 static struct die_info
*
23040 follow_die_offset (sect_offset sect_off
, int offset_in_dwz
,
23041 struct dwarf2_cu
**ref_cu
)
23043 struct die_info temp_die
;
23044 struct dwarf2_cu
*target_cu
, *cu
= *ref_cu
;
23045 struct dwarf2_per_objfile
*dwarf2_per_objfile
23046 = cu
->per_cu
->dwarf2_per_objfile
;
23047 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
23049 gdb_assert (cu
->per_cu
!= NULL
);
23053 if (cu
->per_cu
->is_debug_types
)
23055 /* .debug_types CUs cannot reference anything outside their CU.
23056 If they need to, they have to reference a signatured type via
23057 DW_FORM_ref_sig8. */
23058 if (!offset_in_cu_p (&cu
->header
, sect_off
))
23061 else if (offset_in_dwz
!= cu
->per_cu
->is_dwz
23062 || !offset_in_cu_p (&cu
->header
, sect_off
))
23064 struct dwarf2_per_cu_data
*per_cu
;
23066 per_cu
= dwarf2_find_containing_comp_unit (sect_off
, offset_in_dwz
,
23067 dwarf2_per_objfile
);
23069 /* If necessary, add it to the queue and load its DIEs. */
23070 if (maybe_queue_comp_unit (cu
, per_cu
, cu
->language
))
23071 load_full_comp_unit (per_cu
, cu
->language
);
23073 target_cu
= per_cu
->cu
;
23075 else if (cu
->dies
== NULL
)
23077 /* We're loading full DIEs during partial symbol reading. */
23078 gdb_assert (dwarf2_per_objfile
->reading_partial_symbols
);
23079 load_full_comp_unit (cu
->per_cu
, language_minimal
);
23082 *ref_cu
= target_cu
;
23083 temp_die
.sect_off
= sect_off
;
23084 return (struct die_info
*) htab_find_with_hash (target_cu
->die_hash
,
23086 to_underlying (sect_off
));
23089 /* Follow reference attribute ATTR of SRC_DIE.
23090 On entry *REF_CU is the CU of SRC_DIE.
23091 On exit *REF_CU is the CU of the result. */
23093 static struct die_info
*
23094 follow_die_ref (struct die_info
*src_die
, const struct attribute
*attr
,
23095 struct dwarf2_cu
**ref_cu
)
23097 sect_offset sect_off
= dwarf2_get_ref_die_offset (attr
);
23098 struct dwarf2_cu
*cu
= *ref_cu
;
23099 struct die_info
*die
;
23101 die
= follow_die_offset (sect_off
,
23102 (attr
->form
== DW_FORM_GNU_ref_alt
23103 || cu
->per_cu
->is_dwz
),
23106 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced from DIE "
23107 "at 0x%x [in module %s]"),
23108 to_underlying (sect_off
), to_underlying (src_die
->sect_off
),
23109 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
23114 /* Return DWARF block referenced by DW_AT_location of DIE at SECT_OFF at PER_CU.
23115 Returned value is intended for DW_OP_call*. Returned
23116 dwarf2_locexpr_baton->data has lifetime of
23117 PER_CU->DWARF2_PER_OBJFILE->OBJFILE. */
23119 struct dwarf2_locexpr_baton
23120 dwarf2_fetch_die_loc_sect_off (sect_offset sect_off
,
23121 struct dwarf2_per_cu_data
*per_cu
,
23122 CORE_ADDR (*get_frame_pc
) (void *baton
),
23125 struct dwarf2_cu
*cu
;
23126 struct die_info
*die
;
23127 struct attribute
*attr
;
23128 struct dwarf2_locexpr_baton retval
;
23129 struct objfile
*objfile
= per_cu
->dwarf2_per_objfile
->objfile
;
23130 struct dwarf2_per_objfile
*dwarf2_per_objfile
23131 = get_dwarf2_per_objfile (objfile
);
23133 if (per_cu
->cu
== NULL
)
23138 /* We shouldn't get here for a dummy CU, but don't crash on the user.
23139 Instead just throw an error, not much else we can do. */
23140 error (_("Dwarf Error: Dummy CU at 0x%x referenced in module %s"),
23141 to_underlying (sect_off
), objfile_name (objfile
));
23144 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
23146 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
23147 to_underlying (sect_off
), objfile_name (objfile
));
23149 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
23152 /* DWARF: "If there is no such attribute, then there is no effect.".
23153 DATA is ignored if SIZE is 0. */
23155 retval
.data
= NULL
;
23158 else if (attr_form_is_section_offset (attr
))
23160 struct dwarf2_loclist_baton loclist_baton
;
23161 CORE_ADDR pc
= (*get_frame_pc
) (baton
);
23164 fill_in_loclist_baton (cu
, &loclist_baton
, attr
);
23166 retval
.data
= dwarf2_find_location_expression (&loclist_baton
,
23168 retval
.size
= size
;
23172 if (!attr_form_is_block (attr
))
23173 error (_("Dwarf Error: DIE at 0x%x referenced in module %s "
23174 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
23175 to_underlying (sect_off
), objfile_name (objfile
));
23177 retval
.data
= DW_BLOCK (attr
)->data
;
23178 retval
.size
= DW_BLOCK (attr
)->size
;
23180 retval
.per_cu
= cu
->per_cu
;
23182 age_cached_comp_units (dwarf2_per_objfile
);
23187 /* Like dwarf2_fetch_die_loc_sect_off, but take a CU
23190 struct dwarf2_locexpr_baton
23191 dwarf2_fetch_die_loc_cu_off (cu_offset offset_in_cu
,
23192 struct dwarf2_per_cu_data
*per_cu
,
23193 CORE_ADDR (*get_frame_pc
) (void *baton
),
23196 sect_offset sect_off
= per_cu
->sect_off
+ to_underlying (offset_in_cu
);
23198 return dwarf2_fetch_die_loc_sect_off (sect_off
, per_cu
, get_frame_pc
, baton
);
23201 /* Write a constant of a given type as target-ordered bytes into
23204 static const gdb_byte
*
23205 write_constant_as_bytes (struct obstack
*obstack
,
23206 enum bfd_endian byte_order
,
23213 *len
= TYPE_LENGTH (type
);
23214 result
= (gdb_byte
*) obstack_alloc (obstack
, *len
);
23215 store_unsigned_integer (result
, *len
, byte_order
, value
);
23220 /* If the DIE at OFFSET in PER_CU has a DW_AT_const_value, return a
23221 pointer to the constant bytes and set LEN to the length of the
23222 data. If memory is needed, allocate it on OBSTACK. If the DIE
23223 does not have a DW_AT_const_value, return NULL. */
23226 dwarf2_fetch_constant_bytes (sect_offset sect_off
,
23227 struct dwarf2_per_cu_data
*per_cu
,
23228 struct obstack
*obstack
,
23231 struct dwarf2_cu
*cu
;
23232 struct die_info
*die
;
23233 struct attribute
*attr
;
23234 const gdb_byte
*result
= NULL
;
23237 enum bfd_endian byte_order
;
23238 struct objfile
*objfile
= per_cu
->dwarf2_per_objfile
->objfile
;
23240 if (per_cu
->cu
== NULL
)
23245 /* We shouldn't get here for a dummy CU, but don't crash on the user.
23246 Instead just throw an error, not much else we can do. */
23247 error (_("Dwarf Error: Dummy CU at 0x%x referenced in module %s"),
23248 to_underlying (sect_off
), objfile_name (objfile
));
23251 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
23253 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
23254 to_underlying (sect_off
), objfile_name (objfile
));
23257 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
23261 byte_order
= (bfd_big_endian (objfile
->obfd
)
23262 ? BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
23264 switch (attr
->form
)
23267 case DW_FORM_GNU_addr_index
:
23271 *len
= cu
->header
.addr_size
;
23272 tem
= (gdb_byte
*) obstack_alloc (obstack
, *len
);
23273 store_unsigned_integer (tem
, *len
, byte_order
, DW_ADDR (attr
));
23277 case DW_FORM_string
:
23279 case DW_FORM_GNU_str_index
:
23280 case DW_FORM_GNU_strp_alt
:
23281 /* DW_STRING is already allocated on the objfile obstack, point
23283 result
= (const gdb_byte
*) DW_STRING (attr
);
23284 *len
= strlen (DW_STRING (attr
));
23286 case DW_FORM_block1
:
23287 case DW_FORM_block2
:
23288 case DW_FORM_block4
:
23289 case DW_FORM_block
:
23290 case DW_FORM_exprloc
:
23291 case DW_FORM_data16
:
23292 result
= DW_BLOCK (attr
)->data
;
23293 *len
= DW_BLOCK (attr
)->size
;
23296 /* The DW_AT_const_value attributes are supposed to carry the
23297 symbol's value "represented as it would be on the target
23298 architecture." By the time we get here, it's already been
23299 converted to host endianness, so we just need to sign- or
23300 zero-extend it as appropriate. */
23301 case DW_FORM_data1
:
23302 type
= die_type (die
, cu
);
23303 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 8);
23304 if (result
== NULL
)
23305 result
= write_constant_as_bytes (obstack
, byte_order
,
23308 case DW_FORM_data2
:
23309 type
= die_type (die
, cu
);
23310 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 16);
23311 if (result
== NULL
)
23312 result
= write_constant_as_bytes (obstack
, byte_order
,
23315 case DW_FORM_data4
:
23316 type
= die_type (die
, cu
);
23317 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 32);
23318 if (result
== NULL
)
23319 result
= write_constant_as_bytes (obstack
, byte_order
,
23322 case DW_FORM_data8
:
23323 type
= die_type (die
, cu
);
23324 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 64);
23325 if (result
== NULL
)
23326 result
= write_constant_as_bytes (obstack
, byte_order
,
23330 case DW_FORM_sdata
:
23331 case DW_FORM_implicit_const
:
23332 type
= die_type (die
, cu
);
23333 result
= write_constant_as_bytes (obstack
, byte_order
,
23334 type
, DW_SND (attr
), len
);
23337 case DW_FORM_udata
:
23338 type
= die_type (die
, cu
);
23339 result
= write_constant_as_bytes (obstack
, byte_order
,
23340 type
, DW_UNSND (attr
), len
);
23344 complaint (&symfile_complaints
,
23345 _("unsupported const value attribute form: '%s'"),
23346 dwarf_form_name (attr
->form
));
23353 /* Return the type of the die at OFFSET in PER_CU. Return NULL if no
23354 valid type for this die is found. */
23357 dwarf2_fetch_die_type_sect_off (sect_offset sect_off
,
23358 struct dwarf2_per_cu_data
*per_cu
)
23360 struct dwarf2_cu
*cu
;
23361 struct die_info
*die
;
23363 if (per_cu
->cu
== NULL
)
23369 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
23373 return die_type (die
, cu
);
23376 /* Return the type of the DIE at DIE_OFFSET in the CU named by
23380 dwarf2_get_die_type (cu_offset die_offset
,
23381 struct dwarf2_per_cu_data
*per_cu
)
23383 sect_offset die_offset_sect
= per_cu
->sect_off
+ to_underlying (die_offset
);
23384 return get_die_type_at_offset (die_offset_sect
, per_cu
);
23387 /* Follow type unit SIG_TYPE referenced by SRC_DIE.
23388 On entry *REF_CU is the CU of SRC_DIE.
23389 On exit *REF_CU is the CU of the result.
23390 Returns NULL if the referenced DIE isn't found. */
23392 static struct die_info
*
23393 follow_die_sig_1 (struct die_info
*src_die
, struct signatured_type
*sig_type
,
23394 struct dwarf2_cu
**ref_cu
)
23396 struct die_info temp_die
;
23397 struct dwarf2_cu
*sig_cu
;
23398 struct die_info
*die
;
23400 /* While it might be nice to assert sig_type->type == NULL here,
23401 we can get here for DW_AT_imported_declaration where we need
23402 the DIE not the type. */
23404 /* If necessary, add it to the queue and load its DIEs. */
23406 if (maybe_queue_comp_unit (*ref_cu
, &sig_type
->per_cu
, language_minimal
))
23407 read_signatured_type (sig_type
);
23409 sig_cu
= sig_type
->per_cu
.cu
;
23410 gdb_assert (sig_cu
!= NULL
);
23411 gdb_assert (to_underlying (sig_type
->type_offset_in_section
) != 0);
23412 temp_die
.sect_off
= sig_type
->type_offset_in_section
;
23413 die
= (struct die_info
*) htab_find_with_hash (sig_cu
->die_hash
, &temp_die
,
23414 to_underlying (temp_die
.sect_off
));
23417 struct dwarf2_per_objfile
*dwarf2_per_objfile
23418 = (*ref_cu
)->per_cu
->dwarf2_per_objfile
;
23420 /* For .gdb_index version 7 keep track of included TUs.
23421 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
23422 if (dwarf2_per_objfile
->index_table
!= NULL
23423 && dwarf2_per_objfile
->index_table
->version
<= 7)
23425 VEC_safe_push (dwarf2_per_cu_ptr
,
23426 (*ref_cu
)->per_cu
->imported_symtabs
,
23437 /* Follow signatured type referenced by ATTR in SRC_DIE.
23438 On entry *REF_CU is the CU of SRC_DIE.
23439 On exit *REF_CU is the CU of the result.
23440 The result is the DIE of the type.
23441 If the referenced type cannot be found an error is thrown. */
23443 static struct die_info
*
23444 follow_die_sig (struct die_info
*src_die
, const struct attribute
*attr
,
23445 struct dwarf2_cu
**ref_cu
)
23447 ULONGEST signature
= DW_SIGNATURE (attr
);
23448 struct signatured_type
*sig_type
;
23449 struct die_info
*die
;
23451 gdb_assert (attr
->form
== DW_FORM_ref_sig8
);
23453 sig_type
= lookup_signatured_type (*ref_cu
, signature
);
23454 /* sig_type will be NULL if the signatured type is missing from
23456 if (sig_type
== NULL
)
23458 error (_("Dwarf Error: Cannot find signatured DIE %s referenced"
23459 " from DIE at 0x%x [in module %s]"),
23460 hex_string (signature
), to_underlying (src_die
->sect_off
),
23461 objfile_name ((*ref_cu
)->per_cu
->dwarf2_per_objfile
->objfile
));
23464 die
= follow_die_sig_1 (src_die
, sig_type
, ref_cu
);
23467 dump_die_for_error (src_die
);
23468 error (_("Dwarf Error: Problem reading signatured DIE %s referenced"
23469 " from DIE at 0x%x [in module %s]"),
23470 hex_string (signature
), to_underlying (src_die
->sect_off
),
23471 objfile_name ((*ref_cu
)->per_cu
->dwarf2_per_objfile
->objfile
));
23477 /* Get the type specified by SIGNATURE referenced in DIE/CU,
23478 reading in and processing the type unit if necessary. */
23480 static struct type
*
23481 get_signatured_type (struct die_info
*die
, ULONGEST signature
,
23482 struct dwarf2_cu
*cu
)
23484 struct dwarf2_per_objfile
*dwarf2_per_objfile
23485 = cu
->per_cu
->dwarf2_per_objfile
;
23486 struct signatured_type
*sig_type
;
23487 struct dwarf2_cu
*type_cu
;
23488 struct die_info
*type_die
;
23491 sig_type
= lookup_signatured_type (cu
, signature
);
23492 /* sig_type will be NULL if the signatured type is missing from
23494 if (sig_type
== NULL
)
23496 complaint (&symfile_complaints
,
23497 _("Dwarf Error: Cannot find signatured DIE %s referenced"
23498 " from DIE at 0x%x [in module %s]"),
23499 hex_string (signature
), to_underlying (die
->sect_off
),
23500 objfile_name (dwarf2_per_objfile
->objfile
));
23501 return build_error_marker_type (cu
, die
);
23504 /* If we already know the type we're done. */
23505 if (sig_type
->type
!= NULL
)
23506 return sig_type
->type
;
23509 type_die
= follow_die_sig_1 (die
, sig_type
, &type_cu
);
23510 if (type_die
!= NULL
)
23512 /* N.B. We need to call get_die_type to ensure only one type for this DIE
23513 is created. This is important, for example, because for c++ classes
23514 we need TYPE_NAME set which is only done by new_symbol. Blech. */
23515 type
= read_type_die (type_die
, type_cu
);
23518 complaint (&symfile_complaints
,
23519 _("Dwarf Error: Cannot build signatured type %s"
23520 " referenced from DIE at 0x%x [in module %s]"),
23521 hex_string (signature
), to_underlying (die
->sect_off
),
23522 objfile_name (dwarf2_per_objfile
->objfile
));
23523 type
= build_error_marker_type (cu
, die
);
23528 complaint (&symfile_complaints
,
23529 _("Dwarf Error: Problem reading signatured DIE %s referenced"
23530 " from DIE at 0x%x [in module %s]"),
23531 hex_string (signature
), to_underlying (die
->sect_off
),
23532 objfile_name (dwarf2_per_objfile
->objfile
));
23533 type
= build_error_marker_type (cu
, die
);
23535 sig_type
->type
= type
;
23540 /* Get the type specified by the DW_AT_signature ATTR in DIE/CU,
23541 reading in and processing the type unit if necessary. */
23543 static struct type
*
23544 get_DW_AT_signature_type (struct die_info
*die
, const struct attribute
*attr
,
23545 struct dwarf2_cu
*cu
) /* ARI: editCase function */
23547 /* Yes, DW_AT_signature can use a non-ref_sig8 reference. */
23548 if (attr_form_is_ref (attr
))
23550 struct dwarf2_cu
*type_cu
= cu
;
23551 struct die_info
*type_die
= follow_die_ref (die
, attr
, &type_cu
);
23553 return read_type_die (type_die
, type_cu
);
23555 else if (attr
->form
== DW_FORM_ref_sig8
)
23557 return get_signatured_type (die
, DW_SIGNATURE (attr
), cu
);
23561 struct dwarf2_per_objfile
*dwarf2_per_objfile
23562 = cu
->per_cu
->dwarf2_per_objfile
;
23564 complaint (&symfile_complaints
,
23565 _("Dwarf Error: DW_AT_signature has bad form %s in DIE"
23566 " at 0x%x [in module %s]"),
23567 dwarf_form_name (attr
->form
), to_underlying (die
->sect_off
),
23568 objfile_name (dwarf2_per_objfile
->objfile
));
23569 return build_error_marker_type (cu
, die
);
23573 /* Load the DIEs associated with type unit PER_CU into memory. */
23576 load_full_type_unit (struct dwarf2_per_cu_data
*per_cu
)
23578 struct signatured_type
*sig_type
;
23580 /* Caller is responsible for ensuring type_unit_groups don't get here. */
23581 gdb_assert (! IS_TYPE_UNIT_GROUP (per_cu
));
23583 /* We have the per_cu, but we need the signatured_type.
23584 Fortunately this is an easy translation. */
23585 gdb_assert (per_cu
->is_debug_types
);
23586 sig_type
= (struct signatured_type
*) per_cu
;
23588 gdb_assert (per_cu
->cu
== NULL
);
23590 read_signatured_type (sig_type
);
23592 gdb_assert (per_cu
->cu
!= NULL
);
23595 /* die_reader_func for read_signatured_type.
23596 This is identical to load_full_comp_unit_reader,
23597 but is kept separate for now. */
23600 read_signatured_type_reader (const struct die_reader_specs
*reader
,
23601 const gdb_byte
*info_ptr
,
23602 struct die_info
*comp_unit_die
,
23606 struct dwarf2_cu
*cu
= reader
->cu
;
23608 gdb_assert (cu
->die_hash
== NULL
);
23610 htab_create_alloc_ex (cu
->header
.length
/ 12,
23614 &cu
->comp_unit_obstack
,
23615 hashtab_obstack_allocate
,
23616 dummy_obstack_deallocate
);
23619 comp_unit_die
->child
= read_die_and_siblings (reader
, info_ptr
,
23620 &info_ptr
, comp_unit_die
);
23621 cu
->dies
= comp_unit_die
;
23622 /* comp_unit_die is not stored in die_hash, no need. */
23624 /* We try not to read any attributes in this function, because not
23625 all CUs needed for references have been loaded yet, and symbol
23626 table processing isn't initialized. But we have to set the CU language,
23627 or we won't be able to build types correctly.
23628 Similarly, if we do not read the producer, we can not apply
23629 producer-specific interpretation. */
23630 prepare_one_comp_unit (cu
, cu
->dies
, language_minimal
);
23633 /* Read in a signatured type and build its CU and DIEs.
23634 If the type is a stub for the real type in a DWO file,
23635 read in the real type from the DWO file as well. */
23638 read_signatured_type (struct signatured_type
*sig_type
)
23640 struct dwarf2_per_cu_data
*per_cu
= &sig_type
->per_cu
;
23642 gdb_assert (per_cu
->is_debug_types
);
23643 gdb_assert (per_cu
->cu
== NULL
);
23645 init_cutu_and_read_dies (per_cu
, NULL
, 0, 1,
23646 read_signatured_type_reader
, NULL
);
23647 sig_type
->per_cu
.tu_read
= 1;
23650 /* Decode simple location descriptions.
23651 Given a pointer to a dwarf block that defines a location, compute
23652 the location and return the value.
23654 NOTE drow/2003-11-18: This function is called in two situations
23655 now: for the address of static or global variables (partial symbols
23656 only) and for offsets into structures which are expected to be
23657 (more or less) constant. The partial symbol case should go away,
23658 and only the constant case should remain. That will let this
23659 function complain more accurately. A few special modes are allowed
23660 without complaint for global variables (for instance, global
23661 register values and thread-local values).
23663 A location description containing no operations indicates that the
23664 object is optimized out. The return value is 0 for that case.
23665 FIXME drow/2003-11-16: No callers check for this case any more; soon all
23666 callers will only want a very basic result and this can become a
23669 Note that stack[0] is unused except as a default error return. */
23672 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
23674 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
23676 size_t size
= blk
->size
;
23677 const gdb_byte
*data
= blk
->data
;
23678 CORE_ADDR stack
[64];
23680 unsigned int bytes_read
, unsnd
;
23686 stack
[++stacki
] = 0;
23725 stack
[++stacki
] = op
- DW_OP_lit0
;
23760 stack
[++stacki
] = op
- DW_OP_reg0
;
23762 dwarf2_complex_location_expr_complaint ();
23766 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
23768 stack
[++stacki
] = unsnd
;
23770 dwarf2_complex_location_expr_complaint ();
23774 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
23779 case DW_OP_const1u
:
23780 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
23784 case DW_OP_const1s
:
23785 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
23789 case DW_OP_const2u
:
23790 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
23794 case DW_OP_const2s
:
23795 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
23799 case DW_OP_const4u
:
23800 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
23804 case DW_OP_const4s
:
23805 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
23809 case DW_OP_const8u
:
23810 stack
[++stacki
] = read_8_bytes (objfile
->obfd
, &data
[i
]);
23815 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
23821 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
23826 stack
[stacki
+ 1] = stack
[stacki
];
23831 stack
[stacki
- 1] += stack
[stacki
];
23835 case DW_OP_plus_uconst
:
23836 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
),
23842 stack
[stacki
- 1] -= stack
[stacki
];
23847 /* If we're not the last op, then we definitely can't encode
23848 this using GDB's address_class enum. This is valid for partial
23849 global symbols, although the variable's address will be bogus
23852 dwarf2_complex_location_expr_complaint ();
23855 case DW_OP_GNU_push_tls_address
:
23856 case DW_OP_form_tls_address
:
23857 /* The top of the stack has the offset from the beginning
23858 of the thread control block at which the variable is located. */
23859 /* Nothing should follow this operator, so the top of stack would
23861 /* This is valid for partial global symbols, but the variable's
23862 address will be bogus in the psymtab. Make it always at least
23863 non-zero to not look as a variable garbage collected by linker
23864 which have DW_OP_addr 0. */
23866 dwarf2_complex_location_expr_complaint ();
23870 case DW_OP_GNU_uninit
:
23873 case DW_OP_GNU_addr_index
:
23874 case DW_OP_GNU_const_index
:
23875 stack
[++stacki
] = read_addr_index_from_leb128 (cu
, &data
[i
],
23882 const char *name
= get_DW_OP_name (op
);
23885 complaint (&symfile_complaints
, _("unsupported stack op: '%s'"),
23888 complaint (&symfile_complaints
, _("unsupported stack op: '%02x'"),
23892 return (stack
[stacki
]);
23895 /* Enforce maximum stack depth of SIZE-1 to avoid writing
23896 outside of the allocated space. Also enforce minimum>0. */
23897 if (stacki
>= ARRAY_SIZE (stack
) - 1)
23899 complaint (&symfile_complaints
,
23900 _("location description stack overflow"));
23906 complaint (&symfile_complaints
,
23907 _("location description stack underflow"));
23911 return (stack
[stacki
]);
23914 /* memory allocation interface */
23916 static struct dwarf_block
*
23917 dwarf_alloc_block (struct dwarf2_cu
*cu
)
23919 return XOBNEW (&cu
->comp_unit_obstack
, struct dwarf_block
);
23922 static struct die_info
*
23923 dwarf_alloc_die (struct dwarf2_cu
*cu
, int num_attrs
)
23925 struct die_info
*die
;
23926 size_t size
= sizeof (struct die_info
);
23929 size
+= (num_attrs
- 1) * sizeof (struct attribute
);
23931 die
= (struct die_info
*) obstack_alloc (&cu
->comp_unit_obstack
, size
);
23932 memset (die
, 0, sizeof (struct die_info
));
23937 /* Macro support. */
23939 /* Return file name relative to the compilation directory of file number I in
23940 *LH's file name table. The result is allocated using xmalloc; the caller is
23941 responsible for freeing it. */
23944 file_file_name (int file
, struct line_header
*lh
)
23946 /* Is the file number a valid index into the line header's file name
23947 table? Remember that file numbers start with one, not zero. */
23948 if (1 <= file
&& file
<= lh
->file_names
.size ())
23950 const file_entry
&fe
= lh
->file_names
[file
- 1];
23952 if (!IS_ABSOLUTE_PATH (fe
.name
))
23954 const char *dir
= fe
.include_dir (lh
);
23956 return concat (dir
, SLASH_STRING
, fe
.name
, (char *) NULL
);
23958 return xstrdup (fe
.name
);
23962 /* The compiler produced a bogus file number. We can at least
23963 record the macro definitions made in the file, even if we
23964 won't be able to find the file by name. */
23965 char fake_name
[80];
23967 xsnprintf (fake_name
, sizeof (fake_name
),
23968 "<bad macro file number %d>", file
);
23970 complaint (&symfile_complaints
,
23971 _("bad file number in macro information (%d)"),
23974 return xstrdup (fake_name
);
23978 /* Return the full name of file number I in *LH's file name table.
23979 Use COMP_DIR as the name of the current directory of the
23980 compilation. The result is allocated using xmalloc; the caller is
23981 responsible for freeing it. */
23983 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
23985 /* Is the file number a valid index into the line header's file name
23986 table? Remember that file numbers start with one, not zero. */
23987 if (1 <= file
&& file
<= lh
->file_names
.size ())
23989 char *relative
= file_file_name (file
, lh
);
23991 if (IS_ABSOLUTE_PATH (relative
) || comp_dir
== NULL
)
23993 return reconcat (relative
, comp_dir
, SLASH_STRING
,
23994 relative
, (char *) NULL
);
23997 return file_file_name (file
, lh
);
24001 static struct macro_source_file
*
24002 macro_start_file (int file
, int line
,
24003 struct macro_source_file
*current_file
,
24004 struct line_header
*lh
)
24006 /* File name relative to the compilation directory of this source file. */
24007 char *file_name
= file_file_name (file
, lh
);
24009 if (! current_file
)
24011 /* Note: We don't create a macro table for this compilation unit
24012 at all until we actually get a filename. */
24013 struct macro_table
*macro_table
= get_macro_table ();
24015 /* If we have no current file, then this must be the start_file
24016 directive for the compilation unit's main source file. */
24017 current_file
= macro_set_main (macro_table
, file_name
);
24018 macro_define_special (macro_table
);
24021 current_file
= macro_include (current_file
, line
, file_name
);
24025 return current_file
;
24028 static const char *
24029 consume_improper_spaces (const char *p
, const char *body
)
24033 complaint (&symfile_complaints
,
24034 _("macro definition contains spaces "
24035 "in formal argument list:\n`%s'"),
24047 parse_macro_definition (struct macro_source_file
*file
, int line
,
24052 /* The body string takes one of two forms. For object-like macro
24053 definitions, it should be:
24055 <macro name> " " <definition>
24057 For function-like macro definitions, it should be:
24059 <macro name> "() " <definition>
24061 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
24063 Spaces may appear only where explicitly indicated, and in the
24066 The Dwarf 2 spec says that an object-like macro's name is always
24067 followed by a space, but versions of GCC around March 2002 omit
24068 the space when the macro's definition is the empty string.
24070 The Dwarf 2 spec says that there should be no spaces between the
24071 formal arguments in a function-like macro's formal argument list,
24072 but versions of GCC around March 2002 include spaces after the
24076 /* Find the extent of the macro name. The macro name is terminated
24077 by either a space or null character (for an object-like macro) or
24078 an opening paren (for a function-like macro). */
24079 for (p
= body
; *p
; p
++)
24080 if (*p
== ' ' || *p
== '(')
24083 if (*p
== ' ' || *p
== '\0')
24085 /* It's an object-like macro. */
24086 int name_len
= p
- body
;
24087 char *name
= savestring (body
, name_len
);
24088 const char *replacement
;
24091 replacement
= body
+ name_len
+ 1;
24094 dwarf2_macro_malformed_definition_complaint (body
);
24095 replacement
= body
+ name_len
;
24098 macro_define_object (file
, line
, name
, replacement
);
24102 else if (*p
== '(')
24104 /* It's a function-like macro. */
24105 char *name
= savestring (body
, p
- body
);
24108 char **argv
= XNEWVEC (char *, argv_size
);
24112 p
= consume_improper_spaces (p
, body
);
24114 /* Parse the formal argument list. */
24115 while (*p
&& *p
!= ')')
24117 /* Find the extent of the current argument name. */
24118 const char *arg_start
= p
;
24120 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
24123 if (! *p
|| p
== arg_start
)
24124 dwarf2_macro_malformed_definition_complaint (body
);
24127 /* Make sure argv has room for the new argument. */
24128 if (argc
>= argv_size
)
24131 argv
= XRESIZEVEC (char *, argv
, argv_size
);
24134 argv
[argc
++] = savestring (arg_start
, p
- arg_start
);
24137 p
= consume_improper_spaces (p
, body
);
24139 /* Consume the comma, if present. */
24144 p
= consume_improper_spaces (p
, body
);
24153 /* Perfectly formed definition, no complaints. */
24154 macro_define_function (file
, line
, name
,
24155 argc
, (const char **) argv
,
24157 else if (*p
== '\0')
24159 /* Complain, but do define it. */
24160 dwarf2_macro_malformed_definition_complaint (body
);
24161 macro_define_function (file
, line
, name
,
24162 argc
, (const char **) argv
,
24166 /* Just complain. */
24167 dwarf2_macro_malformed_definition_complaint (body
);
24170 /* Just complain. */
24171 dwarf2_macro_malformed_definition_complaint (body
);
24177 for (i
= 0; i
< argc
; i
++)
24183 dwarf2_macro_malformed_definition_complaint (body
);
24186 /* Skip some bytes from BYTES according to the form given in FORM.
24187 Returns the new pointer. */
24189 static const gdb_byte
*
24190 skip_form_bytes (bfd
*abfd
, const gdb_byte
*bytes
, const gdb_byte
*buffer_end
,
24191 enum dwarf_form form
,
24192 unsigned int offset_size
,
24193 struct dwarf2_section_info
*section
)
24195 unsigned int bytes_read
;
24199 case DW_FORM_data1
:
24204 case DW_FORM_data2
:
24208 case DW_FORM_data4
:
24212 case DW_FORM_data8
:
24216 case DW_FORM_data16
:
24220 case DW_FORM_string
:
24221 read_direct_string (abfd
, bytes
, &bytes_read
);
24222 bytes
+= bytes_read
;
24225 case DW_FORM_sec_offset
:
24227 case DW_FORM_GNU_strp_alt
:
24228 bytes
+= offset_size
;
24231 case DW_FORM_block
:
24232 bytes
+= read_unsigned_leb128 (abfd
, bytes
, &bytes_read
);
24233 bytes
+= bytes_read
;
24236 case DW_FORM_block1
:
24237 bytes
+= 1 + read_1_byte (abfd
, bytes
);
24239 case DW_FORM_block2
:
24240 bytes
+= 2 + read_2_bytes (abfd
, bytes
);
24242 case DW_FORM_block4
:
24243 bytes
+= 4 + read_4_bytes (abfd
, bytes
);
24246 case DW_FORM_sdata
:
24247 case DW_FORM_udata
:
24248 case DW_FORM_GNU_addr_index
:
24249 case DW_FORM_GNU_str_index
:
24250 bytes
= gdb_skip_leb128 (bytes
, buffer_end
);
24253 dwarf2_section_buffer_overflow_complaint (section
);
24258 case DW_FORM_implicit_const
:
24263 complaint (&symfile_complaints
,
24264 _("invalid form 0x%x in `%s'"),
24265 form
, get_section_name (section
));
24273 /* A helper for dwarf_decode_macros that handles skipping an unknown
24274 opcode. Returns an updated pointer to the macro data buffer; or,
24275 on error, issues a complaint and returns NULL. */
24277 static const gdb_byte
*
24278 skip_unknown_opcode (unsigned int opcode
,
24279 const gdb_byte
**opcode_definitions
,
24280 const gdb_byte
*mac_ptr
, const gdb_byte
*mac_end
,
24282 unsigned int offset_size
,
24283 struct dwarf2_section_info
*section
)
24285 unsigned int bytes_read
, i
;
24287 const gdb_byte
*defn
;
24289 if (opcode_definitions
[opcode
] == NULL
)
24291 complaint (&symfile_complaints
,
24292 _("unrecognized DW_MACFINO opcode 0x%x"),
24297 defn
= opcode_definitions
[opcode
];
24298 arg
= read_unsigned_leb128 (abfd
, defn
, &bytes_read
);
24299 defn
+= bytes_read
;
24301 for (i
= 0; i
< arg
; ++i
)
24303 mac_ptr
= skip_form_bytes (abfd
, mac_ptr
, mac_end
,
24304 (enum dwarf_form
) defn
[i
], offset_size
,
24306 if (mac_ptr
== NULL
)
24308 /* skip_form_bytes already issued the complaint. */
24316 /* A helper function which parses the header of a macro section.
24317 If the macro section is the extended (for now called "GNU") type,
24318 then this updates *OFFSET_SIZE. Returns a pointer to just after
24319 the header, or issues a complaint and returns NULL on error. */
24321 static const gdb_byte
*
24322 dwarf_parse_macro_header (const gdb_byte
**opcode_definitions
,
24324 const gdb_byte
*mac_ptr
,
24325 unsigned int *offset_size
,
24326 int section_is_gnu
)
24328 memset (opcode_definitions
, 0, 256 * sizeof (gdb_byte
*));
24330 if (section_is_gnu
)
24332 unsigned int version
, flags
;
24334 version
= read_2_bytes (abfd
, mac_ptr
);
24335 if (version
!= 4 && version
!= 5)
24337 complaint (&symfile_complaints
,
24338 _("unrecognized version `%d' in .debug_macro section"),
24344 flags
= read_1_byte (abfd
, mac_ptr
);
24346 *offset_size
= (flags
& 1) ? 8 : 4;
24348 if ((flags
& 2) != 0)
24349 /* We don't need the line table offset. */
24350 mac_ptr
+= *offset_size
;
24352 /* Vendor opcode descriptions. */
24353 if ((flags
& 4) != 0)
24355 unsigned int i
, count
;
24357 count
= read_1_byte (abfd
, mac_ptr
);
24359 for (i
= 0; i
< count
; ++i
)
24361 unsigned int opcode
, bytes_read
;
24364 opcode
= read_1_byte (abfd
, mac_ptr
);
24366 opcode_definitions
[opcode
] = mac_ptr
;
24367 arg
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
24368 mac_ptr
+= bytes_read
;
24377 /* A helper for dwarf_decode_macros that handles the GNU extensions,
24378 including DW_MACRO_import. */
24381 dwarf_decode_macro_bytes (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
24383 const gdb_byte
*mac_ptr
, const gdb_byte
*mac_end
,
24384 struct macro_source_file
*current_file
,
24385 struct line_header
*lh
,
24386 struct dwarf2_section_info
*section
,
24387 int section_is_gnu
, int section_is_dwz
,
24388 unsigned int offset_size
,
24389 htab_t include_hash
)
24391 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
24392 enum dwarf_macro_record_type macinfo_type
;
24393 int at_commandline
;
24394 const gdb_byte
*opcode_definitions
[256];
24396 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
24397 &offset_size
, section_is_gnu
);
24398 if (mac_ptr
== NULL
)
24400 /* We already issued a complaint. */
24404 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
24405 GDB is still reading the definitions from command line. First
24406 DW_MACINFO_start_file will need to be ignored as it was already executed
24407 to create CURRENT_FILE for the main source holding also the command line
24408 definitions. On first met DW_MACINFO_start_file this flag is reset to
24409 normally execute all the remaining DW_MACINFO_start_file macinfos. */
24411 at_commandline
= 1;
24415 /* Do we at least have room for a macinfo type byte? */
24416 if (mac_ptr
>= mac_end
)
24418 dwarf2_section_buffer_overflow_complaint (section
);
24422 macinfo_type
= (enum dwarf_macro_record_type
) read_1_byte (abfd
, mac_ptr
);
24425 /* Note that we rely on the fact that the corresponding GNU and
24426 DWARF constants are the same. */
24428 DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES
24429 switch (macinfo_type
)
24431 /* A zero macinfo type indicates the end of the macro
24436 case DW_MACRO_define
:
24437 case DW_MACRO_undef
:
24438 case DW_MACRO_define_strp
:
24439 case DW_MACRO_undef_strp
:
24440 case DW_MACRO_define_sup
:
24441 case DW_MACRO_undef_sup
:
24443 unsigned int bytes_read
;
24448 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
24449 mac_ptr
+= bytes_read
;
24451 if (macinfo_type
== DW_MACRO_define
24452 || macinfo_type
== DW_MACRO_undef
)
24454 body
= read_direct_string (abfd
, mac_ptr
, &bytes_read
);
24455 mac_ptr
+= bytes_read
;
24459 LONGEST str_offset
;
24461 str_offset
= read_offset_1 (abfd
, mac_ptr
, offset_size
);
24462 mac_ptr
+= offset_size
;
24464 if (macinfo_type
== DW_MACRO_define_sup
24465 || macinfo_type
== DW_MACRO_undef_sup
24468 struct dwz_file
*dwz
24469 = dwarf2_get_dwz_file (dwarf2_per_objfile
);
24471 body
= read_indirect_string_from_dwz (objfile
,
24475 body
= read_indirect_string_at_offset (dwarf2_per_objfile
,
24479 is_define
= (macinfo_type
== DW_MACRO_define
24480 || macinfo_type
== DW_MACRO_define_strp
24481 || macinfo_type
== DW_MACRO_define_sup
);
24482 if (! current_file
)
24484 /* DWARF violation as no main source is present. */
24485 complaint (&symfile_complaints
,
24486 _("debug info with no main source gives macro %s "
24488 is_define
? _("definition") : _("undefinition"),
24492 if ((line
== 0 && !at_commandline
)
24493 || (line
!= 0 && at_commandline
))
24494 complaint (&symfile_complaints
,
24495 _("debug info gives %s macro %s with %s line %d: %s"),
24496 at_commandline
? _("command-line") : _("in-file"),
24497 is_define
? _("definition") : _("undefinition"),
24498 line
== 0 ? _("zero") : _("non-zero"), line
, body
);
24501 parse_macro_definition (current_file
, line
, body
);
24504 gdb_assert (macinfo_type
== DW_MACRO_undef
24505 || macinfo_type
== DW_MACRO_undef_strp
24506 || macinfo_type
== DW_MACRO_undef_sup
);
24507 macro_undef (current_file
, line
, body
);
24512 case DW_MACRO_start_file
:
24514 unsigned int bytes_read
;
24517 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
24518 mac_ptr
+= bytes_read
;
24519 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
24520 mac_ptr
+= bytes_read
;
24522 if ((line
== 0 && !at_commandline
)
24523 || (line
!= 0 && at_commandline
))
24524 complaint (&symfile_complaints
,
24525 _("debug info gives source %d included "
24526 "from %s at %s line %d"),
24527 file
, at_commandline
? _("command-line") : _("file"),
24528 line
== 0 ? _("zero") : _("non-zero"), line
);
24530 if (at_commandline
)
24532 /* This DW_MACRO_start_file was executed in the
24534 at_commandline
= 0;
24537 current_file
= macro_start_file (file
, line
, current_file
, lh
);
24541 case DW_MACRO_end_file
:
24542 if (! current_file
)
24543 complaint (&symfile_complaints
,
24544 _("macro debug info has an unmatched "
24545 "`close_file' directive"));
24548 current_file
= current_file
->included_by
;
24549 if (! current_file
)
24551 enum dwarf_macro_record_type next_type
;
24553 /* GCC circa March 2002 doesn't produce the zero
24554 type byte marking the end of the compilation
24555 unit. Complain if it's not there, but exit no
24558 /* Do we at least have room for a macinfo type byte? */
24559 if (mac_ptr
>= mac_end
)
24561 dwarf2_section_buffer_overflow_complaint (section
);
24565 /* We don't increment mac_ptr here, so this is just
24568 = (enum dwarf_macro_record_type
) read_1_byte (abfd
,
24570 if (next_type
!= 0)
24571 complaint (&symfile_complaints
,
24572 _("no terminating 0-type entry for "
24573 "macros in `.debug_macinfo' section"));
24580 case DW_MACRO_import
:
24581 case DW_MACRO_import_sup
:
24585 bfd
*include_bfd
= abfd
;
24586 struct dwarf2_section_info
*include_section
= section
;
24587 const gdb_byte
*include_mac_end
= mac_end
;
24588 int is_dwz
= section_is_dwz
;
24589 const gdb_byte
*new_mac_ptr
;
24591 offset
= read_offset_1 (abfd
, mac_ptr
, offset_size
);
24592 mac_ptr
+= offset_size
;
24594 if (macinfo_type
== DW_MACRO_import_sup
)
24596 struct dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
24598 dwarf2_read_section (objfile
, &dwz
->macro
);
24600 include_section
= &dwz
->macro
;
24601 include_bfd
= get_section_bfd_owner (include_section
);
24602 include_mac_end
= dwz
->macro
.buffer
+ dwz
->macro
.size
;
24606 new_mac_ptr
= include_section
->buffer
+ offset
;
24607 slot
= htab_find_slot (include_hash
, new_mac_ptr
, INSERT
);
24611 /* This has actually happened; see
24612 http://sourceware.org/bugzilla/show_bug.cgi?id=13568. */
24613 complaint (&symfile_complaints
,
24614 _("recursive DW_MACRO_import in "
24615 ".debug_macro section"));
24619 *slot
= (void *) new_mac_ptr
;
24621 dwarf_decode_macro_bytes (dwarf2_per_objfile
,
24622 include_bfd
, new_mac_ptr
,
24623 include_mac_end
, current_file
, lh
,
24624 section
, section_is_gnu
, is_dwz
,
24625 offset_size
, include_hash
);
24627 htab_remove_elt (include_hash
, (void *) new_mac_ptr
);
24632 case DW_MACINFO_vendor_ext
:
24633 if (!section_is_gnu
)
24635 unsigned int bytes_read
;
24637 /* This reads the constant, but since we don't recognize
24638 any vendor extensions, we ignore it. */
24639 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
24640 mac_ptr
+= bytes_read
;
24641 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
24642 mac_ptr
+= bytes_read
;
24644 /* We don't recognize any vendor extensions. */
24650 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
24651 mac_ptr
, mac_end
, abfd
, offset_size
,
24653 if (mac_ptr
== NULL
)
24658 } while (macinfo_type
!= 0);
24662 dwarf_decode_macros (struct dwarf2_cu
*cu
, unsigned int offset
,
24663 int section_is_gnu
)
24665 struct dwarf2_per_objfile
*dwarf2_per_objfile
24666 = cu
->per_cu
->dwarf2_per_objfile
;
24667 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
24668 struct line_header
*lh
= cu
->line_header
;
24670 const gdb_byte
*mac_ptr
, *mac_end
;
24671 struct macro_source_file
*current_file
= 0;
24672 enum dwarf_macro_record_type macinfo_type
;
24673 unsigned int offset_size
= cu
->header
.offset_size
;
24674 const gdb_byte
*opcode_definitions
[256];
24676 struct dwarf2_section_info
*section
;
24677 const char *section_name
;
24679 if (cu
->dwo_unit
!= NULL
)
24681 if (section_is_gnu
)
24683 section
= &cu
->dwo_unit
->dwo_file
->sections
.macro
;
24684 section_name
= ".debug_macro.dwo";
24688 section
= &cu
->dwo_unit
->dwo_file
->sections
.macinfo
;
24689 section_name
= ".debug_macinfo.dwo";
24694 if (section_is_gnu
)
24696 section
= &dwarf2_per_objfile
->macro
;
24697 section_name
= ".debug_macro";
24701 section
= &dwarf2_per_objfile
->macinfo
;
24702 section_name
= ".debug_macinfo";
24706 dwarf2_read_section (objfile
, section
);
24707 if (section
->buffer
== NULL
)
24709 complaint (&symfile_complaints
, _("missing %s section"), section_name
);
24712 abfd
= get_section_bfd_owner (section
);
24714 /* First pass: Find the name of the base filename.
24715 This filename is needed in order to process all macros whose definition
24716 (or undefinition) comes from the command line. These macros are defined
24717 before the first DW_MACINFO_start_file entry, and yet still need to be
24718 associated to the base file.
24720 To determine the base file name, we scan the macro definitions until we
24721 reach the first DW_MACINFO_start_file entry. We then initialize
24722 CURRENT_FILE accordingly so that any macro definition found before the
24723 first DW_MACINFO_start_file can still be associated to the base file. */
24725 mac_ptr
= section
->buffer
+ offset
;
24726 mac_end
= section
->buffer
+ section
->size
;
24728 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
24729 &offset_size
, section_is_gnu
);
24730 if (mac_ptr
== NULL
)
24732 /* We already issued a complaint. */
24738 /* Do we at least have room for a macinfo type byte? */
24739 if (mac_ptr
>= mac_end
)
24741 /* Complaint is printed during the second pass as GDB will probably
24742 stop the first pass earlier upon finding
24743 DW_MACINFO_start_file. */
24747 macinfo_type
= (enum dwarf_macro_record_type
) read_1_byte (abfd
, mac_ptr
);
24750 /* Note that we rely on the fact that the corresponding GNU and
24751 DWARF constants are the same. */
24753 DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES
24754 switch (macinfo_type
)
24756 /* A zero macinfo type indicates the end of the macro
24761 case DW_MACRO_define
:
24762 case DW_MACRO_undef
:
24763 /* Only skip the data by MAC_PTR. */
24765 unsigned int bytes_read
;
24767 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
24768 mac_ptr
+= bytes_read
;
24769 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
24770 mac_ptr
+= bytes_read
;
24774 case DW_MACRO_start_file
:
24776 unsigned int bytes_read
;
24779 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
24780 mac_ptr
+= bytes_read
;
24781 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
24782 mac_ptr
+= bytes_read
;
24784 current_file
= macro_start_file (file
, line
, current_file
, lh
);
24788 case DW_MACRO_end_file
:
24789 /* No data to skip by MAC_PTR. */
24792 case DW_MACRO_define_strp
:
24793 case DW_MACRO_undef_strp
:
24794 case DW_MACRO_define_sup
:
24795 case DW_MACRO_undef_sup
:
24797 unsigned int bytes_read
;
24799 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
24800 mac_ptr
+= bytes_read
;
24801 mac_ptr
+= offset_size
;
24805 case DW_MACRO_import
:
24806 case DW_MACRO_import_sup
:
24807 /* Note that, according to the spec, a transparent include
24808 chain cannot call DW_MACRO_start_file. So, we can just
24809 skip this opcode. */
24810 mac_ptr
+= offset_size
;
24813 case DW_MACINFO_vendor_ext
:
24814 /* Only skip the data by MAC_PTR. */
24815 if (!section_is_gnu
)
24817 unsigned int bytes_read
;
24819 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
24820 mac_ptr
+= bytes_read
;
24821 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
24822 mac_ptr
+= bytes_read
;
24827 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
24828 mac_ptr
, mac_end
, abfd
, offset_size
,
24830 if (mac_ptr
== NULL
)
24835 } while (macinfo_type
!= 0 && current_file
== NULL
);
24837 /* Second pass: Process all entries.
24839 Use the AT_COMMAND_LINE flag to determine whether we are still processing
24840 command-line macro definitions/undefinitions. This flag is unset when we
24841 reach the first DW_MACINFO_start_file entry. */
24843 htab_up
include_hash (htab_create_alloc (1, htab_hash_pointer
,
24845 NULL
, xcalloc
, xfree
));
24846 mac_ptr
= section
->buffer
+ offset
;
24847 slot
= htab_find_slot (include_hash
.get (), mac_ptr
, INSERT
);
24848 *slot
= (void *) mac_ptr
;
24849 dwarf_decode_macro_bytes (dwarf2_per_objfile
,
24850 abfd
, mac_ptr
, mac_end
,
24851 current_file
, lh
, section
,
24852 section_is_gnu
, 0, offset_size
,
24853 include_hash
.get ());
24856 /* Check if the attribute's form is a DW_FORM_block*
24857 if so return true else false. */
24860 attr_form_is_block (const struct attribute
*attr
)
24862 return (attr
== NULL
? 0 :
24863 attr
->form
== DW_FORM_block1
24864 || attr
->form
== DW_FORM_block2
24865 || attr
->form
== DW_FORM_block4
24866 || attr
->form
== DW_FORM_block
24867 || attr
->form
== DW_FORM_exprloc
);
24870 /* Return non-zero if ATTR's value is a section offset --- classes
24871 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
24872 You may use DW_UNSND (attr) to retrieve such offsets.
24874 Section 7.5.4, "Attribute Encodings", explains that no attribute
24875 may have a value that belongs to more than one of these classes; it
24876 would be ambiguous if we did, because we use the same forms for all
24880 attr_form_is_section_offset (const struct attribute
*attr
)
24882 return (attr
->form
== DW_FORM_data4
24883 || attr
->form
== DW_FORM_data8
24884 || attr
->form
== DW_FORM_sec_offset
);
24887 /* Return non-zero if ATTR's value falls in the 'constant' class, or
24888 zero otherwise. When this function returns true, you can apply
24889 dwarf2_get_attr_constant_value to it.
24891 However, note that for some attributes you must check
24892 attr_form_is_section_offset before using this test. DW_FORM_data4
24893 and DW_FORM_data8 are members of both the constant class, and of
24894 the classes that contain offsets into other debug sections
24895 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
24896 that, if an attribute's can be either a constant or one of the
24897 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
24898 taken as section offsets, not constants.
24900 DW_FORM_data16 is not considered as dwarf2_get_attr_constant_value
24901 cannot handle that. */
24904 attr_form_is_constant (const struct attribute
*attr
)
24906 switch (attr
->form
)
24908 case DW_FORM_sdata
:
24909 case DW_FORM_udata
:
24910 case DW_FORM_data1
:
24911 case DW_FORM_data2
:
24912 case DW_FORM_data4
:
24913 case DW_FORM_data8
:
24914 case DW_FORM_implicit_const
:
24922 /* DW_ADDR is always stored already as sect_offset; despite for the forms
24923 besides DW_FORM_ref_addr it is stored as cu_offset in the DWARF file. */
24926 attr_form_is_ref (const struct attribute
*attr
)
24928 switch (attr
->form
)
24930 case DW_FORM_ref_addr
:
24935 case DW_FORM_ref_udata
:
24936 case DW_FORM_GNU_ref_alt
:
24943 /* Return the .debug_loc section to use for CU.
24944 For DWO files use .debug_loc.dwo. */
24946 static struct dwarf2_section_info
*
24947 cu_debug_loc_section (struct dwarf2_cu
*cu
)
24949 struct dwarf2_per_objfile
*dwarf2_per_objfile
24950 = cu
->per_cu
->dwarf2_per_objfile
;
24954 struct dwo_sections
*sections
= &cu
->dwo_unit
->dwo_file
->sections
;
24956 return cu
->header
.version
>= 5 ? §ions
->loclists
: §ions
->loc
;
24958 return (cu
->header
.version
>= 5 ? &dwarf2_per_objfile
->loclists
24959 : &dwarf2_per_objfile
->loc
);
24962 /* A helper function that fills in a dwarf2_loclist_baton. */
24965 fill_in_loclist_baton (struct dwarf2_cu
*cu
,
24966 struct dwarf2_loclist_baton
*baton
,
24967 const struct attribute
*attr
)
24969 struct dwarf2_per_objfile
*dwarf2_per_objfile
24970 = cu
->per_cu
->dwarf2_per_objfile
;
24971 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
24973 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
24975 baton
->per_cu
= cu
->per_cu
;
24976 gdb_assert (baton
->per_cu
);
24977 /* We don't know how long the location list is, but make sure we
24978 don't run off the edge of the section. */
24979 baton
->size
= section
->size
- DW_UNSND (attr
);
24980 baton
->data
= section
->buffer
+ DW_UNSND (attr
);
24981 baton
->base_address
= cu
->base_address
;
24982 baton
->from_dwo
= cu
->dwo_unit
!= NULL
;
24986 dwarf2_symbol_mark_computed (const struct attribute
*attr
, struct symbol
*sym
,
24987 struct dwarf2_cu
*cu
, int is_block
)
24989 struct dwarf2_per_objfile
*dwarf2_per_objfile
24990 = cu
->per_cu
->dwarf2_per_objfile
;
24991 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
24992 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
24994 if (attr_form_is_section_offset (attr
)
24995 /* .debug_loc{,.dwo} may not exist at all, or the offset may be outside
24996 the section. If so, fall through to the complaint in the
24998 && DW_UNSND (attr
) < dwarf2_section_size (objfile
, section
))
25000 struct dwarf2_loclist_baton
*baton
;
25002 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_loclist_baton
);
25004 fill_in_loclist_baton (cu
, baton
, attr
);
25006 if (cu
->base_known
== 0)
25007 complaint (&symfile_complaints
,
25008 _("Location list used without "
25009 "specifying the CU base address."));
25011 SYMBOL_ACLASS_INDEX (sym
) = (is_block
25012 ? dwarf2_loclist_block_index
25013 : dwarf2_loclist_index
);
25014 SYMBOL_LOCATION_BATON (sym
) = baton
;
25018 struct dwarf2_locexpr_baton
*baton
;
25020 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
25021 baton
->per_cu
= cu
->per_cu
;
25022 gdb_assert (baton
->per_cu
);
25024 if (attr_form_is_block (attr
))
25026 /* Note that we're just copying the block's data pointer
25027 here, not the actual data. We're still pointing into the
25028 info_buffer for SYM's objfile; right now we never release
25029 that buffer, but when we do clean up properly this may
25031 baton
->size
= DW_BLOCK (attr
)->size
;
25032 baton
->data
= DW_BLOCK (attr
)->data
;
25036 dwarf2_invalid_attrib_class_complaint ("location description",
25037 SYMBOL_NATURAL_NAME (sym
));
25041 SYMBOL_ACLASS_INDEX (sym
) = (is_block
25042 ? dwarf2_locexpr_block_index
25043 : dwarf2_locexpr_index
);
25044 SYMBOL_LOCATION_BATON (sym
) = baton
;
25048 /* Return the OBJFILE associated with the compilation unit CU. If CU
25049 came from a separate debuginfo file, then the master objfile is
25053 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data
*per_cu
)
25055 struct objfile
*objfile
= per_cu
->dwarf2_per_objfile
->objfile
;
25057 /* Return the master objfile, so that we can report and look up the
25058 correct file containing this variable. */
25059 if (objfile
->separate_debug_objfile_backlink
)
25060 objfile
= objfile
->separate_debug_objfile_backlink
;
25065 /* Return comp_unit_head for PER_CU, either already available in PER_CU->CU
25066 (CU_HEADERP is unused in such case) or prepare a temporary copy at
25067 CU_HEADERP first. */
25069 static const struct comp_unit_head
*
25070 per_cu_header_read_in (struct comp_unit_head
*cu_headerp
,
25071 struct dwarf2_per_cu_data
*per_cu
)
25073 const gdb_byte
*info_ptr
;
25076 return &per_cu
->cu
->header
;
25078 info_ptr
= per_cu
->section
->buffer
+ to_underlying (per_cu
->sect_off
);
25080 memset (cu_headerp
, 0, sizeof (*cu_headerp
));
25081 read_comp_unit_head (cu_headerp
, info_ptr
, per_cu
->section
,
25082 rcuh_kind::COMPILE
);
25087 /* Return the address size given in the compilation unit header for CU. */
25090 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data
*per_cu
)
25092 struct comp_unit_head cu_header_local
;
25093 const struct comp_unit_head
*cu_headerp
;
25095 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
25097 return cu_headerp
->addr_size
;
25100 /* Return the offset size given in the compilation unit header for CU. */
25103 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data
*per_cu
)
25105 struct comp_unit_head cu_header_local
;
25106 const struct comp_unit_head
*cu_headerp
;
25108 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
25110 return cu_headerp
->offset_size
;
25113 /* See its dwarf2loc.h declaration. */
25116 dwarf2_per_cu_ref_addr_size (struct dwarf2_per_cu_data
*per_cu
)
25118 struct comp_unit_head cu_header_local
;
25119 const struct comp_unit_head
*cu_headerp
;
25121 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
25123 if (cu_headerp
->version
== 2)
25124 return cu_headerp
->addr_size
;
25126 return cu_headerp
->offset_size
;
25129 /* Return the text offset of the CU. The returned offset comes from
25130 this CU's objfile. If this objfile came from a separate debuginfo
25131 file, then the offset may be different from the corresponding
25132 offset in the parent objfile. */
25135 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data
*per_cu
)
25137 struct objfile
*objfile
= per_cu
->dwarf2_per_objfile
->objfile
;
25139 return ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
25142 /* Return DWARF version number of PER_CU. */
25145 dwarf2_version (struct dwarf2_per_cu_data
*per_cu
)
25147 return per_cu
->dwarf_version
;
25150 /* Locate the .debug_info compilation unit from CU's objfile which contains
25151 the DIE at OFFSET. Raises an error on failure. */
25153 static struct dwarf2_per_cu_data
*
25154 dwarf2_find_containing_comp_unit (sect_offset sect_off
,
25155 unsigned int offset_in_dwz
,
25156 struct dwarf2_per_objfile
*dwarf2_per_objfile
)
25158 struct dwarf2_per_cu_data
*this_cu
;
25160 const sect_offset
*cu_off
;
25163 high
= dwarf2_per_objfile
->n_comp_units
- 1;
25166 struct dwarf2_per_cu_data
*mid_cu
;
25167 int mid
= low
+ (high
- low
) / 2;
25169 mid_cu
= dwarf2_per_objfile
->all_comp_units
[mid
];
25170 cu_off
= &mid_cu
->sect_off
;
25171 if (mid_cu
->is_dwz
> offset_in_dwz
25172 || (mid_cu
->is_dwz
== offset_in_dwz
&& *cu_off
>= sect_off
))
25177 gdb_assert (low
== high
);
25178 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
25179 cu_off
= &this_cu
->sect_off
;
25180 if (this_cu
->is_dwz
!= offset_in_dwz
|| *cu_off
> sect_off
)
25182 if (low
== 0 || this_cu
->is_dwz
!= offset_in_dwz
)
25183 error (_("Dwarf Error: could not find partial DIE containing "
25184 "offset 0x%x [in module %s]"),
25185 to_underlying (sect_off
),
25186 bfd_get_filename (dwarf2_per_objfile
->objfile
->obfd
));
25188 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->sect_off
25190 return dwarf2_per_objfile
->all_comp_units
[low
-1];
25194 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
25195 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
25196 && sect_off
>= this_cu
->sect_off
+ this_cu
->length
)
25197 error (_("invalid dwarf2 offset %u"), to_underlying (sect_off
));
25198 gdb_assert (sect_off
< this_cu
->sect_off
+ this_cu
->length
);
25203 /* Initialize dwarf2_cu CU, owned by PER_CU. */
25206 init_one_comp_unit (struct dwarf2_cu
*cu
, struct dwarf2_per_cu_data
*per_cu
)
25208 memset (cu
, 0, sizeof (*cu
));
25210 cu
->per_cu
= per_cu
;
25211 obstack_init (&cu
->comp_unit_obstack
);
25214 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
25217 prepare_one_comp_unit (struct dwarf2_cu
*cu
, struct die_info
*comp_unit_die
,
25218 enum language pretend_language
)
25220 struct attribute
*attr
;
25222 /* Set the language we're debugging. */
25223 attr
= dwarf2_attr (comp_unit_die
, DW_AT_language
, cu
);
25225 set_cu_language (DW_UNSND (attr
), cu
);
25228 cu
->language
= pretend_language
;
25229 cu
->language_defn
= language_def (cu
->language
);
25232 cu
->producer
= dwarf2_string_attr (comp_unit_die
, DW_AT_producer
, cu
);
25235 /* Release one cached compilation unit, CU. We unlink it from the tree
25236 of compilation units, but we don't remove it from the read_in_chain;
25237 the caller is responsible for that.
25238 NOTE: DATA is a void * because this function is also used as a
25239 cleanup routine. */
25242 free_heap_comp_unit (void *data
)
25244 struct dwarf2_cu
*cu
= (struct dwarf2_cu
*) data
;
25246 gdb_assert (cu
->per_cu
!= NULL
);
25247 cu
->per_cu
->cu
= NULL
;
25250 obstack_free (&cu
->comp_unit_obstack
, NULL
);
25255 /* This cleanup function is passed the address of a dwarf2_cu on the stack
25256 when we're finished with it. We can't free the pointer itself, but be
25257 sure to unlink it from the cache. Also release any associated storage. */
25260 free_stack_comp_unit (void *data
)
25262 struct dwarf2_cu
*cu
= (struct dwarf2_cu
*) data
;
25264 gdb_assert (cu
->per_cu
!= NULL
);
25265 cu
->per_cu
->cu
= NULL
;
25268 obstack_free (&cu
->comp_unit_obstack
, NULL
);
25269 cu
->partial_dies
= NULL
;
25272 /* Free all cached compilation units. */
25275 free_cached_comp_units (void *data
)
25277 struct dwarf2_per_objfile
*dwarf2_per_objfile
25278 = (struct dwarf2_per_objfile
*) data
;
25280 dwarf2_per_objfile
->free_cached_comp_units ();
25283 /* Increase the age counter on each cached compilation unit, and free
25284 any that are too old. */
25287 age_cached_comp_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
25289 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
25291 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
25292 per_cu
= dwarf2_per_objfile
->read_in_chain
;
25293 while (per_cu
!= NULL
)
25295 per_cu
->cu
->last_used
++;
25296 if (per_cu
->cu
->last_used
<= dwarf_max_cache_age
)
25297 dwarf2_mark (per_cu
->cu
);
25298 per_cu
= per_cu
->cu
->read_in_chain
;
25301 per_cu
= dwarf2_per_objfile
->read_in_chain
;
25302 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
25303 while (per_cu
!= NULL
)
25305 struct dwarf2_per_cu_data
*next_cu
;
25307 next_cu
= per_cu
->cu
->read_in_chain
;
25309 if (!per_cu
->cu
->mark
)
25311 free_heap_comp_unit (per_cu
->cu
);
25312 *last_chain
= next_cu
;
25315 last_chain
= &per_cu
->cu
->read_in_chain
;
25321 /* Remove a single compilation unit from the cache. */
25324 free_one_cached_comp_unit (struct dwarf2_per_cu_data
*target_per_cu
)
25326 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
25327 struct dwarf2_per_objfile
*dwarf2_per_objfile
25328 = target_per_cu
->dwarf2_per_objfile
;
25330 per_cu
= dwarf2_per_objfile
->read_in_chain
;
25331 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
25332 while (per_cu
!= NULL
)
25334 struct dwarf2_per_cu_data
*next_cu
;
25336 next_cu
= per_cu
->cu
->read_in_chain
;
25338 if (per_cu
== target_per_cu
)
25340 free_heap_comp_unit (per_cu
->cu
);
25342 *last_chain
= next_cu
;
25346 last_chain
= &per_cu
->cu
->read_in_chain
;
25352 /* Release all extra memory associated with OBJFILE. */
25355 dwarf2_free_objfile (struct objfile
*objfile
)
25357 struct dwarf2_per_objfile
*dwarf2_per_objfile
25358 = get_dwarf2_per_objfile (objfile
);
25360 if (dwarf2_per_objfile
== NULL
)
25363 dwarf2_per_objfile
->~dwarf2_per_objfile ();
25366 /* A set of CU "per_cu" pointer, DIE offset, and GDB type pointer.
25367 We store these in a hash table separate from the DIEs, and preserve them
25368 when the DIEs are flushed out of cache.
25370 The CU "per_cu" pointer is needed because offset alone is not enough to
25371 uniquely identify the type. A file may have multiple .debug_types sections,
25372 or the type may come from a DWO file. Furthermore, while it's more logical
25373 to use per_cu->section+offset, with Fission the section with the data is in
25374 the DWO file but we don't know that section at the point we need it.
25375 We have to use something in dwarf2_per_cu_data (or the pointer to it)
25376 because we can enter the lookup routine, get_die_type_at_offset, from
25377 outside this file, and thus won't necessarily have PER_CU->cu.
25378 Fortunately, PER_CU is stable for the life of the objfile. */
25380 struct dwarf2_per_cu_offset_and_type
25382 const struct dwarf2_per_cu_data
*per_cu
;
25383 sect_offset sect_off
;
25387 /* Hash function for a dwarf2_per_cu_offset_and_type. */
25390 per_cu_offset_and_type_hash (const void *item
)
25392 const struct dwarf2_per_cu_offset_and_type
*ofs
25393 = (const struct dwarf2_per_cu_offset_and_type
*) item
;
25395 return (uintptr_t) ofs
->per_cu
+ to_underlying (ofs
->sect_off
);
25398 /* Equality function for a dwarf2_per_cu_offset_and_type. */
25401 per_cu_offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
25403 const struct dwarf2_per_cu_offset_and_type
*ofs_lhs
25404 = (const struct dwarf2_per_cu_offset_and_type
*) item_lhs
;
25405 const struct dwarf2_per_cu_offset_and_type
*ofs_rhs
25406 = (const struct dwarf2_per_cu_offset_and_type
*) item_rhs
;
25408 return (ofs_lhs
->per_cu
== ofs_rhs
->per_cu
25409 && ofs_lhs
->sect_off
== ofs_rhs
->sect_off
);
25412 /* Set the type associated with DIE to TYPE. Save it in CU's hash
25413 table if necessary. For convenience, return TYPE.
25415 The DIEs reading must have careful ordering to:
25416 * Not cause infite loops trying to read in DIEs as a prerequisite for
25417 reading current DIE.
25418 * Not trying to dereference contents of still incompletely read in types
25419 while reading in other DIEs.
25420 * Enable referencing still incompletely read in types just by a pointer to
25421 the type without accessing its fields.
25423 Therefore caller should follow these rules:
25424 * Try to fetch any prerequisite types we may need to build this DIE type
25425 before building the type and calling set_die_type.
25426 * After building type call set_die_type for current DIE as soon as
25427 possible before fetching more types to complete the current type.
25428 * Make the type as complete as possible before fetching more types. */
25430 static struct type
*
25431 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
25433 struct dwarf2_per_objfile
*dwarf2_per_objfile
25434 = cu
->per_cu
->dwarf2_per_objfile
;
25435 struct dwarf2_per_cu_offset_and_type
**slot
, ofs
;
25436 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
25437 struct attribute
*attr
;
25438 struct dynamic_prop prop
;
25440 /* For Ada types, make sure that the gnat-specific data is always
25441 initialized (if not already set). There are a few types where
25442 we should not be doing so, because the type-specific area is
25443 already used to hold some other piece of info (eg: TYPE_CODE_FLT
25444 where the type-specific area is used to store the floatformat).
25445 But this is not a problem, because the gnat-specific information
25446 is actually not needed for these types. */
25447 if (need_gnat_info (cu
)
25448 && TYPE_CODE (type
) != TYPE_CODE_FUNC
25449 && TYPE_CODE (type
) != TYPE_CODE_FLT
25450 && TYPE_CODE (type
) != TYPE_CODE_METHODPTR
25451 && TYPE_CODE (type
) != TYPE_CODE_MEMBERPTR
25452 && TYPE_CODE (type
) != TYPE_CODE_METHOD
25453 && !HAVE_GNAT_AUX_INFO (type
))
25454 INIT_GNAT_SPECIFIC (type
);
25456 /* Read DW_AT_allocated and set in type. */
25457 attr
= dwarf2_attr (die
, DW_AT_allocated
, cu
);
25458 if (attr_form_is_block (attr
))
25460 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
))
25461 add_dyn_prop (DYN_PROP_ALLOCATED
, prop
, type
, objfile
);
25463 else if (attr
!= NULL
)
25465 complaint (&symfile_complaints
,
25466 _("DW_AT_allocated has the wrong form (%s) at DIE 0x%x"),
25467 (attr
!= NULL
? dwarf_form_name (attr
->form
) : "n/a"),
25468 to_underlying (die
->sect_off
));
25471 /* Read DW_AT_associated and set in type. */
25472 attr
= dwarf2_attr (die
, DW_AT_associated
, cu
);
25473 if (attr_form_is_block (attr
))
25475 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
))
25476 add_dyn_prop (DYN_PROP_ASSOCIATED
, prop
, type
, objfile
);
25478 else if (attr
!= NULL
)
25480 complaint (&symfile_complaints
,
25481 _("DW_AT_associated has the wrong form (%s) at DIE 0x%x"),
25482 (attr
!= NULL
? dwarf_form_name (attr
->form
) : "n/a"),
25483 to_underlying (die
->sect_off
));
25486 /* Read DW_AT_data_location and set in type. */
25487 attr
= dwarf2_attr (die
, DW_AT_data_location
, cu
);
25488 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
))
25489 add_dyn_prop (DYN_PROP_DATA_LOCATION
, prop
, type
, objfile
);
25491 if (dwarf2_per_objfile
->die_type_hash
== NULL
)
25493 dwarf2_per_objfile
->die_type_hash
=
25494 htab_create_alloc_ex (127,
25495 per_cu_offset_and_type_hash
,
25496 per_cu_offset_and_type_eq
,
25498 &objfile
->objfile_obstack
,
25499 hashtab_obstack_allocate
,
25500 dummy_obstack_deallocate
);
25503 ofs
.per_cu
= cu
->per_cu
;
25504 ofs
.sect_off
= die
->sect_off
;
25506 slot
= (struct dwarf2_per_cu_offset_and_type
**)
25507 htab_find_slot (dwarf2_per_objfile
->die_type_hash
, &ofs
, INSERT
);
25509 complaint (&symfile_complaints
,
25510 _("A problem internal to GDB: DIE 0x%x has type already set"),
25511 to_underlying (die
->sect_off
));
25512 *slot
= XOBNEW (&objfile
->objfile_obstack
,
25513 struct dwarf2_per_cu_offset_and_type
);
25518 /* Look up the type for the die at SECT_OFF in PER_CU in die_type_hash,
25519 or return NULL if the die does not have a saved type. */
25521 static struct type
*
25522 get_die_type_at_offset (sect_offset sect_off
,
25523 struct dwarf2_per_cu_data
*per_cu
)
25525 struct dwarf2_per_cu_offset_and_type
*slot
, ofs
;
25526 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
25528 if (dwarf2_per_objfile
->die_type_hash
== NULL
)
25531 ofs
.per_cu
= per_cu
;
25532 ofs
.sect_off
= sect_off
;
25533 slot
= ((struct dwarf2_per_cu_offset_and_type
*)
25534 htab_find (dwarf2_per_objfile
->die_type_hash
, &ofs
));
25541 /* Look up the type for DIE in CU in die_type_hash,
25542 or return NULL if DIE does not have a saved type. */
25544 static struct type
*
25545 get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
25547 return get_die_type_at_offset (die
->sect_off
, cu
->per_cu
);
25550 /* Add a dependence relationship from CU to REF_PER_CU. */
25553 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
25554 struct dwarf2_per_cu_data
*ref_per_cu
)
25558 if (cu
->dependencies
== NULL
)
25560 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
25561 NULL
, &cu
->comp_unit_obstack
,
25562 hashtab_obstack_allocate
,
25563 dummy_obstack_deallocate
);
25565 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
25567 *slot
= ref_per_cu
;
25570 /* Subroutine of dwarf2_mark to pass to htab_traverse.
25571 Set the mark field in every compilation unit in the
25572 cache that we must keep because we are keeping CU. */
25575 dwarf2_mark_helper (void **slot
, void *data
)
25577 struct dwarf2_per_cu_data
*per_cu
;
25579 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
25581 /* cu->dependencies references may not yet have been ever read if QUIT aborts
25582 reading of the chain. As such dependencies remain valid it is not much
25583 useful to track and undo them during QUIT cleanups. */
25584 if (per_cu
->cu
== NULL
)
25587 if (per_cu
->cu
->mark
)
25589 per_cu
->cu
->mark
= 1;
25591 if (per_cu
->cu
->dependencies
!= NULL
)
25592 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
25597 /* Set the mark field in CU and in every other compilation unit in the
25598 cache that we must keep because we are keeping CU. */
25601 dwarf2_mark (struct dwarf2_cu
*cu
)
25606 if (cu
->dependencies
!= NULL
)
25607 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
25611 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
25615 per_cu
->cu
->mark
= 0;
25616 per_cu
= per_cu
->cu
->read_in_chain
;
25620 /* Trivial hash function for partial_die_info: the hash value of a DIE
25621 is its offset in .debug_info for this objfile. */
25624 partial_die_hash (const void *item
)
25626 const struct partial_die_info
*part_die
25627 = (const struct partial_die_info
*) item
;
25629 return to_underlying (part_die
->sect_off
);
25632 /* Trivial comparison function for partial_die_info structures: two DIEs
25633 are equal if they have the same offset. */
25636 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
25638 const struct partial_die_info
*part_die_lhs
25639 = (const struct partial_die_info
*) item_lhs
;
25640 const struct partial_die_info
*part_die_rhs
25641 = (const struct partial_die_info
*) item_rhs
;
25643 return part_die_lhs
->sect_off
== part_die_rhs
->sect_off
;
25646 static struct cmd_list_element
*set_dwarf_cmdlist
;
25647 static struct cmd_list_element
*show_dwarf_cmdlist
;
25650 set_dwarf_cmd (const char *args
, int from_tty
)
25652 help_list (set_dwarf_cmdlist
, "maintenance set dwarf ", all_commands
,
25657 show_dwarf_cmd (const char *args
, int from_tty
)
25659 cmd_show_list (show_dwarf_cmdlist
, from_tty
, "");
25662 /* Free data associated with OBJFILE, if necessary. */
25665 dwarf2_per_objfile_free (struct objfile
*objfile
, void *d
)
25667 struct dwarf2_per_objfile
*data
= (struct dwarf2_per_objfile
*) d
;
25670 for (ix
= 0; ix
< data
->n_comp_units
; ++ix
)
25671 VEC_free (dwarf2_per_cu_ptr
, data
->all_comp_units
[ix
]->imported_symtabs
);
25673 for (ix
= 0; ix
< data
->n_type_units
; ++ix
)
25674 VEC_free (dwarf2_per_cu_ptr
,
25675 data
->all_type_units
[ix
]->per_cu
.imported_symtabs
);
25676 xfree (data
->all_type_units
);
25678 VEC_free (dwarf2_section_info_def
, data
->types
);
25680 if (data
->dwo_files
)
25681 free_dwo_files (data
->dwo_files
, objfile
);
25682 if (data
->dwp_file
)
25683 gdb_bfd_unref (data
->dwp_file
->dbfd
);
25685 if (data
->dwz_file
&& data
->dwz_file
->dwz_bfd
)
25686 gdb_bfd_unref (data
->dwz_file
->dwz_bfd
);
25688 if (data
->index_table
!= NULL
)
25689 data
->index_table
->~mapped_index ();
25693 /* The "save gdb-index" command. */
25695 /* Write SIZE bytes from the buffer pointed to by DATA to FILE, with
25699 file_write (FILE *file
, const void *data
, size_t size
)
25701 if (fwrite (data
, 1, size
, file
) != size
)
25702 error (_("couldn't data write to file"));
25705 /* Write the contents of VEC to FILE, with error checking. */
25707 template<typename Elem
, typename Alloc
>
25709 file_write (FILE *file
, const std::vector
<Elem
, Alloc
> &vec
)
25711 file_write (file
, vec
.data (), vec
.size () * sizeof (vec
[0]));
25714 /* In-memory buffer to prepare data to be written later to a file. */
25718 /* Copy DATA to the end of the buffer. */
25719 template<typename T
>
25720 void append_data (const T
&data
)
25722 std::copy (reinterpret_cast<const gdb_byte
*> (&data
),
25723 reinterpret_cast<const gdb_byte
*> (&data
+ 1),
25724 grow (sizeof (data
)));
25727 /* Copy CSTR (a zero-terminated string) to the end of buffer. The
25728 terminating zero is appended too. */
25729 void append_cstr0 (const char *cstr
)
25731 const size_t size
= strlen (cstr
) + 1;
25732 std::copy (cstr
, cstr
+ size
, grow (size
));
25735 /* Store INPUT as ULEB128 to the end of buffer. */
25736 void append_unsigned_leb128 (ULONGEST input
)
25740 gdb_byte output
= input
& 0x7f;
25744 append_data (output
);
25750 /* Accept a host-format integer in VAL and append it to the buffer
25751 as a target-format integer which is LEN bytes long. */
25752 void append_uint (size_t len
, bfd_endian byte_order
, ULONGEST val
)
25754 ::store_unsigned_integer (grow (len
), len
, byte_order
, val
);
25757 /* Return the size of the buffer. */
25758 size_t size () const
25760 return m_vec
.size ();
25763 /* Return true iff the buffer is empty. */
25764 bool empty () const
25766 return m_vec
.empty ();
25769 /* Write the buffer to FILE. */
25770 void file_write (FILE *file
) const
25772 ::file_write (file
, m_vec
);
25776 /* Grow SIZE bytes at the end of the buffer. Returns a pointer to
25777 the start of the new block. */
25778 gdb_byte
*grow (size_t size
)
25780 m_vec
.resize (m_vec
.size () + size
);
25781 return &*m_vec
.end () - size
;
25784 gdb::byte_vector m_vec
;
25787 /* An entry in the symbol table. */
25788 struct symtab_index_entry
25790 /* The name of the symbol. */
25792 /* The offset of the name in the constant pool. */
25793 offset_type index_offset
;
25794 /* A sorted vector of the indices of all the CUs that hold an object
25796 std::vector
<offset_type
> cu_indices
;
25799 /* The symbol table. This is a power-of-2-sized hash table. */
25800 struct mapped_symtab
25804 data
.resize (1024);
25807 offset_type n_elements
= 0;
25808 std::vector
<symtab_index_entry
> data
;
25811 /* Find a slot in SYMTAB for the symbol NAME. Returns a reference to
25814 Function is used only during write_hash_table so no index format backward
25815 compatibility is needed. */
25817 static symtab_index_entry
&
25818 find_slot (struct mapped_symtab
*symtab
, const char *name
)
25820 offset_type index
, step
, hash
= mapped_index_string_hash (INT_MAX
, name
);
25822 index
= hash
& (symtab
->data
.size () - 1);
25823 step
= ((hash
* 17) & (symtab
->data
.size () - 1)) | 1;
25827 if (symtab
->data
[index
].name
== NULL
25828 || strcmp (name
, symtab
->data
[index
].name
) == 0)
25829 return symtab
->data
[index
];
25830 index
= (index
+ step
) & (symtab
->data
.size () - 1);
25834 /* Expand SYMTAB's hash table. */
25837 hash_expand (struct mapped_symtab
*symtab
)
25839 auto old_entries
= std::move (symtab
->data
);
25841 symtab
->data
.clear ();
25842 symtab
->data
.resize (old_entries
.size () * 2);
25844 for (auto &it
: old_entries
)
25845 if (it
.name
!= NULL
)
25847 auto &ref
= find_slot (symtab
, it
.name
);
25848 ref
= std::move (it
);
25852 /* Add an entry to SYMTAB. NAME is the name of the symbol.
25853 CU_INDEX is the index of the CU in which the symbol appears.
25854 IS_STATIC is one if the symbol is static, otherwise zero (global). */
25857 add_index_entry (struct mapped_symtab
*symtab
, const char *name
,
25858 int is_static
, gdb_index_symbol_kind kind
,
25859 offset_type cu_index
)
25861 offset_type cu_index_and_attrs
;
25863 ++symtab
->n_elements
;
25864 if (4 * symtab
->n_elements
/ 3 >= symtab
->data
.size ())
25865 hash_expand (symtab
);
25867 symtab_index_entry
&slot
= find_slot (symtab
, name
);
25868 if (slot
.name
== NULL
)
25871 /* index_offset is set later. */
25874 cu_index_and_attrs
= 0;
25875 DW2_GDB_INDEX_CU_SET_VALUE (cu_index_and_attrs
, cu_index
);
25876 DW2_GDB_INDEX_SYMBOL_STATIC_SET_VALUE (cu_index_and_attrs
, is_static
);
25877 DW2_GDB_INDEX_SYMBOL_KIND_SET_VALUE (cu_index_and_attrs
, kind
);
25879 /* We don't want to record an index value twice as we want to avoid the
25881 We process all global symbols and then all static symbols
25882 (which would allow us to avoid the duplication by only having to check
25883 the last entry pushed), but a symbol could have multiple kinds in one CU.
25884 To keep things simple we don't worry about the duplication here and
25885 sort and uniqufy the list after we've processed all symbols. */
25886 slot
.cu_indices
.push_back (cu_index_and_attrs
);
25889 /* Sort and remove duplicates of all symbols' cu_indices lists. */
25892 uniquify_cu_indices (struct mapped_symtab
*symtab
)
25894 for (auto &entry
: symtab
->data
)
25896 if (entry
.name
!= NULL
&& !entry
.cu_indices
.empty ())
25898 auto &cu_indices
= entry
.cu_indices
;
25899 std::sort (cu_indices
.begin (), cu_indices
.end ());
25900 auto from
= std::unique (cu_indices
.begin (), cu_indices
.end ());
25901 cu_indices
.erase (from
, cu_indices
.end ());
25906 /* A form of 'const char *' suitable for container keys. Only the
25907 pointer is stored. The strings themselves are compared, not the
25912 c_str_view (const char *cstr
)
25916 bool operator== (const c_str_view
&other
) const
25918 return strcmp (m_cstr
, other
.m_cstr
) == 0;
25921 /* Return the underlying C string. Note, the returned string is
25922 only a reference with lifetime of this object. */
25923 const char *c_str () const
25929 friend class c_str_view_hasher
;
25930 const char *const m_cstr
;
25933 /* A std::unordered_map::hasher for c_str_view that uses the right
25934 hash function for strings in a mapped index. */
25935 class c_str_view_hasher
25938 size_t operator () (const c_str_view
&x
) const
25940 return mapped_index_string_hash (INT_MAX
, x
.m_cstr
);
25944 /* A std::unordered_map::hasher for std::vector<>. */
25945 template<typename T
>
25946 class vector_hasher
25949 size_t operator () (const std::vector
<T
> &key
) const
25951 return iterative_hash (key
.data (),
25952 sizeof (key
.front ()) * key
.size (), 0);
25956 /* Write the mapped hash table SYMTAB to the data buffer OUTPUT, with
25957 constant pool entries going into the data buffer CPOOL. */
25960 write_hash_table (mapped_symtab
*symtab
, data_buf
&output
, data_buf
&cpool
)
25963 /* Elements are sorted vectors of the indices of all the CUs that
25964 hold an object of this name. */
25965 std::unordered_map
<std::vector
<offset_type
>, offset_type
,
25966 vector_hasher
<offset_type
>>
25969 /* We add all the index vectors to the constant pool first, to
25970 ensure alignment is ok. */
25971 for (symtab_index_entry
&entry
: symtab
->data
)
25973 if (entry
.name
== NULL
)
25975 gdb_assert (entry
.index_offset
== 0);
25977 /* Finding before inserting is faster than always trying to
25978 insert, because inserting always allocates a node, does the
25979 lookup, and then destroys the new node if another node
25980 already had the same key. C++17 try_emplace will avoid
25983 = symbol_hash_table
.find (entry
.cu_indices
);
25984 if (found
!= symbol_hash_table
.end ())
25986 entry
.index_offset
= found
->second
;
25990 symbol_hash_table
.emplace (entry
.cu_indices
, cpool
.size ());
25991 entry
.index_offset
= cpool
.size ();
25992 cpool
.append_data (MAYBE_SWAP (entry
.cu_indices
.size ()));
25993 for (const auto index
: entry
.cu_indices
)
25994 cpool
.append_data (MAYBE_SWAP (index
));
25998 /* Now write out the hash table. */
25999 std::unordered_map
<c_str_view
, offset_type
, c_str_view_hasher
> str_table
;
26000 for (const auto &entry
: symtab
->data
)
26002 offset_type str_off
, vec_off
;
26004 if (entry
.name
!= NULL
)
26006 const auto insertpair
= str_table
.emplace (entry
.name
, cpool
.size ());
26007 if (insertpair
.second
)
26008 cpool
.append_cstr0 (entry
.name
);
26009 str_off
= insertpair
.first
->second
;
26010 vec_off
= entry
.index_offset
;
26014 /* While 0 is a valid constant pool index, it is not valid
26015 to have 0 for both offsets. */
26020 output
.append_data (MAYBE_SWAP (str_off
));
26021 output
.append_data (MAYBE_SWAP (vec_off
));
26025 typedef std::unordered_map
<partial_symtab
*, unsigned int> psym_index_map
;
26027 /* Helper struct for building the address table. */
26028 struct addrmap_index_data
26030 addrmap_index_data (data_buf
&addr_vec_
, psym_index_map
&cu_index_htab_
)
26031 : addr_vec (addr_vec_
), cu_index_htab (cu_index_htab_
)
26034 struct objfile
*objfile
;
26035 data_buf
&addr_vec
;
26036 psym_index_map
&cu_index_htab
;
26038 /* Non-zero if the previous_* fields are valid.
26039 We can't write an entry until we see the next entry (since it is only then
26040 that we know the end of the entry). */
26041 int previous_valid
;
26042 /* Index of the CU in the table of all CUs in the index file. */
26043 unsigned int previous_cu_index
;
26044 /* Start address of the CU. */
26045 CORE_ADDR previous_cu_start
;
26048 /* Write an address entry to ADDR_VEC. */
26051 add_address_entry (struct objfile
*objfile
, data_buf
&addr_vec
,
26052 CORE_ADDR start
, CORE_ADDR end
, unsigned int cu_index
)
26054 CORE_ADDR baseaddr
;
26056 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
26058 addr_vec
.append_uint (8, BFD_ENDIAN_LITTLE
, start
- baseaddr
);
26059 addr_vec
.append_uint (8, BFD_ENDIAN_LITTLE
, end
- baseaddr
);
26060 addr_vec
.append_data (MAYBE_SWAP (cu_index
));
26063 /* Worker function for traversing an addrmap to build the address table. */
26066 add_address_entry_worker (void *datap
, CORE_ADDR start_addr
, void *obj
)
26068 struct addrmap_index_data
*data
= (struct addrmap_index_data
*) datap
;
26069 struct partial_symtab
*pst
= (struct partial_symtab
*) obj
;
26071 if (data
->previous_valid
)
26072 add_address_entry (data
->objfile
, data
->addr_vec
,
26073 data
->previous_cu_start
, start_addr
,
26074 data
->previous_cu_index
);
26076 data
->previous_cu_start
= start_addr
;
26079 const auto it
= data
->cu_index_htab
.find (pst
);
26080 gdb_assert (it
!= data
->cu_index_htab
.cend ());
26081 data
->previous_cu_index
= it
->second
;
26082 data
->previous_valid
= 1;
26085 data
->previous_valid
= 0;
26090 /* Write OBJFILE's address map to ADDR_VEC.
26091 CU_INDEX_HTAB is used to map addrmap entries to their CU indices
26092 in the index file. */
26095 write_address_map (struct objfile
*objfile
, data_buf
&addr_vec
,
26096 psym_index_map
&cu_index_htab
)
26098 struct addrmap_index_data
addrmap_index_data (addr_vec
, cu_index_htab
);
26100 /* When writing the address table, we have to cope with the fact that
26101 the addrmap iterator only provides the start of a region; we have to
26102 wait until the next invocation to get the start of the next region. */
26104 addrmap_index_data
.objfile
= objfile
;
26105 addrmap_index_data
.previous_valid
= 0;
26107 addrmap_foreach (objfile
->psymtabs_addrmap
, add_address_entry_worker
,
26108 &addrmap_index_data
);
26110 /* It's highly unlikely the last entry (end address = 0xff...ff)
26111 is valid, but we should still handle it.
26112 The end address is recorded as the start of the next region, but that
26113 doesn't work here. To cope we pass 0xff...ff, this is a rare situation
26115 if (addrmap_index_data
.previous_valid
)
26116 add_address_entry (objfile
, addr_vec
,
26117 addrmap_index_data
.previous_cu_start
, (CORE_ADDR
) -1,
26118 addrmap_index_data
.previous_cu_index
);
26121 /* Return the symbol kind of PSYM. */
26123 static gdb_index_symbol_kind
26124 symbol_kind (struct partial_symbol
*psym
)
26126 domain_enum domain
= PSYMBOL_DOMAIN (psym
);
26127 enum address_class aclass
= PSYMBOL_CLASS (psym
);
26135 return GDB_INDEX_SYMBOL_KIND_FUNCTION
;
26137 return GDB_INDEX_SYMBOL_KIND_TYPE
;
26139 case LOC_CONST_BYTES
:
26140 case LOC_OPTIMIZED_OUT
:
26142 return GDB_INDEX_SYMBOL_KIND_VARIABLE
;
26144 /* Note: It's currently impossible to recognize psyms as enum values
26145 short of reading the type info. For now punt. */
26146 return GDB_INDEX_SYMBOL_KIND_VARIABLE
;
26148 /* There are other LOC_FOO values that one might want to classify
26149 as variables, but dwarf2read.c doesn't currently use them. */
26150 return GDB_INDEX_SYMBOL_KIND_OTHER
;
26152 case STRUCT_DOMAIN
:
26153 return GDB_INDEX_SYMBOL_KIND_TYPE
;
26155 return GDB_INDEX_SYMBOL_KIND_OTHER
;
26159 /* Add a list of partial symbols to SYMTAB. */
26162 write_psymbols (struct mapped_symtab
*symtab
,
26163 std::unordered_set
<partial_symbol
*> &psyms_seen
,
26164 struct partial_symbol
**psymp
,
26166 offset_type cu_index
,
26169 for (; count
-- > 0; ++psymp
)
26171 struct partial_symbol
*psym
= *psymp
;
26173 if (SYMBOL_LANGUAGE (psym
) == language_ada
)
26174 error (_("Ada is not currently supported by the index"));
26176 /* Only add a given psymbol once. */
26177 if (psyms_seen
.insert (psym
).second
)
26179 gdb_index_symbol_kind kind
= symbol_kind (psym
);
26181 add_index_entry (symtab
, SYMBOL_SEARCH_NAME (psym
),
26182 is_static
, kind
, cu_index
);
26187 /* A helper struct used when iterating over debug_types. */
26188 struct signatured_type_index_data
26190 signatured_type_index_data (data_buf
&types_list_
,
26191 std::unordered_set
<partial_symbol
*> &psyms_seen_
)
26192 : types_list (types_list_
), psyms_seen (psyms_seen_
)
26195 struct objfile
*objfile
;
26196 struct mapped_symtab
*symtab
;
26197 data_buf
&types_list
;
26198 std::unordered_set
<partial_symbol
*> &psyms_seen
;
26202 /* A helper function that writes a single signatured_type to an
26206 write_one_signatured_type (void **slot
, void *d
)
26208 struct signatured_type_index_data
*info
26209 = (struct signatured_type_index_data
*) d
;
26210 struct signatured_type
*entry
= (struct signatured_type
*) *slot
;
26211 struct partial_symtab
*psymtab
= entry
->per_cu
.v
.psymtab
;
26213 write_psymbols (info
->symtab
,
26215 &info
->objfile
->global_psymbols
[psymtab
->globals_offset
],
26216 psymtab
->n_global_syms
, info
->cu_index
,
26218 write_psymbols (info
->symtab
,
26220 &info
->objfile
->static_psymbols
[psymtab
->statics_offset
],
26221 psymtab
->n_static_syms
, info
->cu_index
,
26224 info
->types_list
.append_uint (8, BFD_ENDIAN_LITTLE
,
26225 to_underlying (entry
->per_cu
.sect_off
));
26226 info
->types_list
.append_uint (8, BFD_ENDIAN_LITTLE
,
26227 to_underlying (entry
->type_offset_in_tu
));
26228 info
->types_list
.append_uint (8, BFD_ENDIAN_LITTLE
, entry
->signature
);
26235 /* Recurse into all "included" dependencies and count their symbols as
26236 if they appeared in this psymtab. */
26239 recursively_count_psymbols (struct partial_symtab
*psymtab
,
26240 size_t &psyms_seen
)
26242 for (int i
= 0; i
< psymtab
->number_of_dependencies
; ++i
)
26243 if (psymtab
->dependencies
[i
]->user
!= NULL
)
26244 recursively_count_psymbols (psymtab
->dependencies
[i
],
26247 psyms_seen
+= psymtab
->n_global_syms
;
26248 psyms_seen
+= psymtab
->n_static_syms
;
26251 /* Recurse into all "included" dependencies and write their symbols as
26252 if they appeared in this psymtab. */
26255 recursively_write_psymbols (struct objfile
*objfile
,
26256 struct partial_symtab
*psymtab
,
26257 struct mapped_symtab
*symtab
,
26258 std::unordered_set
<partial_symbol
*> &psyms_seen
,
26259 offset_type cu_index
)
26263 for (i
= 0; i
< psymtab
->number_of_dependencies
; ++i
)
26264 if (psymtab
->dependencies
[i
]->user
!= NULL
)
26265 recursively_write_psymbols (objfile
, psymtab
->dependencies
[i
],
26266 symtab
, psyms_seen
, cu_index
);
26268 write_psymbols (symtab
,
26270 &objfile
->global_psymbols
[psymtab
->globals_offset
],
26271 psymtab
->n_global_syms
, cu_index
,
26273 write_psymbols (symtab
,
26275 &objfile
->static_psymbols
[psymtab
->statics_offset
],
26276 psymtab
->n_static_syms
, cu_index
,
26280 /* DWARF-5 .debug_names builder. */
26284 debug_names (struct dwarf2_per_objfile
*dwarf2_per_objfile
, bool is_dwarf64
,
26285 bfd_endian dwarf5_byte_order
)
26286 : m_dwarf5_byte_order (dwarf5_byte_order
),
26287 m_dwarf32 (dwarf5_byte_order
),
26288 m_dwarf64 (dwarf5_byte_order
),
26289 m_dwarf (is_dwarf64
26290 ? static_cast<dwarf
&> (m_dwarf64
)
26291 : static_cast<dwarf
&> (m_dwarf32
)),
26292 m_name_table_string_offs (m_dwarf
.name_table_string_offs
),
26293 m_name_table_entry_offs (m_dwarf
.name_table_entry_offs
),
26294 m_debugstrlookup (dwarf2_per_objfile
)
26297 int dwarf5_offset_size () const
26299 const bool dwarf5_is_dwarf64
= &m_dwarf
== &m_dwarf64
;
26300 return dwarf5_is_dwarf64
? 8 : 4;
26303 /* Is this symbol from DW_TAG_compile_unit or DW_TAG_type_unit? */
26304 enum class unit_kind
{ cu
, tu
};
26306 /* Insert one symbol. */
26307 void insert (const partial_symbol
*psym
, int cu_index
, bool is_static
,
26310 const int dwarf_tag
= psymbol_tag (psym
);
26311 if (dwarf_tag
== 0)
26313 const char *const name
= SYMBOL_SEARCH_NAME (psym
);
26314 const auto insertpair
26315 = m_name_to_value_set
.emplace (c_str_view (name
),
26316 std::set
<symbol_value
> ());
26317 std::set
<symbol_value
> &value_set
= insertpair
.first
->second
;
26318 value_set
.emplace (symbol_value (dwarf_tag
, cu_index
, is_static
, kind
));
26321 /* Build all the tables. All symbols must be already inserted.
26322 This function does not call file_write, caller has to do it
26326 /* Verify the build method has not be called twice. */
26327 gdb_assert (m_abbrev_table
.empty ());
26328 const size_t name_count
= m_name_to_value_set
.size ();
26329 m_bucket_table
.resize
26330 (std::pow (2, std::ceil (std::log2 (name_count
* 4 / 3))));
26331 m_hash_table
.reserve (name_count
);
26332 m_name_table_string_offs
.reserve (name_count
);
26333 m_name_table_entry_offs
.reserve (name_count
);
26335 /* Map each hash of symbol to its name and value. */
26336 struct hash_it_pair
26339 decltype (m_name_to_value_set
)::const_iterator it
;
26341 std::vector
<std::forward_list
<hash_it_pair
>> bucket_hash
;
26342 bucket_hash
.resize (m_bucket_table
.size ());
26343 for (decltype (m_name_to_value_set
)::const_iterator it
26344 = m_name_to_value_set
.cbegin ();
26345 it
!= m_name_to_value_set
.cend ();
26348 const char *const name
= it
->first
.c_str ();
26349 const uint32_t hash
= dwarf5_djb_hash (name
);
26350 hash_it_pair hashitpair
;
26351 hashitpair
.hash
= hash
;
26352 hashitpair
.it
= it
;
26353 auto &slot
= bucket_hash
[hash
% bucket_hash
.size()];
26354 slot
.push_front (std::move (hashitpair
));
26356 for (size_t bucket_ix
= 0; bucket_ix
< bucket_hash
.size (); ++bucket_ix
)
26358 const std::forward_list
<hash_it_pair
> &hashitlist
26359 = bucket_hash
[bucket_ix
];
26360 if (hashitlist
.empty ())
26362 uint32_t &bucket_slot
= m_bucket_table
[bucket_ix
];
26363 /* The hashes array is indexed starting at 1. */
26364 store_unsigned_integer (reinterpret_cast<gdb_byte
*> (&bucket_slot
),
26365 sizeof (bucket_slot
), m_dwarf5_byte_order
,
26366 m_hash_table
.size () + 1);
26367 for (const hash_it_pair
&hashitpair
: hashitlist
)
26369 m_hash_table
.push_back (0);
26370 store_unsigned_integer (reinterpret_cast<gdb_byte
*>
26371 (&m_hash_table
.back ()),
26372 sizeof (m_hash_table
.back ()),
26373 m_dwarf5_byte_order
, hashitpair
.hash
);
26374 const c_str_view
&name
= hashitpair
.it
->first
;
26375 const std::set
<symbol_value
> &value_set
= hashitpair
.it
->second
;
26376 m_name_table_string_offs
.push_back_reorder
26377 (m_debugstrlookup
.lookup (name
.c_str ()));
26378 m_name_table_entry_offs
.push_back_reorder (m_entry_pool
.size ());
26379 gdb_assert (!value_set
.empty ());
26380 for (const symbol_value
&value
: value_set
)
26382 int &idx
= m_indexkey_to_idx
[index_key (value
.dwarf_tag
,
26387 idx
= m_idx_next
++;
26388 m_abbrev_table
.append_unsigned_leb128 (idx
);
26389 m_abbrev_table
.append_unsigned_leb128 (value
.dwarf_tag
);
26390 m_abbrev_table
.append_unsigned_leb128
26391 (value
.kind
== unit_kind::cu
? DW_IDX_compile_unit
26392 : DW_IDX_type_unit
);
26393 m_abbrev_table
.append_unsigned_leb128 (DW_FORM_udata
);
26394 m_abbrev_table
.append_unsigned_leb128 (value
.is_static
26395 ? DW_IDX_GNU_internal
26396 : DW_IDX_GNU_external
);
26397 m_abbrev_table
.append_unsigned_leb128 (DW_FORM_flag_present
);
26399 /* Terminate attributes list. */
26400 m_abbrev_table
.append_unsigned_leb128 (0);
26401 m_abbrev_table
.append_unsigned_leb128 (0);
26404 m_entry_pool
.append_unsigned_leb128 (idx
);
26405 m_entry_pool
.append_unsigned_leb128 (value
.cu_index
);
26408 /* Terminate the list of CUs. */
26409 m_entry_pool
.append_unsigned_leb128 (0);
26412 gdb_assert (m_hash_table
.size () == name_count
);
26414 /* Terminate tags list. */
26415 m_abbrev_table
.append_unsigned_leb128 (0);
26418 /* Return .debug_names bucket count. This must be called only after
26419 calling the build method. */
26420 uint32_t bucket_count () const
26422 /* Verify the build method has been already called. */
26423 gdb_assert (!m_abbrev_table
.empty ());
26424 const uint32_t retval
= m_bucket_table
.size ();
26426 /* Check for overflow. */
26427 gdb_assert (retval
== m_bucket_table
.size ());
26431 /* Return .debug_names names count. This must be called only after
26432 calling the build method. */
26433 uint32_t name_count () const
26435 /* Verify the build method has been already called. */
26436 gdb_assert (!m_abbrev_table
.empty ());
26437 const uint32_t retval
= m_hash_table
.size ();
26439 /* Check for overflow. */
26440 gdb_assert (retval
== m_hash_table
.size ());
26444 /* Return number of bytes of .debug_names abbreviation table. This
26445 must be called only after calling the build method. */
26446 uint32_t abbrev_table_bytes () const
26448 gdb_assert (!m_abbrev_table
.empty ());
26449 return m_abbrev_table
.size ();
26452 /* Recurse into all "included" dependencies and store their symbols
26453 as if they appeared in this psymtab. */
26454 void recursively_write_psymbols
26455 (struct objfile
*objfile
,
26456 struct partial_symtab
*psymtab
,
26457 std::unordered_set
<partial_symbol
*> &psyms_seen
,
26460 for (int i
= 0; i
< psymtab
->number_of_dependencies
; ++i
)
26461 if (psymtab
->dependencies
[i
]->user
!= NULL
)
26462 recursively_write_psymbols (objfile
, psymtab
->dependencies
[i
],
26463 psyms_seen
, cu_index
);
26465 write_psymbols (psyms_seen
,
26466 &objfile
->global_psymbols
[psymtab
->globals_offset
],
26467 psymtab
->n_global_syms
, cu_index
, false, unit_kind::cu
);
26468 write_psymbols (psyms_seen
,
26469 &objfile
->static_psymbols
[psymtab
->statics_offset
],
26470 psymtab
->n_static_syms
, cu_index
, true, unit_kind::cu
);
26473 /* Return number of bytes the .debug_names section will have. This
26474 must be called only after calling the build method. */
26475 size_t bytes () const
26477 /* Verify the build method has been already called. */
26478 gdb_assert (!m_abbrev_table
.empty ());
26479 size_t expected_bytes
= 0;
26480 expected_bytes
+= m_bucket_table
.size () * sizeof (m_bucket_table
[0]);
26481 expected_bytes
+= m_hash_table
.size () * sizeof (m_hash_table
[0]);
26482 expected_bytes
+= m_name_table_string_offs
.bytes ();
26483 expected_bytes
+= m_name_table_entry_offs
.bytes ();
26484 expected_bytes
+= m_abbrev_table
.size ();
26485 expected_bytes
+= m_entry_pool
.size ();
26486 return expected_bytes
;
26489 /* Write .debug_names to FILE_NAMES and .debug_str addition to
26490 FILE_STR. This must be called only after calling the build
26492 void file_write (FILE *file_names
, FILE *file_str
) const
26494 /* Verify the build method has been already called. */
26495 gdb_assert (!m_abbrev_table
.empty ());
26496 ::file_write (file_names
, m_bucket_table
);
26497 ::file_write (file_names
, m_hash_table
);
26498 m_name_table_string_offs
.file_write (file_names
);
26499 m_name_table_entry_offs
.file_write (file_names
);
26500 m_abbrev_table
.file_write (file_names
);
26501 m_entry_pool
.file_write (file_names
);
26502 m_debugstrlookup
.file_write (file_str
);
26505 /* A helper user data for write_one_signatured_type. */
26506 class write_one_signatured_type_data
26509 write_one_signatured_type_data (debug_names
&nametable_
,
26510 signatured_type_index_data
&&info_
)
26511 : nametable (nametable_
), info (std::move (info_
))
26513 debug_names
&nametable
;
26514 struct signatured_type_index_data info
;
26517 /* A helper function to pass write_one_signatured_type to
26518 htab_traverse_noresize. */
26520 write_one_signatured_type (void **slot
, void *d
)
26522 write_one_signatured_type_data
*data
= (write_one_signatured_type_data
*) d
;
26523 struct signatured_type_index_data
*info
= &data
->info
;
26524 struct signatured_type
*entry
= (struct signatured_type
*) *slot
;
26526 data
->nametable
.write_one_signatured_type (entry
, info
);
26533 /* Storage for symbol names mapping them to their .debug_str section
26535 class debug_str_lookup
26539 /* Object costructor to be called for current DWARF2_PER_OBJFILE.
26540 All .debug_str section strings are automatically stored. */
26541 debug_str_lookup (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
26542 : m_abfd (dwarf2_per_objfile
->objfile
->obfd
),
26543 m_dwarf2_per_objfile (dwarf2_per_objfile
)
26545 dwarf2_read_section (dwarf2_per_objfile
->objfile
,
26546 &dwarf2_per_objfile
->str
);
26547 if (dwarf2_per_objfile
->str
.buffer
== NULL
)
26549 for (const gdb_byte
*data
= dwarf2_per_objfile
->str
.buffer
;
26550 data
< (dwarf2_per_objfile
->str
.buffer
26551 + dwarf2_per_objfile
->str
.size
);)
26553 const char *const s
= reinterpret_cast<const char *> (data
);
26554 const auto insertpair
26555 = m_str_table
.emplace (c_str_view (s
),
26556 data
- dwarf2_per_objfile
->str
.buffer
);
26557 if (!insertpair
.second
)
26558 complaint (&symfile_complaints
,
26559 _("Duplicate string \"%s\" in "
26560 ".debug_str section [in module %s]"),
26561 s
, bfd_get_filename (m_abfd
));
26562 data
+= strlen (s
) + 1;
26566 /* Return offset of symbol name S in the .debug_str section. Add
26567 such symbol to the section's end if it does not exist there
26569 size_t lookup (const char *s
)
26571 const auto it
= m_str_table
.find (c_str_view (s
));
26572 if (it
!= m_str_table
.end ())
26574 const size_t offset
= (m_dwarf2_per_objfile
->str
.size
26575 + m_str_add_buf
.size ());
26576 m_str_table
.emplace (c_str_view (s
), offset
);
26577 m_str_add_buf
.append_cstr0 (s
);
26581 /* Append the end of the .debug_str section to FILE. */
26582 void file_write (FILE *file
) const
26584 m_str_add_buf
.file_write (file
);
26588 std::unordered_map
<c_str_view
, size_t, c_str_view_hasher
> m_str_table
;
26590 struct dwarf2_per_objfile
*m_dwarf2_per_objfile
;
26592 /* Data to add at the end of .debug_str for new needed symbol names. */
26593 data_buf m_str_add_buf
;
26596 /* Container to map used DWARF tags to their .debug_names abbreviation
26601 index_key (int dwarf_tag_
, bool is_static_
, unit_kind kind_
)
26602 : dwarf_tag (dwarf_tag_
), is_static (is_static_
), kind (kind_
)
26607 operator== (const index_key
&other
) const
26609 return (dwarf_tag
== other
.dwarf_tag
&& is_static
== other
.is_static
26610 && kind
== other
.kind
);
26613 const int dwarf_tag
;
26614 const bool is_static
;
26615 const unit_kind kind
;
26618 /* Provide std::unordered_map::hasher for index_key. */
26619 class index_key_hasher
26623 operator () (const index_key
&key
) const
26625 return (std::hash
<int>() (key
.dwarf_tag
) << 1) | key
.is_static
;
26629 /* Parameters of one symbol entry. */
26633 const int dwarf_tag
, cu_index
;
26634 const bool is_static
;
26635 const unit_kind kind
;
26637 symbol_value (int dwarf_tag_
, int cu_index_
, bool is_static_
,
26639 : dwarf_tag (dwarf_tag_
), cu_index (cu_index_
), is_static (is_static_
),
26644 operator< (const symbol_value
&other
) const
26664 /* Abstract base class to unify DWARF-32 and DWARF-64 name table
26669 const bfd_endian dwarf5_byte_order
;
26671 explicit offset_vec (bfd_endian dwarf5_byte_order_
)
26672 : dwarf5_byte_order (dwarf5_byte_order_
)
26675 /* Call std::vector::reserve for NELEM elements. */
26676 virtual void reserve (size_t nelem
) = 0;
26678 /* Call std::vector::push_back with store_unsigned_integer byte
26679 reordering for ELEM. */
26680 virtual void push_back_reorder (size_t elem
) = 0;
26682 /* Return expected output size in bytes. */
26683 virtual size_t bytes () const = 0;
26685 /* Write name table to FILE. */
26686 virtual void file_write (FILE *file
) const = 0;
26689 /* Template to unify DWARF-32 and DWARF-64 output. */
26690 template<typename OffsetSize
>
26691 class offset_vec_tmpl
: public offset_vec
26694 explicit offset_vec_tmpl (bfd_endian dwarf5_byte_order_
)
26695 : offset_vec (dwarf5_byte_order_
)
26698 /* Implement offset_vec::reserve. */
26699 void reserve (size_t nelem
) override
26701 m_vec
.reserve (nelem
);
26704 /* Implement offset_vec::push_back_reorder. */
26705 void push_back_reorder (size_t elem
) override
26707 m_vec
.push_back (elem
);
26708 /* Check for overflow. */
26709 gdb_assert (m_vec
.back () == elem
);
26710 store_unsigned_integer (reinterpret_cast<gdb_byte
*> (&m_vec
.back ()),
26711 sizeof (m_vec
.back ()), dwarf5_byte_order
, elem
);
26714 /* Implement offset_vec::bytes. */
26715 size_t bytes () const override
26717 return m_vec
.size () * sizeof (m_vec
[0]);
26720 /* Implement offset_vec::file_write. */
26721 void file_write (FILE *file
) const override
26723 ::file_write (file
, m_vec
);
26727 std::vector
<OffsetSize
> m_vec
;
26730 /* Base class to unify DWARF-32 and DWARF-64 .debug_names output
26731 respecting name table width. */
26735 offset_vec
&name_table_string_offs
, &name_table_entry_offs
;
26737 dwarf (offset_vec
&name_table_string_offs_
,
26738 offset_vec
&name_table_entry_offs_
)
26739 : name_table_string_offs (name_table_string_offs_
),
26740 name_table_entry_offs (name_table_entry_offs_
)
26745 /* Template to unify DWARF-32 and DWARF-64 .debug_names output
26746 respecting name table width. */
26747 template<typename OffsetSize
>
26748 class dwarf_tmpl
: public dwarf
26751 explicit dwarf_tmpl (bfd_endian dwarf5_byte_order_
)
26752 : dwarf (m_name_table_string_offs
, m_name_table_entry_offs
),
26753 m_name_table_string_offs (dwarf5_byte_order_
),
26754 m_name_table_entry_offs (dwarf5_byte_order_
)
26758 offset_vec_tmpl
<OffsetSize
> m_name_table_string_offs
;
26759 offset_vec_tmpl
<OffsetSize
> m_name_table_entry_offs
;
26762 /* Try to reconstruct original DWARF tag for given partial_symbol.
26763 This function is not DWARF-5 compliant but it is sufficient for
26764 GDB as a DWARF-5 index consumer. */
26765 static int psymbol_tag (const struct partial_symbol
*psym
)
26767 domain_enum domain
= PSYMBOL_DOMAIN (psym
);
26768 enum address_class aclass
= PSYMBOL_CLASS (psym
);
26776 return DW_TAG_subprogram
;
26778 return DW_TAG_typedef
;
26780 case LOC_CONST_BYTES
:
26781 case LOC_OPTIMIZED_OUT
:
26783 return DW_TAG_variable
;
26785 /* Note: It's currently impossible to recognize psyms as enum values
26786 short of reading the type info. For now punt. */
26787 return DW_TAG_variable
;
26789 /* There are other LOC_FOO values that one might want to classify
26790 as variables, but dwarf2read.c doesn't currently use them. */
26791 return DW_TAG_variable
;
26793 case STRUCT_DOMAIN
:
26794 return DW_TAG_structure_type
;
26800 /* Call insert for all partial symbols and mark them in PSYMS_SEEN. */
26801 void write_psymbols (std::unordered_set
<partial_symbol
*> &psyms_seen
,
26802 struct partial_symbol
**psymp
, int count
, int cu_index
,
26803 bool is_static
, unit_kind kind
)
26805 for (; count
-- > 0; ++psymp
)
26807 struct partial_symbol
*psym
= *psymp
;
26809 if (SYMBOL_LANGUAGE (psym
) == language_ada
)
26810 error (_("Ada is not currently supported by the index"));
26812 /* Only add a given psymbol once. */
26813 if (psyms_seen
.insert (psym
).second
)
26814 insert (psym
, cu_index
, is_static
, kind
);
26818 /* A helper function that writes a single signatured_type
26819 to a debug_names. */
26821 write_one_signatured_type (struct signatured_type
*entry
,
26822 struct signatured_type_index_data
*info
)
26824 struct partial_symtab
*psymtab
= entry
->per_cu
.v
.psymtab
;
26826 write_psymbols (info
->psyms_seen
,
26827 &info
->objfile
->global_psymbols
[psymtab
->globals_offset
],
26828 psymtab
->n_global_syms
, info
->cu_index
, false,
26830 write_psymbols (info
->psyms_seen
,
26831 &info
->objfile
->static_psymbols
[psymtab
->statics_offset
],
26832 psymtab
->n_static_syms
, info
->cu_index
, true,
26835 info
->types_list
.append_uint (dwarf5_offset_size (), m_dwarf5_byte_order
,
26836 to_underlying (entry
->per_cu
.sect_off
));
26841 /* Store value of each symbol. */
26842 std::unordered_map
<c_str_view
, std::set
<symbol_value
>, c_str_view_hasher
>
26843 m_name_to_value_set
;
26845 /* Tables of DWARF-5 .debug_names. They are in object file byte
26847 std::vector
<uint32_t> m_bucket_table
;
26848 std::vector
<uint32_t> m_hash_table
;
26850 const bfd_endian m_dwarf5_byte_order
;
26851 dwarf_tmpl
<uint32_t> m_dwarf32
;
26852 dwarf_tmpl
<uint64_t> m_dwarf64
;
26854 offset_vec
&m_name_table_string_offs
, &m_name_table_entry_offs
;
26855 debug_str_lookup m_debugstrlookup
;
26857 /* Map each used .debug_names abbreviation tag parameter to its
26859 std::unordered_map
<index_key
, int, index_key_hasher
> m_indexkey_to_idx
;
26861 /* Next unused .debug_names abbreviation tag for
26862 m_indexkey_to_idx. */
26863 int m_idx_next
= 1;
26865 /* .debug_names abbreviation table. */
26866 data_buf m_abbrev_table
;
26868 /* .debug_names entry pool. */
26869 data_buf m_entry_pool
;
26872 /* Return iff any of the needed offsets does not fit into 32-bit
26873 .debug_names section. */
26876 check_dwarf64_offsets (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
26878 for (int i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
26880 const dwarf2_per_cu_data
&per_cu
= *dwarf2_per_objfile
->all_comp_units
[i
];
26882 if (to_underlying (per_cu
.sect_off
) >= (static_cast<uint64_t> (1) << 32))
26885 for (int i
= 0; i
< dwarf2_per_objfile
->n_type_units
; ++i
)
26887 const signatured_type
&sigtype
= *dwarf2_per_objfile
->all_type_units
[i
];
26888 const dwarf2_per_cu_data
&per_cu
= sigtype
.per_cu
;
26890 if (to_underlying (per_cu
.sect_off
) >= (static_cast<uint64_t> (1) << 32))
26896 /* The psyms_seen set is potentially going to be largish (~40k
26897 elements when indexing a -g3 build of GDB itself). Estimate the
26898 number of elements in order to avoid too many rehashes, which
26899 require rebuilding buckets and thus many trips to
26903 psyms_seen_size (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
26905 size_t psyms_count
= 0;
26906 for (int i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
26908 struct dwarf2_per_cu_data
*per_cu
26909 = dwarf2_per_objfile
->all_comp_units
[i
];
26910 struct partial_symtab
*psymtab
= per_cu
->v
.psymtab
;
26912 if (psymtab
!= NULL
&& psymtab
->user
== NULL
)
26913 recursively_count_psymbols (psymtab
, psyms_count
);
26915 /* Generating an index for gdb itself shows a ratio of
26916 TOTAL_SEEN_SYMS/UNIQUE_SYMS or ~5. 4 seems like a good bet. */
26917 return psyms_count
/ 4;
26920 /* Write new .gdb_index section for OBJFILE into OUT_FILE.
26921 Return how many bytes were expected to be written into OUT_FILE. */
26924 write_gdbindex (struct dwarf2_per_objfile
*dwarf2_per_objfile
, FILE *out_file
)
26926 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
26927 mapped_symtab symtab
;
26930 /* While we're scanning CU's create a table that maps a psymtab pointer
26931 (which is what addrmap records) to its index (which is what is recorded
26932 in the index file). This will later be needed to write the address
26934 psym_index_map cu_index_htab
;
26935 cu_index_htab
.reserve (dwarf2_per_objfile
->n_comp_units
);
26937 /* The CU list is already sorted, so we don't need to do additional
26938 work here. Also, the debug_types entries do not appear in
26939 all_comp_units, but only in their own hash table. */
26941 std::unordered_set
<partial_symbol
*> psyms_seen
26942 (psyms_seen_size (dwarf2_per_objfile
));
26943 for (int i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
26945 struct dwarf2_per_cu_data
*per_cu
26946 = dwarf2_per_objfile
->all_comp_units
[i
];
26947 struct partial_symtab
*psymtab
= per_cu
->v
.psymtab
;
26949 /* CU of a shared file from 'dwz -m' may be unused by this main file.
26950 It may be referenced from a local scope but in such case it does not
26951 need to be present in .gdb_index. */
26952 if (psymtab
== NULL
)
26955 if (psymtab
->user
== NULL
)
26956 recursively_write_psymbols (objfile
, psymtab
, &symtab
,
26959 const auto insertpair
= cu_index_htab
.emplace (psymtab
, i
);
26960 gdb_assert (insertpair
.second
);
26962 cu_list
.append_uint (8, BFD_ENDIAN_LITTLE
,
26963 to_underlying (per_cu
->sect_off
));
26964 cu_list
.append_uint (8, BFD_ENDIAN_LITTLE
, per_cu
->length
);
26967 /* Dump the address map. */
26969 write_address_map (objfile
, addr_vec
, cu_index_htab
);
26971 /* Write out the .debug_type entries, if any. */
26972 data_buf types_cu_list
;
26973 if (dwarf2_per_objfile
->signatured_types
)
26975 signatured_type_index_data
sig_data (types_cu_list
,
26978 sig_data
.objfile
= objfile
;
26979 sig_data
.symtab
= &symtab
;
26980 sig_data
.cu_index
= dwarf2_per_objfile
->n_comp_units
;
26981 htab_traverse_noresize (dwarf2_per_objfile
->signatured_types
,
26982 write_one_signatured_type
, &sig_data
);
26985 /* Now that we've processed all symbols we can shrink their cu_indices
26987 uniquify_cu_indices (&symtab
);
26989 data_buf symtab_vec
, constant_pool
;
26990 write_hash_table (&symtab
, symtab_vec
, constant_pool
);
26993 const offset_type size_of_contents
= 6 * sizeof (offset_type
);
26994 offset_type total_len
= size_of_contents
;
26996 /* The version number. */
26997 contents
.append_data (MAYBE_SWAP (8));
26999 /* The offset of the CU list from the start of the file. */
27000 contents
.append_data (MAYBE_SWAP (total_len
));
27001 total_len
+= cu_list
.size ();
27003 /* The offset of the types CU list from the start of the file. */
27004 contents
.append_data (MAYBE_SWAP (total_len
));
27005 total_len
+= types_cu_list
.size ();
27007 /* The offset of the address table from the start of the file. */
27008 contents
.append_data (MAYBE_SWAP (total_len
));
27009 total_len
+= addr_vec
.size ();
27011 /* The offset of the symbol table from the start of the file. */
27012 contents
.append_data (MAYBE_SWAP (total_len
));
27013 total_len
+= symtab_vec
.size ();
27015 /* The offset of the constant pool from the start of the file. */
27016 contents
.append_data (MAYBE_SWAP (total_len
));
27017 total_len
+= constant_pool
.size ();
27019 gdb_assert (contents
.size () == size_of_contents
);
27021 contents
.file_write (out_file
);
27022 cu_list
.file_write (out_file
);
27023 types_cu_list
.file_write (out_file
);
27024 addr_vec
.file_write (out_file
);
27025 symtab_vec
.file_write (out_file
);
27026 constant_pool
.file_write (out_file
);
27031 /* DWARF-5 augmentation string for GDB's DW_IDX_GNU_* extension. */
27032 static const gdb_byte dwarf5_gdb_augmentation
[] = { 'G', 'D', 'B', 0 };
27034 /* Write a new .debug_names section for OBJFILE into OUT_FILE, write
27035 needed addition to .debug_str section to OUT_FILE_STR. Return how
27036 many bytes were expected to be written into OUT_FILE. */
27039 write_debug_names (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
27040 FILE *out_file
, FILE *out_file_str
)
27042 const bool dwarf5_is_dwarf64
= check_dwarf64_offsets (dwarf2_per_objfile
);
27043 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
27044 const enum bfd_endian dwarf5_byte_order
27045 = gdbarch_byte_order (get_objfile_arch (objfile
));
27047 /* The CU list is already sorted, so we don't need to do additional
27048 work here. Also, the debug_types entries do not appear in
27049 all_comp_units, but only in their own hash table. */
27051 debug_names
nametable (dwarf2_per_objfile
, dwarf5_is_dwarf64
,
27052 dwarf5_byte_order
);
27053 std::unordered_set
<partial_symbol
*>
27054 psyms_seen (psyms_seen_size (dwarf2_per_objfile
));
27055 for (int i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
27057 const dwarf2_per_cu_data
*per_cu
= dwarf2_per_objfile
->all_comp_units
[i
];
27058 partial_symtab
*psymtab
= per_cu
->v
.psymtab
;
27060 /* CU of a shared file from 'dwz -m' may be unused by this main
27061 file. It may be referenced from a local scope but in such
27062 case it does not need to be present in .debug_names. */
27063 if (psymtab
== NULL
)
27066 if (psymtab
->user
== NULL
)
27067 nametable
.recursively_write_psymbols (objfile
, psymtab
, psyms_seen
, i
);
27069 cu_list
.append_uint (nametable
.dwarf5_offset_size (), dwarf5_byte_order
,
27070 to_underlying (per_cu
->sect_off
));
27073 /* Write out the .debug_type entries, if any. */
27074 data_buf types_cu_list
;
27075 if (dwarf2_per_objfile
->signatured_types
)
27077 debug_names::write_one_signatured_type_data
sig_data (nametable
,
27078 signatured_type_index_data (types_cu_list
, psyms_seen
));
27080 sig_data
.info
.objfile
= objfile
;
27081 /* It is used only for gdb_index. */
27082 sig_data
.info
.symtab
= nullptr;
27083 sig_data
.info
.cu_index
= 0;
27084 htab_traverse_noresize (dwarf2_per_objfile
->signatured_types
,
27085 debug_names::write_one_signatured_type
,
27089 nametable
.build ();
27091 /* No addr_vec - DWARF-5 uses .debug_aranges generated by GCC. */
27093 const offset_type bytes_of_header
27094 = ((dwarf5_is_dwarf64
? 12 : 4)
27096 + sizeof (dwarf5_gdb_augmentation
));
27097 size_t expected_bytes
= 0;
27098 expected_bytes
+= bytes_of_header
;
27099 expected_bytes
+= cu_list
.size ();
27100 expected_bytes
+= types_cu_list
.size ();
27101 expected_bytes
+= nametable
.bytes ();
27104 if (!dwarf5_is_dwarf64
)
27106 const uint64_t size64
= expected_bytes
- 4;
27107 gdb_assert (size64
< 0xfffffff0);
27108 header
.append_uint (4, dwarf5_byte_order
, size64
);
27112 header
.append_uint (4, dwarf5_byte_order
, 0xffffffff);
27113 header
.append_uint (8, dwarf5_byte_order
, expected_bytes
- 12);
27116 /* The version number. */
27117 header
.append_uint (2, dwarf5_byte_order
, 5);
27120 header
.append_uint (2, dwarf5_byte_order
, 0);
27122 /* comp_unit_count - The number of CUs in the CU list. */
27123 header
.append_uint (4, dwarf5_byte_order
, dwarf2_per_objfile
->n_comp_units
);
27125 /* local_type_unit_count - The number of TUs in the local TU
27127 header
.append_uint (4, dwarf5_byte_order
, dwarf2_per_objfile
->n_type_units
);
27129 /* foreign_type_unit_count - The number of TUs in the foreign TU
27131 header
.append_uint (4, dwarf5_byte_order
, 0);
27133 /* bucket_count - The number of hash buckets in the hash lookup
27135 header
.append_uint (4, dwarf5_byte_order
, nametable
.bucket_count ());
27137 /* name_count - The number of unique names in the index. */
27138 header
.append_uint (4, dwarf5_byte_order
, nametable
.name_count ());
27140 /* abbrev_table_size - The size in bytes of the abbreviations
27142 header
.append_uint (4, dwarf5_byte_order
, nametable
.abbrev_table_bytes ());
27144 /* augmentation_string_size - The size in bytes of the augmentation
27145 string. This value is rounded up to a multiple of 4. */
27146 static_assert (sizeof (dwarf5_gdb_augmentation
) % 4 == 0, "");
27147 header
.append_uint (4, dwarf5_byte_order
, sizeof (dwarf5_gdb_augmentation
));
27148 header
.append_data (dwarf5_gdb_augmentation
);
27150 gdb_assert (header
.size () == bytes_of_header
);
27152 header
.file_write (out_file
);
27153 cu_list
.file_write (out_file
);
27154 types_cu_list
.file_write (out_file
);
27155 nametable
.file_write (out_file
, out_file_str
);
27157 return expected_bytes
;
27160 /* Assert that FILE's size is EXPECTED_SIZE. Assumes file's seek
27161 position is at the end of the file. */
27164 assert_file_size (FILE *file
, const char *filename
, size_t expected_size
)
27166 const auto file_size
= ftell (file
);
27167 if (file_size
== -1)
27168 error (_("Can't get `%s' size"), filename
);
27169 gdb_assert (file_size
== expected_size
);
27172 /* Create an index file for OBJFILE in the directory DIR. */
27175 write_psymtabs_to_index (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
27177 dw_index_kind index_kind
)
27179 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
27181 if (dwarf2_per_objfile
->using_index
)
27182 error (_("Cannot use an index to create the index"));
27184 if (VEC_length (dwarf2_section_info_def
, dwarf2_per_objfile
->types
) > 1)
27185 error (_("Cannot make an index when the file has multiple .debug_types sections"));
27187 if (!objfile
->psymtabs
|| !objfile
->psymtabs_addrmap
)
27191 if (stat (objfile_name (objfile
), &st
) < 0)
27192 perror_with_name (objfile_name (objfile
));
27194 std::string
filename (std::string (dir
) + SLASH_STRING
27195 + lbasename (objfile_name (objfile
))
27196 + (index_kind
== dw_index_kind::DEBUG_NAMES
27197 ? INDEX5_SUFFIX
: INDEX4_SUFFIX
));
27199 FILE *out_file
= gdb_fopen_cloexec (filename
.c_str (), "wb").release ();
27201 error (_("Can't open `%s' for writing"), filename
.c_str ());
27203 /* Order matters here; we want FILE to be closed before FILENAME is
27204 unlinked, because on MS-Windows one cannot delete a file that is
27205 still open. (Don't call anything here that might throw until
27206 file_closer is created.) */
27207 gdb::unlinker
unlink_file (filename
.c_str ());
27208 gdb_file_up
close_out_file (out_file
);
27210 if (index_kind
== dw_index_kind::DEBUG_NAMES
)
27212 std::string
filename_str (std::string (dir
) + SLASH_STRING
27213 + lbasename (objfile_name (objfile
))
27214 + DEBUG_STR_SUFFIX
);
27216 = gdb_fopen_cloexec (filename_str
.c_str (), "wb").release ();
27218 error (_("Can't open `%s' for writing"), filename_str
.c_str ());
27219 gdb::unlinker
unlink_file_str (filename_str
.c_str ());
27220 gdb_file_up
close_out_file_str (out_file_str
);
27222 const size_t total_len
27223 = write_debug_names (dwarf2_per_objfile
, out_file
, out_file_str
);
27224 assert_file_size (out_file
, filename
.c_str (), total_len
);
27226 /* We want to keep the file .debug_str file too. */
27227 unlink_file_str
.keep ();
27231 const size_t total_len
27232 = write_gdbindex (dwarf2_per_objfile
, out_file
);
27233 assert_file_size (out_file
, filename
.c_str (), total_len
);
27236 /* We want to keep the file. */
27237 unlink_file
.keep ();
27240 /* Implementation of the `save gdb-index' command.
27242 Note that the .gdb_index file format used by this command is
27243 documented in the GDB manual. Any changes here must be documented
27247 save_gdb_index_command (const char *arg
, int from_tty
)
27249 struct objfile
*objfile
;
27250 const char dwarf5space
[] = "-dwarf-5 ";
27251 dw_index_kind index_kind
= dw_index_kind::GDB_INDEX
;
27256 arg
= skip_spaces (arg
);
27257 if (strncmp (arg
, dwarf5space
, strlen (dwarf5space
)) == 0)
27259 index_kind
= dw_index_kind::DEBUG_NAMES
;
27260 arg
+= strlen (dwarf5space
);
27261 arg
= skip_spaces (arg
);
27265 error (_("usage: save gdb-index [-dwarf-5] DIRECTORY"));
27267 ALL_OBJFILES (objfile
)
27271 /* If the objfile does not correspond to an actual file, skip it. */
27272 if (stat (objfile_name (objfile
), &st
) < 0)
27275 struct dwarf2_per_objfile
*dwarf2_per_objfile
27276 = get_dwarf2_per_objfile (objfile
);
27278 if (dwarf2_per_objfile
!= NULL
)
27282 write_psymtabs_to_index (dwarf2_per_objfile
, arg
, index_kind
);
27284 CATCH (except
, RETURN_MASK_ERROR
)
27286 exception_fprintf (gdb_stderr
, except
,
27287 _("Error while writing index for `%s': "),
27288 objfile_name (objfile
));
27298 int dwarf_always_disassemble
;
27301 show_dwarf_always_disassemble (struct ui_file
*file
, int from_tty
,
27302 struct cmd_list_element
*c
, const char *value
)
27304 fprintf_filtered (file
,
27305 _("Whether to always disassemble "
27306 "DWARF expressions is %s.\n"),
27311 show_check_physname (struct ui_file
*file
, int from_tty
,
27312 struct cmd_list_element
*c
, const char *value
)
27314 fprintf_filtered (file
,
27315 _("Whether to check \"physname\" is %s.\n"),
27320 _initialize_dwarf2_read (void)
27322 struct cmd_list_element
*c
;
27324 dwarf2_objfile_data_key
27325 = register_objfile_data_with_cleanup (NULL
, dwarf2_per_objfile_free
);
27327 add_prefix_cmd ("dwarf", class_maintenance
, set_dwarf_cmd
, _("\
27328 Set DWARF specific variables.\n\
27329 Configure DWARF variables such as the cache size"),
27330 &set_dwarf_cmdlist
, "maintenance set dwarf ",
27331 0/*allow-unknown*/, &maintenance_set_cmdlist
);
27333 add_prefix_cmd ("dwarf", class_maintenance
, show_dwarf_cmd
, _("\
27334 Show DWARF specific variables\n\
27335 Show DWARF variables such as the cache size"),
27336 &show_dwarf_cmdlist
, "maintenance show dwarf ",
27337 0/*allow-unknown*/, &maintenance_show_cmdlist
);
27339 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
27340 &dwarf_max_cache_age
, _("\
27341 Set the upper bound on the age of cached DWARF compilation units."), _("\
27342 Show the upper bound on the age of cached DWARF compilation units."), _("\
27343 A higher limit means that cached compilation units will be stored\n\
27344 in memory longer, and more total memory will be used. Zero disables\n\
27345 caching, which can slow down startup."),
27347 show_dwarf_max_cache_age
,
27348 &set_dwarf_cmdlist
,
27349 &show_dwarf_cmdlist
);
27351 add_setshow_boolean_cmd ("always-disassemble", class_obscure
,
27352 &dwarf_always_disassemble
, _("\
27353 Set whether `info address' always disassembles DWARF expressions."), _("\
27354 Show whether `info address' always disassembles DWARF expressions."), _("\
27355 When enabled, DWARF expressions are always printed in an assembly-like\n\
27356 syntax. When disabled, expressions will be printed in a more\n\
27357 conversational style, when possible."),
27359 show_dwarf_always_disassemble
,
27360 &set_dwarf_cmdlist
,
27361 &show_dwarf_cmdlist
);
27363 add_setshow_zuinteger_cmd ("dwarf-read", no_class
, &dwarf_read_debug
, _("\
27364 Set debugging of the DWARF reader."), _("\
27365 Show debugging of the DWARF reader."), _("\
27366 When enabled (non-zero), debugging messages are printed during DWARF\n\
27367 reading and symtab expansion. A value of 1 (one) provides basic\n\
27368 information. A value greater than 1 provides more verbose information."),
27371 &setdebuglist
, &showdebuglist
);
27373 add_setshow_zuinteger_cmd ("dwarf-die", no_class
, &dwarf_die_debug
, _("\
27374 Set debugging of the DWARF DIE reader."), _("\
27375 Show debugging of the DWARF DIE reader."), _("\
27376 When enabled (non-zero), DIEs are dumped after they are read in.\n\
27377 The value is the maximum depth to print."),
27380 &setdebuglist
, &showdebuglist
);
27382 add_setshow_zuinteger_cmd ("dwarf-line", no_class
, &dwarf_line_debug
, _("\
27383 Set debugging of the dwarf line reader."), _("\
27384 Show debugging of the dwarf line reader."), _("\
27385 When enabled (non-zero), line number entries are dumped as they are read in.\n\
27386 A value of 1 (one) provides basic information.\n\
27387 A value greater than 1 provides more verbose information."),
27390 &setdebuglist
, &showdebuglist
);
27392 add_setshow_boolean_cmd ("check-physname", no_class
, &check_physname
, _("\
27393 Set cross-checking of \"physname\" code against demangler."), _("\
27394 Show cross-checking of \"physname\" code against demangler."), _("\
27395 When enabled, GDB's internal \"physname\" code is checked against\n\
27397 NULL
, show_check_physname
,
27398 &setdebuglist
, &showdebuglist
);
27400 add_setshow_boolean_cmd ("use-deprecated-index-sections",
27401 no_class
, &use_deprecated_index_sections
, _("\
27402 Set whether to use deprecated gdb_index sections."), _("\
27403 Show whether to use deprecated gdb_index sections."), _("\
27404 When enabled, deprecated .gdb_index sections are used anyway.\n\
27405 Normally they are ignored either because of a missing feature or\n\
27406 performance issue.\n\
27407 Warning: This option must be enabled before gdb reads the file."),
27410 &setlist
, &showlist
);
27412 c
= add_cmd ("gdb-index", class_files
, save_gdb_index_command
,
27414 Save a gdb-index file.\n\
27415 Usage: save gdb-index [-dwarf-5] DIRECTORY\n\
27417 No options create one file with .gdb-index extension for pre-DWARF-5\n\
27418 compatible .gdb_index section. With -dwarf-5 creates two files with\n\
27419 extension .debug_names and .debug_str for DWARF-5 .debug_names section."),
27421 set_cmd_completer (c
, filename_completer
);
27423 dwarf2_locexpr_index
= register_symbol_computed_impl (LOC_COMPUTED
,
27424 &dwarf2_locexpr_funcs
);
27425 dwarf2_loclist_index
= register_symbol_computed_impl (LOC_COMPUTED
,
27426 &dwarf2_loclist_funcs
);
27428 dwarf2_locexpr_block_index
= register_symbol_block_impl (LOC_BLOCK
,
27429 &dwarf2_block_frame_base_locexpr_funcs
);
27430 dwarf2_loclist_block_index
= register_symbol_block_impl (LOC_BLOCK
,
27431 &dwarf2_block_frame_base_loclist_funcs
);
27434 selftests::register_test ("dw2_expand_symtabs_matching",
27435 selftests::dw2_expand_symtabs_matching::run_test
);