1 /* DWARF 2 debugging format support for GDB.
3 Copyright (C) 1994-2017 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 "filename-seen-cache.h"
80 #include <sys/types.h>
82 #include <unordered_set>
83 #include <unordered_map>
86 /* When == 1, print basic high level tracing messages.
87 When > 1, be more verbose.
88 This is in contrast to the low level DIE reading of dwarf_die_debug. */
89 static unsigned int dwarf_read_debug
= 0;
91 /* When non-zero, dump DIEs after they are read in. */
92 static unsigned int dwarf_die_debug
= 0;
94 /* When non-zero, dump line number entries as they are read in. */
95 static unsigned int dwarf_line_debug
= 0;
97 /* When non-zero, cross-check physname against demangler. */
98 static int check_physname
= 0;
100 /* When non-zero, do not reject deprecated .gdb_index sections. */
101 static int use_deprecated_index_sections
= 0;
103 static const struct objfile_data
*dwarf2_objfile_data_key
;
105 /* The "aclass" indices for various kinds of computed DWARF symbols. */
107 static int dwarf2_locexpr_index
;
108 static int dwarf2_loclist_index
;
109 static int dwarf2_locexpr_block_index
;
110 static int dwarf2_loclist_block_index
;
112 /* A descriptor for dwarf sections.
114 S.ASECTION, SIZE are typically initialized when the objfile is first
115 scanned. BUFFER, READIN are filled in later when the section is read.
116 If the section contained compressed data then SIZE is updated to record
117 the uncompressed size of the section.
119 DWP file format V2 introduces a wrinkle that is easiest to handle by
120 creating the concept of virtual sections contained within a real section.
121 In DWP V2 the sections of the input DWO files are concatenated together
122 into one section, but section offsets are kept relative to the original
124 If this is a virtual dwp-v2 section, S.CONTAINING_SECTION is a backlink to
125 the real section this "virtual" section is contained in, and BUFFER,SIZE
126 describe the virtual section. */
128 struct dwarf2_section_info
132 /* If this is a real section, the bfd section. */
134 /* If this is a virtual section, pointer to the containing ("real")
136 struct dwarf2_section_info
*containing_section
;
138 /* Pointer to section data, only valid if readin. */
139 const gdb_byte
*buffer
;
140 /* The size of the section, real or virtual. */
142 /* If this is a virtual section, the offset in the real section.
143 Only valid if is_virtual. */
144 bfd_size_type virtual_offset
;
145 /* True if we have tried to read this section. */
147 /* True if this is a virtual section, False otherwise.
148 This specifies which of s.section and s.containing_section to use. */
152 typedef struct dwarf2_section_info dwarf2_section_info_def
;
153 DEF_VEC_O (dwarf2_section_info_def
);
155 /* All offsets in the index are of this type. It must be
156 architecture-independent. */
157 typedef uint32_t offset_type
;
159 DEF_VEC_I (offset_type
);
161 /* Ensure only legit values are used. */
162 #define DW2_GDB_INDEX_SYMBOL_STATIC_SET_VALUE(cu_index, value) \
164 gdb_assert ((unsigned int) (value) <= 1); \
165 GDB_INDEX_SYMBOL_STATIC_SET_VALUE((cu_index), (value)); \
168 /* Ensure only legit values are used. */
169 #define DW2_GDB_INDEX_SYMBOL_KIND_SET_VALUE(cu_index, value) \
171 gdb_assert ((value) >= GDB_INDEX_SYMBOL_KIND_TYPE \
172 && (value) <= GDB_INDEX_SYMBOL_KIND_OTHER); \
173 GDB_INDEX_SYMBOL_KIND_SET_VALUE((cu_index), (value)); \
176 /* Ensure we don't use more than the alloted nuber of bits for the CU. */
177 #define DW2_GDB_INDEX_CU_SET_VALUE(cu_index, value) \
179 gdb_assert (((value) & ~GDB_INDEX_CU_MASK) == 0); \
180 GDB_INDEX_CU_SET_VALUE((cu_index), (value)); \
185 /* Convert VALUE between big- and little-endian. */
188 byte_swap (offset_type value
)
192 result
= (value
& 0xff) << 24;
193 result
|= (value
& 0xff00) << 8;
194 result
|= (value
& 0xff0000) >> 8;
195 result
|= (value
& 0xff000000) >> 24;
199 #define MAYBE_SWAP(V) byte_swap (V)
202 #define MAYBE_SWAP(V) static_cast<offset_type> (V)
203 #endif /* WORDS_BIGENDIAN */
205 /* An index into a (C++) symbol name component in a symbol name as
206 recorded in the mapped_index's symbol table. For each C++ symbol
207 in the symbol table, we record one entry for the start of each
208 component in the symbol in a table of name components, and then
209 sort the table, in order to be able to binary search symbol names,
210 ignoring leading namespaces, both completion and regular look up.
211 For example, for symbol "A::B::C", we'll have an entry that points
212 to "A::B::C", another that points to "B::C", and another for "C".
213 Note that function symbols in GDB index have no parameter
214 information, just the function/method names. You can convert a
215 name_component to a "const char *" using the
216 'mapped_index::symbol_name_at(offset_type)' method. */
218 struct name_component
220 /* Offset in the symbol name where the component starts. Stored as
221 a (32-bit) offset instead of a pointer to save memory and improve
222 locality on 64-bit architectures. */
223 offset_type name_offset
;
225 /* The symbol's index in the symbol and constant pool tables of a
230 /* A description of the mapped index. The file format is described in
231 a comment by the code that writes the index. */
234 /* Index data format version. */
237 /* The total length of the buffer. */
240 /* A pointer to the address table data. */
241 const gdb_byte
*address_table
;
243 /* Size of the address table data in bytes. */
244 offset_type address_table_size
;
246 /* The symbol table, implemented as a hash table. */
247 const offset_type
*symbol_table
;
249 /* Size in slots, each slot is 2 offset_types. */
250 offset_type symbol_table_slots
;
252 /* A pointer to the constant pool. */
253 const char *constant_pool
;
255 /* The name_component table (a sorted vector). See name_component's
256 description above. */
257 std::vector
<name_component
> name_components
;
259 /* How NAME_COMPONENTS is sorted. */
260 enum case_sensitivity name_components_casing
;
262 /* Convenience method to get at the name of the symbol at IDX in the
264 const char *symbol_name_at (offset_type idx
) const
265 { return this->constant_pool
+ MAYBE_SWAP (this->symbol_table
[idx
]); }
267 /* Build the symbol name component sorted vector, if we haven't
269 void build_name_components ();
271 /* Returns the lower (inclusive) and upper (exclusive) bounds of the
272 possible matches for LN_NO_PARAMS in the name component
274 std::pair
<std::vector
<name_component
>::const_iterator
,
275 std::vector
<name_component
>::const_iterator
>
276 find_name_components_bounds (const lookup_name_info
&ln_no_params
) const;
279 typedef struct dwarf2_per_cu_data
*dwarf2_per_cu_ptr
;
280 DEF_VEC_P (dwarf2_per_cu_ptr
);
284 int nr_uniq_abbrev_tables
;
286 int nr_symtab_sharers
;
287 int nr_stmt_less_type_units
;
288 int nr_all_type_units_reallocs
;
291 /* Collection of data recorded per objfile.
292 This hangs off of dwarf2_objfile_data_key. */
294 struct dwarf2_per_objfile
296 /* Construct a dwarf2_per_objfile for OBJFILE. NAMES points to the
297 dwarf2 section names, or is NULL if the standard ELF names are
299 dwarf2_per_objfile (struct objfile
*objfile
,
300 const dwarf2_debug_sections
*names
);
302 ~dwarf2_per_objfile ();
304 DISABLE_COPY_AND_ASSIGN (dwarf2_per_objfile
);
306 /* Free all cached compilation units. */
307 void free_cached_comp_units ();
309 /* This function is mapped across the sections and remembers the
310 offset and size of each of the debugging sections we are
312 void locate_sections (bfd
*abfd
, asection
*sectp
,
313 const dwarf2_debug_sections
&names
);
316 dwarf2_section_info info
{};
317 dwarf2_section_info abbrev
{};
318 dwarf2_section_info line
{};
319 dwarf2_section_info loc
{};
320 dwarf2_section_info loclists
{};
321 dwarf2_section_info macinfo
{};
322 dwarf2_section_info macro
{};
323 dwarf2_section_info str
{};
324 dwarf2_section_info line_str
{};
325 dwarf2_section_info ranges
{};
326 dwarf2_section_info rnglists
{};
327 dwarf2_section_info addr
{};
328 dwarf2_section_info frame
{};
329 dwarf2_section_info eh_frame
{};
330 dwarf2_section_info gdb_index
{};
332 VEC (dwarf2_section_info_def
) *types
= NULL
;
335 struct objfile
*objfile
= NULL
;
337 /* Table of all the compilation units. This is used to locate
338 the target compilation unit of a particular reference. */
339 struct dwarf2_per_cu_data
**all_comp_units
= NULL
;
341 /* The number of compilation units in ALL_COMP_UNITS. */
342 int n_comp_units
= 0;
344 /* The number of .debug_types-related CUs. */
345 int n_type_units
= 0;
347 /* The number of elements allocated in all_type_units.
348 If there are skeleton-less TUs, we add them to all_type_units lazily. */
349 int n_allocated_type_units
= 0;
351 /* The .debug_types-related CUs (TUs).
352 This is stored in malloc space because we may realloc it. */
353 struct signatured_type
**all_type_units
= NULL
;
355 /* Table of struct type_unit_group objects.
356 The hash key is the DW_AT_stmt_list value. */
357 htab_t type_unit_groups
{};
359 /* A table mapping .debug_types signatures to its signatured_type entry.
360 This is NULL if the .debug_types section hasn't been read in yet. */
361 htab_t signatured_types
{};
363 /* Type unit statistics, to see how well the scaling improvements
365 struct tu_stats tu_stats
{};
367 /* A chain of compilation units that are currently read in, so that
368 they can be freed later. */
369 dwarf2_per_cu_data
*read_in_chain
= NULL
;
371 /* A table mapping DW_AT_dwo_name values to struct dwo_file objects.
372 This is NULL if the table hasn't been allocated yet. */
375 /* True if we've checked for whether there is a DWP file. */
376 bool dwp_checked
= false;
378 /* The DWP file if there is one, or NULL. */
379 struct dwp_file
*dwp_file
= NULL
;
381 /* The shared '.dwz' file, if one exists. This is used when the
382 original data was compressed using 'dwz -m'. */
383 struct dwz_file
*dwz_file
= NULL
;
385 /* A flag indicating whether this objfile has a section loaded at a
387 bool has_section_at_zero
= false;
389 /* True if we are using the mapped index,
390 or we are faking it for OBJF_READNOW's sake. */
391 bool using_index
= false;
393 /* The mapped index, or NULL if .gdb_index is missing or not being used. */
394 mapped_index
*index_table
= NULL
;
396 /* When using index_table, this keeps track of all quick_file_names entries.
397 TUs typically share line table entries with a CU, so we maintain a
398 separate table of all line table entries to support the sharing.
399 Note that while there can be way more TUs than CUs, we've already
400 sorted all the TUs into "type unit groups", grouped by their
401 DW_AT_stmt_list value. Therefore the only sharing done here is with a
402 CU and its associated TU group if there is one. */
403 htab_t quick_file_names_table
{};
405 /* Set during partial symbol reading, to prevent queueing of full
407 bool reading_partial_symbols
= false;
409 /* Table mapping type DIEs to their struct type *.
410 This is NULL if not allocated yet.
411 The mapping is done via (CU/TU + DIE offset) -> type. */
412 htab_t die_type_hash
{};
414 /* The CUs we recently read. */
415 VEC (dwarf2_per_cu_ptr
) *just_read_cus
= NULL
;
417 /* Table containing line_header indexed by offset and offset_in_dwz. */
418 htab_t line_header_hash
{};
420 /* Table containing all filenames. This is an optional because the
421 table is lazily constructed on first access. */
422 gdb::optional
<filename_seen_cache
> filenames_cache
;
425 static struct dwarf2_per_objfile
*dwarf2_per_objfile
;
427 /* Default names of the debugging sections. */
429 /* Note that if the debugging section has been compressed, it might
430 have a name like .zdebug_info. */
432 static const struct dwarf2_debug_sections dwarf2_elf_names
=
434 { ".debug_info", ".zdebug_info" },
435 { ".debug_abbrev", ".zdebug_abbrev" },
436 { ".debug_line", ".zdebug_line" },
437 { ".debug_loc", ".zdebug_loc" },
438 { ".debug_loclists", ".zdebug_loclists" },
439 { ".debug_macinfo", ".zdebug_macinfo" },
440 { ".debug_macro", ".zdebug_macro" },
441 { ".debug_str", ".zdebug_str" },
442 { ".debug_line_str", ".zdebug_line_str" },
443 { ".debug_ranges", ".zdebug_ranges" },
444 { ".debug_rnglists", ".zdebug_rnglists" },
445 { ".debug_types", ".zdebug_types" },
446 { ".debug_addr", ".zdebug_addr" },
447 { ".debug_frame", ".zdebug_frame" },
448 { ".eh_frame", NULL
},
449 { ".gdb_index", ".zgdb_index" },
453 /* List of DWO/DWP sections. */
455 static const struct dwop_section_names
457 struct dwarf2_section_names abbrev_dwo
;
458 struct dwarf2_section_names info_dwo
;
459 struct dwarf2_section_names line_dwo
;
460 struct dwarf2_section_names loc_dwo
;
461 struct dwarf2_section_names loclists_dwo
;
462 struct dwarf2_section_names macinfo_dwo
;
463 struct dwarf2_section_names macro_dwo
;
464 struct dwarf2_section_names str_dwo
;
465 struct dwarf2_section_names str_offsets_dwo
;
466 struct dwarf2_section_names types_dwo
;
467 struct dwarf2_section_names cu_index
;
468 struct dwarf2_section_names tu_index
;
472 { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo" },
473 { ".debug_info.dwo", ".zdebug_info.dwo" },
474 { ".debug_line.dwo", ".zdebug_line.dwo" },
475 { ".debug_loc.dwo", ".zdebug_loc.dwo" },
476 { ".debug_loclists.dwo", ".zdebug_loclists.dwo" },
477 { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo" },
478 { ".debug_macro.dwo", ".zdebug_macro.dwo" },
479 { ".debug_str.dwo", ".zdebug_str.dwo" },
480 { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo" },
481 { ".debug_types.dwo", ".zdebug_types.dwo" },
482 { ".debug_cu_index", ".zdebug_cu_index" },
483 { ".debug_tu_index", ".zdebug_tu_index" },
486 /* local data types */
488 /* The data in a compilation unit header, after target2host
489 translation, looks like this. */
490 struct comp_unit_head
494 unsigned char addr_size
;
495 unsigned char signed_addr_p
;
496 sect_offset abbrev_sect_off
;
498 /* Size of file offsets; either 4 or 8. */
499 unsigned int offset_size
;
501 /* Size of the length field; either 4 or 12. */
502 unsigned int initial_length_size
;
504 enum dwarf_unit_type unit_type
;
506 /* Offset to the first byte of this compilation unit header in the
507 .debug_info section, for resolving relative reference dies. */
508 sect_offset sect_off
;
510 /* Offset to first die in this cu from the start of the cu.
511 This will be the first byte following the compilation unit header. */
512 cu_offset first_die_cu_offset
;
514 /* 64-bit signature of this type unit - it is valid only for
515 UNIT_TYPE DW_UT_type. */
518 /* For types, offset in the type's DIE of the type defined by this TU. */
519 cu_offset type_cu_offset_in_tu
;
522 /* Type used for delaying computation of method physnames.
523 See comments for compute_delayed_physnames. */
524 struct delayed_method_info
526 /* The type to which the method is attached, i.e., its parent class. */
529 /* The index of the method in the type's function fieldlists. */
532 /* The index of the method in the fieldlist. */
535 /* The name of the DIE. */
538 /* The DIE associated with this method. */
539 struct die_info
*die
;
542 typedef struct delayed_method_info delayed_method_info
;
543 DEF_VEC_O (delayed_method_info
);
545 /* Internal state when decoding a particular compilation unit. */
548 /* The objfile containing this compilation unit. */
549 struct objfile
*objfile
;
551 /* The header of the compilation unit. */
552 struct comp_unit_head header
;
554 /* Base address of this compilation unit. */
555 CORE_ADDR base_address
;
557 /* Non-zero if base_address has been set. */
560 /* The language we are debugging. */
561 enum language language
;
562 const struct language_defn
*language_defn
;
564 const char *producer
;
566 /* The generic symbol table building routines have separate lists for
567 file scope symbols and all all other scopes (local scopes). So
568 we need to select the right one to pass to add_symbol_to_list().
569 We do it by keeping a pointer to the correct list in list_in_scope.
571 FIXME: The original dwarf code just treated the file scope as the
572 first local scope, and all other local scopes as nested local
573 scopes, and worked fine. Check to see if we really need to
574 distinguish these in buildsym.c. */
575 struct pending
**list_in_scope
;
577 /* The abbrev table for this CU.
578 Normally this points to the abbrev table in the objfile.
579 But if DWO_UNIT is non-NULL this is the abbrev table in the DWO file. */
580 struct abbrev_table
*abbrev_table
;
582 /* Hash table holding all the loaded partial DIEs
583 with partial_die->offset.SECT_OFF as hash. */
586 /* Storage for things with the same lifetime as this read-in compilation
587 unit, including partial DIEs. */
588 struct obstack comp_unit_obstack
;
590 /* When multiple dwarf2_cu structures are living in memory, this field
591 chains them all together, so that they can be released efficiently.
592 We will probably also want a generation counter so that most-recently-used
593 compilation units are cached... */
594 struct dwarf2_per_cu_data
*read_in_chain
;
596 /* Backlink to our per_cu entry. */
597 struct dwarf2_per_cu_data
*per_cu
;
599 /* How many compilation units ago was this CU last referenced? */
602 /* A hash table of DIE cu_offset for following references with
603 die_info->offset.sect_off as hash. */
606 /* Full DIEs if read in. */
607 struct die_info
*dies
;
609 /* A set of pointers to dwarf2_per_cu_data objects for compilation
610 units referenced by this one. Only set during full symbol processing;
611 partial symbol tables do not have dependencies. */
614 /* Header data from the line table, during full symbol processing. */
615 struct line_header
*line_header
;
616 /* Non-NULL if LINE_HEADER is owned by this DWARF_CU. Otherwise,
617 it's owned by dwarf2_per_objfile::line_header_hash. If non-NULL,
618 this is the DW_TAG_compile_unit die for this CU. We'll hold on
619 to the line header as long as this DIE is being processed. See
620 process_die_scope. */
621 die_info
*line_header_die_owner
;
623 /* A list of methods which need to have physnames computed
624 after all type information has been read. */
625 VEC (delayed_method_info
) *method_list
;
627 /* To be copied to symtab->call_site_htab. */
628 htab_t call_site_htab
;
630 /* Non-NULL if this CU came from a DWO file.
631 There is an invariant here that is important to remember:
632 Except for attributes copied from the top level DIE in the "main"
633 (or "stub") file in preparation for reading the DWO file
634 (e.g., DW_AT_GNU_addr_base), we KISS: there is only *one* CU.
635 Either there isn't a DWO file (in which case this is NULL and the point
636 is moot), or there is and either we're not going to read it (in which
637 case this is NULL) or there is and we are reading it (in which case this
639 struct dwo_unit
*dwo_unit
;
641 /* The DW_AT_addr_base attribute if present, zero otherwise
642 (zero is a valid value though).
643 Note this value comes from the Fission stub CU/TU's DIE. */
646 /* The DW_AT_ranges_base attribute if present, zero otherwise
647 (zero is a valid value though).
648 Note this value comes from the Fission stub CU/TU's DIE.
649 Also note that the value is zero in the non-DWO case so this value can
650 be used without needing to know whether DWO files are in use or not.
651 N.B. This does not apply to DW_AT_ranges appearing in
652 DW_TAG_compile_unit dies. This is a bit of a wart, consider if ever
653 DW_AT_ranges appeared in the DW_TAG_compile_unit of DWO DIEs: then
654 DW_AT_ranges_base *would* have to be applied, and we'd have to care
655 whether the DW_AT_ranges attribute came from the skeleton or DWO. */
656 ULONGEST ranges_base
;
658 /* Mark used when releasing cached dies. */
659 unsigned int mark
: 1;
661 /* This CU references .debug_loc. See the symtab->locations_valid field.
662 This test is imperfect as there may exist optimized debug code not using
663 any location list and still facing inlining issues if handled as
664 unoptimized code. For a future better test see GCC PR other/32998. */
665 unsigned int has_loclist
: 1;
667 /* These cache the results for producer_is_* fields. CHECKED_PRODUCER is set
668 if all the producer_is_* fields are valid. This information is cached
669 because profiling CU expansion showed excessive time spent in
670 producer_is_gxx_lt_4_6. */
671 unsigned int checked_producer
: 1;
672 unsigned int producer_is_gxx_lt_4_6
: 1;
673 unsigned int producer_is_gcc_lt_4_3
: 1;
674 unsigned int producer_is_icc_lt_14
: 1;
676 /* When set, the file that we're processing is known to have
677 debugging info for C++ namespaces. GCC 3.3.x did not produce
678 this information, but later versions do. */
680 unsigned int processing_has_namespace_info
: 1;
683 /* Persistent data held for a compilation unit, even when not
684 processing it. We put a pointer to this structure in the
685 read_symtab_private field of the psymtab. */
687 struct dwarf2_per_cu_data
689 /* The start offset and length of this compilation unit.
690 NOTE: Unlike comp_unit_head.length, this length includes
692 If the DIE refers to a DWO file, this is always of the original die,
694 sect_offset sect_off
;
697 /* DWARF standard version this data has been read from (such as 4 or 5). */
700 /* Flag indicating this compilation unit will be read in before
701 any of the current compilation units are processed. */
702 unsigned int queued
: 1;
704 /* This flag will be set when reading partial DIEs if we need to load
705 absolutely all DIEs for this compilation unit, instead of just the ones
706 we think are interesting. It gets set if we look for a DIE in the
707 hash table and don't find it. */
708 unsigned int load_all_dies
: 1;
710 /* Non-zero if this CU is from .debug_types.
711 Struct dwarf2_per_cu_data is contained in struct signatured_type iff
713 unsigned int is_debug_types
: 1;
715 /* Non-zero if this CU is from the .dwz file. */
716 unsigned int is_dwz
: 1;
718 /* Non-zero if reading a TU directly from a DWO file, bypassing the stub.
719 This flag is only valid if is_debug_types is true.
720 We can't read a CU directly from a DWO file: There are required
721 attributes in the stub. */
722 unsigned int reading_dwo_directly
: 1;
724 /* Non-zero if the TU has been read.
725 This is used to assist the "Stay in DWO Optimization" for Fission:
726 When reading a DWO, it's faster to read TUs from the DWO instead of
727 fetching them from random other DWOs (due to comdat folding).
728 If the TU has already been read, the optimization is unnecessary
729 (and unwise - we don't want to change where gdb thinks the TU lives
731 This flag is only valid if is_debug_types is true. */
732 unsigned int tu_read
: 1;
734 /* The section this CU/TU lives in.
735 If the DIE refers to a DWO file, this is always the original die,
737 struct dwarf2_section_info
*section
;
739 /* Set to non-NULL iff this CU is currently loaded. When it gets freed out
740 of the CU cache it gets reset to NULL again. This is left as NULL for
741 dummy CUs (a CU header, but nothing else). */
742 struct dwarf2_cu
*cu
;
744 /* The corresponding objfile.
745 Normally we can get the objfile from dwarf2_per_objfile.
746 However we can enter this file with just a "per_cu" handle. */
747 struct objfile
*objfile
;
749 /* When dwarf2_per_objfile->using_index is true, the 'quick' field
750 is active. Otherwise, the 'psymtab' field is active. */
753 /* The partial symbol table associated with this compilation unit,
754 or NULL for unread partial units. */
755 struct partial_symtab
*psymtab
;
757 /* Data needed by the "quick" functions. */
758 struct dwarf2_per_cu_quick_data
*quick
;
761 /* The CUs we import using DW_TAG_imported_unit. This is filled in
762 while reading psymtabs, used to compute the psymtab dependencies,
763 and then cleared. Then it is filled in again while reading full
764 symbols, and only deleted when the objfile is destroyed.
766 This is also used to work around a difference between the way gold
767 generates .gdb_index version <=7 and the way gdb does. Arguably this
768 is a gold bug. For symbols coming from TUs, gold records in the index
769 the CU that includes the TU instead of the TU itself. This breaks
770 dw2_lookup_symbol: It assumes that if the index says symbol X lives
771 in CU/TU Y, then one need only expand Y and a subsequent lookup in Y
772 will find X. Alas TUs live in their own symtab, so after expanding CU Y
773 we need to look in TU Z to find X. Fortunately, this is akin to
774 DW_TAG_imported_unit, so we just use the same mechanism: For
775 .gdb_index version <=7 this also records the TUs that the CU referred
776 to. Concurrently with this change gdb was modified to emit version 8
777 indices so we only pay a price for gold generated indices.
778 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
779 VEC (dwarf2_per_cu_ptr
) *imported_symtabs
;
782 /* Entry in the signatured_types hash table. */
784 struct signatured_type
786 /* The "per_cu" object of this type.
787 This struct is used iff per_cu.is_debug_types.
788 N.B.: This is the first member so that it's easy to convert pointers
790 struct dwarf2_per_cu_data per_cu
;
792 /* The type's signature. */
795 /* Offset in the TU of the type's DIE, as read from the TU header.
796 If this TU is a DWO stub and the definition lives in a DWO file
797 (specified by DW_AT_GNU_dwo_name), this value is unusable. */
798 cu_offset type_offset_in_tu
;
800 /* Offset in the section of the type's DIE.
801 If the definition lives in a DWO file, this is the offset in the
802 .debug_types.dwo section.
803 The value is zero until the actual value is known.
804 Zero is otherwise not a valid section offset. */
805 sect_offset type_offset_in_section
;
807 /* Type units are grouped by their DW_AT_stmt_list entry so that they
808 can share them. This points to the containing symtab. */
809 struct type_unit_group
*type_unit_group
;
812 The first time we encounter this type we fully read it in and install it
813 in the symbol tables. Subsequent times we only need the type. */
816 /* Containing DWO unit.
817 This field is valid iff per_cu.reading_dwo_directly. */
818 struct dwo_unit
*dwo_unit
;
821 typedef struct signatured_type
*sig_type_ptr
;
822 DEF_VEC_P (sig_type_ptr
);
824 /* A struct that can be used as a hash key for tables based on DW_AT_stmt_list.
825 This includes type_unit_group and quick_file_names. */
827 struct stmt_list_hash
829 /* The DWO unit this table is from or NULL if there is none. */
830 struct dwo_unit
*dwo_unit
;
832 /* Offset in .debug_line or .debug_line.dwo. */
833 sect_offset line_sect_off
;
836 /* Each element of dwarf2_per_objfile->type_unit_groups is a pointer to
837 an object of this type. */
839 struct type_unit_group
841 /* dwarf2read.c's main "handle" on a TU symtab.
842 To simplify things we create an artificial CU that "includes" all the
843 type units using this stmt_list so that the rest of the code still has
844 a "per_cu" handle on the symtab.
845 This PER_CU is recognized by having no section. */
846 #define IS_TYPE_UNIT_GROUP(per_cu) ((per_cu)->section == NULL)
847 struct dwarf2_per_cu_data per_cu
;
849 /* The TUs that share this DW_AT_stmt_list entry.
850 This is added to while parsing type units to build partial symtabs,
851 and is deleted afterwards and not used again. */
852 VEC (sig_type_ptr
) *tus
;
854 /* The compunit symtab.
855 Type units in a group needn't all be defined in the same source file,
856 so we create an essentially anonymous symtab as the compunit symtab. */
857 struct compunit_symtab
*compunit_symtab
;
859 /* The data used to construct the hash key. */
860 struct stmt_list_hash hash
;
862 /* The number of symtabs from the line header.
863 The value here must match line_header.num_file_names. */
864 unsigned int num_symtabs
;
866 /* The symbol tables for this TU (obtained from the files listed in
868 WARNING: The order of entries here must match the order of entries
869 in the line header. After the first TU using this type_unit_group, the
870 line header for the subsequent TUs is recreated from this. This is done
871 because we need to use the same symtabs for each TU using the same
872 DW_AT_stmt_list value. Also note that symtabs may be repeated here,
873 there's no guarantee the line header doesn't have duplicate entries. */
874 struct symtab
**symtabs
;
877 /* These sections are what may appear in a (real or virtual) DWO file. */
881 struct dwarf2_section_info abbrev
;
882 struct dwarf2_section_info line
;
883 struct dwarf2_section_info loc
;
884 struct dwarf2_section_info loclists
;
885 struct dwarf2_section_info macinfo
;
886 struct dwarf2_section_info macro
;
887 struct dwarf2_section_info str
;
888 struct dwarf2_section_info str_offsets
;
889 /* In the case of a virtual DWO file, these two are unused. */
890 struct dwarf2_section_info info
;
891 VEC (dwarf2_section_info_def
) *types
;
894 /* CUs/TUs in DWP/DWO files. */
898 /* Backlink to the containing struct dwo_file. */
899 struct dwo_file
*dwo_file
;
901 /* The "id" that distinguishes this CU/TU.
902 .debug_info calls this "dwo_id", .debug_types calls this "signature".
903 Since signatures came first, we stick with it for consistency. */
906 /* The section this CU/TU lives in, in the DWO file. */
907 struct dwarf2_section_info
*section
;
909 /* Same as dwarf2_per_cu_data:{sect_off,length} but in the DWO section. */
910 sect_offset sect_off
;
913 /* For types, offset in the type's DIE of the type defined by this TU. */
914 cu_offset type_offset_in_tu
;
917 /* include/dwarf2.h defines the DWP section codes.
918 It defines a max value but it doesn't define a min value, which we
919 use for error checking, so provide one. */
921 enum dwp_v2_section_ids
926 /* Data for one DWO file.
928 This includes virtual DWO files (a virtual DWO file is a DWO file as it
929 appears in a DWP file). DWP files don't really have DWO files per se -
930 comdat folding of types "loses" the DWO file they came from, and from
931 a high level view DWP files appear to contain a mass of random types.
932 However, to maintain consistency with the non-DWP case we pretend DWP
933 files contain virtual DWO files, and we assign each TU with one virtual
934 DWO file (generally based on the line and abbrev section offsets -
935 a heuristic that seems to work in practice). */
939 /* The DW_AT_GNU_dwo_name attribute.
940 For virtual DWO files the name is constructed from the section offsets
941 of abbrev,line,loc,str_offsets so that we combine virtual DWO files
942 from related CU+TUs. */
943 const char *dwo_name
;
945 /* The DW_AT_comp_dir attribute. */
946 const char *comp_dir
;
948 /* The bfd, when the file is open. Otherwise this is NULL.
949 This is unused(NULL) for virtual DWO files where we use dwp_file.dbfd. */
952 /* The sections that make up this DWO file.
953 Remember that for virtual DWO files in DWP V2, these are virtual
954 sections (for lack of a better name). */
955 struct dwo_sections sections
;
957 /* The CUs in the file.
958 Each element is a struct dwo_unit. Multiple CUs per DWO are supported as
959 an extension to handle LLVM's Link Time Optimization output (where
960 multiple source files may be compiled into a single object/dwo pair). */
963 /* Table of TUs in the file.
964 Each element is a struct dwo_unit. */
968 /* These sections are what may appear in a DWP file. */
972 /* These are used by both DWP version 1 and 2. */
973 struct dwarf2_section_info str
;
974 struct dwarf2_section_info cu_index
;
975 struct dwarf2_section_info tu_index
;
977 /* These are only used by DWP version 2 files.
978 In DWP version 1 the .debug_info.dwo, .debug_types.dwo, and other
979 sections are referenced by section number, and are not recorded here.
980 In DWP version 2 there is at most one copy of all these sections, each
981 section being (effectively) comprised of the concatenation of all of the
982 individual sections that exist in the version 1 format.
983 To keep the code simple we treat each of these concatenated pieces as a
984 section itself (a virtual section?). */
985 struct dwarf2_section_info abbrev
;
986 struct dwarf2_section_info info
;
987 struct dwarf2_section_info line
;
988 struct dwarf2_section_info loc
;
989 struct dwarf2_section_info macinfo
;
990 struct dwarf2_section_info macro
;
991 struct dwarf2_section_info str_offsets
;
992 struct dwarf2_section_info types
;
995 /* These sections are what may appear in a virtual DWO file in DWP version 1.
996 A virtual DWO file is a DWO file as it appears in a DWP file. */
998 struct virtual_v1_dwo_sections
1000 struct dwarf2_section_info abbrev
;
1001 struct dwarf2_section_info line
;
1002 struct dwarf2_section_info loc
;
1003 struct dwarf2_section_info macinfo
;
1004 struct dwarf2_section_info macro
;
1005 struct dwarf2_section_info str_offsets
;
1006 /* Each DWP hash table entry records one CU or one TU.
1007 That is recorded here, and copied to dwo_unit.section. */
1008 struct dwarf2_section_info info_or_types
;
1011 /* Similar to virtual_v1_dwo_sections, but for DWP version 2.
1012 In version 2, the sections of the DWO files are concatenated together
1013 and stored in one section of that name. Thus each ELF section contains
1014 several "virtual" sections. */
1016 struct virtual_v2_dwo_sections
1018 bfd_size_type abbrev_offset
;
1019 bfd_size_type abbrev_size
;
1021 bfd_size_type line_offset
;
1022 bfd_size_type line_size
;
1024 bfd_size_type loc_offset
;
1025 bfd_size_type loc_size
;
1027 bfd_size_type macinfo_offset
;
1028 bfd_size_type macinfo_size
;
1030 bfd_size_type macro_offset
;
1031 bfd_size_type macro_size
;
1033 bfd_size_type str_offsets_offset
;
1034 bfd_size_type str_offsets_size
;
1036 /* Each DWP hash table entry records one CU or one TU.
1037 That is recorded here, and copied to dwo_unit.section. */
1038 bfd_size_type info_or_types_offset
;
1039 bfd_size_type info_or_types_size
;
1042 /* Contents of DWP hash tables. */
1044 struct dwp_hash_table
1046 uint32_t version
, nr_columns
;
1047 uint32_t nr_units
, nr_slots
;
1048 const gdb_byte
*hash_table
, *unit_table
;
1053 const gdb_byte
*indices
;
1057 /* This is indexed by column number and gives the id of the section
1059 #define MAX_NR_V2_DWO_SECTIONS \
1060 (1 /* .debug_info or .debug_types */ \
1061 + 1 /* .debug_abbrev */ \
1062 + 1 /* .debug_line */ \
1063 + 1 /* .debug_loc */ \
1064 + 1 /* .debug_str_offsets */ \
1065 + 1 /* .debug_macro or .debug_macinfo */)
1066 int section_ids
[MAX_NR_V2_DWO_SECTIONS
];
1067 const gdb_byte
*offsets
;
1068 const gdb_byte
*sizes
;
1073 /* Data for one DWP file. */
1077 /* Name of the file. */
1080 /* File format version. */
1086 /* Section info for this file. */
1087 struct dwp_sections sections
;
1089 /* Table of CUs in the file. */
1090 const struct dwp_hash_table
*cus
;
1092 /* Table of TUs in the file. */
1093 const struct dwp_hash_table
*tus
;
1095 /* Tables of loaded CUs/TUs. Each entry is a struct dwo_unit *. */
1099 /* Table to map ELF section numbers to their sections.
1100 This is only needed for the DWP V1 file format. */
1101 unsigned int num_sections
;
1102 asection
**elf_sections
;
1105 /* This represents a '.dwz' file. */
1109 /* A dwz file can only contain a few sections. */
1110 struct dwarf2_section_info abbrev
;
1111 struct dwarf2_section_info info
;
1112 struct dwarf2_section_info str
;
1113 struct dwarf2_section_info line
;
1114 struct dwarf2_section_info macro
;
1115 struct dwarf2_section_info gdb_index
;
1117 /* The dwz's BFD. */
1121 /* Struct used to pass misc. parameters to read_die_and_children, et
1122 al. which are used for both .debug_info and .debug_types dies.
1123 All parameters here are unchanging for the life of the call. This
1124 struct exists to abstract away the constant parameters of die reading. */
1126 struct die_reader_specs
1128 /* The bfd of die_section. */
1131 /* The CU of the DIE we are parsing. */
1132 struct dwarf2_cu
*cu
;
1134 /* Non-NULL if reading a DWO file (including one packaged into a DWP). */
1135 struct dwo_file
*dwo_file
;
1137 /* The section the die comes from.
1138 This is either .debug_info or .debug_types, or the .dwo variants. */
1139 struct dwarf2_section_info
*die_section
;
1141 /* die_section->buffer. */
1142 const gdb_byte
*buffer
;
1144 /* The end of the buffer. */
1145 const gdb_byte
*buffer_end
;
1147 /* The value of the DW_AT_comp_dir attribute. */
1148 const char *comp_dir
;
1151 /* Type of function passed to init_cutu_and_read_dies, et.al. */
1152 typedef void (die_reader_func_ftype
) (const struct die_reader_specs
*reader
,
1153 const gdb_byte
*info_ptr
,
1154 struct die_info
*comp_unit_die
,
1158 /* A 1-based directory index. This is a strong typedef to prevent
1159 accidentally using a directory index as a 0-based index into an
1161 enum class dir_index
: unsigned int {};
1163 /* Likewise, a 1-based file name index. */
1164 enum class file_name_index
: unsigned int {};
1168 file_entry () = default;
1170 file_entry (const char *name_
, dir_index d_index_
,
1171 unsigned int mod_time_
, unsigned int length_
)
1174 mod_time (mod_time_
),
1178 /* Return the include directory at D_INDEX stored in LH. Returns
1179 NULL if D_INDEX is out of bounds. */
1180 const char *include_dir (const line_header
*lh
) const;
1182 /* The file name. Note this is an observing pointer. The memory is
1183 owned by debug_line_buffer. */
1184 const char *name
{};
1186 /* The directory index (1-based). */
1187 dir_index d_index
{};
1189 unsigned int mod_time
{};
1191 unsigned int length
{};
1193 /* True if referenced by the Line Number Program. */
1196 /* The associated symbol table, if any. */
1197 struct symtab
*symtab
{};
1200 /* The line number information for a compilation unit (found in the
1201 .debug_line section) begins with a "statement program header",
1202 which contains the following information. */
1209 /* Add an entry to the include directory table. */
1210 void add_include_dir (const char *include_dir
);
1212 /* Add an entry to the file name table. */
1213 void add_file_name (const char *name
, dir_index d_index
,
1214 unsigned int mod_time
, unsigned int length
);
1216 /* Return the include dir at INDEX (1-based). Returns NULL if INDEX
1217 is out of bounds. */
1218 const char *include_dir_at (dir_index index
) const
1220 /* Convert directory index number (1-based) to vector index
1222 size_t vec_index
= to_underlying (index
) - 1;
1224 if (vec_index
>= include_dirs
.size ())
1226 return include_dirs
[vec_index
];
1229 /* Return the file name at INDEX (1-based). Returns NULL if INDEX
1230 is out of bounds. */
1231 file_entry
*file_name_at (file_name_index index
)
1233 /* Convert file name index number (1-based) to vector index
1235 size_t vec_index
= to_underlying (index
) - 1;
1237 if (vec_index
>= file_names
.size ())
1239 return &file_names
[vec_index
];
1242 /* Const version of the above. */
1243 const file_entry
*file_name_at (unsigned int index
) const
1245 if (index
>= file_names
.size ())
1247 return &file_names
[index
];
1250 /* Offset of line number information in .debug_line section. */
1251 sect_offset sect_off
{};
1253 /* OFFSET is for struct dwz_file associated with dwarf2_per_objfile. */
1254 unsigned offset_in_dwz
: 1; /* Can't initialize bitfields in-class. */
1256 unsigned int total_length
{};
1257 unsigned short version
{};
1258 unsigned int header_length
{};
1259 unsigned char minimum_instruction_length
{};
1260 unsigned char maximum_ops_per_instruction
{};
1261 unsigned char default_is_stmt
{};
1263 unsigned char line_range
{};
1264 unsigned char opcode_base
{};
1266 /* standard_opcode_lengths[i] is the number of operands for the
1267 standard opcode whose value is i. This means that
1268 standard_opcode_lengths[0] is unused, and the last meaningful
1269 element is standard_opcode_lengths[opcode_base - 1]. */
1270 std::unique_ptr
<unsigned char[]> standard_opcode_lengths
;
1272 /* The include_directories table. Note these are observing
1273 pointers. The memory is owned by debug_line_buffer. */
1274 std::vector
<const char *> include_dirs
;
1276 /* The file_names table. */
1277 std::vector
<file_entry
> file_names
;
1279 /* The start and end of the statement program following this
1280 header. These point into dwarf2_per_objfile->line_buffer. */
1281 const gdb_byte
*statement_program_start
{}, *statement_program_end
{};
1284 typedef std::unique_ptr
<line_header
> line_header_up
;
1287 file_entry::include_dir (const line_header
*lh
) const
1289 return lh
->include_dir_at (d_index
);
1292 /* When we construct a partial symbol table entry we only
1293 need this much information. */
1294 struct partial_die_info
1296 /* Offset of this DIE. */
1297 sect_offset sect_off
;
1299 /* DWARF-2 tag for this DIE. */
1300 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
1302 /* Assorted flags describing the data found in this DIE. */
1303 unsigned int has_children
: 1;
1304 unsigned int is_external
: 1;
1305 unsigned int is_declaration
: 1;
1306 unsigned int has_type
: 1;
1307 unsigned int has_specification
: 1;
1308 unsigned int has_pc_info
: 1;
1309 unsigned int may_be_inlined
: 1;
1311 /* This DIE has been marked DW_AT_main_subprogram. */
1312 unsigned int main_subprogram
: 1;
1314 /* Flag set if the SCOPE field of this structure has been
1316 unsigned int scope_set
: 1;
1318 /* Flag set if the DIE has a byte_size attribute. */
1319 unsigned int has_byte_size
: 1;
1321 /* Flag set if the DIE has a DW_AT_const_value attribute. */
1322 unsigned int has_const_value
: 1;
1324 /* Flag set if any of the DIE's children are template arguments. */
1325 unsigned int has_template_arguments
: 1;
1327 /* Flag set if fixup_partial_die has been called on this die. */
1328 unsigned int fixup_called
: 1;
1330 /* Flag set if DW_TAG_imported_unit uses DW_FORM_GNU_ref_alt. */
1331 unsigned int is_dwz
: 1;
1333 /* Flag set if spec_offset uses DW_FORM_GNU_ref_alt. */
1334 unsigned int spec_is_dwz
: 1;
1336 /* The name of this DIE. Normally the value of DW_AT_name, but
1337 sometimes a default name for unnamed DIEs. */
1340 /* The linkage name, if present. */
1341 const char *linkage_name
;
1343 /* The scope to prepend to our children. This is generally
1344 allocated on the comp_unit_obstack, so will disappear
1345 when this compilation unit leaves the cache. */
1348 /* Some data associated with the partial DIE. The tag determines
1349 which field is live. */
1352 /* The location description associated with this DIE, if any. */
1353 struct dwarf_block
*locdesc
;
1354 /* The offset of an import, for DW_TAG_imported_unit. */
1355 sect_offset sect_off
;
1358 /* If HAS_PC_INFO, the PC range associated with this DIE. */
1362 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
1363 DW_AT_sibling, if any. */
1364 /* NOTE: This member isn't strictly necessary, read_partial_die could
1365 return DW_AT_sibling values to its caller load_partial_dies. */
1366 const gdb_byte
*sibling
;
1368 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
1369 DW_AT_specification (or DW_AT_abstract_origin or
1370 DW_AT_extension). */
1371 sect_offset spec_offset
;
1373 /* Pointers to this DIE's parent, first child, and next sibling,
1375 struct partial_die_info
*die_parent
, *die_child
, *die_sibling
;
1378 /* This data structure holds the information of an abbrev. */
1381 unsigned int number
; /* number identifying abbrev */
1382 enum dwarf_tag tag
; /* dwarf tag */
1383 unsigned short has_children
; /* boolean */
1384 unsigned short num_attrs
; /* number of attributes */
1385 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
1386 struct abbrev_info
*next
; /* next in chain */
1391 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
1392 ENUM_BITFIELD(dwarf_form
) form
: 16;
1394 /* It is valid only if FORM is DW_FORM_implicit_const. */
1395 LONGEST implicit_const
;
1398 /* Size of abbrev_table.abbrev_hash_table. */
1399 #define ABBREV_HASH_SIZE 121
1401 /* Top level data structure to contain an abbreviation table. */
1405 /* Where the abbrev table came from.
1406 This is used as a sanity check when the table is used. */
1407 sect_offset sect_off
;
1409 /* Storage for the abbrev table. */
1410 struct obstack abbrev_obstack
;
1412 /* Hash table of abbrevs.
1413 This is an array of size ABBREV_HASH_SIZE allocated in abbrev_obstack.
1414 It could be statically allocated, but the previous code didn't so we
1416 struct abbrev_info
**abbrevs
;
1419 /* Attributes have a name and a value. */
1422 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
1423 ENUM_BITFIELD(dwarf_form
) form
: 15;
1425 /* Has DW_STRING already been updated by dwarf2_canonicalize_name? This
1426 field should be in u.str (existing only for DW_STRING) but it is kept
1427 here for better struct attribute alignment. */
1428 unsigned int string_is_canonical
: 1;
1433 struct dwarf_block
*blk
;
1442 /* This data structure holds a complete die structure. */
1445 /* DWARF-2 tag for this DIE. */
1446 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
1448 /* Number of attributes */
1449 unsigned char num_attrs
;
1451 /* True if we're presently building the full type name for the
1452 type derived from this DIE. */
1453 unsigned char building_fullname
: 1;
1455 /* True if this die is in process. PR 16581. */
1456 unsigned char in_process
: 1;
1459 unsigned int abbrev
;
1461 /* Offset in .debug_info or .debug_types section. */
1462 sect_offset sect_off
;
1464 /* The dies in a compilation unit form an n-ary tree. PARENT
1465 points to this die's parent; CHILD points to the first child of
1466 this node; and all the children of a given node are chained
1467 together via their SIBLING fields. */
1468 struct die_info
*child
; /* Its first child, if any. */
1469 struct die_info
*sibling
; /* Its next sibling, if any. */
1470 struct die_info
*parent
; /* Its parent, if any. */
1472 /* An array of attributes, with NUM_ATTRS elements. There may be
1473 zero, but it's not common and zero-sized arrays are not
1474 sufficiently portable C. */
1475 struct attribute attrs
[1];
1478 /* Get at parts of an attribute structure. */
1480 #define DW_STRING(attr) ((attr)->u.str)
1481 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
1482 #define DW_UNSND(attr) ((attr)->u.unsnd)
1483 #define DW_BLOCK(attr) ((attr)->u.blk)
1484 #define DW_SND(attr) ((attr)->u.snd)
1485 #define DW_ADDR(attr) ((attr)->u.addr)
1486 #define DW_SIGNATURE(attr) ((attr)->u.signature)
1488 /* Blocks are a bunch of untyped bytes. */
1493 /* Valid only if SIZE is not zero. */
1494 const gdb_byte
*data
;
1497 #ifndef ATTR_ALLOC_CHUNK
1498 #define ATTR_ALLOC_CHUNK 4
1501 /* Allocate fields for structs, unions and enums in this size. */
1502 #ifndef DW_FIELD_ALLOC_CHUNK
1503 #define DW_FIELD_ALLOC_CHUNK 4
1506 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
1507 but this would require a corresponding change in unpack_field_as_long
1509 static int bits_per_byte
= 8;
1513 struct nextfield
*next
;
1521 struct nextfnfield
*next
;
1522 struct fn_field fnfield
;
1529 struct nextfnfield
*head
;
1532 struct typedef_field_list
1534 struct typedef_field field
;
1535 struct typedef_field_list
*next
;
1538 /* The routines that read and process dies for a C struct or C++ class
1539 pass lists of data member fields and lists of member function fields
1540 in an instance of a field_info structure, as defined below. */
1543 /* List of data member and baseclasses fields. */
1544 struct nextfield
*fields
, *baseclasses
;
1546 /* Number of fields (including baseclasses). */
1549 /* Number of baseclasses. */
1552 /* Set if the accesibility of one of the fields is not public. */
1553 int non_public_fields
;
1555 /* Member function fieldlist array, contains name of possibly overloaded
1556 member function, number of overloaded member functions and a pointer
1557 to the head of the member function field chain. */
1558 struct fnfieldlist
*fnfieldlists
;
1560 /* Number of entries in the fnfieldlists array. */
1563 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
1564 a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
1565 struct typedef_field_list
*typedef_field_list
;
1566 unsigned typedef_field_list_count
;
1569 /* One item on the queue of compilation units to read in full symbols
1571 struct dwarf2_queue_item
1573 struct dwarf2_per_cu_data
*per_cu
;
1574 enum language pretend_language
;
1575 struct dwarf2_queue_item
*next
;
1578 /* The current queue. */
1579 static struct dwarf2_queue_item
*dwarf2_queue
, *dwarf2_queue_tail
;
1581 /* Loaded secondary compilation units are kept in memory until they
1582 have not been referenced for the processing of this many
1583 compilation units. Set this to zero to disable caching. Cache
1584 sizes of up to at least twenty will improve startup time for
1585 typical inter-CU-reference binaries, at an obvious memory cost. */
1586 static int dwarf_max_cache_age
= 5;
1588 show_dwarf_max_cache_age (struct ui_file
*file
, int from_tty
,
1589 struct cmd_list_element
*c
, const char *value
)
1591 fprintf_filtered (file
, _("The upper bound on the age of cached "
1592 "DWARF compilation units is %s.\n"),
1596 /* local function prototypes */
1598 static const char *get_section_name (const struct dwarf2_section_info
*);
1600 static const char *get_section_file_name (const struct dwarf2_section_info
*);
1602 static void dwarf2_find_base_address (struct die_info
*die
,
1603 struct dwarf2_cu
*cu
);
1605 static struct partial_symtab
*create_partial_symtab
1606 (struct dwarf2_per_cu_data
*per_cu
, const char *name
);
1608 static void build_type_psymtabs_reader (const struct die_reader_specs
*reader
,
1609 const gdb_byte
*info_ptr
,
1610 struct die_info
*type_unit_die
,
1611 int has_children
, void *data
);
1613 static void dwarf2_build_psymtabs_hard (struct objfile
*);
1615 static void scan_partial_symbols (struct partial_die_info
*,
1616 CORE_ADDR
*, CORE_ADDR
*,
1617 int, struct dwarf2_cu
*);
1619 static void add_partial_symbol (struct partial_die_info
*,
1620 struct dwarf2_cu
*);
1622 static void add_partial_namespace (struct partial_die_info
*pdi
,
1623 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1624 int set_addrmap
, struct dwarf2_cu
*cu
);
1626 static void add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
1627 CORE_ADDR
*highpc
, int set_addrmap
,
1628 struct dwarf2_cu
*cu
);
1630 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
1631 struct dwarf2_cu
*cu
);
1633 static void add_partial_subprogram (struct partial_die_info
*pdi
,
1634 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1635 int need_pc
, struct dwarf2_cu
*cu
);
1637 static void dwarf2_read_symtab (struct partial_symtab
*,
1640 static void psymtab_to_symtab_1 (struct partial_symtab
*);
1642 static struct abbrev_info
*abbrev_table_lookup_abbrev
1643 (const struct abbrev_table
*, unsigned int);
1645 static struct abbrev_table
*abbrev_table_read_table
1646 (struct dwarf2_section_info
*, sect_offset
);
1648 static void abbrev_table_free (struct abbrev_table
*);
1650 static void abbrev_table_free_cleanup (void *);
1652 static void dwarf2_read_abbrevs (struct dwarf2_cu
*,
1653 struct dwarf2_section_info
*);
1655 static void dwarf2_free_abbrev_table (void *);
1657 static unsigned int peek_abbrev_code (bfd
*, const gdb_byte
*);
1659 static struct partial_die_info
*load_partial_dies
1660 (const struct die_reader_specs
*, const gdb_byte
*, int);
1662 static const gdb_byte
*read_partial_die (const struct die_reader_specs
*,
1663 struct partial_die_info
*,
1664 struct abbrev_info
*,
1668 static struct partial_die_info
*find_partial_die (sect_offset
, int,
1669 struct dwarf2_cu
*);
1671 static void fixup_partial_die (struct partial_die_info
*,
1672 struct dwarf2_cu
*);
1674 static const gdb_byte
*read_attribute (const struct die_reader_specs
*,
1675 struct attribute
*, struct attr_abbrev
*,
1678 static unsigned int read_1_byte (bfd
*, const gdb_byte
*);
1680 static int read_1_signed_byte (bfd
*, const gdb_byte
*);
1682 static unsigned int read_2_bytes (bfd
*, const gdb_byte
*);
1684 static unsigned int read_4_bytes (bfd
*, const gdb_byte
*);
1686 static ULONGEST
read_8_bytes (bfd
*, const gdb_byte
*);
1688 static CORE_ADDR
read_address (bfd
*, const gdb_byte
*ptr
, struct dwarf2_cu
*,
1691 static LONGEST
read_initial_length (bfd
*, const gdb_byte
*, unsigned int *);
1693 static LONGEST read_checked_initial_length_and_offset
1694 (bfd
*, const gdb_byte
*, const struct comp_unit_head
*,
1695 unsigned int *, unsigned int *);
1697 static LONGEST
read_offset (bfd
*, const gdb_byte
*,
1698 const struct comp_unit_head
*,
1701 static LONGEST
read_offset_1 (bfd
*, const gdb_byte
*, unsigned int);
1703 static sect_offset
read_abbrev_offset (struct dwarf2_section_info
*,
1706 static const gdb_byte
*read_n_bytes (bfd
*, const gdb_byte
*, unsigned int);
1708 static const char *read_direct_string (bfd
*, const gdb_byte
*, unsigned int *);
1710 static const char *read_indirect_string (bfd
*, const gdb_byte
*,
1711 const struct comp_unit_head
*,
1714 static const char *read_indirect_line_string (bfd
*, const gdb_byte
*,
1715 const struct comp_unit_head
*,
1718 static const char *read_indirect_string_from_dwz (struct dwz_file
*, LONGEST
);
1720 static LONGEST
read_signed_leb128 (bfd
*, const gdb_byte
*, unsigned int *);
1722 static CORE_ADDR
read_addr_index_from_leb128 (struct dwarf2_cu
*,
1726 static const char *read_str_index (const struct die_reader_specs
*reader
,
1727 ULONGEST str_index
);
1729 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
1731 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
1732 struct dwarf2_cu
*);
1734 static struct attribute
*dwarf2_attr_no_follow (struct die_info
*,
1737 static const char *dwarf2_string_attr (struct die_info
*die
, unsigned int name
,
1738 struct dwarf2_cu
*cu
);
1740 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
1741 struct dwarf2_cu
*cu
);
1743 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
1745 static struct die_info
*die_specification (struct die_info
*die
,
1746 struct dwarf2_cu
**);
1748 static line_header_up
dwarf_decode_line_header (sect_offset sect_off
,
1749 struct dwarf2_cu
*cu
);
1751 static void dwarf_decode_lines (struct line_header
*, const char *,
1752 struct dwarf2_cu
*, struct partial_symtab
*,
1753 CORE_ADDR
, int decode_mapping
);
1755 static void dwarf2_start_subfile (const char *, const char *);
1757 static struct compunit_symtab
*dwarf2_start_symtab (struct dwarf2_cu
*,
1758 const char *, const char *,
1761 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
1762 struct dwarf2_cu
*);
1764 static struct symbol
*new_symbol_full (struct die_info
*, struct type
*,
1765 struct dwarf2_cu
*, struct symbol
*);
1767 static void dwarf2_const_value (const struct attribute
*, struct symbol
*,
1768 struct dwarf2_cu
*);
1770 static void dwarf2_const_value_attr (const struct attribute
*attr
,
1773 struct obstack
*obstack
,
1774 struct dwarf2_cu
*cu
, LONGEST
*value
,
1775 const gdb_byte
**bytes
,
1776 struct dwarf2_locexpr_baton
**baton
);
1778 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
1780 static int need_gnat_info (struct dwarf2_cu
*);
1782 static struct type
*die_descriptive_type (struct die_info
*,
1783 struct dwarf2_cu
*);
1785 static void set_descriptive_type (struct type
*, struct die_info
*,
1786 struct dwarf2_cu
*);
1788 static struct type
*die_containing_type (struct die_info
*,
1789 struct dwarf2_cu
*);
1791 static struct type
*lookup_die_type (struct die_info
*, const struct attribute
*,
1792 struct dwarf2_cu
*);
1794 static struct type
*read_type_die (struct die_info
*, struct dwarf2_cu
*);
1796 static struct type
*read_type_die_1 (struct die_info
*, struct dwarf2_cu
*);
1798 static const char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
1800 static char *typename_concat (struct obstack
*obs
, const char *prefix
,
1801 const char *suffix
, int physname
,
1802 struct dwarf2_cu
*cu
);
1804 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
1806 static void read_type_unit_scope (struct die_info
*, struct dwarf2_cu
*);
1808 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
1810 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
1812 static void read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
);
1814 static void read_variable (struct die_info
*die
, struct dwarf2_cu
*cu
);
1816 static int dwarf2_ranges_read (unsigned, CORE_ADDR
*, CORE_ADDR
*,
1817 struct dwarf2_cu
*, struct partial_symtab
*);
1819 /* How dwarf2_get_pc_bounds constructed its *LOWPC and *HIGHPC return
1820 values. Keep the items ordered with increasing constraints compliance. */
1823 /* No attribute DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges was found. */
1824 PC_BOUNDS_NOT_PRESENT
,
1826 /* Some of the attributes DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges
1827 were present but they do not form a valid range of PC addresses. */
1830 /* Discontiguous range was found - that is DW_AT_ranges was found. */
1833 /* Contiguous range was found - DW_AT_low_pc and DW_AT_high_pc were found. */
1837 static enum pc_bounds_kind
dwarf2_get_pc_bounds (struct die_info
*,
1838 CORE_ADDR
*, CORE_ADDR
*,
1840 struct partial_symtab
*);
1842 static void get_scope_pc_bounds (struct die_info
*,
1843 CORE_ADDR
*, CORE_ADDR
*,
1844 struct dwarf2_cu
*);
1846 static void dwarf2_record_block_ranges (struct die_info
*, struct block
*,
1847 CORE_ADDR
, struct dwarf2_cu
*);
1849 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
1850 struct dwarf2_cu
*);
1852 static void dwarf2_attach_fields_to_type (struct field_info
*,
1853 struct type
*, struct dwarf2_cu
*);
1855 static void dwarf2_add_member_fn (struct field_info
*,
1856 struct die_info
*, struct type
*,
1857 struct dwarf2_cu
*);
1859 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
1861 struct dwarf2_cu
*);
1863 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
1865 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
1867 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
1869 static void read_module (struct die_info
*die
, struct dwarf2_cu
*cu
);
1871 static struct using_direct
**using_directives (enum language
);
1873 static void read_import_statement (struct die_info
*die
, struct dwarf2_cu
*);
1875 static int read_namespace_alias (struct die_info
*die
, struct dwarf2_cu
*cu
);
1877 static struct type
*read_module_type (struct die_info
*die
,
1878 struct dwarf2_cu
*cu
);
1880 static const char *namespace_name (struct die_info
*die
,
1881 int *is_anonymous
, struct dwarf2_cu
*);
1883 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
1885 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
1887 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
1888 struct dwarf2_cu
*);
1890 static struct die_info
*read_die_and_siblings_1
1891 (const struct die_reader_specs
*, const gdb_byte
*, const gdb_byte
**,
1894 static struct die_info
*read_die_and_siblings (const struct die_reader_specs
*,
1895 const gdb_byte
*info_ptr
,
1896 const gdb_byte
**new_info_ptr
,
1897 struct die_info
*parent
);
1899 static const gdb_byte
*read_full_die_1 (const struct die_reader_specs
*,
1900 struct die_info
**, const gdb_byte
*,
1903 static const gdb_byte
*read_full_die (const struct die_reader_specs
*,
1904 struct die_info
**, const gdb_byte
*,
1907 static void process_die (struct die_info
*, struct dwarf2_cu
*);
1909 static const char *dwarf2_canonicalize_name (const char *, struct dwarf2_cu
*,
1912 static const char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
1914 static const char *dwarf2_full_name (const char *name
,
1915 struct die_info
*die
,
1916 struct dwarf2_cu
*cu
);
1918 static const char *dwarf2_physname (const char *name
, struct die_info
*die
,
1919 struct dwarf2_cu
*cu
);
1921 static struct die_info
*dwarf2_extension (struct die_info
*die
,
1922 struct dwarf2_cu
**);
1924 static const char *dwarf_tag_name (unsigned int);
1926 static const char *dwarf_attr_name (unsigned int);
1928 static const char *dwarf_form_name (unsigned int);
1930 static const char *dwarf_bool_name (unsigned int);
1932 static const char *dwarf_type_encoding_name (unsigned int);
1934 static struct die_info
*sibling_die (struct die_info
*);
1936 static void dump_die_shallow (struct ui_file
*, int indent
, struct die_info
*);
1938 static void dump_die_for_error (struct die_info
*);
1940 static void dump_die_1 (struct ui_file
*, int level
, int max_level
,
1943 /*static*/ void dump_die (struct die_info
*, int max_level
);
1945 static void store_in_ref_table (struct die_info
*,
1946 struct dwarf2_cu
*);
1948 static sect_offset
dwarf2_get_ref_die_offset (const struct attribute
*);
1950 static LONGEST
dwarf2_get_attr_constant_value (const struct attribute
*, int);
1952 static struct die_info
*follow_die_ref_or_sig (struct die_info
*,
1953 const struct attribute
*,
1954 struct dwarf2_cu
**);
1956 static struct die_info
*follow_die_ref (struct die_info
*,
1957 const struct attribute
*,
1958 struct dwarf2_cu
**);
1960 static struct die_info
*follow_die_sig (struct die_info
*,
1961 const struct attribute
*,
1962 struct dwarf2_cu
**);
1964 static struct type
*get_signatured_type (struct die_info
*, ULONGEST
,
1965 struct dwarf2_cu
*);
1967 static struct type
*get_DW_AT_signature_type (struct die_info
*,
1968 const struct attribute
*,
1969 struct dwarf2_cu
*);
1971 static void load_full_type_unit (struct dwarf2_per_cu_data
*per_cu
);
1973 static void read_signatured_type (struct signatured_type
*);
1975 static int attr_to_dynamic_prop (const struct attribute
*attr
,
1976 struct die_info
*die
, struct dwarf2_cu
*cu
,
1977 struct dynamic_prop
*prop
);
1979 /* memory allocation interface */
1981 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1983 static struct die_info
*dwarf_alloc_die (struct dwarf2_cu
*, int);
1985 static void dwarf_decode_macros (struct dwarf2_cu
*, unsigned int, int);
1987 static int attr_form_is_block (const struct attribute
*);
1989 static int attr_form_is_section_offset (const struct attribute
*);
1991 static int attr_form_is_constant (const struct attribute
*);
1993 static int attr_form_is_ref (const struct attribute
*);
1995 static void fill_in_loclist_baton (struct dwarf2_cu
*cu
,
1996 struct dwarf2_loclist_baton
*baton
,
1997 const struct attribute
*attr
);
1999 static void dwarf2_symbol_mark_computed (const struct attribute
*attr
,
2001 struct dwarf2_cu
*cu
,
2004 static const gdb_byte
*skip_one_die (const struct die_reader_specs
*reader
,
2005 const gdb_byte
*info_ptr
,
2006 struct abbrev_info
*abbrev
);
2008 static void free_stack_comp_unit (void *);
2010 static hashval_t
partial_die_hash (const void *item
);
2012 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
2014 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
2015 (sect_offset sect_off
, unsigned int offset_in_dwz
, struct objfile
*objfile
);
2017 static void init_one_comp_unit (struct dwarf2_cu
*cu
,
2018 struct dwarf2_per_cu_data
*per_cu
);
2020 static void prepare_one_comp_unit (struct dwarf2_cu
*cu
,
2021 struct die_info
*comp_unit_die
,
2022 enum language pretend_language
);
2024 static void free_heap_comp_unit (void *);
2026 static void free_cached_comp_units (void *);
2028 static void age_cached_comp_units (void);
2030 static void free_one_cached_comp_unit (struct dwarf2_per_cu_data
*);
2032 static struct type
*set_die_type (struct die_info
*, struct type
*,
2033 struct dwarf2_cu
*);
2035 static void create_all_comp_units (struct objfile
*);
2037 static int create_all_type_units (struct objfile
*);
2039 static void load_full_comp_unit (struct dwarf2_per_cu_data
*,
2042 static void process_full_comp_unit (struct dwarf2_per_cu_data
*,
2045 static void process_full_type_unit (struct dwarf2_per_cu_data
*,
2048 static void dwarf2_add_dependence (struct dwarf2_cu
*,
2049 struct dwarf2_per_cu_data
*);
2051 static void dwarf2_mark (struct dwarf2_cu
*);
2053 static void dwarf2_clear_marks (struct dwarf2_per_cu_data
*);
2055 static struct type
*get_die_type_at_offset (sect_offset
,
2056 struct dwarf2_per_cu_data
*);
2058 static struct type
*get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
2060 static void dwarf2_release_queue (void *dummy
);
2062 static void queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
2063 enum language pretend_language
);
2065 static void process_queue (void);
2067 /* The return type of find_file_and_directory. Note, the enclosed
2068 string pointers are only valid while this object is valid. */
2070 struct file_and_directory
2072 /* The filename. This is never NULL. */
2075 /* The compilation directory. NULL if not known. If we needed to
2076 compute a new string, this points to COMP_DIR_STORAGE, otherwise,
2077 points directly to the DW_AT_comp_dir string attribute owned by
2078 the obstack that owns the DIE. */
2079 const char *comp_dir
;
2081 /* If we needed to build a new string for comp_dir, this is what
2082 owns the storage. */
2083 std::string comp_dir_storage
;
2086 static file_and_directory
find_file_and_directory (struct die_info
*die
,
2087 struct dwarf2_cu
*cu
);
2089 static char *file_full_name (int file
, struct line_header
*lh
,
2090 const char *comp_dir
);
2092 /* Expected enum dwarf_unit_type for read_comp_unit_head. */
2093 enum class rcuh_kind
{ COMPILE
, TYPE
};
2095 static const gdb_byte
*read_and_check_comp_unit_head
2096 (struct comp_unit_head
*header
,
2097 struct dwarf2_section_info
*section
,
2098 struct dwarf2_section_info
*abbrev_section
, const gdb_byte
*info_ptr
,
2099 rcuh_kind section_kind
);
2101 static void init_cutu_and_read_dies
2102 (struct dwarf2_per_cu_data
*this_cu
, struct abbrev_table
*abbrev_table
,
2103 int use_existing_cu
, int keep
,
2104 die_reader_func_ftype
*die_reader_func
, void *data
);
2106 static void init_cutu_and_read_dies_simple
2107 (struct dwarf2_per_cu_data
*this_cu
,
2108 die_reader_func_ftype
*die_reader_func
, void *data
);
2110 static htab_t
allocate_signatured_type_table (struct objfile
*objfile
);
2112 static htab_t
allocate_dwo_unit_table (struct objfile
*objfile
);
2114 static struct dwo_unit
*lookup_dwo_unit_in_dwp
2115 (struct dwp_file
*dwp_file
, const char *comp_dir
,
2116 ULONGEST signature
, int is_debug_types
);
2118 static struct dwp_file
*get_dwp_file (void);
2120 static struct dwo_unit
*lookup_dwo_comp_unit
2121 (struct dwarf2_per_cu_data
*, const char *, const char *, ULONGEST
);
2123 static struct dwo_unit
*lookup_dwo_type_unit
2124 (struct signatured_type
*, const char *, const char *);
2126 static void queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data
*);
2128 static void free_dwo_file_cleanup (void *);
2130 static void process_cu_includes (void);
2132 static void check_producer (struct dwarf2_cu
*cu
);
2134 static void free_line_header_voidp (void *arg
);
2136 /* Various complaints about symbol reading that don't abort the process. */
2139 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
2141 complaint (&symfile_complaints
,
2142 _("statement list doesn't fit in .debug_line section"));
2146 dwarf2_debug_line_missing_file_complaint (void)
2148 complaint (&symfile_complaints
,
2149 _(".debug_line section has line data without a file"));
2153 dwarf2_debug_line_missing_end_sequence_complaint (void)
2155 complaint (&symfile_complaints
,
2156 _(".debug_line section has line "
2157 "program sequence without an end"));
2161 dwarf2_complex_location_expr_complaint (void)
2163 complaint (&symfile_complaints
, _("location expression too complex"));
2167 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
2170 complaint (&symfile_complaints
,
2171 _("const value length mismatch for '%s', got %d, expected %d"),
2176 dwarf2_section_buffer_overflow_complaint (struct dwarf2_section_info
*section
)
2178 complaint (&symfile_complaints
,
2179 _("debug info runs off end of %s section"
2181 get_section_name (section
),
2182 get_section_file_name (section
));
2186 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
2188 complaint (&symfile_complaints
,
2189 _("macro debug info contains a "
2190 "malformed macro definition:\n`%s'"),
2195 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
2197 complaint (&symfile_complaints
,
2198 _("invalid attribute class or form for '%s' in '%s'"),
2202 /* Hash function for line_header_hash. */
2205 line_header_hash (const struct line_header
*ofs
)
2207 return to_underlying (ofs
->sect_off
) ^ ofs
->offset_in_dwz
;
2210 /* Hash function for htab_create_alloc_ex for line_header_hash. */
2213 line_header_hash_voidp (const void *item
)
2215 const struct line_header
*ofs
= (const struct line_header
*) item
;
2217 return line_header_hash (ofs
);
2220 /* Equality function for line_header_hash. */
2223 line_header_eq_voidp (const void *item_lhs
, const void *item_rhs
)
2225 const struct line_header
*ofs_lhs
= (const struct line_header
*) item_lhs
;
2226 const struct line_header
*ofs_rhs
= (const struct line_header
*) item_rhs
;
2228 return (ofs_lhs
->sect_off
== ofs_rhs
->sect_off
2229 && ofs_lhs
->offset_in_dwz
== ofs_rhs
->offset_in_dwz
);
2234 /* Read the given attribute value as an address, taking the attribute's
2235 form into account. */
2238 attr_value_as_address (struct attribute
*attr
)
2242 if (attr
->form
!= DW_FORM_addr
&& attr
->form
!= DW_FORM_GNU_addr_index
)
2244 /* Aside from a few clearly defined exceptions, attributes that
2245 contain an address must always be in DW_FORM_addr form.
2246 Unfortunately, some compilers happen to be violating this
2247 requirement by encoding addresses using other forms, such
2248 as DW_FORM_data4 for example. For those broken compilers,
2249 we try to do our best, without any guarantee of success,
2250 to interpret the address correctly. It would also be nice
2251 to generate a complaint, but that would require us to maintain
2252 a list of legitimate cases where a non-address form is allowed,
2253 as well as update callers to pass in at least the CU's DWARF
2254 version. This is more overhead than what we're willing to
2255 expand for a pretty rare case. */
2256 addr
= DW_UNSND (attr
);
2259 addr
= DW_ADDR (attr
);
2264 /* The suffix for an index file. */
2265 #define INDEX_SUFFIX ".gdb-index"
2267 /* See declaration. */
2269 dwarf2_per_objfile::dwarf2_per_objfile (struct objfile
*objfile_
,
2270 const dwarf2_debug_sections
*names
)
2271 : objfile (objfile_
)
2274 names
= &dwarf2_elf_names
;
2276 bfd
*obfd
= objfile
->obfd
;
2278 for (asection
*sec
= obfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2279 locate_sections (obfd
, sec
, *names
);
2282 dwarf2_per_objfile::~dwarf2_per_objfile ()
2284 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
2285 free_cached_comp_units ();
2287 if (quick_file_names_table
)
2288 htab_delete (quick_file_names_table
);
2290 if (line_header_hash
)
2291 htab_delete (line_header_hash
);
2293 /* Everything else should be on the objfile obstack. */
2296 /* See declaration. */
2299 dwarf2_per_objfile::free_cached_comp_units ()
2301 dwarf2_per_cu_data
*per_cu
= read_in_chain
;
2302 dwarf2_per_cu_data
**last_chain
= &read_in_chain
;
2303 while (per_cu
!= NULL
)
2305 dwarf2_per_cu_data
*next_cu
= per_cu
->cu
->read_in_chain
;
2307 free_heap_comp_unit (per_cu
->cu
);
2308 *last_chain
= next_cu
;
2313 /* Try to locate the sections we need for DWARF 2 debugging
2314 information and return true if we have enough to do something.
2315 NAMES points to the dwarf2 section names, or is NULL if the standard
2316 ELF names are used. */
2319 dwarf2_has_info (struct objfile
*objfile
,
2320 const struct dwarf2_debug_sections
*names
)
2322 if (objfile
->flags
& OBJF_READNEVER
)
2325 dwarf2_per_objfile
= ((struct dwarf2_per_objfile
*)
2326 objfile_data (objfile
, dwarf2_objfile_data_key
));
2327 if (!dwarf2_per_objfile
)
2329 /* Initialize per-objfile state. */
2330 struct dwarf2_per_objfile
*data
2331 = XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_per_objfile
);
2333 dwarf2_per_objfile
= new (data
) struct dwarf2_per_objfile (objfile
, names
);
2334 set_objfile_data (objfile
, dwarf2_objfile_data_key
, dwarf2_per_objfile
);
2336 return (!dwarf2_per_objfile
->info
.is_virtual
2337 && dwarf2_per_objfile
->info
.s
.section
!= NULL
2338 && !dwarf2_per_objfile
->abbrev
.is_virtual
2339 && dwarf2_per_objfile
->abbrev
.s
.section
!= NULL
);
2342 /* Return the containing section of virtual section SECTION. */
2344 static struct dwarf2_section_info
*
2345 get_containing_section (const struct dwarf2_section_info
*section
)
2347 gdb_assert (section
->is_virtual
);
2348 return section
->s
.containing_section
;
2351 /* Return the bfd owner of SECTION. */
2354 get_section_bfd_owner (const struct dwarf2_section_info
*section
)
2356 if (section
->is_virtual
)
2358 section
= get_containing_section (section
);
2359 gdb_assert (!section
->is_virtual
);
2361 return section
->s
.section
->owner
;
2364 /* Return the bfd section of SECTION.
2365 Returns NULL if the section is not present. */
2368 get_section_bfd_section (const struct dwarf2_section_info
*section
)
2370 if (section
->is_virtual
)
2372 section
= get_containing_section (section
);
2373 gdb_assert (!section
->is_virtual
);
2375 return section
->s
.section
;
2378 /* Return the name of SECTION. */
2381 get_section_name (const struct dwarf2_section_info
*section
)
2383 asection
*sectp
= get_section_bfd_section (section
);
2385 gdb_assert (sectp
!= NULL
);
2386 return bfd_section_name (get_section_bfd_owner (section
), sectp
);
2389 /* Return the name of the file SECTION is in. */
2392 get_section_file_name (const struct dwarf2_section_info
*section
)
2394 bfd
*abfd
= get_section_bfd_owner (section
);
2396 return bfd_get_filename (abfd
);
2399 /* Return the id of SECTION.
2400 Returns 0 if SECTION doesn't exist. */
2403 get_section_id (const struct dwarf2_section_info
*section
)
2405 asection
*sectp
= get_section_bfd_section (section
);
2412 /* Return the flags of SECTION.
2413 SECTION (or containing section if this is a virtual section) must exist. */
2416 get_section_flags (const struct dwarf2_section_info
*section
)
2418 asection
*sectp
= get_section_bfd_section (section
);
2420 gdb_assert (sectp
!= NULL
);
2421 return bfd_get_section_flags (sectp
->owner
, sectp
);
2424 /* When loading sections, we look either for uncompressed section or for
2425 compressed section names. */
2428 section_is_p (const char *section_name
,
2429 const struct dwarf2_section_names
*names
)
2431 if (names
->normal
!= NULL
2432 && strcmp (section_name
, names
->normal
) == 0)
2434 if (names
->compressed
!= NULL
2435 && strcmp (section_name
, names
->compressed
) == 0)
2440 /* See declaration. */
2443 dwarf2_per_objfile::locate_sections (bfd
*abfd
, asection
*sectp
,
2444 const dwarf2_debug_sections
&names
)
2446 flagword aflag
= bfd_get_section_flags (abfd
, sectp
);
2448 if ((aflag
& SEC_HAS_CONTENTS
) == 0)
2451 else if (section_is_p (sectp
->name
, &names
.info
))
2453 this->info
.s
.section
= sectp
;
2454 this->info
.size
= bfd_get_section_size (sectp
);
2456 else if (section_is_p (sectp
->name
, &names
.abbrev
))
2458 this->abbrev
.s
.section
= sectp
;
2459 this->abbrev
.size
= bfd_get_section_size (sectp
);
2461 else if (section_is_p (sectp
->name
, &names
.line
))
2463 this->line
.s
.section
= sectp
;
2464 this->line
.size
= bfd_get_section_size (sectp
);
2466 else if (section_is_p (sectp
->name
, &names
.loc
))
2468 this->loc
.s
.section
= sectp
;
2469 this->loc
.size
= bfd_get_section_size (sectp
);
2471 else if (section_is_p (sectp
->name
, &names
.loclists
))
2473 this->loclists
.s
.section
= sectp
;
2474 this->loclists
.size
= bfd_get_section_size (sectp
);
2476 else if (section_is_p (sectp
->name
, &names
.macinfo
))
2478 this->macinfo
.s
.section
= sectp
;
2479 this->macinfo
.size
= bfd_get_section_size (sectp
);
2481 else if (section_is_p (sectp
->name
, &names
.macro
))
2483 this->macro
.s
.section
= sectp
;
2484 this->macro
.size
= bfd_get_section_size (sectp
);
2486 else if (section_is_p (sectp
->name
, &names
.str
))
2488 this->str
.s
.section
= sectp
;
2489 this->str
.size
= bfd_get_section_size (sectp
);
2491 else if (section_is_p (sectp
->name
, &names
.line_str
))
2493 this->line_str
.s
.section
= sectp
;
2494 this->line_str
.size
= bfd_get_section_size (sectp
);
2496 else if (section_is_p (sectp
->name
, &names
.addr
))
2498 this->addr
.s
.section
= sectp
;
2499 this->addr
.size
= bfd_get_section_size (sectp
);
2501 else if (section_is_p (sectp
->name
, &names
.frame
))
2503 this->frame
.s
.section
= sectp
;
2504 this->frame
.size
= bfd_get_section_size (sectp
);
2506 else if (section_is_p (sectp
->name
, &names
.eh_frame
))
2508 this->eh_frame
.s
.section
= sectp
;
2509 this->eh_frame
.size
= bfd_get_section_size (sectp
);
2511 else if (section_is_p (sectp
->name
, &names
.ranges
))
2513 this->ranges
.s
.section
= sectp
;
2514 this->ranges
.size
= bfd_get_section_size (sectp
);
2516 else if (section_is_p (sectp
->name
, &names
.rnglists
))
2518 this->rnglists
.s
.section
= sectp
;
2519 this->rnglists
.size
= bfd_get_section_size (sectp
);
2521 else if (section_is_p (sectp
->name
, &names
.types
))
2523 struct dwarf2_section_info type_section
;
2525 memset (&type_section
, 0, sizeof (type_section
));
2526 type_section
.s
.section
= sectp
;
2527 type_section
.size
= bfd_get_section_size (sectp
);
2529 VEC_safe_push (dwarf2_section_info_def
, this->types
,
2532 else if (section_is_p (sectp
->name
, &names
.gdb_index
))
2534 this->gdb_index
.s
.section
= sectp
;
2535 this->gdb_index
.size
= bfd_get_section_size (sectp
);
2538 if ((bfd_get_section_flags (abfd
, sectp
) & (SEC_LOAD
| SEC_ALLOC
))
2539 && bfd_section_vma (abfd
, sectp
) == 0)
2540 this->has_section_at_zero
= true;
2543 /* A helper function that decides whether a section is empty,
2547 dwarf2_section_empty_p (const struct dwarf2_section_info
*section
)
2549 if (section
->is_virtual
)
2550 return section
->size
== 0;
2551 return section
->s
.section
== NULL
|| section
->size
== 0;
2554 /* Read the contents of the section INFO.
2555 OBJFILE is the main object file, but not necessarily the file where
2556 the section comes from. E.g., for DWO files the bfd of INFO is the bfd
2558 If the section is compressed, uncompress it before returning. */
2561 dwarf2_read_section (struct objfile
*objfile
, struct dwarf2_section_info
*info
)
2565 gdb_byte
*buf
, *retbuf
;
2569 info
->buffer
= NULL
;
2572 if (dwarf2_section_empty_p (info
))
2575 sectp
= get_section_bfd_section (info
);
2577 /* If this is a virtual section we need to read in the real one first. */
2578 if (info
->is_virtual
)
2580 struct dwarf2_section_info
*containing_section
=
2581 get_containing_section (info
);
2583 gdb_assert (sectp
!= NULL
);
2584 if ((sectp
->flags
& SEC_RELOC
) != 0)
2586 error (_("Dwarf Error: DWP format V2 with relocations is not"
2587 " supported in section %s [in module %s]"),
2588 get_section_name (info
), get_section_file_name (info
));
2590 dwarf2_read_section (objfile
, containing_section
);
2591 /* Other code should have already caught virtual sections that don't
2593 gdb_assert (info
->virtual_offset
+ info
->size
2594 <= containing_section
->size
);
2595 /* If the real section is empty or there was a problem reading the
2596 section we shouldn't get here. */
2597 gdb_assert (containing_section
->buffer
!= NULL
);
2598 info
->buffer
= containing_section
->buffer
+ info
->virtual_offset
;
2602 /* If the section has relocations, we must read it ourselves.
2603 Otherwise we attach it to the BFD. */
2604 if ((sectp
->flags
& SEC_RELOC
) == 0)
2606 info
->buffer
= gdb_bfd_map_section (sectp
, &info
->size
);
2610 buf
= (gdb_byte
*) obstack_alloc (&objfile
->objfile_obstack
, info
->size
);
2613 /* When debugging .o files, we may need to apply relocations; see
2614 http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
2615 We never compress sections in .o files, so we only need to
2616 try this when the section is not compressed. */
2617 retbuf
= symfile_relocate_debug_section (objfile
, sectp
, buf
);
2620 info
->buffer
= retbuf
;
2624 abfd
= get_section_bfd_owner (info
);
2625 gdb_assert (abfd
!= NULL
);
2627 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
2628 || bfd_bread (buf
, info
->size
, abfd
) != info
->size
)
2630 error (_("Dwarf Error: Can't read DWARF data"
2631 " in section %s [in module %s]"),
2632 bfd_section_name (abfd
, sectp
), bfd_get_filename (abfd
));
2636 /* A helper function that returns the size of a section in a safe way.
2637 If you are positive that the section has been read before using the
2638 size, then it is safe to refer to the dwarf2_section_info object's
2639 "size" field directly. In other cases, you must call this
2640 function, because for compressed sections the size field is not set
2641 correctly until the section has been read. */
2643 static bfd_size_type
2644 dwarf2_section_size (struct objfile
*objfile
,
2645 struct dwarf2_section_info
*info
)
2648 dwarf2_read_section (objfile
, info
);
2652 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
2656 dwarf2_get_section_info (struct objfile
*objfile
,
2657 enum dwarf2_section_enum sect
,
2658 asection
**sectp
, const gdb_byte
**bufp
,
2659 bfd_size_type
*sizep
)
2661 struct dwarf2_per_objfile
*data
2662 = (struct dwarf2_per_objfile
*) objfile_data (objfile
,
2663 dwarf2_objfile_data_key
);
2664 struct dwarf2_section_info
*info
;
2666 /* We may see an objfile without any DWARF, in which case we just
2677 case DWARF2_DEBUG_FRAME
:
2678 info
= &data
->frame
;
2680 case DWARF2_EH_FRAME
:
2681 info
= &data
->eh_frame
;
2684 gdb_assert_not_reached ("unexpected section");
2687 dwarf2_read_section (objfile
, info
);
2689 *sectp
= get_section_bfd_section (info
);
2690 *bufp
= info
->buffer
;
2691 *sizep
= info
->size
;
2694 /* A helper function to find the sections for a .dwz file. */
2697 locate_dwz_sections (bfd
*abfd
, asection
*sectp
, void *arg
)
2699 struct dwz_file
*dwz_file
= (struct dwz_file
*) arg
;
2701 /* Note that we only support the standard ELF names, because .dwz
2702 is ELF-only (at the time of writing). */
2703 if (section_is_p (sectp
->name
, &dwarf2_elf_names
.abbrev
))
2705 dwz_file
->abbrev
.s
.section
= sectp
;
2706 dwz_file
->abbrev
.size
= bfd_get_section_size (sectp
);
2708 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.info
))
2710 dwz_file
->info
.s
.section
= sectp
;
2711 dwz_file
->info
.size
= bfd_get_section_size (sectp
);
2713 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.str
))
2715 dwz_file
->str
.s
.section
= sectp
;
2716 dwz_file
->str
.size
= bfd_get_section_size (sectp
);
2718 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.line
))
2720 dwz_file
->line
.s
.section
= sectp
;
2721 dwz_file
->line
.size
= bfd_get_section_size (sectp
);
2723 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.macro
))
2725 dwz_file
->macro
.s
.section
= sectp
;
2726 dwz_file
->macro
.size
= bfd_get_section_size (sectp
);
2728 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.gdb_index
))
2730 dwz_file
->gdb_index
.s
.section
= sectp
;
2731 dwz_file
->gdb_index
.size
= bfd_get_section_size (sectp
);
2735 /* Open the separate '.dwz' debug file, if needed. Return NULL if
2736 there is no .gnu_debugaltlink section in the file. Error if there
2737 is such a section but the file cannot be found. */
2739 static struct dwz_file
*
2740 dwarf2_get_dwz_file (void)
2742 const char *filename
;
2743 struct dwz_file
*result
;
2744 bfd_size_type buildid_len_arg
;
2748 if (dwarf2_per_objfile
->dwz_file
!= NULL
)
2749 return dwarf2_per_objfile
->dwz_file
;
2751 bfd_set_error (bfd_error_no_error
);
2752 gdb::unique_xmalloc_ptr
<char> data
2753 (bfd_get_alt_debug_link_info (dwarf2_per_objfile
->objfile
->obfd
,
2754 &buildid_len_arg
, &buildid
));
2757 if (bfd_get_error () == bfd_error_no_error
)
2759 error (_("could not read '.gnu_debugaltlink' section: %s"),
2760 bfd_errmsg (bfd_get_error ()));
2763 gdb::unique_xmalloc_ptr
<bfd_byte
> buildid_holder (buildid
);
2765 buildid_len
= (size_t) buildid_len_arg
;
2767 filename
= data
.get ();
2769 std::string abs_storage
;
2770 if (!IS_ABSOLUTE_PATH (filename
))
2772 gdb::unique_xmalloc_ptr
<char> abs
2773 = gdb_realpath (objfile_name (dwarf2_per_objfile
->objfile
));
2775 abs_storage
= ldirname (abs
.get ()) + SLASH_STRING
+ filename
;
2776 filename
= abs_storage
.c_str ();
2779 /* First try the file name given in the section. If that doesn't
2780 work, try to use the build-id instead. */
2781 gdb_bfd_ref_ptr
dwz_bfd (gdb_bfd_open (filename
, gnutarget
, -1));
2782 if (dwz_bfd
!= NULL
)
2784 if (!build_id_verify (dwz_bfd
.get (), buildid_len
, buildid
))
2788 if (dwz_bfd
== NULL
)
2789 dwz_bfd
= build_id_to_debug_bfd (buildid_len
, buildid
);
2791 if (dwz_bfd
== NULL
)
2792 error (_("could not find '.gnu_debugaltlink' file for %s"),
2793 objfile_name (dwarf2_per_objfile
->objfile
));
2795 result
= OBSTACK_ZALLOC (&dwarf2_per_objfile
->objfile
->objfile_obstack
,
2797 result
->dwz_bfd
= dwz_bfd
.release ();
2799 bfd_map_over_sections (result
->dwz_bfd
, locate_dwz_sections
, result
);
2801 gdb_bfd_record_inclusion (dwarf2_per_objfile
->objfile
->obfd
, result
->dwz_bfd
);
2802 dwarf2_per_objfile
->dwz_file
= result
;
2806 /* DWARF quick_symbols_functions support. */
2808 /* TUs can share .debug_line entries, and there can be a lot more TUs than
2809 unique line tables, so we maintain a separate table of all .debug_line
2810 derived entries to support the sharing.
2811 All the quick functions need is the list of file names. We discard the
2812 line_header when we're done and don't need to record it here. */
2813 struct quick_file_names
2815 /* The data used to construct the hash key. */
2816 struct stmt_list_hash hash
;
2818 /* The number of entries in file_names, real_names. */
2819 unsigned int num_file_names
;
2821 /* The file names from the line table, after being run through
2823 const char **file_names
;
2825 /* The file names from the line table after being run through
2826 gdb_realpath. These are computed lazily. */
2827 const char **real_names
;
2830 /* When using the index (and thus not using psymtabs), each CU has an
2831 object of this type. This is used to hold information needed by
2832 the various "quick" methods. */
2833 struct dwarf2_per_cu_quick_data
2835 /* The file table. This can be NULL if there was no file table
2836 or it's currently not read in.
2837 NOTE: This points into dwarf2_per_objfile->quick_file_names_table. */
2838 struct quick_file_names
*file_names
;
2840 /* The corresponding symbol table. This is NULL if symbols for this
2841 CU have not yet been read. */
2842 struct compunit_symtab
*compunit_symtab
;
2844 /* A temporary mark bit used when iterating over all CUs in
2845 expand_symtabs_matching. */
2846 unsigned int mark
: 1;
2848 /* True if we've tried to read the file table and found there isn't one.
2849 There will be no point in trying to read it again next time. */
2850 unsigned int no_file_data
: 1;
2853 /* Utility hash function for a stmt_list_hash. */
2856 hash_stmt_list_entry (const struct stmt_list_hash
*stmt_list_hash
)
2860 if (stmt_list_hash
->dwo_unit
!= NULL
)
2861 v
+= (uintptr_t) stmt_list_hash
->dwo_unit
->dwo_file
;
2862 v
+= to_underlying (stmt_list_hash
->line_sect_off
);
2866 /* Utility equality function for a stmt_list_hash. */
2869 eq_stmt_list_entry (const struct stmt_list_hash
*lhs
,
2870 const struct stmt_list_hash
*rhs
)
2872 if ((lhs
->dwo_unit
!= NULL
) != (rhs
->dwo_unit
!= NULL
))
2874 if (lhs
->dwo_unit
!= NULL
2875 && lhs
->dwo_unit
->dwo_file
!= rhs
->dwo_unit
->dwo_file
)
2878 return lhs
->line_sect_off
== rhs
->line_sect_off
;
2881 /* Hash function for a quick_file_names. */
2884 hash_file_name_entry (const void *e
)
2886 const struct quick_file_names
*file_data
2887 = (const struct quick_file_names
*) e
;
2889 return hash_stmt_list_entry (&file_data
->hash
);
2892 /* Equality function for a quick_file_names. */
2895 eq_file_name_entry (const void *a
, const void *b
)
2897 const struct quick_file_names
*ea
= (const struct quick_file_names
*) a
;
2898 const struct quick_file_names
*eb
= (const struct quick_file_names
*) b
;
2900 return eq_stmt_list_entry (&ea
->hash
, &eb
->hash
);
2903 /* Delete function for a quick_file_names. */
2906 delete_file_name_entry (void *e
)
2908 struct quick_file_names
*file_data
= (struct quick_file_names
*) e
;
2911 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
2913 xfree ((void*) file_data
->file_names
[i
]);
2914 if (file_data
->real_names
)
2915 xfree ((void*) file_data
->real_names
[i
]);
2918 /* The space for the struct itself lives on objfile_obstack,
2919 so we don't free it here. */
2922 /* Create a quick_file_names hash table. */
2925 create_quick_file_names_table (unsigned int nr_initial_entries
)
2927 return htab_create_alloc (nr_initial_entries
,
2928 hash_file_name_entry
, eq_file_name_entry
,
2929 delete_file_name_entry
, xcalloc
, xfree
);
2932 /* Read in PER_CU->CU. This function is unrelated to symtabs, symtab would
2933 have to be created afterwards. You should call age_cached_comp_units after
2934 processing PER_CU->CU. dw2_setup must have been already called. */
2937 load_cu (struct dwarf2_per_cu_data
*per_cu
)
2939 if (per_cu
->is_debug_types
)
2940 load_full_type_unit (per_cu
);
2942 load_full_comp_unit (per_cu
, language_minimal
);
2944 if (per_cu
->cu
== NULL
)
2945 return; /* Dummy CU. */
2947 dwarf2_find_base_address (per_cu
->cu
->dies
, per_cu
->cu
);
2950 /* Read in the symbols for PER_CU. */
2953 dw2_do_instantiate_symtab (struct dwarf2_per_cu_data
*per_cu
)
2955 struct cleanup
*back_to
;
2957 /* Skip type_unit_groups, reading the type units they contain
2958 is handled elsewhere. */
2959 if (IS_TYPE_UNIT_GROUP (per_cu
))
2962 back_to
= make_cleanup (dwarf2_release_queue
, NULL
);
2964 if (dwarf2_per_objfile
->using_index
2965 ? per_cu
->v
.quick
->compunit_symtab
== NULL
2966 : (per_cu
->v
.psymtab
== NULL
|| !per_cu
->v
.psymtab
->readin
))
2968 queue_comp_unit (per_cu
, language_minimal
);
2971 /* If we just loaded a CU from a DWO, and we're working with an index
2972 that may badly handle TUs, load all the TUs in that DWO as well.
2973 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
2974 if (!per_cu
->is_debug_types
2975 && per_cu
->cu
!= NULL
2976 && per_cu
->cu
->dwo_unit
!= NULL
2977 && dwarf2_per_objfile
->index_table
!= NULL
2978 && dwarf2_per_objfile
->index_table
->version
<= 7
2979 /* DWP files aren't supported yet. */
2980 && get_dwp_file () == NULL
)
2981 queue_and_load_all_dwo_tus (per_cu
);
2986 /* Age the cache, releasing compilation units that have not
2987 been used recently. */
2988 age_cached_comp_units ();
2990 do_cleanups (back_to
);
2993 /* Ensure that the symbols for PER_CU have been read in. OBJFILE is
2994 the objfile from which this CU came. Returns the resulting symbol
2997 static struct compunit_symtab
*
2998 dw2_instantiate_symtab (struct dwarf2_per_cu_data
*per_cu
)
3000 gdb_assert (dwarf2_per_objfile
->using_index
);
3001 if (!per_cu
->v
.quick
->compunit_symtab
)
3003 struct cleanup
*back_to
= make_cleanup (free_cached_comp_units
, NULL
);
3004 scoped_restore decrementer
= increment_reading_symtab ();
3005 dw2_do_instantiate_symtab (per_cu
);
3006 process_cu_includes ();
3007 do_cleanups (back_to
);
3010 return per_cu
->v
.quick
->compunit_symtab
;
3013 /* Return the CU/TU given its index.
3015 This is intended for loops like:
3017 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
3018 + dwarf2_per_objfile->n_type_units); ++i)
3020 struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (i);
3026 static struct dwarf2_per_cu_data
*
3027 dw2_get_cutu (int index
)
3029 if (index
>= dwarf2_per_objfile
->n_comp_units
)
3031 index
-= dwarf2_per_objfile
->n_comp_units
;
3032 gdb_assert (index
< dwarf2_per_objfile
->n_type_units
);
3033 return &dwarf2_per_objfile
->all_type_units
[index
]->per_cu
;
3036 return dwarf2_per_objfile
->all_comp_units
[index
];
3039 /* Return the CU given its index.
3040 This differs from dw2_get_cutu in that it's for when you know INDEX
3043 static struct dwarf2_per_cu_data
*
3044 dw2_get_cu (int index
)
3046 gdb_assert (index
>= 0 && index
< dwarf2_per_objfile
->n_comp_units
);
3048 return dwarf2_per_objfile
->all_comp_units
[index
];
3051 /* A helper for create_cus_from_index that handles a given list of
3055 create_cus_from_index_list (struct objfile
*objfile
,
3056 const gdb_byte
*cu_list
, offset_type n_elements
,
3057 struct dwarf2_section_info
*section
,
3063 for (i
= 0; i
< n_elements
; i
+= 2)
3065 gdb_static_assert (sizeof (ULONGEST
) >= 8);
3067 sect_offset sect_off
3068 = (sect_offset
) extract_unsigned_integer (cu_list
, 8, BFD_ENDIAN_LITTLE
);
3069 ULONGEST length
= extract_unsigned_integer (cu_list
+ 8, 8, BFD_ENDIAN_LITTLE
);
3072 dwarf2_per_cu_data
*the_cu
3073 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
3074 struct dwarf2_per_cu_data
);
3075 the_cu
->sect_off
= sect_off
;
3076 the_cu
->length
= length
;
3077 the_cu
->objfile
= objfile
;
3078 the_cu
->section
= section
;
3079 the_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
3080 struct dwarf2_per_cu_quick_data
);
3081 the_cu
->is_dwz
= is_dwz
;
3082 dwarf2_per_objfile
->all_comp_units
[base_offset
+ i
/ 2] = the_cu
;
3086 /* Read the CU list from the mapped index, and use it to create all
3087 the CU objects for this objfile. */
3090 create_cus_from_index (struct objfile
*objfile
,
3091 const gdb_byte
*cu_list
, offset_type cu_list_elements
,
3092 const gdb_byte
*dwz_list
, offset_type dwz_elements
)
3094 struct dwz_file
*dwz
;
3096 dwarf2_per_objfile
->n_comp_units
= (cu_list_elements
+ dwz_elements
) / 2;
3097 dwarf2_per_objfile
->all_comp_units
=
3098 XOBNEWVEC (&objfile
->objfile_obstack
, struct dwarf2_per_cu_data
*,
3099 dwarf2_per_objfile
->n_comp_units
);
3101 create_cus_from_index_list (objfile
, cu_list
, cu_list_elements
,
3102 &dwarf2_per_objfile
->info
, 0, 0);
3104 if (dwz_elements
== 0)
3107 dwz
= dwarf2_get_dwz_file ();
3108 create_cus_from_index_list (objfile
, dwz_list
, dwz_elements
, &dwz
->info
, 1,
3109 cu_list_elements
/ 2);
3112 /* Create the signatured type hash table from the index. */
3115 create_signatured_type_table_from_index (struct objfile
*objfile
,
3116 struct dwarf2_section_info
*section
,
3117 const gdb_byte
*bytes
,
3118 offset_type elements
)
3121 htab_t sig_types_hash
;
3123 dwarf2_per_objfile
->n_type_units
3124 = dwarf2_per_objfile
->n_allocated_type_units
3126 dwarf2_per_objfile
->all_type_units
=
3127 XNEWVEC (struct signatured_type
*, dwarf2_per_objfile
->n_type_units
);
3129 sig_types_hash
= allocate_signatured_type_table (objfile
);
3131 for (i
= 0; i
< elements
; i
+= 3)
3133 struct signatured_type
*sig_type
;
3136 cu_offset type_offset_in_tu
;
3138 gdb_static_assert (sizeof (ULONGEST
) >= 8);
3139 sect_offset sect_off
3140 = (sect_offset
) extract_unsigned_integer (bytes
, 8, BFD_ENDIAN_LITTLE
);
3142 = (cu_offset
) extract_unsigned_integer (bytes
+ 8, 8,
3144 signature
= extract_unsigned_integer (bytes
+ 16, 8, BFD_ENDIAN_LITTLE
);
3147 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
3148 struct signatured_type
);
3149 sig_type
->signature
= signature
;
3150 sig_type
->type_offset_in_tu
= type_offset_in_tu
;
3151 sig_type
->per_cu
.is_debug_types
= 1;
3152 sig_type
->per_cu
.section
= section
;
3153 sig_type
->per_cu
.sect_off
= sect_off
;
3154 sig_type
->per_cu
.objfile
= objfile
;
3155 sig_type
->per_cu
.v
.quick
3156 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
3157 struct dwarf2_per_cu_quick_data
);
3159 slot
= htab_find_slot (sig_types_hash
, sig_type
, INSERT
);
3162 dwarf2_per_objfile
->all_type_units
[i
/ 3] = sig_type
;
3165 dwarf2_per_objfile
->signatured_types
= sig_types_hash
;
3168 /* Read the address map data from the mapped index, and use it to
3169 populate the objfile's psymtabs_addrmap. */
3172 create_addrmap_from_index (struct objfile
*objfile
, struct mapped_index
*index
)
3174 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3175 const gdb_byte
*iter
, *end
;
3176 struct addrmap
*mutable_map
;
3179 auto_obstack temp_obstack
;
3181 mutable_map
= addrmap_create_mutable (&temp_obstack
);
3183 iter
= index
->address_table
;
3184 end
= iter
+ index
->address_table_size
;
3186 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3190 ULONGEST hi
, lo
, cu_index
;
3191 lo
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
3193 hi
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
3195 cu_index
= extract_unsigned_integer (iter
, 4, BFD_ENDIAN_LITTLE
);
3200 complaint (&symfile_complaints
,
3201 _(".gdb_index address table has invalid range (%s - %s)"),
3202 hex_string (lo
), hex_string (hi
));
3206 if (cu_index
>= dwarf2_per_objfile
->n_comp_units
)
3208 complaint (&symfile_complaints
,
3209 _(".gdb_index address table has invalid CU number %u"),
3210 (unsigned) cu_index
);
3214 lo
= gdbarch_adjust_dwarf2_addr (gdbarch
, lo
+ baseaddr
);
3215 hi
= gdbarch_adjust_dwarf2_addr (gdbarch
, hi
+ baseaddr
);
3216 addrmap_set_empty (mutable_map
, lo
, hi
- 1, dw2_get_cutu (cu_index
));
3219 objfile
->psymtabs_addrmap
= addrmap_create_fixed (mutable_map
,
3220 &objfile
->objfile_obstack
);
3223 /* The hash function for strings in the mapped index. This is the same as
3224 SYMBOL_HASH_NEXT, but we keep a separate copy to maintain control over the
3225 implementation. This is necessary because the hash function is tied to the
3226 format of the mapped index file. The hash values do not have to match with
3229 Use INT_MAX for INDEX_VERSION if you generate the current index format. */
3232 mapped_index_string_hash (int index_version
, const void *p
)
3234 const unsigned char *str
= (const unsigned char *) p
;
3238 while ((c
= *str
++) != 0)
3240 if (index_version
>= 5)
3242 r
= r
* 67 + c
- 113;
3248 /* Find a slot in the mapped index INDEX for the object named NAME.
3249 If NAME is found, set *VEC_OUT to point to the CU vector in the
3250 constant pool and return true. If NAME cannot be found, return
3254 find_slot_in_mapped_hash (struct mapped_index
*index
, const char *name
,
3255 offset_type
**vec_out
)
3258 offset_type slot
, step
;
3259 int (*cmp
) (const char *, const char *);
3261 gdb::unique_xmalloc_ptr
<char> without_params
;
3262 if (current_language
->la_language
== language_cplus
3263 || current_language
->la_language
== language_fortran
3264 || current_language
->la_language
== language_d
)
3266 /* NAME is already canonical. Drop any qualifiers as .gdb_index does
3269 if (strchr (name
, '(') != NULL
)
3271 without_params
= cp_remove_params (name
);
3273 if (without_params
!= NULL
)
3274 name
= without_params
.get ();
3278 /* Index version 4 did not support case insensitive searches. But the
3279 indices for case insensitive languages are built in lowercase, therefore
3280 simulate our NAME being searched is also lowercased. */
3281 hash
= mapped_index_string_hash ((index
->version
== 4
3282 && case_sensitivity
== case_sensitive_off
3283 ? 5 : index
->version
),
3286 slot
= hash
& (index
->symbol_table_slots
- 1);
3287 step
= ((hash
* 17) & (index
->symbol_table_slots
- 1)) | 1;
3288 cmp
= (case_sensitivity
== case_sensitive_on
? strcmp
: strcasecmp
);
3292 /* Convert a slot number to an offset into the table. */
3293 offset_type i
= 2 * slot
;
3295 if (index
->symbol_table
[i
] == 0 && index
->symbol_table
[i
+ 1] == 0)
3298 str
= index
->constant_pool
+ MAYBE_SWAP (index
->symbol_table
[i
]);
3299 if (!cmp (name
, str
))
3301 *vec_out
= (offset_type
*) (index
->constant_pool
3302 + MAYBE_SWAP (index
->symbol_table
[i
+ 1]));
3306 slot
= (slot
+ step
) & (index
->symbol_table_slots
- 1);
3310 /* A helper function that reads the .gdb_index from SECTION and fills
3311 in MAP. FILENAME is the name of the file containing the section;
3312 it is used for error reporting. DEPRECATED_OK is nonzero if it is
3313 ok to use deprecated sections.
3315 CU_LIST, CU_LIST_ELEMENTS, TYPES_LIST, and TYPES_LIST_ELEMENTS are
3316 out parameters that are filled in with information about the CU and
3317 TU lists in the section.
3319 Returns 1 if all went well, 0 otherwise. */
3322 read_index_from_section (struct objfile
*objfile
,
3323 const char *filename
,
3325 struct dwarf2_section_info
*section
,
3326 struct mapped_index
*map
,
3327 const gdb_byte
**cu_list
,
3328 offset_type
*cu_list_elements
,
3329 const gdb_byte
**types_list
,
3330 offset_type
*types_list_elements
)
3332 const gdb_byte
*addr
;
3333 offset_type version
;
3334 offset_type
*metadata
;
3337 if (dwarf2_section_empty_p (section
))
3340 /* Older elfutils strip versions could keep the section in the main
3341 executable while splitting it for the separate debug info file. */
3342 if ((get_section_flags (section
) & SEC_HAS_CONTENTS
) == 0)
3345 dwarf2_read_section (objfile
, section
);
3347 addr
= section
->buffer
;
3348 /* Version check. */
3349 version
= MAYBE_SWAP (*(offset_type
*) addr
);
3350 /* Versions earlier than 3 emitted every copy of a psymbol. This
3351 causes the index to behave very poorly for certain requests. Version 3
3352 contained incomplete addrmap. So, it seems better to just ignore such
3356 static int warning_printed
= 0;
3357 if (!warning_printed
)
3359 warning (_("Skipping obsolete .gdb_index section in %s."),
3361 warning_printed
= 1;
3365 /* Index version 4 uses a different hash function than index version
3368 Versions earlier than 6 did not emit psymbols for inlined
3369 functions. Using these files will cause GDB not to be able to
3370 set breakpoints on inlined functions by name, so we ignore these
3371 indices unless the user has done
3372 "set use-deprecated-index-sections on". */
3373 if (version
< 6 && !deprecated_ok
)
3375 static int warning_printed
= 0;
3376 if (!warning_printed
)
3379 Skipping deprecated .gdb_index section in %s.\n\
3380 Do \"set use-deprecated-index-sections on\" before the file is read\n\
3381 to use the section anyway."),
3383 warning_printed
= 1;
3387 /* Version 7 indices generated by gold refer to the CU for a symbol instead
3388 of the TU (for symbols coming from TUs),
3389 http://sourceware.org/bugzilla/show_bug.cgi?id=15021.
3390 Plus gold-generated indices can have duplicate entries for global symbols,
3391 http://sourceware.org/bugzilla/show_bug.cgi?id=15646.
3392 These are just performance bugs, and we can't distinguish gdb-generated
3393 indices from gold-generated ones, so issue no warning here. */
3395 /* Indexes with higher version than the one supported by GDB may be no
3396 longer backward compatible. */
3400 map
->version
= version
;
3401 map
->total_size
= section
->size
;
3403 metadata
= (offset_type
*) (addr
+ sizeof (offset_type
));
3406 *cu_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
3407 *cu_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1]) - MAYBE_SWAP (metadata
[i
]))
3411 *types_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
3412 *types_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1])
3413 - MAYBE_SWAP (metadata
[i
]))
3417 map
->address_table
= addr
+ MAYBE_SWAP (metadata
[i
]);
3418 map
->address_table_size
= (MAYBE_SWAP (metadata
[i
+ 1])
3419 - MAYBE_SWAP (metadata
[i
]));
3422 map
->symbol_table
= (offset_type
*) (addr
+ MAYBE_SWAP (metadata
[i
]));
3423 map
->symbol_table_slots
= ((MAYBE_SWAP (metadata
[i
+ 1])
3424 - MAYBE_SWAP (metadata
[i
]))
3425 / (2 * sizeof (offset_type
)));
3428 map
->constant_pool
= (char *) (addr
+ MAYBE_SWAP (metadata
[i
]));
3434 /* Read the index file. If everything went ok, initialize the "quick"
3435 elements of all the CUs and return 1. Otherwise, return 0. */
3438 dwarf2_read_index (struct objfile
*objfile
)
3440 struct mapped_index local_map
, *map
;
3441 const gdb_byte
*cu_list
, *types_list
, *dwz_list
= NULL
;
3442 offset_type cu_list_elements
, types_list_elements
, dwz_list_elements
= 0;
3443 struct dwz_file
*dwz
;
3445 if (!read_index_from_section (objfile
, objfile_name (objfile
),
3446 use_deprecated_index_sections
,
3447 &dwarf2_per_objfile
->gdb_index
, &local_map
,
3448 &cu_list
, &cu_list_elements
,
3449 &types_list
, &types_list_elements
))
3452 /* Don't use the index if it's empty. */
3453 if (local_map
.symbol_table_slots
== 0)
3456 /* If there is a .dwz file, read it so we can get its CU list as
3458 dwz
= dwarf2_get_dwz_file ();
3461 struct mapped_index dwz_map
;
3462 const gdb_byte
*dwz_types_ignore
;
3463 offset_type dwz_types_elements_ignore
;
3465 if (!read_index_from_section (objfile
, bfd_get_filename (dwz
->dwz_bfd
),
3467 &dwz
->gdb_index
, &dwz_map
,
3468 &dwz_list
, &dwz_list_elements
,
3470 &dwz_types_elements_ignore
))
3472 warning (_("could not read '.gdb_index' section from %s; skipping"),
3473 bfd_get_filename (dwz
->dwz_bfd
));
3478 create_cus_from_index (objfile
, cu_list
, cu_list_elements
, dwz_list
,
3481 if (types_list_elements
)
3483 struct dwarf2_section_info
*section
;
3485 /* We can only handle a single .debug_types when we have an
3487 if (VEC_length (dwarf2_section_info_def
, dwarf2_per_objfile
->types
) != 1)
3490 section
= VEC_index (dwarf2_section_info_def
,
3491 dwarf2_per_objfile
->types
, 0);
3493 create_signatured_type_table_from_index (objfile
, section
, types_list
,
3494 types_list_elements
);
3497 create_addrmap_from_index (objfile
, &local_map
);
3499 map
= XOBNEW (&objfile
->objfile_obstack
, struct mapped_index
);
3500 map
= new (map
) mapped_index ();
3503 dwarf2_per_objfile
->index_table
= map
;
3504 dwarf2_per_objfile
->using_index
= 1;
3505 dwarf2_per_objfile
->quick_file_names_table
=
3506 create_quick_file_names_table (dwarf2_per_objfile
->n_comp_units
);
3511 /* A helper for the "quick" functions which sets the global
3512 dwarf2_per_objfile according to OBJFILE. */
3515 dw2_setup (struct objfile
*objfile
)
3517 dwarf2_per_objfile
= ((struct dwarf2_per_objfile
*)
3518 objfile_data (objfile
, dwarf2_objfile_data_key
));
3519 gdb_assert (dwarf2_per_objfile
);
3522 /* die_reader_func for dw2_get_file_names. */
3525 dw2_get_file_names_reader (const struct die_reader_specs
*reader
,
3526 const gdb_byte
*info_ptr
,
3527 struct die_info
*comp_unit_die
,
3531 struct dwarf2_cu
*cu
= reader
->cu
;
3532 struct dwarf2_per_cu_data
*this_cu
= cu
->per_cu
;
3533 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
3534 struct dwarf2_per_cu_data
*lh_cu
;
3535 struct attribute
*attr
;
3538 struct quick_file_names
*qfn
;
3540 gdb_assert (! this_cu
->is_debug_types
);
3542 /* Our callers never want to match partial units -- instead they
3543 will match the enclosing full CU. */
3544 if (comp_unit_die
->tag
== DW_TAG_partial_unit
)
3546 this_cu
->v
.quick
->no_file_data
= 1;
3554 sect_offset line_offset
{};
3556 attr
= dwarf2_attr (comp_unit_die
, DW_AT_stmt_list
, cu
);
3559 struct quick_file_names find_entry
;
3561 line_offset
= (sect_offset
) DW_UNSND (attr
);
3563 /* We may have already read in this line header (TU line header sharing).
3564 If we have we're done. */
3565 find_entry
.hash
.dwo_unit
= cu
->dwo_unit
;
3566 find_entry
.hash
.line_sect_off
= line_offset
;
3567 slot
= htab_find_slot (dwarf2_per_objfile
->quick_file_names_table
,
3568 &find_entry
, INSERT
);
3571 lh_cu
->v
.quick
->file_names
= (struct quick_file_names
*) *slot
;
3575 lh
= dwarf_decode_line_header (line_offset
, cu
);
3579 lh_cu
->v
.quick
->no_file_data
= 1;
3583 qfn
= XOBNEW (&objfile
->objfile_obstack
, struct quick_file_names
);
3584 qfn
->hash
.dwo_unit
= cu
->dwo_unit
;
3585 qfn
->hash
.line_sect_off
= line_offset
;
3586 gdb_assert (slot
!= NULL
);
3589 file_and_directory fnd
= find_file_and_directory (comp_unit_die
, cu
);
3591 qfn
->num_file_names
= lh
->file_names
.size ();
3593 XOBNEWVEC (&objfile
->objfile_obstack
, const char *, lh
->file_names
.size ());
3594 for (i
= 0; i
< lh
->file_names
.size (); ++i
)
3595 qfn
->file_names
[i
] = file_full_name (i
+ 1, lh
.get (), fnd
.comp_dir
);
3596 qfn
->real_names
= NULL
;
3598 lh_cu
->v
.quick
->file_names
= qfn
;
3601 /* A helper for the "quick" functions which attempts to read the line
3602 table for THIS_CU. */
3604 static struct quick_file_names
*
3605 dw2_get_file_names (struct dwarf2_per_cu_data
*this_cu
)
3607 /* This should never be called for TUs. */
3608 gdb_assert (! this_cu
->is_debug_types
);
3609 /* Nor type unit groups. */
3610 gdb_assert (! IS_TYPE_UNIT_GROUP (this_cu
));
3612 if (this_cu
->v
.quick
->file_names
!= NULL
)
3613 return this_cu
->v
.quick
->file_names
;
3614 /* If we know there is no line data, no point in looking again. */
3615 if (this_cu
->v
.quick
->no_file_data
)
3618 init_cutu_and_read_dies_simple (this_cu
, dw2_get_file_names_reader
, NULL
);
3620 if (this_cu
->v
.quick
->no_file_data
)
3622 return this_cu
->v
.quick
->file_names
;
3625 /* A helper for the "quick" functions which computes and caches the
3626 real path for a given file name from the line table. */
3629 dw2_get_real_path (struct objfile
*objfile
,
3630 struct quick_file_names
*qfn
, int index
)
3632 if (qfn
->real_names
== NULL
)
3633 qfn
->real_names
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
3634 qfn
->num_file_names
, const char *);
3636 if (qfn
->real_names
[index
] == NULL
)
3637 qfn
->real_names
[index
] = gdb_realpath (qfn
->file_names
[index
]).release ();
3639 return qfn
->real_names
[index
];
3642 static struct symtab
*
3643 dw2_find_last_source_symtab (struct objfile
*objfile
)
3645 struct compunit_symtab
*cust
;
3648 dw2_setup (objfile
);
3649 index
= dwarf2_per_objfile
->n_comp_units
- 1;
3650 cust
= dw2_instantiate_symtab (dw2_get_cutu (index
));
3653 return compunit_primary_filetab (cust
);
3656 /* Traversal function for dw2_forget_cached_source_info. */
3659 dw2_free_cached_file_names (void **slot
, void *info
)
3661 struct quick_file_names
*file_data
= (struct quick_file_names
*) *slot
;
3663 if (file_data
->real_names
)
3667 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
3669 xfree ((void*) file_data
->real_names
[i
]);
3670 file_data
->real_names
[i
] = NULL
;
3678 dw2_forget_cached_source_info (struct objfile
*objfile
)
3680 dw2_setup (objfile
);
3682 htab_traverse_noresize (dwarf2_per_objfile
->quick_file_names_table
,
3683 dw2_free_cached_file_names
, NULL
);
3686 /* Helper function for dw2_map_symtabs_matching_filename that expands
3687 the symtabs and calls the iterator. */
3690 dw2_map_expand_apply (struct objfile
*objfile
,
3691 struct dwarf2_per_cu_data
*per_cu
,
3692 const char *name
, const char *real_path
,
3693 gdb::function_view
<bool (symtab
*)> callback
)
3695 struct compunit_symtab
*last_made
= objfile
->compunit_symtabs
;
3697 /* Don't visit already-expanded CUs. */
3698 if (per_cu
->v
.quick
->compunit_symtab
)
3701 /* This may expand more than one symtab, and we want to iterate over
3703 dw2_instantiate_symtab (per_cu
);
3705 return iterate_over_some_symtabs (name
, real_path
, objfile
->compunit_symtabs
,
3706 last_made
, callback
);
3709 /* Implementation of the map_symtabs_matching_filename method. */
3712 dw2_map_symtabs_matching_filename
3713 (struct objfile
*objfile
, const char *name
, const char *real_path
,
3714 gdb::function_view
<bool (symtab
*)> callback
)
3717 const char *name_basename
= lbasename (name
);
3719 dw2_setup (objfile
);
3721 /* The rule is CUs specify all the files, including those used by
3722 any TU, so there's no need to scan TUs here. */
3724 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
3727 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
3728 struct quick_file_names
*file_data
;
3730 /* We only need to look at symtabs not already expanded. */
3731 if (per_cu
->v
.quick
->compunit_symtab
)
3734 file_data
= dw2_get_file_names (per_cu
);
3735 if (file_data
== NULL
)
3738 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
3740 const char *this_name
= file_data
->file_names
[j
];
3741 const char *this_real_name
;
3743 if (compare_filenames_for_search (this_name
, name
))
3745 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3751 /* Before we invoke realpath, which can get expensive when many
3752 files are involved, do a quick comparison of the basenames. */
3753 if (! basenames_may_differ
3754 && FILENAME_CMP (lbasename (this_name
), name_basename
) != 0)
3757 this_real_name
= dw2_get_real_path (objfile
, file_data
, j
);
3758 if (compare_filenames_for_search (this_real_name
, name
))
3760 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3766 if (real_path
!= NULL
)
3768 gdb_assert (IS_ABSOLUTE_PATH (real_path
));
3769 gdb_assert (IS_ABSOLUTE_PATH (name
));
3770 if (this_real_name
!= NULL
3771 && FILENAME_CMP (real_path
, this_real_name
) == 0)
3773 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3785 /* Struct used to manage iterating over all CUs looking for a symbol. */
3787 struct dw2_symtab_iterator
3789 /* The internalized form of .gdb_index. */
3790 struct mapped_index
*index
;
3791 /* If non-zero, only look for symbols that match BLOCK_INDEX. */
3792 int want_specific_block
;
3793 /* One of GLOBAL_BLOCK or STATIC_BLOCK.
3794 Unused if !WANT_SPECIFIC_BLOCK. */
3796 /* The kind of symbol we're looking for. */
3798 /* The list of CUs from the index entry of the symbol,
3799 or NULL if not found. */
3801 /* The next element in VEC to look at. */
3803 /* The number of elements in VEC, or zero if there is no match. */
3805 /* Have we seen a global version of the symbol?
3806 If so we can ignore all further global instances.
3807 This is to work around gold/15646, inefficient gold-generated
3812 /* Initialize the index symtab iterator ITER.
3813 If WANT_SPECIFIC_BLOCK is non-zero, only look for symbols
3814 in block BLOCK_INDEX. Otherwise BLOCK_INDEX is ignored. */
3817 dw2_symtab_iter_init (struct dw2_symtab_iterator
*iter
,
3818 struct mapped_index
*index
,
3819 int want_specific_block
,
3824 iter
->index
= index
;
3825 iter
->want_specific_block
= want_specific_block
;
3826 iter
->block_index
= block_index
;
3827 iter
->domain
= domain
;
3829 iter
->global_seen
= 0;
3831 if (find_slot_in_mapped_hash (index
, name
, &iter
->vec
))
3832 iter
->length
= MAYBE_SWAP (*iter
->vec
);
3840 /* Return the next matching CU or NULL if there are no more. */
3842 static struct dwarf2_per_cu_data
*
3843 dw2_symtab_iter_next (struct dw2_symtab_iterator
*iter
)
3845 for ( ; iter
->next
< iter
->length
; ++iter
->next
)
3847 offset_type cu_index_and_attrs
=
3848 MAYBE_SWAP (iter
->vec
[iter
->next
+ 1]);
3849 offset_type cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
3850 struct dwarf2_per_cu_data
*per_cu
;
3851 int want_static
= iter
->block_index
!= GLOBAL_BLOCK
;
3852 /* This value is only valid for index versions >= 7. */
3853 int is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs
);
3854 gdb_index_symbol_kind symbol_kind
=
3855 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
3856 /* Only check the symbol attributes if they're present.
3857 Indices prior to version 7 don't record them,
3858 and indices >= 7 may elide them for certain symbols
3859 (gold does this). */
3861 (iter
->index
->version
>= 7
3862 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_NONE
);
3864 /* Don't crash on bad data. */
3865 if (cu_index
>= (dwarf2_per_objfile
->n_comp_units
3866 + dwarf2_per_objfile
->n_type_units
))
3868 complaint (&symfile_complaints
,
3869 _(".gdb_index entry has bad CU index"
3871 objfile_name (dwarf2_per_objfile
->objfile
));
3875 per_cu
= dw2_get_cutu (cu_index
);
3877 /* Skip if already read in. */
3878 if (per_cu
->v
.quick
->compunit_symtab
)
3881 /* Check static vs global. */
3884 if (iter
->want_specific_block
3885 && want_static
!= is_static
)
3887 /* Work around gold/15646. */
3888 if (!is_static
&& iter
->global_seen
)
3891 iter
->global_seen
= 1;
3894 /* Only check the symbol's kind if it has one. */
3897 switch (iter
->domain
)
3900 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
3901 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
3902 /* Some types are also in VAR_DOMAIN. */
3903 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
3907 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
3911 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_OTHER
)
3926 static struct compunit_symtab
*
3927 dw2_lookup_symbol (struct objfile
*objfile
, int block_index
,
3928 const char *name
, domain_enum domain
)
3930 struct compunit_symtab
*stab_best
= NULL
;
3931 struct mapped_index
*index
;
3933 dw2_setup (objfile
);
3935 lookup_name_info
lookup_name (name
, symbol_name_match_type::FULL
);
3937 index
= dwarf2_per_objfile
->index_table
;
3939 /* index is NULL if OBJF_READNOW. */
3942 struct dw2_symtab_iterator iter
;
3943 struct dwarf2_per_cu_data
*per_cu
;
3945 dw2_symtab_iter_init (&iter
, index
, 1, block_index
, domain
, name
);
3947 while ((per_cu
= dw2_symtab_iter_next (&iter
)) != NULL
)
3949 struct symbol
*sym
, *with_opaque
= NULL
;
3950 struct compunit_symtab
*stab
= dw2_instantiate_symtab (per_cu
);
3951 const struct blockvector
*bv
= COMPUNIT_BLOCKVECTOR (stab
);
3952 struct block
*block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
3954 sym
= block_find_symbol (block
, name
, domain
,
3955 block_find_non_opaque_type_preferred
,
3958 /* Some caution must be observed with overloaded functions
3959 and methods, since the index will not contain any overload
3960 information (but NAME might contain it). */
3963 && SYMBOL_MATCHES_SEARCH_NAME (sym
, lookup_name
))
3965 if (with_opaque
!= NULL
3966 && SYMBOL_MATCHES_SEARCH_NAME (with_opaque
, lookup_name
))
3969 /* Keep looking through other CUs. */
3977 dw2_print_stats (struct objfile
*objfile
)
3979 int i
, total
, count
;
3981 dw2_setup (objfile
);
3982 total
= dwarf2_per_objfile
->n_comp_units
+ dwarf2_per_objfile
->n_type_units
;
3984 for (i
= 0; i
< total
; ++i
)
3986 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (i
);
3988 if (!per_cu
->v
.quick
->compunit_symtab
)
3991 printf_filtered (_(" Number of read CUs: %d\n"), total
- count
);
3992 printf_filtered (_(" Number of unread CUs: %d\n"), count
);
3995 /* This dumps minimal information about the index.
3996 It is called via "mt print objfiles".
3997 One use is to verify .gdb_index has been loaded by the
3998 gdb.dwarf2/gdb-index.exp testcase. */
4001 dw2_dump (struct objfile
*objfile
)
4003 dw2_setup (objfile
);
4004 gdb_assert (dwarf2_per_objfile
->using_index
);
4005 printf_filtered (".gdb_index:");
4006 if (dwarf2_per_objfile
->index_table
!= NULL
)
4008 printf_filtered (" version %d\n",
4009 dwarf2_per_objfile
->index_table
->version
);
4012 printf_filtered (" faked for \"readnow\"\n");
4013 printf_filtered ("\n");
4017 dw2_relocate (struct objfile
*objfile
,
4018 const struct section_offsets
*new_offsets
,
4019 const struct section_offsets
*delta
)
4021 /* There's nothing to relocate here. */
4025 dw2_expand_symtabs_for_function (struct objfile
*objfile
,
4026 const char *func_name
)
4028 struct mapped_index
*index
;
4030 dw2_setup (objfile
);
4032 index
= dwarf2_per_objfile
->index_table
;
4034 /* index is NULL if OBJF_READNOW. */
4037 struct dw2_symtab_iterator iter
;
4038 struct dwarf2_per_cu_data
*per_cu
;
4040 /* Note: It doesn't matter what we pass for block_index here. */
4041 dw2_symtab_iter_init (&iter
, index
, 0, GLOBAL_BLOCK
, VAR_DOMAIN
,
4044 while ((per_cu
= dw2_symtab_iter_next (&iter
)) != NULL
)
4045 dw2_instantiate_symtab (per_cu
);
4050 dw2_expand_all_symtabs (struct objfile
*objfile
)
4054 dw2_setup (objfile
);
4056 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
4057 + dwarf2_per_objfile
->n_type_units
); ++i
)
4059 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (i
);
4061 dw2_instantiate_symtab (per_cu
);
4066 dw2_expand_symtabs_with_fullname (struct objfile
*objfile
,
4067 const char *fullname
)
4071 dw2_setup (objfile
);
4073 /* We don't need to consider type units here.
4074 This is only called for examining code, e.g. expand_line_sal.
4075 There can be an order of magnitude (or more) more type units
4076 than comp units, and we avoid them if we can. */
4078 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
4081 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (i
);
4082 struct quick_file_names
*file_data
;
4084 /* We only need to look at symtabs not already expanded. */
4085 if (per_cu
->v
.quick
->compunit_symtab
)
4088 file_data
= dw2_get_file_names (per_cu
);
4089 if (file_data
== NULL
)
4092 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
4094 const char *this_fullname
= file_data
->file_names
[j
];
4096 if (filename_cmp (this_fullname
, fullname
) == 0)
4098 dw2_instantiate_symtab (per_cu
);
4106 dw2_map_matching_symbols (struct objfile
*objfile
,
4107 const char * name
, domain_enum domain
,
4109 int (*callback
) (struct block
*,
4110 struct symbol
*, void *),
4111 void *data
, symbol_name_match_type match
,
4112 symbol_compare_ftype
*ordered_compare
)
4114 /* Currently unimplemented; used for Ada. The function can be called if the
4115 current language is Ada for a non-Ada objfile using GNU index. As Ada
4116 does not look for non-Ada symbols this function should just return. */
4119 /* Symbol name matcher for .gdb_index names.
4121 Symbol names in .gdb_index have a few particularities:
4123 - There's no indication of which is the language of each symbol.
4125 Since each language has its own symbol name matching algorithm,
4126 and we don't know which language is the right one, we must match
4127 each symbol against all languages. This would be a potential
4128 performance problem if it were not mitigated by the
4129 mapped_index::name_components lookup table, which significantly
4130 reduces the number of times we need to call into this matcher,
4131 making it a non-issue.
4133 - Symbol names in the index have no overload (parameter)
4134 information. I.e., in C++, "foo(int)" and "foo(long)" both
4135 appear as "foo" in the index, for example.
4137 This means that the lookup names passed to the symbol name
4138 matcher functions must have no parameter information either
4139 because (e.g.) symbol search name "foo" does not match
4140 lookup-name "foo(int)" [while swapping search name for lookup
4143 class gdb_index_symbol_name_matcher
4146 /* Prepares the vector of comparison functions for LOOKUP_NAME. */
4147 gdb_index_symbol_name_matcher (const lookup_name_info
&lookup_name
);
4149 /* Walk all the matcher routines and match SYMBOL_NAME against them.
4150 Returns true if any matcher matches. */
4151 bool matches (const char *symbol_name
);
4154 /* A reference to the lookup name we're matching against. */
4155 const lookup_name_info
&m_lookup_name
;
4157 /* A vector holding all the different symbol name matchers, for all
4159 std::vector
<symbol_name_matcher_ftype
*> m_symbol_name_matcher_funcs
;
4162 gdb_index_symbol_name_matcher::gdb_index_symbol_name_matcher
4163 (const lookup_name_info
&lookup_name
)
4164 : m_lookup_name (lookup_name
)
4166 /* Prepare the vector of comparison functions upfront, to avoid
4167 doing the same work for each symbol. Care is taken to avoid
4168 matching with the same matcher more than once if/when multiple
4169 languages use the same matcher function. */
4170 auto &matchers
= m_symbol_name_matcher_funcs
;
4171 matchers
.reserve (nr_languages
);
4173 matchers
.push_back (default_symbol_name_matcher
);
4175 for (int i
= 0; i
< nr_languages
; i
++)
4177 const language_defn
*lang
= language_def ((enum language
) i
);
4178 if (lang
->la_get_symbol_name_matcher
!= NULL
)
4180 symbol_name_matcher_ftype
*name_matcher
4181 = lang
->la_get_symbol_name_matcher (m_lookup_name
);
4183 /* Don't insert the same comparison routine more than once.
4184 Note that we do this linear walk instead of a cheaper
4185 sorted insert, or use a std::set or something like that,
4186 because relative order of function addresses is not
4187 stable. This is not a problem in practice because the
4188 number of supported languages is low, and the cost here
4189 is tiny compared to the number of searches we'll do
4190 afterwards using this object. */
4191 if (std::find (matchers
.begin (), matchers
.end (), name_matcher
)
4193 matchers
.push_back (name_matcher
);
4199 gdb_index_symbol_name_matcher::matches (const char *symbol_name
)
4201 for (auto matches_name
: m_symbol_name_matcher_funcs
)
4202 if (matches_name (symbol_name
, m_lookup_name
, NULL
))
4208 /* Starting from a search name, return the string that finds the upper
4209 bound of all strings that start with SEARCH_NAME in a sorted name
4210 list. Returns the empty string to indicate that the upper bound is
4211 the end of the list. */
4214 make_sort_after_prefix_name (const char *search_name
)
4216 /* When looking to complete "func", we find the upper bound of all
4217 symbols that start with "func" by looking for where we'd insert
4218 the closest string that would follow "func" in lexicographical
4219 order. Usually, that's "func"-with-last-character-incremented,
4220 i.e. "fund". Mind non-ASCII characters, though. Usually those
4221 will be UTF-8 multi-byte sequences, but we can't be certain.
4222 Especially mind the 0xff character, which is a valid character in
4223 non-UTF-8 source character sets (e.g. Latin1 'ÿ'), and we can't
4224 rule out compilers allowing it in identifiers. Note that
4225 conveniently, strcmp/strcasecmp are specified to compare
4226 characters interpreted as unsigned char. So what we do is treat
4227 the whole string as a base 256 number composed of a sequence of
4228 base 256 "digits" and add 1 to it. I.e., adding 1 to 0xff wraps
4229 to 0, and carries 1 to the following more-significant position.
4230 If the very first character in SEARCH_NAME ends up incremented
4231 and carries/overflows, then the upper bound is the end of the
4232 list. The string after the empty string is also the empty
4235 Some examples of this operation:
4237 SEARCH_NAME => "+1" RESULT
4241 "\xff" "a" "\xff" => "\xff" "b"
4246 Then, with these symbols for example:
4252 completing "func" looks for symbols between "func" and
4253 "func"-with-last-character-incremented, i.e. "fund" (exclusive),
4254 which finds "func" and "func1", but not "fund".
4258 funcÿ (Latin1 'ÿ' [0xff])
4262 completing "funcÿ" looks for symbols between "funcÿ" and "fund"
4263 (exclusive), which finds "funcÿ" and "funcÿ1", but not "fund".
4267 ÿÿ (Latin1 'ÿ' [0xff])
4270 completing "ÿ" or "ÿÿ" looks for symbols between between "ÿÿ" and
4271 the end of the list.
4273 std::string after
= search_name
;
4274 while (!after
.empty () && (unsigned char) after
.back () == 0xff)
4276 if (!after
.empty ())
4277 after
.back () = (unsigned char) after
.back () + 1;
4281 /* See declaration. */
4283 std::pair
<std::vector
<name_component
>::const_iterator
,
4284 std::vector
<name_component
>::const_iterator
>
4285 mapped_index::find_name_components_bounds
4286 (const lookup_name_info
&lookup_name_without_params
) const
4289 = this->name_components_casing
== case_sensitive_on
? strcmp
: strcasecmp
;
4292 = lookup_name_without_params
.cplus ().lookup_name ().c_str ();
4294 /* Comparison function object for lower_bound that matches against a
4295 given symbol name. */
4296 auto lookup_compare_lower
= [&] (const name_component
&elem
,
4299 const char *elem_qualified
= this->symbol_name_at (elem
.idx
);
4300 const char *elem_name
= elem_qualified
+ elem
.name_offset
;
4301 return name_cmp (elem_name
, name
) < 0;
4304 /* Comparison function object for upper_bound that matches against a
4305 given symbol name. */
4306 auto lookup_compare_upper
= [&] (const char *name
,
4307 const name_component
&elem
)
4309 const char *elem_qualified
= this->symbol_name_at (elem
.idx
);
4310 const char *elem_name
= elem_qualified
+ elem
.name_offset
;
4311 return name_cmp (name
, elem_name
) < 0;
4314 auto begin
= this->name_components
.begin ();
4315 auto end
= this->name_components
.end ();
4317 /* Find the lower bound. */
4320 if (lookup_name_without_params
.completion_mode () && cplus
[0] == '\0')
4323 return std::lower_bound (begin
, end
, cplus
, lookup_compare_lower
);
4326 /* Find the upper bound. */
4329 if (lookup_name_without_params
.completion_mode ())
4331 /* In completion mode, we want UPPER to point past all
4332 symbols names that have the same prefix. I.e., with
4333 these symbols, and completing "func":
4335 function << lower bound
4337 other_function << upper bound
4339 We find the upper bound by looking for the insertion
4340 point of "func"-with-last-character-incremented,
4342 std::string after
= make_sort_after_prefix_name (cplus
);
4345 return std::lower_bound (lower
, end
, after
.c_str (),
4346 lookup_compare_lower
);
4349 return std::upper_bound (lower
, end
, cplus
, lookup_compare_upper
);
4352 return {lower
, upper
};
4355 /* See declaration. */
4358 mapped_index::build_name_components ()
4360 if (!this->name_components
.empty ())
4363 this->name_components_casing
= case_sensitivity
;
4365 = this->name_components_casing
== case_sensitive_on
? strcmp
: strcasecmp
;
4367 /* The code below only knows how to break apart components of C++
4368 symbol names (and other languages that use '::' as
4369 namespace/module separator). If we add support for wild matching
4370 to some language that uses some other operator (E.g., Ada, Go and
4371 D use '.'), then we'll need to try splitting the symbol name
4372 according to that language too. Note that Ada does support wild
4373 matching, but doesn't currently support .gdb_index. */
4374 for (size_t iter
= 0; iter
< this->symbol_table_slots
; ++iter
)
4376 offset_type idx
= 2 * iter
;
4378 if (this->symbol_table
[idx
] == 0
4379 && this->symbol_table
[idx
+ 1] == 0)
4382 const char *name
= this->symbol_name_at (idx
);
4384 /* Add each name component to the name component table. */
4385 unsigned int previous_len
= 0;
4386 for (unsigned int current_len
= cp_find_first_component (name
);
4387 name
[current_len
] != '\0';
4388 current_len
+= cp_find_first_component (name
+ current_len
))
4390 gdb_assert (name
[current_len
] == ':');
4391 this->name_components
.push_back ({previous_len
, idx
});
4392 /* Skip the '::'. */
4394 previous_len
= current_len
;
4396 this->name_components
.push_back ({previous_len
, idx
});
4399 /* Sort name_components elements by name. */
4400 auto name_comp_compare
= [&] (const name_component
&left
,
4401 const name_component
&right
)
4403 const char *left_qualified
= this->symbol_name_at (left
.idx
);
4404 const char *right_qualified
= this->symbol_name_at (right
.idx
);
4406 const char *left_name
= left_qualified
+ left
.name_offset
;
4407 const char *right_name
= right_qualified
+ right
.name_offset
;
4409 return name_cmp (left_name
, right_name
) < 0;
4412 std::sort (this->name_components
.begin (),
4413 this->name_components
.end (),
4417 /* Helper for dw2_expand_symtabs_matching that works with a
4418 mapped_index instead of the containing objfile. This is split to a
4419 separate function in order to be able to unit test the
4420 name_components matching using a mock mapped_index. For each
4421 symbol name that matches, calls MATCH_CALLBACK, passing it the
4422 symbol's index in the mapped_index symbol table. */
4425 dw2_expand_symtabs_matching_symbol
4426 (mapped_index
&index
,
4427 const lookup_name_info
&lookup_name_in
,
4428 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
4429 enum search_domain kind
,
4430 gdb::function_view
<void (offset_type
)> match_callback
)
4432 lookup_name_info lookup_name_without_params
4433 = lookup_name_in
.make_ignore_params ();
4434 gdb_index_symbol_name_matcher lookup_name_matcher
4435 (lookup_name_without_params
);
4437 /* Build the symbol name component sorted vector, if we haven't
4439 index
.build_name_components ();
4441 auto bounds
= index
.find_name_components_bounds (lookup_name_without_params
);
4443 /* Now for each symbol name in range, check to see if we have a name
4444 match, and if so, call the MATCH_CALLBACK callback. */
4446 /* The same symbol may appear more than once in the range though.
4447 E.g., if we're looking for symbols that complete "w", and we have
4448 a symbol named "w1::w2", we'll find the two name components for
4449 that same symbol in the range. To be sure we only call the
4450 callback once per symbol, we first collect the symbol name
4451 indexes that matched in a temporary vector and ignore
4453 std::vector
<offset_type
> matches
;
4454 matches
.reserve (std::distance (bounds
.first
, bounds
.second
));
4456 for (; bounds
.first
!= bounds
.second
; ++bounds
.first
)
4458 const char *qualified
= index
.symbol_name_at (bounds
.first
->idx
);
4460 if (!lookup_name_matcher
.matches (qualified
)
4461 || (symbol_matcher
!= NULL
&& !symbol_matcher (qualified
)))
4464 matches
.push_back (bounds
.first
->idx
);
4467 std::sort (matches
.begin (), matches
.end ());
4469 /* Finally call the callback, once per match. */
4471 for (offset_type idx
: matches
)
4475 match_callback (idx
);
4480 /* Above we use a type wider than idx's for 'prev', since 0 and
4481 (offset_type)-1 are both possible values. */
4482 static_assert (sizeof (prev
) > sizeof (offset_type
), "");
4487 namespace selftests
{ namespace dw2_expand_symtabs_matching
{
4489 /* A wrapper around mapped_index that builds a mock mapped_index, from
4490 the symbol list passed as parameter to the constructor. */
4491 class mock_mapped_index
4495 mock_mapped_index (const char *(&symbols
)[N
])
4496 : mock_mapped_index (symbols
, N
)
4499 /* Access the built index. */
4500 mapped_index
&index ()
4504 mock_mapped_index(const mock_mapped_index
&) = delete;
4505 void operator= (const mock_mapped_index
&) = delete;
4508 mock_mapped_index (const char **symbols
, size_t symbols_size
)
4510 /* No string can live at offset zero. Add a dummy entry. */
4511 obstack_grow_str0 (&m_constant_pool
, "");
4513 for (size_t i
= 0; i
< symbols_size
; i
++)
4515 const char *sym
= symbols
[i
];
4516 size_t offset
= obstack_object_size (&m_constant_pool
);
4517 obstack_grow_str0 (&m_constant_pool
, sym
);
4518 m_symbol_table
.push_back (offset
);
4519 m_symbol_table
.push_back (0);
4522 m_index
.constant_pool
= (const char *) obstack_base (&m_constant_pool
);
4523 m_index
.symbol_table
= m_symbol_table
.data ();
4524 m_index
.symbol_table_slots
= m_symbol_table
.size () / 2;
4528 /* The built mapped_index. */
4529 mapped_index m_index
{};
4531 /* The storage that the built mapped_index uses for symbol and
4532 constant pool tables. */
4533 std::vector
<offset_type
> m_symbol_table
;
4534 auto_obstack m_constant_pool
;
4537 /* Convenience function that converts a NULL pointer to a "<null>"
4538 string, to pass to print routines. */
4541 string_or_null (const char *str
)
4543 return str
!= NULL
? str
: "<null>";
4546 /* Check if a lookup_name_info built from
4547 NAME/MATCH_TYPE/COMPLETION_MODE matches the symbols in the mock
4548 index. EXPECTED_LIST is the list of expected matches, in expected
4549 matching order. If no match expected, then an empty list is
4550 specified. Returns true on success. On failure prints a warning
4551 indicating the file:line that failed, and returns false. */
4554 check_match (const char *file
, int line
,
4555 mock_mapped_index
&mock_index
,
4556 const char *name
, symbol_name_match_type match_type
,
4557 bool completion_mode
,
4558 std::initializer_list
<const char *> expected_list
)
4560 lookup_name_info
lookup_name (name
, match_type
, completion_mode
);
4562 bool matched
= true;
4564 auto mismatch
= [&] (const char *expected_str
,
4567 warning (_("%s:%d: match_type=%s, looking-for=\"%s\", "
4568 "expected=\"%s\", got=\"%s\"\n"),
4570 (match_type
== symbol_name_match_type::FULL
4572 name
, string_or_null (expected_str
), string_or_null (got
));
4576 auto expected_it
= expected_list
.begin ();
4577 auto expected_end
= expected_list
.end ();
4579 dw2_expand_symtabs_matching_symbol (mock_index
.index (), lookup_name
,
4581 [&] (offset_type idx
)
4583 const char *matched_name
= mock_index
.index ().symbol_name_at (idx
);
4584 const char *expected_str
4585 = expected_it
== expected_end
? NULL
: *expected_it
++;
4587 if (expected_str
== NULL
|| strcmp (expected_str
, matched_name
) != 0)
4588 mismatch (expected_str
, matched_name
);
4591 const char *expected_str
4592 = expected_it
== expected_end
? NULL
: *expected_it
++;
4593 if (expected_str
!= NULL
)
4594 mismatch (expected_str
, NULL
);
4599 /* The symbols added to the mock mapped_index for testing (in
4601 static const char *test_symbols
[] = {
4610 "ns2::tmpl<int>::foo2",
4611 "(anonymous namespace)::A::B::C",
4613 /* These are used to check that the increment-last-char in the
4614 matching algorithm for completion doesn't match "t1_fund" when
4615 completing "t1_func". */
4621 /* A UTF-8 name with multi-byte sequences to make sure that
4622 cp-name-parser understands this as a single identifier ("função"
4623 is "function" in PT). */
4626 /* \377 (0xff) is Latin1 'ÿ'. */
4629 /* \377 (0xff) is Latin1 'ÿ'. */
4633 /* A name with all sorts of complications. Starts with "z" to make
4634 it easier for the completion tests below. */
4635 #define Z_SYM_NAME \
4636 "z::std::tuple<(anonymous namespace)::ui*, std::bar<(anonymous namespace)::ui> >" \
4637 "::tuple<(anonymous namespace)::ui*, " \
4638 "std::default_delete<(anonymous namespace)::ui>, void>"
4643 /* Returns true if the mapped_index::find_name_component_bounds method
4644 finds EXPECTED_SYMS in INDEX when looking for SEARCH_NAME, in
4648 check_find_bounds_finds (mapped_index
&index
,
4649 const char *search_name
,
4650 gdb::array_view
<const char *> expected_syms
)
4652 lookup_name_info
lookup_name (search_name
,
4653 symbol_name_match_type::FULL
, true);
4655 auto bounds
= index
.find_name_components_bounds (lookup_name
);
4657 size_t distance
= std::distance (bounds
.first
, bounds
.second
);
4658 if (distance
!= expected_syms
.size ())
4661 for (size_t exp_elem
= 0; exp_elem
< distance
; exp_elem
++)
4663 auto nc_elem
= bounds
.first
+ exp_elem
;
4664 const char *qualified
= index
.symbol_name_at (nc_elem
->idx
);
4665 if (strcmp (qualified
, expected_syms
[exp_elem
]) != 0)
4672 /* Test the lower-level mapped_index::find_name_component_bounds
4676 test_mapped_index_find_name_component_bounds ()
4678 mock_mapped_index
mock_index (test_symbols
);
4680 mock_index
.index ().build_name_components ();
4682 /* Test the lower-level mapped_index::find_name_component_bounds
4683 method in completion mode. */
4685 static const char *expected_syms
[] = {
4690 SELF_CHECK (check_find_bounds_finds (mock_index
.index (),
4691 "t1_func", expected_syms
));
4694 /* Check that the increment-last-char in the name matching algorithm
4695 for completion doesn't get confused with Ansi1 'ÿ' / 0xff. */
4697 static const char *expected_syms1
[] = {
4701 SELF_CHECK (check_find_bounds_finds (mock_index
.index (),
4702 "\377", expected_syms1
));
4704 static const char *expected_syms2
[] = {
4707 SELF_CHECK (check_find_bounds_finds (mock_index
.index (),
4708 "\377\377", expected_syms2
));
4712 /* Test dw2_expand_symtabs_matching_symbol. */
4715 test_dw2_expand_symtabs_matching_symbol ()
4717 mock_mapped_index
mock_index (test_symbols
);
4719 /* We let all tests run until the end even if some fails, for debug
4721 bool any_mismatch
= false;
4723 /* Create the expected symbols list (an initializer_list). Needed
4724 because lists have commas, and we need to pass them to CHECK,
4725 which is a macro. */
4726 #define EXPECT(...) { __VA_ARGS__ }
4728 /* Wrapper for check_match that passes down the current
4729 __FILE__/__LINE__. */
4730 #define CHECK_MATCH(NAME, MATCH_TYPE, COMPLETION_MODE, EXPECTED_LIST) \
4731 any_mismatch |= !check_match (__FILE__, __LINE__, \
4733 NAME, MATCH_TYPE, COMPLETION_MODE, \
4736 /* Identity checks. */
4737 for (const char *sym
: test_symbols
)
4739 /* Should be able to match all existing symbols. */
4740 CHECK_MATCH (sym
, symbol_name_match_type::FULL
, false,
4743 /* Should be able to match all existing symbols with
4745 std::string with_params
= std::string (sym
) + "(int)";
4746 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
4749 /* Should be able to match all existing symbols with
4750 parameters and qualifiers. */
4751 with_params
= std::string (sym
) + " ( int ) const";
4752 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
4755 /* This should really find sym, but cp-name-parser.y doesn't
4756 know about lvalue/rvalue qualifiers yet. */
4757 with_params
= std::string (sym
) + " ( int ) &&";
4758 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
4762 /* Check that the name matching algorithm for completion doesn't get
4763 confused with Latin1 'ÿ' / 0xff. */
4765 static const char str
[] = "\377";
4766 CHECK_MATCH (str
, symbol_name_match_type::FULL
, true,
4767 EXPECT ("\377", "\377\377123"));
4770 /* Check that the increment-last-char in the matching algorithm for
4771 completion doesn't match "t1_fund" when completing "t1_func". */
4773 static const char str
[] = "t1_func";
4774 CHECK_MATCH (str
, symbol_name_match_type::FULL
, true,
4775 EXPECT ("t1_func", "t1_func1"));
4778 /* Check that completion mode works at each prefix of the expected
4781 static const char str
[] = "function(int)";
4782 size_t len
= strlen (str
);
4785 for (size_t i
= 1; i
< len
; i
++)
4787 lookup
.assign (str
, i
);
4788 CHECK_MATCH (lookup
.c_str (), symbol_name_match_type::FULL
, true,
4789 EXPECT ("function"));
4793 /* While "w" is a prefix of both components, the match function
4794 should still only be called once. */
4796 CHECK_MATCH ("w", symbol_name_match_type::FULL
, true,
4798 CHECK_MATCH ("w", symbol_name_match_type::WILD
, true,
4802 /* Same, with a "complicated" symbol. */
4804 static const char str
[] = Z_SYM_NAME
;
4805 size_t len
= strlen (str
);
4808 for (size_t i
= 1; i
< len
; i
++)
4810 lookup
.assign (str
, i
);
4811 CHECK_MATCH (lookup
.c_str (), symbol_name_match_type::FULL
, true,
4812 EXPECT (Z_SYM_NAME
));
4816 /* In FULL mode, an incomplete symbol doesn't match. */
4818 CHECK_MATCH ("std::zfunction(int", symbol_name_match_type::FULL
, false,
4822 /* A complete symbol with parameters matches any overload, since the
4823 index has no overload info. */
4825 CHECK_MATCH ("std::zfunction(int)", symbol_name_match_type::FULL
, true,
4826 EXPECT ("std::zfunction", "std::zfunction2"));
4827 CHECK_MATCH ("zfunction(int)", symbol_name_match_type::WILD
, true,
4828 EXPECT ("std::zfunction", "std::zfunction2"));
4829 CHECK_MATCH ("zfunc", symbol_name_match_type::WILD
, true,
4830 EXPECT ("std::zfunction", "std::zfunction2"));
4833 /* Check that whitespace is ignored appropriately. A symbol with a
4834 template argument list. */
4836 static const char expected
[] = "ns::foo<int>";
4837 CHECK_MATCH ("ns :: foo < int > ", symbol_name_match_type::FULL
, false,
4839 CHECK_MATCH ("foo < int > ", symbol_name_match_type::WILD
, false,
4843 /* Check that whitespace is ignored appropriately. A symbol with a
4844 template argument list that includes a pointer. */
4846 static const char expected
[] = "ns::foo<char*>";
4847 /* Try both completion and non-completion modes. */
4848 static const bool completion_mode
[2] = {false, true};
4849 for (size_t i
= 0; i
< 2; i
++)
4851 CHECK_MATCH ("ns :: foo < char * >", symbol_name_match_type::FULL
,
4852 completion_mode
[i
], EXPECT (expected
));
4853 CHECK_MATCH ("foo < char * >", symbol_name_match_type::WILD
,
4854 completion_mode
[i
], EXPECT (expected
));
4856 CHECK_MATCH ("ns :: foo < char * > (int)", symbol_name_match_type::FULL
,
4857 completion_mode
[i
], EXPECT (expected
));
4858 CHECK_MATCH ("foo < char * > (int)", symbol_name_match_type::WILD
,
4859 completion_mode
[i
], EXPECT (expected
));
4864 /* Check method qualifiers are ignored. */
4865 static const char expected
[] = "ns::foo<char*>";
4866 CHECK_MATCH ("ns :: foo < char * > ( int ) const",
4867 symbol_name_match_type::FULL
, true, EXPECT (expected
));
4868 CHECK_MATCH ("ns :: foo < char * > ( int ) &&",
4869 symbol_name_match_type::FULL
, true, EXPECT (expected
));
4870 CHECK_MATCH ("foo < char * > ( int ) const",
4871 symbol_name_match_type::WILD
, true, EXPECT (expected
));
4872 CHECK_MATCH ("foo < char * > ( int ) &&",
4873 symbol_name_match_type::WILD
, true, EXPECT (expected
));
4876 /* Test lookup names that don't match anything. */
4878 CHECK_MATCH ("bar2", symbol_name_match_type::WILD
, false,
4881 CHECK_MATCH ("doesntexist", symbol_name_match_type::FULL
, false,
4885 /* Some wild matching tests, exercising "(anonymous namespace)",
4886 which should not be confused with a parameter list. */
4888 static const char *syms
[] = {
4892 "A :: B :: C ( int )",
4897 for (const char *s
: syms
)
4899 CHECK_MATCH (s
, symbol_name_match_type::WILD
, false,
4900 EXPECT ("(anonymous namespace)::A::B::C"));
4905 static const char expected
[] = "ns2::tmpl<int>::foo2";
4906 CHECK_MATCH ("tmp", symbol_name_match_type::WILD
, true,
4908 CHECK_MATCH ("tmpl<", symbol_name_match_type::WILD
, true,
4912 SELF_CHECK (!any_mismatch
);
4921 test_mapped_index_find_name_component_bounds ();
4922 test_dw2_expand_symtabs_matching_symbol ();
4925 }} // namespace selftests::dw2_expand_symtabs_matching
4927 #endif /* GDB_SELF_TEST */
4929 /* Helper for dw2_expand_matching symtabs. Called on each symbol
4930 matched, to expand corresponding CUs that were marked. IDX is the
4931 index of the symbol name that matched. */
4934 dw2_expand_marked_cus
4935 (mapped_index
&index
, offset_type idx
,
4936 struct objfile
*objfile
,
4937 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
4938 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
4941 offset_type
*vec
, vec_len
, vec_idx
;
4942 bool global_seen
= false;
4944 vec
= (offset_type
*) (index
.constant_pool
4945 + MAYBE_SWAP (index
.symbol_table
[idx
+ 1]));
4946 vec_len
= MAYBE_SWAP (vec
[0]);
4947 for (vec_idx
= 0; vec_idx
< vec_len
; ++vec_idx
)
4949 struct dwarf2_per_cu_data
*per_cu
;
4950 offset_type cu_index_and_attrs
= MAYBE_SWAP (vec
[vec_idx
+ 1]);
4951 /* This value is only valid for index versions >= 7. */
4952 int is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs
);
4953 gdb_index_symbol_kind symbol_kind
=
4954 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
4955 int cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
4956 /* Only check the symbol attributes if they're present.
4957 Indices prior to version 7 don't record them,
4958 and indices >= 7 may elide them for certain symbols
4959 (gold does this). */
4962 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_NONE
);
4964 /* Work around gold/15646. */
4967 if (!is_static
&& global_seen
)
4973 /* Only check the symbol's kind if it has one. */
4978 case VARIABLES_DOMAIN
:
4979 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
)
4982 case FUNCTIONS_DOMAIN
:
4983 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
)
4987 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
4995 /* Don't crash on bad data. */
4996 if (cu_index
>= (dwarf2_per_objfile
->n_comp_units
4997 + dwarf2_per_objfile
->n_type_units
))
4999 complaint (&symfile_complaints
,
5000 _(".gdb_index entry has bad CU index"
5001 " [in module %s]"), objfile_name (objfile
));
5005 per_cu
= dw2_get_cutu (cu_index
);
5006 if (file_matcher
== NULL
|| per_cu
->v
.quick
->mark
)
5008 int symtab_was_null
=
5009 (per_cu
->v
.quick
->compunit_symtab
== NULL
);
5011 dw2_instantiate_symtab (per_cu
);
5013 if (expansion_notify
!= NULL
5015 && per_cu
->v
.quick
->compunit_symtab
!= NULL
)
5016 expansion_notify (per_cu
->v
.quick
->compunit_symtab
);
5022 dw2_expand_symtabs_matching
5023 (struct objfile
*objfile
,
5024 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
5025 const lookup_name_info
&lookup_name
,
5026 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
5027 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
5028 enum search_domain kind
)
5032 dw2_setup (objfile
);
5034 /* index_table is NULL if OBJF_READNOW. */
5035 if (!dwarf2_per_objfile
->index_table
)
5038 if (file_matcher
!= NULL
)
5040 htab_up
visited_found (htab_create_alloc (10, htab_hash_pointer
,
5042 NULL
, xcalloc
, xfree
));
5043 htab_up
visited_not_found (htab_create_alloc (10, htab_hash_pointer
,
5045 NULL
, xcalloc
, xfree
));
5047 /* The rule is CUs specify all the files, including those used by
5048 any TU, so there's no need to scan TUs here. */
5050 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
5053 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
5054 struct quick_file_names
*file_data
;
5059 per_cu
->v
.quick
->mark
= 0;
5061 /* We only need to look at symtabs not already expanded. */
5062 if (per_cu
->v
.quick
->compunit_symtab
)
5065 file_data
= dw2_get_file_names (per_cu
);
5066 if (file_data
== NULL
)
5069 if (htab_find (visited_not_found
.get (), file_data
) != NULL
)
5071 else if (htab_find (visited_found
.get (), file_data
) != NULL
)
5073 per_cu
->v
.quick
->mark
= 1;
5077 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
5079 const char *this_real_name
;
5081 if (file_matcher (file_data
->file_names
[j
], false))
5083 per_cu
->v
.quick
->mark
= 1;
5087 /* Before we invoke realpath, which can get expensive when many
5088 files are involved, do a quick comparison of the basenames. */
5089 if (!basenames_may_differ
5090 && !file_matcher (lbasename (file_data
->file_names
[j
]),
5094 this_real_name
= dw2_get_real_path (objfile
, file_data
, j
);
5095 if (file_matcher (this_real_name
, false))
5097 per_cu
->v
.quick
->mark
= 1;
5102 slot
= htab_find_slot (per_cu
->v
.quick
->mark
5103 ? visited_found
.get ()
5104 : visited_not_found
.get (),
5110 mapped_index
&index
= *dwarf2_per_objfile
->index_table
;
5112 dw2_expand_symtabs_matching_symbol (index
, lookup_name
,
5114 kind
, [&] (offset_type idx
)
5116 dw2_expand_marked_cus (index
, idx
, objfile
, file_matcher
,
5117 expansion_notify
, kind
);
5121 /* A helper for dw2_find_pc_sect_compunit_symtab which finds the most specific
5124 static struct compunit_symtab
*
5125 recursively_find_pc_sect_compunit_symtab (struct compunit_symtab
*cust
,
5130 if (COMPUNIT_BLOCKVECTOR (cust
) != NULL
5131 && blockvector_contains_pc (COMPUNIT_BLOCKVECTOR (cust
), pc
))
5134 if (cust
->includes
== NULL
)
5137 for (i
= 0; cust
->includes
[i
]; ++i
)
5139 struct compunit_symtab
*s
= cust
->includes
[i
];
5141 s
= recursively_find_pc_sect_compunit_symtab (s
, pc
);
5149 static struct compunit_symtab
*
5150 dw2_find_pc_sect_compunit_symtab (struct objfile
*objfile
,
5151 struct bound_minimal_symbol msymbol
,
5153 struct obj_section
*section
,
5156 struct dwarf2_per_cu_data
*data
;
5157 struct compunit_symtab
*result
;
5159 dw2_setup (objfile
);
5161 if (!objfile
->psymtabs_addrmap
)
5164 data
= (struct dwarf2_per_cu_data
*) addrmap_find (objfile
->psymtabs_addrmap
,
5169 if (warn_if_readin
&& data
->v
.quick
->compunit_symtab
)
5170 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
5171 paddress (get_objfile_arch (objfile
), pc
));
5174 = recursively_find_pc_sect_compunit_symtab (dw2_instantiate_symtab (data
),
5176 gdb_assert (result
!= NULL
);
5181 dw2_map_symbol_filenames (struct objfile
*objfile
, symbol_filename_ftype
*fun
,
5182 void *data
, int need_fullname
)
5184 dw2_setup (objfile
);
5186 if (!dwarf2_per_objfile
->filenames_cache
)
5188 dwarf2_per_objfile
->filenames_cache
.emplace ();
5190 htab_up
visited (htab_create_alloc (10,
5191 htab_hash_pointer
, htab_eq_pointer
,
5192 NULL
, xcalloc
, xfree
));
5194 /* The rule is CUs specify all the files, including those used
5195 by any TU, so there's no need to scan TUs here. We can
5196 ignore file names coming from already-expanded CUs. */
5198 for (int i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
5200 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (i
);
5202 if (per_cu
->v
.quick
->compunit_symtab
)
5204 void **slot
= htab_find_slot (visited
.get (),
5205 per_cu
->v
.quick
->file_names
,
5208 *slot
= per_cu
->v
.quick
->file_names
;
5212 for (int i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
5214 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
5215 struct quick_file_names
*file_data
;
5218 /* We only need to look at symtabs not already expanded. */
5219 if (per_cu
->v
.quick
->compunit_symtab
)
5222 file_data
= dw2_get_file_names (per_cu
);
5223 if (file_data
== NULL
)
5226 slot
= htab_find_slot (visited
.get (), file_data
, INSERT
);
5229 /* Already visited. */
5234 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
5236 const char *filename
= file_data
->file_names
[j
];
5237 dwarf2_per_objfile
->filenames_cache
->seen (filename
);
5242 dwarf2_per_objfile
->filenames_cache
->traverse ([&] (const char *filename
)
5244 gdb::unique_xmalloc_ptr
<char> this_real_name
;
5247 this_real_name
= gdb_realpath (filename
);
5248 (*fun
) (filename
, this_real_name
.get (), data
);
5253 dw2_has_symbols (struct objfile
*objfile
)
5258 const struct quick_symbol_functions dwarf2_gdb_index_functions
=
5261 dw2_find_last_source_symtab
,
5262 dw2_forget_cached_source_info
,
5263 dw2_map_symtabs_matching_filename
,
5268 dw2_expand_symtabs_for_function
,
5269 dw2_expand_all_symtabs
,
5270 dw2_expand_symtabs_with_fullname
,
5271 dw2_map_matching_symbols
,
5272 dw2_expand_symtabs_matching
,
5273 dw2_find_pc_sect_compunit_symtab
,
5275 dw2_map_symbol_filenames
5278 /* Initialize for reading DWARF for this objfile. Return 0 if this
5279 file will use psymtabs, or 1 if using the GNU index. */
5282 dwarf2_initialize_objfile (struct objfile
*objfile
)
5284 /* If we're about to read full symbols, don't bother with the
5285 indices. In this case we also don't care if some other debug
5286 format is making psymtabs, because they are all about to be
5288 if ((objfile
->flags
& OBJF_READNOW
))
5292 dwarf2_per_objfile
->using_index
= 1;
5293 create_all_comp_units (objfile
);
5294 create_all_type_units (objfile
);
5295 dwarf2_per_objfile
->quick_file_names_table
=
5296 create_quick_file_names_table (dwarf2_per_objfile
->n_comp_units
);
5298 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
5299 + dwarf2_per_objfile
->n_type_units
); ++i
)
5301 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (i
);
5303 per_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
5304 struct dwarf2_per_cu_quick_data
);
5307 /* Return 1 so that gdb sees the "quick" functions. However,
5308 these functions will be no-ops because we will have expanded
5313 if (dwarf2_read_index (objfile
))
5321 /* Build a partial symbol table. */
5324 dwarf2_build_psymtabs (struct objfile
*objfile
)
5327 if (objfile
->global_psymbols
.capacity () == 0
5328 && objfile
->static_psymbols
.capacity () == 0)
5329 init_psymbol_list (objfile
, 1024);
5333 /* This isn't really ideal: all the data we allocate on the
5334 objfile's obstack is still uselessly kept around. However,
5335 freeing it seems unsafe. */
5336 psymtab_discarder
psymtabs (objfile
);
5337 dwarf2_build_psymtabs_hard (objfile
);
5340 CATCH (except
, RETURN_MASK_ERROR
)
5342 exception_print (gdb_stderr
, except
);
5347 /* Return the total length of the CU described by HEADER. */
5350 get_cu_length (const struct comp_unit_head
*header
)
5352 return header
->initial_length_size
+ header
->length
;
5355 /* Return TRUE if SECT_OFF is within CU_HEADER. */
5358 offset_in_cu_p (const comp_unit_head
*cu_header
, sect_offset sect_off
)
5360 sect_offset bottom
= cu_header
->sect_off
;
5361 sect_offset top
= cu_header
->sect_off
+ get_cu_length (cu_header
);
5363 return sect_off
>= bottom
&& sect_off
< top
;
5366 /* Find the base address of the compilation unit for range lists and
5367 location lists. It will normally be specified by DW_AT_low_pc.
5368 In DWARF-3 draft 4, the base address could be overridden by
5369 DW_AT_entry_pc. It's been removed, but GCC still uses this for
5370 compilation units with discontinuous ranges. */
5373 dwarf2_find_base_address (struct die_info
*die
, struct dwarf2_cu
*cu
)
5375 struct attribute
*attr
;
5378 cu
->base_address
= 0;
5380 attr
= dwarf2_attr (die
, DW_AT_entry_pc
, cu
);
5383 cu
->base_address
= attr_value_as_address (attr
);
5388 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
5391 cu
->base_address
= attr_value_as_address (attr
);
5397 /* Read in the comp unit header information from the debug_info at info_ptr.
5398 Use rcuh_kind::COMPILE as the default type if not known by the caller.
5399 NOTE: This leaves members offset, first_die_offset to be filled in
5402 static const gdb_byte
*
5403 read_comp_unit_head (struct comp_unit_head
*cu_header
,
5404 const gdb_byte
*info_ptr
,
5405 struct dwarf2_section_info
*section
,
5406 rcuh_kind section_kind
)
5409 unsigned int bytes_read
;
5410 const char *filename
= get_section_file_name (section
);
5411 bfd
*abfd
= get_section_bfd_owner (section
);
5413 cu_header
->length
= read_initial_length (abfd
, info_ptr
, &bytes_read
);
5414 cu_header
->initial_length_size
= bytes_read
;
5415 cu_header
->offset_size
= (bytes_read
== 4) ? 4 : 8;
5416 info_ptr
+= bytes_read
;
5417 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
5419 if (cu_header
->version
< 5)
5420 switch (section_kind
)
5422 case rcuh_kind::COMPILE
:
5423 cu_header
->unit_type
= DW_UT_compile
;
5425 case rcuh_kind::TYPE
:
5426 cu_header
->unit_type
= DW_UT_type
;
5429 internal_error (__FILE__
, __LINE__
,
5430 _("read_comp_unit_head: invalid section_kind"));
5434 cu_header
->unit_type
= static_cast<enum dwarf_unit_type
>
5435 (read_1_byte (abfd
, info_ptr
));
5437 switch (cu_header
->unit_type
)
5440 if (section_kind
!= rcuh_kind::COMPILE
)
5441 error (_("Dwarf Error: wrong unit_type in compilation unit header "
5442 "(is DW_UT_compile, should be DW_UT_type) [in module %s]"),
5446 section_kind
= rcuh_kind::TYPE
;
5449 error (_("Dwarf Error: wrong unit_type in compilation unit header "
5450 "(is %d, should be %d or %d) [in module %s]"),
5451 cu_header
->unit_type
, DW_UT_compile
, DW_UT_type
, filename
);
5454 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
5457 cu_header
->abbrev_sect_off
= (sect_offset
) read_offset (abfd
, info_ptr
,
5460 info_ptr
+= bytes_read
;
5461 if (cu_header
->version
< 5)
5463 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
5466 signed_addr
= bfd_get_sign_extend_vma (abfd
);
5467 if (signed_addr
< 0)
5468 internal_error (__FILE__
, __LINE__
,
5469 _("read_comp_unit_head: dwarf from non elf file"));
5470 cu_header
->signed_addr_p
= signed_addr
;
5472 if (section_kind
== rcuh_kind::TYPE
)
5474 LONGEST type_offset
;
5476 cu_header
->signature
= read_8_bytes (abfd
, info_ptr
);
5479 type_offset
= read_offset (abfd
, info_ptr
, cu_header
, &bytes_read
);
5480 info_ptr
+= bytes_read
;
5481 cu_header
->type_cu_offset_in_tu
= (cu_offset
) type_offset
;
5482 if (to_underlying (cu_header
->type_cu_offset_in_tu
) != type_offset
)
5483 error (_("Dwarf Error: Too big type_offset in compilation unit "
5484 "header (is %s) [in module %s]"), plongest (type_offset
),
5491 /* Helper function that returns the proper abbrev section for
5494 static struct dwarf2_section_info
*
5495 get_abbrev_section_for_cu (struct dwarf2_per_cu_data
*this_cu
)
5497 struct dwarf2_section_info
*abbrev
;
5499 if (this_cu
->is_dwz
)
5500 abbrev
= &dwarf2_get_dwz_file ()->abbrev
;
5502 abbrev
= &dwarf2_per_objfile
->abbrev
;
5507 /* Subroutine of read_and_check_comp_unit_head and
5508 read_and_check_type_unit_head to simplify them.
5509 Perform various error checking on the header. */
5512 error_check_comp_unit_head (struct comp_unit_head
*header
,
5513 struct dwarf2_section_info
*section
,
5514 struct dwarf2_section_info
*abbrev_section
)
5516 const char *filename
= get_section_file_name (section
);
5518 if (header
->version
< 2 || header
->version
> 5)
5519 error (_("Dwarf Error: wrong version in compilation unit header "
5520 "(is %d, should be 2, 3, 4 or 5) [in module %s]"), header
->version
,
5523 if (to_underlying (header
->abbrev_sect_off
)
5524 >= dwarf2_section_size (dwarf2_per_objfile
->objfile
, abbrev_section
))
5525 error (_("Dwarf Error: bad offset (0x%x) in compilation unit header "
5526 "(offset 0x%x + 6) [in module %s]"),
5527 to_underlying (header
->abbrev_sect_off
),
5528 to_underlying (header
->sect_off
),
5531 /* Cast to ULONGEST to use 64-bit arithmetic when possible to
5532 avoid potential 32-bit overflow. */
5533 if (((ULONGEST
) header
->sect_off
+ get_cu_length (header
))
5535 error (_("Dwarf Error: bad length (0x%x) in compilation unit header "
5536 "(offset 0x%x + 0) [in module %s]"),
5537 header
->length
, to_underlying (header
->sect_off
),
5541 /* Read in a CU/TU header and perform some basic error checking.
5542 The contents of the header are stored in HEADER.
5543 The result is a pointer to the start of the first DIE. */
5545 static const gdb_byte
*
5546 read_and_check_comp_unit_head (struct comp_unit_head
*header
,
5547 struct dwarf2_section_info
*section
,
5548 struct dwarf2_section_info
*abbrev_section
,
5549 const gdb_byte
*info_ptr
,
5550 rcuh_kind section_kind
)
5552 const gdb_byte
*beg_of_comp_unit
= info_ptr
;
5554 header
->sect_off
= (sect_offset
) (beg_of_comp_unit
- section
->buffer
);
5556 info_ptr
= read_comp_unit_head (header
, info_ptr
, section
, section_kind
);
5558 header
->first_die_cu_offset
= (cu_offset
) (info_ptr
- beg_of_comp_unit
);
5560 error_check_comp_unit_head (header
, section
, abbrev_section
);
5565 /* Fetch the abbreviation table offset from a comp or type unit header. */
5568 read_abbrev_offset (struct dwarf2_section_info
*section
,
5569 sect_offset sect_off
)
5571 bfd
*abfd
= get_section_bfd_owner (section
);
5572 const gdb_byte
*info_ptr
;
5573 unsigned int initial_length_size
, offset_size
;
5576 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
5577 info_ptr
= section
->buffer
+ to_underlying (sect_off
);
5578 read_initial_length (abfd
, info_ptr
, &initial_length_size
);
5579 offset_size
= initial_length_size
== 4 ? 4 : 8;
5580 info_ptr
+= initial_length_size
;
5582 version
= read_2_bytes (abfd
, info_ptr
);
5586 /* Skip unit type and address size. */
5590 return (sect_offset
) read_offset_1 (abfd
, info_ptr
, offset_size
);
5593 /* Allocate a new partial symtab for file named NAME and mark this new
5594 partial symtab as being an include of PST. */
5597 dwarf2_create_include_psymtab (const char *name
, struct partial_symtab
*pst
,
5598 struct objfile
*objfile
)
5600 struct partial_symtab
*subpst
= allocate_psymtab (name
, objfile
);
5602 if (!IS_ABSOLUTE_PATH (subpst
->filename
))
5604 /* It shares objfile->objfile_obstack. */
5605 subpst
->dirname
= pst
->dirname
;
5608 subpst
->textlow
= 0;
5609 subpst
->texthigh
= 0;
5611 subpst
->dependencies
5612 = XOBNEW (&objfile
->objfile_obstack
, struct partial_symtab
*);
5613 subpst
->dependencies
[0] = pst
;
5614 subpst
->number_of_dependencies
= 1;
5616 subpst
->globals_offset
= 0;
5617 subpst
->n_global_syms
= 0;
5618 subpst
->statics_offset
= 0;
5619 subpst
->n_static_syms
= 0;
5620 subpst
->compunit_symtab
= NULL
;
5621 subpst
->read_symtab
= pst
->read_symtab
;
5624 /* No private part is necessary for include psymtabs. This property
5625 can be used to differentiate between such include psymtabs and
5626 the regular ones. */
5627 subpst
->read_symtab_private
= NULL
;
5630 /* Read the Line Number Program data and extract the list of files
5631 included by the source file represented by PST. Build an include
5632 partial symtab for each of these included files. */
5635 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
5636 struct die_info
*die
,
5637 struct partial_symtab
*pst
)
5640 struct attribute
*attr
;
5642 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
5644 lh
= dwarf_decode_line_header ((sect_offset
) DW_UNSND (attr
), cu
);
5646 return; /* No linetable, so no includes. */
5648 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). */
5649 dwarf_decode_lines (lh
.get (), pst
->dirname
, cu
, pst
, pst
->textlow
, 1);
5653 hash_signatured_type (const void *item
)
5655 const struct signatured_type
*sig_type
5656 = (const struct signatured_type
*) item
;
5658 /* This drops the top 32 bits of the signature, but is ok for a hash. */
5659 return sig_type
->signature
;
5663 eq_signatured_type (const void *item_lhs
, const void *item_rhs
)
5665 const struct signatured_type
*lhs
= (const struct signatured_type
*) item_lhs
;
5666 const struct signatured_type
*rhs
= (const struct signatured_type
*) item_rhs
;
5668 return lhs
->signature
== rhs
->signature
;
5671 /* Allocate a hash table for signatured types. */
5674 allocate_signatured_type_table (struct objfile
*objfile
)
5676 return htab_create_alloc_ex (41,
5677 hash_signatured_type
,
5680 &objfile
->objfile_obstack
,
5681 hashtab_obstack_allocate
,
5682 dummy_obstack_deallocate
);
5685 /* A helper function to add a signatured type CU to a table. */
5688 add_signatured_type_cu_to_table (void **slot
, void *datum
)
5690 struct signatured_type
*sigt
= (struct signatured_type
*) *slot
;
5691 struct signatured_type
***datap
= (struct signatured_type
***) datum
;
5699 /* A helper for create_debug_types_hash_table. Read types from SECTION
5700 and fill them into TYPES_HTAB. It will process only type units,
5701 therefore DW_UT_type. */
5704 create_debug_type_hash_table (struct dwo_file
*dwo_file
,
5705 dwarf2_section_info
*section
, htab_t
&types_htab
,
5706 rcuh_kind section_kind
)
5708 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
5709 struct dwarf2_section_info
*abbrev_section
;
5711 const gdb_byte
*info_ptr
, *end_ptr
;
5713 abbrev_section
= (dwo_file
!= NULL
5714 ? &dwo_file
->sections
.abbrev
5715 : &dwarf2_per_objfile
->abbrev
);
5717 if (dwarf_read_debug
)
5718 fprintf_unfiltered (gdb_stdlog
, "Reading %s for %s:\n",
5719 get_section_name (section
),
5720 get_section_file_name (abbrev_section
));
5722 dwarf2_read_section (objfile
, section
);
5723 info_ptr
= section
->buffer
;
5725 if (info_ptr
== NULL
)
5728 /* We can't set abfd until now because the section may be empty or
5729 not present, in which case the bfd is unknown. */
5730 abfd
= get_section_bfd_owner (section
);
5732 /* We don't use init_cutu_and_read_dies_simple, or some such, here
5733 because we don't need to read any dies: the signature is in the
5736 end_ptr
= info_ptr
+ section
->size
;
5737 while (info_ptr
< end_ptr
)
5739 struct signatured_type
*sig_type
;
5740 struct dwo_unit
*dwo_tu
;
5742 const gdb_byte
*ptr
= info_ptr
;
5743 struct comp_unit_head header
;
5744 unsigned int length
;
5746 sect_offset sect_off
= (sect_offset
) (ptr
- section
->buffer
);
5748 /* Initialize it due to a false compiler warning. */
5749 header
.signature
= -1;
5750 header
.type_cu_offset_in_tu
= (cu_offset
) -1;
5752 /* We need to read the type's signature in order to build the hash
5753 table, but we don't need anything else just yet. */
5755 ptr
= read_and_check_comp_unit_head (&header
, section
,
5756 abbrev_section
, ptr
, section_kind
);
5758 length
= get_cu_length (&header
);
5760 /* Skip dummy type units. */
5761 if (ptr
>= info_ptr
+ length
5762 || peek_abbrev_code (abfd
, ptr
) == 0
5763 || header
.unit_type
!= DW_UT_type
)
5769 if (types_htab
== NULL
)
5772 types_htab
= allocate_dwo_unit_table (objfile
);
5774 types_htab
= allocate_signatured_type_table (objfile
);
5780 dwo_tu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
5782 dwo_tu
->dwo_file
= dwo_file
;
5783 dwo_tu
->signature
= header
.signature
;
5784 dwo_tu
->type_offset_in_tu
= header
.type_cu_offset_in_tu
;
5785 dwo_tu
->section
= section
;
5786 dwo_tu
->sect_off
= sect_off
;
5787 dwo_tu
->length
= length
;
5791 /* N.B.: type_offset is not usable if this type uses a DWO file.
5792 The real type_offset is in the DWO file. */
5794 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
5795 struct signatured_type
);
5796 sig_type
->signature
= header
.signature
;
5797 sig_type
->type_offset_in_tu
= header
.type_cu_offset_in_tu
;
5798 sig_type
->per_cu
.objfile
= objfile
;
5799 sig_type
->per_cu
.is_debug_types
= 1;
5800 sig_type
->per_cu
.section
= section
;
5801 sig_type
->per_cu
.sect_off
= sect_off
;
5802 sig_type
->per_cu
.length
= length
;
5805 slot
= htab_find_slot (types_htab
,
5806 dwo_file
? (void*) dwo_tu
: (void *) sig_type
,
5808 gdb_assert (slot
!= NULL
);
5811 sect_offset dup_sect_off
;
5815 const struct dwo_unit
*dup_tu
5816 = (const struct dwo_unit
*) *slot
;
5818 dup_sect_off
= dup_tu
->sect_off
;
5822 const struct signatured_type
*dup_tu
5823 = (const struct signatured_type
*) *slot
;
5825 dup_sect_off
= dup_tu
->per_cu
.sect_off
;
5828 complaint (&symfile_complaints
,
5829 _("debug type entry at offset 0x%x is duplicate to"
5830 " the entry at offset 0x%x, signature %s"),
5831 to_underlying (sect_off
), to_underlying (dup_sect_off
),
5832 hex_string (header
.signature
));
5834 *slot
= dwo_file
? (void *) dwo_tu
: (void *) sig_type
;
5836 if (dwarf_read_debug
> 1)
5837 fprintf_unfiltered (gdb_stdlog
, " offset 0x%x, signature %s\n",
5838 to_underlying (sect_off
),
5839 hex_string (header
.signature
));
5845 /* Create the hash table of all entries in the .debug_types
5846 (or .debug_types.dwo) section(s).
5847 If reading a DWO file, then DWO_FILE is a pointer to the DWO file object,
5848 otherwise it is NULL.
5850 The result is a pointer to the hash table or NULL if there are no types.
5852 Note: This function processes DWO files only, not DWP files. */
5855 create_debug_types_hash_table (struct dwo_file
*dwo_file
,
5856 VEC (dwarf2_section_info_def
) *types
,
5860 struct dwarf2_section_info
*section
;
5862 if (VEC_empty (dwarf2_section_info_def
, types
))
5866 VEC_iterate (dwarf2_section_info_def
, types
, ix
, section
);
5868 create_debug_type_hash_table (dwo_file
, section
, types_htab
,
5872 /* Create the hash table of all entries in the .debug_types section,
5873 and initialize all_type_units.
5874 The result is zero if there is an error (e.g. missing .debug_types section),
5875 otherwise non-zero. */
5878 create_all_type_units (struct objfile
*objfile
)
5880 htab_t types_htab
= NULL
;
5881 struct signatured_type
**iter
;
5883 create_debug_type_hash_table (NULL
, &dwarf2_per_objfile
->info
, types_htab
,
5884 rcuh_kind::COMPILE
);
5885 create_debug_types_hash_table (NULL
, dwarf2_per_objfile
->types
, types_htab
);
5886 if (types_htab
== NULL
)
5888 dwarf2_per_objfile
->signatured_types
= NULL
;
5892 dwarf2_per_objfile
->signatured_types
= types_htab
;
5894 dwarf2_per_objfile
->n_type_units
5895 = dwarf2_per_objfile
->n_allocated_type_units
5896 = htab_elements (types_htab
);
5897 dwarf2_per_objfile
->all_type_units
=
5898 XNEWVEC (struct signatured_type
*, dwarf2_per_objfile
->n_type_units
);
5899 iter
= &dwarf2_per_objfile
->all_type_units
[0];
5900 htab_traverse_noresize (types_htab
, add_signatured_type_cu_to_table
, &iter
);
5901 gdb_assert (iter
- &dwarf2_per_objfile
->all_type_units
[0]
5902 == dwarf2_per_objfile
->n_type_units
);
5907 /* Add an entry for signature SIG to dwarf2_per_objfile->signatured_types.
5908 If SLOT is non-NULL, it is the entry to use in the hash table.
5909 Otherwise we find one. */
5911 static struct signatured_type
*
5912 add_type_unit (ULONGEST sig
, void **slot
)
5914 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
5915 int n_type_units
= dwarf2_per_objfile
->n_type_units
;
5916 struct signatured_type
*sig_type
;
5918 gdb_assert (n_type_units
<= dwarf2_per_objfile
->n_allocated_type_units
);
5920 if (n_type_units
> dwarf2_per_objfile
->n_allocated_type_units
)
5922 if (dwarf2_per_objfile
->n_allocated_type_units
== 0)
5923 dwarf2_per_objfile
->n_allocated_type_units
= 1;
5924 dwarf2_per_objfile
->n_allocated_type_units
*= 2;
5925 dwarf2_per_objfile
->all_type_units
5926 = XRESIZEVEC (struct signatured_type
*,
5927 dwarf2_per_objfile
->all_type_units
,
5928 dwarf2_per_objfile
->n_allocated_type_units
);
5929 ++dwarf2_per_objfile
->tu_stats
.nr_all_type_units_reallocs
;
5931 dwarf2_per_objfile
->n_type_units
= n_type_units
;
5933 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
5934 struct signatured_type
);
5935 dwarf2_per_objfile
->all_type_units
[n_type_units
- 1] = sig_type
;
5936 sig_type
->signature
= sig
;
5937 sig_type
->per_cu
.is_debug_types
= 1;
5938 if (dwarf2_per_objfile
->using_index
)
5940 sig_type
->per_cu
.v
.quick
=
5941 OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
5942 struct dwarf2_per_cu_quick_data
);
5947 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
,
5950 gdb_assert (*slot
== NULL
);
5952 /* The rest of sig_type must be filled in by the caller. */
5956 /* Subroutine of lookup_dwo_signatured_type and lookup_dwp_signatured_type.
5957 Fill in SIG_ENTRY with DWO_ENTRY. */
5960 fill_in_sig_entry_from_dwo_entry (struct objfile
*objfile
,
5961 struct signatured_type
*sig_entry
,
5962 struct dwo_unit
*dwo_entry
)
5964 /* Make sure we're not clobbering something we don't expect to. */
5965 gdb_assert (! sig_entry
->per_cu
.queued
);
5966 gdb_assert (sig_entry
->per_cu
.cu
== NULL
);
5967 if (dwarf2_per_objfile
->using_index
)
5969 gdb_assert (sig_entry
->per_cu
.v
.quick
!= NULL
);
5970 gdb_assert (sig_entry
->per_cu
.v
.quick
->compunit_symtab
== NULL
);
5973 gdb_assert (sig_entry
->per_cu
.v
.psymtab
== NULL
);
5974 gdb_assert (sig_entry
->signature
== dwo_entry
->signature
);
5975 gdb_assert (to_underlying (sig_entry
->type_offset_in_section
) == 0);
5976 gdb_assert (sig_entry
->type_unit_group
== NULL
);
5977 gdb_assert (sig_entry
->dwo_unit
== NULL
);
5979 sig_entry
->per_cu
.section
= dwo_entry
->section
;
5980 sig_entry
->per_cu
.sect_off
= dwo_entry
->sect_off
;
5981 sig_entry
->per_cu
.length
= dwo_entry
->length
;
5982 sig_entry
->per_cu
.reading_dwo_directly
= 1;
5983 sig_entry
->per_cu
.objfile
= objfile
;
5984 sig_entry
->type_offset_in_tu
= dwo_entry
->type_offset_in_tu
;
5985 sig_entry
->dwo_unit
= dwo_entry
;
5988 /* Subroutine of lookup_signatured_type.
5989 If we haven't read the TU yet, create the signatured_type data structure
5990 for a TU to be read in directly from a DWO file, bypassing the stub.
5991 This is the "Stay in DWO Optimization": When there is no DWP file and we're
5992 using .gdb_index, then when reading a CU we want to stay in the DWO file
5993 containing that CU. Otherwise we could end up reading several other DWO
5994 files (due to comdat folding) to process the transitive closure of all the
5995 mentioned TUs, and that can be slow. The current DWO file will have every
5996 type signature that it needs.
5997 We only do this for .gdb_index because in the psymtab case we already have
5998 to read all the DWOs to build the type unit groups. */
6000 static struct signatured_type
*
6001 lookup_dwo_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
6003 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
6004 struct dwo_file
*dwo_file
;
6005 struct dwo_unit find_dwo_entry
, *dwo_entry
;
6006 struct signatured_type find_sig_entry
, *sig_entry
;
6009 gdb_assert (cu
->dwo_unit
&& dwarf2_per_objfile
->using_index
);
6011 /* If TU skeletons have been removed then we may not have read in any
6013 if (dwarf2_per_objfile
->signatured_types
== NULL
)
6015 dwarf2_per_objfile
->signatured_types
6016 = allocate_signatured_type_table (objfile
);
6019 /* We only ever need to read in one copy of a signatured type.
6020 Use the global signatured_types array to do our own comdat-folding
6021 of types. If this is the first time we're reading this TU, and
6022 the TU has an entry in .gdb_index, replace the recorded data from
6023 .gdb_index with this TU. */
6025 find_sig_entry
.signature
= sig
;
6026 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
,
6027 &find_sig_entry
, INSERT
);
6028 sig_entry
= (struct signatured_type
*) *slot
;
6030 /* We can get here with the TU already read, *or* in the process of being
6031 read. Don't reassign the global entry to point to this DWO if that's
6032 the case. Also note that if the TU is already being read, it may not
6033 have come from a DWO, the program may be a mix of Fission-compiled
6034 code and non-Fission-compiled code. */
6036 /* Have we already tried to read this TU?
6037 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
6038 needn't exist in the global table yet). */
6039 if (sig_entry
!= NULL
&& sig_entry
->per_cu
.tu_read
)
6042 /* Note: cu->dwo_unit is the dwo_unit that references this TU, not the
6043 dwo_unit of the TU itself. */
6044 dwo_file
= cu
->dwo_unit
->dwo_file
;
6046 /* Ok, this is the first time we're reading this TU. */
6047 if (dwo_file
->tus
== NULL
)
6049 find_dwo_entry
.signature
= sig
;
6050 dwo_entry
= (struct dwo_unit
*) htab_find (dwo_file
->tus
, &find_dwo_entry
);
6051 if (dwo_entry
== NULL
)
6054 /* If the global table doesn't have an entry for this TU, add one. */
6055 if (sig_entry
== NULL
)
6056 sig_entry
= add_type_unit (sig
, slot
);
6058 fill_in_sig_entry_from_dwo_entry (objfile
, sig_entry
, dwo_entry
);
6059 sig_entry
->per_cu
.tu_read
= 1;
6063 /* Subroutine of lookup_signatured_type.
6064 Look up the type for signature SIG, and if we can't find SIG in .gdb_index
6065 then try the DWP file. If the TU stub (skeleton) has been removed then
6066 it won't be in .gdb_index. */
6068 static struct signatured_type
*
6069 lookup_dwp_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
6071 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
6072 struct dwp_file
*dwp_file
= get_dwp_file ();
6073 struct dwo_unit
*dwo_entry
;
6074 struct signatured_type find_sig_entry
, *sig_entry
;
6077 gdb_assert (cu
->dwo_unit
&& dwarf2_per_objfile
->using_index
);
6078 gdb_assert (dwp_file
!= NULL
);
6080 /* If TU skeletons have been removed then we may not have read in any
6082 if (dwarf2_per_objfile
->signatured_types
== NULL
)
6084 dwarf2_per_objfile
->signatured_types
6085 = allocate_signatured_type_table (objfile
);
6088 find_sig_entry
.signature
= sig
;
6089 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
,
6090 &find_sig_entry
, INSERT
);
6091 sig_entry
= (struct signatured_type
*) *slot
;
6093 /* Have we already tried to read this TU?
6094 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
6095 needn't exist in the global table yet). */
6096 if (sig_entry
!= NULL
)
6099 if (dwp_file
->tus
== NULL
)
6101 dwo_entry
= lookup_dwo_unit_in_dwp (dwp_file
, NULL
,
6102 sig
, 1 /* is_debug_types */);
6103 if (dwo_entry
== NULL
)
6106 sig_entry
= add_type_unit (sig
, slot
);
6107 fill_in_sig_entry_from_dwo_entry (objfile
, sig_entry
, dwo_entry
);
6112 /* Lookup a signature based type for DW_FORM_ref_sig8.
6113 Returns NULL if signature SIG is not present in the table.
6114 It is up to the caller to complain about this. */
6116 static struct signatured_type
*
6117 lookup_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
6120 && dwarf2_per_objfile
->using_index
)
6122 /* We're in a DWO/DWP file, and we're using .gdb_index.
6123 These cases require special processing. */
6124 if (get_dwp_file () == NULL
)
6125 return lookup_dwo_signatured_type (cu
, sig
);
6127 return lookup_dwp_signatured_type (cu
, sig
);
6131 struct signatured_type find_entry
, *entry
;
6133 if (dwarf2_per_objfile
->signatured_types
== NULL
)
6135 find_entry
.signature
= sig
;
6136 entry
= ((struct signatured_type
*)
6137 htab_find (dwarf2_per_objfile
->signatured_types
, &find_entry
));
6142 /* Low level DIE reading support. */
6144 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
6147 init_cu_die_reader (struct die_reader_specs
*reader
,
6148 struct dwarf2_cu
*cu
,
6149 struct dwarf2_section_info
*section
,
6150 struct dwo_file
*dwo_file
)
6152 gdb_assert (section
->readin
&& section
->buffer
!= NULL
);
6153 reader
->abfd
= get_section_bfd_owner (section
);
6155 reader
->dwo_file
= dwo_file
;
6156 reader
->die_section
= section
;
6157 reader
->buffer
= section
->buffer
;
6158 reader
->buffer_end
= section
->buffer
+ section
->size
;
6159 reader
->comp_dir
= NULL
;
6162 /* Subroutine of init_cutu_and_read_dies to simplify it.
6163 Read in the rest of a CU/TU top level DIE from DWO_UNIT.
6164 There's just a lot of work to do, and init_cutu_and_read_dies is big enough
6167 STUB_COMP_UNIT_DIE is for the stub DIE, we copy over certain attributes
6168 from it to the DIE in the DWO. If NULL we are skipping the stub.
6169 STUB_COMP_DIR is similar to STUB_COMP_UNIT_DIE: When reading a TU directly
6170 from the DWO file, bypassing the stub, it contains the DW_AT_comp_dir
6171 attribute of the referencing CU. At most one of STUB_COMP_UNIT_DIE and
6172 STUB_COMP_DIR may be non-NULL.
6173 *RESULT_READER,*RESULT_INFO_PTR,*RESULT_COMP_UNIT_DIE,*RESULT_HAS_CHILDREN
6174 are filled in with the info of the DIE from the DWO file.
6175 ABBREV_TABLE_PROVIDED is non-zero if the caller of init_cutu_and_read_dies
6176 provided an abbrev table to use.
6177 The result is non-zero if a valid (non-dummy) DIE was found. */
6180 read_cutu_die_from_dwo (struct dwarf2_per_cu_data
*this_cu
,
6181 struct dwo_unit
*dwo_unit
,
6182 int abbrev_table_provided
,
6183 struct die_info
*stub_comp_unit_die
,
6184 const char *stub_comp_dir
,
6185 struct die_reader_specs
*result_reader
,
6186 const gdb_byte
**result_info_ptr
,
6187 struct die_info
**result_comp_unit_die
,
6188 int *result_has_children
)
6190 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
6191 struct dwarf2_cu
*cu
= this_cu
->cu
;
6192 struct dwarf2_section_info
*section
;
6194 const gdb_byte
*begin_info_ptr
, *info_ptr
;
6195 struct attribute
*comp_dir
, *stmt_list
, *low_pc
, *high_pc
, *ranges
;
6196 int i
,num_extra_attrs
;
6197 struct dwarf2_section_info
*dwo_abbrev_section
;
6198 struct attribute
*attr
;
6199 struct die_info
*comp_unit_die
;
6201 /* At most one of these may be provided. */
6202 gdb_assert ((stub_comp_unit_die
!= NULL
) + (stub_comp_dir
!= NULL
) <= 1);
6204 /* These attributes aren't processed until later:
6205 DW_AT_stmt_list, DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges.
6206 DW_AT_comp_dir is used now, to find the DWO file, but it is also
6207 referenced later. However, these attributes are found in the stub
6208 which we won't have later. In order to not impose this complication
6209 on the rest of the code, we read them here and copy them to the
6218 if (stub_comp_unit_die
!= NULL
)
6220 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
6222 if (! this_cu
->is_debug_types
)
6223 stmt_list
= dwarf2_attr (stub_comp_unit_die
, DW_AT_stmt_list
, cu
);
6224 low_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_low_pc
, cu
);
6225 high_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_high_pc
, cu
);
6226 ranges
= dwarf2_attr (stub_comp_unit_die
, DW_AT_ranges
, cu
);
6227 comp_dir
= dwarf2_attr (stub_comp_unit_die
, DW_AT_comp_dir
, cu
);
6229 /* There should be a DW_AT_addr_base attribute here (if needed).
6230 We need the value before we can process DW_FORM_GNU_addr_index. */
6232 attr
= dwarf2_attr (stub_comp_unit_die
, DW_AT_GNU_addr_base
, cu
);
6234 cu
->addr_base
= DW_UNSND (attr
);
6236 /* There should be a DW_AT_ranges_base attribute here (if needed).
6237 We need the value before we can process DW_AT_ranges. */
6238 cu
->ranges_base
= 0;
6239 attr
= dwarf2_attr (stub_comp_unit_die
, DW_AT_GNU_ranges_base
, cu
);
6241 cu
->ranges_base
= DW_UNSND (attr
);
6243 else if (stub_comp_dir
!= NULL
)
6245 /* Reconstruct the comp_dir attribute to simplify the code below. */
6246 comp_dir
= XOBNEW (&cu
->comp_unit_obstack
, struct attribute
);
6247 comp_dir
->name
= DW_AT_comp_dir
;
6248 comp_dir
->form
= DW_FORM_string
;
6249 DW_STRING_IS_CANONICAL (comp_dir
) = 0;
6250 DW_STRING (comp_dir
) = stub_comp_dir
;
6253 /* Set up for reading the DWO CU/TU. */
6254 cu
->dwo_unit
= dwo_unit
;
6255 section
= dwo_unit
->section
;
6256 dwarf2_read_section (objfile
, section
);
6257 abfd
= get_section_bfd_owner (section
);
6258 begin_info_ptr
= info_ptr
= (section
->buffer
6259 + to_underlying (dwo_unit
->sect_off
));
6260 dwo_abbrev_section
= &dwo_unit
->dwo_file
->sections
.abbrev
;
6261 init_cu_die_reader (result_reader
, cu
, section
, dwo_unit
->dwo_file
);
6263 if (this_cu
->is_debug_types
)
6265 struct signatured_type
*sig_type
= (struct signatured_type
*) this_cu
;
6267 info_ptr
= read_and_check_comp_unit_head (&cu
->header
, section
,
6269 info_ptr
, rcuh_kind::TYPE
);
6270 /* This is not an assert because it can be caused by bad debug info. */
6271 if (sig_type
->signature
!= cu
->header
.signature
)
6273 error (_("Dwarf Error: signature mismatch %s vs %s while reading"
6274 " TU at offset 0x%x [in module %s]"),
6275 hex_string (sig_type
->signature
),
6276 hex_string (cu
->header
.signature
),
6277 to_underlying (dwo_unit
->sect_off
),
6278 bfd_get_filename (abfd
));
6280 gdb_assert (dwo_unit
->sect_off
== cu
->header
.sect_off
);
6281 /* For DWOs coming from DWP files, we don't know the CU length
6282 nor the type's offset in the TU until now. */
6283 dwo_unit
->length
= get_cu_length (&cu
->header
);
6284 dwo_unit
->type_offset_in_tu
= cu
->header
.type_cu_offset_in_tu
;
6286 /* Establish the type offset that can be used to lookup the type.
6287 For DWO files, we don't know it until now. */
6288 sig_type
->type_offset_in_section
6289 = dwo_unit
->sect_off
+ to_underlying (dwo_unit
->type_offset_in_tu
);
6293 info_ptr
= read_and_check_comp_unit_head (&cu
->header
, section
,
6295 info_ptr
, rcuh_kind::COMPILE
);
6296 gdb_assert (dwo_unit
->sect_off
== cu
->header
.sect_off
);
6297 /* For DWOs coming from DWP files, we don't know the CU length
6299 dwo_unit
->length
= get_cu_length (&cu
->header
);
6302 /* Replace the CU's original abbrev table with the DWO's.
6303 Reminder: We can't read the abbrev table until we've read the header. */
6304 if (abbrev_table_provided
)
6306 /* Don't free the provided abbrev table, the caller of
6307 init_cutu_and_read_dies owns it. */
6308 dwarf2_read_abbrevs (cu
, dwo_abbrev_section
);
6309 /* Ensure the DWO abbrev table gets freed. */
6310 make_cleanup (dwarf2_free_abbrev_table
, cu
);
6314 dwarf2_free_abbrev_table (cu
);
6315 dwarf2_read_abbrevs (cu
, dwo_abbrev_section
);
6316 /* Leave any existing abbrev table cleanup as is. */
6319 /* Read in the die, but leave space to copy over the attributes
6320 from the stub. This has the benefit of simplifying the rest of
6321 the code - all the work to maintain the illusion of a single
6322 DW_TAG_{compile,type}_unit DIE is done here. */
6323 num_extra_attrs
= ((stmt_list
!= NULL
)
6327 + (comp_dir
!= NULL
));
6328 info_ptr
= read_full_die_1 (result_reader
, result_comp_unit_die
, info_ptr
,
6329 result_has_children
, num_extra_attrs
);
6331 /* Copy over the attributes from the stub to the DIE we just read in. */
6332 comp_unit_die
= *result_comp_unit_die
;
6333 i
= comp_unit_die
->num_attrs
;
6334 if (stmt_list
!= NULL
)
6335 comp_unit_die
->attrs
[i
++] = *stmt_list
;
6337 comp_unit_die
->attrs
[i
++] = *low_pc
;
6338 if (high_pc
!= NULL
)
6339 comp_unit_die
->attrs
[i
++] = *high_pc
;
6341 comp_unit_die
->attrs
[i
++] = *ranges
;
6342 if (comp_dir
!= NULL
)
6343 comp_unit_die
->attrs
[i
++] = *comp_dir
;
6344 comp_unit_die
->num_attrs
+= num_extra_attrs
;
6346 if (dwarf_die_debug
)
6348 fprintf_unfiltered (gdb_stdlog
,
6349 "Read die from %s@0x%x of %s:\n",
6350 get_section_name (section
),
6351 (unsigned) (begin_info_ptr
- section
->buffer
),
6352 bfd_get_filename (abfd
));
6353 dump_die (comp_unit_die
, dwarf_die_debug
);
6356 /* Save the comp_dir attribute. If there is no DWP file then we'll read
6357 TUs by skipping the stub and going directly to the entry in the DWO file.
6358 However, skipping the stub means we won't get DW_AT_comp_dir, so we have
6359 to get it via circuitous means. Blech. */
6360 if (comp_dir
!= NULL
)
6361 result_reader
->comp_dir
= DW_STRING (comp_dir
);
6363 /* Skip dummy compilation units. */
6364 if (info_ptr
>= begin_info_ptr
+ dwo_unit
->length
6365 || peek_abbrev_code (abfd
, info_ptr
) == 0)
6368 *result_info_ptr
= info_ptr
;
6372 /* Subroutine of init_cutu_and_read_dies to simplify it.
6373 Look up the DWO unit specified by COMP_UNIT_DIE of THIS_CU.
6374 Returns NULL if the specified DWO unit cannot be found. */
6376 static struct dwo_unit
*
6377 lookup_dwo_unit (struct dwarf2_per_cu_data
*this_cu
,
6378 struct die_info
*comp_unit_die
)
6380 struct dwarf2_cu
*cu
= this_cu
->cu
;
6382 struct dwo_unit
*dwo_unit
;
6383 const char *comp_dir
, *dwo_name
;
6385 gdb_assert (cu
!= NULL
);
6387 /* Yeah, we look dwo_name up again, but it simplifies the code. */
6388 dwo_name
= dwarf2_string_attr (comp_unit_die
, DW_AT_GNU_dwo_name
, cu
);
6389 comp_dir
= dwarf2_string_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
6391 if (this_cu
->is_debug_types
)
6393 struct signatured_type
*sig_type
;
6395 /* Since this_cu is the first member of struct signatured_type,
6396 we can go from a pointer to one to a pointer to the other. */
6397 sig_type
= (struct signatured_type
*) this_cu
;
6398 signature
= sig_type
->signature
;
6399 dwo_unit
= lookup_dwo_type_unit (sig_type
, dwo_name
, comp_dir
);
6403 struct attribute
*attr
;
6405 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_id
, cu
);
6407 error (_("Dwarf Error: missing dwo_id for dwo_name %s"
6409 dwo_name
, objfile_name (this_cu
->objfile
));
6410 signature
= DW_UNSND (attr
);
6411 dwo_unit
= lookup_dwo_comp_unit (this_cu
, dwo_name
, comp_dir
,
6418 /* Subroutine of init_cutu_and_read_dies to simplify it.
6419 See it for a description of the parameters.
6420 Read a TU directly from a DWO file, bypassing the stub.
6422 Note: This function could be a little bit simpler if we shared cleanups
6423 with our caller, init_cutu_and_read_dies. That's generally a fragile thing
6424 to do, so we keep this function self-contained. Or we could move this
6425 into our caller, but it's complex enough already. */
6428 init_tu_and_read_dwo_dies (struct dwarf2_per_cu_data
*this_cu
,
6429 int use_existing_cu
, int keep
,
6430 die_reader_func_ftype
*die_reader_func
,
6433 struct dwarf2_cu
*cu
;
6434 struct signatured_type
*sig_type
;
6435 struct cleanup
*cleanups
, *free_cu_cleanup
= NULL
;
6436 struct die_reader_specs reader
;
6437 const gdb_byte
*info_ptr
;
6438 struct die_info
*comp_unit_die
;
6441 /* Verify we can do the following downcast, and that we have the
6443 gdb_assert (this_cu
->is_debug_types
&& this_cu
->reading_dwo_directly
);
6444 sig_type
= (struct signatured_type
*) this_cu
;
6445 gdb_assert (sig_type
->dwo_unit
!= NULL
);
6447 cleanups
= make_cleanup (null_cleanup
, NULL
);
6449 if (use_existing_cu
&& this_cu
->cu
!= NULL
)
6451 gdb_assert (this_cu
->cu
->dwo_unit
== sig_type
->dwo_unit
);
6453 /* There's no need to do the rereading_dwo_cu handling that
6454 init_cutu_and_read_dies does since we don't read the stub. */
6458 /* If !use_existing_cu, this_cu->cu must be NULL. */
6459 gdb_assert (this_cu
->cu
== NULL
);
6460 cu
= XNEW (struct dwarf2_cu
);
6461 init_one_comp_unit (cu
, this_cu
);
6462 /* If an error occurs while loading, release our storage. */
6463 free_cu_cleanup
= make_cleanup (free_heap_comp_unit
, cu
);
6466 /* A future optimization, if needed, would be to use an existing
6467 abbrev table. When reading DWOs with skeletonless TUs, all the TUs
6468 could share abbrev tables. */
6470 if (read_cutu_die_from_dwo (this_cu
, sig_type
->dwo_unit
,
6471 0 /* abbrev_table_provided */,
6472 NULL
/* stub_comp_unit_die */,
6473 sig_type
->dwo_unit
->dwo_file
->comp_dir
,
6475 &comp_unit_die
, &has_children
) == 0)
6478 do_cleanups (cleanups
);
6482 /* All the "real" work is done here. */
6483 die_reader_func (&reader
, info_ptr
, comp_unit_die
, has_children
, data
);
6485 /* This duplicates the code in init_cutu_and_read_dies,
6486 but the alternative is making the latter more complex.
6487 This function is only for the special case of using DWO files directly:
6488 no point in overly complicating the general case just to handle this. */
6489 if (free_cu_cleanup
!= NULL
)
6493 /* We've successfully allocated this compilation unit. Let our
6494 caller clean it up when finished with it. */
6495 discard_cleanups (free_cu_cleanup
);
6497 /* We can only discard free_cu_cleanup and all subsequent cleanups.
6498 So we have to manually free the abbrev table. */
6499 dwarf2_free_abbrev_table (cu
);
6501 /* Link this CU into read_in_chain. */
6502 this_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
6503 dwarf2_per_objfile
->read_in_chain
= this_cu
;
6506 do_cleanups (free_cu_cleanup
);
6509 do_cleanups (cleanups
);
6512 /* Initialize a CU (or TU) and read its DIEs.
6513 If the CU defers to a DWO file, read the DWO file as well.
6515 ABBREV_TABLE, if non-NULL, is the abbreviation table to use.
6516 Otherwise the table specified in the comp unit header is read in and used.
6517 This is an optimization for when we already have the abbrev table.
6519 If USE_EXISTING_CU is non-zero, and THIS_CU->cu is non-NULL, then use it.
6520 Otherwise, a new CU is allocated with xmalloc.
6522 If KEEP is non-zero, then if we allocated a dwarf2_cu we add it to
6523 read_in_chain. Otherwise the dwarf2_cu data is freed at the end.
6525 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
6526 linker) then DIE_READER_FUNC will not get called. */
6529 init_cutu_and_read_dies (struct dwarf2_per_cu_data
*this_cu
,
6530 struct abbrev_table
*abbrev_table
,
6531 int use_existing_cu
, int keep
,
6532 die_reader_func_ftype
*die_reader_func
,
6535 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
6536 struct dwarf2_section_info
*section
= this_cu
->section
;
6537 bfd
*abfd
= get_section_bfd_owner (section
);
6538 struct dwarf2_cu
*cu
;
6539 const gdb_byte
*begin_info_ptr
, *info_ptr
;
6540 struct die_reader_specs reader
;
6541 struct die_info
*comp_unit_die
;
6543 struct attribute
*attr
;
6544 struct cleanup
*cleanups
, *free_cu_cleanup
= NULL
;
6545 struct signatured_type
*sig_type
= NULL
;
6546 struct dwarf2_section_info
*abbrev_section
;
6547 /* Non-zero if CU currently points to a DWO file and we need to
6548 reread it. When this happens we need to reread the skeleton die
6549 before we can reread the DWO file (this only applies to CUs, not TUs). */
6550 int rereading_dwo_cu
= 0;
6552 if (dwarf_die_debug
)
6553 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset 0x%x\n",
6554 this_cu
->is_debug_types
? "type" : "comp",
6555 to_underlying (this_cu
->sect_off
));
6557 if (use_existing_cu
)
6560 /* If we're reading a TU directly from a DWO file, including a virtual DWO
6561 file (instead of going through the stub), short-circuit all of this. */
6562 if (this_cu
->reading_dwo_directly
)
6564 /* Narrow down the scope of possibilities to have to understand. */
6565 gdb_assert (this_cu
->is_debug_types
);
6566 gdb_assert (abbrev_table
== NULL
);
6567 init_tu_and_read_dwo_dies (this_cu
, use_existing_cu
, keep
,
6568 die_reader_func
, data
);
6572 cleanups
= make_cleanup (null_cleanup
, NULL
);
6574 /* This is cheap if the section is already read in. */
6575 dwarf2_read_section (objfile
, section
);
6577 begin_info_ptr
= info_ptr
= section
->buffer
+ to_underlying (this_cu
->sect_off
);
6579 abbrev_section
= get_abbrev_section_for_cu (this_cu
);
6581 if (use_existing_cu
&& this_cu
->cu
!= NULL
)
6584 /* If this CU is from a DWO file we need to start over, we need to
6585 refetch the attributes from the skeleton CU.
6586 This could be optimized by retrieving those attributes from when we
6587 were here the first time: the previous comp_unit_die was stored in
6588 comp_unit_obstack. But there's no data yet that we need this
6590 if (cu
->dwo_unit
!= NULL
)
6591 rereading_dwo_cu
= 1;
6595 /* If !use_existing_cu, this_cu->cu must be NULL. */
6596 gdb_assert (this_cu
->cu
== NULL
);
6597 cu
= XNEW (struct dwarf2_cu
);
6598 init_one_comp_unit (cu
, this_cu
);
6599 /* If an error occurs while loading, release our storage. */
6600 free_cu_cleanup
= make_cleanup (free_heap_comp_unit
, cu
);
6603 /* Get the header. */
6604 if (to_underlying (cu
->header
.first_die_cu_offset
) != 0 && !rereading_dwo_cu
)
6606 /* We already have the header, there's no need to read it in again. */
6607 info_ptr
+= to_underlying (cu
->header
.first_die_cu_offset
);
6611 if (this_cu
->is_debug_types
)
6613 info_ptr
= read_and_check_comp_unit_head (&cu
->header
, section
,
6614 abbrev_section
, info_ptr
,
6617 /* Since per_cu is the first member of struct signatured_type,
6618 we can go from a pointer to one to a pointer to the other. */
6619 sig_type
= (struct signatured_type
*) this_cu
;
6620 gdb_assert (sig_type
->signature
== cu
->header
.signature
);
6621 gdb_assert (sig_type
->type_offset_in_tu
6622 == cu
->header
.type_cu_offset_in_tu
);
6623 gdb_assert (this_cu
->sect_off
== cu
->header
.sect_off
);
6625 /* LENGTH has not been set yet for type units if we're
6626 using .gdb_index. */
6627 this_cu
->length
= get_cu_length (&cu
->header
);
6629 /* Establish the type offset that can be used to lookup the type. */
6630 sig_type
->type_offset_in_section
=
6631 this_cu
->sect_off
+ to_underlying (sig_type
->type_offset_in_tu
);
6633 this_cu
->dwarf_version
= cu
->header
.version
;
6637 info_ptr
= read_and_check_comp_unit_head (&cu
->header
, section
,
6640 rcuh_kind::COMPILE
);
6642 gdb_assert (this_cu
->sect_off
== cu
->header
.sect_off
);
6643 gdb_assert (this_cu
->length
== get_cu_length (&cu
->header
));
6644 this_cu
->dwarf_version
= cu
->header
.version
;
6648 /* Skip dummy compilation units. */
6649 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
6650 || peek_abbrev_code (abfd
, info_ptr
) == 0)
6652 do_cleanups (cleanups
);
6656 /* If we don't have them yet, read the abbrevs for this compilation unit.
6657 And if we need to read them now, make sure they're freed when we're
6658 done. Note that it's important that if the CU had an abbrev table
6659 on entry we don't free it when we're done: Somewhere up the call stack
6660 it may be in use. */
6661 if (abbrev_table
!= NULL
)
6663 gdb_assert (cu
->abbrev_table
== NULL
);
6664 gdb_assert (cu
->header
.abbrev_sect_off
== abbrev_table
->sect_off
);
6665 cu
->abbrev_table
= abbrev_table
;
6667 else if (cu
->abbrev_table
== NULL
)
6669 dwarf2_read_abbrevs (cu
, abbrev_section
);
6670 make_cleanup (dwarf2_free_abbrev_table
, cu
);
6672 else if (rereading_dwo_cu
)
6674 dwarf2_free_abbrev_table (cu
);
6675 dwarf2_read_abbrevs (cu
, abbrev_section
);
6678 /* Read the top level CU/TU die. */
6679 init_cu_die_reader (&reader
, cu
, section
, NULL
);
6680 info_ptr
= read_full_die (&reader
, &comp_unit_die
, info_ptr
, &has_children
);
6682 /* If we are in a DWO stub, process it and then read in the "real" CU/TU
6684 Note that if USE_EXISTING_OK != 0, and THIS_CU->cu already contains a
6685 DWO CU, that this test will fail (the attribute will not be present). */
6686 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_name
, cu
);
6689 struct dwo_unit
*dwo_unit
;
6690 struct die_info
*dwo_comp_unit_die
;
6694 complaint (&symfile_complaints
,
6695 _("compilation unit with DW_AT_GNU_dwo_name"
6696 " has children (offset 0x%x) [in module %s]"),
6697 to_underlying (this_cu
->sect_off
), bfd_get_filename (abfd
));
6699 dwo_unit
= lookup_dwo_unit (this_cu
, comp_unit_die
);
6700 if (dwo_unit
!= NULL
)
6702 if (read_cutu_die_from_dwo (this_cu
, dwo_unit
,
6703 abbrev_table
!= NULL
,
6704 comp_unit_die
, NULL
,
6706 &dwo_comp_unit_die
, &has_children
) == 0)
6709 do_cleanups (cleanups
);
6712 comp_unit_die
= dwo_comp_unit_die
;
6716 /* Yikes, we couldn't find the rest of the DIE, we only have
6717 the stub. A complaint has already been logged. There's
6718 not much more we can do except pass on the stub DIE to
6719 die_reader_func. We don't want to throw an error on bad
6724 /* All of the above is setup for this call. Yikes. */
6725 die_reader_func (&reader
, info_ptr
, comp_unit_die
, has_children
, data
);
6727 /* Done, clean up. */
6728 if (free_cu_cleanup
!= NULL
)
6732 /* We've successfully allocated this compilation unit. Let our
6733 caller clean it up when finished with it. */
6734 discard_cleanups (free_cu_cleanup
);
6736 /* We can only discard free_cu_cleanup and all subsequent cleanups.
6737 So we have to manually free the abbrev table. */
6738 dwarf2_free_abbrev_table (cu
);
6740 /* Link this CU into read_in_chain. */
6741 this_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
6742 dwarf2_per_objfile
->read_in_chain
= this_cu
;
6745 do_cleanups (free_cu_cleanup
);
6748 do_cleanups (cleanups
);
6751 /* Read CU/TU THIS_CU but do not follow DW_AT_GNU_dwo_name if present.
6752 DWO_FILE, if non-NULL, is the DWO file to read (the caller is assumed
6753 to have already done the lookup to find the DWO file).
6755 The caller is required to fill in THIS_CU->section, THIS_CU->offset, and
6756 THIS_CU->is_debug_types, but nothing else.
6758 We fill in THIS_CU->length.
6760 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
6761 linker) then DIE_READER_FUNC will not get called.
6763 THIS_CU->cu is always freed when done.
6764 This is done in order to not leave THIS_CU->cu in a state where we have
6765 to care whether it refers to the "main" CU or the DWO CU. */
6768 init_cutu_and_read_dies_no_follow (struct dwarf2_per_cu_data
*this_cu
,
6769 struct dwo_file
*dwo_file
,
6770 die_reader_func_ftype
*die_reader_func
,
6773 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
6774 struct dwarf2_section_info
*section
= this_cu
->section
;
6775 bfd
*abfd
= get_section_bfd_owner (section
);
6776 struct dwarf2_section_info
*abbrev_section
;
6777 struct dwarf2_cu cu
;
6778 const gdb_byte
*begin_info_ptr
, *info_ptr
;
6779 struct die_reader_specs reader
;
6780 struct cleanup
*cleanups
;
6781 struct die_info
*comp_unit_die
;
6784 if (dwarf_die_debug
)
6785 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset 0x%x\n",
6786 this_cu
->is_debug_types
? "type" : "comp",
6787 to_underlying (this_cu
->sect_off
));
6789 gdb_assert (this_cu
->cu
== NULL
);
6791 abbrev_section
= (dwo_file
!= NULL
6792 ? &dwo_file
->sections
.abbrev
6793 : get_abbrev_section_for_cu (this_cu
));
6795 /* This is cheap if the section is already read in. */
6796 dwarf2_read_section (objfile
, section
);
6798 init_one_comp_unit (&cu
, this_cu
);
6800 cleanups
= make_cleanup (free_stack_comp_unit
, &cu
);
6802 begin_info_ptr
= info_ptr
= section
->buffer
+ to_underlying (this_cu
->sect_off
);
6803 info_ptr
= read_and_check_comp_unit_head (&cu
.header
, section
,
6804 abbrev_section
, info_ptr
,
6805 (this_cu
->is_debug_types
6807 : rcuh_kind::COMPILE
));
6809 this_cu
->length
= get_cu_length (&cu
.header
);
6811 /* Skip dummy compilation units. */
6812 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
6813 || peek_abbrev_code (abfd
, info_ptr
) == 0)
6815 do_cleanups (cleanups
);
6819 dwarf2_read_abbrevs (&cu
, abbrev_section
);
6820 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
6822 init_cu_die_reader (&reader
, &cu
, section
, dwo_file
);
6823 info_ptr
= read_full_die (&reader
, &comp_unit_die
, info_ptr
, &has_children
);
6825 die_reader_func (&reader
, info_ptr
, comp_unit_die
, has_children
, data
);
6827 do_cleanups (cleanups
);
6830 /* Read a CU/TU, except that this does not look for DW_AT_GNU_dwo_name and
6831 does not lookup the specified DWO file.
6832 This cannot be used to read DWO files.
6834 THIS_CU->cu is always freed when done.
6835 This is done in order to not leave THIS_CU->cu in a state where we have
6836 to care whether it refers to the "main" CU or the DWO CU.
6837 We can revisit this if the data shows there's a performance issue. */
6840 init_cutu_and_read_dies_simple (struct dwarf2_per_cu_data
*this_cu
,
6841 die_reader_func_ftype
*die_reader_func
,
6844 init_cutu_and_read_dies_no_follow (this_cu
, NULL
, die_reader_func
, data
);
6847 /* Type Unit Groups.
6849 Type Unit Groups are a way to collapse the set of all TUs (type units) into
6850 a more manageable set. The grouping is done by DW_AT_stmt_list entry
6851 so that all types coming from the same compilation (.o file) are grouped
6852 together. A future step could be to put the types in the same symtab as
6853 the CU the types ultimately came from. */
6856 hash_type_unit_group (const void *item
)
6858 const struct type_unit_group
*tu_group
6859 = (const struct type_unit_group
*) item
;
6861 return hash_stmt_list_entry (&tu_group
->hash
);
6865 eq_type_unit_group (const void *item_lhs
, const void *item_rhs
)
6867 const struct type_unit_group
*lhs
= (const struct type_unit_group
*) item_lhs
;
6868 const struct type_unit_group
*rhs
= (const struct type_unit_group
*) item_rhs
;
6870 return eq_stmt_list_entry (&lhs
->hash
, &rhs
->hash
);
6873 /* Allocate a hash table for type unit groups. */
6876 allocate_type_unit_groups_table (void)
6878 return htab_create_alloc_ex (3,
6879 hash_type_unit_group
,
6882 &dwarf2_per_objfile
->objfile
->objfile_obstack
,
6883 hashtab_obstack_allocate
,
6884 dummy_obstack_deallocate
);
6887 /* Type units that don't have DW_AT_stmt_list are grouped into their own
6888 partial symtabs. We combine several TUs per psymtab to not let the size
6889 of any one psymtab grow too big. */
6890 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB (1 << 31)
6891 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE 10
6893 /* Helper routine for get_type_unit_group.
6894 Create the type_unit_group object used to hold one or more TUs. */
6896 static struct type_unit_group
*
6897 create_type_unit_group (struct dwarf2_cu
*cu
, sect_offset line_offset_struct
)
6899 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
6900 struct dwarf2_per_cu_data
*per_cu
;
6901 struct type_unit_group
*tu_group
;
6903 tu_group
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
6904 struct type_unit_group
);
6905 per_cu
= &tu_group
->per_cu
;
6906 per_cu
->objfile
= objfile
;
6908 if (dwarf2_per_objfile
->using_index
)
6910 per_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
6911 struct dwarf2_per_cu_quick_data
);
6915 unsigned int line_offset
= to_underlying (line_offset_struct
);
6916 struct partial_symtab
*pst
;
6919 /* Give the symtab a useful name for debug purposes. */
6920 if ((line_offset
& NO_STMT_LIST_TYPE_UNIT_PSYMTAB
) != 0)
6921 name
= xstrprintf ("<type_units_%d>",
6922 (line_offset
& ~NO_STMT_LIST_TYPE_UNIT_PSYMTAB
));
6924 name
= xstrprintf ("<type_units_at_0x%x>", line_offset
);
6926 pst
= create_partial_symtab (per_cu
, name
);
6932 tu_group
->hash
.dwo_unit
= cu
->dwo_unit
;
6933 tu_group
->hash
.line_sect_off
= line_offset_struct
;
6938 /* Look up the type_unit_group for type unit CU, and create it if necessary.
6939 STMT_LIST is a DW_AT_stmt_list attribute. */
6941 static struct type_unit_group
*
6942 get_type_unit_group (struct dwarf2_cu
*cu
, const struct attribute
*stmt_list
)
6944 struct tu_stats
*tu_stats
= &dwarf2_per_objfile
->tu_stats
;
6945 struct type_unit_group
*tu_group
;
6947 unsigned int line_offset
;
6948 struct type_unit_group type_unit_group_for_lookup
;
6950 if (dwarf2_per_objfile
->type_unit_groups
== NULL
)
6952 dwarf2_per_objfile
->type_unit_groups
=
6953 allocate_type_unit_groups_table ();
6956 /* Do we need to create a new group, or can we use an existing one? */
6960 line_offset
= DW_UNSND (stmt_list
);
6961 ++tu_stats
->nr_symtab_sharers
;
6965 /* Ugh, no stmt_list. Rare, but we have to handle it.
6966 We can do various things here like create one group per TU or
6967 spread them over multiple groups to split up the expansion work.
6968 To avoid worst case scenarios (too many groups or too large groups)
6969 we, umm, group them in bunches. */
6970 line_offset
= (NO_STMT_LIST_TYPE_UNIT_PSYMTAB
6971 | (tu_stats
->nr_stmt_less_type_units
6972 / NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE
));
6973 ++tu_stats
->nr_stmt_less_type_units
;
6976 type_unit_group_for_lookup
.hash
.dwo_unit
= cu
->dwo_unit
;
6977 type_unit_group_for_lookup
.hash
.line_sect_off
= (sect_offset
) line_offset
;
6978 slot
= htab_find_slot (dwarf2_per_objfile
->type_unit_groups
,
6979 &type_unit_group_for_lookup
, INSERT
);
6982 tu_group
= (struct type_unit_group
*) *slot
;
6983 gdb_assert (tu_group
!= NULL
);
6987 sect_offset line_offset_struct
= (sect_offset
) line_offset
;
6988 tu_group
= create_type_unit_group (cu
, line_offset_struct
);
6990 ++tu_stats
->nr_symtabs
;
6996 /* Partial symbol tables. */
6998 /* Create a psymtab named NAME and assign it to PER_CU.
7000 The caller must fill in the following details:
7001 dirname, textlow, texthigh. */
7003 static struct partial_symtab
*
7004 create_partial_symtab (struct dwarf2_per_cu_data
*per_cu
, const char *name
)
7006 struct objfile
*objfile
= per_cu
->objfile
;
7007 struct partial_symtab
*pst
;
7009 pst
= start_psymtab_common (objfile
, name
, 0,
7010 objfile
->global_psymbols
,
7011 objfile
->static_psymbols
);
7013 pst
->psymtabs_addrmap_supported
= 1;
7015 /* This is the glue that links PST into GDB's symbol API. */
7016 pst
->read_symtab_private
= per_cu
;
7017 pst
->read_symtab
= dwarf2_read_symtab
;
7018 per_cu
->v
.psymtab
= pst
;
7023 /* The DATA object passed to process_psymtab_comp_unit_reader has this
7026 struct process_psymtab_comp_unit_data
7028 /* True if we are reading a DW_TAG_partial_unit. */
7030 int want_partial_unit
;
7032 /* The "pretend" language that is used if the CU doesn't declare a
7035 enum language pretend_language
;
7038 /* die_reader_func for process_psymtab_comp_unit. */
7041 process_psymtab_comp_unit_reader (const struct die_reader_specs
*reader
,
7042 const gdb_byte
*info_ptr
,
7043 struct die_info
*comp_unit_die
,
7047 struct dwarf2_cu
*cu
= reader
->cu
;
7048 struct objfile
*objfile
= cu
->objfile
;
7049 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
7050 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
7052 CORE_ADDR best_lowpc
= 0, best_highpc
= 0;
7053 struct partial_symtab
*pst
;
7054 enum pc_bounds_kind cu_bounds_kind
;
7055 const char *filename
;
7056 struct process_psymtab_comp_unit_data
*info
7057 = (struct process_psymtab_comp_unit_data
*) data
;
7059 if (comp_unit_die
->tag
== DW_TAG_partial_unit
&& !info
->want_partial_unit
)
7062 gdb_assert (! per_cu
->is_debug_types
);
7064 prepare_one_comp_unit (cu
, comp_unit_die
, info
->pretend_language
);
7066 cu
->list_in_scope
= &file_symbols
;
7068 /* Allocate a new partial symbol table structure. */
7069 filename
= dwarf2_string_attr (comp_unit_die
, DW_AT_name
, cu
);
7070 if (filename
== NULL
)
7073 pst
= create_partial_symtab (per_cu
, filename
);
7075 /* This must be done before calling dwarf2_build_include_psymtabs. */
7076 pst
->dirname
= dwarf2_string_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
7078 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
7080 dwarf2_find_base_address (comp_unit_die
, cu
);
7082 /* Possibly set the default values of LOWPC and HIGHPC from
7084 cu_bounds_kind
= dwarf2_get_pc_bounds (comp_unit_die
, &best_lowpc
,
7085 &best_highpc
, cu
, pst
);
7086 if (cu_bounds_kind
== PC_BOUNDS_HIGH_LOW
&& best_lowpc
< best_highpc
)
7087 /* Store the contiguous range if it is not empty; it can be empty for
7088 CUs with no code. */
7089 addrmap_set_empty (objfile
->psymtabs_addrmap
,
7090 gdbarch_adjust_dwarf2_addr (gdbarch
,
7091 best_lowpc
+ baseaddr
),
7092 gdbarch_adjust_dwarf2_addr (gdbarch
,
7093 best_highpc
+ baseaddr
) - 1,
7096 /* Check if comp unit has_children.
7097 If so, read the rest of the partial symbols from this comp unit.
7098 If not, there's no more debug_info for this comp unit. */
7101 struct partial_die_info
*first_die
;
7102 CORE_ADDR lowpc
, highpc
;
7104 lowpc
= ((CORE_ADDR
) -1);
7105 highpc
= ((CORE_ADDR
) 0);
7107 first_die
= load_partial_dies (reader
, info_ptr
, 1);
7109 scan_partial_symbols (first_die
, &lowpc
, &highpc
,
7110 cu_bounds_kind
<= PC_BOUNDS_INVALID
, cu
);
7112 /* If we didn't find a lowpc, set it to highpc to avoid
7113 complaints from `maint check'. */
7114 if (lowpc
== ((CORE_ADDR
) -1))
7117 /* If the compilation unit didn't have an explicit address range,
7118 then use the information extracted from its child dies. */
7119 if (cu_bounds_kind
<= PC_BOUNDS_INVALID
)
7122 best_highpc
= highpc
;
7125 pst
->textlow
= gdbarch_adjust_dwarf2_addr (gdbarch
, best_lowpc
+ baseaddr
);
7126 pst
->texthigh
= gdbarch_adjust_dwarf2_addr (gdbarch
, best_highpc
+ baseaddr
);
7128 end_psymtab_common (objfile
, pst
);
7130 if (!VEC_empty (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
))
7133 int len
= VEC_length (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
);
7134 struct dwarf2_per_cu_data
*iter
;
7136 /* Fill in 'dependencies' here; we fill in 'users' in a
7138 pst
->number_of_dependencies
= len
;
7140 XOBNEWVEC (&objfile
->objfile_obstack
, struct partial_symtab
*, len
);
7142 VEC_iterate (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
,
7145 pst
->dependencies
[i
] = iter
->v
.psymtab
;
7147 VEC_free (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
);
7150 /* Get the list of files included in the current compilation unit,
7151 and build a psymtab for each of them. */
7152 dwarf2_build_include_psymtabs (cu
, comp_unit_die
, pst
);
7154 if (dwarf_read_debug
)
7156 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
7158 fprintf_unfiltered (gdb_stdlog
,
7159 "Psymtab for %s unit @0x%x: %s - %s"
7160 ", %d global, %d static syms\n",
7161 per_cu
->is_debug_types
? "type" : "comp",
7162 to_underlying (per_cu
->sect_off
),
7163 paddress (gdbarch
, pst
->textlow
),
7164 paddress (gdbarch
, pst
->texthigh
),
7165 pst
->n_global_syms
, pst
->n_static_syms
);
7169 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
7170 Process compilation unit THIS_CU for a psymtab. */
7173 process_psymtab_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
7174 int want_partial_unit
,
7175 enum language pretend_language
)
7177 /* If this compilation unit was already read in, free the
7178 cached copy in order to read it in again. This is
7179 necessary because we skipped some symbols when we first
7180 read in the compilation unit (see load_partial_dies).
7181 This problem could be avoided, but the benefit is unclear. */
7182 if (this_cu
->cu
!= NULL
)
7183 free_one_cached_comp_unit (this_cu
);
7185 if (this_cu
->is_debug_types
)
7186 init_cutu_and_read_dies (this_cu
, NULL
, 0, 0, build_type_psymtabs_reader
,
7190 process_psymtab_comp_unit_data info
;
7191 info
.want_partial_unit
= want_partial_unit
;
7192 info
.pretend_language
= pretend_language
;
7193 init_cutu_and_read_dies (this_cu
, NULL
, 0, 0,
7194 process_psymtab_comp_unit_reader
, &info
);
7197 /* Age out any secondary CUs. */
7198 age_cached_comp_units ();
7201 /* Reader function for build_type_psymtabs. */
7204 build_type_psymtabs_reader (const struct die_reader_specs
*reader
,
7205 const gdb_byte
*info_ptr
,
7206 struct die_info
*type_unit_die
,
7210 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
7211 struct dwarf2_cu
*cu
= reader
->cu
;
7212 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
7213 struct signatured_type
*sig_type
;
7214 struct type_unit_group
*tu_group
;
7215 struct attribute
*attr
;
7216 struct partial_die_info
*first_die
;
7217 CORE_ADDR lowpc
, highpc
;
7218 struct partial_symtab
*pst
;
7220 gdb_assert (data
== NULL
);
7221 gdb_assert (per_cu
->is_debug_types
);
7222 sig_type
= (struct signatured_type
*) per_cu
;
7227 attr
= dwarf2_attr_no_follow (type_unit_die
, DW_AT_stmt_list
);
7228 tu_group
= get_type_unit_group (cu
, attr
);
7230 VEC_safe_push (sig_type_ptr
, tu_group
->tus
, sig_type
);
7232 prepare_one_comp_unit (cu
, type_unit_die
, language_minimal
);
7233 cu
->list_in_scope
= &file_symbols
;
7234 pst
= create_partial_symtab (per_cu
, "");
7237 first_die
= load_partial_dies (reader
, info_ptr
, 1);
7239 lowpc
= (CORE_ADDR
) -1;
7240 highpc
= (CORE_ADDR
) 0;
7241 scan_partial_symbols (first_die
, &lowpc
, &highpc
, 0, cu
);
7243 end_psymtab_common (objfile
, pst
);
7246 /* Struct used to sort TUs by their abbreviation table offset. */
7248 struct tu_abbrev_offset
7250 struct signatured_type
*sig_type
;
7251 sect_offset abbrev_offset
;
7254 /* Helper routine for build_type_psymtabs_1, passed to qsort. */
7257 sort_tu_by_abbrev_offset (const void *ap
, const void *bp
)
7259 const struct tu_abbrev_offset
* const *a
7260 = (const struct tu_abbrev_offset
* const*) ap
;
7261 const struct tu_abbrev_offset
* const *b
7262 = (const struct tu_abbrev_offset
* const*) bp
;
7263 sect_offset aoff
= (*a
)->abbrev_offset
;
7264 sect_offset boff
= (*b
)->abbrev_offset
;
7266 return (aoff
> boff
) - (aoff
< boff
);
7269 /* Efficiently read all the type units.
7270 This does the bulk of the work for build_type_psymtabs.
7272 The efficiency is because we sort TUs by the abbrev table they use and
7273 only read each abbrev table once. In one program there are 200K TUs
7274 sharing 8K abbrev tables.
7276 The main purpose of this function is to support building the
7277 dwarf2_per_objfile->type_unit_groups table.
7278 TUs typically share the DW_AT_stmt_list of the CU they came from, so we
7279 can collapse the search space by grouping them by stmt_list.
7280 The savings can be significant, in the same program from above the 200K TUs
7281 share 8K stmt_list tables.
7283 FUNC is expected to call get_type_unit_group, which will create the
7284 struct type_unit_group if necessary and add it to
7285 dwarf2_per_objfile->type_unit_groups. */
7288 build_type_psymtabs_1 (void)
7290 struct tu_stats
*tu_stats
= &dwarf2_per_objfile
->tu_stats
;
7291 struct cleanup
*cleanups
;
7292 struct abbrev_table
*abbrev_table
;
7293 sect_offset abbrev_offset
;
7294 struct tu_abbrev_offset
*sorted_by_abbrev
;
7297 /* It's up to the caller to not call us multiple times. */
7298 gdb_assert (dwarf2_per_objfile
->type_unit_groups
== NULL
);
7300 if (dwarf2_per_objfile
->n_type_units
== 0)
7303 /* TUs typically share abbrev tables, and there can be way more TUs than
7304 abbrev tables. Sort by abbrev table to reduce the number of times we
7305 read each abbrev table in.
7306 Alternatives are to punt or to maintain a cache of abbrev tables.
7307 This is simpler and efficient enough for now.
7309 Later we group TUs by their DW_AT_stmt_list value (as this defines the
7310 symtab to use). Typically TUs with the same abbrev offset have the same
7311 stmt_list value too so in practice this should work well.
7313 The basic algorithm here is:
7315 sort TUs by abbrev table
7316 for each TU with same abbrev table:
7317 read abbrev table if first user
7318 read TU top level DIE
7319 [IWBN if DWO skeletons had DW_AT_stmt_list]
7322 if (dwarf_read_debug
)
7323 fprintf_unfiltered (gdb_stdlog
, "Building type unit groups ...\n");
7325 /* Sort in a separate table to maintain the order of all_type_units
7326 for .gdb_index: TU indices directly index all_type_units. */
7327 sorted_by_abbrev
= XNEWVEC (struct tu_abbrev_offset
,
7328 dwarf2_per_objfile
->n_type_units
);
7329 for (i
= 0; i
< dwarf2_per_objfile
->n_type_units
; ++i
)
7331 struct signatured_type
*sig_type
= dwarf2_per_objfile
->all_type_units
[i
];
7333 sorted_by_abbrev
[i
].sig_type
= sig_type
;
7334 sorted_by_abbrev
[i
].abbrev_offset
=
7335 read_abbrev_offset (sig_type
->per_cu
.section
,
7336 sig_type
->per_cu
.sect_off
);
7338 cleanups
= make_cleanup (xfree
, sorted_by_abbrev
);
7339 qsort (sorted_by_abbrev
, dwarf2_per_objfile
->n_type_units
,
7340 sizeof (struct tu_abbrev_offset
), sort_tu_by_abbrev_offset
);
7342 abbrev_offset
= (sect_offset
) ~(unsigned) 0;
7343 abbrev_table
= NULL
;
7344 make_cleanup (abbrev_table_free_cleanup
, &abbrev_table
);
7346 for (i
= 0; i
< dwarf2_per_objfile
->n_type_units
; ++i
)
7348 const struct tu_abbrev_offset
*tu
= &sorted_by_abbrev
[i
];
7350 /* Switch to the next abbrev table if necessary. */
7351 if (abbrev_table
== NULL
7352 || tu
->abbrev_offset
!= abbrev_offset
)
7354 if (abbrev_table
!= NULL
)
7356 abbrev_table_free (abbrev_table
);
7357 /* Reset to NULL in case abbrev_table_read_table throws
7358 an error: abbrev_table_free_cleanup will get called. */
7359 abbrev_table
= NULL
;
7361 abbrev_offset
= tu
->abbrev_offset
;
7363 abbrev_table_read_table (&dwarf2_per_objfile
->abbrev
,
7365 ++tu_stats
->nr_uniq_abbrev_tables
;
7368 init_cutu_and_read_dies (&tu
->sig_type
->per_cu
, abbrev_table
, 0, 0,
7369 build_type_psymtabs_reader
, NULL
);
7372 do_cleanups (cleanups
);
7375 /* Print collected type unit statistics. */
7378 print_tu_stats (void)
7380 struct tu_stats
*tu_stats
= &dwarf2_per_objfile
->tu_stats
;
7382 fprintf_unfiltered (gdb_stdlog
, "Type unit statistics:\n");
7383 fprintf_unfiltered (gdb_stdlog
, " %d TUs\n",
7384 dwarf2_per_objfile
->n_type_units
);
7385 fprintf_unfiltered (gdb_stdlog
, " %d uniq abbrev tables\n",
7386 tu_stats
->nr_uniq_abbrev_tables
);
7387 fprintf_unfiltered (gdb_stdlog
, " %d symtabs from stmt_list entries\n",
7388 tu_stats
->nr_symtabs
);
7389 fprintf_unfiltered (gdb_stdlog
, " %d symtab sharers\n",
7390 tu_stats
->nr_symtab_sharers
);
7391 fprintf_unfiltered (gdb_stdlog
, " %d type units without a stmt_list\n",
7392 tu_stats
->nr_stmt_less_type_units
);
7393 fprintf_unfiltered (gdb_stdlog
, " %d all_type_units reallocs\n",
7394 tu_stats
->nr_all_type_units_reallocs
);
7397 /* Traversal function for build_type_psymtabs. */
7400 build_type_psymtab_dependencies (void **slot
, void *info
)
7402 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
7403 struct type_unit_group
*tu_group
= (struct type_unit_group
*) *slot
;
7404 struct dwarf2_per_cu_data
*per_cu
= &tu_group
->per_cu
;
7405 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
7406 int len
= VEC_length (sig_type_ptr
, tu_group
->tus
);
7407 struct signatured_type
*iter
;
7410 gdb_assert (len
> 0);
7411 gdb_assert (IS_TYPE_UNIT_GROUP (per_cu
));
7413 pst
->number_of_dependencies
= len
;
7415 XOBNEWVEC (&objfile
->objfile_obstack
, struct partial_symtab
*, len
);
7417 VEC_iterate (sig_type_ptr
, tu_group
->tus
, i
, iter
);
7420 gdb_assert (iter
->per_cu
.is_debug_types
);
7421 pst
->dependencies
[i
] = iter
->per_cu
.v
.psymtab
;
7422 iter
->type_unit_group
= tu_group
;
7425 VEC_free (sig_type_ptr
, tu_group
->tus
);
7430 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
7431 Build partial symbol tables for the .debug_types comp-units. */
7434 build_type_psymtabs (struct objfile
*objfile
)
7436 if (! create_all_type_units (objfile
))
7439 build_type_psymtabs_1 ();
7442 /* Traversal function for process_skeletonless_type_unit.
7443 Read a TU in a DWO file and build partial symbols for it. */
7446 process_skeletonless_type_unit (void **slot
, void *info
)
7448 struct dwo_unit
*dwo_unit
= (struct dwo_unit
*) *slot
;
7449 struct objfile
*objfile
= (struct objfile
*) info
;
7450 struct signatured_type find_entry
, *entry
;
7452 /* If this TU doesn't exist in the global table, add it and read it in. */
7454 if (dwarf2_per_objfile
->signatured_types
== NULL
)
7456 dwarf2_per_objfile
->signatured_types
7457 = allocate_signatured_type_table (objfile
);
7460 find_entry
.signature
= dwo_unit
->signature
;
7461 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
, &find_entry
,
7463 /* If we've already seen this type there's nothing to do. What's happening
7464 is we're doing our own version of comdat-folding here. */
7468 /* This does the job that create_all_type_units would have done for
7470 entry
= add_type_unit (dwo_unit
->signature
, slot
);
7471 fill_in_sig_entry_from_dwo_entry (objfile
, entry
, dwo_unit
);
7474 /* This does the job that build_type_psymtabs_1 would have done. */
7475 init_cutu_and_read_dies (&entry
->per_cu
, NULL
, 0, 0,
7476 build_type_psymtabs_reader
, NULL
);
7481 /* Traversal function for process_skeletonless_type_units. */
7484 process_dwo_file_for_skeletonless_type_units (void **slot
, void *info
)
7486 struct dwo_file
*dwo_file
= (struct dwo_file
*) *slot
;
7488 if (dwo_file
->tus
!= NULL
)
7490 htab_traverse_noresize (dwo_file
->tus
,
7491 process_skeletonless_type_unit
, info
);
7497 /* Scan all TUs of DWO files, verifying we've processed them.
7498 This is needed in case a TU was emitted without its skeleton.
7499 Note: This can't be done until we know what all the DWO files are. */
7502 process_skeletonless_type_units (struct objfile
*objfile
)
7504 /* Skeletonless TUs in DWP files without .gdb_index is not supported yet. */
7505 if (get_dwp_file () == NULL
7506 && dwarf2_per_objfile
->dwo_files
!= NULL
)
7508 htab_traverse_noresize (dwarf2_per_objfile
->dwo_files
,
7509 process_dwo_file_for_skeletonless_type_units
,
7514 /* Compute the 'user' field for each psymtab in OBJFILE. */
7517 set_partial_user (struct objfile
*objfile
)
7521 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
7523 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (i
);
7524 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
7530 for (j
= 0; j
< pst
->number_of_dependencies
; ++j
)
7532 /* Set the 'user' field only if it is not already set. */
7533 if (pst
->dependencies
[j
]->user
== NULL
)
7534 pst
->dependencies
[j
]->user
= pst
;
7539 /* Build the partial symbol table by doing a quick pass through the
7540 .debug_info and .debug_abbrev sections. */
7543 dwarf2_build_psymtabs_hard (struct objfile
*objfile
)
7545 struct cleanup
*back_to
;
7548 if (dwarf_read_debug
)
7550 fprintf_unfiltered (gdb_stdlog
, "Building psymtabs of objfile %s ...\n",
7551 objfile_name (objfile
));
7554 dwarf2_per_objfile
->reading_partial_symbols
= 1;
7556 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
7558 /* Any cached compilation units will be linked by the per-objfile
7559 read_in_chain. Make sure to free them when we're done. */
7560 back_to
= make_cleanup (free_cached_comp_units
, NULL
);
7562 build_type_psymtabs (objfile
);
7564 create_all_comp_units (objfile
);
7566 /* Create a temporary address map on a temporary obstack. We later
7567 copy this to the final obstack. */
7568 auto_obstack temp_obstack
;
7570 scoped_restore save_psymtabs_addrmap
7571 = make_scoped_restore (&objfile
->psymtabs_addrmap
,
7572 addrmap_create_mutable (&temp_obstack
));
7574 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
7576 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (i
);
7578 process_psymtab_comp_unit (per_cu
, 0, language_minimal
);
7581 /* This has to wait until we read the CUs, we need the list of DWOs. */
7582 process_skeletonless_type_units (objfile
);
7584 /* Now that all TUs have been processed we can fill in the dependencies. */
7585 if (dwarf2_per_objfile
->type_unit_groups
!= NULL
)
7587 htab_traverse_noresize (dwarf2_per_objfile
->type_unit_groups
,
7588 build_type_psymtab_dependencies
, NULL
);
7591 if (dwarf_read_debug
)
7594 set_partial_user (objfile
);
7596 objfile
->psymtabs_addrmap
= addrmap_create_fixed (objfile
->psymtabs_addrmap
,
7597 &objfile
->objfile_obstack
);
7598 /* At this point we want to keep the address map. */
7599 save_psymtabs_addrmap
.release ();
7601 do_cleanups (back_to
);
7603 if (dwarf_read_debug
)
7604 fprintf_unfiltered (gdb_stdlog
, "Done building psymtabs of %s\n",
7605 objfile_name (objfile
));
7608 /* die_reader_func for load_partial_comp_unit. */
7611 load_partial_comp_unit_reader (const struct die_reader_specs
*reader
,
7612 const gdb_byte
*info_ptr
,
7613 struct die_info
*comp_unit_die
,
7617 struct dwarf2_cu
*cu
= reader
->cu
;
7619 prepare_one_comp_unit (cu
, comp_unit_die
, language_minimal
);
7621 /* Check if comp unit has_children.
7622 If so, read the rest of the partial symbols from this comp unit.
7623 If not, there's no more debug_info for this comp unit. */
7625 load_partial_dies (reader
, info_ptr
, 0);
7628 /* Load the partial DIEs for a secondary CU into memory.
7629 This is also used when rereading a primary CU with load_all_dies. */
7632 load_partial_comp_unit (struct dwarf2_per_cu_data
*this_cu
)
7634 init_cutu_and_read_dies (this_cu
, NULL
, 1, 1,
7635 load_partial_comp_unit_reader
, NULL
);
7639 read_comp_units_from_section (struct objfile
*objfile
,
7640 struct dwarf2_section_info
*section
,
7641 struct dwarf2_section_info
*abbrev_section
,
7642 unsigned int is_dwz
,
7645 struct dwarf2_per_cu_data
***all_comp_units
)
7647 const gdb_byte
*info_ptr
;
7649 if (dwarf_read_debug
)
7650 fprintf_unfiltered (gdb_stdlog
, "Reading %s for %s\n",
7651 get_section_name (section
),
7652 get_section_file_name (section
));
7654 dwarf2_read_section (objfile
, section
);
7656 info_ptr
= section
->buffer
;
7658 while (info_ptr
< section
->buffer
+ section
->size
)
7660 struct dwarf2_per_cu_data
*this_cu
;
7662 sect_offset sect_off
= (sect_offset
) (info_ptr
- section
->buffer
);
7664 comp_unit_head cu_header
;
7665 read_and_check_comp_unit_head (&cu_header
, section
, abbrev_section
,
7666 info_ptr
, rcuh_kind::COMPILE
);
7668 /* Save the compilation unit for later lookup. */
7669 if (cu_header
.unit_type
!= DW_UT_type
)
7671 this_cu
= XOBNEW (&objfile
->objfile_obstack
,
7672 struct dwarf2_per_cu_data
);
7673 memset (this_cu
, 0, sizeof (*this_cu
));
7677 auto sig_type
= XOBNEW (&objfile
->objfile_obstack
,
7678 struct signatured_type
);
7679 memset (sig_type
, 0, sizeof (*sig_type
));
7680 sig_type
->signature
= cu_header
.signature
;
7681 sig_type
->type_offset_in_tu
= cu_header
.type_cu_offset_in_tu
;
7682 this_cu
= &sig_type
->per_cu
;
7684 this_cu
->is_debug_types
= (cu_header
.unit_type
== DW_UT_type
);
7685 this_cu
->sect_off
= sect_off
;
7686 this_cu
->length
= cu_header
.length
+ cu_header
.initial_length_size
;
7687 this_cu
->is_dwz
= is_dwz
;
7688 this_cu
->objfile
= objfile
;
7689 this_cu
->section
= section
;
7691 if (*n_comp_units
== *n_allocated
)
7694 *all_comp_units
= XRESIZEVEC (struct dwarf2_per_cu_data
*,
7695 *all_comp_units
, *n_allocated
);
7697 (*all_comp_units
)[*n_comp_units
] = this_cu
;
7700 info_ptr
= info_ptr
+ this_cu
->length
;
7704 /* Create a list of all compilation units in OBJFILE.
7705 This is only done for -readnow and building partial symtabs. */
7708 create_all_comp_units (struct objfile
*objfile
)
7712 struct dwarf2_per_cu_data
**all_comp_units
;
7713 struct dwz_file
*dwz
;
7717 all_comp_units
= XNEWVEC (struct dwarf2_per_cu_data
*, n_allocated
);
7719 read_comp_units_from_section (objfile
, &dwarf2_per_objfile
->info
,
7720 &dwarf2_per_objfile
->abbrev
, 0,
7721 &n_allocated
, &n_comp_units
, &all_comp_units
);
7723 dwz
= dwarf2_get_dwz_file ();
7725 read_comp_units_from_section (objfile
, &dwz
->info
, &dwz
->abbrev
, 1,
7726 &n_allocated
, &n_comp_units
,
7729 dwarf2_per_objfile
->all_comp_units
= XOBNEWVEC (&objfile
->objfile_obstack
,
7730 struct dwarf2_per_cu_data
*,
7732 memcpy (dwarf2_per_objfile
->all_comp_units
, all_comp_units
,
7733 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
7734 xfree (all_comp_units
);
7735 dwarf2_per_objfile
->n_comp_units
= n_comp_units
;
7738 /* Process all loaded DIEs for compilation unit CU, starting at
7739 FIRST_DIE. The caller should pass SET_ADDRMAP == 1 if the compilation
7740 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
7741 DW_AT_ranges). See the comments of add_partial_subprogram on how
7742 SET_ADDRMAP is used and how *LOWPC and *HIGHPC are updated. */
7745 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
7746 CORE_ADDR
*highpc
, int set_addrmap
,
7747 struct dwarf2_cu
*cu
)
7749 struct partial_die_info
*pdi
;
7751 /* Now, march along the PDI's, descending into ones which have
7752 interesting children but skipping the children of the other ones,
7753 until we reach the end of the compilation unit. */
7759 fixup_partial_die (pdi
, cu
);
7761 /* Anonymous namespaces or modules have no name but have interesting
7762 children, so we need to look at them. Ditto for anonymous
7765 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
7766 || pdi
->tag
== DW_TAG_module
|| pdi
->tag
== DW_TAG_enumeration_type
7767 || pdi
->tag
== DW_TAG_imported_unit
)
7771 case DW_TAG_subprogram
:
7772 add_partial_subprogram (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
7774 case DW_TAG_constant
:
7775 case DW_TAG_variable
:
7776 case DW_TAG_typedef
:
7777 case DW_TAG_union_type
:
7778 if (!pdi
->is_declaration
)
7780 add_partial_symbol (pdi
, cu
);
7783 case DW_TAG_class_type
:
7784 case DW_TAG_interface_type
:
7785 case DW_TAG_structure_type
:
7786 if (!pdi
->is_declaration
)
7788 add_partial_symbol (pdi
, cu
);
7790 if (cu
->language
== language_rust
&& pdi
->has_children
)
7791 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
,
7794 case DW_TAG_enumeration_type
:
7795 if (!pdi
->is_declaration
)
7796 add_partial_enumeration (pdi
, cu
);
7798 case DW_TAG_base_type
:
7799 case DW_TAG_subrange_type
:
7800 /* File scope base type definitions are added to the partial
7802 add_partial_symbol (pdi
, cu
);
7804 case DW_TAG_namespace
:
7805 add_partial_namespace (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
7808 add_partial_module (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
7810 case DW_TAG_imported_unit
:
7812 struct dwarf2_per_cu_data
*per_cu
;
7814 /* For now we don't handle imported units in type units. */
7815 if (cu
->per_cu
->is_debug_types
)
7817 error (_("Dwarf Error: DW_TAG_imported_unit is not"
7818 " supported in type units [in module %s]"),
7819 objfile_name (cu
->objfile
));
7822 per_cu
= dwarf2_find_containing_comp_unit (pdi
->d
.sect_off
,
7826 /* Go read the partial unit, if needed. */
7827 if (per_cu
->v
.psymtab
== NULL
)
7828 process_psymtab_comp_unit (per_cu
, 1, cu
->language
);
7830 VEC_safe_push (dwarf2_per_cu_ptr
,
7831 cu
->per_cu
->imported_symtabs
, per_cu
);
7834 case DW_TAG_imported_declaration
:
7835 add_partial_symbol (pdi
, cu
);
7842 /* If the die has a sibling, skip to the sibling. */
7844 pdi
= pdi
->die_sibling
;
7848 /* Functions used to compute the fully scoped name of a partial DIE.
7850 Normally, this is simple. For C++, the parent DIE's fully scoped
7851 name is concatenated with "::" and the partial DIE's name.
7852 Enumerators are an exception; they use the scope of their parent
7853 enumeration type, i.e. the name of the enumeration type is not
7854 prepended to the enumerator.
7856 There are two complexities. One is DW_AT_specification; in this
7857 case "parent" means the parent of the target of the specification,
7858 instead of the direct parent of the DIE. The other is compilers
7859 which do not emit DW_TAG_namespace; in this case we try to guess
7860 the fully qualified name of structure types from their members'
7861 linkage names. This must be done using the DIE's children rather
7862 than the children of any DW_AT_specification target. We only need
7863 to do this for structures at the top level, i.e. if the target of
7864 any DW_AT_specification (if any; otherwise the DIE itself) does not
7867 /* Compute the scope prefix associated with PDI's parent, in
7868 compilation unit CU. The result will be allocated on CU's
7869 comp_unit_obstack, or a copy of the already allocated PDI->NAME
7870 field. NULL is returned if no prefix is necessary. */
7872 partial_die_parent_scope (struct partial_die_info
*pdi
,
7873 struct dwarf2_cu
*cu
)
7875 const char *grandparent_scope
;
7876 struct partial_die_info
*parent
, *real_pdi
;
7878 /* We need to look at our parent DIE; if we have a DW_AT_specification,
7879 then this means the parent of the specification DIE. */
7882 while (real_pdi
->has_specification
)
7883 real_pdi
= find_partial_die (real_pdi
->spec_offset
,
7884 real_pdi
->spec_is_dwz
, cu
);
7886 parent
= real_pdi
->die_parent
;
7890 if (parent
->scope_set
)
7891 return parent
->scope
;
7893 fixup_partial_die (parent
, cu
);
7895 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
7897 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
7898 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
7899 Work around this problem here. */
7900 if (cu
->language
== language_cplus
7901 && parent
->tag
== DW_TAG_namespace
7902 && strcmp (parent
->name
, "::") == 0
7903 && grandparent_scope
== NULL
)
7905 parent
->scope
= NULL
;
7906 parent
->scope_set
= 1;
7910 if (pdi
->tag
== DW_TAG_enumerator
)
7911 /* Enumerators should not get the name of the enumeration as a prefix. */
7912 parent
->scope
= grandparent_scope
;
7913 else if (parent
->tag
== DW_TAG_namespace
7914 || parent
->tag
== DW_TAG_module
7915 || parent
->tag
== DW_TAG_structure_type
7916 || parent
->tag
== DW_TAG_class_type
7917 || parent
->tag
== DW_TAG_interface_type
7918 || parent
->tag
== DW_TAG_union_type
7919 || parent
->tag
== DW_TAG_enumeration_type
)
7921 if (grandparent_scope
== NULL
)
7922 parent
->scope
= parent
->name
;
7924 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
,
7926 parent
->name
, 0, cu
);
7930 /* FIXME drow/2004-04-01: What should we be doing with
7931 function-local names? For partial symbols, we should probably be
7933 complaint (&symfile_complaints
,
7934 _("unhandled containing DIE tag %d for DIE at %d"),
7935 parent
->tag
, to_underlying (pdi
->sect_off
));
7936 parent
->scope
= grandparent_scope
;
7939 parent
->scope_set
= 1;
7940 return parent
->scope
;
7943 /* Return the fully scoped name associated with PDI, from compilation unit
7944 CU. The result will be allocated with malloc. */
7947 partial_die_full_name (struct partial_die_info
*pdi
,
7948 struct dwarf2_cu
*cu
)
7950 const char *parent_scope
;
7952 /* If this is a template instantiation, we can not work out the
7953 template arguments from partial DIEs. So, unfortunately, we have
7954 to go through the full DIEs. At least any work we do building
7955 types here will be reused if full symbols are loaded later. */
7956 if (pdi
->has_template_arguments
)
7958 fixup_partial_die (pdi
, cu
);
7960 if (pdi
->name
!= NULL
&& strchr (pdi
->name
, '<') == NULL
)
7962 struct die_info
*die
;
7963 struct attribute attr
;
7964 struct dwarf2_cu
*ref_cu
= cu
;
7966 /* DW_FORM_ref_addr is using section offset. */
7967 attr
.name
= (enum dwarf_attribute
) 0;
7968 attr
.form
= DW_FORM_ref_addr
;
7969 attr
.u
.unsnd
= to_underlying (pdi
->sect_off
);
7970 die
= follow_die_ref (NULL
, &attr
, &ref_cu
);
7972 return xstrdup (dwarf2_full_name (NULL
, die
, ref_cu
));
7976 parent_scope
= partial_die_parent_scope (pdi
, cu
);
7977 if (parent_scope
== NULL
)
7980 return typename_concat (NULL
, parent_scope
, pdi
->name
, 0, cu
);
7984 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
7986 struct objfile
*objfile
= cu
->objfile
;
7987 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
7989 const char *actual_name
= NULL
;
7991 char *built_actual_name
;
7993 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
7995 built_actual_name
= partial_die_full_name (pdi
, cu
);
7996 if (built_actual_name
!= NULL
)
7997 actual_name
= built_actual_name
;
7999 if (actual_name
== NULL
)
8000 actual_name
= pdi
->name
;
8004 case DW_TAG_subprogram
:
8005 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, pdi
->lowpc
+ baseaddr
);
8006 if (pdi
->is_external
|| cu
->language
== language_ada
)
8008 /* brobecker/2007-12-26: Normally, only "external" DIEs are part
8009 of the global scope. But in Ada, we want to be able to access
8010 nested procedures globally. So all Ada subprograms are stored
8011 in the global scope. */
8012 add_psymbol_to_list (actual_name
, strlen (actual_name
),
8013 built_actual_name
!= NULL
,
8014 VAR_DOMAIN
, LOC_BLOCK
,
8015 &objfile
->global_psymbols
,
8016 addr
, cu
->language
, objfile
);
8020 add_psymbol_to_list (actual_name
, strlen (actual_name
),
8021 built_actual_name
!= NULL
,
8022 VAR_DOMAIN
, LOC_BLOCK
,
8023 &objfile
->static_psymbols
,
8024 addr
, cu
->language
, objfile
);
8027 if (pdi
->main_subprogram
&& actual_name
!= NULL
)
8028 set_objfile_main_name (objfile
, actual_name
, cu
->language
);
8030 case DW_TAG_constant
:
8032 std::vector
<partial_symbol
*> *list
;
8034 if (pdi
->is_external
)
8035 list
= &objfile
->global_psymbols
;
8037 list
= &objfile
->static_psymbols
;
8038 add_psymbol_to_list (actual_name
, strlen (actual_name
),
8039 built_actual_name
!= NULL
, VAR_DOMAIN
, LOC_STATIC
,
8040 list
, 0, cu
->language
, objfile
);
8043 case DW_TAG_variable
:
8045 addr
= decode_locdesc (pdi
->d
.locdesc
, cu
);
8049 && !dwarf2_per_objfile
->has_section_at_zero
)
8051 /* A global or static variable may also have been stripped
8052 out by the linker if unused, in which case its address
8053 will be nullified; do not add such variables into partial
8054 symbol table then. */
8056 else if (pdi
->is_external
)
8059 Don't enter into the minimal symbol tables as there is
8060 a minimal symbol table entry from the ELF symbols already.
8061 Enter into partial symbol table if it has a location
8062 descriptor or a type.
8063 If the location descriptor is missing, new_symbol will create
8064 a LOC_UNRESOLVED symbol, the address of the variable will then
8065 be determined from the minimal symbol table whenever the variable
8067 The address for the partial symbol table entry is not
8068 used by GDB, but it comes in handy for debugging partial symbol
8071 if (pdi
->d
.locdesc
|| pdi
->has_type
)
8072 add_psymbol_to_list (actual_name
, strlen (actual_name
),
8073 built_actual_name
!= NULL
,
8074 VAR_DOMAIN
, LOC_STATIC
,
8075 &objfile
->global_psymbols
,
8077 cu
->language
, objfile
);
8081 int has_loc
= pdi
->d
.locdesc
!= NULL
;
8083 /* Static Variable. Skip symbols whose value we cannot know (those
8084 without location descriptors or constant values). */
8085 if (!has_loc
&& !pdi
->has_const_value
)
8087 xfree (built_actual_name
);
8091 add_psymbol_to_list (actual_name
, strlen (actual_name
),
8092 built_actual_name
!= NULL
,
8093 VAR_DOMAIN
, LOC_STATIC
,
8094 &objfile
->static_psymbols
,
8095 has_loc
? addr
+ baseaddr
: (CORE_ADDR
) 0,
8096 cu
->language
, objfile
);
8099 case DW_TAG_typedef
:
8100 case DW_TAG_base_type
:
8101 case DW_TAG_subrange_type
:
8102 add_psymbol_to_list (actual_name
, strlen (actual_name
),
8103 built_actual_name
!= NULL
,
8104 VAR_DOMAIN
, LOC_TYPEDEF
,
8105 &objfile
->static_psymbols
,
8106 0, cu
->language
, objfile
);
8108 case DW_TAG_imported_declaration
:
8109 case DW_TAG_namespace
:
8110 add_psymbol_to_list (actual_name
, strlen (actual_name
),
8111 built_actual_name
!= NULL
,
8112 VAR_DOMAIN
, LOC_TYPEDEF
,
8113 &objfile
->global_psymbols
,
8114 0, cu
->language
, objfile
);
8117 add_psymbol_to_list (actual_name
, strlen (actual_name
),
8118 built_actual_name
!= NULL
,
8119 MODULE_DOMAIN
, LOC_TYPEDEF
,
8120 &objfile
->global_psymbols
,
8121 0, cu
->language
, objfile
);
8123 case DW_TAG_class_type
:
8124 case DW_TAG_interface_type
:
8125 case DW_TAG_structure_type
:
8126 case DW_TAG_union_type
:
8127 case DW_TAG_enumeration_type
:
8128 /* Skip external references. The DWARF standard says in the section
8129 about "Structure, Union, and Class Type Entries": "An incomplete
8130 structure, union or class type is represented by a structure,
8131 union or class entry that does not have a byte size attribute
8132 and that has a DW_AT_declaration attribute." */
8133 if (!pdi
->has_byte_size
&& pdi
->is_declaration
)
8135 xfree (built_actual_name
);
8139 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
8140 static vs. global. */
8141 add_psymbol_to_list (actual_name
, strlen (actual_name
),
8142 built_actual_name
!= NULL
,
8143 STRUCT_DOMAIN
, LOC_TYPEDEF
,
8144 cu
->language
== language_cplus
8145 ? &objfile
->global_psymbols
8146 : &objfile
->static_psymbols
,
8147 0, cu
->language
, objfile
);
8150 case DW_TAG_enumerator
:
8151 add_psymbol_to_list (actual_name
, strlen (actual_name
),
8152 built_actual_name
!= NULL
,
8153 VAR_DOMAIN
, LOC_CONST
,
8154 cu
->language
== language_cplus
8155 ? &objfile
->global_psymbols
8156 : &objfile
->static_psymbols
,
8157 0, cu
->language
, objfile
);
8163 xfree (built_actual_name
);
8166 /* Read a partial die corresponding to a namespace; also, add a symbol
8167 corresponding to that namespace to the symbol table. NAMESPACE is
8168 the name of the enclosing namespace. */
8171 add_partial_namespace (struct partial_die_info
*pdi
,
8172 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
8173 int set_addrmap
, struct dwarf2_cu
*cu
)
8175 /* Add a symbol for the namespace. */
8177 add_partial_symbol (pdi
, cu
);
8179 /* Now scan partial symbols in that namespace. */
8181 if (pdi
->has_children
)
8182 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, set_addrmap
, cu
);
8185 /* Read a partial die corresponding to a Fortran module. */
8188 add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
8189 CORE_ADDR
*highpc
, int set_addrmap
, struct dwarf2_cu
*cu
)
8191 /* Add a symbol for the namespace. */
8193 add_partial_symbol (pdi
, cu
);
8195 /* Now scan partial symbols in that module. */
8197 if (pdi
->has_children
)
8198 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, set_addrmap
, cu
);
8201 /* Read a partial die corresponding to a subprogram and create a partial
8202 symbol for that subprogram. When the CU language allows it, this
8203 routine also defines a partial symbol for each nested subprogram
8204 that this subprogram contains. If SET_ADDRMAP is true, record the
8205 covered ranges in the addrmap. Set *LOWPC and *HIGHPC to the lowest
8206 and highest PC values found in PDI.
8208 PDI may also be a lexical block, in which case we simply search
8209 recursively for subprograms defined inside that lexical block.
8210 Again, this is only performed when the CU language allows this
8211 type of definitions. */
8214 add_partial_subprogram (struct partial_die_info
*pdi
,
8215 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
8216 int set_addrmap
, struct dwarf2_cu
*cu
)
8218 if (pdi
->tag
== DW_TAG_subprogram
)
8220 if (pdi
->has_pc_info
)
8222 if (pdi
->lowpc
< *lowpc
)
8223 *lowpc
= pdi
->lowpc
;
8224 if (pdi
->highpc
> *highpc
)
8225 *highpc
= pdi
->highpc
;
8228 struct objfile
*objfile
= cu
->objfile
;
8229 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
8234 baseaddr
= ANOFFSET (objfile
->section_offsets
,
8235 SECT_OFF_TEXT (objfile
));
8236 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
,
8237 pdi
->lowpc
+ baseaddr
);
8238 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
,
8239 pdi
->highpc
+ baseaddr
);
8240 addrmap_set_empty (objfile
->psymtabs_addrmap
, lowpc
, highpc
- 1,
8241 cu
->per_cu
->v
.psymtab
);
8245 if (pdi
->has_pc_info
|| (!pdi
->is_external
&& pdi
->may_be_inlined
))
8247 if (!pdi
->is_declaration
)
8248 /* Ignore subprogram DIEs that do not have a name, they are
8249 illegal. Do not emit a complaint at this point, we will
8250 do so when we convert this psymtab into a symtab. */
8252 add_partial_symbol (pdi
, cu
);
8256 if (! pdi
->has_children
)
8259 if (cu
->language
== language_ada
)
8261 pdi
= pdi
->die_child
;
8264 fixup_partial_die (pdi
, cu
);
8265 if (pdi
->tag
== DW_TAG_subprogram
8266 || pdi
->tag
== DW_TAG_lexical_block
)
8267 add_partial_subprogram (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
8268 pdi
= pdi
->die_sibling
;
8273 /* Read a partial die corresponding to an enumeration type. */
8276 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
8277 struct dwarf2_cu
*cu
)
8279 struct partial_die_info
*pdi
;
8281 if (enum_pdi
->name
!= NULL
)
8282 add_partial_symbol (enum_pdi
, cu
);
8284 pdi
= enum_pdi
->die_child
;
8287 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
8288 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
8290 add_partial_symbol (pdi
, cu
);
8291 pdi
= pdi
->die_sibling
;
8295 /* Return the initial uleb128 in the die at INFO_PTR. */
8298 peek_abbrev_code (bfd
*abfd
, const gdb_byte
*info_ptr
)
8300 unsigned int bytes_read
;
8302 return read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
8305 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
8306 Return the corresponding abbrev, or NULL if the number is zero (indicating
8307 an empty DIE). In either case *BYTES_READ will be set to the length of
8308 the initial number. */
8310 static struct abbrev_info
*
8311 peek_die_abbrev (const gdb_byte
*info_ptr
, unsigned int *bytes_read
,
8312 struct dwarf2_cu
*cu
)
8314 bfd
*abfd
= cu
->objfile
->obfd
;
8315 unsigned int abbrev_number
;
8316 struct abbrev_info
*abbrev
;
8318 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
8320 if (abbrev_number
== 0)
8323 abbrev
= abbrev_table_lookup_abbrev (cu
->abbrev_table
, abbrev_number
);
8326 error (_("Dwarf Error: Could not find abbrev number %d in %s"
8327 " at offset 0x%x [in module %s]"),
8328 abbrev_number
, cu
->per_cu
->is_debug_types
? "TU" : "CU",
8329 to_underlying (cu
->header
.sect_off
), bfd_get_filename (abfd
));
8335 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
8336 Returns a pointer to the end of a series of DIEs, terminated by an empty
8337 DIE. Any children of the skipped DIEs will also be skipped. */
8339 static const gdb_byte
*
8340 skip_children (const struct die_reader_specs
*reader
, const gdb_byte
*info_ptr
)
8342 struct dwarf2_cu
*cu
= reader
->cu
;
8343 struct abbrev_info
*abbrev
;
8344 unsigned int bytes_read
;
8348 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
8350 return info_ptr
+ bytes_read
;
8352 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
8356 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
8357 INFO_PTR should point just after the initial uleb128 of a DIE, and the
8358 abbrev corresponding to that skipped uleb128 should be passed in
8359 ABBREV. Returns a pointer to this DIE's sibling, skipping any
8362 static const gdb_byte
*
8363 skip_one_die (const struct die_reader_specs
*reader
, const gdb_byte
*info_ptr
,
8364 struct abbrev_info
*abbrev
)
8366 unsigned int bytes_read
;
8367 struct attribute attr
;
8368 bfd
*abfd
= reader
->abfd
;
8369 struct dwarf2_cu
*cu
= reader
->cu
;
8370 const gdb_byte
*buffer
= reader
->buffer
;
8371 const gdb_byte
*buffer_end
= reader
->buffer_end
;
8372 unsigned int form
, i
;
8374 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
8376 /* The only abbrev we care about is DW_AT_sibling. */
8377 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
8379 read_attribute (reader
, &attr
, &abbrev
->attrs
[i
], info_ptr
);
8380 if (attr
.form
== DW_FORM_ref_addr
)
8381 complaint (&symfile_complaints
,
8382 _("ignoring absolute DW_AT_sibling"));
8385 sect_offset off
= dwarf2_get_ref_die_offset (&attr
);
8386 const gdb_byte
*sibling_ptr
= buffer
+ to_underlying (off
);
8388 if (sibling_ptr
< info_ptr
)
8389 complaint (&symfile_complaints
,
8390 _("DW_AT_sibling points backwards"));
8391 else if (sibling_ptr
> reader
->buffer_end
)
8392 dwarf2_section_buffer_overflow_complaint (reader
->die_section
);
8398 /* If it isn't DW_AT_sibling, skip this attribute. */
8399 form
= abbrev
->attrs
[i
].form
;
8403 case DW_FORM_ref_addr
:
8404 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
8405 and later it is offset sized. */
8406 if (cu
->header
.version
== 2)
8407 info_ptr
+= cu
->header
.addr_size
;
8409 info_ptr
+= cu
->header
.offset_size
;
8411 case DW_FORM_GNU_ref_alt
:
8412 info_ptr
+= cu
->header
.offset_size
;
8415 info_ptr
+= cu
->header
.addr_size
;
8422 case DW_FORM_flag_present
:
8423 case DW_FORM_implicit_const
:
8435 case DW_FORM_ref_sig8
:
8438 case DW_FORM_data16
:
8441 case DW_FORM_string
:
8442 read_direct_string (abfd
, info_ptr
, &bytes_read
);
8443 info_ptr
+= bytes_read
;
8445 case DW_FORM_sec_offset
:
8447 case DW_FORM_GNU_strp_alt
:
8448 info_ptr
+= cu
->header
.offset_size
;
8450 case DW_FORM_exprloc
:
8452 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
8453 info_ptr
+= bytes_read
;
8455 case DW_FORM_block1
:
8456 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
8458 case DW_FORM_block2
:
8459 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
8461 case DW_FORM_block4
:
8462 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
8466 case DW_FORM_ref_udata
:
8467 case DW_FORM_GNU_addr_index
:
8468 case DW_FORM_GNU_str_index
:
8469 info_ptr
= safe_skip_leb128 (info_ptr
, buffer_end
);
8471 case DW_FORM_indirect
:
8472 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
8473 info_ptr
+= bytes_read
;
8474 /* We need to continue parsing from here, so just go back to
8476 goto skip_attribute
;
8479 error (_("Dwarf Error: Cannot handle %s "
8480 "in DWARF reader [in module %s]"),
8481 dwarf_form_name (form
),
8482 bfd_get_filename (abfd
));
8486 if (abbrev
->has_children
)
8487 return skip_children (reader
, info_ptr
);
8492 /* Locate ORIG_PDI's sibling.
8493 INFO_PTR should point to the start of the next DIE after ORIG_PDI. */
8495 static const gdb_byte
*
8496 locate_pdi_sibling (const struct die_reader_specs
*reader
,
8497 struct partial_die_info
*orig_pdi
,
8498 const gdb_byte
*info_ptr
)
8500 /* Do we know the sibling already? */
8502 if (orig_pdi
->sibling
)
8503 return orig_pdi
->sibling
;
8505 /* Are there any children to deal with? */
8507 if (!orig_pdi
->has_children
)
8510 /* Skip the children the long way. */
8512 return skip_children (reader
, info_ptr
);
8515 /* Expand this partial symbol table into a full symbol table. SELF is
8519 dwarf2_read_symtab (struct partial_symtab
*self
,
8520 struct objfile
*objfile
)
8524 warning (_("bug: psymtab for %s is already read in."),
8531 printf_filtered (_("Reading in symbols for %s..."),
8533 gdb_flush (gdb_stdout
);
8536 /* Restore our global data. */
8538 = (struct dwarf2_per_objfile
*) objfile_data (objfile
,
8539 dwarf2_objfile_data_key
);
8541 /* If this psymtab is constructed from a debug-only objfile, the
8542 has_section_at_zero flag will not necessarily be correct. We
8543 can get the correct value for this flag by looking at the data
8544 associated with the (presumably stripped) associated objfile. */
8545 if (objfile
->separate_debug_objfile_backlink
)
8547 struct dwarf2_per_objfile
*dpo_backlink
8548 = ((struct dwarf2_per_objfile
*)
8549 objfile_data (objfile
->separate_debug_objfile_backlink
,
8550 dwarf2_objfile_data_key
));
8552 dwarf2_per_objfile
->has_section_at_zero
8553 = dpo_backlink
->has_section_at_zero
;
8556 dwarf2_per_objfile
->reading_partial_symbols
= 0;
8558 psymtab_to_symtab_1 (self
);
8560 /* Finish up the debug error message. */
8562 printf_filtered (_("done.\n"));
8565 process_cu_includes ();
8568 /* Reading in full CUs. */
8570 /* Add PER_CU to the queue. */
8573 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
8574 enum language pretend_language
)
8576 struct dwarf2_queue_item
*item
;
8579 item
= XNEW (struct dwarf2_queue_item
);
8580 item
->per_cu
= per_cu
;
8581 item
->pretend_language
= pretend_language
;
8584 if (dwarf2_queue
== NULL
)
8585 dwarf2_queue
= item
;
8587 dwarf2_queue_tail
->next
= item
;
8589 dwarf2_queue_tail
= item
;
8592 /* If PER_CU is not yet queued, add it to the queue.
8593 If DEPENDENT_CU is non-NULL, it has a reference to PER_CU so add a
8595 The result is non-zero if PER_CU was queued, otherwise the result is zero
8596 meaning either PER_CU is already queued or it is already loaded.
8598 N.B. There is an invariant here that if a CU is queued then it is loaded.
8599 The caller is required to load PER_CU if we return non-zero. */
8602 maybe_queue_comp_unit (struct dwarf2_cu
*dependent_cu
,
8603 struct dwarf2_per_cu_data
*per_cu
,
8604 enum language pretend_language
)
8606 /* We may arrive here during partial symbol reading, if we need full
8607 DIEs to process an unusual case (e.g. template arguments). Do
8608 not queue PER_CU, just tell our caller to load its DIEs. */
8609 if (dwarf2_per_objfile
->reading_partial_symbols
)
8611 if (per_cu
->cu
== NULL
|| per_cu
->cu
->dies
== NULL
)
8616 /* Mark the dependence relation so that we don't flush PER_CU
8618 if (dependent_cu
!= NULL
)
8619 dwarf2_add_dependence (dependent_cu
, per_cu
);
8621 /* If it's already on the queue, we have nothing to do. */
8625 /* If the compilation unit is already loaded, just mark it as
8627 if (per_cu
->cu
!= NULL
)
8629 per_cu
->cu
->last_used
= 0;
8633 /* Add it to the queue. */
8634 queue_comp_unit (per_cu
, pretend_language
);
8639 /* Process the queue. */
8642 process_queue (void)
8644 struct dwarf2_queue_item
*item
, *next_item
;
8646 if (dwarf_read_debug
)
8648 fprintf_unfiltered (gdb_stdlog
,
8649 "Expanding one or more symtabs of objfile %s ...\n",
8650 objfile_name (dwarf2_per_objfile
->objfile
));
8653 /* The queue starts out with one item, but following a DIE reference
8654 may load a new CU, adding it to the end of the queue. */
8655 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
8657 if ((dwarf2_per_objfile
->using_index
8658 ? !item
->per_cu
->v
.quick
->compunit_symtab
8659 : (item
->per_cu
->v
.psymtab
&& !item
->per_cu
->v
.psymtab
->readin
))
8660 /* Skip dummy CUs. */
8661 && item
->per_cu
->cu
!= NULL
)
8663 struct dwarf2_per_cu_data
*per_cu
= item
->per_cu
;
8664 unsigned int debug_print_threshold
;
8667 if (per_cu
->is_debug_types
)
8669 struct signatured_type
*sig_type
=
8670 (struct signatured_type
*) per_cu
;
8672 sprintf (buf
, "TU %s at offset 0x%x",
8673 hex_string (sig_type
->signature
),
8674 to_underlying (per_cu
->sect_off
));
8675 /* There can be 100s of TUs.
8676 Only print them in verbose mode. */
8677 debug_print_threshold
= 2;
8681 sprintf (buf
, "CU at offset 0x%x",
8682 to_underlying (per_cu
->sect_off
));
8683 debug_print_threshold
= 1;
8686 if (dwarf_read_debug
>= debug_print_threshold
)
8687 fprintf_unfiltered (gdb_stdlog
, "Expanding symtab of %s\n", buf
);
8689 if (per_cu
->is_debug_types
)
8690 process_full_type_unit (per_cu
, item
->pretend_language
);
8692 process_full_comp_unit (per_cu
, item
->pretend_language
);
8694 if (dwarf_read_debug
>= debug_print_threshold
)
8695 fprintf_unfiltered (gdb_stdlog
, "Done expanding %s\n", buf
);
8698 item
->per_cu
->queued
= 0;
8699 next_item
= item
->next
;
8703 dwarf2_queue_tail
= NULL
;
8705 if (dwarf_read_debug
)
8707 fprintf_unfiltered (gdb_stdlog
, "Done expanding symtabs of %s.\n",
8708 objfile_name (dwarf2_per_objfile
->objfile
));
8712 /* Free all allocated queue entries. This function only releases anything if
8713 an error was thrown; if the queue was processed then it would have been
8714 freed as we went along. */
8717 dwarf2_release_queue (void *dummy
)
8719 struct dwarf2_queue_item
*item
, *last
;
8721 item
= dwarf2_queue
;
8724 /* Anything still marked queued is likely to be in an
8725 inconsistent state, so discard it. */
8726 if (item
->per_cu
->queued
)
8728 if (item
->per_cu
->cu
!= NULL
)
8729 free_one_cached_comp_unit (item
->per_cu
);
8730 item
->per_cu
->queued
= 0;
8738 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
8741 /* Read in full symbols for PST, and anything it depends on. */
8744 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
8746 struct dwarf2_per_cu_data
*per_cu
;
8752 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
8753 if (!pst
->dependencies
[i
]->readin
8754 && pst
->dependencies
[i
]->user
== NULL
)
8756 /* Inform about additional files that need to be read in. */
8759 /* FIXME: i18n: Need to make this a single string. */
8760 fputs_filtered (" ", gdb_stdout
);
8762 fputs_filtered ("and ", gdb_stdout
);
8764 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
8765 wrap_here (""); /* Flush output. */
8766 gdb_flush (gdb_stdout
);
8768 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
8771 per_cu
= (struct dwarf2_per_cu_data
*) pst
->read_symtab_private
;
8775 /* It's an include file, no symbols to read for it.
8776 Everything is in the parent symtab. */
8781 dw2_do_instantiate_symtab (per_cu
);
8784 /* Trivial hash function for die_info: the hash value of a DIE
8785 is its offset in .debug_info for this objfile. */
8788 die_hash (const void *item
)
8790 const struct die_info
*die
= (const struct die_info
*) item
;
8792 return to_underlying (die
->sect_off
);
8795 /* Trivial comparison function for die_info structures: two DIEs
8796 are equal if they have the same offset. */
8799 die_eq (const void *item_lhs
, const void *item_rhs
)
8801 const struct die_info
*die_lhs
= (const struct die_info
*) item_lhs
;
8802 const struct die_info
*die_rhs
= (const struct die_info
*) item_rhs
;
8804 return die_lhs
->sect_off
== die_rhs
->sect_off
;
8807 /* die_reader_func for load_full_comp_unit.
8808 This is identical to read_signatured_type_reader,
8809 but is kept separate for now. */
8812 load_full_comp_unit_reader (const struct die_reader_specs
*reader
,
8813 const gdb_byte
*info_ptr
,
8814 struct die_info
*comp_unit_die
,
8818 struct dwarf2_cu
*cu
= reader
->cu
;
8819 enum language
*language_ptr
= (enum language
*) data
;
8821 gdb_assert (cu
->die_hash
== NULL
);
8823 htab_create_alloc_ex (cu
->header
.length
/ 12,
8827 &cu
->comp_unit_obstack
,
8828 hashtab_obstack_allocate
,
8829 dummy_obstack_deallocate
);
8832 comp_unit_die
->child
= read_die_and_siblings (reader
, info_ptr
,
8833 &info_ptr
, comp_unit_die
);
8834 cu
->dies
= comp_unit_die
;
8835 /* comp_unit_die is not stored in die_hash, no need. */
8837 /* We try not to read any attributes in this function, because not
8838 all CUs needed for references have been loaded yet, and symbol
8839 table processing isn't initialized. But we have to set the CU language,
8840 or we won't be able to build types correctly.
8841 Similarly, if we do not read the producer, we can not apply
8842 producer-specific interpretation. */
8843 prepare_one_comp_unit (cu
, cu
->dies
, *language_ptr
);
8846 /* Load the DIEs associated with PER_CU into memory. */
8849 load_full_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
8850 enum language pretend_language
)
8852 gdb_assert (! this_cu
->is_debug_types
);
8854 init_cutu_and_read_dies (this_cu
, NULL
, 1, 1,
8855 load_full_comp_unit_reader
, &pretend_language
);
8858 /* Add a DIE to the delayed physname list. */
8861 add_to_method_list (struct type
*type
, int fnfield_index
, int index
,
8862 const char *name
, struct die_info
*die
,
8863 struct dwarf2_cu
*cu
)
8865 struct delayed_method_info mi
;
8867 mi
.fnfield_index
= fnfield_index
;
8871 VEC_safe_push (delayed_method_info
, cu
->method_list
, &mi
);
8874 /* A cleanup for freeing the delayed method list. */
8877 free_delayed_list (void *ptr
)
8879 struct dwarf2_cu
*cu
= (struct dwarf2_cu
*) ptr
;
8880 if (cu
->method_list
!= NULL
)
8882 VEC_free (delayed_method_info
, cu
->method_list
);
8883 cu
->method_list
= NULL
;
8887 /* Check whether [PHYSNAME, PHYSNAME+LEN) ends with a modifier like
8888 "const" / "volatile". If so, decrements LEN by the length of the
8889 modifier and return true. Otherwise return false. */
8893 check_modifier (const char *physname
, size_t &len
, const char (&mod
)[N
])
8895 size_t mod_len
= sizeof (mod
) - 1;
8896 if (len
> mod_len
&& startswith (physname
+ (len
- mod_len
), mod
))
8904 /* Compute the physnames of any methods on the CU's method list.
8906 The computation of method physnames is delayed in order to avoid the
8907 (bad) condition that one of the method's formal parameters is of an as yet
8911 compute_delayed_physnames (struct dwarf2_cu
*cu
)
8914 struct delayed_method_info
*mi
;
8916 /* Only C++ delays computing physnames. */
8917 if (VEC_empty (delayed_method_info
, cu
->method_list
))
8919 gdb_assert (cu
->language
== language_cplus
);
8921 for (i
= 0; VEC_iterate (delayed_method_info
, cu
->method_list
, i
, mi
) ; ++i
)
8923 const char *physname
;
8924 struct fn_fieldlist
*fn_flp
8925 = &TYPE_FN_FIELDLIST (mi
->type
, mi
->fnfield_index
);
8926 physname
= dwarf2_physname (mi
->name
, mi
->die
, cu
);
8927 TYPE_FN_FIELD_PHYSNAME (fn_flp
->fn_fields
, mi
->index
)
8928 = physname
? physname
: "";
8930 /* Since there's no tag to indicate whether a method is a
8931 const/volatile overload, extract that information out of the
8933 if (physname
!= NULL
)
8935 size_t len
= strlen (physname
);
8939 if (physname
[len
] == ')') /* shortcut */
8941 else if (check_modifier (physname
, len
, " const"))
8942 TYPE_FN_FIELD_CONST (fn_flp
->fn_fields
, mi
->index
) = 1;
8943 else if (check_modifier (physname
, len
, " volatile"))
8944 TYPE_FN_FIELD_VOLATILE (fn_flp
->fn_fields
, mi
->index
) = 1;
8952 /* Go objects should be embedded in a DW_TAG_module DIE,
8953 and it's not clear if/how imported objects will appear.
8954 To keep Go support simple until that's worked out,
8955 go back through what we've read and create something usable.
8956 We could do this while processing each DIE, and feels kinda cleaner,
8957 but that way is more invasive.
8958 This is to, for example, allow the user to type "p var" or "b main"
8959 without having to specify the package name, and allow lookups
8960 of module.object to work in contexts that use the expression
8964 fixup_go_packaging (struct dwarf2_cu
*cu
)
8966 char *package_name
= NULL
;
8967 struct pending
*list
;
8970 for (list
= global_symbols
; list
!= NULL
; list
= list
->next
)
8972 for (i
= 0; i
< list
->nsyms
; ++i
)
8974 struct symbol
*sym
= list
->symbol
[i
];
8976 if (SYMBOL_LANGUAGE (sym
) == language_go
8977 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
8979 char *this_package_name
= go_symbol_package_name (sym
);
8981 if (this_package_name
== NULL
)
8983 if (package_name
== NULL
)
8984 package_name
= this_package_name
;
8987 if (strcmp (package_name
, this_package_name
) != 0)
8988 complaint (&symfile_complaints
,
8989 _("Symtab %s has objects from two different Go packages: %s and %s"),
8990 (symbol_symtab (sym
) != NULL
8991 ? symtab_to_filename_for_display
8992 (symbol_symtab (sym
))
8993 : objfile_name (cu
->objfile
)),
8994 this_package_name
, package_name
);
8995 xfree (this_package_name
);
9001 if (package_name
!= NULL
)
9003 struct objfile
*objfile
= cu
->objfile
;
9004 const char *saved_package_name
9005 = (const char *) obstack_copy0 (&objfile
->per_bfd
->storage_obstack
,
9007 strlen (package_name
));
9008 struct type
*type
= init_type (objfile
, TYPE_CODE_MODULE
, 0,
9009 saved_package_name
);
9012 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
9014 sym
= allocate_symbol (objfile
);
9015 SYMBOL_SET_LANGUAGE (sym
, language_go
, &objfile
->objfile_obstack
);
9016 SYMBOL_SET_NAMES (sym
, saved_package_name
,
9017 strlen (saved_package_name
), 0, objfile
);
9018 /* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
9019 e.g., "main" finds the "main" module and not C's main(). */
9020 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
9021 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
9022 SYMBOL_TYPE (sym
) = type
;
9024 add_symbol_to_list (sym
, &global_symbols
);
9026 xfree (package_name
);
9030 /* Return the symtab for PER_CU. This works properly regardless of
9031 whether we're using the index or psymtabs. */
9033 static struct compunit_symtab
*
9034 get_compunit_symtab (struct dwarf2_per_cu_data
*per_cu
)
9036 return (dwarf2_per_objfile
->using_index
9037 ? per_cu
->v
.quick
->compunit_symtab
9038 : per_cu
->v
.psymtab
->compunit_symtab
);
9041 /* A helper function for computing the list of all symbol tables
9042 included by PER_CU. */
9045 recursively_compute_inclusions (VEC (compunit_symtab_ptr
) **result
,
9046 htab_t all_children
, htab_t all_type_symtabs
,
9047 struct dwarf2_per_cu_data
*per_cu
,
9048 struct compunit_symtab
*immediate_parent
)
9052 struct compunit_symtab
*cust
;
9053 struct dwarf2_per_cu_data
*iter
;
9055 slot
= htab_find_slot (all_children
, per_cu
, INSERT
);
9058 /* This inclusion and its children have been processed. */
9063 /* Only add a CU if it has a symbol table. */
9064 cust
= get_compunit_symtab (per_cu
);
9067 /* If this is a type unit only add its symbol table if we haven't
9068 seen it yet (type unit per_cu's can share symtabs). */
9069 if (per_cu
->is_debug_types
)
9071 slot
= htab_find_slot (all_type_symtabs
, cust
, INSERT
);
9075 VEC_safe_push (compunit_symtab_ptr
, *result
, cust
);
9076 if (cust
->user
== NULL
)
9077 cust
->user
= immediate_parent
;
9082 VEC_safe_push (compunit_symtab_ptr
, *result
, cust
);
9083 if (cust
->user
== NULL
)
9084 cust
->user
= immediate_parent
;
9089 VEC_iterate (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
, ix
, iter
);
9092 recursively_compute_inclusions (result
, all_children
,
9093 all_type_symtabs
, iter
, cust
);
9097 /* Compute the compunit_symtab 'includes' fields for the compunit_symtab of
9101 compute_compunit_symtab_includes (struct dwarf2_per_cu_data
*per_cu
)
9103 gdb_assert (! per_cu
->is_debug_types
);
9105 if (!VEC_empty (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
))
9108 struct dwarf2_per_cu_data
*per_cu_iter
;
9109 struct compunit_symtab
*compunit_symtab_iter
;
9110 VEC (compunit_symtab_ptr
) *result_symtabs
= NULL
;
9111 htab_t all_children
, all_type_symtabs
;
9112 struct compunit_symtab
*cust
= get_compunit_symtab (per_cu
);
9114 /* If we don't have a symtab, we can just skip this case. */
9118 all_children
= htab_create_alloc (1, htab_hash_pointer
, htab_eq_pointer
,
9119 NULL
, xcalloc
, xfree
);
9120 all_type_symtabs
= htab_create_alloc (1, htab_hash_pointer
, htab_eq_pointer
,
9121 NULL
, xcalloc
, xfree
);
9124 VEC_iterate (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
,
9128 recursively_compute_inclusions (&result_symtabs
, all_children
,
9129 all_type_symtabs
, per_cu_iter
,
9133 /* Now we have a transitive closure of all the included symtabs. */
9134 len
= VEC_length (compunit_symtab_ptr
, result_symtabs
);
9136 = XOBNEWVEC (&dwarf2_per_objfile
->objfile
->objfile_obstack
,
9137 struct compunit_symtab
*, len
+ 1);
9139 VEC_iterate (compunit_symtab_ptr
, result_symtabs
, ix
,
9140 compunit_symtab_iter
);
9142 cust
->includes
[ix
] = compunit_symtab_iter
;
9143 cust
->includes
[len
] = NULL
;
9145 VEC_free (compunit_symtab_ptr
, result_symtabs
);
9146 htab_delete (all_children
);
9147 htab_delete (all_type_symtabs
);
9151 /* Compute the 'includes' field for the symtabs of all the CUs we just
9155 process_cu_includes (void)
9158 struct dwarf2_per_cu_data
*iter
;
9161 VEC_iterate (dwarf2_per_cu_ptr
, dwarf2_per_objfile
->just_read_cus
,
9165 if (! iter
->is_debug_types
)
9166 compute_compunit_symtab_includes (iter
);
9169 VEC_free (dwarf2_per_cu_ptr
, dwarf2_per_objfile
->just_read_cus
);
9172 /* Generate full symbol information for PER_CU, whose DIEs have
9173 already been loaded into memory. */
9176 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
9177 enum language pretend_language
)
9179 struct dwarf2_cu
*cu
= per_cu
->cu
;
9180 struct objfile
*objfile
= per_cu
->objfile
;
9181 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
9182 CORE_ADDR lowpc
, highpc
;
9183 struct compunit_symtab
*cust
;
9184 struct cleanup
*delayed_list_cleanup
;
9186 struct block
*static_block
;
9189 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
9192 scoped_free_pendings free_pending
;
9193 delayed_list_cleanup
= make_cleanup (free_delayed_list
, cu
);
9195 cu
->list_in_scope
= &file_symbols
;
9197 cu
->language
= pretend_language
;
9198 cu
->language_defn
= language_def (cu
->language
);
9200 /* Do line number decoding in read_file_scope () */
9201 process_die (cu
->dies
, cu
);
9203 /* For now fudge the Go package. */
9204 if (cu
->language
== language_go
)
9205 fixup_go_packaging (cu
);
9207 /* Now that we have processed all the DIEs in the CU, all the types
9208 should be complete, and it should now be safe to compute all of the
9210 compute_delayed_physnames (cu
);
9211 do_cleanups (delayed_list_cleanup
);
9213 /* Some compilers don't define a DW_AT_high_pc attribute for the
9214 compilation unit. If the DW_AT_high_pc is missing, synthesize
9215 it, by scanning the DIE's below the compilation unit. */
9216 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
9218 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
9219 static_block
= end_symtab_get_static_block (addr
, 0, 1);
9221 /* If the comp unit has DW_AT_ranges, it may have discontiguous ranges.
9222 Also, DW_AT_ranges may record ranges not belonging to any child DIEs
9223 (such as virtual method tables). Record the ranges in STATIC_BLOCK's
9224 addrmap to help ensure it has an accurate map of pc values belonging to
9226 dwarf2_record_block_ranges (cu
->dies
, static_block
, baseaddr
, cu
);
9228 cust
= end_symtab_from_static_block (static_block
,
9229 SECT_OFF_TEXT (objfile
), 0);
9233 int gcc_4_minor
= producer_is_gcc_ge_4 (cu
->producer
);
9235 /* Set symtab language to language from DW_AT_language. If the
9236 compilation is from a C file generated by language preprocessors, do
9237 not set the language if it was already deduced by start_subfile. */
9238 if (!(cu
->language
== language_c
9239 && COMPUNIT_FILETABS (cust
)->language
!= language_unknown
))
9240 COMPUNIT_FILETABS (cust
)->language
= cu
->language
;
9242 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
9243 produce DW_AT_location with location lists but it can be possibly
9244 invalid without -fvar-tracking. Still up to GCC-4.4.x incl. 4.4.0
9245 there were bugs in prologue debug info, fixed later in GCC-4.5
9246 by "unwind info for epilogues" patch (which is not directly related).
9248 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
9249 needed, it would be wrong due to missing DW_AT_producer there.
9251 Still one can confuse GDB by using non-standard GCC compilation
9252 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
9254 if (cu
->has_loclist
&& gcc_4_minor
>= 5)
9255 cust
->locations_valid
= 1;
9257 if (gcc_4_minor
>= 5)
9258 cust
->epilogue_unwind_valid
= 1;
9260 cust
->call_site_htab
= cu
->call_site_htab
;
9263 if (dwarf2_per_objfile
->using_index
)
9264 per_cu
->v
.quick
->compunit_symtab
= cust
;
9267 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
9268 pst
->compunit_symtab
= cust
;
9272 /* Push it for inclusion processing later. */
9273 VEC_safe_push (dwarf2_per_cu_ptr
, dwarf2_per_objfile
->just_read_cus
, per_cu
);
9276 /* Generate full symbol information for type unit PER_CU, whose DIEs have
9277 already been loaded into memory. */
9280 process_full_type_unit (struct dwarf2_per_cu_data
*per_cu
,
9281 enum language pretend_language
)
9283 struct dwarf2_cu
*cu
= per_cu
->cu
;
9284 struct objfile
*objfile
= per_cu
->objfile
;
9285 struct compunit_symtab
*cust
;
9286 struct cleanup
*delayed_list_cleanup
;
9287 struct signatured_type
*sig_type
;
9289 gdb_assert (per_cu
->is_debug_types
);
9290 sig_type
= (struct signatured_type
*) per_cu
;
9293 scoped_free_pendings free_pending
;
9294 delayed_list_cleanup
= make_cleanup (free_delayed_list
, cu
);
9296 cu
->list_in_scope
= &file_symbols
;
9298 cu
->language
= pretend_language
;
9299 cu
->language_defn
= language_def (cu
->language
);
9301 /* The symbol tables are set up in read_type_unit_scope. */
9302 process_die (cu
->dies
, cu
);
9304 /* For now fudge the Go package. */
9305 if (cu
->language
== language_go
)
9306 fixup_go_packaging (cu
);
9308 /* Now that we have processed all the DIEs in the CU, all the types
9309 should be complete, and it should now be safe to compute all of the
9311 compute_delayed_physnames (cu
);
9312 do_cleanups (delayed_list_cleanup
);
9314 /* TUs share symbol tables.
9315 If this is the first TU to use this symtab, complete the construction
9316 of it with end_expandable_symtab. Otherwise, complete the addition of
9317 this TU's symbols to the existing symtab. */
9318 if (sig_type
->type_unit_group
->compunit_symtab
== NULL
)
9320 cust
= end_expandable_symtab (0, SECT_OFF_TEXT (objfile
));
9321 sig_type
->type_unit_group
->compunit_symtab
= cust
;
9325 /* Set symtab language to language from DW_AT_language. If the
9326 compilation is from a C file generated by language preprocessors,
9327 do not set the language if it was already deduced by
9329 if (!(cu
->language
== language_c
9330 && COMPUNIT_FILETABS (cust
)->language
!= language_c
))
9331 COMPUNIT_FILETABS (cust
)->language
= cu
->language
;
9336 augment_type_symtab ();
9337 cust
= sig_type
->type_unit_group
->compunit_symtab
;
9340 if (dwarf2_per_objfile
->using_index
)
9341 per_cu
->v
.quick
->compunit_symtab
= cust
;
9344 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
9345 pst
->compunit_symtab
= cust
;
9350 /* Process an imported unit DIE. */
9353 process_imported_unit_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
9355 struct attribute
*attr
;
9357 /* For now we don't handle imported units in type units. */
9358 if (cu
->per_cu
->is_debug_types
)
9360 error (_("Dwarf Error: DW_TAG_imported_unit is not"
9361 " supported in type units [in module %s]"),
9362 objfile_name (cu
->objfile
));
9365 attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
9368 sect_offset sect_off
= dwarf2_get_ref_die_offset (attr
);
9369 bool is_dwz
= (attr
->form
== DW_FORM_GNU_ref_alt
|| cu
->per_cu
->is_dwz
);
9370 dwarf2_per_cu_data
*per_cu
9371 = dwarf2_find_containing_comp_unit (sect_off
, is_dwz
, cu
->objfile
);
9373 /* If necessary, add it to the queue and load its DIEs. */
9374 if (maybe_queue_comp_unit (cu
, per_cu
, cu
->language
))
9375 load_full_comp_unit (per_cu
, cu
->language
);
9377 VEC_safe_push (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
,
9382 /* RAII object that represents a process_die scope: i.e.,
9383 starts/finishes processing a DIE. */
9384 class process_die_scope
9387 process_die_scope (die_info
*die
, dwarf2_cu
*cu
)
9388 : m_die (die
), m_cu (cu
)
9390 /* We should only be processing DIEs not already in process. */
9391 gdb_assert (!m_die
->in_process
);
9392 m_die
->in_process
= true;
9395 ~process_die_scope ()
9397 m_die
->in_process
= false;
9399 /* If we're done processing the DIE for the CU that owns the line
9400 header, we don't need the line header anymore. */
9401 if (m_cu
->line_header_die_owner
== m_die
)
9403 delete m_cu
->line_header
;
9404 m_cu
->line_header
= NULL
;
9405 m_cu
->line_header_die_owner
= NULL
;
9414 /* Process a die and its children. */
9417 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
9419 process_die_scope
scope (die
, cu
);
9423 case DW_TAG_padding
:
9425 case DW_TAG_compile_unit
:
9426 case DW_TAG_partial_unit
:
9427 read_file_scope (die
, cu
);
9429 case DW_TAG_type_unit
:
9430 read_type_unit_scope (die
, cu
);
9432 case DW_TAG_subprogram
:
9433 case DW_TAG_inlined_subroutine
:
9434 read_func_scope (die
, cu
);
9436 case DW_TAG_lexical_block
:
9437 case DW_TAG_try_block
:
9438 case DW_TAG_catch_block
:
9439 read_lexical_block_scope (die
, cu
);
9441 case DW_TAG_call_site
:
9442 case DW_TAG_GNU_call_site
:
9443 read_call_site_scope (die
, cu
);
9445 case DW_TAG_class_type
:
9446 case DW_TAG_interface_type
:
9447 case DW_TAG_structure_type
:
9448 case DW_TAG_union_type
:
9449 process_structure_scope (die
, cu
);
9451 case DW_TAG_enumeration_type
:
9452 process_enumeration_scope (die
, cu
);
9455 /* These dies have a type, but processing them does not create
9456 a symbol or recurse to process the children. Therefore we can
9457 read them on-demand through read_type_die. */
9458 case DW_TAG_subroutine_type
:
9459 case DW_TAG_set_type
:
9460 case DW_TAG_array_type
:
9461 case DW_TAG_pointer_type
:
9462 case DW_TAG_ptr_to_member_type
:
9463 case DW_TAG_reference_type
:
9464 case DW_TAG_rvalue_reference_type
:
9465 case DW_TAG_string_type
:
9468 case DW_TAG_base_type
:
9469 case DW_TAG_subrange_type
:
9470 case DW_TAG_typedef
:
9471 /* Add a typedef symbol for the type definition, if it has a
9473 new_symbol (die
, read_type_die (die
, cu
), cu
);
9475 case DW_TAG_common_block
:
9476 read_common_block (die
, cu
);
9478 case DW_TAG_common_inclusion
:
9480 case DW_TAG_namespace
:
9481 cu
->processing_has_namespace_info
= 1;
9482 read_namespace (die
, cu
);
9485 cu
->processing_has_namespace_info
= 1;
9486 read_module (die
, cu
);
9488 case DW_TAG_imported_declaration
:
9489 cu
->processing_has_namespace_info
= 1;
9490 if (read_namespace_alias (die
, cu
))
9492 /* The declaration is not a global namespace alias: fall through. */
9493 case DW_TAG_imported_module
:
9494 cu
->processing_has_namespace_info
= 1;
9495 if (die
->child
!= NULL
&& (die
->tag
== DW_TAG_imported_declaration
9496 || cu
->language
!= language_fortran
))
9497 complaint (&symfile_complaints
, _("Tag '%s' has unexpected children"),
9498 dwarf_tag_name (die
->tag
));
9499 read_import_statement (die
, cu
);
9502 case DW_TAG_imported_unit
:
9503 process_imported_unit_die (die
, cu
);
9506 case DW_TAG_variable
:
9507 read_variable (die
, cu
);
9511 new_symbol (die
, NULL
, cu
);
9516 /* DWARF name computation. */
9518 /* A helper function for dwarf2_compute_name which determines whether DIE
9519 needs to have the name of the scope prepended to the name listed in the
9523 die_needs_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
9525 struct attribute
*attr
;
9529 case DW_TAG_namespace
:
9530 case DW_TAG_typedef
:
9531 case DW_TAG_class_type
:
9532 case DW_TAG_interface_type
:
9533 case DW_TAG_structure_type
:
9534 case DW_TAG_union_type
:
9535 case DW_TAG_enumeration_type
:
9536 case DW_TAG_enumerator
:
9537 case DW_TAG_subprogram
:
9538 case DW_TAG_inlined_subroutine
:
9540 case DW_TAG_imported_declaration
:
9543 case DW_TAG_variable
:
9544 case DW_TAG_constant
:
9545 /* We only need to prefix "globally" visible variables. These include
9546 any variable marked with DW_AT_external or any variable that
9547 lives in a namespace. [Variables in anonymous namespaces
9548 require prefixing, but they are not DW_AT_external.] */
9550 if (dwarf2_attr (die
, DW_AT_specification
, cu
))
9552 struct dwarf2_cu
*spec_cu
= cu
;
9554 return die_needs_namespace (die_specification (die
, &spec_cu
),
9558 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
9559 if (attr
== NULL
&& die
->parent
->tag
!= DW_TAG_namespace
9560 && die
->parent
->tag
!= DW_TAG_module
)
9562 /* A variable in a lexical block of some kind does not need a
9563 namespace, even though in C++ such variables may be external
9564 and have a mangled name. */
9565 if (die
->parent
->tag
== DW_TAG_lexical_block
9566 || die
->parent
->tag
== DW_TAG_try_block
9567 || die
->parent
->tag
== DW_TAG_catch_block
9568 || die
->parent
->tag
== DW_TAG_subprogram
)
9577 /* Return the DIE's linkage name attribute, either DW_AT_linkage_name
9578 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
9579 defined for the given DIE. */
9581 static struct attribute
*
9582 dw2_linkage_name_attr (struct die_info
*die
, struct dwarf2_cu
*cu
)
9584 struct attribute
*attr
;
9586 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
9588 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
9593 /* Return the DIE's linkage name as a string, either DW_AT_linkage_name
9594 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
9595 defined for the given DIE. */
9598 dw2_linkage_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
9600 const char *linkage_name
;
9602 linkage_name
= dwarf2_string_attr (die
, DW_AT_linkage_name
, cu
);
9603 if (linkage_name
== NULL
)
9604 linkage_name
= dwarf2_string_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
9606 return linkage_name
;
9609 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
9610 compute the physname for the object, which include a method's:
9611 - formal parameters (C++),
9612 - receiver type (Go),
9614 The term "physname" is a bit confusing.
9615 For C++, for example, it is the demangled name.
9616 For Go, for example, it's the mangled name.
9618 For Ada, return the DIE's linkage name rather than the fully qualified
9619 name. PHYSNAME is ignored..
9621 The result is allocated on the objfile_obstack and canonicalized. */
9624 dwarf2_compute_name (const char *name
,
9625 struct die_info
*die
, struct dwarf2_cu
*cu
,
9628 struct objfile
*objfile
= cu
->objfile
;
9631 name
= dwarf2_name (die
, cu
);
9633 /* For Fortran GDB prefers DW_AT_*linkage_name for the physname if present
9634 but otherwise compute it by typename_concat inside GDB.
9635 FIXME: Actually this is not really true, or at least not always true.
9636 It's all very confusing. SYMBOL_SET_NAMES doesn't try to demangle
9637 Fortran names because there is no mangling standard. So new_symbol_full
9638 will set the demangled name to the result of dwarf2_full_name, and it is
9639 the demangled name that GDB uses if it exists. */
9640 if (cu
->language
== language_ada
9641 || (cu
->language
== language_fortran
&& physname
))
9643 /* For Ada unit, we prefer the linkage name over the name, as
9644 the former contains the exported name, which the user expects
9645 to be able to reference. Ideally, we want the user to be able
9646 to reference this entity using either natural or linkage name,
9647 but we haven't started looking at this enhancement yet. */
9648 const char *linkage_name
= dw2_linkage_name (die
, cu
);
9650 if (linkage_name
!= NULL
)
9651 return linkage_name
;
9654 /* These are the only languages we know how to qualify names in. */
9656 && (cu
->language
== language_cplus
9657 || cu
->language
== language_fortran
|| cu
->language
== language_d
9658 || cu
->language
== language_rust
))
9660 if (die_needs_namespace (die
, cu
))
9663 const char *canonical_name
= NULL
;
9667 prefix
= determine_prefix (die
, cu
);
9668 if (*prefix
!= '\0')
9670 char *prefixed_name
= typename_concat (NULL
, prefix
, name
,
9673 buf
.puts (prefixed_name
);
9674 xfree (prefixed_name
);
9679 /* Template parameters may be specified in the DIE's DW_AT_name, or
9680 as children with DW_TAG_template_type_param or
9681 DW_TAG_value_type_param. If the latter, add them to the name
9682 here. If the name already has template parameters, then
9683 skip this step; some versions of GCC emit both, and
9684 it is more efficient to use the pre-computed name.
9686 Something to keep in mind about this process: it is very
9687 unlikely, or in some cases downright impossible, to produce
9688 something that will match the mangled name of a function.
9689 If the definition of the function has the same debug info,
9690 we should be able to match up with it anyway. But fallbacks
9691 using the minimal symbol, for instance to find a method
9692 implemented in a stripped copy of libstdc++, will not work.
9693 If we do not have debug info for the definition, we will have to
9694 match them up some other way.
9696 When we do name matching there is a related problem with function
9697 templates; two instantiated function templates are allowed to
9698 differ only by their return types, which we do not add here. */
9700 if (cu
->language
== language_cplus
&& strchr (name
, '<') == NULL
)
9702 struct attribute
*attr
;
9703 struct die_info
*child
;
9706 die
->building_fullname
= 1;
9708 for (child
= die
->child
; child
!= NULL
; child
= child
->sibling
)
9712 const gdb_byte
*bytes
;
9713 struct dwarf2_locexpr_baton
*baton
;
9716 if (child
->tag
!= DW_TAG_template_type_param
9717 && child
->tag
!= DW_TAG_template_value_param
)
9728 attr
= dwarf2_attr (child
, DW_AT_type
, cu
);
9731 complaint (&symfile_complaints
,
9732 _("template parameter missing DW_AT_type"));
9733 buf
.puts ("UNKNOWN_TYPE");
9736 type
= die_type (child
, cu
);
9738 if (child
->tag
== DW_TAG_template_type_param
)
9740 c_print_type (type
, "", &buf
, -1, 0, &type_print_raw_options
);
9744 attr
= dwarf2_attr (child
, DW_AT_const_value
, cu
);
9747 complaint (&symfile_complaints
,
9748 _("template parameter missing "
9749 "DW_AT_const_value"));
9750 buf
.puts ("UNKNOWN_VALUE");
9754 dwarf2_const_value_attr (attr
, type
, name
,
9755 &cu
->comp_unit_obstack
, cu
,
9756 &value
, &bytes
, &baton
);
9758 if (TYPE_NOSIGN (type
))
9759 /* GDB prints characters as NUMBER 'CHAR'. If that's
9760 changed, this can use value_print instead. */
9761 c_printchar (value
, type
, &buf
);
9764 struct value_print_options opts
;
9767 v
= dwarf2_evaluate_loc_desc (type
, NULL
,
9771 else if (bytes
!= NULL
)
9773 v
= allocate_value (type
);
9774 memcpy (value_contents_writeable (v
), bytes
,
9775 TYPE_LENGTH (type
));
9778 v
= value_from_longest (type
, value
);
9780 /* Specify decimal so that we do not depend on
9782 get_formatted_print_options (&opts
, 'd');
9784 value_print (v
, &buf
, &opts
);
9790 die
->building_fullname
= 0;
9794 /* Close the argument list, with a space if necessary
9795 (nested templates). */
9796 if (!buf
.empty () && buf
.string ().back () == '>')
9803 /* For C++ methods, append formal parameter type
9804 information, if PHYSNAME. */
9806 if (physname
&& die
->tag
== DW_TAG_subprogram
9807 && cu
->language
== language_cplus
)
9809 struct type
*type
= read_type_die (die
, cu
);
9811 c_type_print_args (type
, &buf
, 1, cu
->language
,
9812 &type_print_raw_options
);
9814 if (cu
->language
== language_cplus
)
9816 /* Assume that an artificial first parameter is
9817 "this", but do not crash if it is not. RealView
9818 marks unnamed (and thus unused) parameters as
9819 artificial; there is no way to differentiate
9821 if (TYPE_NFIELDS (type
) > 0
9822 && TYPE_FIELD_ARTIFICIAL (type
, 0)
9823 && TYPE_CODE (TYPE_FIELD_TYPE (type
, 0)) == TYPE_CODE_PTR
9824 && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type
,
9826 buf
.puts (" const");
9830 const std::string
&intermediate_name
= buf
.string ();
9832 if (cu
->language
== language_cplus
)
9834 = dwarf2_canonicalize_name (intermediate_name
.c_str (), cu
,
9835 &objfile
->per_bfd
->storage_obstack
);
9837 /* If we only computed INTERMEDIATE_NAME, or if
9838 INTERMEDIATE_NAME is already canonical, then we need to
9839 copy it to the appropriate obstack. */
9840 if (canonical_name
== NULL
|| canonical_name
== intermediate_name
.c_str ())
9841 name
= ((const char *)
9842 obstack_copy0 (&objfile
->per_bfd
->storage_obstack
,
9843 intermediate_name
.c_str (),
9844 intermediate_name
.length ()));
9846 name
= canonical_name
;
9853 /* Return the fully qualified name of DIE, based on its DW_AT_name.
9854 If scope qualifiers are appropriate they will be added. The result
9855 will be allocated on the storage_obstack, or NULL if the DIE does
9856 not have a name. NAME may either be from a previous call to
9857 dwarf2_name or NULL.
9859 The output string will be canonicalized (if C++). */
9862 dwarf2_full_name (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
9864 return dwarf2_compute_name (name
, die
, cu
, 0);
9867 /* Construct a physname for the given DIE in CU. NAME may either be
9868 from a previous call to dwarf2_name or NULL. The result will be
9869 allocated on the objfile_objstack or NULL if the DIE does not have a
9872 The output string will be canonicalized (if C++). */
9875 dwarf2_physname (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
9877 struct objfile
*objfile
= cu
->objfile
;
9878 const char *retval
, *mangled
= NULL
, *canon
= NULL
;
9881 /* In this case dwarf2_compute_name is just a shortcut not building anything
9883 if (!die_needs_namespace (die
, cu
))
9884 return dwarf2_compute_name (name
, die
, cu
, 1);
9886 mangled
= dw2_linkage_name (die
, cu
);
9888 /* rustc emits invalid values for DW_AT_linkage_name. Ignore these.
9889 See https://github.com/rust-lang/rust/issues/32925. */
9890 if (cu
->language
== language_rust
&& mangled
!= NULL
9891 && strchr (mangled
, '{') != NULL
)
9894 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
9896 gdb::unique_xmalloc_ptr
<char> demangled
;
9897 if (mangled
!= NULL
)
9899 /* Use DMGL_RET_DROP for C++ template functions to suppress their return
9900 type. It is easier for GDB users to search for such functions as
9901 `name(params)' than `long name(params)'. In such case the minimal
9902 symbol names do not match the full symbol names but for template
9903 functions there is never a need to look up their definition from their
9904 declaration so the only disadvantage remains the minimal symbol
9905 variant `long name(params)' does not have the proper inferior type.
9908 if (cu
->language
== language_go
)
9910 /* This is a lie, but we already lie to the caller new_symbol_full.
9911 new_symbol_full assumes we return the mangled name.
9912 This just undoes that lie until things are cleaned up. */
9916 demangled
.reset (gdb_demangle (mangled
,
9917 (DMGL_PARAMS
| DMGL_ANSI
9921 canon
= demangled
.get ();
9929 if (canon
== NULL
|| check_physname
)
9931 const char *physname
= dwarf2_compute_name (name
, die
, cu
, 1);
9933 if (canon
!= NULL
&& strcmp (physname
, canon
) != 0)
9935 /* It may not mean a bug in GDB. The compiler could also
9936 compute DW_AT_linkage_name incorrectly. But in such case
9937 GDB would need to be bug-to-bug compatible. */
9939 complaint (&symfile_complaints
,
9940 _("Computed physname <%s> does not match demangled <%s> "
9941 "(from linkage <%s>) - DIE at 0x%x [in module %s]"),
9942 physname
, canon
, mangled
, to_underlying (die
->sect_off
),
9943 objfile_name (objfile
));
9945 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
9946 is available here - over computed PHYSNAME. It is safer
9947 against both buggy GDB and buggy compilers. */
9961 retval
= ((const char *)
9962 obstack_copy0 (&objfile
->per_bfd
->storage_obstack
,
9963 retval
, strlen (retval
)));
9968 /* Inspect DIE in CU for a namespace alias. If one exists, record
9969 a new symbol for it.
9971 Returns 1 if a namespace alias was recorded, 0 otherwise. */
9974 read_namespace_alias (struct die_info
*die
, struct dwarf2_cu
*cu
)
9976 struct attribute
*attr
;
9978 /* If the die does not have a name, this is not a namespace
9980 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
9984 struct die_info
*d
= die
;
9985 struct dwarf2_cu
*imported_cu
= cu
;
9987 /* If the compiler has nested DW_AT_imported_declaration DIEs,
9988 keep inspecting DIEs until we hit the underlying import. */
9989 #define MAX_NESTED_IMPORTED_DECLARATIONS 100
9990 for (num
= 0; num
< MAX_NESTED_IMPORTED_DECLARATIONS
; ++num
)
9992 attr
= dwarf2_attr (d
, DW_AT_import
, cu
);
9996 d
= follow_die_ref (d
, attr
, &imported_cu
);
9997 if (d
->tag
!= DW_TAG_imported_declaration
)
10001 if (num
== MAX_NESTED_IMPORTED_DECLARATIONS
)
10003 complaint (&symfile_complaints
,
10004 _("DIE at 0x%x has too many recursively imported "
10005 "declarations"), to_underlying (d
->sect_off
));
10012 sect_offset sect_off
= dwarf2_get_ref_die_offset (attr
);
10014 type
= get_die_type_at_offset (sect_off
, cu
->per_cu
);
10015 if (type
!= NULL
&& TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
10017 /* This declaration is a global namespace alias. Add
10018 a symbol for it whose type is the aliased namespace. */
10019 new_symbol (die
, type
, cu
);
10028 /* Return the using directives repository (global or local?) to use in the
10029 current context for LANGUAGE.
10031 For Ada, imported declarations can materialize renamings, which *may* be
10032 global. However it is impossible (for now?) in DWARF to distinguish
10033 "external" imported declarations and "static" ones. As all imported
10034 declarations seem to be static in all other languages, make them all CU-wide
10035 global only in Ada. */
10037 static struct using_direct
**
10038 using_directives (enum language language
)
10040 if (language
== language_ada
&& context_stack_depth
== 0)
10041 return &global_using_directives
;
10043 return &local_using_directives
;
10046 /* Read the import statement specified by the given die and record it. */
10049 read_import_statement (struct die_info
*die
, struct dwarf2_cu
*cu
)
10051 struct objfile
*objfile
= cu
->objfile
;
10052 struct attribute
*import_attr
;
10053 struct die_info
*imported_die
, *child_die
;
10054 struct dwarf2_cu
*imported_cu
;
10055 const char *imported_name
;
10056 const char *imported_name_prefix
;
10057 const char *canonical_name
;
10058 const char *import_alias
;
10059 const char *imported_declaration
= NULL
;
10060 const char *import_prefix
;
10061 std::vector
<const char *> excludes
;
10063 import_attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
10064 if (import_attr
== NULL
)
10066 complaint (&symfile_complaints
, _("Tag '%s' has no DW_AT_import"),
10067 dwarf_tag_name (die
->tag
));
10072 imported_die
= follow_die_ref_or_sig (die
, import_attr
, &imported_cu
);
10073 imported_name
= dwarf2_name (imported_die
, imported_cu
);
10074 if (imported_name
== NULL
)
10076 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
10078 The import in the following code:
10092 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
10093 <52> DW_AT_decl_file : 1
10094 <53> DW_AT_decl_line : 6
10095 <54> DW_AT_import : <0x75>
10096 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
10097 <59> DW_AT_name : B
10098 <5b> DW_AT_decl_file : 1
10099 <5c> DW_AT_decl_line : 2
10100 <5d> DW_AT_type : <0x6e>
10102 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
10103 <76> DW_AT_byte_size : 4
10104 <77> DW_AT_encoding : 5 (signed)
10106 imports the wrong die ( 0x75 instead of 0x58 ).
10107 This case will be ignored until the gcc bug is fixed. */
10111 /* Figure out the local name after import. */
10112 import_alias
= dwarf2_name (die
, cu
);
10114 /* Figure out where the statement is being imported to. */
10115 import_prefix
= determine_prefix (die
, cu
);
10117 /* Figure out what the scope of the imported die is and prepend it
10118 to the name of the imported die. */
10119 imported_name_prefix
= determine_prefix (imported_die
, imported_cu
);
10121 if (imported_die
->tag
!= DW_TAG_namespace
10122 && imported_die
->tag
!= DW_TAG_module
)
10124 imported_declaration
= imported_name
;
10125 canonical_name
= imported_name_prefix
;
10127 else if (strlen (imported_name_prefix
) > 0)
10128 canonical_name
= obconcat (&objfile
->objfile_obstack
,
10129 imported_name_prefix
,
10130 (cu
->language
== language_d
? "." : "::"),
10131 imported_name
, (char *) NULL
);
10133 canonical_name
= imported_name
;
10135 if (die
->tag
== DW_TAG_imported_module
&& cu
->language
== language_fortran
)
10136 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
10137 child_die
= sibling_die (child_die
))
10139 /* DWARF-4: A Fortran use statement with a “rename list” may be
10140 represented by an imported module entry with an import attribute
10141 referring to the module and owned entries corresponding to those
10142 entities that are renamed as part of being imported. */
10144 if (child_die
->tag
!= DW_TAG_imported_declaration
)
10146 complaint (&symfile_complaints
,
10147 _("child DW_TAG_imported_declaration expected "
10148 "- DIE at 0x%x [in module %s]"),
10149 to_underlying (child_die
->sect_off
), objfile_name (objfile
));
10153 import_attr
= dwarf2_attr (child_die
, DW_AT_import
, cu
);
10154 if (import_attr
== NULL
)
10156 complaint (&symfile_complaints
, _("Tag '%s' has no DW_AT_import"),
10157 dwarf_tag_name (child_die
->tag
));
10162 imported_die
= follow_die_ref_or_sig (child_die
, import_attr
,
10164 imported_name
= dwarf2_name (imported_die
, imported_cu
);
10165 if (imported_name
== NULL
)
10167 complaint (&symfile_complaints
,
10168 _("child DW_TAG_imported_declaration has unknown "
10169 "imported name - DIE at 0x%x [in module %s]"),
10170 to_underlying (child_die
->sect_off
), objfile_name (objfile
));
10174 excludes
.push_back (imported_name
);
10176 process_die (child_die
, cu
);
10179 add_using_directive (using_directives (cu
->language
),
10183 imported_declaration
,
10186 &objfile
->objfile_obstack
);
10189 /* ICC<14 does not output the required DW_AT_declaration on incomplete
10190 types, but gives them a size of zero. Starting with version 14,
10191 ICC is compatible with GCC. */
10194 producer_is_icc_lt_14 (struct dwarf2_cu
*cu
)
10196 if (!cu
->checked_producer
)
10197 check_producer (cu
);
10199 return cu
->producer_is_icc_lt_14
;
10202 /* Check for possibly missing DW_AT_comp_dir with relative .debug_line
10203 directory paths. GCC SVN r127613 (new option -fdebug-prefix-map) fixed
10204 this, it was first present in GCC release 4.3.0. */
10207 producer_is_gcc_lt_4_3 (struct dwarf2_cu
*cu
)
10209 if (!cu
->checked_producer
)
10210 check_producer (cu
);
10212 return cu
->producer_is_gcc_lt_4_3
;
10215 static file_and_directory
10216 find_file_and_directory (struct die_info
*die
, struct dwarf2_cu
*cu
)
10218 file_and_directory res
;
10220 /* Find the filename. Do not use dwarf2_name here, since the filename
10221 is not a source language identifier. */
10222 res
.name
= dwarf2_string_attr (die
, DW_AT_name
, cu
);
10223 res
.comp_dir
= dwarf2_string_attr (die
, DW_AT_comp_dir
, cu
);
10225 if (res
.comp_dir
== NULL
10226 && producer_is_gcc_lt_4_3 (cu
) && res
.name
!= NULL
10227 && IS_ABSOLUTE_PATH (res
.name
))
10229 res
.comp_dir_storage
= ldirname (res
.name
);
10230 if (!res
.comp_dir_storage
.empty ())
10231 res
.comp_dir
= res
.comp_dir_storage
.c_str ();
10233 if (res
.comp_dir
!= NULL
)
10235 /* Irix 6.2 native cc prepends <machine>.: to the compilation
10236 directory, get rid of it. */
10237 const char *cp
= strchr (res
.comp_dir
, ':');
10239 if (cp
&& cp
!= res
.comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
10240 res
.comp_dir
= cp
+ 1;
10243 if (res
.name
== NULL
)
10244 res
.name
= "<unknown>";
10249 /* Handle DW_AT_stmt_list for a compilation unit.
10250 DIE is the DW_TAG_compile_unit die for CU.
10251 COMP_DIR is the compilation directory. LOWPC is passed to
10252 dwarf_decode_lines. See dwarf_decode_lines comments about it. */
10255 handle_DW_AT_stmt_list (struct die_info
*die
, struct dwarf2_cu
*cu
,
10256 const char *comp_dir
, CORE_ADDR lowpc
) /* ARI: editCase function */
10258 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
10259 struct attribute
*attr
;
10260 struct line_header line_header_local
;
10261 hashval_t line_header_local_hash
;
10263 int decode_mapping
;
10265 gdb_assert (! cu
->per_cu
->is_debug_types
);
10267 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
10271 sect_offset line_offset
= (sect_offset
) DW_UNSND (attr
);
10273 /* The line header hash table is only created if needed (it exists to
10274 prevent redundant reading of the line table for partial_units).
10275 If we're given a partial_unit, we'll need it. If we're given a
10276 compile_unit, then use the line header hash table if it's already
10277 created, but don't create one just yet. */
10279 if (dwarf2_per_objfile
->line_header_hash
== NULL
10280 && die
->tag
== DW_TAG_partial_unit
)
10282 dwarf2_per_objfile
->line_header_hash
10283 = htab_create_alloc_ex (127, line_header_hash_voidp
,
10284 line_header_eq_voidp
,
10285 free_line_header_voidp
,
10286 &objfile
->objfile_obstack
,
10287 hashtab_obstack_allocate
,
10288 dummy_obstack_deallocate
);
10291 line_header_local
.sect_off
= line_offset
;
10292 line_header_local
.offset_in_dwz
= cu
->per_cu
->is_dwz
;
10293 line_header_local_hash
= line_header_hash (&line_header_local
);
10294 if (dwarf2_per_objfile
->line_header_hash
!= NULL
)
10296 slot
= htab_find_slot_with_hash (dwarf2_per_objfile
->line_header_hash
,
10297 &line_header_local
,
10298 line_header_local_hash
, NO_INSERT
);
10300 /* For DW_TAG_compile_unit we need info like symtab::linetable which
10301 is not present in *SLOT (since if there is something in *SLOT then
10302 it will be for a partial_unit). */
10303 if (die
->tag
== DW_TAG_partial_unit
&& slot
!= NULL
)
10305 gdb_assert (*slot
!= NULL
);
10306 cu
->line_header
= (struct line_header
*) *slot
;
10311 /* dwarf_decode_line_header does not yet provide sufficient information.
10312 We always have to call also dwarf_decode_lines for it. */
10313 line_header_up lh
= dwarf_decode_line_header (line_offset
, cu
);
10317 cu
->line_header
= lh
.release ();
10318 cu
->line_header_die_owner
= die
;
10320 if (dwarf2_per_objfile
->line_header_hash
== NULL
)
10324 slot
= htab_find_slot_with_hash (dwarf2_per_objfile
->line_header_hash
,
10325 &line_header_local
,
10326 line_header_local_hash
, INSERT
);
10327 gdb_assert (slot
!= NULL
);
10329 if (slot
!= NULL
&& *slot
== NULL
)
10331 /* This newly decoded line number information unit will be owned
10332 by line_header_hash hash table. */
10333 *slot
= cu
->line_header
;
10334 cu
->line_header_die_owner
= NULL
;
10338 /* We cannot free any current entry in (*slot) as that struct line_header
10339 may be already used by multiple CUs. Create only temporary decoded
10340 line_header for this CU - it may happen at most once for each line
10341 number information unit. And if we're not using line_header_hash
10342 then this is what we want as well. */
10343 gdb_assert (die
->tag
!= DW_TAG_partial_unit
);
10345 decode_mapping
= (die
->tag
!= DW_TAG_partial_unit
);
10346 dwarf_decode_lines (cu
->line_header
, comp_dir
, cu
, NULL
, lowpc
,
10351 /* Process DW_TAG_compile_unit or DW_TAG_partial_unit. */
10354 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
10356 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
10357 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
10358 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
10359 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
10360 struct attribute
*attr
;
10361 struct die_info
*child_die
;
10362 CORE_ADDR baseaddr
;
10364 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
10366 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
10368 /* If we didn't find a lowpc, set it to highpc to avoid complaints
10369 from finish_block. */
10370 if (lowpc
== ((CORE_ADDR
) -1))
10372 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
10374 file_and_directory fnd
= find_file_and_directory (die
, cu
);
10376 prepare_one_comp_unit (cu
, die
, cu
->language
);
10378 /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
10379 standardised yet. As a workaround for the language detection we fall
10380 back to the DW_AT_producer string. */
10381 if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL") != NULL
)
10382 cu
->language
= language_opencl
;
10384 /* Similar hack for Go. */
10385 if (cu
->producer
&& strstr (cu
->producer
, "GNU Go ") != NULL
)
10386 set_cu_language (DW_LANG_Go
, cu
);
10388 dwarf2_start_symtab (cu
, fnd
.name
, fnd
.comp_dir
, lowpc
);
10390 /* Decode line number information if present. We do this before
10391 processing child DIEs, so that the line header table is available
10392 for DW_AT_decl_file. */
10393 handle_DW_AT_stmt_list (die
, cu
, fnd
.comp_dir
, lowpc
);
10395 /* Process all dies in compilation unit. */
10396 if (die
->child
!= NULL
)
10398 child_die
= die
->child
;
10399 while (child_die
&& child_die
->tag
)
10401 process_die (child_die
, cu
);
10402 child_die
= sibling_die (child_die
);
10406 /* Decode macro information, if present. Dwarf 2 macro information
10407 refers to information in the line number info statement program
10408 header, so we can only read it if we've read the header
10410 attr
= dwarf2_attr (die
, DW_AT_macros
, cu
);
10412 attr
= dwarf2_attr (die
, DW_AT_GNU_macros
, cu
);
10413 if (attr
&& cu
->line_header
)
10415 if (dwarf2_attr (die
, DW_AT_macro_info
, cu
))
10416 complaint (&symfile_complaints
,
10417 _("CU refers to both DW_AT_macros and DW_AT_macro_info"));
10419 dwarf_decode_macros (cu
, DW_UNSND (attr
), 1);
10423 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
10424 if (attr
&& cu
->line_header
)
10426 unsigned int macro_offset
= DW_UNSND (attr
);
10428 dwarf_decode_macros (cu
, macro_offset
, 0);
10433 /* TU version of handle_DW_AT_stmt_list for read_type_unit_scope.
10434 Create the set of symtabs used by this TU, or if this TU is sharing
10435 symtabs with another TU and the symtabs have already been created
10436 then restore those symtabs in the line header.
10437 We don't need the pc/line-number mapping for type units. */
10440 setup_type_unit_groups (struct die_info
*die
, struct dwarf2_cu
*cu
)
10442 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
10443 struct type_unit_group
*tu_group
;
10445 struct attribute
*attr
;
10447 struct signatured_type
*sig_type
;
10449 gdb_assert (per_cu
->is_debug_types
);
10450 sig_type
= (struct signatured_type
*) per_cu
;
10452 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
10454 /* If we're using .gdb_index (includes -readnow) then
10455 per_cu->type_unit_group may not have been set up yet. */
10456 if (sig_type
->type_unit_group
== NULL
)
10457 sig_type
->type_unit_group
= get_type_unit_group (cu
, attr
);
10458 tu_group
= sig_type
->type_unit_group
;
10460 /* If we've already processed this stmt_list there's no real need to
10461 do it again, we could fake it and just recreate the part we need
10462 (file name,index -> symtab mapping). If data shows this optimization
10463 is useful we can do it then. */
10464 first_time
= tu_group
->compunit_symtab
== NULL
;
10466 /* We have to handle the case of both a missing DW_AT_stmt_list or bad
10471 sect_offset line_offset
= (sect_offset
) DW_UNSND (attr
);
10472 lh
= dwarf_decode_line_header (line_offset
, cu
);
10477 dwarf2_start_symtab (cu
, "", NULL
, 0);
10480 gdb_assert (tu_group
->symtabs
== NULL
);
10481 restart_symtab (tu_group
->compunit_symtab
, "", 0);
10486 cu
->line_header
= lh
.release ();
10487 cu
->line_header_die_owner
= die
;
10491 struct compunit_symtab
*cust
= dwarf2_start_symtab (cu
, "", NULL
, 0);
10493 /* Note: We don't assign tu_group->compunit_symtab yet because we're
10494 still initializing it, and our caller (a few levels up)
10495 process_full_type_unit still needs to know if this is the first
10498 tu_group
->num_symtabs
= cu
->line_header
->file_names
.size ();
10499 tu_group
->symtabs
= XNEWVEC (struct symtab
*,
10500 cu
->line_header
->file_names
.size ());
10502 for (i
= 0; i
< cu
->line_header
->file_names
.size (); ++i
)
10504 file_entry
&fe
= cu
->line_header
->file_names
[i
];
10506 dwarf2_start_subfile (fe
.name
, fe
.include_dir (cu
->line_header
));
10508 if (current_subfile
->symtab
== NULL
)
10510 /* NOTE: start_subfile will recognize when it's been
10511 passed a file it has already seen. So we can't
10512 assume there's a simple mapping from
10513 cu->line_header->file_names to subfiles, plus
10514 cu->line_header->file_names may contain dups. */
10515 current_subfile
->symtab
10516 = allocate_symtab (cust
, current_subfile
->name
);
10519 fe
.symtab
= current_subfile
->symtab
;
10520 tu_group
->symtabs
[i
] = fe
.symtab
;
10525 restart_symtab (tu_group
->compunit_symtab
, "", 0);
10527 for (i
= 0; i
< cu
->line_header
->file_names
.size (); ++i
)
10529 file_entry
&fe
= cu
->line_header
->file_names
[i
];
10531 fe
.symtab
= tu_group
->symtabs
[i
];
10535 /* The main symtab is allocated last. Type units don't have DW_AT_name
10536 so they don't have a "real" (so to speak) symtab anyway.
10537 There is later code that will assign the main symtab to all symbols
10538 that don't have one. We need to handle the case of a symbol with a
10539 missing symtab (DW_AT_decl_file) anyway. */
10542 /* Process DW_TAG_type_unit.
10543 For TUs we want to skip the first top level sibling if it's not the
10544 actual type being defined by this TU. In this case the first top
10545 level sibling is there to provide context only. */
10548 read_type_unit_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
10550 struct die_info
*child_die
;
10552 prepare_one_comp_unit (cu
, die
, language_minimal
);
10554 /* Initialize (or reinitialize) the machinery for building symtabs.
10555 We do this before processing child DIEs, so that the line header table
10556 is available for DW_AT_decl_file. */
10557 setup_type_unit_groups (die
, cu
);
10559 if (die
->child
!= NULL
)
10561 child_die
= die
->child
;
10562 while (child_die
&& child_die
->tag
)
10564 process_die (child_die
, cu
);
10565 child_die
= sibling_die (child_die
);
10572 http://gcc.gnu.org/wiki/DebugFission
10573 http://gcc.gnu.org/wiki/DebugFissionDWP
10575 To simplify handling of both DWO files ("object" files with the DWARF info)
10576 and DWP files (a file with the DWOs packaged up into one file), we treat
10577 DWP files as having a collection of virtual DWO files. */
10580 hash_dwo_file (const void *item
)
10582 const struct dwo_file
*dwo_file
= (const struct dwo_file
*) item
;
10585 hash
= htab_hash_string (dwo_file
->dwo_name
);
10586 if (dwo_file
->comp_dir
!= NULL
)
10587 hash
+= htab_hash_string (dwo_file
->comp_dir
);
10592 eq_dwo_file (const void *item_lhs
, const void *item_rhs
)
10594 const struct dwo_file
*lhs
= (const struct dwo_file
*) item_lhs
;
10595 const struct dwo_file
*rhs
= (const struct dwo_file
*) item_rhs
;
10597 if (strcmp (lhs
->dwo_name
, rhs
->dwo_name
) != 0)
10599 if (lhs
->comp_dir
== NULL
|| rhs
->comp_dir
== NULL
)
10600 return lhs
->comp_dir
== rhs
->comp_dir
;
10601 return strcmp (lhs
->comp_dir
, rhs
->comp_dir
) == 0;
10604 /* Allocate a hash table for DWO files. */
10607 allocate_dwo_file_hash_table (void)
10609 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
10611 return htab_create_alloc_ex (41,
10615 &objfile
->objfile_obstack
,
10616 hashtab_obstack_allocate
,
10617 dummy_obstack_deallocate
);
10620 /* Lookup DWO file DWO_NAME. */
10623 lookup_dwo_file_slot (const char *dwo_name
, const char *comp_dir
)
10625 struct dwo_file find_entry
;
10628 if (dwarf2_per_objfile
->dwo_files
== NULL
)
10629 dwarf2_per_objfile
->dwo_files
= allocate_dwo_file_hash_table ();
10631 memset (&find_entry
, 0, sizeof (find_entry
));
10632 find_entry
.dwo_name
= dwo_name
;
10633 find_entry
.comp_dir
= comp_dir
;
10634 slot
= htab_find_slot (dwarf2_per_objfile
->dwo_files
, &find_entry
, INSERT
);
10640 hash_dwo_unit (const void *item
)
10642 const struct dwo_unit
*dwo_unit
= (const struct dwo_unit
*) item
;
10644 /* This drops the top 32 bits of the id, but is ok for a hash. */
10645 return dwo_unit
->signature
;
10649 eq_dwo_unit (const void *item_lhs
, const void *item_rhs
)
10651 const struct dwo_unit
*lhs
= (const struct dwo_unit
*) item_lhs
;
10652 const struct dwo_unit
*rhs
= (const struct dwo_unit
*) item_rhs
;
10654 /* The signature is assumed to be unique within the DWO file.
10655 So while object file CU dwo_id's always have the value zero,
10656 that's OK, assuming each object file DWO file has only one CU,
10657 and that's the rule for now. */
10658 return lhs
->signature
== rhs
->signature
;
10661 /* Allocate a hash table for DWO CUs,TUs.
10662 There is one of these tables for each of CUs,TUs for each DWO file. */
10665 allocate_dwo_unit_table (struct objfile
*objfile
)
10667 /* Start out with a pretty small number.
10668 Generally DWO files contain only one CU and maybe some TUs. */
10669 return htab_create_alloc_ex (3,
10673 &objfile
->objfile_obstack
,
10674 hashtab_obstack_allocate
,
10675 dummy_obstack_deallocate
);
10678 /* Structure used to pass data to create_dwo_debug_info_hash_table_reader. */
10680 struct create_dwo_cu_data
10682 struct dwo_file
*dwo_file
;
10683 struct dwo_unit dwo_unit
;
10686 /* die_reader_func for create_dwo_cu. */
10689 create_dwo_cu_reader (const struct die_reader_specs
*reader
,
10690 const gdb_byte
*info_ptr
,
10691 struct die_info
*comp_unit_die
,
10695 struct dwarf2_cu
*cu
= reader
->cu
;
10696 sect_offset sect_off
= cu
->per_cu
->sect_off
;
10697 struct dwarf2_section_info
*section
= cu
->per_cu
->section
;
10698 struct create_dwo_cu_data
*data
= (struct create_dwo_cu_data
*) datap
;
10699 struct dwo_file
*dwo_file
= data
->dwo_file
;
10700 struct dwo_unit
*dwo_unit
= &data
->dwo_unit
;
10701 struct attribute
*attr
;
10703 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_id
, cu
);
10706 complaint (&symfile_complaints
,
10707 _("Dwarf Error: debug entry at offset 0x%x is missing"
10708 " its dwo_id [in module %s]"),
10709 to_underlying (sect_off
), dwo_file
->dwo_name
);
10713 dwo_unit
->dwo_file
= dwo_file
;
10714 dwo_unit
->signature
= DW_UNSND (attr
);
10715 dwo_unit
->section
= section
;
10716 dwo_unit
->sect_off
= sect_off
;
10717 dwo_unit
->length
= cu
->per_cu
->length
;
10719 if (dwarf_read_debug
)
10720 fprintf_unfiltered (gdb_stdlog
, " offset 0x%x, dwo_id %s\n",
10721 to_underlying (sect_off
),
10722 hex_string (dwo_unit
->signature
));
10725 /* Create the dwo_units for the CUs in a DWO_FILE.
10726 Note: This function processes DWO files only, not DWP files. */
10729 create_cus_hash_table (struct dwo_file
&dwo_file
, dwarf2_section_info
§ion
,
10732 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
10733 const gdb_byte
*info_ptr
, *end_ptr
;
10735 dwarf2_read_section (objfile
, §ion
);
10736 info_ptr
= section
.buffer
;
10738 if (info_ptr
== NULL
)
10741 if (dwarf_read_debug
)
10743 fprintf_unfiltered (gdb_stdlog
, "Reading %s for %s:\n",
10744 get_section_name (§ion
),
10745 get_section_file_name (§ion
));
10748 end_ptr
= info_ptr
+ section
.size
;
10749 while (info_ptr
< end_ptr
)
10751 struct dwarf2_per_cu_data per_cu
;
10752 struct create_dwo_cu_data create_dwo_cu_data
;
10753 struct dwo_unit
*dwo_unit
;
10755 sect_offset sect_off
= (sect_offset
) (info_ptr
- section
.buffer
);
10757 memset (&create_dwo_cu_data
.dwo_unit
, 0,
10758 sizeof (create_dwo_cu_data
.dwo_unit
));
10759 memset (&per_cu
, 0, sizeof (per_cu
));
10760 per_cu
.objfile
= objfile
;
10761 per_cu
.is_debug_types
= 0;
10762 per_cu
.sect_off
= sect_offset (info_ptr
- section
.buffer
);
10763 per_cu
.section
= §ion
;
10764 create_dwo_cu_data
.dwo_file
= &dwo_file
;
10766 init_cutu_and_read_dies_no_follow (
10767 &per_cu
, &dwo_file
, create_dwo_cu_reader
, &create_dwo_cu_data
);
10768 info_ptr
+= per_cu
.length
;
10770 // If the unit could not be parsed, skip it.
10771 if (create_dwo_cu_data
.dwo_unit
.dwo_file
== NULL
)
10774 if (cus_htab
== NULL
)
10775 cus_htab
= allocate_dwo_unit_table (objfile
);
10777 dwo_unit
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_unit
);
10778 *dwo_unit
= create_dwo_cu_data
.dwo_unit
;
10779 slot
= htab_find_slot (cus_htab
, dwo_unit
, INSERT
);
10780 gdb_assert (slot
!= NULL
);
10783 const struct dwo_unit
*dup_cu
= (const struct dwo_unit
*)*slot
;
10784 sect_offset dup_sect_off
= dup_cu
->sect_off
;
10786 complaint (&symfile_complaints
,
10787 _("debug cu entry at offset 0x%x is duplicate to"
10788 " the entry at offset 0x%x, signature %s"),
10789 to_underlying (sect_off
), to_underlying (dup_sect_off
),
10790 hex_string (dwo_unit
->signature
));
10792 *slot
= (void *)dwo_unit
;
10796 /* DWP file .debug_{cu,tu}_index section format:
10797 [ref: http://gcc.gnu.org/wiki/DebugFissionDWP]
10801 Both index sections have the same format, and serve to map a 64-bit
10802 signature to a set of section numbers. Each section begins with a header,
10803 followed by a hash table of 64-bit signatures, a parallel table of 32-bit
10804 indexes, and a pool of 32-bit section numbers. The index sections will be
10805 aligned at 8-byte boundaries in the file.
10807 The index section header consists of:
10809 V, 32 bit version number
10811 N, 32 bit number of compilation units or type units in the index
10812 M, 32 bit number of slots in the hash table
10814 Numbers are recorded using the byte order of the application binary.
10816 The hash table begins at offset 16 in the section, and consists of an array
10817 of M 64-bit slots. Each slot contains a 64-bit signature (using the byte
10818 order of the application binary). Unused slots in the hash table are 0.
10819 (We rely on the extreme unlikeliness of a signature being exactly 0.)
10821 The parallel table begins immediately after the hash table
10822 (at offset 16 + 8 * M from the beginning of the section), and consists of an
10823 array of 32-bit indexes (using the byte order of the application binary),
10824 corresponding 1-1 with slots in the hash table. Each entry in the parallel
10825 table contains a 32-bit index into the pool of section numbers. For unused
10826 hash table slots, the corresponding entry in the parallel table will be 0.
10828 The pool of section numbers begins immediately following the hash table
10829 (at offset 16 + 12 * M from the beginning of the section). The pool of
10830 section numbers consists of an array of 32-bit words (using the byte order
10831 of the application binary). Each item in the array is indexed starting
10832 from 0. The hash table entry provides the index of the first section
10833 number in the set. Additional section numbers in the set follow, and the
10834 set is terminated by a 0 entry (section number 0 is not used in ELF).
10836 In each set of section numbers, the .debug_info.dwo or .debug_types.dwo
10837 section must be the first entry in the set, and the .debug_abbrev.dwo must
10838 be the second entry. Other members of the set may follow in any order.
10844 DWP Version 2 combines all the .debug_info, etc. sections into one,
10845 and the entries in the index tables are now offsets into these sections.
10846 CU offsets begin at 0. TU offsets begin at the size of the .debug_info
10849 Index Section Contents:
10851 Hash Table of Signatures dwp_hash_table.hash_table
10852 Parallel Table of Indices dwp_hash_table.unit_table
10853 Table of Section Offsets dwp_hash_table.v2.{section_ids,offsets}
10854 Table of Section Sizes dwp_hash_table.v2.sizes
10856 The index section header consists of:
10858 V, 32 bit version number
10859 L, 32 bit number of columns in the table of section offsets
10860 N, 32 bit number of compilation units or type units in the index
10861 M, 32 bit number of slots in the hash table
10863 Numbers are recorded using the byte order of the application binary.
10865 The hash table has the same format as version 1.
10866 The parallel table of indices has the same format as version 1,
10867 except that the entries are origin-1 indices into the table of sections
10868 offsets and the table of section sizes.
10870 The table of offsets begins immediately following the parallel table
10871 (at offset 16 + 12 * M from the beginning of the section). The table is
10872 a two-dimensional array of 32-bit words (using the byte order of the
10873 application binary), with L columns and N+1 rows, in row-major order.
10874 Each row in the array is indexed starting from 0. The first row provides
10875 a key to the remaining rows: each column in this row provides an identifier
10876 for a debug section, and the offsets in the same column of subsequent rows
10877 refer to that section. The section identifiers are:
10879 DW_SECT_INFO 1 .debug_info.dwo
10880 DW_SECT_TYPES 2 .debug_types.dwo
10881 DW_SECT_ABBREV 3 .debug_abbrev.dwo
10882 DW_SECT_LINE 4 .debug_line.dwo
10883 DW_SECT_LOC 5 .debug_loc.dwo
10884 DW_SECT_STR_OFFSETS 6 .debug_str_offsets.dwo
10885 DW_SECT_MACINFO 7 .debug_macinfo.dwo
10886 DW_SECT_MACRO 8 .debug_macro.dwo
10888 The offsets provided by the CU and TU index sections are the base offsets
10889 for the contributions made by each CU or TU to the corresponding section
10890 in the package file. Each CU and TU header contains an abbrev_offset
10891 field, used to find the abbreviations table for that CU or TU within the
10892 contribution to the .debug_abbrev.dwo section for that CU or TU, and should
10893 be interpreted as relative to the base offset given in the index section.
10894 Likewise, offsets into .debug_line.dwo from DW_AT_stmt_list attributes
10895 should be interpreted as relative to the base offset for .debug_line.dwo,
10896 and offsets into other debug sections obtained from DWARF attributes should
10897 also be interpreted as relative to the corresponding base offset.
10899 The table of sizes begins immediately following the table of offsets.
10900 Like the table of offsets, it is a two-dimensional array of 32-bit words,
10901 with L columns and N rows, in row-major order. Each row in the array is
10902 indexed starting from 1 (row 0 is shared by the two tables).
10906 Hash table lookup is handled the same in version 1 and 2:
10908 We assume that N and M will not exceed 2^32 - 1.
10909 The size of the hash table, M, must be 2^k such that 2^k > 3*N/2.
10911 Given a 64-bit compilation unit signature or a type signature S, an entry
10912 in the hash table is located as follows:
10914 1) Calculate a primary hash H = S & MASK(k), where MASK(k) is a mask with
10915 the low-order k bits all set to 1.
10917 2) Calculate a secondary hash H' = (((S >> 32) & MASK(k)) | 1).
10919 3) If the hash table entry at index H matches the signature, use that
10920 entry. If the hash table entry at index H is unused (all zeroes),
10921 terminate the search: the signature is not present in the table.
10923 4) Let H = (H + H') modulo M. Repeat at Step 3.
10925 Because M > N and H' and M are relatively prime, the search is guaranteed
10926 to stop at an unused slot or find the match. */
10928 /* Create a hash table to map DWO IDs to their CU/TU entry in
10929 .debug_{info,types}.dwo in DWP_FILE.
10930 Returns NULL if there isn't one.
10931 Note: This function processes DWP files only, not DWO files. */
10933 static struct dwp_hash_table
*
10934 create_dwp_hash_table (struct dwp_file
*dwp_file
, int is_debug_types
)
10936 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
10937 bfd
*dbfd
= dwp_file
->dbfd
;
10938 const gdb_byte
*index_ptr
, *index_end
;
10939 struct dwarf2_section_info
*index
;
10940 uint32_t version
, nr_columns
, nr_units
, nr_slots
;
10941 struct dwp_hash_table
*htab
;
10943 if (is_debug_types
)
10944 index
= &dwp_file
->sections
.tu_index
;
10946 index
= &dwp_file
->sections
.cu_index
;
10948 if (dwarf2_section_empty_p (index
))
10950 dwarf2_read_section (objfile
, index
);
10952 index_ptr
= index
->buffer
;
10953 index_end
= index_ptr
+ index
->size
;
10955 version
= read_4_bytes (dbfd
, index_ptr
);
10958 nr_columns
= read_4_bytes (dbfd
, index_ptr
);
10962 nr_units
= read_4_bytes (dbfd
, index_ptr
);
10964 nr_slots
= read_4_bytes (dbfd
, index_ptr
);
10967 if (version
!= 1 && version
!= 2)
10969 error (_("Dwarf Error: unsupported DWP file version (%s)"
10970 " [in module %s]"),
10971 pulongest (version
), dwp_file
->name
);
10973 if (nr_slots
!= (nr_slots
& -nr_slots
))
10975 error (_("Dwarf Error: number of slots in DWP hash table (%s)"
10976 " is not power of 2 [in module %s]"),
10977 pulongest (nr_slots
), dwp_file
->name
);
10980 htab
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwp_hash_table
);
10981 htab
->version
= version
;
10982 htab
->nr_columns
= nr_columns
;
10983 htab
->nr_units
= nr_units
;
10984 htab
->nr_slots
= nr_slots
;
10985 htab
->hash_table
= index_ptr
;
10986 htab
->unit_table
= htab
->hash_table
+ sizeof (uint64_t) * nr_slots
;
10988 /* Exit early if the table is empty. */
10989 if (nr_slots
== 0 || nr_units
== 0
10990 || (version
== 2 && nr_columns
== 0))
10992 /* All must be zero. */
10993 if (nr_slots
!= 0 || nr_units
!= 0
10994 || (version
== 2 && nr_columns
!= 0))
10996 complaint (&symfile_complaints
,
10997 _("Empty DWP but nr_slots,nr_units,nr_columns not"
10998 " all zero [in modules %s]"),
11006 htab
->section_pool
.v1
.indices
=
11007 htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
11008 /* It's harder to decide whether the section is too small in v1.
11009 V1 is deprecated anyway so we punt. */
11013 const gdb_byte
*ids_ptr
= htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
11014 int *ids
= htab
->section_pool
.v2
.section_ids
;
11015 /* Reverse map for error checking. */
11016 int ids_seen
[DW_SECT_MAX
+ 1];
11019 if (nr_columns
< 2)
11021 error (_("Dwarf Error: bad DWP hash table, too few columns"
11022 " in section table [in module %s]"),
11025 if (nr_columns
> MAX_NR_V2_DWO_SECTIONS
)
11027 error (_("Dwarf Error: bad DWP hash table, too many columns"
11028 " in section table [in module %s]"),
11031 memset (ids
, 255, (DW_SECT_MAX
+ 1) * sizeof (int32_t));
11032 memset (ids_seen
, 255, (DW_SECT_MAX
+ 1) * sizeof (int32_t));
11033 for (i
= 0; i
< nr_columns
; ++i
)
11035 int id
= read_4_bytes (dbfd
, ids_ptr
+ i
* sizeof (uint32_t));
11037 if (id
< DW_SECT_MIN
|| id
> DW_SECT_MAX
)
11039 error (_("Dwarf Error: bad DWP hash table, bad section id %d"
11040 " in section table [in module %s]"),
11041 id
, dwp_file
->name
);
11043 if (ids_seen
[id
] != -1)
11045 error (_("Dwarf Error: bad DWP hash table, duplicate section"
11046 " id %d in section table [in module %s]"),
11047 id
, dwp_file
->name
);
11052 /* Must have exactly one info or types section. */
11053 if (((ids_seen
[DW_SECT_INFO
] != -1)
11054 + (ids_seen
[DW_SECT_TYPES
] != -1))
11057 error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
11058 " DWO info/types section [in module %s]"),
11061 /* Must have an abbrev section. */
11062 if (ids_seen
[DW_SECT_ABBREV
] == -1)
11064 error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
11065 " section [in module %s]"),
11068 htab
->section_pool
.v2
.offsets
= ids_ptr
+ sizeof (uint32_t) * nr_columns
;
11069 htab
->section_pool
.v2
.sizes
=
11070 htab
->section_pool
.v2
.offsets
+ (sizeof (uint32_t)
11071 * nr_units
* nr_columns
);
11072 if ((htab
->section_pool
.v2
.sizes
+ (sizeof (uint32_t)
11073 * nr_units
* nr_columns
))
11076 error (_("Dwarf Error: DWP index section is corrupt (too small)"
11077 " [in module %s]"),
11085 /* Update SECTIONS with the data from SECTP.
11087 This function is like the other "locate" section routines that are
11088 passed to bfd_map_over_sections, but in this context the sections to
11089 read comes from the DWP V1 hash table, not the full ELF section table.
11091 The result is non-zero for success, or zero if an error was found. */
11094 locate_v1_virtual_dwo_sections (asection
*sectp
,
11095 struct virtual_v1_dwo_sections
*sections
)
11097 const struct dwop_section_names
*names
= &dwop_section_names
;
11099 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
11101 /* There can be only one. */
11102 if (sections
->abbrev
.s
.section
!= NULL
)
11104 sections
->abbrev
.s
.section
= sectp
;
11105 sections
->abbrev
.size
= bfd_get_section_size (sectp
);
11107 else if (section_is_p (sectp
->name
, &names
->info_dwo
)
11108 || section_is_p (sectp
->name
, &names
->types_dwo
))
11110 /* There can be only one. */
11111 if (sections
->info_or_types
.s
.section
!= NULL
)
11113 sections
->info_or_types
.s
.section
= sectp
;
11114 sections
->info_or_types
.size
= bfd_get_section_size (sectp
);
11116 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
11118 /* There can be only one. */
11119 if (sections
->line
.s
.section
!= NULL
)
11121 sections
->line
.s
.section
= sectp
;
11122 sections
->line
.size
= bfd_get_section_size (sectp
);
11124 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
11126 /* There can be only one. */
11127 if (sections
->loc
.s
.section
!= NULL
)
11129 sections
->loc
.s
.section
= sectp
;
11130 sections
->loc
.size
= bfd_get_section_size (sectp
);
11132 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
11134 /* There can be only one. */
11135 if (sections
->macinfo
.s
.section
!= NULL
)
11137 sections
->macinfo
.s
.section
= sectp
;
11138 sections
->macinfo
.size
= bfd_get_section_size (sectp
);
11140 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
11142 /* There can be only one. */
11143 if (sections
->macro
.s
.section
!= NULL
)
11145 sections
->macro
.s
.section
= sectp
;
11146 sections
->macro
.size
= bfd_get_section_size (sectp
);
11148 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
11150 /* There can be only one. */
11151 if (sections
->str_offsets
.s
.section
!= NULL
)
11153 sections
->str_offsets
.s
.section
= sectp
;
11154 sections
->str_offsets
.size
= bfd_get_section_size (sectp
);
11158 /* No other kind of section is valid. */
11165 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
11166 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
11167 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
11168 This is for DWP version 1 files. */
11170 static struct dwo_unit
*
11171 create_dwo_unit_in_dwp_v1 (struct dwp_file
*dwp_file
,
11172 uint32_t unit_index
,
11173 const char *comp_dir
,
11174 ULONGEST signature
, int is_debug_types
)
11176 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
11177 const struct dwp_hash_table
*dwp_htab
=
11178 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
11179 bfd
*dbfd
= dwp_file
->dbfd
;
11180 const char *kind
= is_debug_types
? "TU" : "CU";
11181 struct dwo_file
*dwo_file
;
11182 struct dwo_unit
*dwo_unit
;
11183 struct virtual_v1_dwo_sections sections
;
11184 void **dwo_file_slot
;
11187 gdb_assert (dwp_file
->version
== 1);
11189 if (dwarf_read_debug
)
11191 fprintf_unfiltered (gdb_stdlog
, "Reading %s %s/%s in DWP V1 file: %s\n",
11193 pulongest (unit_index
), hex_string (signature
),
11197 /* Fetch the sections of this DWO unit.
11198 Put a limit on the number of sections we look for so that bad data
11199 doesn't cause us to loop forever. */
11201 #define MAX_NR_V1_DWO_SECTIONS \
11202 (1 /* .debug_info or .debug_types */ \
11203 + 1 /* .debug_abbrev */ \
11204 + 1 /* .debug_line */ \
11205 + 1 /* .debug_loc */ \
11206 + 1 /* .debug_str_offsets */ \
11207 + 1 /* .debug_macro or .debug_macinfo */ \
11208 + 1 /* trailing zero */)
11210 memset (§ions
, 0, sizeof (sections
));
11212 for (i
= 0; i
< MAX_NR_V1_DWO_SECTIONS
; ++i
)
11215 uint32_t section_nr
=
11216 read_4_bytes (dbfd
,
11217 dwp_htab
->section_pool
.v1
.indices
11218 + (unit_index
+ i
) * sizeof (uint32_t));
11220 if (section_nr
== 0)
11222 if (section_nr
>= dwp_file
->num_sections
)
11224 error (_("Dwarf Error: bad DWP hash table, section number too large"
11225 " [in module %s]"),
11229 sectp
= dwp_file
->elf_sections
[section_nr
];
11230 if (! locate_v1_virtual_dwo_sections (sectp
, §ions
))
11232 error (_("Dwarf Error: bad DWP hash table, invalid section found"
11233 " [in module %s]"),
11239 || dwarf2_section_empty_p (§ions
.info_or_types
)
11240 || dwarf2_section_empty_p (§ions
.abbrev
))
11242 error (_("Dwarf Error: bad DWP hash table, missing DWO sections"
11243 " [in module %s]"),
11246 if (i
== MAX_NR_V1_DWO_SECTIONS
)
11248 error (_("Dwarf Error: bad DWP hash table, too many DWO sections"
11249 " [in module %s]"),
11253 /* It's easier for the rest of the code if we fake a struct dwo_file and
11254 have dwo_unit "live" in that. At least for now.
11256 The DWP file can be made up of a random collection of CUs and TUs.
11257 However, for each CU + set of TUs that came from the same original DWO
11258 file, we can combine them back into a virtual DWO file to save space
11259 (fewer struct dwo_file objects to allocate). Remember that for really
11260 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
11262 std::string virtual_dwo_name
=
11263 string_printf ("virtual-dwo/%d-%d-%d-%d",
11264 get_section_id (§ions
.abbrev
),
11265 get_section_id (§ions
.line
),
11266 get_section_id (§ions
.loc
),
11267 get_section_id (§ions
.str_offsets
));
11268 /* Can we use an existing virtual DWO file? */
11269 dwo_file_slot
= lookup_dwo_file_slot (virtual_dwo_name
.c_str (), comp_dir
);
11270 /* Create one if necessary. */
11271 if (*dwo_file_slot
== NULL
)
11273 if (dwarf_read_debug
)
11275 fprintf_unfiltered (gdb_stdlog
, "Creating virtual DWO: %s\n",
11276 virtual_dwo_name
.c_str ());
11278 dwo_file
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_file
);
11280 = (const char *) obstack_copy0 (&objfile
->objfile_obstack
,
11281 virtual_dwo_name
.c_str (),
11282 virtual_dwo_name
.size ());
11283 dwo_file
->comp_dir
= comp_dir
;
11284 dwo_file
->sections
.abbrev
= sections
.abbrev
;
11285 dwo_file
->sections
.line
= sections
.line
;
11286 dwo_file
->sections
.loc
= sections
.loc
;
11287 dwo_file
->sections
.macinfo
= sections
.macinfo
;
11288 dwo_file
->sections
.macro
= sections
.macro
;
11289 dwo_file
->sections
.str_offsets
= sections
.str_offsets
;
11290 /* The "str" section is global to the entire DWP file. */
11291 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
11292 /* The info or types section is assigned below to dwo_unit,
11293 there's no need to record it in dwo_file.
11294 Also, we can't simply record type sections in dwo_file because
11295 we record a pointer into the vector in dwo_unit. As we collect more
11296 types we'll grow the vector and eventually have to reallocate space
11297 for it, invalidating all copies of pointers into the previous
11299 *dwo_file_slot
= dwo_file
;
11303 if (dwarf_read_debug
)
11305 fprintf_unfiltered (gdb_stdlog
, "Using existing virtual DWO: %s\n",
11306 virtual_dwo_name
.c_str ());
11308 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
11311 dwo_unit
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_unit
);
11312 dwo_unit
->dwo_file
= dwo_file
;
11313 dwo_unit
->signature
= signature
;
11314 dwo_unit
->section
=
11315 XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_section_info
);
11316 *dwo_unit
->section
= sections
.info_or_types
;
11317 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
11322 /* Subroutine of create_dwo_unit_in_dwp_v2 to simplify it.
11323 Given a pointer to the containing section SECTION, and OFFSET,SIZE of the
11324 piece within that section used by a TU/CU, return a virtual section
11325 of just that piece. */
11327 static struct dwarf2_section_info
11328 create_dwp_v2_section (struct dwarf2_section_info
*section
,
11329 bfd_size_type offset
, bfd_size_type size
)
11331 struct dwarf2_section_info result
;
11334 gdb_assert (section
!= NULL
);
11335 gdb_assert (!section
->is_virtual
);
11337 memset (&result
, 0, sizeof (result
));
11338 result
.s
.containing_section
= section
;
11339 result
.is_virtual
= 1;
11344 sectp
= get_section_bfd_section (section
);
11346 /* Flag an error if the piece denoted by OFFSET,SIZE is outside the
11347 bounds of the real section. This is a pretty-rare event, so just
11348 flag an error (easier) instead of a warning and trying to cope. */
11350 || offset
+ size
> bfd_get_section_size (sectp
))
11352 error (_("Dwarf Error: Bad DWP V2 section info, doesn't fit"
11353 " in section %s [in module %s]"),
11354 sectp
? bfd_section_name (abfd
, sectp
) : "<unknown>",
11355 objfile_name (dwarf2_per_objfile
->objfile
));
11358 result
.virtual_offset
= offset
;
11359 result
.size
= size
;
11363 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
11364 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
11365 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
11366 This is for DWP version 2 files. */
11368 static struct dwo_unit
*
11369 create_dwo_unit_in_dwp_v2 (struct dwp_file
*dwp_file
,
11370 uint32_t unit_index
,
11371 const char *comp_dir
,
11372 ULONGEST signature
, int is_debug_types
)
11374 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
11375 const struct dwp_hash_table
*dwp_htab
=
11376 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
11377 bfd
*dbfd
= dwp_file
->dbfd
;
11378 const char *kind
= is_debug_types
? "TU" : "CU";
11379 struct dwo_file
*dwo_file
;
11380 struct dwo_unit
*dwo_unit
;
11381 struct virtual_v2_dwo_sections sections
;
11382 void **dwo_file_slot
;
11385 gdb_assert (dwp_file
->version
== 2);
11387 if (dwarf_read_debug
)
11389 fprintf_unfiltered (gdb_stdlog
, "Reading %s %s/%s in DWP V2 file: %s\n",
11391 pulongest (unit_index
), hex_string (signature
),
11395 /* Fetch the section offsets of this DWO unit. */
11397 memset (§ions
, 0, sizeof (sections
));
11399 for (i
= 0; i
< dwp_htab
->nr_columns
; ++i
)
11401 uint32_t offset
= read_4_bytes (dbfd
,
11402 dwp_htab
->section_pool
.v2
.offsets
11403 + (((unit_index
- 1) * dwp_htab
->nr_columns
11405 * sizeof (uint32_t)));
11406 uint32_t size
= read_4_bytes (dbfd
,
11407 dwp_htab
->section_pool
.v2
.sizes
11408 + (((unit_index
- 1) * dwp_htab
->nr_columns
11410 * sizeof (uint32_t)));
11412 switch (dwp_htab
->section_pool
.v2
.section_ids
[i
])
11415 case DW_SECT_TYPES
:
11416 sections
.info_or_types_offset
= offset
;
11417 sections
.info_or_types_size
= size
;
11419 case DW_SECT_ABBREV
:
11420 sections
.abbrev_offset
= offset
;
11421 sections
.abbrev_size
= size
;
11424 sections
.line_offset
= offset
;
11425 sections
.line_size
= size
;
11428 sections
.loc_offset
= offset
;
11429 sections
.loc_size
= size
;
11431 case DW_SECT_STR_OFFSETS
:
11432 sections
.str_offsets_offset
= offset
;
11433 sections
.str_offsets_size
= size
;
11435 case DW_SECT_MACINFO
:
11436 sections
.macinfo_offset
= offset
;
11437 sections
.macinfo_size
= size
;
11439 case DW_SECT_MACRO
:
11440 sections
.macro_offset
= offset
;
11441 sections
.macro_size
= size
;
11446 /* It's easier for the rest of the code if we fake a struct dwo_file and
11447 have dwo_unit "live" in that. At least for now.
11449 The DWP file can be made up of a random collection of CUs and TUs.
11450 However, for each CU + set of TUs that came from the same original DWO
11451 file, we can combine them back into a virtual DWO file to save space
11452 (fewer struct dwo_file objects to allocate). Remember that for really
11453 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
11455 std::string virtual_dwo_name
=
11456 string_printf ("virtual-dwo/%ld-%ld-%ld-%ld",
11457 (long) (sections
.abbrev_size
? sections
.abbrev_offset
: 0),
11458 (long) (sections
.line_size
? sections
.line_offset
: 0),
11459 (long) (sections
.loc_size
? sections
.loc_offset
: 0),
11460 (long) (sections
.str_offsets_size
11461 ? sections
.str_offsets_offset
: 0));
11462 /* Can we use an existing virtual DWO file? */
11463 dwo_file_slot
= lookup_dwo_file_slot (virtual_dwo_name
.c_str (), comp_dir
);
11464 /* Create one if necessary. */
11465 if (*dwo_file_slot
== NULL
)
11467 if (dwarf_read_debug
)
11469 fprintf_unfiltered (gdb_stdlog
, "Creating virtual DWO: %s\n",
11470 virtual_dwo_name
.c_str ());
11472 dwo_file
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_file
);
11474 = (const char *) obstack_copy0 (&objfile
->objfile_obstack
,
11475 virtual_dwo_name
.c_str (),
11476 virtual_dwo_name
.size ());
11477 dwo_file
->comp_dir
= comp_dir
;
11478 dwo_file
->sections
.abbrev
=
11479 create_dwp_v2_section (&dwp_file
->sections
.abbrev
,
11480 sections
.abbrev_offset
, sections
.abbrev_size
);
11481 dwo_file
->sections
.line
=
11482 create_dwp_v2_section (&dwp_file
->sections
.line
,
11483 sections
.line_offset
, sections
.line_size
);
11484 dwo_file
->sections
.loc
=
11485 create_dwp_v2_section (&dwp_file
->sections
.loc
,
11486 sections
.loc_offset
, sections
.loc_size
);
11487 dwo_file
->sections
.macinfo
=
11488 create_dwp_v2_section (&dwp_file
->sections
.macinfo
,
11489 sections
.macinfo_offset
, sections
.macinfo_size
);
11490 dwo_file
->sections
.macro
=
11491 create_dwp_v2_section (&dwp_file
->sections
.macro
,
11492 sections
.macro_offset
, sections
.macro_size
);
11493 dwo_file
->sections
.str_offsets
=
11494 create_dwp_v2_section (&dwp_file
->sections
.str_offsets
,
11495 sections
.str_offsets_offset
,
11496 sections
.str_offsets_size
);
11497 /* The "str" section is global to the entire DWP file. */
11498 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
11499 /* The info or types section is assigned below to dwo_unit,
11500 there's no need to record it in dwo_file.
11501 Also, we can't simply record type sections in dwo_file because
11502 we record a pointer into the vector in dwo_unit. As we collect more
11503 types we'll grow the vector and eventually have to reallocate space
11504 for it, invalidating all copies of pointers into the previous
11506 *dwo_file_slot
= dwo_file
;
11510 if (dwarf_read_debug
)
11512 fprintf_unfiltered (gdb_stdlog
, "Using existing virtual DWO: %s\n",
11513 virtual_dwo_name
.c_str ());
11515 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
11518 dwo_unit
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_unit
);
11519 dwo_unit
->dwo_file
= dwo_file
;
11520 dwo_unit
->signature
= signature
;
11521 dwo_unit
->section
=
11522 XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_section_info
);
11523 *dwo_unit
->section
= create_dwp_v2_section (is_debug_types
11524 ? &dwp_file
->sections
.types
11525 : &dwp_file
->sections
.info
,
11526 sections
.info_or_types_offset
,
11527 sections
.info_or_types_size
);
11528 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
11533 /* Lookup the DWO unit with SIGNATURE in DWP_FILE.
11534 Returns NULL if the signature isn't found. */
11536 static struct dwo_unit
*
11537 lookup_dwo_unit_in_dwp (struct dwp_file
*dwp_file
, const char *comp_dir
,
11538 ULONGEST signature
, int is_debug_types
)
11540 const struct dwp_hash_table
*dwp_htab
=
11541 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
11542 bfd
*dbfd
= dwp_file
->dbfd
;
11543 uint32_t mask
= dwp_htab
->nr_slots
- 1;
11544 uint32_t hash
= signature
& mask
;
11545 uint32_t hash2
= ((signature
>> 32) & mask
) | 1;
11548 struct dwo_unit find_dwo_cu
;
11550 memset (&find_dwo_cu
, 0, sizeof (find_dwo_cu
));
11551 find_dwo_cu
.signature
= signature
;
11552 slot
= htab_find_slot (is_debug_types
11553 ? dwp_file
->loaded_tus
11554 : dwp_file
->loaded_cus
,
11555 &find_dwo_cu
, INSERT
);
11558 return (struct dwo_unit
*) *slot
;
11560 /* Use a for loop so that we don't loop forever on bad debug info. */
11561 for (i
= 0; i
< dwp_htab
->nr_slots
; ++i
)
11563 ULONGEST signature_in_table
;
11565 signature_in_table
=
11566 read_8_bytes (dbfd
, dwp_htab
->hash_table
+ hash
* sizeof (uint64_t));
11567 if (signature_in_table
== signature
)
11569 uint32_t unit_index
=
11570 read_4_bytes (dbfd
,
11571 dwp_htab
->unit_table
+ hash
* sizeof (uint32_t));
11573 if (dwp_file
->version
== 1)
11575 *slot
= create_dwo_unit_in_dwp_v1 (dwp_file
, unit_index
,
11576 comp_dir
, signature
,
11581 *slot
= create_dwo_unit_in_dwp_v2 (dwp_file
, unit_index
,
11582 comp_dir
, signature
,
11585 return (struct dwo_unit
*) *slot
;
11587 if (signature_in_table
== 0)
11589 hash
= (hash
+ hash2
) & mask
;
11592 error (_("Dwarf Error: bad DWP hash table, lookup didn't terminate"
11593 " [in module %s]"),
11597 /* Subroutine of open_dwo_file,open_dwp_file to simplify them.
11598 Open the file specified by FILE_NAME and hand it off to BFD for
11599 preliminary analysis. Return a newly initialized bfd *, which
11600 includes a canonicalized copy of FILE_NAME.
11601 If IS_DWP is TRUE, we're opening a DWP file, otherwise a DWO file.
11602 SEARCH_CWD is true if the current directory is to be searched.
11603 It will be searched before debug-file-directory.
11604 If successful, the file is added to the bfd include table of the
11605 objfile's bfd (see gdb_bfd_record_inclusion).
11606 If unable to find/open the file, return NULL.
11607 NOTE: This function is derived from symfile_bfd_open. */
11609 static gdb_bfd_ref_ptr
11610 try_open_dwop_file (const char *file_name
, int is_dwp
, int search_cwd
)
11613 char *absolute_name
;
11614 /* Blech. OPF_TRY_CWD_FIRST also disables searching the path list if
11615 FILE_NAME contains a '/'. So we can't use it. Instead prepend "."
11616 to debug_file_directory. */
11618 static const char dirname_separator_string
[] = { DIRNAME_SEPARATOR
, '\0' };
11622 if (*debug_file_directory
!= '\0')
11623 search_path
= concat (".", dirname_separator_string
,
11624 debug_file_directory
, (char *) NULL
);
11626 search_path
= xstrdup (".");
11629 search_path
= xstrdup (debug_file_directory
);
11631 flags
= OPF_RETURN_REALPATH
;
11633 flags
|= OPF_SEARCH_IN_PATH
;
11634 desc
= openp (search_path
, flags
, file_name
,
11635 O_RDONLY
| O_BINARY
, &absolute_name
);
11636 xfree (search_path
);
11640 gdb_bfd_ref_ptr
sym_bfd (gdb_bfd_open (absolute_name
, gnutarget
, desc
));
11641 xfree (absolute_name
);
11642 if (sym_bfd
== NULL
)
11644 bfd_set_cacheable (sym_bfd
.get (), 1);
11646 if (!bfd_check_format (sym_bfd
.get (), bfd_object
))
11649 /* Success. Record the bfd as having been included by the objfile's bfd.
11650 This is important because things like demangled_names_hash lives in the
11651 objfile's per_bfd space and may have references to things like symbol
11652 names that live in the DWO/DWP file's per_bfd space. PR 16426. */
11653 gdb_bfd_record_inclusion (dwarf2_per_objfile
->objfile
->obfd
, sym_bfd
.get ());
11658 /* Try to open DWO file FILE_NAME.
11659 COMP_DIR is the DW_AT_comp_dir attribute.
11660 The result is the bfd handle of the file.
11661 If there is a problem finding or opening the file, return NULL.
11662 Upon success, the canonicalized path of the file is stored in the bfd,
11663 same as symfile_bfd_open. */
11665 static gdb_bfd_ref_ptr
11666 open_dwo_file (const char *file_name
, const char *comp_dir
)
11668 if (IS_ABSOLUTE_PATH (file_name
))
11669 return try_open_dwop_file (file_name
, 0 /*is_dwp*/, 0 /*search_cwd*/);
11671 /* Before trying the search path, try DWO_NAME in COMP_DIR. */
11673 if (comp_dir
!= NULL
)
11675 char *path_to_try
= concat (comp_dir
, SLASH_STRING
,
11676 file_name
, (char *) NULL
);
11678 /* NOTE: If comp_dir is a relative path, this will also try the
11679 search path, which seems useful. */
11680 gdb_bfd_ref_ptr
abfd (try_open_dwop_file (path_to_try
, 0 /*is_dwp*/,
11681 1 /*search_cwd*/));
11682 xfree (path_to_try
);
11687 /* That didn't work, try debug-file-directory, which, despite its name,
11688 is a list of paths. */
11690 if (*debug_file_directory
== '\0')
11693 return try_open_dwop_file (file_name
, 0 /*is_dwp*/, 1 /*search_cwd*/);
11696 /* This function is mapped across the sections and remembers the offset and
11697 size of each of the DWO debugging sections we are interested in. */
11700 dwarf2_locate_dwo_sections (bfd
*abfd
, asection
*sectp
, void *dwo_sections_ptr
)
11702 struct dwo_sections
*dwo_sections
= (struct dwo_sections
*) dwo_sections_ptr
;
11703 const struct dwop_section_names
*names
= &dwop_section_names
;
11705 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
11707 dwo_sections
->abbrev
.s
.section
= sectp
;
11708 dwo_sections
->abbrev
.size
= bfd_get_section_size (sectp
);
11710 else if (section_is_p (sectp
->name
, &names
->info_dwo
))
11712 dwo_sections
->info
.s
.section
= sectp
;
11713 dwo_sections
->info
.size
= bfd_get_section_size (sectp
);
11715 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
11717 dwo_sections
->line
.s
.section
= sectp
;
11718 dwo_sections
->line
.size
= bfd_get_section_size (sectp
);
11720 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
11722 dwo_sections
->loc
.s
.section
= sectp
;
11723 dwo_sections
->loc
.size
= bfd_get_section_size (sectp
);
11725 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
11727 dwo_sections
->macinfo
.s
.section
= sectp
;
11728 dwo_sections
->macinfo
.size
= bfd_get_section_size (sectp
);
11730 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
11732 dwo_sections
->macro
.s
.section
= sectp
;
11733 dwo_sections
->macro
.size
= bfd_get_section_size (sectp
);
11735 else if (section_is_p (sectp
->name
, &names
->str_dwo
))
11737 dwo_sections
->str
.s
.section
= sectp
;
11738 dwo_sections
->str
.size
= bfd_get_section_size (sectp
);
11740 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
11742 dwo_sections
->str_offsets
.s
.section
= sectp
;
11743 dwo_sections
->str_offsets
.size
= bfd_get_section_size (sectp
);
11745 else if (section_is_p (sectp
->name
, &names
->types_dwo
))
11747 struct dwarf2_section_info type_section
;
11749 memset (&type_section
, 0, sizeof (type_section
));
11750 type_section
.s
.section
= sectp
;
11751 type_section
.size
= bfd_get_section_size (sectp
);
11752 VEC_safe_push (dwarf2_section_info_def
, dwo_sections
->types
,
11757 /* Initialize the use of the DWO file specified by DWO_NAME and referenced
11758 by PER_CU. This is for the non-DWP case.
11759 The result is NULL if DWO_NAME can't be found. */
11761 static struct dwo_file
*
11762 open_and_init_dwo_file (struct dwarf2_per_cu_data
*per_cu
,
11763 const char *dwo_name
, const char *comp_dir
)
11765 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
11766 struct dwo_file
*dwo_file
;
11767 struct cleanup
*cleanups
;
11769 gdb_bfd_ref_ptr
dbfd (open_dwo_file (dwo_name
, comp_dir
));
11772 if (dwarf_read_debug
)
11773 fprintf_unfiltered (gdb_stdlog
, "DWO file not found: %s\n", dwo_name
);
11776 dwo_file
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_file
);
11777 dwo_file
->dwo_name
= dwo_name
;
11778 dwo_file
->comp_dir
= comp_dir
;
11779 dwo_file
->dbfd
= dbfd
.release ();
11781 cleanups
= make_cleanup (free_dwo_file_cleanup
, dwo_file
);
11783 bfd_map_over_sections (dwo_file
->dbfd
, dwarf2_locate_dwo_sections
,
11784 &dwo_file
->sections
);
11786 create_cus_hash_table (*dwo_file
, dwo_file
->sections
.info
, dwo_file
->cus
);
11788 create_debug_types_hash_table (dwo_file
, dwo_file
->sections
.types
,
11791 discard_cleanups (cleanups
);
11793 if (dwarf_read_debug
)
11794 fprintf_unfiltered (gdb_stdlog
, "DWO file found: %s\n", dwo_name
);
11799 /* This function is mapped across the sections and remembers the offset and
11800 size of each of the DWP debugging sections common to version 1 and 2 that
11801 we are interested in. */
11804 dwarf2_locate_common_dwp_sections (bfd
*abfd
, asection
*sectp
,
11805 void *dwp_file_ptr
)
11807 struct dwp_file
*dwp_file
= (struct dwp_file
*) dwp_file_ptr
;
11808 const struct dwop_section_names
*names
= &dwop_section_names
;
11809 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
11811 /* Record the ELF section number for later lookup: this is what the
11812 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
11813 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
11814 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
11816 /* Look for specific sections that we need. */
11817 if (section_is_p (sectp
->name
, &names
->str_dwo
))
11819 dwp_file
->sections
.str
.s
.section
= sectp
;
11820 dwp_file
->sections
.str
.size
= bfd_get_section_size (sectp
);
11822 else if (section_is_p (sectp
->name
, &names
->cu_index
))
11824 dwp_file
->sections
.cu_index
.s
.section
= sectp
;
11825 dwp_file
->sections
.cu_index
.size
= bfd_get_section_size (sectp
);
11827 else if (section_is_p (sectp
->name
, &names
->tu_index
))
11829 dwp_file
->sections
.tu_index
.s
.section
= sectp
;
11830 dwp_file
->sections
.tu_index
.size
= bfd_get_section_size (sectp
);
11834 /* This function is mapped across the sections and remembers the offset and
11835 size of each of the DWP version 2 debugging sections that we are interested
11836 in. This is split into a separate function because we don't know if we
11837 have version 1 or 2 until we parse the cu_index/tu_index sections. */
11840 dwarf2_locate_v2_dwp_sections (bfd
*abfd
, asection
*sectp
, void *dwp_file_ptr
)
11842 struct dwp_file
*dwp_file
= (struct dwp_file
*) dwp_file_ptr
;
11843 const struct dwop_section_names
*names
= &dwop_section_names
;
11844 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
11846 /* Record the ELF section number for later lookup: this is what the
11847 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
11848 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
11849 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
11851 /* Look for specific sections that we need. */
11852 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
11854 dwp_file
->sections
.abbrev
.s
.section
= sectp
;
11855 dwp_file
->sections
.abbrev
.size
= bfd_get_section_size (sectp
);
11857 else if (section_is_p (sectp
->name
, &names
->info_dwo
))
11859 dwp_file
->sections
.info
.s
.section
= sectp
;
11860 dwp_file
->sections
.info
.size
= bfd_get_section_size (sectp
);
11862 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
11864 dwp_file
->sections
.line
.s
.section
= sectp
;
11865 dwp_file
->sections
.line
.size
= bfd_get_section_size (sectp
);
11867 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
11869 dwp_file
->sections
.loc
.s
.section
= sectp
;
11870 dwp_file
->sections
.loc
.size
= bfd_get_section_size (sectp
);
11872 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
11874 dwp_file
->sections
.macinfo
.s
.section
= sectp
;
11875 dwp_file
->sections
.macinfo
.size
= bfd_get_section_size (sectp
);
11877 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
11879 dwp_file
->sections
.macro
.s
.section
= sectp
;
11880 dwp_file
->sections
.macro
.size
= bfd_get_section_size (sectp
);
11882 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
11884 dwp_file
->sections
.str_offsets
.s
.section
= sectp
;
11885 dwp_file
->sections
.str_offsets
.size
= bfd_get_section_size (sectp
);
11887 else if (section_is_p (sectp
->name
, &names
->types_dwo
))
11889 dwp_file
->sections
.types
.s
.section
= sectp
;
11890 dwp_file
->sections
.types
.size
= bfd_get_section_size (sectp
);
11894 /* Hash function for dwp_file loaded CUs/TUs. */
11897 hash_dwp_loaded_cutus (const void *item
)
11899 const struct dwo_unit
*dwo_unit
= (const struct dwo_unit
*) item
;
11901 /* This drops the top 32 bits of the signature, but is ok for a hash. */
11902 return dwo_unit
->signature
;
11905 /* Equality function for dwp_file loaded CUs/TUs. */
11908 eq_dwp_loaded_cutus (const void *a
, const void *b
)
11910 const struct dwo_unit
*dua
= (const struct dwo_unit
*) a
;
11911 const struct dwo_unit
*dub
= (const struct dwo_unit
*) b
;
11913 return dua
->signature
== dub
->signature
;
11916 /* Allocate a hash table for dwp_file loaded CUs/TUs. */
11919 allocate_dwp_loaded_cutus_table (struct objfile
*objfile
)
11921 return htab_create_alloc_ex (3,
11922 hash_dwp_loaded_cutus
,
11923 eq_dwp_loaded_cutus
,
11925 &objfile
->objfile_obstack
,
11926 hashtab_obstack_allocate
,
11927 dummy_obstack_deallocate
);
11930 /* Try to open DWP file FILE_NAME.
11931 The result is the bfd handle of the file.
11932 If there is a problem finding or opening the file, return NULL.
11933 Upon success, the canonicalized path of the file is stored in the bfd,
11934 same as symfile_bfd_open. */
11936 static gdb_bfd_ref_ptr
11937 open_dwp_file (const char *file_name
)
11939 gdb_bfd_ref_ptr
abfd (try_open_dwop_file (file_name
, 1 /*is_dwp*/,
11940 1 /*search_cwd*/));
11944 /* Work around upstream bug 15652.
11945 http://sourceware.org/bugzilla/show_bug.cgi?id=15652
11946 [Whether that's a "bug" is debatable, but it is getting in our way.]
11947 We have no real idea where the dwp file is, because gdb's realpath-ing
11948 of the executable's path may have discarded the needed info.
11949 [IWBN if the dwp file name was recorded in the executable, akin to
11950 .gnu_debuglink, but that doesn't exist yet.]
11951 Strip the directory from FILE_NAME and search again. */
11952 if (*debug_file_directory
!= '\0')
11954 /* Don't implicitly search the current directory here.
11955 If the user wants to search "." to handle this case,
11956 it must be added to debug-file-directory. */
11957 return try_open_dwop_file (lbasename (file_name
), 1 /*is_dwp*/,
11964 /* Initialize the use of the DWP file for the current objfile.
11965 By convention the name of the DWP file is ${objfile}.dwp.
11966 The result is NULL if it can't be found. */
11968 static struct dwp_file
*
11969 open_and_init_dwp_file (void)
11971 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
11972 struct dwp_file
*dwp_file
;
11974 /* Try to find first .dwp for the binary file before any symbolic links
11977 /* If the objfile is a debug file, find the name of the real binary
11978 file and get the name of dwp file from there. */
11979 std::string dwp_name
;
11980 if (objfile
->separate_debug_objfile_backlink
!= NULL
)
11982 struct objfile
*backlink
= objfile
->separate_debug_objfile_backlink
;
11983 const char *backlink_basename
= lbasename (backlink
->original_name
);
11985 dwp_name
= ldirname (objfile
->original_name
) + SLASH_STRING
+ backlink_basename
;
11988 dwp_name
= objfile
->original_name
;
11990 dwp_name
+= ".dwp";
11992 gdb_bfd_ref_ptr
dbfd (open_dwp_file (dwp_name
.c_str ()));
11994 && strcmp (objfile
->original_name
, objfile_name (objfile
)) != 0)
11996 /* Try to find .dwp for the binary file after gdb_realpath resolving. */
11997 dwp_name
= objfile_name (objfile
);
11998 dwp_name
+= ".dwp";
11999 dbfd
= open_dwp_file (dwp_name
.c_str ());
12004 if (dwarf_read_debug
)
12005 fprintf_unfiltered (gdb_stdlog
, "DWP file not found: %s\n", dwp_name
.c_str ());
12008 dwp_file
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwp_file
);
12009 dwp_file
->name
= bfd_get_filename (dbfd
.get ());
12010 dwp_file
->dbfd
= dbfd
.release ();
12012 /* +1: section 0 is unused */
12013 dwp_file
->num_sections
= bfd_count_sections (dwp_file
->dbfd
) + 1;
12014 dwp_file
->elf_sections
=
12015 OBSTACK_CALLOC (&objfile
->objfile_obstack
,
12016 dwp_file
->num_sections
, asection
*);
12018 bfd_map_over_sections (dwp_file
->dbfd
, dwarf2_locate_common_dwp_sections
,
12021 dwp_file
->cus
= create_dwp_hash_table (dwp_file
, 0);
12023 dwp_file
->tus
= create_dwp_hash_table (dwp_file
, 1);
12025 /* The DWP file version is stored in the hash table. Oh well. */
12026 if (dwp_file
->cus
&& dwp_file
->tus
12027 && dwp_file
->cus
->version
!= dwp_file
->tus
->version
)
12029 /* Technically speaking, we should try to limp along, but this is
12030 pretty bizarre. We use pulongest here because that's the established
12031 portability solution (e.g, we cannot use %u for uint32_t). */
12032 error (_("Dwarf Error: DWP file CU version %s doesn't match"
12033 " TU version %s [in DWP file %s]"),
12034 pulongest (dwp_file
->cus
->version
),
12035 pulongest (dwp_file
->tus
->version
), dwp_name
.c_str ());
12039 dwp_file
->version
= dwp_file
->cus
->version
;
12040 else if (dwp_file
->tus
)
12041 dwp_file
->version
= dwp_file
->tus
->version
;
12043 dwp_file
->version
= 2;
12045 if (dwp_file
->version
== 2)
12046 bfd_map_over_sections (dwp_file
->dbfd
, dwarf2_locate_v2_dwp_sections
,
12049 dwp_file
->loaded_cus
= allocate_dwp_loaded_cutus_table (objfile
);
12050 dwp_file
->loaded_tus
= allocate_dwp_loaded_cutus_table (objfile
);
12052 if (dwarf_read_debug
)
12054 fprintf_unfiltered (gdb_stdlog
, "DWP file found: %s\n", dwp_file
->name
);
12055 fprintf_unfiltered (gdb_stdlog
,
12056 " %s CUs, %s TUs\n",
12057 pulongest (dwp_file
->cus
? dwp_file
->cus
->nr_units
: 0),
12058 pulongest (dwp_file
->tus
? dwp_file
->tus
->nr_units
: 0));
12064 /* Wrapper around open_and_init_dwp_file, only open it once. */
12066 static struct dwp_file
*
12067 get_dwp_file (void)
12069 if (! dwarf2_per_objfile
->dwp_checked
)
12071 dwarf2_per_objfile
->dwp_file
= open_and_init_dwp_file ();
12072 dwarf2_per_objfile
->dwp_checked
= 1;
12074 return dwarf2_per_objfile
->dwp_file
;
12077 /* Subroutine of lookup_dwo_comp_unit, lookup_dwo_type_unit.
12078 Look up the CU/TU with signature SIGNATURE, either in DWO file DWO_NAME
12079 or in the DWP file for the objfile, referenced by THIS_UNIT.
12080 If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
12081 IS_DEBUG_TYPES is non-zero if reading a TU, otherwise read a CU.
12083 This is called, for example, when wanting to read a variable with a
12084 complex location. Therefore we don't want to do file i/o for every call.
12085 Therefore we don't want to look for a DWO file on every call.
12086 Therefore we first see if we've already seen SIGNATURE in a DWP file,
12087 then we check if we've already seen DWO_NAME, and only THEN do we check
12090 The result is a pointer to the dwo_unit object or NULL if we didn't find it
12091 (dwo_id mismatch or couldn't find the DWO/DWP file). */
12093 static struct dwo_unit
*
12094 lookup_dwo_cutu (struct dwarf2_per_cu_data
*this_unit
,
12095 const char *dwo_name
, const char *comp_dir
,
12096 ULONGEST signature
, int is_debug_types
)
12098 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
12099 const char *kind
= is_debug_types
? "TU" : "CU";
12100 void **dwo_file_slot
;
12101 struct dwo_file
*dwo_file
;
12102 struct dwp_file
*dwp_file
;
12104 /* First see if there's a DWP file.
12105 If we have a DWP file but didn't find the DWO inside it, don't
12106 look for the original DWO file. It makes gdb behave differently
12107 depending on whether one is debugging in the build tree. */
12109 dwp_file
= get_dwp_file ();
12110 if (dwp_file
!= NULL
)
12112 const struct dwp_hash_table
*dwp_htab
=
12113 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12115 if (dwp_htab
!= NULL
)
12117 struct dwo_unit
*dwo_cutu
=
12118 lookup_dwo_unit_in_dwp (dwp_file
, comp_dir
,
12119 signature
, is_debug_types
);
12121 if (dwo_cutu
!= NULL
)
12123 if (dwarf_read_debug
)
12125 fprintf_unfiltered (gdb_stdlog
,
12126 "Virtual DWO %s %s found: @%s\n",
12127 kind
, hex_string (signature
),
12128 host_address_to_string (dwo_cutu
));
12136 /* No DWP file, look for the DWO file. */
12138 dwo_file_slot
= lookup_dwo_file_slot (dwo_name
, comp_dir
);
12139 if (*dwo_file_slot
== NULL
)
12141 /* Read in the file and build a table of the CUs/TUs it contains. */
12142 *dwo_file_slot
= open_and_init_dwo_file (this_unit
, dwo_name
, comp_dir
);
12144 /* NOTE: This will be NULL if unable to open the file. */
12145 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
12147 if (dwo_file
!= NULL
)
12149 struct dwo_unit
*dwo_cutu
= NULL
;
12151 if (is_debug_types
&& dwo_file
->tus
)
12153 struct dwo_unit find_dwo_cutu
;
12155 memset (&find_dwo_cutu
, 0, sizeof (find_dwo_cutu
));
12156 find_dwo_cutu
.signature
= signature
;
12158 = (struct dwo_unit
*) htab_find (dwo_file
->tus
, &find_dwo_cutu
);
12160 else if (!is_debug_types
&& dwo_file
->cus
)
12162 struct dwo_unit find_dwo_cutu
;
12164 memset (&find_dwo_cutu
, 0, sizeof (find_dwo_cutu
));
12165 find_dwo_cutu
.signature
= signature
;
12166 dwo_cutu
= (struct dwo_unit
*)htab_find (dwo_file
->cus
,
12170 if (dwo_cutu
!= NULL
)
12172 if (dwarf_read_debug
)
12174 fprintf_unfiltered (gdb_stdlog
, "DWO %s %s(%s) found: @%s\n",
12175 kind
, dwo_name
, hex_string (signature
),
12176 host_address_to_string (dwo_cutu
));
12183 /* We didn't find it. This could mean a dwo_id mismatch, or
12184 someone deleted the DWO/DWP file, or the search path isn't set up
12185 correctly to find the file. */
12187 if (dwarf_read_debug
)
12189 fprintf_unfiltered (gdb_stdlog
, "DWO %s %s(%s) not found\n",
12190 kind
, dwo_name
, hex_string (signature
));
12193 /* This is a warning and not a complaint because it can be caused by
12194 pilot error (e.g., user accidentally deleting the DWO). */
12196 /* Print the name of the DWP file if we looked there, helps the user
12197 better diagnose the problem. */
12198 std::string dwp_text
;
12200 if (dwp_file
!= NULL
)
12201 dwp_text
= string_printf (" [in DWP file %s]",
12202 lbasename (dwp_file
->name
));
12204 warning (_("Could not find DWO %s %s(%s)%s referenced by %s at offset 0x%x"
12205 " [in module %s]"),
12206 kind
, dwo_name
, hex_string (signature
),
12208 this_unit
->is_debug_types
? "TU" : "CU",
12209 to_underlying (this_unit
->sect_off
), objfile_name (objfile
));
12214 /* Lookup the DWO CU DWO_NAME/SIGNATURE referenced from THIS_CU.
12215 See lookup_dwo_cutu_unit for details. */
12217 static struct dwo_unit
*
12218 lookup_dwo_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
12219 const char *dwo_name
, const char *comp_dir
,
12220 ULONGEST signature
)
12222 return lookup_dwo_cutu (this_cu
, dwo_name
, comp_dir
, signature
, 0);
12225 /* Lookup the DWO TU DWO_NAME/SIGNATURE referenced from THIS_TU.
12226 See lookup_dwo_cutu_unit for details. */
12228 static struct dwo_unit
*
12229 lookup_dwo_type_unit (struct signatured_type
*this_tu
,
12230 const char *dwo_name
, const char *comp_dir
)
12232 return lookup_dwo_cutu (&this_tu
->per_cu
, dwo_name
, comp_dir
, this_tu
->signature
, 1);
12235 /* Traversal function for queue_and_load_all_dwo_tus. */
12238 queue_and_load_dwo_tu (void **slot
, void *info
)
12240 struct dwo_unit
*dwo_unit
= (struct dwo_unit
*) *slot
;
12241 struct dwarf2_per_cu_data
*per_cu
= (struct dwarf2_per_cu_data
*) info
;
12242 ULONGEST signature
= dwo_unit
->signature
;
12243 struct signatured_type
*sig_type
=
12244 lookup_dwo_signatured_type (per_cu
->cu
, signature
);
12246 if (sig_type
!= NULL
)
12248 struct dwarf2_per_cu_data
*sig_cu
= &sig_type
->per_cu
;
12250 /* We pass NULL for DEPENDENT_CU because we don't yet know if there's
12251 a real dependency of PER_CU on SIG_TYPE. That is detected later
12252 while processing PER_CU. */
12253 if (maybe_queue_comp_unit (NULL
, sig_cu
, per_cu
->cu
->language
))
12254 load_full_type_unit (sig_cu
);
12255 VEC_safe_push (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
, sig_cu
);
12261 /* Queue all TUs contained in the DWO of PER_CU to be read in.
12262 The DWO may have the only definition of the type, though it may not be
12263 referenced anywhere in PER_CU. Thus we have to load *all* its TUs.
12264 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
12267 queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data
*per_cu
)
12269 struct dwo_unit
*dwo_unit
;
12270 struct dwo_file
*dwo_file
;
12272 gdb_assert (!per_cu
->is_debug_types
);
12273 gdb_assert (get_dwp_file () == NULL
);
12274 gdb_assert (per_cu
->cu
!= NULL
);
12276 dwo_unit
= per_cu
->cu
->dwo_unit
;
12277 gdb_assert (dwo_unit
!= NULL
);
12279 dwo_file
= dwo_unit
->dwo_file
;
12280 if (dwo_file
->tus
!= NULL
)
12281 htab_traverse_noresize (dwo_file
->tus
, queue_and_load_dwo_tu
, per_cu
);
12284 /* Free all resources associated with DWO_FILE.
12285 Close the DWO file and munmap the sections.
12286 All memory should be on the objfile obstack. */
12289 free_dwo_file (struct dwo_file
*dwo_file
, struct objfile
*objfile
)
12292 /* Note: dbfd is NULL for virtual DWO files. */
12293 gdb_bfd_unref (dwo_file
->dbfd
);
12295 VEC_free (dwarf2_section_info_def
, dwo_file
->sections
.types
);
12298 /* Wrapper for free_dwo_file for use in cleanups. */
12301 free_dwo_file_cleanup (void *arg
)
12303 struct dwo_file
*dwo_file
= (struct dwo_file
*) arg
;
12304 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
12306 free_dwo_file (dwo_file
, objfile
);
12309 /* Traversal function for free_dwo_files. */
12312 free_dwo_file_from_slot (void **slot
, void *info
)
12314 struct dwo_file
*dwo_file
= (struct dwo_file
*) *slot
;
12315 struct objfile
*objfile
= (struct objfile
*) info
;
12317 free_dwo_file (dwo_file
, objfile
);
12322 /* Free all resources associated with DWO_FILES. */
12325 free_dwo_files (htab_t dwo_files
, struct objfile
*objfile
)
12327 htab_traverse_noresize (dwo_files
, free_dwo_file_from_slot
, objfile
);
12330 /* Read in various DIEs. */
12332 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
12333 Inherit only the children of the DW_AT_abstract_origin DIE not being
12334 already referenced by DW_AT_abstract_origin from the children of the
12338 inherit_abstract_dies (struct die_info
*die
, struct dwarf2_cu
*cu
)
12340 struct die_info
*child_die
;
12341 sect_offset
*offsetp
;
12342 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
12343 struct die_info
*origin_die
;
12344 /* Iterator of the ORIGIN_DIE children. */
12345 struct die_info
*origin_child_die
;
12346 struct attribute
*attr
;
12347 struct dwarf2_cu
*origin_cu
;
12348 struct pending
**origin_previous_list_in_scope
;
12350 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
12354 /* Note that following die references may follow to a die in a
12358 origin_die
= follow_die_ref (die
, attr
, &origin_cu
);
12360 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
12362 origin_previous_list_in_scope
= origin_cu
->list_in_scope
;
12363 origin_cu
->list_in_scope
= cu
->list_in_scope
;
12365 if (die
->tag
!= origin_die
->tag
12366 && !(die
->tag
== DW_TAG_inlined_subroutine
12367 && origin_die
->tag
== DW_TAG_subprogram
))
12368 complaint (&symfile_complaints
,
12369 _("DIE 0x%x and its abstract origin 0x%x have different tags"),
12370 to_underlying (die
->sect_off
),
12371 to_underlying (origin_die
->sect_off
));
12373 std::vector
<sect_offset
> offsets
;
12375 for (child_die
= die
->child
;
12376 child_die
&& child_die
->tag
;
12377 child_die
= sibling_die (child_die
))
12379 struct die_info
*child_origin_die
;
12380 struct dwarf2_cu
*child_origin_cu
;
12382 /* We are trying to process concrete instance entries:
12383 DW_TAG_call_site DIEs indeed have a DW_AT_abstract_origin tag, but
12384 it's not relevant to our analysis here. i.e. detecting DIEs that are
12385 present in the abstract instance but not referenced in the concrete
12387 if (child_die
->tag
== DW_TAG_call_site
12388 || child_die
->tag
== DW_TAG_GNU_call_site
)
12391 /* For each CHILD_DIE, find the corresponding child of
12392 ORIGIN_DIE. If there is more than one layer of
12393 DW_AT_abstract_origin, follow them all; there shouldn't be,
12394 but GCC versions at least through 4.4 generate this (GCC PR
12396 child_origin_die
= child_die
;
12397 child_origin_cu
= cu
;
12400 attr
= dwarf2_attr (child_origin_die
, DW_AT_abstract_origin
,
12404 child_origin_die
= follow_die_ref (child_origin_die
, attr
,
12408 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
12409 counterpart may exist. */
12410 if (child_origin_die
!= child_die
)
12412 if (child_die
->tag
!= child_origin_die
->tag
12413 && !(child_die
->tag
== DW_TAG_inlined_subroutine
12414 && child_origin_die
->tag
== DW_TAG_subprogram
))
12415 complaint (&symfile_complaints
,
12416 _("Child DIE 0x%x and its abstract origin 0x%x have "
12418 to_underlying (child_die
->sect_off
),
12419 to_underlying (child_origin_die
->sect_off
));
12420 if (child_origin_die
->parent
!= origin_die
)
12421 complaint (&symfile_complaints
,
12422 _("Child DIE 0x%x and its abstract origin 0x%x have "
12423 "different parents"),
12424 to_underlying (child_die
->sect_off
),
12425 to_underlying (child_origin_die
->sect_off
));
12427 offsets
.push_back (child_origin_die
->sect_off
);
12430 std::sort (offsets
.begin (), offsets
.end ());
12431 sect_offset
*offsets_end
= offsets
.data () + offsets
.size ();
12432 for (offsetp
= offsets
.data () + 1; offsetp
< offsets_end
; offsetp
++)
12433 if (offsetp
[-1] == *offsetp
)
12434 complaint (&symfile_complaints
,
12435 _("Multiple children of DIE 0x%x refer "
12436 "to DIE 0x%x as their abstract origin"),
12437 to_underlying (die
->sect_off
), to_underlying (*offsetp
));
12439 offsetp
= offsets
.data ();
12440 origin_child_die
= origin_die
->child
;
12441 while (origin_child_die
&& origin_child_die
->tag
)
12443 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
12444 while (offsetp
< offsets_end
12445 && *offsetp
< origin_child_die
->sect_off
)
12447 if (offsetp
>= offsets_end
12448 || *offsetp
> origin_child_die
->sect_off
)
12450 /* Found that ORIGIN_CHILD_DIE is really not referenced.
12451 Check whether we're already processing ORIGIN_CHILD_DIE.
12452 This can happen with mutually referenced abstract_origins.
12454 if (!origin_child_die
->in_process
)
12455 process_die (origin_child_die
, origin_cu
);
12457 origin_child_die
= sibling_die (origin_child_die
);
12459 origin_cu
->list_in_scope
= origin_previous_list_in_scope
;
12463 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
12465 struct objfile
*objfile
= cu
->objfile
;
12466 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
12467 struct context_stack
*newobj
;
12470 struct die_info
*child_die
;
12471 struct attribute
*attr
, *call_line
, *call_file
;
12473 CORE_ADDR baseaddr
;
12474 struct block
*block
;
12475 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
12476 std::vector
<struct symbol
*> template_args
;
12477 struct template_symbol
*templ_func
= NULL
;
12481 /* If we do not have call site information, we can't show the
12482 caller of this inlined function. That's too confusing, so
12483 only use the scope for local variables. */
12484 call_line
= dwarf2_attr (die
, DW_AT_call_line
, cu
);
12485 call_file
= dwarf2_attr (die
, DW_AT_call_file
, cu
);
12486 if (call_line
== NULL
|| call_file
== NULL
)
12488 read_lexical_block_scope (die
, cu
);
12493 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
12495 name
= dwarf2_name (die
, cu
);
12497 /* Ignore functions with missing or empty names. These are actually
12498 illegal according to the DWARF standard. */
12501 complaint (&symfile_complaints
,
12502 _("missing name for subprogram DIE at %d"),
12503 to_underlying (die
->sect_off
));
12507 /* Ignore functions with missing or invalid low and high pc attributes. */
12508 if (dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
)
12509 <= PC_BOUNDS_INVALID
)
12511 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
12512 if (!attr
|| !DW_UNSND (attr
))
12513 complaint (&symfile_complaints
,
12514 _("cannot get low and high bounds "
12515 "for subprogram DIE at %d"),
12516 to_underlying (die
->sect_off
));
12520 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
12521 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
12523 /* If we have any template arguments, then we must allocate a
12524 different sort of symbol. */
12525 for (child_die
= die
->child
; child_die
; child_die
= sibling_die (child_die
))
12527 if (child_die
->tag
== DW_TAG_template_type_param
12528 || child_die
->tag
== DW_TAG_template_value_param
)
12530 templ_func
= allocate_template_symbol (objfile
);
12531 templ_func
->subclass
= SYMBOL_TEMPLATE
;
12536 newobj
= push_context (0, lowpc
);
12537 newobj
->name
= new_symbol_full (die
, read_type_die (die
, cu
), cu
,
12538 (struct symbol
*) templ_func
);
12540 /* If there is a location expression for DW_AT_frame_base, record
12542 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
12544 dwarf2_symbol_mark_computed (attr
, newobj
->name
, cu
, 1);
12546 /* If there is a location for the static link, record it. */
12547 newobj
->static_link
= NULL
;
12548 attr
= dwarf2_attr (die
, DW_AT_static_link
, cu
);
12551 newobj
->static_link
12552 = XOBNEW (&objfile
->objfile_obstack
, struct dynamic_prop
);
12553 attr_to_dynamic_prop (attr
, die
, cu
, newobj
->static_link
);
12556 cu
->list_in_scope
= &local_symbols
;
12558 if (die
->child
!= NULL
)
12560 child_die
= die
->child
;
12561 while (child_die
&& child_die
->tag
)
12563 if (child_die
->tag
== DW_TAG_template_type_param
12564 || child_die
->tag
== DW_TAG_template_value_param
)
12566 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
12569 template_args
.push_back (arg
);
12572 process_die (child_die
, cu
);
12573 child_die
= sibling_die (child_die
);
12577 inherit_abstract_dies (die
, cu
);
12579 /* If we have a DW_AT_specification, we might need to import using
12580 directives from the context of the specification DIE. See the
12581 comment in determine_prefix. */
12582 if (cu
->language
== language_cplus
12583 && dwarf2_attr (die
, DW_AT_specification
, cu
))
12585 struct dwarf2_cu
*spec_cu
= cu
;
12586 struct die_info
*spec_die
= die_specification (die
, &spec_cu
);
12590 child_die
= spec_die
->child
;
12591 while (child_die
&& child_die
->tag
)
12593 if (child_die
->tag
== DW_TAG_imported_module
)
12594 process_die (child_die
, spec_cu
);
12595 child_die
= sibling_die (child_die
);
12598 /* In some cases, GCC generates specification DIEs that
12599 themselves contain DW_AT_specification attributes. */
12600 spec_die
= die_specification (spec_die
, &spec_cu
);
12604 newobj
= pop_context ();
12605 /* Make a block for the local symbols within. */
12606 block
= finish_block (newobj
->name
, &local_symbols
, newobj
->old_blocks
,
12607 newobj
->static_link
, lowpc
, highpc
);
12609 /* For C++, set the block's scope. */
12610 if ((cu
->language
== language_cplus
12611 || cu
->language
== language_fortran
12612 || cu
->language
== language_d
12613 || cu
->language
== language_rust
)
12614 && cu
->processing_has_namespace_info
)
12615 block_set_scope (block
, determine_prefix (die
, cu
),
12616 &objfile
->objfile_obstack
);
12618 /* If we have address ranges, record them. */
12619 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
12621 gdbarch_make_symbol_special (gdbarch
, newobj
->name
, objfile
);
12623 /* Attach template arguments to function. */
12624 if (!template_args
.empty ())
12626 gdb_assert (templ_func
!= NULL
);
12628 templ_func
->n_template_arguments
= template_args
.size ();
12629 templ_func
->template_arguments
12630 = XOBNEWVEC (&objfile
->objfile_obstack
, struct symbol
*,
12631 templ_func
->n_template_arguments
);
12632 memcpy (templ_func
->template_arguments
,
12633 template_args
.data (),
12634 (templ_func
->n_template_arguments
* sizeof (struct symbol
*)));
12637 /* In C++, we can have functions nested inside functions (e.g., when
12638 a function declares a class that has methods). This means that
12639 when we finish processing a function scope, we may need to go
12640 back to building a containing block's symbol lists. */
12641 local_symbols
= newobj
->locals
;
12642 local_using_directives
= newobj
->local_using_directives
;
12644 /* If we've finished processing a top-level function, subsequent
12645 symbols go in the file symbol list. */
12646 if (outermost_context_p ())
12647 cu
->list_in_scope
= &file_symbols
;
12650 /* Process all the DIES contained within a lexical block scope. Start
12651 a new scope, process the dies, and then close the scope. */
12654 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
12656 struct objfile
*objfile
= cu
->objfile
;
12657 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
12658 struct context_stack
*newobj
;
12659 CORE_ADDR lowpc
, highpc
;
12660 struct die_info
*child_die
;
12661 CORE_ADDR baseaddr
;
12663 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
12665 /* Ignore blocks with missing or invalid low and high pc attributes. */
12666 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
12667 as multiple lexical blocks? Handling children in a sane way would
12668 be nasty. Might be easier to properly extend generic blocks to
12669 describe ranges. */
12670 switch (dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
12672 case PC_BOUNDS_NOT_PRESENT
:
12673 /* DW_TAG_lexical_block has no attributes, process its children as if
12674 there was no wrapping by that DW_TAG_lexical_block.
12675 GCC does no longer produces such DWARF since GCC r224161. */
12676 for (child_die
= die
->child
;
12677 child_die
!= NULL
&& child_die
->tag
;
12678 child_die
= sibling_die (child_die
))
12679 process_die (child_die
, cu
);
12681 case PC_BOUNDS_INVALID
:
12684 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
12685 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
12687 push_context (0, lowpc
);
12688 if (die
->child
!= NULL
)
12690 child_die
= die
->child
;
12691 while (child_die
&& child_die
->tag
)
12693 process_die (child_die
, cu
);
12694 child_die
= sibling_die (child_die
);
12697 inherit_abstract_dies (die
, cu
);
12698 newobj
= pop_context ();
12700 if (local_symbols
!= NULL
|| local_using_directives
!= NULL
)
12702 struct block
*block
12703 = finish_block (0, &local_symbols
, newobj
->old_blocks
, NULL
,
12704 newobj
->start_addr
, highpc
);
12706 /* Note that recording ranges after traversing children, as we
12707 do here, means that recording a parent's ranges entails
12708 walking across all its children's ranges as they appear in
12709 the address map, which is quadratic behavior.
12711 It would be nicer to record the parent's ranges before
12712 traversing its children, simply overriding whatever you find
12713 there. But since we don't even decide whether to create a
12714 block until after we've traversed its children, that's hard
12716 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
12718 local_symbols
= newobj
->locals
;
12719 local_using_directives
= newobj
->local_using_directives
;
12722 /* Read in DW_TAG_call_site and insert it to CU->call_site_htab. */
12725 read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
12727 struct objfile
*objfile
= cu
->objfile
;
12728 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
12729 CORE_ADDR pc
, baseaddr
;
12730 struct attribute
*attr
;
12731 struct call_site
*call_site
, call_site_local
;
12734 struct die_info
*child_die
;
12736 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
12738 attr
= dwarf2_attr (die
, DW_AT_call_return_pc
, cu
);
12741 /* This was a pre-DWARF-5 GNU extension alias
12742 for DW_AT_call_return_pc. */
12743 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
12747 complaint (&symfile_complaints
,
12748 _("missing DW_AT_call_return_pc for DW_TAG_call_site "
12749 "DIE 0x%x [in module %s]"),
12750 to_underlying (die
->sect_off
), objfile_name (objfile
));
12753 pc
= attr_value_as_address (attr
) + baseaddr
;
12754 pc
= gdbarch_adjust_dwarf2_addr (gdbarch
, pc
);
12756 if (cu
->call_site_htab
== NULL
)
12757 cu
->call_site_htab
= htab_create_alloc_ex (16, core_addr_hash
, core_addr_eq
,
12758 NULL
, &objfile
->objfile_obstack
,
12759 hashtab_obstack_allocate
, NULL
);
12760 call_site_local
.pc
= pc
;
12761 slot
= htab_find_slot (cu
->call_site_htab
, &call_site_local
, INSERT
);
12764 complaint (&symfile_complaints
,
12765 _("Duplicate PC %s for DW_TAG_call_site "
12766 "DIE 0x%x [in module %s]"),
12767 paddress (gdbarch
, pc
), to_underlying (die
->sect_off
),
12768 objfile_name (objfile
));
12772 /* Count parameters at the caller. */
12775 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
12776 child_die
= sibling_die (child_die
))
12778 if (child_die
->tag
!= DW_TAG_call_site_parameter
12779 && child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
12781 complaint (&symfile_complaints
,
12782 _("Tag %d is not DW_TAG_call_site_parameter in "
12783 "DW_TAG_call_site child DIE 0x%x [in module %s]"),
12784 child_die
->tag
, to_underlying (child_die
->sect_off
),
12785 objfile_name (objfile
));
12793 = ((struct call_site
*)
12794 obstack_alloc (&objfile
->objfile_obstack
,
12795 sizeof (*call_site
)
12796 + (sizeof (*call_site
->parameter
) * (nparams
- 1))));
12798 memset (call_site
, 0, sizeof (*call_site
) - sizeof (*call_site
->parameter
));
12799 call_site
->pc
= pc
;
12801 if (dwarf2_flag_true_p (die
, DW_AT_call_tail_call
, cu
)
12802 || dwarf2_flag_true_p (die
, DW_AT_GNU_tail_call
, cu
))
12804 struct die_info
*func_die
;
12806 /* Skip also over DW_TAG_inlined_subroutine. */
12807 for (func_die
= die
->parent
;
12808 func_die
&& func_die
->tag
!= DW_TAG_subprogram
12809 && func_die
->tag
!= DW_TAG_subroutine_type
;
12810 func_die
= func_die
->parent
);
12812 /* DW_AT_call_all_calls is a superset
12813 of DW_AT_call_all_tail_calls. */
12815 && !dwarf2_flag_true_p (func_die
, DW_AT_call_all_calls
, cu
)
12816 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_call_sites
, cu
)
12817 && !dwarf2_flag_true_p (func_die
, DW_AT_call_all_tail_calls
, cu
)
12818 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_tail_call_sites
, cu
))
12820 /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
12821 not complete. But keep CALL_SITE for look ups via call_site_htab,
12822 both the initial caller containing the real return address PC and
12823 the final callee containing the current PC of a chain of tail
12824 calls do not need to have the tail call list complete. But any
12825 function candidate for a virtual tail call frame searched via
12826 TYPE_TAIL_CALL_LIST must have the tail call list complete to be
12827 determined unambiguously. */
12831 struct type
*func_type
= NULL
;
12834 func_type
= get_die_type (func_die
, cu
);
12835 if (func_type
!= NULL
)
12837 gdb_assert (TYPE_CODE (func_type
) == TYPE_CODE_FUNC
);
12839 /* Enlist this call site to the function. */
12840 call_site
->tail_call_next
= TYPE_TAIL_CALL_LIST (func_type
);
12841 TYPE_TAIL_CALL_LIST (func_type
) = call_site
;
12844 complaint (&symfile_complaints
,
12845 _("Cannot find function owning DW_TAG_call_site "
12846 "DIE 0x%x [in module %s]"),
12847 to_underlying (die
->sect_off
), objfile_name (objfile
));
12851 attr
= dwarf2_attr (die
, DW_AT_call_target
, cu
);
12853 attr
= dwarf2_attr (die
, DW_AT_GNU_call_site_target
, cu
);
12855 attr
= dwarf2_attr (die
, DW_AT_call_origin
, cu
);
12858 /* This was a pre-DWARF-5 GNU extension alias for DW_AT_call_origin. */
12859 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
12861 SET_FIELD_DWARF_BLOCK (call_site
->target
, NULL
);
12862 if (!attr
|| (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0))
12863 /* Keep NULL DWARF_BLOCK. */;
12864 else if (attr_form_is_block (attr
))
12866 struct dwarf2_locexpr_baton
*dlbaton
;
12868 dlbaton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
12869 dlbaton
->data
= DW_BLOCK (attr
)->data
;
12870 dlbaton
->size
= DW_BLOCK (attr
)->size
;
12871 dlbaton
->per_cu
= cu
->per_cu
;
12873 SET_FIELD_DWARF_BLOCK (call_site
->target
, dlbaton
);
12875 else if (attr_form_is_ref (attr
))
12877 struct dwarf2_cu
*target_cu
= cu
;
12878 struct die_info
*target_die
;
12880 target_die
= follow_die_ref (die
, attr
, &target_cu
);
12881 gdb_assert (target_cu
->objfile
== objfile
);
12882 if (die_is_declaration (target_die
, target_cu
))
12884 const char *target_physname
;
12886 /* Prefer the mangled name; otherwise compute the demangled one. */
12887 target_physname
= dw2_linkage_name (target_die
, target_cu
);
12888 if (target_physname
== NULL
)
12889 target_physname
= dwarf2_physname (NULL
, target_die
, target_cu
);
12890 if (target_physname
== NULL
)
12891 complaint (&symfile_complaints
,
12892 _("DW_AT_call_target target DIE has invalid "
12893 "physname, for referencing DIE 0x%x [in module %s]"),
12894 to_underlying (die
->sect_off
), objfile_name (objfile
));
12896 SET_FIELD_PHYSNAME (call_site
->target
, target_physname
);
12902 /* DW_AT_entry_pc should be preferred. */
12903 if (dwarf2_get_pc_bounds (target_die
, &lowpc
, NULL
, target_cu
, NULL
)
12904 <= PC_BOUNDS_INVALID
)
12905 complaint (&symfile_complaints
,
12906 _("DW_AT_call_target target DIE has invalid "
12907 "low pc, for referencing DIE 0x%x [in module %s]"),
12908 to_underlying (die
->sect_off
), objfile_name (objfile
));
12911 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
12912 SET_FIELD_PHYSADDR (call_site
->target
, lowpc
);
12917 complaint (&symfile_complaints
,
12918 _("DW_TAG_call_site DW_AT_call_target is neither "
12919 "block nor reference, for DIE 0x%x [in module %s]"),
12920 to_underlying (die
->sect_off
), objfile_name (objfile
));
12922 call_site
->per_cu
= cu
->per_cu
;
12924 for (child_die
= die
->child
;
12925 child_die
&& child_die
->tag
;
12926 child_die
= sibling_die (child_die
))
12928 struct call_site_parameter
*parameter
;
12929 struct attribute
*loc
, *origin
;
12931 if (child_die
->tag
!= DW_TAG_call_site_parameter
12932 && child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
12934 /* Already printed the complaint above. */
12938 gdb_assert (call_site
->parameter_count
< nparams
);
12939 parameter
= &call_site
->parameter
[call_site
->parameter_count
];
12941 /* DW_AT_location specifies the register number or DW_AT_abstract_origin
12942 specifies DW_TAG_formal_parameter. Value of the data assumed for the
12943 register is contained in DW_AT_call_value. */
12945 loc
= dwarf2_attr (child_die
, DW_AT_location
, cu
);
12946 origin
= dwarf2_attr (child_die
, DW_AT_call_parameter
, cu
);
12947 if (origin
== NULL
)
12949 /* This was a pre-DWARF-5 GNU extension alias
12950 for DW_AT_call_parameter. */
12951 origin
= dwarf2_attr (child_die
, DW_AT_abstract_origin
, cu
);
12953 if (loc
== NULL
&& origin
!= NULL
&& attr_form_is_ref (origin
))
12955 parameter
->kind
= CALL_SITE_PARAMETER_PARAM_OFFSET
;
12957 sect_offset sect_off
12958 = (sect_offset
) dwarf2_get_ref_die_offset (origin
);
12959 if (!offset_in_cu_p (&cu
->header
, sect_off
))
12961 /* As DW_OP_GNU_parameter_ref uses CU-relative offset this
12962 binding can be done only inside one CU. Such referenced DIE
12963 therefore cannot be even moved to DW_TAG_partial_unit. */
12964 complaint (&symfile_complaints
,
12965 _("DW_AT_call_parameter offset is not in CU for "
12966 "DW_TAG_call_site child DIE 0x%x [in module %s]"),
12967 to_underlying (child_die
->sect_off
),
12968 objfile_name (objfile
));
12971 parameter
->u
.param_cu_off
12972 = (cu_offset
) (sect_off
- cu
->header
.sect_off
);
12974 else if (loc
== NULL
|| origin
!= NULL
|| !attr_form_is_block (loc
))
12976 complaint (&symfile_complaints
,
12977 _("No DW_FORM_block* DW_AT_location for "
12978 "DW_TAG_call_site child DIE 0x%x [in module %s]"),
12979 to_underlying (child_die
->sect_off
), objfile_name (objfile
));
12984 parameter
->u
.dwarf_reg
= dwarf_block_to_dwarf_reg
12985 (DW_BLOCK (loc
)->data
, &DW_BLOCK (loc
)->data
[DW_BLOCK (loc
)->size
]);
12986 if (parameter
->u
.dwarf_reg
!= -1)
12987 parameter
->kind
= CALL_SITE_PARAMETER_DWARF_REG
;
12988 else if (dwarf_block_to_sp_offset (gdbarch
, DW_BLOCK (loc
)->data
,
12989 &DW_BLOCK (loc
)->data
[DW_BLOCK (loc
)->size
],
12990 ¶meter
->u
.fb_offset
))
12991 parameter
->kind
= CALL_SITE_PARAMETER_FB_OFFSET
;
12994 complaint (&symfile_complaints
,
12995 _("Only single DW_OP_reg or DW_OP_fbreg is supported "
12996 "for DW_FORM_block* DW_AT_location is supported for "
12997 "DW_TAG_call_site child DIE 0x%x "
12999 to_underlying (child_die
->sect_off
),
13000 objfile_name (objfile
));
13005 attr
= dwarf2_attr (child_die
, DW_AT_call_value
, cu
);
13007 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_value
, cu
);
13008 if (!attr_form_is_block (attr
))
13010 complaint (&symfile_complaints
,
13011 _("No DW_FORM_block* DW_AT_call_value for "
13012 "DW_TAG_call_site child DIE 0x%x [in module %s]"),
13013 to_underlying (child_die
->sect_off
),
13014 objfile_name (objfile
));
13017 parameter
->value
= DW_BLOCK (attr
)->data
;
13018 parameter
->value_size
= DW_BLOCK (attr
)->size
;
13020 /* Parameters are not pre-cleared by memset above. */
13021 parameter
->data_value
= NULL
;
13022 parameter
->data_value_size
= 0;
13023 call_site
->parameter_count
++;
13025 attr
= dwarf2_attr (child_die
, DW_AT_call_data_value
, cu
);
13027 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_data_value
, cu
);
13030 if (!attr_form_is_block (attr
))
13031 complaint (&symfile_complaints
,
13032 _("No DW_FORM_block* DW_AT_call_data_value for "
13033 "DW_TAG_call_site child DIE 0x%x [in module %s]"),
13034 to_underlying (child_die
->sect_off
),
13035 objfile_name (objfile
));
13038 parameter
->data_value
= DW_BLOCK (attr
)->data
;
13039 parameter
->data_value_size
= DW_BLOCK (attr
)->size
;
13045 /* Helper function for read_variable. If DIE represents a virtual
13046 table, then return the type of the concrete object that is
13047 associated with the virtual table. Otherwise, return NULL. */
13049 static struct type
*
13050 rust_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
13052 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
13056 /* Find the type DIE. */
13057 struct die_info
*type_die
= NULL
;
13058 struct dwarf2_cu
*type_cu
= cu
;
13060 if (attr_form_is_ref (attr
))
13061 type_die
= follow_die_ref (die
, attr
, &type_cu
);
13062 if (type_die
== NULL
)
13065 if (dwarf2_attr (type_die
, DW_AT_containing_type
, type_cu
) == NULL
)
13067 return die_containing_type (type_die
, type_cu
);
13070 /* Read a variable (DW_TAG_variable) DIE and create a new symbol. */
13073 read_variable (struct die_info
*die
, struct dwarf2_cu
*cu
)
13075 struct rust_vtable_symbol
*storage
= NULL
;
13077 if (cu
->language
== language_rust
)
13079 struct type
*containing_type
= rust_containing_type (die
, cu
);
13081 if (containing_type
!= NULL
)
13083 struct objfile
*objfile
= cu
->objfile
;
13085 storage
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
13086 struct rust_vtable_symbol
);
13087 initialize_objfile_symbol (storage
);
13088 storage
->concrete_type
= containing_type
;
13089 storage
->subclass
= SYMBOL_RUST_VTABLE
;
13093 new_symbol_full (die
, NULL
, cu
, storage
);
13096 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET
13097 reading .debug_rnglists.
13098 Callback's type should be:
13099 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
13100 Return true if the attributes are present and valid, otherwise,
13103 template <typename Callback
>
13105 dwarf2_rnglists_process (unsigned offset
, struct dwarf2_cu
*cu
,
13106 Callback
&&callback
)
13108 struct objfile
*objfile
= cu
->objfile
;
13109 bfd
*obfd
= objfile
->obfd
;
13110 /* Base address selection entry. */
13113 const gdb_byte
*buffer
;
13114 CORE_ADDR baseaddr
;
13115 bool overflow
= false;
13117 found_base
= cu
->base_known
;
13118 base
= cu
->base_address
;
13120 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->rnglists
);
13121 if (offset
>= dwarf2_per_objfile
->rnglists
.size
)
13123 complaint (&symfile_complaints
,
13124 _("Offset %d out of bounds for DW_AT_ranges attribute"),
13128 buffer
= dwarf2_per_objfile
->rnglists
.buffer
+ offset
;
13130 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
13134 /* Initialize it due to a false compiler warning. */
13135 CORE_ADDR range_beginning
= 0, range_end
= 0;
13136 const gdb_byte
*buf_end
= (dwarf2_per_objfile
->rnglists
.buffer
13137 + dwarf2_per_objfile
->rnglists
.size
);
13138 unsigned int bytes_read
;
13140 if (buffer
== buf_end
)
13145 const auto rlet
= static_cast<enum dwarf_range_list_entry
>(*buffer
++);
13148 case DW_RLE_end_of_list
:
13150 case DW_RLE_base_address
:
13151 if (buffer
+ cu
->header
.addr_size
> buf_end
)
13156 base
= read_address (obfd
, buffer
, cu
, &bytes_read
);
13158 buffer
+= bytes_read
;
13160 case DW_RLE_start_length
:
13161 if (buffer
+ cu
->header
.addr_size
> buf_end
)
13166 range_beginning
= read_address (obfd
, buffer
, cu
, &bytes_read
);
13167 buffer
+= bytes_read
;
13168 range_end
= (range_beginning
13169 + read_unsigned_leb128 (obfd
, buffer
, &bytes_read
));
13170 buffer
+= bytes_read
;
13171 if (buffer
> buf_end
)
13177 case DW_RLE_offset_pair
:
13178 range_beginning
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
13179 buffer
+= bytes_read
;
13180 if (buffer
> buf_end
)
13185 range_end
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
13186 buffer
+= bytes_read
;
13187 if (buffer
> buf_end
)
13193 case DW_RLE_start_end
:
13194 if (buffer
+ 2 * cu
->header
.addr_size
> buf_end
)
13199 range_beginning
= read_address (obfd
, buffer
, cu
, &bytes_read
);
13200 buffer
+= bytes_read
;
13201 range_end
= read_address (obfd
, buffer
, cu
, &bytes_read
);
13202 buffer
+= bytes_read
;
13205 complaint (&symfile_complaints
,
13206 _("Invalid .debug_rnglists data (no base address)"));
13209 if (rlet
== DW_RLE_end_of_list
|| overflow
)
13211 if (rlet
== DW_RLE_base_address
)
13216 /* We have no valid base address for the ranges
13218 complaint (&symfile_complaints
,
13219 _("Invalid .debug_rnglists data (no base address)"));
13223 if (range_beginning
> range_end
)
13225 /* Inverted range entries are invalid. */
13226 complaint (&symfile_complaints
,
13227 _("Invalid .debug_rnglists data (inverted range)"));
13231 /* Empty range entries have no effect. */
13232 if (range_beginning
== range_end
)
13235 range_beginning
+= base
;
13238 /* A not-uncommon case of bad debug info.
13239 Don't pollute the addrmap with bad data. */
13240 if (range_beginning
+ baseaddr
== 0
13241 && !dwarf2_per_objfile
->has_section_at_zero
)
13243 complaint (&symfile_complaints
,
13244 _(".debug_rnglists entry has start address of zero"
13245 " [in module %s]"), objfile_name (objfile
));
13249 callback (range_beginning
, range_end
);
13254 complaint (&symfile_complaints
,
13255 _("Offset %d is not terminated "
13256 "for DW_AT_ranges attribute"),
13264 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET reading .debug_ranges.
13265 Callback's type should be:
13266 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
13267 Return 1 if the attributes are present and valid, otherwise, return 0. */
13269 template <typename Callback
>
13271 dwarf2_ranges_process (unsigned offset
, struct dwarf2_cu
*cu
,
13272 Callback
&&callback
)
13274 struct objfile
*objfile
= cu
->objfile
;
13275 struct comp_unit_head
*cu_header
= &cu
->header
;
13276 bfd
*obfd
= objfile
->obfd
;
13277 unsigned int addr_size
= cu_header
->addr_size
;
13278 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
13279 /* Base address selection entry. */
13282 unsigned int dummy
;
13283 const gdb_byte
*buffer
;
13284 CORE_ADDR baseaddr
;
13286 if (cu_header
->version
>= 5)
13287 return dwarf2_rnglists_process (offset
, cu
, callback
);
13289 found_base
= cu
->base_known
;
13290 base
= cu
->base_address
;
13292 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->ranges
);
13293 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
13295 complaint (&symfile_complaints
,
13296 _("Offset %d out of bounds for DW_AT_ranges attribute"),
13300 buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
13302 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
13306 CORE_ADDR range_beginning
, range_end
;
13308 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
13309 buffer
+= addr_size
;
13310 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
13311 buffer
+= addr_size
;
13312 offset
+= 2 * addr_size
;
13314 /* An end of list marker is a pair of zero addresses. */
13315 if (range_beginning
== 0 && range_end
== 0)
13316 /* Found the end of list entry. */
13319 /* Each base address selection entry is a pair of 2 values.
13320 The first is the largest possible address, the second is
13321 the base address. Check for a base address here. */
13322 if ((range_beginning
& mask
) == mask
)
13324 /* If we found the largest possible address, then we already
13325 have the base address in range_end. */
13333 /* We have no valid base address for the ranges
13335 complaint (&symfile_complaints
,
13336 _("Invalid .debug_ranges data (no base address)"));
13340 if (range_beginning
> range_end
)
13342 /* Inverted range entries are invalid. */
13343 complaint (&symfile_complaints
,
13344 _("Invalid .debug_ranges data (inverted range)"));
13348 /* Empty range entries have no effect. */
13349 if (range_beginning
== range_end
)
13352 range_beginning
+= base
;
13355 /* A not-uncommon case of bad debug info.
13356 Don't pollute the addrmap with bad data. */
13357 if (range_beginning
+ baseaddr
== 0
13358 && !dwarf2_per_objfile
->has_section_at_zero
)
13360 complaint (&symfile_complaints
,
13361 _(".debug_ranges entry has start address of zero"
13362 " [in module %s]"), objfile_name (objfile
));
13366 callback (range_beginning
, range_end
);
13372 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
13373 Return 1 if the attributes are present and valid, otherwise, return 0.
13374 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
13377 dwarf2_ranges_read (unsigned offset
, CORE_ADDR
*low_return
,
13378 CORE_ADDR
*high_return
, struct dwarf2_cu
*cu
,
13379 struct partial_symtab
*ranges_pst
)
13381 struct objfile
*objfile
= cu
->objfile
;
13382 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
13383 const CORE_ADDR baseaddr
= ANOFFSET (objfile
->section_offsets
,
13384 SECT_OFF_TEXT (objfile
));
13387 CORE_ADDR high
= 0;
13390 retval
= dwarf2_ranges_process (offset
, cu
,
13391 [&] (CORE_ADDR range_beginning
, CORE_ADDR range_end
)
13393 if (ranges_pst
!= NULL
)
13398 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
,
13399 range_beginning
+ baseaddr
);
13400 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
,
13401 range_end
+ baseaddr
);
13402 addrmap_set_empty (objfile
->psymtabs_addrmap
, lowpc
, highpc
- 1,
13406 /* FIXME: This is recording everything as a low-high
13407 segment of consecutive addresses. We should have a
13408 data structure for discontiguous block ranges
13412 low
= range_beginning
;
13418 if (range_beginning
< low
)
13419 low
= range_beginning
;
13420 if (range_end
> high
)
13428 /* If the first entry is an end-of-list marker, the range
13429 describes an empty scope, i.e. no instructions. */
13435 *high_return
= high
;
13439 /* Get low and high pc attributes from a die. See enum pc_bounds_kind
13440 definition for the return value. *LOWPC and *HIGHPC are set iff
13441 neither PC_BOUNDS_NOT_PRESENT nor PC_BOUNDS_INVALID are returned. */
13443 static enum pc_bounds_kind
13444 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
13445 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
,
13446 struct partial_symtab
*pst
)
13448 struct attribute
*attr
;
13449 struct attribute
*attr_high
;
13451 CORE_ADDR high
= 0;
13452 enum pc_bounds_kind ret
;
13454 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
13457 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
13460 low
= attr_value_as_address (attr
);
13461 high
= attr_value_as_address (attr_high
);
13462 if (cu
->header
.version
>= 4 && attr_form_is_constant (attr_high
))
13466 /* Found high w/o low attribute. */
13467 return PC_BOUNDS_INVALID
;
13469 /* Found consecutive range of addresses. */
13470 ret
= PC_BOUNDS_HIGH_LOW
;
13474 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
13477 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
13478 We take advantage of the fact that DW_AT_ranges does not appear
13479 in DW_TAG_compile_unit of DWO files. */
13480 int need_ranges_base
= die
->tag
!= DW_TAG_compile_unit
;
13481 unsigned int ranges_offset
= (DW_UNSND (attr
)
13482 + (need_ranges_base
13486 /* Value of the DW_AT_ranges attribute is the offset in the
13487 .debug_ranges section. */
13488 if (!dwarf2_ranges_read (ranges_offset
, &low
, &high
, cu
, pst
))
13489 return PC_BOUNDS_INVALID
;
13490 /* Found discontinuous range of addresses. */
13491 ret
= PC_BOUNDS_RANGES
;
13494 return PC_BOUNDS_NOT_PRESENT
;
13497 /* read_partial_die has also the strict LOW < HIGH requirement. */
13499 return PC_BOUNDS_INVALID
;
13501 /* When using the GNU linker, .gnu.linkonce. sections are used to
13502 eliminate duplicate copies of functions and vtables and such.
13503 The linker will arbitrarily choose one and discard the others.
13504 The AT_*_pc values for such functions refer to local labels in
13505 these sections. If the section from that file was discarded, the
13506 labels are not in the output, so the relocs get a value of 0.
13507 If this is a discarded function, mark the pc bounds as invalid,
13508 so that GDB will ignore it. */
13509 if (low
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
13510 return PC_BOUNDS_INVALID
;
13518 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
13519 its low and high PC addresses. Do nothing if these addresses could not
13520 be determined. Otherwise, set LOWPC to the low address if it is smaller,
13521 and HIGHPC to the high address if greater than HIGHPC. */
13524 dwarf2_get_subprogram_pc_bounds (struct die_info
*die
,
13525 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
13526 struct dwarf2_cu
*cu
)
13528 CORE_ADDR low
, high
;
13529 struct die_info
*child
= die
->child
;
13531 if (dwarf2_get_pc_bounds (die
, &low
, &high
, cu
, NULL
) >= PC_BOUNDS_RANGES
)
13533 *lowpc
= std::min (*lowpc
, low
);
13534 *highpc
= std::max (*highpc
, high
);
13537 /* If the language does not allow nested subprograms (either inside
13538 subprograms or lexical blocks), we're done. */
13539 if (cu
->language
!= language_ada
)
13542 /* Check all the children of the given DIE. If it contains nested
13543 subprograms, then check their pc bounds. Likewise, we need to
13544 check lexical blocks as well, as they may also contain subprogram
13546 while (child
&& child
->tag
)
13548 if (child
->tag
== DW_TAG_subprogram
13549 || child
->tag
== DW_TAG_lexical_block
)
13550 dwarf2_get_subprogram_pc_bounds (child
, lowpc
, highpc
, cu
);
13551 child
= sibling_die (child
);
13555 /* Get the low and high pc's represented by the scope DIE, and store
13556 them in *LOWPC and *HIGHPC. If the correct values can't be
13557 determined, set *LOWPC to -1 and *HIGHPC to 0. */
13560 get_scope_pc_bounds (struct die_info
*die
,
13561 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
13562 struct dwarf2_cu
*cu
)
13564 CORE_ADDR best_low
= (CORE_ADDR
) -1;
13565 CORE_ADDR best_high
= (CORE_ADDR
) 0;
13566 CORE_ADDR current_low
, current_high
;
13568 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
, NULL
)
13569 >= PC_BOUNDS_RANGES
)
13571 best_low
= current_low
;
13572 best_high
= current_high
;
13576 struct die_info
*child
= die
->child
;
13578 while (child
&& child
->tag
)
13580 switch (child
->tag
) {
13581 case DW_TAG_subprogram
:
13582 dwarf2_get_subprogram_pc_bounds (child
, &best_low
, &best_high
, cu
);
13584 case DW_TAG_namespace
:
13585 case DW_TAG_module
:
13586 /* FIXME: carlton/2004-01-16: Should we do this for
13587 DW_TAG_class_type/DW_TAG_structure_type, too? I think
13588 that current GCC's always emit the DIEs corresponding
13589 to definitions of methods of classes as children of a
13590 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
13591 the DIEs giving the declarations, which could be
13592 anywhere). But I don't see any reason why the
13593 standards says that they have to be there. */
13594 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
13596 if (current_low
!= ((CORE_ADDR
) -1))
13598 best_low
= std::min (best_low
, current_low
);
13599 best_high
= std::max (best_high
, current_high
);
13607 child
= sibling_die (child
);
13612 *highpc
= best_high
;
13615 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
13619 dwarf2_record_block_ranges (struct die_info
*die
, struct block
*block
,
13620 CORE_ADDR baseaddr
, struct dwarf2_cu
*cu
)
13622 struct objfile
*objfile
= cu
->objfile
;
13623 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
13624 struct attribute
*attr
;
13625 struct attribute
*attr_high
;
13627 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
13630 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
13633 CORE_ADDR low
= attr_value_as_address (attr
);
13634 CORE_ADDR high
= attr_value_as_address (attr_high
);
13636 if (cu
->header
.version
>= 4 && attr_form_is_constant (attr_high
))
13639 low
= gdbarch_adjust_dwarf2_addr (gdbarch
, low
+ baseaddr
);
13640 high
= gdbarch_adjust_dwarf2_addr (gdbarch
, high
+ baseaddr
);
13641 record_block_range (block
, low
, high
- 1);
13645 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
13648 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
13649 We take advantage of the fact that DW_AT_ranges does not appear
13650 in DW_TAG_compile_unit of DWO files. */
13651 int need_ranges_base
= die
->tag
!= DW_TAG_compile_unit
;
13653 /* The value of the DW_AT_ranges attribute is the offset of the
13654 address range list in the .debug_ranges section. */
13655 unsigned long offset
= (DW_UNSND (attr
)
13656 + (need_ranges_base
? cu
->ranges_base
: 0));
13657 const gdb_byte
*buffer
;
13659 /* For some target architectures, but not others, the
13660 read_address function sign-extends the addresses it returns.
13661 To recognize base address selection entries, we need a
13663 unsigned int addr_size
= cu
->header
.addr_size
;
13664 CORE_ADDR base_select_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
13666 /* The base address, to which the next pair is relative. Note
13667 that this 'base' is a DWARF concept: most entries in a range
13668 list are relative, to reduce the number of relocs against the
13669 debugging information. This is separate from this function's
13670 'baseaddr' argument, which GDB uses to relocate debugging
13671 information from a shared library based on the address at
13672 which the library was loaded. */
13673 CORE_ADDR base
= cu
->base_address
;
13674 int base_known
= cu
->base_known
;
13676 dwarf2_ranges_process (offset
, cu
,
13677 [&] (CORE_ADDR start
, CORE_ADDR end
)
13681 start
= gdbarch_adjust_dwarf2_addr (gdbarch
, start
);
13682 end
= gdbarch_adjust_dwarf2_addr (gdbarch
, end
);
13683 record_block_range (block
, start
, end
- 1);
13688 /* Check whether the producer field indicates either of GCC < 4.6, or the
13689 Intel C/C++ compiler, and cache the result in CU. */
13692 check_producer (struct dwarf2_cu
*cu
)
13696 if (cu
->producer
== NULL
)
13698 /* For unknown compilers expect their behavior is DWARF version
13701 GCC started to support .debug_types sections by -gdwarf-4 since
13702 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
13703 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
13704 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
13705 interpreted incorrectly by GDB now - GCC PR debug/48229. */
13707 else if (producer_is_gcc (cu
->producer
, &major
, &minor
))
13709 cu
->producer_is_gxx_lt_4_6
= major
< 4 || (major
== 4 && minor
< 6);
13710 cu
->producer_is_gcc_lt_4_3
= major
< 4 || (major
== 4 && minor
< 3);
13712 else if (producer_is_icc (cu
->producer
, &major
, &minor
))
13713 cu
->producer_is_icc_lt_14
= major
< 14;
13716 /* For other non-GCC compilers, expect their behavior is DWARF version
13720 cu
->checked_producer
= 1;
13723 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
13724 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
13725 during 4.6.0 experimental. */
13728 producer_is_gxx_lt_4_6 (struct dwarf2_cu
*cu
)
13730 if (!cu
->checked_producer
)
13731 check_producer (cu
);
13733 return cu
->producer_is_gxx_lt_4_6
;
13736 /* Return the default accessibility type if it is not overriden by
13737 DW_AT_accessibility. */
13739 static enum dwarf_access_attribute
13740 dwarf2_default_access_attribute (struct die_info
*die
, struct dwarf2_cu
*cu
)
13742 if (cu
->header
.version
< 3 || producer_is_gxx_lt_4_6 (cu
))
13744 /* The default DWARF 2 accessibility for members is public, the default
13745 accessibility for inheritance is private. */
13747 if (die
->tag
!= DW_TAG_inheritance
)
13748 return DW_ACCESS_public
;
13750 return DW_ACCESS_private
;
13754 /* DWARF 3+ defines the default accessibility a different way. The same
13755 rules apply now for DW_TAG_inheritance as for the members and it only
13756 depends on the container kind. */
13758 if (die
->parent
->tag
== DW_TAG_class_type
)
13759 return DW_ACCESS_private
;
13761 return DW_ACCESS_public
;
13765 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
13766 offset. If the attribute was not found return 0, otherwise return
13767 1. If it was found but could not properly be handled, set *OFFSET
13771 handle_data_member_location (struct die_info
*die
, struct dwarf2_cu
*cu
,
13774 struct attribute
*attr
;
13776 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
13781 /* Note that we do not check for a section offset first here.
13782 This is because DW_AT_data_member_location is new in DWARF 4,
13783 so if we see it, we can assume that a constant form is really
13784 a constant and not a section offset. */
13785 if (attr_form_is_constant (attr
))
13786 *offset
= dwarf2_get_attr_constant_value (attr
, 0);
13787 else if (attr_form_is_section_offset (attr
))
13788 dwarf2_complex_location_expr_complaint ();
13789 else if (attr_form_is_block (attr
))
13790 *offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
13792 dwarf2_complex_location_expr_complaint ();
13800 /* Add an aggregate field to the field list. */
13803 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
13804 struct dwarf2_cu
*cu
)
13806 struct objfile
*objfile
= cu
->objfile
;
13807 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
13808 struct nextfield
*new_field
;
13809 struct attribute
*attr
;
13811 const char *fieldname
= "";
13813 /* Allocate a new field list entry and link it in. */
13814 new_field
= XNEW (struct nextfield
);
13815 make_cleanup (xfree
, new_field
);
13816 memset (new_field
, 0, sizeof (struct nextfield
));
13818 if (die
->tag
== DW_TAG_inheritance
)
13820 new_field
->next
= fip
->baseclasses
;
13821 fip
->baseclasses
= new_field
;
13825 new_field
->next
= fip
->fields
;
13826 fip
->fields
= new_field
;
13830 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
13832 new_field
->accessibility
= DW_UNSND (attr
);
13834 new_field
->accessibility
= dwarf2_default_access_attribute (die
, cu
);
13835 if (new_field
->accessibility
!= DW_ACCESS_public
)
13836 fip
->non_public_fields
= 1;
13838 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
13840 new_field
->virtuality
= DW_UNSND (attr
);
13842 new_field
->virtuality
= DW_VIRTUALITY_none
;
13844 fp
= &new_field
->field
;
13846 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
13850 /* Data member other than a C++ static data member. */
13852 /* Get type of field. */
13853 fp
->type
= die_type (die
, cu
);
13855 SET_FIELD_BITPOS (*fp
, 0);
13857 /* Get bit size of field (zero if none). */
13858 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
13861 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
13865 FIELD_BITSIZE (*fp
) = 0;
13868 /* Get bit offset of field. */
13869 if (handle_data_member_location (die
, cu
, &offset
))
13870 SET_FIELD_BITPOS (*fp
, offset
* bits_per_byte
);
13871 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
13874 if (gdbarch_bits_big_endian (gdbarch
))
13876 /* For big endian bits, the DW_AT_bit_offset gives the
13877 additional bit offset from the MSB of the containing
13878 anonymous object to the MSB of the field. We don't
13879 have to do anything special since we don't need to
13880 know the size of the anonymous object. */
13881 SET_FIELD_BITPOS (*fp
, FIELD_BITPOS (*fp
) + DW_UNSND (attr
));
13885 /* For little endian bits, compute the bit offset to the
13886 MSB of the anonymous object, subtract off the number of
13887 bits from the MSB of the field to the MSB of the
13888 object, and then subtract off the number of bits of
13889 the field itself. The result is the bit offset of
13890 the LSB of the field. */
13891 int anonymous_size
;
13892 int bit_offset
= DW_UNSND (attr
);
13894 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
13897 /* The size of the anonymous object containing
13898 the bit field is explicit, so use the
13899 indicated size (in bytes). */
13900 anonymous_size
= DW_UNSND (attr
);
13904 /* The size of the anonymous object containing
13905 the bit field must be inferred from the type
13906 attribute of the data member containing the
13908 anonymous_size
= TYPE_LENGTH (fp
->type
);
13910 SET_FIELD_BITPOS (*fp
,
13911 (FIELD_BITPOS (*fp
)
13912 + anonymous_size
* bits_per_byte
13913 - bit_offset
- FIELD_BITSIZE (*fp
)));
13916 attr
= dwarf2_attr (die
, DW_AT_data_bit_offset
, cu
);
13918 SET_FIELD_BITPOS (*fp
, (FIELD_BITPOS (*fp
)
13919 + dwarf2_get_attr_constant_value (attr
, 0)));
13921 /* Get name of field. */
13922 fieldname
= dwarf2_name (die
, cu
);
13923 if (fieldname
== NULL
)
13926 /* The name is already allocated along with this objfile, so we don't
13927 need to duplicate it for the type. */
13928 fp
->name
= fieldname
;
13930 /* Change accessibility for artificial fields (e.g. virtual table
13931 pointer or virtual base class pointer) to private. */
13932 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
13934 FIELD_ARTIFICIAL (*fp
) = 1;
13935 new_field
->accessibility
= DW_ACCESS_private
;
13936 fip
->non_public_fields
= 1;
13939 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
13941 /* C++ static member. */
13943 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
13944 is a declaration, but all versions of G++ as of this writing
13945 (so through at least 3.2.1) incorrectly generate
13946 DW_TAG_variable tags. */
13948 const char *physname
;
13950 /* Get name of field. */
13951 fieldname
= dwarf2_name (die
, cu
);
13952 if (fieldname
== NULL
)
13955 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
13957 /* Only create a symbol if this is an external value.
13958 new_symbol checks this and puts the value in the global symbol
13959 table, which we want. If it is not external, new_symbol
13960 will try to put the value in cu->list_in_scope which is wrong. */
13961 && dwarf2_flag_true_p (die
, DW_AT_external
, cu
))
13963 /* A static const member, not much different than an enum as far as
13964 we're concerned, except that we can support more types. */
13965 new_symbol (die
, NULL
, cu
);
13968 /* Get physical name. */
13969 physname
= dwarf2_physname (fieldname
, die
, cu
);
13971 /* The name is already allocated along with this objfile, so we don't
13972 need to duplicate it for the type. */
13973 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
13974 FIELD_TYPE (*fp
) = die_type (die
, cu
);
13975 FIELD_NAME (*fp
) = fieldname
;
13977 else if (die
->tag
== DW_TAG_inheritance
)
13981 /* C++ base class field. */
13982 if (handle_data_member_location (die
, cu
, &offset
))
13983 SET_FIELD_BITPOS (*fp
, offset
* bits_per_byte
);
13984 FIELD_BITSIZE (*fp
) = 0;
13985 FIELD_TYPE (*fp
) = die_type (die
, cu
);
13986 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
13987 fip
->nbaseclasses
++;
13991 /* Add a typedef defined in the scope of the FIP's class. */
13994 dwarf2_add_typedef (struct field_info
*fip
, struct die_info
*die
,
13995 struct dwarf2_cu
*cu
)
13997 struct typedef_field_list
*new_field
;
13998 struct typedef_field
*fp
;
14000 /* Allocate a new field list entry and link it in. */
14001 new_field
= XCNEW (struct typedef_field_list
);
14002 make_cleanup (xfree
, new_field
);
14004 gdb_assert (die
->tag
== DW_TAG_typedef
);
14006 fp
= &new_field
->field
;
14008 /* Get name of field. */
14009 fp
->name
= dwarf2_name (die
, cu
);
14010 if (fp
->name
== NULL
)
14013 fp
->type
= read_type_die (die
, cu
);
14015 /* Save accessibility. */
14016 enum dwarf_access_attribute accessibility
;
14017 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
14019 accessibility
= (enum dwarf_access_attribute
) DW_UNSND (attr
);
14021 accessibility
= dwarf2_default_access_attribute (die
, cu
);
14022 switch (accessibility
)
14024 case DW_ACCESS_public
:
14025 /* The assumed value if neither private nor protected. */
14027 case DW_ACCESS_private
:
14028 fp
->is_private
= 1;
14030 case DW_ACCESS_protected
:
14031 fp
->is_protected
= 1;
14034 complaint (&symfile_complaints
,
14035 _("Unhandled DW_AT_accessibility value (%x)"), accessibility
);
14038 new_field
->next
= fip
->typedef_field_list
;
14039 fip
->typedef_field_list
= new_field
;
14040 fip
->typedef_field_list_count
++;
14043 /* Create the vector of fields, and attach it to the type. */
14046 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
14047 struct dwarf2_cu
*cu
)
14049 int nfields
= fip
->nfields
;
14051 /* Record the field count, allocate space for the array of fields,
14052 and create blank accessibility bitfields if necessary. */
14053 TYPE_NFIELDS (type
) = nfields
;
14054 TYPE_FIELDS (type
) = (struct field
*)
14055 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
14056 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
14058 if (fip
->non_public_fields
&& cu
->language
!= language_ada
)
14060 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
14062 TYPE_FIELD_PRIVATE_BITS (type
) =
14063 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
14064 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
14066 TYPE_FIELD_PROTECTED_BITS (type
) =
14067 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
14068 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
14070 TYPE_FIELD_IGNORE_BITS (type
) =
14071 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
14072 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
14075 /* If the type has baseclasses, allocate and clear a bit vector for
14076 TYPE_FIELD_VIRTUAL_BITS. */
14077 if (fip
->nbaseclasses
&& cu
->language
!= language_ada
)
14079 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
14080 unsigned char *pointer
;
14082 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
14083 pointer
= (unsigned char *) TYPE_ALLOC (type
, num_bytes
);
14084 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
14085 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
14086 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
14089 /* Copy the saved-up fields into the field vector. Start from the head of
14090 the list, adding to the tail of the field array, so that they end up in
14091 the same order in the array in which they were added to the list. */
14092 while (nfields
-- > 0)
14094 struct nextfield
*fieldp
;
14098 fieldp
= fip
->fields
;
14099 fip
->fields
= fieldp
->next
;
14103 fieldp
= fip
->baseclasses
;
14104 fip
->baseclasses
= fieldp
->next
;
14107 TYPE_FIELD (type
, nfields
) = fieldp
->field
;
14108 switch (fieldp
->accessibility
)
14110 case DW_ACCESS_private
:
14111 if (cu
->language
!= language_ada
)
14112 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
14115 case DW_ACCESS_protected
:
14116 if (cu
->language
!= language_ada
)
14117 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
14120 case DW_ACCESS_public
:
14124 /* Unknown accessibility. Complain and treat it as public. */
14126 complaint (&symfile_complaints
, _("unsupported accessibility %d"),
14127 fieldp
->accessibility
);
14131 if (nfields
< fip
->nbaseclasses
)
14133 switch (fieldp
->virtuality
)
14135 case DW_VIRTUALITY_virtual
:
14136 case DW_VIRTUALITY_pure_virtual
:
14137 if (cu
->language
== language_ada
)
14138 error (_("unexpected virtuality in component of Ada type"));
14139 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
14146 /* Return true if this member function is a constructor, false
14150 dwarf2_is_constructor (struct die_info
*die
, struct dwarf2_cu
*cu
)
14152 const char *fieldname
;
14153 const char *type_name
;
14156 if (die
->parent
== NULL
)
14159 if (die
->parent
->tag
!= DW_TAG_structure_type
14160 && die
->parent
->tag
!= DW_TAG_union_type
14161 && die
->parent
->tag
!= DW_TAG_class_type
)
14164 fieldname
= dwarf2_name (die
, cu
);
14165 type_name
= dwarf2_name (die
->parent
, cu
);
14166 if (fieldname
== NULL
|| type_name
== NULL
)
14169 len
= strlen (fieldname
);
14170 return (strncmp (fieldname
, type_name
, len
) == 0
14171 && (type_name
[len
] == '\0' || type_name
[len
] == '<'));
14174 /* Add a member function to the proper fieldlist. */
14177 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
14178 struct type
*type
, struct dwarf2_cu
*cu
)
14180 struct objfile
*objfile
= cu
->objfile
;
14181 struct attribute
*attr
;
14182 struct fnfieldlist
*flp
;
14184 struct fn_field
*fnp
;
14185 const char *fieldname
;
14186 struct nextfnfield
*new_fnfield
;
14187 struct type
*this_type
;
14188 enum dwarf_access_attribute accessibility
;
14190 if (cu
->language
== language_ada
)
14191 error (_("unexpected member function in Ada type"));
14193 /* Get name of member function. */
14194 fieldname
= dwarf2_name (die
, cu
);
14195 if (fieldname
== NULL
)
14198 /* Look up member function name in fieldlist. */
14199 for (i
= 0; i
< fip
->nfnfields
; i
++)
14201 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
14205 /* Create new list element if necessary. */
14206 if (i
< fip
->nfnfields
)
14207 flp
= &fip
->fnfieldlists
[i
];
14210 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
14212 fip
->fnfieldlists
= (struct fnfieldlist
*)
14213 xrealloc (fip
->fnfieldlists
,
14214 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
14215 * sizeof (struct fnfieldlist
));
14216 if (fip
->nfnfields
== 0)
14217 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
14219 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
14220 flp
->name
= fieldname
;
14223 i
= fip
->nfnfields
++;
14226 /* Create a new member function field and chain it to the field list
14228 new_fnfield
= XNEW (struct nextfnfield
);
14229 make_cleanup (xfree
, new_fnfield
);
14230 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
14231 new_fnfield
->next
= flp
->head
;
14232 flp
->head
= new_fnfield
;
14235 /* Fill in the member function field info. */
14236 fnp
= &new_fnfield
->fnfield
;
14238 /* Delay processing of the physname until later. */
14239 if (cu
->language
== language_cplus
)
14241 add_to_method_list (type
, i
, flp
->length
- 1, fieldname
,
14246 const char *physname
= dwarf2_physname (fieldname
, die
, cu
);
14247 fnp
->physname
= physname
? physname
: "";
14250 fnp
->type
= alloc_type (objfile
);
14251 this_type
= read_type_die (die
, cu
);
14252 if (this_type
&& TYPE_CODE (this_type
) == TYPE_CODE_FUNC
)
14254 int nparams
= TYPE_NFIELDS (this_type
);
14256 /* TYPE is the domain of this method, and THIS_TYPE is the type
14257 of the method itself (TYPE_CODE_METHOD). */
14258 smash_to_method_type (fnp
->type
, type
,
14259 TYPE_TARGET_TYPE (this_type
),
14260 TYPE_FIELDS (this_type
),
14261 TYPE_NFIELDS (this_type
),
14262 TYPE_VARARGS (this_type
));
14264 /* Handle static member functions.
14265 Dwarf2 has no clean way to discern C++ static and non-static
14266 member functions. G++ helps GDB by marking the first
14267 parameter for non-static member functions (which is the this
14268 pointer) as artificial. We obtain this information from
14269 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
14270 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (this_type
, 0) == 0)
14271 fnp
->voffset
= VOFFSET_STATIC
;
14274 complaint (&symfile_complaints
, _("member function type missing for '%s'"),
14275 dwarf2_full_name (fieldname
, die
, cu
));
14277 /* Get fcontext from DW_AT_containing_type if present. */
14278 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
14279 fnp
->fcontext
= die_containing_type (die
, cu
);
14281 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
14282 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
14284 /* Get accessibility. */
14285 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
14287 accessibility
= (enum dwarf_access_attribute
) DW_UNSND (attr
);
14289 accessibility
= dwarf2_default_access_attribute (die
, cu
);
14290 switch (accessibility
)
14292 case DW_ACCESS_private
:
14293 fnp
->is_private
= 1;
14295 case DW_ACCESS_protected
:
14296 fnp
->is_protected
= 1;
14300 /* Check for artificial methods. */
14301 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
14302 if (attr
&& DW_UNSND (attr
) != 0)
14303 fnp
->is_artificial
= 1;
14305 fnp
->is_constructor
= dwarf2_is_constructor (die
, cu
);
14307 /* Get index in virtual function table if it is a virtual member
14308 function. For older versions of GCC, this is an offset in the
14309 appropriate virtual table, as specified by DW_AT_containing_type.
14310 For everyone else, it is an expression to be evaluated relative
14311 to the object address. */
14313 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
14316 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
> 0)
14318 if (DW_BLOCK (attr
)->data
[0] == DW_OP_constu
)
14320 /* Old-style GCC. */
14321 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
14323 else if (DW_BLOCK (attr
)->data
[0] == DW_OP_deref
14324 || (DW_BLOCK (attr
)->size
> 1
14325 && DW_BLOCK (attr
)->data
[0] == DW_OP_deref_size
14326 && DW_BLOCK (attr
)->data
[1] == cu
->header
.addr_size
))
14328 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
);
14329 if ((fnp
->voffset
% cu
->header
.addr_size
) != 0)
14330 dwarf2_complex_location_expr_complaint ();
14332 fnp
->voffset
/= cu
->header
.addr_size
;
14336 dwarf2_complex_location_expr_complaint ();
14338 if (!fnp
->fcontext
)
14340 /* If there is no `this' field and no DW_AT_containing_type,
14341 we cannot actually find a base class context for the
14343 if (TYPE_NFIELDS (this_type
) == 0
14344 || !TYPE_FIELD_ARTIFICIAL (this_type
, 0))
14346 complaint (&symfile_complaints
,
14347 _("cannot determine context for virtual member "
14348 "function \"%s\" (offset %d)"),
14349 fieldname
, to_underlying (die
->sect_off
));
14354 = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type
, 0));
14358 else if (attr_form_is_section_offset (attr
))
14360 dwarf2_complex_location_expr_complaint ();
14364 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
14370 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
14371 if (attr
&& DW_UNSND (attr
))
14373 /* GCC does this, as of 2008-08-25; PR debug/37237. */
14374 complaint (&symfile_complaints
,
14375 _("Member function \"%s\" (offset %d) is virtual "
14376 "but the vtable offset is not specified"),
14377 fieldname
, to_underlying (die
->sect_off
));
14378 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
14379 TYPE_CPLUS_DYNAMIC (type
) = 1;
14384 /* Create the vector of member function fields, and attach it to the type. */
14387 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
14388 struct dwarf2_cu
*cu
)
14390 struct fnfieldlist
*flp
;
14393 if (cu
->language
== language_ada
)
14394 error (_("unexpected member functions in Ada type"));
14396 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
14397 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
14398 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
14400 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
14402 struct nextfnfield
*nfp
= flp
->head
;
14403 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
14406 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
14407 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
14408 fn_flp
->fn_fields
= (struct fn_field
*)
14409 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
14410 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
14411 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
14414 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
14417 /* Returns non-zero if NAME is the name of a vtable member in CU's
14418 language, zero otherwise. */
14420 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
14422 static const char vptr
[] = "_vptr";
14424 /* Look for the C++ form of the vtable. */
14425 if (startswith (name
, vptr
) && is_cplus_marker (name
[sizeof (vptr
) - 1]))
14431 /* GCC outputs unnamed structures that are really pointers to member
14432 functions, with the ABI-specified layout. If TYPE describes
14433 such a structure, smash it into a member function type.
14435 GCC shouldn't do this; it should just output pointer to member DIEs.
14436 This is GCC PR debug/28767. */
14439 quirk_gcc_member_function_pointer (struct type
*type
, struct objfile
*objfile
)
14441 struct type
*pfn_type
, *self_type
, *new_type
;
14443 /* Check for a structure with no name and two children. */
14444 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
|| TYPE_NFIELDS (type
) != 2)
14447 /* Check for __pfn and __delta members. */
14448 if (TYPE_FIELD_NAME (type
, 0) == NULL
14449 || strcmp (TYPE_FIELD_NAME (type
, 0), "__pfn") != 0
14450 || TYPE_FIELD_NAME (type
, 1) == NULL
14451 || strcmp (TYPE_FIELD_NAME (type
, 1), "__delta") != 0)
14454 /* Find the type of the method. */
14455 pfn_type
= TYPE_FIELD_TYPE (type
, 0);
14456 if (pfn_type
== NULL
14457 || TYPE_CODE (pfn_type
) != TYPE_CODE_PTR
14458 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type
)) != TYPE_CODE_FUNC
)
14461 /* Look for the "this" argument. */
14462 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
14463 if (TYPE_NFIELDS (pfn_type
) == 0
14464 /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
14465 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type
, 0)) != TYPE_CODE_PTR
)
14468 self_type
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type
, 0));
14469 new_type
= alloc_type (objfile
);
14470 smash_to_method_type (new_type
, self_type
, TYPE_TARGET_TYPE (pfn_type
),
14471 TYPE_FIELDS (pfn_type
), TYPE_NFIELDS (pfn_type
),
14472 TYPE_VARARGS (pfn_type
));
14473 smash_to_methodptr_type (type
, new_type
);
14477 /* Called when we find the DIE that starts a structure or union scope
14478 (definition) to create a type for the structure or union. Fill in
14479 the type's name and general properties; the members will not be
14480 processed until process_structure_scope. A symbol table entry for
14481 the type will also not be done until process_structure_scope (assuming
14482 the type has a name).
14484 NOTE: we need to call these functions regardless of whether or not the
14485 DIE has a DW_AT_name attribute, since it might be an anonymous
14486 structure or union. This gets the type entered into our set of
14487 user defined types. */
14489 static struct type
*
14490 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14492 struct objfile
*objfile
= cu
->objfile
;
14494 struct attribute
*attr
;
14497 /* If the definition of this type lives in .debug_types, read that type.
14498 Don't follow DW_AT_specification though, that will take us back up
14499 the chain and we want to go down. */
14500 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
);
14503 type
= get_DW_AT_signature_type (die
, attr
, cu
);
14505 /* The type's CU may not be the same as CU.
14506 Ensure TYPE is recorded with CU in die_type_hash. */
14507 return set_die_type (die
, type
, cu
);
14510 type
= alloc_type (objfile
);
14511 INIT_CPLUS_SPECIFIC (type
);
14513 name
= dwarf2_name (die
, cu
);
14516 if (cu
->language
== language_cplus
14517 || cu
->language
== language_d
14518 || cu
->language
== language_rust
)
14520 const char *full_name
= dwarf2_full_name (name
, die
, cu
);
14522 /* dwarf2_full_name might have already finished building the DIE's
14523 type. If so, there is no need to continue. */
14524 if (get_die_type (die
, cu
) != NULL
)
14525 return get_die_type (die
, cu
);
14527 TYPE_TAG_NAME (type
) = full_name
;
14528 if (die
->tag
== DW_TAG_structure_type
14529 || die
->tag
== DW_TAG_class_type
)
14530 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
14534 /* The name is already allocated along with this objfile, so
14535 we don't need to duplicate it for the type. */
14536 TYPE_TAG_NAME (type
) = name
;
14537 if (die
->tag
== DW_TAG_class_type
)
14538 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
14542 if (die
->tag
== DW_TAG_structure_type
)
14544 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
14546 else if (die
->tag
== DW_TAG_union_type
)
14548 TYPE_CODE (type
) = TYPE_CODE_UNION
;
14552 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
14555 if (cu
->language
== language_cplus
&& die
->tag
== DW_TAG_class_type
)
14556 TYPE_DECLARED_CLASS (type
) = 1;
14558 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
14561 if (attr_form_is_constant (attr
))
14562 TYPE_LENGTH (type
) = DW_UNSND (attr
);
14565 /* For the moment, dynamic type sizes are not supported
14566 by GDB's struct type. The actual size is determined
14567 on-demand when resolving the type of a given object,
14568 so set the type's length to zero for now. Otherwise,
14569 we record an expression as the length, and that expression
14570 could lead to a very large value, which could eventually
14571 lead to us trying to allocate that much memory when creating
14572 a value of that type. */
14573 TYPE_LENGTH (type
) = 0;
14578 TYPE_LENGTH (type
) = 0;
14581 if (producer_is_icc_lt_14 (cu
) && (TYPE_LENGTH (type
) == 0))
14583 /* ICC<14 does not output the required DW_AT_declaration on
14584 incomplete types, but gives them a size of zero. */
14585 TYPE_STUB (type
) = 1;
14588 TYPE_STUB_SUPPORTED (type
) = 1;
14590 if (die_is_declaration (die
, cu
))
14591 TYPE_STUB (type
) = 1;
14592 else if (attr
== NULL
&& die
->child
== NULL
14593 && producer_is_realview (cu
->producer
))
14594 /* RealView does not output the required DW_AT_declaration
14595 on incomplete types. */
14596 TYPE_STUB (type
) = 1;
14598 /* We need to add the type field to the die immediately so we don't
14599 infinitely recurse when dealing with pointers to the structure
14600 type within the structure itself. */
14601 set_die_type (die
, type
, cu
);
14603 /* set_die_type should be already done. */
14604 set_descriptive_type (type
, die
, cu
);
14609 /* Finish creating a structure or union type, including filling in
14610 its members and creating a symbol for it. */
14613 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
14615 struct objfile
*objfile
= cu
->objfile
;
14616 struct die_info
*child_die
;
14619 type
= get_die_type (die
, cu
);
14621 type
= read_structure_type (die
, cu
);
14623 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
14625 struct field_info fi
;
14626 std::vector
<struct symbol
*> template_args
;
14627 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
14629 memset (&fi
, 0, sizeof (struct field_info
));
14631 child_die
= die
->child
;
14633 while (child_die
&& child_die
->tag
)
14635 if (child_die
->tag
== DW_TAG_member
14636 || child_die
->tag
== DW_TAG_variable
)
14638 /* NOTE: carlton/2002-11-05: A C++ static data member
14639 should be a DW_TAG_member that is a declaration, but
14640 all versions of G++ as of this writing (so through at
14641 least 3.2.1) incorrectly generate DW_TAG_variable
14642 tags for them instead. */
14643 dwarf2_add_field (&fi
, child_die
, cu
);
14645 else if (child_die
->tag
== DW_TAG_subprogram
)
14647 /* Rust doesn't have member functions in the C++ sense.
14648 However, it does emit ordinary functions as children
14649 of a struct DIE. */
14650 if (cu
->language
== language_rust
)
14651 read_func_scope (child_die
, cu
);
14654 /* C++ member function. */
14655 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
14658 else if (child_die
->tag
== DW_TAG_inheritance
)
14660 /* C++ base class field. */
14661 dwarf2_add_field (&fi
, child_die
, cu
);
14663 else if (child_die
->tag
== DW_TAG_typedef
)
14664 dwarf2_add_typedef (&fi
, child_die
, cu
);
14665 else if (child_die
->tag
== DW_TAG_template_type_param
14666 || child_die
->tag
== DW_TAG_template_value_param
)
14668 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
14671 template_args
.push_back (arg
);
14674 child_die
= sibling_die (child_die
);
14677 /* Attach template arguments to type. */
14678 if (!template_args
.empty ())
14680 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
14681 TYPE_N_TEMPLATE_ARGUMENTS (type
) = template_args
.size ();
14682 TYPE_TEMPLATE_ARGUMENTS (type
)
14683 = XOBNEWVEC (&objfile
->objfile_obstack
,
14685 TYPE_N_TEMPLATE_ARGUMENTS (type
));
14686 memcpy (TYPE_TEMPLATE_ARGUMENTS (type
),
14687 template_args
.data (),
14688 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
14689 * sizeof (struct symbol
*)));
14692 /* Attach fields and member functions to the type. */
14694 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
14697 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
14699 /* Get the type which refers to the base class (possibly this
14700 class itself) which contains the vtable pointer for the current
14701 class from the DW_AT_containing_type attribute. This use of
14702 DW_AT_containing_type is a GNU extension. */
14704 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
14706 struct type
*t
= die_containing_type (die
, cu
);
14708 set_type_vptr_basetype (type
, t
);
14713 /* Our own class provides vtbl ptr. */
14714 for (i
= TYPE_NFIELDS (t
) - 1;
14715 i
>= TYPE_N_BASECLASSES (t
);
14718 const char *fieldname
= TYPE_FIELD_NAME (t
, i
);
14720 if (is_vtable_name (fieldname
, cu
))
14722 set_type_vptr_fieldno (type
, i
);
14727 /* Complain if virtual function table field not found. */
14728 if (i
< TYPE_N_BASECLASSES (t
))
14729 complaint (&symfile_complaints
,
14730 _("virtual function table pointer "
14731 "not found when defining class '%s'"),
14732 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
14737 set_type_vptr_fieldno (type
, TYPE_VPTR_FIELDNO (t
));
14740 else if (cu
->producer
14741 && startswith (cu
->producer
, "IBM(R) XL C/C++ Advanced Edition"))
14743 /* The IBM XLC compiler does not provide direct indication
14744 of the containing type, but the vtable pointer is
14745 always named __vfp. */
14749 for (i
= TYPE_NFIELDS (type
) - 1;
14750 i
>= TYPE_N_BASECLASSES (type
);
14753 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
14755 set_type_vptr_fieldno (type
, i
);
14756 set_type_vptr_basetype (type
, type
);
14763 /* Copy fi.typedef_field_list linked list elements content into the
14764 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
14765 if (fi
.typedef_field_list
)
14767 int i
= fi
.typedef_field_list_count
;
14769 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
14770 TYPE_TYPEDEF_FIELD_ARRAY (type
)
14771 = ((struct typedef_field
*)
14772 TYPE_ALLOC (type
, sizeof (TYPE_TYPEDEF_FIELD (type
, 0)) * i
));
14773 TYPE_TYPEDEF_FIELD_COUNT (type
) = i
;
14775 /* Reverse the list order to keep the debug info elements order. */
14778 struct typedef_field
*dest
, *src
;
14780 dest
= &TYPE_TYPEDEF_FIELD (type
, i
);
14781 src
= &fi
.typedef_field_list
->field
;
14782 fi
.typedef_field_list
= fi
.typedef_field_list
->next
;
14787 do_cleanups (back_to
);
14790 quirk_gcc_member_function_pointer (type
, objfile
);
14792 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
14793 snapshots) has been known to create a die giving a declaration
14794 for a class that has, as a child, a die giving a definition for a
14795 nested class. So we have to process our children even if the
14796 current die is a declaration. Normally, of course, a declaration
14797 won't have any children at all. */
14799 child_die
= die
->child
;
14801 while (child_die
!= NULL
&& child_die
->tag
)
14803 if (child_die
->tag
== DW_TAG_member
14804 || child_die
->tag
== DW_TAG_variable
14805 || child_die
->tag
== DW_TAG_inheritance
14806 || child_die
->tag
== DW_TAG_template_value_param
14807 || child_die
->tag
== DW_TAG_template_type_param
)
14812 process_die (child_die
, cu
);
14814 child_die
= sibling_die (child_die
);
14817 /* Do not consider external references. According to the DWARF standard,
14818 these DIEs are identified by the fact that they have no byte_size
14819 attribute, and a declaration attribute. */
14820 if (dwarf2_attr (die
, DW_AT_byte_size
, cu
) != NULL
14821 || !die_is_declaration (die
, cu
))
14822 new_symbol (die
, type
, cu
);
14825 /* Assuming DIE is an enumeration type, and TYPE is its associated type,
14826 update TYPE using some information only available in DIE's children. */
14829 update_enumeration_type_from_children (struct die_info
*die
,
14831 struct dwarf2_cu
*cu
)
14833 struct die_info
*child_die
;
14834 int unsigned_enum
= 1;
14838 auto_obstack obstack
;
14840 for (child_die
= die
->child
;
14841 child_die
!= NULL
&& child_die
->tag
;
14842 child_die
= sibling_die (child_die
))
14844 struct attribute
*attr
;
14846 const gdb_byte
*bytes
;
14847 struct dwarf2_locexpr_baton
*baton
;
14850 if (child_die
->tag
!= DW_TAG_enumerator
)
14853 attr
= dwarf2_attr (child_die
, DW_AT_const_value
, cu
);
14857 name
= dwarf2_name (child_die
, cu
);
14859 name
= "<anonymous enumerator>";
14861 dwarf2_const_value_attr (attr
, type
, name
, &obstack
, cu
,
14862 &value
, &bytes
, &baton
);
14868 else if ((mask
& value
) != 0)
14873 /* If we already know that the enum type is neither unsigned, nor
14874 a flag type, no need to look at the rest of the enumerates. */
14875 if (!unsigned_enum
&& !flag_enum
)
14880 TYPE_UNSIGNED (type
) = 1;
14882 TYPE_FLAG_ENUM (type
) = 1;
14885 /* Given a DW_AT_enumeration_type die, set its type. We do not
14886 complete the type's fields yet, or create any symbols. */
14888 static struct type
*
14889 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14891 struct objfile
*objfile
= cu
->objfile
;
14893 struct attribute
*attr
;
14896 /* If the definition of this type lives in .debug_types, read that type.
14897 Don't follow DW_AT_specification though, that will take us back up
14898 the chain and we want to go down. */
14899 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
);
14902 type
= get_DW_AT_signature_type (die
, attr
, cu
);
14904 /* The type's CU may not be the same as CU.
14905 Ensure TYPE is recorded with CU in die_type_hash. */
14906 return set_die_type (die
, type
, cu
);
14909 type
= alloc_type (objfile
);
14911 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
14912 name
= dwarf2_full_name (NULL
, die
, cu
);
14914 TYPE_TAG_NAME (type
) = name
;
14916 attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
14919 struct type
*underlying_type
= die_type (die
, cu
);
14921 TYPE_TARGET_TYPE (type
) = underlying_type
;
14924 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
14927 TYPE_LENGTH (type
) = DW_UNSND (attr
);
14931 TYPE_LENGTH (type
) = 0;
14934 /* The enumeration DIE can be incomplete. In Ada, any type can be
14935 declared as private in the package spec, and then defined only
14936 inside the package body. Such types are known as Taft Amendment
14937 Types. When another package uses such a type, an incomplete DIE
14938 may be generated by the compiler. */
14939 if (die_is_declaration (die
, cu
))
14940 TYPE_STUB (type
) = 1;
14942 /* Finish the creation of this type by using the enum's children.
14943 We must call this even when the underlying type has been provided
14944 so that we can determine if we're looking at a "flag" enum. */
14945 update_enumeration_type_from_children (die
, type
, cu
);
14947 /* If this type has an underlying type that is not a stub, then we
14948 may use its attributes. We always use the "unsigned" attribute
14949 in this situation, because ordinarily we guess whether the type
14950 is unsigned -- but the guess can be wrong and the underlying type
14951 can tell us the reality. However, we defer to a local size
14952 attribute if one exists, because this lets the compiler override
14953 the underlying type if needed. */
14954 if (TYPE_TARGET_TYPE (type
) != NULL
&& !TYPE_STUB (TYPE_TARGET_TYPE (type
)))
14956 TYPE_UNSIGNED (type
) = TYPE_UNSIGNED (TYPE_TARGET_TYPE (type
));
14957 if (TYPE_LENGTH (type
) == 0)
14958 TYPE_LENGTH (type
) = TYPE_LENGTH (TYPE_TARGET_TYPE (type
));
14961 TYPE_DECLARED_CLASS (type
) = dwarf2_flag_true_p (die
, DW_AT_enum_class
, cu
);
14963 return set_die_type (die
, type
, cu
);
14966 /* Given a pointer to a die which begins an enumeration, process all
14967 the dies that define the members of the enumeration, and create the
14968 symbol for the enumeration type.
14970 NOTE: We reverse the order of the element list. */
14973 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
14975 struct type
*this_type
;
14977 this_type
= get_die_type (die
, cu
);
14978 if (this_type
== NULL
)
14979 this_type
= read_enumeration_type (die
, cu
);
14981 if (die
->child
!= NULL
)
14983 struct die_info
*child_die
;
14984 struct symbol
*sym
;
14985 struct field
*fields
= NULL
;
14986 int num_fields
= 0;
14989 child_die
= die
->child
;
14990 while (child_die
&& child_die
->tag
)
14992 if (child_die
->tag
!= DW_TAG_enumerator
)
14994 process_die (child_die
, cu
);
14998 name
= dwarf2_name (child_die
, cu
);
15001 sym
= new_symbol (child_die
, this_type
, cu
);
15003 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
15005 fields
= (struct field
*)
15007 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
15008 * sizeof (struct field
));
15011 FIELD_NAME (fields
[num_fields
]) = SYMBOL_LINKAGE_NAME (sym
);
15012 FIELD_TYPE (fields
[num_fields
]) = NULL
;
15013 SET_FIELD_ENUMVAL (fields
[num_fields
], SYMBOL_VALUE (sym
));
15014 FIELD_BITSIZE (fields
[num_fields
]) = 0;
15020 child_die
= sibling_die (child_die
);
15025 TYPE_NFIELDS (this_type
) = num_fields
;
15026 TYPE_FIELDS (this_type
) = (struct field
*)
15027 TYPE_ALLOC (this_type
, sizeof (struct field
) * num_fields
);
15028 memcpy (TYPE_FIELDS (this_type
), fields
,
15029 sizeof (struct field
) * num_fields
);
15034 /* If we are reading an enum from a .debug_types unit, and the enum
15035 is a declaration, and the enum is not the signatured type in the
15036 unit, then we do not want to add a symbol for it. Adding a
15037 symbol would in some cases obscure the true definition of the
15038 enum, giving users an incomplete type when the definition is
15039 actually available. Note that we do not want to do this for all
15040 enums which are just declarations, because C++0x allows forward
15041 enum declarations. */
15042 if (cu
->per_cu
->is_debug_types
15043 && die_is_declaration (die
, cu
))
15045 struct signatured_type
*sig_type
;
15047 sig_type
= (struct signatured_type
*) cu
->per_cu
;
15048 gdb_assert (to_underlying (sig_type
->type_offset_in_section
) != 0);
15049 if (sig_type
->type_offset_in_section
!= die
->sect_off
)
15053 new_symbol (die
, this_type
, cu
);
15056 /* Extract all information from a DW_TAG_array_type DIE and put it in
15057 the DIE's type field. For now, this only handles one dimensional
15060 static struct type
*
15061 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
15063 struct objfile
*objfile
= cu
->objfile
;
15064 struct die_info
*child_die
;
15066 struct type
*element_type
, *range_type
, *index_type
;
15067 struct attribute
*attr
;
15069 unsigned int bit_stride
= 0;
15071 element_type
= die_type (die
, cu
);
15073 /* The die_type call above may have already set the type for this DIE. */
15074 type
= get_die_type (die
, cu
);
15078 attr
= dwarf2_attr (die
, DW_AT_byte_stride
, cu
);
15080 bit_stride
= DW_UNSND (attr
) * 8;
15082 attr
= dwarf2_attr (die
, DW_AT_bit_stride
, cu
);
15084 bit_stride
= DW_UNSND (attr
);
15086 /* Irix 6.2 native cc creates array types without children for
15087 arrays with unspecified length. */
15088 if (die
->child
== NULL
)
15090 index_type
= objfile_type (objfile
)->builtin_int
;
15091 range_type
= create_static_range_type (NULL
, index_type
, 0, -1);
15092 type
= create_array_type_with_stride (NULL
, element_type
, range_type
,
15094 return set_die_type (die
, type
, cu
);
15097 std::vector
<struct type
*> range_types
;
15098 child_die
= die
->child
;
15099 while (child_die
&& child_die
->tag
)
15101 if (child_die
->tag
== DW_TAG_subrange_type
)
15103 struct type
*child_type
= read_type_die (child_die
, cu
);
15105 if (child_type
!= NULL
)
15107 /* The range type was succesfully read. Save it for the
15108 array type creation. */
15109 range_types
.push_back (child_type
);
15112 child_die
= sibling_die (child_die
);
15115 /* Dwarf2 dimensions are output from left to right, create the
15116 necessary array types in backwards order. */
15118 type
= element_type
;
15120 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
15124 while (i
< range_types
.size ())
15125 type
= create_array_type_with_stride (NULL
, type
, range_types
[i
++],
15130 size_t ndim
= range_types
.size ();
15132 type
= create_array_type_with_stride (NULL
, type
, range_types
[ndim
],
15136 /* Understand Dwarf2 support for vector types (like they occur on
15137 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
15138 array type. This is not part of the Dwarf2/3 standard yet, but a
15139 custom vendor extension. The main difference between a regular
15140 array and the vector variant is that vectors are passed by value
15142 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
15144 make_vector_type (type
);
15146 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
15147 implementation may choose to implement triple vectors using this
15149 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
15152 if (DW_UNSND (attr
) >= TYPE_LENGTH (type
))
15153 TYPE_LENGTH (type
) = DW_UNSND (attr
);
15155 complaint (&symfile_complaints
,
15156 _("DW_AT_byte_size for array type smaller "
15157 "than the total size of elements"));
15160 name
= dwarf2_name (die
, cu
);
15162 TYPE_NAME (type
) = name
;
15164 /* Install the type in the die. */
15165 set_die_type (die
, type
, cu
);
15167 /* set_die_type should be already done. */
15168 set_descriptive_type (type
, die
, cu
);
15173 static enum dwarf_array_dim_ordering
15174 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
15176 struct attribute
*attr
;
15178 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
15181 return (enum dwarf_array_dim_ordering
) DW_SND (attr
);
15183 /* GNU F77 is a special case, as at 08/2004 array type info is the
15184 opposite order to the dwarf2 specification, but data is still
15185 laid out as per normal fortran.
15187 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
15188 version checking. */
15190 if (cu
->language
== language_fortran
15191 && cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
15193 return DW_ORD_row_major
;
15196 switch (cu
->language_defn
->la_array_ordering
)
15198 case array_column_major
:
15199 return DW_ORD_col_major
;
15200 case array_row_major
:
15202 return DW_ORD_row_major
;
15206 /* Extract all information from a DW_TAG_set_type DIE and put it in
15207 the DIE's type field. */
15209 static struct type
*
15210 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
15212 struct type
*domain_type
, *set_type
;
15213 struct attribute
*attr
;
15215 domain_type
= die_type (die
, cu
);
15217 /* The die_type call above may have already set the type for this DIE. */
15218 set_type
= get_die_type (die
, cu
);
15222 set_type
= create_set_type (NULL
, domain_type
);
15224 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
15226 TYPE_LENGTH (set_type
) = DW_UNSND (attr
);
15228 return set_die_type (die
, set_type
, cu
);
15231 /* A helper for read_common_block that creates a locexpr baton.
15232 SYM is the symbol which we are marking as computed.
15233 COMMON_DIE is the DIE for the common block.
15234 COMMON_LOC is the location expression attribute for the common
15236 MEMBER_LOC is the location expression attribute for the particular
15237 member of the common block that we are processing.
15238 CU is the CU from which the above come. */
15241 mark_common_block_symbol_computed (struct symbol
*sym
,
15242 struct die_info
*common_die
,
15243 struct attribute
*common_loc
,
15244 struct attribute
*member_loc
,
15245 struct dwarf2_cu
*cu
)
15247 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
15248 struct dwarf2_locexpr_baton
*baton
;
15250 unsigned int cu_off
;
15251 enum bfd_endian byte_order
= gdbarch_byte_order (get_objfile_arch (objfile
));
15252 LONGEST offset
= 0;
15254 gdb_assert (common_loc
&& member_loc
);
15255 gdb_assert (attr_form_is_block (common_loc
));
15256 gdb_assert (attr_form_is_block (member_loc
)
15257 || attr_form_is_constant (member_loc
));
15259 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
15260 baton
->per_cu
= cu
->per_cu
;
15261 gdb_assert (baton
->per_cu
);
15263 baton
->size
= 5 /* DW_OP_call4 */ + 1 /* DW_OP_plus */;
15265 if (attr_form_is_constant (member_loc
))
15267 offset
= dwarf2_get_attr_constant_value (member_loc
, 0);
15268 baton
->size
+= 1 /* DW_OP_addr */ + cu
->header
.addr_size
;
15271 baton
->size
+= DW_BLOCK (member_loc
)->size
;
15273 ptr
= (gdb_byte
*) obstack_alloc (&objfile
->objfile_obstack
, baton
->size
);
15276 *ptr
++ = DW_OP_call4
;
15277 cu_off
= common_die
->sect_off
- cu
->per_cu
->sect_off
;
15278 store_unsigned_integer (ptr
, 4, byte_order
, cu_off
);
15281 if (attr_form_is_constant (member_loc
))
15283 *ptr
++ = DW_OP_addr
;
15284 store_unsigned_integer (ptr
, cu
->header
.addr_size
, byte_order
, offset
);
15285 ptr
+= cu
->header
.addr_size
;
15289 /* We have to copy the data here, because DW_OP_call4 will only
15290 use a DW_AT_location attribute. */
15291 memcpy (ptr
, DW_BLOCK (member_loc
)->data
, DW_BLOCK (member_loc
)->size
);
15292 ptr
+= DW_BLOCK (member_loc
)->size
;
15295 *ptr
++ = DW_OP_plus
;
15296 gdb_assert (ptr
- baton
->data
== baton
->size
);
15298 SYMBOL_LOCATION_BATON (sym
) = baton
;
15299 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
15302 /* Create appropriate locally-scoped variables for all the
15303 DW_TAG_common_block entries. Also create a struct common_block
15304 listing all such variables for `info common'. COMMON_BLOCK_DOMAIN
15305 is used to sepate the common blocks name namespace from regular
15309 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
15311 struct attribute
*attr
;
15313 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
15316 /* Support the .debug_loc offsets. */
15317 if (attr_form_is_block (attr
))
15321 else if (attr_form_is_section_offset (attr
))
15323 dwarf2_complex_location_expr_complaint ();
15328 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
15329 "common block member");
15334 if (die
->child
!= NULL
)
15336 struct objfile
*objfile
= cu
->objfile
;
15337 struct die_info
*child_die
;
15338 size_t n_entries
= 0, size
;
15339 struct common_block
*common_block
;
15340 struct symbol
*sym
;
15342 for (child_die
= die
->child
;
15343 child_die
&& child_die
->tag
;
15344 child_die
= sibling_die (child_die
))
15347 size
= (sizeof (struct common_block
)
15348 + (n_entries
- 1) * sizeof (struct symbol
*));
15350 = (struct common_block
*) obstack_alloc (&objfile
->objfile_obstack
,
15352 memset (common_block
->contents
, 0, n_entries
* sizeof (struct symbol
*));
15353 common_block
->n_entries
= 0;
15355 for (child_die
= die
->child
;
15356 child_die
&& child_die
->tag
;
15357 child_die
= sibling_die (child_die
))
15359 /* Create the symbol in the DW_TAG_common_block block in the current
15361 sym
= new_symbol (child_die
, NULL
, cu
);
15364 struct attribute
*member_loc
;
15366 common_block
->contents
[common_block
->n_entries
++] = sym
;
15368 member_loc
= dwarf2_attr (child_die
, DW_AT_data_member_location
,
15372 /* GDB has handled this for a long time, but it is
15373 not specified by DWARF. It seems to have been
15374 emitted by gfortran at least as recently as:
15375 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=23057. */
15376 complaint (&symfile_complaints
,
15377 _("Variable in common block has "
15378 "DW_AT_data_member_location "
15379 "- DIE at 0x%x [in module %s]"),
15380 to_underlying (child_die
->sect_off
),
15381 objfile_name (cu
->objfile
));
15383 if (attr_form_is_section_offset (member_loc
))
15384 dwarf2_complex_location_expr_complaint ();
15385 else if (attr_form_is_constant (member_loc
)
15386 || attr_form_is_block (member_loc
))
15389 mark_common_block_symbol_computed (sym
, die
, attr
,
15393 dwarf2_complex_location_expr_complaint ();
15398 sym
= new_symbol (die
, objfile_type (objfile
)->builtin_void
, cu
);
15399 SYMBOL_VALUE_COMMON_BLOCK (sym
) = common_block
;
15403 /* Create a type for a C++ namespace. */
15405 static struct type
*
15406 read_namespace_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
15408 struct objfile
*objfile
= cu
->objfile
;
15409 const char *previous_prefix
, *name
;
15413 /* For extensions, reuse the type of the original namespace. */
15414 if (dwarf2_attr (die
, DW_AT_extension
, cu
) != NULL
)
15416 struct die_info
*ext_die
;
15417 struct dwarf2_cu
*ext_cu
= cu
;
15419 ext_die
= dwarf2_extension (die
, &ext_cu
);
15420 type
= read_type_die (ext_die
, ext_cu
);
15422 /* EXT_CU may not be the same as CU.
15423 Ensure TYPE is recorded with CU in die_type_hash. */
15424 return set_die_type (die
, type
, cu
);
15427 name
= namespace_name (die
, &is_anonymous
, cu
);
15429 /* Now build the name of the current namespace. */
15431 previous_prefix
= determine_prefix (die
, cu
);
15432 if (previous_prefix
[0] != '\0')
15433 name
= typename_concat (&objfile
->objfile_obstack
,
15434 previous_prefix
, name
, 0, cu
);
15436 /* Create the type. */
15437 type
= init_type (objfile
, TYPE_CODE_NAMESPACE
, 0, name
);
15438 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
15440 return set_die_type (die
, type
, cu
);
15443 /* Read a namespace scope. */
15446 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
15448 struct objfile
*objfile
= cu
->objfile
;
15451 /* Add a symbol associated to this if we haven't seen the namespace
15452 before. Also, add a using directive if it's an anonymous
15455 if (dwarf2_attr (die
, DW_AT_extension
, cu
) == NULL
)
15459 type
= read_type_die (die
, cu
);
15460 new_symbol (die
, type
, cu
);
15462 namespace_name (die
, &is_anonymous
, cu
);
15465 const char *previous_prefix
= determine_prefix (die
, cu
);
15467 std::vector
<const char *> excludes
;
15468 add_using_directive (using_directives (cu
->language
),
15469 previous_prefix
, TYPE_NAME (type
), NULL
,
15470 NULL
, excludes
, 0, &objfile
->objfile_obstack
);
15474 if (die
->child
!= NULL
)
15476 struct die_info
*child_die
= die
->child
;
15478 while (child_die
&& child_die
->tag
)
15480 process_die (child_die
, cu
);
15481 child_die
= sibling_die (child_die
);
15486 /* Read a Fortran module as type. This DIE can be only a declaration used for
15487 imported module. Still we need that type as local Fortran "use ... only"
15488 declaration imports depend on the created type in determine_prefix. */
15490 static struct type
*
15491 read_module_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
15493 struct objfile
*objfile
= cu
->objfile
;
15494 const char *module_name
;
15497 module_name
= dwarf2_name (die
, cu
);
15499 complaint (&symfile_complaints
,
15500 _("DW_TAG_module has no name, offset 0x%x"),
15501 to_underlying (die
->sect_off
));
15502 type
= init_type (objfile
, TYPE_CODE_MODULE
, 0, module_name
);
15504 /* determine_prefix uses TYPE_TAG_NAME. */
15505 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
15507 return set_die_type (die
, type
, cu
);
15510 /* Read a Fortran module. */
15513 read_module (struct die_info
*die
, struct dwarf2_cu
*cu
)
15515 struct die_info
*child_die
= die
->child
;
15518 type
= read_type_die (die
, cu
);
15519 new_symbol (die
, type
, cu
);
15521 while (child_die
&& child_die
->tag
)
15523 process_die (child_die
, cu
);
15524 child_die
= sibling_die (child_die
);
15528 /* Return the name of the namespace represented by DIE. Set
15529 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
15532 static const char *
15533 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
15535 struct die_info
*current_die
;
15536 const char *name
= NULL
;
15538 /* Loop through the extensions until we find a name. */
15540 for (current_die
= die
;
15541 current_die
!= NULL
;
15542 current_die
= dwarf2_extension (die
, &cu
))
15544 /* We don't use dwarf2_name here so that we can detect the absence
15545 of a name -> anonymous namespace. */
15546 name
= dwarf2_string_attr (die
, DW_AT_name
, cu
);
15552 /* Is it an anonymous namespace? */
15554 *is_anonymous
= (name
== NULL
);
15556 name
= CP_ANONYMOUS_NAMESPACE_STR
;
15561 /* Extract all information from a DW_TAG_pointer_type DIE and add to
15562 the user defined type vector. */
15564 static struct type
*
15565 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
15567 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
15568 struct comp_unit_head
*cu_header
= &cu
->header
;
15570 struct attribute
*attr_byte_size
;
15571 struct attribute
*attr_address_class
;
15572 int byte_size
, addr_class
;
15573 struct type
*target_type
;
15575 target_type
= die_type (die
, cu
);
15577 /* The die_type call above may have already set the type for this DIE. */
15578 type
= get_die_type (die
, cu
);
15582 type
= lookup_pointer_type (target_type
);
15584 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
15585 if (attr_byte_size
)
15586 byte_size
= DW_UNSND (attr_byte_size
);
15588 byte_size
= cu_header
->addr_size
;
15590 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
15591 if (attr_address_class
)
15592 addr_class
= DW_UNSND (attr_address_class
);
15594 addr_class
= DW_ADDR_none
;
15596 /* If the pointer size or address class is different than the
15597 default, create a type variant marked as such and set the
15598 length accordingly. */
15599 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
15601 if (gdbarch_address_class_type_flags_p (gdbarch
))
15605 type_flags
= gdbarch_address_class_type_flags
15606 (gdbarch
, byte_size
, addr_class
);
15607 gdb_assert ((type_flags
& ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
15609 type
= make_type_with_address_space (type
, type_flags
);
15611 else if (TYPE_LENGTH (type
) != byte_size
)
15613 complaint (&symfile_complaints
,
15614 _("invalid pointer size %d"), byte_size
);
15618 /* Should we also complain about unhandled address classes? */
15622 TYPE_LENGTH (type
) = byte_size
;
15623 return set_die_type (die
, type
, cu
);
15626 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
15627 the user defined type vector. */
15629 static struct type
*
15630 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
15633 struct type
*to_type
;
15634 struct type
*domain
;
15636 to_type
= die_type (die
, cu
);
15637 domain
= die_containing_type (die
, cu
);
15639 /* The calls above may have already set the type for this DIE. */
15640 type
= get_die_type (die
, cu
);
15644 if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_METHOD
)
15645 type
= lookup_methodptr_type (to_type
);
15646 else if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_FUNC
)
15648 struct type
*new_type
= alloc_type (cu
->objfile
);
15650 smash_to_method_type (new_type
, domain
, TYPE_TARGET_TYPE (to_type
),
15651 TYPE_FIELDS (to_type
), TYPE_NFIELDS (to_type
),
15652 TYPE_VARARGS (to_type
));
15653 type
= lookup_methodptr_type (new_type
);
15656 type
= lookup_memberptr_type (to_type
, domain
);
15658 return set_die_type (die
, type
, cu
);
15661 /* Extract all information from a DW_TAG_{rvalue_,}reference_type DIE and add to
15662 the user defined type vector. */
15664 static struct type
*
15665 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
,
15666 enum type_code refcode
)
15668 struct comp_unit_head
*cu_header
= &cu
->header
;
15669 struct type
*type
, *target_type
;
15670 struct attribute
*attr
;
15672 gdb_assert (refcode
== TYPE_CODE_REF
|| refcode
== TYPE_CODE_RVALUE_REF
);
15674 target_type
= die_type (die
, cu
);
15676 /* The die_type call above may have already set the type for this DIE. */
15677 type
= get_die_type (die
, cu
);
15681 type
= lookup_reference_type (target_type
, refcode
);
15682 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
15685 TYPE_LENGTH (type
) = DW_UNSND (attr
);
15689 TYPE_LENGTH (type
) = cu_header
->addr_size
;
15691 return set_die_type (die
, type
, cu
);
15694 /* Add the given cv-qualifiers to the element type of the array. GCC
15695 outputs DWARF type qualifiers that apply to an array, not the
15696 element type. But GDB relies on the array element type to carry
15697 the cv-qualifiers. This mimics section 6.7.3 of the C99
15700 static struct type
*
15701 add_array_cv_type (struct die_info
*die
, struct dwarf2_cu
*cu
,
15702 struct type
*base_type
, int cnst
, int voltl
)
15704 struct type
*el_type
, *inner_array
;
15706 base_type
= copy_type (base_type
);
15707 inner_array
= base_type
;
15709 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array
)) == TYPE_CODE_ARRAY
)
15711 TYPE_TARGET_TYPE (inner_array
) =
15712 copy_type (TYPE_TARGET_TYPE (inner_array
));
15713 inner_array
= TYPE_TARGET_TYPE (inner_array
);
15716 el_type
= TYPE_TARGET_TYPE (inner_array
);
15717 cnst
|= TYPE_CONST (el_type
);
15718 voltl
|= TYPE_VOLATILE (el_type
);
15719 TYPE_TARGET_TYPE (inner_array
) = make_cv_type (cnst
, voltl
, el_type
, NULL
);
15721 return set_die_type (die
, base_type
, cu
);
15724 static struct type
*
15725 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
15727 struct type
*base_type
, *cv_type
;
15729 base_type
= die_type (die
, cu
);
15731 /* The die_type call above may have already set the type for this DIE. */
15732 cv_type
= get_die_type (die
, cu
);
15736 /* In case the const qualifier is applied to an array type, the element type
15737 is so qualified, not the array type (section 6.7.3 of C99). */
15738 if (TYPE_CODE (base_type
) == TYPE_CODE_ARRAY
)
15739 return add_array_cv_type (die
, cu
, base_type
, 1, 0);
15741 cv_type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
15742 return set_die_type (die
, cv_type
, cu
);
15745 static struct type
*
15746 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
15748 struct type
*base_type
, *cv_type
;
15750 base_type
= die_type (die
, cu
);
15752 /* The die_type call above may have already set the type for this DIE. */
15753 cv_type
= get_die_type (die
, cu
);
15757 /* In case the volatile qualifier is applied to an array type, the
15758 element type is so qualified, not the array type (section 6.7.3
15760 if (TYPE_CODE (base_type
) == TYPE_CODE_ARRAY
)
15761 return add_array_cv_type (die
, cu
, base_type
, 0, 1);
15763 cv_type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
15764 return set_die_type (die
, cv_type
, cu
);
15767 /* Handle DW_TAG_restrict_type. */
15769 static struct type
*
15770 read_tag_restrict_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
15772 struct type
*base_type
, *cv_type
;
15774 base_type
= die_type (die
, cu
);
15776 /* The die_type call above may have already set the type for this DIE. */
15777 cv_type
= get_die_type (die
, cu
);
15781 cv_type
= make_restrict_type (base_type
);
15782 return set_die_type (die
, cv_type
, cu
);
15785 /* Handle DW_TAG_atomic_type. */
15787 static struct type
*
15788 read_tag_atomic_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
15790 struct type
*base_type
, *cv_type
;
15792 base_type
= die_type (die
, cu
);
15794 /* The die_type call above may have already set the type for this DIE. */
15795 cv_type
= get_die_type (die
, cu
);
15799 cv_type
= make_atomic_type (base_type
);
15800 return set_die_type (die
, cv_type
, cu
);
15803 /* Extract all information from a DW_TAG_string_type DIE and add to
15804 the user defined type vector. It isn't really a user defined type,
15805 but it behaves like one, with other DIE's using an AT_user_def_type
15806 attribute to reference it. */
15808 static struct type
*
15809 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
15811 struct objfile
*objfile
= cu
->objfile
;
15812 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
15813 struct type
*type
, *range_type
, *index_type
, *char_type
;
15814 struct attribute
*attr
;
15815 unsigned int length
;
15817 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
15820 length
= DW_UNSND (attr
);
15824 /* Check for the DW_AT_byte_size attribute. */
15825 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
15828 length
= DW_UNSND (attr
);
15836 index_type
= objfile_type (objfile
)->builtin_int
;
15837 range_type
= create_static_range_type (NULL
, index_type
, 1, length
);
15838 char_type
= language_string_char_type (cu
->language_defn
, gdbarch
);
15839 type
= create_string_type (NULL
, char_type
, range_type
);
15841 return set_die_type (die
, type
, cu
);
15844 /* Assuming that DIE corresponds to a function, returns nonzero
15845 if the function is prototyped. */
15848 prototyped_function_p (struct die_info
*die
, struct dwarf2_cu
*cu
)
15850 struct attribute
*attr
;
15852 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
15853 if (attr
&& (DW_UNSND (attr
) != 0))
15856 /* The DWARF standard implies that the DW_AT_prototyped attribute
15857 is only meaninful for C, but the concept also extends to other
15858 languages that allow unprototyped functions (Eg: Objective C).
15859 For all other languages, assume that functions are always
15861 if (cu
->language
!= language_c
15862 && cu
->language
!= language_objc
15863 && cu
->language
!= language_opencl
)
15866 /* RealView does not emit DW_AT_prototyped. We can not distinguish
15867 prototyped and unprototyped functions; default to prototyped,
15868 since that is more common in modern code (and RealView warns
15869 about unprototyped functions). */
15870 if (producer_is_realview (cu
->producer
))
15876 /* Handle DIES due to C code like:
15880 int (*funcp)(int a, long l);
15884 ('funcp' generates a DW_TAG_subroutine_type DIE). */
15886 static struct type
*
15887 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
15889 struct objfile
*objfile
= cu
->objfile
;
15890 struct type
*type
; /* Type that this function returns. */
15891 struct type
*ftype
; /* Function that returns above type. */
15892 struct attribute
*attr
;
15894 type
= die_type (die
, cu
);
15896 /* The die_type call above may have already set the type for this DIE. */
15897 ftype
= get_die_type (die
, cu
);
15901 ftype
= lookup_function_type (type
);
15903 if (prototyped_function_p (die
, cu
))
15904 TYPE_PROTOTYPED (ftype
) = 1;
15906 /* Store the calling convention in the type if it's available in
15907 the subroutine die. Otherwise set the calling convention to
15908 the default value DW_CC_normal. */
15909 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
15911 TYPE_CALLING_CONVENTION (ftype
) = DW_UNSND (attr
);
15912 else if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL"))
15913 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_GDB_IBM_OpenCL
;
15915 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_normal
;
15917 /* Record whether the function returns normally to its caller or not
15918 if the DWARF producer set that information. */
15919 attr
= dwarf2_attr (die
, DW_AT_noreturn
, cu
);
15920 if (attr
&& (DW_UNSND (attr
) != 0))
15921 TYPE_NO_RETURN (ftype
) = 1;
15923 /* We need to add the subroutine type to the die immediately so
15924 we don't infinitely recurse when dealing with parameters
15925 declared as the same subroutine type. */
15926 set_die_type (die
, ftype
, cu
);
15928 if (die
->child
!= NULL
)
15930 struct type
*void_type
= objfile_type (objfile
)->builtin_void
;
15931 struct die_info
*child_die
;
15932 int nparams
, iparams
;
15934 /* Count the number of parameters.
15935 FIXME: GDB currently ignores vararg functions, but knows about
15936 vararg member functions. */
15938 child_die
= die
->child
;
15939 while (child_die
&& child_die
->tag
)
15941 if (child_die
->tag
== DW_TAG_formal_parameter
)
15943 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
15944 TYPE_VARARGS (ftype
) = 1;
15945 child_die
= sibling_die (child_die
);
15948 /* Allocate storage for parameters and fill them in. */
15949 TYPE_NFIELDS (ftype
) = nparams
;
15950 TYPE_FIELDS (ftype
) = (struct field
*)
15951 TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
));
15953 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
15954 even if we error out during the parameters reading below. */
15955 for (iparams
= 0; iparams
< nparams
; iparams
++)
15956 TYPE_FIELD_TYPE (ftype
, iparams
) = void_type
;
15959 child_die
= die
->child
;
15960 while (child_die
&& child_die
->tag
)
15962 if (child_die
->tag
== DW_TAG_formal_parameter
)
15964 struct type
*arg_type
;
15966 /* DWARF version 2 has no clean way to discern C++
15967 static and non-static member functions. G++ helps
15968 GDB by marking the first parameter for non-static
15969 member functions (which is the this pointer) as
15970 artificial. We pass this information to
15971 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
15973 DWARF version 3 added DW_AT_object_pointer, which GCC
15974 4.5 does not yet generate. */
15975 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
15977 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
15979 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
15980 arg_type
= die_type (child_die
, cu
);
15982 /* RealView does not mark THIS as const, which the testsuite
15983 expects. GCC marks THIS as const in method definitions,
15984 but not in the class specifications (GCC PR 43053). */
15985 if (cu
->language
== language_cplus
&& !TYPE_CONST (arg_type
)
15986 && TYPE_FIELD_ARTIFICIAL (ftype
, iparams
))
15989 struct dwarf2_cu
*arg_cu
= cu
;
15990 const char *name
= dwarf2_name (child_die
, cu
);
15992 attr
= dwarf2_attr (die
, DW_AT_object_pointer
, cu
);
15995 /* If the compiler emits this, use it. */
15996 if (follow_die_ref (die
, attr
, &arg_cu
) == child_die
)
15999 else if (name
&& strcmp (name
, "this") == 0)
16000 /* Function definitions will have the argument names. */
16002 else if (name
== NULL
&& iparams
== 0)
16003 /* Declarations may not have the names, so like
16004 elsewhere in GDB, assume an artificial first
16005 argument is "this". */
16009 arg_type
= make_cv_type (1, TYPE_VOLATILE (arg_type
),
16013 TYPE_FIELD_TYPE (ftype
, iparams
) = arg_type
;
16016 child_die
= sibling_die (child_die
);
16023 static struct type
*
16024 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
16026 struct objfile
*objfile
= cu
->objfile
;
16027 const char *name
= NULL
;
16028 struct type
*this_type
, *target_type
;
16030 name
= dwarf2_full_name (NULL
, die
, cu
);
16031 this_type
= init_type (objfile
, TYPE_CODE_TYPEDEF
, 0, name
);
16032 TYPE_TARGET_STUB (this_type
) = 1;
16033 set_die_type (die
, this_type
, cu
);
16034 target_type
= die_type (die
, cu
);
16035 if (target_type
!= this_type
)
16036 TYPE_TARGET_TYPE (this_type
) = target_type
;
16039 /* Self-referential typedefs are, it seems, not allowed by the DWARF
16040 spec and cause infinite loops in GDB. */
16041 complaint (&symfile_complaints
,
16042 _("Self-referential DW_TAG_typedef "
16043 "- DIE at 0x%x [in module %s]"),
16044 to_underlying (die
->sect_off
), objfile_name (objfile
));
16045 TYPE_TARGET_TYPE (this_type
) = NULL
;
16050 /* Allocate a floating-point type of size BITS and name NAME. Pass NAME_HINT
16051 (which may be different from NAME) to the architecture back-end to allow
16052 it to guess the correct format if necessary. */
16054 static struct type
*
16055 dwarf2_init_float_type (struct objfile
*objfile
, int bits
, const char *name
,
16056 const char *name_hint
)
16058 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
16059 const struct floatformat
**format
;
16062 format
= gdbarch_floatformat_for_type (gdbarch
, name_hint
, bits
);
16064 type
= init_float_type (objfile
, bits
, name
, format
);
16066 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
, name
);
16071 /* Find a representation of a given base type and install
16072 it in the TYPE field of the die. */
16074 static struct type
*
16075 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16077 struct objfile
*objfile
= cu
->objfile
;
16079 struct attribute
*attr
;
16080 int encoding
= 0, bits
= 0;
16083 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
16086 encoding
= DW_UNSND (attr
);
16088 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16091 bits
= DW_UNSND (attr
) * TARGET_CHAR_BIT
;
16093 name
= dwarf2_name (die
, cu
);
16096 complaint (&symfile_complaints
,
16097 _("DW_AT_name missing from DW_TAG_base_type"));
16102 case DW_ATE_address
:
16103 /* Turn DW_ATE_address into a void * pointer. */
16104 type
= init_type (objfile
, TYPE_CODE_VOID
, TARGET_CHAR_BIT
, NULL
);
16105 type
= init_pointer_type (objfile
, bits
, name
, type
);
16107 case DW_ATE_boolean
:
16108 type
= init_boolean_type (objfile
, bits
, 1, name
);
16110 case DW_ATE_complex_float
:
16111 type
= dwarf2_init_float_type (objfile
, bits
/ 2, NULL
, name
);
16112 type
= init_complex_type (objfile
, name
, type
);
16114 case DW_ATE_decimal_float
:
16115 type
= init_decfloat_type (objfile
, bits
, name
);
16118 type
= dwarf2_init_float_type (objfile
, bits
, name
, name
);
16120 case DW_ATE_signed
:
16121 type
= init_integer_type (objfile
, bits
, 0, name
);
16123 case DW_ATE_unsigned
:
16124 if (cu
->language
== language_fortran
16126 && startswith (name
, "character("))
16127 type
= init_character_type (objfile
, bits
, 1, name
);
16129 type
= init_integer_type (objfile
, bits
, 1, name
);
16131 case DW_ATE_signed_char
:
16132 if (cu
->language
== language_ada
|| cu
->language
== language_m2
16133 || cu
->language
== language_pascal
16134 || cu
->language
== language_fortran
)
16135 type
= init_character_type (objfile
, bits
, 0, name
);
16137 type
= init_integer_type (objfile
, bits
, 0, name
);
16139 case DW_ATE_unsigned_char
:
16140 if (cu
->language
== language_ada
|| cu
->language
== language_m2
16141 || cu
->language
== language_pascal
16142 || cu
->language
== language_fortran
16143 || cu
->language
== language_rust
)
16144 type
= init_character_type (objfile
, bits
, 1, name
);
16146 type
= init_integer_type (objfile
, bits
, 1, name
);
16150 gdbarch
*arch
= get_objfile_arch (objfile
);
16153 type
= builtin_type (arch
)->builtin_char16
;
16154 else if (bits
== 32)
16155 type
= builtin_type (arch
)->builtin_char32
;
16158 complaint (&symfile_complaints
,
16159 _("unsupported DW_ATE_UTF bit size: '%d'"),
16161 type
= init_integer_type (objfile
, bits
, 1, name
);
16163 return set_die_type (die
, type
, cu
);
16168 complaint (&symfile_complaints
, _("unsupported DW_AT_encoding: '%s'"),
16169 dwarf_type_encoding_name (encoding
));
16170 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
, name
);
16174 if (name
&& strcmp (name
, "char") == 0)
16175 TYPE_NOSIGN (type
) = 1;
16177 return set_die_type (die
, type
, cu
);
16180 /* Parse dwarf attribute if it's a block, reference or constant and put the
16181 resulting value of the attribute into struct bound_prop.
16182 Returns 1 if ATTR could be resolved into PROP, 0 otherwise. */
16185 attr_to_dynamic_prop (const struct attribute
*attr
, struct die_info
*die
,
16186 struct dwarf2_cu
*cu
, struct dynamic_prop
*prop
)
16188 struct dwarf2_property_baton
*baton
;
16189 struct obstack
*obstack
= &cu
->objfile
->objfile_obstack
;
16191 if (attr
== NULL
|| prop
== NULL
)
16194 if (attr_form_is_block (attr
))
16196 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
16197 baton
->referenced_type
= NULL
;
16198 baton
->locexpr
.per_cu
= cu
->per_cu
;
16199 baton
->locexpr
.size
= DW_BLOCK (attr
)->size
;
16200 baton
->locexpr
.data
= DW_BLOCK (attr
)->data
;
16201 prop
->data
.baton
= baton
;
16202 prop
->kind
= PROP_LOCEXPR
;
16203 gdb_assert (prop
->data
.baton
!= NULL
);
16205 else if (attr_form_is_ref (attr
))
16207 struct dwarf2_cu
*target_cu
= cu
;
16208 struct die_info
*target_die
;
16209 struct attribute
*target_attr
;
16211 target_die
= follow_die_ref (die
, attr
, &target_cu
);
16212 target_attr
= dwarf2_attr (target_die
, DW_AT_location
, target_cu
);
16213 if (target_attr
== NULL
)
16214 target_attr
= dwarf2_attr (target_die
, DW_AT_data_member_location
,
16216 if (target_attr
== NULL
)
16219 switch (target_attr
->name
)
16221 case DW_AT_location
:
16222 if (attr_form_is_section_offset (target_attr
))
16224 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
16225 baton
->referenced_type
= die_type (target_die
, target_cu
);
16226 fill_in_loclist_baton (cu
, &baton
->loclist
, target_attr
);
16227 prop
->data
.baton
= baton
;
16228 prop
->kind
= PROP_LOCLIST
;
16229 gdb_assert (prop
->data
.baton
!= NULL
);
16231 else if (attr_form_is_block (target_attr
))
16233 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
16234 baton
->referenced_type
= die_type (target_die
, target_cu
);
16235 baton
->locexpr
.per_cu
= cu
->per_cu
;
16236 baton
->locexpr
.size
= DW_BLOCK (target_attr
)->size
;
16237 baton
->locexpr
.data
= DW_BLOCK (target_attr
)->data
;
16238 prop
->data
.baton
= baton
;
16239 prop
->kind
= PROP_LOCEXPR
;
16240 gdb_assert (prop
->data
.baton
!= NULL
);
16244 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
16245 "dynamic property");
16249 case DW_AT_data_member_location
:
16253 if (!handle_data_member_location (target_die
, target_cu
,
16257 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
16258 baton
->referenced_type
= read_type_die (target_die
->parent
,
16260 baton
->offset_info
.offset
= offset
;
16261 baton
->offset_info
.type
= die_type (target_die
, target_cu
);
16262 prop
->data
.baton
= baton
;
16263 prop
->kind
= PROP_ADDR_OFFSET
;
16268 else if (attr_form_is_constant (attr
))
16270 prop
->data
.const_val
= dwarf2_get_attr_constant_value (attr
, 0);
16271 prop
->kind
= PROP_CONST
;
16275 dwarf2_invalid_attrib_class_complaint (dwarf_form_name (attr
->form
),
16276 dwarf2_name (die
, cu
));
16283 /* Read the given DW_AT_subrange DIE. */
16285 static struct type
*
16286 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16288 struct type
*base_type
, *orig_base_type
;
16289 struct type
*range_type
;
16290 struct attribute
*attr
;
16291 struct dynamic_prop low
, high
;
16292 int low_default_is_valid
;
16293 int high_bound_is_count
= 0;
16295 LONGEST negative_mask
;
16297 orig_base_type
= die_type (die
, cu
);
16298 /* If ORIG_BASE_TYPE is a typedef, it will not be TYPE_UNSIGNED,
16299 whereas the real type might be. So, we use ORIG_BASE_TYPE when
16300 creating the range type, but we use the result of check_typedef
16301 when examining properties of the type. */
16302 base_type
= check_typedef (orig_base_type
);
16304 /* The die_type call above may have already set the type for this DIE. */
16305 range_type
= get_die_type (die
, cu
);
16309 low
.kind
= PROP_CONST
;
16310 high
.kind
= PROP_CONST
;
16311 high
.data
.const_val
= 0;
16313 /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
16314 omitting DW_AT_lower_bound. */
16315 switch (cu
->language
)
16318 case language_cplus
:
16319 low
.data
.const_val
= 0;
16320 low_default_is_valid
= 1;
16322 case language_fortran
:
16323 low
.data
.const_val
= 1;
16324 low_default_is_valid
= 1;
16327 case language_objc
:
16328 case language_rust
:
16329 low
.data
.const_val
= 0;
16330 low_default_is_valid
= (cu
->header
.version
>= 4);
16334 case language_pascal
:
16335 low
.data
.const_val
= 1;
16336 low_default_is_valid
= (cu
->header
.version
>= 4);
16339 low
.data
.const_val
= 0;
16340 low_default_is_valid
= 0;
16344 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
16346 attr_to_dynamic_prop (attr
, die
, cu
, &low
);
16347 else if (!low_default_is_valid
)
16348 complaint (&symfile_complaints
, _("Missing DW_AT_lower_bound "
16349 "- DIE at 0x%x [in module %s]"),
16350 to_underlying (die
->sect_off
), objfile_name (cu
->objfile
));
16352 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
16353 if (!attr_to_dynamic_prop (attr
, die
, cu
, &high
))
16355 attr
= dwarf2_attr (die
, DW_AT_count
, cu
);
16356 if (attr_to_dynamic_prop (attr
, die
, cu
, &high
))
16358 /* If bounds are constant do the final calculation here. */
16359 if (low
.kind
== PROP_CONST
&& high
.kind
== PROP_CONST
)
16360 high
.data
.const_val
= low
.data
.const_val
+ high
.data
.const_val
- 1;
16362 high_bound_is_count
= 1;
16366 /* Dwarf-2 specifications explicitly allows to create subrange types
16367 without specifying a base type.
16368 In that case, the base type must be set to the type of
16369 the lower bound, upper bound or count, in that order, if any of these
16370 three attributes references an object that has a type.
16371 If no base type is found, the Dwarf-2 specifications say that
16372 a signed integer type of size equal to the size of an address should
16374 For the following C code: `extern char gdb_int [];'
16375 GCC produces an empty range DIE.
16376 FIXME: muller/2010-05-28: Possible references to object for low bound,
16377 high bound or count are not yet handled by this code. */
16378 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
16380 struct objfile
*objfile
= cu
->objfile
;
16381 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
16382 int addr_size
= gdbarch_addr_bit (gdbarch
) /8;
16383 struct type
*int_type
= objfile_type (objfile
)->builtin_int
;
16385 /* Test "int", "long int", and "long long int" objfile types,
16386 and select the first one having a size above or equal to the
16387 architecture address size. */
16388 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
16389 base_type
= int_type
;
16392 int_type
= objfile_type (objfile
)->builtin_long
;
16393 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
16394 base_type
= int_type
;
16397 int_type
= objfile_type (objfile
)->builtin_long_long
;
16398 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
16399 base_type
= int_type
;
16404 /* Normally, the DWARF producers are expected to use a signed
16405 constant form (Eg. DW_FORM_sdata) to express negative bounds.
16406 But this is unfortunately not always the case, as witnessed
16407 with GCC, for instance, where the ambiguous DW_FORM_dataN form
16408 is used instead. To work around that ambiguity, we treat
16409 the bounds as signed, and thus sign-extend their values, when
16410 the base type is signed. */
16412 -((LONGEST
) 1 << (TYPE_LENGTH (base_type
) * TARGET_CHAR_BIT
- 1));
16413 if (low
.kind
== PROP_CONST
16414 && !TYPE_UNSIGNED (base_type
) && (low
.data
.const_val
& negative_mask
))
16415 low
.data
.const_val
|= negative_mask
;
16416 if (high
.kind
== PROP_CONST
16417 && !TYPE_UNSIGNED (base_type
) && (high
.data
.const_val
& negative_mask
))
16418 high
.data
.const_val
|= negative_mask
;
16420 range_type
= create_range_type (NULL
, orig_base_type
, &low
, &high
);
16422 if (high_bound_is_count
)
16423 TYPE_RANGE_DATA (range_type
)->flag_upper_bound_is_count
= 1;
16425 /* Ada expects an empty array on no boundary attributes. */
16426 if (attr
== NULL
&& cu
->language
!= language_ada
)
16427 TYPE_HIGH_BOUND_KIND (range_type
) = PROP_UNDEFINED
;
16429 name
= dwarf2_name (die
, cu
);
16431 TYPE_NAME (range_type
) = name
;
16433 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16435 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
16437 set_die_type (die
, range_type
, cu
);
16439 /* set_die_type should be already done. */
16440 set_descriptive_type (range_type
, die
, cu
);
16445 static struct type
*
16446 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16450 /* For now, we only support the C meaning of an unspecified type: void. */
16452 type
= init_type (cu
->objfile
, TYPE_CODE_VOID
, 0, NULL
);
16453 TYPE_NAME (type
) = dwarf2_name (die
, cu
);
16455 return set_die_type (die
, type
, cu
);
16458 /* Read a single die and all its descendents. Set the die's sibling
16459 field to NULL; set other fields in the die correctly, and set all
16460 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
16461 location of the info_ptr after reading all of those dies. PARENT
16462 is the parent of the die in question. */
16464 static struct die_info
*
16465 read_die_and_children (const struct die_reader_specs
*reader
,
16466 const gdb_byte
*info_ptr
,
16467 const gdb_byte
**new_info_ptr
,
16468 struct die_info
*parent
)
16470 struct die_info
*die
;
16471 const gdb_byte
*cur_ptr
;
16474 cur_ptr
= read_full_die_1 (reader
, &die
, info_ptr
, &has_children
, 0);
16477 *new_info_ptr
= cur_ptr
;
16480 store_in_ref_table (die
, reader
->cu
);
16483 die
->child
= read_die_and_siblings_1 (reader
, cur_ptr
, new_info_ptr
, die
);
16487 *new_info_ptr
= cur_ptr
;
16490 die
->sibling
= NULL
;
16491 die
->parent
= parent
;
16495 /* Read a die, all of its descendents, and all of its siblings; set
16496 all of the fields of all of the dies correctly. Arguments are as
16497 in read_die_and_children. */
16499 static struct die_info
*
16500 read_die_and_siblings_1 (const struct die_reader_specs
*reader
,
16501 const gdb_byte
*info_ptr
,
16502 const gdb_byte
**new_info_ptr
,
16503 struct die_info
*parent
)
16505 struct die_info
*first_die
, *last_sibling
;
16506 const gdb_byte
*cur_ptr
;
16508 cur_ptr
= info_ptr
;
16509 first_die
= last_sibling
= NULL
;
16513 struct die_info
*die
16514 = read_die_and_children (reader
, cur_ptr
, &cur_ptr
, parent
);
16518 *new_info_ptr
= cur_ptr
;
16525 last_sibling
->sibling
= die
;
16527 last_sibling
= die
;
16531 /* Read a die, all of its descendents, and all of its siblings; set
16532 all of the fields of all of the dies correctly. Arguments are as
16533 in read_die_and_children.
16534 This the main entry point for reading a DIE and all its children. */
16536 static struct die_info
*
16537 read_die_and_siblings (const struct die_reader_specs
*reader
,
16538 const gdb_byte
*info_ptr
,
16539 const gdb_byte
**new_info_ptr
,
16540 struct die_info
*parent
)
16542 struct die_info
*die
= read_die_and_siblings_1 (reader
, info_ptr
,
16543 new_info_ptr
, parent
);
16545 if (dwarf_die_debug
)
16547 fprintf_unfiltered (gdb_stdlog
,
16548 "Read die from %s@0x%x of %s:\n",
16549 get_section_name (reader
->die_section
),
16550 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
16551 bfd_get_filename (reader
->abfd
));
16552 dump_die (die
, dwarf_die_debug
);
16558 /* Read a die and all its attributes, leave space for NUM_EXTRA_ATTRS
16560 The caller is responsible for filling in the extra attributes
16561 and updating (*DIEP)->num_attrs.
16562 Set DIEP to point to a newly allocated die with its information,
16563 except for its child, sibling, and parent fields.
16564 Set HAS_CHILDREN to tell whether the die has children or not. */
16566 static const gdb_byte
*
16567 read_full_die_1 (const struct die_reader_specs
*reader
,
16568 struct die_info
**diep
, const gdb_byte
*info_ptr
,
16569 int *has_children
, int num_extra_attrs
)
16571 unsigned int abbrev_number
, bytes_read
, i
;
16572 struct abbrev_info
*abbrev
;
16573 struct die_info
*die
;
16574 struct dwarf2_cu
*cu
= reader
->cu
;
16575 bfd
*abfd
= reader
->abfd
;
16577 sect_offset sect_off
= (sect_offset
) (info_ptr
- reader
->buffer
);
16578 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
16579 info_ptr
+= bytes_read
;
16580 if (!abbrev_number
)
16587 abbrev
= abbrev_table_lookup_abbrev (cu
->abbrev_table
, abbrev_number
);
16589 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
16591 bfd_get_filename (abfd
));
16593 die
= dwarf_alloc_die (cu
, abbrev
->num_attrs
+ num_extra_attrs
);
16594 die
->sect_off
= sect_off
;
16595 die
->tag
= abbrev
->tag
;
16596 die
->abbrev
= abbrev_number
;
16598 /* Make the result usable.
16599 The caller needs to update num_attrs after adding the extra
16601 die
->num_attrs
= abbrev
->num_attrs
;
16603 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
16604 info_ptr
= read_attribute (reader
, &die
->attrs
[i
], &abbrev
->attrs
[i
],
16608 *has_children
= abbrev
->has_children
;
16612 /* Read a die and all its attributes.
16613 Set DIEP to point to a newly allocated die with its information,
16614 except for its child, sibling, and parent fields.
16615 Set HAS_CHILDREN to tell whether the die has children or not. */
16617 static const gdb_byte
*
16618 read_full_die (const struct die_reader_specs
*reader
,
16619 struct die_info
**diep
, const gdb_byte
*info_ptr
,
16622 const gdb_byte
*result
;
16624 result
= read_full_die_1 (reader
, diep
, info_ptr
, has_children
, 0);
16626 if (dwarf_die_debug
)
16628 fprintf_unfiltered (gdb_stdlog
,
16629 "Read die from %s@0x%x of %s:\n",
16630 get_section_name (reader
->die_section
),
16631 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
16632 bfd_get_filename (reader
->abfd
));
16633 dump_die (*diep
, dwarf_die_debug
);
16639 /* Abbreviation tables.
16641 In DWARF version 2, the description of the debugging information is
16642 stored in a separate .debug_abbrev section. Before we read any
16643 dies from a section we read in all abbreviations and install them
16644 in a hash table. */
16646 /* Allocate space for a struct abbrev_info object in ABBREV_TABLE. */
16648 static struct abbrev_info
*
16649 abbrev_table_alloc_abbrev (struct abbrev_table
*abbrev_table
)
16651 struct abbrev_info
*abbrev
;
16653 abbrev
= XOBNEW (&abbrev_table
->abbrev_obstack
, struct abbrev_info
);
16654 memset (abbrev
, 0, sizeof (struct abbrev_info
));
16659 /* Add an abbreviation to the table. */
16662 abbrev_table_add_abbrev (struct abbrev_table
*abbrev_table
,
16663 unsigned int abbrev_number
,
16664 struct abbrev_info
*abbrev
)
16666 unsigned int hash_number
;
16668 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
16669 abbrev
->next
= abbrev_table
->abbrevs
[hash_number
];
16670 abbrev_table
->abbrevs
[hash_number
] = abbrev
;
16673 /* Look up an abbrev in the table.
16674 Returns NULL if the abbrev is not found. */
16676 static struct abbrev_info
*
16677 abbrev_table_lookup_abbrev (const struct abbrev_table
*abbrev_table
,
16678 unsigned int abbrev_number
)
16680 unsigned int hash_number
;
16681 struct abbrev_info
*abbrev
;
16683 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
16684 abbrev
= abbrev_table
->abbrevs
[hash_number
];
16688 if (abbrev
->number
== abbrev_number
)
16690 abbrev
= abbrev
->next
;
16695 /* Read in an abbrev table. */
16697 static struct abbrev_table
*
16698 abbrev_table_read_table (struct dwarf2_section_info
*section
,
16699 sect_offset sect_off
)
16701 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
16702 bfd
*abfd
= get_section_bfd_owner (section
);
16703 struct abbrev_table
*abbrev_table
;
16704 const gdb_byte
*abbrev_ptr
;
16705 struct abbrev_info
*cur_abbrev
;
16706 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
16707 unsigned int abbrev_form
;
16708 struct attr_abbrev
*cur_attrs
;
16709 unsigned int allocated_attrs
;
16711 abbrev_table
= XNEW (struct abbrev_table
);
16712 abbrev_table
->sect_off
= sect_off
;
16713 obstack_init (&abbrev_table
->abbrev_obstack
);
16714 abbrev_table
->abbrevs
=
16715 XOBNEWVEC (&abbrev_table
->abbrev_obstack
, struct abbrev_info
*,
16717 memset (abbrev_table
->abbrevs
, 0,
16718 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
16720 dwarf2_read_section (objfile
, section
);
16721 abbrev_ptr
= section
->buffer
+ to_underlying (sect_off
);
16722 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
16723 abbrev_ptr
+= bytes_read
;
16725 allocated_attrs
= ATTR_ALLOC_CHUNK
;
16726 cur_attrs
= XNEWVEC (struct attr_abbrev
, allocated_attrs
);
16728 /* Loop until we reach an abbrev number of 0. */
16729 while (abbrev_number
)
16731 cur_abbrev
= abbrev_table_alloc_abbrev (abbrev_table
);
16733 /* read in abbrev header */
16734 cur_abbrev
->number
= abbrev_number
;
16736 = (enum dwarf_tag
) read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
16737 abbrev_ptr
+= bytes_read
;
16738 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
16741 /* now read in declarations */
16744 LONGEST implicit_const
;
16746 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
16747 abbrev_ptr
+= bytes_read
;
16748 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
16749 abbrev_ptr
+= bytes_read
;
16750 if (abbrev_form
== DW_FORM_implicit_const
)
16752 implicit_const
= read_signed_leb128 (abfd
, abbrev_ptr
,
16754 abbrev_ptr
+= bytes_read
;
16758 /* Initialize it due to a false compiler warning. */
16759 implicit_const
= -1;
16762 if (abbrev_name
== 0)
16765 if (cur_abbrev
->num_attrs
== allocated_attrs
)
16767 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
16769 = XRESIZEVEC (struct attr_abbrev
, cur_attrs
, allocated_attrs
);
16772 cur_attrs
[cur_abbrev
->num_attrs
].name
16773 = (enum dwarf_attribute
) abbrev_name
;
16774 cur_attrs
[cur_abbrev
->num_attrs
].form
16775 = (enum dwarf_form
) abbrev_form
;
16776 cur_attrs
[cur_abbrev
->num_attrs
].implicit_const
= implicit_const
;
16777 ++cur_abbrev
->num_attrs
;
16780 cur_abbrev
->attrs
=
16781 XOBNEWVEC (&abbrev_table
->abbrev_obstack
, struct attr_abbrev
,
16782 cur_abbrev
->num_attrs
);
16783 memcpy (cur_abbrev
->attrs
, cur_attrs
,
16784 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
16786 abbrev_table_add_abbrev (abbrev_table
, abbrev_number
, cur_abbrev
);
16788 /* Get next abbreviation.
16789 Under Irix6 the abbreviations for a compilation unit are not
16790 always properly terminated with an abbrev number of 0.
16791 Exit loop if we encounter an abbreviation which we have
16792 already read (which means we are about to read the abbreviations
16793 for the next compile unit) or if the end of the abbreviation
16794 table is reached. */
16795 if ((unsigned int) (abbrev_ptr
- section
->buffer
) >= section
->size
)
16797 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
16798 abbrev_ptr
+= bytes_read
;
16799 if (abbrev_table_lookup_abbrev (abbrev_table
, abbrev_number
) != NULL
)
16804 return abbrev_table
;
16807 /* Free the resources held by ABBREV_TABLE. */
16810 abbrev_table_free (struct abbrev_table
*abbrev_table
)
16812 obstack_free (&abbrev_table
->abbrev_obstack
, NULL
);
16813 xfree (abbrev_table
);
16816 /* Same as abbrev_table_free but as a cleanup.
16817 We pass in a pointer to the pointer to the table so that we can
16818 set the pointer to NULL when we're done. It also simplifies
16819 build_type_psymtabs_1. */
16822 abbrev_table_free_cleanup (void *table_ptr
)
16824 struct abbrev_table
**abbrev_table_ptr
= (struct abbrev_table
**) table_ptr
;
16826 if (*abbrev_table_ptr
!= NULL
)
16827 abbrev_table_free (*abbrev_table_ptr
);
16828 *abbrev_table_ptr
= NULL
;
16831 /* Read the abbrev table for CU from ABBREV_SECTION. */
16834 dwarf2_read_abbrevs (struct dwarf2_cu
*cu
,
16835 struct dwarf2_section_info
*abbrev_section
)
16838 abbrev_table_read_table (abbrev_section
, cu
->header
.abbrev_sect_off
);
16841 /* Release the memory used by the abbrev table for a compilation unit. */
16844 dwarf2_free_abbrev_table (void *ptr_to_cu
)
16846 struct dwarf2_cu
*cu
= (struct dwarf2_cu
*) ptr_to_cu
;
16848 if (cu
->abbrev_table
!= NULL
)
16849 abbrev_table_free (cu
->abbrev_table
);
16850 /* Set this to NULL so that we SEGV if we try to read it later,
16851 and also because free_comp_unit verifies this is NULL. */
16852 cu
->abbrev_table
= NULL
;
16855 /* Returns nonzero if TAG represents a type that we might generate a partial
16859 is_type_tag_for_partial (int tag
)
16864 /* Some types that would be reasonable to generate partial symbols for,
16865 that we don't at present. */
16866 case DW_TAG_array_type
:
16867 case DW_TAG_file_type
:
16868 case DW_TAG_ptr_to_member_type
:
16869 case DW_TAG_set_type
:
16870 case DW_TAG_string_type
:
16871 case DW_TAG_subroutine_type
:
16873 case DW_TAG_base_type
:
16874 case DW_TAG_class_type
:
16875 case DW_TAG_interface_type
:
16876 case DW_TAG_enumeration_type
:
16877 case DW_TAG_structure_type
:
16878 case DW_TAG_subrange_type
:
16879 case DW_TAG_typedef
:
16880 case DW_TAG_union_type
:
16887 /* Load all DIEs that are interesting for partial symbols into memory. */
16889 static struct partial_die_info
*
16890 load_partial_dies (const struct die_reader_specs
*reader
,
16891 const gdb_byte
*info_ptr
, int building_psymtab
)
16893 struct dwarf2_cu
*cu
= reader
->cu
;
16894 struct objfile
*objfile
= cu
->objfile
;
16895 struct partial_die_info
*part_die
;
16896 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
16897 struct abbrev_info
*abbrev
;
16898 unsigned int bytes_read
;
16899 unsigned int load_all
= 0;
16900 int nesting_level
= 1;
16905 gdb_assert (cu
->per_cu
!= NULL
);
16906 if (cu
->per_cu
->load_all_dies
)
16910 = htab_create_alloc_ex (cu
->header
.length
/ 12,
16914 &cu
->comp_unit_obstack
,
16915 hashtab_obstack_allocate
,
16916 dummy_obstack_deallocate
);
16918 part_die
= XOBNEW (&cu
->comp_unit_obstack
, struct partial_die_info
);
16922 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
16924 /* A NULL abbrev means the end of a series of children. */
16925 if (abbrev
== NULL
)
16927 if (--nesting_level
== 0)
16929 /* PART_DIE was probably the last thing allocated on the
16930 comp_unit_obstack, so we could call obstack_free
16931 here. We don't do that because the waste is small,
16932 and will be cleaned up when we're done with this
16933 compilation unit. This way, we're also more robust
16934 against other users of the comp_unit_obstack. */
16937 info_ptr
+= bytes_read
;
16938 last_die
= parent_die
;
16939 parent_die
= parent_die
->die_parent
;
16943 /* Check for template arguments. We never save these; if
16944 they're seen, we just mark the parent, and go on our way. */
16945 if (parent_die
!= NULL
16946 && cu
->language
== language_cplus
16947 && (abbrev
->tag
== DW_TAG_template_type_param
16948 || abbrev
->tag
== DW_TAG_template_value_param
))
16950 parent_die
->has_template_arguments
= 1;
16954 /* We don't need a partial DIE for the template argument. */
16955 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
16960 /* We only recurse into c++ subprograms looking for template arguments.
16961 Skip their other children. */
16963 && cu
->language
== language_cplus
16964 && parent_die
!= NULL
16965 && parent_die
->tag
== DW_TAG_subprogram
)
16967 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
16971 /* Check whether this DIE is interesting enough to save. Normally
16972 we would not be interested in members here, but there may be
16973 later variables referencing them via DW_AT_specification (for
16974 static members). */
16976 && !is_type_tag_for_partial (abbrev
->tag
)
16977 && abbrev
->tag
!= DW_TAG_constant
16978 && abbrev
->tag
!= DW_TAG_enumerator
16979 && abbrev
->tag
!= DW_TAG_subprogram
16980 && abbrev
->tag
!= DW_TAG_lexical_block
16981 && abbrev
->tag
!= DW_TAG_variable
16982 && abbrev
->tag
!= DW_TAG_namespace
16983 && abbrev
->tag
!= DW_TAG_module
16984 && abbrev
->tag
!= DW_TAG_member
16985 && abbrev
->tag
!= DW_TAG_imported_unit
16986 && abbrev
->tag
!= DW_TAG_imported_declaration
)
16988 /* Otherwise we skip to the next sibling, if any. */
16989 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
16993 info_ptr
= read_partial_die (reader
, part_die
, abbrev
, bytes_read
,
16996 /* This two-pass algorithm for processing partial symbols has a
16997 high cost in cache pressure. Thus, handle some simple cases
16998 here which cover the majority of C partial symbols. DIEs
16999 which neither have specification tags in them, nor could have
17000 specification tags elsewhere pointing at them, can simply be
17001 processed and discarded.
17003 This segment is also optional; scan_partial_symbols and
17004 add_partial_symbol will handle these DIEs if we chain
17005 them in normally. When compilers which do not emit large
17006 quantities of duplicate debug information are more common,
17007 this code can probably be removed. */
17009 /* Any complete simple types at the top level (pretty much all
17010 of them, for a language without namespaces), can be processed
17012 if (parent_die
== NULL
17013 && part_die
->has_specification
== 0
17014 && part_die
->is_declaration
== 0
17015 && ((part_die
->tag
== DW_TAG_typedef
&& !part_die
->has_children
)
17016 || part_die
->tag
== DW_TAG_base_type
17017 || part_die
->tag
== DW_TAG_subrange_type
))
17019 if (building_psymtab
&& part_die
->name
!= NULL
)
17020 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
17021 VAR_DOMAIN
, LOC_TYPEDEF
,
17022 &objfile
->static_psymbols
,
17023 0, cu
->language
, objfile
);
17024 info_ptr
= locate_pdi_sibling (reader
, part_die
, info_ptr
);
17028 /* The exception for DW_TAG_typedef with has_children above is
17029 a workaround of GCC PR debug/47510. In the case of this complaint
17030 type_name_no_tag_or_error will error on such types later.
17032 GDB skipped children of DW_TAG_typedef by the shortcut above and then
17033 it could not find the child DIEs referenced later, this is checked
17034 above. In correct DWARF DW_TAG_typedef should have no children. */
17036 if (part_die
->tag
== DW_TAG_typedef
&& part_die
->has_children
)
17037 complaint (&symfile_complaints
,
17038 _("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
17039 "- DIE at 0x%x [in module %s]"),
17040 to_underlying (part_die
->sect_off
), objfile_name (objfile
));
17042 /* If we're at the second level, and we're an enumerator, and
17043 our parent has no specification (meaning possibly lives in a
17044 namespace elsewhere), then we can add the partial symbol now
17045 instead of queueing it. */
17046 if (part_die
->tag
== DW_TAG_enumerator
17047 && parent_die
!= NULL
17048 && parent_die
->die_parent
== NULL
17049 && parent_die
->tag
== DW_TAG_enumeration_type
17050 && parent_die
->has_specification
== 0)
17052 if (part_die
->name
== NULL
)
17053 complaint (&symfile_complaints
,
17054 _("malformed enumerator DIE ignored"));
17055 else if (building_psymtab
)
17056 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
17057 VAR_DOMAIN
, LOC_CONST
,
17058 cu
->language
== language_cplus
17059 ? &objfile
->global_psymbols
17060 : &objfile
->static_psymbols
,
17061 0, cu
->language
, objfile
);
17063 info_ptr
= locate_pdi_sibling (reader
, part_die
, info_ptr
);
17067 /* We'll save this DIE so link it in. */
17068 part_die
->die_parent
= parent_die
;
17069 part_die
->die_sibling
= NULL
;
17070 part_die
->die_child
= NULL
;
17072 if (last_die
&& last_die
== parent_die
)
17073 last_die
->die_child
= part_die
;
17075 last_die
->die_sibling
= part_die
;
17077 last_die
= part_die
;
17079 if (first_die
== NULL
)
17080 first_die
= part_die
;
17082 /* Maybe add the DIE to the hash table. Not all DIEs that we
17083 find interesting need to be in the hash table, because we
17084 also have the parent/sibling/child chains; only those that we
17085 might refer to by offset later during partial symbol reading.
17087 For now this means things that might have be the target of a
17088 DW_AT_specification, DW_AT_abstract_origin, or
17089 DW_AT_extension. DW_AT_extension will refer only to
17090 namespaces; DW_AT_abstract_origin refers to functions (and
17091 many things under the function DIE, but we do not recurse
17092 into function DIEs during partial symbol reading) and
17093 possibly variables as well; DW_AT_specification refers to
17094 declarations. Declarations ought to have the DW_AT_declaration
17095 flag. It happens that GCC forgets to put it in sometimes, but
17096 only for functions, not for types.
17098 Adding more things than necessary to the hash table is harmless
17099 except for the performance cost. Adding too few will result in
17100 wasted time in find_partial_die, when we reread the compilation
17101 unit with load_all_dies set. */
17104 || abbrev
->tag
== DW_TAG_constant
17105 || abbrev
->tag
== DW_TAG_subprogram
17106 || abbrev
->tag
== DW_TAG_variable
17107 || abbrev
->tag
== DW_TAG_namespace
17108 || part_die
->is_declaration
)
17112 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
17113 to_underlying (part_die
->sect_off
),
17118 part_die
= XOBNEW (&cu
->comp_unit_obstack
, struct partial_die_info
);
17120 /* For some DIEs we want to follow their children (if any). For C
17121 we have no reason to follow the children of structures; for other
17122 languages we have to, so that we can get at method physnames
17123 to infer fully qualified class names, for DW_AT_specification,
17124 and for C++ template arguments. For C++, we also look one level
17125 inside functions to find template arguments (if the name of the
17126 function does not already contain the template arguments).
17128 For Ada, we need to scan the children of subprograms and lexical
17129 blocks as well because Ada allows the definition of nested
17130 entities that could be interesting for the debugger, such as
17131 nested subprograms for instance. */
17132 if (last_die
->has_children
17134 || last_die
->tag
== DW_TAG_namespace
17135 || last_die
->tag
== DW_TAG_module
17136 || last_die
->tag
== DW_TAG_enumeration_type
17137 || (cu
->language
== language_cplus
17138 && last_die
->tag
== DW_TAG_subprogram
17139 && (last_die
->name
== NULL
17140 || strchr (last_die
->name
, '<') == NULL
))
17141 || (cu
->language
!= language_c
17142 && (last_die
->tag
== DW_TAG_class_type
17143 || last_die
->tag
== DW_TAG_interface_type
17144 || last_die
->tag
== DW_TAG_structure_type
17145 || last_die
->tag
== DW_TAG_union_type
))
17146 || (cu
->language
== language_ada
17147 && (last_die
->tag
== DW_TAG_subprogram
17148 || last_die
->tag
== DW_TAG_lexical_block
))))
17151 parent_die
= last_die
;
17155 /* Otherwise we skip to the next sibling, if any. */
17156 info_ptr
= locate_pdi_sibling (reader
, last_die
, info_ptr
);
17158 /* Back to the top, do it again. */
17162 /* Read a minimal amount of information into the minimal die structure. */
17164 static const gdb_byte
*
17165 read_partial_die (const struct die_reader_specs
*reader
,
17166 struct partial_die_info
*part_die
,
17167 struct abbrev_info
*abbrev
, unsigned int abbrev_len
,
17168 const gdb_byte
*info_ptr
)
17170 struct dwarf2_cu
*cu
= reader
->cu
;
17171 struct objfile
*objfile
= cu
->objfile
;
17172 const gdb_byte
*buffer
= reader
->buffer
;
17174 struct attribute attr
;
17175 int has_low_pc_attr
= 0;
17176 int has_high_pc_attr
= 0;
17177 int high_pc_relative
= 0;
17179 memset (part_die
, 0, sizeof (struct partial_die_info
));
17181 part_die
->sect_off
= (sect_offset
) (info_ptr
- buffer
);
17183 info_ptr
+= abbrev_len
;
17185 if (abbrev
== NULL
)
17188 part_die
->tag
= abbrev
->tag
;
17189 part_die
->has_children
= abbrev
->has_children
;
17191 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
17193 info_ptr
= read_attribute (reader
, &attr
, &abbrev
->attrs
[i
], info_ptr
);
17195 /* Store the data if it is of an attribute we want to keep in a
17196 partial symbol table. */
17200 switch (part_die
->tag
)
17202 case DW_TAG_compile_unit
:
17203 case DW_TAG_partial_unit
:
17204 case DW_TAG_type_unit
:
17205 /* Compilation units have a DW_AT_name that is a filename, not
17206 a source language identifier. */
17207 case DW_TAG_enumeration_type
:
17208 case DW_TAG_enumerator
:
17209 /* These tags always have simple identifiers already; no need
17210 to canonicalize them. */
17211 part_die
->name
= DW_STRING (&attr
);
17215 = dwarf2_canonicalize_name (DW_STRING (&attr
), cu
,
17216 &objfile
->per_bfd
->storage_obstack
);
17220 case DW_AT_linkage_name
:
17221 case DW_AT_MIPS_linkage_name
:
17222 /* Note that both forms of linkage name might appear. We
17223 assume they will be the same, and we only store the last
17225 if (cu
->language
== language_ada
)
17226 part_die
->name
= DW_STRING (&attr
);
17227 part_die
->linkage_name
= DW_STRING (&attr
);
17230 has_low_pc_attr
= 1;
17231 part_die
->lowpc
= attr_value_as_address (&attr
);
17233 case DW_AT_high_pc
:
17234 has_high_pc_attr
= 1;
17235 part_die
->highpc
= attr_value_as_address (&attr
);
17236 if (cu
->header
.version
>= 4 && attr_form_is_constant (&attr
))
17237 high_pc_relative
= 1;
17239 case DW_AT_location
:
17240 /* Support the .debug_loc offsets. */
17241 if (attr_form_is_block (&attr
))
17243 part_die
->d
.locdesc
= DW_BLOCK (&attr
);
17245 else if (attr_form_is_section_offset (&attr
))
17247 dwarf2_complex_location_expr_complaint ();
17251 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
17252 "partial symbol information");
17255 case DW_AT_external
:
17256 part_die
->is_external
= DW_UNSND (&attr
);
17258 case DW_AT_declaration
:
17259 part_die
->is_declaration
= DW_UNSND (&attr
);
17262 part_die
->has_type
= 1;
17264 case DW_AT_abstract_origin
:
17265 case DW_AT_specification
:
17266 case DW_AT_extension
:
17267 part_die
->has_specification
= 1;
17268 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
);
17269 part_die
->spec_is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
17270 || cu
->per_cu
->is_dwz
);
17272 case DW_AT_sibling
:
17273 /* Ignore absolute siblings, they might point outside of
17274 the current compile unit. */
17275 if (attr
.form
== DW_FORM_ref_addr
)
17276 complaint (&symfile_complaints
,
17277 _("ignoring absolute DW_AT_sibling"));
17280 sect_offset off
= dwarf2_get_ref_die_offset (&attr
);
17281 const gdb_byte
*sibling_ptr
= buffer
+ to_underlying (off
);
17283 if (sibling_ptr
< info_ptr
)
17284 complaint (&symfile_complaints
,
17285 _("DW_AT_sibling points backwards"));
17286 else if (sibling_ptr
> reader
->buffer_end
)
17287 dwarf2_section_buffer_overflow_complaint (reader
->die_section
);
17289 part_die
->sibling
= sibling_ptr
;
17292 case DW_AT_byte_size
:
17293 part_die
->has_byte_size
= 1;
17295 case DW_AT_const_value
:
17296 part_die
->has_const_value
= 1;
17298 case DW_AT_calling_convention
:
17299 /* DWARF doesn't provide a way to identify a program's source-level
17300 entry point. DW_AT_calling_convention attributes are only meant
17301 to describe functions' calling conventions.
17303 However, because it's a necessary piece of information in
17304 Fortran, and before DWARF 4 DW_CC_program was the only
17305 piece of debugging information whose definition refers to
17306 a 'main program' at all, several compilers marked Fortran
17307 main programs with DW_CC_program --- even when those
17308 functions use the standard calling conventions.
17310 Although DWARF now specifies a way to provide this
17311 information, we support this practice for backward
17313 if (DW_UNSND (&attr
) == DW_CC_program
17314 && cu
->language
== language_fortran
)
17315 part_die
->main_subprogram
= 1;
17318 if (DW_UNSND (&attr
) == DW_INL_inlined
17319 || DW_UNSND (&attr
) == DW_INL_declared_inlined
)
17320 part_die
->may_be_inlined
= 1;
17324 if (part_die
->tag
== DW_TAG_imported_unit
)
17326 part_die
->d
.sect_off
= dwarf2_get_ref_die_offset (&attr
);
17327 part_die
->is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
17328 || cu
->per_cu
->is_dwz
);
17332 case DW_AT_main_subprogram
:
17333 part_die
->main_subprogram
= DW_UNSND (&attr
);
17341 if (high_pc_relative
)
17342 part_die
->highpc
+= part_die
->lowpc
;
17344 if (has_low_pc_attr
&& has_high_pc_attr
)
17346 /* When using the GNU linker, .gnu.linkonce. sections are used to
17347 eliminate duplicate copies of functions and vtables and such.
17348 The linker will arbitrarily choose one and discard the others.
17349 The AT_*_pc values for such functions refer to local labels in
17350 these sections. If the section from that file was discarded, the
17351 labels are not in the output, so the relocs get a value of 0.
17352 If this is a discarded function, mark the pc bounds as invalid,
17353 so that GDB will ignore it. */
17354 if (part_die
->lowpc
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
17356 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
17358 complaint (&symfile_complaints
,
17359 _("DW_AT_low_pc %s is zero "
17360 "for DIE at 0x%x [in module %s]"),
17361 paddress (gdbarch
, part_die
->lowpc
),
17362 to_underlying (part_die
->sect_off
), objfile_name (objfile
));
17364 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
17365 else if (part_die
->lowpc
>= part_die
->highpc
)
17367 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
17369 complaint (&symfile_complaints
,
17370 _("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
17371 "for DIE at 0x%x [in module %s]"),
17372 paddress (gdbarch
, part_die
->lowpc
),
17373 paddress (gdbarch
, part_die
->highpc
),
17374 to_underlying (part_die
->sect_off
),
17375 objfile_name (objfile
));
17378 part_die
->has_pc_info
= 1;
17384 /* Find a cached partial DIE at OFFSET in CU. */
17386 static struct partial_die_info
*
17387 find_partial_die_in_comp_unit (sect_offset sect_off
, struct dwarf2_cu
*cu
)
17389 struct partial_die_info
*lookup_die
= NULL
;
17390 struct partial_die_info part_die
;
17392 part_die
.sect_off
= sect_off
;
17393 lookup_die
= ((struct partial_die_info
*)
17394 htab_find_with_hash (cu
->partial_dies
, &part_die
,
17395 to_underlying (sect_off
)));
17400 /* Find a partial DIE at OFFSET, which may or may not be in CU,
17401 except in the case of .debug_types DIEs which do not reference
17402 outside their CU (they do however referencing other types via
17403 DW_FORM_ref_sig8). */
17405 static struct partial_die_info
*
17406 find_partial_die (sect_offset sect_off
, int offset_in_dwz
, struct dwarf2_cu
*cu
)
17408 struct objfile
*objfile
= cu
->objfile
;
17409 struct dwarf2_per_cu_data
*per_cu
= NULL
;
17410 struct partial_die_info
*pd
= NULL
;
17412 if (offset_in_dwz
== cu
->per_cu
->is_dwz
17413 && offset_in_cu_p (&cu
->header
, sect_off
))
17415 pd
= find_partial_die_in_comp_unit (sect_off
, cu
);
17418 /* We missed recording what we needed.
17419 Load all dies and try again. */
17420 per_cu
= cu
->per_cu
;
17424 /* TUs don't reference other CUs/TUs (except via type signatures). */
17425 if (cu
->per_cu
->is_debug_types
)
17427 error (_("Dwarf Error: Type Unit at offset 0x%x contains"
17428 " external reference to offset 0x%x [in module %s].\n"),
17429 to_underlying (cu
->header
.sect_off
), to_underlying (sect_off
),
17430 bfd_get_filename (objfile
->obfd
));
17432 per_cu
= dwarf2_find_containing_comp_unit (sect_off
, offset_in_dwz
,
17435 if (per_cu
->cu
== NULL
|| per_cu
->cu
->partial_dies
== NULL
)
17436 load_partial_comp_unit (per_cu
);
17438 per_cu
->cu
->last_used
= 0;
17439 pd
= find_partial_die_in_comp_unit (sect_off
, per_cu
->cu
);
17442 /* If we didn't find it, and not all dies have been loaded,
17443 load them all and try again. */
17445 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
17447 per_cu
->load_all_dies
= 1;
17449 /* This is nasty. When we reread the DIEs, somewhere up the call chain
17450 THIS_CU->cu may already be in use. So we can't just free it and
17451 replace its DIEs with the ones we read in. Instead, we leave those
17452 DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
17453 and clobber THIS_CU->cu->partial_dies with the hash table for the new
17455 load_partial_comp_unit (per_cu
);
17457 pd
= find_partial_die_in_comp_unit (sect_off
, per_cu
->cu
);
17461 internal_error (__FILE__
, __LINE__
,
17462 _("could not find partial DIE 0x%x "
17463 "in cache [from module %s]\n"),
17464 to_underlying (sect_off
), bfd_get_filename (objfile
->obfd
));
17468 /* See if we can figure out if the class lives in a namespace. We do
17469 this by looking for a member function; its demangled name will
17470 contain namespace info, if there is any. */
17473 guess_partial_die_structure_name (struct partial_die_info
*struct_pdi
,
17474 struct dwarf2_cu
*cu
)
17476 /* NOTE: carlton/2003-10-07: Getting the info this way changes
17477 what template types look like, because the demangler
17478 frequently doesn't give the same name as the debug info. We
17479 could fix this by only using the demangled name to get the
17480 prefix (but see comment in read_structure_type). */
17482 struct partial_die_info
*real_pdi
;
17483 struct partial_die_info
*child_pdi
;
17485 /* If this DIE (this DIE's specification, if any) has a parent, then
17486 we should not do this. We'll prepend the parent's fully qualified
17487 name when we create the partial symbol. */
17489 real_pdi
= struct_pdi
;
17490 while (real_pdi
->has_specification
)
17491 real_pdi
= find_partial_die (real_pdi
->spec_offset
,
17492 real_pdi
->spec_is_dwz
, cu
);
17494 if (real_pdi
->die_parent
!= NULL
)
17497 for (child_pdi
= struct_pdi
->die_child
;
17499 child_pdi
= child_pdi
->die_sibling
)
17501 if (child_pdi
->tag
== DW_TAG_subprogram
17502 && child_pdi
->linkage_name
!= NULL
)
17504 char *actual_class_name
17505 = language_class_name_from_physname (cu
->language_defn
,
17506 child_pdi
->linkage_name
);
17507 if (actual_class_name
!= NULL
)
17511 obstack_copy0 (&cu
->objfile
->per_bfd
->storage_obstack
,
17513 strlen (actual_class_name
)));
17514 xfree (actual_class_name
);
17521 /* Adjust PART_DIE before generating a symbol for it. This function
17522 may set the is_external flag or change the DIE's name. */
17525 fixup_partial_die (struct partial_die_info
*part_die
,
17526 struct dwarf2_cu
*cu
)
17528 /* Once we've fixed up a die, there's no point in doing so again.
17529 This also avoids a memory leak if we were to call
17530 guess_partial_die_structure_name multiple times. */
17531 if (part_die
->fixup_called
)
17534 /* If we found a reference attribute and the DIE has no name, try
17535 to find a name in the referred to DIE. */
17537 if (part_die
->name
== NULL
&& part_die
->has_specification
)
17539 struct partial_die_info
*spec_die
;
17541 spec_die
= find_partial_die (part_die
->spec_offset
,
17542 part_die
->spec_is_dwz
, cu
);
17544 fixup_partial_die (spec_die
, cu
);
17546 if (spec_die
->name
)
17548 part_die
->name
= spec_die
->name
;
17550 /* Copy DW_AT_external attribute if it is set. */
17551 if (spec_die
->is_external
)
17552 part_die
->is_external
= spec_die
->is_external
;
17556 /* Set default names for some unnamed DIEs. */
17558 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
17559 part_die
->name
= CP_ANONYMOUS_NAMESPACE_STR
;
17561 /* If there is no parent die to provide a namespace, and there are
17562 children, see if we can determine the namespace from their linkage
17564 if (cu
->language
== language_cplus
17565 && !VEC_empty (dwarf2_section_info_def
, dwarf2_per_objfile
->types
)
17566 && part_die
->die_parent
== NULL
17567 && part_die
->has_children
17568 && (part_die
->tag
== DW_TAG_class_type
17569 || part_die
->tag
== DW_TAG_structure_type
17570 || part_die
->tag
== DW_TAG_union_type
))
17571 guess_partial_die_structure_name (part_die
, cu
);
17573 /* GCC might emit a nameless struct or union that has a linkage
17574 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
17575 if (part_die
->name
== NULL
17576 && (part_die
->tag
== DW_TAG_class_type
17577 || part_die
->tag
== DW_TAG_interface_type
17578 || part_die
->tag
== DW_TAG_structure_type
17579 || part_die
->tag
== DW_TAG_union_type
)
17580 && part_die
->linkage_name
!= NULL
)
17584 demangled
= gdb_demangle (part_die
->linkage_name
, DMGL_TYPES
);
17589 /* Strip any leading namespaces/classes, keep only the base name.
17590 DW_AT_name for named DIEs does not contain the prefixes. */
17591 base
= strrchr (demangled
, ':');
17592 if (base
&& base
> demangled
&& base
[-1] == ':')
17599 obstack_copy0 (&cu
->objfile
->per_bfd
->storage_obstack
,
17600 base
, strlen (base
)));
17605 part_die
->fixup_called
= 1;
17608 /* Read an attribute value described by an attribute form. */
17610 static const gdb_byte
*
17611 read_attribute_value (const struct die_reader_specs
*reader
,
17612 struct attribute
*attr
, unsigned form
,
17613 LONGEST implicit_const
, const gdb_byte
*info_ptr
)
17615 struct dwarf2_cu
*cu
= reader
->cu
;
17616 struct objfile
*objfile
= cu
->objfile
;
17617 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
17618 bfd
*abfd
= reader
->abfd
;
17619 struct comp_unit_head
*cu_header
= &cu
->header
;
17620 unsigned int bytes_read
;
17621 struct dwarf_block
*blk
;
17623 attr
->form
= (enum dwarf_form
) form
;
17626 case DW_FORM_ref_addr
:
17627 if (cu
->header
.version
== 2)
17628 DW_UNSND (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
17630 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
,
17631 &cu
->header
, &bytes_read
);
17632 info_ptr
+= bytes_read
;
17634 case DW_FORM_GNU_ref_alt
:
17635 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
17636 info_ptr
+= bytes_read
;
17639 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
17640 DW_ADDR (attr
) = gdbarch_adjust_dwarf2_addr (gdbarch
, DW_ADDR (attr
));
17641 info_ptr
+= bytes_read
;
17643 case DW_FORM_block2
:
17644 blk
= dwarf_alloc_block (cu
);
17645 blk
->size
= read_2_bytes (abfd
, info_ptr
);
17647 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
17648 info_ptr
+= blk
->size
;
17649 DW_BLOCK (attr
) = blk
;
17651 case DW_FORM_block4
:
17652 blk
= dwarf_alloc_block (cu
);
17653 blk
->size
= read_4_bytes (abfd
, info_ptr
);
17655 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
17656 info_ptr
+= blk
->size
;
17657 DW_BLOCK (attr
) = blk
;
17659 case DW_FORM_data2
:
17660 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
17663 case DW_FORM_data4
:
17664 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
17667 case DW_FORM_data8
:
17668 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
17671 case DW_FORM_data16
:
17672 blk
= dwarf_alloc_block (cu
);
17674 blk
->data
= read_n_bytes (abfd
, info_ptr
, 16);
17676 DW_BLOCK (attr
) = blk
;
17678 case DW_FORM_sec_offset
:
17679 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
17680 info_ptr
+= bytes_read
;
17682 case DW_FORM_string
:
17683 DW_STRING (attr
) = read_direct_string (abfd
, info_ptr
, &bytes_read
);
17684 DW_STRING_IS_CANONICAL (attr
) = 0;
17685 info_ptr
+= bytes_read
;
17688 if (!cu
->per_cu
->is_dwz
)
17690 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
17692 DW_STRING_IS_CANONICAL (attr
) = 0;
17693 info_ptr
+= bytes_read
;
17697 case DW_FORM_line_strp
:
17698 if (!cu
->per_cu
->is_dwz
)
17700 DW_STRING (attr
) = read_indirect_line_string (abfd
, info_ptr
,
17701 cu_header
, &bytes_read
);
17702 DW_STRING_IS_CANONICAL (attr
) = 0;
17703 info_ptr
+= bytes_read
;
17707 case DW_FORM_GNU_strp_alt
:
17709 struct dwz_file
*dwz
= dwarf2_get_dwz_file ();
17710 LONGEST str_offset
= read_offset (abfd
, info_ptr
, cu_header
,
17713 DW_STRING (attr
) = read_indirect_string_from_dwz (dwz
, str_offset
);
17714 DW_STRING_IS_CANONICAL (attr
) = 0;
17715 info_ptr
+= bytes_read
;
17718 case DW_FORM_exprloc
:
17719 case DW_FORM_block
:
17720 blk
= dwarf_alloc_block (cu
);
17721 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
17722 info_ptr
+= bytes_read
;
17723 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
17724 info_ptr
+= blk
->size
;
17725 DW_BLOCK (attr
) = blk
;
17727 case DW_FORM_block1
:
17728 blk
= dwarf_alloc_block (cu
);
17729 blk
->size
= read_1_byte (abfd
, info_ptr
);
17731 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
17732 info_ptr
+= blk
->size
;
17733 DW_BLOCK (attr
) = blk
;
17735 case DW_FORM_data1
:
17736 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
17740 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
17743 case DW_FORM_flag_present
:
17744 DW_UNSND (attr
) = 1;
17746 case DW_FORM_sdata
:
17747 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
17748 info_ptr
+= bytes_read
;
17750 case DW_FORM_udata
:
17751 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
17752 info_ptr
+= bytes_read
;
17755 DW_UNSND (attr
) = (to_underlying (cu
->header
.sect_off
)
17756 + read_1_byte (abfd
, info_ptr
));
17760 DW_UNSND (attr
) = (to_underlying (cu
->header
.sect_off
)
17761 + read_2_bytes (abfd
, info_ptr
));
17765 DW_UNSND (attr
) = (to_underlying (cu
->header
.sect_off
)
17766 + read_4_bytes (abfd
, info_ptr
));
17770 DW_UNSND (attr
) = (to_underlying (cu
->header
.sect_off
)
17771 + read_8_bytes (abfd
, info_ptr
));
17774 case DW_FORM_ref_sig8
:
17775 DW_SIGNATURE (attr
) = read_8_bytes (abfd
, info_ptr
);
17778 case DW_FORM_ref_udata
:
17779 DW_UNSND (attr
) = (to_underlying (cu
->header
.sect_off
)
17780 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
17781 info_ptr
+= bytes_read
;
17783 case DW_FORM_indirect
:
17784 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
17785 info_ptr
+= bytes_read
;
17786 if (form
== DW_FORM_implicit_const
)
17788 implicit_const
= read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
17789 info_ptr
+= bytes_read
;
17791 info_ptr
= read_attribute_value (reader
, attr
, form
, implicit_const
,
17794 case DW_FORM_implicit_const
:
17795 DW_SND (attr
) = implicit_const
;
17797 case DW_FORM_GNU_addr_index
:
17798 if (reader
->dwo_file
== NULL
)
17800 /* For now flag a hard error.
17801 Later we can turn this into a complaint. */
17802 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
17803 dwarf_form_name (form
),
17804 bfd_get_filename (abfd
));
17806 DW_ADDR (attr
) = read_addr_index_from_leb128 (cu
, info_ptr
, &bytes_read
);
17807 info_ptr
+= bytes_read
;
17809 case DW_FORM_GNU_str_index
:
17810 if (reader
->dwo_file
== NULL
)
17812 /* For now flag a hard error.
17813 Later we can turn this into a complaint if warranted. */
17814 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
17815 dwarf_form_name (form
),
17816 bfd_get_filename (abfd
));
17819 ULONGEST str_index
=
17820 read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
17822 DW_STRING (attr
) = read_str_index (reader
, str_index
);
17823 DW_STRING_IS_CANONICAL (attr
) = 0;
17824 info_ptr
+= bytes_read
;
17828 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
17829 dwarf_form_name (form
),
17830 bfd_get_filename (abfd
));
17834 if (cu
->per_cu
->is_dwz
&& attr_form_is_ref (attr
))
17835 attr
->form
= DW_FORM_GNU_ref_alt
;
17837 /* We have seen instances where the compiler tried to emit a byte
17838 size attribute of -1 which ended up being encoded as an unsigned
17839 0xffffffff. Although 0xffffffff is technically a valid size value,
17840 an object of this size seems pretty unlikely so we can relatively
17841 safely treat these cases as if the size attribute was invalid and
17842 treat them as zero by default. */
17843 if (attr
->name
== DW_AT_byte_size
17844 && form
== DW_FORM_data4
17845 && DW_UNSND (attr
) >= 0xffffffff)
17848 (&symfile_complaints
,
17849 _("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
17850 hex_string (DW_UNSND (attr
)));
17851 DW_UNSND (attr
) = 0;
17857 /* Read an attribute described by an abbreviated attribute. */
17859 static const gdb_byte
*
17860 read_attribute (const struct die_reader_specs
*reader
,
17861 struct attribute
*attr
, struct attr_abbrev
*abbrev
,
17862 const gdb_byte
*info_ptr
)
17864 attr
->name
= abbrev
->name
;
17865 return read_attribute_value (reader
, attr
, abbrev
->form
,
17866 abbrev
->implicit_const
, info_ptr
);
17869 /* Read dwarf information from a buffer. */
17871 static unsigned int
17872 read_1_byte (bfd
*abfd
, const gdb_byte
*buf
)
17874 return bfd_get_8 (abfd
, buf
);
17878 read_1_signed_byte (bfd
*abfd
, const gdb_byte
*buf
)
17880 return bfd_get_signed_8 (abfd
, buf
);
17883 static unsigned int
17884 read_2_bytes (bfd
*abfd
, const gdb_byte
*buf
)
17886 return bfd_get_16 (abfd
, buf
);
17890 read_2_signed_bytes (bfd
*abfd
, const gdb_byte
*buf
)
17892 return bfd_get_signed_16 (abfd
, buf
);
17895 static unsigned int
17896 read_4_bytes (bfd
*abfd
, const gdb_byte
*buf
)
17898 return bfd_get_32 (abfd
, buf
);
17902 read_4_signed_bytes (bfd
*abfd
, const gdb_byte
*buf
)
17904 return bfd_get_signed_32 (abfd
, buf
);
17908 read_8_bytes (bfd
*abfd
, const gdb_byte
*buf
)
17910 return bfd_get_64 (abfd
, buf
);
17914 read_address (bfd
*abfd
, const gdb_byte
*buf
, struct dwarf2_cu
*cu
,
17915 unsigned int *bytes_read
)
17917 struct comp_unit_head
*cu_header
= &cu
->header
;
17918 CORE_ADDR retval
= 0;
17920 if (cu_header
->signed_addr_p
)
17922 switch (cu_header
->addr_size
)
17925 retval
= bfd_get_signed_16 (abfd
, buf
);
17928 retval
= bfd_get_signed_32 (abfd
, buf
);
17931 retval
= bfd_get_signed_64 (abfd
, buf
);
17934 internal_error (__FILE__
, __LINE__
,
17935 _("read_address: bad switch, signed [in module %s]"),
17936 bfd_get_filename (abfd
));
17941 switch (cu_header
->addr_size
)
17944 retval
= bfd_get_16 (abfd
, buf
);
17947 retval
= bfd_get_32 (abfd
, buf
);
17950 retval
= bfd_get_64 (abfd
, buf
);
17953 internal_error (__FILE__
, __LINE__
,
17954 _("read_address: bad switch, "
17955 "unsigned [in module %s]"),
17956 bfd_get_filename (abfd
));
17960 *bytes_read
= cu_header
->addr_size
;
17964 /* Read the initial length from a section. The (draft) DWARF 3
17965 specification allows the initial length to take up either 4 bytes
17966 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
17967 bytes describe the length and all offsets will be 8 bytes in length
17970 An older, non-standard 64-bit format is also handled by this
17971 function. The older format in question stores the initial length
17972 as an 8-byte quantity without an escape value. Lengths greater
17973 than 2^32 aren't very common which means that the initial 4 bytes
17974 is almost always zero. Since a length value of zero doesn't make
17975 sense for the 32-bit format, this initial zero can be considered to
17976 be an escape value which indicates the presence of the older 64-bit
17977 format. As written, the code can't detect (old format) lengths
17978 greater than 4GB. If it becomes necessary to handle lengths
17979 somewhat larger than 4GB, we could allow other small values (such
17980 as the non-sensical values of 1, 2, and 3) to also be used as
17981 escape values indicating the presence of the old format.
17983 The value returned via bytes_read should be used to increment the
17984 relevant pointer after calling read_initial_length().
17986 [ Note: read_initial_length() and read_offset() are based on the
17987 document entitled "DWARF Debugging Information Format", revision
17988 3, draft 8, dated November 19, 2001. This document was obtained
17991 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
17993 This document is only a draft and is subject to change. (So beware.)
17995 Details regarding the older, non-standard 64-bit format were
17996 determined empirically by examining 64-bit ELF files produced by
17997 the SGI toolchain on an IRIX 6.5 machine.
17999 - Kevin, July 16, 2002
18003 read_initial_length (bfd
*abfd
, const gdb_byte
*buf
, unsigned int *bytes_read
)
18005 LONGEST length
= bfd_get_32 (abfd
, buf
);
18007 if (length
== 0xffffffff)
18009 length
= bfd_get_64 (abfd
, buf
+ 4);
18012 else if (length
== 0)
18014 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
18015 length
= bfd_get_64 (abfd
, buf
);
18026 /* Cover function for read_initial_length.
18027 Returns the length of the object at BUF, and stores the size of the
18028 initial length in *BYTES_READ and stores the size that offsets will be in
18030 If the initial length size is not equivalent to that specified in
18031 CU_HEADER then issue a complaint.
18032 This is useful when reading non-comp-unit headers. */
18035 read_checked_initial_length_and_offset (bfd
*abfd
, const gdb_byte
*buf
,
18036 const struct comp_unit_head
*cu_header
,
18037 unsigned int *bytes_read
,
18038 unsigned int *offset_size
)
18040 LONGEST length
= read_initial_length (abfd
, buf
, bytes_read
);
18042 gdb_assert (cu_header
->initial_length_size
== 4
18043 || cu_header
->initial_length_size
== 8
18044 || cu_header
->initial_length_size
== 12);
18046 if (cu_header
->initial_length_size
!= *bytes_read
)
18047 complaint (&symfile_complaints
,
18048 _("intermixed 32-bit and 64-bit DWARF sections"));
18050 *offset_size
= (*bytes_read
== 4) ? 4 : 8;
18054 /* Read an offset from the data stream. The size of the offset is
18055 given by cu_header->offset_size. */
18058 read_offset (bfd
*abfd
, const gdb_byte
*buf
,
18059 const struct comp_unit_head
*cu_header
,
18060 unsigned int *bytes_read
)
18062 LONGEST offset
= read_offset_1 (abfd
, buf
, cu_header
->offset_size
);
18064 *bytes_read
= cu_header
->offset_size
;
18068 /* Read an offset from the data stream. */
18071 read_offset_1 (bfd
*abfd
, const gdb_byte
*buf
, unsigned int offset_size
)
18073 LONGEST retval
= 0;
18075 switch (offset_size
)
18078 retval
= bfd_get_32 (abfd
, buf
);
18081 retval
= bfd_get_64 (abfd
, buf
);
18084 internal_error (__FILE__
, __LINE__
,
18085 _("read_offset_1: bad switch [in module %s]"),
18086 bfd_get_filename (abfd
));
18092 static const gdb_byte
*
18093 read_n_bytes (bfd
*abfd
, const gdb_byte
*buf
, unsigned int size
)
18095 /* If the size of a host char is 8 bits, we can return a pointer
18096 to the buffer, otherwise we have to copy the data to a buffer
18097 allocated on the temporary obstack. */
18098 gdb_assert (HOST_CHAR_BIT
== 8);
18102 static const char *
18103 read_direct_string (bfd
*abfd
, const gdb_byte
*buf
,
18104 unsigned int *bytes_read_ptr
)
18106 /* If the size of a host char is 8 bits, we can return a pointer
18107 to the string, otherwise we have to copy the string to a buffer
18108 allocated on the temporary obstack. */
18109 gdb_assert (HOST_CHAR_BIT
== 8);
18112 *bytes_read_ptr
= 1;
18115 *bytes_read_ptr
= strlen ((const char *) buf
) + 1;
18116 return (const char *) buf
;
18119 /* Return pointer to string at section SECT offset STR_OFFSET with error
18120 reporting strings FORM_NAME and SECT_NAME. */
18122 static const char *
18123 read_indirect_string_at_offset_from (bfd
*abfd
, LONGEST str_offset
,
18124 struct dwarf2_section_info
*sect
,
18125 const char *form_name
,
18126 const char *sect_name
)
18128 dwarf2_read_section (dwarf2_per_objfile
->objfile
, sect
);
18129 if (sect
->buffer
== NULL
)
18130 error (_("%s used without %s section [in module %s]"),
18131 form_name
, sect_name
, bfd_get_filename (abfd
));
18132 if (str_offset
>= sect
->size
)
18133 error (_("%s pointing outside of %s section [in module %s]"),
18134 form_name
, sect_name
, bfd_get_filename (abfd
));
18135 gdb_assert (HOST_CHAR_BIT
== 8);
18136 if (sect
->buffer
[str_offset
] == '\0')
18138 return (const char *) (sect
->buffer
+ str_offset
);
18141 /* Return pointer to string at .debug_str offset STR_OFFSET. */
18143 static const char *
18144 read_indirect_string_at_offset (bfd
*abfd
, LONGEST str_offset
)
18146 return read_indirect_string_at_offset_from (abfd
, str_offset
,
18147 &dwarf2_per_objfile
->str
,
18148 "DW_FORM_strp", ".debug_str");
18151 /* Return pointer to string at .debug_line_str offset STR_OFFSET. */
18153 static const char *
18154 read_indirect_line_string_at_offset (bfd
*abfd
, LONGEST str_offset
)
18156 return read_indirect_string_at_offset_from (abfd
, str_offset
,
18157 &dwarf2_per_objfile
->line_str
,
18158 "DW_FORM_line_strp",
18159 ".debug_line_str");
18162 /* Read a string at offset STR_OFFSET in the .debug_str section from
18163 the .dwz file DWZ. Throw an error if the offset is too large. If
18164 the string consists of a single NUL byte, return NULL; otherwise
18165 return a pointer to the string. */
18167 static const char *
18168 read_indirect_string_from_dwz (struct dwz_file
*dwz
, LONGEST str_offset
)
18170 dwarf2_read_section (dwarf2_per_objfile
->objfile
, &dwz
->str
);
18172 if (dwz
->str
.buffer
== NULL
)
18173 error (_("DW_FORM_GNU_strp_alt used without .debug_str "
18174 "section [in module %s]"),
18175 bfd_get_filename (dwz
->dwz_bfd
));
18176 if (str_offset
>= dwz
->str
.size
)
18177 error (_("DW_FORM_GNU_strp_alt pointing outside of "
18178 ".debug_str section [in module %s]"),
18179 bfd_get_filename (dwz
->dwz_bfd
));
18180 gdb_assert (HOST_CHAR_BIT
== 8);
18181 if (dwz
->str
.buffer
[str_offset
] == '\0')
18183 return (const char *) (dwz
->str
.buffer
+ str_offset
);
18186 /* Return pointer to string at .debug_str offset as read from BUF.
18187 BUF is assumed to be in a compilation unit described by CU_HEADER.
18188 Return *BYTES_READ_PTR count of bytes read from BUF. */
18190 static const char *
18191 read_indirect_string (bfd
*abfd
, const gdb_byte
*buf
,
18192 const struct comp_unit_head
*cu_header
,
18193 unsigned int *bytes_read_ptr
)
18195 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
, bytes_read_ptr
);
18197 return read_indirect_string_at_offset (abfd
, str_offset
);
18200 /* Return pointer to string at .debug_line_str offset as read from BUF.
18201 BUF is assumed to be in a compilation unit described by CU_HEADER.
18202 Return *BYTES_READ_PTR count of bytes read from BUF. */
18204 static const char *
18205 read_indirect_line_string (bfd
*abfd
, const gdb_byte
*buf
,
18206 const struct comp_unit_head
*cu_header
,
18207 unsigned int *bytes_read_ptr
)
18209 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
, bytes_read_ptr
);
18211 return read_indirect_line_string_at_offset (abfd
, str_offset
);
18215 read_unsigned_leb128 (bfd
*abfd
, const gdb_byte
*buf
,
18216 unsigned int *bytes_read_ptr
)
18219 unsigned int num_read
;
18221 unsigned char byte
;
18228 byte
= bfd_get_8 (abfd
, buf
);
18231 result
|= ((ULONGEST
) (byte
& 127) << shift
);
18232 if ((byte
& 128) == 0)
18238 *bytes_read_ptr
= num_read
;
18243 read_signed_leb128 (bfd
*abfd
, const gdb_byte
*buf
,
18244 unsigned int *bytes_read_ptr
)
18247 int shift
, num_read
;
18248 unsigned char byte
;
18255 byte
= bfd_get_8 (abfd
, buf
);
18258 result
|= ((LONGEST
) (byte
& 127) << shift
);
18260 if ((byte
& 128) == 0)
18265 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
18266 result
|= -(((LONGEST
) 1) << shift
);
18267 *bytes_read_ptr
= num_read
;
18271 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
18272 ADDR_BASE is the DW_AT_GNU_addr_base attribute or zero.
18273 ADDR_SIZE is the size of addresses from the CU header. */
18276 read_addr_index_1 (unsigned int addr_index
, ULONGEST addr_base
, int addr_size
)
18278 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
18279 bfd
*abfd
= objfile
->obfd
;
18280 const gdb_byte
*info_ptr
;
18282 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->addr
);
18283 if (dwarf2_per_objfile
->addr
.buffer
== NULL
)
18284 error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
18285 objfile_name (objfile
));
18286 if (addr_base
+ addr_index
* addr_size
>= dwarf2_per_objfile
->addr
.size
)
18287 error (_("DW_FORM_addr_index pointing outside of "
18288 ".debug_addr section [in module %s]"),
18289 objfile_name (objfile
));
18290 info_ptr
= (dwarf2_per_objfile
->addr
.buffer
18291 + addr_base
+ addr_index
* addr_size
);
18292 if (addr_size
== 4)
18293 return bfd_get_32 (abfd
, info_ptr
);
18295 return bfd_get_64 (abfd
, info_ptr
);
18298 /* Given index ADDR_INDEX in .debug_addr, fetch the value. */
18301 read_addr_index (struct dwarf2_cu
*cu
, unsigned int addr_index
)
18303 return read_addr_index_1 (addr_index
, cu
->addr_base
, cu
->header
.addr_size
);
18306 /* Given a pointer to an leb128 value, fetch the value from .debug_addr. */
18309 read_addr_index_from_leb128 (struct dwarf2_cu
*cu
, const gdb_byte
*info_ptr
,
18310 unsigned int *bytes_read
)
18312 bfd
*abfd
= cu
->objfile
->obfd
;
18313 unsigned int addr_index
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
18315 return read_addr_index (cu
, addr_index
);
18318 /* Data structure to pass results from dwarf2_read_addr_index_reader
18319 back to dwarf2_read_addr_index. */
18321 struct dwarf2_read_addr_index_data
18323 ULONGEST addr_base
;
18327 /* die_reader_func for dwarf2_read_addr_index. */
18330 dwarf2_read_addr_index_reader (const struct die_reader_specs
*reader
,
18331 const gdb_byte
*info_ptr
,
18332 struct die_info
*comp_unit_die
,
18336 struct dwarf2_cu
*cu
= reader
->cu
;
18337 struct dwarf2_read_addr_index_data
*aidata
=
18338 (struct dwarf2_read_addr_index_data
*) data
;
18340 aidata
->addr_base
= cu
->addr_base
;
18341 aidata
->addr_size
= cu
->header
.addr_size
;
18344 /* Given an index in .debug_addr, fetch the value.
18345 NOTE: This can be called during dwarf expression evaluation,
18346 long after the debug information has been read, and thus per_cu->cu
18347 may no longer exist. */
18350 dwarf2_read_addr_index (struct dwarf2_per_cu_data
*per_cu
,
18351 unsigned int addr_index
)
18353 struct objfile
*objfile
= per_cu
->objfile
;
18354 struct dwarf2_cu
*cu
= per_cu
->cu
;
18355 ULONGEST addr_base
;
18358 /* This is intended to be called from outside this file. */
18359 dw2_setup (objfile
);
18361 /* We need addr_base and addr_size.
18362 If we don't have PER_CU->cu, we have to get it.
18363 Nasty, but the alternative is storing the needed info in PER_CU,
18364 which at this point doesn't seem justified: it's not clear how frequently
18365 it would get used and it would increase the size of every PER_CU.
18366 Entry points like dwarf2_per_cu_addr_size do a similar thing
18367 so we're not in uncharted territory here.
18368 Alas we need to be a bit more complicated as addr_base is contained
18371 We don't need to read the entire CU(/TU).
18372 We just need the header and top level die.
18374 IWBN to use the aging mechanism to let us lazily later discard the CU.
18375 For now we skip this optimization. */
18379 addr_base
= cu
->addr_base
;
18380 addr_size
= cu
->header
.addr_size
;
18384 struct dwarf2_read_addr_index_data aidata
;
18386 /* Note: We can't use init_cutu_and_read_dies_simple here,
18387 we need addr_base. */
18388 init_cutu_and_read_dies (per_cu
, NULL
, 0, 0,
18389 dwarf2_read_addr_index_reader
, &aidata
);
18390 addr_base
= aidata
.addr_base
;
18391 addr_size
= aidata
.addr_size
;
18394 return read_addr_index_1 (addr_index
, addr_base
, addr_size
);
18397 /* Given a DW_FORM_GNU_str_index, fetch the string.
18398 This is only used by the Fission support. */
18400 static const char *
18401 read_str_index (const struct die_reader_specs
*reader
, ULONGEST str_index
)
18403 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
18404 const char *objf_name
= objfile_name (objfile
);
18405 bfd
*abfd
= objfile
->obfd
;
18406 struct dwarf2_cu
*cu
= reader
->cu
;
18407 struct dwarf2_section_info
*str_section
= &reader
->dwo_file
->sections
.str
;
18408 struct dwarf2_section_info
*str_offsets_section
=
18409 &reader
->dwo_file
->sections
.str_offsets
;
18410 const gdb_byte
*info_ptr
;
18411 ULONGEST str_offset
;
18412 static const char form_name
[] = "DW_FORM_GNU_str_index";
18414 dwarf2_read_section (objfile
, str_section
);
18415 dwarf2_read_section (objfile
, str_offsets_section
);
18416 if (str_section
->buffer
== NULL
)
18417 error (_("%s used without .debug_str.dwo section"
18418 " in CU at offset 0x%x [in module %s]"),
18419 form_name
, to_underlying (cu
->header
.sect_off
), objf_name
);
18420 if (str_offsets_section
->buffer
== NULL
)
18421 error (_("%s used without .debug_str_offsets.dwo section"
18422 " in CU at offset 0x%x [in module %s]"),
18423 form_name
, to_underlying (cu
->header
.sect_off
), objf_name
);
18424 if (str_index
* cu
->header
.offset_size
>= str_offsets_section
->size
)
18425 error (_("%s pointing outside of .debug_str_offsets.dwo"
18426 " section in CU at offset 0x%x [in module %s]"),
18427 form_name
, to_underlying (cu
->header
.sect_off
), objf_name
);
18428 info_ptr
= (str_offsets_section
->buffer
18429 + str_index
* cu
->header
.offset_size
);
18430 if (cu
->header
.offset_size
== 4)
18431 str_offset
= bfd_get_32 (abfd
, info_ptr
);
18433 str_offset
= bfd_get_64 (abfd
, info_ptr
);
18434 if (str_offset
>= str_section
->size
)
18435 error (_("Offset from %s pointing outside of"
18436 " .debug_str.dwo section in CU at offset 0x%x [in module %s]"),
18437 form_name
, to_underlying (cu
->header
.sect_off
), objf_name
);
18438 return (const char *) (str_section
->buffer
+ str_offset
);
18441 /* Return the length of an LEB128 number in BUF. */
18444 leb128_size (const gdb_byte
*buf
)
18446 const gdb_byte
*begin
= buf
;
18452 if ((byte
& 128) == 0)
18453 return buf
- begin
;
18458 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
18467 cu
->language
= language_c
;
18470 case DW_LANG_C_plus_plus
:
18471 case DW_LANG_C_plus_plus_11
:
18472 case DW_LANG_C_plus_plus_14
:
18473 cu
->language
= language_cplus
;
18476 cu
->language
= language_d
;
18478 case DW_LANG_Fortran77
:
18479 case DW_LANG_Fortran90
:
18480 case DW_LANG_Fortran95
:
18481 case DW_LANG_Fortran03
:
18482 case DW_LANG_Fortran08
:
18483 cu
->language
= language_fortran
;
18486 cu
->language
= language_go
;
18488 case DW_LANG_Mips_Assembler
:
18489 cu
->language
= language_asm
;
18491 case DW_LANG_Ada83
:
18492 case DW_LANG_Ada95
:
18493 cu
->language
= language_ada
;
18495 case DW_LANG_Modula2
:
18496 cu
->language
= language_m2
;
18498 case DW_LANG_Pascal83
:
18499 cu
->language
= language_pascal
;
18502 cu
->language
= language_objc
;
18505 case DW_LANG_Rust_old
:
18506 cu
->language
= language_rust
;
18508 case DW_LANG_Cobol74
:
18509 case DW_LANG_Cobol85
:
18511 cu
->language
= language_minimal
;
18514 cu
->language_defn
= language_def (cu
->language
);
18517 /* Return the named attribute or NULL if not there. */
18519 static struct attribute
*
18520 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
18525 struct attribute
*spec
= NULL
;
18527 for (i
= 0; i
< die
->num_attrs
; ++i
)
18529 if (die
->attrs
[i
].name
== name
)
18530 return &die
->attrs
[i
];
18531 if (die
->attrs
[i
].name
== DW_AT_specification
18532 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
18533 spec
= &die
->attrs
[i
];
18539 die
= follow_die_ref (die
, spec
, &cu
);
18545 /* Return the named attribute or NULL if not there,
18546 but do not follow DW_AT_specification, etc.
18547 This is for use in contexts where we're reading .debug_types dies.
18548 Following DW_AT_specification, DW_AT_abstract_origin will take us
18549 back up the chain, and we want to go down. */
18551 static struct attribute
*
18552 dwarf2_attr_no_follow (struct die_info
*die
, unsigned int name
)
18556 for (i
= 0; i
< die
->num_attrs
; ++i
)
18557 if (die
->attrs
[i
].name
== name
)
18558 return &die
->attrs
[i
];
18563 /* Return the string associated with a string-typed attribute, or NULL if it
18564 is either not found or is of an incorrect type. */
18566 static const char *
18567 dwarf2_string_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
18569 struct attribute
*attr
;
18570 const char *str
= NULL
;
18572 attr
= dwarf2_attr (die
, name
, cu
);
18576 if (attr
->form
== DW_FORM_strp
|| attr
->form
== DW_FORM_line_strp
18577 || attr
->form
== DW_FORM_string
18578 || attr
->form
== DW_FORM_GNU_str_index
18579 || attr
->form
== DW_FORM_GNU_strp_alt
)
18580 str
= DW_STRING (attr
);
18582 complaint (&symfile_complaints
,
18583 _("string type expected for attribute %s for "
18584 "DIE at 0x%x in module %s"),
18585 dwarf_attr_name (name
), to_underlying (die
->sect_off
),
18586 objfile_name (cu
->objfile
));
18592 /* Return non-zero iff the attribute NAME is defined for the given DIE,
18593 and holds a non-zero value. This function should only be used for
18594 DW_FORM_flag or DW_FORM_flag_present attributes. */
18597 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
18599 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
18601 return (attr
&& DW_UNSND (attr
));
18605 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
18607 /* A DIE is a declaration if it has a DW_AT_declaration attribute
18608 which value is non-zero. However, we have to be careful with
18609 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
18610 (via dwarf2_flag_true_p) follows this attribute. So we may
18611 end up accidently finding a declaration attribute that belongs
18612 to a different DIE referenced by the specification attribute,
18613 even though the given DIE does not have a declaration attribute. */
18614 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
18615 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
18618 /* Return the die giving the specification for DIE, if there is
18619 one. *SPEC_CU is the CU containing DIE on input, and the CU
18620 containing the return value on output. If there is no
18621 specification, but there is an abstract origin, that is
18624 static struct die_info
*
18625 die_specification (struct die_info
*die
, struct dwarf2_cu
**spec_cu
)
18627 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
,
18630 if (spec_attr
== NULL
)
18631 spec_attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, *spec_cu
);
18633 if (spec_attr
== NULL
)
18636 return follow_die_ref (die
, spec_attr
, spec_cu
);
18639 /* Stub for free_line_header to match void * callback types. */
18642 free_line_header_voidp (void *arg
)
18644 struct line_header
*lh
= (struct line_header
*) arg
;
18650 line_header::add_include_dir (const char *include_dir
)
18652 if (dwarf_line_debug
>= 2)
18653 fprintf_unfiltered (gdb_stdlog
, "Adding dir %zu: %s\n",
18654 include_dirs
.size () + 1, include_dir
);
18656 include_dirs
.push_back (include_dir
);
18660 line_header::add_file_name (const char *name
,
18662 unsigned int mod_time
,
18663 unsigned int length
)
18665 if (dwarf_line_debug
>= 2)
18666 fprintf_unfiltered (gdb_stdlog
, "Adding file %u: %s\n",
18667 (unsigned) file_names
.size () + 1, name
);
18669 file_names
.emplace_back (name
, d_index
, mod_time
, length
);
18672 /* A convenience function to find the proper .debug_line section for a CU. */
18674 static struct dwarf2_section_info
*
18675 get_debug_line_section (struct dwarf2_cu
*cu
)
18677 struct dwarf2_section_info
*section
;
18679 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
18681 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
18682 section
= &cu
->dwo_unit
->dwo_file
->sections
.line
;
18683 else if (cu
->per_cu
->is_dwz
)
18685 struct dwz_file
*dwz
= dwarf2_get_dwz_file ();
18687 section
= &dwz
->line
;
18690 section
= &dwarf2_per_objfile
->line
;
18695 /* Read directory or file name entry format, starting with byte of
18696 format count entries, ULEB128 pairs of entry formats, ULEB128 of
18697 entries count and the entries themselves in the described entry
18701 read_formatted_entries (bfd
*abfd
, const gdb_byte
**bufp
,
18702 struct line_header
*lh
,
18703 const struct comp_unit_head
*cu_header
,
18704 void (*callback
) (struct line_header
*lh
,
18707 unsigned int mod_time
,
18708 unsigned int length
))
18710 gdb_byte format_count
, formati
;
18711 ULONGEST data_count
, datai
;
18712 const gdb_byte
*buf
= *bufp
;
18713 const gdb_byte
*format_header_data
;
18714 unsigned int bytes_read
;
18716 format_count
= read_1_byte (abfd
, buf
);
18718 format_header_data
= buf
;
18719 for (formati
= 0; formati
< format_count
; formati
++)
18721 read_unsigned_leb128 (abfd
, buf
, &bytes_read
);
18723 read_unsigned_leb128 (abfd
, buf
, &bytes_read
);
18727 data_count
= read_unsigned_leb128 (abfd
, buf
, &bytes_read
);
18729 for (datai
= 0; datai
< data_count
; datai
++)
18731 const gdb_byte
*format
= format_header_data
;
18732 struct file_entry fe
;
18734 for (formati
= 0; formati
< format_count
; formati
++)
18736 ULONGEST content_type
= read_unsigned_leb128 (abfd
, format
, &bytes_read
);
18737 format
+= bytes_read
;
18739 ULONGEST form
= read_unsigned_leb128 (abfd
, format
, &bytes_read
);
18740 format
+= bytes_read
;
18742 gdb::optional
<const char *> string
;
18743 gdb::optional
<unsigned int> uint
;
18747 case DW_FORM_string
:
18748 string
.emplace (read_direct_string (abfd
, buf
, &bytes_read
));
18752 case DW_FORM_line_strp
:
18753 string
.emplace (read_indirect_line_string (abfd
, buf
,
18759 case DW_FORM_data1
:
18760 uint
.emplace (read_1_byte (abfd
, buf
));
18764 case DW_FORM_data2
:
18765 uint
.emplace (read_2_bytes (abfd
, buf
));
18769 case DW_FORM_data4
:
18770 uint
.emplace (read_4_bytes (abfd
, buf
));
18774 case DW_FORM_data8
:
18775 uint
.emplace (read_8_bytes (abfd
, buf
));
18779 case DW_FORM_udata
:
18780 uint
.emplace (read_unsigned_leb128 (abfd
, buf
, &bytes_read
));
18784 case DW_FORM_block
:
18785 /* It is valid only for DW_LNCT_timestamp which is ignored by
18790 switch (content_type
)
18793 if (string
.has_value ())
18796 case DW_LNCT_directory_index
:
18797 if (uint
.has_value ())
18798 fe
.d_index
= (dir_index
) *uint
;
18800 case DW_LNCT_timestamp
:
18801 if (uint
.has_value ())
18802 fe
.mod_time
= *uint
;
18805 if (uint
.has_value ())
18811 complaint (&symfile_complaints
,
18812 _("Unknown format content type %s"),
18813 pulongest (content_type
));
18817 callback (lh
, fe
.name
, fe
.d_index
, fe
.mod_time
, fe
.length
);
18823 /* Read the statement program header starting at OFFSET in
18824 .debug_line, or .debug_line.dwo. Return a pointer
18825 to a struct line_header, allocated using xmalloc.
18826 Returns NULL if there is a problem reading the header, e.g., if it
18827 has a version we don't understand.
18829 NOTE: the strings in the include directory and file name tables of
18830 the returned object point into the dwarf line section buffer,
18831 and must not be freed. */
18833 static line_header_up
18834 dwarf_decode_line_header (sect_offset sect_off
, struct dwarf2_cu
*cu
)
18836 const gdb_byte
*line_ptr
;
18837 unsigned int bytes_read
, offset_size
;
18839 const char *cur_dir
, *cur_file
;
18840 struct dwarf2_section_info
*section
;
18843 section
= get_debug_line_section (cu
);
18844 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
18845 if (section
->buffer
== NULL
)
18847 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
18848 complaint (&symfile_complaints
, _("missing .debug_line.dwo section"));
18850 complaint (&symfile_complaints
, _("missing .debug_line section"));
18854 /* We can't do this until we know the section is non-empty.
18855 Only then do we know we have such a section. */
18856 abfd
= get_section_bfd_owner (section
);
18858 /* Make sure that at least there's room for the total_length field.
18859 That could be 12 bytes long, but we're just going to fudge that. */
18860 if (to_underlying (sect_off
) + 4 >= section
->size
)
18862 dwarf2_statement_list_fits_in_line_number_section_complaint ();
18866 line_header_up
lh (new line_header ());
18868 lh
->sect_off
= sect_off
;
18869 lh
->offset_in_dwz
= cu
->per_cu
->is_dwz
;
18871 line_ptr
= section
->buffer
+ to_underlying (sect_off
);
18873 /* Read in the header. */
18875 read_checked_initial_length_and_offset (abfd
, line_ptr
, &cu
->header
,
18876 &bytes_read
, &offset_size
);
18877 line_ptr
+= bytes_read
;
18878 if (line_ptr
+ lh
->total_length
> (section
->buffer
+ section
->size
))
18880 dwarf2_statement_list_fits_in_line_number_section_complaint ();
18883 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
18884 lh
->version
= read_2_bytes (abfd
, line_ptr
);
18886 if (lh
->version
> 5)
18888 /* This is a version we don't understand. The format could have
18889 changed in ways we don't handle properly so just punt. */
18890 complaint (&symfile_complaints
,
18891 _("unsupported version in .debug_line section"));
18894 if (lh
->version
>= 5)
18896 gdb_byte segment_selector_size
;
18898 /* Skip address size. */
18899 read_1_byte (abfd
, line_ptr
);
18902 segment_selector_size
= read_1_byte (abfd
, line_ptr
);
18904 if (segment_selector_size
!= 0)
18906 complaint (&symfile_complaints
,
18907 _("unsupported segment selector size %u "
18908 "in .debug_line section"),
18909 segment_selector_size
);
18913 lh
->header_length
= read_offset_1 (abfd
, line_ptr
, offset_size
);
18914 line_ptr
+= offset_size
;
18915 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
18917 if (lh
->version
>= 4)
18919 lh
->maximum_ops_per_instruction
= read_1_byte (abfd
, line_ptr
);
18923 lh
->maximum_ops_per_instruction
= 1;
18925 if (lh
->maximum_ops_per_instruction
== 0)
18927 lh
->maximum_ops_per_instruction
= 1;
18928 complaint (&symfile_complaints
,
18929 _("invalid maximum_ops_per_instruction "
18930 "in `.debug_line' section"));
18933 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
18935 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
18937 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
18939 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
18941 lh
->standard_opcode_lengths
.reset (new unsigned char[lh
->opcode_base
]);
18943 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
18944 for (i
= 1; i
< lh
->opcode_base
; ++i
)
18946 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
18950 if (lh
->version
>= 5)
18952 /* Read directory table. */
18953 read_formatted_entries (abfd
, &line_ptr
, lh
.get (), &cu
->header
,
18954 [] (struct line_header
*lh
, const char *name
,
18955 dir_index d_index
, unsigned int mod_time
,
18956 unsigned int length
)
18958 lh
->add_include_dir (name
);
18961 /* Read file name table. */
18962 read_formatted_entries (abfd
, &line_ptr
, lh
.get (), &cu
->header
,
18963 [] (struct line_header
*lh
, const char *name
,
18964 dir_index d_index
, unsigned int mod_time
,
18965 unsigned int length
)
18967 lh
->add_file_name (name
, d_index
, mod_time
, length
);
18972 /* Read directory table. */
18973 while ((cur_dir
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
18975 line_ptr
+= bytes_read
;
18976 lh
->add_include_dir (cur_dir
);
18978 line_ptr
+= bytes_read
;
18980 /* Read file name table. */
18981 while ((cur_file
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
18983 unsigned int mod_time
, length
;
18986 line_ptr
+= bytes_read
;
18987 d_index
= (dir_index
) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
18988 line_ptr
+= bytes_read
;
18989 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
18990 line_ptr
+= bytes_read
;
18991 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
18992 line_ptr
+= bytes_read
;
18994 lh
->add_file_name (cur_file
, d_index
, mod_time
, length
);
18996 line_ptr
+= bytes_read
;
18998 lh
->statement_program_start
= line_ptr
;
19000 if (line_ptr
> (section
->buffer
+ section
->size
))
19001 complaint (&symfile_complaints
,
19002 _("line number info header doesn't "
19003 "fit in `.debug_line' section"));
19008 /* Subroutine of dwarf_decode_lines to simplify it.
19009 Return the file name of the psymtab for included file FILE_INDEX
19010 in line header LH of PST.
19011 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
19012 If space for the result is malloc'd, it will be freed by a cleanup.
19013 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename.
19015 The function creates dangling cleanup registration. */
19017 static const char *
19018 psymtab_include_file_name (const struct line_header
*lh
, int file_index
,
19019 const struct partial_symtab
*pst
,
19020 const char *comp_dir
)
19022 const file_entry
&fe
= lh
->file_names
[file_index
];
19023 const char *include_name
= fe
.name
;
19024 const char *include_name_to_compare
= include_name
;
19025 const char *pst_filename
;
19026 char *copied_name
= NULL
;
19029 const char *dir_name
= fe
.include_dir (lh
);
19031 if (!IS_ABSOLUTE_PATH (include_name
)
19032 && (dir_name
!= NULL
|| comp_dir
!= NULL
))
19034 /* Avoid creating a duplicate psymtab for PST.
19035 We do this by comparing INCLUDE_NAME and PST_FILENAME.
19036 Before we do the comparison, however, we need to account
19037 for DIR_NAME and COMP_DIR.
19038 First prepend dir_name (if non-NULL). If we still don't
19039 have an absolute path prepend comp_dir (if non-NULL).
19040 However, the directory we record in the include-file's
19041 psymtab does not contain COMP_DIR (to match the
19042 corresponding symtab(s)).
19047 bash$ gcc -g ./hello.c
19048 include_name = "hello.c"
19050 DW_AT_comp_dir = comp_dir = "/tmp"
19051 DW_AT_name = "./hello.c"
19055 if (dir_name
!= NULL
)
19057 char *tem
= concat (dir_name
, SLASH_STRING
,
19058 include_name
, (char *)NULL
);
19060 make_cleanup (xfree
, tem
);
19061 include_name
= tem
;
19062 include_name_to_compare
= include_name
;
19064 if (!IS_ABSOLUTE_PATH (include_name
) && comp_dir
!= NULL
)
19066 char *tem
= concat (comp_dir
, SLASH_STRING
,
19067 include_name
, (char *)NULL
);
19069 make_cleanup (xfree
, tem
);
19070 include_name_to_compare
= tem
;
19074 pst_filename
= pst
->filename
;
19075 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
19077 copied_name
= concat (pst
->dirname
, SLASH_STRING
,
19078 pst_filename
, (char *)NULL
);
19079 pst_filename
= copied_name
;
19082 file_is_pst
= FILENAME_CMP (include_name_to_compare
, pst_filename
) == 0;
19084 if (copied_name
!= NULL
)
19085 xfree (copied_name
);
19089 return include_name
;
19092 /* State machine to track the state of the line number program. */
19094 class lnp_state_machine
19097 /* Initialize a machine state for the start of a line number
19099 lnp_state_machine (gdbarch
*arch
, line_header
*lh
, bool record_lines_p
);
19101 file_entry
*current_file ()
19103 /* lh->file_names is 0-based, but the file name numbers in the
19104 statement program are 1-based. */
19105 return m_line_header
->file_name_at (m_file
);
19108 /* Record the line in the state machine. END_SEQUENCE is true if
19109 we're processing the end of a sequence. */
19110 void record_line (bool end_sequence
);
19112 /* Check address and if invalid nop-out the rest of the lines in this
19114 void check_line_address (struct dwarf2_cu
*cu
,
19115 const gdb_byte
*line_ptr
,
19116 CORE_ADDR lowpc
, CORE_ADDR address
);
19118 void handle_set_discriminator (unsigned int discriminator
)
19120 m_discriminator
= discriminator
;
19121 m_line_has_non_zero_discriminator
|= discriminator
!= 0;
19124 /* Handle DW_LNE_set_address. */
19125 void handle_set_address (CORE_ADDR baseaddr
, CORE_ADDR address
)
19128 address
+= baseaddr
;
19129 m_address
= gdbarch_adjust_dwarf2_line (m_gdbarch
, address
, false);
19132 /* Handle DW_LNS_advance_pc. */
19133 void handle_advance_pc (CORE_ADDR adjust
);
19135 /* Handle a special opcode. */
19136 void handle_special_opcode (unsigned char op_code
);
19138 /* Handle DW_LNS_advance_line. */
19139 void handle_advance_line (int line_delta
)
19141 advance_line (line_delta
);
19144 /* Handle DW_LNS_set_file. */
19145 void handle_set_file (file_name_index file
);
19147 /* Handle DW_LNS_negate_stmt. */
19148 void handle_negate_stmt ()
19150 m_is_stmt
= !m_is_stmt
;
19153 /* Handle DW_LNS_const_add_pc. */
19154 void handle_const_add_pc ();
19156 /* Handle DW_LNS_fixed_advance_pc. */
19157 void handle_fixed_advance_pc (CORE_ADDR addr_adj
)
19159 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
19163 /* Handle DW_LNS_copy. */
19164 void handle_copy ()
19166 record_line (false);
19167 m_discriminator
= 0;
19170 /* Handle DW_LNE_end_sequence. */
19171 void handle_end_sequence ()
19173 m_record_line_callback
= ::record_line
;
19177 /* Advance the line by LINE_DELTA. */
19178 void advance_line (int line_delta
)
19180 m_line
+= line_delta
;
19182 if (line_delta
!= 0)
19183 m_line_has_non_zero_discriminator
= m_discriminator
!= 0;
19186 gdbarch
*m_gdbarch
;
19188 /* True if we're recording lines.
19189 Otherwise we're building partial symtabs and are just interested in
19190 finding include files mentioned by the line number program. */
19191 bool m_record_lines_p
;
19193 /* The line number header. */
19194 line_header
*m_line_header
;
19196 /* These are part of the standard DWARF line number state machine,
19197 and initialized according to the DWARF spec. */
19199 unsigned char m_op_index
= 0;
19200 /* The line table index (1-based) of the current file. */
19201 file_name_index m_file
= (file_name_index
) 1;
19202 unsigned int m_line
= 1;
19204 /* These are initialized in the constructor. */
19206 CORE_ADDR m_address
;
19208 unsigned int m_discriminator
;
19210 /* Additional bits of state we need to track. */
19212 /* The last file that we called dwarf2_start_subfile for.
19213 This is only used for TLLs. */
19214 unsigned int m_last_file
= 0;
19215 /* The last file a line number was recorded for. */
19216 struct subfile
*m_last_subfile
= NULL
;
19218 /* The function to call to record a line. */
19219 record_line_ftype
*m_record_line_callback
= NULL
;
19221 /* The last line number that was recorded, used to coalesce
19222 consecutive entries for the same line. This can happen, for
19223 example, when discriminators are present. PR 17276. */
19224 unsigned int m_last_line
= 0;
19225 bool m_line_has_non_zero_discriminator
= false;
19229 lnp_state_machine::handle_advance_pc (CORE_ADDR adjust
)
19231 CORE_ADDR addr_adj
= (((m_op_index
+ adjust
)
19232 / m_line_header
->maximum_ops_per_instruction
)
19233 * m_line_header
->minimum_instruction_length
);
19234 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
19235 m_op_index
= ((m_op_index
+ adjust
)
19236 % m_line_header
->maximum_ops_per_instruction
);
19240 lnp_state_machine::handle_special_opcode (unsigned char op_code
)
19242 unsigned char adj_opcode
= op_code
- m_line_header
->opcode_base
;
19243 CORE_ADDR addr_adj
= (((m_op_index
19244 + (adj_opcode
/ m_line_header
->line_range
))
19245 / m_line_header
->maximum_ops_per_instruction
)
19246 * m_line_header
->minimum_instruction_length
);
19247 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
19248 m_op_index
= ((m_op_index
+ (adj_opcode
/ m_line_header
->line_range
))
19249 % m_line_header
->maximum_ops_per_instruction
);
19251 int line_delta
= (m_line_header
->line_base
19252 + (adj_opcode
% m_line_header
->line_range
));
19253 advance_line (line_delta
);
19254 record_line (false);
19255 m_discriminator
= 0;
19259 lnp_state_machine::handle_set_file (file_name_index file
)
19263 const file_entry
*fe
= current_file ();
19265 dwarf2_debug_line_missing_file_complaint ();
19266 else if (m_record_lines_p
)
19268 const char *dir
= fe
->include_dir (m_line_header
);
19270 m_last_subfile
= current_subfile
;
19271 m_line_has_non_zero_discriminator
= m_discriminator
!= 0;
19272 dwarf2_start_subfile (fe
->name
, dir
);
19277 lnp_state_machine::handle_const_add_pc ()
19280 = (255 - m_line_header
->opcode_base
) / m_line_header
->line_range
;
19283 = (((m_op_index
+ adjust
)
19284 / m_line_header
->maximum_ops_per_instruction
)
19285 * m_line_header
->minimum_instruction_length
);
19287 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
19288 m_op_index
= ((m_op_index
+ adjust
)
19289 % m_line_header
->maximum_ops_per_instruction
);
19292 /* Ignore this record_line request. */
19295 noop_record_line (struct subfile
*subfile
, int line
, CORE_ADDR pc
)
19300 /* Return non-zero if we should add LINE to the line number table.
19301 LINE is the line to add, LAST_LINE is the last line that was added,
19302 LAST_SUBFILE is the subfile for LAST_LINE.
19303 LINE_HAS_NON_ZERO_DISCRIMINATOR is non-zero if LINE has ever
19304 had a non-zero discriminator.
19306 We have to be careful in the presence of discriminators.
19307 E.g., for this line:
19309 for (i = 0; i < 100000; i++);
19311 clang can emit four line number entries for that one line,
19312 each with a different discriminator.
19313 See gdb.dwarf2/dw2-single-line-discriminators.exp for an example.
19315 However, we want gdb to coalesce all four entries into one.
19316 Otherwise the user could stepi into the middle of the line and
19317 gdb would get confused about whether the pc really was in the
19318 middle of the line.
19320 Things are further complicated by the fact that two consecutive
19321 line number entries for the same line is a heuristic used by gcc
19322 to denote the end of the prologue. So we can't just discard duplicate
19323 entries, we have to be selective about it. The heuristic we use is
19324 that we only collapse consecutive entries for the same line if at least
19325 one of those entries has a non-zero discriminator. PR 17276.
19327 Note: Addresses in the line number state machine can never go backwards
19328 within one sequence, thus this coalescing is ok. */
19331 dwarf_record_line_p (unsigned int line
, unsigned int last_line
,
19332 int line_has_non_zero_discriminator
,
19333 struct subfile
*last_subfile
)
19335 if (current_subfile
!= last_subfile
)
19337 if (line
!= last_line
)
19339 /* Same line for the same file that we've seen already.
19340 As a last check, for pr 17276, only record the line if the line
19341 has never had a non-zero discriminator. */
19342 if (!line_has_non_zero_discriminator
)
19347 /* Use P_RECORD_LINE to record line number LINE beginning at address ADDRESS
19348 in the line table of subfile SUBFILE. */
19351 dwarf_record_line_1 (struct gdbarch
*gdbarch
, struct subfile
*subfile
,
19352 unsigned int line
, CORE_ADDR address
,
19353 record_line_ftype p_record_line
)
19355 CORE_ADDR addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
19357 if (dwarf_line_debug
)
19359 fprintf_unfiltered (gdb_stdlog
,
19360 "Recording line %u, file %s, address %s\n",
19361 line
, lbasename (subfile
->name
),
19362 paddress (gdbarch
, address
));
19365 (*p_record_line
) (subfile
, line
, addr
);
19368 /* Subroutine of dwarf_decode_lines_1 to simplify it.
19369 Mark the end of a set of line number records.
19370 The arguments are the same as for dwarf_record_line_1.
19371 If SUBFILE is NULL the request is ignored. */
19374 dwarf_finish_line (struct gdbarch
*gdbarch
, struct subfile
*subfile
,
19375 CORE_ADDR address
, record_line_ftype p_record_line
)
19377 if (subfile
== NULL
)
19380 if (dwarf_line_debug
)
19382 fprintf_unfiltered (gdb_stdlog
,
19383 "Finishing current line, file %s, address %s\n",
19384 lbasename (subfile
->name
),
19385 paddress (gdbarch
, address
));
19388 dwarf_record_line_1 (gdbarch
, subfile
, 0, address
, p_record_line
);
19392 lnp_state_machine::record_line (bool end_sequence
)
19394 if (dwarf_line_debug
)
19396 fprintf_unfiltered (gdb_stdlog
,
19397 "Processing actual line %u: file %u,"
19398 " address %s, is_stmt %u, discrim %u\n",
19399 m_line
, to_underlying (m_file
),
19400 paddress (m_gdbarch
, m_address
),
19401 m_is_stmt
, m_discriminator
);
19404 file_entry
*fe
= current_file ();
19407 dwarf2_debug_line_missing_file_complaint ();
19408 /* For now we ignore lines not starting on an instruction boundary.
19409 But not when processing end_sequence for compatibility with the
19410 previous version of the code. */
19411 else if (m_op_index
== 0 || end_sequence
)
19413 fe
->included_p
= 1;
19414 if (m_record_lines_p
&& m_is_stmt
)
19416 if (m_last_subfile
!= current_subfile
|| end_sequence
)
19418 dwarf_finish_line (m_gdbarch
, m_last_subfile
,
19419 m_address
, m_record_line_callback
);
19424 if (dwarf_record_line_p (m_line
, m_last_line
,
19425 m_line_has_non_zero_discriminator
,
19428 dwarf_record_line_1 (m_gdbarch
, current_subfile
,
19430 m_record_line_callback
);
19432 m_last_subfile
= current_subfile
;
19433 m_last_line
= m_line
;
19439 lnp_state_machine::lnp_state_machine (gdbarch
*arch
, line_header
*lh
,
19440 bool record_lines_p
)
19443 m_record_lines_p
= record_lines_p
;
19444 m_line_header
= lh
;
19446 m_record_line_callback
= ::record_line
;
19448 /* Call `gdbarch_adjust_dwarf2_line' on the initial 0 address as if there
19449 was a line entry for it so that the backend has a chance to adjust it
19450 and also record it in case it needs it. This is currently used by MIPS
19451 code, cf. `mips_adjust_dwarf2_line'. */
19452 m_address
= gdbarch_adjust_dwarf2_line (arch
, 0, 0);
19453 m_is_stmt
= lh
->default_is_stmt
;
19454 m_discriminator
= 0;
19458 lnp_state_machine::check_line_address (struct dwarf2_cu
*cu
,
19459 const gdb_byte
*line_ptr
,
19460 CORE_ADDR lowpc
, CORE_ADDR address
)
19462 /* If address < lowpc then it's not a usable value, it's outside the
19463 pc range of the CU. However, we restrict the test to only address
19464 values of zero to preserve GDB's previous behaviour which is to
19465 handle the specific case of a function being GC'd by the linker. */
19467 if (address
== 0 && address
< lowpc
)
19469 /* This line table is for a function which has been
19470 GCd by the linker. Ignore it. PR gdb/12528 */
19472 struct objfile
*objfile
= cu
->objfile
;
19473 long line_offset
= line_ptr
- get_debug_line_section (cu
)->buffer
;
19475 complaint (&symfile_complaints
,
19476 _(".debug_line address at offset 0x%lx is 0 [in module %s]"),
19477 line_offset
, objfile_name (objfile
));
19478 m_record_line_callback
= noop_record_line
;
19479 /* Note: record_line_callback is left as noop_record_line until
19480 we see DW_LNE_end_sequence. */
19484 /* Subroutine of dwarf_decode_lines to simplify it.
19485 Process the line number information in LH.
19486 If DECODE_FOR_PST_P is non-zero, all we do is process the line number
19487 program in order to set included_p for every referenced header. */
19490 dwarf_decode_lines_1 (struct line_header
*lh
, struct dwarf2_cu
*cu
,
19491 const int decode_for_pst_p
, CORE_ADDR lowpc
)
19493 const gdb_byte
*line_ptr
, *extended_end
;
19494 const gdb_byte
*line_end
;
19495 unsigned int bytes_read
, extended_len
;
19496 unsigned char op_code
, extended_op
;
19497 CORE_ADDR baseaddr
;
19498 struct objfile
*objfile
= cu
->objfile
;
19499 bfd
*abfd
= objfile
->obfd
;
19500 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
19501 /* True if we're recording line info (as opposed to building partial
19502 symtabs and just interested in finding include files mentioned by
19503 the line number program). */
19504 bool record_lines_p
= !decode_for_pst_p
;
19506 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
19508 line_ptr
= lh
->statement_program_start
;
19509 line_end
= lh
->statement_program_end
;
19511 /* Read the statement sequences until there's nothing left. */
19512 while (line_ptr
< line_end
)
19514 /* The DWARF line number program state machine. Reset the state
19515 machine at the start of each sequence. */
19516 lnp_state_machine
state_machine (gdbarch
, lh
, record_lines_p
);
19517 bool end_sequence
= false;
19519 if (record_lines_p
)
19521 /* Start a subfile for the current file of the state
19523 const file_entry
*fe
= state_machine
.current_file ();
19526 dwarf2_start_subfile (fe
->name
, fe
->include_dir (lh
));
19529 /* Decode the table. */
19530 while (line_ptr
< line_end
&& !end_sequence
)
19532 op_code
= read_1_byte (abfd
, line_ptr
);
19535 if (op_code
>= lh
->opcode_base
)
19537 /* Special opcode. */
19538 state_machine
.handle_special_opcode (op_code
);
19540 else switch (op_code
)
19542 case DW_LNS_extended_op
:
19543 extended_len
= read_unsigned_leb128 (abfd
, line_ptr
,
19545 line_ptr
+= bytes_read
;
19546 extended_end
= line_ptr
+ extended_len
;
19547 extended_op
= read_1_byte (abfd
, line_ptr
);
19549 switch (extended_op
)
19551 case DW_LNE_end_sequence
:
19552 state_machine
.handle_end_sequence ();
19553 end_sequence
= true;
19555 case DW_LNE_set_address
:
19558 = read_address (abfd
, line_ptr
, cu
, &bytes_read
);
19559 line_ptr
+= bytes_read
;
19561 state_machine
.check_line_address (cu
, line_ptr
,
19563 state_machine
.handle_set_address (baseaddr
, address
);
19566 case DW_LNE_define_file
:
19568 const char *cur_file
;
19569 unsigned int mod_time
, length
;
19572 cur_file
= read_direct_string (abfd
, line_ptr
,
19574 line_ptr
+= bytes_read
;
19575 dindex
= (dir_index
)
19576 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
19577 line_ptr
+= bytes_read
;
19579 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
19580 line_ptr
+= bytes_read
;
19582 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
19583 line_ptr
+= bytes_read
;
19584 lh
->add_file_name (cur_file
, dindex
, mod_time
, length
);
19587 case DW_LNE_set_discriminator
:
19589 /* The discriminator is not interesting to the
19590 debugger; just ignore it. We still need to
19591 check its value though:
19592 if there are consecutive entries for the same
19593 (non-prologue) line we want to coalesce them.
19596 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
19597 line_ptr
+= bytes_read
;
19599 state_machine
.handle_set_discriminator (discr
);
19603 complaint (&symfile_complaints
,
19604 _("mangled .debug_line section"));
19607 /* Make sure that we parsed the extended op correctly. If e.g.
19608 we expected a different address size than the producer used,
19609 we may have read the wrong number of bytes. */
19610 if (line_ptr
!= extended_end
)
19612 complaint (&symfile_complaints
,
19613 _("mangled .debug_line section"));
19618 state_machine
.handle_copy ();
19620 case DW_LNS_advance_pc
:
19623 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
19624 line_ptr
+= bytes_read
;
19626 state_machine
.handle_advance_pc (adjust
);
19629 case DW_LNS_advance_line
:
19632 = read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
19633 line_ptr
+= bytes_read
;
19635 state_machine
.handle_advance_line (line_delta
);
19638 case DW_LNS_set_file
:
19640 file_name_index file
19641 = (file_name_index
) read_unsigned_leb128 (abfd
, line_ptr
,
19643 line_ptr
+= bytes_read
;
19645 state_machine
.handle_set_file (file
);
19648 case DW_LNS_set_column
:
19649 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
19650 line_ptr
+= bytes_read
;
19652 case DW_LNS_negate_stmt
:
19653 state_machine
.handle_negate_stmt ();
19655 case DW_LNS_set_basic_block
:
19657 /* Add to the address register of the state machine the
19658 address increment value corresponding to special opcode
19659 255. I.e., this value is scaled by the minimum
19660 instruction length since special opcode 255 would have
19661 scaled the increment. */
19662 case DW_LNS_const_add_pc
:
19663 state_machine
.handle_const_add_pc ();
19665 case DW_LNS_fixed_advance_pc
:
19667 CORE_ADDR addr_adj
= read_2_bytes (abfd
, line_ptr
);
19670 state_machine
.handle_fixed_advance_pc (addr_adj
);
19675 /* Unknown standard opcode, ignore it. */
19678 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
19680 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
19681 line_ptr
+= bytes_read
;
19688 dwarf2_debug_line_missing_end_sequence_complaint ();
19690 /* We got a DW_LNE_end_sequence (or we ran off the end of the buffer,
19691 in which case we still finish recording the last line). */
19692 state_machine
.record_line (true);
19696 /* Decode the Line Number Program (LNP) for the given line_header
19697 structure and CU. The actual information extracted and the type
19698 of structures created from the LNP depends on the value of PST.
19700 1. If PST is NULL, then this procedure uses the data from the program
19701 to create all necessary symbol tables, and their linetables.
19703 2. If PST is not NULL, this procedure reads the program to determine
19704 the list of files included by the unit represented by PST, and
19705 builds all the associated partial symbol tables.
19707 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
19708 It is used for relative paths in the line table.
19709 NOTE: When processing partial symtabs (pst != NULL),
19710 comp_dir == pst->dirname.
19712 NOTE: It is important that psymtabs have the same file name (via strcmp)
19713 as the corresponding symtab. Since COMP_DIR is not used in the name of the
19714 symtab we don't use it in the name of the psymtabs we create.
19715 E.g. expand_line_sal requires this when finding psymtabs to expand.
19716 A good testcase for this is mb-inline.exp.
19718 LOWPC is the lowest address in CU (or 0 if not known).
19720 Boolean DECODE_MAPPING specifies we need to fully decode .debug_line
19721 for its PC<->lines mapping information. Otherwise only the filename
19722 table is read in. */
19725 dwarf_decode_lines (struct line_header
*lh
, const char *comp_dir
,
19726 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
,
19727 CORE_ADDR lowpc
, int decode_mapping
)
19729 struct objfile
*objfile
= cu
->objfile
;
19730 const int decode_for_pst_p
= (pst
!= NULL
);
19732 if (decode_mapping
)
19733 dwarf_decode_lines_1 (lh
, cu
, decode_for_pst_p
, lowpc
);
19735 if (decode_for_pst_p
)
19739 /* Now that we're done scanning the Line Header Program, we can
19740 create the psymtab of each included file. */
19741 for (file_index
= 0; file_index
< lh
->file_names
.size (); file_index
++)
19742 if (lh
->file_names
[file_index
].included_p
== 1)
19744 const char *include_name
=
19745 psymtab_include_file_name (lh
, file_index
, pst
, comp_dir
);
19746 if (include_name
!= NULL
)
19747 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
19752 /* Make sure a symtab is created for every file, even files
19753 which contain only variables (i.e. no code with associated
19755 struct compunit_symtab
*cust
= buildsym_compunit_symtab ();
19758 for (i
= 0; i
< lh
->file_names
.size (); i
++)
19760 file_entry
&fe
= lh
->file_names
[i
];
19762 dwarf2_start_subfile (fe
.name
, fe
.include_dir (lh
));
19764 if (current_subfile
->symtab
== NULL
)
19766 current_subfile
->symtab
19767 = allocate_symtab (cust
, current_subfile
->name
);
19769 fe
.symtab
= current_subfile
->symtab
;
19774 /* Start a subfile for DWARF. FILENAME is the name of the file and
19775 DIRNAME the name of the source directory which contains FILENAME
19776 or NULL if not known.
19777 This routine tries to keep line numbers from identical absolute and
19778 relative file names in a common subfile.
19780 Using the `list' example from the GDB testsuite, which resides in
19781 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
19782 of /srcdir/list0.c yields the following debugging information for list0.c:
19784 DW_AT_name: /srcdir/list0.c
19785 DW_AT_comp_dir: /compdir
19786 files.files[0].name: list0.h
19787 files.files[0].dir: /srcdir
19788 files.files[1].name: list0.c
19789 files.files[1].dir: /srcdir
19791 The line number information for list0.c has to end up in a single
19792 subfile, so that `break /srcdir/list0.c:1' works as expected.
19793 start_subfile will ensure that this happens provided that we pass the
19794 concatenation of files.files[1].dir and files.files[1].name as the
19798 dwarf2_start_subfile (const char *filename
, const char *dirname
)
19802 /* In order not to lose the line information directory,
19803 we concatenate it to the filename when it makes sense.
19804 Note that the Dwarf3 standard says (speaking of filenames in line
19805 information): ``The directory index is ignored for file names
19806 that represent full path names''. Thus ignoring dirname in the
19807 `else' branch below isn't an issue. */
19809 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
19811 copy
= concat (dirname
, SLASH_STRING
, filename
, (char *)NULL
);
19815 start_subfile (filename
);
19821 /* Start a symtab for DWARF.
19822 NAME, COMP_DIR, LOW_PC are passed to start_symtab. */
19824 static struct compunit_symtab
*
19825 dwarf2_start_symtab (struct dwarf2_cu
*cu
,
19826 const char *name
, const char *comp_dir
, CORE_ADDR low_pc
)
19828 struct compunit_symtab
*cust
19829 = start_symtab (cu
->objfile
, name
, comp_dir
, low_pc
, cu
->language
);
19831 record_debugformat ("DWARF 2");
19832 record_producer (cu
->producer
);
19834 /* We assume that we're processing GCC output. */
19835 processing_gcc_compilation
= 2;
19837 cu
->processing_has_namespace_info
= 0;
19843 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
19844 struct dwarf2_cu
*cu
)
19846 struct objfile
*objfile
= cu
->objfile
;
19847 struct comp_unit_head
*cu_header
= &cu
->header
;
19849 /* NOTE drow/2003-01-30: There used to be a comment and some special
19850 code here to turn a symbol with DW_AT_external and a
19851 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
19852 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
19853 with some versions of binutils) where shared libraries could have
19854 relocations against symbols in their debug information - the
19855 minimal symbol would have the right address, but the debug info
19856 would not. It's no longer necessary, because we will explicitly
19857 apply relocations when we read in the debug information now. */
19859 /* A DW_AT_location attribute with no contents indicates that a
19860 variable has been optimized away. */
19861 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
19863 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
19867 /* Handle one degenerate form of location expression specially, to
19868 preserve GDB's previous behavior when section offsets are
19869 specified. If this is just a DW_OP_addr or DW_OP_GNU_addr_index
19870 then mark this symbol as LOC_STATIC. */
19872 if (attr_form_is_block (attr
)
19873 && ((DW_BLOCK (attr
)->data
[0] == DW_OP_addr
19874 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
)
19875 || (DW_BLOCK (attr
)->data
[0] == DW_OP_GNU_addr_index
19876 && (DW_BLOCK (attr
)->size
19877 == 1 + leb128_size (&DW_BLOCK (attr
)->data
[1])))))
19879 unsigned int dummy
;
19881 if (DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
19882 SYMBOL_VALUE_ADDRESS (sym
) =
19883 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
19885 SYMBOL_VALUE_ADDRESS (sym
) =
19886 read_addr_index_from_leb128 (cu
, DW_BLOCK (attr
)->data
+ 1, &dummy
);
19887 SYMBOL_ACLASS_INDEX (sym
) = LOC_STATIC
;
19888 fixup_symbol_section (sym
, objfile
);
19889 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
19890 SYMBOL_SECTION (sym
));
19894 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
19895 expression evaluator, and use LOC_COMPUTED only when necessary
19896 (i.e. when the value of a register or memory location is
19897 referenced, or a thread-local block, etc.). Then again, it might
19898 not be worthwhile. I'm assuming that it isn't unless performance
19899 or memory numbers show me otherwise. */
19901 dwarf2_symbol_mark_computed (attr
, sym
, cu
, 0);
19903 if (SYMBOL_COMPUTED_OPS (sym
)->location_has_loclist
)
19904 cu
->has_loclist
= 1;
19907 /* Given a pointer to a DWARF information entry, figure out if we need
19908 to make a symbol table entry for it, and if so, create a new entry
19909 and return a pointer to it.
19910 If TYPE is NULL, determine symbol type from the die, otherwise
19911 used the passed type.
19912 If SPACE is not NULL, use it to hold the new symbol. If it is
19913 NULL, allocate a new symbol on the objfile's obstack. */
19915 static struct symbol
*
19916 new_symbol_full (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
,
19917 struct symbol
*space
)
19919 struct objfile
*objfile
= cu
->objfile
;
19920 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
19921 struct symbol
*sym
= NULL
;
19923 struct attribute
*attr
= NULL
;
19924 struct attribute
*attr2
= NULL
;
19925 CORE_ADDR baseaddr
;
19926 struct pending
**list_to_add
= NULL
;
19928 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
19930 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
19932 name
= dwarf2_name (die
, cu
);
19935 const char *linkagename
;
19936 int suppress_add
= 0;
19941 sym
= allocate_symbol (objfile
);
19942 OBJSTAT (objfile
, n_syms
++);
19944 /* Cache this symbol's name and the name's demangled form (if any). */
19945 SYMBOL_SET_LANGUAGE (sym
, cu
->language
, &objfile
->objfile_obstack
);
19946 linkagename
= dwarf2_physname (name
, die
, cu
);
19947 SYMBOL_SET_NAMES (sym
, linkagename
, strlen (linkagename
), 0, objfile
);
19949 /* Fortran does not have mangling standard and the mangling does differ
19950 between gfortran, iFort etc. */
19951 if (cu
->language
== language_fortran
19952 && symbol_get_demangled_name (&(sym
->ginfo
)) == NULL
)
19953 symbol_set_demangled_name (&(sym
->ginfo
),
19954 dwarf2_full_name (name
, die
, cu
),
19957 /* Default assumptions.
19958 Use the passed type or decode it from the die. */
19959 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
19960 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
19962 SYMBOL_TYPE (sym
) = type
;
19964 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
19965 attr
= dwarf2_attr (die
,
19966 inlined_func
? DW_AT_call_line
: DW_AT_decl_line
,
19970 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
19973 attr
= dwarf2_attr (die
,
19974 inlined_func
? DW_AT_call_file
: DW_AT_decl_file
,
19978 file_name_index file_index
= (file_name_index
) DW_UNSND (attr
);
19979 struct file_entry
*fe
;
19981 if (cu
->line_header
!= NULL
)
19982 fe
= cu
->line_header
->file_name_at (file_index
);
19987 complaint (&symfile_complaints
,
19988 _("file index out of range"));
19990 symbol_set_symtab (sym
, fe
->symtab
);
19996 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
20001 addr
= attr_value_as_address (attr
);
20002 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, addr
+ baseaddr
);
20003 SYMBOL_VALUE_ADDRESS (sym
) = addr
;
20005 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_core_addr
;
20006 SYMBOL_DOMAIN (sym
) = LABEL_DOMAIN
;
20007 SYMBOL_ACLASS_INDEX (sym
) = LOC_LABEL
;
20008 add_symbol_to_list (sym
, cu
->list_in_scope
);
20010 case DW_TAG_subprogram
:
20011 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
20013 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
20014 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
20015 if ((attr2
&& (DW_UNSND (attr2
) != 0))
20016 || cu
->language
== language_ada
)
20018 /* Subprograms marked external are stored as a global symbol.
20019 Ada subprograms, whether marked external or not, are always
20020 stored as a global symbol, because we want to be able to
20021 access them globally. For instance, we want to be able
20022 to break on a nested subprogram without having to
20023 specify the context. */
20024 list_to_add
= &global_symbols
;
20028 list_to_add
= cu
->list_in_scope
;
20031 case DW_TAG_inlined_subroutine
:
20032 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
20034 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
20035 SYMBOL_INLINED (sym
) = 1;
20036 list_to_add
= cu
->list_in_scope
;
20038 case DW_TAG_template_value_param
:
20040 /* Fall through. */
20041 case DW_TAG_constant
:
20042 case DW_TAG_variable
:
20043 case DW_TAG_member
:
20044 /* Compilation with minimal debug info may result in
20045 variables with missing type entries. Change the
20046 misleading `void' type to something sensible. */
20047 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
20048 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_int
;
20050 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
20051 /* In the case of DW_TAG_member, we should only be called for
20052 static const members. */
20053 if (die
->tag
== DW_TAG_member
)
20055 /* dwarf2_add_field uses die_is_declaration,
20056 so we do the same. */
20057 gdb_assert (die_is_declaration (die
, cu
));
20062 dwarf2_const_value (attr
, sym
, cu
);
20063 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
20066 if (attr2
&& (DW_UNSND (attr2
) != 0))
20067 list_to_add
= &global_symbols
;
20069 list_to_add
= cu
->list_in_scope
;
20073 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
20076 var_decode_location (attr
, sym
, cu
);
20077 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
20079 /* Fortran explicitly imports any global symbols to the local
20080 scope by DW_TAG_common_block. */
20081 if (cu
->language
== language_fortran
&& die
->parent
20082 && die
->parent
->tag
== DW_TAG_common_block
)
20085 if (SYMBOL_CLASS (sym
) == LOC_STATIC
20086 && SYMBOL_VALUE_ADDRESS (sym
) == 0
20087 && !dwarf2_per_objfile
->has_section_at_zero
)
20089 /* When a static variable is eliminated by the linker,
20090 the corresponding debug information is not stripped
20091 out, but the variable address is set to null;
20092 do not add such variables into symbol table. */
20094 else if (attr2
&& (DW_UNSND (attr2
) != 0))
20096 /* Workaround gfortran PR debug/40040 - it uses
20097 DW_AT_location for variables in -fPIC libraries which may
20098 get overriden by other libraries/executable and get
20099 a different address. Resolve it by the minimal symbol
20100 which may come from inferior's executable using copy
20101 relocation. Make this workaround only for gfortran as for
20102 other compilers GDB cannot guess the minimal symbol
20103 Fortran mangling kind. */
20104 if (cu
->language
== language_fortran
&& die
->parent
20105 && die
->parent
->tag
== DW_TAG_module
20107 && startswith (cu
->producer
, "GNU Fortran"))
20108 SYMBOL_ACLASS_INDEX (sym
) = LOC_UNRESOLVED
;
20110 /* A variable with DW_AT_external is never static,
20111 but it may be block-scoped. */
20112 list_to_add
= (cu
->list_in_scope
== &file_symbols
20113 ? &global_symbols
: cu
->list_in_scope
);
20116 list_to_add
= cu
->list_in_scope
;
20120 /* We do not know the address of this symbol.
20121 If it is an external symbol and we have type information
20122 for it, enter the symbol as a LOC_UNRESOLVED symbol.
20123 The address of the variable will then be determined from
20124 the minimal symbol table whenever the variable is
20126 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
20128 /* Fortran explicitly imports any global symbols to the local
20129 scope by DW_TAG_common_block. */
20130 if (cu
->language
== language_fortran
&& die
->parent
20131 && die
->parent
->tag
== DW_TAG_common_block
)
20133 /* SYMBOL_CLASS doesn't matter here because
20134 read_common_block is going to reset it. */
20136 list_to_add
= cu
->list_in_scope
;
20138 else if (attr2
&& (DW_UNSND (attr2
) != 0)
20139 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
20141 /* A variable with DW_AT_external is never static, but it
20142 may be block-scoped. */
20143 list_to_add
= (cu
->list_in_scope
== &file_symbols
20144 ? &global_symbols
: cu
->list_in_scope
);
20146 SYMBOL_ACLASS_INDEX (sym
) = LOC_UNRESOLVED
;
20148 else if (!die_is_declaration (die
, cu
))
20150 /* Use the default LOC_OPTIMIZED_OUT class. */
20151 gdb_assert (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
);
20153 list_to_add
= cu
->list_in_scope
;
20157 case DW_TAG_formal_parameter
:
20158 /* If we are inside a function, mark this as an argument. If
20159 not, we might be looking at an argument to an inlined function
20160 when we do not have enough information to show inlined frames;
20161 pretend it's a local variable in that case so that the user can
20163 if (context_stack_depth
> 0
20164 && context_stack
[context_stack_depth
- 1].name
!= NULL
)
20165 SYMBOL_IS_ARGUMENT (sym
) = 1;
20166 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
20169 var_decode_location (attr
, sym
, cu
);
20171 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
20174 dwarf2_const_value (attr
, sym
, cu
);
20177 list_to_add
= cu
->list_in_scope
;
20179 case DW_TAG_unspecified_parameters
:
20180 /* From varargs functions; gdb doesn't seem to have any
20181 interest in this information, so just ignore it for now.
20184 case DW_TAG_template_type_param
:
20186 /* Fall through. */
20187 case DW_TAG_class_type
:
20188 case DW_TAG_interface_type
:
20189 case DW_TAG_structure_type
:
20190 case DW_TAG_union_type
:
20191 case DW_TAG_set_type
:
20192 case DW_TAG_enumeration_type
:
20193 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
20194 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
20197 /* NOTE: carlton/2003-11-10: C++ class symbols shouldn't
20198 really ever be static objects: otherwise, if you try
20199 to, say, break of a class's method and you're in a file
20200 which doesn't mention that class, it won't work unless
20201 the check for all static symbols in lookup_symbol_aux
20202 saves you. See the OtherFileClass tests in
20203 gdb.c++/namespace.exp. */
20207 list_to_add
= (cu
->list_in_scope
== &file_symbols
20208 && cu
->language
== language_cplus
20209 ? &global_symbols
: cu
->list_in_scope
);
20211 /* The semantics of C++ state that "struct foo {
20212 ... }" also defines a typedef for "foo". */
20213 if (cu
->language
== language_cplus
20214 || cu
->language
== language_ada
20215 || cu
->language
== language_d
20216 || cu
->language
== language_rust
)
20218 /* The symbol's name is already allocated along
20219 with this objfile, so we don't need to
20220 duplicate it for the type. */
20221 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
20222 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
20227 case DW_TAG_typedef
:
20228 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
20229 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
20230 list_to_add
= cu
->list_in_scope
;
20232 case DW_TAG_base_type
:
20233 case DW_TAG_subrange_type
:
20234 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
20235 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
20236 list_to_add
= cu
->list_in_scope
;
20238 case DW_TAG_enumerator
:
20239 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
20242 dwarf2_const_value (attr
, sym
, cu
);
20245 /* NOTE: carlton/2003-11-10: See comment above in the
20246 DW_TAG_class_type, etc. block. */
20248 list_to_add
= (cu
->list_in_scope
== &file_symbols
20249 && cu
->language
== language_cplus
20250 ? &global_symbols
: cu
->list_in_scope
);
20253 case DW_TAG_imported_declaration
:
20254 case DW_TAG_namespace
:
20255 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
20256 list_to_add
= &global_symbols
;
20258 case DW_TAG_module
:
20259 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
20260 SYMBOL_DOMAIN (sym
) = MODULE_DOMAIN
;
20261 list_to_add
= &global_symbols
;
20263 case DW_TAG_common_block
:
20264 SYMBOL_ACLASS_INDEX (sym
) = LOC_COMMON_BLOCK
;
20265 SYMBOL_DOMAIN (sym
) = COMMON_BLOCK_DOMAIN
;
20266 add_symbol_to_list (sym
, cu
->list_in_scope
);
20269 /* Not a tag we recognize. Hopefully we aren't processing
20270 trash data, but since we must specifically ignore things
20271 we don't recognize, there is nothing else we should do at
20273 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
20274 dwarf_tag_name (die
->tag
));
20280 sym
->hash_next
= objfile
->template_symbols
;
20281 objfile
->template_symbols
= sym
;
20282 list_to_add
= NULL
;
20285 if (list_to_add
!= NULL
)
20286 add_symbol_to_list (sym
, list_to_add
);
20288 /* For the benefit of old versions of GCC, check for anonymous
20289 namespaces based on the demangled name. */
20290 if (!cu
->processing_has_namespace_info
20291 && cu
->language
== language_cplus
)
20292 cp_scan_for_anonymous_namespaces (sym
, objfile
);
20297 /* A wrapper for new_symbol_full that always allocates a new symbol. */
20299 static struct symbol
*
20300 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
20302 return new_symbol_full (die
, type
, cu
, NULL
);
20305 /* Given an attr with a DW_FORM_dataN value in host byte order,
20306 zero-extend it as appropriate for the symbol's type. The DWARF
20307 standard (v4) is not entirely clear about the meaning of using
20308 DW_FORM_dataN for a constant with a signed type, where the type is
20309 wider than the data. The conclusion of a discussion on the DWARF
20310 list was that this is unspecified. We choose to always zero-extend
20311 because that is the interpretation long in use by GCC. */
20314 dwarf2_const_value_data (const struct attribute
*attr
, struct obstack
*obstack
,
20315 struct dwarf2_cu
*cu
, LONGEST
*value
, int bits
)
20317 struct objfile
*objfile
= cu
->objfile
;
20318 enum bfd_endian byte_order
= bfd_big_endian (objfile
->obfd
) ?
20319 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
20320 LONGEST l
= DW_UNSND (attr
);
20322 if (bits
< sizeof (*value
) * 8)
20324 l
&= ((LONGEST
) 1 << bits
) - 1;
20327 else if (bits
== sizeof (*value
) * 8)
20331 gdb_byte
*bytes
= (gdb_byte
*) obstack_alloc (obstack
, bits
/ 8);
20332 store_unsigned_integer (bytes
, bits
/ 8, byte_order
, l
);
20339 /* Read a constant value from an attribute. Either set *VALUE, or if
20340 the value does not fit in *VALUE, set *BYTES - either already
20341 allocated on the objfile obstack, or newly allocated on OBSTACK,
20342 or, set *BATON, if we translated the constant to a location
20346 dwarf2_const_value_attr (const struct attribute
*attr
, struct type
*type
,
20347 const char *name
, struct obstack
*obstack
,
20348 struct dwarf2_cu
*cu
,
20349 LONGEST
*value
, const gdb_byte
**bytes
,
20350 struct dwarf2_locexpr_baton
**baton
)
20352 struct objfile
*objfile
= cu
->objfile
;
20353 struct comp_unit_head
*cu_header
= &cu
->header
;
20354 struct dwarf_block
*blk
;
20355 enum bfd_endian byte_order
= (bfd_big_endian (objfile
->obfd
) ?
20356 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
20362 switch (attr
->form
)
20365 case DW_FORM_GNU_addr_index
:
20369 if (TYPE_LENGTH (type
) != cu_header
->addr_size
)
20370 dwarf2_const_value_length_mismatch_complaint (name
,
20371 cu_header
->addr_size
,
20372 TYPE_LENGTH (type
));
20373 /* Symbols of this form are reasonably rare, so we just
20374 piggyback on the existing location code rather than writing
20375 a new implementation of symbol_computed_ops. */
20376 *baton
= XOBNEW (obstack
, struct dwarf2_locexpr_baton
);
20377 (*baton
)->per_cu
= cu
->per_cu
;
20378 gdb_assert ((*baton
)->per_cu
);
20380 (*baton
)->size
= 2 + cu_header
->addr_size
;
20381 data
= (gdb_byte
*) obstack_alloc (obstack
, (*baton
)->size
);
20382 (*baton
)->data
= data
;
20384 data
[0] = DW_OP_addr
;
20385 store_unsigned_integer (&data
[1], cu_header
->addr_size
,
20386 byte_order
, DW_ADDR (attr
));
20387 data
[cu_header
->addr_size
+ 1] = DW_OP_stack_value
;
20390 case DW_FORM_string
:
20392 case DW_FORM_GNU_str_index
:
20393 case DW_FORM_GNU_strp_alt
:
20394 /* DW_STRING is already allocated on the objfile obstack, point
20396 *bytes
= (const gdb_byte
*) DW_STRING (attr
);
20398 case DW_FORM_block1
:
20399 case DW_FORM_block2
:
20400 case DW_FORM_block4
:
20401 case DW_FORM_block
:
20402 case DW_FORM_exprloc
:
20403 case DW_FORM_data16
:
20404 blk
= DW_BLOCK (attr
);
20405 if (TYPE_LENGTH (type
) != blk
->size
)
20406 dwarf2_const_value_length_mismatch_complaint (name
, blk
->size
,
20407 TYPE_LENGTH (type
));
20408 *bytes
= blk
->data
;
20411 /* The DW_AT_const_value attributes are supposed to carry the
20412 symbol's value "represented as it would be on the target
20413 architecture." By the time we get here, it's already been
20414 converted to host endianness, so we just need to sign- or
20415 zero-extend it as appropriate. */
20416 case DW_FORM_data1
:
20417 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 8);
20419 case DW_FORM_data2
:
20420 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 16);
20422 case DW_FORM_data4
:
20423 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 32);
20425 case DW_FORM_data8
:
20426 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 64);
20429 case DW_FORM_sdata
:
20430 case DW_FORM_implicit_const
:
20431 *value
= DW_SND (attr
);
20434 case DW_FORM_udata
:
20435 *value
= DW_UNSND (attr
);
20439 complaint (&symfile_complaints
,
20440 _("unsupported const value attribute form: '%s'"),
20441 dwarf_form_name (attr
->form
));
20448 /* Copy constant value from an attribute to a symbol. */
20451 dwarf2_const_value (const struct attribute
*attr
, struct symbol
*sym
,
20452 struct dwarf2_cu
*cu
)
20454 struct objfile
*objfile
= cu
->objfile
;
20456 const gdb_byte
*bytes
;
20457 struct dwarf2_locexpr_baton
*baton
;
20459 dwarf2_const_value_attr (attr
, SYMBOL_TYPE (sym
),
20460 SYMBOL_PRINT_NAME (sym
),
20461 &objfile
->objfile_obstack
, cu
,
20462 &value
, &bytes
, &baton
);
20466 SYMBOL_LOCATION_BATON (sym
) = baton
;
20467 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
20469 else if (bytes
!= NULL
)
20471 SYMBOL_VALUE_BYTES (sym
) = bytes
;
20472 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST_BYTES
;
20476 SYMBOL_VALUE (sym
) = value
;
20477 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST
;
20481 /* Return the type of the die in question using its DW_AT_type attribute. */
20483 static struct type
*
20484 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
20486 struct attribute
*type_attr
;
20488 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
20491 /* A missing DW_AT_type represents a void type. */
20492 return objfile_type (cu
->objfile
)->builtin_void
;
20495 return lookup_die_type (die
, type_attr
, cu
);
20498 /* True iff CU's producer generates GNAT Ada auxiliary information
20499 that allows to find parallel types through that information instead
20500 of having to do expensive parallel lookups by type name. */
20503 need_gnat_info (struct dwarf2_cu
*cu
)
20505 /* FIXME: brobecker/2010-10-12: As of now, only the AdaCore version
20506 of GNAT produces this auxiliary information, without any indication
20507 that it is produced. Part of enhancing the FSF version of GNAT
20508 to produce that information will be to put in place an indicator
20509 that we can use in order to determine whether the descriptive type
20510 info is available or not. One suggestion that has been made is
20511 to use a new attribute, attached to the CU die. For now, assume
20512 that the descriptive type info is not available. */
20516 /* Return the auxiliary type of the die in question using its
20517 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
20518 attribute is not present. */
20520 static struct type
*
20521 die_descriptive_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
20523 struct attribute
*type_attr
;
20525 type_attr
= dwarf2_attr (die
, DW_AT_GNAT_descriptive_type
, cu
);
20529 return lookup_die_type (die
, type_attr
, cu
);
20532 /* If DIE has a descriptive_type attribute, then set the TYPE's
20533 descriptive type accordingly. */
20536 set_descriptive_type (struct type
*type
, struct die_info
*die
,
20537 struct dwarf2_cu
*cu
)
20539 struct type
*descriptive_type
= die_descriptive_type (die
, cu
);
20541 if (descriptive_type
)
20543 ALLOCATE_GNAT_AUX_TYPE (type
);
20544 TYPE_DESCRIPTIVE_TYPE (type
) = descriptive_type
;
20548 /* Return the containing type of the die in question using its
20549 DW_AT_containing_type attribute. */
20551 static struct type
*
20552 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
20554 struct attribute
*type_attr
;
20556 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
20558 error (_("Dwarf Error: Problem turning containing type into gdb type "
20559 "[in module %s]"), objfile_name (cu
->objfile
));
20561 return lookup_die_type (die
, type_attr
, cu
);
20564 /* Return an error marker type to use for the ill formed type in DIE/CU. */
20566 static struct type
*
20567 build_error_marker_type (struct dwarf2_cu
*cu
, struct die_info
*die
)
20569 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
20570 char *message
, *saved
;
20572 message
= xstrprintf (_("<unknown type in %s, CU 0x%x, DIE 0x%x>"),
20573 objfile_name (objfile
),
20574 to_underlying (cu
->header
.sect_off
),
20575 to_underlying (die
->sect_off
));
20576 saved
= (char *) obstack_copy0 (&objfile
->objfile_obstack
,
20577 message
, strlen (message
));
20580 return init_type (objfile
, TYPE_CODE_ERROR
, 0, saved
);
20583 /* Look up the type of DIE in CU using its type attribute ATTR.
20584 ATTR must be one of: DW_AT_type, DW_AT_GNAT_descriptive_type,
20585 DW_AT_containing_type.
20586 If there is no type substitute an error marker. */
20588 static struct type
*
20589 lookup_die_type (struct die_info
*die
, const struct attribute
*attr
,
20590 struct dwarf2_cu
*cu
)
20592 struct objfile
*objfile
= cu
->objfile
;
20593 struct type
*this_type
;
20595 gdb_assert (attr
->name
== DW_AT_type
20596 || attr
->name
== DW_AT_GNAT_descriptive_type
20597 || attr
->name
== DW_AT_containing_type
);
20599 /* First see if we have it cached. */
20601 if (attr
->form
== DW_FORM_GNU_ref_alt
)
20603 struct dwarf2_per_cu_data
*per_cu
;
20604 sect_offset sect_off
= dwarf2_get_ref_die_offset (attr
);
20606 per_cu
= dwarf2_find_containing_comp_unit (sect_off
, 1, cu
->objfile
);
20607 this_type
= get_die_type_at_offset (sect_off
, per_cu
);
20609 else if (attr_form_is_ref (attr
))
20611 sect_offset sect_off
= dwarf2_get_ref_die_offset (attr
);
20613 this_type
= get_die_type_at_offset (sect_off
, cu
->per_cu
);
20615 else if (attr
->form
== DW_FORM_ref_sig8
)
20617 ULONGEST signature
= DW_SIGNATURE (attr
);
20619 return get_signatured_type (die
, signature
, cu
);
20623 complaint (&symfile_complaints
,
20624 _("Dwarf Error: Bad type attribute %s in DIE"
20625 " at 0x%x [in module %s]"),
20626 dwarf_attr_name (attr
->name
), to_underlying (die
->sect_off
),
20627 objfile_name (objfile
));
20628 return build_error_marker_type (cu
, die
);
20631 /* If not cached we need to read it in. */
20633 if (this_type
== NULL
)
20635 struct die_info
*type_die
= NULL
;
20636 struct dwarf2_cu
*type_cu
= cu
;
20638 if (attr_form_is_ref (attr
))
20639 type_die
= follow_die_ref (die
, attr
, &type_cu
);
20640 if (type_die
== NULL
)
20641 return build_error_marker_type (cu
, die
);
20642 /* If we find the type now, it's probably because the type came
20643 from an inter-CU reference and the type's CU got expanded before
20645 this_type
= read_type_die (type_die
, type_cu
);
20648 /* If we still don't have a type use an error marker. */
20650 if (this_type
== NULL
)
20651 return build_error_marker_type (cu
, die
);
20656 /* Return the type in DIE, CU.
20657 Returns NULL for invalid types.
20659 This first does a lookup in die_type_hash,
20660 and only reads the die in if necessary.
20662 NOTE: This can be called when reading in partial or full symbols. */
20664 static struct type
*
20665 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
20667 struct type
*this_type
;
20669 this_type
= get_die_type (die
, cu
);
20673 return read_type_die_1 (die
, cu
);
20676 /* Read the type in DIE, CU.
20677 Returns NULL for invalid types. */
20679 static struct type
*
20680 read_type_die_1 (struct die_info
*die
, struct dwarf2_cu
*cu
)
20682 struct type
*this_type
= NULL
;
20686 case DW_TAG_class_type
:
20687 case DW_TAG_interface_type
:
20688 case DW_TAG_structure_type
:
20689 case DW_TAG_union_type
:
20690 this_type
= read_structure_type (die
, cu
);
20692 case DW_TAG_enumeration_type
:
20693 this_type
= read_enumeration_type (die
, cu
);
20695 case DW_TAG_subprogram
:
20696 case DW_TAG_subroutine_type
:
20697 case DW_TAG_inlined_subroutine
:
20698 this_type
= read_subroutine_type (die
, cu
);
20700 case DW_TAG_array_type
:
20701 this_type
= read_array_type (die
, cu
);
20703 case DW_TAG_set_type
:
20704 this_type
= read_set_type (die
, cu
);
20706 case DW_TAG_pointer_type
:
20707 this_type
= read_tag_pointer_type (die
, cu
);
20709 case DW_TAG_ptr_to_member_type
:
20710 this_type
= read_tag_ptr_to_member_type (die
, cu
);
20712 case DW_TAG_reference_type
:
20713 this_type
= read_tag_reference_type (die
, cu
, TYPE_CODE_REF
);
20715 case DW_TAG_rvalue_reference_type
:
20716 this_type
= read_tag_reference_type (die
, cu
, TYPE_CODE_RVALUE_REF
);
20718 case DW_TAG_const_type
:
20719 this_type
= read_tag_const_type (die
, cu
);
20721 case DW_TAG_volatile_type
:
20722 this_type
= read_tag_volatile_type (die
, cu
);
20724 case DW_TAG_restrict_type
:
20725 this_type
= read_tag_restrict_type (die
, cu
);
20727 case DW_TAG_string_type
:
20728 this_type
= read_tag_string_type (die
, cu
);
20730 case DW_TAG_typedef
:
20731 this_type
= read_typedef (die
, cu
);
20733 case DW_TAG_subrange_type
:
20734 this_type
= read_subrange_type (die
, cu
);
20736 case DW_TAG_base_type
:
20737 this_type
= read_base_type (die
, cu
);
20739 case DW_TAG_unspecified_type
:
20740 this_type
= read_unspecified_type (die
, cu
);
20742 case DW_TAG_namespace
:
20743 this_type
= read_namespace_type (die
, cu
);
20745 case DW_TAG_module
:
20746 this_type
= read_module_type (die
, cu
);
20748 case DW_TAG_atomic_type
:
20749 this_type
= read_tag_atomic_type (die
, cu
);
20752 complaint (&symfile_complaints
,
20753 _("unexpected tag in read_type_die: '%s'"),
20754 dwarf_tag_name (die
->tag
));
20761 /* See if we can figure out if the class lives in a namespace. We do
20762 this by looking for a member function; its demangled name will
20763 contain namespace info, if there is any.
20764 Return the computed name or NULL.
20765 Space for the result is allocated on the objfile's obstack.
20766 This is the full-die version of guess_partial_die_structure_name.
20767 In this case we know DIE has no useful parent. */
20770 guess_full_die_structure_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
20772 struct die_info
*spec_die
;
20773 struct dwarf2_cu
*spec_cu
;
20774 struct die_info
*child
;
20777 spec_die
= die_specification (die
, &spec_cu
);
20778 if (spec_die
!= NULL
)
20784 for (child
= die
->child
;
20786 child
= child
->sibling
)
20788 if (child
->tag
== DW_TAG_subprogram
)
20790 const char *linkage_name
= dw2_linkage_name (child
, cu
);
20792 if (linkage_name
!= NULL
)
20795 = language_class_name_from_physname (cu
->language_defn
,
20799 if (actual_name
!= NULL
)
20801 const char *die_name
= dwarf2_name (die
, cu
);
20803 if (die_name
!= NULL
20804 && strcmp (die_name
, actual_name
) != 0)
20806 /* Strip off the class name from the full name.
20807 We want the prefix. */
20808 int die_name_len
= strlen (die_name
);
20809 int actual_name_len
= strlen (actual_name
);
20811 /* Test for '::' as a sanity check. */
20812 if (actual_name_len
> die_name_len
+ 2
20813 && actual_name
[actual_name_len
20814 - die_name_len
- 1] == ':')
20815 name
= (char *) obstack_copy0 (
20816 &cu
->objfile
->per_bfd
->storage_obstack
,
20817 actual_name
, actual_name_len
- die_name_len
- 2);
20820 xfree (actual_name
);
20829 /* GCC might emit a nameless typedef that has a linkage name. Determine the
20830 prefix part in such case. See
20831 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
20833 static const char *
20834 anonymous_struct_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
20836 struct attribute
*attr
;
20839 if (die
->tag
!= DW_TAG_class_type
&& die
->tag
!= DW_TAG_interface_type
20840 && die
->tag
!= DW_TAG_structure_type
&& die
->tag
!= DW_TAG_union_type
)
20843 if (dwarf2_string_attr (die
, DW_AT_name
, cu
) != NULL
)
20846 attr
= dw2_linkage_name_attr (die
, cu
);
20847 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
20850 /* dwarf2_name had to be already called. */
20851 gdb_assert (DW_STRING_IS_CANONICAL (attr
));
20853 /* Strip the base name, keep any leading namespaces/classes. */
20854 base
= strrchr (DW_STRING (attr
), ':');
20855 if (base
== NULL
|| base
== DW_STRING (attr
) || base
[-1] != ':')
20858 return (char *) obstack_copy0 (&cu
->objfile
->per_bfd
->storage_obstack
,
20860 &base
[-1] - DW_STRING (attr
));
20863 /* Return the name of the namespace/class that DIE is defined within,
20864 or "" if we can't tell. The caller should not xfree the result.
20866 For example, if we're within the method foo() in the following
20876 then determine_prefix on foo's die will return "N::C". */
20878 static const char *
20879 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
20881 struct die_info
*parent
, *spec_die
;
20882 struct dwarf2_cu
*spec_cu
;
20883 struct type
*parent_type
;
20884 const char *retval
;
20886 if (cu
->language
!= language_cplus
20887 && cu
->language
!= language_fortran
&& cu
->language
!= language_d
20888 && cu
->language
!= language_rust
)
20891 retval
= anonymous_struct_prefix (die
, cu
);
20895 /* We have to be careful in the presence of DW_AT_specification.
20896 For example, with GCC 3.4, given the code
20900 // Definition of N::foo.
20904 then we'll have a tree of DIEs like this:
20906 1: DW_TAG_compile_unit
20907 2: DW_TAG_namespace // N
20908 3: DW_TAG_subprogram // declaration of N::foo
20909 4: DW_TAG_subprogram // definition of N::foo
20910 DW_AT_specification // refers to die #3
20912 Thus, when processing die #4, we have to pretend that we're in
20913 the context of its DW_AT_specification, namely the contex of die
20916 spec_die
= die_specification (die
, &spec_cu
);
20917 if (spec_die
== NULL
)
20918 parent
= die
->parent
;
20921 parent
= spec_die
->parent
;
20925 if (parent
== NULL
)
20927 else if (parent
->building_fullname
)
20930 const char *parent_name
;
20932 /* It has been seen on RealView 2.2 built binaries,
20933 DW_TAG_template_type_param types actually _defined_ as
20934 children of the parent class:
20937 template class <class Enum> Class{};
20938 Class<enum E> class_e;
20940 1: DW_TAG_class_type (Class)
20941 2: DW_TAG_enumeration_type (E)
20942 3: DW_TAG_enumerator (enum1:0)
20943 3: DW_TAG_enumerator (enum2:1)
20945 2: DW_TAG_template_type_param
20946 DW_AT_type DW_FORM_ref_udata (E)
20948 Besides being broken debug info, it can put GDB into an
20949 infinite loop. Consider:
20951 When we're building the full name for Class<E>, we'll start
20952 at Class, and go look over its template type parameters,
20953 finding E. We'll then try to build the full name of E, and
20954 reach here. We're now trying to build the full name of E,
20955 and look over the parent DIE for containing scope. In the
20956 broken case, if we followed the parent DIE of E, we'd again
20957 find Class, and once again go look at its template type
20958 arguments, etc., etc. Simply don't consider such parent die
20959 as source-level parent of this die (it can't be, the language
20960 doesn't allow it), and break the loop here. */
20961 name
= dwarf2_name (die
, cu
);
20962 parent_name
= dwarf2_name (parent
, cu
);
20963 complaint (&symfile_complaints
,
20964 _("template param type '%s' defined within parent '%s'"),
20965 name
? name
: "<unknown>",
20966 parent_name
? parent_name
: "<unknown>");
20970 switch (parent
->tag
)
20972 case DW_TAG_namespace
:
20973 parent_type
= read_type_die (parent
, cu
);
20974 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
20975 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
20976 Work around this problem here. */
20977 if (cu
->language
== language_cplus
20978 && strcmp (TYPE_TAG_NAME (parent_type
), "::") == 0)
20980 /* We give a name to even anonymous namespaces. */
20981 return TYPE_TAG_NAME (parent_type
);
20982 case DW_TAG_class_type
:
20983 case DW_TAG_interface_type
:
20984 case DW_TAG_structure_type
:
20985 case DW_TAG_union_type
:
20986 case DW_TAG_module
:
20987 parent_type
= read_type_die (parent
, cu
);
20988 if (TYPE_TAG_NAME (parent_type
) != NULL
)
20989 return TYPE_TAG_NAME (parent_type
);
20991 /* An anonymous structure is only allowed non-static data
20992 members; no typedefs, no member functions, et cetera.
20993 So it does not need a prefix. */
20995 case DW_TAG_compile_unit
:
20996 case DW_TAG_partial_unit
:
20997 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
20998 if (cu
->language
== language_cplus
20999 && !VEC_empty (dwarf2_section_info_def
, dwarf2_per_objfile
->types
)
21000 && die
->child
!= NULL
21001 && (die
->tag
== DW_TAG_class_type
21002 || die
->tag
== DW_TAG_structure_type
21003 || die
->tag
== DW_TAG_union_type
))
21005 char *name
= guess_full_die_structure_name (die
, cu
);
21010 case DW_TAG_enumeration_type
:
21011 parent_type
= read_type_die (parent
, cu
);
21012 if (TYPE_DECLARED_CLASS (parent_type
))
21014 if (TYPE_TAG_NAME (parent_type
) != NULL
)
21015 return TYPE_TAG_NAME (parent_type
);
21018 /* Fall through. */
21020 return determine_prefix (parent
, cu
);
21024 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
21025 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
21026 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
21027 an obconcat, otherwise allocate storage for the result. The CU argument is
21028 used to determine the language and hence, the appropriate separator. */
21030 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
21033 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
21034 int physname
, struct dwarf2_cu
*cu
)
21036 const char *lead
= "";
21039 if (suffix
== NULL
|| suffix
[0] == '\0'
21040 || prefix
== NULL
|| prefix
[0] == '\0')
21042 else if (cu
->language
== language_d
)
21044 /* For D, the 'main' function could be defined in any module, but it
21045 should never be prefixed. */
21046 if (strcmp (suffix
, "D main") == 0)
21054 else if (cu
->language
== language_fortran
&& physname
)
21056 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
21057 DW_AT_MIPS_linkage_name is preferred and used instead. */
21065 if (prefix
== NULL
)
21067 if (suffix
== NULL
)
21074 xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1));
21076 strcpy (retval
, lead
);
21077 strcat (retval
, prefix
);
21078 strcat (retval
, sep
);
21079 strcat (retval
, suffix
);
21084 /* We have an obstack. */
21085 return obconcat (obs
, lead
, prefix
, sep
, suffix
, (char *) NULL
);
21089 /* Return sibling of die, NULL if no sibling. */
21091 static struct die_info
*
21092 sibling_die (struct die_info
*die
)
21094 return die
->sibling
;
21097 /* Get name of a die, return NULL if not found. */
21099 static const char *
21100 dwarf2_canonicalize_name (const char *name
, struct dwarf2_cu
*cu
,
21101 struct obstack
*obstack
)
21103 if (name
&& cu
->language
== language_cplus
)
21105 std::string canon_name
= cp_canonicalize_string (name
);
21107 if (!canon_name
.empty ())
21109 if (canon_name
!= name
)
21110 name
= (const char *) obstack_copy0 (obstack
,
21111 canon_name
.c_str (),
21112 canon_name
.length ());
21119 /* Get name of a die, return NULL if not found.
21120 Anonymous namespaces are converted to their magic string. */
21122 static const char *
21123 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
21125 struct attribute
*attr
;
21127 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
21128 if ((!attr
|| !DW_STRING (attr
))
21129 && die
->tag
!= DW_TAG_namespace
21130 && die
->tag
!= DW_TAG_class_type
21131 && die
->tag
!= DW_TAG_interface_type
21132 && die
->tag
!= DW_TAG_structure_type
21133 && die
->tag
!= DW_TAG_union_type
)
21138 case DW_TAG_compile_unit
:
21139 case DW_TAG_partial_unit
:
21140 /* Compilation units have a DW_AT_name that is a filename, not
21141 a source language identifier. */
21142 case DW_TAG_enumeration_type
:
21143 case DW_TAG_enumerator
:
21144 /* These tags always have simple identifiers already; no need
21145 to canonicalize them. */
21146 return DW_STRING (attr
);
21148 case DW_TAG_namespace
:
21149 if (attr
!= NULL
&& DW_STRING (attr
) != NULL
)
21150 return DW_STRING (attr
);
21151 return CP_ANONYMOUS_NAMESPACE_STR
;
21153 case DW_TAG_class_type
:
21154 case DW_TAG_interface_type
:
21155 case DW_TAG_structure_type
:
21156 case DW_TAG_union_type
:
21157 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
21158 structures or unions. These were of the form "._%d" in GCC 4.1,
21159 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
21160 and GCC 4.4. We work around this problem by ignoring these. */
21161 if (attr
&& DW_STRING (attr
)
21162 && (startswith (DW_STRING (attr
), "._")
21163 || startswith (DW_STRING (attr
), "<anonymous")))
21166 /* GCC might emit a nameless typedef that has a linkage name. See
21167 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
21168 if (!attr
|| DW_STRING (attr
) == NULL
)
21170 char *demangled
= NULL
;
21172 attr
= dw2_linkage_name_attr (die
, cu
);
21173 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
21176 /* Avoid demangling DW_STRING (attr) the second time on a second
21177 call for the same DIE. */
21178 if (!DW_STRING_IS_CANONICAL (attr
))
21179 demangled
= gdb_demangle (DW_STRING (attr
), DMGL_TYPES
);
21185 /* FIXME: we already did this for the partial symbol... */
21188 obstack_copy0 (&cu
->objfile
->per_bfd
->storage_obstack
,
21189 demangled
, strlen (demangled
)));
21190 DW_STRING_IS_CANONICAL (attr
) = 1;
21193 /* Strip any leading namespaces/classes, keep only the base name.
21194 DW_AT_name for named DIEs does not contain the prefixes. */
21195 base
= strrchr (DW_STRING (attr
), ':');
21196 if (base
&& base
> DW_STRING (attr
) && base
[-1] == ':')
21199 return DW_STRING (attr
);
21208 if (!DW_STRING_IS_CANONICAL (attr
))
21211 = dwarf2_canonicalize_name (DW_STRING (attr
), cu
,
21212 &cu
->objfile
->per_bfd
->storage_obstack
);
21213 DW_STRING_IS_CANONICAL (attr
) = 1;
21215 return DW_STRING (attr
);
21218 /* Return the die that this die in an extension of, or NULL if there
21219 is none. *EXT_CU is the CU containing DIE on input, and the CU
21220 containing the return value on output. */
21222 static struct die_info
*
21223 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
**ext_cu
)
21225 struct attribute
*attr
;
21227 attr
= dwarf2_attr (die
, DW_AT_extension
, *ext_cu
);
21231 return follow_die_ref (die
, attr
, ext_cu
);
21234 /* Convert a DIE tag into its string name. */
21236 static const char *
21237 dwarf_tag_name (unsigned tag
)
21239 const char *name
= get_DW_TAG_name (tag
);
21242 return "DW_TAG_<unknown>";
21247 /* Convert a DWARF attribute code into its string name. */
21249 static const char *
21250 dwarf_attr_name (unsigned attr
)
21254 #ifdef MIPS /* collides with DW_AT_HP_block_index */
21255 if (attr
== DW_AT_MIPS_fde
)
21256 return "DW_AT_MIPS_fde";
21258 if (attr
== DW_AT_HP_block_index
)
21259 return "DW_AT_HP_block_index";
21262 name
= get_DW_AT_name (attr
);
21265 return "DW_AT_<unknown>";
21270 /* Convert a DWARF value form code into its string name. */
21272 static const char *
21273 dwarf_form_name (unsigned form
)
21275 const char *name
= get_DW_FORM_name (form
);
21278 return "DW_FORM_<unknown>";
21283 static const char *
21284 dwarf_bool_name (unsigned mybool
)
21292 /* Convert a DWARF type code into its string name. */
21294 static const char *
21295 dwarf_type_encoding_name (unsigned enc
)
21297 const char *name
= get_DW_ATE_name (enc
);
21300 return "DW_ATE_<unknown>";
21306 dump_die_shallow (struct ui_file
*f
, int indent
, struct die_info
*die
)
21310 print_spaces (indent
, f
);
21311 fprintf_unfiltered (f
, "Die: %s (abbrev %d, offset 0x%x)\n",
21312 dwarf_tag_name (die
->tag
), die
->abbrev
,
21313 to_underlying (die
->sect_off
));
21315 if (die
->parent
!= NULL
)
21317 print_spaces (indent
, f
);
21318 fprintf_unfiltered (f
, " parent at offset: 0x%x\n",
21319 to_underlying (die
->parent
->sect_off
));
21322 print_spaces (indent
, f
);
21323 fprintf_unfiltered (f
, " has children: %s\n",
21324 dwarf_bool_name (die
->child
!= NULL
));
21326 print_spaces (indent
, f
);
21327 fprintf_unfiltered (f
, " attributes:\n");
21329 for (i
= 0; i
< die
->num_attrs
; ++i
)
21331 print_spaces (indent
, f
);
21332 fprintf_unfiltered (f
, " %s (%s) ",
21333 dwarf_attr_name (die
->attrs
[i
].name
),
21334 dwarf_form_name (die
->attrs
[i
].form
));
21336 switch (die
->attrs
[i
].form
)
21339 case DW_FORM_GNU_addr_index
:
21340 fprintf_unfiltered (f
, "address: ");
21341 fputs_filtered (hex_string (DW_ADDR (&die
->attrs
[i
])), f
);
21343 case DW_FORM_block2
:
21344 case DW_FORM_block4
:
21345 case DW_FORM_block
:
21346 case DW_FORM_block1
:
21347 fprintf_unfiltered (f
, "block: size %s",
21348 pulongest (DW_BLOCK (&die
->attrs
[i
])->size
));
21350 case DW_FORM_exprloc
:
21351 fprintf_unfiltered (f
, "expression: size %s",
21352 pulongest (DW_BLOCK (&die
->attrs
[i
])->size
));
21354 case DW_FORM_data16
:
21355 fprintf_unfiltered (f
, "constant of 16 bytes");
21357 case DW_FORM_ref_addr
:
21358 fprintf_unfiltered (f
, "ref address: ");
21359 fputs_filtered (hex_string (DW_UNSND (&die
->attrs
[i
])), f
);
21361 case DW_FORM_GNU_ref_alt
:
21362 fprintf_unfiltered (f
, "alt ref address: ");
21363 fputs_filtered (hex_string (DW_UNSND (&die
->attrs
[i
])), f
);
21369 case DW_FORM_ref_udata
:
21370 fprintf_unfiltered (f
, "constant ref: 0x%lx (adjusted)",
21371 (long) (DW_UNSND (&die
->attrs
[i
])));
21373 case DW_FORM_data1
:
21374 case DW_FORM_data2
:
21375 case DW_FORM_data4
:
21376 case DW_FORM_data8
:
21377 case DW_FORM_udata
:
21378 case DW_FORM_sdata
:
21379 fprintf_unfiltered (f
, "constant: %s",
21380 pulongest (DW_UNSND (&die
->attrs
[i
])));
21382 case DW_FORM_sec_offset
:
21383 fprintf_unfiltered (f
, "section offset: %s",
21384 pulongest (DW_UNSND (&die
->attrs
[i
])));
21386 case DW_FORM_ref_sig8
:
21387 fprintf_unfiltered (f
, "signature: %s",
21388 hex_string (DW_SIGNATURE (&die
->attrs
[i
])));
21390 case DW_FORM_string
:
21392 case DW_FORM_line_strp
:
21393 case DW_FORM_GNU_str_index
:
21394 case DW_FORM_GNU_strp_alt
:
21395 fprintf_unfiltered (f
, "string: \"%s\" (%s canonicalized)",
21396 DW_STRING (&die
->attrs
[i
])
21397 ? DW_STRING (&die
->attrs
[i
]) : "",
21398 DW_STRING_IS_CANONICAL (&die
->attrs
[i
]) ? "is" : "not");
21401 if (DW_UNSND (&die
->attrs
[i
]))
21402 fprintf_unfiltered (f
, "flag: TRUE");
21404 fprintf_unfiltered (f
, "flag: FALSE");
21406 case DW_FORM_flag_present
:
21407 fprintf_unfiltered (f
, "flag: TRUE");
21409 case DW_FORM_indirect
:
21410 /* The reader will have reduced the indirect form to
21411 the "base form" so this form should not occur. */
21412 fprintf_unfiltered (f
,
21413 "unexpected attribute form: DW_FORM_indirect");
21415 case DW_FORM_implicit_const
:
21416 fprintf_unfiltered (f
, "constant: %s",
21417 plongest (DW_SND (&die
->attrs
[i
])));
21420 fprintf_unfiltered (f
, "unsupported attribute form: %d.",
21421 die
->attrs
[i
].form
);
21424 fprintf_unfiltered (f
, "\n");
21429 dump_die_for_error (struct die_info
*die
)
21431 dump_die_shallow (gdb_stderr
, 0, die
);
21435 dump_die_1 (struct ui_file
*f
, int level
, int max_level
, struct die_info
*die
)
21437 int indent
= level
* 4;
21439 gdb_assert (die
!= NULL
);
21441 if (level
>= max_level
)
21444 dump_die_shallow (f
, indent
, die
);
21446 if (die
->child
!= NULL
)
21448 print_spaces (indent
, f
);
21449 fprintf_unfiltered (f
, " Children:");
21450 if (level
+ 1 < max_level
)
21452 fprintf_unfiltered (f
, "\n");
21453 dump_die_1 (f
, level
+ 1, max_level
, die
->child
);
21457 fprintf_unfiltered (f
,
21458 " [not printed, max nesting level reached]\n");
21462 if (die
->sibling
!= NULL
&& level
> 0)
21464 dump_die_1 (f
, level
, max_level
, die
->sibling
);
21468 /* This is called from the pdie macro in gdbinit.in.
21469 It's not static so gcc will keep a copy callable from gdb. */
21472 dump_die (struct die_info
*die
, int max_level
)
21474 dump_die_1 (gdb_stdlog
, 0, max_level
, die
);
21478 store_in_ref_table (struct die_info
*die
, struct dwarf2_cu
*cu
)
21482 slot
= htab_find_slot_with_hash (cu
->die_hash
, die
,
21483 to_underlying (die
->sect_off
),
21489 /* Return DIE offset of ATTR. Return 0 with complaint if ATTR is not of the
21493 dwarf2_get_ref_die_offset (const struct attribute
*attr
)
21495 if (attr_form_is_ref (attr
))
21496 return (sect_offset
) DW_UNSND (attr
);
21498 complaint (&symfile_complaints
,
21499 _("unsupported die ref attribute form: '%s'"),
21500 dwarf_form_name (attr
->form
));
21504 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
21505 * the value held by the attribute is not constant. */
21508 dwarf2_get_attr_constant_value (const struct attribute
*attr
, int default_value
)
21510 if (attr
->form
== DW_FORM_sdata
|| attr
->form
== DW_FORM_implicit_const
)
21511 return DW_SND (attr
);
21512 else if (attr
->form
== DW_FORM_udata
21513 || attr
->form
== DW_FORM_data1
21514 || attr
->form
== DW_FORM_data2
21515 || attr
->form
== DW_FORM_data4
21516 || attr
->form
== DW_FORM_data8
)
21517 return DW_UNSND (attr
);
21520 /* For DW_FORM_data16 see attr_form_is_constant. */
21521 complaint (&symfile_complaints
,
21522 _("Attribute value is not a constant (%s)"),
21523 dwarf_form_name (attr
->form
));
21524 return default_value
;
21528 /* Follow reference or signature attribute ATTR of SRC_DIE.
21529 On entry *REF_CU is the CU of SRC_DIE.
21530 On exit *REF_CU is the CU of the result. */
21532 static struct die_info
*
21533 follow_die_ref_or_sig (struct die_info
*src_die
, const struct attribute
*attr
,
21534 struct dwarf2_cu
**ref_cu
)
21536 struct die_info
*die
;
21538 if (attr_form_is_ref (attr
))
21539 die
= follow_die_ref (src_die
, attr
, ref_cu
);
21540 else if (attr
->form
== DW_FORM_ref_sig8
)
21541 die
= follow_die_sig (src_die
, attr
, ref_cu
);
21544 dump_die_for_error (src_die
);
21545 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
21546 objfile_name ((*ref_cu
)->objfile
));
21552 /* Follow reference OFFSET.
21553 On entry *REF_CU is the CU of the source die referencing OFFSET.
21554 On exit *REF_CU is the CU of the result.
21555 Returns NULL if OFFSET is invalid. */
21557 static struct die_info
*
21558 follow_die_offset (sect_offset sect_off
, int offset_in_dwz
,
21559 struct dwarf2_cu
**ref_cu
)
21561 struct die_info temp_die
;
21562 struct dwarf2_cu
*target_cu
, *cu
= *ref_cu
;
21564 gdb_assert (cu
->per_cu
!= NULL
);
21568 if (cu
->per_cu
->is_debug_types
)
21570 /* .debug_types CUs cannot reference anything outside their CU.
21571 If they need to, they have to reference a signatured type via
21572 DW_FORM_ref_sig8. */
21573 if (!offset_in_cu_p (&cu
->header
, sect_off
))
21576 else if (offset_in_dwz
!= cu
->per_cu
->is_dwz
21577 || !offset_in_cu_p (&cu
->header
, sect_off
))
21579 struct dwarf2_per_cu_data
*per_cu
;
21581 per_cu
= dwarf2_find_containing_comp_unit (sect_off
, offset_in_dwz
,
21584 /* If necessary, add it to the queue and load its DIEs. */
21585 if (maybe_queue_comp_unit (cu
, per_cu
, cu
->language
))
21586 load_full_comp_unit (per_cu
, cu
->language
);
21588 target_cu
= per_cu
->cu
;
21590 else if (cu
->dies
== NULL
)
21592 /* We're loading full DIEs during partial symbol reading. */
21593 gdb_assert (dwarf2_per_objfile
->reading_partial_symbols
);
21594 load_full_comp_unit (cu
->per_cu
, language_minimal
);
21597 *ref_cu
= target_cu
;
21598 temp_die
.sect_off
= sect_off
;
21599 return (struct die_info
*) htab_find_with_hash (target_cu
->die_hash
,
21601 to_underlying (sect_off
));
21604 /* Follow reference attribute ATTR of SRC_DIE.
21605 On entry *REF_CU is the CU of SRC_DIE.
21606 On exit *REF_CU is the CU of the result. */
21608 static struct die_info
*
21609 follow_die_ref (struct die_info
*src_die
, const struct attribute
*attr
,
21610 struct dwarf2_cu
**ref_cu
)
21612 sect_offset sect_off
= dwarf2_get_ref_die_offset (attr
);
21613 struct dwarf2_cu
*cu
= *ref_cu
;
21614 struct die_info
*die
;
21616 die
= follow_die_offset (sect_off
,
21617 (attr
->form
== DW_FORM_GNU_ref_alt
21618 || cu
->per_cu
->is_dwz
),
21621 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced from DIE "
21622 "at 0x%x [in module %s]"),
21623 to_underlying (sect_off
), to_underlying (src_die
->sect_off
),
21624 objfile_name (cu
->objfile
));
21629 /* Return DWARF block referenced by DW_AT_location of DIE at SECT_OFF at PER_CU.
21630 Returned value is intended for DW_OP_call*. Returned
21631 dwarf2_locexpr_baton->data has lifetime of PER_CU->OBJFILE. */
21633 struct dwarf2_locexpr_baton
21634 dwarf2_fetch_die_loc_sect_off (sect_offset sect_off
,
21635 struct dwarf2_per_cu_data
*per_cu
,
21636 CORE_ADDR (*get_frame_pc
) (void *baton
),
21639 struct dwarf2_cu
*cu
;
21640 struct die_info
*die
;
21641 struct attribute
*attr
;
21642 struct dwarf2_locexpr_baton retval
;
21644 dw2_setup (per_cu
->objfile
);
21646 if (per_cu
->cu
== NULL
)
21651 /* We shouldn't get here for a dummy CU, but don't crash on the user.
21652 Instead just throw an error, not much else we can do. */
21653 error (_("Dwarf Error: Dummy CU at 0x%x referenced in module %s"),
21654 to_underlying (sect_off
), objfile_name (per_cu
->objfile
));
21657 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
21659 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
21660 to_underlying (sect_off
), objfile_name (per_cu
->objfile
));
21662 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
21665 /* DWARF: "If there is no such attribute, then there is no effect.".
21666 DATA is ignored if SIZE is 0. */
21668 retval
.data
= NULL
;
21671 else if (attr_form_is_section_offset (attr
))
21673 struct dwarf2_loclist_baton loclist_baton
;
21674 CORE_ADDR pc
= (*get_frame_pc
) (baton
);
21677 fill_in_loclist_baton (cu
, &loclist_baton
, attr
);
21679 retval
.data
= dwarf2_find_location_expression (&loclist_baton
,
21681 retval
.size
= size
;
21685 if (!attr_form_is_block (attr
))
21686 error (_("Dwarf Error: DIE at 0x%x referenced in module %s "
21687 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
21688 to_underlying (sect_off
), objfile_name (per_cu
->objfile
));
21690 retval
.data
= DW_BLOCK (attr
)->data
;
21691 retval
.size
= DW_BLOCK (attr
)->size
;
21693 retval
.per_cu
= cu
->per_cu
;
21695 age_cached_comp_units ();
21700 /* Like dwarf2_fetch_die_loc_sect_off, but take a CU
21703 struct dwarf2_locexpr_baton
21704 dwarf2_fetch_die_loc_cu_off (cu_offset offset_in_cu
,
21705 struct dwarf2_per_cu_data
*per_cu
,
21706 CORE_ADDR (*get_frame_pc
) (void *baton
),
21709 sect_offset sect_off
= per_cu
->sect_off
+ to_underlying (offset_in_cu
);
21711 return dwarf2_fetch_die_loc_sect_off (sect_off
, per_cu
, get_frame_pc
, baton
);
21714 /* Write a constant of a given type as target-ordered bytes into
21717 static const gdb_byte
*
21718 write_constant_as_bytes (struct obstack
*obstack
,
21719 enum bfd_endian byte_order
,
21726 *len
= TYPE_LENGTH (type
);
21727 result
= (gdb_byte
*) obstack_alloc (obstack
, *len
);
21728 store_unsigned_integer (result
, *len
, byte_order
, value
);
21733 /* If the DIE at OFFSET in PER_CU has a DW_AT_const_value, return a
21734 pointer to the constant bytes and set LEN to the length of the
21735 data. If memory is needed, allocate it on OBSTACK. If the DIE
21736 does not have a DW_AT_const_value, return NULL. */
21739 dwarf2_fetch_constant_bytes (sect_offset sect_off
,
21740 struct dwarf2_per_cu_data
*per_cu
,
21741 struct obstack
*obstack
,
21744 struct dwarf2_cu
*cu
;
21745 struct die_info
*die
;
21746 struct attribute
*attr
;
21747 const gdb_byte
*result
= NULL
;
21750 enum bfd_endian byte_order
;
21752 dw2_setup (per_cu
->objfile
);
21754 if (per_cu
->cu
== NULL
)
21759 /* We shouldn't get here for a dummy CU, but don't crash on the user.
21760 Instead just throw an error, not much else we can do. */
21761 error (_("Dwarf Error: Dummy CU at 0x%x referenced in module %s"),
21762 to_underlying (sect_off
), objfile_name (per_cu
->objfile
));
21765 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
21767 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
21768 to_underlying (sect_off
), objfile_name (per_cu
->objfile
));
21771 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
21775 byte_order
= (bfd_big_endian (per_cu
->objfile
->obfd
)
21776 ? BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
21778 switch (attr
->form
)
21781 case DW_FORM_GNU_addr_index
:
21785 *len
= cu
->header
.addr_size
;
21786 tem
= (gdb_byte
*) obstack_alloc (obstack
, *len
);
21787 store_unsigned_integer (tem
, *len
, byte_order
, DW_ADDR (attr
));
21791 case DW_FORM_string
:
21793 case DW_FORM_GNU_str_index
:
21794 case DW_FORM_GNU_strp_alt
:
21795 /* DW_STRING is already allocated on the objfile obstack, point
21797 result
= (const gdb_byte
*) DW_STRING (attr
);
21798 *len
= strlen (DW_STRING (attr
));
21800 case DW_FORM_block1
:
21801 case DW_FORM_block2
:
21802 case DW_FORM_block4
:
21803 case DW_FORM_block
:
21804 case DW_FORM_exprloc
:
21805 case DW_FORM_data16
:
21806 result
= DW_BLOCK (attr
)->data
;
21807 *len
= DW_BLOCK (attr
)->size
;
21810 /* The DW_AT_const_value attributes are supposed to carry the
21811 symbol's value "represented as it would be on the target
21812 architecture." By the time we get here, it's already been
21813 converted to host endianness, so we just need to sign- or
21814 zero-extend it as appropriate. */
21815 case DW_FORM_data1
:
21816 type
= die_type (die
, cu
);
21817 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 8);
21818 if (result
== NULL
)
21819 result
= write_constant_as_bytes (obstack
, byte_order
,
21822 case DW_FORM_data2
:
21823 type
= die_type (die
, cu
);
21824 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 16);
21825 if (result
== NULL
)
21826 result
= write_constant_as_bytes (obstack
, byte_order
,
21829 case DW_FORM_data4
:
21830 type
= die_type (die
, cu
);
21831 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 32);
21832 if (result
== NULL
)
21833 result
= write_constant_as_bytes (obstack
, byte_order
,
21836 case DW_FORM_data8
:
21837 type
= die_type (die
, cu
);
21838 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 64);
21839 if (result
== NULL
)
21840 result
= write_constant_as_bytes (obstack
, byte_order
,
21844 case DW_FORM_sdata
:
21845 case DW_FORM_implicit_const
:
21846 type
= die_type (die
, cu
);
21847 result
= write_constant_as_bytes (obstack
, byte_order
,
21848 type
, DW_SND (attr
), len
);
21851 case DW_FORM_udata
:
21852 type
= die_type (die
, cu
);
21853 result
= write_constant_as_bytes (obstack
, byte_order
,
21854 type
, DW_UNSND (attr
), len
);
21858 complaint (&symfile_complaints
,
21859 _("unsupported const value attribute form: '%s'"),
21860 dwarf_form_name (attr
->form
));
21867 /* Return the type of the die at OFFSET in PER_CU. Return NULL if no
21868 valid type for this die is found. */
21871 dwarf2_fetch_die_type_sect_off (sect_offset sect_off
,
21872 struct dwarf2_per_cu_data
*per_cu
)
21874 struct dwarf2_cu
*cu
;
21875 struct die_info
*die
;
21877 dw2_setup (per_cu
->objfile
);
21879 if (per_cu
->cu
== NULL
)
21885 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
21889 return die_type (die
, cu
);
21892 /* Return the type of the DIE at DIE_OFFSET in the CU named by
21896 dwarf2_get_die_type (cu_offset die_offset
,
21897 struct dwarf2_per_cu_data
*per_cu
)
21899 dw2_setup (per_cu
->objfile
);
21901 sect_offset die_offset_sect
= per_cu
->sect_off
+ to_underlying (die_offset
);
21902 return get_die_type_at_offset (die_offset_sect
, per_cu
);
21905 /* Follow type unit SIG_TYPE referenced by SRC_DIE.
21906 On entry *REF_CU is the CU of SRC_DIE.
21907 On exit *REF_CU is the CU of the result.
21908 Returns NULL if the referenced DIE isn't found. */
21910 static struct die_info
*
21911 follow_die_sig_1 (struct die_info
*src_die
, struct signatured_type
*sig_type
,
21912 struct dwarf2_cu
**ref_cu
)
21914 struct die_info temp_die
;
21915 struct dwarf2_cu
*sig_cu
;
21916 struct die_info
*die
;
21918 /* While it might be nice to assert sig_type->type == NULL here,
21919 we can get here for DW_AT_imported_declaration where we need
21920 the DIE not the type. */
21922 /* If necessary, add it to the queue and load its DIEs. */
21924 if (maybe_queue_comp_unit (*ref_cu
, &sig_type
->per_cu
, language_minimal
))
21925 read_signatured_type (sig_type
);
21927 sig_cu
= sig_type
->per_cu
.cu
;
21928 gdb_assert (sig_cu
!= NULL
);
21929 gdb_assert (to_underlying (sig_type
->type_offset_in_section
) != 0);
21930 temp_die
.sect_off
= sig_type
->type_offset_in_section
;
21931 die
= (struct die_info
*) htab_find_with_hash (sig_cu
->die_hash
, &temp_die
,
21932 to_underlying (temp_die
.sect_off
));
21935 /* For .gdb_index version 7 keep track of included TUs.
21936 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
21937 if (dwarf2_per_objfile
->index_table
!= NULL
21938 && dwarf2_per_objfile
->index_table
->version
<= 7)
21940 VEC_safe_push (dwarf2_per_cu_ptr
,
21941 (*ref_cu
)->per_cu
->imported_symtabs
,
21952 /* Follow signatured type referenced by ATTR in SRC_DIE.
21953 On entry *REF_CU is the CU of SRC_DIE.
21954 On exit *REF_CU is the CU of the result.
21955 The result is the DIE of the type.
21956 If the referenced type cannot be found an error is thrown. */
21958 static struct die_info
*
21959 follow_die_sig (struct die_info
*src_die
, const struct attribute
*attr
,
21960 struct dwarf2_cu
**ref_cu
)
21962 ULONGEST signature
= DW_SIGNATURE (attr
);
21963 struct signatured_type
*sig_type
;
21964 struct die_info
*die
;
21966 gdb_assert (attr
->form
== DW_FORM_ref_sig8
);
21968 sig_type
= lookup_signatured_type (*ref_cu
, signature
);
21969 /* sig_type will be NULL if the signatured type is missing from
21971 if (sig_type
== NULL
)
21973 error (_("Dwarf Error: Cannot find signatured DIE %s referenced"
21974 " from DIE at 0x%x [in module %s]"),
21975 hex_string (signature
), to_underlying (src_die
->sect_off
),
21976 objfile_name ((*ref_cu
)->objfile
));
21979 die
= follow_die_sig_1 (src_die
, sig_type
, ref_cu
);
21982 dump_die_for_error (src_die
);
21983 error (_("Dwarf Error: Problem reading signatured DIE %s referenced"
21984 " from DIE at 0x%x [in module %s]"),
21985 hex_string (signature
), to_underlying (src_die
->sect_off
),
21986 objfile_name ((*ref_cu
)->objfile
));
21992 /* Get the type specified by SIGNATURE referenced in DIE/CU,
21993 reading in and processing the type unit if necessary. */
21995 static struct type
*
21996 get_signatured_type (struct die_info
*die
, ULONGEST signature
,
21997 struct dwarf2_cu
*cu
)
21999 struct signatured_type
*sig_type
;
22000 struct dwarf2_cu
*type_cu
;
22001 struct die_info
*type_die
;
22004 sig_type
= lookup_signatured_type (cu
, signature
);
22005 /* sig_type will be NULL if the signatured type is missing from
22007 if (sig_type
== NULL
)
22009 complaint (&symfile_complaints
,
22010 _("Dwarf Error: Cannot find signatured DIE %s referenced"
22011 " from DIE at 0x%x [in module %s]"),
22012 hex_string (signature
), to_underlying (die
->sect_off
),
22013 objfile_name (dwarf2_per_objfile
->objfile
));
22014 return build_error_marker_type (cu
, die
);
22017 /* If we already know the type we're done. */
22018 if (sig_type
->type
!= NULL
)
22019 return sig_type
->type
;
22022 type_die
= follow_die_sig_1 (die
, sig_type
, &type_cu
);
22023 if (type_die
!= NULL
)
22025 /* N.B. We need to call get_die_type to ensure only one type for this DIE
22026 is created. This is important, for example, because for c++ classes
22027 we need TYPE_NAME set which is only done by new_symbol. Blech. */
22028 type
= read_type_die (type_die
, type_cu
);
22031 complaint (&symfile_complaints
,
22032 _("Dwarf Error: Cannot build signatured type %s"
22033 " referenced from DIE at 0x%x [in module %s]"),
22034 hex_string (signature
), to_underlying (die
->sect_off
),
22035 objfile_name (dwarf2_per_objfile
->objfile
));
22036 type
= build_error_marker_type (cu
, die
);
22041 complaint (&symfile_complaints
,
22042 _("Dwarf Error: Problem reading signatured DIE %s referenced"
22043 " from DIE at 0x%x [in module %s]"),
22044 hex_string (signature
), to_underlying (die
->sect_off
),
22045 objfile_name (dwarf2_per_objfile
->objfile
));
22046 type
= build_error_marker_type (cu
, die
);
22048 sig_type
->type
= type
;
22053 /* Get the type specified by the DW_AT_signature ATTR in DIE/CU,
22054 reading in and processing the type unit if necessary. */
22056 static struct type
*
22057 get_DW_AT_signature_type (struct die_info
*die
, const struct attribute
*attr
,
22058 struct dwarf2_cu
*cu
) /* ARI: editCase function */
22060 /* Yes, DW_AT_signature can use a non-ref_sig8 reference. */
22061 if (attr_form_is_ref (attr
))
22063 struct dwarf2_cu
*type_cu
= cu
;
22064 struct die_info
*type_die
= follow_die_ref (die
, attr
, &type_cu
);
22066 return read_type_die (type_die
, type_cu
);
22068 else if (attr
->form
== DW_FORM_ref_sig8
)
22070 return get_signatured_type (die
, DW_SIGNATURE (attr
), cu
);
22074 complaint (&symfile_complaints
,
22075 _("Dwarf Error: DW_AT_signature has bad form %s in DIE"
22076 " at 0x%x [in module %s]"),
22077 dwarf_form_name (attr
->form
), to_underlying (die
->sect_off
),
22078 objfile_name (dwarf2_per_objfile
->objfile
));
22079 return build_error_marker_type (cu
, die
);
22083 /* Load the DIEs associated with type unit PER_CU into memory. */
22086 load_full_type_unit (struct dwarf2_per_cu_data
*per_cu
)
22088 struct signatured_type
*sig_type
;
22090 /* Caller is responsible for ensuring type_unit_groups don't get here. */
22091 gdb_assert (! IS_TYPE_UNIT_GROUP (per_cu
));
22093 /* We have the per_cu, but we need the signatured_type.
22094 Fortunately this is an easy translation. */
22095 gdb_assert (per_cu
->is_debug_types
);
22096 sig_type
= (struct signatured_type
*) per_cu
;
22098 gdb_assert (per_cu
->cu
== NULL
);
22100 read_signatured_type (sig_type
);
22102 gdb_assert (per_cu
->cu
!= NULL
);
22105 /* die_reader_func for read_signatured_type.
22106 This is identical to load_full_comp_unit_reader,
22107 but is kept separate for now. */
22110 read_signatured_type_reader (const struct die_reader_specs
*reader
,
22111 const gdb_byte
*info_ptr
,
22112 struct die_info
*comp_unit_die
,
22116 struct dwarf2_cu
*cu
= reader
->cu
;
22118 gdb_assert (cu
->die_hash
== NULL
);
22120 htab_create_alloc_ex (cu
->header
.length
/ 12,
22124 &cu
->comp_unit_obstack
,
22125 hashtab_obstack_allocate
,
22126 dummy_obstack_deallocate
);
22129 comp_unit_die
->child
= read_die_and_siblings (reader
, info_ptr
,
22130 &info_ptr
, comp_unit_die
);
22131 cu
->dies
= comp_unit_die
;
22132 /* comp_unit_die is not stored in die_hash, no need. */
22134 /* We try not to read any attributes in this function, because not
22135 all CUs needed for references have been loaded yet, and symbol
22136 table processing isn't initialized. But we have to set the CU language,
22137 or we won't be able to build types correctly.
22138 Similarly, if we do not read the producer, we can not apply
22139 producer-specific interpretation. */
22140 prepare_one_comp_unit (cu
, cu
->dies
, language_minimal
);
22143 /* Read in a signatured type and build its CU and DIEs.
22144 If the type is a stub for the real type in a DWO file,
22145 read in the real type from the DWO file as well. */
22148 read_signatured_type (struct signatured_type
*sig_type
)
22150 struct dwarf2_per_cu_data
*per_cu
= &sig_type
->per_cu
;
22152 gdb_assert (per_cu
->is_debug_types
);
22153 gdb_assert (per_cu
->cu
== NULL
);
22155 init_cutu_and_read_dies (per_cu
, NULL
, 0, 1,
22156 read_signatured_type_reader
, NULL
);
22157 sig_type
->per_cu
.tu_read
= 1;
22160 /* Decode simple location descriptions.
22161 Given a pointer to a dwarf block that defines a location, compute
22162 the location and return the value.
22164 NOTE drow/2003-11-18: This function is called in two situations
22165 now: for the address of static or global variables (partial symbols
22166 only) and for offsets into structures which are expected to be
22167 (more or less) constant. The partial symbol case should go away,
22168 and only the constant case should remain. That will let this
22169 function complain more accurately. A few special modes are allowed
22170 without complaint for global variables (for instance, global
22171 register values and thread-local values).
22173 A location description containing no operations indicates that the
22174 object is optimized out. The return value is 0 for that case.
22175 FIXME drow/2003-11-16: No callers check for this case any more; soon all
22176 callers will only want a very basic result and this can become a
22179 Note that stack[0] is unused except as a default error return. */
22182 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
22184 struct objfile
*objfile
= cu
->objfile
;
22186 size_t size
= blk
->size
;
22187 const gdb_byte
*data
= blk
->data
;
22188 CORE_ADDR stack
[64];
22190 unsigned int bytes_read
, unsnd
;
22196 stack
[++stacki
] = 0;
22235 stack
[++stacki
] = op
- DW_OP_lit0
;
22270 stack
[++stacki
] = op
- DW_OP_reg0
;
22272 dwarf2_complex_location_expr_complaint ();
22276 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
22278 stack
[++stacki
] = unsnd
;
22280 dwarf2_complex_location_expr_complaint ();
22284 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
22289 case DW_OP_const1u
:
22290 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
22294 case DW_OP_const1s
:
22295 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
22299 case DW_OP_const2u
:
22300 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
22304 case DW_OP_const2s
:
22305 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
22309 case DW_OP_const4u
:
22310 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
22314 case DW_OP_const4s
:
22315 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
22319 case DW_OP_const8u
:
22320 stack
[++stacki
] = read_8_bytes (objfile
->obfd
, &data
[i
]);
22325 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
22331 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
22336 stack
[stacki
+ 1] = stack
[stacki
];
22341 stack
[stacki
- 1] += stack
[stacki
];
22345 case DW_OP_plus_uconst
:
22346 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
),
22352 stack
[stacki
- 1] -= stack
[stacki
];
22357 /* If we're not the last op, then we definitely can't encode
22358 this using GDB's address_class enum. This is valid for partial
22359 global symbols, although the variable's address will be bogus
22362 dwarf2_complex_location_expr_complaint ();
22365 case DW_OP_GNU_push_tls_address
:
22366 case DW_OP_form_tls_address
:
22367 /* The top of the stack has the offset from the beginning
22368 of the thread control block at which the variable is located. */
22369 /* Nothing should follow this operator, so the top of stack would
22371 /* This is valid for partial global symbols, but the variable's
22372 address will be bogus in the psymtab. Make it always at least
22373 non-zero to not look as a variable garbage collected by linker
22374 which have DW_OP_addr 0. */
22376 dwarf2_complex_location_expr_complaint ();
22380 case DW_OP_GNU_uninit
:
22383 case DW_OP_GNU_addr_index
:
22384 case DW_OP_GNU_const_index
:
22385 stack
[++stacki
] = read_addr_index_from_leb128 (cu
, &data
[i
],
22392 const char *name
= get_DW_OP_name (op
);
22395 complaint (&symfile_complaints
, _("unsupported stack op: '%s'"),
22398 complaint (&symfile_complaints
, _("unsupported stack op: '%02x'"),
22402 return (stack
[stacki
]);
22405 /* Enforce maximum stack depth of SIZE-1 to avoid writing
22406 outside of the allocated space. Also enforce minimum>0. */
22407 if (stacki
>= ARRAY_SIZE (stack
) - 1)
22409 complaint (&symfile_complaints
,
22410 _("location description stack overflow"));
22416 complaint (&symfile_complaints
,
22417 _("location description stack underflow"));
22421 return (stack
[stacki
]);
22424 /* memory allocation interface */
22426 static struct dwarf_block
*
22427 dwarf_alloc_block (struct dwarf2_cu
*cu
)
22429 return XOBNEW (&cu
->comp_unit_obstack
, struct dwarf_block
);
22432 static struct die_info
*
22433 dwarf_alloc_die (struct dwarf2_cu
*cu
, int num_attrs
)
22435 struct die_info
*die
;
22436 size_t size
= sizeof (struct die_info
);
22439 size
+= (num_attrs
- 1) * sizeof (struct attribute
);
22441 die
= (struct die_info
*) obstack_alloc (&cu
->comp_unit_obstack
, size
);
22442 memset (die
, 0, sizeof (struct die_info
));
22447 /* Macro support. */
22449 /* Return file name relative to the compilation directory of file number I in
22450 *LH's file name table. The result is allocated using xmalloc; the caller is
22451 responsible for freeing it. */
22454 file_file_name (int file
, struct line_header
*lh
)
22456 /* Is the file number a valid index into the line header's file name
22457 table? Remember that file numbers start with one, not zero. */
22458 if (1 <= file
&& file
<= lh
->file_names
.size ())
22460 const file_entry
&fe
= lh
->file_names
[file
- 1];
22462 if (!IS_ABSOLUTE_PATH (fe
.name
))
22464 const char *dir
= fe
.include_dir (lh
);
22466 return concat (dir
, SLASH_STRING
, fe
.name
, (char *) NULL
);
22468 return xstrdup (fe
.name
);
22472 /* The compiler produced a bogus file number. We can at least
22473 record the macro definitions made in the file, even if we
22474 won't be able to find the file by name. */
22475 char fake_name
[80];
22477 xsnprintf (fake_name
, sizeof (fake_name
),
22478 "<bad macro file number %d>", file
);
22480 complaint (&symfile_complaints
,
22481 _("bad file number in macro information (%d)"),
22484 return xstrdup (fake_name
);
22488 /* Return the full name of file number I in *LH's file name table.
22489 Use COMP_DIR as the name of the current directory of the
22490 compilation. The result is allocated using xmalloc; the caller is
22491 responsible for freeing it. */
22493 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
22495 /* Is the file number a valid index into the line header's file name
22496 table? Remember that file numbers start with one, not zero. */
22497 if (1 <= file
&& file
<= lh
->file_names
.size ())
22499 char *relative
= file_file_name (file
, lh
);
22501 if (IS_ABSOLUTE_PATH (relative
) || comp_dir
== NULL
)
22503 return reconcat (relative
, comp_dir
, SLASH_STRING
,
22504 relative
, (char *) NULL
);
22507 return file_file_name (file
, lh
);
22511 static struct macro_source_file
*
22512 macro_start_file (int file
, int line
,
22513 struct macro_source_file
*current_file
,
22514 struct line_header
*lh
)
22516 /* File name relative to the compilation directory of this source file. */
22517 char *file_name
= file_file_name (file
, lh
);
22519 if (! current_file
)
22521 /* Note: We don't create a macro table for this compilation unit
22522 at all until we actually get a filename. */
22523 struct macro_table
*macro_table
= get_macro_table ();
22525 /* If we have no current file, then this must be the start_file
22526 directive for the compilation unit's main source file. */
22527 current_file
= macro_set_main (macro_table
, file_name
);
22528 macro_define_special (macro_table
);
22531 current_file
= macro_include (current_file
, line
, file_name
);
22535 return current_file
;
22538 static const char *
22539 consume_improper_spaces (const char *p
, const char *body
)
22543 complaint (&symfile_complaints
,
22544 _("macro definition contains spaces "
22545 "in formal argument list:\n`%s'"),
22557 parse_macro_definition (struct macro_source_file
*file
, int line
,
22562 /* The body string takes one of two forms. For object-like macro
22563 definitions, it should be:
22565 <macro name> " " <definition>
22567 For function-like macro definitions, it should be:
22569 <macro name> "() " <definition>
22571 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
22573 Spaces may appear only where explicitly indicated, and in the
22576 The Dwarf 2 spec says that an object-like macro's name is always
22577 followed by a space, but versions of GCC around March 2002 omit
22578 the space when the macro's definition is the empty string.
22580 The Dwarf 2 spec says that there should be no spaces between the
22581 formal arguments in a function-like macro's formal argument list,
22582 but versions of GCC around March 2002 include spaces after the
22586 /* Find the extent of the macro name. The macro name is terminated
22587 by either a space or null character (for an object-like macro) or
22588 an opening paren (for a function-like macro). */
22589 for (p
= body
; *p
; p
++)
22590 if (*p
== ' ' || *p
== '(')
22593 if (*p
== ' ' || *p
== '\0')
22595 /* It's an object-like macro. */
22596 int name_len
= p
- body
;
22597 char *name
= savestring (body
, name_len
);
22598 const char *replacement
;
22601 replacement
= body
+ name_len
+ 1;
22604 dwarf2_macro_malformed_definition_complaint (body
);
22605 replacement
= body
+ name_len
;
22608 macro_define_object (file
, line
, name
, replacement
);
22612 else if (*p
== '(')
22614 /* It's a function-like macro. */
22615 char *name
= savestring (body
, p
- body
);
22618 char **argv
= XNEWVEC (char *, argv_size
);
22622 p
= consume_improper_spaces (p
, body
);
22624 /* Parse the formal argument list. */
22625 while (*p
&& *p
!= ')')
22627 /* Find the extent of the current argument name. */
22628 const char *arg_start
= p
;
22630 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
22633 if (! *p
|| p
== arg_start
)
22634 dwarf2_macro_malformed_definition_complaint (body
);
22637 /* Make sure argv has room for the new argument. */
22638 if (argc
>= argv_size
)
22641 argv
= XRESIZEVEC (char *, argv
, argv_size
);
22644 argv
[argc
++] = savestring (arg_start
, p
- arg_start
);
22647 p
= consume_improper_spaces (p
, body
);
22649 /* Consume the comma, if present. */
22654 p
= consume_improper_spaces (p
, body
);
22663 /* Perfectly formed definition, no complaints. */
22664 macro_define_function (file
, line
, name
,
22665 argc
, (const char **) argv
,
22667 else if (*p
== '\0')
22669 /* Complain, but do define it. */
22670 dwarf2_macro_malformed_definition_complaint (body
);
22671 macro_define_function (file
, line
, name
,
22672 argc
, (const char **) argv
,
22676 /* Just complain. */
22677 dwarf2_macro_malformed_definition_complaint (body
);
22680 /* Just complain. */
22681 dwarf2_macro_malformed_definition_complaint (body
);
22687 for (i
= 0; i
< argc
; i
++)
22693 dwarf2_macro_malformed_definition_complaint (body
);
22696 /* Skip some bytes from BYTES according to the form given in FORM.
22697 Returns the new pointer. */
22699 static const gdb_byte
*
22700 skip_form_bytes (bfd
*abfd
, const gdb_byte
*bytes
, const gdb_byte
*buffer_end
,
22701 enum dwarf_form form
,
22702 unsigned int offset_size
,
22703 struct dwarf2_section_info
*section
)
22705 unsigned int bytes_read
;
22709 case DW_FORM_data1
:
22714 case DW_FORM_data2
:
22718 case DW_FORM_data4
:
22722 case DW_FORM_data8
:
22726 case DW_FORM_data16
:
22730 case DW_FORM_string
:
22731 read_direct_string (abfd
, bytes
, &bytes_read
);
22732 bytes
+= bytes_read
;
22735 case DW_FORM_sec_offset
:
22737 case DW_FORM_GNU_strp_alt
:
22738 bytes
+= offset_size
;
22741 case DW_FORM_block
:
22742 bytes
+= read_unsigned_leb128 (abfd
, bytes
, &bytes_read
);
22743 bytes
+= bytes_read
;
22746 case DW_FORM_block1
:
22747 bytes
+= 1 + read_1_byte (abfd
, bytes
);
22749 case DW_FORM_block2
:
22750 bytes
+= 2 + read_2_bytes (abfd
, bytes
);
22752 case DW_FORM_block4
:
22753 bytes
+= 4 + read_4_bytes (abfd
, bytes
);
22756 case DW_FORM_sdata
:
22757 case DW_FORM_udata
:
22758 case DW_FORM_GNU_addr_index
:
22759 case DW_FORM_GNU_str_index
:
22760 bytes
= gdb_skip_leb128 (bytes
, buffer_end
);
22763 dwarf2_section_buffer_overflow_complaint (section
);
22768 case DW_FORM_implicit_const
:
22773 complaint (&symfile_complaints
,
22774 _("invalid form 0x%x in `%s'"),
22775 form
, get_section_name (section
));
22783 /* A helper for dwarf_decode_macros that handles skipping an unknown
22784 opcode. Returns an updated pointer to the macro data buffer; or,
22785 on error, issues a complaint and returns NULL. */
22787 static const gdb_byte
*
22788 skip_unknown_opcode (unsigned int opcode
,
22789 const gdb_byte
**opcode_definitions
,
22790 const gdb_byte
*mac_ptr
, const gdb_byte
*mac_end
,
22792 unsigned int offset_size
,
22793 struct dwarf2_section_info
*section
)
22795 unsigned int bytes_read
, i
;
22797 const gdb_byte
*defn
;
22799 if (opcode_definitions
[opcode
] == NULL
)
22801 complaint (&symfile_complaints
,
22802 _("unrecognized DW_MACFINO opcode 0x%x"),
22807 defn
= opcode_definitions
[opcode
];
22808 arg
= read_unsigned_leb128 (abfd
, defn
, &bytes_read
);
22809 defn
+= bytes_read
;
22811 for (i
= 0; i
< arg
; ++i
)
22813 mac_ptr
= skip_form_bytes (abfd
, mac_ptr
, mac_end
,
22814 (enum dwarf_form
) defn
[i
], offset_size
,
22816 if (mac_ptr
== NULL
)
22818 /* skip_form_bytes already issued the complaint. */
22826 /* A helper function which parses the header of a macro section.
22827 If the macro section is the extended (for now called "GNU") type,
22828 then this updates *OFFSET_SIZE. Returns a pointer to just after
22829 the header, or issues a complaint and returns NULL on error. */
22831 static const gdb_byte
*
22832 dwarf_parse_macro_header (const gdb_byte
**opcode_definitions
,
22834 const gdb_byte
*mac_ptr
,
22835 unsigned int *offset_size
,
22836 int section_is_gnu
)
22838 memset (opcode_definitions
, 0, 256 * sizeof (gdb_byte
*));
22840 if (section_is_gnu
)
22842 unsigned int version
, flags
;
22844 version
= read_2_bytes (abfd
, mac_ptr
);
22845 if (version
!= 4 && version
!= 5)
22847 complaint (&symfile_complaints
,
22848 _("unrecognized version `%d' in .debug_macro section"),
22854 flags
= read_1_byte (abfd
, mac_ptr
);
22856 *offset_size
= (flags
& 1) ? 8 : 4;
22858 if ((flags
& 2) != 0)
22859 /* We don't need the line table offset. */
22860 mac_ptr
+= *offset_size
;
22862 /* Vendor opcode descriptions. */
22863 if ((flags
& 4) != 0)
22865 unsigned int i
, count
;
22867 count
= read_1_byte (abfd
, mac_ptr
);
22869 for (i
= 0; i
< count
; ++i
)
22871 unsigned int opcode
, bytes_read
;
22874 opcode
= read_1_byte (abfd
, mac_ptr
);
22876 opcode_definitions
[opcode
] = mac_ptr
;
22877 arg
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
22878 mac_ptr
+= bytes_read
;
22887 /* A helper for dwarf_decode_macros that handles the GNU extensions,
22888 including DW_MACRO_import. */
22891 dwarf_decode_macro_bytes (bfd
*abfd
,
22892 const gdb_byte
*mac_ptr
, const gdb_byte
*mac_end
,
22893 struct macro_source_file
*current_file
,
22894 struct line_header
*lh
,
22895 struct dwarf2_section_info
*section
,
22896 int section_is_gnu
, int section_is_dwz
,
22897 unsigned int offset_size
,
22898 htab_t include_hash
)
22900 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
22901 enum dwarf_macro_record_type macinfo_type
;
22902 int at_commandline
;
22903 const gdb_byte
*opcode_definitions
[256];
22905 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
22906 &offset_size
, section_is_gnu
);
22907 if (mac_ptr
== NULL
)
22909 /* We already issued a complaint. */
22913 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
22914 GDB is still reading the definitions from command line. First
22915 DW_MACINFO_start_file will need to be ignored as it was already executed
22916 to create CURRENT_FILE for the main source holding also the command line
22917 definitions. On first met DW_MACINFO_start_file this flag is reset to
22918 normally execute all the remaining DW_MACINFO_start_file macinfos. */
22920 at_commandline
= 1;
22924 /* Do we at least have room for a macinfo type byte? */
22925 if (mac_ptr
>= mac_end
)
22927 dwarf2_section_buffer_overflow_complaint (section
);
22931 macinfo_type
= (enum dwarf_macro_record_type
) read_1_byte (abfd
, mac_ptr
);
22934 /* Note that we rely on the fact that the corresponding GNU and
22935 DWARF constants are the same. */
22936 switch (macinfo_type
)
22938 /* A zero macinfo type indicates the end of the macro
22943 case DW_MACRO_define
:
22944 case DW_MACRO_undef
:
22945 case DW_MACRO_define_strp
:
22946 case DW_MACRO_undef_strp
:
22947 case DW_MACRO_define_sup
:
22948 case DW_MACRO_undef_sup
:
22950 unsigned int bytes_read
;
22955 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
22956 mac_ptr
+= bytes_read
;
22958 if (macinfo_type
== DW_MACRO_define
22959 || macinfo_type
== DW_MACRO_undef
)
22961 body
= read_direct_string (abfd
, mac_ptr
, &bytes_read
);
22962 mac_ptr
+= bytes_read
;
22966 LONGEST str_offset
;
22968 str_offset
= read_offset_1 (abfd
, mac_ptr
, offset_size
);
22969 mac_ptr
+= offset_size
;
22971 if (macinfo_type
== DW_MACRO_define_sup
22972 || macinfo_type
== DW_MACRO_undef_sup
22975 struct dwz_file
*dwz
= dwarf2_get_dwz_file ();
22977 body
= read_indirect_string_from_dwz (dwz
, str_offset
);
22980 body
= read_indirect_string_at_offset (abfd
, str_offset
);
22983 is_define
= (macinfo_type
== DW_MACRO_define
22984 || macinfo_type
== DW_MACRO_define_strp
22985 || macinfo_type
== DW_MACRO_define_sup
);
22986 if (! current_file
)
22988 /* DWARF violation as no main source is present. */
22989 complaint (&symfile_complaints
,
22990 _("debug info with no main source gives macro %s "
22992 is_define
? _("definition") : _("undefinition"),
22996 if ((line
== 0 && !at_commandline
)
22997 || (line
!= 0 && at_commandline
))
22998 complaint (&symfile_complaints
,
22999 _("debug info gives %s macro %s with %s line %d: %s"),
23000 at_commandline
? _("command-line") : _("in-file"),
23001 is_define
? _("definition") : _("undefinition"),
23002 line
== 0 ? _("zero") : _("non-zero"), line
, body
);
23005 parse_macro_definition (current_file
, line
, body
);
23008 gdb_assert (macinfo_type
== DW_MACRO_undef
23009 || macinfo_type
== DW_MACRO_undef_strp
23010 || macinfo_type
== DW_MACRO_undef_sup
);
23011 macro_undef (current_file
, line
, body
);
23016 case DW_MACRO_start_file
:
23018 unsigned int bytes_read
;
23021 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
23022 mac_ptr
+= bytes_read
;
23023 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
23024 mac_ptr
+= bytes_read
;
23026 if ((line
== 0 && !at_commandline
)
23027 || (line
!= 0 && at_commandline
))
23028 complaint (&symfile_complaints
,
23029 _("debug info gives source %d included "
23030 "from %s at %s line %d"),
23031 file
, at_commandline
? _("command-line") : _("file"),
23032 line
== 0 ? _("zero") : _("non-zero"), line
);
23034 if (at_commandline
)
23036 /* This DW_MACRO_start_file was executed in the
23038 at_commandline
= 0;
23041 current_file
= macro_start_file (file
, line
, current_file
, lh
);
23045 case DW_MACRO_end_file
:
23046 if (! current_file
)
23047 complaint (&symfile_complaints
,
23048 _("macro debug info has an unmatched "
23049 "`close_file' directive"));
23052 current_file
= current_file
->included_by
;
23053 if (! current_file
)
23055 enum dwarf_macro_record_type next_type
;
23057 /* GCC circa March 2002 doesn't produce the zero
23058 type byte marking the end of the compilation
23059 unit. Complain if it's not there, but exit no
23062 /* Do we at least have room for a macinfo type byte? */
23063 if (mac_ptr
>= mac_end
)
23065 dwarf2_section_buffer_overflow_complaint (section
);
23069 /* We don't increment mac_ptr here, so this is just
23072 = (enum dwarf_macro_record_type
) read_1_byte (abfd
,
23074 if (next_type
!= 0)
23075 complaint (&symfile_complaints
,
23076 _("no terminating 0-type entry for "
23077 "macros in `.debug_macinfo' section"));
23084 case DW_MACRO_import
:
23085 case DW_MACRO_import_sup
:
23089 bfd
*include_bfd
= abfd
;
23090 struct dwarf2_section_info
*include_section
= section
;
23091 const gdb_byte
*include_mac_end
= mac_end
;
23092 int is_dwz
= section_is_dwz
;
23093 const gdb_byte
*new_mac_ptr
;
23095 offset
= read_offset_1 (abfd
, mac_ptr
, offset_size
);
23096 mac_ptr
+= offset_size
;
23098 if (macinfo_type
== DW_MACRO_import_sup
)
23100 struct dwz_file
*dwz
= dwarf2_get_dwz_file ();
23102 dwarf2_read_section (objfile
, &dwz
->macro
);
23104 include_section
= &dwz
->macro
;
23105 include_bfd
= get_section_bfd_owner (include_section
);
23106 include_mac_end
= dwz
->macro
.buffer
+ dwz
->macro
.size
;
23110 new_mac_ptr
= include_section
->buffer
+ offset
;
23111 slot
= htab_find_slot (include_hash
, new_mac_ptr
, INSERT
);
23115 /* This has actually happened; see
23116 http://sourceware.org/bugzilla/show_bug.cgi?id=13568. */
23117 complaint (&symfile_complaints
,
23118 _("recursive DW_MACRO_import in "
23119 ".debug_macro section"));
23123 *slot
= (void *) new_mac_ptr
;
23125 dwarf_decode_macro_bytes (include_bfd
, new_mac_ptr
,
23126 include_mac_end
, current_file
, lh
,
23127 section
, section_is_gnu
, is_dwz
,
23128 offset_size
, include_hash
);
23130 htab_remove_elt (include_hash
, (void *) new_mac_ptr
);
23135 case DW_MACINFO_vendor_ext
:
23136 if (!section_is_gnu
)
23138 unsigned int bytes_read
;
23140 /* This reads the constant, but since we don't recognize
23141 any vendor extensions, we ignore it. */
23142 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
23143 mac_ptr
+= bytes_read
;
23144 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
23145 mac_ptr
+= bytes_read
;
23147 /* We don't recognize any vendor extensions. */
23153 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
23154 mac_ptr
, mac_end
, abfd
, offset_size
,
23156 if (mac_ptr
== NULL
)
23160 } while (macinfo_type
!= 0);
23164 dwarf_decode_macros (struct dwarf2_cu
*cu
, unsigned int offset
,
23165 int section_is_gnu
)
23167 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
23168 struct line_header
*lh
= cu
->line_header
;
23170 const gdb_byte
*mac_ptr
, *mac_end
;
23171 struct macro_source_file
*current_file
= 0;
23172 enum dwarf_macro_record_type macinfo_type
;
23173 unsigned int offset_size
= cu
->header
.offset_size
;
23174 const gdb_byte
*opcode_definitions
[256];
23176 struct dwarf2_section_info
*section
;
23177 const char *section_name
;
23179 if (cu
->dwo_unit
!= NULL
)
23181 if (section_is_gnu
)
23183 section
= &cu
->dwo_unit
->dwo_file
->sections
.macro
;
23184 section_name
= ".debug_macro.dwo";
23188 section
= &cu
->dwo_unit
->dwo_file
->sections
.macinfo
;
23189 section_name
= ".debug_macinfo.dwo";
23194 if (section_is_gnu
)
23196 section
= &dwarf2_per_objfile
->macro
;
23197 section_name
= ".debug_macro";
23201 section
= &dwarf2_per_objfile
->macinfo
;
23202 section_name
= ".debug_macinfo";
23206 dwarf2_read_section (objfile
, section
);
23207 if (section
->buffer
== NULL
)
23209 complaint (&symfile_complaints
, _("missing %s section"), section_name
);
23212 abfd
= get_section_bfd_owner (section
);
23214 /* First pass: Find the name of the base filename.
23215 This filename is needed in order to process all macros whose definition
23216 (or undefinition) comes from the command line. These macros are defined
23217 before the first DW_MACINFO_start_file entry, and yet still need to be
23218 associated to the base file.
23220 To determine the base file name, we scan the macro definitions until we
23221 reach the first DW_MACINFO_start_file entry. We then initialize
23222 CURRENT_FILE accordingly so that any macro definition found before the
23223 first DW_MACINFO_start_file can still be associated to the base file. */
23225 mac_ptr
= section
->buffer
+ offset
;
23226 mac_end
= section
->buffer
+ section
->size
;
23228 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
23229 &offset_size
, section_is_gnu
);
23230 if (mac_ptr
== NULL
)
23232 /* We already issued a complaint. */
23238 /* Do we at least have room for a macinfo type byte? */
23239 if (mac_ptr
>= mac_end
)
23241 /* Complaint is printed during the second pass as GDB will probably
23242 stop the first pass earlier upon finding
23243 DW_MACINFO_start_file. */
23247 macinfo_type
= (enum dwarf_macro_record_type
) read_1_byte (abfd
, mac_ptr
);
23250 /* Note that we rely on the fact that the corresponding GNU and
23251 DWARF constants are the same. */
23252 switch (macinfo_type
)
23254 /* A zero macinfo type indicates the end of the macro
23259 case DW_MACRO_define
:
23260 case DW_MACRO_undef
:
23261 /* Only skip the data by MAC_PTR. */
23263 unsigned int bytes_read
;
23265 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
23266 mac_ptr
+= bytes_read
;
23267 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
23268 mac_ptr
+= bytes_read
;
23272 case DW_MACRO_start_file
:
23274 unsigned int bytes_read
;
23277 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
23278 mac_ptr
+= bytes_read
;
23279 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
23280 mac_ptr
+= bytes_read
;
23282 current_file
= macro_start_file (file
, line
, current_file
, lh
);
23286 case DW_MACRO_end_file
:
23287 /* No data to skip by MAC_PTR. */
23290 case DW_MACRO_define_strp
:
23291 case DW_MACRO_undef_strp
:
23292 case DW_MACRO_define_sup
:
23293 case DW_MACRO_undef_sup
:
23295 unsigned int bytes_read
;
23297 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
23298 mac_ptr
+= bytes_read
;
23299 mac_ptr
+= offset_size
;
23303 case DW_MACRO_import
:
23304 case DW_MACRO_import_sup
:
23305 /* Note that, according to the spec, a transparent include
23306 chain cannot call DW_MACRO_start_file. So, we can just
23307 skip this opcode. */
23308 mac_ptr
+= offset_size
;
23311 case DW_MACINFO_vendor_ext
:
23312 /* Only skip the data by MAC_PTR. */
23313 if (!section_is_gnu
)
23315 unsigned int bytes_read
;
23317 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
23318 mac_ptr
+= bytes_read
;
23319 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
23320 mac_ptr
+= bytes_read
;
23325 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
23326 mac_ptr
, mac_end
, abfd
, offset_size
,
23328 if (mac_ptr
== NULL
)
23332 } while (macinfo_type
!= 0 && current_file
== NULL
);
23334 /* Second pass: Process all entries.
23336 Use the AT_COMMAND_LINE flag to determine whether we are still processing
23337 command-line macro definitions/undefinitions. This flag is unset when we
23338 reach the first DW_MACINFO_start_file entry. */
23340 htab_up
include_hash (htab_create_alloc (1, htab_hash_pointer
,
23342 NULL
, xcalloc
, xfree
));
23343 mac_ptr
= section
->buffer
+ offset
;
23344 slot
= htab_find_slot (include_hash
.get (), mac_ptr
, INSERT
);
23345 *slot
= (void *) mac_ptr
;
23346 dwarf_decode_macro_bytes (abfd
, mac_ptr
, mac_end
,
23347 current_file
, lh
, section
,
23348 section_is_gnu
, 0, offset_size
,
23349 include_hash
.get ());
23352 /* Check if the attribute's form is a DW_FORM_block*
23353 if so return true else false. */
23356 attr_form_is_block (const struct attribute
*attr
)
23358 return (attr
== NULL
? 0 :
23359 attr
->form
== DW_FORM_block1
23360 || attr
->form
== DW_FORM_block2
23361 || attr
->form
== DW_FORM_block4
23362 || attr
->form
== DW_FORM_block
23363 || attr
->form
== DW_FORM_exprloc
);
23366 /* Return non-zero if ATTR's value is a section offset --- classes
23367 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
23368 You may use DW_UNSND (attr) to retrieve such offsets.
23370 Section 7.5.4, "Attribute Encodings", explains that no attribute
23371 may have a value that belongs to more than one of these classes; it
23372 would be ambiguous if we did, because we use the same forms for all
23376 attr_form_is_section_offset (const struct attribute
*attr
)
23378 return (attr
->form
== DW_FORM_data4
23379 || attr
->form
== DW_FORM_data8
23380 || attr
->form
== DW_FORM_sec_offset
);
23383 /* Return non-zero if ATTR's value falls in the 'constant' class, or
23384 zero otherwise. When this function returns true, you can apply
23385 dwarf2_get_attr_constant_value to it.
23387 However, note that for some attributes you must check
23388 attr_form_is_section_offset before using this test. DW_FORM_data4
23389 and DW_FORM_data8 are members of both the constant class, and of
23390 the classes that contain offsets into other debug sections
23391 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
23392 that, if an attribute's can be either a constant or one of the
23393 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
23394 taken as section offsets, not constants.
23396 DW_FORM_data16 is not considered as dwarf2_get_attr_constant_value
23397 cannot handle that. */
23400 attr_form_is_constant (const struct attribute
*attr
)
23402 switch (attr
->form
)
23404 case DW_FORM_sdata
:
23405 case DW_FORM_udata
:
23406 case DW_FORM_data1
:
23407 case DW_FORM_data2
:
23408 case DW_FORM_data4
:
23409 case DW_FORM_data8
:
23410 case DW_FORM_implicit_const
:
23418 /* DW_ADDR is always stored already as sect_offset; despite for the forms
23419 besides DW_FORM_ref_addr it is stored as cu_offset in the DWARF file. */
23422 attr_form_is_ref (const struct attribute
*attr
)
23424 switch (attr
->form
)
23426 case DW_FORM_ref_addr
:
23431 case DW_FORM_ref_udata
:
23432 case DW_FORM_GNU_ref_alt
:
23439 /* Return the .debug_loc section to use for CU.
23440 For DWO files use .debug_loc.dwo. */
23442 static struct dwarf2_section_info
*
23443 cu_debug_loc_section (struct dwarf2_cu
*cu
)
23447 struct dwo_sections
*sections
= &cu
->dwo_unit
->dwo_file
->sections
;
23449 return cu
->header
.version
>= 5 ? §ions
->loclists
: §ions
->loc
;
23451 return (cu
->header
.version
>= 5 ? &dwarf2_per_objfile
->loclists
23452 : &dwarf2_per_objfile
->loc
);
23455 /* A helper function that fills in a dwarf2_loclist_baton. */
23458 fill_in_loclist_baton (struct dwarf2_cu
*cu
,
23459 struct dwarf2_loclist_baton
*baton
,
23460 const struct attribute
*attr
)
23462 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
23464 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
23466 baton
->per_cu
= cu
->per_cu
;
23467 gdb_assert (baton
->per_cu
);
23468 /* We don't know how long the location list is, but make sure we
23469 don't run off the edge of the section. */
23470 baton
->size
= section
->size
- DW_UNSND (attr
);
23471 baton
->data
= section
->buffer
+ DW_UNSND (attr
);
23472 baton
->base_address
= cu
->base_address
;
23473 baton
->from_dwo
= cu
->dwo_unit
!= NULL
;
23477 dwarf2_symbol_mark_computed (const struct attribute
*attr
, struct symbol
*sym
,
23478 struct dwarf2_cu
*cu
, int is_block
)
23480 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
23481 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
23483 if (attr_form_is_section_offset (attr
)
23484 /* .debug_loc{,.dwo} may not exist at all, or the offset may be outside
23485 the section. If so, fall through to the complaint in the
23487 && DW_UNSND (attr
) < dwarf2_section_size (objfile
, section
))
23489 struct dwarf2_loclist_baton
*baton
;
23491 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_loclist_baton
);
23493 fill_in_loclist_baton (cu
, baton
, attr
);
23495 if (cu
->base_known
== 0)
23496 complaint (&symfile_complaints
,
23497 _("Location list used without "
23498 "specifying the CU base address."));
23500 SYMBOL_ACLASS_INDEX (sym
) = (is_block
23501 ? dwarf2_loclist_block_index
23502 : dwarf2_loclist_index
);
23503 SYMBOL_LOCATION_BATON (sym
) = baton
;
23507 struct dwarf2_locexpr_baton
*baton
;
23509 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
23510 baton
->per_cu
= cu
->per_cu
;
23511 gdb_assert (baton
->per_cu
);
23513 if (attr_form_is_block (attr
))
23515 /* Note that we're just copying the block's data pointer
23516 here, not the actual data. We're still pointing into the
23517 info_buffer for SYM's objfile; right now we never release
23518 that buffer, but when we do clean up properly this may
23520 baton
->size
= DW_BLOCK (attr
)->size
;
23521 baton
->data
= DW_BLOCK (attr
)->data
;
23525 dwarf2_invalid_attrib_class_complaint ("location description",
23526 SYMBOL_NATURAL_NAME (sym
));
23530 SYMBOL_ACLASS_INDEX (sym
) = (is_block
23531 ? dwarf2_locexpr_block_index
23532 : dwarf2_locexpr_index
);
23533 SYMBOL_LOCATION_BATON (sym
) = baton
;
23537 /* Return the OBJFILE associated with the compilation unit CU. If CU
23538 came from a separate debuginfo file, then the master objfile is
23542 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data
*per_cu
)
23544 struct objfile
*objfile
= per_cu
->objfile
;
23546 /* Return the master objfile, so that we can report and look up the
23547 correct file containing this variable. */
23548 if (objfile
->separate_debug_objfile_backlink
)
23549 objfile
= objfile
->separate_debug_objfile_backlink
;
23554 /* Return comp_unit_head for PER_CU, either already available in PER_CU->CU
23555 (CU_HEADERP is unused in such case) or prepare a temporary copy at
23556 CU_HEADERP first. */
23558 static const struct comp_unit_head
*
23559 per_cu_header_read_in (struct comp_unit_head
*cu_headerp
,
23560 struct dwarf2_per_cu_data
*per_cu
)
23562 const gdb_byte
*info_ptr
;
23565 return &per_cu
->cu
->header
;
23567 info_ptr
= per_cu
->section
->buffer
+ to_underlying (per_cu
->sect_off
);
23569 memset (cu_headerp
, 0, sizeof (*cu_headerp
));
23570 read_comp_unit_head (cu_headerp
, info_ptr
, per_cu
->section
,
23571 rcuh_kind::COMPILE
);
23576 /* Return the address size given in the compilation unit header for CU. */
23579 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data
*per_cu
)
23581 struct comp_unit_head cu_header_local
;
23582 const struct comp_unit_head
*cu_headerp
;
23584 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
23586 return cu_headerp
->addr_size
;
23589 /* Return the offset size given in the compilation unit header for CU. */
23592 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data
*per_cu
)
23594 struct comp_unit_head cu_header_local
;
23595 const struct comp_unit_head
*cu_headerp
;
23597 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
23599 return cu_headerp
->offset_size
;
23602 /* See its dwarf2loc.h declaration. */
23605 dwarf2_per_cu_ref_addr_size (struct dwarf2_per_cu_data
*per_cu
)
23607 struct comp_unit_head cu_header_local
;
23608 const struct comp_unit_head
*cu_headerp
;
23610 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
23612 if (cu_headerp
->version
== 2)
23613 return cu_headerp
->addr_size
;
23615 return cu_headerp
->offset_size
;
23618 /* Return the text offset of the CU. The returned offset comes from
23619 this CU's objfile. If this objfile came from a separate debuginfo
23620 file, then the offset may be different from the corresponding
23621 offset in the parent objfile. */
23624 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data
*per_cu
)
23626 struct objfile
*objfile
= per_cu
->objfile
;
23628 return ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
23631 /* Return DWARF version number of PER_CU. */
23634 dwarf2_version (struct dwarf2_per_cu_data
*per_cu
)
23636 return per_cu
->dwarf_version
;
23639 /* Locate the .debug_info compilation unit from CU's objfile which contains
23640 the DIE at OFFSET. Raises an error on failure. */
23642 static struct dwarf2_per_cu_data
*
23643 dwarf2_find_containing_comp_unit (sect_offset sect_off
,
23644 unsigned int offset_in_dwz
,
23645 struct objfile
*objfile
)
23647 struct dwarf2_per_cu_data
*this_cu
;
23649 const sect_offset
*cu_off
;
23652 high
= dwarf2_per_objfile
->n_comp_units
- 1;
23655 struct dwarf2_per_cu_data
*mid_cu
;
23656 int mid
= low
+ (high
- low
) / 2;
23658 mid_cu
= dwarf2_per_objfile
->all_comp_units
[mid
];
23659 cu_off
= &mid_cu
->sect_off
;
23660 if (mid_cu
->is_dwz
> offset_in_dwz
23661 || (mid_cu
->is_dwz
== offset_in_dwz
&& *cu_off
>= sect_off
))
23666 gdb_assert (low
== high
);
23667 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
23668 cu_off
= &this_cu
->sect_off
;
23669 if (this_cu
->is_dwz
!= offset_in_dwz
|| *cu_off
> sect_off
)
23671 if (low
== 0 || this_cu
->is_dwz
!= offset_in_dwz
)
23672 error (_("Dwarf Error: could not find partial DIE containing "
23673 "offset 0x%x [in module %s]"),
23674 to_underlying (sect_off
), bfd_get_filename (objfile
->obfd
));
23676 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->sect_off
23678 return dwarf2_per_objfile
->all_comp_units
[low
-1];
23682 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
23683 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
23684 && sect_off
>= this_cu
->sect_off
+ this_cu
->length
)
23685 error (_("invalid dwarf2 offset %u"), to_underlying (sect_off
));
23686 gdb_assert (sect_off
< this_cu
->sect_off
+ this_cu
->length
);
23691 /* Initialize dwarf2_cu CU, owned by PER_CU. */
23694 init_one_comp_unit (struct dwarf2_cu
*cu
, struct dwarf2_per_cu_data
*per_cu
)
23696 memset (cu
, 0, sizeof (*cu
));
23698 cu
->per_cu
= per_cu
;
23699 cu
->objfile
= per_cu
->objfile
;
23700 obstack_init (&cu
->comp_unit_obstack
);
23703 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
23706 prepare_one_comp_unit (struct dwarf2_cu
*cu
, struct die_info
*comp_unit_die
,
23707 enum language pretend_language
)
23709 struct attribute
*attr
;
23711 /* Set the language we're debugging. */
23712 attr
= dwarf2_attr (comp_unit_die
, DW_AT_language
, cu
);
23714 set_cu_language (DW_UNSND (attr
), cu
);
23717 cu
->language
= pretend_language
;
23718 cu
->language_defn
= language_def (cu
->language
);
23721 cu
->producer
= dwarf2_string_attr (comp_unit_die
, DW_AT_producer
, cu
);
23724 /* Release one cached compilation unit, CU. We unlink it from the tree
23725 of compilation units, but we don't remove it from the read_in_chain;
23726 the caller is responsible for that.
23727 NOTE: DATA is a void * because this function is also used as a
23728 cleanup routine. */
23731 free_heap_comp_unit (void *data
)
23733 struct dwarf2_cu
*cu
= (struct dwarf2_cu
*) data
;
23735 gdb_assert (cu
->per_cu
!= NULL
);
23736 cu
->per_cu
->cu
= NULL
;
23739 obstack_free (&cu
->comp_unit_obstack
, NULL
);
23744 /* This cleanup function is passed the address of a dwarf2_cu on the stack
23745 when we're finished with it. We can't free the pointer itself, but be
23746 sure to unlink it from the cache. Also release any associated storage. */
23749 free_stack_comp_unit (void *data
)
23751 struct dwarf2_cu
*cu
= (struct dwarf2_cu
*) data
;
23753 gdb_assert (cu
->per_cu
!= NULL
);
23754 cu
->per_cu
->cu
= NULL
;
23757 obstack_free (&cu
->comp_unit_obstack
, NULL
);
23758 cu
->partial_dies
= NULL
;
23761 /* Free all cached compilation units. */
23764 free_cached_comp_units (void *data
)
23766 dwarf2_per_objfile
->free_cached_comp_units ();
23769 /* Increase the age counter on each cached compilation unit, and free
23770 any that are too old. */
23773 age_cached_comp_units (void)
23775 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
23777 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
23778 per_cu
= dwarf2_per_objfile
->read_in_chain
;
23779 while (per_cu
!= NULL
)
23781 per_cu
->cu
->last_used
++;
23782 if (per_cu
->cu
->last_used
<= dwarf_max_cache_age
)
23783 dwarf2_mark (per_cu
->cu
);
23784 per_cu
= per_cu
->cu
->read_in_chain
;
23787 per_cu
= dwarf2_per_objfile
->read_in_chain
;
23788 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
23789 while (per_cu
!= NULL
)
23791 struct dwarf2_per_cu_data
*next_cu
;
23793 next_cu
= per_cu
->cu
->read_in_chain
;
23795 if (!per_cu
->cu
->mark
)
23797 free_heap_comp_unit (per_cu
->cu
);
23798 *last_chain
= next_cu
;
23801 last_chain
= &per_cu
->cu
->read_in_chain
;
23807 /* Remove a single compilation unit from the cache. */
23810 free_one_cached_comp_unit (struct dwarf2_per_cu_data
*target_per_cu
)
23812 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
23814 per_cu
= dwarf2_per_objfile
->read_in_chain
;
23815 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
23816 while (per_cu
!= NULL
)
23818 struct dwarf2_per_cu_data
*next_cu
;
23820 next_cu
= per_cu
->cu
->read_in_chain
;
23822 if (per_cu
== target_per_cu
)
23824 free_heap_comp_unit (per_cu
->cu
);
23826 *last_chain
= next_cu
;
23830 last_chain
= &per_cu
->cu
->read_in_chain
;
23836 /* Release all extra memory associated with OBJFILE. */
23839 dwarf2_free_objfile (struct objfile
*objfile
)
23842 = (struct dwarf2_per_objfile
*) objfile_data (objfile
,
23843 dwarf2_objfile_data_key
);
23845 if (dwarf2_per_objfile
== NULL
)
23848 dwarf2_per_objfile
->~dwarf2_per_objfile ();
23851 /* A set of CU "per_cu" pointer, DIE offset, and GDB type pointer.
23852 We store these in a hash table separate from the DIEs, and preserve them
23853 when the DIEs are flushed out of cache.
23855 The CU "per_cu" pointer is needed because offset alone is not enough to
23856 uniquely identify the type. A file may have multiple .debug_types sections,
23857 or the type may come from a DWO file. Furthermore, while it's more logical
23858 to use per_cu->section+offset, with Fission the section with the data is in
23859 the DWO file but we don't know that section at the point we need it.
23860 We have to use something in dwarf2_per_cu_data (or the pointer to it)
23861 because we can enter the lookup routine, get_die_type_at_offset, from
23862 outside this file, and thus won't necessarily have PER_CU->cu.
23863 Fortunately, PER_CU is stable for the life of the objfile. */
23865 struct dwarf2_per_cu_offset_and_type
23867 const struct dwarf2_per_cu_data
*per_cu
;
23868 sect_offset sect_off
;
23872 /* Hash function for a dwarf2_per_cu_offset_and_type. */
23875 per_cu_offset_and_type_hash (const void *item
)
23877 const struct dwarf2_per_cu_offset_and_type
*ofs
23878 = (const struct dwarf2_per_cu_offset_and_type
*) item
;
23880 return (uintptr_t) ofs
->per_cu
+ to_underlying (ofs
->sect_off
);
23883 /* Equality function for a dwarf2_per_cu_offset_and_type. */
23886 per_cu_offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
23888 const struct dwarf2_per_cu_offset_and_type
*ofs_lhs
23889 = (const struct dwarf2_per_cu_offset_and_type
*) item_lhs
;
23890 const struct dwarf2_per_cu_offset_and_type
*ofs_rhs
23891 = (const struct dwarf2_per_cu_offset_and_type
*) item_rhs
;
23893 return (ofs_lhs
->per_cu
== ofs_rhs
->per_cu
23894 && ofs_lhs
->sect_off
== ofs_rhs
->sect_off
);
23897 /* Set the type associated with DIE to TYPE. Save it in CU's hash
23898 table if necessary. For convenience, return TYPE.
23900 The DIEs reading must have careful ordering to:
23901 * Not cause infite loops trying to read in DIEs as a prerequisite for
23902 reading current DIE.
23903 * Not trying to dereference contents of still incompletely read in types
23904 while reading in other DIEs.
23905 * Enable referencing still incompletely read in types just by a pointer to
23906 the type without accessing its fields.
23908 Therefore caller should follow these rules:
23909 * Try to fetch any prerequisite types we may need to build this DIE type
23910 before building the type and calling set_die_type.
23911 * After building type call set_die_type for current DIE as soon as
23912 possible before fetching more types to complete the current type.
23913 * Make the type as complete as possible before fetching more types. */
23915 static struct type
*
23916 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
23918 struct dwarf2_per_cu_offset_and_type
**slot
, ofs
;
23919 struct objfile
*objfile
= cu
->objfile
;
23920 struct attribute
*attr
;
23921 struct dynamic_prop prop
;
23923 /* For Ada types, make sure that the gnat-specific data is always
23924 initialized (if not already set). There are a few types where
23925 we should not be doing so, because the type-specific area is
23926 already used to hold some other piece of info (eg: TYPE_CODE_FLT
23927 where the type-specific area is used to store the floatformat).
23928 But this is not a problem, because the gnat-specific information
23929 is actually not needed for these types. */
23930 if (need_gnat_info (cu
)
23931 && TYPE_CODE (type
) != TYPE_CODE_FUNC
23932 && TYPE_CODE (type
) != TYPE_CODE_FLT
23933 && TYPE_CODE (type
) != TYPE_CODE_METHODPTR
23934 && TYPE_CODE (type
) != TYPE_CODE_MEMBERPTR
23935 && TYPE_CODE (type
) != TYPE_CODE_METHOD
23936 && !HAVE_GNAT_AUX_INFO (type
))
23937 INIT_GNAT_SPECIFIC (type
);
23939 /* Read DW_AT_allocated and set in type. */
23940 attr
= dwarf2_attr (die
, DW_AT_allocated
, cu
);
23941 if (attr_form_is_block (attr
))
23943 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
))
23944 add_dyn_prop (DYN_PROP_ALLOCATED
, prop
, type
, objfile
);
23946 else if (attr
!= NULL
)
23948 complaint (&symfile_complaints
,
23949 _("DW_AT_allocated has the wrong form (%s) at DIE 0x%x"),
23950 (attr
!= NULL
? dwarf_form_name (attr
->form
) : "n/a"),
23951 to_underlying (die
->sect_off
));
23954 /* Read DW_AT_associated and set in type. */
23955 attr
= dwarf2_attr (die
, DW_AT_associated
, cu
);
23956 if (attr_form_is_block (attr
))
23958 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
))
23959 add_dyn_prop (DYN_PROP_ASSOCIATED
, prop
, type
, objfile
);
23961 else if (attr
!= NULL
)
23963 complaint (&symfile_complaints
,
23964 _("DW_AT_associated has the wrong form (%s) at DIE 0x%x"),
23965 (attr
!= NULL
? dwarf_form_name (attr
->form
) : "n/a"),
23966 to_underlying (die
->sect_off
));
23969 /* Read DW_AT_data_location and set in type. */
23970 attr
= dwarf2_attr (die
, DW_AT_data_location
, cu
);
23971 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
))
23972 add_dyn_prop (DYN_PROP_DATA_LOCATION
, prop
, type
, objfile
);
23974 if (dwarf2_per_objfile
->die_type_hash
== NULL
)
23976 dwarf2_per_objfile
->die_type_hash
=
23977 htab_create_alloc_ex (127,
23978 per_cu_offset_and_type_hash
,
23979 per_cu_offset_and_type_eq
,
23981 &objfile
->objfile_obstack
,
23982 hashtab_obstack_allocate
,
23983 dummy_obstack_deallocate
);
23986 ofs
.per_cu
= cu
->per_cu
;
23987 ofs
.sect_off
= die
->sect_off
;
23989 slot
= (struct dwarf2_per_cu_offset_and_type
**)
23990 htab_find_slot (dwarf2_per_objfile
->die_type_hash
, &ofs
, INSERT
);
23992 complaint (&symfile_complaints
,
23993 _("A problem internal to GDB: DIE 0x%x has type already set"),
23994 to_underlying (die
->sect_off
));
23995 *slot
= XOBNEW (&objfile
->objfile_obstack
,
23996 struct dwarf2_per_cu_offset_and_type
);
24001 /* Look up the type for the die at SECT_OFF in PER_CU in die_type_hash,
24002 or return NULL if the die does not have a saved type. */
24004 static struct type
*
24005 get_die_type_at_offset (sect_offset sect_off
,
24006 struct dwarf2_per_cu_data
*per_cu
)
24008 struct dwarf2_per_cu_offset_and_type
*slot
, ofs
;
24010 if (dwarf2_per_objfile
->die_type_hash
== NULL
)
24013 ofs
.per_cu
= per_cu
;
24014 ofs
.sect_off
= sect_off
;
24015 slot
= ((struct dwarf2_per_cu_offset_and_type
*)
24016 htab_find (dwarf2_per_objfile
->die_type_hash
, &ofs
));
24023 /* Look up the type for DIE in CU in die_type_hash,
24024 or return NULL if DIE does not have a saved type. */
24026 static struct type
*
24027 get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
24029 return get_die_type_at_offset (die
->sect_off
, cu
->per_cu
);
24032 /* Add a dependence relationship from CU to REF_PER_CU. */
24035 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
24036 struct dwarf2_per_cu_data
*ref_per_cu
)
24040 if (cu
->dependencies
== NULL
)
24042 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
24043 NULL
, &cu
->comp_unit_obstack
,
24044 hashtab_obstack_allocate
,
24045 dummy_obstack_deallocate
);
24047 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
24049 *slot
= ref_per_cu
;
24052 /* Subroutine of dwarf2_mark to pass to htab_traverse.
24053 Set the mark field in every compilation unit in the
24054 cache that we must keep because we are keeping CU. */
24057 dwarf2_mark_helper (void **slot
, void *data
)
24059 struct dwarf2_per_cu_data
*per_cu
;
24061 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
24063 /* cu->dependencies references may not yet have been ever read if QUIT aborts
24064 reading of the chain. As such dependencies remain valid it is not much
24065 useful to track and undo them during QUIT cleanups. */
24066 if (per_cu
->cu
== NULL
)
24069 if (per_cu
->cu
->mark
)
24071 per_cu
->cu
->mark
= 1;
24073 if (per_cu
->cu
->dependencies
!= NULL
)
24074 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
24079 /* Set the mark field in CU and in every other compilation unit in the
24080 cache that we must keep because we are keeping CU. */
24083 dwarf2_mark (struct dwarf2_cu
*cu
)
24088 if (cu
->dependencies
!= NULL
)
24089 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
24093 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
24097 per_cu
->cu
->mark
= 0;
24098 per_cu
= per_cu
->cu
->read_in_chain
;
24102 /* Trivial hash function for partial_die_info: the hash value of a DIE
24103 is its offset in .debug_info for this objfile. */
24106 partial_die_hash (const void *item
)
24108 const struct partial_die_info
*part_die
24109 = (const struct partial_die_info
*) item
;
24111 return to_underlying (part_die
->sect_off
);
24114 /* Trivial comparison function for partial_die_info structures: two DIEs
24115 are equal if they have the same offset. */
24118 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
24120 const struct partial_die_info
*part_die_lhs
24121 = (const struct partial_die_info
*) item_lhs
;
24122 const struct partial_die_info
*part_die_rhs
24123 = (const struct partial_die_info
*) item_rhs
;
24125 return part_die_lhs
->sect_off
== part_die_rhs
->sect_off
;
24128 static struct cmd_list_element
*set_dwarf_cmdlist
;
24129 static struct cmd_list_element
*show_dwarf_cmdlist
;
24132 set_dwarf_cmd (const char *args
, int from_tty
)
24134 help_list (set_dwarf_cmdlist
, "maintenance set dwarf ", all_commands
,
24139 show_dwarf_cmd (const char *args
, int from_tty
)
24141 cmd_show_list (show_dwarf_cmdlist
, from_tty
, "");
24144 /* Free data associated with OBJFILE, if necessary. */
24147 dwarf2_per_objfile_free (struct objfile
*objfile
, void *d
)
24149 struct dwarf2_per_objfile
*data
= (struct dwarf2_per_objfile
*) d
;
24152 /* Make sure we don't accidentally use dwarf2_per_objfile while
24154 dwarf2_per_objfile
= NULL
;
24156 for (ix
= 0; ix
< data
->n_comp_units
; ++ix
)
24157 VEC_free (dwarf2_per_cu_ptr
, data
->all_comp_units
[ix
]->imported_symtabs
);
24159 for (ix
= 0; ix
< data
->n_type_units
; ++ix
)
24160 VEC_free (dwarf2_per_cu_ptr
,
24161 data
->all_type_units
[ix
]->per_cu
.imported_symtabs
);
24162 xfree (data
->all_type_units
);
24164 VEC_free (dwarf2_section_info_def
, data
->types
);
24166 if (data
->dwo_files
)
24167 free_dwo_files (data
->dwo_files
, objfile
);
24168 if (data
->dwp_file
)
24169 gdb_bfd_unref (data
->dwp_file
->dbfd
);
24171 if (data
->dwz_file
&& data
->dwz_file
->dwz_bfd
)
24172 gdb_bfd_unref (data
->dwz_file
->dwz_bfd
);
24174 if (data
->index_table
!= NULL
)
24175 data
->index_table
->~mapped_index ();
24179 /* The "save gdb-index" command. */
24181 /* In-memory buffer to prepare data to be written later to a file. */
24185 /* Copy DATA to the end of the buffer. */
24186 template<typename T
>
24187 void append_data (const T
&data
)
24189 std::copy (reinterpret_cast<const gdb_byte
*> (&data
),
24190 reinterpret_cast<const gdb_byte
*> (&data
+ 1),
24191 grow (sizeof (data
)));
24194 /* Copy CSTR (a zero-terminated string) to the end of buffer. The
24195 terminating zero is appended too. */
24196 void append_cstr0 (const char *cstr
)
24198 const size_t size
= strlen (cstr
) + 1;
24199 std::copy (cstr
, cstr
+ size
, grow (size
));
24202 /* Accept a host-format integer in VAL and append it to the buffer
24203 as a target-format integer which is LEN bytes long. */
24204 void append_uint (size_t len
, bfd_endian byte_order
, ULONGEST val
)
24206 ::store_unsigned_integer (grow (len
), len
, byte_order
, val
);
24209 /* Return the size of the buffer. */
24210 size_t size () const
24212 return m_vec
.size ();
24215 /* Write the buffer to FILE. */
24216 void file_write (FILE *file
) const
24218 if (::fwrite (m_vec
.data (), 1, m_vec
.size (), file
) != m_vec
.size ())
24219 error (_("couldn't write data to file"));
24223 /* Grow SIZE bytes at the end of the buffer. Returns a pointer to
24224 the start of the new block. */
24225 gdb_byte
*grow (size_t size
)
24227 m_vec
.resize (m_vec
.size () + size
);
24228 return &*m_vec
.end () - size
;
24231 gdb::byte_vector m_vec
;
24234 /* An entry in the symbol table. */
24235 struct symtab_index_entry
24237 /* The name of the symbol. */
24239 /* The offset of the name in the constant pool. */
24240 offset_type index_offset
;
24241 /* A sorted vector of the indices of all the CUs that hold an object
24243 std::vector
<offset_type
> cu_indices
;
24246 /* The symbol table. This is a power-of-2-sized hash table. */
24247 struct mapped_symtab
24251 data
.resize (1024);
24254 offset_type n_elements
= 0;
24255 std::vector
<symtab_index_entry
> data
;
24258 /* Find a slot in SYMTAB for the symbol NAME. Returns a reference to
24261 Function is used only during write_hash_table so no index format backward
24262 compatibility is needed. */
24264 static symtab_index_entry
&
24265 find_slot (struct mapped_symtab
*symtab
, const char *name
)
24267 offset_type index
, step
, hash
= mapped_index_string_hash (INT_MAX
, name
);
24269 index
= hash
& (symtab
->data
.size () - 1);
24270 step
= ((hash
* 17) & (symtab
->data
.size () - 1)) | 1;
24274 if (symtab
->data
[index
].name
== NULL
24275 || strcmp (name
, symtab
->data
[index
].name
) == 0)
24276 return symtab
->data
[index
];
24277 index
= (index
+ step
) & (symtab
->data
.size () - 1);
24281 /* Expand SYMTAB's hash table. */
24284 hash_expand (struct mapped_symtab
*symtab
)
24286 auto old_entries
= std::move (symtab
->data
);
24288 symtab
->data
.clear ();
24289 symtab
->data
.resize (old_entries
.size () * 2);
24291 for (auto &it
: old_entries
)
24292 if (it
.name
!= NULL
)
24294 auto &ref
= find_slot (symtab
, it
.name
);
24295 ref
= std::move (it
);
24299 /* Add an entry to SYMTAB. NAME is the name of the symbol.
24300 CU_INDEX is the index of the CU in which the symbol appears.
24301 IS_STATIC is one if the symbol is static, otherwise zero (global). */
24304 add_index_entry (struct mapped_symtab
*symtab
, const char *name
,
24305 int is_static
, gdb_index_symbol_kind kind
,
24306 offset_type cu_index
)
24308 offset_type cu_index_and_attrs
;
24310 ++symtab
->n_elements
;
24311 if (4 * symtab
->n_elements
/ 3 >= symtab
->data
.size ())
24312 hash_expand (symtab
);
24314 symtab_index_entry
&slot
= find_slot (symtab
, name
);
24315 if (slot
.name
== NULL
)
24318 /* index_offset is set later. */
24321 cu_index_and_attrs
= 0;
24322 DW2_GDB_INDEX_CU_SET_VALUE (cu_index_and_attrs
, cu_index
);
24323 DW2_GDB_INDEX_SYMBOL_STATIC_SET_VALUE (cu_index_and_attrs
, is_static
);
24324 DW2_GDB_INDEX_SYMBOL_KIND_SET_VALUE (cu_index_and_attrs
, kind
);
24326 /* We don't want to record an index value twice as we want to avoid the
24328 We process all global symbols and then all static symbols
24329 (which would allow us to avoid the duplication by only having to check
24330 the last entry pushed), but a symbol could have multiple kinds in one CU.
24331 To keep things simple we don't worry about the duplication here and
24332 sort and uniqufy the list after we've processed all symbols. */
24333 slot
.cu_indices
.push_back (cu_index_and_attrs
);
24336 /* Sort and remove duplicates of all symbols' cu_indices lists. */
24339 uniquify_cu_indices (struct mapped_symtab
*symtab
)
24341 for (auto &entry
: symtab
->data
)
24343 if (entry
.name
!= NULL
&& !entry
.cu_indices
.empty ())
24345 auto &cu_indices
= entry
.cu_indices
;
24346 std::sort (cu_indices
.begin (), cu_indices
.end ());
24347 auto from
= std::unique (cu_indices
.begin (), cu_indices
.end ());
24348 cu_indices
.erase (from
, cu_indices
.end ());
24353 /* A form of 'const char *' suitable for container keys. Only the
24354 pointer is stored. The strings themselves are compared, not the
24359 c_str_view (const char *cstr
)
24363 bool operator== (const c_str_view
&other
) const
24365 return strcmp (m_cstr
, other
.m_cstr
) == 0;
24369 friend class c_str_view_hasher
;
24370 const char *const m_cstr
;
24373 /* A std::unordered_map::hasher for c_str_view that uses the right
24374 hash function for strings in a mapped index. */
24375 class c_str_view_hasher
24378 size_t operator () (const c_str_view
&x
) const
24380 return mapped_index_string_hash (INT_MAX
, x
.m_cstr
);
24384 /* A std::unordered_map::hasher for std::vector<>. */
24385 template<typename T
>
24386 class vector_hasher
24389 size_t operator () (const std::vector
<T
> &key
) const
24391 return iterative_hash (key
.data (),
24392 sizeof (key
.front ()) * key
.size (), 0);
24396 /* Write the mapped hash table SYMTAB to the data buffer OUTPUT, with
24397 constant pool entries going into the data buffer CPOOL. */
24400 write_hash_table (mapped_symtab
*symtab
, data_buf
&output
, data_buf
&cpool
)
24403 /* Elements are sorted vectors of the indices of all the CUs that
24404 hold an object of this name. */
24405 std::unordered_map
<std::vector
<offset_type
>, offset_type
,
24406 vector_hasher
<offset_type
>>
24409 /* We add all the index vectors to the constant pool first, to
24410 ensure alignment is ok. */
24411 for (symtab_index_entry
&entry
: symtab
->data
)
24413 if (entry
.name
== NULL
)
24415 gdb_assert (entry
.index_offset
== 0);
24417 /* Finding before inserting is faster than always trying to
24418 insert, because inserting always allocates a node, does the
24419 lookup, and then destroys the new node if another node
24420 already had the same key. C++17 try_emplace will avoid
24423 = symbol_hash_table
.find (entry
.cu_indices
);
24424 if (found
!= symbol_hash_table
.end ())
24426 entry
.index_offset
= found
->second
;
24430 symbol_hash_table
.emplace (entry
.cu_indices
, cpool
.size ());
24431 entry
.index_offset
= cpool
.size ();
24432 cpool
.append_data (MAYBE_SWAP (entry
.cu_indices
.size ()));
24433 for (const auto index
: entry
.cu_indices
)
24434 cpool
.append_data (MAYBE_SWAP (index
));
24438 /* Now write out the hash table. */
24439 std::unordered_map
<c_str_view
, offset_type
, c_str_view_hasher
> str_table
;
24440 for (const auto &entry
: symtab
->data
)
24442 offset_type str_off
, vec_off
;
24444 if (entry
.name
!= NULL
)
24446 const auto insertpair
= str_table
.emplace (entry
.name
, cpool
.size ());
24447 if (insertpair
.second
)
24448 cpool
.append_cstr0 (entry
.name
);
24449 str_off
= insertpair
.first
->second
;
24450 vec_off
= entry
.index_offset
;
24454 /* While 0 is a valid constant pool index, it is not valid
24455 to have 0 for both offsets. */
24460 output
.append_data (MAYBE_SWAP (str_off
));
24461 output
.append_data (MAYBE_SWAP (vec_off
));
24465 typedef std::unordered_map
<partial_symtab
*, unsigned int> psym_index_map
;
24467 /* Helper struct for building the address table. */
24468 struct addrmap_index_data
24470 addrmap_index_data (data_buf
&addr_vec_
, psym_index_map
&cu_index_htab_
)
24471 : addr_vec (addr_vec_
), cu_index_htab (cu_index_htab_
)
24474 struct objfile
*objfile
;
24475 data_buf
&addr_vec
;
24476 psym_index_map
&cu_index_htab
;
24478 /* Non-zero if the previous_* fields are valid.
24479 We can't write an entry until we see the next entry (since it is only then
24480 that we know the end of the entry). */
24481 int previous_valid
;
24482 /* Index of the CU in the table of all CUs in the index file. */
24483 unsigned int previous_cu_index
;
24484 /* Start address of the CU. */
24485 CORE_ADDR previous_cu_start
;
24488 /* Write an address entry to ADDR_VEC. */
24491 add_address_entry (struct objfile
*objfile
, data_buf
&addr_vec
,
24492 CORE_ADDR start
, CORE_ADDR end
, unsigned int cu_index
)
24494 CORE_ADDR baseaddr
;
24496 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
24498 addr_vec
.append_uint (8, BFD_ENDIAN_LITTLE
, start
- baseaddr
);
24499 addr_vec
.append_uint (8, BFD_ENDIAN_LITTLE
, end
- baseaddr
);
24500 addr_vec
.append_data (MAYBE_SWAP (cu_index
));
24503 /* Worker function for traversing an addrmap to build the address table. */
24506 add_address_entry_worker (void *datap
, CORE_ADDR start_addr
, void *obj
)
24508 struct addrmap_index_data
*data
= (struct addrmap_index_data
*) datap
;
24509 struct partial_symtab
*pst
= (struct partial_symtab
*) obj
;
24511 if (data
->previous_valid
)
24512 add_address_entry (data
->objfile
, data
->addr_vec
,
24513 data
->previous_cu_start
, start_addr
,
24514 data
->previous_cu_index
);
24516 data
->previous_cu_start
= start_addr
;
24519 const auto it
= data
->cu_index_htab
.find (pst
);
24520 gdb_assert (it
!= data
->cu_index_htab
.cend ());
24521 data
->previous_cu_index
= it
->second
;
24522 data
->previous_valid
= 1;
24525 data
->previous_valid
= 0;
24530 /* Write OBJFILE's address map to ADDR_VEC.
24531 CU_INDEX_HTAB is used to map addrmap entries to their CU indices
24532 in the index file. */
24535 write_address_map (struct objfile
*objfile
, data_buf
&addr_vec
,
24536 psym_index_map
&cu_index_htab
)
24538 struct addrmap_index_data
addrmap_index_data (addr_vec
, cu_index_htab
);
24540 /* When writing the address table, we have to cope with the fact that
24541 the addrmap iterator only provides the start of a region; we have to
24542 wait until the next invocation to get the start of the next region. */
24544 addrmap_index_data
.objfile
= objfile
;
24545 addrmap_index_data
.previous_valid
= 0;
24547 addrmap_foreach (objfile
->psymtabs_addrmap
, add_address_entry_worker
,
24548 &addrmap_index_data
);
24550 /* It's highly unlikely the last entry (end address = 0xff...ff)
24551 is valid, but we should still handle it.
24552 The end address is recorded as the start of the next region, but that
24553 doesn't work here. To cope we pass 0xff...ff, this is a rare situation
24555 if (addrmap_index_data
.previous_valid
)
24556 add_address_entry (objfile
, addr_vec
,
24557 addrmap_index_data
.previous_cu_start
, (CORE_ADDR
) -1,
24558 addrmap_index_data
.previous_cu_index
);
24561 /* Return the symbol kind of PSYM. */
24563 static gdb_index_symbol_kind
24564 symbol_kind (struct partial_symbol
*psym
)
24566 domain_enum domain
= PSYMBOL_DOMAIN (psym
);
24567 enum address_class aclass
= PSYMBOL_CLASS (psym
);
24575 return GDB_INDEX_SYMBOL_KIND_FUNCTION
;
24577 return GDB_INDEX_SYMBOL_KIND_TYPE
;
24579 case LOC_CONST_BYTES
:
24580 case LOC_OPTIMIZED_OUT
:
24582 return GDB_INDEX_SYMBOL_KIND_VARIABLE
;
24584 /* Note: It's currently impossible to recognize psyms as enum values
24585 short of reading the type info. For now punt. */
24586 return GDB_INDEX_SYMBOL_KIND_VARIABLE
;
24588 /* There are other LOC_FOO values that one might want to classify
24589 as variables, but dwarf2read.c doesn't currently use them. */
24590 return GDB_INDEX_SYMBOL_KIND_OTHER
;
24592 case STRUCT_DOMAIN
:
24593 return GDB_INDEX_SYMBOL_KIND_TYPE
;
24595 return GDB_INDEX_SYMBOL_KIND_OTHER
;
24599 /* Add a list of partial symbols to SYMTAB. */
24602 write_psymbols (struct mapped_symtab
*symtab
,
24603 std::unordered_set
<partial_symbol
*> &psyms_seen
,
24604 struct partial_symbol
**psymp
,
24606 offset_type cu_index
,
24609 for (; count
-- > 0; ++psymp
)
24611 struct partial_symbol
*psym
= *psymp
;
24613 if (SYMBOL_LANGUAGE (psym
) == language_ada
)
24614 error (_("Ada is not currently supported by the index"));
24616 /* Only add a given psymbol once. */
24617 if (psyms_seen
.insert (psym
).second
)
24619 gdb_index_symbol_kind kind
= symbol_kind (psym
);
24621 add_index_entry (symtab
, SYMBOL_SEARCH_NAME (psym
),
24622 is_static
, kind
, cu_index
);
24627 /* A helper struct used when iterating over debug_types. */
24628 struct signatured_type_index_data
24630 signatured_type_index_data (data_buf
&types_list_
,
24631 std::unordered_set
<partial_symbol
*> &psyms_seen_
)
24632 : types_list (types_list_
), psyms_seen (psyms_seen_
)
24635 struct objfile
*objfile
;
24636 struct mapped_symtab
*symtab
;
24637 data_buf
&types_list
;
24638 std::unordered_set
<partial_symbol
*> &psyms_seen
;
24642 /* A helper function that writes a single signatured_type to an
24646 write_one_signatured_type (void **slot
, void *d
)
24648 struct signatured_type_index_data
*info
24649 = (struct signatured_type_index_data
*) d
;
24650 struct signatured_type
*entry
= (struct signatured_type
*) *slot
;
24651 struct partial_symtab
*psymtab
= entry
->per_cu
.v
.psymtab
;
24653 write_psymbols (info
->symtab
,
24655 &info
->objfile
->global_psymbols
[psymtab
->globals_offset
],
24656 psymtab
->n_global_syms
, info
->cu_index
,
24658 write_psymbols (info
->symtab
,
24660 &info
->objfile
->static_psymbols
[psymtab
->statics_offset
],
24661 psymtab
->n_static_syms
, info
->cu_index
,
24664 info
->types_list
.append_uint (8, BFD_ENDIAN_LITTLE
,
24665 to_underlying (entry
->per_cu
.sect_off
));
24666 info
->types_list
.append_uint (8, BFD_ENDIAN_LITTLE
,
24667 to_underlying (entry
->type_offset_in_tu
));
24668 info
->types_list
.append_uint (8, BFD_ENDIAN_LITTLE
, entry
->signature
);
24675 /* Recurse into all "included" dependencies and count their symbols as
24676 if they appeared in this psymtab. */
24679 recursively_count_psymbols (struct partial_symtab
*psymtab
,
24680 size_t &psyms_seen
)
24682 for (int i
= 0; i
< psymtab
->number_of_dependencies
; ++i
)
24683 if (psymtab
->dependencies
[i
]->user
!= NULL
)
24684 recursively_count_psymbols (psymtab
->dependencies
[i
],
24687 psyms_seen
+= psymtab
->n_global_syms
;
24688 psyms_seen
+= psymtab
->n_static_syms
;
24691 /* Recurse into all "included" dependencies and write their symbols as
24692 if they appeared in this psymtab. */
24695 recursively_write_psymbols (struct objfile
*objfile
,
24696 struct partial_symtab
*psymtab
,
24697 struct mapped_symtab
*symtab
,
24698 std::unordered_set
<partial_symbol
*> &psyms_seen
,
24699 offset_type cu_index
)
24703 for (i
= 0; i
< psymtab
->number_of_dependencies
; ++i
)
24704 if (psymtab
->dependencies
[i
]->user
!= NULL
)
24705 recursively_write_psymbols (objfile
, psymtab
->dependencies
[i
],
24706 symtab
, psyms_seen
, cu_index
);
24708 write_psymbols (symtab
,
24710 &objfile
->global_psymbols
[psymtab
->globals_offset
],
24711 psymtab
->n_global_syms
, cu_index
,
24713 write_psymbols (symtab
,
24715 &objfile
->static_psymbols
[psymtab
->statics_offset
],
24716 psymtab
->n_static_syms
, cu_index
,
24720 /* Create an index file for OBJFILE in the directory DIR. */
24723 write_psymtabs_to_index (struct objfile
*objfile
, const char *dir
)
24725 if (dwarf2_per_objfile
->using_index
)
24726 error (_("Cannot use an index to create the index"));
24728 if (VEC_length (dwarf2_section_info_def
, dwarf2_per_objfile
->types
) > 1)
24729 error (_("Cannot make an index when the file has multiple .debug_types sections"));
24731 if (!objfile
->psymtabs
|| !objfile
->psymtabs_addrmap
)
24735 if (stat (objfile_name (objfile
), &st
) < 0)
24736 perror_with_name (objfile_name (objfile
));
24738 std::string
filename (std::string (dir
) + SLASH_STRING
24739 + lbasename (objfile_name (objfile
)) + INDEX_SUFFIX
);
24741 FILE *out_file
= gdb_fopen_cloexec (filename
.c_str (), "wb").release ();
24743 error (_("Can't open `%s' for writing"), filename
.c_str ());
24745 /* Order matters here; we want FILE to be closed before FILENAME is
24746 unlinked, because on MS-Windows one cannot delete a file that is
24747 still open. (Don't call anything here that might throw until
24748 file_closer is created.) */
24749 gdb::unlinker
unlink_file (filename
.c_str ());
24750 gdb_file_up
close_out_file (out_file
);
24752 mapped_symtab symtab
;
24755 /* While we're scanning CU's create a table that maps a psymtab pointer
24756 (which is what addrmap records) to its index (which is what is recorded
24757 in the index file). This will later be needed to write the address
24759 psym_index_map cu_index_htab
;
24760 cu_index_htab
.reserve (dwarf2_per_objfile
->n_comp_units
);
24762 /* The CU list is already sorted, so we don't need to do additional
24763 work here. Also, the debug_types entries do not appear in
24764 all_comp_units, but only in their own hash table. */
24766 /* The psyms_seen set is potentially going to be largish (~40k
24767 elements when indexing a -g3 build of GDB itself). Estimate the
24768 number of elements in order to avoid too many rehashes, which
24769 require rebuilding buckets and thus many trips to
24771 size_t psyms_count
= 0;
24772 for (int i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
24774 struct dwarf2_per_cu_data
*per_cu
24775 = dwarf2_per_objfile
->all_comp_units
[i
];
24776 struct partial_symtab
*psymtab
= per_cu
->v
.psymtab
;
24778 if (psymtab
!= NULL
&& psymtab
->user
== NULL
)
24779 recursively_count_psymbols (psymtab
, psyms_count
);
24781 /* Generating an index for gdb itself shows a ratio of
24782 TOTAL_SEEN_SYMS/UNIQUE_SYMS or ~5. 4 seems like a good bet. */
24783 std::unordered_set
<partial_symbol
*> psyms_seen (psyms_count
/ 4);
24784 for (int i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
24786 struct dwarf2_per_cu_data
*per_cu
24787 = dwarf2_per_objfile
->all_comp_units
[i
];
24788 struct partial_symtab
*psymtab
= per_cu
->v
.psymtab
;
24790 /* CU of a shared file from 'dwz -m' may be unused by this main file.
24791 It may be referenced from a local scope but in such case it does not
24792 need to be present in .gdb_index. */
24793 if (psymtab
== NULL
)
24796 if (psymtab
->user
== NULL
)
24797 recursively_write_psymbols (objfile
, psymtab
, &symtab
,
24800 const auto insertpair
= cu_index_htab
.emplace (psymtab
, i
);
24801 gdb_assert (insertpair
.second
);
24803 cu_list
.append_uint (8, BFD_ENDIAN_LITTLE
,
24804 to_underlying (per_cu
->sect_off
));
24805 cu_list
.append_uint (8, BFD_ENDIAN_LITTLE
, per_cu
->length
);
24808 /* Dump the address map. */
24810 write_address_map (objfile
, addr_vec
, cu_index_htab
);
24812 /* Write out the .debug_type entries, if any. */
24813 data_buf types_cu_list
;
24814 if (dwarf2_per_objfile
->signatured_types
)
24816 signatured_type_index_data
sig_data (types_cu_list
,
24819 sig_data
.objfile
= objfile
;
24820 sig_data
.symtab
= &symtab
;
24821 sig_data
.cu_index
= dwarf2_per_objfile
->n_comp_units
;
24822 htab_traverse_noresize (dwarf2_per_objfile
->signatured_types
,
24823 write_one_signatured_type
, &sig_data
);
24826 /* Now that we've processed all symbols we can shrink their cu_indices
24828 uniquify_cu_indices (&symtab
);
24830 data_buf symtab_vec
, constant_pool
;
24831 write_hash_table (&symtab
, symtab_vec
, constant_pool
);
24834 const offset_type size_of_contents
= 6 * sizeof (offset_type
);
24835 offset_type total_len
= size_of_contents
;
24837 /* The version number. */
24838 contents
.append_data (MAYBE_SWAP (8));
24840 /* The offset of the CU list from the start of the file. */
24841 contents
.append_data (MAYBE_SWAP (total_len
));
24842 total_len
+= cu_list
.size ();
24844 /* The offset of the types CU list from the start of the file. */
24845 contents
.append_data (MAYBE_SWAP (total_len
));
24846 total_len
+= types_cu_list
.size ();
24848 /* The offset of the address table from the start of the file. */
24849 contents
.append_data (MAYBE_SWAP (total_len
));
24850 total_len
+= addr_vec
.size ();
24852 /* The offset of the symbol table from the start of the file. */
24853 contents
.append_data (MAYBE_SWAP (total_len
));
24854 total_len
+= symtab_vec
.size ();
24856 /* The offset of the constant pool from the start of the file. */
24857 contents
.append_data (MAYBE_SWAP (total_len
));
24858 total_len
+= constant_pool
.size ();
24860 gdb_assert (contents
.size () == size_of_contents
);
24862 contents
.file_write (out_file
);
24863 cu_list
.file_write (out_file
);
24864 types_cu_list
.file_write (out_file
);
24865 addr_vec
.file_write (out_file
);
24866 symtab_vec
.file_write (out_file
);
24867 constant_pool
.file_write (out_file
);
24869 /* We want to keep the file. */
24870 unlink_file
.keep ();
24873 /* Implementation of the `save gdb-index' command.
24875 Note that the file format used by this command is documented in the
24876 GDB manual. Any changes here must be documented there. */
24879 save_gdb_index_command (const char *arg
, int from_tty
)
24881 struct objfile
*objfile
;
24884 error (_("usage: save gdb-index DIRECTORY"));
24886 ALL_OBJFILES (objfile
)
24890 /* If the objfile does not correspond to an actual file, skip it. */
24891 if (stat (objfile_name (objfile
), &st
) < 0)
24895 = (struct dwarf2_per_objfile
*) objfile_data (objfile
,
24896 dwarf2_objfile_data_key
);
24897 if (dwarf2_per_objfile
)
24902 write_psymtabs_to_index (objfile
, arg
);
24904 CATCH (except
, RETURN_MASK_ERROR
)
24906 exception_fprintf (gdb_stderr
, except
,
24907 _("Error while writing index for `%s': "),
24908 objfile_name (objfile
));
24917 int dwarf_always_disassemble
;
24920 show_dwarf_always_disassemble (struct ui_file
*file
, int from_tty
,
24921 struct cmd_list_element
*c
, const char *value
)
24923 fprintf_filtered (file
,
24924 _("Whether to always disassemble "
24925 "DWARF expressions is %s.\n"),
24930 show_check_physname (struct ui_file
*file
, int from_tty
,
24931 struct cmd_list_element
*c
, const char *value
)
24933 fprintf_filtered (file
,
24934 _("Whether to check \"physname\" is %s.\n"),
24939 _initialize_dwarf2_read (void)
24941 struct cmd_list_element
*c
;
24943 dwarf2_objfile_data_key
24944 = register_objfile_data_with_cleanup (NULL
, dwarf2_per_objfile_free
);
24946 add_prefix_cmd ("dwarf", class_maintenance
, set_dwarf_cmd
, _("\
24947 Set DWARF specific variables.\n\
24948 Configure DWARF variables such as the cache size"),
24949 &set_dwarf_cmdlist
, "maintenance set dwarf ",
24950 0/*allow-unknown*/, &maintenance_set_cmdlist
);
24952 add_prefix_cmd ("dwarf", class_maintenance
, show_dwarf_cmd
, _("\
24953 Show DWARF specific variables\n\
24954 Show DWARF variables such as the cache size"),
24955 &show_dwarf_cmdlist
, "maintenance show dwarf ",
24956 0/*allow-unknown*/, &maintenance_show_cmdlist
);
24958 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
24959 &dwarf_max_cache_age
, _("\
24960 Set the upper bound on the age of cached DWARF compilation units."), _("\
24961 Show the upper bound on the age of cached DWARF compilation units."), _("\
24962 A higher limit means that cached compilation units will be stored\n\
24963 in memory longer, and more total memory will be used. Zero disables\n\
24964 caching, which can slow down startup."),
24966 show_dwarf_max_cache_age
,
24967 &set_dwarf_cmdlist
,
24968 &show_dwarf_cmdlist
);
24970 add_setshow_boolean_cmd ("always-disassemble", class_obscure
,
24971 &dwarf_always_disassemble
, _("\
24972 Set whether `info address' always disassembles DWARF expressions."), _("\
24973 Show whether `info address' always disassembles DWARF expressions."), _("\
24974 When enabled, DWARF expressions are always printed in an assembly-like\n\
24975 syntax. When disabled, expressions will be printed in a more\n\
24976 conversational style, when possible."),
24978 show_dwarf_always_disassemble
,
24979 &set_dwarf_cmdlist
,
24980 &show_dwarf_cmdlist
);
24982 add_setshow_zuinteger_cmd ("dwarf-read", no_class
, &dwarf_read_debug
, _("\
24983 Set debugging of the DWARF reader."), _("\
24984 Show debugging of the DWARF reader."), _("\
24985 When enabled (non-zero), debugging messages are printed during DWARF\n\
24986 reading and symtab expansion. A value of 1 (one) provides basic\n\
24987 information. A value greater than 1 provides more verbose information."),
24990 &setdebuglist
, &showdebuglist
);
24992 add_setshow_zuinteger_cmd ("dwarf-die", no_class
, &dwarf_die_debug
, _("\
24993 Set debugging of the DWARF DIE reader."), _("\
24994 Show debugging of the DWARF DIE reader."), _("\
24995 When enabled (non-zero), DIEs are dumped after they are read in.\n\
24996 The value is the maximum depth to print."),
24999 &setdebuglist
, &showdebuglist
);
25001 add_setshow_zuinteger_cmd ("dwarf-line", no_class
, &dwarf_line_debug
, _("\
25002 Set debugging of the dwarf line reader."), _("\
25003 Show debugging of the dwarf line reader."), _("\
25004 When enabled (non-zero), line number entries are dumped as they are read in.\n\
25005 A value of 1 (one) provides basic information.\n\
25006 A value greater than 1 provides more verbose information."),
25009 &setdebuglist
, &showdebuglist
);
25011 add_setshow_boolean_cmd ("check-physname", no_class
, &check_physname
, _("\
25012 Set cross-checking of \"physname\" code against demangler."), _("\
25013 Show cross-checking of \"physname\" code against demangler."), _("\
25014 When enabled, GDB's internal \"physname\" code is checked against\n\
25016 NULL
, show_check_physname
,
25017 &setdebuglist
, &showdebuglist
);
25019 add_setshow_boolean_cmd ("use-deprecated-index-sections",
25020 no_class
, &use_deprecated_index_sections
, _("\
25021 Set whether to use deprecated gdb_index sections."), _("\
25022 Show whether to use deprecated gdb_index sections."), _("\
25023 When enabled, deprecated .gdb_index sections are used anyway.\n\
25024 Normally they are ignored either because of a missing feature or\n\
25025 performance issue.\n\
25026 Warning: This option must be enabled before gdb reads the file."),
25029 &setlist
, &showlist
);
25031 c
= add_cmd ("gdb-index", class_files
, save_gdb_index_command
,
25033 Save a gdb-index file.\n\
25034 Usage: save gdb-index DIRECTORY"),
25036 set_cmd_completer (c
, filename_completer
);
25038 dwarf2_locexpr_index
= register_symbol_computed_impl (LOC_COMPUTED
,
25039 &dwarf2_locexpr_funcs
);
25040 dwarf2_loclist_index
= register_symbol_computed_impl (LOC_COMPUTED
,
25041 &dwarf2_loclist_funcs
);
25043 dwarf2_locexpr_block_index
= register_symbol_block_impl (LOC_BLOCK
,
25044 &dwarf2_block_frame_base_locexpr_funcs
);
25045 dwarf2_loclist_block_index
= register_symbol_block_impl (LOC_BLOCK
,
25046 &dwarf2_block_frame_base_loclist_funcs
);
25049 selftests::register_test ("dw2_expand_symtabs_matching",
25050 selftests::dw2_expand_symtabs_matching::run_test
);