1 /* DWARF 2 debugging format support for GDB.
3 Copyright (C) 1994-2021 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. */
32 #include "dwarf2/read.h"
33 #include "dwarf2/abbrev.h"
34 #include "dwarf2/attribute.h"
35 #include "dwarf2/comp-unit-head.h"
36 #include "dwarf2/cu.h"
37 #include "dwarf2/index-cache.h"
38 #include "dwarf2/index-common.h"
39 #include "dwarf2/leb.h"
40 #include "dwarf2/line-header.h"
41 #include "dwarf2/dwz.h"
42 #include "dwarf2/macro.h"
43 #include "dwarf2/die.h"
44 #include "dwarf2/sect-names.h"
45 #include "dwarf2/stringify.h"
46 #include "dwarf2/public.h"
54 #include "gdb-demangle.h"
55 #include "filenames.h" /* for DOSish file names */
57 #include "complaints.h"
58 #include "dwarf2/expr.h"
59 #include "dwarf2/loc.h"
60 #include "cp-support.h"
66 #include "typeprint.h"
71 #include "gdbcore.h" /* for gnutarget */
72 #include "gdb/gdb-index.h"
77 #include "namespace.h"
78 #include "gdbsupport/function-view.h"
79 #include "gdbsupport/gdb_optional.h"
80 #include "gdbsupport/underlying.h"
81 #include "gdbsupport/hash_enum.h"
82 #include "filename-seen-cache.h"
86 #include <unordered_map>
87 #include "gdbsupport/selftest.h"
88 #include "rust-lang.h"
89 #include "gdbsupport/pathstuff.h"
90 #include "count-one-bits.h"
91 #include <unordered_set>
93 /* When == 1, print basic high level tracing messages.
94 When > 1, be more verbose.
95 This is in contrast to the low level DIE reading of dwarf_die_debug. */
96 static unsigned int dwarf_read_debug
= 0;
98 /* Print a "dwarf-read" debug statement if dwarf_read_debug is >= 1. */
100 #define dwarf_read_debug_printf(fmt, ...) \
101 debug_prefixed_printf_cond (dwarf_read_debug >= 1, "dwarf-read", fmt, \
104 /* Print a "dwarf-read" debug statement if dwarf_read_debug is >= 2. */
106 #define dwarf_read_debug_printf_v(fmt, ...) \
107 debug_prefixed_printf_cond (dwarf_read_debug >= 2, "dwarf-read", fmt, \
110 /* When non-zero, dump DIEs after they are read in. */
111 static unsigned int dwarf_die_debug
= 0;
113 /* When non-zero, dump line number entries as they are read in. */
114 unsigned int dwarf_line_debug
= 0;
116 /* When true, cross-check physname against demangler. */
117 static bool check_physname
= false;
119 /* When true, do not reject deprecated .gdb_index sections. */
120 static bool use_deprecated_index_sections
= false;
122 /* This is used to store the data that is always per objfile. */
123 static const objfile_key
<dwarf2_per_objfile
> dwarf2_objfile_data_key
;
125 /* These are used to store the dwarf2_per_bfd objects.
127 objfiles having the same BFD, which doesn't require relocations, are going to
128 share a dwarf2_per_bfd object, which is held in the _bfd_data_key version.
130 Other objfiles are not going to share a dwarf2_per_bfd with any other
131 objfiles, so they'll have their own version kept in the _objfile_data_key
133 static const struct bfd_key
<dwarf2_per_bfd
> dwarf2_per_bfd_bfd_data_key
;
134 static const struct objfile_key
<dwarf2_per_bfd
> dwarf2_per_bfd_objfile_data_key
;
136 /* The "aclass" indices for various kinds of computed DWARF symbols. */
138 static int dwarf2_locexpr_index
;
139 static int dwarf2_loclist_index
;
140 static int dwarf2_locexpr_block_index
;
141 static int dwarf2_loclist_block_index
;
143 /* Size of .debug_loclists section header for 32-bit DWARF format. */
144 #define LOCLIST_HEADER_SIZE32 12
146 /* Size of .debug_loclists section header for 64-bit DWARF format. */
147 #define LOCLIST_HEADER_SIZE64 20
149 /* Size of .debug_rnglists section header for 32-bit DWARF format. */
150 #define RNGLIST_HEADER_SIZE32 12
152 /* Size of .debug_rnglists section header for 64-bit DWARF format. */
153 #define RNGLIST_HEADER_SIZE64 20
155 /* An index into a (C++) symbol name component in a symbol name as
156 recorded in the mapped_index's symbol table. For each C++ symbol
157 in the symbol table, we record one entry for the start of each
158 component in the symbol in a table of name components, and then
159 sort the table, in order to be able to binary search symbol names,
160 ignoring leading namespaces, both completion and regular look up.
161 For example, for symbol "A::B::C", we'll have an entry that points
162 to "A::B::C", another that points to "B::C", and another for "C".
163 Note that function symbols in GDB index have no parameter
164 information, just the function/method names. You can convert a
165 name_component to a "const char *" using the
166 'mapped_index::symbol_name_at(offset_type)' method. */
168 struct name_component
170 /* Offset in the symbol name where the component starts. Stored as
171 a (32-bit) offset instead of a pointer to save memory and improve
172 locality on 64-bit architectures. */
173 offset_type name_offset
;
175 /* The symbol's index in the symbol and constant pool tables of a
180 /* Base class containing bits shared by both .gdb_index and
181 .debug_name indexes. */
183 struct mapped_index_base
185 mapped_index_base () = default;
186 DISABLE_COPY_AND_ASSIGN (mapped_index_base
);
188 /* The name_component table (a sorted vector). See name_component's
189 description above. */
190 std::vector
<name_component
> name_components
;
192 /* How NAME_COMPONENTS is sorted. */
193 enum case_sensitivity name_components_casing
;
195 /* Return the number of names in the symbol table. */
196 virtual size_t symbol_name_count () const = 0;
198 /* Get the name of the symbol at IDX in the symbol table. */
199 virtual const char *symbol_name_at
200 (offset_type idx
, dwarf2_per_objfile
*per_objfile
) const = 0;
202 /* Return whether the name at IDX in the symbol table should be
204 virtual bool symbol_name_slot_invalid (offset_type idx
) const
209 /* Build the symbol name component sorted vector, if we haven't
211 void build_name_components (dwarf2_per_objfile
*per_objfile
);
213 /* Returns the lower (inclusive) and upper (exclusive) bounds of the
214 possible matches for LN_NO_PARAMS in the name component
216 std::pair
<std::vector
<name_component
>::const_iterator
,
217 std::vector
<name_component
>::const_iterator
>
218 find_name_components_bounds (const lookup_name_info
&ln_no_params
,
220 dwarf2_per_objfile
*per_objfile
) const;
222 /* Prevent deleting/destroying via a base class pointer. */
224 ~mapped_index_base() = default;
227 /* This is a view into the index that converts from bytes to an
228 offset_type, and allows indexing. Unaligned bytes are specifically
229 allowed here, and handled via unpacking. */
234 offset_view () = default;
236 explicit offset_view (gdb::array_view
<const gdb_byte
> bytes
)
241 /* Extract the INDEXth offset_type from the array. */
242 offset_type
operator[] (size_t index
) const
244 const gdb_byte
*bytes
= &m_bytes
[index
* sizeof (offset_type
)];
245 return (offset_type
) extract_unsigned_integer (bytes
,
246 sizeof (offset_type
),
250 /* Return the number of offset_types in this array. */
253 return m_bytes
.size () / sizeof (offset_type
);
256 /* Return true if this view is empty. */
259 return m_bytes
.empty ();
263 /* The underlying bytes. */
264 gdb::array_view
<const gdb_byte
> m_bytes
;
267 /* A description of the mapped index. The file format is described in
268 a comment by the code that writes the index. */
269 struct mapped_index final
: public mapped_index_base
271 /* Index data format version. */
274 /* The address table data. */
275 gdb::array_view
<const gdb_byte
> address_table
;
277 /* The symbol table, implemented as a hash table. */
278 offset_view symbol_table
;
280 /* A pointer to the constant pool. */
281 gdb::array_view
<const gdb_byte
> constant_pool
;
283 /* Return the index into the constant pool of the name of the IDXth
284 symbol in the symbol table. */
285 offset_type
symbol_name_index (offset_type idx
) const
287 return symbol_table
[2 * idx
];
290 /* Return the index into the constant pool of the CU vector of the
291 IDXth symbol in the symbol table. */
292 offset_type
symbol_vec_index (offset_type idx
) const
294 return symbol_table
[2 * idx
+ 1];
297 bool symbol_name_slot_invalid (offset_type idx
) const override
299 return (symbol_name_index (idx
) == 0
300 && symbol_vec_index (idx
) == 0);
303 /* Convenience method to get at the name of the symbol at IDX in the
305 const char *symbol_name_at
306 (offset_type idx
, dwarf2_per_objfile
*per_objfile
) const override
308 return (const char *) (this->constant_pool
.data ()
309 + symbol_name_index (idx
));
312 size_t symbol_name_count () const override
313 { return this->symbol_table
.size () / 2; }
316 /* A description of the mapped .debug_names.
317 Uninitialized map has CU_COUNT 0. */
318 struct mapped_debug_names final
: public mapped_index_base
320 bfd_endian dwarf5_byte_order
;
321 bool dwarf5_is_dwarf64
;
322 bool augmentation_is_gdb
;
324 uint32_t cu_count
= 0;
325 uint32_t tu_count
, bucket_count
, name_count
;
326 const gdb_byte
*cu_table_reordered
, *tu_table_reordered
;
327 const uint32_t *bucket_table_reordered
, *hash_table_reordered
;
328 const gdb_byte
*name_table_string_offs_reordered
;
329 const gdb_byte
*name_table_entry_offs_reordered
;
330 const gdb_byte
*entry_pool
;
337 /* Attribute name DW_IDX_*. */
340 /* Attribute form DW_FORM_*. */
343 /* Value if FORM is DW_FORM_implicit_const. */
344 LONGEST implicit_const
;
346 std::vector
<attr
> attr_vec
;
349 std::unordered_map
<ULONGEST
, index_val
> abbrev_map
;
351 const char *namei_to_name
352 (uint32_t namei
, dwarf2_per_objfile
*per_objfile
) const;
354 /* Implementation of the mapped_index_base virtual interface, for
355 the name_components cache. */
357 const char *symbol_name_at
358 (offset_type idx
, dwarf2_per_objfile
*per_objfile
) const override
359 { return namei_to_name (idx
, per_objfile
); }
361 size_t symbol_name_count () const override
362 { return this->name_count
; }
365 /* See dwarf2read.h. */
368 get_dwarf2_per_objfile (struct objfile
*objfile
)
370 return dwarf2_objfile_data_key
.get (objfile
);
373 /* Default names of the debugging sections. */
375 /* Note that if the debugging section has been compressed, it might
376 have a name like .zdebug_info. */
378 const struct dwarf2_debug_sections dwarf2_elf_names
=
380 { ".debug_info", ".zdebug_info" },
381 { ".debug_abbrev", ".zdebug_abbrev" },
382 { ".debug_line", ".zdebug_line" },
383 { ".debug_loc", ".zdebug_loc" },
384 { ".debug_loclists", ".zdebug_loclists" },
385 { ".debug_macinfo", ".zdebug_macinfo" },
386 { ".debug_macro", ".zdebug_macro" },
387 { ".debug_str", ".zdebug_str" },
388 { ".debug_str_offsets", ".zdebug_str_offsets" },
389 { ".debug_line_str", ".zdebug_line_str" },
390 { ".debug_ranges", ".zdebug_ranges" },
391 { ".debug_rnglists", ".zdebug_rnglists" },
392 { ".debug_types", ".zdebug_types" },
393 { ".debug_addr", ".zdebug_addr" },
394 { ".debug_frame", ".zdebug_frame" },
395 { ".eh_frame", NULL
},
396 { ".gdb_index", ".zgdb_index" },
397 { ".debug_names", ".zdebug_names" },
398 { ".debug_aranges", ".zdebug_aranges" },
402 /* List of DWO/DWP sections. */
404 static const struct dwop_section_names
406 struct dwarf2_section_names abbrev_dwo
;
407 struct dwarf2_section_names info_dwo
;
408 struct dwarf2_section_names line_dwo
;
409 struct dwarf2_section_names loc_dwo
;
410 struct dwarf2_section_names loclists_dwo
;
411 struct dwarf2_section_names macinfo_dwo
;
412 struct dwarf2_section_names macro_dwo
;
413 struct dwarf2_section_names rnglists_dwo
;
414 struct dwarf2_section_names str_dwo
;
415 struct dwarf2_section_names str_offsets_dwo
;
416 struct dwarf2_section_names types_dwo
;
417 struct dwarf2_section_names cu_index
;
418 struct dwarf2_section_names tu_index
;
422 { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo" },
423 { ".debug_info.dwo", ".zdebug_info.dwo" },
424 { ".debug_line.dwo", ".zdebug_line.dwo" },
425 { ".debug_loc.dwo", ".zdebug_loc.dwo" },
426 { ".debug_loclists.dwo", ".zdebug_loclists.dwo" },
427 { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo" },
428 { ".debug_macro.dwo", ".zdebug_macro.dwo" },
429 { ".debug_rnglists.dwo", ".zdebug_rnglists.dwo" },
430 { ".debug_str.dwo", ".zdebug_str.dwo" },
431 { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo" },
432 { ".debug_types.dwo", ".zdebug_types.dwo" },
433 { ".debug_cu_index", ".zdebug_cu_index" },
434 { ".debug_tu_index", ".zdebug_tu_index" },
437 /* local data types */
439 /* The location list and range list sections (.debug_loclists & .debug_rnglists)
440 begin with a header, which contains the following information. */
441 struct loclists_rnglists_header
443 /* A 4-byte or 12-byte length containing the length of the
444 set of entries for this compilation unit, not including the
445 length field itself. */
448 /* A 2-byte version identifier. */
451 /* A 1-byte unsigned integer containing the size in bytes of an address on
452 the target system. */
453 unsigned char addr_size
;
455 /* A 1-byte unsigned integer containing the size in bytes of a segment selector
456 on the target system. */
457 unsigned char segment_collector_size
;
459 /* A 4-byte count of the number of offsets that follow the header. */
460 unsigned int offset_entry_count
;
463 /* A struct that can be used as a hash key for tables based on DW_AT_stmt_list.
464 This includes type_unit_group and quick_file_names. */
466 struct stmt_list_hash
468 /* The DWO unit this table is from or NULL if there is none. */
469 struct dwo_unit
*dwo_unit
;
471 /* Offset in .debug_line or .debug_line.dwo. */
472 sect_offset line_sect_off
;
475 /* Each element of dwarf2_per_bfd->type_unit_groups is a pointer to
476 an object of this type. This contains elements of type unit groups
477 that can be shared across objfiles. The non-shareable parts are in
478 type_unit_group_unshareable. */
480 struct type_unit_group
: public dwarf2_per_cu_data
482 /* The TUs that share this DW_AT_stmt_list entry.
483 This is added to while parsing type units to build partial symtabs,
484 and is deleted afterwards and not used again. */
485 std::vector
<signatured_type
*> *tus
= nullptr;
487 /* The data used to construct the hash key. */
488 struct stmt_list_hash hash
{};
491 /* These sections are what may appear in a (real or virtual) DWO file. */
495 struct dwarf2_section_info abbrev
;
496 struct dwarf2_section_info line
;
497 struct dwarf2_section_info loc
;
498 struct dwarf2_section_info loclists
;
499 struct dwarf2_section_info macinfo
;
500 struct dwarf2_section_info macro
;
501 struct dwarf2_section_info rnglists
;
502 struct dwarf2_section_info str
;
503 struct dwarf2_section_info str_offsets
;
504 /* In the case of a virtual DWO file, these two are unused. */
505 struct dwarf2_section_info info
;
506 std::vector
<dwarf2_section_info
> types
;
509 /* CUs/TUs in DWP/DWO files. */
513 /* Backlink to the containing struct dwo_file. */
514 struct dwo_file
*dwo_file
;
516 /* The "id" that distinguishes this CU/TU.
517 .debug_info calls this "dwo_id", .debug_types calls this "signature".
518 Since signatures came first, we stick with it for consistency. */
521 /* The section this CU/TU lives in, in the DWO file. */
522 struct dwarf2_section_info
*section
;
524 /* Same as dwarf2_per_cu_data:{sect_off,length} but in the DWO section. */
525 sect_offset sect_off
;
528 /* For types, offset in the type's DIE of the type defined by this TU. */
529 cu_offset type_offset_in_tu
;
532 /* include/dwarf2.h defines the DWP section codes.
533 It defines a max value but it doesn't define a min value, which we
534 use for error checking, so provide one. */
536 enum dwp_v2_section_ids
541 /* Data for one DWO file.
543 This includes virtual DWO files (a virtual DWO file is a DWO file as it
544 appears in a DWP file). DWP files don't really have DWO files per se -
545 comdat folding of types "loses" the DWO file they came from, and from
546 a high level view DWP files appear to contain a mass of random types.
547 However, to maintain consistency with the non-DWP case we pretend DWP
548 files contain virtual DWO files, and we assign each TU with one virtual
549 DWO file (generally based on the line and abbrev section offsets -
550 a heuristic that seems to work in practice). */
554 dwo_file () = default;
555 DISABLE_COPY_AND_ASSIGN (dwo_file
);
557 /* The DW_AT_GNU_dwo_name or DW_AT_dwo_name attribute.
558 For virtual DWO files the name is constructed from the section offsets
559 of abbrev,line,loc,str_offsets so that we combine virtual DWO files
560 from related CU+TUs. */
561 const char *dwo_name
= nullptr;
563 /* The DW_AT_comp_dir attribute. */
564 const char *comp_dir
= nullptr;
566 /* The bfd, when the file is open. Otherwise this is NULL.
567 This is unused(NULL) for virtual DWO files where we use dwp_file.dbfd. */
568 gdb_bfd_ref_ptr dbfd
;
570 /* The sections that make up this DWO file.
571 Remember that for virtual DWO files in DWP V2 or DWP V5, these are virtual
572 sections (for lack of a better name). */
573 struct dwo_sections sections
{};
575 /* The CUs in the file.
576 Each element is a struct dwo_unit. Multiple CUs per DWO are supported as
577 an extension to handle LLVM's Link Time Optimization output (where
578 multiple source files may be compiled into a single object/dwo pair). */
581 /* Table of TUs in the file.
582 Each element is a struct dwo_unit. */
586 /* These sections are what may appear in a DWP file. */
590 /* These are used by all DWP versions (1, 2 and 5). */
591 struct dwarf2_section_info str
;
592 struct dwarf2_section_info cu_index
;
593 struct dwarf2_section_info tu_index
;
595 /* These are only used by DWP version 2 and version 5 files.
596 In DWP version 1 the .debug_info.dwo, .debug_types.dwo, and other
597 sections are referenced by section number, and are not recorded here.
598 In DWP version 2 or 5 there is at most one copy of all these sections,
599 each section being (effectively) comprised of the concatenation of all of
600 the individual sections that exist in the version 1 format.
601 To keep the code simple we treat each of these concatenated pieces as a
602 section itself (a virtual section?). */
603 struct dwarf2_section_info abbrev
;
604 struct dwarf2_section_info info
;
605 struct dwarf2_section_info line
;
606 struct dwarf2_section_info loc
;
607 struct dwarf2_section_info loclists
;
608 struct dwarf2_section_info macinfo
;
609 struct dwarf2_section_info macro
;
610 struct dwarf2_section_info rnglists
;
611 struct dwarf2_section_info str_offsets
;
612 struct dwarf2_section_info types
;
615 /* These sections are what may appear in a virtual DWO file in DWP version 1.
616 A virtual DWO file is a DWO file as it appears in a DWP file. */
618 struct virtual_v1_dwo_sections
620 struct dwarf2_section_info abbrev
;
621 struct dwarf2_section_info line
;
622 struct dwarf2_section_info loc
;
623 struct dwarf2_section_info macinfo
;
624 struct dwarf2_section_info macro
;
625 struct dwarf2_section_info str_offsets
;
626 /* Each DWP hash table entry records one CU or one TU.
627 That is recorded here, and copied to dwo_unit.section. */
628 struct dwarf2_section_info info_or_types
;
631 /* Similar to virtual_v1_dwo_sections, but for DWP version 2 or 5.
632 In version 2, the sections of the DWO files are concatenated together
633 and stored in one section of that name. Thus each ELF section contains
634 several "virtual" sections. */
636 struct virtual_v2_or_v5_dwo_sections
638 bfd_size_type abbrev_offset
;
639 bfd_size_type abbrev_size
;
641 bfd_size_type line_offset
;
642 bfd_size_type line_size
;
644 bfd_size_type loc_offset
;
645 bfd_size_type loc_size
;
647 bfd_size_type loclists_offset
;
648 bfd_size_type loclists_size
;
650 bfd_size_type macinfo_offset
;
651 bfd_size_type macinfo_size
;
653 bfd_size_type macro_offset
;
654 bfd_size_type macro_size
;
656 bfd_size_type rnglists_offset
;
657 bfd_size_type rnglists_size
;
659 bfd_size_type str_offsets_offset
;
660 bfd_size_type str_offsets_size
;
662 /* Each DWP hash table entry records one CU or one TU.
663 That is recorded here, and copied to dwo_unit.section. */
664 bfd_size_type info_or_types_offset
;
665 bfd_size_type info_or_types_size
;
668 /* Contents of DWP hash tables. */
670 struct dwp_hash_table
672 uint32_t version
, nr_columns
;
673 uint32_t nr_units
, nr_slots
;
674 const gdb_byte
*hash_table
, *unit_table
;
679 const gdb_byte
*indices
;
683 /* This is indexed by column number and gives the id of the section
685 #define MAX_NR_V2_DWO_SECTIONS \
686 (1 /* .debug_info or .debug_types */ \
687 + 1 /* .debug_abbrev */ \
688 + 1 /* .debug_line */ \
689 + 1 /* .debug_loc */ \
690 + 1 /* .debug_str_offsets */ \
691 + 1 /* .debug_macro or .debug_macinfo */)
692 int section_ids
[MAX_NR_V2_DWO_SECTIONS
];
693 const gdb_byte
*offsets
;
694 const gdb_byte
*sizes
;
698 /* This is indexed by column number and gives the id of the section
700 #define MAX_NR_V5_DWO_SECTIONS \
701 (1 /* .debug_info */ \
702 + 1 /* .debug_abbrev */ \
703 + 1 /* .debug_line */ \
704 + 1 /* .debug_loclists */ \
705 + 1 /* .debug_str_offsets */ \
706 + 1 /* .debug_macro */ \
707 + 1 /* .debug_rnglists */)
708 int section_ids
[MAX_NR_V5_DWO_SECTIONS
];
709 const gdb_byte
*offsets
;
710 const gdb_byte
*sizes
;
715 /* Data for one DWP file. */
719 dwp_file (const char *name_
, gdb_bfd_ref_ptr
&&abfd
)
721 dbfd (std::move (abfd
))
725 /* Name of the file. */
728 /* File format version. */
732 gdb_bfd_ref_ptr dbfd
;
734 /* Section info for this file. */
735 struct dwp_sections sections
{};
737 /* Table of CUs in the file. */
738 const struct dwp_hash_table
*cus
= nullptr;
740 /* Table of TUs in the file. */
741 const struct dwp_hash_table
*tus
= nullptr;
743 /* Tables of loaded CUs/TUs. Each entry is a struct dwo_unit *. */
747 /* Table to map ELF section numbers to their sections.
748 This is only needed for the DWP V1 file format. */
749 unsigned int num_sections
= 0;
750 asection
**elf_sections
= nullptr;
753 /* Struct used to pass misc. parameters to read_die_and_children, et
754 al. which are used for both .debug_info and .debug_types dies.
755 All parameters here are unchanging for the life of the call. This
756 struct exists to abstract away the constant parameters of die reading. */
758 struct die_reader_specs
760 /* The bfd of die_section. */
763 /* The CU of the DIE we are parsing. */
764 struct dwarf2_cu
*cu
;
766 /* Non-NULL if reading a DWO file (including one packaged into a DWP). */
767 struct dwo_file
*dwo_file
;
769 /* The section the die comes from.
770 This is either .debug_info or .debug_types, or the .dwo variants. */
771 struct dwarf2_section_info
*die_section
;
773 /* die_section->buffer. */
774 const gdb_byte
*buffer
;
776 /* The end of the buffer. */
777 const gdb_byte
*buffer_end
;
779 /* The abbreviation table to use when reading the DIEs. */
780 struct abbrev_table
*abbrev_table
;
783 /* A subclass of die_reader_specs that holds storage and has complex
784 constructor and destructor behavior. */
786 class cutu_reader
: public die_reader_specs
790 cutu_reader (dwarf2_per_cu_data
*this_cu
,
791 dwarf2_per_objfile
*per_objfile
,
792 struct abbrev_table
*abbrev_table
,
793 dwarf2_cu
*existing_cu
,
796 explicit cutu_reader (struct dwarf2_per_cu_data
*this_cu
,
797 dwarf2_per_objfile
*per_objfile
,
798 struct dwarf2_cu
*parent_cu
= nullptr,
799 struct dwo_file
*dwo_file
= nullptr);
801 DISABLE_COPY_AND_ASSIGN (cutu_reader
);
803 const gdb_byte
*info_ptr
= nullptr;
804 struct die_info
*comp_unit_die
= nullptr;
805 bool dummy_p
= false;
807 /* Release the new CU, putting it on the chain. This cannot be done
812 void init_tu_and_read_dwo_dies (dwarf2_per_cu_data
*this_cu
,
813 dwarf2_per_objfile
*per_objfile
,
814 dwarf2_cu
*existing_cu
);
816 struct dwarf2_per_cu_data
*m_this_cu
;
817 std::unique_ptr
<dwarf2_cu
> m_new_cu
;
819 /* The ordinary abbreviation table. */
820 abbrev_table_up m_abbrev_table_holder
;
822 /* The DWO abbreviation table. */
823 abbrev_table_up m_dwo_abbrev_table
;
826 /* When we construct a partial symbol table entry we only
827 need this much information. */
828 struct partial_die_info
: public allocate_on_obstack
830 partial_die_info (sect_offset sect_off
, const struct abbrev_info
*abbrev
);
832 /* Disable assign but still keep copy ctor, which is needed
833 load_partial_dies. */
834 partial_die_info
& operator=(const partial_die_info
& rhs
) = delete;
835 partial_die_info (const partial_die_info
&) = default;
837 /* Adjust the partial die before generating a symbol for it. This
838 function may set the is_external flag or change the DIE's
840 void fixup (struct dwarf2_cu
*cu
);
842 /* Read a minimal amount of information into the minimal die
844 const gdb_byte
*read (const struct die_reader_specs
*reader
,
845 const struct abbrev_info
&abbrev
,
846 const gdb_byte
*info_ptr
);
848 /* Compute the name of this partial DIE. This memoizes the
849 result, so it is safe to call multiple times. */
850 const char *name (dwarf2_cu
*cu
);
852 /* Offset of this DIE. */
853 const sect_offset sect_off
;
855 /* DWARF-2 tag for this DIE. */
856 const ENUM_BITFIELD(dwarf_tag
) tag
: 16;
858 /* Assorted flags describing the data found in this DIE. */
859 const unsigned int has_children
: 1;
861 unsigned int is_external
: 1;
862 unsigned int is_declaration
: 1;
863 unsigned int has_type
: 1;
864 unsigned int has_specification
: 1;
865 unsigned int has_pc_info
: 1;
866 unsigned int may_be_inlined
: 1;
868 /* This DIE has been marked DW_AT_main_subprogram. */
869 unsigned int main_subprogram
: 1;
871 /* Flag set if the SCOPE field of this structure has been
873 unsigned int scope_set
: 1;
875 /* Flag set if the DIE has a byte_size attribute. */
876 unsigned int has_byte_size
: 1;
878 /* Flag set if the DIE has a DW_AT_const_value attribute. */
879 unsigned int has_const_value
: 1;
881 /* Flag set if any of the DIE's children are template arguments. */
882 unsigned int has_template_arguments
: 1;
884 /* Flag set if fixup has been called on this die. */
885 unsigned int fixup_called
: 1;
887 /* Flag set if DW_TAG_imported_unit uses DW_FORM_GNU_ref_alt. */
888 unsigned int is_dwz
: 1;
890 /* Flag set if spec_offset uses DW_FORM_GNU_ref_alt. */
891 unsigned int spec_is_dwz
: 1;
893 unsigned int canonical_name
: 1;
895 /* The name of this DIE. Normally the value of DW_AT_name, but
896 sometimes a default name for unnamed DIEs. */
897 const char *raw_name
= nullptr;
899 /* The linkage name, if present. */
900 const char *linkage_name
= nullptr;
902 /* The scope to prepend to our children. This is generally
903 allocated on the comp_unit_obstack, so will disappear
904 when this compilation unit leaves the cache. */
905 const char *scope
= nullptr;
907 /* Some data associated with the partial DIE. The tag determines
908 which field is live. */
911 /* The location description associated with this DIE, if any. */
912 struct dwarf_block
*locdesc
;
913 /* The offset of an import, for DW_TAG_imported_unit. */
914 sect_offset sect_off
;
917 /* If HAS_PC_INFO, the PC range associated with this DIE. */
919 CORE_ADDR highpc
= 0;
921 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
922 DW_AT_sibling, if any. */
923 /* NOTE: This member isn't strictly necessary, partial_die_info::read
924 could return DW_AT_sibling values to its caller load_partial_dies. */
925 const gdb_byte
*sibling
= nullptr;
927 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
928 DW_AT_specification (or DW_AT_abstract_origin or
930 sect_offset spec_offset
{};
932 /* Pointers to this DIE's parent, first child, and next sibling,
934 struct partial_die_info
*die_parent
= nullptr;
935 struct partial_die_info
*die_child
= nullptr;
936 struct partial_die_info
*die_sibling
= nullptr;
938 friend struct partial_die_info
*
939 dwarf2_cu::find_partial_die (sect_offset sect_off
);
942 /* Only need to do look up in dwarf2_cu::find_partial_die. */
943 partial_die_info (sect_offset sect_off
)
944 : partial_die_info (sect_off
, DW_TAG_padding
, 0)
948 partial_die_info (sect_offset sect_off_
, enum dwarf_tag tag_
,
950 : sect_off (sect_off_
), tag (tag_
), has_children (has_children_
)
955 has_specification
= 0;
962 has_template_arguments
= 0;
970 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
971 but this would require a corresponding change in unpack_field_as_long
973 static int bits_per_byte
= 8;
975 struct variant_part_builder
;
977 /* When reading a variant, we track a bit more information about the
978 field, and store it in an object of this type. */
982 int first_field
= -1;
985 /* A variant can contain other variant parts. */
986 std::vector
<variant_part_builder
> variant_parts
;
988 /* If we see a DW_TAG_variant, then this will be set if this is the
990 bool default_branch
= false;
991 /* If we see a DW_AT_discr_value, then this will be the discriminant
993 ULONGEST discriminant_value
= 0;
994 /* If we see a DW_AT_discr_list, then this is a pointer to the list
996 struct dwarf_block
*discr_list_data
= nullptr;
999 /* This represents a DW_TAG_variant_part. */
1001 struct variant_part_builder
1003 /* The offset of the discriminant field. */
1004 sect_offset discriminant_offset
{};
1006 /* Variants that are direct children of this variant part. */
1007 std::vector
<variant_field
> variants
;
1009 /* True if we're currently reading a variant. */
1010 bool processing_variant
= false;
1015 int accessibility
= 0;
1017 /* Variant parts need to find the discriminant, which is a DIE
1018 reference. We track the section offset of each field to make
1021 struct field field
{};
1026 const char *name
= nullptr;
1027 std::vector
<struct fn_field
> fnfields
;
1030 /* The routines that read and process dies for a C struct or C++ class
1031 pass lists of data member fields and lists of member function fields
1032 in an instance of a field_info structure, as defined below. */
1035 /* List of data member and baseclasses fields. */
1036 std::vector
<struct nextfield
> fields
;
1037 std::vector
<struct nextfield
> baseclasses
;
1039 /* Set if the accessibility of one of the fields is not public. */
1040 bool non_public_fields
= false;
1042 /* Member function fieldlist array, contains name of possibly overloaded
1043 member function, number of overloaded member functions and a pointer
1044 to the head of the member function field chain. */
1045 std::vector
<struct fnfieldlist
> fnfieldlists
;
1047 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
1048 a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
1049 std::vector
<struct decl_field
> typedef_field_list
;
1051 /* Nested types defined by this class and the number of elements in this
1053 std::vector
<struct decl_field
> nested_types_list
;
1055 /* If non-null, this is the variant part we are currently
1057 variant_part_builder
*current_variant_part
= nullptr;
1058 /* This holds all the top-level variant parts attached to the type
1060 std::vector
<variant_part_builder
> variant_parts
;
1062 /* Return the total number of fields (including baseclasses). */
1063 int nfields () const
1065 return fields
.size () + baseclasses
.size ();
1069 /* Loaded secondary compilation units are kept in memory until they
1070 have not been referenced for the processing of this many
1071 compilation units. Set this to zero to disable caching. Cache
1072 sizes of up to at least twenty will improve startup time for
1073 typical inter-CU-reference binaries, at an obvious memory cost. */
1074 static int dwarf_max_cache_age
= 5;
1076 show_dwarf_max_cache_age (struct ui_file
*file
, int from_tty
,
1077 struct cmd_list_element
*c
, const char *value
)
1079 fprintf_filtered (file
, _("The upper bound on the age of cached "
1080 "DWARF compilation units is %s.\n"),
1084 /* local function prototypes */
1086 static void dwarf2_find_base_address (struct die_info
*die
,
1087 struct dwarf2_cu
*cu
);
1089 static dwarf2_psymtab
*create_partial_symtab
1090 (dwarf2_per_cu_data
*per_cu
, dwarf2_per_objfile
*per_objfile
,
1093 static void build_type_psymtabs_reader (const struct die_reader_specs
*reader
,
1094 const gdb_byte
*info_ptr
,
1095 struct die_info
*type_unit_die
);
1097 static void dwarf2_build_psymtabs_hard (dwarf2_per_objfile
*per_objfile
);
1099 static void scan_partial_symbols (struct partial_die_info
*,
1100 CORE_ADDR
*, CORE_ADDR
*,
1101 int, struct dwarf2_cu
*);
1103 static void add_partial_symbol (struct partial_die_info
*,
1104 struct dwarf2_cu
*);
1106 static void add_partial_namespace (struct partial_die_info
*pdi
,
1107 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1108 int set_addrmap
, struct dwarf2_cu
*cu
);
1110 static void add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
1111 CORE_ADDR
*highpc
, int set_addrmap
,
1112 struct dwarf2_cu
*cu
);
1114 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
1115 struct dwarf2_cu
*cu
);
1117 static void add_partial_subprogram (struct partial_die_info
*pdi
,
1118 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1119 int need_pc
, struct dwarf2_cu
*cu
);
1121 static unsigned int peek_abbrev_code (bfd
*, const gdb_byte
*);
1123 static struct partial_die_info
*load_partial_dies
1124 (const struct die_reader_specs
*, const gdb_byte
*, int);
1126 /* A pair of partial_die_info and compilation unit. */
1127 struct cu_partial_die_info
1129 /* The compilation unit of the partial_die_info. */
1130 struct dwarf2_cu
*cu
;
1131 /* A partial_die_info. */
1132 struct partial_die_info
*pdi
;
1134 cu_partial_die_info (struct dwarf2_cu
*cu
, struct partial_die_info
*pdi
)
1140 cu_partial_die_info () = delete;
1143 static const struct cu_partial_die_info
find_partial_die (sect_offset
, int,
1144 struct dwarf2_cu
*);
1146 static const gdb_byte
*read_attribute (const struct die_reader_specs
*,
1148 const struct attr_abbrev
*,
1151 static void read_attribute_reprocess (const struct die_reader_specs
*reader
,
1152 struct attribute
*attr
, dwarf_tag tag
);
1154 static CORE_ADDR
read_addr_index (struct dwarf2_cu
*cu
, unsigned int addr_index
);
1156 static sect_offset
read_abbrev_offset (dwarf2_per_objfile
*per_objfile
,
1157 dwarf2_section_info
*, sect_offset
);
1159 static const char *read_indirect_string
1160 (dwarf2_per_objfile
*per_objfile
, bfd
*, const gdb_byte
*,
1161 const struct comp_unit_head
*, unsigned int *);
1163 static const char *read_indirect_string_at_offset
1164 (dwarf2_per_objfile
*per_objfile
, LONGEST str_offset
);
1166 static CORE_ADDR
read_addr_index_from_leb128 (struct dwarf2_cu
*,
1170 static const char *read_dwo_str_index (const struct die_reader_specs
*reader
,
1171 ULONGEST str_index
);
1173 static const char *read_stub_str_index (struct dwarf2_cu
*cu
,
1174 ULONGEST str_index
);
1176 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
1177 struct dwarf2_cu
*);
1179 static const char *dwarf2_string_attr (struct die_info
*die
, unsigned int name
,
1180 struct dwarf2_cu
*cu
);
1182 static const char *dwarf2_dwo_name (struct die_info
*die
, struct dwarf2_cu
*cu
);
1184 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
1185 struct dwarf2_cu
*cu
);
1187 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
1189 static struct die_info
*die_specification (struct die_info
*die
,
1190 struct dwarf2_cu
**);
1192 static line_header_up
dwarf_decode_line_header (sect_offset sect_off
,
1193 struct dwarf2_cu
*cu
);
1195 static void dwarf_decode_lines (struct line_header
*, const char *,
1196 struct dwarf2_cu
*, dwarf2_psymtab
*,
1197 CORE_ADDR
, int decode_mapping
);
1199 static void dwarf2_start_subfile (struct dwarf2_cu
*, const char *,
1202 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
1203 struct dwarf2_cu
*, struct symbol
* = NULL
);
1205 static void dwarf2_const_value (const struct attribute
*, struct symbol
*,
1206 struct dwarf2_cu
*);
1208 static void dwarf2_const_value_attr (const struct attribute
*attr
,
1211 struct obstack
*obstack
,
1212 struct dwarf2_cu
*cu
, LONGEST
*value
,
1213 const gdb_byte
**bytes
,
1214 struct dwarf2_locexpr_baton
**baton
);
1216 static struct type
*read_subrange_index_type (struct die_info
*die
,
1217 struct dwarf2_cu
*cu
);
1219 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
1221 static int need_gnat_info (struct dwarf2_cu
*);
1223 static struct type
*die_descriptive_type (struct die_info
*,
1224 struct dwarf2_cu
*);
1226 static void set_descriptive_type (struct type
*, struct die_info
*,
1227 struct dwarf2_cu
*);
1229 static struct type
*die_containing_type (struct die_info
*,
1230 struct dwarf2_cu
*);
1232 static struct type
*lookup_die_type (struct die_info
*, const struct attribute
*,
1233 struct dwarf2_cu
*);
1235 static struct type
*read_type_die (struct die_info
*, struct dwarf2_cu
*);
1237 static struct type
*read_type_die_1 (struct die_info
*, struct dwarf2_cu
*);
1239 static const char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
1241 static char *typename_concat (struct obstack
*obs
, const char *prefix
,
1242 const char *suffix
, int physname
,
1243 struct dwarf2_cu
*cu
);
1245 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
1247 static void read_type_unit_scope (struct die_info
*, struct dwarf2_cu
*);
1249 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
1251 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
1253 static void read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
);
1255 static void read_variable (struct die_info
*die
, struct dwarf2_cu
*cu
);
1257 /* Return the .debug_loclists section to use for cu. */
1258 static struct dwarf2_section_info
*cu_debug_loc_section (struct dwarf2_cu
*cu
);
1260 /* Return the .debug_rnglists section to use for cu. */
1261 static struct dwarf2_section_info
*cu_debug_rnglists_section
1262 (struct dwarf2_cu
*cu
, dwarf_tag tag
);
1264 /* How dwarf2_get_pc_bounds constructed its *LOWPC and *HIGHPC return
1265 values. Keep the items ordered with increasing constraints compliance. */
1268 /* No attribute DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges was found. */
1269 PC_BOUNDS_NOT_PRESENT
,
1271 /* Some of the attributes DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges
1272 were present but they do not form a valid range of PC addresses. */
1275 /* Discontiguous range was found - that is DW_AT_ranges was found. */
1278 /* Contiguous range was found - DW_AT_low_pc and DW_AT_high_pc were found. */
1282 static enum pc_bounds_kind
dwarf2_get_pc_bounds (struct die_info
*,
1283 CORE_ADDR
*, CORE_ADDR
*,
1287 static void get_scope_pc_bounds (struct die_info
*,
1288 CORE_ADDR
*, CORE_ADDR
*,
1289 struct dwarf2_cu
*);
1291 static void dwarf2_record_block_ranges (struct die_info
*, struct block
*,
1292 CORE_ADDR
, struct dwarf2_cu
*);
1294 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
1295 struct dwarf2_cu
*);
1297 static void dwarf2_attach_fields_to_type (struct field_info
*,
1298 struct type
*, struct dwarf2_cu
*);
1300 static void dwarf2_add_member_fn (struct field_info
*,
1301 struct die_info
*, struct type
*,
1302 struct dwarf2_cu
*);
1304 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
1306 struct dwarf2_cu
*);
1308 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
1310 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
1312 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
1314 static void read_module (struct die_info
*die
, struct dwarf2_cu
*cu
);
1316 static struct using_direct
**using_directives (struct dwarf2_cu
*cu
);
1318 static void read_import_statement (struct die_info
*die
, struct dwarf2_cu
*);
1320 static int read_namespace_alias (struct die_info
*die
, struct dwarf2_cu
*cu
);
1322 static struct type
*read_module_type (struct die_info
*die
,
1323 struct dwarf2_cu
*cu
);
1325 static const char *namespace_name (struct die_info
*die
,
1326 int *is_anonymous
, struct dwarf2_cu
*);
1328 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
1330 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*,
1333 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
1334 struct dwarf2_cu
*);
1336 static struct die_info
*read_die_and_siblings_1
1337 (const struct die_reader_specs
*, const gdb_byte
*, const gdb_byte
**,
1340 static struct die_info
*read_die_and_siblings (const struct die_reader_specs
*,
1341 const gdb_byte
*info_ptr
,
1342 const gdb_byte
**new_info_ptr
,
1343 struct die_info
*parent
);
1345 static const gdb_byte
*read_full_die_1 (const struct die_reader_specs
*,
1346 struct die_info
**, const gdb_byte
*,
1349 static const gdb_byte
*read_full_die (const struct die_reader_specs
*,
1350 struct die_info
**, const gdb_byte
*);
1352 static void process_die (struct die_info
*, struct dwarf2_cu
*);
1354 static const char *dwarf2_canonicalize_name (const char *, struct dwarf2_cu
*,
1357 static const char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
1359 static const char *dwarf2_full_name (const char *name
,
1360 struct die_info
*die
,
1361 struct dwarf2_cu
*cu
);
1363 static const char *dwarf2_physname (const char *name
, struct die_info
*die
,
1364 struct dwarf2_cu
*cu
);
1366 static struct die_info
*dwarf2_extension (struct die_info
*die
,
1367 struct dwarf2_cu
**);
1369 static void dump_die_shallow (struct ui_file
*, int indent
, struct die_info
*);
1371 static void dump_die_for_error (struct die_info
*);
1373 static void dump_die_1 (struct ui_file
*, int level
, int max_level
,
1376 /*static*/ void dump_die (struct die_info
*, int max_level
);
1378 static void store_in_ref_table (struct die_info
*,
1379 struct dwarf2_cu
*);
1381 static struct die_info
*follow_die_ref_or_sig (struct die_info
*,
1382 const struct attribute
*,
1383 struct dwarf2_cu
**);
1385 static struct die_info
*follow_die_ref (struct die_info
*,
1386 const struct attribute
*,
1387 struct dwarf2_cu
**);
1389 static struct die_info
*follow_die_sig (struct die_info
*,
1390 const struct attribute
*,
1391 struct dwarf2_cu
**);
1393 static struct type
*get_signatured_type (struct die_info
*, ULONGEST
,
1394 struct dwarf2_cu
*);
1396 static struct type
*get_DW_AT_signature_type (struct die_info
*,
1397 const struct attribute
*,
1398 struct dwarf2_cu
*);
1400 static void load_full_type_unit (dwarf2_per_cu_data
*per_cu
,
1401 dwarf2_per_objfile
*per_objfile
);
1403 static void read_signatured_type (signatured_type
*sig_type
,
1404 dwarf2_per_objfile
*per_objfile
);
1406 static int attr_to_dynamic_prop (const struct attribute
*attr
,
1407 struct die_info
*die
, struct dwarf2_cu
*cu
,
1408 struct dynamic_prop
*prop
, struct type
*type
);
1410 /* memory allocation interface */
1412 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1414 static struct die_info
*dwarf_alloc_die (struct dwarf2_cu
*, int);
1416 static void dwarf_decode_macros (struct dwarf2_cu
*, unsigned int, int);
1418 static void fill_in_loclist_baton (struct dwarf2_cu
*cu
,
1419 struct dwarf2_loclist_baton
*baton
,
1420 const struct attribute
*attr
);
1422 static void dwarf2_symbol_mark_computed (const struct attribute
*attr
,
1424 struct dwarf2_cu
*cu
,
1427 static const gdb_byte
*skip_one_die (const struct die_reader_specs
*reader
,
1428 const gdb_byte
*info_ptr
,
1429 const struct abbrev_info
*abbrev
);
1431 static hashval_t
partial_die_hash (const void *item
);
1433 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1435 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1436 (sect_offset sect_off
, unsigned int offset_in_dwz
,
1437 dwarf2_per_objfile
*per_objfile
);
1439 static void prepare_one_comp_unit (struct dwarf2_cu
*cu
,
1440 struct die_info
*comp_unit_die
,
1441 enum language pretend_language
);
1443 static struct type
*set_die_type (struct die_info
*, struct type
*,
1444 struct dwarf2_cu
*, bool = false);
1446 static void create_all_comp_units (dwarf2_per_objfile
*per_objfile
);
1448 static void load_full_comp_unit (dwarf2_per_cu_data
*per_cu
,
1449 dwarf2_per_objfile
*per_objfile
,
1450 dwarf2_cu
*existing_cu
,
1452 enum language pretend_language
);
1454 static void process_full_comp_unit (dwarf2_cu
*cu
,
1455 enum language pretend_language
);
1457 static void process_full_type_unit (dwarf2_cu
*cu
,
1458 enum language pretend_language
);
1460 static struct type
*get_die_type_at_offset (sect_offset
,
1461 dwarf2_per_cu_data
*per_cu
,
1462 dwarf2_per_objfile
*per_objfile
);
1464 static struct type
*get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
1466 static void queue_comp_unit (dwarf2_per_cu_data
*per_cu
,
1467 dwarf2_per_objfile
*per_objfile
,
1468 enum language pretend_language
);
1470 static void process_queue (dwarf2_per_objfile
*per_objfile
);
1472 /* Class, the destructor of which frees all allocated queue entries. This
1473 will only have work to do if an error was thrown while processing the
1474 dwarf. If no error was thrown then the queue entries should have all
1475 been processed, and freed, as we went along. */
1477 class dwarf2_queue_guard
1480 explicit dwarf2_queue_guard (dwarf2_per_objfile
*per_objfile
)
1481 : m_per_objfile (per_objfile
)
1483 gdb_assert (!m_per_objfile
->per_bfd
->queue
.has_value ());
1485 m_per_objfile
->per_bfd
->queue
.emplace ();
1488 /* Free any entries remaining on the queue. There should only be
1489 entries left if we hit an error while processing the dwarf. */
1490 ~dwarf2_queue_guard ()
1492 gdb_assert (m_per_objfile
->per_bfd
->queue
.has_value ());
1494 m_per_objfile
->per_bfd
->queue
.reset ();
1497 DISABLE_COPY_AND_ASSIGN (dwarf2_queue_guard
);
1500 dwarf2_per_objfile
*m_per_objfile
;
1503 dwarf2_queue_item::~dwarf2_queue_item ()
1505 /* Anything still marked queued is likely to be in an
1506 inconsistent state, so discard it. */
1509 per_objfile
->remove_cu (per_cu
);
1514 /* See dwarf2/read.h. */
1517 dwarf2_per_cu_data_deleter::operator() (dwarf2_per_cu_data
*data
)
1519 if (data
->is_debug_types
)
1520 delete static_cast<signatured_type
*> (data
);
1525 /* The return type of find_file_and_directory. Note, the enclosed
1526 string pointers are only valid while this object is valid. */
1528 struct file_and_directory
1530 /* The filename. This is never NULL. */
1533 /* The compilation directory. NULL if not known. If we needed to
1534 compute a new string, this points to COMP_DIR_STORAGE, otherwise,
1535 points directly to the DW_AT_comp_dir string attribute owned by
1536 the obstack that owns the DIE. */
1537 const char *comp_dir
;
1539 /* If we needed to build a new string for comp_dir, this is what
1540 owns the storage. */
1541 std::string comp_dir_storage
;
1544 static file_and_directory
find_file_and_directory (struct die_info
*die
,
1545 struct dwarf2_cu
*cu
);
1547 static htab_up
allocate_signatured_type_table ();
1549 static htab_up
allocate_dwo_unit_table ();
1551 static struct dwo_unit
*lookup_dwo_unit_in_dwp
1552 (dwarf2_per_objfile
*per_objfile
, struct dwp_file
*dwp_file
,
1553 const char *comp_dir
, ULONGEST signature
, int is_debug_types
);
1555 static struct dwp_file
*get_dwp_file (dwarf2_per_objfile
*per_objfile
);
1557 static struct dwo_unit
*lookup_dwo_comp_unit
1558 (dwarf2_cu
*cu
, const char *dwo_name
, const char *comp_dir
,
1559 ULONGEST signature
);
1561 static struct dwo_unit
*lookup_dwo_type_unit
1562 (dwarf2_cu
*cu
, const char *dwo_name
, const char *comp_dir
);
1564 static void queue_and_load_all_dwo_tus (dwarf2_cu
*cu
);
1566 /* A unique pointer to a dwo_file. */
1568 typedef std::unique_ptr
<struct dwo_file
> dwo_file_up
;
1570 static void process_cu_includes (dwarf2_per_objfile
*per_objfile
);
1572 static void check_producer (struct dwarf2_cu
*cu
);
1574 /* Various complaints about symbol reading that don't abort the process. */
1577 dwarf2_debug_line_missing_file_complaint (void)
1579 complaint (_(".debug_line section has line data without a file"));
1583 dwarf2_debug_line_missing_end_sequence_complaint (void)
1585 complaint (_(".debug_line section has line "
1586 "program sequence without an end"));
1590 dwarf2_complex_location_expr_complaint (void)
1592 complaint (_("location expression too complex"));
1596 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
1599 complaint (_("const value length mismatch for '%s', got %d, expected %d"),
1604 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
1606 complaint (_("invalid attribute class or form for '%s' in '%s'"),
1610 /* Hash function for line_header_hash. */
1613 line_header_hash (const struct line_header
*ofs
)
1615 return to_underlying (ofs
->sect_off
) ^ ofs
->offset_in_dwz
;
1618 /* Hash function for htab_create_alloc_ex for line_header_hash. */
1621 line_header_hash_voidp (const void *item
)
1623 const struct line_header
*ofs
= (const struct line_header
*) item
;
1625 return line_header_hash (ofs
);
1628 /* Equality function for line_header_hash. */
1631 line_header_eq_voidp (const void *item_lhs
, const void *item_rhs
)
1633 const struct line_header
*ofs_lhs
= (const struct line_header
*) item_lhs
;
1634 const struct line_header
*ofs_rhs
= (const struct line_header
*) item_rhs
;
1636 return (ofs_lhs
->sect_off
== ofs_rhs
->sect_off
1637 && ofs_lhs
->offset_in_dwz
== ofs_rhs
->offset_in_dwz
);
1642 /* See declaration. */
1644 dwarf2_per_bfd::dwarf2_per_bfd (bfd
*obfd
, const dwarf2_debug_sections
*names
,
1647 can_copy (can_copy_
)
1650 names
= &dwarf2_elf_names
;
1652 for (asection
*sec
= obfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
1653 locate_sections (obfd
, sec
, *names
);
1656 dwarf2_per_bfd::~dwarf2_per_bfd ()
1658 for (auto &per_cu
: all_comp_units
)
1659 per_cu
->imported_symtabs_free ();
1661 /* Everything else should be on this->obstack. */
1667 dwarf2_per_objfile::remove_all_cus ()
1669 gdb_assert (!this->per_bfd
->queue
.has_value ());
1671 for (auto pair
: m_dwarf2_cus
)
1674 m_dwarf2_cus
.clear ();
1677 /* A helper class that calls free_cached_comp_units on
1680 class free_cached_comp_units
1684 explicit free_cached_comp_units (dwarf2_per_objfile
*per_objfile
)
1685 : m_per_objfile (per_objfile
)
1689 ~free_cached_comp_units ()
1691 m_per_objfile
->remove_all_cus ();
1694 DISABLE_COPY_AND_ASSIGN (free_cached_comp_units
);
1698 dwarf2_per_objfile
*m_per_objfile
;
1704 dwarf2_per_objfile::symtab_set_p (const dwarf2_per_cu_data
*per_cu
) const
1706 gdb_assert (per_cu
->index
< this->m_symtabs
.size ());
1708 return this->m_symtabs
[per_cu
->index
] != nullptr;
1714 dwarf2_per_objfile::get_symtab (const dwarf2_per_cu_data
*per_cu
) const
1716 gdb_assert (per_cu
->index
< this->m_symtabs
.size ());
1718 return this->m_symtabs
[per_cu
->index
];
1724 dwarf2_per_objfile::set_symtab (const dwarf2_per_cu_data
*per_cu
,
1725 compunit_symtab
*symtab
)
1727 gdb_assert (per_cu
->index
< this->m_symtabs
.size ());
1728 gdb_assert (this->m_symtabs
[per_cu
->index
] == nullptr);
1730 this->m_symtabs
[per_cu
->index
] = symtab
;
1733 /* Try to locate the sections we need for DWARF 2 debugging
1734 information and return true if we have enough to do something.
1735 NAMES points to the dwarf2 section names, or is NULL if the standard
1736 ELF names are used. CAN_COPY is true for formats where symbol
1737 interposition is possible and so symbol values must follow copy
1738 relocation rules. */
1741 dwarf2_has_info (struct objfile
*objfile
,
1742 const struct dwarf2_debug_sections
*names
,
1745 if (objfile
->flags
& OBJF_READNEVER
)
1748 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
1750 if (per_objfile
== NULL
)
1752 dwarf2_per_bfd
*per_bfd
;
1754 /* We can share a "dwarf2_per_bfd" with other objfiles if the
1755 BFD doesn't require relocations.
1757 We don't share with objfiles for which -readnow was requested,
1758 because it would complicate things when loading the same BFD with
1759 -readnow and then without -readnow. */
1760 if (!gdb_bfd_requires_relocations (objfile
->obfd
)
1761 && (objfile
->flags
& OBJF_READNOW
) == 0)
1763 /* See if one has been created for this BFD yet. */
1764 per_bfd
= dwarf2_per_bfd_bfd_data_key
.get (objfile
->obfd
);
1766 if (per_bfd
== nullptr)
1768 /* No, create it now. */
1769 per_bfd
= new dwarf2_per_bfd (objfile
->obfd
, names
, can_copy
);
1770 dwarf2_per_bfd_bfd_data_key
.set (objfile
->obfd
, per_bfd
);
1775 /* No sharing possible, create one specifically for this objfile. */
1776 per_bfd
= new dwarf2_per_bfd (objfile
->obfd
, names
, can_copy
);
1777 dwarf2_per_bfd_objfile_data_key
.set (objfile
, per_bfd
);
1780 per_objfile
= dwarf2_objfile_data_key
.emplace (objfile
, objfile
, per_bfd
);
1783 return (!per_objfile
->per_bfd
->info
.is_virtual
1784 && per_objfile
->per_bfd
->info
.s
.section
!= NULL
1785 && !per_objfile
->per_bfd
->abbrev
.is_virtual
1786 && per_objfile
->per_bfd
->abbrev
.s
.section
!= NULL
);
1789 /* See declaration. */
1792 dwarf2_per_bfd::locate_sections (bfd
*abfd
, asection
*sectp
,
1793 const dwarf2_debug_sections
&names
)
1795 flagword aflag
= bfd_section_flags (sectp
);
1797 if ((aflag
& SEC_HAS_CONTENTS
) == 0)
1800 else if (elf_section_data (sectp
)->this_hdr
.sh_size
1801 > bfd_get_file_size (abfd
))
1803 bfd_size_type size
= elf_section_data (sectp
)->this_hdr
.sh_size
;
1804 warning (_("Discarding section %s which has a section size (%s"
1805 ") larger than the file size [in module %s]"),
1806 bfd_section_name (sectp
), phex_nz (size
, sizeof (size
)),
1807 bfd_get_filename (abfd
));
1809 else if (names
.info
.matches (sectp
->name
))
1811 this->info
.s
.section
= sectp
;
1812 this->info
.size
= bfd_section_size (sectp
);
1814 else if (names
.abbrev
.matches (sectp
->name
))
1816 this->abbrev
.s
.section
= sectp
;
1817 this->abbrev
.size
= bfd_section_size (sectp
);
1819 else if (names
.line
.matches (sectp
->name
))
1821 this->line
.s
.section
= sectp
;
1822 this->line
.size
= bfd_section_size (sectp
);
1824 else if (names
.loc
.matches (sectp
->name
))
1826 this->loc
.s
.section
= sectp
;
1827 this->loc
.size
= bfd_section_size (sectp
);
1829 else if (names
.loclists
.matches (sectp
->name
))
1831 this->loclists
.s
.section
= sectp
;
1832 this->loclists
.size
= bfd_section_size (sectp
);
1834 else if (names
.macinfo
.matches (sectp
->name
))
1836 this->macinfo
.s
.section
= sectp
;
1837 this->macinfo
.size
= bfd_section_size (sectp
);
1839 else if (names
.macro
.matches (sectp
->name
))
1841 this->macro
.s
.section
= sectp
;
1842 this->macro
.size
= bfd_section_size (sectp
);
1844 else if (names
.str
.matches (sectp
->name
))
1846 this->str
.s
.section
= sectp
;
1847 this->str
.size
= bfd_section_size (sectp
);
1849 else if (names
.str_offsets
.matches (sectp
->name
))
1851 this->str_offsets
.s
.section
= sectp
;
1852 this->str_offsets
.size
= bfd_section_size (sectp
);
1854 else if (names
.line_str
.matches (sectp
->name
))
1856 this->line_str
.s
.section
= sectp
;
1857 this->line_str
.size
= bfd_section_size (sectp
);
1859 else if (names
.addr
.matches (sectp
->name
))
1861 this->addr
.s
.section
= sectp
;
1862 this->addr
.size
= bfd_section_size (sectp
);
1864 else if (names
.frame
.matches (sectp
->name
))
1866 this->frame
.s
.section
= sectp
;
1867 this->frame
.size
= bfd_section_size (sectp
);
1869 else if (names
.eh_frame
.matches (sectp
->name
))
1871 this->eh_frame
.s
.section
= sectp
;
1872 this->eh_frame
.size
= bfd_section_size (sectp
);
1874 else if (names
.ranges
.matches (sectp
->name
))
1876 this->ranges
.s
.section
= sectp
;
1877 this->ranges
.size
= bfd_section_size (sectp
);
1879 else if (names
.rnglists
.matches (sectp
->name
))
1881 this->rnglists
.s
.section
= sectp
;
1882 this->rnglists
.size
= bfd_section_size (sectp
);
1884 else if (names
.types
.matches (sectp
->name
))
1886 struct dwarf2_section_info type_section
;
1888 memset (&type_section
, 0, sizeof (type_section
));
1889 type_section
.s
.section
= sectp
;
1890 type_section
.size
= bfd_section_size (sectp
);
1892 this->types
.push_back (type_section
);
1894 else if (names
.gdb_index
.matches (sectp
->name
))
1896 this->gdb_index
.s
.section
= sectp
;
1897 this->gdb_index
.size
= bfd_section_size (sectp
);
1899 else if (names
.debug_names
.matches (sectp
->name
))
1901 this->debug_names
.s
.section
= sectp
;
1902 this->debug_names
.size
= bfd_section_size (sectp
);
1904 else if (names
.debug_aranges
.matches (sectp
->name
))
1906 this->debug_aranges
.s
.section
= sectp
;
1907 this->debug_aranges
.size
= bfd_section_size (sectp
);
1910 if ((bfd_section_flags (sectp
) & (SEC_LOAD
| SEC_ALLOC
))
1911 && bfd_section_vma (sectp
) == 0)
1912 this->has_section_at_zero
= true;
1915 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
1919 dwarf2_get_section_info (struct objfile
*objfile
,
1920 enum dwarf2_section_enum sect
,
1921 asection
**sectp
, const gdb_byte
**bufp
,
1922 bfd_size_type
*sizep
)
1924 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
1925 struct dwarf2_section_info
*info
;
1927 /* We may see an objfile without any DWARF, in which case we just
1929 if (per_objfile
== NULL
)
1938 case DWARF2_DEBUG_FRAME
:
1939 info
= &per_objfile
->per_bfd
->frame
;
1941 case DWARF2_EH_FRAME
:
1942 info
= &per_objfile
->per_bfd
->eh_frame
;
1945 gdb_assert_not_reached ("unexpected section");
1948 info
->read (objfile
);
1950 *sectp
= info
->get_bfd_section ();
1951 *bufp
= info
->buffer
;
1952 *sizep
= info
->size
;
1956 /* DWARF quick_symbol_functions support. */
1958 /* TUs can share .debug_line entries, and there can be a lot more TUs than
1959 unique line tables, so we maintain a separate table of all .debug_line
1960 derived entries to support the sharing.
1961 All the quick functions need is the list of file names. We discard the
1962 line_header when we're done and don't need to record it here. */
1963 struct quick_file_names
1965 /* The data used to construct the hash key. */
1966 struct stmt_list_hash hash
;
1968 /* The number of entries in file_names, real_names. */
1969 unsigned int num_file_names
;
1971 /* The file names from the line table, after being run through
1973 const char **file_names
;
1975 /* The file names from the line table after being run through
1976 gdb_realpath. These are computed lazily. */
1977 const char **real_names
;
1980 /* When using the index (and thus not using psymtabs), each CU has an
1981 object of this type. This is used to hold information needed by
1982 the various "quick" methods. */
1983 struct dwarf2_per_cu_quick_data
1985 /* The file table. This can be NULL if there was no file table
1986 or it's currently not read in.
1987 NOTE: This points into dwarf2_per_objfile->per_bfd->quick_file_names_table. */
1988 struct quick_file_names
*file_names
;
1990 /* A temporary mark bit used when iterating over all CUs in
1991 expand_symtabs_matching. */
1992 unsigned int mark
: 1;
1994 /* True if we've tried to read the file table and found there isn't one.
1995 There will be no point in trying to read it again next time. */
1996 unsigned int no_file_data
: 1;
1999 /* A subclass of psymbol_functions that arranges to read the DWARF
2000 partial symbols when needed. */
2001 struct lazy_dwarf_reader
: public psymbol_functions
2003 using psymbol_functions::psymbol_functions
;
2005 bool can_lazily_read_symbols () override
2010 void read_partial_symbols (struct objfile
*objfile
) override
2012 if (dwarf2_has_info (objfile
, nullptr))
2013 dwarf2_build_psymtabs (objfile
, this);
2017 static quick_symbol_functions_up
2018 make_lazy_dwarf_reader ()
2020 return quick_symbol_functions_up (new lazy_dwarf_reader
);
2023 struct dwarf2_base_index_functions
: public quick_symbol_functions
2025 bool has_symbols (struct objfile
*objfile
) override
;
2027 bool has_unexpanded_symtabs (struct objfile
*objfile
) override
;
2029 struct symtab
*find_last_source_symtab (struct objfile
*objfile
) override
;
2031 void forget_cached_source_info (struct objfile
*objfile
) override
;
2033 enum language
lookup_global_symbol_language (struct objfile
*objfile
,
2036 bool *symbol_found_p
) override
2038 *symbol_found_p
= false;
2039 return language_unknown
;
2042 void print_stats (struct objfile
*objfile
, bool print_bcache
) override
;
2044 void expand_all_symtabs (struct objfile
*objfile
) override
;
2046 struct compunit_symtab
*find_pc_sect_compunit_symtab
2047 (struct objfile
*objfile
, struct bound_minimal_symbol msymbol
,
2048 CORE_ADDR pc
, struct obj_section
*section
, int warn_if_readin
) override
;
2050 struct compunit_symtab
*find_compunit_symtab_by_address
2051 (struct objfile
*objfile
, CORE_ADDR address
) override
2056 void map_symbol_filenames (struct objfile
*objfile
,
2057 gdb::function_view
<symbol_filename_ftype
> fun
,
2058 bool need_fullname
) override
;
2061 struct dwarf2_gdb_index
: public dwarf2_base_index_functions
2063 void dump (struct objfile
*objfile
) override
;
2065 void expand_matching_symbols
2067 const lookup_name_info
&lookup_name
,
2070 symbol_compare_ftype
*ordered_compare
) override
;
2072 bool expand_symtabs_matching
2073 (struct objfile
*objfile
,
2074 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
2075 const lookup_name_info
*lookup_name
,
2076 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
2077 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
2078 block_search_flags search_flags
,
2080 enum search_domain kind
) override
;
2083 struct dwarf2_debug_names_index
: public dwarf2_base_index_functions
2085 void dump (struct objfile
*objfile
) override
;
2087 void expand_matching_symbols
2089 const lookup_name_info
&lookup_name
,
2092 symbol_compare_ftype
*ordered_compare
) override
;
2094 bool expand_symtabs_matching
2095 (struct objfile
*objfile
,
2096 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
2097 const lookup_name_info
*lookup_name
,
2098 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
2099 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
2100 block_search_flags search_flags
,
2102 enum search_domain kind
) override
;
2105 static quick_symbol_functions_up
2106 make_dwarf_gdb_index ()
2108 return quick_symbol_functions_up (new dwarf2_gdb_index
);
2111 static quick_symbol_functions_up
2112 make_dwarf_debug_names ()
2114 return quick_symbol_functions_up (new dwarf2_debug_names_index
);
2117 /* Utility hash function for a stmt_list_hash. */
2120 hash_stmt_list_entry (const struct stmt_list_hash
*stmt_list_hash
)
2124 if (stmt_list_hash
->dwo_unit
!= NULL
)
2125 v
+= (uintptr_t) stmt_list_hash
->dwo_unit
->dwo_file
;
2126 v
+= to_underlying (stmt_list_hash
->line_sect_off
);
2130 /* Utility equality function for a stmt_list_hash. */
2133 eq_stmt_list_entry (const struct stmt_list_hash
*lhs
,
2134 const struct stmt_list_hash
*rhs
)
2136 if ((lhs
->dwo_unit
!= NULL
) != (rhs
->dwo_unit
!= NULL
))
2138 if (lhs
->dwo_unit
!= NULL
2139 && lhs
->dwo_unit
->dwo_file
!= rhs
->dwo_unit
->dwo_file
)
2142 return lhs
->line_sect_off
== rhs
->line_sect_off
;
2145 /* Hash function for a quick_file_names. */
2148 hash_file_name_entry (const void *e
)
2150 const struct quick_file_names
*file_data
2151 = (const struct quick_file_names
*) e
;
2153 return hash_stmt_list_entry (&file_data
->hash
);
2156 /* Equality function for a quick_file_names. */
2159 eq_file_name_entry (const void *a
, const void *b
)
2161 const struct quick_file_names
*ea
= (const struct quick_file_names
*) a
;
2162 const struct quick_file_names
*eb
= (const struct quick_file_names
*) b
;
2164 return eq_stmt_list_entry (&ea
->hash
, &eb
->hash
);
2167 /* Delete function for a quick_file_names. */
2170 delete_file_name_entry (void *e
)
2172 struct quick_file_names
*file_data
= (struct quick_file_names
*) e
;
2175 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
2177 xfree ((void*) file_data
->file_names
[i
]);
2178 if (file_data
->real_names
)
2179 xfree ((void*) file_data
->real_names
[i
]);
2182 /* The space for the struct itself lives on the obstack, so we don't
2186 /* Create a quick_file_names hash table. */
2189 create_quick_file_names_table (unsigned int nr_initial_entries
)
2191 return htab_up (htab_create_alloc (nr_initial_entries
,
2192 hash_file_name_entry
, eq_file_name_entry
,
2193 delete_file_name_entry
, xcalloc
, xfree
));
2196 /* Read in CU (dwarf2_cu object) for PER_CU in the context of PER_OBJFILE. This
2197 function is unrelated to symtabs, symtab would have to be created afterwards.
2198 You should call age_cached_comp_units after processing the CU. */
2201 load_cu (dwarf2_per_cu_data
*per_cu
, dwarf2_per_objfile
*per_objfile
,
2204 if (per_cu
->is_debug_types
)
2205 load_full_type_unit (per_cu
, per_objfile
);
2207 load_full_comp_unit (per_cu
, per_objfile
, per_objfile
->get_cu (per_cu
),
2208 skip_partial
, language_minimal
);
2210 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
2212 return nullptr; /* Dummy CU. */
2214 dwarf2_find_base_address (cu
->dies
, cu
);
2219 /* Read in the symbols for PER_CU in the context of PER_OBJFILE. */
2222 dw2_do_instantiate_symtab (dwarf2_per_cu_data
*per_cu
,
2223 dwarf2_per_objfile
*per_objfile
, bool skip_partial
)
2225 /* Skip type_unit_groups, reading the type units they contain
2226 is handled elsewhere. */
2227 if (per_cu
->type_unit_group_p ())
2231 /* The destructor of dwarf2_queue_guard frees any entries left on
2232 the queue. After this point we're guaranteed to leave this function
2233 with the dwarf queue empty. */
2234 dwarf2_queue_guard
q_guard (per_objfile
);
2236 if (!per_objfile
->symtab_set_p (per_cu
))
2238 queue_comp_unit (per_cu
, per_objfile
, language_minimal
);
2239 dwarf2_cu
*cu
= load_cu (per_cu
, per_objfile
, skip_partial
);
2241 /* If we just loaded a CU from a DWO, and we're working with an index
2242 that may badly handle TUs, load all the TUs in that DWO as well.
2243 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
2244 if (!per_cu
->is_debug_types
2246 && cu
->dwo_unit
!= NULL
2247 && per_objfile
->per_bfd
->index_table
!= NULL
2248 && per_objfile
->per_bfd
->index_table
->version
<= 7
2249 /* DWP files aren't supported yet. */
2250 && get_dwp_file (per_objfile
) == NULL
)
2251 queue_and_load_all_dwo_tus (cu
);
2254 process_queue (per_objfile
);
2257 /* Age the cache, releasing compilation units that have not
2258 been used recently. */
2259 per_objfile
->age_comp_units ();
2262 /* Ensure that the symbols for PER_CU have been read in. DWARF2_PER_OBJFILE is
2263 the per-objfile for which this symtab is instantiated.
2265 Returns the resulting symbol table. */
2267 static struct compunit_symtab
*
2268 dw2_instantiate_symtab (dwarf2_per_cu_data
*per_cu
,
2269 dwarf2_per_objfile
*per_objfile
,
2272 gdb_assert (per_objfile
->per_bfd
->using_index
);
2274 if (!per_objfile
->symtab_set_p (per_cu
))
2276 free_cached_comp_units
freer (per_objfile
);
2277 scoped_restore decrementer
= increment_reading_symtab ();
2278 dw2_do_instantiate_symtab (per_cu
, per_objfile
, skip_partial
);
2279 process_cu_includes (per_objfile
);
2282 return per_objfile
->get_symtab (per_cu
);
2287 dwarf2_per_cu_data_up
2288 dwarf2_per_bfd::allocate_per_cu ()
2290 dwarf2_per_cu_data_up
result (new dwarf2_per_cu_data
);
2291 result
->per_bfd
= this;
2292 result
->index
= all_comp_units
.size ();
2299 dwarf2_per_bfd::allocate_signatured_type (ULONGEST signature
)
2301 signatured_type_up
result (new signatured_type (signature
));
2302 result
->per_bfd
= this;
2303 result
->index
= all_comp_units
.size ();
2304 result
->is_debug_types
= true;
2309 /* Return a new dwarf2_per_cu_data allocated on the per-bfd
2310 obstack, and constructed with the specified field values. */
2312 static dwarf2_per_cu_data_up
2313 create_cu_from_index_list (dwarf2_per_bfd
*per_bfd
,
2314 struct dwarf2_section_info
*section
,
2316 sect_offset sect_off
, ULONGEST length
)
2318 dwarf2_per_cu_data_up the_cu
= per_bfd
->allocate_per_cu ();
2319 the_cu
->sect_off
= sect_off
;
2320 the_cu
->length
= length
;
2321 the_cu
->section
= section
;
2322 the_cu
->v
.quick
= OBSTACK_ZALLOC (&per_bfd
->obstack
,
2323 struct dwarf2_per_cu_quick_data
);
2324 the_cu
->is_dwz
= is_dwz
;
2328 /* A helper for create_cus_from_index that handles a given list of
2332 create_cus_from_index_list (dwarf2_per_bfd
*per_bfd
,
2333 const gdb_byte
*cu_list
, offset_type n_elements
,
2334 struct dwarf2_section_info
*section
,
2337 for (offset_type i
= 0; i
< n_elements
; i
+= 2)
2339 gdb_static_assert (sizeof (ULONGEST
) >= 8);
2341 sect_offset sect_off
2342 = (sect_offset
) extract_unsigned_integer (cu_list
, 8, BFD_ENDIAN_LITTLE
);
2343 ULONGEST length
= extract_unsigned_integer (cu_list
+ 8, 8, BFD_ENDIAN_LITTLE
);
2346 dwarf2_per_cu_data_up per_cu
2347 = create_cu_from_index_list (per_bfd
, section
, is_dwz
, sect_off
,
2349 per_bfd
->all_comp_units
.push_back (std::move (per_cu
));
2353 /* Read the CU list from the mapped index, and use it to create all
2354 the CU objects for PER_BFD. */
2357 create_cus_from_index (dwarf2_per_bfd
*per_bfd
,
2358 const gdb_byte
*cu_list
, offset_type cu_list_elements
,
2359 const gdb_byte
*dwz_list
, offset_type dwz_elements
)
2361 gdb_assert (per_bfd
->all_comp_units
.empty ());
2362 per_bfd
->all_comp_units
.reserve ((cu_list_elements
+ dwz_elements
) / 2);
2364 create_cus_from_index_list (per_bfd
, cu_list
, cu_list_elements
,
2367 if (dwz_elements
== 0)
2370 dwz_file
*dwz
= dwarf2_get_dwz_file (per_bfd
);
2371 create_cus_from_index_list (per_bfd
, dwz_list
, dwz_elements
,
2375 /* Create the signatured type hash table from the index. */
2378 create_signatured_type_table_from_index
2379 (dwarf2_per_bfd
*per_bfd
, struct dwarf2_section_info
*section
,
2380 const gdb_byte
*bytes
, offset_type elements
)
2382 htab_up sig_types_hash
= allocate_signatured_type_table ();
2384 for (offset_type i
= 0; i
< elements
; i
+= 3)
2386 signatured_type_up sig_type
;
2389 cu_offset type_offset_in_tu
;
2391 gdb_static_assert (sizeof (ULONGEST
) >= 8);
2392 sect_offset sect_off
2393 = (sect_offset
) extract_unsigned_integer (bytes
, 8, BFD_ENDIAN_LITTLE
);
2395 = (cu_offset
) extract_unsigned_integer (bytes
+ 8, 8,
2397 signature
= extract_unsigned_integer (bytes
+ 16, 8, BFD_ENDIAN_LITTLE
);
2400 sig_type
= per_bfd
->allocate_signatured_type (signature
);
2401 sig_type
->type_offset_in_tu
= type_offset_in_tu
;
2402 sig_type
->section
= section
;
2403 sig_type
->sect_off
= sect_off
;
2405 = OBSTACK_ZALLOC (&per_bfd
->obstack
,
2406 struct dwarf2_per_cu_quick_data
);
2408 slot
= htab_find_slot (sig_types_hash
.get (), sig_type
.get (), INSERT
);
2409 *slot
= sig_type
.get ();
2411 per_bfd
->all_comp_units
.emplace_back (sig_type
.release ());
2414 per_bfd
->signatured_types
= std::move (sig_types_hash
);
2417 /* Create the signatured type hash table from .debug_names. */
2420 create_signatured_type_table_from_debug_names
2421 (dwarf2_per_objfile
*per_objfile
,
2422 const mapped_debug_names
&map
,
2423 struct dwarf2_section_info
*section
,
2424 struct dwarf2_section_info
*abbrev_section
)
2426 struct objfile
*objfile
= per_objfile
->objfile
;
2428 section
->read (objfile
);
2429 abbrev_section
->read (objfile
);
2431 htab_up sig_types_hash
= allocate_signatured_type_table ();
2433 for (uint32_t i
= 0; i
< map
.tu_count
; ++i
)
2435 signatured_type_up sig_type
;
2438 sect_offset sect_off
2439 = (sect_offset
) (extract_unsigned_integer
2440 (map
.tu_table_reordered
+ i
* map
.offset_size
,
2442 map
.dwarf5_byte_order
));
2444 comp_unit_head cu_header
;
2445 read_and_check_comp_unit_head (per_objfile
, &cu_header
, section
,
2447 section
->buffer
+ to_underlying (sect_off
),
2450 sig_type
= per_objfile
->per_bfd
->allocate_signatured_type
2451 (cu_header
.signature
);
2452 sig_type
->type_offset_in_tu
= cu_header
.type_cu_offset_in_tu
;
2453 sig_type
->section
= section
;
2454 sig_type
->sect_off
= sect_off
;
2456 = OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
,
2457 struct dwarf2_per_cu_quick_data
);
2459 slot
= htab_find_slot (sig_types_hash
.get (), sig_type
.get (), INSERT
);
2460 *slot
= sig_type
.get ();
2462 per_objfile
->per_bfd
->all_comp_units
.emplace_back (sig_type
.release ());
2465 per_objfile
->per_bfd
->signatured_types
= std::move (sig_types_hash
);
2468 /* Read the address map data from the mapped index, and use it to
2469 populate the psymtabs_addrmap. */
2472 create_addrmap_from_index (dwarf2_per_objfile
*per_objfile
,
2473 struct mapped_index
*index
)
2475 struct objfile
*objfile
= per_objfile
->objfile
;
2476 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
2477 struct gdbarch
*gdbarch
= objfile
->arch ();
2478 const gdb_byte
*iter
, *end
;
2479 struct addrmap
*mutable_map
;
2482 auto_obstack temp_obstack
;
2484 mutable_map
= addrmap_create_mutable (&temp_obstack
);
2486 iter
= index
->address_table
.data ();
2487 end
= iter
+ index
->address_table
.size ();
2489 baseaddr
= objfile
->text_section_offset ();
2493 ULONGEST hi
, lo
, cu_index
;
2494 lo
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
2496 hi
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
2498 cu_index
= extract_unsigned_integer (iter
, 4, BFD_ENDIAN_LITTLE
);
2503 complaint (_(".gdb_index address table has invalid range (%s - %s)"),
2504 hex_string (lo
), hex_string (hi
));
2508 if (cu_index
>= per_bfd
->all_comp_units
.size ())
2510 complaint (_(".gdb_index address table has invalid CU number %u"),
2511 (unsigned) cu_index
);
2515 lo
= gdbarch_adjust_dwarf2_addr (gdbarch
, lo
+ baseaddr
) - baseaddr
;
2516 hi
= gdbarch_adjust_dwarf2_addr (gdbarch
, hi
+ baseaddr
) - baseaddr
;
2517 addrmap_set_empty (mutable_map
, lo
, hi
- 1,
2518 per_bfd
->get_cu (cu_index
));
2521 per_bfd
->index_addrmap
= addrmap_create_fixed (mutable_map
,
2525 /* Read the address map data from DWARF-5 .debug_aranges, and use it to
2526 populate the psymtabs_addrmap. */
2529 create_addrmap_from_aranges (dwarf2_per_objfile
*per_objfile
,
2530 struct dwarf2_section_info
*section
)
2532 struct objfile
*objfile
= per_objfile
->objfile
;
2533 bfd
*abfd
= objfile
->obfd
;
2534 struct gdbarch
*gdbarch
= objfile
->arch ();
2535 const CORE_ADDR baseaddr
= objfile
->text_section_offset ();
2536 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
2538 auto_obstack temp_obstack
;
2539 addrmap
*mutable_map
= addrmap_create_mutable (&temp_obstack
);
2541 std::unordered_map
<sect_offset
,
2542 dwarf2_per_cu_data
*,
2543 gdb::hash_enum
<sect_offset
>>
2544 debug_info_offset_to_per_cu
;
2545 for (const auto &per_cu
: per_bfd
->all_comp_units
)
2547 const auto insertpair
2548 = debug_info_offset_to_per_cu
.emplace (per_cu
->sect_off
,
2550 if (!insertpair
.second
)
2552 warning (_("Section .debug_aranges in %s has duplicate "
2553 "debug_info_offset %s, ignoring .debug_aranges."),
2554 objfile_name (objfile
), sect_offset_str (per_cu
->sect_off
));
2559 section
->read (objfile
);
2561 const bfd_endian dwarf5_byte_order
= gdbarch_byte_order (gdbarch
);
2563 const gdb_byte
*addr
= section
->buffer
;
2565 while (addr
< section
->buffer
+ section
->size
)
2567 const gdb_byte
*const entry_addr
= addr
;
2568 unsigned int bytes_read
;
2570 const LONGEST entry_length
= read_initial_length (abfd
, addr
,
2574 const gdb_byte
*const entry_end
= addr
+ entry_length
;
2575 const bool dwarf5_is_dwarf64
= bytes_read
!= 4;
2576 const uint8_t offset_size
= dwarf5_is_dwarf64
? 8 : 4;
2577 if (addr
+ entry_length
> section
->buffer
+ section
->size
)
2579 warning (_("Section .debug_aranges in %s entry at offset %s "
2580 "length %s exceeds section length %s, "
2581 "ignoring .debug_aranges."),
2582 objfile_name (objfile
),
2583 plongest (entry_addr
- section
->buffer
),
2584 plongest (bytes_read
+ entry_length
),
2585 pulongest (section
->size
));
2589 /* The version number. */
2590 const uint16_t version
= read_2_bytes (abfd
, addr
);
2594 warning (_("Section .debug_aranges in %s entry at offset %s "
2595 "has unsupported version %d, ignoring .debug_aranges."),
2596 objfile_name (objfile
),
2597 plongest (entry_addr
- section
->buffer
), version
);
2601 const uint64_t debug_info_offset
2602 = extract_unsigned_integer (addr
, offset_size
, dwarf5_byte_order
);
2603 addr
+= offset_size
;
2604 const auto per_cu_it
2605 = debug_info_offset_to_per_cu
.find (sect_offset (debug_info_offset
));
2606 if (per_cu_it
== debug_info_offset_to_per_cu
.cend ())
2608 warning (_("Section .debug_aranges in %s entry at offset %s "
2609 "debug_info_offset %s does not exists, "
2610 "ignoring .debug_aranges."),
2611 objfile_name (objfile
),
2612 plongest (entry_addr
- section
->buffer
),
2613 pulongest (debug_info_offset
));
2616 dwarf2_per_cu_data
*const per_cu
= per_cu_it
->second
;
2618 const uint8_t address_size
= *addr
++;
2619 if (address_size
< 1 || address_size
> 8)
2621 warning (_("Section .debug_aranges in %s entry at offset %s "
2622 "address_size %u is invalid, ignoring .debug_aranges."),
2623 objfile_name (objfile
),
2624 plongest (entry_addr
- section
->buffer
), address_size
);
2628 const uint8_t segment_selector_size
= *addr
++;
2629 if (segment_selector_size
!= 0)
2631 warning (_("Section .debug_aranges in %s entry at offset %s "
2632 "segment_selector_size %u is not supported, "
2633 "ignoring .debug_aranges."),
2634 objfile_name (objfile
),
2635 plongest (entry_addr
- section
->buffer
),
2636 segment_selector_size
);
2640 /* Must pad to an alignment boundary that is twice the address
2641 size. It is undocumented by the DWARF standard but GCC does
2642 use it. However, not every compiler does this. We can see
2643 whether it has happened by looking at the total length of the
2644 contents of the aranges for this CU -- it if isn't a multiple
2645 of twice the address size, then we skip any leftover
2647 addr
+= (entry_end
- addr
) % (2 * address_size
);
2651 if (addr
+ 2 * address_size
> entry_end
)
2653 warning (_("Section .debug_aranges in %s entry at offset %s "
2654 "address list is not properly terminated, "
2655 "ignoring .debug_aranges."),
2656 objfile_name (objfile
),
2657 plongest (entry_addr
- section
->buffer
));
2660 ULONGEST start
= extract_unsigned_integer (addr
, address_size
,
2662 addr
+= address_size
;
2663 ULONGEST length
= extract_unsigned_integer (addr
, address_size
,
2665 addr
+= address_size
;
2666 if (start
== 0 && length
== 0)
2668 if (start
== 0 && !per_bfd
->has_section_at_zero
)
2670 /* Symbol was eliminated due to a COMDAT group. */
2673 ULONGEST end
= start
+ length
;
2674 start
= (gdbarch_adjust_dwarf2_addr (gdbarch
, start
+ baseaddr
)
2676 end
= (gdbarch_adjust_dwarf2_addr (gdbarch
, end
+ baseaddr
)
2678 addrmap_set_empty (mutable_map
, start
, end
- 1, per_cu
);
2682 per_bfd
->index_addrmap
= addrmap_create_fixed (mutable_map
,
2686 /* A helper function that reads the .gdb_index from BUFFER and fills
2687 in MAP. FILENAME is the name of the file containing the data;
2688 it is used for error reporting. DEPRECATED_OK is true if it is
2689 ok to use deprecated sections.
2691 CU_LIST, CU_LIST_ELEMENTS, TYPES_LIST, and TYPES_LIST_ELEMENTS are
2692 out parameters that are filled in with information about the CU and
2693 TU lists in the section.
2695 Returns true if all went well, false otherwise. */
2698 read_gdb_index_from_buffer (const char *filename
,
2700 gdb::array_view
<const gdb_byte
> buffer
,
2701 struct mapped_index
*map
,
2702 const gdb_byte
**cu_list
,
2703 offset_type
*cu_list_elements
,
2704 const gdb_byte
**types_list
,
2705 offset_type
*types_list_elements
)
2707 const gdb_byte
*addr
= &buffer
[0];
2708 offset_view
metadata (buffer
);
2710 /* Version check. */
2711 offset_type version
= metadata
[0];
2712 /* Versions earlier than 3 emitted every copy of a psymbol. This
2713 causes the index to behave very poorly for certain requests. Version 3
2714 contained incomplete addrmap. So, it seems better to just ignore such
2718 static int warning_printed
= 0;
2719 if (!warning_printed
)
2721 warning (_("Skipping obsolete .gdb_index section in %s."),
2723 warning_printed
= 1;
2727 /* Index version 4 uses a different hash function than index version
2730 Versions earlier than 6 did not emit psymbols for inlined
2731 functions. Using these files will cause GDB not to be able to
2732 set breakpoints on inlined functions by name, so we ignore these
2733 indices unless the user has done
2734 "set use-deprecated-index-sections on". */
2735 if (version
< 6 && !deprecated_ok
)
2737 static int warning_printed
= 0;
2738 if (!warning_printed
)
2741 Skipping deprecated .gdb_index section in %s.\n\
2742 Do \"set use-deprecated-index-sections on\" before the file is read\n\
2743 to use the section anyway."),
2745 warning_printed
= 1;
2749 /* Version 7 indices generated by gold refer to the CU for a symbol instead
2750 of the TU (for symbols coming from TUs),
2751 http://sourceware.org/bugzilla/show_bug.cgi?id=15021.
2752 Plus gold-generated indices can have duplicate entries for global symbols,
2753 http://sourceware.org/bugzilla/show_bug.cgi?id=15646.
2754 These are just performance bugs, and we can't distinguish gdb-generated
2755 indices from gold-generated ones, so issue no warning here. */
2757 /* Indexes with higher version than the one supported by GDB may be no
2758 longer backward compatible. */
2762 map
->version
= version
;
2765 *cu_list
= addr
+ metadata
[i
];
2766 *cu_list_elements
= (metadata
[i
+ 1] - metadata
[i
]) / 8;
2769 *types_list
= addr
+ metadata
[i
];
2770 *types_list_elements
= (metadata
[i
+ 1] - metadata
[i
]) / 8;
2773 const gdb_byte
*address_table
= addr
+ metadata
[i
];
2774 const gdb_byte
*address_table_end
= addr
+ metadata
[i
+ 1];
2776 = gdb::array_view
<const gdb_byte
> (address_table
, address_table_end
);
2779 const gdb_byte
*symbol_table
= addr
+ metadata
[i
];
2780 const gdb_byte
*symbol_table_end
= addr
+ metadata
[i
+ 1];
2782 = offset_view (gdb::array_view
<const gdb_byte
> (symbol_table
,
2786 map
->constant_pool
= buffer
.slice (metadata
[i
]);
2791 /* Callback types for dwarf2_read_gdb_index. */
2793 typedef gdb::function_view
2794 <gdb::array_view
<const gdb_byte
>(objfile
*, dwarf2_per_bfd
*)>
2795 get_gdb_index_contents_ftype
;
2796 typedef gdb::function_view
2797 <gdb::array_view
<const gdb_byte
>(objfile
*, dwz_file
*)>
2798 get_gdb_index_contents_dwz_ftype
;
2800 /* Read .gdb_index. If everything went ok, initialize the "quick"
2801 elements of all the CUs and return 1. Otherwise, return 0. */
2804 dwarf2_read_gdb_index
2805 (dwarf2_per_objfile
*per_objfile
,
2806 get_gdb_index_contents_ftype get_gdb_index_contents
,
2807 get_gdb_index_contents_dwz_ftype get_gdb_index_contents_dwz
)
2809 const gdb_byte
*cu_list
, *types_list
, *dwz_list
= NULL
;
2810 offset_type cu_list_elements
, types_list_elements
, dwz_list_elements
= 0;
2811 struct dwz_file
*dwz
;
2812 struct objfile
*objfile
= per_objfile
->objfile
;
2813 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
2815 gdb::array_view
<const gdb_byte
> main_index_contents
2816 = get_gdb_index_contents (objfile
, per_bfd
);
2818 if (main_index_contents
.empty ())
2821 std::unique_ptr
<struct mapped_index
> map (new struct mapped_index
);
2822 if (!read_gdb_index_from_buffer (objfile_name (objfile
),
2823 use_deprecated_index_sections
,
2824 main_index_contents
, map
.get (), &cu_list
,
2825 &cu_list_elements
, &types_list
,
2826 &types_list_elements
))
2829 /* Don't use the index if it's empty. */
2830 if (map
->symbol_table
.empty ())
2833 /* If there is a .dwz file, read it so we can get its CU list as
2835 dwz
= dwarf2_get_dwz_file (per_bfd
);
2838 struct mapped_index dwz_map
;
2839 const gdb_byte
*dwz_types_ignore
;
2840 offset_type dwz_types_elements_ignore
;
2842 gdb::array_view
<const gdb_byte
> dwz_index_content
2843 = get_gdb_index_contents_dwz (objfile
, dwz
);
2845 if (dwz_index_content
.empty ())
2848 if (!read_gdb_index_from_buffer (bfd_get_filename (dwz
->dwz_bfd
.get ()),
2849 1, dwz_index_content
, &dwz_map
,
2850 &dwz_list
, &dwz_list_elements
,
2852 &dwz_types_elements_ignore
))
2854 warning (_("could not read '.gdb_index' section from %s; skipping"),
2855 bfd_get_filename (dwz
->dwz_bfd
.get ()));
2860 create_cus_from_index (per_bfd
, cu_list
, cu_list_elements
, dwz_list
,
2863 if (types_list_elements
)
2865 /* We can only handle a single .debug_types when we have an
2867 if (per_bfd
->types
.size () != 1)
2870 dwarf2_section_info
*section
= &per_bfd
->types
[0];
2872 create_signatured_type_table_from_index (per_bfd
, section
, types_list
,
2873 types_list_elements
);
2876 create_addrmap_from_index (per_objfile
, map
.get ());
2878 per_bfd
->index_table
= std::move (map
);
2879 per_bfd
->using_index
= 1;
2880 per_bfd
->quick_file_names_table
=
2881 create_quick_file_names_table (per_bfd
->all_comp_units
.size ());
2886 /* die_reader_func for dw2_get_file_names. */
2889 dw2_get_file_names_reader (const struct die_reader_specs
*reader
,
2890 struct die_info
*comp_unit_die
)
2892 struct dwarf2_cu
*cu
= reader
->cu
;
2893 struct dwarf2_per_cu_data
*this_cu
= cu
->per_cu
;
2894 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
2895 struct dwarf2_per_cu_data
*lh_cu
;
2896 struct attribute
*attr
;
2898 struct quick_file_names
*qfn
;
2900 gdb_assert (! this_cu
->is_debug_types
);
2902 /* Our callers never want to match partial units -- instead they
2903 will match the enclosing full CU. */
2904 if (comp_unit_die
->tag
== DW_TAG_partial_unit
)
2906 this_cu
->v
.quick
->no_file_data
= 1;
2914 sect_offset line_offset
{};
2916 attr
= dwarf2_attr (comp_unit_die
, DW_AT_stmt_list
, cu
);
2917 if (attr
!= nullptr && attr
->form_is_unsigned ())
2919 struct quick_file_names find_entry
;
2921 line_offset
= (sect_offset
) attr
->as_unsigned ();
2923 /* We may have already read in this line header (TU line header sharing).
2924 If we have we're done. */
2925 find_entry
.hash
.dwo_unit
= cu
->dwo_unit
;
2926 find_entry
.hash
.line_sect_off
= line_offset
;
2927 slot
= htab_find_slot (per_objfile
->per_bfd
->quick_file_names_table
.get (),
2928 &find_entry
, INSERT
);
2931 lh_cu
->v
.quick
->file_names
= (struct quick_file_names
*) *slot
;
2935 lh
= dwarf_decode_line_header (line_offset
, cu
);
2939 lh_cu
->v
.quick
->no_file_data
= 1;
2943 qfn
= XOBNEW (&per_objfile
->per_bfd
->obstack
, struct quick_file_names
);
2944 qfn
->hash
.dwo_unit
= cu
->dwo_unit
;
2945 qfn
->hash
.line_sect_off
= line_offset
;
2946 gdb_assert (slot
!= NULL
);
2949 file_and_directory fnd
= find_file_and_directory (comp_unit_die
, cu
);
2952 if (strcmp (fnd
.name
, "<unknown>") != 0)
2955 qfn
->num_file_names
= offset
+ lh
->file_names_size ();
2957 XOBNEWVEC (&per_objfile
->per_bfd
->obstack
, const char *,
2958 qfn
->num_file_names
);
2960 qfn
->file_names
[0] = xstrdup (fnd
.name
);
2961 for (int i
= 0; i
< lh
->file_names_size (); ++i
)
2962 qfn
->file_names
[i
+ offset
] = lh
->file_full_name (i
+ 1,
2963 fnd
.comp_dir
).release ();
2964 qfn
->real_names
= NULL
;
2966 lh_cu
->v
.quick
->file_names
= qfn
;
2969 /* A helper for the "quick" functions which attempts to read the line
2970 table for THIS_CU. */
2972 static struct quick_file_names
*
2973 dw2_get_file_names (dwarf2_per_cu_data
*this_cu
,
2974 dwarf2_per_objfile
*per_objfile
)
2976 /* This should never be called for TUs. */
2977 gdb_assert (! this_cu
->is_debug_types
);
2978 /* Nor type unit groups. */
2979 gdb_assert (! this_cu
->type_unit_group_p ());
2981 if (this_cu
->v
.quick
->file_names
!= NULL
)
2982 return this_cu
->v
.quick
->file_names
;
2983 /* If we know there is no line data, no point in looking again. */
2984 if (this_cu
->v
.quick
->no_file_data
)
2987 cutu_reader
reader (this_cu
, per_objfile
);
2988 if (!reader
.dummy_p
)
2989 dw2_get_file_names_reader (&reader
, reader
.comp_unit_die
);
2991 if (this_cu
->v
.quick
->no_file_data
)
2993 return this_cu
->v
.quick
->file_names
;
2996 /* A helper for the "quick" functions which computes and caches the
2997 real path for a given file name from the line table. */
3000 dw2_get_real_path (dwarf2_per_objfile
*per_objfile
,
3001 struct quick_file_names
*qfn
, int index
)
3003 if (qfn
->real_names
== NULL
)
3004 qfn
->real_names
= OBSTACK_CALLOC (&per_objfile
->per_bfd
->obstack
,
3005 qfn
->num_file_names
, const char *);
3007 if (qfn
->real_names
[index
] == NULL
)
3008 qfn
->real_names
[index
] = gdb_realpath (qfn
->file_names
[index
]).release ();
3010 return qfn
->real_names
[index
];
3014 dwarf2_base_index_functions::find_last_source_symtab (struct objfile
*objfile
)
3016 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3017 dwarf2_per_cu_data
*dwarf_cu
3018 = per_objfile
->per_bfd
->all_comp_units
.back ().get ();
3019 compunit_symtab
*cust
= dw2_instantiate_symtab (dwarf_cu
, per_objfile
, false);
3024 return compunit_primary_filetab (cust
);
3027 /* Traversal function for dw2_forget_cached_source_info. */
3030 dw2_free_cached_file_names (void **slot
, void *info
)
3032 struct quick_file_names
*file_data
= (struct quick_file_names
*) *slot
;
3034 if (file_data
->real_names
)
3038 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
3040 xfree ((void*) file_data
->real_names
[i
]);
3041 file_data
->real_names
[i
] = NULL
;
3049 dwarf2_base_index_functions::forget_cached_source_info
3050 (struct objfile
*objfile
)
3052 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3054 htab_traverse_noresize (per_objfile
->per_bfd
->quick_file_names_table
.get (),
3055 dw2_free_cached_file_names
, NULL
);
3058 /* Struct used to manage iterating over all CUs looking for a symbol. */
3060 struct dw2_symtab_iterator
3062 /* The dwarf2_per_objfile owning the CUs we are iterating on. */
3063 dwarf2_per_objfile
*per_objfile
;
3064 /* If set, only look for symbols that match that block. Valid values are
3065 GLOBAL_BLOCK and STATIC_BLOCK. */
3066 gdb::optional
<block_enum
> block_index
;
3067 /* The kind of symbol we're looking for. */
3069 /* The list of CUs from the index entry of the symbol,
3070 or NULL if not found. */
3072 /* The next element in VEC to look at. */
3074 /* The number of elements in VEC, or zero if there is no match. */
3076 /* Have we seen a global version of the symbol?
3077 If so we can ignore all further global instances.
3078 This is to work around gold/15646, inefficient gold-generated
3083 /* Initialize the index symtab iterator ITER, offset_type NAMEI variant. */
3086 dw2_symtab_iter_init (struct dw2_symtab_iterator
*iter
,
3087 dwarf2_per_objfile
*per_objfile
,
3088 gdb::optional
<block_enum
> block_index
,
3089 domain_enum domain
, offset_type namei
)
3091 iter
->per_objfile
= per_objfile
;
3092 iter
->block_index
= block_index
;
3093 iter
->domain
= domain
;
3095 iter
->global_seen
= 0;
3099 mapped_index
*index
= per_objfile
->per_bfd
->index_table
.get ();
3100 /* index is NULL if OBJF_READNOW. */
3104 gdb_assert (!index
->symbol_name_slot_invalid (namei
));
3105 offset_type vec_idx
= index
->symbol_vec_index (namei
);
3107 iter
->vec
= offset_view (index
->constant_pool
.slice (vec_idx
));
3108 iter
->length
= iter
->vec
[0];
3111 /* Return the next matching CU or NULL if there are no more. */
3113 static struct dwarf2_per_cu_data
*
3114 dw2_symtab_iter_next (struct dw2_symtab_iterator
*iter
)
3116 dwarf2_per_objfile
*per_objfile
= iter
->per_objfile
;
3118 for ( ; iter
->next
< iter
->length
; ++iter
->next
)
3120 offset_type cu_index_and_attrs
= iter
->vec
[iter
->next
+ 1];
3121 offset_type cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
3122 gdb_index_symbol_kind symbol_kind
=
3123 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
3124 /* Only check the symbol attributes if they're present.
3125 Indices prior to version 7 don't record them,
3126 and indices >= 7 may elide them for certain symbols
3127 (gold does this). */
3129 (per_objfile
->per_bfd
->index_table
->version
>= 7
3130 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_NONE
);
3132 /* Don't crash on bad data. */
3133 if (cu_index
>= per_objfile
->per_bfd
->all_comp_units
.size ())
3135 complaint (_(".gdb_index entry has bad CU index"
3136 " [in module %s]"), objfile_name (per_objfile
->objfile
));
3140 dwarf2_per_cu_data
*per_cu
= per_objfile
->per_bfd
->get_cu (cu_index
);
3142 /* Skip if already read in. */
3143 if (per_objfile
->symtab_set_p (per_cu
))
3146 /* Check static vs global. */
3149 bool is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs
);
3151 if (iter
->block_index
.has_value ())
3153 bool want_static
= *iter
->block_index
== STATIC_BLOCK
;
3155 if (is_static
!= want_static
)
3159 /* Work around gold/15646. */
3161 && symbol_kind
== GDB_INDEX_SYMBOL_KIND_TYPE
)
3163 if (iter
->global_seen
)
3166 iter
->global_seen
= 1;
3170 /* Only check the symbol's kind if it has one. */
3173 switch (iter
->domain
)
3176 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
3177 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
3178 /* Some types are also in VAR_DOMAIN. */
3179 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
3183 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
3187 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_OTHER
)
3191 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_OTHER
)
3207 dwarf2_base_index_functions::print_stats (struct objfile
*objfile
,
3213 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3214 int total
= per_objfile
->per_bfd
->all_comp_units
.size ();
3217 for (int i
= 0; i
< total
; ++i
)
3219 dwarf2_per_cu_data
*per_cu
= per_objfile
->per_bfd
->get_cu (i
);
3221 if (!per_objfile
->symtab_set_p (per_cu
))
3224 printf_filtered (_(" Number of read CUs: %d\n"), total
- count
);
3225 printf_filtered (_(" Number of unread CUs: %d\n"), count
);
3228 /* This dumps minimal information about the index.
3229 It is called via "mt print objfiles".
3230 One use is to verify .gdb_index has been loaded by the
3231 gdb.dwarf2/gdb-index.exp testcase. */
3234 dwarf2_gdb_index::dump (struct objfile
*objfile
)
3236 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3238 gdb_assert (per_objfile
->per_bfd
->using_index
);
3239 printf_filtered (".gdb_index:");
3240 if (per_objfile
->per_bfd
->index_table
!= NULL
)
3242 printf_filtered (" version %d\n",
3243 per_objfile
->per_bfd
->index_table
->version
);
3246 printf_filtered (" faked for \"readnow\"\n");
3247 printf_filtered ("\n");
3251 dwarf2_base_index_functions::expand_all_symtabs (struct objfile
*objfile
)
3253 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3254 int total_units
= per_objfile
->per_bfd
->all_comp_units
.size ();
3256 for (int i
= 0; i
< total_units
; ++i
)
3258 dwarf2_per_cu_data
*per_cu
= per_objfile
->per_bfd
->get_cu (i
);
3260 /* We don't want to directly expand a partial CU, because if we
3261 read it with the wrong language, then assertion failures can
3262 be triggered later on. See PR symtab/23010. So, tell
3263 dw2_instantiate_symtab to skip partial CUs -- any important
3264 partial CU will be read via DW_TAG_imported_unit anyway. */
3265 dw2_instantiate_symtab (per_cu
, per_objfile
, true);
3270 dw2_expand_symtabs_matching_symbol
3271 (mapped_index_base
&index
,
3272 const lookup_name_info
&lookup_name_in
,
3273 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
3274 gdb::function_view
<bool (offset_type
)> match_callback
,
3275 dwarf2_per_objfile
*per_objfile
);
3278 dw2_expand_symtabs_matching_one
3279 (dwarf2_per_cu_data
*per_cu
,
3280 dwarf2_per_objfile
*per_objfile
,
3281 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
3282 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
);
3285 dwarf2_gdb_index::expand_matching_symbols
3286 (struct objfile
*objfile
,
3287 const lookup_name_info
&name
, domain_enum domain
,
3289 symbol_compare_ftype
*ordered_compare
)
3292 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3294 const block_enum block_kind
= global
? GLOBAL_BLOCK
: STATIC_BLOCK
;
3296 if (per_objfile
->per_bfd
->index_table
!= nullptr)
3298 mapped_index
&index
= *per_objfile
->per_bfd
->index_table
;
3300 const char *match_name
= name
.ada ().lookup_name ().c_str ();
3301 auto matcher
= [&] (const char *symname
)
3303 if (ordered_compare
== nullptr)
3305 return ordered_compare (symname
, match_name
) == 0;
3308 dw2_expand_symtabs_matching_symbol (index
, name
, matcher
,
3309 [&] (offset_type namei
)
3311 struct dw2_symtab_iterator iter
;
3312 struct dwarf2_per_cu_data
*per_cu
;
3314 dw2_symtab_iter_init (&iter
, per_objfile
, block_kind
, domain
,
3316 while ((per_cu
= dw2_symtab_iter_next (&iter
)) != NULL
)
3317 dw2_expand_symtabs_matching_one (per_cu
, per_objfile
, nullptr,
3324 /* We have -readnow: no .gdb_index, but no partial symtabs either. So,
3325 proceed assuming all symtabs have been read in. */
3329 /* Starting from a search name, return the string that finds the upper
3330 bound of all strings that start with SEARCH_NAME in a sorted name
3331 list. Returns the empty string to indicate that the upper bound is
3332 the end of the list. */
3335 make_sort_after_prefix_name (const char *search_name
)
3337 /* When looking to complete "func", we find the upper bound of all
3338 symbols that start with "func" by looking for where we'd insert
3339 the closest string that would follow "func" in lexicographical
3340 order. Usually, that's "func"-with-last-character-incremented,
3341 i.e. "fund". Mind non-ASCII characters, though. Usually those
3342 will be UTF-8 multi-byte sequences, but we can't be certain.
3343 Especially mind the 0xff character, which is a valid character in
3344 non-UTF-8 source character sets (e.g. Latin1 'ÿ'), and we can't
3345 rule out compilers allowing it in identifiers. Note that
3346 conveniently, strcmp/strcasecmp are specified to compare
3347 characters interpreted as unsigned char. So what we do is treat
3348 the whole string as a base 256 number composed of a sequence of
3349 base 256 "digits" and add 1 to it. I.e., adding 1 to 0xff wraps
3350 to 0, and carries 1 to the following more-significant position.
3351 If the very first character in SEARCH_NAME ends up incremented
3352 and carries/overflows, then the upper bound is the end of the
3353 list. The string after the empty string is also the empty
3356 Some examples of this operation:
3358 SEARCH_NAME => "+1" RESULT
3362 "\xff" "a" "\xff" => "\xff" "b"
3367 Then, with these symbols for example:
3373 completing "func" looks for symbols between "func" and
3374 "func"-with-last-character-incremented, i.e. "fund" (exclusive),
3375 which finds "func" and "func1", but not "fund".
3379 funcÿ (Latin1 'ÿ' [0xff])
3383 completing "funcÿ" looks for symbols between "funcÿ" and "fund"
3384 (exclusive), which finds "funcÿ" and "funcÿ1", but not "fund".
3388 ÿÿ (Latin1 'ÿ' [0xff])
3391 completing "ÿ" or "ÿÿ" looks for symbols between between "ÿÿ" and
3392 the end of the list.
3394 std::string after
= search_name
;
3395 while (!after
.empty () && (unsigned char) after
.back () == 0xff)
3397 if (!after
.empty ())
3398 after
.back () = (unsigned char) after
.back () + 1;
3402 /* See declaration. */
3404 std::pair
<std::vector
<name_component
>::const_iterator
,
3405 std::vector
<name_component
>::const_iterator
>
3406 mapped_index_base::find_name_components_bounds
3407 (const lookup_name_info
&lookup_name_without_params
, language lang
,
3408 dwarf2_per_objfile
*per_objfile
) const
3411 = this->name_components_casing
== case_sensitive_on
? strcmp
: strcasecmp
;
3413 const char *lang_name
3414 = lookup_name_without_params
.language_lookup_name (lang
);
3416 /* Comparison function object for lower_bound that matches against a
3417 given symbol name. */
3418 auto lookup_compare_lower
= [&] (const name_component
&elem
,
3421 const char *elem_qualified
= this->symbol_name_at (elem
.idx
, per_objfile
);
3422 const char *elem_name
= elem_qualified
+ elem
.name_offset
;
3423 return name_cmp (elem_name
, name
) < 0;
3426 /* Comparison function object for upper_bound that matches against a
3427 given symbol name. */
3428 auto lookup_compare_upper
= [&] (const char *name
,
3429 const name_component
&elem
)
3431 const char *elem_qualified
= this->symbol_name_at (elem
.idx
, per_objfile
);
3432 const char *elem_name
= elem_qualified
+ elem
.name_offset
;
3433 return name_cmp (name
, elem_name
) < 0;
3436 auto begin
= this->name_components
.begin ();
3437 auto end
= this->name_components
.end ();
3439 /* Find the lower bound. */
3442 if (lookup_name_without_params
.completion_mode () && lang_name
[0] == '\0')
3445 return std::lower_bound (begin
, end
, lang_name
, lookup_compare_lower
);
3448 /* Find the upper bound. */
3451 if (lookup_name_without_params
.completion_mode ())
3453 /* In completion mode, we want UPPER to point past all
3454 symbols names that have the same prefix. I.e., with
3455 these symbols, and completing "func":
3457 function << lower bound
3459 other_function << upper bound
3461 We find the upper bound by looking for the insertion
3462 point of "func"-with-last-character-incremented,
3464 std::string after
= make_sort_after_prefix_name (lang_name
);
3467 return std::lower_bound (lower
, end
, after
.c_str (),
3468 lookup_compare_lower
);
3471 return std::upper_bound (lower
, end
, lang_name
, lookup_compare_upper
);
3474 return {lower
, upper
};
3477 /* See declaration. */
3480 mapped_index_base::build_name_components (dwarf2_per_objfile
*per_objfile
)
3482 if (!this->name_components
.empty ())
3485 this->name_components_casing
= case_sensitivity
;
3487 = this->name_components_casing
== case_sensitive_on
? strcmp
: strcasecmp
;
3489 /* The code below only knows how to break apart components of C++
3490 symbol names (and other languages that use '::' as
3491 namespace/module separator) and Ada symbol names. */
3492 auto count
= this->symbol_name_count ();
3493 for (offset_type idx
= 0; idx
< count
; idx
++)
3495 if (this->symbol_name_slot_invalid (idx
))
3498 const char *name
= this->symbol_name_at (idx
, per_objfile
);
3500 /* Add each name component to the name component table. */
3501 unsigned int previous_len
= 0;
3503 if (strstr (name
, "::") != nullptr)
3505 for (unsigned int current_len
= cp_find_first_component (name
);
3506 name
[current_len
] != '\0';
3507 current_len
+= cp_find_first_component (name
+ current_len
))
3509 gdb_assert (name
[current_len
] == ':');
3510 this->name_components
.push_back ({previous_len
, idx
});
3511 /* Skip the '::'. */
3513 previous_len
= current_len
;
3518 /* Handle the Ada encoded (aka mangled) form here. */
3519 for (const char *iter
= strstr (name
, "__");
3521 iter
= strstr (iter
, "__"))
3523 this->name_components
.push_back ({previous_len
, idx
});
3525 previous_len
= iter
- name
;
3529 this->name_components
.push_back ({previous_len
, idx
});
3532 /* Sort name_components elements by name. */
3533 auto name_comp_compare
= [&] (const name_component
&left
,
3534 const name_component
&right
)
3536 const char *left_qualified
3537 = this->symbol_name_at (left
.idx
, per_objfile
);
3538 const char *right_qualified
3539 = this->symbol_name_at (right
.idx
, per_objfile
);
3541 const char *left_name
= left_qualified
+ left
.name_offset
;
3542 const char *right_name
= right_qualified
+ right
.name_offset
;
3544 return name_cmp (left_name
, right_name
) < 0;
3547 std::sort (this->name_components
.begin (),
3548 this->name_components
.end (),
3552 /* Helper for dw2_expand_symtabs_matching that works with a
3553 mapped_index_base instead of the containing objfile. This is split
3554 to a separate function in order to be able to unit test the
3555 name_components matching using a mock mapped_index_base. For each
3556 symbol name that matches, calls MATCH_CALLBACK, passing it the
3557 symbol's index in the mapped_index_base symbol table. */
3560 dw2_expand_symtabs_matching_symbol
3561 (mapped_index_base
&index
,
3562 const lookup_name_info
&lookup_name_in
,
3563 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
3564 gdb::function_view
<bool (offset_type
)> match_callback
,
3565 dwarf2_per_objfile
*per_objfile
)
3567 lookup_name_info lookup_name_without_params
3568 = lookup_name_in
.make_ignore_params ();
3570 /* Build the symbol name component sorted vector, if we haven't
3572 index
.build_name_components (per_objfile
);
3574 /* The same symbol may appear more than once in the range though.
3575 E.g., if we're looking for symbols that complete "w", and we have
3576 a symbol named "w1::w2", we'll find the two name components for
3577 that same symbol in the range. To be sure we only call the
3578 callback once per symbol, we first collect the symbol name
3579 indexes that matched in a temporary vector and ignore
3581 std::vector
<offset_type
> matches
;
3583 struct name_and_matcher
3585 symbol_name_matcher_ftype
*matcher
;
3588 bool operator== (const name_and_matcher
&other
) const
3590 return matcher
== other
.matcher
&& strcmp (name
, other
.name
) == 0;
3594 /* A vector holding all the different symbol name matchers, for all
3596 std::vector
<name_and_matcher
> matchers
;
3598 for (int i
= 0; i
< nr_languages
; i
++)
3600 enum language lang_e
= (enum language
) i
;
3602 const language_defn
*lang
= language_def (lang_e
);
3603 symbol_name_matcher_ftype
*name_matcher
3604 = lang
->get_symbol_name_matcher (lookup_name_without_params
);
3606 name_and_matcher key
{
3608 lookup_name_without_params
.language_lookup_name (lang_e
)
3611 /* Don't insert the same comparison routine more than once.
3612 Note that we do this linear walk. This is not a problem in
3613 practice because the number of supported languages is
3615 if (std::find (matchers
.begin (), matchers
.end (), key
)
3618 matchers
.push_back (std::move (key
));
3621 = index
.find_name_components_bounds (lookup_name_without_params
,
3622 lang_e
, per_objfile
);
3624 /* Now for each symbol name in range, check to see if we have a name
3625 match, and if so, call the MATCH_CALLBACK callback. */
3627 for (; bounds
.first
!= bounds
.second
; ++bounds
.first
)
3629 const char *qualified
3630 = index
.symbol_name_at (bounds
.first
->idx
, per_objfile
);
3632 if (!name_matcher (qualified
, lookup_name_without_params
, NULL
)
3633 || (symbol_matcher
!= NULL
&& !symbol_matcher (qualified
)))
3636 matches
.push_back (bounds
.first
->idx
);
3640 std::sort (matches
.begin (), matches
.end ());
3642 /* Finally call the callback, once per match. */
3645 for (offset_type idx
: matches
)
3649 if (!match_callback (idx
))
3658 /* Above we use a type wider than idx's for 'prev', since 0 and
3659 (offset_type)-1 are both possible values. */
3660 static_assert (sizeof (prev
) > sizeof (offset_type
), "");
3667 namespace selftests
{ namespace dw2_expand_symtabs_matching
{
3669 /* A mock .gdb_index/.debug_names-like name index table, enough to
3670 exercise dw2_expand_symtabs_matching_symbol, which works with the
3671 mapped_index_base interface. Builds an index from the symbol list
3672 passed as parameter to the constructor. */
3673 class mock_mapped_index
: public mapped_index_base
3676 mock_mapped_index (gdb::array_view
<const char *> symbols
)
3677 : m_symbol_table (symbols
)
3680 DISABLE_COPY_AND_ASSIGN (mock_mapped_index
);
3682 /* Return the number of names in the symbol table. */
3683 size_t symbol_name_count () const override
3685 return m_symbol_table
.size ();
3688 /* Get the name of the symbol at IDX in the symbol table. */
3689 const char *symbol_name_at
3690 (offset_type idx
, dwarf2_per_objfile
*per_objfile
) const override
3692 return m_symbol_table
[idx
];
3696 gdb::array_view
<const char *> m_symbol_table
;
3699 /* Convenience function that converts a NULL pointer to a "<null>"
3700 string, to pass to print routines. */
3703 string_or_null (const char *str
)
3705 return str
!= NULL
? str
: "<null>";
3708 /* Check if a lookup_name_info built from
3709 NAME/MATCH_TYPE/COMPLETION_MODE matches the symbols in the mock
3710 index. EXPECTED_LIST is the list of expected matches, in expected
3711 matching order. If no match expected, then an empty list is
3712 specified. Returns true on success. On failure prints a warning
3713 indicating the file:line that failed, and returns false. */
3716 check_match (const char *file
, int line
,
3717 mock_mapped_index
&mock_index
,
3718 const char *name
, symbol_name_match_type match_type
,
3719 bool completion_mode
,
3720 std::initializer_list
<const char *> expected_list
,
3721 dwarf2_per_objfile
*per_objfile
)
3723 lookup_name_info
lookup_name (name
, match_type
, completion_mode
);
3725 bool matched
= true;
3727 auto mismatch
= [&] (const char *expected_str
,
3730 warning (_("%s:%d: match_type=%s, looking-for=\"%s\", "
3731 "expected=\"%s\", got=\"%s\"\n"),
3733 (match_type
== symbol_name_match_type::FULL
3735 name
, string_or_null (expected_str
), string_or_null (got
));
3739 auto expected_it
= expected_list
.begin ();
3740 auto expected_end
= expected_list
.end ();
3742 dw2_expand_symtabs_matching_symbol (mock_index
, lookup_name
,
3744 [&] (offset_type idx
)
3746 const char *matched_name
= mock_index
.symbol_name_at (idx
, per_objfile
);
3747 const char *expected_str
3748 = expected_it
== expected_end
? NULL
: *expected_it
++;
3750 if (expected_str
== NULL
|| strcmp (expected_str
, matched_name
) != 0)
3751 mismatch (expected_str
, matched_name
);
3755 const char *expected_str
3756 = expected_it
== expected_end
? NULL
: *expected_it
++;
3757 if (expected_str
!= NULL
)
3758 mismatch (expected_str
, NULL
);
3763 /* The symbols added to the mock mapped_index for testing (in
3765 static const char *test_symbols
[] = {
3774 "ns2::tmpl<int>::foo2",
3775 "(anonymous namespace)::A::B::C",
3777 /* These are used to check that the increment-last-char in the
3778 matching algorithm for completion doesn't match "t1_fund" when
3779 completing "t1_func". */
3785 /* A UTF-8 name with multi-byte sequences to make sure that
3786 cp-name-parser understands this as a single identifier ("função"
3787 is "function" in PT). */
3790 /* \377 (0xff) is Latin1 'ÿ'. */
3793 /* \377 (0xff) is Latin1 'ÿ'. */
3797 /* A name with all sorts of complications. Starts with "z" to make
3798 it easier for the completion tests below. */
3799 #define Z_SYM_NAME \
3800 "z::std::tuple<(anonymous namespace)::ui*, std::bar<(anonymous namespace)::ui> >" \
3801 "::tuple<(anonymous namespace)::ui*, " \
3802 "std::default_delete<(anonymous namespace)::ui>, void>"
3807 /* Returns true if the mapped_index_base::find_name_component_bounds
3808 method finds EXPECTED_SYMS in INDEX when looking for SEARCH_NAME,
3809 in completion mode. */
3812 check_find_bounds_finds (mapped_index_base
&index
,
3813 const char *search_name
,
3814 gdb::array_view
<const char *> expected_syms
,
3815 dwarf2_per_objfile
*per_objfile
)
3817 lookup_name_info
lookup_name (search_name
,
3818 symbol_name_match_type::FULL
, true);
3820 auto bounds
= index
.find_name_components_bounds (lookup_name
,
3824 size_t distance
= std::distance (bounds
.first
, bounds
.second
);
3825 if (distance
!= expected_syms
.size ())
3828 for (size_t exp_elem
= 0; exp_elem
< distance
; exp_elem
++)
3830 auto nc_elem
= bounds
.first
+ exp_elem
;
3831 const char *qualified
= index
.symbol_name_at (nc_elem
->idx
, per_objfile
);
3832 if (strcmp (qualified
, expected_syms
[exp_elem
]) != 0)
3839 /* Test the lower-level mapped_index::find_name_component_bounds
3843 test_mapped_index_find_name_component_bounds ()
3845 mock_mapped_index
mock_index (test_symbols
);
3847 mock_index
.build_name_components (NULL
/* per_objfile */);
3849 /* Test the lower-level mapped_index::find_name_component_bounds
3850 method in completion mode. */
3852 static const char *expected_syms
[] = {
3857 SELF_CHECK (check_find_bounds_finds
3858 (mock_index
, "t1_func", expected_syms
,
3859 NULL
/* per_objfile */));
3862 /* Check that the increment-last-char in the name matching algorithm
3863 for completion doesn't get confused with Ansi1 'ÿ' / 0xff. */
3865 static const char *expected_syms1
[] = {
3869 SELF_CHECK (check_find_bounds_finds
3870 (mock_index
, "\377", expected_syms1
, NULL
/* per_objfile */));
3872 static const char *expected_syms2
[] = {
3875 SELF_CHECK (check_find_bounds_finds
3876 (mock_index
, "\377\377", expected_syms2
,
3877 NULL
/* per_objfile */));
3881 /* Test dw2_expand_symtabs_matching_symbol. */
3884 test_dw2_expand_symtabs_matching_symbol ()
3886 mock_mapped_index
mock_index (test_symbols
);
3888 /* We let all tests run until the end even if some fails, for debug
3890 bool any_mismatch
= false;
3892 /* Create the expected symbols list (an initializer_list). Needed
3893 because lists have commas, and we need to pass them to CHECK,
3894 which is a macro. */
3895 #define EXPECT(...) { __VA_ARGS__ }
3897 /* Wrapper for check_match that passes down the current
3898 __FILE__/__LINE__. */
3899 #define CHECK_MATCH(NAME, MATCH_TYPE, COMPLETION_MODE, EXPECTED_LIST) \
3900 any_mismatch |= !check_match (__FILE__, __LINE__, \
3902 NAME, MATCH_TYPE, COMPLETION_MODE, \
3903 EXPECTED_LIST, NULL)
3905 /* Identity checks. */
3906 for (const char *sym
: test_symbols
)
3908 /* Should be able to match all existing symbols. */
3909 CHECK_MATCH (sym
, symbol_name_match_type::FULL
, false,
3912 /* Should be able to match all existing symbols with
3914 std::string with_params
= std::string (sym
) + "(int)";
3915 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
3918 /* Should be able to match all existing symbols with
3919 parameters and qualifiers. */
3920 with_params
= std::string (sym
) + " ( int ) const";
3921 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
3924 /* This should really find sym, but cp-name-parser.y doesn't
3925 know about lvalue/rvalue qualifiers yet. */
3926 with_params
= std::string (sym
) + " ( int ) &&";
3927 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
3931 /* Check that the name matching algorithm for completion doesn't get
3932 confused with Latin1 'ÿ' / 0xff. */
3934 static const char str
[] = "\377";
3935 CHECK_MATCH (str
, symbol_name_match_type::FULL
, true,
3936 EXPECT ("\377", "\377\377123"));
3939 /* Check that the increment-last-char in the matching algorithm for
3940 completion doesn't match "t1_fund" when completing "t1_func". */
3942 static const char str
[] = "t1_func";
3943 CHECK_MATCH (str
, symbol_name_match_type::FULL
, true,
3944 EXPECT ("t1_func", "t1_func1"));
3947 /* Check that completion mode works at each prefix of the expected
3950 static const char str
[] = "function(int)";
3951 size_t len
= strlen (str
);
3954 for (size_t i
= 1; i
< len
; i
++)
3956 lookup
.assign (str
, i
);
3957 CHECK_MATCH (lookup
.c_str (), symbol_name_match_type::FULL
, true,
3958 EXPECT ("function"));
3962 /* While "w" is a prefix of both components, the match function
3963 should still only be called once. */
3965 CHECK_MATCH ("w", symbol_name_match_type::FULL
, true,
3967 CHECK_MATCH ("w", symbol_name_match_type::WILD
, true,
3971 /* Same, with a "complicated" symbol. */
3973 static const char str
[] = Z_SYM_NAME
;
3974 size_t len
= strlen (str
);
3977 for (size_t i
= 1; i
< len
; i
++)
3979 lookup
.assign (str
, i
);
3980 CHECK_MATCH (lookup
.c_str (), symbol_name_match_type::FULL
, true,
3981 EXPECT (Z_SYM_NAME
));
3985 /* In FULL mode, an incomplete symbol doesn't match. */
3987 CHECK_MATCH ("std::zfunction(int", symbol_name_match_type::FULL
, false,
3991 /* A complete symbol with parameters matches any overload, since the
3992 index has no overload info. */
3994 CHECK_MATCH ("std::zfunction(int)", symbol_name_match_type::FULL
, true,
3995 EXPECT ("std::zfunction", "std::zfunction2"));
3996 CHECK_MATCH ("zfunction(int)", symbol_name_match_type::WILD
, true,
3997 EXPECT ("std::zfunction", "std::zfunction2"));
3998 CHECK_MATCH ("zfunc", symbol_name_match_type::WILD
, true,
3999 EXPECT ("std::zfunction", "std::zfunction2"));
4002 /* Check that whitespace is ignored appropriately. A symbol with a
4003 template argument list. */
4005 static const char expected
[] = "ns::foo<int>";
4006 CHECK_MATCH ("ns :: foo < int > ", symbol_name_match_type::FULL
, false,
4008 CHECK_MATCH ("foo < int > ", symbol_name_match_type::WILD
, false,
4012 /* Check that whitespace is ignored appropriately. A symbol with a
4013 template argument list that includes a pointer. */
4015 static const char expected
[] = "ns::foo<char*>";
4016 /* Try both completion and non-completion modes. */
4017 static const bool completion_mode
[2] = {false, true};
4018 for (size_t i
= 0; i
< 2; i
++)
4020 CHECK_MATCH ("ns :: foo < char * >", symbol_name_match_type::FULL
,
4021 completion_mode
[i
], EXPECT (expected
));
4022 CHECK_MATCH ("foo < char * >", symbol_name_match_type::WILD
,
4023 completion_mode
[i
], EXPECT (expected
));
4025 CHECK_MATCH ("ns :: foo < char * > (int)", symbol_name_match_type::FULL
,
4026 completion_mode
[i
], EXPECT (expected
));
4027 CHECK_MATCH ("foo < char * > (int)", symbol_name_match_type::WILD
,
4028 completion_mode
[i
], EXPECT (expected
));
4033 /* Check method qualifiers are ignored. */
4034 static const char expected
[] = "ns::foo<char*>";
4035 CHECK_MATCH ("ns :: foo < char * > ( int ) const",
4036 symbol_name_match_type::FULL
, true, EXPECT (expected
));
4037 CHECK_MATCH ("ns :: foo < char * > ( int ) &&",
4038 symbol_name_match_type::FULL
, true, EXPECT (expected
));
4039 CHECK_MATCH ("foo < char * > ( int ) const",
4040 symbol_name_match_type::WILD
, true, EXPECT (expected
));
4041 CHECK_MATCH ("foo < char * > ( int ) &&",
4042 symbol_name_match_type::WILD
, true, EXPECT (expected
));
4045 /* Test lookup names that don't match anything. */
4047 CHECK_MATCH ("bar2", symbol_name_match_type::WILD
, false,
4050 CHECK_MATCH ("doesntexist", symbol_name_match_type::FULL
, false,
4054 /* Some wild matching tests, exercising "(anonymous namespace)",
4055 which should not be confused with a parameter list. */
4057 static const char *syms
[] = {
4061 "A :: B :: C ( int )",
4066 for (const char *s
: syms
)
4068 CHECK_MATCH (s
, symbol_name_match_type::WILD
, false,
4069 EXPECT ("(anonymous namespace)::A::B::C"));
4074 static const char expected
[] = "ns2::tmpl<int>::foo2";
4075 CHECK_MATCH ("tmp", symbol_name_match_type::WILD
, true,
4077 CHECK_MATCH ("tmpl<", symbol_name_match_type::WILD
, true,
4081 SELF_CHECK (!any_mismatch
);
4090 test_mapped_index_find_name_component_bounds ();
4091 test_dw2_expand_symtabs_matching_symbol ();
4094 }} // namespace selftests::dw2_expand_symtabs_matching
4096 #endif /* GDB_SELF_TEST */
4098 /* If FILE_MATCHER is NULL or if PER_CU has
4099 dwarf2_per_cu_quick_data::MARK set (see
4100 dw_expand_symtabs_matching_file_matcher), expand the CU and call
4101 EXPANSION_NOTIFY on it. */
4104 dw2_expand_symtabs_matching_one
4105 (dwarf2_per_cu_data
*per_cu
,
4106 dwarf2_per_objfile
*per_objfile
,
4107 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
4108 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
)
4110 if (file_matcher
== NULL
|| per_cu
->v
.quick
->mark
)
4112 bool symtab_was_null
= !per_objfile
->symtab_set_p (per_cu
);
4114 compunit_symtab
*symtab
4115 = dw2_instantiate_symtab (per_cu
, per_objfile
, false);
4116 gdb_assert (symtab
!= nullptr);
4118 if (expansion_notify
!= NULL
&& symtab_was_null
)
4119 return expansion_notify (symtab
);
4124 /* Helper for dw2_expand_matching symtabs. Called on each symbol
4125 matched, to expand corresponding CUs that were marked. IDX is the
4126 index of the symbol name that matched. */
4129 dw2_expand_marked_cus
4130 (dwarf2_per_objfile
*per_objfile
, offset_type idx
,
4131 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
4132 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
4133 block_search_flags search_flags
,
4136 offset_type vec_len
, vec_idx
;
4137 bool global_seen
= false;
4138 mapped_index
&index
= *per_objfile
->per_bfd
->index_table
;
4140 offset_view
vec (index
.constant_pool
.slice (index
.symbol_vec_index (idx
)));
4142 for (vec_idx
= 0; vec_idx
< vec_len
; ++vec_idx
)
4144 offset_type cu_index_and_attrs
= vec
[vec_idx
+ 1];
4145 /* This value is only valid for index versions >= 7. */
4146 int is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs
);
4147 gdb_index_symbol_kind symbol_kind
=
4148 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
4149 int cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
4150 /* Only check the symbol attributes if they're present.
4151 Indices prior to version 7 don't record them,
4152 and indices >= 7 may elide them for certain symbols
4153 (gold does this). */
4156 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_NONE
);
4158 /* Work around gold/15646. */
4161 && symbol_kind
== GDB_INDEX_SYMBOL_KIND_TYPE
)
4169 /* Only check the symbol's kind if it has one. */
4174 if ((search_flags
& SEARCH_STATIC_BLOCK
) == 0)
4179 if ((search_flags
& SEARCH_GLOBAL_BLOCK
) == 0)
4185 case VARIABLES_DOMAIN
:
4186 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
)
4189 case FUNCTIONS_DOMAIN
:
4190 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
)
4194 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
4197 case MODULES_DOMAIN
:
4198 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_OTHER
)
4206 /* Don't crash on bad data. */
4207 if (cu_index
>= per_objfile
->per_bfd
->all_comp_units
.size ())
4209 complaint (_(".gdb_index entry has bad CU index"
4210 " [in module %s]"), objfile_name (per_objfile
->objfile
));
4214 dwarf2_per_cu_data
*per_cu
= per_objfile
->per_bfd
->get_cu (cu_index
);
4215 if (!dw2_expand_symtabs_matching_one (per_cu
, per_objfile
, file_matcher
,
4223 /* If FILE_MATCHER is non-NULL, set all the
4224 dwarf2_per_cu_quick_data::MARK of the current DWARF2_PER_OBJFILE
4225 that match FILE_MATCHER. */
4228 dw_expand_symtabs_matching_file_matcher
4229 (dwarf2_per_objfile
*per_objfile
,
4230 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
)
4232 if (file_matcher
== NULL
)
4235 htab_up
visited_found (htab_create_alloc (10, htab_hash_pointer
,
4237 NULL
, xcalloc
, xfree
));
4238 htab_up
visited_not_found (htab_create_alloc (10, htab_hash_pointer
,
4240 NULL
, xcalloc
, xfree
));
4242 /* The rule is CUs specify all the files, including those used by
4243 any TU, so there's no need to scan TUs here. */
4245 for (const auto &per_cu
: per_objfile
->per_bfd
->all_comp_units
)
4249 if (per_cu
->is_debug_types
)
4251 per_cu
->v
.quick
->mark
= 0;
4253 /* We only need to look at symtabs not already expanded. */
4254 if (per_objfile
->symtab_set_p (per_cu
.get ()))
4257 quick_file_names
*file_data
= dw2_get_file_names (per_cu
.get (),
4259 if (file_data
== NULL
)
4262 if (htab_find (visited_not_found
.get (), file_data
) != NULL
)
4264 else if (htab_find (visited_found
.get (), file_data
) != NULL
)
4266 per_cu
->v
.quick
->mark
= 1;
4270 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
4272 const char *this_real_name
;
4274 if (file_matcher (file_data
->file_names
[j
], false))
4276 per_cu
->v
.quick
->mark
= 1;
4280 /* Before we invoke realpath, which can get expensive when many
4281 files are involved, do a quick comparison of the basenames. */
4282 if (!basenames_may_differ
4283 && !file_matcher (lbasename (file_data
->file_names
[j
]),
4287 this_real_name
= dw2_get_real_path (per_objfile
, file_data
, j
);
4288 if (file_matcher (this_real_name
, false))
4290 per_cu
->v
.quick
->mark
= 1;
4295 void **slot
= htab_find_slot (per_cu
->v
.quick
->mark
4296 ? visited_found
.get ()
4297 : visited_not_found
.get (),
4304 dwarf2_gdb_index::expand_symtabs_matching
4305 (struct objfile
*objfile
,
4306 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
4307 const lookup_name_info
*lookup_name
,
4308 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
4309 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
4310 block_search_flags search_flags
,
4312 enum search_domain kind
)
4314 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
4316 /* index_table is NULL if OBJF_READNOW. */
4317 if (!per_objfile
->per_bfd
->index_table
)
4320 dw_expand_symtabs_matching_file_matcher (per_objfile
, file_matcher
);
4322 if (symbol_matcher
== NULL
&& lookup_name
== NULL
)
4324 for (const auto &per_cu
: per_objfile
->per_bfd
->all_comp_units
)
4328 if (!dw2_expand_symtabs_matching_one (per_cu
.get (), per_objfile
,
4336 mapped_index
&index
= *per_objfile
->per_bfd
->index_table
;
4339 = dw2_expand_symtabs_matching_symbol (index
, *lookup_name
,
4341 [&] (offset_type idx
)
4343 if (!dw2_expand_marked_cus (per_objfile
, idx
, file_matcher
,
4344 expansion_notify
, search_flags
, kind
))
4352 /* A helper for dw2_find_pc_sect_compunit_symtab which finds the most specific
4355 static struct compunit_symtab
*
4356 recursively_find_pc_sect_compunit_symtab (struct compunit_symtab
*cust
,
4361 if (COMPUNIT_BLOCKVECTOR (cust
) != NULL
4362 && blockvector_contains_pc (COMPUNIT_BLOCKVECTOR (cust
), pc
))
4365 if (cust
->includes
== NULL
)
4368 for (i
= 0; cust
->includes
[i
]; ++i
)
4370 struct compunit_symtab
*s
= cust
->includes
[i
];
4372 s
= recursively_find_pc_sect_compunit_symtab (s
, pc
);
4380 struct compunit_symtab
*
4381 dwarf2_base_index_functions::find_pc_sect_compunit_symtab
4382 (struct objfile
*objfile
,
4383 struct bound_minimal_symbol msymbol
,
4385 struct obj_section
*section
,
4388 struct dwarf2_per_cu_data
*data
;
4389 struct compunit_symtab
*result
;
4391 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
4392 if (per_objfile
->per_bfd
->index_addrmap
== nullptr)
4395 CORE_ADDR baseaddr
= objfile
->text_section_offset ();
4396 data
= ((struct dwarf2_per_cu_data
*)
4397 addrmap_find (per_objfile
->per_bfd
->index_addrmap
,
4402 if (warn_if_readin
&& per_objfile
->symtab_set_p (data
))
4403 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
4404 paddress (objfile
->arch (), pc
));
4406 result
= recursively_find_pc_sect_compunit_symtab
4407 (dw2_instantiate_symtab (data
, per_objfile
, false), pc
);
4409 gdb_assert (result
!= NULL
);
4414 dwarf2_base_index_functions::map_symbol_filenames
4415 (struct objfile
*objfile
,
4416 gdb::function_view
<symbol_filename_ftype
> fun
,
4419 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
4421 /* Use caches to ensure we only call FUN once for each filename. */
4422 filename_seen_cache filenames_cache
;
4423 std::unordered_set
<quick_file_names
*> qfn_cache
;
4425 /* The rule is CUs specify all the files, including those used by any TU,
4426 so there's no need to scan TUs here. We can ignore file names coming
4427 from already-expanded CUs. It is possible that an expanded CU might
4428 reuse the file names data from a currently unexpanded CU, in this
4429 case we don't want to report the files from the unexpanded CU. */
4431 for (const auto &per_cu
: per_objfile
->per_bfd
->all_comp_units
)
4433 if (per_objfile
->symtab_set_p (per_cu
.get ()))
4435 if (per_cu
->v
.quick
->file_names
!= nullptr)
4436 qfn_cache
.insert (per_cu
->v
.quick
->file_names
);
4440 for (const auto &per_cu
: per_objfile
->per_bfd
->all_comp_units
)
4442 /* We only need to look at symtabs not already expanded. */
4443 if (per_objfile
->symtab_set_p (per_cu
.get ()))
4446 quick_file_names
*file_data
= dw2_get_file_names (per_cu
.get (),
4448 if (file_data
== nullptr
4449 || qfn_cache
.find (file_data
) != qfn_cache
.end ())
4452 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
4454 const char *filename
= file_data
->file_names
[j
];
4455 filenames_cache
.seen (filename
);
4459 filenames_cache
.traverse ([&] (const char *filename
)
4461 gdb::unique_xmalloc_ptr
<char> this_real_name
;
4464 this_real_name
= gdb_realpath (filename
);
4465 fun (filename
, this_real_name
.get ());
4470 dwarf2_base_index_functions::has_symbols (struct objfile
*objfile
)
4475 /* See quick_symbol_functions::has_unexpanded_symtabs in quick-symbol.h. */
4478 dwarf2_base_index_functions::has_unexpanded_symtabs (struct objfile
*objfile
)
4480 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
4482 for (const auto &per_cu
: per_objfile
->per_bfd
->all_comp_units
)
4484 /* Is this already expanded? */
4485 if (per_objfile
->symtab_set_p (per_cu
.get ()))
4488 /* It has not yet been expanded. */
4495 /* DWARF-5 debug_names reader. */
4497 /* DWARF-5 augmentation string for GDB's DW_IDX_GNU_* extension. */
4498 static const gdb_byte dwarf5_augmentation
[] = { 'G', 'D', 'B', 0 };
4500 /* A helper function that reads the .debug_names section in SECTION
4501 and fills in MAP. FILENAME is the name of the file containing the
4502 section; it is used for error reporting.
4504 Returns true if all went well, false otherwise. */
4507 read_debug_names_from_section (struct objfile
*objfile
,
4508 const char *filename
,
4509 struct dwarf2_section_info
*section
,
4510 mapped_debug_names
&map
)
4512 if (section
->empty ())
4515 /* Older elfutils strip versions could keep the section in the main
4516 executable while splitting it for the separate debug info file. */
4517 if ((section
->get_flags () & SEC_HAS_CONTENTS
) == 0)
4520 section
->read (objfile
);
4522 map
.dwarf5_byte_order
= gdbarch_byte_order (objfile
->arch ());
4524 const gdb_byte
*addr
= section
->buffer
;
4526 bfd
*const abfd
= section
->get_bfd_owner ();
4528 unsigned int bytes_read
;
4529 LONGEST length
= read_initial_length (abfd
, addr
, &bytes_read
);
4532 map
.dwarf5_is_dwarf64
= bytes_read
!= 4;
4533 map
.offset_size
= map
.dwarf5_is_dwarf64
? 8 : 4;
4534 if (bytes_read
+ length
!= section
->size
)
4536 /* There may be multiple per-CU indices. */
4537 warning (_("Section .debug_names in %s length %s does not match "
4538 "section length %s, ignoring .debug_names."),
4539 filename
, plongest (bytes_read
+ length
),
4540 pulongest (section
->size
));
4544 /* The version number. */
4545 uint16_t version
= read_2_bytes (abfd
, addr
);
4549 warning (_("Section .debug_names in %s has unsupported version %d, "
4550 "ignoring .debug_names."),
4556 uint16_t padding
= read_2_bytes (abfd
, addr
);
4560 warning (_("Section .debug_names in %s has unsupported padding %d, "
4561 "ignoring .debug_names."),
4566 /* comp_unit_count - The number of CUs in the CU list. */
4567 map
.cu_count
= read_4_bytes (abfd
, addr
);
4570 /* local_type_unit_count - The number of TUs in the local TU
4572 map
.tu_count
= read_4_bytes (abfd
, addr
);
4575 /* foreign_type_unit_count - The number of TUs in the foreign TU
4577 uint32_t foreign_tu_count
= read_4_bytes (abfd
, addr
);
4579 if (foreign_tu_count
!= 0)
4581 warning (_("Section .debug_names in %s has unsupported %lu foreign TUs, "
4582 "ignoring .debug_names."),
4583 filename
, static_cast<unsigned long> (foreign_tu_count
));
4587 /* bucket_count - The number of hash buckets in the hash lookup
4589 map
.bucket_count
= read_4_bytes (abfd
, addr
);
4592 /* name_count - The number of unique names in the index. */
4593 map
.name_count
= read_4_bytes (abfd
, addr
);
4596 /* abbrev_table_size - The size in bytes of the abbreviations
4598 uint32_t abbrev_table_size
= read_4_bytes (abfd
, addr
);
4601 /* augmentation_string_size - The size in bytes of the augmentation
4602 string. This value is rounded up to a multiple of 4. */
4603 uint32_t augmentation_string_size
= read_4_bytes (abfd
, addr
);
4605 map
.augmentation_is_gdb
= ((augmentation_string_size
4606 == sizeof (dwarf5_augmentation
))
4607 && memcmp (addr
, dwarf5_augmentation
,
4608 sizeof (dwarf5_augmentation
)) == 0);
4609 augmentation_string_size
+= (-augmentation_string_size
) & 3;
4610 addr
+= augmentation_string_size
;
4613 map
.cu_table_reordered
= addr
;
4614 addr
+= map
.cu_count
* map
.offset_size
;
4616 /* List of Local TUs */
4617 map
.tu_table_reordered
= addr
;
4618 addr
+= map
.tu_count
* map
.offset_size
;
4620 /* Hash Lookup Table */
4621 map
.bucket_table_reordered
= reinterpret_cast<const uint32_t *> (addr
);
4622 addr
+= map
.bucket_count
* 4;
4623 map
.hash_table_reordered
= reinterpret_cast<const uint32_t *> (addr
);
4624 addr
+= map
.name_count
* 4;
4627 map
.name_table_string_offs_reordered
= addr
;
4628 addr
+= map
.name_count
* map
.offset_size
;
4629 map
.name_table_entry_offs_reordered
= addr
;
4630 addr
+= map
.name_count
* map
.offset_size
;
4632 const gdb_byte
*abbrev_table_start
= addr
;
4635 const ULONGEST index_num
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
4640 const auto insertpair
4641 = map
.abbrev_map
.emplace (index_num
, mapped_debug_names::index_val ());
4642 if (!insertpair
.second
)
4644 warning (_("Section .debug_names in %s has duplicate index %s, "
4645 "ignoring .debug_names."),
4646 filename
, pulongest (index_num
));
4649 mapped_debug_names::index_val
&indexval
= insertpair
.first
->second
;
4650 indexval
.dwarf_tag
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
4655 mapped_debug_names::index_val::attr attr
;
4656 attr
.dw_idx
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
4658 attr
.form
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
4660 if (attr
.form
== DW_FORM_implicit_const
)
4662 attr
.implicit_const
= read_signed_leb128 (abfd
, addr
,
4666 if (attr
.dw_idx
== 0 && attr
.form
== 0)
4668 indexval
.attr_vec
.push_back (std::move (attr
));
4671 if (addr
!= abbrev_table_start
+ abbrev_table_size
)
4673 warning (_("Section .debug_names in %s has abbreviation_table "
4674 "of size %s vs. written as %u, ignoring .debug_names."),
4675 filename
, plongest (addr
- abbrev_table_start
),
4679 map
.entry_pool
= addr
;
4684 /* A helper for create_cus_from_debug_names that handles the MAP's CU
4688 create_cus_from_debug_names_list (dwarf2_per_bfd
*per_bfd
,
4689 const mapped_debug_names
&map
,
4690 dwarf2_section_info
§ion
,
4693 if (!map
.augmentation_is_gdb
)
4695 for (uint32_t i
= 0; i
< map
.cu_count
; ++i
)
4697 sect_offset sect_off
4698 = (sect_offset
) (extract_unsigned_integer
4699 (map
.cu_table_reordered
+ i
* map
.offset_size
,
4701 map
.dwarf5_byte_order
));
4702 /* We don't know the length of the CU, because the CU list in a
4703 .debug_names index can be incomplete, so we can't use the start
4704 of the next CU as end of this CU. We create the CUs here with
4705 length 0, and in cutu_reader::cutu_reader we'll fill in the
4707 dwarf2_per_cu_data_up per_cu
4708 = create_cu_from_index_list (per_bfd
, §ion
, is_dwz
,
4710 per_bfd
->all_comp_units
.push_back (std::move (per_cu
));
4715 sect_offset sect_off_prev
;
4716 for (uint32_t i
= 0; i
<= map
.cu_count
; ++i
)
4718 sect_offset sect_off_next
;
4719 if (i
< map
.cu_count
)
4722 = (sect_offset
) (extract_unsigned_integer
4723 (map
.cu_table_reordered
+ i
* map
.offset_size
,
4725 map
.dwarf5_byte_order
));
4728 sect_off_next
= (sect_offset
) section
.size
;
4731 const ULONGEST length
= sect_off_next
- sect_off_prev
;
4732 dwarf2_per_cu_data_up per_cu
4733 = create_cu_from_index_list (per_bfd
, §ion
, is_dwz
,
4734 sect_off_prev
, length
);
4735 per_bfd
->all_comp_units
.push_back (std::move (per_cu
));
4737 sect_off_prev
= sect_off_next
;
4741 /* Read the CU list from the mapped index, and use it to create all
4742 the CU objects for this dwarf2_per_objfile. */
4745 create_cus_from_debug_names (dwarf2_per_bfd
*per_bfd
,
4746 const mapped_debug_names
&map
,
4747 const mapped_debug_names
&dwz_map
)
4749 gdb_assert (per_bfd
->all_comp_units
.empty ());
4750 per_bfd
->all_comp_units
.reserve (map
.cu_count
+ dwz_map
.cu_count
);
4752 create_cus_from_debug_names_list (per_bfd
, map
, per_bfd
->info
,
4753 false /* is_dwz */);
4755 if (dwz_map
.cu_count
== 0)
4758 dwz_file
*dwz
= dwarf2_get_dwz_file (per_bfd
);
4759 create_cus_from_debug_names_list (per_bfd
, dwz_map
, dwz
->info
,
4763 /* Read .debug_names. If everything went ok, initialize the "quick"
4764 elements of all the CUs and return true. Otherwise, return false. */
4767 dwarf2_read_debug_names (dwarf2_per_objfile
*per_objfile
)
4769 std::unique_ptr
<mapped_debug_names
> map (new mapped_debug_names
);
4770 mapped_debug_names dwz_map
;
4771 struct objfile
*objfile
= per_objfile
->objfile
;
4772 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
4774 if (!read_debug_names_from_section (objfile
, objfile_name (objfile
),
4775 &per_bfd
->debug_names
, *map
))
4778 /* Don't use the index if it's empty. */
4779 if (map
->name_count
== 0)
4782 /* If there is a .dwz file, read it so we can get its CU list as
4784 dwz_file
*dwz
= dwarf2_get_dwz_file (per_bfd
);
4787 if (!read_debug_names_from_section (objfile
,
4788 bfd_get_filename (dwz
->dwz_bfd
.get ()),
4789 &dwz
->debug_names
, dwz_map
))
4791 warning (_("could not read '.debug_names' section from %s; skipping"),
4792 bfd_get_filename (dwz
->dwz_bfd
.get ()));
4797 create_cus_from_debug_names (per_bfd
, *map
, dwz_map
);
4799 if (map
->tu_count
!= 0)
4801 /* We can only handle a single .debug_types when we have an
4803 if (per_bfd
->types
.size () != 1)
4806 dwarf2_section_info
*section
= &per_bfd
->types
[0];
4808 create_signatured_type_table_from_debug_names
4809 (per_objfile
, *map
, section
, &per_bfd
->abbrev
);
4812 create_addrmap_from_aranges (per_objfile
, &per_bfd
->debug_aranges
);
4814 per_bfd
->debug_names_table
= std::move (map
);
4815 per_bfd
->using_index
= 1;
4816 per_bfd
->quick_file_names_table
=
4817 create_quick_file_names_table (per_bfd
->all_comp_units
.size ());
4822 /* Type used to manage iterating over all CUs looking for a symbol for
4825 class dw2_debug_names_iterator
4828 dw2_debug_names_iterator (const mapped_debug_names
&map
,
4829 block_search_flags block_index
,
4831 const char *name
, dwarf2_per_objfile
*per_objfile
)
4832 : m_map (map
), m_block_index (block_index
), m_domain (domain
),
4833 m_addr (find_vec_in_debug_names (map
, name
, per_objfile
)),
4834 m_per_objfile (per_objfile
)
4837 dw2_debug_names_iterator (const mapped_debug_names
&map
,
4838 search_domain search
, uint32_t namei
,
4839 dwarf2_per_objfile
*per_objfile
,
4840 domain_enum domain
= UNDEF_DOMAIN
)
4844 m_addr (find_vec_in_debug_names (map
, namei
, per_objfile
)),
4845 m_per_objfile (per_objfile
)
4848 dw2_debug_names_iterator (const mapped_debug_names
&map
,
4849 block_search_flags block_index
, domain_enum domain
,
4850 uint32_t namei
, dwarf2_per_objfile
*per_objfile
)
4851 : m_map (map
), m_block_index (block_index
), m_domain (domain
),
4852 m_addr (find_vec_in_debug_names (map
, namei
, per_objfile
)),
4853 m_per_objfile (per_objfile
)
4856 /* Return the next matching CU or NULL if there are no more. */
4857 dwarf2_per_cu_data
*next ();
4860 static const gdb_byte
*find_vec_in_debug_names (const mapped_debug_names
&map
,
4862 dwarf2_per_objfile
*per_objfile
);
4863 static const gdb_byte
*find_vec_in_debug_names (const mapped_debug_names
&map
,
4865 dwarf2_per_objfile
*per_objfile
);
4867 /* The internalized form of .debug_names. */
4868 const mapped_debug_names
&m_map
;
4870 /* Restrict the search to these blocks. */
4871 block_search_flags m_block_index
= (SEARCH_GLOBAL_BLOCK
4872 | SEARCH_STATIC_BLOCK
);
4874 /* The kind of symbol we're looking for. */
4875 const domain_enum m_domain
= UNDEF_DOMAIN
;
4876 const search_domain m_search
= ALL_DOMAIN
;
4878 /* The list of CUs from the index entry of the symbol, or NULL if
4880 const gdb_byte
*m_addr
;
4882 dwarf2_per_objfile
*m_per_objfile
;
4886 mapped_debug_names::namei_to_name
4887 (uint32_t namei
, dwarf2_per_objfile
*per_objfile
) const
4889 const ULONGEST namei_string_offs
4890 = extract_unsigned_integer ((name_table_string_offs_reordered
4891 + namei
* offset_size
),
4894 return read_indirect_string_at_offset (per_objfile
, namei_string_offs
);
4897 /* Find a slot in .debug_names for the object named NAME. If NAME is
4898 found, return pointer to its pool data. If NAME cannot be found,
4902 dw2_debug_names_iterator::find_vec_in_debug_names
4903 (const mapped_debug_names
&map
, const char *name
,
4904 dwarf2_per_objfile
*per_objfile
)
4906 int (*cmp
) (const char *, const char *);
4908 gdb::unique_xmalloc_ptr
<char> without_params
;
4909 if (current_language
->la_language
== language_cplus
4910 || current_language
->la_language
== language_fortran
4911 || current_language
->la_language
== language_d
)
4913 /* NAME is already canonical. Drop any qualifiers as
4914 .debug_names does not contain any. */
4916 if (strchr (name
, '(') != NULL
)
4918 without_params
= cp_remove_params (name
);
4919 if (without_params
!= NULL
)
4920 name
= without_params
.get ();
4924 cmp
= (case_sensitivity
== case_sensitive_on
? strcmp
: strcasecmp
);
4926 const uint32_t full_hash
= dwarf5_djb_hash (name
);
4928 = extract_unsigned_integer (reinterpret_cast<const gdb_byte
*>
4929 (map
.bucket_table_reordered
4930 + (full_hash
% map
.bucket_count
)), 4,
4931 map
.dwarf5_byte_order
);
4935 if (namei
>= map
.name_count
)
4937 complaint (_("Wrong .debug_names with name index %u but name_count=%u "
4939 namei
, map
.name_count
,
4940 objfile_name (per_objfile
->objfile
));
4946 const uint32_t namei_full_hash
4947 = extract_unsigned_integer (reinterpret_cast<const gdb_byte
*>
4948 (map
.hash_table_reordered
+ namei
), 4,
4949 map
.dwarf5_byte_order
);
4950 if (full_hash
% map
.bucket_count
!= namei_full_hash
% map
.bucket_count
)
4953 if (full_hash
== namei_full_hash
)
4955 const char *const namei_string
= map
.namei_to_name (namei
, per_objfile
);
4957 #if 0 /* An expensive sanity check. */
4958 if (namei_full_hash
!= dwarf5_djb_hash (namei_string
))
4960 complaint (_("Wrong .debug_names hash for string at index %u "
4962 namei
, objfile_name (dwarf2_per_objfile
->objfile
));
4967 if (cmp (namei_string
, name
) == 0)
4969 const ULONGEST namei_entry_offs
4970 = extract_unsigned_integer ((map
.name_table_entry_offs_reordered
4971 + namei
* map
.offset_size
),
4972 map
.offset_size
, map
.dwarf5_byte_order
);
4973 return map
.entry_pool
+ namei_entry_offs
;
4978 if (namei
>= map
.name_count
)
4984 dw2_debug_names_iterator::find_vec_in_debug_names
4985 (const mapped_debug_names
&map
, uint32_t namei
, dwarf2_per_objfile
*per_objfile
)
4987 if (namei
>= map
.name_count
)
4989 complaint (_("Wrong .debug_names with name index %u but name_count=%u "
4991 namei
, map
.name_count
,
4992 objfile_name (per_objfile
->objfile
));
4996 const ULONGEST namei_entry_offs
4997 = extract_unsigned_integer ((map
.name_table_entry_offs_reordered
4998 + namei
* map
.offset_size
),
4999 map
.offset_size
, map
.dwarf5_byte_order
);
5000 return map
.entry_pool
+ namei_entry_offs
;
5003 /* See dw2_debug_names_iterator. */
5005 dwarf2_per_cu_data
*
5006 dw2_debug_names_iterator::next ()
5011 dwarf2_per_bfd
*per_bfd
= m_per_objfile
->per_bfd
;
5012 struct objfile
*objfile
= m_per_objfile
->objfile
;
5013 bfd
*const abfd
= objfile
->obfd
;
5017 unsigned int bytes_read
;
5018 const ULONGEST abbrev
= read_unsigned_leb128 (abfd
, m_addr
, &bytes_read
);
5019 m_addr
+= bytes_read
;
5023 const auto indexval_it
= m_map
.abbrev_map
.find (abbrev
);
5024 if (indexval_it
== m_map
.abbrev_map
.cend ())
5026 complaint (_("Wrong .debug_names undefined abbrev code %s "
5028 pulongest (abbrev
), objfile_name (objfile
));
5031 const mapped_debug_names::index_val
&indexval
= indexval_it
->second
;
5032 enum class symbol_linkage
{
5036 } symbol_linkage_
= symbol_linkage::unknown
;
5037 dwarf2_per_cu_data
*per_cu
= NULL
;
5038 for (const mapped_debug_names::index_val::attr
&attr
: indexval
.attr_vec
)
5043 case DW_FORM_implicit_const
:
5044 ull
= attr
.implicit_const
;
5046 case DW_FORM_flag_present
:
5050 ull
= read_unsigned_leb128 (abfd
, m_addr
, &bytes_read
);
5051 m_addr
+= bytes_read
;
5054 ull
= read_4_bytes (abfd
, m_addr
);
5058 ull
= read_8_bytes (abfd
, m_addr
);
5061 case DW_FORM_ref_sig8
:
5062 ull
= read_8_bytes (abfd
, m_addr
);
5066 complaint (_("Unsupported .debug_names form %s [in module %s]"),
5067 dwarf_form_name (attr
.form
),
5068 objfile_name (objfile
));
5071 switch (attr
.dw_idx
)
5073 case DW_IDX_compile_unit
:
5074 /* Don't crash on bad data. */
5075 if (ull
>= per_bfd
->all_comp_units
.size ())
5077 complaint (_(".debug_names entry has bad CU index %s"
5080 objfile_name (objfile
));
5083 per_cu
= per_bfd
->get_cu (ull
);
5085 case DW_IDX_type_unit
:
5086 /* Don't crash on bad data. */
5087 if (ull
>= per_bfd
->tu_stats
.nr_tus
)
5089 complaint (_(".debug_names entry has bad TU index %s"
5092 objfile_name (objfile
));
5095 per_cu
= per_bfd
->get_cu (ull
+ per_bfd
->tu_stats
.nr_tus
);
5097 case DW_IDX_die_offset
:
5098 /* In a per-CU index (as opposed to a per-module index), index
5099 entries without CU attribute implicitly refer to the single CU. */
5101 per_cu
= per_bfd
->get_cu (0);
5103 case DW_IDX_GNU_internal
:
5104 if (!m_map
.augmentation_is_gdb
)
5106 symbol_linkage_
= symbol_linkage::static_
;
5108 case DW_IDX_GNU_external
:
5109 if (!m_map
.augmentation_is_gdb
)
5111 symbol_linkage_
= symbol_linkage::extern_
;
5116 /* Skip if already read in. */
5117 if (m_per_objfile
->symtab_set_p (per_cu
))
5120 /* Check static vs global. */
5121 if (symbol_linkage_
!= symbol_linkage::unknown
)
5123 if (symbol_linkage_
== symbol_linkage::static_
)
5125 if ((m_block_index
& SEARCH_STATIC_BLOCK
) == 0)
5130 if ((m_block_index
& SEARCH_GLOBAL_BLOCK
) == 0)
5135 /* Match dw2_symtab_iter_next, symbol_kind
5136 and debug_names::psymbol_tag. */
5140 switch (indexval
.dwarf_tag
)
5142 case DW_TAG_variable
:
5143 case DW_TAG_subprogram
:
5144 /* Some types are also in VAR_DOMAIN. */
5145 case DW_TAG_typedef
:
5146 case DW_TAG_structure_type
:
5153 switch (indexval
.dwarf_tag
)
5155 case DW_TAG_typedef
:
5156 case DW_TAG_structure_type
:
5163 switch (indexval
.dwarf_tag
)
5166 case DW_TAG_variable
:
5173 switch (indexval
.dwarf_tag
)
5185 /* Match dw2_expand_symtabs_matching, symbol_kind and
5186 debug_names::psymbol_tag. */
5189 case VARIABLES_DOMAIN
:
5190 switch (indexval
.dwarf_tag
)
5192 case DW_TAG_variable
:
5198 case FUNCTIONS_DOMAIN
:
5199 switch (indexval
.dwarf_tag
)
5201 case DW_TAG_subprogram
:
5208 switch (indexval
.dwarf_tag
)
5210 case DW_TAG_typedef
:
5211 case DW_TAG_structure_type
:
5217 case MODULES_DOMAIN
:
5218 switch (indexval
.dwarf_tag
)
5232 /* This dumps minimal information about .debug_names. It is called
5233 via "mt print objfiles". The gdb.dwarf2/gdb-index.exp testcase
5234 uses this to verify that .debug_names has been loaded. */
5237 dwarf2_debug_names_index::dump (struct objfile
*objfile
)
5239 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
5241 gdb_assert (per_objfile
->per_bfd
->using_index
);
5242 printf_filtered (".debug_names:");
5243 if (per_objfile
->per_bfd
->debug_names_table
)
5244 printf_filtered (" exists\n");
5246 printf_filtered (" faked for \"readnow\"\n");
5247 printf_filtered ("\n");
5251 dwarf2_debug_names_index::expand_matching_symbols
5252 (struct objfile
*objfile
,
5253 const lookup_name_info
&name
, domain_enum domain
,
5255 symbol_compare_ftype
*ordered_compare
)
5257 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
5259 /* debug_names_table is NULL if OBJF_READNOW. */
5260 if (!per_objfile
->per_bfd
->debug_names_table
)
5263 mapped_debug_names
&map
= *per_objfile
->per_bfd
->debug_names_table
;
5264 const block_search_flags block_flags
5265 = global
? SEARCH_GLOBAL_BLOCK
: SEARCH_STATIC_BLOCK
;
5267 const char *match_name
= name
.ada ().lookup_name ().c_str ();
5268 auto matcher
= [&] (const char *symname
)
5270 if (ordered_compare
== nullptr)
5272 return ordered_compare (symname
, match_name
) == 0;
5275 dw2_expand_symtabs_matching_symbol (map
, name
, matcher
,
5276 [&] (offset_type namei
)
5278 /* The name was matched, now expand corresponding CUs that were
5280 dw2_debug_names_iterator
iter (map
, block_flags
, domain
, namei
,
5283 struct dwarf2_per_cu_data
*per_cu
;
5284 while ((per_cu
= iter
.next ()) != NULL
)
5285 dw2_expand_symtabs_matching_one (per_cu
, per_objfile
, nullptr,
5292 dwarf2_debug_names_index::expand_symtabs_matching
5293 (struct objfile
*objfile
,
5294 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
5295 const lookup_name_info
*lookup_name
,
5296 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
5297 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
5298 block_search_flags search_flags
,
5300 enum search_domain kind
)
5302 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
5304 /* debug_names_table is NULL if OBJF_READNOW. */
5305 if (!per_objfile
->per_bfd
->debug_names_table
)
5308 dw_expand_symtabs_matching_file_matcher (per_objfile
, file_matcher
);
5310 if (symbol_matcher
== NULL
&& lookup_name
== NULL
)
5312 for (const auto &per_cu
: per_objfile
->per_bfd
->all_comp_units
)
5316 if (!dw2_expand_symtabs_matching_one (per_cu
.get (), per_objfile
,
5324 mapped_debug_names
&map
= *per_objfile
->per_bfd
->debug_names_table
;
5327 = dw2_expand_symtabs_matching_symbol (map
, *lookup_name
,
5329 [&] (offset_type namei
)
5331 /* The name was matched, now expand corresponding CUs that were
5333 dw2_debug_names_iterator
iter (map
, kind
, namei
, per_objfile
, domain
);
5335 struct dwarf2_per_cu_data
*per_cu
;
5336 while ((per_cu
= iter
.next ()) != NULL
)
5337 if (!dw2_expand_symtabs_matching_one (per_cu
, per_objfile
,
5347 /* Get the content of the .gdb_index section of OBJ. SECTION_OWNER should point
5348 to either a dwarf2_per_bfd or dwz_file object. */
5350 template <typename T
>
5351 static gdb::array_view
<const gdb_byte
>
5352 get_gdb_index_contents_from_section (objfile
*obj
, T
*section_owner
)
5354 dwarf2_section_info
*section
= §ion_owner
->gdb_index
;
5356 if (section
->empty ())
5359 /* Older elfutils strip versions could keep the section in the main
5360 executable while splitting it for the separate debug info file. */
5361 if ((section
->get_flags () & SEC_HAS_CONTENTS
) == 0)
5364 section
->read (obj
);
5366 /* dwarf2_section_info::size is a bfd_size_type, while
5367 gdb::array_view works with size_t. On 32-bit hosts, with
5368 --enable-64-bit-bfd, bfd_size_type is a 64-bit type, while size_t
5369 is 32-bit. So we need an explicit narrowing conversion here.
5370 This is fine, because it's impossible to allocate or mmap an
5371 array/buffer larger than what size_t can represent. */
5372 return gdb::make_array_view (section
->buffer
, section
->size
);
5375 /* Lookup the index cache for the contents of the index associated to
5378 static gdb::array_view
<const gdb_byte
>
5379 get_gdb_index_contents_from_cache (objfile
*obj
, dwarf2_per_bfd
*dwarf2_per_bfd
)
5381 const bfd_build_id
*build_id
= build_id_bfd_get (obj
->obfd
);
5382 if (build_id
== nullptr)
5385 return global_index_cache
.lookup_gdb_index (build_id
,
5386 &dwarf2_per_bfd
->index_cache_res
);
5389 /* Same as the above, but for DWZ. */
5391 static gdb::array_view
<const gdb_byte
>
5392 get_gdb_index_contents_from_cache_dwz (objfile
*obj
, dwz_file
*dwz
)
5394 const bfd_build_id
*build_id
= build_id_bfd_get (dwz
->dwz_bfd
.get ());
5395 if (build_id
== nullptr)
5398 return global_index_cache
.lookup_gdb_index (build_id
, &dwz
->index_cache_res
);
5401 /* See dwarf2/public.h. */
5404 dwarf2_initialize_objfile (struct objfile
*objfile
)
5406 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
5407 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
5409 dwarf_read_debug_printf ("called");
5411 /* If we're about to read full symbols, don't bother with the
5412 indices. In this case we also don't care if some other debug
5413 format is making psymtabs, because they are all about to be
5415 if ((objfile
->flags
& OBJF_READNOW
))
5417 dwarf_read_debug_printf ("readnow requested");
5419 /* When using READNOW, the using_index flag (set below) indicates that
5420 PER_BFD was already initialized, when we loaded some other objfile. */
5421 if (per_bfd
->using_index
)
5423 dwarf_read_debug_printf ("using_index already set");
5424 per_objfile
->resize_symtabs ();
5425 objfile
->qf
.push_front (make_dwarf_gdb_index ());
5429 per_bfd
->using_index
= 1;
5430 create_all_comp_units (per_objfile
);
5431 per_bfd
->quick_file_names_table
5432 = create_quick_file_names_table (per_bfd
->all_comp_units
.size ());
5433 per_objfile
->resize_symtabs ();
5435 for (int i
= 0; i
< per_bfd
->all_comp_units
.size (); ++i
)
5437 dwarf2_per_cu_data
*per_cu
= per_bfd
->get_cu (i
);
5439 per_cu
->v
.quick
= OBSTACK_ZALLOC (&per_bfd
->obstack
,
5440 struct dwarf2_per_cu_quick_data
);
5443 /* Arrange for gdb to see the "quick" functions. However, these
5444 functions will be no-ops because we will have expanded all
5446 objfile
->qf
.push_front (make_dwarf_gdb_index ());
5450 /* Was a debug names index already read when we processed an objfile sharing
5452 if (per_bfd
->debug_names_table
!= nullptr)
5454 dwarf_read_debug_printf ("re-using shared debug names table");
5455 per_objfile
->resize_symtabs ();
5456 objfile
->qf
.push_front (make_dwarf_debug_names ());
5460 /* Was a GDB index already read when we processed an objfile sharing
5462 if (per_bfd
->index_table
!= nullptr)
5464 dwarf_read_debug_printf ("re-using shared index table");
5465 per_objfile
->resize_symtabs ();
5466 objfile
->qf
.push_front (make_dwarf_gdb_index ());
5470 /* There might already be partial symtabs built for this BFD. This happens
5471 when loading the same binary twice with the index-cache enabled. If so,
5472 don't try to read an index. The objfile / per_objfile initialization will
5473 be completed in dwarf2_build_psymtabs, in the standard partial symtabs
5475 if (per_bfd
->partial_symtabs
!= nullptr)
5477 dwarf_read_debug_printf ("re-using shared partial symtabs");
5478 objfile
->qf
.push_front (make_lazy_dwarf_reader ());
5482 if (dwarf2_read_debug_names (per_objfile
))
5484 dwarf_read_debug_printf ("found debug names");
5485 per_objfile
->resize_symtabs ();
5486 objfile
->qf
.push_front (make_dwarf_debug_names ());
5490 if (dwarf2_read_gdb_index (per_objfile
,
5491 get_gdb_index_contents_from_section
<struct dwarf2_per_bfd
>,
5492 get_gdb_index_contents_from_section
<dwz_file
>))
5494 dwarf_read_debug_printf ("found gdb index from file");
5495 per_objfile
->resize_symtabs ();
5496 objfile
->qf
.push_front (make_dwarf_gdb_index ());
5500 /* ... otherwise, try to find the index in the index cache. */
5501 if (dwarf2_read_gdb_index (per_objfile
,
5502 get_gdb_index_contents_from_cache
,
5503 get_gdb_index_contents_from_cache_dwz
))
5505 dwarf_read_debug_printf ("found gdb index from cache");
5506 global_index_cache
.hit ();
5507 per_objfile
->resize_symtabs ();
5508 objfile
->qf
.push_front (make_dwarf_gdb_index ());
5512 global_index_cache
.miss ();
5513 objfile
->qf
.push_front (make_lazy_dwarf_reader ());
5518 /* Build a partial symbol table. */
5521 dwarf2_build_psymtabs (struct objfile
*objfile
, psymbol_functions
*psf
)
5523 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
5524 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
5526 if (per_bfd
->partial_symtabs
!= nullptr)
5528 /* Partial symbols were already read, so now we can simply
5532 psf
= new psymbol_functions (per_bfd
->partial_symtabs
);
5533 objfile
->qf
.emplace_front (psf
);
5536 psf
->set_partial_symtabs (per_bfd
->partial_symtabs
);
5537 per_objfile
->resize_symtabs ();
5543 psf
= new psymbol_functions
;
5544 objfile
->qf
.emplace_front (psf
);
5546 const std::shared_ptr
<psymtab_storage
> &partial_symtabs
5547 = psf
->get_partial_symtabs ();
5549 /* Set the local reference to partial symtabs, so that we don't try
5550 to read them again if reading another objfile with the same BFD.
5551 If we can't in fact share, this won't make a difference anyway as
5552 the dwarf2_per_bfd object won't be shared. */
5553 per_bfd
->partial_symtabs
= partial_symtabs
;
5557 /* This isn't really ideal: all the data we allocate on the
5558 objfile's obstack is still uselessly kept around. However,
5559 freeing it seems unsafe. */
5560 psymtab_discarder
psymtabs (partial_symtabs
.get ());
5561 dwarf2_build_psymtabs_hard (per_objfile
);
5564 per_objfile
->resize_symtabs ();
5566 /* (maybe) store an index in the cache. */
5567 global_index_cache
.store (per_objfile
);
5569 catch (const gdb_exception_error
&except
)
5571 exception_print (gdb_stderr
, except
);
5575 /* Find the base address of the compilation unit for range lists and
5576 location lists. It will normally be specified by DW_AT_low_pc.
5577 In DWARF-3 draft 4, the base address could be overridden by
5578 DW_AT_entry_pc. It's been removed, but GCC still uses this for
5579 compilation units with discontinuous ranges. */
5582 dwarf2_find_base_address (struct die_info
*die
, struct dwarf2_cu
*cu
)
5584 struct attribute
*attr
;
5586 cu
->base_address
.reset ();
5588 attr
= dwarf2_attr (die
, DW_AT_entry_pc
, cu
);
5589 if (attr
!= nullptr)
5590 cu
->base_address
= attr
->as_address ();
5593 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
5594 if (attr
!= nullptr)
5595 cu
->base_address
= attr
->as_address ();
5599 /* Helper function that returns the proper abbrev section for
5602 static struct dwarf2_section_info
*
5603 get_abbrev_section_for_cu (struct dwarf2_per_cu_data
*this_cu
)
5605 struct dwarf2_section_info
*abbrev
;
5606 dwarf2_per_bfd
*per_bfd
= this_cu
->per_bfd
;
5608 if (this_cu
->is_dwz
)
5609 abbrev
= &dwarf2_get_dwz_file (per_bfd
, true)->abbrev
;
5611 abbrev
= &per_bfd
->abbrev
;
5616 /* Fetch the abbreviation table offset from a comp or type unit header. */
5619 read_abbrev_offset (dwarf2_per_objfile
*per_objfile
,
5620 struct dwarf2_section_info
*section
,
5621 sect_offset sect_off
)
5623 bfd
*abfd
= section
->get_bfd_owner ();
5624 const gdb_byte
*info_ptr
;
5625 unsigned int initial_length_size
, offset_size
;
5628 section
->read (per_objfile
->objfile
);
5629 info_ptr
= section
->buffer
+ to_underlying (sect_off
);
5630 read_initial_length (abfd
, info_ptr
, &initial_length_size
);
5631 offset_size
= initial_length_size
== 4 ? 4 : 8;
5632 info_ptr
+= initial_length_size
;
5634 version
= read_2_bytes (abfd
, info_ptr
);
5638 /* Skip unit type and address size. */
5642 return (sect_offset
) read_offset (abfd
, info_ptr
, offset_size
);
5645 /* A partial symtab that is used only for include files. */
5646 struct dwarf2_include_psymtab
: public partial_symtab
5648 dwarf2_include_psymtab (const char *filename
,
5649 psymtab_storage
*partial_symtabs
,
5650 objfile_per_bfd_storage
*objfile_per_bfd
)
5651 : partial_symtab (filename
, partial_symtabs
, objfile_per_bfd
)
5655 void read_symtab (struct objfile
*objfile
) override
5657 /* It's an include file, no symbols to read for it.
5658 Everything is in the includer symtab. */
5660 /* The expansion of a dwarf2_include_psymtab is just a trigger for
5661 expansion of the includer psymtab. We use the dependencies[0] field to
5662 model the includer. But if we go the regular route of calling
5663 expand_psymtab here, and having expand_psymtab call expand_dependencies
5664 to expand the includer, we'll only use expand_psymtab on the includer
5665 (making it a non-toplevel psymtab), while if we expand the includer via
5666 another path, we'll use read_symtab (making it a toplevel psymtab).
5667 So, don't pretend a dwarf2_include_psymtab is an actual toplevel
5668 psymtab, and trigger read_symtab on the includer here directly. */
5669 includer ()->read_symtab (objfile
);
5672 void expand_psymtab (struct objfile
*objfile
) override
5674 /* This is not called by read_symtab, and should not be called by any
5675 expand_dependencies. */
5679 bool readin_p (struct objfile
*objfile
) const override
5681 return includer ()->readin_p (objfile
);
5684 compunit_symtab
*get_compunit_symtab (struct objfile
*objfile
) const override
5690 partial_symtab
*includer () const
5692 /* An include psymtab has exactly one dependency: the psymtab that
5694 gdb_assert (this->number_of_dependencies
== 1);
5695 return this->dependencies
[0];
5699 /* Allocate a new partial symtab for file named NAME and mark this new
5700 partial symtab as being an include of PST. */
5703 dwarf2_create_include_psymtab (dwarf2_per_bfd
*per_bfd
,
5705 dwarf2_psymtab
*pst
,
5706 psymtab_storage
*partial_symtabs
,
5707 objfile_per_bfd_storage
*objfile_per_bfd
)
5709 dwarf2_include_psymtab
*subpst
5710 = new dwarf2_include_psymtab (name
, partial_symtabs
, objfile_per_bfd
);
5712 if (!IS_ABSOLUTE_PATH (subpst
->filename
))
5713 subpst
->dirname
= pst
->dirname
;
5715 subpst
->dependencies
= per_bfd
->partial_symtabs
->allocate_dependencies (1);
5716 subpst
->dependencies
[0] = pst
;
5717 subpst
->number_of_dependencies
= 1;
5720 /* Read the Line Number Program data and extract the list of files
5721 included by the source file represented by PST. Build an include
5722 partial symtab for each of these included files. */
5725 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
5726 struct die_info
*die
,
5727 dwarf2_psymtab
*pst
)
5730 struct attribute
*attr
;
5732 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
5733 if (attr
!= nullptr && attr
->form_is_unsigned ())
5734 lh
= dwarf_decode_line_header ((sect_offset
) attr
->as_unsigned (), cu
);
5736 return; /* No linetable, so no includes. */
5738 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). Also note
5739 that we pass in the raw text_low here; that is ok because we're
5740 only decoding the line table to make include partial symtabs, and
5741 so the addresses aren't really used. */
5742 dwarf_decode_lines (lh
.get (), pst
->dirname
, cu
, pst
,
5743 pst
->raw_text_low (), 1);
5747 hash_signatured_type (const void *item
)
5749 const struct signatured_type
*sig_type
5750 = (const struct signatured_type
*) item
;
5752 /* This drops the top 32 bits of the signature, but is ok for a hash. */
5753 return sig_type
->signature
;
5757 eq_signatured_type (const void *item_lhs
, const void *item_rhs
)
5759 const struct signatured_type
*lhs
= (const struct signatured_type
*) item_lhs
;
5760 const struct signatured_type
*rhs
= (const struct signatured_type
*) item_rhs
;
5762 return lhs
->signature
== rhs
->signature
;
5765 /* Allocate a hash table for signatured types. */
5768 allocate_signatured_type_table ()
5770 return htab_up (htab_create_alloc (41,
5771 hash_signatured_type
,
5773 NULL
, xcalloc
, xfree
));
5776 /* A helper for create_debug_types_hash_table. Read types from SECTION
5777 and fill them into TYPES_HTAB. It will process only type units,
5778 therefore DW_UT_type. */
5781 create_debug_type_hash_table (dwarf2_per_objfile
*per_objfile
,
5782 struct dwo_file
*dwo_file
,
5783 dwarf2_section_info
*section
, htab_up
&types_htab
,
5784 rcuh_kind section_kind
)
5786 struct objfile
*objfile
= per_objfile
->objfile
;
5787 struct dwarf2_section_info
*abbrev_section
;
5789 const gdb_byte
*info_ptr
, *end_ptr
;
5791 abbrev_section
= &dwo_file
->sections
.abbrev
;
5793 dwarf_read_debug_printf ("Reading %s for %s",
5794 section
->get_name (),
5795 abbrev_section
->get_file_name ());
5797 section
->read (objfile
);
5798 info_ptr
= section
->buffer
;
5800 if (info_ptr
== NULL
)
5803 /* We can't set abfd until now because the section may be empty or
5804 not present, in which case the bfd is unknown. */
5805 abfd
= section
->get_bfd_owner ();
5807 /* We don't use cutu_reader here because we don't need to read
5808 any dies: the signature is in the header. */
5810 end_ptr
= info_ptr
+ section
->size
;
5811 while (info_ptr
< end_ptr
)
5813 signatured_type_up sig_type
;
5814 struct dwo_unit
*dwo_tu
;
5816 const gdb_byte
*ptr
= info_ptr
;
5817 struct comp_unit_head header
;
5818 unsigned int length
;
5820 sect_offset sect_off
= (sect_offset
) (ptr
- section
->buffer
);
5822 /* Initialize it due to a false compiler warning. */
5823 header
.signature
= -1;
5824 header
.type_cu_offset_in_tu
= (cu_offset
) -1;
5826 /* We need to read the type's signature in order to build the hash
5827 table, but we don't need anything else just yet. */
5829 ptr
= read_and_check_comp_unit_head (per_objfile
, &header
, section
,
5830 abbrev_section
, ptr
, section_kind
);
5832 length
= header
.get_length ();
5834 /* Skip dummy type units. */
5835 if (ptr
>= info_ptr
+ length
5836 || peek_abbrev_code (abfd
, ptr
) == 0
5837 || (header
.unit_type
!= DW_UT_type
5838 && header
.unit_type
!= DW_UT_split_type
))
5844 if (types_htab
== NULL
)
5845 types_htab
= allocate_dwo_unit_table ();
5847 dwo_tu
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, dwo_unit
);
5848 dwo_tu
->dwo_file
= dwo_file
;
5849 dwo_tu
->signature
= header
.signature
;
5850 dwo_tu
->type_offset_in_tu
= header
.type_cu_offset_in_tu
;
5851 dwo_tu
->section
= section
;
5852 dwo_tu
->sect_off
= sect_off
;
5853 dwo_tu
->length
= length
;
5855 slot
= htab_find_slot (types_htab
.get (), dwo_tu
, INSERT
);
5856 gdb_assert (slot
!= NULL
);
5858 complaint (_("debug type entry at offset %s is duplicate to"
5859 " the entry at offset %s, signature %s"),
5860 sect_offset_str (sect_off
),
5861 sect_offset_str (dwo_tu
->sect_off
),
5862 hex_string (header
.signature
));
5865 dwarf_read_debug_printf_v (" offset %s, signature %s",
5866 sect_offset_str (sect_off
),
5867 hex_string (header
.signature
));
5873 /* Create the hash table of all entries in the .debug_types
5874 (or .debug_types.dwo) section(s).
5875 DWO_FILE is a pointer to the DWO file object.
5877 The result is a pointer to the hash table or NULL if there are no types.
5879 Note: This function processes DWO files only, not DWP files. */
5882 create_debug_types_hash_table (dwarf2_per_objfile
*per_objfile
,
5883 struct dwo_file
*dwo_file
,
5884 gdb::array_view
<dwarf2_section_info
> type_sections
,
5885 htab_up
&types_htab
)
5887 for (dwarf2_section_info
§ion
: type_sections
)
5888 create_debug_type_hash_table (per_objfile
, dwo_file
, §ion
, types_htab
,
5892 /* Add an entry for signature SIG to dwarf2_per_objfile->per_bfd->signatured_types.
5893 If SLOT is non-NULL, it is the entry to use in the hash table.
5894 Otherwise we find one. */
5896 static struct signatured_type
*
5897 add_type_unit (dwarf2_per_objfile
*per_objfile
, ULONGEST sig
, void **slot
)
5899 if (per_objfile
->per_bfd
->all_comp_units
.size ()
5900 == per_objfile
->per_bfd
->all_comp_units
.capacity ())
5901 ++per_objfile
->per_bfd
->tu_stats
.nr_all_type_units_reallocs
;
5903 signatured_type_up sig_type_holder
5904 = per_objfile
->per_bfd
->allocate_signatured_type (sig
);
5905 signatured_type
*sig_type
= sig_type_holder
.get ();
5907 per_objfile
->resize_symtabs ();
5909 per_objfile
->per_bfd
->all_comp_units
.emplace_back
5910 (sig_type_holder
.release ());
5911 if (per_objfile
->per_bfd
->using_index
)
5914 OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
,
5915 struct dwarf2_per_cu_quick_data
);
5920 slot
= htab_find_slot (per_objfile
->per_bfd
->signatured_types
.get (),
5923 gdb_assert (*slot
== NULL
);
5925 /* The rest of sig_type must be filled in by the caller. */
5929 /* Subroutine of lookup_dwo_signatured_type and lookup_dwp_signatured_type.
5930 Fill in SIG_ENTRY with DWO_ENTRY. */
5933 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile
*per_objfile
,
5934 struct signatured_type
*sig_entry
,
5935 struct dwo_unit
*dwo_entry
)
5937 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
5939 /* Make sure we're not clobbering something we don't expect to. */
5940 gdb_assert (! sig_entry
->queued
);
5941 gdb_assert (per_objfile
->get_cu (sig_entry
) == NULL
);
5942 if (per_bfd
->using_index
)
5944 gdb_assert (sig_entry
->v
.quick
!= NULL
);
5945 gdb_assert (!per_objfile
->symtab_set_p (sig_entry
));
5948 gdb_assert (sig_entry
->v
.psymtab
== NULL
);
5949 gdb_assert (sig_entry
->signature
== dwo_entry
->signature
);
5950 gdb_assert (to_underlying (sig_entry
->type_offset_in_section
) == 0);
5951 gdb_assert (sig_entry
->type_unit_group
== NULL
);
5952 gdb_assert (sig_entry
->dwo_unit
== NULL
);
5954 sig_entry
->section
= dwo_entry
->section
;
5955 sig_entry
->sect_off
= dwo_entry
->sect_off
;
5956 sig_entry
->length
= dwo_entry
->length
;
5957 sig_entry
->reading_dwo_directly
= 1;
5958 sig_entry
->per_bfd
= per_bfd
;
5959 sig_entry
->type_offset_in_tu
= dwo_entry
->type_offset_in_tu
;
5960 sig_entry
->dwo_unit
= dwo_entry
;
5963 /* Subroutine of lookup_signatured_type.
5964 If we haven't read the TU yet, create the signatured_type data structure
5965 for a TU to be read in directly from a DWO file, bypassing the stub.
5966 This is the "Stay in DWO Optimization": When there is no DWP file and we're
5967 using .gdb_index, then when reading a CU we want to stay in the DWO file
5968 containing that CU. Otherwise we could end up reading several other DWO
5969 files (due to comdat folding) to process the transitive closure of all the
5970 mentioned TUs, and that can be slow. The current DWO file will have every
5971 type signature that it needs.
5972 We only do this for .gdb_index because in the psymtab case we already have
5973 to read all the DWOs to build the type unit groups. */
5975 static struct signatured_type
*
5976 lookup_dwo_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
5978 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
5979 struct dwo_file
*dwo_file
;
5980 struct dwo_unit find_dwo_entry
, *dwo_entry
;
5983 gdb_assert (cu
->dwo_unit
&& per_objfile
->per_bfd
->using_index
);
5985 /* If TU skeletons have been removed then we may not have read in any
5987 if (per_objfile
->per_bfd
->signatured_types
== NULL
)
5988 per_objfile
->per_bfd
->signatured_types
= allocate_signatured_type_table ();
5990 /* We only ever need to read in one copy of a signatured type.
5991 Use the global signatured_types array to do our own comdat-folding
5992 of types. If this is the first time we're reading this TU, and
5993 the TU has an entry in .gdb_index, replace the recorded data from
5994 .gdb_index with this TU. */
5996 signatured_type
find_sig_entry (sig
);
5997 slot
= htab_find_slot (per_objfile
->per_bfd
->signatured_types
.get (),
5998 &find_sig_entry
, INSERT
);
5999 signatured_type
*sig_entry
= (struct signatured_type
*) *slot
;
6001 /* We can get here with the TU already read, *or* in the process of being
6002 read. Don't reassign the global entry to point to this DWO if that's
6003 the case. Also note that if the TU is already being read, it may not
6004 have come from a DWO, the program may be a mix of Fission-compiled
6005 code and non-Fission-compiled code. */
6007 /* Have we already tried to read this TU?
6008 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
6009 needn't exist in the global table yet). */
6010 if (sig_entry
!= NULL
&& sig_entry
->tu_read
)
6013 /* Note: cu->dwo_unit is the dwo_unit that references this TU, not the
6014 dwo_unit of the TU itself. */
6015 dwo_file
= cu
->dwo_unit
->dwo_file
;
6017 /* Ok, this is the first time we're reading this TU. */
6018 if (dwo_file
->tus
== NULL
)
6020 find_dwo_entry
.signature
= sig
;
6021 dwo_entry
= (struct dwo_unit
*) htab_find (dwo_file
->tus
.get (),
6023 if (dwo_entry
== NULL
)
6026 /* If the global table doesn't have an entry for this TU, add one. */
6027 if (sig_entry
== NULL
)
6028 sig_entry
= add_type_unit (per_objfile
, sig
, slot
);
6030 fill_in_sig_entry_from_dwo_entry (per_objfile
, sig_entry
, dwo_entry
);
6031 sig_entry
->tu_read
= 1;
6035 /* Subroutine of lookup_signatured_type.
6036 Look up the type for signature SIG, and if we can't find SIG in .gdb_index
6037 then try the DWP file. If the TU stub (skeleton) has been removed then
6038 it won't be in .gdb_index. */
6040 static struct signatured_type
*
6041 lookup_dwp_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
6043 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
6044 struct dwp_file
*dwp_file
= get_dwp_file (per_objfile
);
6045 struct dwo_unit
*dwo_entry
;
6048 gdb_assert (cu
->dwo_unit
&& per_objfile
->per_bfd
->using_index
);
6049 gdb_assert (dwp_file
!= NULL
);
6051 /* If TU skeletons have been removed then we may not have read in any
6053 if (per_objfile
->per_bfd
->signatured_types
== NULL
)
6054 per_objfile
->per_bfd
->signatured_types
= allocate_signatured_type_table ();
6056 signatured_type
find_sig_entry (sig
);
6057 slot
= htab_find_slot (per_objfile
->per_bfd
->signatured_types
.get (),
6058 &find_sig_entry
, INSERT
);
6059 signatured_type
*sig_entry
= (struct signatured_type
*) *slot
;
6061 /* Have we already tried to read this TU?
6062 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
6063 needn't exist in the global table yet). */
6064 if (sig_entry
!= NULL
)
6067 if (dwp_file
->tus
== NULL
)
6069 dwo_entry
= lookup_dwo_unit_in_dwp (per_objfile
, dwp_file
, NULL
, sig
,
6070 1 /* is_debug_types */);
6071 if (dwo_entry
== NULL
)
6074 sig_entry
= add_type_unit (per_objfile
, sig
, slot
);
6075 fill_in_sig_entry_from_dwo_entry (per_objfile
, sig_entry
, dwo_entry
);
6080 /* Lookup a signature based type for DW_FORM_ref_sig8.
6081 Returns NULL if signature SIG is not present in the table.
6082 It is up to the caller to complain about this. */
6084 static struct signatured_type
*
6085 lookup_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
6087 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
6089 if (cu
->dwo_unit
&& per_objfile
->per_bfd
->using_index
)
6091 /* We're in a DWO/DWP file, and we're using .gdb_index.
6092 These cases require special processing. */
6093 if (get_dwp_file (per_objfile
) == NULL
)
6094 return lookup_dwo_signatured_type (cu
, sig
);
6096 return lookup_dwp_signatured_type (cu
, sig
);
6100 if (per_objfile
->per_bfd
->signatured_types
== NULL
)
6102 signatured_type
find_entry (sig
);
6103 return ((struct signatured_type
*)
6104 htab_find (per_objfile
->per_bfd
->signatured_types
.get (),
6109 /* Low level DIE reading support. */
6111 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
6114 init_cu_die_reader (struct die_reader_specs
*reader
,
6115 struct dwarf2_cu
*cu
,
6116 struct dwarf2_section_info
*section
,
6117 struct dwo_file
*dwo_file
,
6118 struct abbrev_table
*abbrev_table
)
6120 gdb_assert (section
->readin
&& section
->buffer
!= NULL
);
6121 reader
->abfd
= section
->get_bfd_owner ();
6123 reader
->dwo_file
= dwo_file
;
6124 reader
->die_section
= section
;
6125 reader
->buffer
= section
->buffer
;
6126 reader
->buffer_end
= section
->buffer
+ section
->size
;
6127 reader
->abbrev_table
= abbrev_table
;
6130 /* Subroutine of cutu_reader to simplify it.
6131 Read in the rest of a CU/TU top level DIE from DWO_UNIT.
6132 There's just a lot of work to do, and cutu_reader is big enough
6135 STUB_COMP_UNIT_DIE is for the stub DIE, we copy over certain attributes
6136 from it to the DIE in the DWO. If NULL we are skipping the stub.
6137 STUB_COMP_DIR is similar to STUB_COMP_UNIT_DIE: When reading a TU directly
6138 from the DWO file, bypassing the stub, it contains the DW_AT_comp_dir
6139 attribute of the referencing CU. At most one of STUB_COMP_UNIT_DIE and
6140 STUB_COMP_DIR may be non-NULL.
6141 *RESULT_READER,*RESULT_INFO_PTR,*RESULT_COMP_UNIT_DIE
6142 are filled in with the info of the DIE from the DWO file.
6143 *RESULT_DWO_ABBREV_TABLE will be filled in with the abbrev table allocated
6144 from the dwo. Since *RESULT_READER references this abbrev table, it must be
6145 kept around for at least as long as *RESULT_READER.
6147 The result is non-zero if a valid (non-dummy) DIE was found. */
6150 read_cutu_die_from_dwo (dwarf2_cu
*cu
,
6151 struct dwo_unit
*dwo_unit
,
6152 struct die_info
*stub_comp_unit_die
,
6153 const char *stub_comp_dir
,
6154 struct die_reader_specs
*result_reader
,
6155 const gdb_byte
**result_info_ptr
,
6156 struct die_info
**result_comp_unit_die
,
6157 abbrev_table_up
*result_dwo_abbrev_table
)
6159 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
6160 dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
6161 struct objfile
*objfile
= per_objfile
->objfile
;
6163 const gdb_byte
*begin_info_ptr
, *info_ptr
;
6164 struct attribute
*comp_dir
, *stmt_list
, *low_pc
, *high_pc
, *ranges
;
6165 int i
,num_extra_attrs
;
6166 struct dwarf2_section_info
*dwo_abbrev_section
;
6167 struct die_info
*comp_unit_die
;
6169 /* At most one of these may be provided. */
6170 gdb_assert ((stub_comp_unit_die
!= NULL
) + (stub_comp_dir
!= NULL
) <= 1);
6172 /* These attributes aren't processed until later:
6173 DW_AT_stmt_list, DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges.
6174 DW_AT_comp_dir is used now, to find the DWO file, but it is also
6175 referenced later. However, these attributes are found in the stub
6176 which we won't have later. In order to not impose this complication
6177 on the rest of the code, we read them here and copy them to the
6186 if (stub_comp_unit_die
!= NULL
)
6188 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
6190 if (!per_cu
->is_debug_types
)
6191 stmt_list
= dwarf2_attr (stub_comp_unit_die
, DW_AT_stmt_list
, cu
);
6192 low_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_low_pc
, cu
);
6193 high_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_high_pc
, cu
);
6194 ranges
= dwarf2_attr (stub_comp_unit_die
, DW_AT_ranges
, cu
);
6195 comp_dir
= dwarf2_attr (stub_comp_unit_die
, DW_AT_comp_dir
, cu
);
6197 cu
->addr_base
= stub_comp_unit_die
->addr_base ();
6199 /* There should be a DW_AT_GNU_ranges_base attribute here (if needed).
6200 We need the value before we can process DW_AT_ranges values from the
6202 cu
->gnu_ranges_base
= stub_comp_unit_die
->gnu_ranges_base ();
6204 /* For DWARF5: record the DW_AT_rnglists_base value from the skeleton. If
6205 there are attributes of form DW_FORM_rnglistx in the skeleton, they'll
6206 need the rnglists base. Attributes of form DW_FORM_rnglistx in the
6207 split unit don't use it, as the DWO has its own .debug_rnglists.dwo
6209 cu
->rnglists_base
= stub_comp_unit_die
->rnglists_base ();
6211 else if (stub_comp_dir
!= NULL
)
6213 /* Reconstruct the comp_dir attribute to simplify the code below. */
6214 comp_dir
= OBSTACK_ZALLOC (&cu
->comp_unit_obstack
, struct attribute
);
6215 comp_dir
->name
= DW_AT_comp_dir
;
6216 comp_dir
->form
= DW_FORM_string
;
6217 comp_dir
->set_string_noncanonical (stub_comp_dir
);
6220 /* Set up for reading the DWO CU/TU. */
6221 cu
->dwo_unit
= dwo_unit
;
6222 dwarf2_section_info
*section
= dwo_unit
->section
;
6223 section
->read (objfile
);
6224 abfd
= section
->get_bfd_owner ();
6225 begin_info_ptr
= info_ptr
= (section
->buffer
6226 + to_underlying (dwo_unit
->sect_off
));
6227 dwo_abbrev_section
= &dwo_unit
->dwo_file
->sections
.abbrev
;
6229 if (per_cu
->is_debug_types
)
6231 signatured_type
*sig_type
= (struct signatured_type
*) per_cu
;
6233 info_ptr
= read_and_check_comp_unit_head (per_objfile
, &cu
->header
,
6234 section
, dwo_abbrev_section
,
6235 info_ptr
, rcuh_kind::TYPE
);
6236 /* This is not an assert because it can be caused by bad debug info. */
6237 if (sig_type
->signature
!= cu
->header
.signature
)
6239 error (_("Dwarf Error: signature mismatch %s vs %s while reading"
6240 " TU at offset %s [in module %s]"),
6241 hex_string (sig_type
->signature
),
6242 hex_string (cu
->header
.signature
),
6243 sect_offset_str (dwo_unit
->sect_off
),
6244 bfd_get_filename (abfd
));
6246 gdb_assert (dwo_unit
->sect_off
== cu
->header
.sect_off
);
6247 /* For DWOs coming from DWP files, we don't know the CU length
6248 nor the type's offset in the TU until now. */
6249 dwo_unit
->length
= cu
->header
.get_length ();
6250 dwo_unit
->type_offset_in_tu
= cu
->header
.type_cu_offset_in_tu
;
6252 /* Establish the type offset that can be used to lookup the type.
6253 For DWO files, we don't know it until now. */
6254 sig_type
->type_offset_in_section
6255 = dwo_unit
->sect_off
+ to_underlying (dwo_unit
->type_offset_in_tu
);
6259 info_ptr
= read_and_check_comp_unit_head (per_objfile
, &cu
->header
,
6260 section
, dwo_abbrev_section
,
6261 info_ptr
, rcuh_kind::COMPILE
);
6262 gdb_assert (dwo_unit
->sect_off
== cu
->header
.sect_off
);
6263 /* For DWOs coming from DWP files, we don't know the CU length
6265 dwo_unit
->length
= cu
->header
.get_length ();
6268 dwo_abbrev_section
->read (objfile
);
6269 *result_dwo_abbrev_table
6270 = abbrev_table::read (dwo_abbrev_section
, cu
->header
.abbrev_sect_off
);
6271 init_cu_die_reader (result_reader
, cu
, section
, dwo_unit
->dwo_file
,
6272 result_dwo_abbrev_table
->get ());
6274 /* Read in the die, but leave space to copy over the attributes
6275 from the stub. This has the benefit of simplifying the rest of
6276 the code - all the work to maintain the illusion of a single
6277 DW_TAG_{compile,type}_unit DIE is done here. */
6278 num_extra_attrs
= ((stmt_list
!= NULL
)
6282 + (comp_dir
!= NULL
));
6283 info_ptr
= read_full_die_1 (result_reader
, result_comp_unit_die
, info_ptr
,
6286 /* Copy over the attributes from the stub to the DIE we just read in. */
6287 comp_unit_die
= *result_comp_unit_die
;
6288 i
= comp_unit_die
->num_attrs
;
6289 if (stmt_list
!= NULL
)
6290 comp_unit_die
->attrs
[i
++] = *stmt_list
;
6292 comp_unit_die
->attrs
[i
++] = *low_pc
;
6293 if (high_pc
!= NULL
)
6294 comp_unit_die
->attrs
[i
++] = *high_pc
;
6296 comp_unit_die
->attrs
[i
++] = *ranges
;
6297 if (comp_dir
!= NULL
)
6298 comp_unit_die
->attrs
[i
++] = *comp_dir
;
6299 comp_unit_die
->num_attrs
+= num_extra_attrs
;
6301 if (dwarf_die_debug
)
6303 fprintf_unfiltered (gdb_stdlog
,
6304 "Read die from %s@0x%x of %s:\n",
6305 section
->get_name (),
6306 (unsigned) (begin_info_ptr
- section
->buffer
),
6307 bfd_get_filename (abfd
));
6308 dump_die (comp_unit_die
, dwarf_die_debug
);
6311 /* Skip dummy compilation units. */
6312 if (info_ptr
>= begin_info_ptr
+ dwo_unit
->length
6313 || peek_abbrev_code (abfd
, info_ptr
) == 0)
6316 *result_info_ptr
= info_ptr
;
6320 /* Return the signature of the compile unit, if found. In DWARF 4 and before,
6321 the signature is in the DW_AT_GNU_dwo_id attribute. In DWARF 5 and later, the
6322 signature is part of the header. */
6323 static gdb::optional
<ULONGEST
>
6324 lookup_dwo_id (struct dwarf2_cu
*cu
, struct die_info
* comp_unit_die
)
6326 if (cu
->header
.version
>= 5)
6327 return cu
->header
.signature
;
6328 struct attribute
*attr
;
6329 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_id
, cu
);
6330 if (attr
== nullptr || !attr
->form_is_unsigned ())
6331 return gdb::optional
<ULONGEST
> ();
6332 return attr
->as_unsigned ();
6335 /* Subroutine of cutu_reader to simplify it.
6336 Look up the DWO unit specified by COMP_UNIT_DIE of THIS_CU.
6337 Returns NULL if the specified DWO unit cannot be found. */
6339 static struct dwo_unit
*
6340 lookup_dwo_unit (dwarf2_cu
*cu
, die_info
*comp_unit_die
, const char *dwo_name
)
6342 dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
6343 struct dwo_unit
*dwo_unit
;
6344 const char *comp_dir
;
6346 gdb_assert (cu
!= NULL
);
6348 /* Yeah, we look dwo_name up again, but it simplifies the code. */
6349 dwo_name
= dwarf2_dwo_name (comp_unit_die
, cu
);
6350 comp_dir
= dwarf2_string_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
6352 if (per_cu
->is_debug_types
)
6353 dwo_unit
= lookup_dwo_type_unit (cu
, dwo_name
, comp_dir
);
6356 gdb::optional
<ULONGEST
> signature
= lookup_dwo_id (cu
, comp_unit_die
);
6358 if (!signature
.has_value ())
6359 error (_("Dwarf Error: missing dwo_id for dwo_name %s"
6361 dwo_name
, bfd_get_filename (per_cu
->per_bfd
->obfd
));
6363 dwo_unit
= lookup_dwo_comp_unit (cu
, dwo_name
, comp_dir
, *signature
);
6369 /* Subroutine of cutu_reader to simplify it.
6370 See it for a description of the parameters.
6371 Read a TU directly from a DWO file, bypassing the stub. */
6374 cutu_reader::init_tu_and_read_dwo_dies (dwarf2_per_cu_data
*this_cu
,
6375 dwarf2_per_objfile
*per_objfile
,
6376 dwarf2_cu
*existing_cu
)
6378 struct signatured_type
*sig_type
;
6380 /* Verify we can do the following downcast, and that we have the
6382 gdb_assert (this_cu
->is_debug_types
&& this_cu
->reading_dwo_directly
);
6383 sig_type
= (struct signatured_type
*) this_cu
;
6384 gdb_assert (sig_type
->dwo_unit
!= NULL
);
6388 if (existing_cu
!= nullptr)
6391 gdb_assert (cu
->dwo_unit
== sig_type
->dwo_unit
);
6392 /* There's no need to do the rereading_dwo_cu handling that
6393 cutu_reader does since we don't read the stub. */
6397 /* If an existing_cu is provided, a dwarf2_cu must not exist for this_cu
6398 in per_objfile yet. */
6399 gdb_assert (per_objfile
->get_cu (this_cu
) == nullptr);
6400 m_new_cu
.reset (new dwarf2_cu (this_cu
, per_objfile
));
6401 cu
= m_new_cu
.get ();
6404 /* A future optimization, if needed, would be to use an existing
6405 abbrev table. When reading DWOs with skeletonless TUs, all the TUs
6406 could share abbrev tables. */
6408 if (read_cutu_die_from_dwo (cu
, sig_type
->dwo_unit
,
6409 NULL
/* stub_comp_unit_die */,
6410 sig_type
->dwo_unit
->dwo_file
->comp_dir
,
6413 &m_dwo_abbrev_table
) == 0)
6420 /* Initialize a CU (or TU) and read its DIEs.
6421 If the CU defers to a DWO file, read the DWO file as well.
6423 ABBREV_TABLE, if non-NULL, is the abbreviation table to use.
6424 Otherwise the table specified in the comp unit header is read in and used.
6425 This is an optimization for when we already have the abbrev table.
6427 If EXISTING_CU is non-NULL, then use it. Otherwise, a new CU is
6430 cutu_reader::cutu_reader (dwarf2_per_cu_data
*this_cu
,
6431 dwarf2_per_objfile
*per_objfile
,
6432 struct abbrev_table
*abbrev_table
,
6433 dwarf2_cu
*existing_cu
,
6435 : die_reader_specs
{},
6438 struct objfile
*objfile
= per_objfile
->objfile
;
6439 struct dwarf2_section_info
*section
= this_cu
->section
;
6440 bfd
*abfd
= section
->get_bfd_owner ();
6441 const gdb_byte
*begin_info_ptr
;
6442 struct signatured_type
*sig_type
= NULL
;
6443 struct dwarf2_section_info
*abbrev_section
;
6444 /* Non-zero if CU currently points to a DWO file and we need to
6445 reread it. When this happens we need to reread the skeleton die
6446 before we can reread the DWO file (this only applies to CUs, not TUs). */
6447 int rereading_dwo_cu
= 0;
6449 if (dwarf_die_debug
)
6450 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset %s\n",
6451 this_cu
->is_debug_types
? "type" : "comp",
6452 sect_offset_str (this_cu
->sect_off
));
6454 /* If we're reading a TU directly from a DWO file, including a virtual DWO
6455 file (instead of going through the stub), short-circuit all of this. */
6456 if (this_cu
->reading_dwo_directly
)
6458 /* Narrow down the scope of possibilities to have to understand. */
6459 gdb_assert (this_cu
->is_debug_types
);
6460 gdb_assert (abbrev_table
== NULL
);
6461 init_tu_and_read_dwo_dies (this_cu
, per_objfile
, existing_cu
);
6465 /* This is cheap if the section is already read in. */
6466 section
->read (objfile
);
6468 begin_info_ptr
= info_ptr
= section
->buffer
+ to_underlying (this_cu
->sect_off
);
6470 abbrev_section
= get_abbrev_section_for_cu (this_cu
);
6474 if (existing_cu
!= nullptr)
6477 /* If this CU is from a DWO file we need to start over, we need to
6478 refetch the attributes from the skeleton CU.
6479 This could be optimized by retrieving those attributes from when we
6480 were here the first time: the previous comp_unit_die was stored in
6481 comp_unit_obstack. But there's no data yet that we need this
6483 if (cu
->dwo_unit
!= NULL
)
6484 rereading_dwo_cu
= 1;
6488 /* If an existing_cu is provided, a dwarf2_cu must not exist for this_cu
6489 in per_objfile yet. */
6490 gdb_assert (per_objfile
->get_cu (this_cu
) == nullptr);
6491 m_new_cu
.reset (new dwarf2_cu (this_cu
, per_objfile
));
6492 cu
= m_new_cu
.get ();
6495 /* Get the header. */
6496 if (to_underlying (cu
->header
.first_die_cu_offset
) != 0 && !rereading_dwo_cu
)
6498 /* We already have the header, there's no need to read it in again. */
6499 info_ptr
+= to_underlying (cu
->header
.first_die_cu_offset
);
6503 if (this_cu
->is_debug_types
)
6505 info_ptr
= read_and_check_comp_unit_head (per_objfile
, &cu
->header
,
6506 section
, abbrev_section
,
6507 info_ptr
, rcuh_kind::TYPE
);
6509 /* Since per_cu is the first member of struct signatured_type,
6510 we can go from a pointer to one to a pointer to the other. */
6511 sig_type
= (struct signatured_type
*) this_cu
;
6512 gdb_assert (sig_type
->signature
== cu
->header
.signature
);
6513 gdb_assert (sig_type
->type_offset_in_tu
6514 == cu
->header
.type_cu_offset_in_tu
);
6515 gdb_assert (this_cu
->sect_off
== cu
->header
.sect_off
);
6517 /* LENGTH has not been set yet for type units if we're
6518 using .gdb_index. */
6519 this_cu
->length
= cu
->header
.get_length ();
6521 /* Establish the type offset that can be used to lookup the type. */
6522 sig_type
->type_offset_in_section
=
6523 this_cu
->sect_off
+ to_underlying (sig_type
->type_offset_in_tu
);
6525 this_cu
->dwarf_version
= cu
->header
.version
;
6529 info_ptr
= read_and_check_comp_unit_head (per_objfile
, &cu
->header
,
6530 section
, abbrev_section
,
6532 rcuh_kind::COMPILE
);
6534 gdb_assert (this_cu
->sect_off
== cu
->header
.sect_off
);
6535 if (this_cu
->length
== 0)
6536 this_cu
->length
= cu
->header
.get_length ();
6538 gdb_assert (this_cu
->length
== cu
->header
.get_length ());
6539 this_cu
->dwarf_version
= cu
->header
.version
;
6543 /* Skip dummy compilation units. */
6544 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
6545 || peek_abbrev_code (abfd
, info_ptr
) == 0)
6551 /* If we don't have them yet, read the abbrevs for this compilation unit.
6552 And if we need to read them now, make sure they're freed when we're
6554 if (abbrev_table
!= NULL
)
6555 gdb_assert (cu
->header
.abbrev_sect_off
== abbrev_table
->sect_off
);
6558 abbrev_section
->read (objfile
);
6559 m_abbrev_table_holder
6560 = abbrev_table::read (abbrev_section
, cu
->header
.abbrev_sect_off
);
6561 abbrev_table
= m_abbrev_table_holder
.get ();
6564 /* Read the top level CU/TU die. */
6565 init_cu_die_reader (this, cu
, section
, NULL
, abbrev_table
);
6566 info_ptr
= read_full_die (this, &comp_unit_die
, info_ptr
);
6568 if (skip_partial
&& comp_unit_die
->tag
== DW_TAG_partial_unit
)
6574 /* If we are in a DWO stub, process it and then read in the "real" CU/TU
6575 from the DWO file. read_cutu_die_from_dwo will allocate the abbreviation
6576 table from the DWO file and pass the ownership over to us. It will be
6577 referenced from READER, so we must make sure to free it after we're done
6580 Note that if USE_EXISTING_OK != 0, and THIS_CU->cu already contains a
6581 DWO CU, that this test will fail (the attribute will not be present). */
6582 const char *dwo_name
= dwarf2_dwo_name (comp_unit_die
, cu
);
6583 if (dwo_name
!= nullptr)
6585 struct dwo_unit
*dwo_unit
;
6586 struct die_info
*dwo_comp_unit_die
;
6588 if (comp_unit_die
->has_children
)
6590 complaint (_("compilation unit with DW_AT_GNU_dwo_name"
6591 " has children (offset %s) [in module %s]"),
6592 sect_offset_str (this_cu
->sect_off
),
6593 bfd_get_filename (abfd
));
6595 dwo_unit
= lookup_dwo_unit (cu
, comp_unit_die
, dwo_name
);
6596 if (dwo_unit
!= NULL
)
6598 if (read_cutu_die_from_dwo (cu
, dwo_unit
,
6599 comp_unit_die
, NULL
,
6602 &m_dwo_abbrev_table
) == 0)
6608 comp_unit_die
= dwo_comp_unit_die
;
6612 /* Yikes, we couldn't find the rest of the DIE, we only have
6613 the stub. A complaint has already been logged. There's
6614 not much more we can do except pass on the stub DIE to
6615 die_reader_func. We don't want to throw an error on bad
6622 cutu_reader::keep ()
6624 /* Done, clean up. */
6625 gdb_assert (!dummy_p
);
6626 if (m_new_cu
!= NULL
)
6628 /* Save this dwarf2_cu in the per_objfile. The per_objfile owns it
6630 dwarf2_per_objfile
*per_objfile
= m_new_cu
->per_objfile
;
6631 per_objfile
->set_cu (m_this_cu
, m_new_cu
.release ());
6635 /* Read CU/TU THIS_CU but do not follow DW_AT_GNU_dwo_name (DW_AT_dwo_name)
6636 if present. DWO_FILE, if non-NULL, is the DWO file to read (the caller is
6637 assumed to have already done the lookup to find the DWO file).
6639 The caller is required to fill in THIS_CU->section, THIS_CU->offset, and
6640 THIS_CU->is_debug_types, but nothing else.
6642 We fill in THIS_CU->length.
6644 THIS_CU->cu is always freed when done.
6645 This is done in order to not leave THIS_CU->cu in a state where we have
6646 to care whether it refers to the "main" CU or the DWO CU.
6648 When parent_cu is passed, it is used to provide a default value for
6649 str_offsets_base and addr_base from the parent. */
6651 cutu_reader::cutu_reader (dwarf2_per_cu_data
*this_cu
,
6652 dwarf2_per_objfile
*per_objfile
,
6653 struct dwarf2_cu
*parent_cu
,
6654 struct dwo_file
*dwo_file
)
6655 : die_reader_specs
{},
6658 struct objfile
*objfile
= per_objfile
->objfile
;
6659 struct dwarf2_section_info
*section
= this_cu
->section
;
6660 bfd
*abfd
= section
->get_bfd_owner ();
6661 struct dwarf2_section_info
*abbrev_section
;
6662 const gdb_byte
*begin_info_ptr
, *info_ptr
;
6664 if (dwarf_die_debug
)
6665 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset %s\n",
6666 this_cu
->is_debug_types
? "type" : "comp",
6667 sect_offset_str (this_cu
->sect_off
));
6669 gdb_assert (per_objfile
->get_cu (this_cu
) == nullptr);
6671 abbrev_section
= (dwo_file
!= NULL
6672 ? &dwo_file
->sections
.abbrev
6673 : get_abbrev_section_for_cu (this_cu
));
6675 /* This is cheap if the section is already read in. */
6676 section
->read (objfile
);
6678 m_new_cu
.reset (new dwarf2_cu (this_cu
, per_objfile
));
6680 begin_info_ptr
= info_ptr
= section
->buffer
+ to_underlying (this_cu
->sect_off
);
6681 info_ptr
= read_and_check_comp_unit_head (per_objfile
, &m_new_cu
->header
,
6682 section
, abbrev_section
, info_ptr
,
6683 (this_cu
->is_debug_types
6685 : rcuh_kind::COMPILE
));
6687 if (parent_cu
!= nullptr)
6689 m_new_cu
->str_offsets_base
= parent_cu
->str_offsets_base
;
6690 m_new_cu
->addr_base
= parent_cu
->addr_base
;
6692 this_cu
->length
= m_new_cu
->header
.get_length ();
6694 /* Skip dummy compilation units. */
6695 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
6696 || peek_abbrev_code (abfd
, info_ptr
) == 0)
6702 abbrev_section
->read (objfile
);
6703 m_abbrev_table_holder
6704 = abbrev_table::read (abbrev_section
, m_new_cu
->header
.abbrev_sect_off
);
6706 init_cu_die_reader (this, m_new_cu
.get (), section
, dwo_file
,
6707 m_abbrev_table_holder
.get ());
6708 info_ptr
= read_full_die (this, &comp_unit_die
, info_ptr
);
6712 /* Type Unit Groups.
6714 Type Unit Groups are a way to collapse the set of all TUs (type units) into
6715 a more manageable set. The grouping is done by DW_AT_stmt_list entry
6716 so that all types coming from the same compilation (.o file) are grouped
6717 together. A future step could be to put the types in the same symtab as
6718 the CU the types ultimately came from. */
6721 hash_type_unit_group (const void *item
)
6723 const struct type_unit_group
*tu_group
6724 = (const struct type_unit_group
*) item
;
6726 return hash_stmt_list_entry (&tu_group
->hash
);
6730 eq_type_unit_group (const void *item_lhs
, const void *item_rhs
)
6732 const struct type_unit_group
*lhs
= (const struct type_unit_group
*) item_lhs
;
6733 const struct type_unit_group
*rhs
= (const struct type_unit_group
*) item_rhs
;
6735 return eq_stmt_list_entry (&lhs
->hash
, &rhs
->hash
);
6738 /* Allocate a hash table for type unit groups. */
6741 allocate_type_unit_groups_table ()
6743 return htab_up (htab_create_alloc (3,
6744 hash_type_unit_group
,
6746 htab_delete_entry
<type_unit_group
>,
6750 /* Type units that don't have DW_AT_stmt_list are grouped into their own
6751 partial symtabs. We combine several TUs per psymtab to not let the size
6752 of any one psymtab grow too big. */
6753 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB (1 << 31)
6754 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE 10
6756 /* Helper routine for get_type_unit_group.
6757 Create the type_unit_group object used to hold one or more TUs. */
6759 static std::unique_ptr
<type_unit_group
>
6760 create_type_unit_group (struct dwarf2_cu
*cu
, sect_offset line_offset_struct
)
6762 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
6763 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
6765 std::unique_ptr
<type_unit_group
> tu_group (new type_unit_group
);
6766 tu_group
->per_bfd
= per_bfd
;
6768 if (per_bfd
->using_index
)
6770 tu_group
->v
.quick
= OBSTACK_ZALLOC (&per_bfd
->obstack
,
6771 struct dwarf2_per_cu_quick_data
);
6775 unsigned int line_offset
= to_underlying (line_offset_struct
);
6776 dwarf2_psymtab
*pst
;
6779 /* Give the symtab a useful name for debug purposes. */
6780 if ((line_offset
& NO_STMT_LIST_TYPE_UNIT_PSYMTAB
) != 0)
6781 name
= string_printf ("<type_units_%d>",
6782 (line_offset
& ~NO_STMT_LIST_TYPE_UNIT_PSYMTAB
));
6784 name
= string_printf ("<type_units_at_0x%x>", line_offset
);
6786 pst
= create_partial_symtab (tu_group
.get (), per_objfile
,
6788 pst
->anonymous
= true;
6791 tu_group
->hash
.dwo_unit
= cu
->dwo_unit
;
6792 tu_group
->hash
.line_sect_off
= line_offset_struct
;
6797 /* Look up the type_unit_group for type unit CU, and create it if necessary.
6798 STMT_LIST is a DW_AT_stmt_list attribute. */
6800 static struct type_unit_group
*
6801 get_type_unit_group (struct dwarf2_cu
*cu
, const struct attribute
*stmt_list
)
6803 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
6804 struct tu_stats
*tu_stats
= &per_objfile
->per_bfd
->tu_stats
;
6805 struct type_unit_group
*tu_group
;
6807 unsigned int line_offset
;
6808 struct type_unit_group type_unit_group_for_lookup
;
6810 if (per_objfile
->per_bfd
->type_unit_groups
== NULL
)
6811 per_objfile
->per_bfd
->type_unit_groups
= allocate_type_unit_groups_table ();
6813 /* Do we need to create a new group, or can we use an existing one? */
6815 if (stmt_list
!= nullptr && stmt_list
->form_is_unsigned ())
6817 line_offset
= stmt_list
->as_unsigned ();
6818 ++tu_stats
->nr_symtab_sharers
;
6822 /* Ugh, no stmt_list. Rare, but we have to handle it.
6823 We can do various things here like create one group per TU or
6824 spread them over multiple groups to split up the expansion work.
6825 To avoid worst case scenarios (too many groups or too large groups)
6826 we, umm, group them in bunches. */
6827 line_offset
= (NO_STMT_LIST_TYPE_UNIT_PSYMTAB
6828 | (tu_stats
->nr_stmt_less_type_units
6829 / NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE
));
6830 ++tu_stats
->nr_stmt_less_type_units
;
6833 type_unit_group_for_lookup
.hash
.dwo_unit
= cu
->dwo_unit
;
6834 type_unit_group_for_lookup
.hash
.line_sect_off
= (sect_offset
) line_offset
;
6835 slot
= htab_find_slot (per_objfile
->per_bfd
->type_unit_groups
.get (),
6836 &type_unit_group_for_lookup
, INSERT
);
6837 if (*slot
== nullptr)
6839 sect_offset line_offset_struct
= (sect_offset
) line_offset
;
6840 std::unique_ptr
<type_unit_group
> grp
6841 = create_type_unit_group (cu
, line_offset_struct
);
6842 *slot
= grp
.release ();
6843 ++tu_stats
->nr_symtabs
;
6846 tu_group
= (struct type_unit_group
*) *slot
;
6847 gdb_assert (tu_group
!= nullptr);
6851 /* Partial symbol tables. */
6853 /* Create a psymtab named NAME and assign it to PER_CU.
6855 The caller must fill in the following details:
6856 dirname, textlow, texthigh. */
6858 static dwarf2_psymtab
*
6859 create_partial_symtab (dwarf2_per_cu_data
*per_cu
,
6860 dwarf2_per_objfile
*per_objfile
,
6864 = new dwarf2_psymtab (name
, per_objfile
->per_bfd
->partial_symtabs
.get (),
6865 per_objfile
->objfile
->per_bfd
, per_cu
);
6867 pst
->psymtabs_addrmap_supported
= true;
6869 /* This is the glue that links PST into GDB's symbol API. */
6870 per_cu
->v
.psymtab
= pst
;
6875 /* DIE reader function for process_psymtab_comp_unit. */
6878 process_psymtab_comp_unit_reader (const struct die_reader_specs
*reader
,
6879 const gdb_byte
*info_ptr
,
6880 struct die_info
*comp_unit_die
,
6881 enum language pretend_language
)
6883 struct dwarf2_cu
*cu
= reader
->cu
;
6884 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
6885 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
6886 struct objfile
*objfile
= per_objfile
->objfile
;
6887 struct gdbarch
*gdbarch
= objfile
->arch ();
6888 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
6890 CORE_ADDR best_lowpc
= 0, best_highpc
= 0;
6891 dwarf2_psymtab
*pst
;
6892 enum pc_bounds_kind cu_bounds_kind
;
6893 const char *filename
;
6895 gdb_assert (! per_cu
->is_debug_types
);
6897 prepare_one_comp_unit (cu
, comp_unit_die
, pretend_language
);
6899 /* Allocate a new partial symbol table structure. */
6900 gdb::unique_xmalloc_ptr
<char> debug_filename
;
6901 static const char artificial
[] = "<artificial>";
6902 filename
= dwarf2_string_attr (comp_unit_die
, DW_AT_name
, cu
);
6903 if (filename
== NULL
)
6905 else if (strcmp (filename
, artificial
) == 0)
6907 debug_filename
.reset (concat (artificial
, "@",
6908 sect_offset_str (per_cu
->sect_off
),
6910 filename
= debug_filename
.get ();
6913 pst
= create_partial_symtab (per_cu
, per_objfile
, filename
);
6915 /* This must be done before calling dwarf2_build_include_psymtabs. */
6916 pst
->dirname
= dwarf2_string_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
6918 baseaddr
= objfile
->text_section_offset ();
6920 dwarf2_find_base_address (comp_unit_die
, cu
);
6922 /* Possibly set the default values of LOWPC and HIGHPC from
6924 cu_bounds_kind
= dwarf2_get_pc_bounds (comp_unit_die
, &best_lowpc
,
6925 &best_highpc
, cu
, pst
);
6926 if (cu_bounds_kind
== PC_BOUNDS_HIGH_LOW
&& best_lowpc
< best_highpc
)
6929 = (gdbarch_adjust_dwarf2_addr (gdbarch
, best_lowpc
+ baseaddr
)
6932 = (gdbarch_adjust_dwarf2_addr (gdbarch
, best_highpc
+ baseaddr
)
6934 /* Store the contiguous range if it is not empty; it can be
6935 empty for CUs with no code. */
6936 addrmap_set_empty (per_bfd
->partial_symtabs
->psymtabs_addrmap
,
6940 /* Check if comp unit has_children.
6941 If so, read the rest of the partial symbols from this comp unit.
6942 If not, there's no more debug_info for this comp unit. */
6943 if (comp_unit_die
->has_children
)
6945 struct partial_die_info
*first_die
;
6946 CORE_ADDR lowpc
, highpc
;
6948 lowpc
= ((CORE_ADDR
) -1);
6949 highpc
= ((CORE_ADDR
) 0);
6951 first_die
= load_partial_dies (reader
, info_ptr
, 1);
6953 scan_partial_symbols (first_die
, &lowpc
, &highpc
,
6954 cu_bounds_kind
<= PC_BOUNDS_INVALID
, cu
);
6956 /* If we didn't find a lowpc, set it to highpc to avoid
6957 complaints from `maint check'. */
6958 if (lowpc
== ((CORE_ADDR
) -1))
6961 /* If the compilation unit didn't have an explicit address range,
6962 then use the information extracted from its child dies. */
6963 if (cu_bounds_kind
<= PC_BOUNDS_INVALID
)
6966 best_highpc
= highpc
;
6969 pst
->set_text_low (gdbarch_adjust_dwarf2_addr (gdbarch
,
6970 best_lowpc
+ baseaddr
)
6972 pst
->set_text_high (gdbarch_adjust_dwarf2_addr (gdbarch
,
6973 best_highpc
+ baseaddr
)
6978 if (!cu
->per_cu
->imported_symtabs_empty ())
6981 int len
= cu
->per_cu
->imported_symtabs_size ();
6983 /* Fill in 'dependencies' here; we fill in 'users' in a
6985 pst
->number_of_dependencies
= len
;
6987 = per_bfd
->partial_symtabs
->allocate_dependencies (len
);
6988 for (i
= 0; i
< len
; ++i
)
6990 pst
->dependencies
[i
]
6991 = cu
->per_cu
->imported_symtabs
->at (i
)->v
.psymtab
;
6994 cu
->per_cu
->imported_symtabs_free ();
6997 /* Get the list of files included in the current compilation unit,
6998 and build a psymtab for each of them. */
6999 dwarf2_build_include_psymtabs (cu
, comp_unit_die
, pst
);
7001 dwarf_read_debug_printf ("Psymtab for %s unit @%s: %s - %s"
7002 ", %d global, %d static syms",
7003 per_cu
->is_debug_types
? "type" : "comp",
7004 sect_offset_str (per_cu
->sect_off
),
7005 paddress (gdbarch
, pst
->text_low (objfile
)),
7006 paddress (gdbarch
, pst
->text_high (objfile
)),
7007 (int) pst
->global_psymbols
.size (),
7008 (int) pst
->static_psymbols
.size ());
7011 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
7012 Process compilation unit THIS_CU for a psymtab. */
7015 process_psymtab_comp_unit (dwarf2_per_cu_data
*this_cu
,
7016 dwarf2_per_objfile
*per_objfile
,
7017 bool want_partial_unit
,
7018 enum language pretend_language
)
7020 /* If this compilation unit was already read in, free the
7021 cached copy in order to read it in again. This is
7022 necessary because we skipped some symbols when we first
7023 read in the compilation unit (see load_partial_dies).
7024 This problem could be avoided, but the benefit is unclear. */
7025 per_objfile
->remove_cu (this_cu
);
7027 cutu_reader
reader (this_cu
, per_objfile
, nullptr, nullptr, false);
7029 if (reader
.comp_unit_die
== nullptr)
7032 switch (reader
.comp_unit_die
->tag
)
7034 case DW_TAG_compile_unit
:
7035 this_cu
->unit_type
= DW_UT_compile
;
7037 case DW_TAG_partial_unit
:
7038 this_cu
->unit_type
= DW_UT_partial
;
7040 case DW_TAG_type_unit
:
7041 this_cu
->unit_type
= DW_UT_type
;
7044 error (_("Dwarf Error: unexpected tag '%s' at offset %s [in module %s]"),
7045 dwarf_tag_name (reader
.comp_unit_die
->tag
),
7046 sect_offset_str (reader
.cu
->per_cu
->sect_off
),
7047 objfile_name (per_objfile
->objfile
));
7054 else if (this_cu
->is_debug_types
)
7055 build_type_psymtabs_reader (&reader
, reader
.info_ptr
,
7056 reader
.comp_unit_die
);
7057 else if (want_partial_unit
7058 || reader
.comp_unit_die
->tag
!= DW_TAG_partial_unit
)
7059 process_psymtab_comp_unit_reader (&reader
, reader
.info_ptr
,
7060 reader
.comp_unit_die
,
7063 /* Age out any secondary CUs. */
7064 per_objfile
->age_comp_units ();
7067 /* Reader function for build_type_psymtabs. */
7070 build_type_psymtabs_reader (const struct die_reader_specs
*reader
,
7071 const gdb_byte
*info_ptr
,
7072 struct die_info
*type_unit_die
)
7074 dwarf2_per_objfile
*per_objfile
= reader
->cu
->per_objfile
;
7075 struct dwarf2_cu
*cu
= reader
->cu
;
7076 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
7077 struct signatured_type
*sig_type
;
7078 struct type_unit_group
*tu_group
;
7079 struct attribute
*attr
;
7080 struct partial_die_info
*first_die
;
7081 CORE_ADDR lowpc
, highpc
;
7082 dwarf2_psymtab
*pst
;
7084 gdb_assert (per_cu
->is_debug_types
);
7085 sig_type
= (struct signatured_type
*) per_cu
;
7087 if (! type_unit_die
->has_children
)
7090 attr
= type_unit_die
->attr (DW_AT_stmt_list
);
7091 tu_group
= get_type_unit_group (cu
, attr
);
7093 if (tu_group
->tus
== nullptr)
7094 tu_group
->tus
= new std::vector
<signatured_type
*>;
7095 tu_group
->tus
->push_back (sig_type
);
7097 prepare_one_comp_unit (cu
, type_unit_die
, language_minimal
);
7098 pst
= create_partial_symtab (per_cu
, per_objfile
, "");
7099 pst
->anonymous
= true;
7101 first_die
= load_partial_dies (reader
, info_ptr
, 1);
7103 lowpc
= (CORE_ADDR
) -1;
7104 highpc
= (CORE_ADDR
) 0;
7105 scan_partial_symbols (first_die
, &lowpc
, &highpc
, 0, cu
);
7110 /* Struct used to sort TUs by their abbreviation table offset. */
7112 struct tu_abbrev_offset
7114 tu_abbrev_offset (signatured_type
*sig_type_
, sect_offset abbrev_offset_
)
7115 : sig_type (sig_type_
), abbrev_offset (abbrev_offset_
)
7118 /* This is used when sorting. */
7119 bool operator< (const tu_abbrev_offset
&other
) const
7121 return abbrev_offset
< other
.abbrev_offset
;
7124 signatured_type
*sig_type
;
7125 sect_offset abbrev_offset
;
7128 /* Efficiently read all the type units.
7130 The efficiency is because we sort TUs by the abbrev table they use and
7131 only read each abbrev table once. In one program there are 200K TUs
7132 sharing 8K abbrev tables.
7134 The main purpose of this function is to support building the
7135 dwarf2_per_objfile->per_bfd->type_unit_groups table.
7136 TUs typically share the DW_AT_stmt_list of the CU they came from, so we
7137 can collapse the search space by grouping them by stmt_list.
7138 The savings can be significant, in the same program from above the 200K TUs
7139 share 8K stmt_list tables.
7141 FUNC is expected to call get_type_unit_group, which will create the
7142 struct type_unit_group if necessary and add it to
7143 dwarf2_per_objfile->per_bfd->type_unit_groups. */
7146 build_type_psymtabs (dwarf2_per_objfile
*per_objfile
)
7148 struct tu_stats
*tu_stats
= &per_objfile
->per_bfd
->tu_stats
;
7149 abbrev_table_up abbrev_table
;
7150 sect_offset abbrev_offset
;
7152 /* It's up to the caller to not call us multiple times. */
7153 gdb_assert (per_objfile
->per_bfd
->type_unit_groups
== NULL
);
7155 if (per_objfile
->per_bfd
->tu_stats
.nr_tus
== 0)
7158 /* TUs typically share abbrev tables, and there can be way more TUs than
7159 abbrev tables. Sort by abbrev table to reduce the number of times we
7160 read each abbrev table in.
7161 Alternatives are to punt or to maintain a cache of abbrev tables.
7162 This is simpler and efficient enough for now.
7164 Later we group TUs by their DW_AT_stmt_list value (as this defines the
7165 symtab to use). Typically TUs with the same abbrev offset have the same
7166 stmt_list value too so in practice this should work well.
7168 The basic algorithm here is:
7170 sort TUs by abbrev table
7171 for each TU with same abbrev table:
7172 read abbrev table if first user
7173 read TU top level DIE
7174 [IWBN if DWO skeletons had DW_AT_stmt_list]
7177 dwarf_read_debug_printf ("Building type unit groups ...");
7179 /* Sort in a separate table to maintain the order of all_comp_units
7180 for .gdb_index: TU indices directly index all_type_units. */
7181 std::vector
<tu_abbrev_offset
> sorted_by_abbrev
;
7182 sorted_by_abbrev
.reserve (per_objfile
->per_bfd
->tu_stats
.nr_tus
);
7184 for (const auto &cu
: per_objfile
->per_bfd
->all_comp_units
)
7186 if (cu
->is_debug_types
)
7188 auto sig_type
= static_cast<signatured_type
*> (cu
.get ());
7189 sorted_by_abbrev
.emplace_back
7190 (sig_type
, read_abbrev_offset (per_objfile
, sig_type
->section
,
7191 sig_type
->sect_off
));
7195 std::sort (sorted_by_abbrev
.begin (), sorted_by_abbrev
.end ());
7197 abbrev_offset
= (sect_offset
) ~(unsigned) 0;
7199 for (const tu_abbrev_offset
&tu
: sorted_by_abbrev
)
7201 /* Switch to the next abbrev table if necessary. */
7202 if (abbrev_table
== NULL
7203 || tu
.abbrev_offset
!= abbrev_offset
)
7205 abbrev_offset
= tu
.abbrev_offset
;
7206 per_objfile
->per_bfd
->abbrev
.read (per_objfile
->objfile
);
7208 abbrev_table::read (&per_objfile
->per_bfd
->abbrev
, abbrev_offset
);
7209 ++tu_stats
->nr_uniq_abbrev_tables
;
7212 cutu_reader
reader (tu
.sig_type
, per_objfile
,
7213 abbrev_table
.get (), nullptr, false);
7214 if (!reader
.dummy_p
)
7215 build_type_psymtabs_reader (&reader
, reader
.info_ptr
,
7216 reader
.comp_unit_die
);
7220 /* Print collected type unit statistics. */
7223 print_tu_stats (dwarf2_per_objfile
*per_objfile
)
7225 struct tu_stats
*tu_stats
= &per_objfile
->per_bfd
->tu_stats
;
7227 dwarf_read_debug_printf ("Type unit statistics:");
7228 dwarf_read_debug_printf (" %d TUs", tu_stats
->nr_tus
);
7229 dwarf_read_debug_printf (" %d uniq abbrev tables",
7230 tu_stats
->nr_uniq_abbrev_tables
);
7231 dwarf_read_debug_printf (" %d symtabs from stmt_list entries",
7232 tu_stats
->nr_symtabs
);
7233 dwarf_read_debug_printf (" %d symtab sharers",
7234 tu_stats
->nr_symtab_sharers
);
7235 dwarf_read_debug_printf (" %d type units without a stmt_list",
7236 tu_stats
->nr_stmt_less_type_units
);
7237 dwarf_read_debug_printf (" %d all_type_units reallocs",
7238 tu_stats
->nr_all_type_units_reallocs
);
7241 /* Traversal function for build_type_psymtabs. */
7244 build_type_psymtab_dependencies (void **slot
, void *info
)
7246 dwarf2_per_objfile
*per_objfile
= (dwarf2_per_objfile
*) info
;
7247 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
7248 struct type_unit_group
*tu_group
= (struct type_unit_group
*) *slot
;
7249 dwarf2_psymtab
*pst
= tu_group
->v
.psymtab
;
7250 int len
= (tu_group
->tus
== nullptr) ? 0 : tu_group
->tus
->size ();
7253 gdb_assert (len
> 0);
7254 gdb_assert (tu_group
->type_unit_group_p ());
7256 pst
->number_of_dependencies
= len
;
7257 pst
->dependencies
= per_bfd
->partial_symtabs
->allocate_dependencies (len
);
7258 for (i
= 0; i
< len
; ++i
)
7260 struct signatured_type
*iter
= tu_group
->tus
->at (i
);
7261 gdb_assert (iter
->is_debug_types
);
7262 pst
->dependencies
[i
] = iter
->v
.psymtab
;
7263 iter
->type_unit_group
= tu_group
;
7266 delete tu_group
->tus
;
7267 tu_group
->tus
= nullptr;
7272 /* Traversal function for process_skeletonless_type_unit.
7273 Read a TU in a DWO file and build partial symbols for it. */
7276 process_skeletonless_type_unit (void **slot
, void *info
)
7278 struct dwo_unit
*dwo_unit
= (struct dwo_unit
*) *slot
;
7279 dwarf2_per_objfile
*per_objfile
= (dwarf2_per_objfile
*) info
;
7281 /* If this TU doesn't exist in the global table, add it and read it in. */
7283 if (per_objfile
->per_bfd
->signatured_types
== NULL
)
7284 per_objfile
->per_bfd
->signatured_types
= allocate_signatured_type_table ();
7286 signatured_type
find_entry (dwo_unit
->signature
);
7287 slot
= htab_find_slot (per_objfile
->per_bfd
->signatured_types
.get (),
7288 &find_entry
, INSERT
);
7289 /* If we've already seen this type there's nothing to do. What's happening
7290 is we're doing our own version of comdat-folding here. */
7294 /* This does the job that create_all_comp_units would have done for
7296 signatured_type
*entry
7297 = add_type_unit (per_objfile
, dwo_unit
->signature
, slot
);
7298 fill_in_sig_entry_from_dwo_entry (per_objfile
, entry
, dwo_unit
);
7301 /* This does the job that build_type_psymtabs would have done. */
7302 cutu_reader
reader (entry
, per_objfile
, nullptr, nullptr, false);
7303 if (!reader
.dummy_p
)
7304 build_type_psymtabs_reader (&reader
, reader
.info_ptr
,
7305 reader
.comp_unit_die
);
7310 /* Traversal function for process_skeletonless_type_units. */
7313 process_dwo_file_for_skeletonless_type_units (void **slot
, void *info
)
7315 struct dwo_file
*dwo_file
= (struct dwo_file
*) *slot
;
7317 if (dwo_file
->tus
!= NULL
)
7318 htab_traverse_noresize (dwo_file
->tus
.get (),
7319 process_skeletonless_type_unit
, info
);
7324 /* Scan all TUs of DWO files, verifying we've processed them.
7325 This is needed in case a TU was emitted without its skeleton.
7326 Note: This can't be done until we know what all the DWO files are. */
7329 process_skeletonless_type_units (dwarf2_per_objfile
*per_objfile
)
7331 /* Skeletonless TUs in DWP files without .gdb_index is not supported yet. */
7332 if (get_dwp_file (per_objfile
) == NULL
7333 && per_objfile
->per_bfd
->dwo_files
!= NULL
)
7335 htab_traverse_noresize (per_objfile
->per_bfd
->dwo_files
.get (),
7336 process_dwo_file_for_skeletonless_type_units
,
7341 /* Compute the 'user' field for each psymtab in DWARF2_PER_OBJFILE. */
7344 set_partial_user (dwarf2_per_objfile
*per_objfile
)
7346 for (const auto &per_cu
: per_objfile
->per_bfd
->all_comp_units
)
7348 dwarf2_psymtab
*pst
= per_cu
->v
.psymtab
;
7353 for (int j
= 0; j
< pst
->number_of_dependencies
; ++j
)
7355 /* Set the 'user' field only if it is not already set. */
7356 if (pst
->dependencies
[j
]->user
== NULL
)
7357 pst
->dependencies
[j
]->user
= pst
;
7362 /* Build the partial symbol table by doing a quick pass through the
7363 .debug_info and .debug_abbrev sections. */
7366 dwarf2_build_psymtabs_hard (dwarf2_per_objfile
*per_objfile
)
7368 struct objfile
*objfile
= per_objfile
->objfile
;
7369 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
7371 dwarf_read_debug_printf ("Building psymtabs of objfile %s ...",
7372 objfile_name (objfile
));
7374 scoped_restore restore_reading_psyms
7375 = make_scoped_restore (&per_bfd
->reading_partial_symbols
, true);
7377 per_bfd
->info
.read (objfile
);
7379 /* Any cached compilation units will be linked by the per-objfile
7380 read_in_chain. Make sure to free them when we're done. */
7381 free_cached_comp_units
freer (per_objfile
);
7383 create_all_comp_units (per_objfile
);
7384 build_type_psymtabs (per_objfile
);
7386 /* Create a temporary address map on a temporary obstack. We later
7387 copy this to the final obstack. */
7388 auto_obstack temp_obstack
;
7390 scoped_restore save_psymtabs_addrmap
7391 = make_scoped_restore (&per_bfd
->partial_symtabs
->psymtabs_addrmap
,
7392 addrmap_create_mutable (&temp_obstack
));
7394 for (const auto &per_cu
: per_bfd
->all_comp_units
)
7396 if (per_cu
->v
.psymtab
!= NULL
)
7397 /* In case a forward DW_TAG_imported_unit has read the CU already. */
7399 process_psymtab_comp_unit (per_cu
.get (), per_objfile
, false,
7403 /* This has to wait until we read the CUs, we need the list of DWOs. */
7404 process_skeletonless_type_units (per_objfile
);
7406 /* Now that all TUs have been processed we can fill in the dependencies. */
7407 if (per_bfd
->type_unit_groups
!= NULL
)
7409 htab_traverse_noresize (per_bfd
->type_unit_groups
.get (),
7410 build_type_psymtab_dependencies
, per_objfile
);
7413 if (dwarf_read_debug
> 0)
7414 print_tu_stats (per_objfile
);
7416 set_partial_user (per_objfile
);
7418 per_bfd
->partial_symtabs
->psymtabs_addrmap
7419 = addrmap_create_fixed (per_bfd
->partial_symtabs
->psymtabs_addrmap
,
7420 per_bfd
->partial_symtabs
->obstack ());
7421 /* At this point we want to keep the address map. */
7422 save_psymtabs_addrmap
.release ();
7424 dwarf_read_debug_printf ("Done building psymtabs of %s",
7425 objfile_name (objfile
));
7428 /* Load the partial DIEs for a secondary CU into memory.
7429 This is also used when rereading a primary CU with load_all_dies. */
7432 load_partial_comp_unit (dwarf2_per_cu_data
*this_cu
,
7433 dwarf2_per_objfile
*per_objfile
,
7434 dwarf2_cu
*existing_cu
)
7436 cutu_reader
reader (this_cu
, per_objfile
, nullptr, existing_cu
, false);
7438 if (!reader
.dummy_p
)
7440 prepare_one_comp_unit (reader
.cu
, reader
.comp_unit_die
,
7443 /* Check if comp unit has_children.
7444 If so, read the rest of the partial symbols from this comp unit.
7445 If not, there's no more debug_info for this comp unit. */
7446 if (reader
.comp_unit_die
->has_children
)
7447 load_partial_dies (&reader
, reader
.info_ptr
, 0);
7454 read_comp_units_from_section (dwarf2_per_objfile
*per_objfile
,
7455 struct dwarf2_section_info
*section
,
7456 struct dwarf2_section_info
*abbrev_section
,
7457 unsigned int is_dwz
,
7458 htab_up
&types_htab
,
7459 rcuh_kind section_kind
)
7461 const gdb_byte
*info_ptr
;
7462 struct objfile
*objfile
= per_objfile
->objfile
;
7464 dwarf_read_debug_printf ("Reading %s for %s",
7465 section
->get_name (),
7466 section
->get_file_name ());
7468 section
->read (objfile
);
7470 info_ptr
= section
->buffer
;
7472 while (info_ptr
< section
->buffer
+ section
->size
)
7474 dwarf2_per_cu_data_up this_cu
;
7476 sect_offset sect_off
= (sect_offset
) (info_ptr
- section
->buffer
);
7478 comp_unit_head cu_header
;
7479 read_and_check_comp_unit_head (per_objfile
, &cu_header
, section
,
7480 abbrev_section
, info_ptr
,
7483 /* Save the compilation unit for later lookup. */
7484 if (cu_header
.unit_type
!= DW_UT_type
)
7485 this_cu
= per_objfile
->per_bfd
->allocate_per_cu ();
7488 if (types_htab
== nullptr)
7489 types_htab
= allocate_signatured_type_table ();
7491 auto sig_type
= per_objfile
->per_bfd
->allocate_signatured_type
7492 (cu_header
.signature
);
7493 signatured_type
*sig_ptr
= sig_type
.get ();
7494 sig_type
->type_offset_in_tu
= cu_header
.type_cu_offset_in_tu
;
7495 this_cu
.reset (sig_type
.release ());
7497 void **slot
= htab_find_slot (types_htab
.get (), sig_ptr
, INSERT
);
7498 gdb_assert (slot
!= nullptr);
7499 if (*slot
!= nullptr)
7500 complaint (_("debug type entry at offset %s is duplicate to"
7501 " the entry at offset %s, signature %s"),
7502 sect_offset_str (sect_off
),
7503 sect_offset_str (sig_ptr
->sect_off
),
7504 hex_string (sig_ptr
->signature
));
7507 this_cu
->sect_off
= sect_off
;
7508 this_cu
->length
= cu_header
.length
+ cu_header
.initial_length_size
;
7509 this_cu
->is_dwz
= is_dwz
;
7510 this_cu
->section
= section
;
7512 info_ptr
= info_ptr
+ this_cu
->length
;
7513 per_objfile
->per_bfd
->all_comp_units
.push_back (std::move (this_cu
));
7517 /* Create a list of all compilation units in OBJFILE.
7518 This is only done for -readnow and building partial symtabs. */
7521 create_all_comp_units (dwarf2_per_objfile
*per_objfile
)
7525 read_comp_units_from_section (per_objfile
, &per_objfile
->per_bfd
->info
,
7526 &per_objfile
->per_bfd
->abbrev
, 0,
7527 types_htab
, rcuh_kind::COMPILE
);
7528 for (dwarf2_section_info
§ion
: per_objfile
->per_bfd
->types
)
7529 read_comp_units_from_section (per_objfile
, §ion
,
7530 &per_objfile
->per_bfd
->abbrev
, 0,
7531 types_htab
, rcuh_kind::TYPE
);
7533 dwz_file
*dwz
= dwarf2_get_dwz_file (per_objfile
->per_bfd
);
7535 read_comp_units_from_section (per_objfile
, &dwz
->info
, &dwz
->abbrev
, 1,
7536 types_htab
, rcuh_kind::COMPILE
);
7538 per_objfile
->per_bfd
->signatured_types
= std::move (types_htab
);
7541 /* Process all loaded DIEs for compilation unit CU, starting at
7542 FIRST_DIE. The caller should pass SET_ADDRMAP == 1 if the compilation
7543 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
7544 DW_AT_ranges). See the comments of add_partial_subprogram on how
7545 SET_ADDRMAP is used and how *LOWPC and *HIGHPC are updated. */
7548 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
7549 CORE_ADDR
*highpc
, int set_addrmap
,
7550 struct dwarf2_cu
*cu
)
7552 struct partial_die_info
*pdi
;
7554 /* Now, march along the PDI's, descending into ones which have
7555 interesting children but skipping the children of the other ones,
7556 until we reach the end of the compilation unit. */
7564 /* Anonymous namespaces or modules have no name but have interesting
7565 children, so we need to look at them. Ditto for anonymous
7568 if (pdi
->raw_name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
7569 || pdi
->tag
== DW_TAG_module
|| pdi
->tag
== DW_TAG_enumeration_type
7570 || pdi
->tag
== DW_TAG_imported_unit
7571 || pdi
->tag
== DW_TAG_inlined_subroutine
)
7575 case DW_TAG_subprogram
:
7576 case DW_TAG_inlined_subroutine
:
7577 add_partial_subprogram (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
7578 if (cu
->per_cu
->lang
== language_cplus
)
7579 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
,
7582 case DW_TAG_constant
:
7583 case DW_TAG_variable
:
7584 case DW_TAG_typedef
:
7585 case DW_TAG_union_type
:
7586 if (!pdi
->is_declaration
7587 || (pdi
->tag
== DW_TAG_variable
&& pdi
->is_external
))
7589 add_partial_symbol (pdi
, cu
);
7592 case DW_TAG_class_type
:
7593 case DW_TAG_interface_type
:
7594 case DW_TAG_structure_type
:
7595 if (!pdi
->is_declaration
)
7597 add_partial_symbol (pdi
, cu
);
7599 if ((cu
->per_cu
->lang
== language_rust
7600 || cu
->per_cu
->lang
== language_cplus
)
7601 && pdi
->has_children
)
7602 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
,
7605 case DW_TAG_enumeration_type
:
7606 if (!pdi
->is_declaration
)
7607 add_partial_enumeration (pdi
, cu
);
7609 case DW_TAG_base_type
:
7610 case DW_TAG_subrange_type
:
7611 /* File scope base type definitions are added to the partial
7613 add_partial_symbol (pdi
, cu
);
7615 case DW_TAG_namespace
:
7616 add_partial_namespace (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
7619 if (!pdi
->is_declaration
)
7620 add_partial_module (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
7622 case DW_TAG_imported_unit
:
7624 struct dwarf2_per_cu_data
*per_cu
;
7626 /* For now we don't handle imported units in type units. */
7627 if (cu
->per_cu
->is_debug_types
)
7629 error (_("Dwarf Error: DW_TAG_imported_unit is not"
7630 " supported in type units [in module %s]"),
7631 objfile_name (cu
->per_objfile
->objfile
));
7634 per_cu
= dwarf2_find_containing_comp_unit
7635 (pdi
->d
.sect_off
, pdi
->is_dwz
, cu
->per_objfile
);
7637 /* Go read the partial unit, if needed. */
7638 if (per_cu
->v
.psymtab
== NULL
)
7639 process_psymtab_comp_unit (per_cu
, cu
->per_objfile
, true,
7642 if (pdi
->die_parent
== nullptr
7643 && per_cu
->unit_type
== DW_UT_compile
7644 && per_cu
->lang
== language_cplus
)
7645 /* Regard import as hint. See corresponding code in
7646 process_imported_unit_die. */
7649 cu
->per_cu
->imported_symtabs_push (per_cu
);
7652 case DW_TAG_imported_declaration
:
7653 add_partial_symbol (pdi
, cu
);
7660 /* If the die has a sibling, skip to the sibling. */
7662 pdi
= pdi
->die_sibling
;
7666 /* Functions used to compute the fully scoped name of a partial DIE.
7668 Normally, this is simple. For C++, the parent DIE's fully scoped
7669 name is concatenated with "::" and the partial DIE's name.
7670 Enumerators are an exception; they use the scope of their parent
7671 enumeration type, i.e. the name of the enumeration type is not
7672 prepended to the enumerator.
7674 There are two complexities. One is DW_AT_specification; in this
7675 case "parent" means the parent of the target of the specification,
7676 instead of the direct parent of the DIE. The other is compilers
7677 which do not emit DW_TAG_namespace; in this case we try to guess
7678 the fully qualified name of structure types from their members'
7679 linkage names. This must be done using the DIE's children rather
7680 than the children of any DW_AT_specification target. We only need
7681 to do this for structures at the top level, i.e. if the target of
7682 any DW_AT_specification (if any; otherwise the DIE itself) does not
7685 /* Compute the scope prefix associated with PDI's parent, in
7686 compilation unit CU. The result will be allocated on CU's
7687 comp_unit_obstack, or a copy of the already allocated PDI->NAME
7688 field. NULL is returned if no prefix is necessary. */
7690 partial_die_parent_scope (struct partial_die_info
*pdi
,
7691 struct dwarf2_cu
*cu
)
7693 const char *grandparent_scope
;
7694 struct partial_die_info
*parent
, *real_pdi
;
7696 /* We need to look at our parent DIE; if we have a DW_AT_specification,
7697 then this means the parent of the specification DIE. */
7700 while (real_pdi
->has_specification
)
7702 auto res
= find_partial_die (real_pdi
->spec_offset
,
7703 real_pdi
->spec_is_dwz
, cu
);
7708 parent
= real_pdi
->die_parent
;
7712 if (parent
->scope_set
)
7713 return parent
->scope
;
7717 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
7719 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
7720 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
7721 Work around this problem here. */
7722 if (cu
->per_cu
->lang
== language_cplus
7723 && parent
->tag
== DW_TAG_namespace
7724 && strcmp (parent
->name (cu
), "::") == 0
7725 && grandparent_scope
== NULL
)
7727 parent
->scope
= NULL
;
7728 parent
->scope_set
= 1;
7732 /* Nested subroutines in Fortran get a prefix. */
7733 if (pdi
->tag
== DW_TAG_enumerator
)
7734 /* Enumerators should not get the name of the enumeration as a prefix. */
7735 parent
->scope
= grandparent_scope
;
7736 else if (parent
->tag
== DW_TAG_namespace
7737 || parent
->tag
== DW_TAG_module
7738 || parent
->tag
== DW_TAG_structure_type
7739 || parent
->tag
== DW_TAG_class_type
7740 || parent
->tag
== DW_TAG_interface_type
7741 || parent
->tag
== DW_TAG_union_type
7742 || parent
->tag
== DW_TAG_enumeration_type
7743 || (cu
->per_cu
->lang
== language_fortran
7744 && parent
->tag
== DW_TAG_subprogram
7745 && pdi
->tag
== DW_TAG_subprogram
))
7747 if (grandparent_scope
== NULL
)
7748 parent
->scope
= parent
->name (cu
);
7750 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
,
7752 parent
->name (cu
), 0, cu
);
7756 /* FIXME drow/2004-04-01: What should we be doing with
7757 function-local names? For partial symbols, we should probably be
7759 complaint (_("unhandled containing DIE tag %s for DIE at %s"),
7760 dwarf_tag_name (parent
->tag
),
7761 sect_offset_str (pdi
->sect_off
));
7762 parent
->scope
= grandparent_scope
;
7765 parent
->scope_set
= 1;
7766 return parent
->scope
;
7769 /* Return the fully scoped name associated with PDI, from compilation unit
7770 CU. The result will be allocated with malloc. */
7772 static gdb::unique_xmalloc_ptr
<char>
7773 partial_die_full_name (struct partial_die_info
*pdi
,
7774 struct dwarf2_cu
*cu
)
7776 const char *parent_scope
;
7778 /* If this is a template instantiation, we can not work out the
7779 template arguments from partial DIEs. So, unfortunately, we have
7780 to go through the full DIEs. At least any work we do building
7781 types here will be reused if full symbols are loaded later. */
7782 if (pdi
->has_template_arguments
)
7786 if (pdi
->name (cu
) != NULL
&& strchr (pdi
->name (cu
), '<') == NULL
)
7788 struct die_info
*die
;
7789 struct attribute attr
;
7790 struct dwarf2_cu
*ref_cu
= cu
;
7792 /* DW_FORM_ref_addr is using section offset. */
7793 attr
.name
= (enum dwarf_attribute
) 0;
7794 attr
.form
= DW_FORM_ref_addr
;
7795 attr
.u
.unsnd
= to_underlying (pdi
->sect_off
);
7796 die
= follow_die_ref (NULL
, &attr
, &ref_cu
);
7798 return make_unique_xstrdup (dwarf2_full_name (NULL
, die
, ref_cu
));
7802 parent_scope
= partial_die_parent_scope (pdi
, cu
);
7803 if (parent_scope
== NULL
)
7806 return gdb::unique_xmalloc_ptr
<char> (typename_concat (NULL
, parent_scope
,
7812 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
7814 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
7815 struct objfile
*objfile
= per_objfile
->objfile
;
7816 struct gdbarch
*gdbarch
= objfile
->arch ();
7818 const char *actual_name
= NULL
;
7821 baseaddr
= objfile
->text_section_offset ();
7823 gdb::unique_xmalloc_ptr
<char> built_actual_name
7824 = partial_die_full_name (pdi
, cu
);
7825 if (built_actual_name
!= NULL
)
7826 actual_name
= built_actual_name
.get ();
7828 if (actual_name
== NULL
)
7829 actual_name
= pdi
->name (cu
);
7831 partial_symbol psymbol
;
7832 memset (&psymbol
, 0, sizeof (psymbol
));
7833 psymbol
.ginfo
.set_language (cu
->per_cu
->lang
,
7834 &objfile
->objfile_obstack
);
7835 psymbol
.ginfo
.set_section_index (-1);
7837 /* The code below indicates that the psymbol should be installed by
7839 gdb::optional
<psymbol_placement
> where
;
7843 case DW_TAG_inlined_subroutine
:
7844 case DW_TAG_subprogram
:
7845 addr
= (gdbarch_adjust_dwarf2_addr (gdbarch
, pdi
->lowpc
+ baseaddr
)
7847 if (pdi
->is_external
7848 || cu
->per_cu
->lang
== language_ada
7849 || (cu
->per_cu
->lang
== language_fortran
7850 && pdi
->die_parent
!= NULL
7851 && pdi
->die_parent
->tag
== DW_TAG_subprogram
))
7853 /* Normally, only "external" DIEs are part of the global scope.
7854 But in Ada and Fortran, we want to be able to access nested
7855 procedures globally. So all Ada and Fortran subprograms are
7856 stored in the global scope. */
7857 where
= psymbol_placement::GLOBAL
;
7860 where
= psymbol_placement::STATIC
;
7862 psymbol
.domain
= VAR_DOMAIN
;
7863 psymbol
.aclass
= LOC_BLOCK
;
7864 psymbol
.ginfo
.set_section_index (SECT_OFF_TEXT (objfile
));
7865 psymbol
.ginfo
.value
.address
= addr
;
7867 if (pdi
->main_subprogram
&& actual_name
!= NULL
)
7868 set_objfile_main_name (objfile
, actual_name
, cu
->per_cu
->lang
);
7870 case DW_TAG_constant
:
7871 psymbol
.domain
= VAR_DOMAIN
;
7872 psymbol
.aclass
= LOC_STATIC
;
7873 where
= (pdi
->is_external
7874 ? psymbol_placement::GLOBAL
7875 : psymbol_placement::STATIC
);
7877 case DW_TAG_variable
:
7879 addr
= decode_locdesc (pdi
->d
.locdesc
, cu
);
7883 && !per_objfile
->per_bfd
->has_section_at_zero
)
7885 /* A global or static variable may also have been stripped
7886 out by the linker if unused, in which case its address
7887 will be nullified; do not add such variables into partial
7888 symbol table then. */
7890 else if (pdi
->is_external
)
7893 Don't enter into the minimal symbol tables as there is
7894 a minimal symbol table entry from the ELF symbols already.
7895 Enter into partial symbol table if it has a location
7896 descriptor or a type.
7897 If the location descriptor is missing, new_symbol will create
7898 a LOC_UNRESOLVED symbol, the address of the variable will then
7899 be determined from the minimal symbol table whenever the variable
7901 The address for the partial symbol table entry is not
7902 used by GDB, but it comes in handy for debugging partial symbol
7905 if (pdi
->d
.locdesc
|| pdi
->has_type
)
7907 psymbol
.domain
= VAR_DOMAIN
;
7908 psymbol
.aclass
= LOC_STATIC
;
7909 psymbol
.ginfo
.set_section_index (SECT_OFF_TEXT (objfile
));
7910 psymbol
.ginfo
.value
.address
= addr
;
7911 where
= psymbol_placement::GLOBAL
;
7916 int has_loc
= pdi
->d
.locdesc
!= NULL
;
7918 /* Static Variable. Skip symbols whose value we cannot know (those
7919 without location descriptors or constant values). */
7920 if (!has_loc
&& !pdi
->has_const_value
)
7923 psymbol
.domain
= VAR_DOMAIN
;
7924 psymbol
.aclass
= LOC_STATIC
;
7925 psymbol
.ginfo
.set_section_index (SECT_OFF_TEXT (objfile
));
7927 psymbol
.ginfo
.value
.address
= addr
;
7928 where
= psymbol_placement::STATIC
;
7931 case DW_TAG_array_type
:
7932 case DW_TAG_typedef
:
7933 case DW_TAG_base_type
:
7934 case DW_TAG_subrange_type
:
7935 psymbol
.domain
= VAR_DOMAIN
;
7936 psymbol
.aclass
= LOC_TYPEDEF
;
7937 where
= psymbol_placement::STATIC
;
7939 case DW_TAG_imported_declaration
:
7940 case DW_TAG_namespace
:
7941 psymbol
.domain
= VAR_DOMAIN
;
7942 psymbol
.aclass
= LOC_TYPEDEF
;
7943 where
= psymbol_placement::GLOBAL
;
7946 /* With Fortran 77 there might be a "BLOCK DATA" module
7947 available without any name. If so, we skip the module as it
7948 doesn't bring any value. */
7949 if (actual_name
!= nullptr)
7951 psymbol
.domain
= MODULE_DOMAIN
;
7952 psymbol
.aclass
= LOC_TYPEDEF
;
7953 where
= psymbol_placement::GLOBAL
;
7956 case DW_TAG_class_type
:
7957 case DW_TAG_interface_type
:
7958 case DW_TAG_structure_type
:
7959 case DW_TAG_union_type
:
7960 case DW_TAG_enumeration_type
:
7961 /* Skip external references. The DWARF standard says in the section
7962 about "Structure, Union, and Class Type Entries": "An incomplete
7963 structure, union or class type is represented by a structure,
7964 union or class entry that does not have a byte size attribute
7965 and that has a DW_AT_declaration attribute." */
7966 if (!pdi
->has_byte_size
&& pdi
->is_declaration
)
7969 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
7970 static vs. global. */
7971 psymbol
.domain
= STRUCT_DOMAIN
;
7972 psymbol
.aclass
= LOC_TYPEDEF
;
7973 where
= (cu
->per_cu
->lang
== language_cplus
7974 ? psymbol_placement::GLOBAL
7975 : psymbol_placement::STATIC
);
7977 case DW_TAG_enumerator
:
7978 psymbol
.domain
= VAR_DOMAIN
;
7979 psymbol
.aclass
= LOC_CONST
;
7980 where
= (cu
->per_cu
->lang
== language_cplus
7981 ? psymbol_placement::GLOBAL
7982 : psymbol_placement::STATIC
);
7988 if (where
.has_value ())
7990 if (built_actual_name
!= nullptr)
7991 actual_name
= objfile
->intern (actual_name
);
7992 if (pdi
->linkage_name
== nullptr
7993 || cu
->per_cu
->lang
== language_ada
)
7994 psymbol
.ginfo
.set_linkage_name (actual_name
);
7997 psymbol
.ginfo
.set_demangled_name (actual_name
,
7998 &objfile
->objfile_obstack
);
7999 psymbol
.ginfo
.set_linkage_name (pdi
->linkage_name
);
8001 cu
->per_cu
->v
.psymtab
->add_psymbol
8002 (psymbol
, *where
, per_objfile
->per_bfd
->partial_symtabs
.get (),
8007 /* Read a partial die corresponding to a namespace; also, add a symbol
8008 corresponding to that namespace to the symbol table. NAMESPACE is
8009 the name of the enclosing namespace. */
8012 add_partial_namespace (struct partial_die_info
*pdi
,
8013 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
8014 int set_addrmap
, struct dwarf2_cu
*cu
)
8016 /* Add a symbol for the namespace. */
8018 add_partial_symbol (pdi
, cu
);
8020 /* Now scan partial symbols in that namespace. */
8022 if (pdi
->has_children
)
8023 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, set_addrmap
, cu
);
8026 /* Read a partial die corresponding to a Fortran module. */
8029 add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
8030 CORE_ADDR
*highpc
, int set_addrmap
, struct dwarf2_cu
*cu
)
8032 /* Add a symbol for the namespace. */
8034 add_partial_symbol (pdi
, cu
);
8036 /* Now scan partial symbols in that module. */
8038 if (pdi
->has_children
)
8039 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, set_addrmap
, cu
);
8042 /* Read a partial die corresponding to a subprogram or an inlined
8043 subprogram and create a partial symbol for that subprogram.
8044 When the CU language allows it, this routine also defines a partial
8045 symbol for each nested subprogram that this subprogram contains.
8046 If SET_ADDRMAP is true, record the covered ranges in the addrmap.
8047 Set *LOWPC and *HIGHPC to the lowest and highest PC values found in PDI.
8049 PDI may also be a lexical block, in which case we simply search
8050 recursively for subprograms defined inside that lexical block.
8051 Again, this is only performed when the CU language allows this
8052 type of definitions. */
8055 add_partial_subprogram (struct partial_die_info
*pdi
,
8056 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
8057 int set_addrmap
, struct dwarf2_cu
*cu
)
8059 if (pdi
->tag
== DW_TAG_subprogram
|| pdi
->tag
== DW_TAG_inlined_subroutine
)
8061 if (pdi
->has_pc_info
)
8063 if (pdi
->lowpc
< *lowpc
)
8064 *lowpc
= pdi
->lowpc
;
8065 if (pdi
->highpc
> *highpc
)
8066 *highpc
= pdi
->highpc
;
8069 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
8070 dwarf2_per_bfd
*per_bfd
= cu
->per_objfile
->per_bfd
;
8071 struct gdbarch
*gdbarch
= objfile
->arch ();
8073 CORE_ADDR this_highpc
;
8074 CORE_ADDR this_lowpc
;
8076 baseaddr
= objfile
->text_section_offset ();
8078 = (gdbarch_adjust_dwarf2_addr (gdbarch
,
8079 pdi
->lowpc
+ baseaddr
)
8082 = (gdbarch_adjust_dwarf2_addr (gdbarch
,
8083 pdi
->highpc
+ baseaddr
)
8085 addrmap_set_empty (per_bfd
->partial_symtabs
->psymtabs_addrmap
,
8086 this_lowpc
, this_highpc
- 1,
8087 cu
->per_cu
->v
.psymtab
);
8091 if (pdi
->has_pc_info
|| (!pdi
->is_external
&& pdi
->may_be_inlined
))
8093 if (!pdi
->is_declaration
)
8094 /* Ignore subprogram DIEs that do not have a name, they are
8095 illegal. Do not emit a complaint at this point, we will
8096 do so when we convert this psymtab into a symtab. */
8098 add_partial_symbol (pdi
, cu
);
8102 if (! pdi
->has_children
)
8105 if (cu
->per_cu
->lang
== language_ada
8106 || cu
->per_cu
->lang
== language_fortran
)
8108 pdi
= pdi
->die_child
;
8112 if (pdi
->tag
== DW_TAG_subprogram
8113 || pdi
->tag
== DW_TAG_inlined_subroutine
8114 || pdi
->tag
== DW_TAG_lexical_block
)
8115 add_partial_subprogram (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
8116 pdi
= pdi
->die_sibling
;
8121 /* Read a partial die corresponding to an enumeration type. */
8124 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
8125 struct dwarf2_cu
*cu
)
8127 struct partial_die_info
*pdi
;
8129 if (enum_pdi
->name (cu
) != NULL
)
8130 add_partial_symbol (enum_pdi
, cu
);
8132 pdi
= enum_pdi
->die_child
;
8135 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->raw_name
== NULL
)
8136 complaint (_("malformed enumerator DIE ignored"));
8138 add_partial_symbol (pdi
, cu
);
8139 pdi
= pdi
->die_sibling
;
8143 /* Return the initial uleb128 in the die at INFO_PTR. */
8146 peek_abbrev_code (bfd
*abfd
, const gdb_byte
*info_ptr
)
8148 unsigned int bytes_read
;
8150 return read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
8153 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit
8154 READER::CU. Use READER::ABBREV_TABLE to lookup any abbreviation.
8156 Return the corresponding abbrev, or NULL if the number is zero (indicating
8157 an empty DIE). In either case *BYTES_READ will be set to the length of
8158 the initial number. */
8160 static const struct abbrev_info
*
8161 peek_die_abbrev (const die_reader_specs
&reader
,
8162 const gdb_byte
*info_ptr
, unsigned int *bytes_read
)
8164 dwarf2_cu
*cu
= reader
.cu
;
8165 bfd
*abfd
= reader
.abfd
;
8166 unsigned int abbrev_number
8167 = read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
8169 if (abbrev_number
== 0)
8172 const abbrev_info
*abbrev
8173 = reader
.abbrev_table
->lookup_abbrev (abbrev_number
);
8176 error (_("Dwarf Error: Could not find abbrev number %d in %s"
8177 " at offset %s [in module %s]"),
8178 abbrev_number
, cu
->per_cu
->is_debug_types
? "TU" : "CU",
8179 sect_offset_str (cu
->header
.sect_off
), bfd_get_filename (abfd
));
8185 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
8186 Returns a pointer to the end of a series of DIEs, terminated by an empty
8187 DIE. Any children of the skipped DIEs will also be skipped. */
8189 static const gdb_byte
*
8190 skip_children (const struct die_reader_specs
*reader
, const gdb_byte
*info_ptr
)
8194 unsigned int bytes_read
;
8195 const abbrev_info
*abbrev
= peek_die_abbrev (*reader
, info_ptr
,
8199 return info_ptr
+ bytes_read
;
8201 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
8205 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
8206 INFO_PTR should point just after the initial uleb128 of a DIE, and the
8207 abbrev corresponding to that skipped uleb128 should be passed in
8208 ABBREV. Returns a pointer to this DIE's sibling, skipping any
8211 static const gdb_byte
*
8212 skip_one_die (const struct die_reader_specs
*reader
, const gdb_byte
*info_ptr
,
8213 const struct abbrev_info
*abbrev
)
8215 unsigned int bytes_read
;
8216 struct attribute attr
;
8217 bfd
*abfd
= reader
->abfd
;
8218 struct dwarf2_cu
*cu
= reader
->cu
;
8219 const gdb_byte
*buffer
= reader
->buffer
;
8220 const gdb_byte
*buffer_end
= reader
->buffer_end
;
8221 unsigned int form
, i
;
8223 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
8225 /* The only abbrev we care about is DW_AT_sibling. */
8226 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
8228 read_attribute (reader
, &attr
, &abbrev
->attrs
[i
], info_ptr
);
8229 if (attr
.form
== DW_FORM_ref_addr
)
8230 complaint (_("ignoring absolute DW_AT_sibling"));
8233 sect_offset off
= attr
.get_ref_die_offset ();
8234 const gdb_byte
*sibling_ptr
= buffer
+ to_underlying (off
);
8236 if (sibling_ptr
< info_ptr
)
8237 complaint (_("DW_AT_sibling points backwards"));
8238 else if (sibling_ptr
> reader
->buffer_end
)
8239 reader
->die_section
->overflow_complaint ();
8245 /* If it isn't DW_AT_sibling, skip this attribute. */
8246 form
= abbrev
->attrs
[i
].form
;
8250 case DW_FORM_ref_addr
:
8251 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
8252 and later it is offset sized. */
8253 if (cu
->header
.version
== 2)
8254 info_ptr
+= cu
->header
.addr_size
;
8256 info_ptr
+= cu
->header
.offset_size
;
8258 case DW_FORM_GNU_ref_alt
:
8259 info_ptr
+= cu
->header
.offset_size
;
8262 info_ptr
+= cu
->header
.addr_size
;
8270 case DW_FORM_flag_present
:
8271 case DW_FORM_implicit_const
:
8288 case DW_FORM_ref_sig8
:
8291 case DW_FORM_data16
:
8294 case DW_FORM_string
:
8295 read_direct_string (abfd
, info_ptr
, &bytes_read
);
8296 info_ptr
+= bytes_read
;
8298 case DW_FORM_sec_offset
:
8300 case DW_FORM_GNU_strp_alt
:
8301 info_ptr
+= cu
->header
.offset_size
;
8303 case DW_FORM_exprloc
:
8305 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
8306 info_ptr
+= bytes_read
;
8308 case DW_FORM_block1
:
8309 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
8311 case DW_FORM_block2
:
8312 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
8314 case DW_FORM_block4
:
8315 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
8321 case DW_FORM_ref_udata
:
8322 case DW_FORM_GNU_addr_index
:
8323 case DW_FORM_GNU_str_index
:
8324 case DW_FORM_rnglistx
:
8325 case DW_FORM_loclistx
:
8326 info_ptr
= safe_skip_leb128 (info_ptr
, buffer_end
);
8328 case DW_FORM_indirect
:
8329 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
8330 info_ptr
+= bytes_read
;
8331 /* We need to continue parsing from here, so just go back to
8333 goto skip_attribute
;
8336 error (_("Dwarf Error: Cannot handle %s "
8337 "in DWARF reader [in module %s]"),
8338 dwarf_form_name (form
),
8339 bfd_get_filename (abfd
));
8343 if (abbrev
->has_children
)
8344 return skip_children (reader
, info_ptr
);
8349 /* Locate ORIG_PDI's sibling.
8350 INFO_PTR should point to the start of the next DIE after ORIG_PDI. */
8352 static const gdb_byte
*
8353 locate_pdi_sibling (const struct die_reader_specs
*reader
,
8354 struct partial_die_info
*orig_pdi
,
8355 const gdb_byte
*info_ptr
)
8357 /* Do we know the sibling already? */
8359 if (orig_pdi
->sibling
)
8360 return orig_pdi
->sibling
;
8362 /* Are there any children to deal with? */
8364 if (!orig_pdi
->has_children
)
8367 /* Skip the children the long way. */
8369 return skip_children (reader
, info_ptr
);
8372 /* Expand this partial symbol table into a full symbol table. SELF is
8376 dwarf2_psymtab::read_symtab (struct objfile
*objfile
)
8378 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
8380 gdb_assert (!per_objfile
->symtab_set_p (per_cu_data
));
8382 /* If this psymtab is constructed from a debug-only objfile, the
8383 has_section_at_zero flag will not necessarily be correct. We
8384 can get the correct value for this flag by looking at the data
8385 associated with the (presumably stripped) associated objfile. */
8386 if (objfile
->separate_debug_objfile_backlink
)
8388 dwarf2_per_objfile
*per_objfile_backlink
8389 = get_dwarf2_per_objfile (objfile
->separate_debug_objfile_backlink
);
8391 per_objfile
->per_bfd
->has_section_at_zero
8392 = per_objfile_backlink
->per_bfd
->has_section_at_zero
;
8395 expand_psymtab (objfile
);
8397 process_cu_includes (per_objfile
);
8400 /* Reading in full CUs. */
8402 /* Add PER_CU to the queue. */
8405 queue_comp_unit (dwarf2_per_cu_data
*per_cu
,
8406 dwarf2_per_objfile
*per_objfile
,
8407 enum language pretend_language
)
8411 gdb_assert (per_objfile
->per_bfd
->queue
.has_value ());
8412 per_cu
->per_bfd
->queue
->emplace (per_cu
, per_objfile
, pretend_language
);
8415 /* If PER_CU is not yet expanded of queued for expansion, add it to the queue.
8417 If DEPENDENT_CU is non-NULL, it has a reference to PER_CU so add a
8420 Return true if maybe_queue_comp_unit requires the caller to load the CU's
8421 DIEs, false otherwise.
8423 Explanation: there is an invariant that if a CU is queued for expansion
8424 (present in `dwarf2_per_bfd::queue`), then its DIEs are loaded
8425 (a dwarf2_cu object exists for this CU, and `dwarf2_per_objfile::get_cu`
8426 returns non-nullptr). If the CU gets enqueued by this function but its DIEs
8427 are not yet loaded, the the caller must load the CU's DIEs to ensure the
8428 invariant is respected.
8430 The caller is therefore not required to load the CU's DIEs (we return false)
8433 - the CU is already expanded, and therefore does not get enqueued
8434 - the CU gets enqueued for expansion, but its DIEs are already loaded
8436 Note that the caller should not use this function's return value as an
8437 indicator of whether the CU's DIEs are loaded right now, it should check
8438 that by calling `dwarf2_per_objfile::get_cu` instead. */
8441 maybe_queue_comp_unit (struct dwarf2_cu
*dependent_cu
,
8442 dwarf2_per_cu_data
*per_cu
,
8443 dwarf2_per_objfile
*per_objfile
,
8444 enum language pretend_language
)
8446 /* We may arrive here during partial symbol reading, if we need full
8447 DIEs to process an unusual case (e.g. template arguments). Do
8448 not queue PER_CU, just tell our caller to load its DIEs. */
8449 if (per_cu
->per_bfd
->reading_partial_symbols
)
8451 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
8453 if (cu
== NULL
|| cu
->dies
== NULL
)
8458 /* Mark the dependence relation so that we don't flush PER_CU
8460 if (dependent_cu
!= NULL
)
8461 dependent_cu
->add_dependence (per_cu
);
8463 /* If it's already on the queue, we have nothing to do. */
8466 /* Verify the invariant that if a CU is queued for expansion, its DIEs are
8468 gdb_assert (per_objfile
->get_cu (per_cu
) != nullptr);
8470 /* If the CU is queued for expansion, it should not already be
8472 gdb_assert (!per_objfile
->symtab_set_p (per_cu
));
8474 /* The DIEs are already loaded, the caller doesn't need to do it. */
8478 bool queued
= false;
8479 if (!per_objfile
->symtab_set_p (per_cu
))
8481 /* Add it to the queue. */
8482 queue_comp_unit (per_cu
, per_objfile
, pretend_language
);
8486 /* If the compilation unit is already loaded, just mark it as
8488 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
8492 /* Ask the caller to load the CU's DIEs if the CU got enqueued for expansion
8493 and the DIEs are not already loaded. */
8494 return queued
&& cu
== nullptr;
8497 /* Process the queue. */
8500 process_queue (dwarf2_per_objfile
*per_objfile
)
8502 dwarf_read_debug_printf ("Expanding one or more symtabs of objfile %s ...",
8503 objfile_name (per_objfile
->objfile
));
8505 /* The queue starts out with one item, but following a DIE reference
8506 may load a new CU, adding it to the end of the queue. */
8507 while (!per_objfile
->per_bfd
->queue
->empty ())
8509 dwarf2_queue_item
&item
= per_objfile
->per_bfd
->queue
->front ();
8510 dwarf2_per_cu_data
*per_cu
= item
.per_cu
;
8512 if (!per_objfile
->symtab_set_p (per_cu
))
8514 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
8516 /* Skip dummy CUs. */
8519 unsigned int debug_print_threshold
;
8522 if (per_cu
->is_debug_types
)
8524 struct signatured_type
*sig_type
=
8525 (struct signatured_type
*) per_cu
;
8527 sprintf (buf
, "TU %s at offset %s",
8528 hex_string (sig_type
->signature
),
8529 sect_offset_str (per_cu
->sect_off
));
8530 /* There can be 100s of TUs.
8531 Only print them in verbose mode. */
8532 debug_print_threshold
= 2;
8536 sprintf (buf
, "CU at offset %s",
8537 sect_offset_str (per_cu
->sect_off
));
8538 debug_print_threshold
= 1;
8541 if (dwarf_read_debug
>= debug_print_threshold
)
8542 dwarf_read_debug_printf ("Expanding symtab of %s", buf
);
8544 if (per_cu
->is_debug_types
)
8545 process_full_type_unit (cu
, item
.pretend_language
);
8547 process_full_comp_unit (cu
, item
.pretend_language
);
8549 if (dwarf_read_debug
>= debug_print_threshold
)
8550 dwarf_read_debug_printf ("Done expanding %s", buf
);
8555 per_objfile
->per_bfd
->queue
->pop ();
8558 dwarf_read_debug_printf ("Done expanding symtabs of %s.",
8559 objfile_name (per_objfile
->objfile
));
8562 /* Read in full symbols for PST, and anything it depends on. */
8565 dwarf2_psymtab::expand_psymtab (struct objfile
*objfile
)
8567 gdb_assert (!readin_p (objfile
));
8569 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
8570 free_cached_comp_units
freer (per_objfile
);
8571 expand_dependencies (objfile
);
8573 dw2_do_instantiate_symtab (per_cu_data
, per_objfile
, false);
8574 gdb_assert (get_compunit_symtab (objfile
) != nullptr);
8577 /* See psympriv.h. */
8580 dwarf2_psymtab::readin_p (struct objfile
*objfile
) const
8582 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
8583 return per_objfile
->symtab_set_p (per_cu_data
);
8586 /* See psympriv.h. */
8589 dwarf2_psymtab::get_compunit_symtab (struct objfile
*objfile
) const
8591 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
8592 return per_objfile
->get_symtab (per_cu_data
);
8595 /* Trivial hash function for die_info: the hash value of a DIE
8596 is its offset in .debug_info for this objfile. */
8599 die_hash (const void *item
)
8601 const struct die_info
*die
= (const struct die_info
*) item
;
8603 return to_underlying (die
->sect_off
);
8606 /* Trivial comparison function for die_info structures: two DIEs
8607 are equal if they have the same offset. */
8610 die_eq (const void *item_lhs
, const void *item_rhs
)
8612 const struct die_info
*die_lhs
= (const struct die_info
*) item_lhs
;
8613 const struct die_info
*die_rhs
= (const struct die_info
*) item_rhs
;
8615 return die_lhs
->sect_off
== die_rhs
->sect_off
;
8618 /* Load the DIEs associated with PER_CU into memory.
8620 In some cases, the caller, while reading partial symbols, will need to load
8621 the full symbols for the CU for some reason. It will already have a
8622 dwarf2_cu object for THIS_CU and pass it as EXISTING_CU, so it can be re-used
8623 rather than creating a new one. */
8626 load_full_comp_unit (dwarf2_per_cu_data
*this_cu
,
8627 dwarf2_per_objfile
*per_objfile
,
8628 dwarf2_cu
*existing_cu
,
8630 enum language pretend_language
)
8632 gdb_assert (! this_cu
->is_debug_types
);
8634 cutu_reader
reader (this_cu
, per_objfile
, NULL
, existing_cu
, skip_partial
);
8638 struct dwarf2_cu
*cu
= reader
.cu
;
8639 const gdb_byte
*info_ptr
= reader
.info_ptr
;
8641 gdb_assert (cu
->die_hash
== NULL
);
8643 htab_create_alloc_ex (cu
->header
.length
/ 12,
8647 &cu
->comp_unit_obstack
,
8648 hashtab_obstack_allocate
,
8649 dummy_obstack_deallocate
);
8651 if (reader
.comp_unit_die
->has_children
)
8652 reader
.comp_unit_die
->child
8653 = read_die_and_siblings (&reader
, reader
.info_ptr
,
8654 &info_ptr
, reader
.comp_unit_die
);
8655 cu
->dies
= reader
.comp_unit_die
;
8656 /* comp_unit_die is not stored in die_hash, no need. */
8658 /* We try not to read any attributes in this function, because not
8659 all CUs needed for references have been loaded yet, and symbol
8660 table processing isn't initialized. But we have to set the CU language,
8661 or we won't be able to build types correctly.
8662 Similarly, if we do not read the producer, we can not apply
8663 producer-specific interpretation. */
8664 prepare_one_comp_unit (cu
, cu
->dies
, pretend_language
);
8669 /* Add a DIE to the delayed physname list. */
8672 add_to_method_list (struct type
*type
, int fnfield_index
, int index
,
8673 const char *name
, struct die_info
*die
,
8674 struct dwarf2_cu
*cu
)
8676 struct delayed_method_info mi
;
8678 mi
.fnfield_index
= fnfield_index
;
8682 cu
->method_list
.push_back (mi
);
8685 /* Check whether [PHYSNAME, PHYSNAME+LEN) ends with a modifier like
8686 "const" / "volatile". If so, decrements LEN by the length of the
8687 modifier and return true. Otherwise return false. */
8691 check_modifier (const char *physname
, size_t &len
, const char (&mod
)[N
])
8693 size_t mod_len
= sizeof (mod
) - 1;
8694 if (len
> mod_len
&& startswith (physname
+ (len
- mod_len
), mod
))
8702 /* Compute the physnames of any methods on the CU's method list.
8704 The computation of method physnames is delayed in order to avoid the
8705 (bad) condition that one of the method's formal parameters is of an as yet
8709 compute_delayed_physnames (struct dwarf2_cu
*cu
)
8711 /* Only C++ delays computing physnames. */
8712 if (cu
->method_list
.empty ())
8714 gdb_assert (cu
->per_cu
->lang
== language_cplus
);
8716 for (const delayed_method_info
&mi
: cu
->method_list
)
8718 const char *physname
;
8719 struct fn_fieldlist
*fn_flp
8720 = &TYPE_FN_FIELDLIST (mi
.type
, mi
.fnfield_index
);
8721 physname
= dwarf2_physname (mi
.name
, mi
.die
, cu
);
8722 TYPE_FN_FIELD_PHYSNAME (fn_flp
->fn_fields
, mi
.index
)
8723 = physname
? physname
: "";
8725 /* Since there's no tag to indicate whether a method is a
8726 const/volatile overload, extract that information out of the
8728 if (physname
!= NULL
)
8730 size_t len
= strlen (physname
);
8734 if (physname
[len
] == ')') /* shortcut */
8736 else if (check_modifier (physname
, len
, " const"))
8737 TYPE_FN_FIELD_CONST (fn_flp
->fn_fields
, mi
.index
) = 1;
8738 else if (check_modifier (physname
, len
, " volatile"))
8739 TYPE_FN_FIELD_VOLATILE (fn_flp
->fn_fields
, mi
.index
) = 1;
8746 /* The list is no longer needed. */
8747 cu
->method_list
.clear ();
8750 /* Go objects should be embedded in a DW_TAG_module DIE,
8751 and it's not clear if/how imported objects will appear.
8752 To keep Go support simple until that's worked out,
8753 go back through what we've read and create something usable.
8754 We could do this while processing each DIE, and feels kinda cleaner,
8755 but that way is more invasive.
8756 This is to, for example, allow the user to type "p var" or "b main"
8757 without having to specify the package name, and allow lookups
8758 of module.object to work in contexts that use the expression
8762 fixup_go_packaging (struct dwarf2_cu
*cu
)
8764 gdb::unique_xmalloc_ptr
<char> package_name
;
8765 struct pending
*list
;
8768 for (list
= *cu
->get_builder ()->get_global_symbols ();
8772 for (i
= 0; i
< list
->nsyms
; ++i
)
8774 struct symbol
*sym
= list
->symbol
[i
];
8776 if (sym
->language () == language_go
8777 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
8779 gdb::unique_xmalloc_ptr
<char> this_package_name
8780 (go_symbol_package_name (sym
));
8782 if (this_package_name
== NULL
)
8784 if (package_name
== NULL
)
8785 package_name
= std::move (this_package_name
);
8788 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
8789 if (strcmp (package_name
.get (), this_package_name
.get ()) != 0)
8790 complaint (_("Symtab %s has objects from two different Go packages: %s and %s"),
8791 (symbol_symtab (sym
) != NULL
8792 ? symtab_to_filename_for_display
8793 (symbol_symtab (sym
))
8794 : objfile_name (objfile
)),
8795 this_package_name
.get (), package_name
.get ());
8801 if (package_name
!= NULL
)
8803 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
8804 const char *saved_package_name
= objfile
->intern (package_name
.get ());
8805 struct type
*type
= init_type (objfile
, TYPE_CODE_MODULE
, 0,
8806 saved_package_name
);
8809 sym
= new (&objfile
->objfile_obstack
) symbol
;
8810 sym
->set_language (language_go
, &objfile
->objfile_obstack
);
8811 sym
->compute_and_set_names (saved_package_name
, false, objfile
->per_bfd
);
8812 /* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
8813 e.g., "main" finds the "main" module and not C's main(). */
8814 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
8815 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
8816 SYMBOL_TYPE (sym
) = type
;
8818 add_symbol_to_list (sym
, cu
->get_builder ()->get_global_symbols ());
8822 /* Allocate a fully-qualified name consisting of the two parts on the
8826 rust_fully_qualify (struct obstack
*obstack
, const char *p1
, const char *p2
)
8828 return obconcat (obstack
, p1
, "::", p2
, (char *) NULL
);
8831 /* A helper that allocates a variant part to attach to a Rust enum
8832 type. OBSTACK is where the results should be allocated. TYPE is
8833 the type we're processing. DISCRIMINANT_INDEX is the index of the
8834 discriminant. It must be the index of one of the fields of TYPE,
8835 or -1 to mean there is no discriminant (univariant enum).
8836 DEFAULT_INDEX is the index of the default field; or -1 if there is
8837 no default. RANGES is indexed by "effective" field number (the
8838 field index, but omitting the discriminant and default fields) and
8839 must hold the discriminant values used by the variants. Note that
8840 RANGES must have a lifetime at least as long as OBSTACK -- either
8841 already allocated on it, or static. */
8844 alloc_rust_variant (struct obstack
*obstack
, struct type
*type
,
8845 int discriminant_index
, int default_index
,
8846 gdb::array_view
<discriminant_range
> ranges
)
8848 /* When DISCRIMINANT_INDEX == -1, we have a univariant enum. */
8849 gdb_assert (discriminant_index
== -1
8850 || (discriminant_index
>= 0
8851 && discriminant_index
< type
->num_fields ()));
8852 gdb_assert (default_index
== -1
8853 || (default_index
>= 0 && default_index
< type
->num_fields ()));
8855 /* We have one variant for each non-discriminant field. */
8856 int n_variants
= type
->num_fields ();
8857 if (discriminant_index
!= -1)
8860 variant
*variants
= new (obstack
) variant
[n_variants
];
8863 for (int i
= 0; i
< type
->num_fields (); ++i
)
8865 if (i
== discriminant_index
)
8868 variants
[var_idx
].first_field
= i
;
8869 variants
[var_idx
].last_field
= i
+ 1;
8871 /* The default field does not need a range, but other fields do.
8872 We skipped the discriminant above. */
8873 if (i
!= default_index
)
8875 variants
[var_idx
].discriminants
= ranges
.slice (range_idx
, 1);
8882 gdb_assert (range_idx
== ranges
.size ());
8883 gdb_assert (var_idx
== n_variants
);
8885 variant_part
*part
= new (obstack
) variant_part
;
8886 part
->discriminant_index
= discriminant_index
;
8887 /* If there is no discriminant, then whether it is signed is of no
8890 = (discriminant_index
== -1
8892 : type
->field (discriminant_index
).type ()->is_unsigned ());
8893 part
->variants
= gdb::array_view
<variant
> (variants
, n_variants
);
8895 void *storage
= obstack_alloc (obstack
, sizeof (gdb::array_view
<variant_part
>));
8896 gdb::array_view
<variant_part
> *prop_value
8897 = new (storage
) gdb::array_view
<variant_part
> (part
, 1);
8899 struct dynamic_prop prop
;
8900 prop
.set_variant_parts (prop_value
);
8902 type
->add_dyn_prop (DYN_PROP_VARIANT_PARTS
, prop
);
8905 /* Some versions of rustc emitted enums in an unusual way.
8907 Ordinary enums were emitted as unions. The first element of each
8908 structure in the union was named "RUST$ENUM$DISR". This element
8909 held the discriminant.
8911 These versions of Rust also implemented the "non-zero"
8912 optimization. When the enum had two values, and one is empty and
8913 the other holds a pointer that cannot be zero, the pointer is used
8914 as the discriminant, with a zero value meaning the empty variant.
8915 Here, the union's first member is of the form
8916 RUST$ENCODED$ENUM$<fieldno>$<fieldno>$...$<variantname>
8917 where the fieldnos are the indices of the fields that should be
8918 traversed in order to find the field (which may be several fields deep)
8919 and the variantname is the name of the variant of the case when the
8922 This function recognizes whether TYPE is of one of these forms,
8923 and, if so, smashes it to be a variant type. */
8926 quirk_rust_enum (struct type
*type
, struct objfile
*objfile
)
8928 gdb_assert (type
->code () == TYPE_CODE_UNION
);
8930 /* We don't need to deal with empty enums. */
8931 if (type
->num_fields () == 0)
8934 #define RUST_ENUM_PREFIX "RUST$ENCODED$ENUM$"
8935 if (type
->num_fields () == 1
8936 && startswith (TYPE_FIELD_NAME (type
, 0), RUST_ENUM_PREFIX
))
8938 const char *name
= TYPE_FIELD_NAME (type
, 0) + strlen (RUST_ENUM_PREFIX
);
8940 /* Decode the field name to find the offset of the
8942 ULONGEST bit_offset
= 0;
8943 struct type
*field_type
= type
->field (0).type ();
8944 while (name
[0] >= '0' && name
[0] <= '9')
8947 unsigned long index
= strtoul (name
, &tail
, 10);
8950 || index
>= field_type
->num_fields ()
8951 || (TYPE_FIELD_LOC_KIND (field_type
, index
)
8952 != FIELD_LOC_KIND_BITPOS
))
8954 complaint (_("Could not parse Rust enum encoding string \"%s\""
8956 TYPE_FIELD_NAME (type
, 0),
8957 objfile_name (objfile
));
8962 bit_offset
+= TYPE_FIELD_BITPOS (field_type
, index
);
8963 field_type
= field_type
->field (index
).type ();
8966 /* Smash this type to be a structure type. We have to do this
8967 because the type has already been recorded. */
8968 type
->set_code (TYPE_CODE_STRUCT
);
8969 type
->set_num_fields (3);
8970 /* Save the field we care about. */
8971 struct field saved_field
= type
->field (0);
8973 ((struct field
*) TYPE_ZALLOC (type
, 3 * sizeof (struct field
)));
8975 /* Put the discriminant at index 0. */
8976 type
->field (0).set_type (field_type
);
8977 TYPE_FIELD_ARTIFICIAL (type
, 0) = 1;
8978 TYPE_FIELD_NAME (type
, 0) = "<<discriminant>>";
8979 SET_FIELD_BITPOS (type
->field (0), bit_offset
);
8981 /* The order of fields doesn't really matter, so put the real
8982 field at index 1 and the data-less field at index 2. */
8983 type
->field (1) = saved_field
;
8984 TYPE_FIELD_NAME (type
, 1)
8985 = rust_last_path_segment (type
->field (1).type ()->name ());
8986 type
->field (1).type ()->set_name
8987 (rust_fully_qualify (&objfile
->objfile_obstack
, type
->name (),
8988 TYPE_FIELD_NAME (type
, 1)));
8990 const char *dataless_name
8991 = rust_fully_qualify (&objfile
->objfile_obstack
, type
->name (),
8993 struct type
*dataless_type
= init_type (objfile
, TYPE_CODE_VOID
, 0,
8995 type
->field (2).set_type (dataless_type
);
8996 /* NAME points into the original discriminant name, which
8997 already has the correct lifetime. */
8998 TYPE_FIELD_NAME (type
, 2) = name
;
8999 SET_FIELD_BITPOS (type
->field (2), 0);
9001 /* Indicate that this is a variant type. */
9002 static discriminant_range ranges
[1] = { { 0, 0 } };
9003 alloc_rust_variant (&objfile
->objfile_obstack
, type
, 0, 1, ranges
);
9005 /* A union with a single anonymous field is probably an old-style
9007 else if (type
->num_fields () == 1 && streq (TYPE_FIELD_NAME (type
, 0), ""))
9009 /* Smash this type to be a structure type. We have to do this
9010 because the type has already been recorded. */
9011 type
->set_code (TYPE_CODE_STRUCT
);
9013 struct type
*field_type
= type
->field (0).type ();
9014 const char *variant_name
9015 = rust_last_path_segment (field_type
->name ());
9016 TYPE_FIELD_NAME (type
, 0) = variant_name
;
9017 field_type
->set_name
9018 (rust_fully_qualify (&objfile
->objfile_obstack
,
9019 type
->name (), variant_name
));
9021 alloc_rust_variant (&objfile
->objfile_obstack
, type
, -1, 0, {});
9025 struct type
*disr_type
= nullptr;
9026 for (int i
= 0; i
< type
->num_fields (); ++i
)
9028 disr_type
= type
->field (i
).type ();
9030 if (disr_type
->code () != TYPE_CODE_STRUCT
)
9032 /* All fields of a true enum will be structs. */
9035 else if (disr_type
->num_fields () == 0)
9037 /* Could be data-less variant, so keep going. */
9038 disr_type
= nullptr;
9040 else if (strcmp (TYPE_FIELD_NAME (disr_type
, 0),
9041 "RUST$ENUM$DISR") != 0)
9043 /* Not a Rust enum. */
9053 /* If we got here without a discriminant, then it's probably
9055 if (disr_type
== nullptr)
9058 /* Smash this type to be a structure type. We have to do this
9059 because the type has already been recorded. */
9060 type
->set_code (TYPE_CODE_STRUCT
);
9062 /* Make space for the discriminant field. */
9063 struct field
*disr_field
= &disr_type
->field (0);
9065 = (struct field
*) TYPE_ZALLOC (type
, ((type
->num_fields () + 1)
9066 * sizeof (struct field
)));
9067 memcpy (new_fields
+ 1, type
->fields (),
9068 type
->num_fields () * sizeof (struct field
));
9069 type
->set_fields (new_fields
);
9070 type
->set_num_fields (type
->num_fields () + 1);
9072 /* Install the discriminant at index 0 in the union. */
9073 type
->field (0) = *disr_field
;
9074 TYPE_FIELD_ARTIFICIAL (type
, 0) = 1;
9075 TYPE_FIELD_NAME (type
, 0) = "<<discriminant>>";
9077 /* We need a way to find the correct discriminant given a
9078 variant name. For convenience we build a map here. */
9079 struct type
*enum_type
= disr_field
->type ();
9080 std::unordered_map
<std::string
, ULONGEST
> discriminant_map
;
9081 for (int i
= 0; i
< enum_type
->num_fields (); ++i
)
9083 if (TYPE_FIELD_LOC_KIND (enum_type
, i
) == FIELD_LOC_KIND_ENUMVAL
)
9086 = rust_last_path_segment (TYPE_FIELD_NAME (enum_type
, i
));
9087 discriminant_map
[name
] = TYPE_FIELD_ENUMVAL (enum_type
, i
);
9091 int n_fields
= type
->num_fields ();
9092 /* We don't need a range entry for the discriminant, but we do
9093 need one for every other field, as there is no default
9095 discriminant_range
*ranges
= XOBNEWVEC (&objfile
->objfile_obstack
,
9098 /* Skip the discriminant here. */
9099 for (int i
= 1; i
< n_fields
; ++i
)
9101 /* Find the final word in the name of this variant's type.
9102 That name can be used to look up the correct
9104 const char *variant_name
9105 = rust_last_path_segment (type
->field (i
).type ()->name ());
9107 auto iter
= discriminant_map
.find (variant_name
);
9108 if (iter
!= discriminant_map
.end ())
9110 ranges
[i
- 1].low
= iter
->second
;
9111 ranges
[i
- 1].high
= iter
->second
;
9114 /* In Rust, each element should have the size of the
9116 TYPE_LENGTH (type
->field (i
).type ()) = TYPE_LENGTH (type
);
9118 /* Remove the discriminant field, if it exists. */
9119 struct type
*sub_type
= type
->field (i
).type ();
9120 if (sub_type
->num_fields () > 0)
9122 sub_type
->set_num_fields (sub_type
->num_fields () - 1);
9123 sub_type
->set_fields (sub_type
->fields () + 1);
9125 TYPE_FIELD_NAME (type
, i
) = variant_name
;
9127 (rust_fully_qualify (&objfile
->objfile_obstack
,
9128 type
->name (), variant_name
));
9131 /* Indicate that this is a variant type. */
9132 alloc_rust_variant (&objfile
->objfile_obstack
, type
, 0, -1,
9133 gdb::array_view
<discriminant_range
> (ranges
,
9138 /* Rewrite some Rust unions to be structures with variants parts. */
9141 rust_union_quirks (struct dwarf2_cu
*cu
)
9143 gdb_assert (cu
->per_cu
->lang
== language_rust
);
9144 for (type
*type_
: cu
->rust_unions
)
9145 quirk_rust_enum (type_
, cu
->per_objfile
->objfile
);
9146 /* We don't need this any more. */
9147 cu
->rust_unions
.clear ();
9152 type_unit_group_unshareable
*
9153 dwarf2_per_objfile::get_type_unit_group_unshareable (type_unit_group
*tu_group
)
9155 auto iter
= this->m_type_units
.find (tu_group
);
9156 if (iter
!= this->m_type_units
.end ())
9157 return iter
->second
.get ();
9159 type_unit_group_unshareable_up
uniq (new type_unit_group_unshareable
);
9160 type_unit_group_unshareable
*result
= uniq
.get ();
9161 this->m_type_units
[tu_group
] = std::move (uniq
);
9166 dwarf2_per_objfile::get_type_for_signatured_type
9167 (signatured_type
*sig_type
) const
9169 auto iter
= this->m_type_map
.find (sig_type
);
9170 if (iter
== this->m_type_map
.end ())
9173 return iter
->second
;
9176 void dwarf2_per_objfile::set_type_for_signatured_type
9177 (signatured_type
*sig_type
, struct type
*type
)
9179 gdb_assert (this->m_type_map
.find (sig_type
) == this->m_type_map
.end ());
9181 this->m_type_map
[sig_type
] = type
;
9184 /* A helper function for computing the list of all symbol tables
9185 included by PER_CU. */
9188 recursively_compute_inclusions (std::vector
<compunit_symtab
*> *result
,
9189 htab_t all_children
, htab_t all_type_symtabs
,
9190 dwarf2_per_cu_data
*per_cu
,
9191 dwarf2_per_objfile
*per_objfile
,
9192 struct compunit_symtab
*immediate_parent
)
9194 void **slot
= htab_find_slot (all_children
, per_cu
, INSERT
);
9197 /* This inclusion and its children have been processed. */
9203 /* Only add a CU if it has a symbol table. */
9204 compunit_symtab
*cust
= per_objfile
->get_symtab (per_cu
);
9207 /* If this is a type unit only add its symbol table if we haven't
9208 seen it yet (type unit per_cu's can share symtabs). */
9209 if (per_cu
->is_debug_types
)
9211 slot
= htab_find_slot (all_type_symtabs
, cust
, INSERT
);
9215 result
->push_back (cust
);
9216 if (cust
->user
== NULL
)
9217 cust
->user
= immediate_parent
;
9222 result
->push_back (cust
);
9223 if (cust
->user
== NULL
)
9224 cust
->user
= immediate_parent
;
9228 if (!per_cu
->imported_symtabs_empty ())
9229 for (dwarf2_per_cu_data
*ptr
: *per_cu
->imported_symtabs
)
9231 recursively_compute_inclusions (result
, all_children
,
9232 all_type_symtabs
, ptr
, per_objfile
,
9237 /* Compute the compunit_symtab 'includes' fields for the compunit_symtab of
9241 compute_compunit_symtab_includes (dwarf2_per_cu_data
*per_cu
,
9242 dwarf2_per_objfile
*per_objfile
)
9244 gdb_assert (! per_cu
->is_debug_types
);
9246 if (!per_cu
->imported_symtabs_empty ())
9249 std::vector
<compunit_symtab
*> result_symtabs
;
9250 compunit_symtab
*cust
= per_objfile
->get_symtab (per_cu
);
9252 /* If we don't have a symtab, we can just skip this case. */
9256 htab_up
all_children (htab_create_alloc (1, htab_hash_pointer
,
9258 NULL
, xcalloc
, xfree
));
9259 htab_up
all_type_symtabs (htab_create_alloc (1, htab_hash_pointer
,
9261 NULL
, xcalloc
, xfree
));
9263 for (dwarf2_per_cu_data
*ptr
: *per_cu
->imported_symtabs
)
9265 recursively_compute_inclusions (&result_symtabs
, all_children
.get (),
9266 all_type_symtabs
.get (), ptr
,
9270 /* Now we have a transitive closure of all the included symtabs. */
9271 len
= result_symtabs
.size ();
9273 = XOBNEWVEC (&per_objfile
->objfile
->objfile_obstack
,
9274 struct compunit_symtab
*, len
+ 1);
9275 memcpy (cust
->includes
, result_symtabs
.data (),
9276 len
* sizeof (compunit_symtab
*));
9277 cust
->includes
[len
] = NULL
;
9281 /* Compute the 'includes' field for the symtabs of all the CUs we just
9285 process_cu_includes (dwarf2_per_objfile
*per_objfile
)
9287 for (dwarf2_per_cu_data
*iter
: per_objfile
->per_bfd
->just_read_cus
)
9289 if (! iter
->is_debug_types
)
9290 compute_compunit_symtab_includes (iter
, per_objfile
);
9293 per_objfile
->per_bfd
->just_read_cus
.clear ();
9296 /* Generate full symbol information for CU, whose DIEs have
9297 already been loaded into memory. */
9300 process_full_comp_unit (dwarf2_cu
*cu
, enum language pretend_language
)
9302 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
9303 struct objfile
*objfile
= per_objfile
->objfile
;
9304 struct gdbarch
*gdbarch
= objfile
->arch ();
9305 CORE_ADDR lowpc
, highpc
;
9306 struct compunit_symtab
*cust
;
9308 struct block
*static_block
;
9311 baseaddr
= objfile
->text_section_offset ();
9313 /* Clear the list here in case something was left over. */
9314 cu
->method_list
.clear ();
9316 dwarf2_find_base_address (cu
->dies
, cu
);
9318 /* Before we start reading the top-level DIE, ensure it has a valid tag
9320 switch (cu
->dies
->tag
)
9322 case DW_TAG_compile_unit
:
9323 case DW_TAG_partial_unit
:
9324 case DW_TAG_type_unit
:
9327 error (_("Dwarf Error: unexpected tag '%s' at offset %s [in module %s]"),
9328 dwarf_tag_name (cu
->dies
->tag
),
9329 sect_offset_str (cu
->per_cu
->sect_off
),
9330 objfile_name (per_objfile
->objfile
));
9333 /* Do line number decoding in read_file_scope () */
9334 process_die (cu
->dies
, cu
);
9336 /* For now fudge the Go package. */
9337 if (cu
->per_cu
->lang
== language_go
)
9338 fixup_go_packaging (cu
);
9340 /* Now that we have processed all the DIEs in the CU, all the types
9341 should be complete, and it should now be safe to compute all of the
9343 compute_delayed_physnames (cu
);
9345 if (cu
->per_cu
->lang
== language_rust
)
9346 rust_union_quirks (cu
);
9348 /* Some compilers don't define a DW_AT_high_pc attribute for the
9349 compilation unit. If the DW_AT_high_pc is missing, synthesize
9350 it, by scanning the DIE's below the compilation unit. */
9351 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
9353 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
9354 static_block
= cu
->get_builder ()->end_symtab_get_static_block (addr
, 0, 1);
9356 /* If the comp unit has DW_AT_ranges, it may have discontiguous ranges.
9357 Also, DW_AT_ranges may record ranges not belonging to any child DIEs
9358 (such as virtual method tables). Record the ranges in STATIC_BLOCK's
9359 addrmap to help ensure it has an accurate map of pc values belonging to
9361 dwarf2_record_block_ranges (cu
->dies
, static_block
, baseaddr
, cu
);
9363 cust
= cu
->get_builder ()->end_symtab_from_static_block (static_block
,
9364 SECT_OFF_TEXT (objfile
),
9369 int gcc_4_minor
= producer_is_gcc_ge_4 (cu
->producer
);
9371 /* Set symtab language to language from DW_AT_language. If the
9372 compilation is from a C file generated by language preprocessors, do
9373 not set the language if it was already deduced by start_subfile. */
9374 if (!(cu
->per_cu
->lang
== language_c
9375 && COMPUNIT_FILETABS (cust
)->language
!= language_unknown
))
9376 COMPUNIT_FILETABS (cust
)->language
= cu
->per_cu
->lang
;
9378 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
9379 produce DW_AT_location with location lists but it can be possibly
9380 invalid without -fvar-tracking. Still up to GCC-4.4.x incl. 4.4.0
9381 there were bugs in prologue debug info, fixed later in GCC-4.5
9382 by "unwind info for epilogues" patch (which is not directly related).
9384 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
9385 needed, it would be wrong due to missing DW_AT_producer there.
9387 Still one can confuse GDB by using non-standard GCC compilation
9388 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
9390 if (cu
->has_loclist
&& gcc_4_minor
>= 5)
9391 cust
->locations_valid
= 1;
9393 if (gcc_4_minor
>= 5)
9394 cust
->epilogue_unwind_valid
= 1;
9396 cust
->call_site_htab
= cu
->call_site_htab
;
9399 per_objfile
->set_symtab (cu
->per_cu
, cust
);
9401 /* Push it for inclusion processing later. */
9402 per_objfile
->per_bfd
->just_read_cus
.push_back (cu
->per_cu
);
9404 /* Not needed any more. */
9405 cu
->reset_builder ();
9408 /* Generate full symbol information for type unit CU, whose DIEs have
9409 already been loaded into memory. */
9412 process_full_type_unit (dwarf2_cu
*cu
,
9413 enum language pretend_language
)
9415 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
9416 struct objfile
*objfile
= per_objfile
->objfile
;
9417 struct compunit_symtab
*cust
;
9418 struct signatured_type
*sig_type
;
9420 gdb_assert (cu
->per_cu
->is_debug_types
);
9421 sig_type
= (struct signatured_type
*) cu
->per_cu
;
9423 /* Clear the list here in case something was left over. */
9424 cu
->method_list
.clear ();
9426 /* The symbol tables are set up in read_type_unit_scope. */
9427 process_die (cu
->dies
, cu
);
9429 /* For now fudge the Go package. */
9430 if (cu
->per_cu
->lang
== language_go
)
9431 fixup_go_packaging (cu
);
9433 /* Now that we have processed all the DIEs in the CU, all the types
9434 should be complete, and it should now be safe to compute all of the
9436 compute_delayed_physnames (cu
);
9438 if (cu
->per_cu
->lang
== language_rust
)
9439 rust_union_quirks (cu
);
9441 /* TUs share symbol tables.
9442 If this is the first TU to use this symtab, complete the construction
9443 of it with end_expandable_symtab. Otherwise, complete the addition of
9444 this TU's symbols to the existing symtab. */
9445 type_unit_group_unshareable
*tug_unshare
=
9446 per_objfile
->get_type_unit_group_unshareable (sig_type
->type_unit_group
);
9447 if (tug_unshare
->compunit_symtab
== NULL
)
9449 buildsym_compunit
*builder
= cu
->get_builder ();
9450 cust
= builder
->end_expandable_symtab (0, SECT_OFF_TEXT (objfile
));
9451 tug_unshare
->compunit_symtab
= cust
;
9455 /* Set symtab language to language from DW_AT_language. If the
9456 compilation is from a C file generated by language preprocessors,
9457 do not set the language if it was already deduced by
9459 if (!(cu
->per_cu
->lang
== language_c
9460 && COMPUNIT_FILETABS (cust
)->language
!= language_c
))
9461 COMPUNIT_FILETABS (cust
)->language
= cu
->per_cu
->lang
;
9466 cu
->get_builder ()->augment_type_symtab ();
9467 cust
= tug_unshare
->compunit_symtab
;
9470 per_objfile
->set_symtab (cu
->per_cu
, cust
);
9472 /* Not needed any more. */
9473 cu
->reset_builder ();
9476 /* Process an imported unit DIE. */
9479 process_imported_unit_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
9481 struct attribute
*attr
;
9483 /* For now we don't handle imported units in type units. */
9484 if (cu
->per_cu
->is_debug_types
)
9486 error (_("Dwarf Error: DW_TAG_imported_unit is not"
9487 " supported in type units [in module %s]"),
9488 objfile_name (cu
->per_objfile
->objfile
));
9491 attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
9494 sect_offset sect_off
= attr
->get_ref_die_offset ();
9495 bool is_dwz
= (attr
->form
== DW_FORM_GNU_ref_alt
|| cu
->per_cu
->is_dwz
);
9496 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
9497 dwarf2_per_cu_data
*per_cu
9498 = dwarf2_find_containing_comp_unit (sect_off
, is_dwz
, per_objfile
);
9500 /* We're importing a C++ compilation unit with tag DW_TAG_compile_unit
9501 into another compilation unit, at root level. Regard this as a hint,
9503 if (die
->parent
&& die
->parent
->parent
== NULL
9504 && per_cu
->unit_type
== DW_UT_compile
9505 && per_cu
->lang
== language_cplus
)
9508 /* If necessary, add it to the queue and load its DIEs. */
9509 if (maybe_queue_comp_unit (cu
, per_cu
, per_objfile
,
9511 load_full_comp_unit (per_cu
, per_objfile
, per_objfile
->get_cu (per_cu
),
9512 false, cu
->per_cu
->lang
);
9514 cu
->per_cu
->imported_symtabs_push (per_cu
);
9518 /* RAII object that represents a process_die scope: i.e.,
9519 starts/finishes processing a DIE. */
9520 class process_die_scope
9523 process_die_scope (die_info
*die
, dwarf2_cu
*cu
)
9524 : m_die (die
), m_cu (cu
)
9526 /* We should only be processing DIEs not already in process. */
9527 gdb_assert (!m_die
->in_process
);
9528 m_die
->in_process
= true;
9531 ~process_die_scope ()
9533 m_die
->in_process
= false;
9535 /* If we're done processing the DIE for the CU that owns the line
9536 header, we don't need the line header anymore. */
9537 if (m_cu
->line_header_die_owner
== m_die
)
9539 delete m_cu
->line_header
;
9540 m_cu
->line_header
= NULL
;
9541 m_cu
->line_header_die_owner
= NULL
;
9550 /* Process a die and its children. */
9553 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
9555 process_die_scope
scope (die
, cu
);
9559 case DW_TAG_padding
:
9561 case DW_TAG_compile_unit
:
9562 case DW_TAG_partial_unit
:
9563 read_file_scope (die
, cu
);
9565 case DW_TAG_type_unit
:
9566 read_type_unit_scope (die
, cu
);
9568 case DW_TAG_subprogram
:
9569 /* Nested subprograms in Fortran get a prefix. */
9570 if (cu
->per_cu
->lang
== language_fortran
9571 && die
->parent
!= NULL
9572 && die
->parent
->tag
== DW_TAG_subprogram
)
9573 cu
->processing_has_namespace_info
= true;
9575 case DW_TAG_inlined_subroutine
:
9576 read_func_scope (die
, cu
);
9578 case DW_TAG_lexical_block
:
9579 case DW_TAG_try_block
:
9580 case DW_TAG_catch_block
:
9581 read_lexical_block_scope (die
, cu
);
9583 case DW_TAG_call_site
:
9584 case DW_TAG_GNU_call_site
:
9585 read_call_site_scope (die
, cu
);
9587 case DW_TAG_class_type
:
9588 case DW_TAG_interface_type
:
9589 case DW_TAG_structure_type
:
9590 case DW_TAG_union_type
:
9591 process_structure_scope (die
, cu
);
9593 case DW_TAG_enumeration_type
:
9594 process_enumeration_scope (die
, cu
);
9597 /* These dies have a type, but processing them does not create
9598 a symbol or recurse to process the children. Therefore we can
9599 read them on-demand through read_type_die. */
9600 case DW_TAG_subroutine_type
:
9601 case DW_TAG_set_type
:
9602 case DW_TAG_pointer_type
:
9603 case DW_TAG_ptr_to_member_type
:
9604 case DW_TAG_reference_type
:
9605 case DW_TAG_rvalue_reference_type
:
9606 case DW_TAG_string_type
:
9609 case DW_TAG_array_type
:
9610 /* We only need to handle this case for Ada -- in other
9611 languages, it's normal for the compiler to emit a typedef
9613 if (cu
->per_cu
->lang
!= language_ada
)
9616 case DW_TAG_base_type
:
9617 case DW_TAG_subrange_type
:
9618 case DW_TAG_typedef
:
9619 /* Add a typedef symbol for the type definition, if it has a
9621 new_symbol (die
, read_type_die (die
, cu
), cu
);
9623 case DW_TAG_common_block
:
9624 read_common_block (die
, cu
);
9626 case DW_TAG_common_inclusion
:
9628 case DW_TAG_namespace
:
9629 cu
->processing_has_namespace_info
= true;
9630 read_namespace (die
, cu
);
9633 cu
->processing_has_namespace_info
= true;
9634 read_module (die
, cu
);
9636 case DW_TAG_imported_declaration
:
9637 cu
->processing_has_namespace_info
= true;
9638 if (read_namespace_alias (die
, cu
))
9640 /* The declaration is not a global namespace alias. */
9642 case DW_TAG_imported_module
:
9643 cu
->processing_has_namespace_info
= true;
9644 if (die
->child
!= NULL
&& (die
->tag
== DW_TAG_imported_declaration
9645 || cu
->per_cu
->lang
!= language_fortran
))
9646 complaint (_("Tag '%s' has unexpected children"),
9647 dwarf_tag_name (die
->tag
));
9648 read_import_statement (die
, cu
);
9651 case DW_TAG_imported_unit
:
9652 process_imported_unit_die (die
, cu
);
9655 case DW_TAG_variable
:
9656 read_variable (die
, cu
);
9660 new_symbol (die
, NULL
, cu
);
9665 /* DWARF name computation. */
9667 /* A helper function for dwarf2_compute_name which determines whether DIE
9668 needs to have the name of the scope prepended to the name listed in the
9672 die_needs_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
9674 struct attribute
*attr
;
9678 case DW_TAG_namespace
:
9679 case DW_TAG_typedef
:
9680 case DW_TAG_class_type
:
9681 case DW_TAG_interface_type
:
9682 case DW_TAG_structure_type
:
9683 case DW_TAG_union_type
:
9684 case DW_TAG_enumeration_type
:
9685 case DW_TAG_enumerator
:
9686 case DW_TAG_subprogram
:
9687 case DW_TAG_inlined_subroutine
:
9689 case DW_TAG_imported_declaration
:
9692 case DW_TAG_variable
:
9693 case DW_TAG_constant
:
9694 /* We only need to prefix "globally" visible variables. These include
9695 any variable marked with DW_AT_external or any variable that
9696 lives in a namespace. [Variables in anonymous namespaces
9697 require prefixing, but they are not DW_AT_external.] */
9699 if (dwarf2_attr (die
, DW_AT_specification
, cu
))
9701 struct dwarf2_cu
*spec_cu
= cu
;
9703 return die_needs_namespace (die_specification (die
, &spec_cu
),
9707 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
9708 if (attr
== NULL
&& die
->parent
->tag
!= DW_TAG_namespace
9709 && die
->parent
->tag
!= DW_TAG_module
)
9711 /* A variable in a lexical block of some kind does not need a
9712 namespace, even though in C++ such variables may be external
9713 and have a mangled name. */
9714 if (die
->parent
->tag
== DW_TAG_lexical_block
9715 || die
->parent
->tag
== DW_TAG_try_block
9716 || die
->parent
->tag
== DW_TAG_catch_block
9717 || die
->parent
->tag
== DW_TAG_subprogram
)
9726 /* Return the DIE's linkage name attribute, either DW_AT_linkage_name
9727 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
9728 defined for the given DIE. */
9730 static struct attribute
*
9731 dw2_linkage_name_attr (struct die_info
*die
, struct dwarf2_cu
*cu
)
9733 struct attribute
*attr
;
9735 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
9737 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
9742 /* Return the DIE's linkage name as a string, either DW_AT_linkage_name
9743 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
9744 defined for the given DIE. */
9747 dw2_linkage_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
9749 const char *linkage_name
;
9751 linkage_name
= dwarf2_string_attr (die
, DW_AT_linkage_name
, cu
);
9752 if (linkage_name
== NULL
)
9753 linkage_name
= dwarf2_string_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
9755 /* rustc emits invalid values for DW_AT_linkage_name. Ignore these.
9756 See https://github.com/rust-lang/rust/issues/32925. */
9757 if (cu
->per_cu
->lang
== language_rust
&& linkage_name
!= NULL
9758 && strchr (linkage_name
, '{') != NULL
)
9759 linkage_name
= NULL
;
9761 return linkage_name
;
9764 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
9765 compute the physname for the object, which include a method's:
9766 - formal parameters (C++),
9767 - receiver type (Go),
9769 The term "physname" is a bit confusing.
9770 For C++, for example, it is the demangled name.
9771 For Go, for example, it's the mangled name.
9773 For Ada, return the DIE's linkage name rather than the fully qualified
9774 name. PHYSNAME is ignored..
9776 The result is allocated on the objfile->per_bfd's obstack and
9780 dwarf2_compute_name (const char *name
,
9781 struct die_info
*die
, struct dwarf2_cu
*cu
,
9784 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
9787 name
= dwarf2_name (die
, cu
);
9789 enum language lang
= cu
->per_cu
->lang
;
9791 /* For Fortran GDB prefers DW_AT_*linkage_name for the physname if present
9792 but otherwise compute it by typename_concat inside GDB.
9793 FIXME: Actually this is not really true, or at least not always true.
9794 It's all very confusing. compute_and_set_names doesn't try to demangle
9795 Fortran names because there is no mangling standard. So new_symbol
9796 will set the demangled name to the result of dwarf2_full_name, and it is
9797 the demangled name that GDB uses if it exists. */
9798 if (lang
== language_ada
9799 || (lang
== language_fortran
&& physname
))
9801 /* For Ada unit, we prefer the linkage name over the name, as
9802 the former contains the exported name, which the user expects
9803 to be able to reference. Ideally, we want the user to be able
9804 to reference this entity using either natural or linkage name,
9805 but we haven't started looking at this enhancement yet. */
9806 const char *linkage_name
= dw2_linkage_name (die
, cu
);
9808 if (linkage_name
!= NULL
)
9809 return linkage_name
;
9812 /* These are the only languages we know how to qualify names in. */
9814 && (lang
== language_cplus
9815 || lang
== language_fortran
|| lang
== language_d
9816 || lang
== language_rust
))
9818 if (die_needs_namespace (die
, cu
))
9821 const char *canonical_name
= NULL
;
9825 prefix
= determine_prefix (die
, cu
);
9826 if (*prefix
!= '\0')
9828 gdb::unique_xmalloc_ptr
<char> prefixed_name
9829 (typename_concat (NULL
, prefix
, name
, physname
, cu
));
9831 buf
.puts (prefixed_name
.get ());
9836 /* Template parameters may be specified in the DIE's DW_AT_name, or
9837 as children with DW_TAG_template_type_param or
9838 DW_TAG_value_type_param. If the latter, add them to the name
9839 here. If the name already has template parameters, then
9840 skip this step; some versions of GCC emit both, and
9841 it is more efficient to use the pre-computed name.
9843 Something to keep in mind about this process: it is very
9844 unlikely, or in some cases downright impossible, to produce
9845 something that will match the mangled name of a function.
9846 If the definition of the function has the same debug info,
9847 we should be able to match up with it anyway. But fallbacks
9848 using the minimal symbol, for instance to find a method
9849 implemented in a stripped copy of libstdc++, will not work.
9850 If we do not have debug info for the definition, we will have to
9851 match them up some other way.
9853 When we do name matching there is a related problem with function
9854 templates; two instantiated function templates are allowed to
9855 differ only by their return types, which we do not add here. */
9857 if (lang
== language_cplus
&& strchr (name
, '<') == NULL
)
9859 struct attribute
*attr
;
9860 struct die_info
*child
;
9863 die
->building_fullname
= 1;
9865 for (child
= die
->child
; child
!= NULL
; child
= child
->sibling
)
9869 const gdb_byte
*bytes
;
9870 struct dwarf2_locexpr_baton
*baton
;
9873 if (child
->tag
!= DW_TAG_template_type_param
9874 && child
->tag
!= DW_TAG_template_value_param
)
9885 attr
= dwarf2_attr (child
, DW_AT_type
, cu
);
9888 complaint (_("template parameter missing DW_AT_type"));
9889 buf
.puts ("UNKNOWN_TYPE");
9892 type
= die_type (child
, cu
);
9894 if (child
->tag
== DW_TAG_template_type_param
)
9896 cu
->language_defn
->print_type (type
, "", &buf
, -1, 0,
9897 &type_print_raw_options
);
9901 attr
= dwarf2_attr (child
, DW_AT_const_value
, cu
);
9904 complaint (_("template parameter missing "
9905 "DW_AT_const_value"));
9906 buf
.puts ("UNKNOWN_VALUE");
9910 dwarf2_const_value_attr (attr
, type
, name
,
9911 &cu
->comp_unit_obstack
, cu
,
9912 &value
, &bytes
, &baton
);
9914 if (type
->has_no_signedness ())
9915 /* GDB prints characters as NUMBER 'CHAR'. If that's
9916 changed, this can use value_print instead. */
9917 cu
->language_defn
->printchar (value
, type
, &buf
);
9920 struct value_print_options opts
;
9923 v
= dwarf2_evaluate_loc_desc (type
, NULL
,
9927 baton
->per_objfile
);
9928 else if (bytes
!= NULL
)
9930 v
= allocate_value (type
);
9931 memcpy (value_contents_writeable (v
), bytes
,
9932 TYPE_LENGTH (type
));
9935 v
= value_from_longest (type
, value
);
9937 /* Specify decimal so that we do not depend on
9939 get_formatted_print_options (&opts
, 'd');
9941 value_print (v
, &buf
, &opts
);
9946 die
->building_fullname
= 0;
9950 /* Close the argument list, with a space if necessary
9951 (nested templates). */
9952 if (!buf
.empty () && buf
.string ().back () == '>')
9959 /* For C++ methods, append formal parameter type
9960 information, if PHYSNAME. */
9962 if (physname
&& die
->tag
== DW_TAG_subprogram
9963 && lang
== language_cplus
)
9965 struct type
*type
= read_type_die (die
, cu
);
9967 c_type_print_args (type
, &buf
, 1, lang
,
9968 &type_print_raw_options
);
9970 if (lang
== language_cplus
)
9972 /* Assume that an artificial first parameter is
9973 "this", but do not crash if it is not. RealView
9974 marks unnamed (and thus unused) parameters as
9975 artificial; there is no way to differentiate
9977 if (type
->num_fields () > 0
9978 && TYPE_FIELD_ARTIFICIAL (type
, 0)
9979 && type
->field (0).type ()->code () == TYPE_CODE_PTR
9980 && TYPE_CONST (TYPE_TARGET_TYPE (type
->field (0).type ())))
9981 buf
.puts (" const");
9985 const std::string
&intermediate_name
= buf
.string ();
9987 if (lang
== language_cplus
)
9989 = dwarf2_canonicalize_name (intermediate_name
.c_str (), cu
,
9992 /* If we only computed INTERMEDIATE_NAME, or if
9993 INTERMEDIATE_NAME is already canonical, then we need to
9995 if (canonical_name
== NULL
|| canonical_name
== intermediate_name
.c_str ())
9996 name
= objfile
->intern (intermediate_name
);
9998 name
= canonical_name
;
10005 /* Return the fully qualified name of DIE, based on its DW_AT_name.
10006 If scope qualifiers are appropriate they will be added. The result
10007 will be allocated on the storage_obstack, or NULL if the DIE does
10008 not have a name. NAME may either be from a previous call to
10009 dwarf2_name or NULL.
10011 The output string will be canonicalized (if C++). */
10013 static const char *
10014 dwarf2_full_name (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
10016 return dwarf2_compute_name (name
, die
, cu
, 0);
10019 /* Construct a physname for the given DIE in CU. NAME may either be
10020 from a previous call to dwarf2_name or NULL. The result will be
10021 allocated on the objfile_objstack or NULL if the DIE does not have a
10024 The output string will be canonicalized (if C++). */
10026 static const char *
10027 dwarf2_physname (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
10029 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
10030 const char *retval
, *mangled
= NULL
, *canon
= NULL
;
10033 /* In this case dwarf2_compute_name is just a shortcut not building anything
10035 if (!die_needs_namespace (die
, cu
))
10036 return dwarf2_compute_name (name
, die
, cu
, 1);
10038 if (cu
->per_cu
->lang
!= language_rust
)
10039 mangled
= dw2_linkage_name (die
, cu
);
10041 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
10043 gdb::unique_xmalloc_ptr
<char> demangled
;
10044 if (mangled
!= NULL
)
10046 if (cu
->language_defn
->store_sym_names_in_linkage_form_p ())
10048 /* Do nothing (do not demangle the symbol name). */
10052 /* Use DMGL_RET_DROP for C++ template functions to suppress
10053 their return type. It is easier for GDB users to search
10054 for such functions as `name(params)' than `long name(params)'.
10055 In such case the minimal symbol names do not match the full
10056 symbol names but for template functions there is never a need
10057 to look up their definition from their declaration so
10058 the only disadvantage remains the minimal symbol variant
10059 `long name(params)' does not have the proper inferior type. */
10060 demangled
.reset (gdb_demangle (mangled
,
10061 (DMGL_PARAMS
| DMGL_ANSI
10062 | DMGL_RET_DROP
)));
10065 canon
= demangled
.get ();
10073 if (canon
== NULL
|| check_physname
)
10075 const char *physname
= dwarf2_compute_name (name
, die
, cu
, 1);
10077 if (canon
!= NULL
&& strcmp (physname
, canon
) != 0)
10079 /* It may not mean a bug in GDB. The compiler could also
10080 compute DW_AT_linkage_name incorrectly. But in such case
10081 GDB would need to be bug-to-bug compatible. */
10083 complaint (_("Computed physname <%s> does not match demangled <%s> "
10084 "(from linkage <%s>) - DIE at %s [in module %s]"),
10085 physname
, canon
, mangled
, sect_offset_str (die
->sect_off
),
10086 objfile_name (objfile
));
10088 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
10089 is available here - over computed PHYSNAME. It is safer
10090 against both buggy GDB and buggy compilers. */
10104 retval
= objfile
->intern (retval
);
10109 /* Inspect DIE in CU for a namespace alias. If one exists, record
10110 a new symbol for it.
10112 Returns 1 if a namespace alias was recorded, 0 otherwise. */
10115 read_namespace_alias (struct die_info
*die
, struct dwarf2_cu
*cu
)
10117 struct attribute
*attr
;
10119 /* If the die does not have a name, this is not a namespace
10121 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
10125 struct die_info
*d
= die
;
10126 struct dwarf2_cu
*imported_cu
= cu
;
10128 /* If the compiler has nested DW_AT_imported_declaration DIEs,
10129 keep inspecting DIEs until we hit the underlying import. */
10130 #define MAX_NESTED_IMPORTED_DECLARATIONS 100
10131 for (num
= 0; num
< MAX_NESTED_IMPORTED_DECLARATIONS
; ++num
)
10133 attr
= dwarf2_attr (d
, DW_AT_import
, cu
);
10137 d
= follow_die_ref (d
, attr
, &imported_cu
);
10138 if (d
->tag
!= DW_TAG_imported_declaration
)
10142 if (num
== MAX_NESTED_IMPORTED_DECLARATIONS
)
10144 complaint (_("DIE at %s has too many recursively imported "
10145 "declarations"), sect_offset_str (d
->sect_off
));
10152 sect_offset sect_off
= attr
->get_ref_die_offset ();
10154 type
= get_die_type_at_offset (sect_off
, cu
->per_cu
, cu
->per_objfile
);
10155 if (type
!= NULL
&& type
->code () == TYPE_CODE_NAMESPACE
)
10157 /* This declaration is a global namespace alias. Add
10158 a symbol for it whose type is the aliased namespace. */
10159 new_symbol (die
, type
, cu
);
10168 /* Return the using directives repository (global or local?) to use in the
10169 current context for CU.
10171 For Ada, imported declarations can materialize renamings, which *may* be
10172 global. However it is impossible (for now?) in DWARF to distinguish
10173 "external" imported declarations and "static" ones. As all imported
10174 declarations seem to be static in all other languages, make them all CU-wide
10175 global only in Ada. */
10177 static struct using_direct
**
10178 using_directives (struct dwarf2_cu
*cu
)
10180 if (cu
->per_cu
->lang
== language_ada
10181 && cu
->get_builder ()->outermost_context_p ())
10182 return cu
->get_builder ()->get_global_using_directives ();
10184 return cu
->get_builder ()->get_local_using_directives ();
10187 /* Read the import statement specified by the given die and record it. */
10190 read_import_statement (struct die_info
*die
, struct dwarf2_cu
*cu
)
10192 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
10193 struct attribute
*import_attr
;
10194 struct die_info
*imported_die
, *child_die
;
10195 struct dwarf2_cu
*imported_cu
;
10196 const char *imported_name
;
10197 const char *imported_name_prefix
;
10198 const char *canonical_name
;
10199 const char *import_alias
;
10200 const char *imported_declaration
= NULL
;
10201 const char *import_prefix
;
10202 std::vector
<const char *> excludes
;
10204 import_attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
10205 if (import_attr
== NULL
)
10207 complaint (_("Tag '%s' has no DW_AT_import"),
10208 dwarf_tag_name (die
->tag
));
10213 imported_die
= follow_die_ref_or_sig (die
, import_attr
, &imported_cu
);
10214 imported_name
= dwarf2_name (imported_die
, imported_cu
);
10215 if (imported_name
== NULL
)
10217 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
10219 The import in the following code:
10233 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
10234 <52> DW_AT_decl_file : 1
10235 <53> DW_AT_decl_line : 6
10236 <54> DW_AT_import : <0x75>
10237 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
10238 <59> DW_AT_name : B
10239 <5b> DW_AT_decl_file : 1
10240 <5c> DW_AT_decl_line : 2
10241 <5d> DW_AT_type : <0x6e>
10243 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
10244 <76> DW_AT_byte_size : 4
10245 <77> DW_AT_encoding : 5 (signed)
10247 imports the wrong die ( 0x75 instead of 0x58 ).
10248 This case will be ignored until the gcc bug is fixed. */
10252 /* Figure out the local name after import. */
10253 import_alias
= dwarf2_name (die
, cu
);
10255 /* Figure out where the statement is being imported to. */
10256 import_prefix
= determine_prefix (die
, cu
);
10258 /* Figure out what the scope of the imported die is and prepend it
10259 to the name of the imported die. */
10260 imported_name_prefix
= determine_prefix (imported_die
, imported_cu
);
10262 if (imported_die
->tag
!= DW_TAG_namespace
10263 && imported_die
->tag
!= DW_TAG_module
)
10265 imported_declaration
= imported_name
;
10266 canonical_name
= imported_name_prefix
;
10268 else if (strlen (imported_name_prefix
) > 0)
10269 canonical_name
= obconcat (&objfile
->objfile_obstack
,
10270 imported_name_prefix
,
10271 (cu
->per_cu
->lang
== language_d
10274 imported_name
, (char *) NULL
);
10276 canonical_name
= imported_name
;
10278 if (die
->tag
== DW_TAG_imported_module
10279 && cu
->per_cu
->lang
== language_fortran
)
10280 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
10281 child_die
= child_die
->sibling
)
10283 /* DWARF-4: A Fortran use statement with a “rename list” may be
10284 represented by an imported module entry with an import attribute
10285 referring to the module and owned entries corresponding to those
10286 entities that are renamed as part of being imported. */
10288 if (child_die
->tag
!= DW_TAG_imported_declaration
)
10290 complaint (_("child DW_TAG_imported_declaration expected "
10291 "- DIE at %s [in module %s]"),
10292 sect_offset_str (child_die
->sect_off
),
10293 objfile_name (objfile
));
10297 import_attr
= dwarf2_attr (child_die
, DW_AT_import
, cu
);
10298 if (import_attr
== NULL
)
10300 complaint (_("Tag '%s' has no DW_AT_import"),
10301 dwarf_tag_name (child_die
->tag
));
10306 imported_die
= follow_die_ref_or_sig (child_die
, import_attr
,
10308 imported_name
= dwarf2_name (imported_die
, imported_cu
);
10309 if (imported_name
== NULL
)
10311 complaint (_("child DW_TAG_imported_declaration has unknown "
10312 "imported name - DIE at %s [in module %s]"),
10313 sect_offset_str (child_die
->sect_off
),
10314 objfile_name (objfile
));
10318 excludes
.push_back (imported_name
);
10320 process_die (child_die
, cu
);
10323 add_using_directive (using_directives (cu
),
10327 imported_declaration
,
10330 &objfile
->objfile_obstack
);
10333 /* ICC<14 does not output the required DW_AT_declaration on incomplete
10334 types, but gives them a size of zero. Starting with version 14,
10335 ICC is compatible with GCC. */
10338 producer_is_icc_lt_14 (struct dwarf2_cu
*cu
)
10340 if (!cu
->checked_producer
)
10341 check_producer (cu
);
10343 return cu
->producer_is_icc_lt_14
;
10346 /* ICC generates a DW_AT_type for C void functions. This was observed on
10347 ICC 14.0.5.212, and appears to be against the DWARF spec (V5 3.3.2)
10348 which says that void functions should not have a DW_AT_type. */
10351 producer_is_icc (struct dwarf2_cu
*cu
)
10353 if (!cu
->checked_producer
)
10354 check_producer (cu
);
10356 return cu
->producer_is_icc
;
10359 /* Check for possibly missing DW_AT_comp_dir with relative .debug_line
10360 directory paths. GCC SVN r127613 (new option -fdebug-prefix-map) fixed
10361 this, it was first present in GCC release 4.3.0. */
10364 producer_is_gcc_lt_4_3 (struct dwarf2_cu
*cu
)
10366 if (!cu
->checked_producer
)
10367 check_producer (cu
);
10369 return cu
->producer_is_gcc_lt_4_3
;
10372 static file_and_directory
10373 find_file_and_directory (struct die_info
*die
, struct dwarf2_cu
*cu
)
10375 file_and_directory res
;
10377 /* Find the filename. Do not use dwarf2_name here, since the filename
10378 is not a source language identifier. */
10379 res
.name
= dwarf2_string_attr (die
, DW_AT_name
, cu
);
10380 res
.comp_dir
= dwarf2_string_attr (die
, DW_AT_comp_dir
, cu
);
10382 if (res
.comp_dir
== NULL
10383 && producer_is_gcc_lt_4_3 (cu
) && res
.name
!= NULL
10384 && IS_ABSOLUTE_PATH (res
.name
))
10386 res
.comp_dir_storage
= ldirname (res
.name
);
10387 if (!res
.comp_dir_storage
.empty ())
10388 res
.comp_dir
= res
.comp_dir_storage
.c_str ();
10390 if (res
.comp_dir
!= NULL
)
10392 /* Irix 6.2 native cc prepends <machine>.: to the compilation
10393 directory, get rid of it. */
10394 const char *cp
= strchr (res
.comp_dir
, ':');
10396 if (cp
&& cp
!= res
.comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
10397 res
.comp_dir
= cp
+ 1;
10400 if (res
.name
== NULL
)
10401 res
.name
= "<unknown>";
10406 /* Handle DW_AT_stmt_list for a compilation unit.
10407 DIE is the DW_TAG_compile_unit die for CU.
10408 COMP_DIR is the compilation directory. LOWPC is passed to
10409 dwarf_decode_lines. See dwarf_decode_lines comments about it. */
10412 handle_DW_AT_stmt_list (struct die_info
*die
, struct dwarf2_cu
*cu
,
10413 const char *comp_dir
, CORE_ADDR lowpc
) /* ARI: editCase function */
10415 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
10416 struct attribute
*attr
;
10417 struct line_header line_header_local
;
10418 hashval_t line_header_local_hash
;
10420 int decode_mapping
;
10422 gdb_assert (! cu
->per_cu
->is_debug_types
);
10424 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
10425 if (attr
== NULL
|| !attr
->form_is_unsigned ())
10428 sect_offset line_offset
= (sect_offset
) attr
->as_unsigned ();
10430 /* The line header hash table is only created if needed (it exists to
10431 prevent redundant reading of the line table for partial_units).
10432 If we're given a partial_unit, we'll need it. If we're given a
10433 compile_unit, then use the line header hash table if it's already
10434 created, but don't create one just yet. */
10436 if (per_objfile
->line_header_hash
== NULL
10437 && die
->tag
== DW_TAG_partial_unit
)
10439 per_objfile
->line_header_hash
10440 .reset (htab_create_alloc (127, line_header_hash_voidp
,
10441 line_header_eq_voidp
,
10442 htab_delete_entry
<line_header
>,
10446 line_header_local
.sect_off
= line_offset
;
10447 line_header_local
.offset_in_dwz
= cu
->per_cu
->is_dwz
;
10448 line_header_local_hash
= line_header_hash (&line_header_local
);
10449 if (per_objfile
->line_header_hash
!= NULL
)
10451 slot
= htab_find_slot_with_hash (per_objfile
->line_header_hash
.get (),
10452 &line_header_local
,
10453 line_header_local_hash
, NO_INSERT
);
10455 /* For DW_TAG_compile_unit we need info like symtab::linetable which
10456 is not present in *SLOT (since if there is something in *SLOT then
10457 it will be for a partial_unit). */
10458 if (die
->tag
== DW_TAG_partial_unit
&& slot
!= NULL
)
10460 gdb_assert (*slot
!= NULL
);
10461 cu
->line_header
= (struct line_header
*) *slot
;
10466 /* dwarf_decode_line_header does not yet provide sufficient information.
10467 We always have to call also dwarf_decode_lines for it. */
10468 line_header_up lh
= dwarf_decode_line_header (line_offset
, cu
);
10472 cu
->line_header
= lh
.release ();
10473 cu
->line_header_die_owner
= die
;
10475 if (per_objfile
->line_header_hash
== NULL
)
10479 slot
= htab_find_slot_with_hash (per_objfile
->line_header_hash
.get (),
10480 &line_header_local
,
10481 line_header_local_hash
, INSERT
);
10482 gdb_assert (slot
!= NULL
);
10484 if (slot
!= NULL
&& *slot
== NULL
)
10486 /* This newly decoded line number information unit will be owned
10487 by line_header_hash hash table. */
10488 *slot
= cu
->line_header
;
10489 cu
->line_header_die_owner
= NULL
;
10493 /* We cannot free any current entry in (*slot) as that struct line_header
10494 may be already used by multiple CUs. Create only temporary decoded
10495 line_header for this CU - it may happen at most once for each line
10496 number information unit. And if we're not using line_header_hash
10497 then this is what we want as well. */
10498 gdb_assert (die
->tag
!= DW_TAG_partial_unit
);
10500 decode_mapping
= (die
->tag
!= DW_TAG_partial_unit
);
10501 dwarf_decode_lines (cu
->line_header
, comp_dir
, cu
, NULL
, lowpc
,
10506 /* Process DW_TAG_compile_unit or DW_TAG_partial_unit. */
10509 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
10511 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
10512 struct objfile
*objfile
= per_objfile
->objfile
;
10513 struct gdbarch
*gdbarch
= objfile
->arch ();
10514 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
10515 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
10516 struct attribute
*attr
;
10517 struct die_info
*child_die
;
10518 CORE_ADDR baseaddr
;
10520 prepare_one_comp_unit (cu
, die
, cu
->per_cu
->lang
);
10521 baseaddr
= objfile
->text_section_offset ();
10523 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
10525 /* If we didn't find a lowpc, set it to highpc to avoid complaints
10526 from finish_block. */
10527 if (lowpc
== ((CORE_ADDR
) -1))
10529 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
10531 file_and_directory fnd
= find_file_and_directory (die
, cu
);
10533 cu
->start_symtab (fnd
.name
, fnd
.comp_dir
, lowpc
);
10535 gdb_assert (per_objfile
->sym_cu
== nullptr);
10536 scoped_restore restore_sym_cu
10537 = make_scoped_restore (&per_objfile
->sym_cu
, cu
);
10539 /* Decode line number information if present. We do this before
10540 processing child DIEs, so that the line header table is available
10541 for DW_AT_decl_file. */
10542 handle_DW_AT_stmt_list (die
, cu
, fnd
.comp_dir
, lowpc
);
10544 /* Process all dies in compilation unit. */
10545 if (die
->child
!= NULL
)
10547 child_die
= die
->child
;
10548 while (child_die
&& child_die
->tag
)
10550 process_die (child_die
, cu
);
10551 child_die
= child_die
->sibling
;
10554 per_objfile
->sym_cu
= nullptr;
10556 /* Decode macro information, if present. Dwarf 2 macro information
10557 refers to information in the line number info statement program
10558 header, so we can only read it if we've read the header
10560 attr
= dwarf2_attr (die
, DW_AT_macros
, cu
);
10562 attr
= dwarf2_attr (die
, DW_AT_GNU_macros
, cu
);
10563 if (attr
!= nullptr && attr
->form_is_unsigned () && cu
->line_header
)
10565 if (dwarf2_attr (die
, DW_AT_macro_info
, cu
))
10566 complaint (_("CU refers to both DW_AT_macros and DW_AT_macro_info"));
10568 dwarf_decode_macros (cu
, attr
->as_unsigned (), 1);
10572 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
10573 if (attr
!= nullptr && attr
->form_is_unsigned () && cu
->line_header
)
10575 unsigned int macro_offset
= attr
->as_unsigned ();
10577 dwarf_decode_macros (cu
, macro_offset
, 0);
10583 dwarf2_cu::setup_type_unit_groups (struct die_info
*die
)
10585 struct type_unit_group
*tu_group
;
10587 struct attribute
*attr
;
10589 struct signatured_type
*sig_type
;
10591 gdb_assert (per_cu
->is_debug_types
);
10592 sig_type
= (struct signatured_type
*) per_cu
;
10594 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, this);
10596 /* If we're using .gdb_index (includes -readnow) then
10597 per_cu->type_unit_group may not have been set up yet. */
10598 if (sig_type
->type_unit_group
== NULL
)
10599 sig_type
->type_unit_group
= get_type_unit_group (this, attr
);
10600 tu_group
= sig_type
->type_unit_group
;
10602 /* If we've already processed this stmt_list there's no real need to
10603 do it again, we could fake it and just recreate the part we need
10604 (file name,index -> symtab mapping). If data shows this optimization
10605 is useful we can do it then. */
10606 type_unit_group_unshareable
*tug_unshare
10607 = per_objfile
->get_type_unit_group_unshareable (tu_group
);
10608 first_time
= tug_unshare
->compunit_symtab
== NULL
;
10610 /* We have to handle the case of both a missing DW_AT_stmt_list or bad
10613 if (attr
!= NULL
&& attr
->form_is_unsigned ())
10615 sect_offset line_offset
= (sect_offset
) attr
->as_unsigned ();
10616 lh
= dwarf_decode_line_header (line_offset
, this);
10621 start_symtab ("", NULL
, 0);
10624 gdb_assert (tug_unshare
->symtabs
== NULL
);
10625 gdb_assert (m_builder
== nullptr);
10626 struct compunit_symtab
*cust
= tug_unshare
->compunit_symtab
;
10627 m_builder
.reset (new struct buildsym_compunit
10628 (COMPUNIT_OBJFILE (cust
), "",
10629 COMPUNIT_DIRNAME (cust
),
10630 compunit_language (cust
),
10632 list_in_scope
= get_builder ()->get_file_symbols ();
10637 line_header
= lh
.release ();
10638 line_header_die_owner
= die
;
10642 struct compunit_symtab
*cust
= start_symtab ("", NULL
, 0);
10644 /* Note: We don't assign tu_group->compunit_symtab yet because we're
10645 still initializing it, and our caller (a few levels up)
10646 process_full_type_unit still needs to know if this is the first
10649 tug_unshare
->symtabs
10650 = XOBNEWVEC (&COMPUNIT_OBJFILE (cust
)->objfile_obstack
,
10651 struct symtab
*, line_header
->file_names_size ());
10653 auto &file_names
= line_header
->file_names ();
10654 for (i
= 0; i
< file_names
.size (); ++i
)
10656 file_entry
&fe
= file_names
[i
];
10657 dwarf2_start_subfile (this, fe
.name
,
10658 fe
.include_dir (line_header
));
10659 buildsym_compunit
*b
= get_builder ();
10660 if (b
->get_current_subfile ()->symtab
== NULL
)
10662 /* NOTE: start_subfile will recognize when it's been
10663 passed a file it has already seen. So we can't
10664 assume there's a simple mapping from
10665 cu->line_header->file_names to subfiles, plus
10666 cu->line_header->file_names may contain dups. */
10667 b
->get_current_subfile ()->symtab
10668 = allocate_symtab (cust
, b
->get_current_subfile ()->name
);
10671 fe
.symtab
= b
->get_current_subfile ()->symtab
;
10672 tug_unshare
->symtabs
[i
] = fe
.symtab
;
10677 gdb_assert (m_builder
== nullptr);
10678 struct compunit_symtab
*cust
= tug_unshare
->compunit_symtab
;
10679 m_builder
.reset (new struct buildsym_compunit
10680 (COMPUNIT_OBJFILE (cust
), "",
10681 COMPUNIT_DIRNAME (cust
),
10682 compunit_language (cust
),
10684 list_in_scope
= get_builder ()->get_file_symbols ();
10686 auto &file_names
= line_header
->file_names ();
10687 for (i
= 0; i
< file_names
.size (); ++i
)
10689 file_entry
&fe
= file_names
[i
];
10690 fe
.symtab
= tug_unshare
->symtabs
[i
];
10694 /* The main symtab is allocated last. Type units don't have DW_AT_name
10695 so they don't have a "real" (so to speak) symtab anyway.
10696 There is later code that will assign the main symtab to all symbols
10697 that don't have one. We need to handle the case of a symbol with a
10698 missing symtab (DW_AT_decl_file) anyway. */
10701 /* Process DW_TAG_type_unit.
10702 For TUs we want to skip the first top level sibling if it's not the
10703 actual type being defined by this TU. In this case the first top
10704 level sibling is there to provide context only. */
10707 read_type_unit_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
10709 struct die_info
*child_die
;
10711 prepare_one_comp_unit (cu
, die
, language_minimal
);
10713 /* Initialize (or reinitialize) the machinery for building symtabs.
10714 We do this before processing child DIEs, so that the line header table
10715 is available for DW_AT_decl_file. */
10716 cu
->setup_type_unit_groups (die
);
10718 if (die
->child
!= NULL
)
10720 child_die
= die
->child
;
10721 while (child_die
&& child_die
->tag
)
10723 process_die (child_die
, cu
);
10724 child_die
= child_die
->sibling
;
10731 http://gcc.gnu.org/wiki/DebugFission
10732 http://gcc.gnu.org/wiki/DebugFissionDWP
10734 To simplify handling of both DWO files ("object" files with the DWARF info)
10735 and DWP files (a file with the DWOs packaged up into one file), we treat
10736 DWP files as having a collection of virtual DWO files. */
10739 hash_dwo_file (const void *item
)
10741 const struct dwo_file
*dwo_file
= (const struct dwo_file
*) item
;
10744 hash
= htab_hash_string (dwo_file
->dwo_name
);
10745 if (dwo_file
->comp_dir
!= NULL
)
10746 hash
+= htab_hash_string (dwo_file
->comp_dir
);
10751 eq_dwo_file (const void *item_lhs
, const void *item_rhs
)
10753 const struct dwo_file
*lhs
= (const struct dwo_file
*) item_lhs
;
10754 const struct dwo_file
*rhs
= (const struct dwo_file
*) item_rhs
;
10756 if (strcmp (lhs
->dwo_name
, rhs
->dwo_name
) != 0)
10758 if (lhs
->comp_dir
== NULL
|| rhs
->comp_dir
== NULL
)
10759 return lhs
->comp_dir
== rhs
->comp_dir
;
10760 return strcmp (lhs
->comp_dir
, rhs
->comp_dir
) == 0;
10763 /* Allocate a hash table for DWO files. */
10766 allocate_dwo_file_hash_table ()
10768 return htab_up (htab_create_alloc (41,
10771 htab_delete_entry
<dwo_file
>,
10775 /* Lookup DWO file DWO_NAME. */
10778 lookup_dwo_file_slot (dwarf2_per_objfile
*per_objfile
,
10779 const char *dwo_name
,
10780 const char *comp_dir
)
10782 struct dwo_file find_entry
;
10785 if (per_objfile
->per_bfd
->dwo_files
== NULL
)
10786 per_objfile
->per_bfd
->dwo_files
= allocate_dwo_file_hash_table ();
10788 find_entry
.dwo_name
= dwo_name
;
10789 find_entry
.comp_dir
= comp_dir
;
10790 slot
= htab_find_slot (per_objfile
->per_bfd
->dwo_files
.get (), &find_entry
,
10797 hash_dwo_unit (const void *item
)
10799 const struct dwo_unit
*dwo_unit
= (const struct dwo_unit
*) item
;
10801 /* This drops the top 32 bits of the id, but is ok for a hash. */
10802 return dwo_unit
->signature
;
10806 eq_dwo_unit (const void *item_lhs
, const void *item_rhs
)
10808 const struct dwo_unit
*lhs
= (const struct dwo_unit
*) item_lhs
;
10809 const struct dwo_unit
*rhs
= (const struct dwo_unit
*) item_rhs
;
10811 /* The signature is assumed to be unique within the DWO file.
10812 So while object file CU dwo_id's always have the value zero,
10813 that's OK, assuming each object file DWO file has only one CU,
10814 and that's the rule for now. */
10815 return lhs
->signature
== rhs
->signature
;
10818 /* Allocate a hash table for DWO CUs,TUs.
10819 There is one of these tables for each of CUs,TUs for each DWO file. */
10822 allocate_dwo_unit_table ()
10824 /* Start out with a pretty small number.
10825 Generally DWO files contain only one CU and maybe some TUs. */
10826 return htab_up (htab_create_alloc (3,
10829 NULL
, xcalloc
, xfree
));
10832 /* die_reader_func for create_dwo_cu. */
10835 create_dwo_cu_reader (const struct die_reader_specs
*reader
,
10836 const gdb_byte
*info_ptr
,
10837 struct die_info
*comp_unit_die
,
10838 struct dwo_file
*dwo_file
,
10839 struct dwo_unit
*dwo_unit
)
10841 struct dwarf2_cu
*cu
= reader
->cu
;
10842 sect_offset sect_off
= cu
->per_cu
->sect_off
;
10843 struct dwarf2_section_info
*section
= cu
->per_cu
->section
;
10845 gdb::optional
<ULONGEST
> signature
= lookup_dwo_id (cu
, comp_unit_die
);
10846 if (!signature
.has_value ())
10848 complaint (_("Dwarf Error: debug entry at offset %s is missing"
10849 " its dwo_id [in module %s]"),
10850 sect_offset_str (sect_off
), dwo_file
->dwo_name
);
10854 dwo_unit
->dwo_file
= dwo_file
;
10855 dwo_unit
->signature
= *signature
;
10856 dwo_unit
->section
= section
;
10857 dwo_unit
->sect_off
= sect_off
;
10858 dwo_unit
->length
= cu
->per_cu
->length
;
10860 dwarf_read_debug_printf (" offset %s, dwo_id %s",
10861 sect_offset_str (sect_off
),
10862 hex_string (dwo_unit
->signature
));
10865 /* Create the dwo_units for the CUs in a DWO_FILE.
10866 Note: This function processes DWO files only, not DWP files. */
10869 create_cus_hash_table (dwarf2_per_objfile
*per_objfile
,
10870 dwarf2_cu
*cu
, struct dwo_file
&dwo_file
,
10871 dwarf2_section_info
§ion
, htab_up
&cus_htab
)
10873 struct objfile
*objfile
= per_objfile
->objfile
;
10874 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
10875 const gdb_byte
*info_ptr
, *end_ptr
;
10877 section
.read (objfile
);
10878 info_ptr
= section
.buffer
;
10880 if (info_ptr
== NULL
)
10883 dwarf_read_debug_printf ("Reading %s for %s:",
10884 section
.get_name (),
10885 section
.get_file_name ());
10887 end_ptr
= info_ptr
+ section
.size
;
10888 while (info_ptr
< end_ptr
)
10890 struct dwarf2_per_cu_data per_cu
;
10891 struct dwo_unit read_unit
{};
10892 struct dwo_unit
*dwo_unit
;
10894 sect_offset sect_off
= (sect_offset
) (info_ptr
- section
.buffer
);
10896 per_cu
.per_bfd
= per_bfd
;
10897 per_cu
.is_debug_types
= 0;
10898 per_cu
.sect_off
= sect_offset (info_ptr
- section
.buffer
);
10899 per_cu
.section
= §ion
;
10901 cutu_reader
reader (&per_cu
, per_objfile
, cu
, &dwo_file
);
10902 if (!reader
.dummy_p
)
10903 create_dwo_cu_reader (&reader
, reader
.info_ptr
, reader
.comp_unit_die
,
10904 &dwo_file
, &read_unit
);
10905 info_ptr
+= per_cu
.length
;
10907 // If the unit could not be parsed, skip it.
10908 if (read_unit
.dwo_file
== NULL
)
10911 if (cus_htab
== NULL
)
10912 cus_htab
= allocate_dwo_unit_table ();
10914 dwo_unit
= OBSTACK_ZALLOC (&per_bfd
->obstack
,
10916 *dwo_unit
= read_unit
;
10917 slot
= htab_find_slot (cus_htab
.get (), dwo_unit
, INSERT
);
10918 gdb_assert (slot
!= NULL
);
10921 const struct dwo_unit
*dup_cu
= (const struct dwo_unit
*)*slot
;
10922 sect_offset dup_sect_off
= dup_cu
->sect_off
;
10924 complaint (_("debug cu entry at offset %s is duplicate to"
10925 " the entry at offset %s, signature %s"),
10926 sect_offset_str (sect_off
), sect_offset_str (dup_sect_off
),
10927 hex_string (dwo_unit
->signature
));
10929 *slot
= (void *)dwo_unit
;
10933 /* DWP file .debug_{cu,tu}_index section format:
10934 [ref: http://gcc.gnu.org/wiki/DebugFissionDWP]
10935 [ref: http://dwarfstd.org/doc/DWARF5.pdf, sect 7.3.5 "DWARF Package Files"]
10937 DWP Versions 1 & 2 are older, pre-standard format versions. The first
10938 officially standard DWP format was published with DWARF v5 and is called
10939 Version 5. There are no versions 3 or 4.
10943 Both index sections have the same format, and serve to map a 64-bit
10944 signature to a set of section numbers. Each section begins with a header,
10945 followed by a hash table of 64-bit signatures, a parallel table of 32-bit
10946 indexes, and a pool of 32-bit section numbers. The index sections will be
10947 aligned at 8-byte boundaries in the file.
10949 The index section header consists of:
10951 V, 32 bit version number
10953 N, 32 bit number of compilation units or type units in the index
10954 M, 32 bit number of slots in the hash table
10956 Numbers are recorded using the byte order of the application binary.
10958 The hash table begins at offset 16 in the section, and consists of an array
10959 of M 64-bit slots. Each slot contains a 64-bit signature (using the byte
10960 order of the application binary). Unused slots in the hash table are 0.
10961 (We rely on the extreme unlikeliness of a signature being exactly 0.)
10963 The parallel table begins immediately after the hash table
10964 (at offset 16 + 8 * M from the beginning of the section), and consists of an
10965 array of 32-bit indexes (using the byte order of the application binary),
10966 corresponding 1-1 with slots in the hash table. Each entry in the parallel
10967 table contains a 32-bit index into the pool of section numbers. For unused
10968 hash table slots, the corresponding entry in the parallel table will be 0.
10970 The pool of section numbers begins immediately following the hash table
10971 (at offset 16 + 12 * M from the beginning of the section). The pool of
10972 section numbers consists of an array of 32-bit words (using the byte order
10973 of the application binary). Each item in the array is indexed starting
10974 from 0. The hash table entry provides the index of the first section
10975 number in the set. Additional section numbers in the set follow, and the
10976 set is terminated by a 0 entry (section number 0 is not used in ELF).
10978 In each set of section numbers, the .debug_info.dwo or .debug_types.dwo
10979 section must be the first entry in the set, and the .debug_abbrev.dwo must
10980 be the second entry. Other members of the set may follow in any order.
10984 DWP Versions 2 and 5:
10986 DWP Versions 2 and 5 combine all the .debug_info, etc. sections into one,
10987 and the entries in the index tables are now offsets into these sections.
10988 CU offsets begin at 0. TU offsets begin at the size of the .debug_info
10991 Index Section Contents:
10993 Hash Table of Signatures dwp_hash_table.hash_table
10994 Parallel Table of Indices dwp_hash_table.unit_table
10995 Table of Section Offsets dwp_hash_table.{v2|v5}.{section_ids,offsets}
10996 Table of Section Sizes dwp_hash_table.{v2|v5}.sizes
10998 The index section header consists of:
11000 V, 32 bit version number
11001 L, 32 bit number of columns in the table of section offsets
11002 N, 32 bit number of compilation units or type units in the index
11003 M, 32 bit number of slots in the hash table
11005 Numbers are recorded using the byte order of the application binary.
11007 The hash table has the same format as version 1.
11008 The parallel table of indices has the same format as version 1,
11009 except that the entries are origin-1 indices into the table of sections
11010 offsets and the table of section sizes.
11012 The table of offsets begins immediately following the parallel table
11013 (at offset 16 + 12 * M from the beginning of the section). The table is
11014 a two-dimensional array of 32-bit words (using the byte order of the
11015 application binary), with L columns and N+1 rows, in row-major order.
11016 Each row in the array is indexed starting from 0. The first row provides
11017 a key to the remaining rows: each column in this row provides an identifier
11018 for a debug section, and the offsets in the same column of subsequent rows
11019 refer to that section. The section identifiers for Version 2 are:
11021 DW_SECT_INFO 1 .debug_info.dwo
11022 DW_SECT_TYPES 2 .debug_types.dwo
11023 DW_SECT_ABBREV 3 .debug_abbrev.dwo
11024 DW_SECT_LINE 4 .debug_line.dwo
11025 DW_SECT_LOC 5 .debug_loc.dwo
11026 DW_SECT_STR_OFFSETS 6 .debug_str_offsets.dwo
11027 DW_SECT_MACINFO 7 .debug_macinfo.dwo
11028 DW_SECT_MACRO 8 .debug_macro.dwo
11030 The section identifiers for Version 5 are:
11032 DW_SECT_INFO_V5 1 .debug_info.dwo
11033 DW_SECT_RESERVED_V5 2 --
11034 DW_SECT_ABBREV_V5 3 .debug_abbrev.dwo
11035 DW_SECT_LINE_V5 4 .debug_line.dwo
11036 DW_SECT_LOCLISTS_V5 5 .debug_loclists.dwo
11037 DW_SECT_STR_OFFSETS_V5 6 .debug_str_offsets.dwo
11038 DW_SECT_MACRO_V5 7 .debug_macro.dwo
11039 DW_SECT_RNGLISTS_V5 8 .debug_rnglists.dwo
11041 The offsets provided by the CU and TU index sections are the base offsets
11042 for the contributions made by each CU or TU to the corresponding section
11043 in the package file. Each CU and TU header contains an abbrev_offset
11044 field, used to find the abbreviations table for that CU or TU within the
11045 contribution to the .debug_abbrev.dwo section for that CU or TU, and should
11046 be interpreted as relative to the base offset given in the index section.
11047 Likewise, offsets into .debug_line.dwo from DW_AT_stmt_list attributes
11048 should be interpreted as relative to the base offset for .debug_line.dwo,
11049 and offsets into other debug sections obtained from DWARF attributes should
11050 also be interpreted as relative to the corresponding base offset.
11052 The table of sizes begins immediately following the table of offsets.
11053 Like the table of offsets, it is a two-dimensional array of 32-bit words,
11054 with L columns and N rows, in row-major order. Each row in the array is
11055 indexed starting from 1 (row 0 is shared by the two tables).
11059 Hash table lookup is handled the same in version 1 and 2:
11061 We assume that N and M will not exceed 2^32 - 1.
11062 The size of the hash table, M, must be 2^k such that 2^k > 3*N/2.
11064 Given a 64-bit compilation unit signature or a type signature S, an entry
11065 in the hash table is located as follows:
11067 1) Calculate a primary hash H = S & MASK(k), where MASK(k) is a mask with
11068 the low-order k bits all set to 1.
11070 2) Calculate a secondary hash H' = (((S >> 32) & MASK(k)) | 1).
11072 3) If the hash table entry at index H matches the signature, use that
11073 entry. If the hash table entry at index H is unused (all zeroes),
11074 terminate the search: the signature is not present in the table.
11076 4) Let H = (H + H') modulo M. Repeat at Step 3.
11078 Because M > N and H' and M are relatively prime, the search is guaranteed
11079 to stop at an unused slot or find the match. */
11081 /* Create a hash table to map DWO IDs to their CU/TU entry in
11082 .debug_{info,types}.dwo in DWP_FILE.
11083 Returns NULL if there isn't one.
11084 Note: This function processes DWP files only, not DWO files. */
11086 static struct dwp_hash_table
*
11087 create_dwp_hash_table (dwarf2_per_objfile
*per_objfile
,
11088 struct dwp_file
*dwp_file
, int is_debug_types
)
11090 struct objfile
*objfile
= per_objfile
->objfile
;
11091 bfd
*dbfd
= dwp_file
->dbfd
.get ();
11092 const gdb_byte
*index_ptr
, *index_end
;
11093 struct dwarf2_section_info
*index
;
11094 uint32_t version
, nr_columns
, nr_units
, nr_slots
;
11095 struct dwp_hash_table
*htab
;
11097 if (is_debug_types
)
11098 index
= &dwp_file
->sections
.tu_index
;
11100 index
= &dwp_file
->sections
.cu_index
;
11102 if (index
->empty ())
11104 index
->read (objfile
);
11106 index_ptr
= index
->buffer
;
11107 index_end
= index_ptr
+ index
->size
;
11109 /* For Version 5, the version is really 2 bytes of data & 2 bytes of padding.
11110 For now it's safe to just read 4 bytes (particularly as it's difficult to
11111 tell if you're dealing with Version 5 before you've read the version). */
11112 version
= read_4_bytes (dbfd
, index_ptr
);
11114 if (version
== 2 || version
== 5)
11115 nr_columns
= read_4_bytes (dbfd
, index_ptr
);
11119 nr_units
= read_4_bytes (dbfd
, index_ptr
);
11121 nr_slots
= read_4_bytes (dbfd
, index_ptr
);
11124 if (version
!= 1 && version
!= 2 && version
!= 5)
11126 error (_("Dwarf Error: unsupported DWP file version (%s)"
11127 " [in module %s]"),
11128 pulongest (version
), dwp_file
->name
);
11130 if (nr_slots
!= (nr_slots
& -nr_slots
))
11132 error (_("Dwarf Error: number of slots in DWP hash table (%s)"
11133 " is not power of 2 [in module %s]"),
11134 pulongest (nr_slots
), dwp_file
->name
);
11137 htab
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, struct dwp_hash_table
);
11138 htab
->version
= version
;
11139 htab
->nr_columns
= nr_columns
;
11140 htab
->nr_units
= nr_units
;
11141 htab
->nr_slots
= nr_slots
;
11142 htab
->hash_table
= index_ptr
;
11143 htab
->unit_table
= htab
->hash_table
+ sizeof (uint64_t) * nr_slots
;
11145 /* Exit early if the table is empty. */
11146 if (nr_slots
== 0 || nr_units
== 0
11147 || (version
== 2 && nr_columns
== 0)
11148 || (version
== 5 && nr_columns
== 0))
11150 /* All must be zero. */
11151 if (nr_slots
!= 0 || nr_units
!= 0
11152 || (version
== 2 && nr_columns
!= 0)
11153 || (version
== 5 && nr_columns
!= 0))
11155 complaint (_("Empty DWP but nr_slots,nr_units,nr_columns not"
11156 " all zero [in modules %s]"),
11164 htab
->section_pool
.v1
.indices
=
11165 htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
11166 /* It's harder to decide whether the section is too small in v1.
11167 V1 is deprecated anyway so we punt. */
11169 else if (version
== 2)
11171 const gdb_byte
*ids_ptr
= htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
11172 int *ids
= htab
->section_pool
.v2
.section_ids
;
11173 size_t sizeof_ids
= sizeof (htab
->section_pool
.v2
.section_ids
);
11174 /* Reverse map for error checking. */
11175 int ids_seen
[DW_SECT_MAX
+ 1];
11178 if (nr_columns
< 2)
11180 error (_("Dwarf Error: bad DWP hash table, too few columns"
11181 " in section table [in module %s]"),
11184 if (nr_columns
> MAX_NR_V2_DWO_SECTIONS
)
11186 error (_("Dwarf Error: bad DWP hash table, too many columns"
11187 " in section table [in module %s]"),
11190 memset (ids
, 255, sizeof_ids
);
11191 memset (ids_seen
, 255, sizeof (ids_seen
));
11192 for (i
= 0; i
< nr_columns
; ++i
)
11194 int id
= read_4_bytes (dbfd
, ids_ptr
+ i
* sizeof (uint32_t));
11196 if (id
< DW_SECT_MIN
|| id
> DW_SECT_MAX
)
11198 error (_("Dwarf Error: bad DWP hash table, bad section id %d"
11199 " in section table [in module %s]"),
11200 id
, dwp_file
->name
);
11202 if (ids_seen
[id
] != -1)
11204 error (_("Dwarf Error: bad DWP hash table, duplicate section"
11205 " id %d in section table [in module %s]"),
11206 id
, dwp_file
->name
);
11211 /* Must have exactly one info or types section. */
11212 if (((ids_seen
[DW_SECT_INFO
] != -1)
11213 + (ids_seen
[DW_SECT_TYPES
] != -1))
11216 error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
11217 " DWO info/types section [in module %s]"),
11220 /* Must have an abbrev section. */
11221 if (ids_seen
[DW_SECT_ABBREV
] == -1)
11223 error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
11224 " section [in module %s]"),
11227 htab
->section_pool
.v2
.offsets
= ids_ptr
+ sizeof (uint32_t) * nr_columns
;
11228 htab
->section_pool
.v2
.sizes
=
11229 htab
->section_pool
.v2
.offsets
+ (sizeof (uint32_t)
11230 * nr_units
* nr_columns
);
11231 if ((htab
->section_pool
.v2
.sizes
+ (sizeof (uint32_t)
11232 * nr_units
* nr_columns
))
11235 error (_("Dwarf Error: DWP index section is corrupt (too small)"
11236 " [in module %s]"),
11240 else /* version == 5 */
11242 const gdb_byte
*ids_ptr
= htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
11243 int *ids
= htab
->section_pool
.v5
.section_ids
;
11244 size_t sizeof_ids
= sizeof (htab
->section_pool
.v5
.section_ids
);
11245 /* Reverse map for error checking. */
11246 int ids_seen
[DW_SECT_MAX_V5
+ 1];
11248 if (nr_columns
< 2)
11250 error (_("Dwarf Error: bad DWP hash table, too few columns"
11251 " in section table [in module %s]"),
11254 if (nr_columns
> MAX_NR_V5_DWO_SECTIONS
)
11256 error (_("Dwarf Error: bad DWP hash table, too many columns"
11257 " in section table [in module %s]"),
11260 memset (ids
, 255, sizeof_ids
);
11261 memset (ids_seen
, 255, sizeof (ids_seen
));
11262 for (int i
= 0; i
< nr_columns
; ++i
)
11264 int id
= read_4_bytes (dbfd
, ids_ptr
+ i
* sizeof (uint32_t));
11266 if (id
< DW_SECT_MIN
|| id
> DW_SECT_MAX_V5
)
11268 error (_("Dwarf Error: bad DWP hash table, bad section id %d"
11269 " in section table [in module %s]"),
11270 id
, dwp_file
->name
);
11272 if (ids_seen
[id
] != -1)
11274 error (_("Dwarf Error: bad DWP hash table, duplicate section"
11275 " id %d in section table [in module %s]"),
11276 id
, dwp_file
->name
);
11281 /* Must have seen an info section. */
11282 if (ids_seen
[DW_SECT_INFO_V5
] == -1)
11284 error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
11285 " DWO info/types section [in module %s]"),
11288 /* Must have an abbrev section. */
11289 if (ids_seen
[DW_SECT_ABBREV_V5
] == -1)
11291 error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
11292 " section [in module %s]"),
11295 htab
->section_pool
.v5
.offsets
= ids_ptr
+ sizeof (uint32_t) * nr_columns
;
11296 htab
->section_pool
.v5
.sizes
11297 = htab
->section_pool
.v5
.offsets
+ (sizeof (uint32_t)
11298 * nr_units
* nr_columns
);
11299 if ((htab
->section_pool
.v5
.sizes
+ (sizeof (uint32_t)
11300 * nr_units
* nr_columns
))
11303 error (_("Dwarf Error: DWP index section is corrupt (too small)"
11304 " [in module %s]"),
11312 /* Update SECTIONS with the data from SECTP.
11314 This function is like the other "locate" section routines, but in
11315 this context the sections to read comes from the DWP V1 hash table,
11316 not the full ELF section table.
11318 The result is non-zero for success, or zero if an error was found. */
11321 locate_v1_virtual_dwo_sections (asection
*sectp
,
11322 struct virtual_v1_dwo_sections
*sections
)
11324 const struct dwop_section_names
*names
= &dwop_section_names
;
11326 if (names
->abbrev_dwo
.matches (sectp
->name
))
11328 /* There can be only one. */
11329 if (sections
->abbrev
.s
.section
!= NULL
)
11331 sections
->abbrev
.s
.section
= sectp
;
11332 sections
->abbrev
.size
= bfd_section_size (sectp
);
11334 else if (names
->info_dwo
.matches (sectp
->name
)
11335 || names
->types_dwo
.matches (sectp
->name
))
11337 /* There can be only one. */
11338 if (sections
->info_or_types
.s
.section
!= NULL
)
11340 sections
->info_or_types
.s
.section
= sectp
;
11341 sections
->info_or_types
.size
= bfd_section_size (sectp
);
11343 else if (names
->line_dwo
.matches (sectp
->name
))
11345 /* There can be only one. */
11346 if (sections
->line
.s
.section
!= NULL
)
11348 sections
->line
.s
.section
= sectp
;
11349 sections
->line
.size
= bfd_section_size (sectp
);
11351 else if (names
->loc_dwo
.matches (sectp
->name
))
11353 /* There can be only one. */
11354 if (sections
->loc
.s
.section
!= NULL
)
11356 sections
->loc
.s
.section
= sectp
;
11357 sections
->loc
.size
= bfd_section_size (sectp
);
11359 else if (names
->macinfo_dwo
.matches (sectp
->name
))
11361 /* There can be only one. */
11362 if (sections
->macinfo
.s
.section
!= NULL
)
11364 sections
->macinfo
.s
.section
= sectp
;
11365 sections
->macinfo
.size
= bfd_section_size (sectp
);
11367 else if (names
->macro_dwo
.matches (sectp
->name
))
11369 /* There can be only one. */
11370 if (sections
->macro
.s
.section
!= NULL
)
11372 sections
->macro
.s
.section
= sectp
;
11373 sections
->macro
.size
= bfd_section_size (sectp
);
11375 else if (names
->str_offsets_dwo
.matches (sectp
->name
))
11377 /* There can be only one. */
11378 if (sections
->str_offsets
.s
.section
!= NULL
)
11380 sections
->str_offsets
.s
.section
= sectp
;
11381 sections
->str_offsets
.size
= bfd_section_size (sectp
);
11385 /* No other kind of section is valid. */
11392 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
11393 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
11394 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
11395 This is for DWP version 1 files. */
11397 static struct dwo_unit
*
11398 create_dwo_unit_in_dwp_v1 (dwarf2_per_objfile
*per_objfile
,
11399 struct dwp_file
*dwp_file
,
11400 uint32_t unit_index
,
11401 const char *comp_dir
,
11402 ULONGEST signature
, int is_debug_types
)
11404 const struct dwp_hash_table
*dwp_htab
=
11405 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
11406 bfd
*dbfd
= dwp_file
->dbfd
.get ();
11407 const char *kind
= is_debug_types
? "TU" : "CU";
11408 struct dwo_file
*dwo_file
;
11409 struct dwo_unit
*dwo_unit
;
11410 struct virtual_v1_dwo_sections sections
;
11411 void **dwo_file_slot
;
11414 gdb_assert (dwp_file
->version
== 1);
11416 dwarf_read_debug_printf ("Reading %s %s/%s in DWP V1 file: %s",
11417 kind
, pulongest (unit_index
), hex_string (signature
),
11420 /* Fetch the sections of this DWO unit.
11421 Put a limit on the number of sections we look for so that bad data
11422 doesn't cause us to loop forever. */
11424 #define MAX_NR_V1_DWO_SECTIONS \
11425 (1 /* .debug_info or .debug_types */ \
11426 + 1 /* .debug_abbrev */ \
11427 + 1 /* .debug_line */ \
11428 + 1 /* .debug_loc */ \
11429 + 1 /* .debug_str_offsets */ \
11430 + 1 /* .debug_macro or .debug_macinfo */ \
11431 + 1 /* trailing zero */)
11433 memset (§ions
, 0, sizeof (sections
));
11435 for (i
= 0; i
< MAX_NR_V1_DWO_SECTIONS
; ++i
)
11438 uint32_t section_nr
=
11439 read_4_bytes (dbfd
,
11440 dwp_htab
->section_pool
.v1
.indices
11441 + (unit_index
+ i
) * sizeof (uint32_t));
11443 if (section_nr
== 0)
11445 if (section_nr
>= dwp_file
->num_sections
)
11447 error (_("Dwarf Error: bad DWP hash table, section number too large"
11448 " [in module %s]"),
11452 sectp
= dwp_file
->elf_sections
[section_nr
];
11453 if (! locate_v1_virtual_dwo_sections (sectp
, §ions
))
11455 error (_("Dwarf Error: bad DWP hash table, invalid section found"
11456 " [in module %s]"),
11462 || sections
.info_or_types
.empty ()
11463 || sections
.abbrev
.empty ())
11465 error (_("Dwarf Error: bad DWP hash table, missing DWO sections"
11466 " [in module %s]"),
11469 if (i
== MAX_NR_V1_DWO_SECTIONS
)
11471 error (_("Dwarf Error: bad DWP hash table, too many DWO sections"
11472 " [in module %s]"),
11476 /* It's easier for the rest of the code if we fake a struct dwo_file and
11477 have dwo_unit "live" in that. At least for now.
11479 The DWP file can be made up of a random collection of CUs and TUs.
11480 However, for each CU + set of TUs that came from the same original DWO
11481 file, we can combine them back into a virtual DWO file to save space
11482 (fewer struct dwo_file objects to allocate). Remember that for really
11483 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
11485 std::string virtual_dwo_name
=
11486 string_printf ("virtual-dwo/%d-%d-%d-%d",
11487 sections
.abbrev
.get_id (),
11488 sections
.line
.get_id (),
11489 sections
.loc
.get_id (),
11490 sections
.str_offsets
.get_id ());
11491 /* Can we use an existing virtual DWO file? */
11492 dwo_file_slot
= lookup_dwo_file_slot (per_objfile
, virtual_dwo_name
.c_str (),
11494 /* Create one if necessary. */
11495 if (*dwo_file_slot
== NULL
)
11497 dwarf_read_debug_printf ("Creating virtual DWO: %s",
11498 virtual_dwo_name
.c_str ());
11500 dwo_file
= new struct dwo_file
;
11501 dwo_file
->dwo_name
= per_objfile
->objfile
->intern (virtual_dwo_name
);
11502 dwo_file
->comp_dir
= comp_dir
;
11503 dwo_file
->sections
.abbrev
= sections
.abbrev
;
11504 dwo_file
->sections
.line
= sections
.line
;
11505 dwo_file
->sections
.loc
= sections
.loc
;
11506 dwo_file
->sections
.macinfo
= sections
.macinfo
;
11507 dwo_file
->sections
.macro
= sections
.macro
;
11508 dwo_file
->sections
.str_offsets
= sections
.str_offsets
;
11509 /* The "str" section is global to the entire DWP file. */
11510 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
11511 /* The info or types section is assigned below to dwo_unit,
11512 there's no need to record it in dwo_file.
11513 Also, we can't simply record type sections in dwo_file because
11514 we record a pointer into the vector in dwo_unit. As we collect more
11515 types we'll grow the vector and eventually have to reallocate space
11516 for it, invalidating all copies of pointers into the previous
11518 *dwo_file_slot
= dwo_file
;
11522 dwarf_read_debug_printf ("Using existing virtual DWO: %s",
11523 virtual_dwo_name
.c_str ());
11525 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
11528 dwo_unit
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, struct dwo_unit
);
11529 dwo_unit
->dwo_file
= dwo_file
;
11530 dwo_unit
->signature
= signature
;
11531 dwo_unit
->section
=
11532 XOBNEW (&per_objfile
->per_bfd
->obstack
, struct dwarf2_section_info
);
11533 *dwo_unit
->section
= sections
.info_or_types
;
11534 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
11539 /* Subroutine of create_dwo_unit_in_dwp_v2 and create_dwo_unit_in_dwp_v5 to
11540 simplify them. Given a pointer to the containing section SECTION, and
11541 OFFSET,SIZE of the piece within that section used by a TU/CU, return a
11542 virtual section of just that piece. */
11544 static struct dwarf2_section_info
11545 create_dwp_v2_or_v5_section (dwarf2_per_objfile
*per_objfile
,
11546 struct dwarf2_section_info
*section
,
11547 bfd_size_type offset
, bfd_size_type size
)
11549 struct dwarf2_section_info result
;
11552 gdb_assert (section
!= NULL
);
11553 gdb_assert (!section
->is_virtual
);
11555 memset (&result
, 0, sizeof (result
));
11556 result
.s
.containing_section
= section
;
11557 result
.is_virtual
= true;
11562 sectp
= section
->get_bfd_section ();
11564 /* Flag an error if the piece denoted by OFFSET,SIZE is outside the
11565 bounds of the real section. This is a pretty-rare event, so just
11566 flag an error (easier) instead of a warning and trying to cope. */
11568 || offset
+ size
> bfd_section_size (sectp
))
11570 error (_("Dwarf Error: Bad DWP V2 or V5 section info, doesn't fit"
11571 " in section %s [in module %s]"),
11572 sectp
? bfd_section_name (sectp
) : "<unknown>",
11573 objfile_name (per_objfile
->objfile
));
11576 result
.virtual_offset
= offset
;
11577 result
.size
= size
;
11581 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
11582 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
11583 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
11584 This is for DWP version 2 files. */
11586 static struct dwo_unit
*
11587 create_dwo_unit_in_dwp_v2 (dwarf2_per_objfile
*per_objfile
,
11588 struct dwp_file
*dwp_file
,
11589 uint32_t unit_index
,
11590 const char *comp_dir
,
11591 ULONGEST signature
, int is_debug_types
)
11593 const struct dwp_hash_table
*dwp_htab
=
11594 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
11595 bfd
*dbfd
= dwp_file
->dbfd
.get ();
11596 const char *kind
= is_debug_types
? "TU" : "CU";
11597 struct dwo_file
*dwo_file
;
11598 struct dwo_unit
*dwo_unit
;
11599 struct virtual_v2_or_v5_dwo_sections sections
;
11600 void **dwo_file_slot
;
11603 gdb_assert (dwp_file
->version
== 2);
11605 dwarf_read_debug_printf ("Reading %s %s/%s in DWP V2 file: %s",
11606 kind
, pulongest (unit_index
), hex_string (signature
),
11609 /* Fetch the section offsets of this DWO unit. */
11611 memset (§ions
, 0, sizeof (sections
));
11613 for (i
= 0; i
< dwp_htab
->nr_columns
; ++i
)
11615 uint32_t offset
= read_4_bytes (dbfd
,
11616 dwp_htab
->section_pool
.v2
.offsets
11617 + (((unit_index
- 1) * dwp_htab
->nr_columns
11619 * sizeof (uint32_t)));
11620 uint32_t size
= read_4_bytes (dbfd
,
11621 dwp_htab
->section_pool
.v2
.sizes
11622 + (((unit_index
- 1) * dwp_htab
->nr_columns
11624 * sizeof (uint32_t)));
11626 switch (dwp_htab
->section_pool
.v2
.section_ids
[i
])
11629 case DW_SECT_TYPES
:
11630 sections
.info_or_types_offset
= offset
;
11631 sections
.info_or_types_size
= size
;
11633 case DW_SECT_ABBREV
:
11634 sections
.abbrev_offset
= offset
;
11635 sections
.abbrev_size
= size
;
11638 sections
.line_offset
= offset
;
11639 sections
.line_size
= size
;
11642 sections
.loc_offset
= offset
;
11643 sections
.loc_size
= size
;
11645 case DW_SECT_STR_OFFSETS
:
11646 sections
.str_offsets_offset
= offset
;
11647 sections
.str_offsets_size
= size
;
11649 case DW_SECT_MACINFO
:
11650 sections
.macinfo_offset
= offset
;
11651 sections
.macinfo_size
= size
;
11653 case DW_SECT_MACRO
:
11654 sections
.macro_offset
= offset
;
11655 sections
.macro_size
= size
;
11660 /* It's easier for the rest of the code if we fake a struct dwo_file and
11661 have dwo_unit "live" in that. At least for now.
11663 The DWP file can be made up of a random collection of CUs and TUs.
11664 However, for each CU + set of TUs that came from the same original DWO
11665 file, we can combine them back into a virtual DWO file to save space
11666 (fewer struct dwo_file objects to allocate). Remember that for really
11667 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
11669 std::string virtual_dwo_name
=
11670 string_printf ("virtual-dwo/%ld-%ld-%ld-%ld",
11671 (long) (sections
.abbrev_size
? sections
.abbrev_offset
: 0),
11672 (long) (sections
.line_size
? sections
.line_offset
: 0),
11673 (long) (sections
.loc_size
? sections
.loc_offset
: 0),
11674 (long) (sections
.str_offsets_size
11675 ? sections
.str_offsets_offset
: 0));
11676 /* Can we use an existing virtual DWO file? */
11677 dwo_file_slot
= lookup_dwo_file_slot (per_objfile
, virtual_dwo_name
.c_str (),
11679 /* Create one if necessary. */
11680 if (*dwo_file_slot
== NULL
)
11682 dwarf_read_debug_printf ("Creating virtual DWO: %s",
11683 virtual_dwo_name
.c_str ());
11685 dwo_file
= new struct dwo_file
;
11686 dwo_file
->dwo_name
= per_objfile
->objfile
->intern (virtual_dwo_name
);
11687 dwo_file
->comp_dir
= comp_dir
;
11688 dwo_file
->sections
.abbrev
=
11689 create_dwp_v2_or_v5_section (per_objfile
, &dwp_file
->sections
.abbrev
,
11690 sections
.abbrev_offset
,
11691 sections
.abbrev_size
);
11692 dwo_file
->sections
.line
=
11693 create_dwp_v2_or_v5_section (per_objfile
, &dwp_file
->sections
.line
,
11694 sections
.line_offset
,
11695 sections
.line_size
);
11696 dwo_file
->sections
.loc
=
11697 create_dwp_v2_or_v5_section (per_objfile
, &dwp_file
->sections
.loc
,
11698 sections
.loc_offset
, sections
.loc_size
);
11699 dwo_file
->sections
.macinfo
=
11700 create_dwp_v2_or_v5_section (per_objfile
, &dwp_file
->sections
.macinfo
,
11701 sections
.macinfo_offset
,
11702 sections
.macinfo_size
);
11703 dwo_file
->sections
.macro
=
11704 create_dwp_v2_or_v5_section (per_objfile
, &dwp_file
->sections
.macro
,
11705 sections
.macro_offset
,
11706 sections
.macro_size
);
11707 dwo_file
->sections
.str_offsets
=
11708 create_dwp_v2_or_v5_section (per_objfile
,
11709 &dwp_file
->sections
.str_offsets
,
11710 sections
.str_offsets_offset
,
11711 sections
.str_offsets_size
);
11712 /* The "str" section is global to the entire DWP file. */
11713 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
11714 /* The info or types section is assigned below to dwo_unit,
11715 there's no need to record it in dwo_file.
11716 Also, we can't simply record type sections in dwo_file because
11717 we record a pointer into the vector in dwo_unit. As we collect more
11718 types we'll grow the vector and eventually have to reallocate space
11719 for it, invalidating all copies of pointers into the previous
11721 *dwo_file_slot
= dwo_file
;
11725 dwarf_read_debug_printf ("Using existing virtual DWO: %s",
11726 virtual_dwo_name
.c_str ());
11728 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
11731 dwo_unit
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, struct dwo_unit
);
11732 dwo_unit
->dwo_file
= dwo_file
;
11733 dwo_unit
->signature
= signature
;
11734 dwo_unit
->section
=
11735 XOBNEW (&per_objfile
->per_bfd
->obstack
, struct dwarf2_section_info
);
11736 *dwo_unit
->section
= create_dwp_v2_or_v5_section
11739 ? &dwp_file
->sections
.types
11740 : &dwp_file
->sections
.info
,
11741 sections
.info_or_types_offset
,
11742 sections
.info_or_types_size
);
11743 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
11748 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
11749 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
11750 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
11751 This is for DWP version 5 files. */
11753 static struct dwo_unit
*
11754 create_dwo_unit_in_dwp_v5 (dwarf2_per_objfile
*per_objfile
,
11755 struct dwp_file
*dwp_file
,
11756 uint32_t unit_index
,
11757 const char *comp_dir
,
11758 ULONGEST signature
, int is_debug_types
)
11760 const struct dwp_hash_table
*dwp_htab
11761 = is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
11762 bfd
*dbfd
= dwp_file
->dbfd
.get ();
11763 const char *kind
= is_debug_types
? "TU" : "CU";
11764 struct dwo_file
*dwo_file
;
11765 struct dwo_unit
*dwo_unit
;
11766 struct virtual_v2_or_v5_dwo_sections sections
{};
11767 void **dwo_file_slot
;
11769 gdb_assert (dwp_file
->version
== 5);
11771 dwarf_read_debug_printf ("Reading %s %s/%s in DWP V5 file: %s",
11772 kind
, pulongest (unit_index
), hex_string (signature
),
11775 /* Fetch the section offsets of this DWO unit. */
11777 /* memset (§ions, 0, sizeof (sections)); */
11779 for (int i
= 0; i
< dwp_htab
->nr_columns
; ++i
)
11781 uint32_t offset
= read_4_bytes (dbfd
,
11782 dwp_htab
->section_pool
.v5
.offsets
11783 + (((unit_index
- 1)
11784 * dwp_htab
->nr_columns
11786 * sizeof (uint32_t)));
11787 uint32_t size
= read_4_bytes (dbfd
,
11788 dwp_htab
->section_pool
.v5
.sizes
11789 + (((unit_index
- 1) * dwp_htab
->nr_columns
11791 * sizeof (uint32_t)));
11793 switch (dwp_htab
->section_pool
.v5
.section_ids
[i
])
11795 case DW_SECT_ABBREV_V5
:
11796 sections
.abbrev_offset
= offset
;
11797 sections
.abbrev_size
= size
;
11799 case DW_SECT_INFO_V5
:
11800 sections
.info_or_types_offset
= offset
;
11801 sections
.info_or_types_size
= size
;
11803 case DW_SECT_LINE_V5
:
11804 sections
.line_offset
= offset
;
11805 sections
.line_size
= size
;
11807 case DW_SECT_LOCLISTS_V5
:
11808 sections
.loclists_offset
= offset
;
11809 sections
.loclists_size
= size
;
11811 case DW_SECT_MACRO_V5
:
11812 sections
.macro_offset
= offset
;
11813 sections
.macro_size
= size
;
11815 case DW_SECT_RNGLISTS_V5
:
11816 sections
.rnglists_offset
= offset
;
11817 sections
.rnglists_size
= size
;
11819 case DW_SECT_STR_OFFSETS_V5
:
11820 sections
.str_offsets_offset
= offset
;
11821 sections
.str_offsets_size
= size
;
11823 case DW_SECT_RESERVED_V5
:
11829 /* It's easier for the rest of the code if we fake a struct dwo_file and
11830 have dwo_unit "live" in that. At least for now.
11832 The DWP file can be made up of a random collection of CUs and TUs.
11833 However, for each CU + set of TUs that came from the same original DWO
11834 file, we can combine them back into a virtual DWO file to save space
11835 (fewer struct dwo_file objects to allocate). Remember that for really
11836 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
11838 std::string virtual_dwo_name
=
11839 string_printf ("virtual-dwo/%ld-%ld-%ld-%ld-%ld-%ld",
11840 (long) (sections
.abbrev_size
? sections
.abbrev_offset
: 0),
11841 (long) (sections
.line_size
? sections
.line_offset
: 0),
11842 (long) (sections
.loclists_size
? sections
.loclists_offset
: 0),
11843 (long) (sections
.str_offsets_size
11844 ? sections
.str_offsets_offset
: 0),
11845 (long) (sections
.macro_size
? sections
.macro_offset
: 0),
11846 (long) (sections
.rnglists_size
? sections
.rnglists_offset
: 0));
11847 /* Can we use an existing virtual DWO file? */
11848 dwo_file_slot
= lookup_dwo_file_slot (per_objfile
,
11849 virtual_dwo_name
.c_str (),
11851 /* Create one if necessary. */
11852 if (*dwo_file_slot
== NULL
)
11854 dwarf_read_debug_printf ("Creating virtual DWO: %s",
11855 virtual_dwo_name
.c_str ());
11857 dwo_file
= new struct dwo_file
;
11858 dwo_file
->dwo_name
= per_objfile
->objfile
->intern (virtual_dwo_name
);
11859 dwo_file
->comp_dir
= comp_dir
;
11860 dwo_file
->sections
.abbrev
=
11861 create_dwp_v2_or_v5_section (per_objfile
,
11862 &dwp_file
->sections
.abbrev
,
11863 sections
.abbrev_offset
,
11864 sections
.abbrev_size
);
11865 dwo_file
->sections
.line
=
11866 create_dwp_v2_or_v5_section (per_objfile
,
11867 &dwp_file
->sections
.line
,
11868 sections
.line_offset
, sections
.line_size
);
11869 dwo_file
->sections
.macro
=
11870 create_dwp_v2_or_v5_section (per_objfile
,
11871 &dwp_file
->sections
.macro
,
11872 sections
.macro_offset
,
11873 sections
.macro_size
);
11874 dwo_file
->sections
.loclists
=
11875 create_dwp_v2_or_v5_section (per_objfile
,
11876 &dwp_file
->sections
.loclists
,
11877 sections
.loclists_offset
,
11878 sections
.loclists_size
);
11879 dwo_file
->sections
.rnglists
=
11880 create_dwp_v2_or_v5_section (per_objfile
,
11881 &dwp_file
->sections
.rnglists
,
11882 sections
.rnglists_offset
,
11883 sections
.rnglists_size
);
11884 dwo_file
->sections
.str_offsets
=
11885 create_dwp_v2_or_v5_section (per_objfile
,
11886 &dwp_file
->sections
.str_offsets
,
11887 sections
.str_offsets_offset
,
11888 sections
.str_offsets_size
);
11889 /* The "str" section is global to the entire DWP file. */
11890 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
11891 /* The info or types section is assigned below to dwo_unit,
11892 there's no need to record it in dwo_file.
11893 Also, we can't simply record type sections in dwo_file because
11894 we record a pointer into the vector in dwo_unit. As we collect more
11895 types we'll grow the vector and eventually have to reallocate space
11896 for it, invalidating all copies of pointers into the previous
11898 *dwo_file_slot
= dwo_file
;
11902 dwarf_read_debug_printf ("Using existing virtual DWO: %s",
11903 virtual_dwo_name
.c_str ());
11905 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
11908 dwo_unit
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, struct dwo_unit
);
11909 dwo_unit
->dwo_file
= dwo_file
;
11910 dwo_unit
->signature
= signature
;
11912 = XOBNEW (&per_objfile
->per_bfd
->obstack
, struct dwarf2_section_info
);
11913 *dwo_unit
->section
= create_dwp_v2_or_v5_section (per_objfile
,
11914 &dwp_file
->sections
.info
,
11915 sections
.info_or_types_offset
,
11916 sections
.info_or_types_size
);
11917 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
11922 /* Lookup the DWO unit with SIGNATURE in DWP_FILE.
11923 Returns NULL if the signature isn't found. */
11925 static struct dwo_unit
*
11926 lookup_dwo_unit_in_dwp (dwarf2_per_objfile
*per_objfile
,
11927 struct dwp_file
*dwp_file
, const char *comp_dir
,
11928 ULONGEST signature
, int is_debug_types
)
11930 const struct dwp_hash_table
*dwp_htab
=
11931 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
11932 bfd
*dbfd
= dwp_file
->dbfd
.get ();
11933 uint32_t mask
= dwp_htab
->nr_slots
- 1;
11934 uint32_t hash
= signature
& mask
;
11935 uint32_t hash2
= ((signature
>> 32) & mask
) | 1;
11938 struct dwo_unit find_dwo_cu
;
11940 memset (&find_dwo_cu
, 0, sizeof (find_dwo_cu
));
11941 find_dwo_cu
.signature
= signature
;
11942 slot
= htab_find_slot (is_debug_types
11943 ? dwp_file
->loaded_tus
.get ()
11944 : dwp_file
->loaded_cus
.get (),
11945 &find_dwo_cu
, INSERT
);
11948 return (struct dwo_unit
*) *slot
;
11950 /* Use a for loop so that we don't loop forever on bad debug info. */
11951 for (i
= 0; i
< dwp_htab
->nr_slots
; ++i
)
11953 ULONGEST signature_in_table
;
11955 signature_in_table
=
11956 read_8_bytes (dbfd
, dwp_htab
->hash_table
+ hash
* sizeof (uint64_t));
11957 if (signature_in_table
== signature
)
11959 uint32_t unit_index
=
11960 read_4_bytes (dbfd
,
11961 dwp_htab
->unit_table
+ hash
* sizeof (uint32_t));
11963 if (dwp_file
->version
== 1)
11965 *slot
= create_dwo_unit_in_dwp_v1 (per_objfile
, dwp_file
,
11966 unit_index
, comp_dir
,
11967 signature
, is_debug_types
);
11969 else if (dwp_file
->version
== 2)
11971 *slot
= create_dwo_unit_in_dwp_v2 (per_objfile
, dwp_file
,
11972 unit_index
, comp_dir
,
11973 signature
, is_debug_types
);
11975 else /* version == 5 */
11977 *slot
= create_dwo_unit_in_dwp_v5 (per_objfile
, dwp_file
,
11978 unit_index
, comp_dir
,
11979 signature
, is_debug_types
);
11981 return (struct dwo_unit
*) *slot
;
11983 if (signature_in_table
== 0)
11985 hash
= (hash
+ hash2
) & mask
;
11988 error (_("Dwarf Error: bad DWP hash table, lookup didn't terminate"
11989 " [in module %s]"),
11993 /* Subroutine of open_dwo_file,open_dwp_file to simplify them.
11994 Open the file specified by FILE_NAME and hand it off to BFD for
11995 preliminary analysis. Return a newly initialized bfd *, which
11996 includes a canonicalized copy of FILE_NAME.
11997 If IS_DWP is TRUE, we're opening a DWP file, otherwise a DWO file.
11998 SEARCH_CWD is true if the current directory is to be searched.
11999 It will be searched before debug-file-directory.
12000 If successful, the file is added to the bfd include table of the
12001 objfile's bfd (see gdb_bfd_record_inclusion).
12002 If unable to find/open the file, return NULL.
12003 NOTE: This function is derived from symfile_bfd_open. */
12005 static gdb_bfd_ref_ptr
12006 try_open_dwop_file (dwarf2_per_objfile
*per_objfile
,
12007 const char *file_name
, int is_dwp
, int search_cwd
)
12010 /* Blech. OPF_TRY_CWD_FIRST also disables searching the path list if
12011 FILE_NAME contains a '/'. So we can't use it. Instead prepend "."
12012 to debug_file_directory. */
12013 const char *search_path
;
12014 static const char dirname_separator_string
[] = { DIRNAME_SEPARATOR
, '\0' };
12016 gdb::unique_xmalloc_ptr
<char> search_path_holder
;
12019 if (*debug_file_directory
!= '\0')
12021 search_path_holder
.reset (concat (".", dirname_separator_string
,
12022 debug_file_directory
,
12024 search_path
= search_path_holder
.get ();
12030 search_path
= debug_file_directory
;
12032 /* Add the path for the executable binary to the list of search paths. */
12033 std::string objfile_dir
= ldirname (objfile_name (per_objfile
->objfile
));
12034 search_path_holder
.reset (concat (objfile_dir
.c_str (),
12035 dirname_separator_string
,
12036 search_path
, nullptr));
12037 search_path
= search_path_holder
.get ();
12039 openp_flags flags
= OPF_RETURN_REALPATH
;
12041 flags
|= OPF_SEARCH_IN_PATH
;
12043 gdb::unique_xmalloc_ptr
<char> absolute_name
;
12044 desc
= openp (search_path
, flags
, file_name
,
12045 O_RDONLY
| O_BINARY
, &absolute_name
);
12049 gdb_bfd_ref_ptr
sym_bfd (gdb_bfd_open (absolute_name
.get (),
12051 if (sym_bfd
== NULL
)
12053 bfd_set_cacheable (sym_bfd
.get (), 1);
12055 if (!bfd_check_format (sym_bfd
.get (), bfd_object
))
12058 /* Success. Record the bfd as having been included by the objfile's bfd.
12059 This is important because things like demangled_names_hash lives in the
12060 objfile's per_bfd space and may have references to things like symbol
12061 names that live in the DWO/DWP file's per_bfd space. PR 16426. */
12062 gdb_bfd_record_inclusion (per_objfile
->objfile
->obfd
, sym_bfd
.get ());
12067 /* Try to open DWO file FILE_NAME.
12068 COMP_DIR is the DW_AT_comp_dir attribute.
12069 The result is the bfd handle of the file.
12070 If there is a problem finding or opening the file, return NULL.
12071 Upon success, the canonicalized path of the file is stored in the bfd,
12072 same as symfile_bfd_open. */
12074 static gdb_bfd_ref_ptr
12075 open_dwo_file (dwarf2_per_objfile
*per_objfile
,
12076 const char *file_name
, const char *comp_dir
)
12078 if (IS_ABSOLUTE_PATH (file_name
))
12079 return try_open_dwop_file (per_objfile
, file_name
,
12080 0 /*is_dwp*/, 0 /*search_cwd*/);
12082 /* Before trying the search path, try DWO_NAME in COMP_DIR. */
12084 if (comp_dir
!= NULL
)
12086 gdb::unique_xmalloc_ptr
<char> path_to_try
12087 (concat (comp_dir
, SLASH_STRING
, file_name
, (char *) NULL
));
12089 /* NOTE: If comp_dir is a relative path, this will also try the
12090 search path, which seems useful. */
12091 gdb_bfd_ref_ptr
abfd (try_open_dwop_file (per_objfile
, path_to_try
.get (),
12093 1 /*search_cwd*/));
12098 /* That didn't work, try debug-file-directory, which, despite its name,
12099 is a list of paths. */
12101 if (*debug_file_directory
== '\0')
12104 return try_open_dwop_file (per_objfile
, file_name
,
12105 0 /*is_dwp*/, 1 /*search_cwd*/);
12108 /* This function is mapped across the sections and remembers the offset and
12109 size of each of the DWO debugging sections we are interested in. */
12112 dwarf2_locate_dwo_sections (bfd
*abfd
, asection
*sectp
,
12113 dwo_sections
*dwo_sections
)
12115 const struct dwop_section_names
*names
= &dwop_section_names
;
12117 if (names
->abbrev_dwo
.matches (sectp
->name
))
12119 dwo_sections
->abbrev
.s
.section
= sectp
;
12120 dwo_sections
->abbrev
.size
= bfd_section_size (sectp
);
12122 else if (names
->info_dwo
.matches (sectp
->name
))
12124 dwo_sections
->info
.s
.section
= sectp
;
12125 dwo_sections
->info
.size
= bfd_section_size (sectp
);
12127 else if (names
->line_dwo
.matches (sectp
->name
))
12129 dwo_sections
->line
.s
.section
= sectp
;
12130 dwo_sections
->line
.size
= bfd_section_size (sectp
);
12132 else if (names
->loc_dwo
.matches (sectp
->name
))
12134 dwo_sections
->loc
.s
.section
= sectp
;
12135 dwo_sections
->loc
.size
= bfd_section_size (sectp
);
12137 else if (names
->loclists_dwo
.matches (sectp
->name
))
12139 dwo_sections
->loclists
.s
.section
= sectp
;
12140 dwo_sections
->loclists
.size
= bfd_section_size (sectp
);
12142 else if (names
->macinfo_dwo
.matches (sectp
->name
))
12144 dwo_sections
->macinfo
.s
.section
= sectp
;
12145 dwo_sections
->macinfo
.size
= bfd_section_size (sectp
);
12147 else if (names
->macro_dwo
.matches (sectp
->name
))
12149 dwo_sections
->macro
.s
.section
= sectp
;
12150 dwo_sections
->macro
.size
= bfd_section_size (sectp
);
12152 else if (names
->rnglists_dwo
.matches (sectp
->name
))
12154 dwo_sections
->rnglists
.s
.section
= sectp
;
12155 dwo_sections
->rnglists
.size
= bfd_section_size (sectp
);
12157 else if (names
->str_dwo
.matches (sectp
->name
))
12159 dwo_sections
->str
.s
.section
= sectp
;
12160 dwo_sections
->str
.size
= bfd_section_size (sectp
);
12162 else if (names
->str_offsets_dwo
.matches (sectp
->name
))
12164 dwo_sections
->str_offsets
.s
.section
= sectp
;
12165 dwo_sections
->str_offsets
.size
= bfd_section_size (sectp
);
12167 else if (names
->types_dwo
.matches (sectp
->name
))
12169 struct dwarf2_section_info type_section
;
12171 memset (&type_section
, 0, sizeof (type_section
));
12172 type_section
.s
.section
= sectp
;
12173 type_section
.size
= bfd_section_size (sectp
);
12174 dwo_sections
->types
.push_back (type_section
);
12178 /* Initialize the use of the DWO file specified by DWO_NAME and referenced
12179 by PER_CU. This is for the non-DWP case.
12180 The result is NULL if DWO_NAME can't be found. */
12182 static struct dwo_file
*
12183 open_and_init_dwo_file (dwarf2_cu
*cu
, const char *dwo_name
,
12184 const char *comp_dir
)
12186 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
12188 gdb_bfd_ref_ptr dbfd
= open_dwo_file (per_objfile
, dwo_name
, comp_dir
);
12191 dwarf_read_debug_printf ("DWO file not found: %s", dwo_name
);
12196 dwo_file_up
dwo_file (new struct dwo_file
);
12197 dwo_file
->dwo_name
= dwo_name
;
12198 dwo_file
->comp_dir
= comp_dir
;
12199 dwo_file
->dbfd
= std::move (dbfd
);
12201 for (asection
*sec
: gdb_bfd_sections (dwo_file
->dbfd
))
12202 dwarf2_locate_dwo_sections (dwo_file
->dbfd
.get (), sec
,
12203 &dwo_file
->sections
);
12205 create_cus_hash_table (per_objfile
, cu
, *dwo_file
, dwo_file
->sections
.info
,
12208 if (cu
->per_cu
->dwarf_version
< 5)
12210 create_debug_types_hash_table (per_objfile
, dwo_file
.get (),
12211 dwo_file
->sections
.types
, dwo_file
->tus
);
12215 create_debug_type_hash_table (per_objfile
, dwo_file
.get (),
12216 &dwo_file
->sections
.info
, dwo_file
->tus
,
12217 rcuh_kind::COMPILE
);
12220 dwarf_read_debug_printf ("DWO file found: %s", dwo_name
);
12222 return dwo_file
.release ();
12225 /* This function is mapped across the sections and remembers the offset and
12226 size of each of the DWP debugging sections common to version 1 and 2 that
12227 we are interested in. */
12230 dwarf2_locate_common_dwp_sections (bfd
*abfd
, asection
*sectp
,
12231 dwp_file
*dwp_file
)
12233 const struct dwop_section_names
*names
= &dwop_section_names
;
12234 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
12236 /* Record the ELF section number for later lookup: this is what the
12237 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
12238 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
12239 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
12241 /* Look for specific sections that we need. */
12242 if (names
->str_dwo
.matches (sectp
->name
))
12244 dwp_file
->sections
.str
.s
.section
= sectp
;
12245 dwp_file
->sections
.str
.size
= bfd_section_size (sectp
);
12247 else if (names
->cu_index
.matches (sectp
->name
))
12249 dwp_file
->sections
.cu_index
.s
.section
= sectp
;
12250 dwp_file
->sections
.cu_index
.size
= bfd_section_size (sectp
);
12252 else if (names
->tu_index
.matches (sectp
->name
))
12254 dwp_file
->sections
.tu_index
.s
.section
= sectp
;
12255 dwp_file
->sections
.tu_index
.size
= bfd_section_size (sectp
);
12259 /* This function is mapped across the sections and remembers the offset and
12260 size of each of the DWP version 2 debugging sections that we are interested
12261 in. This is split into a separate function because we don't know if we
12262 have version 1 or 2 or 5 until we parse the cu_index/tu_index sections. */
12265 dwarf2_locate_v2_dwp_sections (bfd
*abfd
, asection
*sectp
, void *dwp_file_ptr
)
12267 struct dwp_file
*dwp_file
= (struct dwp_file
*) dwp_file_ptr
;
12268 const struct dwop_section_names
*names
= &dwop_section_names
;
12269 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
12271 /* Record the ELF section number for later lookup: this is what the
12272 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
12273 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
12274 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
12276 /* Look for specific sections that we need. */
12277 if (names
->abbrev_dwo
.matches (sectp
->name
))
12279 dwp_file
->sections
.abbrev
.s
.section
= sectp
;
12280 dwp_file
->sections
.abbrev
.size
= bfd_section_size (sectp
);
12282 else if (names
->info_dwo
.matches (sectp
->name
))
12284 dwp_file
->sections
.info
.s
.section
= sectp
;
12285 dwp_file
->sections
.info
.size
= bfd_section_size (sectp
);
12287 else if (names
->line_dwo
.matches (sectp
->name
))
12289 dwp_file
->sections
.line
.s
.section
= sectp
;
12290 dwp_file
->sections
.line
.size
= bfd_section_size (sectp
);
12292 else if (names
->loc_dwo
.matches (sectp
->name
))
12294 dwp_file
->sections
.loc
.s
.section
= sectp
;
12295 dwp_file
->sections
.loc
.size
= bfd_section_size (sectp
);
12297 else if (names
->macinfo_dwo
.matches (sectp
->name
))
12299 dwp_file
->sections
.macinfo
.s
.section
= sectp
;
12300 dwp_file
->sections
.macinfo
.size
= bfd_section_size (sectp
);
12302 else if (names
->macro_dwo
.matches (sectp
->name
))
12304 dwp_file
->sections
.macro
.s
.section
= sectp
;
12305 dwp_file
->sections
.macro
.size
= bfd_section_size (sectp
);
12307 else if (names
->str_offsets_dwo
.matches (sectp
->name
))
12309 dwp_file
->sections
.str_offsets
.s
.section
= sectp
;
12310 dwp_file
->sections
.str_offsets
.size
= bfd_section_size (sectp
);
12312 else if (names
->types_dwo
.matches (sectp
->name
))
12314 dwp_file
->sections
.types
.s
.section
= sectp
;
12315 dwp_file
->sections
.types
.size
= bfd_section_size (sectp
);
12319 /* This function is mapped across the sections and remembers the offset and
12320 size of each of the DWP version 5 debugging sections that we are interested
12321 in. This is split into a separate function because we don't know if we
12322 have version 1 or 2 or 5 until we parse the cu_index/tu_index sections. */
12325 dwarf2_locate_v5_dwp_sections (bfd
*abfd
, asection
*sectp
, void *dwp_file_ptr
)
12327 struct dwp_file
*dwp_file
= (struct dwp_file
*) dwp_file_ptr
;
12328 const struct dwop_section_names
*names
= &dwop_section_names
;
12329 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
12331 /* Record the ELF section number for later lookup: this is what the
12332 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
12333 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
12334 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
12336 /* Look for specific sections that we need. */
12337 if (names
->abbrev_dwo
.matches (sectp
->name
))
12339 dwp_file
->sections
.abbrev
.s
.section
= sectp
;
12340 dwp_file
->sections
.abbrev
.size
= bfd_section_size (sectp
);
12342 else if (names
->info_dwo
.matches (sectp
->name
))
12344 dwp_file
->sections
.info
.s
.section
= sectp
;
12345 dwp_file
->sections
.info
.size
= bfd_section_size (sectp
);
12347 else if (names
->line_dwo
.matches (sectp
->name
))
12349 dwp_file
->sections
.line
.s
.section
= sectp
;
12350 dwp_file
->sections
.line
.size
= bfd_section_size (sectp
);
12352 else if (names
->loclists_dwo
.matches (sectp
->name
))
12354 dwp_file
->sections
.loclists
.s
.section
= sectp
;
12355 dwp_file
->sections
.loclists
.size
= bfd_section_size (sectp
);
12357 else if (names
->macro_dwo
.matches (sectp
->name
))
12359 dwp_file
->sections
.macro
.s
.section
= sectp
;
12360 dwp_file
->sections
.macro
.size
= bfd_section_size (sectp
);
12362 else if (names
->rnglists_dwo
.matches (sectp
->name
))
12364 dwp_file
->sections
.rnglists
.s
.section
= sectp
;
12365 dwp_file
->sections
.rnglists
.size
= bfd_section_size (sectp
);
12367 else if (names
->str_offsets_dwo
.matches (sectp
->name
))
12369 dwp_file
->sections
.str_offsets
.s
.section
= sectp
;
12370 dwp_file
->sections
.str_offsets
.size
= bfd_section_size (sectp
);
12374 /* Hash function for dwp_file loaded CUs/TUs. */
12377 hash_dwp_loaded_cutus (const void *item
)
12379 const struct dwo_unit
*dwo_unit
= (const struct dwo_unit
*) item
;
12381 /* This drops the top 32 bits of the signature, but is ok for a hash. */
12382 return dwo_unit
->signature
;
12385 /* Equality function for dwp_file loaded CUs/TUs. */
12388 eq_dwp_loaded_cutus (const void *a
, const void *b
)
12390 const struct dwo_unit
*dua
= (const struct dwo_unit
*) a
;
12391 const struct dwo_unit
*dub
= (const struct dwo_unit
*) b
;
12393 return dua
->signature
== dub
->signature
;
12396 /* Allocate a hash table for dwp_file loaded CUs/TUs. */
12399 allocate_dwp_loaded_cutus_table ()
12401 return htab_up (htab_create_alloc (3,
12402 hash_dwp_loaded_cutus
,
12403 eq_dwp_loaded_cutus
,
12404 NULL
, xcalloc
, xfree
));
12407 /* Try to open DWP file FILE_NAME.
12408 The result is the bfd handle of the file.
12409 If there is a problem finding or opening the file, return NULL.
12410 Upon success, the canonicalized path of the file is stored in the bfd,
12411 same as symfile_bfd_open. */
12413 static gdb_bfd_ref_ptr
12414 open_dwp_file (dwarf2_per_objfile
*per_objfile
, const char *file_name
)
12416 gdb_bfd_ref_ptr
abfd (try_open_dwop_file (per_objfile
, file_name
,
12418 1 /*search_cwd*/));
12422 /* Work around upstream bug 15652.
12423 http://sourceware.org/bugzilla/show_bug.cgi?id=15652
12424 [Whether that's a "bug" is debatable, but it is getting in our way.]
12425 We have no real idea where the dwp file is, because gdb's realpath-ing
12426 of the executable's path may have discarded the needed info.
12427 [IWBN if the dwp file name was recorded in the executable, akin to
12428 .gnu_debuglink, but that doesn't exist yet.]
12429 Strip the directory from FILE_NAME and search again. */
12430 if (*debug_file_directory
!= '\0')
12432 /* Don't implicitly search the current directory here.
12433 If the user wants to search "." to handle this case,
12434 it must be added to debug-file-directory. */
12435 return try_open_dwop_file (per_objfile
, lbasename (file_name
),
12443 /* Initialize the use of the DWP file for the current objfile.
12444 By convention the name of the DWP file is ${objfile}.dwp.
12445 The result is NULL if it can't be found. */
12447 static std::unique_ptr
<struct dwp_file
>
12448 open_and_init_dwp_file (dwarf2_per_objfile
*per_objfile
)
12450 struct objfile
*objfile
= per_objfile
->objfile
;
12452 /* Try to find first .dwp for the binary file before any symbolic links
12455 /* If the objfile is a debug file, find the name of the real binary
12456 file and get the name of dwp file from there. */
12457 std::string dwp_name
;
12458 if (objfile
->separate_debug_objfile_backlink
!= NULL
)
12460 struct objfile
*backlink
= objfile
->separate_debug_objfile_backlink
;
12461 const char *backlink_basename
= lbasename (backlink
->original_name
);
12463 dwp_name
= ldirname (objfile
->original_name
) + SLASH_STRING
+ backlink_basename
;
12466 dwp_name
= objfile
->original_name
;
12468 dwp_name
+= ".dwp";
12470 gdb_bfd_ref_ptr
dbfd (open_dwp_file (per_objfile
, dwp_name
.c_str ()));
12472 && strcmp (objfile
->original_name
, objfile_name (objfile
)) != 0)
12474 /* Try to find .dwp for the binary file after gdb_realpath resolving. */
12475 dwp_name
= objfile_name (objfile
);
12476 dwp_name
+= ".dwp";
12477 dbfd
= open_dwp_file (per_objfile
, dwp_name
.c_str ());
12482 dwarf_read_debug_printf ("DWP file not found: %s", dwp_name
.c_str ());
12484 return std::unique_ptr
<dwp_file
> ();
12487 const char *name
= bfd_get_filename (dbfd
.get ());
12488 std::unique_ptr
<struct dwp_file
> dwp_file
12489 (new struct dwp_file (name
, std::move (dbfd
)));
12491 dwp_file
->num_sections
= elf_numsections (dwp_file
->dbfd
);
12492 dwp_file
->elf_sections
=
12493 OBSTACK_CALLOC (&per_objfile
->per_bfd
->obstack
,
12494 dwp_file
->num_sections
, asection
*);
12496 for (asection
*sec
: gdb_bfd_sections (dwp_file
->dbfd
))
12497 dwarf2_locate_common_dwp_sections (dwp_file
->dbfd
.get (), sec
,
12500 dwp_file
->cus
= create_dwp_hash_table (per_objfile
, dwp_file
.get (), 0);
12502 dwp_file
->tus
= create_dwp_hash_table (per_objfile
, dwp_file
.get (), 1);
12504 /* The DWP file version is stored in the hash table. Oh well. */
12505 if (dwp_file
->cus
&& dwp_file
->tus
12506 && dwp_file
->cus
->version
!= dwp_file
->tus
->version
)
12508 /* Technically speaking, we should try to limp along, but this is
12509 pretty bizarre. We use pulongest here because that's the established
12510 portability solution (e.g, we cannot use %u for uint32_t). */
12511 error (_("Dwarf Error: DWP file CU version %s doesn't match"
12512 " TU version %s [in DWP file %s]"),
12513 pulongest (dwp_file
->cus
->version
),
12514 pulongest (dwp_file
->tus
->version
), dwp_name
.c_str ());
12518 dwp_file
->version
= dwp_file
->cus
->version
;
12519 else if (dwp_file
->tus
)
12520 dwp_file
->version
= dwp_file
->tus
->version
;
12522 dwp_file
->version
= 2;
12524 for (asection
*sec
: gdb_bfd_sections (dwp_file
->dbfd
))
12526 if (dwp_file
->version
== 2)
12527 dwarf2_locate_v2_dwp_sections (dwp_file
->dbfd
.get (), sec
,
12530 dwarf2_locate_v5_dwp_sections (dwp_file
->dbfd
.get (), sec
,
12534 dwp_file
->loaded_cus
= allocate_dwp_loaded_cutus_table ();
12535 dwp_file
->loaded_tus
= allocate_dwp_loaded_cutus_table ();
12537 dwarf_read_debug_printf ("DWP file found: %s", dwp_file
->name
);
12538 dwarf_read_debug_printf (" %s CUs, %s TUs",
12539 pulongest (dwp_file
->cus
? dwp_file
->cus
->nr_units
: 0),
12540 pulongest (dwp_file
->tus
? dwp_file
->tus
->nr_units
: 0));
12545 /* Wrapper around open_and_init_dwp_file, only open it once. */
12547 static struct dwp_file
*
12548 get_dwp_file (dwarf2_per_objfile
*per_objfile
)
12550 if (!per_objfile
->per_bfd
->dwp_checked
)
12552 per_objfile
->per_bfd
->dwp_file
= open_and_init_dwp_file (per_objfile
);
12553 per_objfile
->per_bfd
->dwp_checked
= 1;
12555 return per_objfile
->per_bfd
->dwp_file
.get ();
12558 /* Subroutine of lookup_dwo_comp_unit, lookup_dwo_type_unit.
12559 Look up the CU/TU with signature SIGNATURE, either in DWO file DWO_NAME
12560 or in the DWP file for the objfile, referenced by THIS_UNIT.
12561 If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
12562 IS_DEBUG_TYPES is non-zero if reading a TU, otherwise read a CU.
12564 This is called, for example, when wanting to read a variable with a
12565 complex location. Therefore we don't want to do file i/o for every call.
12566 Therefore we don't want to look for a DWO file on every call.
12567 Therefore we first see if we've already seen SIGNATURE in a DWP file,
12568 then we check if we've already seen DWO_NAME, and only THEN do we check
12571 The result is a pointer to the dwo_unit object or NULL if we didn't find it
12572 (dwo_id mismatch or couldn't find the DWO/DWP file). */
12574 static struct dwo_unit
*
12575 lookup_dwo_cutu (dwarf2_cu
*cu
, const char *dwo_name
, const char *comp_dir
,
12576 ULONGEST signature
, int is_debug_types
)
12578 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
12579 struct objfile
*objfile
= per_objfile
->objfile
;
12580 const char *kind
= is_debug_types
? "TU" : "CU";
12581 void **dwo_file_slot
;
12582 struct dwo_file
*dwo_file
;
12583 struct dwp_file
*dwp_file
;
12585 /* First see if there's a DWP file.
12586 If we have a DWP file but didn't find the DWO inside it, don't
12587 look for the original DWO file. It makes gdb behave differently
12588 depending on whether one is debugging in the build tree. */
12590 dwp_file
= get_dwp_file (per_objfile
);
12591 if (dwp_file
!= NULL
)
12593 const struct dwp_hash_table
*dwp_htab
=
12594 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12596 if (dwp_htab
!= NULL
)
12598 struct dwo_unit
*dwo_cutu
=
12599 lookup_dwo_unit_in_dwp (per_objfile
, dwp_file
, comp_dir
, signature
,
12602 if (dwo_cutu
!= NULL
)
12604 dwarf_read_debug_printf ("Virtual DWO %s %s found: @%s",
12605 kind
, hex_string (signature
),
12606 host_address_to_string (dwo_cutu
));
12614 /* No DWP file, look for the DWO file. */
12616 dwo_file_slot
= lookup_dwo_file_slot (per_objfile
, dwo_name
, comp_dir
);
12617 if (*dwo_file_slot
== NULL
)
12619 /* Read in the file and build a table of the CUs/TUs it contains. */
12620 *dwo_file_slot
= open_and_init_dwo_file (cu
, dwo_name
, comp_dir
);
12622 /* NOTE: This will be NULL if unable to open the file. */
12623 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
12625 if (dwo_file
!= NULL
)
12627 struct dwo_unit
*dwo_cutu
= NULL
;
12629 if (is_debug_types
&& dwo_file
->tus
)
12631 struct dwo_unit find_dwo_cutu
;
12633 memset (&find_dwo_cutu
, 0, sizeof (find_dwo_cutu
));
12634 find_dwo_cutu
.signature
= signature
;
12636 = (struct dwo_unit
*) htab_find (dwo_file
->tus
.get (),
12639 else if (!is_debug_types
&& dwo_file
->cus
)
12641 struct dwo_unit find_dwo_cutu
;
12643 memset (&find_dwo_cutu
, 0, sizeof (find_dwo_cutu
));
12644 find_dwo_cutu
.signature
= signature
;
12645 dwo_cutu
= (struct dwo_unit
*)htab_find (dwo_file
->cus
.get (),
12649 if (dwo_cutu
!= NULL
)
12651 dwarf_read_debug_printf ("DWO %s %s(%s) found: @%s",
12652 kind
, dwo_name
, hex_string (signature
),
12653 host_address_to_string (dwo_cutu
));
12660 /* We didn't find it. This could mean a dwo_id mismatch, or
12661 someone deleted the DWO/DWP file, or the search path isn't set up
12662 correctly to find the file. */
12664 dwarf_read_debug_printf ("DWO %s %s(%s) not found",
12665 kind
, dwo_name
, hex_string (signature
));
12667 /* This is a warning and not a complaint because it can be caused by
12668 pilot error (e.g., user accidentally deleting the DWO). */
12670 /* Print the name of the DWP file if we looked there, helps the user
12671 better diagnose the problem. */
12672 std::string dwp_text
;
12674 if (dwp_file
!= NULL
)
12675 dwp_text
= string_printf (" [in DWP file %s]",
12676 lbasename (dwp_file
->name
));
12678 warning (_("Could not find DWO %s %s(%s)%s referenced by %s at offset %s"
12679 " [in module %s]"),
12680 kind
, dwo_name
, hex_string (signature
), dwp_text
.c_str (), kind
,
12681 sect_offset_str (cu
->per_cu
->sect_off
), objfile_name (objfile
));
12686 /* Lookup the DWO CU DWO_NAME/SIGNATURE referenced from THIS_CU.
12687 See lookup_dwo_cutu_unit for details. */
12689 static struct dwo_unit
*
12690 lookup_dwo_comp_unit (dwarf2_cu
*cu
, const char *dwo_name
, const char *comp_dir
,
12691 ULONGEST signature
)
12693 gdb_assert (!cu
->per_cu
->is_debug_types
);
12695 return lookup_dwo_cutu (cu
, dwo_name
, comp_dir
, signature
, 0);
12698 /* Lookup the DWO TU DWO_NAME/SIGNATURE referenced from THIS_TU.
12699 See lookup_dwo_cutu_unit for details. */
12701 static struct dwo_unit
*
12702 lookup_dwo_type_unit (dwarf2_cu
*cu
, const char *dwo_name
, const char *comp_dir
)
12704 gdb_assert (cu
->per_cu
->is_debug_types
);
12706 signatured_type
*sig_type
= (signatured_type
*) cu
->per_cu
;
12708 return lookup_dwo_cutu (cu
, dwo_name
, comp_dir
, sig_type
->signature
, 1);
12711 /* Traversal function for queue_and_load_all_dwo_tus. */
12714 queue_and_load_dwo_tu (void **slot
, void *info
)
12716 struct dwo_unit
*dwo_unit
= (struct dwo_unit
*) *slot
;
12717 dwarf2_cu
*cu
= (dwarf2_cu
*) info
;
12718 ULONGEST signature
= dwo_unit
->signature
;
12719 signatured_type
*sig_type
= lookup_dwo_signatured_type (cu
, signature
);
12721 if (sig_type
!= NULL
)
12723 /* We pass NULL for DEPENDENT_CU because we don't yet know if there's
12724 a real dependency of PER_CU on SIG_TYPE. That is detected later
12725 while processing PER_CU. */
12726 if (maybe_queue_comp_unit (NULL
, sig_type
, cu
->per_objfile
,
12728 load_full_type_unit (sig_type
, cu
->per_objfile
);
12729 cu
->per_cu
->imported_symtabs_push (sig_type
);
12735 /* Queue all TUs contained in the DWO of CU to be read in.
12736 The DWO may have the only definition of the type, though it may not be
12737 referenced anywhere in PER_CU. Thus we have to load *all* its TUs.
12738 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
12741 queue_and_load_all_dwo_tus (dwarf2_cu
*cu
)
12743 struct dwo_unit
*dwo_unit
;
12744 struct dwo_file
*dwo_file
;
12746 gdb_assert (cu
!= nullptr);
12747 gdb_assert (!cu
->per_cu
->is_debug_types
);
12748 gdb_assert (get_dwp_file (cu
->per_objfile
) == nullptr);
12750 dwo_unit
= cu
->dwo_unit
;
12751 gdb_assert (dwo_unit
!= NULL
);
12753 dwo_file
= dwo_unit
->dwo_file
;
12754 if (dwo_file
->tus
!= NULL
)
12755 htab_traverse_noresize (dwo_file
->tus
.get (), queue_and_load_dwo_tu
, cu
);
12758 /* Read in various DIEs. */
12760 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
12761 Inherit only the children of the DW_AT_abstract_origin DIE not being
12762 already referenced by DW_AT_abstract_origin from the children of the
12766 inherit_abstract_dies (struct die_info
*die
, struct dwarf2_cu
*cu
)
12768 struct die_info
*child_die
;
12769 sect_offset
*offsetp
;
12770 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
12771 struct die_info
*origin_die
;
12772 /* Iterator of the ORIGIN_DIE children. */
12773 struct die_info
*origin_child_die
;
12774 struct attribute
*attr
;
12775 struct dwarf2_cu
*origin_cu
;
12776 struct pending
**origin_previous_list_in_scope
;
12778 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
12782 /* Note that following die references may follow to a die in a
12786 origin_die
= follow_die_ref (die
, attr
, &origin_cu
);
12788 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
12790 origin_previous_list_in_scope
= origin_cu
->list_in_scope
;
12791 origin_cu
->list_in_scope
= cu
->list_in_scope
;
12793 if (die
->tag
!= origin_die
->tag
12794 && !(die
->tag
== DW_TAG_inlined_subroutine
12795 && origin_die
->tag
== DW_TAG_subprogram
))
12796 complaint (_("DIE %s and its abstract origin %s have different tags"),
12797 sect_offset_str (die
->sect_off
),
12798 sect_offset_str (origin_die
->sect_off
));
12800 /* Find if the concrete and abstract trees are structurally the
12801 same. This is a shallow traversal and it is not bullet-proof;
12802 the compiler can trick the debugger into believing that the trees
12803 are isomorphic, whereas they actually are not. However, the
12804 likelyhood of this happening is pretty low, and a full-fledged
12805 check would be an overkill. */
12806 bool are_isomorphic
= true;
12807 die_info
*concrete_child
= die
->child
;
12808 die_info
*abstract_child
= origin_die
->child
;
12809 while (concrete_child
!= nullptr || abstract_child
!= nullptr)
12811 if (concrete_child
== nullptr
12812 || abstract_child
== nullptr
12813 || concrete_child
->tag
!= abstract_child
->tag
)
12815 are_isomorphic
= false;
12819 concrete_child
= concrete_child
->sibling
;
12820 abstract_child
= abstract_child
->sibling
;
12823 /* Walk the origin's children in parallel to the concrete children.
12824 This helps match an origin child in case the debug info misses
12825 DW_AT_abstract_origin attributes. Keep in mind that the abstract
12826 origin tree may not have the same tree structure as the concrete
12828 die_info
*corresponding_abstract_child
12829 = are_isomorphic
? origin_die
->child
: nullptr;
12831 std::vector
<sect_offset
> offsets
;
12833 for (child_die
= die
->child
;
12834 child_die
&& child_die
->tag
;
12835 child_die
= child_die
->sibling
)
12837 struct die_info
*child_origin_die
;
12838 struct dwarf2_cu
*child_origin_cu
;
12840 /* We are trying to process concrete instance entries:
12841 DW_TAG_call_site DIEs indeed have a DW_AT_abstract_origin tag, but
12842 it's not relevant to our analysis here. i.e. detecting DIEs that are
12843 present in the abstract instance but not referenced in the concrete
12845 if (child_die
->tag
== DW_TAG_call_site
12846 || child_die
->tag
== DW_TAG_GNU_call_site
)
12848 if (are_isomorphic
)
12849 corresponding_abstract_child
12850 = corresponding_abstract_child
->sibling
;
12854 /* For each CHILD_DIE, find the corresponding child of
12855 ORIGIN_DIE. If there is more than one layer of
12856 DW_AT_abstract_origin, follow them all; there shouldn't be,
12857 but GCC versions at least through 4.4 generate this (GCC PR
12859 child_origin_die
= child_die
;
12860 child_origin_cu
= cu
;
12863 attr
= dwarf2_attr (child_origin_die
, DW_AT_abstract_origin
,
12867 child_origin_die
= follow_die_ref (child_origin_die
, attr
,
12871 /* If missing DW_AT_abstract_origin, try the corresponding child
12872 of the origin. Clang emits such lexical scopes. */
12873 if (child_origin_die
== child_die
12874 && dwarf2_attr (child_die
, DW_AT_abstract_origin
, cu
) == nullptr
12876 && child_die
->tag
== DW_TAG_lexical_block
)
12877 child_origin_die
= corresponding_abstract_child
;
12879 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
12880 counterpart may exist. */
12881 if (child_origin_die
!= child_die
)
12883 if (child_die
->tag
!= child_origin_die
->tag
12884 && !(child_die
->tag
== DW_TAG_inlined_subroutine
12885 && child_origin_die
->tag
== DW_TAG_subprogram
))
12886 complaint (_("Child DIE %s and its abstract origin %s have "
12888 sect_offset_str (child_die
->sect_off
),
12889 sect_offset_str (child_origin_die
->sect_off
));
12890 if (child_origin_die
->parent
!= origin_die
)
12891 complaint (_("Child DIE %s and its abstract origin %s have "
12892 "different parents"),
12893 sect_offset_str (child_die
->sect_off
),
12894 sect_offset_str (child_origin_die
->sect_off
));
12896 offsets
.push_back (child_origin_die
->sect_off
);
12899 if (are_isomorphic
)
12900 corresponding_abstract_child
= corresponding_abstract_child
->sibling
;
12902 std::sort (offsets
.begin (), offsets
.end ());
12903 sect_offset
*offsets_end
= offsets
.data () + offsets
.size ();
12904 for (offsetp
= offsets
.data () + 1; offsetp
< offsets_end
; offsetp
++)
12905 if (offsetp
[-1] == *offsetp
)
12906 complaint (_("Multiple children of DIE %s refer "
12907 "to DIE %s as their abstract origin"),
12908 sect_offset_str (die
->sect_off
), sect_offset_str (*offsetp
));
12910 offsetp
= offsets
.data ();
12911 origin_child_die
= origin_die
->child
;
12912 while (origin_child_die
&& origin_child_die
->tag
)
12914 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
12915 while (offsetp
< offsets_end
12916 && *offsetp
< origin_child_die
->sect_off
)
12918 if (offsetp
>= offsets_end
12919 || *offsetp
> origin_child_die
->sect_off
)
12921 /* Found that ORIGIN_CHILD_DIE is really not referenced.
12922 Check whether we're already processing ORIGIN_CHILD_DIE.
12923 This can happen with mutually referenced abstract_origins.
12925 if (!origin_child_die
->in_process
)
12926 process_die (origin_child_die
, origin_cu
);
12928 origin_child_die
= origin_child_die
->sibling
;
12930 origin_cu
->list_in_scope
= origin_previous_list_in_scope
;
12932 if (cu
!= origin_cu
)
12933 compute_delayed_physnames (origin_cu
);
12937 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
12939 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
12940 struct gdbarch
*gdbarch
= objfile
->arch ();
12941 struct context_stack
*newobj
;
12944 struct die_info
*child_die
;
12945 struct attribute
*attr
, *call_line
, *call_file
;
12947 CORE_ADDR baseaddr
;
12948 struct block
*block
;
12949 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
12950 std::vector
<struct symbol
*> template_args
;
12951 struct template_symbol
*templ_func
= NULL
;
12955 /* If we do not have call site information, we can't show the
12956 caller of this inlined function. That's too confusing, so
12957 only use the scope for local variables. */
12958 call_line
= dwarf2_attr (die
, DW_AT_call_line
, cu
);
12959 call_file
= dwarf2_attr (die
, DW_AT_call_file
, cu
);
12960 if (call_line
== NULL
|| call_file
== NULL
)
12962 read_lexical_block_scope (die
, cu
);
12967 baseaddr
= objfile
->text_section_offset ();
12969 name
= dwarf2_name (die
, cu
);
12971 /* Ignore functions with missing or empty names. These are actually
12972 illegal according to the DWARF standard. */
12975 complaint (_("missing name for subprogram DIE at %s"),
12976 sect_offset_str (die
->sect_off
));
12980 /* Ignore functions with missing or invalid low and high pc attributes. */
12981 if (dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
)
12982 <= PC_BOUNDS_INVALID
)
12984 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
12985 if (attr
== nullptr || !attr
->as_boolean ())
12986 complaint (_("cannot get low and high bounds "
12987 "for subprogram DIE at %s"),
12988 sect_offset_str (die
->sect_off
));
12992 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
12993 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
12995 /* If we have any template arguments, then we must allocate a
12996 different sort of symbol. */
12997 for (child_die
= die
->child
; child_die
; child_die
= child_die
->sibling
)
12999 if (child_die
->tag
== DW_TAG_template_type_param
13000 || child_die
->tag
== DW_TAG_template_value_param
)
13002 templ_func
= new (&objfile
->objfile_obstack
) template_symbol
;
13003 templ_func
->subclass
= SYMBOL_TEMPLATE
;
13008 gdb_assert (cu
->get_builder () != nullptr);
13009 newobj
= cu
->get_builder ()->push_context (0, lowpc
);
13010 newobj
->name
= new_symbol (die
, read_type_die (die
, cu
), cu
,
13011 (struct symbol
*) templ_func
);
13013 if (dwarf2_flag_true_p (die
, DW_AT_main_subprogram
, cu
))
13014 set_objfile_main_name (objfile
, newobj
->name
->linkage_name (),
13017 /* If there is a location expression for DW_AT_frame_base, record
13019 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
13020 if (attr
!= nullptr)
13021 dwarf2_symbol_mark_computed (attr
, newobj
->name
, cu
, 1);
13023 /* If there is a location for the static link, record it. */
13024 newobj
->static_link
= NULL
;
13025 attr
= dwarf2_attr (die
, DW_AT_static_link
, cu
);
13026 if (attr
!= nullptr)
13028 newobj
->static_link
13029 = XOBNEW (&objfile
->objfile_obstack
, struct dynamic_prop
);
13030 attr_to_dynamic_prop (attr
, die
, cu
, newobj
->static_link
,
13034 cu
->list_in_scope
= cu
->get_builder ()->get_local_symbols ();
13036 if (die
->child
!= NULL
)
13038 child_die
= die
->child
;
13039 while (child_die
&& child_die
->tag
)
13041 if (child_die
->tag
== DW_TAG_template_type_param
13042 || child_die
->tag
== DW_TAG_template_value_param
)
13044 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
13047 template_args
.push_back (arg
);
13050 process_die (child_die
, cu
);
13051 child_die
= child_die
->sibling
;
13055 inherit_abstract_dies (die
, cu
);
13057 /* If we have a DW_AT_specification, we might need to import using
13058 directives from the context of the specification DIE. See the
13059 comment in determine_prefix. */
13060 if (cu
->per_cu
->lang
== language_cplus
13061 && dwarf2_attr (die
, DW_AT_specification
, cu
))
13063 struct dwarf2_cu
*spec_cu
= cu
;
13064 struct die_info
*spec_die
= die_specification (die
, &spec_cu
);
13068 child_die
= spec_die
->child
;
13069 while (child_die
&& child_die
->tag
)
13071 if (child_die
->tag
== DW_TAG_imported_module
)
13072 process_die (child_die
, spec_cu
);
13073 child_die
= child_die
->sibling
;
13076 /* In some cases, GCC generates specification DIEs that
13077 themselves contain DW_AT_specification attributes. */
13078 spec_die
= die_specification (spec_die
, &spec_cu
);
13082 struct context_stack cstk
= cu
->get_builder ()->pop_context ();
13083 /* Make a block for the local symbols within. */
13084 block
= cu
->get_builder ()->finish_block (cstk
.name
, cstk
.old_blocks
,
13085 cstk
.static_link
, lowpc
, highpc
);
13087 /* For C++, set the block's scope. */
13088 if ((cu
->per_cu
->lang
== language_cplus
13089 || cu
->per_cu
->lang
== language_fortran
13090 || cu
->per_cu
->lang
== language_d
13091 || cu
->per_cu
->lang
== language_rust
)
13092 && cu
->processing_has_namespace_info
)
13093 block_set_scope (block
, determine_prefix (die
, cu
),
13094 &objfile
->objfile_obstack
);
13096 /* If we have address ranges, record them. */
13097 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
13099 gdbarch_make_symbol_special (gdbarch
, cstk
.name
, objfile
);
13101 /* Attach template arguments to function. */
13102 if (!template_args
.empty ())
13104 gdb_assert (templ_func
!= NULL
);
13106 templ_func
->n_template_arguments
= template_args
.size ();
13107 templ_func
->template_arguments
13108 = XOBNEWVEC (&objfile
->objfile_obstack
, struct symbol
*,
13109 templ_func
->n_template_arguments
);
13110 memcpy (templ_func
->template_arguments
,
13111 template_args
.data (),
13112 (templ_func
->n_template_arguments
* sizeof (struct symbol
*)));
13114 /* Make sure that the symtab is set on the new symbols. Even
13115 though they don't appear in this symtab directly, other parts
13116 of gdb assume that symbols do, and this is reasonably
13118 for (symbol
*sym
: template_args
)
13119 symbol_set_symtab (sym
, symbol_symtab (templ_func
));
13122 /* In C++, we can have functions nested inside functions (e.g., when
13123 a function declares a class that has methods). This means that
13124 when we finish processing a function scope, we may need to go
13125 back to building a containing block's symbol lists. */
13126 *cu
->get_builder ()->get_local_symbols () = cstk
.locals
;
13127 cu
->get_builder ()->set_local_using_directives (cstk
.local_using_directives
);
13129 /* If we've finished processing a top-level function, subsequent
13130 symbols go in the file symbol list. */
13131 if (cu
->get_builder ()->outermost_context_p ())
13132 cu
->list_in_scope
= cu
->get_builder ()->get_file_symbols ();
13135 /* Process all the DIES contained within a lexical block scope. Start
13136 a new scope, process the dies, and then close the scope. */
13139 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13141 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
13142 struct gdbarch
*gdbarch
= objfile
->arch ();
13143 CORE_ADDR lowpc
, highpc
;
13144 struct die_info
*child_die
;
13145 CORE_ADDR baseaddr
;
13147 baseaddr
= objfile
->text_section_offset ();
13149 /* Ignore blocks with missing or invalid low and high pc attributes. */
13150 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
13151 as multiple lexical blocks? Handling children in a sane way would
13152 be nasty. Might be easier to properly extend generic blocks to
13153 describe ranges. */
13154 switch (dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
13156 case PC_BOUNDS_NOT_PRESENT
:
13157 /* DW_TAG_lexical_block has no attributes, process its children as if
13158 there was no wrapping by that DW_TAG_lexical_block.
13159 GCC does no longer produces such DWARF since GCC r224161. */
13160 for (child_die
= die
->child
;
13161 child_die
!= NULL
&& child_die
->tag
;
13162 child_die
= child_die
->sibling
)
13164 /* We might already be processing this DIE. This can happen
13165 in an unusual circumstance -- where a subroutine A
13166 appears lexically in another subroutine B, but A actually
13167 inlines B. The recursion is broken here, rather than in
13168 inherit_abstract_dies, because it seems better to simply
13169 drop concrete children here. */
13170 if (!child_die
->in_process
)
13171 process_die (child_die
, cu
);
13174 case PC_BOUNDS_INVALID
:
13177 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
13178 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
13180 cu
->get_builder ()->push_context (0, lowpc
);
13181 if (die
->child
!= NULL
)
13183 child_die
= die
->child
;
13184 while (child_die
&& child_die
->tag
)
13186 process_die (child_die
, cu
);
13187 child_die
= child_die
->sibling
;
13190 inherit_abstract_dies (die
, cu
);
13191 struct context_stack cstk
= cu
->get_builder ()->pop_context ();
13193 if (*cu
->get_builder ()->get_local_symbols () != NULL
13194 || (*cu
->get_builder ()->get_local_using_directives ()) != NULL
)
13196 struct block
*block
13197 = cu
->get_builder ()->finish_block (0, cstk
.old_blocks
, NULL
,
13198 cstk
.start_addr
, highpc
);
13200 /* Note that recording ranges after traversing children, as we
13201 do here, means that recording a parent's ranges entails
13202 walking across all its children's ranges as they appear in
13203 the address map, which is quadratic behavior.
13205 It would be nicer to record the parent's ranges before
13206 traversing its children, simply overriding whatever you find
13207 there. But since we don't even decide whether to create a
13208 block until after we've traversed its children, that's hard
13210 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
13212 *cu
->get_builder ()->get_local_symbols () = cstk
.locals
;
13213 cu
->get_builder ()->set_local_using_directives (cstk
.local_using_directives
);
13216 /* Read in DW_TAG_call_site and insert it to CU->call_site_htab. */
13219 read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13221 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
13222 struct objfile
*objfile
= per_objfile
->objfile
;
13223 struct gdbarch
*gdbarch
= objfile
->arch ();
13224 CORE_ADDR pc
, baseaddr
;
13225 struct attribute
*attr
;
13226 struct call_site
*call_site
, call_site_local
;
13229 struct die_info
*child_die
;
13231 baseaddr
= objfile
->text_section_offset ();
13233 attr
= dwarf2_attr (die
, DW_AT_call_return_pc
, cu
);
13236 /* This was a pre-DWARF-5 GNU extension alias
13237 for DW_AT_call_return_pc. */
13238 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
13242 complaint (_("missing DW_AT_call_return_pc for DW_TAG_call_site "
13243 "DIE %s [in module %s]"),
13244 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
13247 pc
= attr
->as_address () + baseaddr
;
13248 pc
= gdbarch_adjust_dwarf2_addr (gdbarch
, pc
);
13250 if (cu
->call_site_htab
== NULL
)
13251 cu
->call_site_htab
= htab_create_alloc_ex (16, core_addr_hash
, core_addr_eq
,
13252 NULL
, &objfile
->objfile_obstack
,
13253 hashtab_obstack_allocate
, NULL
);
13254 call_site_local
.pc
= pc
;
13255 slot
= htab_find_slot (cu
->call_site_htab
, &call_site_local
, INSERT
);
13258 complaint (_("Duplicate PC %s for DW_TAG_call_site "
13259 "DIE %s [in module %s]"),
13260 paddress (gdbarch
, pc
), sect_offset_str (die
->sect_off
),
13261 objfile_name (objfile
));
13265 /* Count parameters at the caller. */
13268 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
13269 child_die
= child_die
->sibling
)
13271 if (child_die
->tag
!= DW_TAG_call_site_parameter
13272 && child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
13274 complaint (_("Tag %d is not DW_TAG_call_site_parameter in "
13275 "DW_TAG_call_site child DIE %s [in module %s]"),
13276 child_die
->tag
, sect_offset_str (child_die
->sect_off
),
13277 objfile_name (objfile
));
13285 = ((struct call_site
*)
13286 obstack_alloc (&objfile
->objfile_obstack
,
13287 sizeof (*call_site
)
13288 + (sizeof (*call_site
->parameter
) * (nparams
- 1))));
13290 memset (call_site
, 0, sizeof (*call_site
) - sizeof (*call_site
->parameter
));
13291 call_site
->pc
= pc
;
13293 if (dwarf2_flag_true_p (die
, DW_AT_call_tail_call
, cu
)
13294 || dwarf2_flag_true_p (die
, DW_AT_GNU_tail_call
, cu
))
13296 struct die_info
*func_die
;
13298 /* Skip also over DW_TAG_inlined_subroutine. */
13299 for (func_die
= die
->parent
;
13300 func_die
&& func_die
->tag
!= DW_TAG_subprogram
13301 && func_die
->tag
!= DW_TAG_subroutine_type
;
13302 func_die
= func_die
->parent
);
13304 /* DW_AT_call_all_calls is a superset
13305 of DW_AT_call_all_tail_calls. */
13307 && !dwarf2_flag_true_p (func_die
, DW_AT_call_all_calls
, cu
)
13308 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_call_sites
, cu
)
13309 && !dwarf2_flag_true_p (func_die
, DW_AT_call_all_tail_calls
, cu
)
13310 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_tail_call_sites
, cu
))
13312 /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
13313 not complete. But keep CALL_SITE for look ups via call_site_htab,
13314 both the initial caller containing the real return address PC and
13315 the final callee containing the current PC of a chain of tail
13316 calls do not need to have the tail call list complete. But any
13317 function candidate for a virtual tail call frame searched via
13318 TYPE_TAIL_CALL_LIST must have the tail call list complete to be
13319 determined unambiguously. */
13323 struct type
*func_type
= NULL
;
13326 func_type
= get_die_type (func_die
, cu
);
13327 if (func_type
!= NULL
)
13329 gdb_assert (func_type
->code () == TYPE_CODE_FUNC
);
13331 /* Enlist this call site to the function. */
13332 call_site
->tail_call_next
= TYPE_TAIL_CALL_LIST (func_type
);
13333 TYPE_TAIL_CALL_LIST (func_type
) = call_site
;
13336 complaint (_("Cannot find function owning DW_TAG_call_site "
13337 "DIE %s [in module %s]"),
13338 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
13342 attr
= dwarf2_attr (die
, DW_AT_call_target
, cu
);
13344 attr
= dwarf2_attr (die
, DW_AT_GNU_call_site_target
, cu
);
13346 attr
= dwarf2_attr (die
, DW_AT_call_origin
, cu
);
13349 /* This was a pre-DWARF-5 GNU extension alias for DW_AT_call_origin. */
13350 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
13352 SET_FIELD_DWARF_BLOCK (call_site
->target
, NULL
);
13353 if (!attr
|| (attr
->form_is_block () && attr
->as_block ()->size
== 0))
13354 /* Keep NULL DWARF_BLOCK. */;
13355 else if (attr
->form_is_block ())
13357 struct dwarf2_locexpr_baton
*dlbaton
;
13358 struct dwarf_block
*block
= attr
->as_block ();
13360 dlbaton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
13361 dlbaton
->data
= block
->data
;
13362 dlbaton
->size
= block
->size
;
13363 dlbaton
->per_objfile
= per_objfile
;
13364 dlbaton
->per_cu
= cu
->per_cu
;
13366 SET_FIELD_DWARF_BLOCK (call_site
->target
, dlbaton
);
13368 else if (attr
->form_is_ref ())
13370 struct dwarf2_cu
*target_cu
= cu
;
13371 struct die_info
*target_die
;
13373 target_die
= follow_die_ref (die
, attr
, &target_cu
);
13374 gdb_assert (target_cu
->per_objfile
->objfile
== objfile
);
13375 if (die_is_declaration (target_die
, target_cu
))
13377 const char *target_physname
;
13379 /* Prefer the mangled name; otherwise compute the demangled one. */
13380 target_physname
= dw2_linkage_name (target_die
, target_cu
);
13381 if (target_physname
== NULL
)
13382 target_physname
= dwarf2_physname (NULL
, target_die
, target_cu
);
13383 if (target_physname
== NULL
)
13384 complaint (_("DW_AT_call_target target DIE has invalid "
13385 "physname, for referencing DIE %s [in module %s]"),
13386 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
13388 SET_FIELD_PHYSNAME (call_site
->target
, target_physname
);
13394 /* DW_AT_entry_pc should be preferred. */
13395 if (dwarf2_get_pc_bounds (target_die
, &lowpc
, NULL
, target_cu
, NULL
)
13396 <= PC_BOUNDS_INVALID
)
13397 complaint (_("DW_AT_call_target target DIE has invalid "
13398 "low pc, for referencing DIE %s [in module %s]"),
13399 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
13402 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
13403 SET_FIELD_PHYSADDR (call_site
->target
, lowpc
);
13408 complaint (_("DW_TAG_call_site DW_AT_call_target is neither "
13409 "block nor reference, for DIE %s [in module %s]"),
13410 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
13412 call_site
->per_cu
= cu
->per_cu
;
13413 call_site
->per_objfile
= per_objfile
;
13415 for (child_die
= die
->child
;
13416 child_die
&& child_die
->tag
;
13417 child_die
= child_die
->sibling
)
13419 struct call_site_parameter
*parameter
;
13420 struct attribute
*loc
, *origin
;
13422 if (child_die
->tag
!= DW_TAG_call_site_parameter
13423 && child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
13425 /* Already printed the complaint above. */
13429 gdb_assert (call_site
->parameter_count
< nparams
);
13430 parameter
= &call_site
->parameter
[call_site
->parameter_count
];
13432 /* DW_AT_location specifies the register number or DW_AT_abstract_origin
13433 specifies DW_TAG_formal_parameter. Value of the data assumed for the
13434 register is contained in DW_AT_call_value. */
13436 loc
= dwarf2_attr (child_die
, DW_AT_location
, cu
);
13437 origin
= dwarf2_attr (child_die
, DW_AT_call_parameter
, cu
);
13438 if (origin
== NULL
)
13440 /* This was a pre-DWARF-5 GNU extension alias
13441 for DW_AT_call_parameter. */
13442 origin
= dwarf2_attr (child_die
, DW_AT_abstract_origin
, cu
);
13444 if (loc
== NULL
&& origin
!= NULL
&& origin
->form_is_ref ())
13446 parameter
->kind
= CALL_SITE_PARAMETER_PARAM_OFFSET
;
13448 sect_offset sect_off
= origin
->get_ref_die_offset ();
13449 if (!cu
->header
.offset_in_cu_p (sect_off
))
13451 /* As DW_OP_GNU_parameter_ref uses CU-relative offset this
13452 binding can be done only inside one CU. Such referenced DIE
13453 therefore cannot be even moved to DW_TAG_partial_unit. */
13454 complaint (_("DW_AT_call_parameter offset is not in CU for "
13455 "DW_TAG_call_site child DIE %s [in module %s]"),
13456 sect_offset_str (child_die
->sect_off
),
13457 objfile_name (objfile
));
13460 parameter
->u
.param_cu_off
13461 = (cu_offset
) (sect_off
- cu
->header
.sect_off
);
13463 else if (loc
== NULL
|| origin
!= NULL
|| !loc
->form_is_block ())
13465 complaint (_("No DW_FORM_block* DW_AT_location for "
13466 "DW_TAG_call_site child DIE %s [in module %s]"),
13467 sect_offset_str (child_die
->sect_off
), objfile_name (objfile
));
13472 struct dwarf_block
*block
= loc
->as_block ();
13474 parameter
->u
.dwarf_reg
= dwarf_block_to_dwarf_reg
13475 (block
->data
, &block
->data
[block
->size
]);
13476 if (parameter
->u
.dwarf_reg
!= -1)
13477 parameter
->kind
= CALL_SITE_PARAMETER_DWARF_REG
;
13478 else if (dwarf_block_to_sp_offset (gdbarch
, block
->data
,
13479 &block
->data
[block
->size
],
13480 ¶meter
->u
.fb_offset
))
13481 parameter
->kind
= CALL_SITE_PARAMETER_FB_OFFSET
;
13484 complaint (_("Only single DW_OP_reg or DW_OP_fbreg is supported "
13485 "for DW_FORM_block* DW_AT_location is supported for "
13486 "DW_TAG_call_site child DIE %s "
13488 sect_offset_str (child_die
->sect_off
),
13489 objfile_name (objfile
));
13494 attr
= dwarf2_attr (child_die
, DW_AT_call_value
, cu
);
13496 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_value
, cu
);
13497 if (attr
== NULL
|| !attr
->form_is_block ())
13499 complaint (_("No DW_FORM_block* DW_AT_call_value for "
13500 "DW_TAG_call_site child DIE %s [in module %s]"),
13501 sect_offset_str (child_die
->sect_off
),
13502 objfile_name (objfile
));
13506 struct dwarf_block
*block
= attr
->as_block ();
13507 parameter
->value
= block
->data
;
13508 parameter
->value_size
= block
->size
;
13510 /* Parameters are not pre-cleared by memset above. */
13511 parameter
->data_value
= NULL
;
13512 parameter
->data_value_size
= 0;
13513 call_site
->parameter_count
++;
13515 attr
= dwarf2_attr (child_die
, DW_AT_call_data_value
, cu
);
13517 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_data_value
, cu
);
13518 if (attr
!= nullptr)
13520 if (!attr
->form_is_block ())
13521 complaint (_("No DW_FORM_block* DW_AT_call_data_value for "
13522 "DW_TAG_call_site child DIE %s [in module %s]"),
13523 sect_offset_str (child_die
->sect_off
),
13524 objfile_name (objfile
));
13527 block
= attr
->as_block ();
13528 parameter
->data_value
= block
->data
;
13529 parameter
->data_value_size
= block
->size
;
13535 /* Helper function for read_variable. If DIE represents a virtual
13536 table, then return the type of the concrete object that is
13537 associated with the virtual table. Otherwise, return NULL. */
13539 static struct type
*
13540 rust_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
13542 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
13546 /* Find the type DIE. */
13547 struct die_info
*type_die
= NULL
;
13548 struct dwarf2_cu
*type_cu
= cu
;
13550 if (attr
->form_is_ref ())
13551 type_die
= follow_die_ref (die
, attr
, &type_cu
);
13552 if (type_die
== NULL
)
13555 if (dwarf2_attr (type_die
, DW_AT_containing_type
, type_cu
) == NULL
)
13557 return die_containing_type (type_die
, type_cu
);
13560 /* Read a variable (DW_TAG_variable) DIE and create a new symbol. */
13563 read_variable (struct die_info
*die
, struct dwarf2_cu
*cu
)
13565 struct rust_vtable_symbol
*storage
= NULL
;
13567 if (cu
->per_cu
->lang
== language_rust
)
13569 struct type
*containing_type
= rust_containing_type (die
, cu
);
13571 if (containing_type
!= NULL
)
13573 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
13575 storage
= new (&objfile
->objfile_obstack
) rust_vtable_symbol
;
13576 storage
->concrete_type
= containing_type
;
13577 storage
->subclass
= SYMBOL_RUST_VTABLE
;
13581 struct symbol
*res
= new_symbol (die
, NULL
, cu
, storage
);
13582 struct attribute
*abstract_origin
13583 = dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
13584 struct attribute
*loc
= dwarf2_attr (die
, DW_AT_location
, cu
);
13585 if (res
== NULL
&& loc
&& abstract_origin
)
13587 /* We have a variable without a name, but with a location and an abstract
13588 origin. This may be a concrete instance of an abstract variable
13589 referenced from an DW_OP_GNU_variable_value, so save it to find it back
13591 struct dwarf2_cu
*origin_cu
= cu
;
13592 struct die_info
*origin_die
13593 = follow_die_ref (die
, abstract_origin
, &origin_cu
);
13594 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
13595 per_objfile
->per_bfd
->abstract_to_concrete
13596 [origin_die
->sect_off
].push_back (die
->sect_off
);
13600 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET
13601 reading .debug_rnglists.
13602 Callback's type should be:
13603 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
13604 Return true if the attributes are present and valid, otherwise,
13607 template <typename Callback
>
13609 dwarf2_rnglists_process (unsigned offset
, struct dwarf2_cu
*cu
,
13610 dwarf_tag tag
, Callback
&&callback
)
13612 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
13613 struct objfile
*objfile
= per_objfile
->objfile
;
13614 bfd
*obfd
= objfile
->obfd
;
13615 /* Base address selection entry. */
13616 gdb::optional
<CORE_ADDR
> base
;
13617 const gdb_byte
*buffer
;
13618 CORE_ADDR baseaddr
;
13619 bool overflow
= false;
13620 ULONGEST addr_index
;
13621 struct dwarf2_section_info
*rnglists_section
;
13623 base
= cu
->base_address
;
13624 rnglists_section
= cu_debug_rnglists_section (cu
, tag
);
13625 rnglists_section
->read (objfile
);
13627 if (offset
>= rnglists_section
->size
)
13629 complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
13633 buffer
= rnglists_section
->buffer
+ offset
;
13635 baseaddr
= objfile
->text_section_offset ();
13639 /* Initialize it due to a false compiler warning. */
13640 CORE_ADDR range_beginning
= 0, range_end
= 0;
13641 const gdb_byte
*buf_end
= (rnglists_section
->buffer
13642 + rnglists_section
->size
);
13643 unsigned int bytes_read
;
13645 if (buffer
== buf_end
)
13650 const auto rlet
= static_cast<enum dwarf_range_list_entry
>(*buffer
++);
13653 case DW_RLE_end_of_list
:
13655 case DW_RLE_base_address
:
13656 if (buffer
+ cu
->header
.addr_size
> buf_end
)
13661 base
= cu
->header
.read_address (obfd
, buffer
, &bytes_read
);
13662 buffer
+= bytes_read
;
13664 case DW_RLE_base_addressx
:
13665 addr_index
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
13666 buffer
+= bytes_read
;
13667 base
= read_addr_index (cu
, addr_index
);
13669 case DW_RLE_start_length
:
13670 if (buffer
+ cu
->header
.addr_size
> buf_end
)
13675 range_beginning
= cu
->header
.read_address (obfd
, buffer
,
13677 buffer
+= bytes_read
;
13678 range_end
= (range_beginning
13679 + read_unsigned_leb128 (obfd
, buffer
, &bytes_read
));
13680 buffer
+= bytes_read
;
13681 if (buffer
> buf_end
)
13687 case DW_RLE_startx_length
:
13688 addr_index
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
13689 buffer
+= bytes_read
;
13690 range_beginning
= read_addr_index (cu
, addr_index
);
13691 if (buffer
> buf_end
)
13696 range_end
= (range_beginning
13697 + read_unsigned_leb128 (obfd
, buffer
, &bytes_read
));
13698 buffer
+= bytes_read
;
13700 case DW_RLE_offset_pair
:
13701 range_beginning
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
13702 buffer
+= bytes_read
;
13703 if (buffer
> buf_end
)
13708 range_end
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
13709 buffer
+= bytes_read
;
13710 if (buffer
> buf_end
)
13716 case DW_RLE_start_end
:
13717 if (buffer
+ 2 * cu
->header
.addr_size
> buf_end
)
13722 range_beginning
= cu
->header
.read_address (obfd
, buffer
,
13724 buffer
+= bytes_read
;
13725 range_end
= cu
->header
.read_address (obfd
, buffer
, &bytes_read
);
13726 buffer
+= bytes_read
;
13728 case DW_RLE_startx_endx
:
13729 addr_index
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
13730 buffer
+= bytes_read
;
13731 range_beginning
= read_addr_index (cu
, addr_index
);
13732 if (buffer
> buf_end
)
13737 addr_index
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
13738 buffer
+= bytes_read
;
13739 range_end
= read_addr_index (cu
, addr_index
);
13742 complaint (_("Invalid .debug_rnglists data (no base address)"));
13745 if (rlet
== DW_RLE_end_of_list
|| overflow
)
13747 if (rlet
== DW_RLE_base_address
)
13750 if (range_beginning
> range_end
)
13752 /* Inverted range entries are invalid. */
13753 complaint (_("Invalid .debug_rnglists data (inverted range)"));
13757 /* Empty range entries have no effect. */
13758 if (range_beginning
== range_end
)
13761 /* Only DW_RLE_offset_pair needs the base address added. */
13762 if (rlet
== DW_RLE_offset_pair
)
13764 if (!base
.has_value ())
13766 /* We have no valid base address for the DW_RLE_offset_pair. */
13767 complaint (_("Invalid .debug_rnglists data (no base address for "
13768 "DW_RLE_offset_pair)"));
13772 range_beginning
+= *base
;
13773 range_end
+= *base
;
13776 /* A not-uncommon case of bad debug info.
13777 Don't pollute the addrmap with bad data. */
13778 if (range_beginning
+ baseaddr
== 0
13779 && !per_objfile
->per_bfd
->has_section_at_zero
)
13781 complaint (_(".debug_rnglists entry has start address of zero"
13782 " [in module %s]"), objfile_name (objfile
));
13786 callback (range_beginning
, range_end
);
13791 complaint (_("Offset %d is not terminated "
13792 "for DW_AT_ranges attribute"),
13800 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET reading .debug_ranges.
13801 Callback's type should be:
13802 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
13803 Return 1 if the attributes are present and valid, otherwise, return 0. */
13805 template <typename Callback
>
13807 dwarf2_ranges_process (unsigned offset
, struct dwarf2_cu
*cu
, dwarf_tag tag
,
13808 Callback
&&callback
)
13810 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
13811 struct objfile
*objfile
= per_objfile
->objfile
;
13812 struct comp_unit_head
*cu_header
= &cu
->header
;
13813 bfd
*obfd
= objfile
->obfd
;
13814 unsigned int addr_size
= cu_header
->addr_size
;
13815 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
13816 /* Base address selection entry. */
13817 gdb::optional
<CORE_ADDR
> base
;
13818 unsigned int dummy
;
13819 const gdb_byte
*buffer
;
13820 CORE_ADDR baseaddr
;
13822 if (cu_header
->version
>= 5)
13823 return dwarf2_rnglists_process (offset
, cu
, tag
, callback
);
13825 base
= cu
->base_address
;
13827 per_objfile
->per_bfd
->ranges
.read (objfile
);
13828 if (offset
>= per_objfile
->per_bfd
->ranges
.size
)
13830 complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
13834 buffer
= per_objfile
->per_bfd
->ranges
.buffer
+ offset
;
13836 baseaddr
= objfile
->text_section_offset ();
13840 CORE_ADDR range_beginning
, range_end
;
13842 range_beginning
= cu
->header
.read_address (obfd
, buffer
, &dummy
);
13843 buffer
+= addr_size
;
13844 range_end
= cu
->header
.read_address (obfd
, buffer
, &dummy
);
13845 buffer
+= addr_size
;
13846 offset
+= 2 * addr_size
;
13848 /* An end of list marker is a pair of zero addresses. */
13849 if (range_beginning
== 0 && range_end
== 0)
13850 /* Found the end of list entry. */
13853 /* Each base address selection entry is a pair of 2 values.
13854 The first is the largest possible address, the second is
13855 the base address. Check for a base address here. */
13856 if ((range_beginning
& mask
) == mask
)
13858 /* If we found the largest possible address, then we already
13859 have the base address in range_end. */
13864 if (!base
.has_value ())
13866 /* We have no valid base address for the ranges
13868 complaint (_("Invalid .debug_ranges data (no base address)"));
13872 if (range_beginning
> range_end
)
13874 /* Inverted range entries are invalid. */
13875 complaint (_("Invalid .debug_ranges data (inverted range)"));
13879 /* Empty range entries have no effect. */
13880 if (range_beginning
== range_end
)
13883 range_beginning
+= *base
;
13884 range_end
+= *base
;
13886 /* A not-uncommon case of bad debug info.
13887 Don't pollute the addrmap with bad data. */
13888 if (range_beginning
+ baseaddr
== 0
13889 && !per_objfile
->per_bfd
->has_section_at_zero
)
13891 complaint (_(".debug_ranges entry has start address of zero"
13892 " [in module %s]"), objfile_name (objfile
));
13896 callback (range_beginning
, range_end
);
13902 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
13903 Return 1 if the attributes are present and valid, otherwise, return 0.
13904 If RANGES_PST is not NULL we should set up the `psymtabs_addrmap'. */
13907 dwarf2_ranges_read (unsigned offset
, CORE_ADDR
*low_return
,
13908 CORE_ADDR
*high_return
, struct dwarf2_cu
*cu
,
13909 dwarf2_psymtab
*ranges_pst
, dwarf_tag tag
)
13911 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
13912 dwarf2_per_bfd
*per_bfd
= cu
->per_objfile
->per_bfd
;
13913 struct gdbarch
*gdbarch
= objfile
->arch ();
13914 const CORE_ADDR baseaddr
= objfile
->text_section_offset ();
13917 CORE_ADDR high
= 0;
13920 retval
= dwarf2_ranges_process (offset
, cu
, tag
,
13921 [&] (CORE_ADDR range_beginning
, CORE_ADDR range_end
)
13923 if (ranges_pst
!= NULL
)
13928 lowpc
= (gdbarch_adjust_dwarf2_addr (gdbarch
,
13929 range_beginning
+ baseaddr
)
13931 highpc
= (gdbarch_adjust_dwarf2_addr (gdbarch
,
13932 range_end
+ baseaddr
)
13934 addrmap_set_empty (per_bfd
->partial_symtabs
->psymtabs_addrmap
,
13935 lowpc
, highpc
- 1, ranges_pst
);
13938 /* FIXME: This is recording everything as a low-high
13939 segment of consecutive addresses. We should have a
13940 data structure for discontiguous block ranges
13944 low
= range_beginning
;
13950 if (range_beginning
< low
)
13951 low
= range_beginning
;
13952 if (range_end
> high
)
13960 /* If the first entry is an end-of-list marker, the range
13961 describes an empty scope, i.e. no instructions. */
13967 *high_return
= high
;
13971 /* Get low and high pc attributes from a die. See enum pc_bounds_kind
13972 definition for the return value. *LOWPC and *HIGHPC are set iff
13973 neither PC_BOUNDS_NOT_PRESENT nor PC_BOUNDS_INVALID are returned. */
13975 static enum pc_bounds_kind
13976 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
13977 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
,
13978 dwarf2_psymtab
*pst
)
13980 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
13981 struct attribute
*attr
;
13982 struct attribute
*attr_high
;
13984 CORE_ADDR high
= 0;
13985 enum pc_bounds_kind ret
;
13987 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
13990 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
13991 if (attr
!= nullptr)
13993 low
= attr
->as_address ();
13994 high
= attr_high
->as_address ();
13995 if (cu
->header
.version
>= 4 && attr_high
->form_is_constant ())
13999 /* Found high w/o low attribute. */
14000 return PC_BOUNDS_INVALID
;
14002 /* Found consecutive range of addresses. */
14003 ret
= PC_BOUNDS_HIGH_LOW
;
14007 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
14008 if (attr
!= nullptr && attr
->form_is_unsigned ())
14010 /* Offset in the .debug_ranges or .debug_rnglist section (depending
14011 on DWARF version). */
14012 ULONGEST ranges_offset
= attr
->as_unsigned ();
14014 /* See dwarf2_cu::gnu_ranges_base's doc for why we might want to add
14016 if (die
->tag
!= DW_TAG_compile_unit
)
14017 ranges_offset
+= cu
->gnu_ranges_base
;
14019 /* Value of the DW_AT_ranges attribute is the offset in the
14020 .debug_ranges section. */
14021 if (!dwarf2_ranges_read (ranges_offset
, &low
, &high
, cu
, pst
,
14023 return PC_BOUNDS_INVALID
;
14024 /* Found discontinuous range of addresses. */
14025 ret
= PC_BOUNDS_RANGES
;
14028 return PC_BOUNDS_NOT_PRESENT
;
14031 /* partial_die_info::read has also the strict LOW < HIGH requirement. */
14033 return PC_BOUNDS_INVALID
;
14035 /* When using the GNU linker, .gnu.linkonce. sections are used to
14036 eliminate duplicate copies of functions and vtables and such.
14037 The linker will arbitrarily choose one and discard the others.
14038 The AT_*_pc values for such functions refer to local labels in
14039 these sections. If the section from that file was discarded, the
14040 labels are not in the output, so the relocs get a value of 0.
14041 If this is a discarded function, mark the pc bounds as invalid,
14042 so that GDB will ignore it. */
14043 if (low
== 0 && !per_objfile
->per_bfd
->has_section_at_zero
)
14044 return PC_BOUNDS_INVALID
;
14052 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
14053 its low and high PC addresses. Do nothing if these addresses could not
14054 be determined. Otherwise, set LOWPC to the low address if it is smaller,
14055 and HIGHPC to the high address if greater than HIGHPC. */
14058 dwarf2_get_subprogram_pc_bounds (struct die_info
*die
,
14059 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
14060 struct dwarf2_cu
*cu
)
14062 CORE_ADDR low
, high
;
14063 struct die_info
*child
= die
->child
;
14065 if (dwarf2_get_pc_bounds (die
, &low
, &high
, cu
, NULL
) >= PC_BOUNDS_RANGES
)
14067 *lowpc
= std::min (*lowpc
, low
);
14068 *highpc
= std::max (*highpc
, high
);
14071 /* If the language does not allow nested subprograms (either inside
14072 subprograms or lexical blocks), we're done. */
14073 if (cu
->per_cu
->lang
!= language_ada
)
14076 /* Check all the children of the given DIE. If it contains nested
14077 subprograms, then check their pc bounds. Likewise, we need to
14078 check lexical blocks as well, as they may also contain subprogram
14080 while (child
&& child
->tag
)
14082 if (child
->tag
== DW_TAG_subprogram
14083 || child
->tag
== DW_TAG_lexical_block
)
14084 dwarf2_get_subprogram_pc_bounds (child
, lowpc
, highpc
, cu
);
14085 child
= child
->sibling
;
14089 /* Get the low and high pc's represented by the scope DIE, and store
14090 them in *LOWPC and *HIGHPC. If the correct values can't be
14091 determined, set *LOWPC to -1 and *HIGHPC to 0. */
14094 get_scope_pc_bounds (struct die_info
*die
,
14095 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
14096 struct dwarf2_cu
*cu
)
14098 CORE_ADDR best_low
= (CORE_ADDR
) -1;
14099 CORE_ADDR best_high
= (CORE_ADDR
) 0;
14100 CORE_ADDR current_low
, current_high
;
14102 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
, NULL
)
14103 >= PC_BOUNDS_RANGES
)
14105 best_low
= current_low
;
14106 best_high
= current_high
;
14110 struct die_info
*child
= die
->child
;
14112 while (child
&& child
->tag
)
14114 switch (child
->tag
) {
14115 case DW_TAG_subprogram
:
14116 dwarf2_get_subprogram_pc_bounds (child
, &best_low
, &best_high
, cu
);
14118 case DW_TAG_namespace
:
14119 case DW_TAG_module
:
14120 /* FIXME: carlton/2004-01-16: Should we do this for
14121 DW_TAG_class_type/DW_TAG_structure_type, too? I think
14122 that current GCC's always emit the DIEs corresponding
14123 to definitions of methods of classes as children of a
14124 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
14125 the DIEs giving the declarations, which could be
14126 anywhere). But I don't see any reason why the
14127 standards says that they have to be there. */
14128 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
14130 if (current_low
!= ((CORE_ADDR
) -1))
14132 best_low
= std::min (best_low
, current_low
);
14133 best_high
= std::max (best_high
, current_high
);
14141 child
= child
->sibling
;
14146 *highpc
= best_high
;
14149 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
14153 dwarf2_record_block_ranges (struct die_info
*die
, struct block
*block
,
14154 CORE_ADDR baseaddr
, struct dwarf2_cu
*cu
)
14156 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
14157 struct gdbarch
*gdbarch
= objfile
->arch ();
14158 struct attribute
*attr
;
14159 struct attribute
*attr_high
;
14161 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
14164 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
14165 if (attr
!= nullptr)
14167 CORE_ADDR low
= attr
->as_address ();
14168 CORE_ADDR high
= attr_high
->as_address ();
14170 if (cu
->header
.version
>= 4 && attr_high
->form_is_constant ())
14173 low
= gdbarch_adjust_dwarf2_addr (gdbarch
, low
+ baseaddr
);
14174 high
= gdbarch_adjust_dwarf2_addr (gdbarch
, high
+ baseaddr
);
14175 cu
->get_builder ()->record_block_range (block
, low
, high
- 1);
14179 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
14180 if (attr
!= nullptr && attr
->form_is_unsigned ())
14182 /* Offset in the .debug_ranges or .debug_rnglist section (depending
14183 on DWARF version). */
14184 ULONGEST ranges_offset
= attr
->as_unsigned ();
14186 /* See dwarf2_cu::gnu_ranges_base's doc for why we might want to add
14188 if (die
->tag
!= DW_TAG_compile_unit
)
14189 ranges_offset
+= cu
->gnu_ranges_base
;
14191 std::vector
<blockrange
> blockvec
;
14192 dwarf2_ranges_process (ranges_offset
, cu
, die
->tag
,
14193 [&] (CORE_ADDR start
, CORE_ADDR end
)
14197 start
= gdbarch_adjust_dwarf2_addr (gdbarch
, start
);
14198 end
= gdbarch_adjust_dwarf2_addr (gdbarch
, end
);
14199 cu
->get_builder ()->record_block_range (block
, start
, end
- 1);
14200 blockvec
.emplace_back (start
, end
);
14203 BLOCK_RANGES(block
) = make_blockranges (objfile
, blockvec
);
14207 /* Check whether the producer field indicates either of GCC < 4.6, or the
14208 Intel C/C++ compiler, and cache the result in CU. */
14211 check_producer (struct dwarf2_cu
*cu
)
14215 if (cu
->producer
== NULL
)
14217 /* For unknown compilers expect their behavior is DWARF version
14220 GCC started to support .debug_types sections by -gdwarf-4 since
14221 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
14222 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
14223 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
14224 interpreted incorrectly by GDB now - GCC PR debug/48229. */
14226 else if (producer_is_gcc (cu
->producer
, &major
, &minor
))
14228 cu
->producer_is_gxx_lt_4_6
= major
< 4 || (major
== 4 && minor
< 6);
14229 cu
->producer_is_gcc_lt_4_3
= major
< 4 || (major
== 4 && minor
< 3);
14231 else if (producer_is_icc (cu
->producer
, &major
, &minor
))
14233 cu
->producer_is_icc
= true;
14234 cu
->producer_is_icc_lt_14
= major
< 14;
14236 else if (startswith (cu
->producer
, "CodeWarrior S12/L-ISA"))
14237 cu
->producer_is_codewarrior
= true;
14240 /* For other non-GCC compilers, expect their behavior is DWARF version
14244 cu
->checked_producer
= true;
14247 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
14248 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
14249 during 4.6.0 experimental. */
14252 producer_is_gxx_lt_4_6 (struct dwarf2_cu
*cu
)
14254 if (!cu
->checked_producer
)
14255 check_producer (cu
);
14257 return cu
->producer_is_gxx_lt_4_6
;
14261 /* Codewarrior (at least as of version 5.0.40) generates dwarf line information
14262 with incorrect is_stmt attributes. */
14265 producer_is_codewarrior (struct dwarf2_cu
*cu
)
14267 if (!cu
->checked_producer
)
14268 check_producer (cu
);
14270 return cu
->producer_is_codewarrior
;
14273 /* Return the accessibility of DIE, as given by DW_AT_accessibility.
14274 If that attribute is not available, return the appropriate
14277 static enum dwarf_access_attribute
14278 dwarf2_access_attribute (struct die_info
*die
, struct dwarf2_cu
*cu
)
14280 attribute
*attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
14281 if (attr
!= nullptr)
14283 LONGEST value
= attr
->constant_value (-1);
14284 if (value
== DW_ACCESS_public
14285 || value
== DW_ACCESS_protected
14286 || value
== DW_ACCESS_private
)
14287 return (dwarf_access_attribute
) value
;
14288 complaint (_("Unhandled DW_AT_accessibility value (%s)"),
14292 if (cu
->header
.version
< 3 || producer_is_gxx_lt_4_6 (cu
))
14294 /* The default DWARF 2 accessibility for members is public, the default
14295 accessibility for inheritance is private. */
14297 if (die
->tag
!= DW_TAG_inheritance
)
14298 return DW_ACCESS_public
;
14300 return DW_ACCESS_private
;
14304 /* DWARF 3+ defines the default accessibility a different way. The same
14305 rules apply now for DW_TAG_inheritance as for the members and it only
14306 depends on the container kind. */
14308 if (die
->parent
->tag
== DW_TAG_class_type
)
14309 return DW_ACCESS_private
;
14311 return DW_ACCESS_public
;
14315 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
14316 offset. If the attribute was not found return 0, otherwise return
14317 1. If it was found but could not properly be handled, set *OFFSET
14321 handle_data_member_location (struct die_info
*die
, struct dwarf2_cu
*cu
,
14324 struct attribute
*attr
;
14326 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
14331 /* Note that we do not check for a section offset first here.
14332 This is because DW_AT_data_member_location is new in DWARF 4,
14333 so if we see it, we can assume that a constant form is really
14334 a constant and not a section offset. */
14335 if (attr
->form_is_constant ())
14336 *offset
= attr
->constant_value (0);
14337 else if (attr
->form_is_section_offset ())
14338 dwarf2_complex_location_expr_complaint ();
14339 else if (attr
->form_is_block ())
14340 *offset
= decode_locdesc (attr
->as_block (), cu
);
14342 dwarf2_complex_location_expr_complaint ();
14350 /* Look for DW_AT_data_member_location and store the results in FIELD. */
14353 handle_data_member_location (struct die_info
*die
, struct dwarf2_cu
*cu
,
14354 struct field
*field
)
14356 struct attribute
*attr
;
14358 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
14361 if (attr
->form_is_constant ())
14363 LONGEST offset
= attr
->constant_value (0);
14364 SET_FIELD_BITPOS (*field
, offset
* bits_per_byte
);
14366 else if (attr
->form_is_section_offset ())
14367 dwarf2_complex_location_expr_complaint ();
14368 else if (attr
->form_is_block ())
14371 CORE_ADDR offset
= decode_locdesc (attr
->as_block (), cu
, &handled
);
14373 SET_FIELD_BITPOS (*field
, offset
* bits_per_byte
);
14376 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
14377 struct objfile
*objfile
= per_objfile
->objfile
;
14378 struct dwarf2_locexpr_baton
*dlbaton
14379 = XOBNEW (&objfile
->objfile_obstack
,
14380 struct dwarf2_locexpr_baton
);
14381 dlbaton
->data
= attr
->as_block ()->data
;
14382 dlbaton
->size
= attr
->as_block ()->size
;
14383 /* When using this baton, we want to compute the address
14384 of the field, not the value. This is why
14385 is_reference is set to false here. */
14386 dlbaton
->is_reference
= false;
14387 dlbaton
->per_objfile
= per_objfile
;
14388 dlbaton
->per_cu
= cu
->per_cu
;
14390 SET_FIELD_DWARF_BLOCK (*field
, dlbaton
);
14394 dwarf2_complex_location_expr_complaint ();
14398 /* Add an aggregate field to the field list. */
14401 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
14402 struct dwarf2_cu
*cu
)
14404 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
14405 struct gdbarch
*gdbarch
= objfile
->arch ();
14406 struct nextfield
*new_field
;
14407 struct attribute
*attr
;
14409 const char *fieldname
= "";
14411 if (die
->tag
== DW_TAG_inheritance
)
14413 fip
->baseclasses
.emplace_back ();
14414 new_field
= &fip
->baseclasses
.back ();
14418 fip
->fields
.emplace_back ();
14419 new_field
= &fip
->fields
.back ();
14422 new_field
->offset
= die
->sect_off
;
14424 new_field
->accessibility
= dwarf2_access_attribute (die
, cu
);
14425 if (new_field
->accessibility
!= DW_ACCESS_public
)
14426 fip
->non_public_fields
= true;
14428 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
14429 if (attr
!= nullptr)
14430 new_field
->virtuality
= attr
->as_virtuality ();
14432 new_field
->virtuality
= DW_VIRTUALITY_none
;
14434 fp
= &new_field
->field
;
14436 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
14438 /* Data member other than a C++ static data member. */
14440 /* Get type of field. */
14441 fp
->set_type (die_type (die
, cu
));
14443 SET_FIELD_BITPOS (*fp
, 0);
14445 /* Get bit size of field (zero if none). */
14446 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
14447 if (attr
!= nullptr)
14449 FIELD_BITSIZE (*fp
) = attr
->constant_value (0);
14453 FIELD_BITSIZE (*fp
) = 0;
14456 /* Get bit offset of field. */
14457 handle_data_member_location (die
, cu
, fp
);
14458 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
14459 if (attr
!= nullptr && attr
->form_is_constant ())
14461 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
)
14463 /* For big endian bits, the DW_AT_bit_offset gives the
14464 additional bit offset from the MSB of the containing
14465 anonymous object to the MSB of the field. We don't
14466 have to do anything special since we don't need to
14467 know the size of the anonymous object. */
14468 SET_FIELD_BITPOS (*fp
, (FIELD_BITPOS (*fp
)
14469 + attr
->constant_value (0)));
14473 /* For little endian bits, compute the bit offset to the
14474 MSB of the anonymous object, subtract off the number of
14475 bits from the MSB of the field to the MSB of the
14476 object, and then subtract off the number of bits of
14477 the field itself. The result is the bit offset of
14478 the LSB of the field. */
14479 int anonymous_size
;
14480 int bit_offset
= attr
->constant_value (0);
14482 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
14483 if (attr
!= nullptr && attr
->form_is_constant ())
14485 /* The size of the anonymous object containing
14486 the bit field is explicit, so use the
14487 indicated size (in bytes). */
14488 anonymous_size
= attr
->constant_value (0);
14492 /* The size of the anonymous object containing
14493 the bit field must be inferred from the type
14494 attribute of the data member containing the
14496 anonymous_size
= TYPE_LENGTH (fp
->type ());
14498 SET_FIELD_BITPOS (*fp
,
14499 (FIELD_BITPOS (*fp
)
14500 + anonymous_size
* bits_per_byte
14501 - bit_offset
- FIELD_BITSIZE (*fp
)));
14504 attr
= dwarf2_attr (die
, DW_AT_data_bit_offset
, cu
);
14506 SET_FIELD_BITPOS (*fp
, (FIELD_BITPOS (*fp
)
14507 + attr
->constant_value (0)));
14509 /* Get name of field. */
14510 fieldname
= dwarf2_name (die
, cu
);
14511 if (fieldname
== NULL
)
14514 /* The name is already allocated along with this objfile, so we don't
14515 need to duplicate it for the type. */
14516 fp
->name
= fieldname
;
14518 /* Change accessibility for artificial fields (e.g. virtual table
14519 pointer or virtual base class pointer) to private. */
14520 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
14522 FIELD_ARTIFICIAL (*fp
) = 1;
14523 new_field
->accessibility
= DW_ACCESS_private
;
14524 fip
->non_public_fields
= true;
14527 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
14529 /* C++ static member. */
14531 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
14532 is a declaration, but all versions of G++ as of this writing
14533 (so through at least 3.2.1) incorrectly generate
14534 DW_TAG_variable tags. */
14536 const char *physname
;
14538 /* Get name of field. */
14539 fieldname
= dwarf2_name (die
, cu
);
14540 if (fieldname
== NULL
)
14543 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
14545 /* Only create a symbol if this is an external value.
14546 new_symbol checks this and puts the value in the global symbol
14547 table, which we want. If it is not external, new_symbol
14548 will try to put the value in cu->list_in_scope which is wrong. */
14549 && dwarf2_flag_true_p (die
, DW_AT_external
, cu
))
14551 /* A static const member, not much different than an enum as far as
14552 we're concerned, except that we can support more types. */
14553 new_symbol (die
, NULL
, cu
);
14556 /* Get physical name. */
14557 physname
= dwarf2_physname (fieldname
, die
, cu
);
14559 /* The name is already allocated along with this objfile, so we don't
14560 need to duplicate it for the type. */
14561 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
14562 fp
->set_type (die_type (die
, cu
));
14563 FIELD_NAME (*fp
) = fieldname
;
14565 else if (die
->tag
== DW_TAG_inheritance
)
14567 /* C++ base class field. */
14568 handle_data_member_location (die
, cu
, fp
);
14569 FIELD_BITSIZE (*fp
) = 0;
14570 fp
->set_type (die_type (die
, cu
));
14571 FIELD_NAME (*fp
) = fp
->type ()->name ();
14574 gdb_assert_not_reached ("missing case in dwarf2_add_field");
14577 /* Can the type given by DIE define another type? */
14580 type_can_define_types (const struct die_info
*die
)
14584 case DW_TAG_typedef
:
14585 case DW_TAG_class_type
:
14586 case DW_TAG_structure_type
:
14587 case DW_TAG_union_type
:
14588 case DW_TAG_enumeration_type
:
14596 /* Add a type definition defined in the scope of the FIP's class. */
14599 dwarf2_add_type_defn (struct field_info
*fip
, struct die_info
*die
,
14600 struct dwarf2_cu
*cu
)
14602 struct decl_field fp
;
14603 memset (&fp
, 0, sizeof (fp
));
14605 gdb_assert (type_can_define_types (die
));
14607 /* Get name of field. NULL is okay here, meaning an anonymous type. */
14608 fp
.name
= dwarf2_name (die
, cu
);
14609 fp
.type
= read_type_die (die
, cu
);
14611 /* Save accessibility. */
14612 dwarf_access_attribute accessibility
= dwarf2_access_attribute (die
, cu
);
14613 switch (accessibility
)
14615 case DW_ACCESS_public
:
14616 /* The assumed value if neither private nor protected. */
14618 case DW_ACCESS_private
:
14621 case DW_ACCESS_protected
:
14622 fp
.is_protected
= 1;
14626 if (die
->tag
== DW_TAG_typedef
)
14627 fip
->typedef_field_list
.push_back (fp
);
14629 fip
->nested_types_list
.push_back (fp
);
14632 /* A convenience typedef that's used when finding the discriminant
14633 field for a variant part. */
14634 typedef std::unordered_map
<sect_offset
, int, gdb::hash_enum
<sect_offset
>>
14637 /* Compute the discriminant range for a given variant. OBSTACK is
14638 where the results will be stored. VARIANT is the variant to
14639 process. IS_UNSIGNED indicates whether the discriminant is signed
14642 static const gdb::array_view
<discriminant_range
>
14643 convert_variant_range (struct obstack
*obstack
, const variant_field
&variant
,
14646 std::vector
<discriminant_range
> ranges
;
14648 if (variant
.default_branch
)
14651 if (variant
.discr_list_data
== nullptr)
14653 discriminant_range r
14654 = {variant
.discriminant_value
, variant
.discriminant_value
};
14655 ranges
.push_back (r
);
14659 gdb::array_view
<const gdb_byte
> data (variant
.discr_list_data
->data
,
14660 variant
.discr_list_data
->size
);
14661 while (!data
.empty ())
14663 if (data
[0] != DW_DSC_range
&& data
[0] != DW_DSC_label
)
14665 complaint (_("invalid discriminant marker: %d"), data
[0]);
14668 bool is_range
= data
[0] == DW_DSC_range
;
14669 data
= data
.slice (1);
14671 ULONGEST low
, high
;
14672 unsigned int bytes_read
;
14676 complaint (_("DW_AT_discr_list missing low value"));
14680 low
= read_unsigned_leb128 (nullptr, data
.data (), &bytes_read
);
14682 low
= (ULONGEST
) read_signed_leb128 (nullptr, data
.data (),
14684 data
= data
.slice (bytes_read
);
14690 complaint (_("DW_AT_discr_list missing high value"));
14694 high
= read_unsigned_leb128 (nullptr, data
.data (),
14697 high
= (LONGEST
) read_signed_leb128 (nullptr, data
.data (),
14699 data
= data
.slice (bytes_read
);
14704 ranges
.push_back ({ low
, high
});
14708 discriminant_range
*result
= XOBNEWVEC (obstack
, discriminant_range
,
14710 std::copy (ranges
.begin (), ranges
.end (), result
);
14711 return gdb::array_view
<discriminant_range
> (result
, ranges
.size ());
14714 static const gdb::array_view
<variant_part
> create_variant_parts
14715 (struct obstack
*obstack
,
14716 const offset_map_type
&offset_map
,
14717 struct field_info
*fi
,
14718 const std::vector
<variant_part_builder
> &variant_parts
);
14720 /* Fill in a "struct variant" for a given variant field. RESULT is
14721 the variant to fill in. OBSTACK is where any needed allocations
14722 will be done. OFFSET_MAP holds the mapping from section offsets to
14723 fields for the type. FI describes the fields of the type we're
14724 processing. FIELD is the variant field we're converting. */
14727 create_one_variant (variant
&result
, struct obstack
*obstack
,
14728 const offset_map_type
&offset_map
,
14729 struct field_info
*fi
, const variant_field
&field
)
14731 result
.discriminants
= convert_variant_range (obstack
, field
, false);
14732 result
.first_field
= field
.first_field
+ fi
->baseclasses
.size ();
14733 result
.last_field
= field
.last_field
+ fi
->baseclasses
.size ();
14734 result
.parts
= create_variant_parts (obstack
, offset_map
, fi
,
14735 field
.variant_parts
);
14738 /* Fill in a "struct variant_part" for a given variant part. RESULT
14739 is the variant part to fill in. OBSTACK is where any needed
14740 allocations will be done. OFFSET_MAP holds the mapping from
14741 section offsets to fields for the type. FI describes the fields of
14742 the type we're processing. BUILDER is the variant part to be
14746 create_one_variant_part (variant_part
&result
,
14747 struct obstack
*obstack
,
14748 const offset_map_type
&offset_map
,
14749 struct field_info
*fi
,
14750 const variant_part_builder
&builder
)
14752 auto iter
= offset_map
.find (builder
.discriminant_offset
);
14753 if (iter
== offset_map
.end ())
14755 result
.discriminant_index
= -1;
14756 /* Doesn't matter. */
14757 result
.is_unsigned
= false;
14761 result
.discriminant_index
= iter
->second
;
14763 = fi
->fields
[result
.discriminant_index
].field
.type ()->is_unsigned ();
14766 size_t n
= builder
.variants
.size ();
14767 variant
*output
= new (obstack
) variant
[n
];
14768 for (size_t i
= 0; i
< n
; ++i
)
14769 create_one_variant (output
[i
], obstack
, offset_map
, fi
,
14770 builder
.variants
[i
]);
14772 result
.variants
= gdb::array_view
<variant
> (output
, n
);
14775 /* Create a vector of variant parts that can be attached to a type.
14776 OBSTACK is where any needed allocations will be done. OFFSET_MAP
14777 holds the mapping from section offsets to fields for the type. FI
14778 describes the fields of the type we're processing. VARIANT_PARTS
14779 is the vector to convert. */
14781 static const gdb::array_view
<variant_part
>
14782 create_variant_parts (struct obstack
*obstack
,
14783 const offset_map_type
&offset_map
,
14784 struct field_info
*fi
,
14785 const std::vector
<variant_part_builder
> &variant_parts
)
14787 if (variant_parts
.empty ())
14790 size_t n
= variant_parts
.size ();
14791 variant_part
*result
= new (obstack
) variant_part
[n
];
14792 for (size_t i
= 0; i
< n
; ++i
)
14793 create_one_variant_part (result
[i
], obstack
, offset_map
, fi
,
14796 return gdb::array_view
<variant_part
> (result
, n
);
14799 /* Compute the variant part vector for FIP, attaching it to TYPE when
14803 add_variant_property (struct field_info
*fip
, struct type
*type
,
14804 struct dwarf2_cu
*cu
)
14806 /* Map section offsets of fields to their field index. Note the
14807 field index here does not take the number of baseclasses into
14809 offset_map_type offset_map
;
14810 for (int i
= 0; i
< fip
->fields
.size (); ++i
)
14811 offset_map
[fip
->fields
[i
].offset
] = i
;
14813 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
14814 gdb::array_view
<variant_part
> parts
14815 = create_variant_parts (&objfile
->objfile_obstack
, offset_map
, fip
,
14816 fip
->variant_parts
);
14818 struct dynamic_prop prop
;
14819 prop
.set_variant_parts ((gdb::array_view
<variant_part
> *)
14820 obstack_copy (&objfile
->objfile_obstack
, &parts
,
14823 type
->add_dyn_prop (DYN_PROP_VARIANT_PARTS
, prop
);
14826 /* Create the vector of fields, and attach it to the type. */
14829 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
14830 struct dwarf2_cu
*cu
)
14832 int nfields
= fip
->nfields ();
14834 /* Record the field count, allocate space for the array of fields,
14835 and create blank accessibility bitfields if necessary. */
14836 type
->set_num_fields (nfields
);
14838 ((struct field
*) TYPE_ZALLOC (type
, sizeof (struct field
) * nfields
));
14840 if (fip
->non_public_fields
&& cu
->per_cu
->lang
!= language_ada
)
14842 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
14844 TYPE_FIELD_PRIVATE_BITS (type
) =
14845 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
14846 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
14848 TYPE_FIELD_PROTECTED_BITS (type
) =
14849 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
14850 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
14852 TYPE_FIELD_IGNORE_BITS (type
) =
14853 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
14854 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
14857 /* If the type has baseclasses, allocate and clear a bit vector for
14858 TYPE_FIELD_VIRTUAL_BITS. */
14859 if (!fip
->baseclasses
.empty () && cu
->per_cu
->lang
!= language_ada
)
14861 int num_bytes
= B_BYTES (fip
->baseclasses
.size ());
14862 unsigned char *pointer
;
14864 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
14865 pointer
= (unsigned char *) TYPE_ALLOC (type
, num_bytes
);
14866 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
14867 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->baseclasses
.size ());
14868 TYPE_N_BASECLASSES (type
) = fip
->baseclasses
.size ();
14871 if (!fip
->variant_parts
.empty ())
14872 add_variant_property (fip
, type
, cu
);
14874 /* Copy the saved-up fields into the field vector. */
14875 for (int i
= 0; i
< nfields
; ++i
)
14877 struct nextfield
&field
14878 = ((i
< fip
->baseclasses
.size ()) ? fip
->baseclasses
[i
]
14879 : fip
->fields
[i
- fip
->baseclasses
.size ()]);
14881 type
->field (i
) = field
.field
;
14882 switch (field
.accessibility
)
14884 case DW_ACCESS_private
:
14885 if (cu
->per_cu
->lang
!= language_ada
)
14886 SET_TYPE_FIELD_PRIVATE (type
, i
);
14889 case DW_ACCESS_protected
:
14890 if (cu
->per_cu
->lang
!= language_ada
)
14891 SET_TYPE_FIELD_PROTECTED (type
, i
);
14894 case DW_ACCESS_public
:
14898 /* Unknown accessibility. Complain and treat it as public. */
14900 complaint (_("unsupported accessibility %d"),
14901 field
.accessibility
);
14905 if (i
< fip
->baseclasses
.size ())
14907 switch (field
.virtuality
)
14909 case DW_VIRTUALITY_virtual
:
14910 case DW_VIRTUALITY_pure_virtual
:
14911 if (cu
->per_cu
->lang
== language_ada
)
14912 error (_("unexpected virtuality in component of Ada type"));
14913 SET_TYPE_FIELD_VIRTUAL (type
, i
);
14920 /* Return true if this member function is a constructor, false
14924 dwarf2_is_constructor (struct die_info
*die
, struct dwarf2_cu
*cu
)
14926 const char *fieldname
;
14927 const char *type_name
;
14930 if (die
->parent
== NULL
)
14933 if (die
->parent
->tag
!= DW_TAG_structure_type
14934 && die
->parent
->tag
!= DW_TAG_union_type
14935 && die
->parent
->tag
!= DW_TAG_class_type
)
14938 fieldname
= dwarf2_name (die
, cu
);
14939 type_name
= dwarf2_name (die
->parent
, cu
);
14940 if (fieldname
== NULL
|| type_name
== NULL
)
14943 len
= strlen (fieldname
);
14944 return (strncmp (fieldname
, type_name
, len
) == 0
14945 && (type_name
[len
] == '\0' || type_name
[len
] == '<'));
14948 /* Add a member function to the proper fieldlist. */
14951 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
14952 struct type
*type
, struct dwarf2_cu
*cu
)
14954 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
14955 struct attribute
*attr
;
14957 struct fnfieldlist
*flp
= nullptr;
14958 struct fn_field
*fnp
;
14959 const char *fieldname
;
14960 struct type
*this_type
;
14962 if (cu
->per_cu
->lang
== language_ada
)
14963 error (_("unexpected member function in Ada type"));
14965 /* Get name of member function. */
14966 fieldname
= dwarf2_name (die
, cu
);
14967 if (fieldname
== NULL
)
14970 /* Look up member function name in fieldlist. */
14971 for (i
= 0; i
< fip
->fnfieldlists
.size (); i
++)
14973 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
14975 flp
= &fip
->fnfieldlists
[i
];
14980 /* Create a new fnfieldlist if necessary. */
14981 if (flp
== nullptr)
14983 fip
->fnfieldlists
.emplace_back ();
14984 flp
= &fip
->fnfieldlists
.back ();
14985 flp
->name
= fieldname
;
14986 i
= fip
->fnfieldlists
.size () - 1;
14989 /* Create a new member function field and add it to the vector of
14991 flp
->fnfields
.emplace_back ();
14992 fnp
= &flp
->fnfields
.back ();
14994 /* Delay processing of the physname until later. */
14995 if (cu
->per_cu
->lang
== language_cplus
)
14996 add_to_method_list (type
, i
, flp
->fnfields
.size () - 1, fieldname
,
15000 const char *physname
= dwarf2_physname (fieldname
, die
, cu
);
15001 fnp
->physname
= physname
? physname
: "";
15004 fnp
->type
= alloc_type (objfile
);
15005 this_type
= read_type_die (die
, cu
);
15006 if (this_type
&& this_type
->code () == TYPE_CODE_FUNC
)
15008 int nparams
= this_type
->num_fields ();
15010 /* TYPE is the domain of this method, and THIS_TYPE is the type
15011 of the method itself (TYPE_CODE_METHOD). */
15012 smash_to_method_type (fnp
->type
, type
,
15013 TYPE_TARGET_TYPE (this_type
),
15014 this_type
->fields (),
15015 this_type
->num_fields (),
15016 this_type
->has_varargs ());
15018 /* Handle static member functions.
15019 Dwarf2 has no clean way to discern C++ static and non-static
15020 member functions. G++ helps GDB by marking the first
15021 parameter for non-static member functions (which is the this
15022 pointer) as artificial. We obtain this information from
15023 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
15024 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (this_type
, 0) == 0)
15025 fnp
->voffset
= VOFFSET_STATIC
;
15028 complaint (_("member function type missing for '%s'"),
15029 dwarf2_full_name (fieldname
, die
, cu
));
15031 /* Get fcontext from DW_AT_containing_type if present. */
15032 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
15033 fnp
->fcontext
= die_containing_type (die
, cu
);
15035 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
15036 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
15038 /* Get accessibility. */
15039 dwarf_access_attribute accessibility
= dwarf2_access_attribute (die
, cu
);
15040 switch (accessibility
)
15042 case DW_ACCESS_private
:
15043 fnp
->is_private
= 1;
15045 case DW_ACCESS_protected
:
15046 fnp
->is_protected
= 1;
15050 /* Check for artificial methods. */
15051 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
15052 if (attr
&& attr
->as_boolean ())
15053 fnp
->is_artificial
= 1;
15055 /* Check for defaulted methods. */
15056 attr
= dwarf2_attr (die
, DW_AT_defaulted
, cu
);
15057 if (attr
!= nullptr)
15058 fnp
->defaulted
= attr
->defaulted ();
15060 /* Check for deleted methods. */
15061 attr
= dwarf2_attr (die
, DW_AT_deleted
, cu
);
15062 if (attr
!= nullptr && attr
->as_boolean ())
15063 fnp
->is_deleted
= 1;
15065 fnp
->is_constructor
= dwarf2_is_constructor (die
, cu
);
15067 /* Get index in virtual function table if it is a virtual member
15068 function. For older versions of GCC, this is an offset in the
15069 appropriate virtual table, as specified by DW_AT_containing_type.
15070 For everyone else, it is an expression to be evaluated relative
15071 to the object address. */
15073 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
15074 if (attr
!= nullptr)
15076 if (attr
->form_is_block () && attr
->as_block ()->size
> 0)
15078 struct dwarf_block
*block
= attr
->as_block ();
15080 if (block
->data
[0] == DW_OP_constu
)
15082 /* Old-style GCC. */
15083 fnp
->voffset
= decode_locdesc (block
, cu
) + 2;
15085 else if (block
->data
[0] == DW_OP_deref
15086 || (block
->size
> 1
15087 && block
->data
[0] == DW_OP_deref_size
15088 && block
->data
[1] == cu
->header
.addr_size
))
15090 fnp
->voffset
= decode_locdesc (block
, cu
);
15091 if ((fnp
->voffset
% cu
->header
.addr_size
) != 0)
15092 dwarf2_complex_location_expr_complaint ();
15094 fnp
->voffset
/= cu
->header
.addr_size
;
15098 dwarf2_complex_location_expr_complaint ();
15100 if (!fnp
->fcontext
)
15102 /* If there is no `this' field and no DW_AT_containing_type,
15103 we cannot actually find a base class context for the
15105 if (this_type
->num_fields () == 0
15106 || !TYPE_FIELD_ARTIFICIAL (this_type
, 0))
15108 complaint (_("cannot determine context for virtual member "
15109 "function \"%s\" (offset %s)"),
15110 fieldname
, sect_offset_str (die
->sect_off
));
15115 = TYPE_TARGET_TYPE (this_type
->field (0).type ());
15119 else if (attr
->form_is_section_offset ())
15121 dwarf2_complex_location_expr_complaint ();
15125 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
15131 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
15132 if (attr
!= nullptr && attr
->as_virtuality () != DW_VIRTUALITY_none
)
15134 /* GCC does this, as of 2008-08-25; PR debug/37237. */
15135 complaint (_("Member function \"%s\" (offset %s) is virtual "
15136 "but the vtable offset is not specified"),
15137 fieldname
, sect_offset_str (die
->sect_off
));
15138 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15139 TYPE_CPLUS_DYNAMIC (type
) = 1;
15144 /* Create the vector of member function fields, and attach it to the type. */
15147 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
15148 struct dwarf2_cu
*cu
)
15150 if (cu
->per_cu
->lang
== language_ada
)
15151 error (_("unexpected member functions in Ada type"));
15153 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15154 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
15156 sizeof (struct fn_fieldlist
) * fip
->fnfieldlists
.size ());
15158 for (int i
= 0; i
< fip
->fnfieldlists
.size (); i
++)
15160 struct fnfieldlist
&nf
= fip
->fnfieldlists
[i
];
15161 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
15163 TYPE_FN_FIELDLIST_NAME (type
, i
) = nf
.name
;
15164 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = nf
.fnfields
.size ();
15165 fn_flp
->fn_fields
= (struct fn_field
*)
15166 TYPE_ALLOC (type
, sizeof (struct fn_field
) * nf
.fnfields
.size ());
15168 for (int k
= 0; k
< nf
.fnfields
.size (); ++k
)
15169 fn_flp
->fn_fields
[k
] = nf
.fnfields
[k
];
15172 TYPE_NFN_FIELDS (type
) = fip
->fnfieldlists
.size ();
15175 /* Returns non-zero if NAME is the name of a vtable member in CU's
15176 language, zero otherwise. */
15178 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
15180 static const char vptr
[] = "_vptr";
15182 /* Look for the C++ form of the vtable. */
15183 if (startswith (name
, vptr
) && is_cplus_marker (name
[sizeof (vptr
) - 1]))
15189 /* GCC outputs unnamed structures that are really pointers to member
15190 functions, with the ABI-specified layout. If TYPE describes
15191 such a structure, smash it into a member function type.
15193 GCC shouldn't do this; it should just output pointer to member DIEs.
15194 This is GCC PR debug/28767. */
15197 quirk_gcc_member_function_pointer (struct type
*type
, struct objfile
*objfile
)
15199 struct type
*pfn_type
, *self_type
, *new_type
;
15201 /* Check for a structure with no name and two children. */
15202 if (type
->code () != TYPE_CODE_STRUCT
|| type
->num_fields () != 2)
15205 /* Check for __pfn and __delta members. */
15206 if (TYPE_FIELD_NAME (type
, 0) == NULL
15207 || strcmp (TYPE_FIELD_NAME (type
, 0), "__pfn") != 0
15208 || TYPE_FIELD_NAME (type
, 1) == NULL
15209 || strcmp (TYPE_FIELD_NAME (type
, 1), "__delta") != 0)
15212 /* Find the type of the method. */
15213 pfn_type
= type
->field (0).type ();
15214 if (pfn_type
== NULL
15215 || pfn_type
->code () != TYPE_CODE_PTR
15216 || TYPE_TARGET_TYPE (pfn_type
)->code () != TYPE_CODE_FUNC
)
15219 /* Look for the "this" argument. */
15220 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
15221 if (pfn_type
->num_fields () == 0
15222 /* || pfn_type->field (0).type () == NULL */
15223 || pfn_type
->field (0).type ()->code () != TYPE_CODE_PTR
)
15226 self_type
= TYPE_TARGET_TYPE (pfn_type
->field (0).type ());
15227 new_type
= alloc_type (objfile
);
15228 smash_to_method_type (new_type
, self_type
, TYPE_TARGET_TYPE (pfn_type
),
15229 pfn_type
->fields (), pfn_type
->num_fields (),
15230 pfn_type
->has_varargs ());
15231 smash_to_methodptr_type (type
, new_type
);
15234 /* Helper for quirk_ada_thick_pointer. If TYPE is an array type that
15235 requires rewriting, then copy it and return the updated copy.
15236 Otherwise return nullptr. */
15238 static struct type
*
15239 rewrite_array_type (struct type
*type
)
15241 if (type
->code () != TYPE_CODE_ARRAY
)
15244 struct type
*index_type
= type
->index_type ();
15245 range_bounds
*current_bounds
= index_type
->bounds ();
15247 /* Handle multi-dimensional arrays. */
15248 struct type
*new_target
= rewrite_array_type (TYPE_TARGET_TYPE (type
));
15249 if (new_target
== nullptr)
15251 /* Maybe we don't need to rewrite this array. */
15252 if (current_bounds
->low
.kind () == PROP_CONST
15253 && current_bounds
->high
.kind () == PROP_CONST
)
15257 /* Either the target type was rewritten, or the bounds have to be
15258 updated. Either way we want to copy the type and update
15260 struct type
*copy
= copy_type (type
);
15261 int nfields
= copy
->num_fields ();
15263 = ((struct field
*) TYPE_ZALLOC (copy
,
15264 nfields
* sizeof (struct field
)));
15265 memcpy (new_fields
, copy
->fields (), nfields
* sizeof (struct field
));
15266 copy
->set_fields (new_fields
);
15267 if (new_target
!= nullptr)
15268 TYPE_TARGET_TYPE (copy
) = new_target
;
15270 struct type
*index_copy
= copy_type (index_type
);
15271 range_bounds
*bounds
15272 = (struct range_bounds
*) TYPE_ZALLOC (index_copy
,
15273 sizeof (range_bounds
));
15274 *bounds
= *current_bounds
;
15275 bounds
->low
.set_const_val (1);
15276 bounds
->high
.set_const_val (0);
15277 index_copy
->set_bounds (bounds
);
15278 copy
->set_index_type (index_copy
);
15283 /* While some versions of GCC will generate complicated DWARF for an
15284 array (see quirk_ada_thick_pointer), more recent versions were
15285 modified to emit an explicit thick pointer structure. However, in
15286 this case, the array still has DWARF expressions for its ranges,
15287 and these must be ignored. */
15290 quirk_ada_thick_pointer_struct (struct die_info
*die
, struct dwarf2_cu
*cu
,
15293 gdb_assert (cu
->per_cu
->lang
== language_ada
);
15295 /* Check for a structure with two children. */
15296 if (type
->code () != TYPE_CODE_STRUCT
|| type
->num_fields () != 2)
15299 /* Check for P_ARRAY and P_BOUNDS members. */
15300 if (TYPE_FIELD_NAME (type
, 0) == NULL
15301 || strcmp (TYPE_FIELD_NAME (type
, 0), "P_ARRAY") != 0
15302 || TYPE_FIELD_NAME (type
, 1) == NULL
15303 || strcmp (TYPE_FIELD_NAME (type
, 1), "P_BOUNDS") != 0)
15306 /* Make sure we're looking at a pointer to an array. */
15307 if (type
->field (0).type ()->code () != TYPE_CODE_PTR
)
15310 /* The Ada code already knows how to handle these types, so all that
15311 we need to do is turn the bounds into static bounds. However, we
15312 don't want to rewrite existing array or index types in-place,
15313 because those may be referenced in other contexts where this
15314 rewriting is undesirable. */
15315 struct type
*new_ary_type
15316 = rewrite_array_type (TYPE_TARGET_TYPE (type
->field (0).type ()));
15317 if (new_ary_type
!= nullptr)
15318 type
->field (0).set_type (lookup_pointer_type (new_ary_type
));
15321 /* If the DIE has a DW_AT_alignment attribute, return its value, doing
15322 appropriate error checking and issuing complaints if there is a
15326 get_alignment (struct dwarf2_cu
*cu
, struct die_info
*die
)
15328 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_alignment
, cu
);
15330 if (attr
== nullptr)
15333 if (!attr
->form_is_constant ())
15335 complaint (_("DW_AT_alignment must have constant form"
15336 " - DIE at %s [in module %s]"),
15337 sect_offset_str (die
->sect_off
),
15338 objfile_name (cu
->per_objfile
->objfile
));
15342 LONGEST val
= attr
->constant_value (0);
15345 complaint (_("DW_AT_alignment value must not be negative"
15346 " - DIE at %s [in module %s]"),
15347 sect_offset_str (die
->sect_off
),
15348 objfile_name (cu
->per_objfile
->objfile
));
15351 ULONGEST align
= val
;
15355 complaint (_("DW_AT_alignment value must not be zero"
15356 " - DIE at %s [in module %s]"),
15357 sect_offset_str (die
->sect_off
),
15358 objfile_name (cu
->per_objfile
->objfile
));
15361 if ((align
& (align
- 1)) != 0)
15363 complaint (_("DW_AT_alignment value must be a power of 2"
15364 " - DIE at %s [in module %s]"),
15365 sect_offset_str (die
->sect_off
),
15366 objfile_name (cu
->per_objfile
->objfile
));
15373 /* If the DIE has a DW_AT_alignment attribute, use its value to set
15374 the alignment for TYPE. */
15377 maybe_set_alignment (struct dwarf2_cu
*cu
, struct die_info
*die
,
15380 if (!set_type_align (type
, get_alignment (cu
, die
)))
15381 complaint (_("DW_AT_alignment value too large"
15382 " - DIE at %s [in module %s]"),
15383 sect_offset_str (die
->sect_off
),
15384 objfile_name (cu
->per_objfile
->objfile
));
15387 /* Check if the given VALUE is a valid enum dwarf_calling_convention
15388 constant for a type, according to DWARF5 spec, Table 5.5. */
15391 is_valid_DW_AT_calling_convention_for_type (ULONGEST value
)
15396 case DW_CC_pass_by_reference
:
15397 case DW_CC_pass_by_value
:
15401 complaint (_("unrecognized DW_AT_calling_convention value "
15402 "(%s) for a type"), pulongest (value
));
15407 /* Check if the given VALUE is a valid enum dwarf_calling_convention
15408 constant for a subroutine, according to DWARF5 spec, Table 3.3, and
15409 also according to GNU-specific values (see include/dwarf2.h). */
15412 is_valid_DW_AT_calling_convention_for_subroutine (ULONGEST value
)
15417 case DW_CC_program
:
15421 case DW_CC_GNU_renesas_sh
:
15422 case DW_CC_GNU_borland_fastcall_i386
:
15423 case DW_CC_GDB_IBM_OpenCL
:
15427 complaint (_("unrecognized DW_AT_calling_convention value "
15428 "(%s) for a subroutine"), pulongest (value
));
15433 /* Called when we find the DIE that starts a structure or union scope
15434 (definition) to create a type for the structure or union. Fill in
15435 the type's name and general properties; the members will not be
15436 processed until process_structure_scope. A symbol table entry for
15437 the type will also not be done until process_structure_scope (assuming
15438 the type has a name).
15440 NOTE: we need to call these functions regardless of whether or not the
15441 DIE has a DW_AT_name attribute, since it might be an anonymous
15442 structure or union. This gets the type entered into our set of
15443 user defined types. */
15445 static struct type
*
15446 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
15448 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
15450 struct attribute
*attr
;
15453 /* If the definition of this type lives in .debug_types, read that type.
15454 Don't follow DW_AT_specification though, that will take us back up
15455 the chain and we want to go down. */
15456 attr
= die
->attr (DW_AT_signature
);
15457 if (attr
!= nullptr)
15459 type
= get_DW_AT_signature_type (die
, attr
, cu
);
15461 /* The type's CU may not be the same as CU.
15462 Ensure TYPE is recorded with CU in die_type_hash. */
15463 return set_die_type (die
, type
, cu
);
15466 type
= alloc_type (objfile
);
15467 INIT_CPLUS_SPECIFIC (type
);
15469 name
= dwarf2_name (die
, cu
);
15472 if (cu
->per_cu
->lang
== language_cplus
15473 || cu
->per_cu
->lang
== language_d
15474 || cu
->per_cu
->lang
== language_rust
)
15476 const char *full_name
= dwarf2_full_name (name
, die
, cu
);
15478 /* dwarf2_full_name might have already finished building the DIE's
15479 type. If so, there is no need to continue. */
15480 if (get_die_type (die
, cu
) != NULL
)
15481 return get_die_type (die
, cu
);
15483 type
->set_name (full_name
);
15487 /* The name is already allocated along with this objfile, so
15488 we don't need to duplicate it for the type. */
15489 type
->set_name (name
);
15493 if (die
->tag
== DW_TAG_structure_type
)
15495 type
->set_code (TYPE_CODE_STRUCT
);
15497 else if (die
->tag
== DW_TAG_union_type
)
15499 type
->set_code (TYPE_CODE_UNION
);
15503 type
->set_code (TYPE_CODE_STRUCT
);
15506 if (cu
->per_cu
->lang
== language_cplus
&& die
->tag
== DW_TAG_class_type
)
15507 type
->set_is_declared_class (true);
15509 /* Store the calling convention in the type if it's available in
15510 the die. Otherwise the calling convention remains set to
15511 the default value DW_CC_normal. */
15512 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
15513 if (attr
!= nullptr
15514 && is_valid_DW_AT_calling_convention_for_type (attr
->constant_value (0)))
15516 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15517 TYPE_CPLUS_CALLING_CONVENTION (type
)
15518 = (enum dwarf_calling_convention
) (attr
->constant_value (0));
15521 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
15522 if (attr
!= nullptr)
15524 if (attr
->form_is_constant ())
15525 TYPE_LENGTH (type
) = attr
->constant_value (0);
15528 struct dynamic_prop prop
;
15529 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
, cu
->addr_type ()))
15530 type
->add_dyn_prop (DYN_PROP_BYTE_SIZE
, prop
);
15531 TYPE_LENGTH (type
) = 0;
15536 TYPE_LENGTH (type
) = 0;
15539 maybe_set_alignment (cu
, die
, type
);
15541 if (producer_is_icc_lt_14 (cu
) && (TYPE_LENGTH (type
) == 0))
15543 /* ICC<14 does not output the required DW_AT_declaration on
15544 incomplete types, but gives them a size of zero. */
15545 type
->set_is_stub (true);
15548 type
->set_stub_is_supported (true);
15550 if (die_is_declaration (die
, cu
))
15551 type
->set_is_stub (true);
15552 else if (attr
== NULL
&& die
->child
== NULL
15553 && producer_is_realview (cu
->producer
))
15554 /* RealView does not output the required DW_AT_declaration
15555 on incomplete types. */
15556 type
->set_is_stub (true);
15558 /* We need to add the type field to the die immediately so we don't
15559 infinitely recurse when dealing with pointers to the structure
15560 type within the structure itself. */
15561 set_die_type (die
, type
, cu
);
15563 /* set_die_type should be already done. */
15564 set_descriptive_type (type
, die
, cu
);
15569 static void handle_struct_member_die
15570 (struct die_info
*child_die
,
15572 struct field_info
*fi
,
15573 std::vector
<struct symbol
*> *template_args
,
15574 struct dwarf2_cu
*cu
);
15576 /* A helper for handle_struct_member_die that handles
15577 DW_TAG_variant_part. */
15580 handle_variant_part (struct die_info
*die
, struct type
*type
,
15581 struct field_info
*fi
,
15582 std::vector
<struct symbol
*> *template_args
,
15583 struct dwarf2_cu
*cu
)
15585 variant_part_builder
*new_part
;
15586 if (fi
->current_variant_part
== nullptr)
15588 fi
->variant_parts
.emplace_back ();
15589 new_part
= &fi
->variant_parts
.back ();
15591 else if (!fi
->current_variant_part
->processing_variant
)
15593 complaint (_("nested DW_TAG_variant_part seen "
15594 "- DIE at %s [in module %s]"),
15595 sect_offset_str (die
->sect_off
),
15596 objfile_name (cu
->per_objfile
->objfile
));
15601 variant_field
¤t
= fi
->current_variant_part
->variants
.back ();
15602 current
.variant_parts
.emplace_back ();
15603 new_part
= ¤t
.variant_parts
.back ();
15606 /* When we recurse, we want callees to add to this new variant
15608 scoped_restore save_current_variant_part
15609 = make_scoped_restore (&fi
->current_variant_part
, new_part
);
15611 struct attribute
*discr
= dwarf2_attr (die
, DW_AT_discr
, cu
);
15614 /* It's a univariant form, an extension we support. */
15616 else if (discr
->form_is_ref ())
15618 struct dwarf2_cu
*target_cu
= cu
;
15619 struct die_info
*target_die
= follow_die_ref (die
, discr
, &target_cu
);
15621 new_part
->discriminant_offset
= target_die
->sect_off
;
15625 complaint (_("DW_AT_discr does not have DIE reference form"
15626 " - DIE at %s [in module %s]"),
15627 sect_offset_str (die
->sect_off
),
15628 objfile_name (cu
->per_objfile
->objfile
));
15631 for (die_info
*child_die
= die
->child
;
15633 child_die
= child_die
->sibling
)
15634 handle_struct_member_die (child_die
, type
, fi
, template_args
, cu
);
15637 /* A helper for handle_struct_member_die that handles
15641 handle_variant (struct die_info
*die
, struct type
*type
,
15642 struct field_info
*fi
,
15643 std::vector
<struct symbol
*> *template_args
,
15644 struct dwarf2_cu
*cu
)
15646 if (fi
->current_variant_part
== nullptr)
15648 complaint (_("saw DW_TAG_variant outside DW_TAG_variant_part "
15649 "- DIE at %s [in module %s]"),
15650 sect_offset_str (die
->sect_off
),
15651 objfile_name (cu
->per_objfile
->objfile
));
15654 if (fi
->current_variant_part
->processing_variant
)
15656 complaint (_("nested DW_TAG_variant seen "
15657 "- DIE at %s [in module %s]"),
15658 sect_offset_str (die
->sect_off
),
15659 objfile_name (cu
->per_objfile
->objfile
));
15663 scoped_restore save_processing_variant
15664 = make_scoped_restore (&fi
->current_variant_part
->processing_variant
,
15667 fi
->current_variant_part
->variants
.emplace_back ();
15668 variant_field
&variant
= fi
->current_variant_part
->variants
.back ();
15669 variant
.first_field
= fi
->fields
.size ();
15671 /* In a variant we want to get the discriminant and also add a
15672 field for our sole member child. */
15673 struct attribute
*discr
= dwarf2_attr (die
, DW_AT_discr_value
, cu
);
15674 if (discr
== nullptr || !discr
->form_is_constant ())
15676 discr
= dwarf2_attr (die
, DW_AT_discr_list
, cu
);
15677 if (discr
== nullptr || discr
->as_block ()->size
== 0)
15678 variant
.default_branch
= true;
15680 variant
.discr_list_data
= discr
->as_block ();
15683 variant
.discriminant_value
= discr
->constant_value (0);
15685 for (die_info
*variant_child
= die
->child
;
15686 variant_child
!= NULL
;
15687 variant_child
= variant_child
->sibling
)
15688 handle_struct_member_die (variant_child
, type
, fi
, template_args
, cu
);
15690 variant
.last_field
= fi
->fields
.size ();
15693 /* A helper for process_structure_scope that handles a single member
15697 handle_struct_member_die (struct die_info
*child_die
, struct type
*type
,
15698 struct field_info
*fi
,
15699 std::vector
<struct symbol
*> *template_args
,
15700 struct dwarf2_cu
*cu
)
15702 if (child_die
->tag
== DW_TAG_member
15703 || child_die
->tag
== DW_TAG_variable
)
15705 /* NOTE: carlton/2002-11-05: A C++ static data member
15706 should be a DW_TAG_member that is a declaration, but
15707 all versions of G++ as of this writing (so through at
15708 least 3.2.1) incorrectly generate DW_TAG_variable
15709 tags for them instead. */
15710 dwarf2_add_field (fi
, child_die
, cu
);
15712 else if (child_die
->tag
== DW_TAG_subprogram
)
15714 /* Rust doesn't have member functions in the C++ sense.
15715 However, it does emit ordinary functions as children
15716 of a struct DIE. */
15717 if (cu
->per_cu
->lang
== language_rust
)
15718 read_func_scope (child_die
, cu
);
15721 /* C++ member function. */
15722 dwarf2_add_member_fn (fi
, child_die
, type
, cu
);
15725 else if (child_die
->tag
== DW_TAG_inheritance
)
15727 /* C++ base class field. */
15728 dwarf2_add_field (fi
, child_die
, cu
);
15730 else if (type_can_define_types (child_die
))
15731 dwarf2_add_type_defn (fi
, child_die
, cu
);
15732 else if (child_die
->tag
== DW_TAG_template_type_param
15733 || child_die
->tag
== DW_TAG_template_value_param
)
15735 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
15738 template_args
->push_back (arg
);
15740 else if (child_die
->tag
== DW_TAG_variant_part
)
15741 handle_variant_part (child_die
, type
, fi
, template_args
, cu
);
15742 else if (child_die
->tag
== DW_TAG_variant
)
15743 handle_variant (child_die
, type
, fi
, template_args
, cu
);
15746 /* Finish creating a structure or union type, including filling in
15747 its members and creating a symbol for it. */
15750 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
15752 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
15753 struct die_info
*child_die
;
15756 type
= get_die_type (die
, cu
);
15758 type
= read_structure_type (die
, cu
);
15760 bool has_template_parameters
= false;
15761 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
15763 struct field_info fi
;
15764 std::vector
<struct symbol
*> template_args
;
15766 child_die
= die
->child
;
15768 while (child_die
&& child_die
->tag
)
15770 handle_struct_member_die (child_die
, type
, &fi
, &template_args
, cu
);
15771 child_die
= child_die
->sibling
;
15774 /* Attach template arguments to type. */
15775 if (!template_args
.empty ())
15777 has_template_parameters
= true;
15778 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15779 TYPE_N_TEMPLATE_ARGUMENTS (type
) = template_args
.size ();
15780 TYPE_TEMPLATE_ARGUMENTS (type
)
15781 = XOBNEWVEC (&objfile
->objfile_obstack
,
15783 TYPE_N_TEMPLATE_ARGUMENTS (type
));
15784 memcpy (TYPE_TEMPLATE_ARGUMENTS (type
),
15785 template_args
.data (),
15786 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
15787 * sizeof (struct symbol
*)));
15790 /* Attach fields and member functions to the type. */
15791 if (fi
.nfields () > 0)
15792 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
15793 if (!fi
.fnfieldlists
.empty ())
15795 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
15797 /* Get the type which refers to the base class (possibly this
15798 class itself) which contains the vtable pointer for the current
15799 class from the DW_AT_containing_type attribute. This use of
15800 DW_AT_containing_type is a GNU extension. */
15802 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
15804 struct type
*t
= die_containing_type (die
, cu
);
15806 set_type_vptr_basetype (type
, t
);
15811 /* Our own class provides vtbl ptr. */
15812 for (i
= t
->num_fields () - 1;
15813 i
>= TYPE_N_BASECLASSES (t
);
15816 const char *fieldname
= TYPE_FIELD_NAME (t
, i
);
15818 if (is_vtable_name (fieldname
, cu
))
15820 set_type_vptr_fieldno (type
, i
);
15825 /* Complain if virtual function table field not found. */
15826 if (i
< TYPE_N_BASECLASSES (t
))
15827 complaint (_("virtual function table pointer "
15828 "not found when defining class '%s'"),
15829 type
->name () ? type
->name () : "");
15833 set_type_vptr_fieldno (type
, TYPE_VPTR_FIELDNO (t
));
15836 else if (cu
->producer
15837 && startswith (cu
->producer
, "IBM(R) XL C/C++ Advanced Edition"))
15839 /* The IBM XLC compiler does not provide direct indication
15840 of the containing type, but the vtable pointer is
15841 always named __vfp. */
15845 for (i
= type
->num_fields () - 1;
15846 i
>= TYPE_N_BASECLASSES (type
);
15849 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
15851 set_type_vptr_fieldno (type
, i
);
15852 set_type_vptr_basetype (type
, type
);
15859 /* Copy fi.typedef_field_list linked list elements content into the
15860 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
15861 if (!fi
.typedef_field_list
.empty ())
15863 int count
= fi
.typedef_field_list
.size ();
15865 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15866 TYPE_TYPEDEF_FIELD_ARRAY (type
)
15867 = ((struct decl_field
*)
15869 sizeof (TYPE_TYPEDEF_FIELD (type
, 0)) * count
));
15870 TYPE_TYPEDEF_FIELD_COUNT (type
) = count
;
15872 for (int i
= 0; i
< fi
.typedef_field_list
.size (); ++i
)
15873 TYPE_TYPEDEF_FIELD (type
, i
) = fi
.typedef_field_list
[i
];
15876 /* Copy fi.nested_types_list linked list elements content into the
15877 allocated array TYPE_NESTED_TYPES_ARRAY (type). */
15878 if (!fi
.nested_types_list
.empty ()
15879 && cu
->per_cu
->lang
!= language_ada
)
15881 int count
= fi
.nested_types_list
.size ();
15883 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15884 TYPE_NESTED_TYPES_ARRAY (type
)
15885 = ((struct decl_field
*)
15886 TYPE_ALLOC (type
, sizeof (struct decl_field
) * count
));
15887 TYPE_NESTED_TYPES_COUNT (type
) = count
;
15889 for (int i
= 0; i
< fi
.nested_types_list
.size (); ++i
)
15890 TYPE_NESTED_TYPES_FIELD (type
, i
) = fi
.nested_types_list
[i
];
15894 quirk_gcc_member_function_pointer (type
, objfile
);
15895 if (cu
->per_cu
->lang
== language_rust
&& die
->tag
== DW_TAG_union_type
)
15896 cu
->rust_unions
.push_back (type
);
15897 else if (cu
->per_cu
->lang
== language_ada
)
15898 quirk_ada_thick_pointer_struct (die
, cu
, type
);
15900 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
15901 snapshots) has been known to create a die giving a declaration
15902 for a class that has, as a child, a die giving a definition for a
15903 nested class. So we have to process our children even if the
15904 current die is a declaration. Normally, of course, a declaration
15905 won't have any children at all. */
15907 child_die
= die
->child
;
15909 while (child_die
!= NULL
&& child_die
->tag
)
15911 if (child_die
->tag
== DW_TAG_member
15912 || child_die
->tag
== DW_TAG_variable
15913 || child_die
->tag
== DW_TAG_inheritance
15914 || child_die
->tag
== DW_TAG_template_value_param
15915 || child_die
->tag
== DW_TAG_template_type_param
)
15920 process_die (child_die
, cu
);
15922 child_die
= child_die
->sibling
;
15925 /* Do not consider external references. According to the DWARF standard,
15926 these DIEs are identified by the fact that they have no byte_size
15927 attribute, and a declaration attribute. */
15928 if (dwarf2_attr (die
, DW_AT_byte_size
, cu
) != NULL
15929 || !die_is_declaration (die
, cu
)
15930 || dwarf2_attr (die
, DW_AT_signature
, cu
) != NULL
)
15932 struct symbol
*sym
= new_symbol (die
, type
, cu
);
15934 if (has_template_parameters
)
15936 struct symtab
*symtab
;
15937 if (sym
!= nullptr)
15938 symtab
= symbol_symtab (sym
);
15939 else if (cu
->line_header
!= nullptr)
15941 /* Any related symtab will do. */
15943 = cu
->line_header
->file_names ()[0].symtab
;
15948 complaint (_("could not find suitable "
15949 "symtab for template parameter"
15950 " - DIE at %s [in module %s]"),
15951 sect_offset_str (die
->sect_off
),
15952 objfile_name (objfile
));
15955 if (symtab
!= nullptr)
15957 /* Make sure that the symtab is set on the new symbols.
15958 Even though they don't appear in this symtab directly,
15959 other parts of gdb assume that symbols do, and this is
15960 reasonably true. */
15961 for (int i
= 0; i
< TYPE_N_TEMPLATE_ARGUMENTS (type
); ++i
)
15962 symbol_set_symtab (TYPE_TEMPLATE_ARGUMENT (type
, i
), symtab
);
15968 /* Assuming DIE is an enumeration type, and TYPE is its associated
15969 type, update TYPE using some information only available in DIE's
15970 children. In particular, the fields are computed. */
15973 update_enumeration_type_from_children (struct die_info
*die
,
15975 struct dwarf2_cu
*cu
)
15977 struct die_info
*child_die
;
15978 int unsigned_enum
= 1;
15981 auto_obstack obstack
;
15982 std::vector
<struct field
> fields
;
15984 for (child_die
= die
->child
;
15985 child_die
!= NULL
&& child_die
->tag
;
15986 child_die
= child_die
->sibling
)
15988 struct attribute
*attr
;
15990 const gdb_byte
*bytes
;
15991 struct dwarf2_locexpr_baton
*baton
;
15994 if (child_die
->tag
!= DW_TAG_enumerator
)
15997 attr
= dwarf2_attr (child_die
, DW_AT_const_value
, cu
);
16001 name
= dwarf2_name (child_die
, cu
);
16003 name
= "<anonymous enumerator>";
16005 dwarf2_const_value_attr (attr
, type
, name
, &obstack
, cu
,
16006 &value
, &bytes
, &baton
);
16014 if (count_one_bits_ll (value
) >= 2)
16018 fields
.emplace_back ();
16019 struct field
&field
= fields
.back ();
16020 FIELD_NAME (field
) = dwarf2_physname (name
, child_die
, cu
);
16021 SET_FIELD_ENUMVAL (field
, value
);
16024 if (!fields
.empty ())
16026 type
->set_num_fields (fields
.size ());
16029 TYPE_ALLOC (type
, sizeof (struct field
) * fields
.size ()));
16030 memcpy (type
->fields (), fields
.data (),
16031 sizeof (struct field
) * fields
.size ());
16035 type
->set_is_unsigned (true);
16038 type
->set_is_flag_enum (true);
16041 /* Given a DW_AT_enumeration_type die, set its type. We do not
16042 complete the type's fields yet, or create any symbols. */
16044 static struct type
*
16045 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16047 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
16049 struct attribute
*attr
;
16052 /* If the definition of this type lives in .debug_types, read that type.
16053 Don't follow DW_AT_specification though, that will take us back up
16054 the chain and we want to go down. */
16055 attr
= die
->attr (DW_AT_signature
);
16056 if (attr
!= nullptr)
16058 type
= get_DW_AT_signature_type (die
, attr
, cu
);
16060 /* The type's CU may not be the same as CU.
16061 Ensure TYPE is recorded with CU in die_type_hash. */
16062 return set_die_type (die
, type
, cu
);
16065 type
= alloc_type (objfile
);
16067 type
->set_code (TYPE_CODE_ENUM
);
16068 name
= dwarf2_full_name (NULL
, die
, cu
);
16070 type
->set_name (name
);
16072 attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
16075 struct type
*underlying_type
= die_type (die
, cu
);
16077 TYPE_TARGET_TYPE (type
) = underlying_type
;
16080 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16081 if (attr
!= nullptr)
16083 TYPE_LENGTH (type
) = attr
->constant_value (0);
16087 TYPE_LENGTH (type
) = 0;
16090 maybe_set_alignment (cu
, die
, type
);
16092 /* The enumeration DIE can be incomplete. In Ada, any type can be
16093 declared as private in the package spec, and then defined only
16094 inside the package body. Such types are known as Taft Amendment
16095 Types. When another package uses such a type, an incomplete DIE
16096 may be generated by the compiler. */
16097 if (die_is_declaration (die
, cu
))
16098 type
->set_is_stub (true);
16100 /* If this type has an underlying type that is not a stub, then we
16101 may use its attributes. We always use the "unsigned" attribute
16102 in this situation, because ordinarily we guess whether the type
16103 is unsigned -- but the guess can be wrong and the underlying type
16104 can tell us the reality. However, we defer to a local size
16105 attribute if one exists, because this lets the compiler override
16106 the underlying type if needed. */
16107 if (TYPE_TARGET_TYPE (type
) != NULL
&& !TYPE_TARGET_TYPE (type
)->is_stub ())
16109 struct type
*underlying_type
= TYPE_TARGET_TYPE (type
);
16110 underlying_type
= check_typedef (underlying_type
);
16112 type
->set_is_unsigned (underlying_type
->is_unsigned ());
16114 if (TYPE_LENGTH (type
) == 0)
16115 TYPE_LENGTH (type
) = TYPE_LENGTH (underlying_type
);
16117 if (TYPE_RAW_ALIGN (type
) == 0
16118 && TYPE_RAW_ALIGN (underlying_type
) != 0)
16119 set_type_align (type
, TYPE_RAW_ALIGN (underlying_type
));
16122 type
->set_is_declared_class (dwarf2_flag_true_p (die
, DW_AT_enum_class
, cu
));
16124 set_die_type (die
, type
, cu
);
16126 /* Finish the creation of this type by using the enum's children.
16127 Note that, as usual, this must come after set_die_type to avoid
16128 infinite recursion when trying to compute the names of the
16130 update_enumeration_type_from_children (die
, type
, cu
);
16135 /* Given a pointer to a die which begins an enumeration, process all
16136 the dies that define the members of the enumeration, and create the
16137 symbol for the enumeration type.
16139 NOTE: We reverse the order of the element list. */
16142 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
16144 struct type
*this_type
;
16146 this_type
= get_die_type (die
, cu
);
16147 if (this_type
== NULL
)
16148 this_type
= read_enumeration_type (die
, cu
);
16150 if (die
->child
!= NULL
)
16152 struct die_info
*child_die
;
16155 child_die
= die
->child
;
16156 while (child_die
&& child_die
->tag
)
16158 if (child_die
->tag
!= DW_TAG_enumerator
)
16160 process_die (child_die
, cu
);
16164 name
= dwarf2_name (child_die
, cu
);
16166 new_symbol (child_die
, this_type
, cu
);
16169 child_die
= child_die
->sibling
;
16173 /* If we are reading an enum from a .debug_types unit, and the enum
16174 is a declaration, and the enum is not the signatured type in the
16175 unit, then we do not want to add a symbol for it. Adding a
16176 symbol would in some cases obscure the true definition of the
16177 enum, giving users an incomplete type when the definition is
16178 actually available. Note that we do not want to do this for all
16179 enums which are just declarations, because C++0x allows forward
16180 enum declarations. */
16181 if (cu
->per_cu
->is_debug_types
16182 && die_is_declaration (die
, cu
))
16184 struct signatured_type
*sig_type
;
16186 sig_type
= (struct signatured_type
*) cu
->per_cu
;
16187 gdb_assert (to_underlying (sig_type
->type_offset_in_section
) != 0);
16188 if (sig_type
->type_offset_in_section
!= die
->sect_off
)
16192 new_symbol (die
, this_type
, cu
);
16195 /* Helper function for quirk_ada_thick_pointer that examines a bounds
16196 expression for an index type and finds the corresponding field
16197 offset in the hidden "P_BOUNDS" structure. Returns true on success
16198 and updates *FIELD, false if it fails to recognize an
16202 recognize_bound_expression (struct die_info
*die
, enum dwarf_attribute name
,
16203 int *bounds_offset
, struct field
*field
,
16204 struct dwarf2_cu
*cu
)
16206 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
16207 if (attr
== nullptr || !attr
->form_is_block ())
16210 const struct dwarf_block
*block
= attr
->as_block ();
16211 const gdb_byte
*start
= block
->data
;
16212 const gdb_byte
*end
= block
->data
+ block
->size
;
16214 /* The expression to recognize generally looks like:
16216 (DW_OP_push_object_address; DW_OP_plus_uconst: 8; DW_OP_deref;
16217 DW_OP_plus_uconst: 4; DW_OP_deref_size: 4)
16219 However, the second "plus_uconst" may be missing:
16221 (DW_OP_push_object_address; DW_OP_plus_uconst: 8; DW_OP_deref;
16222 DW_OP_deref_size: 4)
16224 This happens when the field is at the start of the structure.
16226 Also, the final deref may not be sized:
16228 (DW_OP_push_object_address; DW_OP_plus_uconst: 4; DW_OP_deref;
16231 This happens when the size of the index type happens to be the
16232 same as the architecture's word size. This can occur with or
16233 without the second plus_uconst. */
16235 if (end
- start
< 2)
16237 if (*start
++ != DW_OP_push_object_address
)
16239 if (*start
++ != DW_OP_plus_uconst
)
16242 uint64_t this_bound_off
;
16243 start
= gdb_read_uleb128 (start
, end
, &this_bound_off
);
16244 if (start
== nullptr || (int) this_bound_off
!= this_bound_off
)
16246 /* Update *BOUNDS_OFFSET if needed, or alternatively verify that it
16247 is consistent among all bounds. */
16248 if (*bounds_offset
== -1)
16249 *bounds_offset
= this_bound_off
;
16250 else if (*bounds_offset
!= this_bound_off
)
16253 if (start
== end
|| *start
++ != DW_OP_deref
)
16259 else if (*start
== DW_OP_deref_size
|| *start
== DW_OP_deref
)
16261 /* This means an offset of 0. */
16263 else if (*start
++ != DW_OP_plus_uconst
)
16267 /* The size is the parameter to DW_OP_plus_uconst. */
16269 start
= gdb_read_uleb128 (start
, end
, &val
);
16270 if (start
== nullptr)
16272 if ((int) val
!= val
)
16281 if (*start
== DW_OP_deref_size
)
16283 start
= gdb_read_uleb128 (start
+ 1, end
, &size
);
16284 if (start
== nullptr)
16287 else if (*start
== DW_OP_deref
)
16289 size
= cu
->header
.addr_size
;
16295 SET_FIELD_BITPOS (*field
, 8 * offset
);
16296 if (size
!= TYPE_LENGTH (field
->type ()))
16297 FIELD_BITSIZE (*field
) = 8 * size
;
16302 /* With -fgnat-encodings=minimal, gcc will emit some unusual DWARF for
16303 some kinds of Ada arrays:
16305 <1><11db>: Abbrev Number: 7 (DW_TAG_array_type)
16306 <11dc> DW_AT_name : (indirect string, offset: 0x1bb8): string
16307 <11e0> DW_AT_data_location: 2 byte block: 97 6
16308 (DW_OP_push_object_address; DW_OP_deref)
16309 <11e3> DW_AT_type : <0x1173>
16310 <11e7> DW_AT_sibling : <0x1201>
16311 <2><11eb>: Abbrev Number: 8 (DW_TAG_subrange_type)
16312 <11ec> DW_AT_type : <0x1206>
16313 <11f0> DW_AT_lower_bound : 6 byte block: 97 23 8 6 94 4
16314 (DW_OP_push_object_address; DW_OP_plus_uconst: 8; DW_OP_deref;
16315 DW_OP_deref_size: 4)
16316 <11f7> DW_AT_upper_bound : 8 byte block: 97 23 8 6 23 4 94 4
16317 (DW_OP_push_object_address; DW_OP_plus_uconst: 8; DW_OP_deref;
16318 DW_OP_plus_uconst: 4; DW_OP_deref_size: 4)
16320 This actually represents a "thick pointer", which is a structure
16321 with two elements: one that is a pointer to the array data, and one
16322 that is a pointer to another structure; this second structure holds
16325 This returns a new type on success, or nullptr if this didn't
16326 recognize the type. */
16328 static struct type
*
16329 quirk_ada_thick_pointer (struct die_info
*die
, struct dwarf2_cu
*cu
,
16332 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_data_location
, cu
);
16333 /* So far we've only seen this with block form. */
16334 if (attr
== nullptr || !attr
->form_is_block ())
16337 /* Note that this will fail if the structure layout is changed by
16338 the compiler. However, we have no good way to recognize some
16339 other layout, because we don't know what expression the compiler
16340 might choose to emit should this happen. */
16341 struct dwarf_block
*blk
= attr
->as_block ();
16343 || blk
->data
[0] != DW_OP_push_object_address
16344 || blk
->data
[1] != DW_OP_deref
)
16347 int bounds_offset
= -1;
16348 int max_align
= -1;
16349 std::vector
<struct field
> range_fields
;
16350 for (struct die_info
*child_die
= die
->child
;
16352 child_die
= child_die
->sibling
)
16354 if (child_die
->tag
== DW_TAG_subrange_type
)
16356 struct type
*underlying
= read_subrange_index_type (child_die
, cu
);
16358 int this_align
= type_align (underlying
);
16359 if (this_align
> max_align
)
16360 max_align
= this_align
;
16362 range_fields
.emplace_back ();
16363 range_fields
.emplace_back ();
16365 struct field
&lower
= range_fields
[range_fields
.size () - 2];
16366 struct field
&upper
= range_fields
[range_fields
.size () - 1];
16368 lower
.set_type (underlying
);
16369 FIELD_ARTIFICIAL (lower
) = 1;
16371 upper
.set_type (underlying
);
16372 FIELD_ARTIFICIAL (upper
) = 1;
16374 if (!recognize_bound_expression (child_die
, DW_AT_lower_bound
,
16375 &bounds_offset
, &lower
, cu
)
16376 || !recognize_bound_expression (child_die
, DW_AT_upper_bound
,
16377 &bounds_offset
, &upper
, cu
))
16382 /* This shouldn't really happen, but double-check that we found
16383 where the bounds are stored. */
16384 if (bounds_offset
== -1)
16387 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
16388 for (int i
= 0; i
< range_fields
.size (); i
+= 2)
16392 /* Set the name of each field in the bounds. */
16393 xsnprintf (name
, sizeof (name
), "LB%d", i
/ 2);
16394 FIELD_NAME (range_fields
[i
]) = objfile
->intern (name
);
16395 xsnprintf (name
, sizeof (name
), "UB%d", i
/ 2);
16396 FIELD_NAME (range_fields
[i
+ 1]) = objfile
->intern (name
);
16399 struct type
*bounds
= alloc_type (objfile
);
16400 bounds
->set_code (TYPE_CODE_STRUCT
);
16402 bounds
->set_num_fields (range_fields
.size ());
16404 ((struct field
*) TYPE_ALLOC (bounds
, (bounds
->num_fields ()
16405 * sizeof (struct field
))));
16406 memcpy (bounds
->fields (), range_fields
.data (),
16407 bounds
->num_fields () * sizeof (struct field
));
16409 int last_fieldno
= range_fields
.size () - 1;
16410 int bounds_size
= (TYPE_FIELD_BITPOS (bounds
, last_fieldno
) / 8
16411 + TYPE_LENGTH (bounds
->field (last_fieldno
).type ()));
16412 TYPE_LENGTH (bounds
) = align_up (bounds_size
, max_align
);
16414 /* Rewrite the existing array type in place. Specifically, we
16415 remove any dynamic properties we might have read, and we replace
16416 the index types. */
16417 struct type
*iter
= type
;
16418 for (int i
= 0; i
< range_fields
.size (); i
+= 2)
16420 gdb_assert (iter
->code () == TYPE_CODE_ARRAY
);
16421 iter
->main_type
->dyn_prop_list
= nullptr;
16422 iter
->set_index_type
16423 (create_static_range_type (NULL
, bounds
->field (i
).type (), 1, 0));
16424 iter
= TYPE_TARGET_TYPE (iter
);
16427 struct type
*result
= alloc_type (objfile
);
16428 result
->set_code (TYPE_CODE_STRUCT
);
16430 result
->set_num_fields (2);
16432 ((struct field
*) TYPE_ZALLOC (result
, (result
->num_fields ()
16433 * sizeof (struct field
))));
16435 /* The names are chosen to coincide with what the compiler does with
16436 -fgnat-encodings=all, which the Ada code in gdb already
16438 TYPE_FIELD_NAME (result
, 0) = "P_ARRAY";
16439 result
->field (0).set_type (lookup_pointer_type (type
));
16441 TYPE_FIELD_NAME (result
, 1) = "P_BOUNDS";
16442 result
->field (1).set_type (lookup_pointer_type (bounds
));
16443 SET_FIELD_BITPOS (result
->field (1), 8 * bounds_offset
);
16445 result
->set_name (type
->name ());
16446 TYPE_LENGTH (result
) = (TYPE_LENGTH (result
->field (0).type ())
16447 + TYPE_LENGTH (result
->field (1).type ()));
16452 /* Extract all information from a DW_TAG_array_type DIE and put it in
16453 the DIE's type field. For now, this only handles one dimensional
16456 static struct type
*
16457 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16459 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
16460 struct die_info
*child_die
;
16462 struct type
*element_type
, *range_type
, *index_type
;
16463 struct attribute
*attr
;
16465 struct dynamic_prop
*byte_stride_prop
= NULL
;
16466 unsigned int bit_stride
= 0;
16468 element_type
= die_type (die
, cu
);
16470 /* The die_type call above may have already set the type for this DIE. */
16471 type
= get_die_type (die
, cu
);
16475 attr
= dwarf2_attr (die
, DW_AT_byte_stride
, cu
);
16479 struct type
*prop_type
= cu
->addr_sized_int_type (false);
16482 = (struct dynamic_prop
*) alloca (sizeof (struct dynamic_prop
));
16483 stride_ok
= attr_to_dynamic_prop (attr
, die
, cu
, byte_stride_prop
,
16487 complaint (_("unable to read array DW_AT_byte_stride "
16488 " - DIE at %s [in module %s]"),
16489 sect_offset_str (die
->sect_off
),
16490 objfile_name (cu
->per_objfile
->objfile
));
16491 /* Ignore this attribute. We will likely not be able to print
16492 arrays of this type correctly, but there is little we can do
16493 to help if we cannot read the attribute's value. */
16494 byte_stride_prop
= NULL
;
16498 attr
= dwarf2_attr (die
, DW_AT_bit_stride
, cu
);
16500 bit_stride
= attr
->constant_value (0);
16502 /* Irix 6.2 native cc creates array types without children for
16503 arrays with unspecified length. */
16504 if (die
->child
== NULL
)
16506 index_type
= objfile_type (objfile
)->builtin_int
;
16507 range_type
= create_static_range_type (NULL
, index_type
, 0, -1);
16508 type
= create_array_type_with_stride (NULL
, element_type
, range_type
,
16509 byte_stride_prop
, bit_stride
);
16510 return set_die_type (die
, type
, cu
);
16513 std::vector
<struct type
*> range_types
;
16514 child_die
= die
->child
;
16515 while (child_die
&& child_die
->tag
)
16517 if (child_die
->tag
== DW_TAG_subrange_type
)
16519 struct type
*child_type
= read_type_die (child_die
, cu
);
16521 if (child_type
!= NULL
)
16523 /* The range type was succesfully read. Save it for the
16524 array type creation. */
16525 range_types
.push_back (child_type
);
16528 child_die
= child_die
->sibling
;
16531 if (range_types
.empty ())
16533 complaint (_("unable to find array range - DIE at %s [in module %s]"),
16534 sect_offset_str (die
->sect_off
),
16535 objfile_name (cu
->per_objfile
->objfile
));
16539 /* Dwarf2 dimensions are output from left to right, create the
16540 necessary array types in backwards order. */
16542 type
= element_type
;
16544 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
16548 while (i
< range_types
.size ())
16550 type
= create_array_type_with_stride (NULL
, type
, range_types
[i
++],
16551 byte_stride_prop
, bit_stride
);
16553 byte_stride_prop
= nullptr;
16558 size_t ndim
= range_types
.size ();
16561 type
= create_array_type_with_stride (NULL
, type
, range_types
[ndim
],
16562 byte_stride_prop
, bit_stride
);
16564 byte_stride_prop
= nullptr;
16568 gdb_assert (type
!= element_type
);
16570 /* Understand Dwarf2 support for vector types (like they occur on
16571 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
16572 array type. This is not part of the Dwarf2/3 standard yet, but a
16573 custom vendor extension. The main difference between a regular
16574 array and the vector variant is that vectors are passed by value
16576 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
16577 if (attr
!= nullptr)
16578 make_vector_type (type
);
16580 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
16581 implementation may choose to implement triple vectors using this
16583 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16584 if (attr
!= nullptr && attr
->form_is_unsigned ())
16586 if (attr
->as_unsigned () >= TYPE_LENGTH (type
))
16587 TYPE_LENGTH (type
) = attr
->as_unsigned ();
16589 complaint (_("DW_AT_byte_size for array type smaller "
16590 "than the total size of elements"));
16593 name
= dwarf2_name (die
, cu
);
16595 type
->set_name (name
);
16597 maybe_set_alignment (cu
, die
, type
);
16599 struct type
*replacement_type
= nullptr;
16600 if (cu
->per_cu
->lang
== language_ada
)
16602 replacement_type
= quirk_ada_thick_pointer (die
, cu
, type
);
16603 if (replacement_type
!= nullptr)
16604 type
= replacement_type
;
16607 /* Install the type in the die. */
16608 set_die_type (die
, type
, cu
, replacement_type
!= nullptr);
16610 /* set_die_type should be already done. */
16611 set_descriptive_type (type
, die
, cu
);
16616 static enum dwarf_array_dim_ordering
16617 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
16619 struct attribute
*attr
;
16621 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
16623 if (attr
!= nullptr)
16625 LONGEST val
= attr
->constant_value (-1);
16626 if (val
== DW_ORD_row_major
|| val
== DW_ORD_col_major
)
16627 return (enum dwarf_array_dim_ordering
) val
;
16630 /* GNU F77 is a special case, as at 08/2004 array type info is the
16631 opposite order to the dwarf2 specification, but data is still
16632 laid out as per normal fortran.
16634 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
16635 version checking. */
16637 if (cu
->per_cu
->lang
== language_fortran
16638 && cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
16640 return DW_ORD_row_major
;
16643 switch (cu
->language_defn
->array_ordering ())
16645 case array_column_major
:
16646 return DW_ORD_col_major
;
16647 case array_row_major
:
16649 return DW_ORD_row_major
;
16653 /* Extract all information from a DW_TAG_set_type DIE and put it in
16654 the DIE's type field. */
16656 static struct type
*
16657 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16659 struct type
*domain_type
, *set_type
;
16660 struct attribute
*attr
;
16662 domain_type
= die_type (die
, cu
);
16664 /* The die_type call above may have already set the type for this DIE. */
16665 set_type
= get_die_type (die
, cu
);
16669 set_type
= create_set_type (NULL
, domain_type
);
16671 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16672 if (attr
!= nullptr && attr
->form_is_unsigned ())
16673 TYPE_LENGTH (set_type
) = attr
->as_unsigned ();
16675 maybe_set_alignment (cu
, die
, set_type
);
16677 return set_die_type (die
, set_type
, cu
);
16680 /* A helper for read_common_block that creates a locexpr baton.
16681 SYM is the symbol which we are marking as computed.
16682 COMMON_DIE is the DIE for the common block.
16683 COMMON_LOC is the location expression attribute for the common
16685 MEMBER_LOC is the location expression attribute for the particular
16686 member of the common block that we are processing.
16687 CU is the CU from which the above come. */
16690 mark_common_block_symbol_computed (struct symbol
*sym
,
16691 struct die_info
*common_die
,
16692 struct attribute
*common_loc
,
16693 struct attribute
*member_loc
,
16694 struct dwarf2_cu
*cu
)
16696 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
16697 struct objfile
*objfile
= per_objfile
->objfile
;
16698 struct dwarf2_locexpr_baton
*baton
;
16700 unsigned int cu_off
;
16701 enum bfd_endian byte_order
= gdbarch_byte_order (objfile
->arch ());
16702 LONGEST offset
= 0;
16704 gdb_assert (common_loc
&& member_loc
);
16705 gdb_assert (common_loc
->form_is_block ());
16706 gdb_assert (member_loc
->form_is_block ()
16707 || member_loc
->form_is_constant ());
16709 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
16710 baton
->per_objfile
= per_objfile
;
16711 baton
->per_cu
= cu
->per_cu
;
16712 gdb_assert (baton
->per_cu
);
16714 baton
->size
= 5 /* DW_OP_call4 */ + 1 /* DW_OP_plus */;
16716 if (member_loc
->form_is_constant ())
16718 offset
= member_loc
->constant_value (0);
16719 baton
->size
+= 1 /* DW_OP_addr */ + cu
->header
.addr_size
;
16722 baton
->size
+= member_loc
->as_block ()->size
;
16724 ptr
= (gdb_byte
*) obstack_alloc (&objfile
->objfile_obstack
, baton
->size
);
16727 *ptr
++ = DW_OP_call4
;
16728 cu_off
= common_die
->sect_off
- cu
->per_cu
->sect_off
;
16729 store_unsigned_integer (ptr
, 4, byte_order
, cu_off
);
16732 if (member_loc
->form_is_constant ())
16734 *ptr
++ = DW_OP_addr
;
16735 store_unsigned_integer (ptr
, cu
->header
.addr_size
, byte_order
, offset
);
16736 ptr
+= cu
->header
.addr_size
;
16740 /* We have to copy the data here, because DW_OP_call4 will only
16741 use a DW_AT_location attribute. */
16742 struct dwarf_block
*block
= member_loc
->as_block ();
16743 memcpy (ptr
, block
->data
, block
->size
);
16744 ptr
+= block
->size
;
16747 *ptr
++ = DW_OP_plus
;
16748 gdb_assert (ptr
- baton
->data
== baton
->size
);
16750 SYMBOL_LOCATION_BATON (sym
) = baton
;
16751 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
16754 /* Create appropriate locally-scoped variables for all the
16755 DW_TAG_common_block entries. Also create a struct common_block
16756 listing all such variables for `info common'. COMMON_BLOCK_DOMAIN
16757 is used to separate the common blocks name namespace from regular
16761 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
16763 struct attribute
*attr
;
16765 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
16766 if (attr
!= nullptr)
16768 /* Support the .debug_loc offsets. */
16769 if (attr
->form_is_block ())
16773 else if (attr
->form_is_section_offset ())
16775 dwarf2_complex_location_expr_complaint ();
16780 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
16781 "common block member");
16786 if (die
->child
!= NULL
)
16788 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
16789 struct die_info
*child_die
;
16790 size_t n_entries
= 0, size
;
16791 struct common_block
*common_block
;
16792 struct symbol
*sym
;
16794 for (child_die
= die
->child
;
16795 child_die
&& child_die
->tag
;
16796 child_die
= child_die
->sibling
)
16799 size
= (sizeof (struct common_block
)
16800 + (n_entries
- 1) * sizeof (struct symbol
*));
16802 = (struct common_block
*) obstack_alloc (&objfile
->objfile_obstack
,
16804 memset (common_block
->contents
, 0, n_entries
* sizeof (struct symbol
*));
16805 common_block
->n_entries
= 0;
16807 for (child_die
= die
->child
;
16808 child_die
&& child_die
->tag
;
16809 child_die
= child_die
->sibling
)
16811 /* Create the symbol in the DW_TAG_common_block block in the current
16813 sym
= new_symbol (child_die
, NULL
, cu
);
16816 struct attribute
*member_loc
;
16818 common_block
->contents
[common_block
->n_entries
++] = sym
;
16820 member_loc
= dwarf2_attr (child_die
, DW_AT_data_member_location
,
16824 /* GDB has handled this for a long time, but it is
16825 not specified by DWARF. It seems to have been
16826 emitted by gfortran at least as recently as:
16827 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=23057. */
16828 complaint (_("Variable in common block has "
16829 "DW_AT_data_member_location "
16830 "- DIE at %s [in module %s]"),
16831 sect_offset_str (child_die
->sect_off
),
16832 objfile_name (objfile
));
16834 if (member_loc
->form_is_section_offset ())
16835 dwarf2_complex_location_expr_complaint ();
16836 else if (member_loc
->form_is_constant ()
16837 || member_loc
->form_is_block ())
16839 if (attr
!= nullptr)
16840 mark_common_block_symbol_computed (sym
, die
, attr
,
16844 dwarf2_complex_location_expr_complaint ();
16849 sym
= new_symbol (die
, objfile_type (objfile
)->builtin_void
, cu
);
16850 SYMBOL_VALUE_COMMON_BLOCK (sym
) = common_block
;
16854 /* Create a type for a C++ namespace. */
16856 static struct type
*
16857 read_namespace_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16859 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
16860 const char *previous_prefix
, *name
;
16864 /* For extensions, reuse the type of the original namespace. */
16865 if (dwarf2_attr (die
, DW_AT_extension
, cu
) != NULL
)
16867 struct die_info
*ext_die
;
16868 struct dwarf2_cu
*ext_cu
= cu
;
16870 ext_die
= dwarf2_extension (die
, &ext_cu
);
16871 type
= read_type_die (ext_die
, ext_cu
);
16873 /* EXT_CU may not be the same as CU.
16874 Ensure TYPE is recorded with CU in die_type_hash. */
16875 return set_die_type (die
, type
, cu
);
16878 name
= namespace_name (die
, &is_anonymous
, cu
);
16880 /* Now build the name of the current namespace. */
16882 previous_prefix
= determine_prefix (die
, cu
);
16883 if (previous_prefix
[0] != '\0')
16884 name
= typename_concat (&objfile
->objfile_obstack
,
16885 previous_prefix
, name
, 0, cu
);
16887 /* Create the type. */
16888 type
= init_type (objfile
, TYPE_CODE_NAMESPACE
, 0, name
);
16890 return set_die_type (die
, type
, cu
);
16893 /* Read a namespace scope. */
16896 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
16898 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
16901 /* Add a symbol associated to this if we haven't seen the namespace
16902 before. Also, add a using directive if it's an anonymous
16905 if (dwarf2_attr (die
, DW_AT_extension
, cu
) == NULL
)
16909 type
= read_type_die (die
, cu
);
16910 new_symbol (die
, type
, cu
);
16912 namespace_name (die
, &is_anonymous
, cu
);
16915 const char *previous_prefix
= determine_prefix (die
, cu
);
16917 std::vector
<const char *> excludes
;
16918 add_using_directive (using_directives (cu
),
16919 previous_prefix
, type
->name (), NULL
,
16920 NULL
, excludes
, 0, &objfile
->objfile_obstack
);
16924 if (die
->child
!= NULL
)
16926 struct die_info
*child_die
= die
->child
;
16928 while (child_die
&& child_die
->tag
)
16930 process_die (child_die
, cu
);
16931 child_die
= child_die
->sibling
;
16936 /* Read a Fortran module as type. This DIE can be only a declaration used for
16937 imported module. Still we need that type as local Fortran "use ... only"
16938 declaration imports depend on the created type in determine_prefix. */
16940 static struct type
*
16941 read_module_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16943 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
16944 const char *module_name
;
16947 module_name
= dwarf2_name (die
, cu
);
16948 type
= init_type (objfile
, TYPE_CODE_MODULE
, 0, module_name
);
16950 return set_die_type (die
, type
, cu
);
16953 /* Read a Fortran module. */
16956 read_module (struct die_info
*die
, struct dwarf2_cu
*cu
)
16958 struct die_info
*child_die
= die
->child
;
16961 type
= read_type_die (die
, cu
);
16962 new_symbol (die
, type
, cu
);
16964 while (child_die
&& child_die
->tag
)
16966 process_die (child_die
, cu
);
16967 child_die
= child_die
->sibling
;
16971 /* Return the name of the namespace represented by DIE. Set
16972 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
16975 static const char *
16976 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
16978 struct die_info
*current_die
;
16979 const char *name
= NULL
;
16981 /* Loop through the extensions until we find a name. */
16983 for (current_die
= die
;
16984 current_die
!= NULL
;
16985 current_die
= dwarf2_extension (die
, &cu
))
16987 /* We don't use dwarf2_name here so that we can detect the absence
16988 of a name -> anonymous namespace. */
16989 name
= dwarf2_string_attr (die
, DW_AT_name
, cu
);
16995 /* Is it an anonymous namespace? */
16997 *is_anonymous
= (name
== NULL
);
16999 name
= CP_ANONYMOUS_NAMESPACE_STR
;
17004 /* Extract all information from a DW_TAG_pointer_type DIE and add to
17005 the user defined type vector. */
17007 static struct type
*
17008 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17010 struct gdbarch
*gdbarch
= cu
->per_objfile
->objfile
->arch ();
17011 struct comp_unit_head
*cu_header
= &cu
->header
;
17013 struct attribute
*attr_byte_size
;
17014 struct attribute
*attr_address_class
;
17015 int byte_size
, addr_class
;
17016 struct type
*target_type
;
17018 target_type
= die_type (die
, cu
);
17020 /* The die_type call above may have already set the type for this DIE. */
17021 type
= get_die_type (die
, cu
);
17025 type
= lookup_pointer_type (target_type
);
17027 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17028 if (attr_byte_size
)
17029 byte_size
= attr_byte_size
->constant_value (cu_header
->addr_size
);
17031 byte_size
= cu_header
->addr_size
;
17033 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
17034 if (attr_address_class
)
17035 addr_class
= attr_address_class
->constant_value (DW_ADDR_none
);
17037 addr_class
= DW_ADDR_none
;
17039 ULONGEST alignment
= get_alignment (cu
, die
);
17041 /* If the pointer size, alignment, or address class is different
17042 than the default, create a type variant marked as such and set
17043 the length accordingly. */
17044 if (TYPE_LENGTH (type
) != byte_size
17045 || (alignment
!= 0 && TYPE_RAW_ALIGN (type
) != 0
17046 && alignment
!= TYPE_RAW_ALIGN (type
))
17047 || addr_class
!= DW_ADDR_none
)
17049 if (gdbarch_address_class_type_flags_p (gdbarch
))
17051 type_instance_flags type_flags
17052 = gdbarch_address_class_type_flags (gdbarch
, byte_size
,
17054 gdb_assert ((type_flags
& ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
17056 type
= make_type_with_address_space (type
, type_flags
);
17058 else if (TYPE_LENGTH (type
) != byte_size
)
17060 complaint (_("invalid pointer size %d"), byte_size
);
17062 else if (TYPE_RAW_ALIGN (type
) != alignment
)
17064 complaint (_("Invalid DW_AT_alignment"
17065 " - DIE at %s [in module %s]"),
17066 sect_offset_str (die
->sect_off
),
17067 objfile_name (cu
->per_objfile
->objfile
));
17071 /* Should we also complain about unhandled address classes? */
17075 TYPE_LENGTH (type
) = byte_size
;
17076 set_type_align (type
, alignment
);
17077 return set_die_type (die
, type
, cu
);
17080 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
17081 the user defined type vector. */
17083 static struct type
*
17084 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17087 struct type
*to_type
;
17088 struct type
*domain
;
17090 to_type
= die_type (die
, cu
);
17091 domain
= die_containing_type (die
, cu
);
17093 /* The calls above may have already set the type for this DIE. */
17094 type
= get_die_type (die
, cu
);
17098 if (check_typedef (to_type
)->code () == TYPE_CODE_METHOD
)
17099 type
= lookup_methodptr_type (to_type
);
17100 else if (check_typedef (to_type
)->code () == TYPE_CODE_FUNC
)
17102 struct type
*new_type
= alloc_type (cu
->per_objfile
->objfile
);
17104 smash_to_method_type (new_type
, domain
, TYPE_TARGET_TYPE (to_type
),
17105 to_type
->fields (), to_type
->num_fields (),
17106 to_type
->has_varargs ());
17107 type
= lookup_methodptr_type (new_type
);
17110 type
= lookup_memberptr_type (to_type
, domain
);
17112 return set_die_type (die
, type
, cu
);
17115 /* Extract all information from a DW_TAG_{rvalue_,}reference_type DIE and add to
17116 the user defined type vector. */
17118 static struct type
*
17119 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
,
17120 enum type_code refcode
)
17122 struct comp_unit_head
*cu_header
= &cu
->header
;
17123 struct type
*type
, *target_type
;
17124 struct attribute
*attr
;
17126 gdb_assert (refcode
== TYPE_CODE_REF
|| refcode
== TYPE_CODE_RVALUE_REF
);
17128 target_type
= die_type (die
, cu
);
17130 /* The die_type call above may have already set the type for this DIE. */
17131 type
= get_die_type (die
, cu
);
17135 type
= lookup_reference_type (target_type
, refcode
);
17136 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17137 if (attr
!= nullptr)
17139 TYPE_LENGTH (type
) = attr
->constant_value (cu_header
->addr_size
);
17143 TYPE_LENGTH (type
) = cu_header
->addr_size
;
17145 maybe_set_alignment (cu
, die
, type
);
17146 return set_die_type (die
, type
, cu
);
17149 /* Add the given cv-qualifiers to the element type of the array. GCC
17150 outputs DWARF type qualifiers that apply to an array, not the
17151 element type. But GDB relies on the array element type to carry
17152 the cv-qualifiers. This mimics section 6.7.3 of the C99
17155 static struct type
*
17156 add_array_cv_type (struct die_info
*die
, struct dwarf2_cu
*cu
,
17157 struct type
*base_type
, int cnst
, int voltl
)
17159 struct type
*el_type
, *inner_array
;
17161 base_type
= copy_type (base_type
);
17162 inner_array
= base_type
;
17164 while (TYPE_TARGET_TYPE (inner_array
)->code () == TYPE_CODE_ARRAY
)
17166 TYPE_TARGET_TYPE (inner_array
) =
17167 copy_type (TYPE_TARGET_TYPE (inner_array
));
17168 inner_array
= TYPE_TARGET_TYPE (inner_array
);
17171 el_type
= TYPE_TARGET_TYPE (inner_array
);
17172 cnst
|= TYPE_CONST (el_type
);
17173 voltl
|= TYPE_VOLATILE (el_type
);
17174 TYPE_TARGET_TYPE (inner_array
) = make_cv_type (cnst
, voltl
, el_type
, NULL
);
17176 return set_die_type (die
, base_type
, cu
);
17179 static struct type
*
17180 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17182 struct type
*base_type
, *cv_type
;
17184 base_type
= die_type (die
, cu
);
17186 /* The die_type call above may have already set the type for this DIE. */
17187 cv_type
= get_die_type (die
, cu
);
17191 /* In case the const qualifier is applied to an array type, the element type
17192 is so qualified, not the array type (section 6.7.3 of C99). */
17193 if (base_type
->code () == TYPE_CODE_ARRAY
)
17194 return add_array_cv_type (die
, cu
, base_type
, 1, 0);
17196 cv_type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
17197 return set_die_type (die
, cv_type
, cu
);
17200 static struct type
*
17201 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17203 struct type
*base_type
, *cv_type
;
17205 base_type
= die_type (die
, cu
);
17207 /* The die_type call above may have already set the type for this DIE. */
17208 cv_type
= get_die_type (die
, cu
);
17212 /* In case the volatile qualifier is applied to an array type, the
17213 element type is so qualified, not the array type (section 6.7.3
17215 if (base_type
->code () == TYPE_CODE_ARRAY
)
17216 return add_array_cv_type (die
, cu
, base_type
, 0, 1);
17218 cv_type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
17219 return set_die_type (die
, cv_type
, cu
);
17222 /* Handle DW_TAG_restrict_type. */
17224 static struct type
*
17225 read_tag_restrict_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17227 struct type
*base_type
, *cv_type
;
17229 base_type
= die_type (die
, cu
);
17231 /* The die_type call above may have already set the type for this DIE. */
17232 cv_type
= get_die_type (die
, cu
);
17236 cv_type
= make_restrict_type (base_type
);
17237 return set_die_type (die
, cv_type
, cu
);
17240 /* Handle DW_TAG_atomic_type. */
17242 static struct type
*
17243 read_tag_atomic_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17245 struct type
*base_type
, *cv_type
;
17247 base_type
= die_type (die
, cu
);
17249 /* The die_type call above may have already set the type for this DIE. */
17250 cv_type
= get_die_type (die
, cu
);
17254 cv_type
= make_atomic_type (base_type
);
17255 return set_die_type (die
, cv_type
, cu
);
17258 /* Extract all information from a DW_TAG_string_type DIE and add to
17259 the user defined type vector. It isn't really a user defined type,
17260 but it behaves like one, with other DIE's using an AT_user_def_type
17261 attribute to reference it. */
17263 static struct type
*
17264 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17266 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17267 struct gdbarch
*gdbarch
= objfile
->arch ();
17268 struct type
*type
, *range_type
, *index_type
, *char_type
;
17269 struct attribute
*attr
;
17270 struct dynamic_prop prop
;
17271 bool length_is_constant
= true;
17274 /* There are a couple of places where bit sizes might be made use of
17275 when parsing a DW_TAG_string_type, however, no producer that we know
17276 of make use of these. Handling bit sizes that are a multiple of the
17277 byte size is easy enough, but what about other bit sizes? Lets deal
17278 with that problem when we have to. Warn about these attributes being
17279 unsupported, then parse the type and ignore them like we always
17281 if (dwarf2_attr (die
, DW_AT_bit_size
, cu
) != nullptr
17282 || dwarf2_attr (die
, DW_AT_string_length_bit_size
, cu
) != nullptr)
17284 static bool warning_printed
= false;
17285 if (!warning_printed
)
17287 warning (_("DW_AT_bit_size and DW_AT_string_length_bit_size not "
17288 "currently supported on DW_TAG_string_type."));
17289 warning_printed
= true;
17293 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
17294 if (attr
!= nullptr && !attr
->form_is_constant ())
17296 /* The string length describes the location at which the length of
17297 the string can be found. The size of the length field can be
17298 specified with one of the attributes below. */
17299 struct type
*prop_type
;
17300 struct attribute
*len
17301 = dwarf2_attr (die
, DW_AT_string_length_byte_size
, cu
);
17302 if (len
== nullptr)
17303 len
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17304 if (len
!= nullptr && len
->form_is_constant ())
17306 /* Pass 0 as the default as we know this attribute is constant
17307 and the default value will not be returned. */
17308 LONGEST sz
= len
->constant_value (0);
17309 prop_type
= cu
->per_objfile
->int_type (sz
, true);
17313 /* If the size is not specified then we assume it is the size of
17314 an address on this target. */
17315 prop_type
= cu
->addr_sized_int_type (true);
17318 /* Convert the attribute into a dynamic property. */
17319 if (!attr_to_dynamic_prop (attr
, die
, cu
, &prop
, prop_type
))
17322 length_is_constant
= false;
17324 else if (attr
!= nullptr)
17326 /* This DW_AT_string_length just contains the length with no
17327 indirection. There's no need to create a dynamic property in this
17328 case. Pass 0 for the default value as we know it will not be
17329 returned in this case. */
17330 length
= attr
->constant_value (0);
17332 else if ((attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
)) != nullptr)
17334 /* We don't currently support non-constant byte sizes for strings. */
17335 length
= attr
->constant_value (1);
17339 /* Use 1 as a fallback length if we have nothing else. */
17343 index_type
= objfile_type (objfile
)->builtin_int
;
17344 if (length_is_constant
)
17345 range_type
= create_static_range_type (NULL
, index_type
, 1, length
);
17348 struct dynamic_prop low_bound
;
17350 low_bound
.set_const_val (1);
17351 range_type
= create_range_type (NULL
, index_type
, &low_bound
, &prop
, 0);
17353 char_type
= language_string_char_type (cu
->language_defn
, gdbarch
);
17354 type
= create_string_type (NULL
, char_type
, range_type
);
17356 return set_die_type (die
, type
, cu
);
17359 /* Assuming that DIE corresponds to a function, returns nonzero
17360 if the function is prototyped. */
17363 prototyped_function_p (struct die_info
*die
, struct dwarf2_cu
*cu
)
17365 struct attribute
*attr
;
17367 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
17368 if (attr
&& attr
->as_boolean ())
17371 /* The DWARF standard implies that the DW_AT_prototyped attribute
17372 is only meaningful for C, but the concept also extends to other
17373 languages that allow unprototyped functions (Eg: Objective C).
17374 For all other languages, assume that functions are always
17376 if (cu
->per_cu
->lang
!= language_c
17377 && cu
->per_cu
->lang
!= language_objc
17378 && cu
->per_cu
->lang
!= language_opencl
)
17381 /* RealView does not emit DW_AT_prototyped. We can not distinguish
17382 prototyped and unprototyped functions; default to prototyped,
17383 since that is more common in modern code (and RealView warns
17384 about unprototyped functions). */
17385 if (producer_is_realview (cu
->producer
))
17391 /* Handle DIES due to C code like:
17395 int (*funcp)(int a, long l);
17399 ('funcp' generates a DW_TAG_subroutine_type DIE). */
17401 static struct type
*
17402 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17404 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17405 struct type
*type
; /* Type that this function returns. */
17406 struct type
*ftype
; /* Function that returns above type. */
17407 struct attribute
*attr
;
17409 type
= die_type (die
, cu
);
17411 /* The die_type call above may have already set the type for this DIE. */
17412 ftype
= get_die_type (die
, cu
);
17416 ftype
= lookup_function_type (type
);
17418 if (prototyped_function_p (die
, cu
))
17419 ftype
->set_is_prototyped (true);
17421 /* Store the calling convention in the type if it's available in
17422 the subroutine die. Otherwise set the calling convention to
17423 the default value DW_CC_normal. */
17424 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
17425 if (attr
!= nullptr
17426 && is_valid_DW_AT_calling_convention_for_subroutine (attr
->constant_value (0)))
17427 TYPE_CALLING_CONVENTION (ftype
)
17428 = (enum dwarf_calling_convention
) attr
->constant_value (0);
17429 else if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL"))
17430 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_GDB_IBM_OpenCL
;
17432 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_normal
;
17434 /* Record whether the function returns normally to its caller or not
17435 if the DWARF producer set that information. */
17436 attr
= dwarf2_attr (die
, DW_AT_noreturn
, cu
);
17437 if (attr
&& attr
->as_boolean ())
17438 TYPE_NO_RETURN (ftype
) = 1;
17440 /* We need to add the subroutine type to the die immediately so
17441 we don't infinitely recurse when dealing with parameters
17442 declared as the same subroutine type. */
17443 set_die_type (die
, ftype
, cu
);
17445 if (die
->child
!= NULL
)
17447 struct type
*void_type
= objfile_type (objfile
)->builtin_void
;
17448 struct die_info
*child_die
;
17449 int nparams
, iparams
;
17451 /* Count the number of parameters.
17452 FIXME: GDB currently ignores vararg functions, but knows about
17453 vararg member functions. */
17455 child_die
= die
->child
;
17456 while (child_die
&& child_die
->tag
)
17458 if (child_die
->tag
== DW_TAG_formal_parameter
)
17460 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
17461 ftype
->set_has_varargs (true);
17463 child_die
= child_die
->sibling
;
17466 /* Allocate storage for parameters and fill them in. */
17467 ftype
->set_num_fields (nparams
);
17469 ((struct field
*) TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
)));
17471 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
17472 even if we error out during the parameters reading below. */
17473 for (iparams
= 0; iparams
< nparams
; iparams
++)
17474 ftype
->field (iparams
).set_type (void_type
);
17477 child_die
= die
->child
;
17478 while (child_die
&& child_die
->tag
)
17480 if (child_die
->tag
== DW_TAG_formal_parameter
)
17482 struct type
*arg_type
;
17484 /* DWARF version 2 has no clean way to discern C++
17485 static and non-static member functions. G++ helps
17486 GDB by marking the first parameter for non-static
17487 member functions (which is the this pointer) as
17488 artificial. We pass this information to
17489 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
17491 DWARF version 3 added DW_AT_object_pointer, which GCC
17492 4.5 does not yet generate. */
17493 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
17494 if (attr
!= nullptr)
17495 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = attr
->as_boolean ();
17497 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
17498 arg_type
= die_type (child_die
, cu
);
17500 /* RealView does not mark THIS as const, which the testsuite
17501 expects. GCC marks THIS as const in method definitions,
17502 but not in the class specifications (GCC PR 43053). */
17503 if (cu
->per_cu
->lang
== language_cplus
17504 && !TYPE_CONST (arg_type
)
17505 && TYPE_FIELD_ARTIFICIAL (ftype
, iparams
))
17508 struct dwarf2_cu
*arg_cu
= cu
;
17509 const char *name
= dwarf2_name (child_die
, cu
);
17511 attr
= dwarf2_attr (die
, DW_AT_object_pointer
, cu
);
17512 if (attr
!= nullptr)
17514 /* If the compiler emits this, use it. */
17515 if (follow_die_ref (die
, attr
, &arg_cu
) == child_die
)
17518 else if (name
&& strcmp (name
, "this") == 0)
17519 /* Function definitions will have the argument names. */
17521 else if (name
== NULL
&& iparams
== 0)
17522 /* Declarations may not have the names, so like
17523 elsewhere in GDB, assume an artificial first
17524 argument is "this". */
17528 arg_type
= make_cv_type (1, TYPE_VOLATILE (arg_type
),
17532 ftype
->field (iparams
).set_type (arg_type
);
17535 child_die
= child_die
->sibling
;
17542 static struct type
*
17543 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
17545 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17546 const char *name
= NULL
;
17547 struct type
*this_type
, *target_type
;
17549 name
= dwarf2_full_name (NULL
, die
, cu
);
17550 this_type
= init_type (objfile
, TYPE_CODE_TYPEDEF
, 0, name
);
17551 this_type
->set_target_is_stub (true);
17552 set_die_type (die
, this_type
, cu
);
17553 target_type
= die_type (die
, cu
);
17554 if (target_type
!= this_type
)
17555 TYPE_TARGET_TYPE (this_type
) = target_type
;
17558 /* Self-referential typedefs are, it seems, not allowed by the DWARF
17559 spec and cause infinite loops in GDB. */
17560 complaint (_("Self-referential DW_TAG_typedef "
17561 "- DIE at %s [in module %s]"),
17562 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
17563 TYPE_TARGET_TYPE (this_type
) = NULL
;
17567 /* Gcc-7 and before supports -feliminate-dwarf2-dups, which generates
17568 anonymous typedefs, which is, strictly speaking, invalid DWARF.
17569 Handle these by just returning the target type, rather than
17570 constructing an anonymous typedef type and trying to handle this
17572 set_die_type (die
, target_type
, cu
);
17573 return target_type
;
17578 /* Helper for get_dwarf2_rational_constant that computes the value of
17579 a given gmp_mpz given an attribute. */
17582 get_mpz (struct dwarf2_cu
*cu
, gdb_mpz
*value
, struct attribute
*attr
)
17584 /* GCC will sometimes emit a 16-byte constant value as a DWARF
17585 location expression that pushes an implicit value. */
17586 if (attr
->form
== DW_FORM_exprloc
)
17588 dwarf_block
*blk
= attr
->as_block ();
17589 if (blk
->size
> 0 && blk
->data
[0] == DW_OP_implicit_value
)
17592 const gdb_byte
*ptr
= safe_read_uleb128 (blk
->data
+ 1,
17593 blk
->data
+ blk
->size
,
17595 if (ptr
- blk
->data
+ len
<= blk
->size
)
17597 mpz_import (value
->val
, len
,
17598 bfd_big_endian (cu
->per_objfile
->objfile
->obfd
) ? 1 : -1,
17604 /* On failure set it to 1. */
17605 *value
= gdb_mpz (1);
17607 else if (attr
->form_is_block ())
17609 dwarf_block
*blk
= attr
->as_block ();
17610 mpz_import (value
->val
, blk
->size
,
17611 bfd_big_endian (cu
->per_objfile
->objfile
->obfd
) ? 1 : -1,
17612 1, 0, 0, blk
->data
);
17615 *value
= gdb_mpz (attr
->constant_value (1));
17618 /* Assuming DIE is a rational DW_TAG_constant, read the DIE's
17619 numerator and denominator into NUMERATOR and DENOMINATOR (resp).
17621 If the numerator and/or numerator attribute is missing,
17622 a complaint is filed, and NUMERATOR and DENOMINATOR are left
17626 get_dwarf2_rational_constant (struct die_info
*die
, struct dwarf2_cu
*cu
,
17627 gdb_mpz
*numerator
, gdb_mpz
*denominator
)
17629 struct attribute
*num_attr
, *denom_attr
;
17631 num_attr
= dwarf2_attr (die
, DW_AT_GNU_numerator
, cu
);
17632 if (num_attr
== nullptr)
17633 complaint (_("DW_AT_GNU_numerator missing in %s DIE at %s"),
17634 dwarf_tag_name (die
->tag
), sect_offset_str (die
->sect_off
));
17636 denom_attr
= dwarf2_attr (die
, DW_AT_GNU_denominator
, cu
);
17637 if (denom_attr
== nullptr)
17638 complaint (_("DW_AT_GNU_denominator missing in %s DIE at %s"),
17639 dwarf_tag_name (die
->tag
), sect_offset_str (die
->sect_off
));
17641 if (num_attr
== nullptr || denom_attr
== nullptr)
17644 get_mpz (cu
, numerator
, num_attr
);
17645 get_mpz (cu
, denominator
, denom_attr
);
17648 /* Same as get_dwarf2_rational_constant, but extracting an unsigned
17649 rational constant, rather than a signed one.
17651 If the rational constant has a negative value, a complaint
17652 is filed, and NUMERATOR and DENOMINATOR are left untouched. */
17655 get_dwarf2_unsigned_rational_constant (struct die_info
*die
,
17656 struct dwarf2_cu
*cu
,
17657 gdb_mpz
*numerator
,
17658 gdb_mpz
*denominator
)
17663 get_dwarf2_rational_constant (die
, cu
, &num
, &denom
);
17664 if (mpz_sgn (num
.val
) == -1 && mpz_sgn (denom
.val
) == -1)
17666 mpz_neg (num
.val
, num
.val
);
17667 mpz_neg (denom
.val
, denom
.val
);
17669 else if (mpz_sgn (num
.val
) == -1)
17671 complaint (_("unexpected negative value for DW_AT_GNU_numerator"
17673 sect_offset_str (die
->sect_off
));
17676 else if (mpz_sgn (denom
.val
) == -1)
17678 complaint (_("unexpected negative value for DW_AT_GNU_denominator"
17680 sect_offset_str (die
->sect_off
));
17684 *numerator
= std::move (num
);
17685 *denominator
= std::move (denom
);
17688 /* Assuming that ENCODING is a string whose contents starting at the
17689 K'th character is "_nn" where "nn" is a decimal number, scan that
17690 number and set RESULT to the value. K is updated to point to the
17691 character immediately following the number.
17693 If the string does not conform to the format described above, false
17694 is returned, and K may or may not be changed. */
17697 ada_get_gnat_encoded_number (const char *encoding
, int &k
, gdb_mpz
*result
)
17699 /* The next character should be an underscore ('_') followed
17701 if (encoding
[k
] != '_' || !isdigit (encoding
[k
+ 1]))
17704 /* Skip the underscore. */
17708 /* Determine the number of digits for our number. */
17709 while (isdigit (encoding
[k
]))
17714 std::string
copy (&encoding
[start
], k
- start
);
17715 if (mpz_set_str (result
->val
, copy
.c_str (), 10) == -1)
17721 /* Scan two numbers from ENCODING at OFFSET, assuming the string is of
17722 the form _NN_DD, where NN and DD are decimal numbers. Set NUM and
17723 DENOM, update OFFSET, and return true on success. Return false on
17727 ada_get_gnat_encoded_ratio (const char *encoding
, int &offset
,
17728 gdb_mpz
*num
, gdb_mpz
*denom
)
17730 if (!ada_get_gnat_encoded_number (encoding
, offset
, num
))
17732 return ada_get_gnat_encoded_number (encoding
, offset
, denom
);
17735 /* Assuming DIE corresponds to a fixed point type, finish the creation
17736 of the corresponding TYPE by setting its type-specific data. CU is
17737 the DIE's CU. SUFFIX is the "XF" type name suffix coming from GNAT
17738 encodings. It is nullptr if the GNAT encoding should be
17742 finish_fixed_point_type (struct type
*type
, const char *suffix
,
17743 struct die_info
*die
, struct dwarf2_cu
*cu
)
17745 gdb_assert (type
->code () == TYPE_CODE_FIXED_POINT
17746 && TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_FIXED_POINT
);
17748 /* If GNAT encodings are preferred, don't examine the
17750 struct attribute
*attr
= nullptr;
17751 if (suffix
== nullptr)
17753 attr
= dwarf2_attr (die
, DW_AT_binary_scale
, cu
);
17754 if (attr
== nullptr)
17755 attr
= dwarf2_attr (die
, DW_AT_decimal_scale
, cu
);
17756 if (attr
== nullptr)
17757 attr
= dwarf2_attr (die
, DW_AT_small
, cu
);
17760 /* Numerator and denominator of our fixed-point type's scaling factor.
17761 The default is a scaling factor of 1, which we use as a fallback
17762 when we are not able to decode it (problem with the debugging info,
17763 unsupported forms, bug in GDB, etc...). Using that as the default
17764 allows us to at least print the unscaled value, which might still
17765 be useful to a user. */
17766 gdb_mpz
scale_num (1);
17767 gdb_mpz
scale_denom (1);
17769 if (attr
== nullptr)
17772 if (suffix
!= nullptr
17773 && ada_get_gnat_encoded_ratio (suffix
, offset
, &scale_num
,
17775 /* The number might be encoded as _nn_dd_nn_dd, where the
17776 second ratio is the 'small value. In this situation, we
17777 want the second value. */
17778 && (suffix
[offset
] != '_'
17779 || ada_get_gnat_encoded_ratio (suffix
, offset
, &scale_num
,
17786 /* Scaling factor not found. Assume a scaling factor of 1,
17787 and hope for the best. At least the user will be able to
17788 see the encoded value. */
17791 complaint (_("no scale found for fixed-point type (DIE at %s)"),
17792 sect_offset_str (die
->sect_off
));
17795 else if (attr
->name
== DW_AT_binary_scale
)
17797 LONGEST scale_exp
= attr
->constant_value (0);
17798 gdb_mpz
*num_or_denom
= scale_exp
> 0 ? &scale_num
: &scale_denom
;
17800 mpz_mul_2exp (num_or_denom
->val
, num_or_denom
->val
, std::abs (scale_exp
));
17802 else if (attr
->name
== DW_AT_decimal_scale
)
17804 LONGEST scale_exp
= attr
->constant_value (0);
17805 gdb_mpz
*num_or_denom
= scale_exp
> 0 ? &scale_num
: &scale_denom
;
17807 mpz_ui_pow_ui (num_or_denom
->val
, 10, std::abs (scale_exp
));
17809 else if (attr
->name
== DW_AT_small
)
17811 struct die_info
*scale_die
;
17812 struct dwarf2_cu
*scale_cu
= cu
;
17814 scale_die
= follow_die_ref (die
, attr
, &scale_cu
);
17815 if (scale_die
->tag
== DW_TAG_constant
)
17816 get_dwarf2_unsigned_rational_constant (scale_die
, scale_cu
,
17817 &scale_num
, &scale_denom
);
17819 complaint (_("%s DIE not supported as target of DW_AT_small attribute"
17821 dwarf_tag_name (die
->tag
), sect_offset_str (die
->sect_off
));
17825 complaint (_("unsupported scale attribute %s for fixed-point type"
17827 dwarf_attr_name (attr
->name
),
17828 sect_offset_str (die
->sect_off
));
17831 gdb_mpq
&scaling_factor
= type
->fixed_point_info ().scaling_factor
;
17832 mpz_set (mpq_numref (scaling_factor
.val
), scale_num
.val
);
17833 mpz_set (mpq_denref (scaling_factor
.val
), scale_denom
.val
);
17834 mpq_canonicalize (scaling_factor
.val
);
17837 /* The gnat-encoding suffix for fixed point. */
17839 #define GNAT_FIXED_POINT_SUFFIX "___XF_"
17841 /* If NAME encodes an Ada fixed-point type, return a pointer to the
17842 "XF" suffix of the name. The text after this is what encodes the
17843 'small and 'delta information. Otherwise, return nullptr. */
17845 static const char *
17846 gnat_encoded_fixed_point_type_info (const char *name
)
17848 return strstr (name
, GNAT_FIXED_POINT_SUFFIX
);
17851 /* Allocate a floating-point type of size BITS and name NAME. Pass NAME_HINT
17852 (which may be different from NAME) to the architecture back-end to allow
17853 it to guess the correct format if necessary. */
17855 static struct type
*
17856 dwarf2_init_float_type (struct objfile
*objfile
, int bits
, const char *name
,
17857 const char *name_hint
, enum bfd_endian byte_order
)
17859 struct gdbarch
*gdbarch
= objfile
->arch ();
17860 const struct floatformat
**format
;
17863 format
= gdbarch_floatformat_for_type (gdbarch
, name_hint
, bits
);
17865 type
= init_float_type (objfile
, bits
, name
, format
, byte_order
);
17867 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
, name
);
17872 /* Allocate an integer type of size BITS and name NAME. */
17874 static struct type
*
17875 dwarf2_init_integer_type (struct dwarf2_cu
*cu
, struct objfile
*objfile
,
17876 int bits
, int unsigned_p
, const char *name
)
17880 /* Versions of Intel's C Compiler generate an integer type called "void"
17881 instead of using DW_TAG_unspecified_type. This has been seen on
17882 at least versions 14, 17, and 18. */
17883 if (bits
== 0 && producer_is_icc (cu
) && name
!= nullptr
17884 && strcmp (name
, "void") == 0)
17885 type
= objfile_type (objfile
)->builtin_void
;
17887 type
= init_integer_type (objfile
, bits
, unsigned_p
, name
);
17892 /* Return true if DIE has a DW_AT_small attribute whose value is
17893 a constant rational, where both the numerator and denominator
17896 CU is the DIE's Compilation Unit. */
17899 has_zero_over_zero_small_attribute (struct die_info
*die
,
17900 struct dwarf2_cu
*cu
)
17902 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_small
, cu
);
17903 if (attr
== nullptr)
17906 struct dwarf2_cu
*scale_cu
= cu
;
17907 struct die_info
*scale_die
17908 = follow_die_ref (die
, attr
, &scale_cu
);
17910 if (scale_die
->tag
!= DW_TAG_constant
)
17913 gdb_mpz
num (1), denom (1);
17914 get_dwarf2_rational_constant (scale_die
, cu
, &num
, &denom
);
17915 return mpz_sgn (num
.val
) == 0 && mpz_sgn (denom
.val
) == 0;
17918 /* Initialise and return a floating point type of size BITS suitable for
17919 use as a component of a complex number. The NAME_HINT is passed through
17920 when initialising the floating point type and is the name of the complex
17923 As DWARF doesn't currently provide an explicit name for the components
17924 of a complex number, but it can be helpful to have these components
17925 named, we try to select a suitable name based on the size of the
17927 static struct type
*
17928 dwarf2_init_complex_target_type (struct dwarf2_cu
*cu
,
17929 struct objfile
*objfile
,
17930 int bits
, const char *name_hint
,
17931 enum bfd_endian byte_order
)
17933 gdbarch
*gdbarch
= objfile
->arch ();
17934 struct type
*tt
= nullptr;
17936 /* Try to find a suitable floating point builtin type of size BITS.
17937 We're going to use the name of this type as the name for the complex
17938 target type that we are about to create. */
17939 switch (cu
->per_cu
->lang
)
17941 case language_fortran
:
17945 tt
= builtin_f_type (gdbarch
)->builtin_real
;
17948 tt
= builtin_f_type (gdbarch
)->builtin_real_s8
;
17950 case 96: /* The x86-32 ABI specifies 96-bit long double. */
17952 tt
= builtin_f_type (gdbarch
)->builtin_real_s16
;
17960 tt
= builtin_type (gdbarch
)->builtin_float
;
17963 tt
= builtin_type (gdbarch
)->builtin_double
;
17965 case 96: /* The x86-32 ABI specifies 96-bit long double. */
17967 tt
= builtin_type (gdbarch
)->builtin_long_double
;
17973 /* If the type we found doesn't match the size we were looking for, then
17974 pretend we didn't find a type at all, the complex target type we
17975 create will then be nameless. */
17976 if (tt
!= nullptr && TYPE_LENGTH (tt
) * TARGET_CHAR_BIT
!= bits
)
17979 const char *name
= (tt
== nullptr) ? nullptr : tt
->name ();
17980 return dwarf2_init_float_type (objfile
, bits
, name
, name_hint
, byte_order
);
17983 /* Find a representation of a given base type and install
17984 it in the TYPE field of the die. */
17986 static struct type
*
17987 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17989 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17991 struct attribute
*attr
;
17992 int encoding
= 0, bits
= 0;
17996 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
17997 if (attr
!= nullptr && attr
->form_is_constant ())
17998 encoding
= attr
->constant_value (0);
17999 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
18000 if (attr
!= nullptr)
18001 bits
= attr
->constant_value (0) * TARGET_CHAR_BIT
;
18002 name
= dwarf2_name (die
, cu
);
18004 complaint (_("DW_AT_name missing from DW_TAG_base_type"));
18006 arch
= objfile
->arch ();
18007 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
18009 attr
= dwarf2_attr (die
, DW_AT_endianity
, cu
);
18010 if (attr
!= nullptr && attr
->form_is_constant ())
18012 int endianity
= attr
->constant_value (0);
18017 byte_order
= BFD_ENDIAN_BIG
;
18019 case DW_END_little
:
18020 byte_order
= BFD_ENDIAN_LITTLE
;
18023 complaint (_("DW_AT_endianity has unrecognized value %d"), endianity
);
18028 if ((encoding
== DW_ATE_signed_fixed
|| encoding
== DW_ATE_unsigned_fixed
)
18029 && cu
->per_cu
->lang
== language_ada
18030 && has_zero_over_zero_small_attribute (die
, cu
))
18032 /* brobecker/2018-02-24: This is a fixed point type for which
18033 the scaling factor is represented as fraction whose value
18034 does not make sense (zero divided by zero), so we should
18035 normally never see these. However, there is a small category
18036 of fixed point types for which GNAT is unable to provide
18037 the scaling factor via the standard DWARF mechanisms, and
18038 for which the info is provided via the GNAT encodings instead.
18039 This is likely what this DIE is about. */
18040 encoding
= (encoding
== DW_ATE_signed_fixed
18042 : DW_ATE_unsigned
);
18045 /* With GNAT encodings, fixed-point information will be encoded in
18046 the type name. Note that this can also occur with the above
18047 zero-over-zero case, which is why this is a separate "if" rather
18048 than an "else if". */
18049 const char *gnat_encoding_suffix
= nullptr;
18050 if ((encoding
== DW_ATE_signed
|| encoding
== DW_ATE_unsigned
)
18051 && cu
->per_cu
->lang
== language_ada
18052 && name
!= nullptr)
18054 gnat_encoding_suffix
= gnat_encoded_fixed_point_type_info (name
);
18055 if (gnat_encoding_suffix
!= nullptr)
18057 gdb_assert (startswith (gnat_encoding_suffix
,
18058 GNAT_FIXED_POINT_SUFFIX
));
18059 name
= obstack_strndup (&cu
->per_objfile
->objfile
->objfile_obstack
,
18060 name
, gnat_encoding_suffix
- name
);
18061 /* Use -1 here so that SUFFIX points at the "_" after the
18063 gnat_encoding_suffix
+= strlen (GNAT_FIXED_POINT_SUFFIX
) - 1;
18065 encoding
= (encoding
== DW_ATE_signed
18066 ? DW_ATE_signed_fixed
18067 : DW_ATE_unsigned_fixed
);
18073 case DW_ATE_address
:
18074 /* Turn DW_ATE_address into a void * pointer. */
18075 type
= init_type (objfile
, TYPE_CODE_VOID
, TARGET_CHAR_BIT
, NULL
);
18076 type
= init_pointer_type (objfile
, bits
, name
, type
);
18078 case DW_ATE_boolean
:
18079 type
= init_boolean_type (objfile
, bits
, 1, name
);
18081 case DW_ATE_complex_float
:
18082 type
= dwarf2_init_complex_target_type (cu
, objfile
, bits
/ 2, name
,
18084 if (type
->code () == TYPE_CODE_ERROR
)
18086 if (name
== nullptr)
18088 struct obstack
*obstack
18089 = &cu
->per_objfile
->objfile
->objfile_obstack
;
18090 name
= obconcat (obstack
, "_Complex ", type
->name (),
18093 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
, name
);
18096 type
= init_complex_type (name
, type
);
18098 case DW_ATE_decimal_float
:
18099 type
= init_decfloat_type (objfile
, bits
, name
);
18102 type
= dwarf2_init_float_type (objfile
, bits
, name
, name
, byte_order
);
18104 case DW_ATE_signed
:
18105 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 0, name
);
18107 case DW_ATE_unsigned
:
18108 if (cu
->per_cu
->lang
== language_fortran
18110 && startswith (name
, "character("))
18111 type
= init_character_type (objfile
, bits
, 1, name
);
18113 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 1, name
);
18115 case DW_ATE_signed_char
:
18116 if (cu
->per_cu
->lang
== language_ada
18117 || cu
->per_cu
->lang
== language_m2
18118 || cu
->per_cu
->lang
== language_pascal
18119 || cu
->per_cu
->lang
== language_fortran
)
18120 type
= init_character_type (objfile
, bits
, 0, name
);
18122 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 0, name
);
18124 case DW_ATE_unsigned_char
:
18125 if (cu
->per_cu
->lang
== language_ada
18126 || cu
->per_cu
->lang
== language_m2
18127 || cu
->per_cu
->lang
== language_pascal
18128 || cu
->per_cu
->lang
== language_fortran
18129 || cu
->per_cu
->lang
== language_rust
)
18130 type
= init_character_type (objfile
, bits
, 1, name
);
18132 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 1, name
);
18137 type
= builtin_type (arch
)->builtin_char16
;
18138 else if (bits
== 32)
18139 type
= builtin_type (arch
)->builtin_char32
;
18142 complaint (_("unsupported DW_ATE_UTF bit size: '%d'"),
18144 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 1, name
);
18146 return set_die_type (die
, type
, cu
);
18149 case DW_ATE_signed_fixed
:
18150 type
= init_fixed_point_type (objfile
, bits
, 0, name
);
18151 finish_fixed_point_type (type
, gnat_encoding_suffix
, die
, cu
);
18153 case DW_ATE_unsigned_fixed
:
18154 type
= init_fixed_point_type (objfile
, bits
, 1, name
);
18155 finish_fixed_point_type (type
, gnat_encoding_suffix
, die
, cu
);
18159 complaint (_("unsupported DW_AT_encoding: '%s'"),
18160 dwarf_type_encoding_name (encoding
));
18161 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
, name
);
18165 if (name
&& strcmp (name
, "char") == 0)
18166 type
->set_has_no_signedness (true);
18168 maybe_set_alignment (cu
, die
, type
);
18170 type
->set_endianity_is_not_default (gdbarch_byte_order (arch
) != byte_order
);
18172 if (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_INT
)
18174 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
18175 if (attr
!= nullptr && attr
->as_unsigned () <= 8 * TYPE_LENGTH (type
))
18177 unsigned real_bit_size
= attr
->as_unsigned ();
18178 attr
= dwarf2_attr (die
, DW_AT_data_bit_offset
, cu
);
18179 /* Only use the attributes if they make sense together. */
18180 if (attr
== nullptr
18181 || (attr
->as_unsigned () + real_bit_size
18182 <= 8 * TYPE_LENGTH (type
)))
18184 TYPE_MAIN_TYPE (type
)->type_specific
.int_stuff
.bit_size
18186 if (attr
!= nullptr)
18187 TYPE_MAIN_TYPE (type
)->type_specific
.int_stuff
.bit_offset
18188 = attr
->as_unsigned ();
18193 return set_die_type (die
, type
, cu
);
18196 /* A helper function that returns the name of DIE, if it refers to a
18197 variable declaration. */
18199 static const char *
18200 var_decl_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
18202 if (die
->tag
!= DW_TAG_variable
)
18205 attribute
*attr
= dwarf2_attr (die
, DW_AT_declaration
, cu
);
18206 if (attr
== nullptr || !attr
->as_boolean ())
18209 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
18210 if (attr
== nullptr)
18212 return attr
->as_string ();
18215 /* Parse dwarf attribute if it's a block, reference or constant and put the
18216 resulting value of the attribute into struct bound_prop.
18217 Returns 1 if ATTR could be resolved into PROP, 0 otherwise. */
18220 attr_to_dynamic_prop (const struct attribute
*attr
, struct die_info
*die
,
18221 struct dwarf2_cu
*cu
, struct dynamic_prop
*prop
,
18222 struct type
*default_type
)
18224 struct dwarf2_property_baton
*baton
;
18225 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
18226 struct objfile
*objfile
= per_objfile
->objfile
;
18227 struct obstack
*obstack
= &objfile
->objfile_obstack
;
18229 gdb_assert (default_type
!= NULL
);
18231 if (attr
== NULL
|| prop
== NULL
)
18234 if (attr
->form_is_block ())
18236 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
18237 baton
->property_type
= default_type
;
18238 baton
->locexpr
.per_cu
= cu
->per_cu
;
18239 baton
->locexpr
.per_objfile
= per_objfile
;
18241 struct dwarf_block
*block
= attr
->as_block ();
18242 baton
->locexpr
.size
= block
->size
;
18243 baton
->locexpr
.data
= block
->data
;
18244 switch (attr
->name
)
18246 case DW_AT_string_length
:
18247 baton
->locexpr
.is_reference
= true;
18250 baton
->locexpr
.is_reference
= false;
18254 prop
->set_locexpr (baton
);
18255 gdb_assert (prop
->baton () != NULL
);
18257 else if (attr
->form_is_ref ())
18259 struct dwarf2_cu
*target_cu
= cu
;
18260 struct die_info
*target_die
;
18261 struct attribute
*target_attr
;
18263 target_die
= follow_die_ref (die
, attr
, &target_cu
);
18264 target_attr
= dwarf2_attr (target_die
, DW_AT_location
, target_cu
);
18265 if (target_attr
== NULL
)
18266 target_attr
= dwarf2_attr (target_die
, DW_AT_data_member_location
,
18268 if (target_attr
== NULL
)
18270 const char *name
= var_decl_name (target_die
, target_cu
);
18271 if (name
!= nullptr)
18273 prop
->set_variable_name (name
);
18279 switch (target_attr
->name
)
18281 case DW_AT_location
:
18282 if (target_attr
->form_is_section_offset ())
18284 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
18285 baton
->property_type
= die_type (target_die
, target_cu
);
18286 fill_in_loclist_baton (cu
, &baton
->loclist
, target_attr
);
18287 prop
->set_loclist (baton
);
18288 gdb_assert (prop
->baton () != NULL
);
18290 else if (target_attr
->form_is_block ())
18292 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
18293 baton
->property_type
= die_type (target_die
, target_cu
);
18294 baton
->locexpr
.per_cu
= cu
->per_cu
;
18295 baton
->locexpr
.per_objfile
= per_objfile
;
18296 struct dwarf_block
*block
= target_attr
->as_block ();
18297 baton
->locexpr
.size
= block
->size
;
18298 baton
->locexpr
.data
= block
->data
;
18299 baton
->locexpr
.is_reference
= true;
18300 prop
->set_locexpr (baton
);
18301 gdb_assert (prop
->baton () != NULL
);
18305 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
18306 "dynamic property");
18310 case DW_AT_data_member_location
:
18314 if (!handle_data_member_location (target_die
, target_cu
,
18318 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
18319 baton
->property_type
= read_type_die (target_die
->parent
,
18321 baton
->offset_info
.offset
= offset
;
18322 baton
->offset_info
.type
= die_type (target_die
, target_cu
);
18323 prop
->set_addr_offset (baton
);
18328 else if (attr
->form_is_constant ())
18329 prop
->set_const_val (attr
->constant_value (0));
18332 dwarf2_invalid_attrib_class_complaint (dwarf_form_name (attr
->form
),
18333 dwarf2_name (die
, cu
));
18343 dwarf2_per_objfile::int_type (int size_in_bytes
, bool unsigned_p
) const
18345 struct type
*int_type
;
18347 /* Helper macro to examine the various builtin types. */
18348 #define TRY_TYPE(F) \
18349 int_type = (unsigned_p \
18350 ? objfile_type (objfile)->builtin_unsigned_ ## F \
18351 : objfile_type (objfile)->builtin_ ## F); \
18352 if (int_type != NULL && TYPE_LENGTH (int_type) == size_in_bytes) \
18359 TRY_TYPE (long_long
);
18363 gdb_assert_not_reached ("unable to find suitable integer type");
18366 /* Read the DW_AT_type attribute for a sub-range. If this attribute is not
18367 present (which is valid) then compute the default type based on the
18368 compilation units address size. */
18370 static struct type
*
18371 read_subrange_index_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18373 struct type
*index_type
= die_type (die
, cu
);
18375 /* Dwarf-2 specifications explicitly allows to create subrange types
18376 without specifying a base type.
18377 In that case, the base type must be set to the type of
18378 the lower bound, upper bound or count, in that order, if any of these
18379 three attributes references an object that has a type.
18380 If no base type is found, the Dwarf-2 specifications say that
18381 a signed integer type of size equal to the size of an address should
18383 For the following C code: `extern char gdb_int [];'
18384 GCC produces an empty range DIE.
18385 FIXME: muller/2010-05-28: Possible references to object for low bound,
18386 high bound or count are not yet handled by this code. */
18387 if (index_type
->code () == TYPE_CODE_VOID
)
18388 index_type
= cu
->addr_sized_int_type (false);
18393 /* Read the given DW_AT_subrange DIE. */
18395 static struct type
*
18396 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18398 struct type
*base_type
, *orig_base_type
;
18399 struct type
*range_type
;
18400 struct attribute
*attr
;
18401 struct dynamic_prop low
, high
;
18402 int low_default_is_valid
;
18403 int high_bound_is_count
= 0;
18405 ULONGEST negative_mask
;
18407 orig_base_type
= read_subrange_index_type (die
, cu
);
18409 /* If ORIG_BASE_TYPE is a typedef, it will not be TYPE_UNSIGNED,
18410 whereas the real type might be. So, we use ORIG_BASE_TYPE when
18411 creating the range type, but we use the result of check_typedef
18412 when examining properties of the type. */
18413 base_type
= check_typedef (orig_base_type
);
18415 /* The die_type call above may have already set the type for this DIE. */
18416 range_type
= get_die_type (die
, cu
);
18420 high
.set_const_val (0);
18422 /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
18423 omitting DW_AT_lower_bound. */
18424 switch (cu
->per_cu
->lang
)
18427 case language_cplus
:
18428 low
.set_const_val (0);
18429 low_default_is_valid
= 1;
18431 case language_fortran
:
18432 low
.set_const_val (1);
18433 low_default_is_valid
= 1;
18436 case language_objc
:
18437 case language_rust
:
18438 low
.set_const_val (0);
18439 low_default_is_valid
= (cu
->header
.version
>= 4);
18443 case language_pascal
:
18444 low
.set_const_val (1);
18445 low_default_is_valid
= (cu
->header
.version
>= 4);
18448 low
.set_const_val (0);
18449 low_default_is_valid
= 0;
18453 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
18454 if (attr
!= nullptr)
18455 attr_to_dynamic_prop (attr
, die
, cu
, &low
, base_type
);
18456 else if (!low_default_is_valid
)
18457 complaint (_("Missing DW_AT_lower_bound "
18458 "- DIE at %s [in module %s]"),
18459 sect_offset_str (die
->sect_off
),
18460 objfile_name (cu
->per_objfile
->objfile
));
18462 struct attribute
*attr_ub
, *attr_count
;
18463 attr
= attr_ub
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
18464 if (!attr_to_dynamic_prop (attr
, die
, cu
, &high
, base_type
))
18466 attr
= attr_count
= dwarf2_attr (die
, DW_AT_count
, cu
);
18467 if (attr_to_dynamic_prop (attr
, die
, cu
, &high
, base_type
))
18469 /* If bounds are constant do the final calculation here. */
18470 if (low
.kind () == PROP_CONST
&& high
.kind () == PROP_CONST
)
18471 high
.set_const_val (low
.const_val () + high
.const_val () - 1);
18473 high_bound_is_count
= 1;
18477 if (attr_ub
!= NULL
)
18478 complaint (_("Unresolved DW_AT_upper_bound "
18479 "- DIE at %s [in module %s]"),
18480 sect_offset_str (die
->sect_off
),
18481 objfile_name (cu
->per_objfile
->objfile
));
18482 if (attr_count
!= NULL
)
18483 complaint (_("Unresolved DW_AT_count "
18484 "- DIE at %s [in module %s]"),
18485 sect_offset_str (die
->sect_off
),
18486 objfile_name (cu
->per_objfile
->objfile
));
18491 struct attribute
*bias_attr
= dwarf2_attr (die
, DW_AT_GNU_bias
, cu
);
18492 if (bias_attr
!= nullptr && bias_attr
->form_is_constant ())
18493 bias
= bias_attr
->constant_value (0);
18495 /* Normally, the DWARF producers are expected to use a signed
18496 constant form (Eg. DW_FORM_sdata) to express negative bounds.
18497 But this is unfortunately not always the case, as witnessed
18498 with GCC, for instance, where the ambiguous DW_FORM_dataN form
18499 is used instead. To work around that ambiguity, we treat
18500 the bounds as signed, and thus sign-extend their values, when
18501 the base type is signed. */
18503 -((ULONGEST
) 1 << (TYPE_LENGTH (base_type
) * TARGET_CHAR_BIT
- 1));
18504 if (low
.kind () == PROP_CONST
18505 && !base_type
->is_unsigned () && (low
.const_val () & negative_mask
))
18506 low
.set_const_val (low
.const_val () | negative_mask
);
18507 if (high
.kind () == PROP_CONST
18508 && !base_type
->is_unsigned () && (high
.const_val () & negative_mask
))
18509 high
.set_const_val (high
.const_val () | negative_mask
);
18511 /* Check for bit and byte strides. */
18512 struct dynamic_prop byte_stride_prop
;
18513 attribute
*attr_byte_stride
= dwarf2_attr (die
, DW_AT_byte_stride
, cu
);
18514 if (attr_byte_stride
!= nullptr)
18516 struct type
*prop_type
= cu
->addr_sized_int_type (false);
18517 attr_to_dynamic_prop (attr_byte_stride
, die
, cu
, &byte_stride_prop
,
18521 struct dynamic_prop bit_stride_prop
;
18522 attribute
*attr_bit_stride
= dwarf2_attr (die
, DW_AT_bit_stride
, cu
);
18523 if (attr_bit_stride
!= nullptr)
18525 /* It only makes sense to have either a bit or byte stride. */
18526 if (attr_byte_stride
!= nullptr)
18528 complaint (_("Found DW_AT_bit_stride and DW_AT_byte_stride "
18529 "- DIE at %s [in module %s]"),
18530 sect_offset_str (die
->sect_off
),
18531 objfile_name (cu
->per_objfile
->objfile
));
18532 attr_bit_stride
= nullptr;
18536 struct type
*prop_type
= cu
->addr_sized_int_type (false);
18537 attr_to_dynamic_prop (attr_bit_stride
, die
, cu
, &bit_stride_prop
,
18542 if (attr_byte_stride
!= nullptr
18543 || attr_bit_stride
!= nullptr)
18545 bool byte_stride_p
= (attr_byte_stride
!= nullptr);
18546 struct dynamic_prop
*stride
18547 = byte_stride_p
? &byte_stride_prop
: &bit_stride_prop
;
18550 = create_range_type_with_stride (NULL
, orig_base_type
, &low
,
18551 &high
, bias
, stride
, byte_stride_p
);
18554 range_type
= create_range_type (NULL
, orig_base_type
, &low
, &high
, bias
);
18556 if (high_bound_is_count
)
18557 range_type
->bounds ()->flag_upper_bound_is_count
= 1;
18559 /* Ada expects an empty array on no boundary attributes. */
18560 if (attr
== NULL
&& cu
->per_cu
->lang
!= language_ada
)
18561 range_type
->bounds ()->high
.set_undefined ();
18563 name
= dwarf2_name (die
, cu
);
18565 range_type
->set_name (name
);
18567 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
18568 if (attr
!= nullptr)
18569 TYPE_LENGTH (range_type
) = attr
->constant_value (0);
18571 maybe_set_alignment (cu
, die
, range_type
);
18573 set_die_type (die
, range_type
, cu
);
18575 /* set_die_type should be already done. */
18576 set_descriptive_type (range_type
, die
, cu
);
18581 static struct type
*
18582 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18586 type
= init_type (cu
->per_objfile
->objfile
, TYPE_CODE_VOID
, 0, NULL
);
18587 type
->set_name (dwarf2_name (die
, cu
));
18589 /* In Ada, an unspecified type is typically used when the description
18590 of the type is deferred to a different unit. When encountering
18591 such a type, we treat it as a stub, and try to resolve it later on,
18593 if (cu
->per_cu
->lang
== language_ada
)
18594 type
->set_is_stub (true);
18596 return set_die_type (die
, type
, cu
);
18599 /* Read a single die and all its descendents. Set the die's sibling
18600 field to NULL; set other fields in the die correctly, and set all
18601 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
18602 location of the info_ptr after reading all of those dies. PARENT
18603 is the parent of the die in question. */
18605 static struct die_info
*
18606 read_die_and_children (const struct die_reader_specs
*reader
,
18607 const gdb_byte
*info_ptr
,
18608 const gdb_byte
**new_info_ptr
,
18609 struct die_info
*parent
)
18611 struct die_info
*die
;
18612 const gdb_byte
*cur_ptr
;
18614 cur_ptr
= read_full_die_1 (reader
, &die
, info_ptr
, 0);
18617 *new_info_ptr
= cur_ptr
;
18620 store_in_ref_table (die
, reader
->cu
);
18622 if (die
->has_children
)
18623 die
->child
= read_die_and_siblings_1 (reader
, cur_ptr
, new_info_ptr
, die
);
18627 *new_info_ptr
= cur_ptr
;
18630 die
->sibling
= NULL
;
18631 die
->parent
= parent
;
18635 /* Read a die, all of its descendents, and all of its siblings; set
18636 all of the fields of all of the dies correctly. Arguments are as
18637 in read_die_and_children. */
18639 static struct die_info
*
18640 read_die_and_siblings_1 (const struct die_reader_specs
*reader
,
18641 const gdb_byte
*info_ptr
,
18642 const gdb_byte
**new_info_ptr
,
18643 struct die_info
*parent
)
18645 struct die_info
*first_die
, *last_sibling
;
18646 const gdb_byte
*cur_ptr
;
18648 cur_ptr
= info_ptr
;
18649 first_die
= last_sibling
= NULL
;
18653 struct die_info
*die
18654 = read_die_and_children (reader
, cur_ptr
, &cur_ptr
, parent
);
18658 *new_info_ptr
= cur_ptr
;
18665 last_sibling
->sibling
= die
;
18667 last_sibling
= die
;
18671 /* Read a die, all of its descendents, and all of its siblings; set
18672 all of the fields of all of the dies correctly. Arguments are as
18673 in read_die_and_children.
18674 This the main entry point for reading a DIE and all its children. */
18676 static struct die_info
*
18677 read_die_and_siblings (const struct die_reader_specs
*reader
,
18678 const gdb_byte
*info_ptr
,
18679 const gdb_byte
**new_info_ptr
,
18680 struct die_info
*parent
)
18682 struct die_info
*die
= read_die_and_siblings_1 (reader
, info_ptr
,
18683 new_info_ptr
, parent
);
18685 if (dwarf_die_debug
)
18687 fprintf_unfiltered (gdb_stdlog
,
18688 "Read die from %s@0x%x of %s:\n",
18689 reader
->die_section
->get_name (),
18690 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
18691 bfd_get_filename (reader
->abfd
));
18692 dump_die (die
, dwarf_die_debug
);
18698 /* Read a die and all its attributes, leave space for NUM_EXTRA_ATTRS
18700 The caller is responsible for filling in the extra attributes
18701 and updating (*DIEP)->num_attrs.
18702 Set DIEP to point to a newly allocated die with its information,
18703 except for its child, sibling, and parent fields. */
18705 static const gdb_byte
*
18706 read_full_die_1 (const struct die_reader_specs
*reader
,
18707 struct die_info
**diep
, const gdb_byte
*info_ptr
,
18708 int num_extra_attrs
)
18710 unsigned int abbrev_number
, bytes_read
, i
;
18711 const struct abbrev_info
*abbrev
;
18712 struct die_info
*die
;
18713 struct dwarf2_cu
*cu
= reader
->cu
;
18714 bfd
*abfd
= reader
->abfd
;
18716 sect_offset sect_off
= (sect_offset
) (info_ptr
- reader
->buffer
);
18717 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
18718 info_ptr
+= bytes_read
;
18719 if (!abbrev_number
)
18725 abbrev
= reader
->abbrev_table
->lookup_abbrev (abbrev_number
);
18727 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
18729 bfd_get_filename (abfd
));
18731 die
= dwarf_alloc_die (cu
, abbrev
->num_attrs
+ num_extra_attrs
);
18732 die
->sect_off
= sect_off
;
18733 die
->tag
= abbrev
->tag
;
18734 die
->abbrev
= abbrev_number
;
18735 die
->has_children
= abbrev
->has_children
;
18737 /* Make the result usable.
18738 The caller needs to update num_attrs after adding the extra
18740 die
->num_attrs
= abbrev
->num_attrs
;
18742 bool any_need_reprocess
= false;
18743 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
18745 info_ptr
= read_attribute (reader
, &die
->attrs
[i
], &abbrev
->attrs
[i
],
18747 if (die
->attrs
[i
].requires_reprocessing_p ())
18748 any_need_reprocess
= true;
18751 struct attribute
*attr
= die
->attr (DW_AT_str_offsets_base
);
18752 if (attr
!= nullptr && attr
->form_is_unsigned ())
18753 cu
->str_offsets_base
= attr
->as_unsigned ();
18755 attr
= die
->attr (DW_AT_loclists_base
);
18756 if (attr
!= nullptr)
18757 cu
->loclist_base
= attr
->as_unsigned ();
18759 auto maybe_addr_base
= die
->addr_base ();
18760 if (maybe_addr_base
.has_value ())
18761 cu
->addr_base
= *maybe_addr_base
;
18763 attr
= die
->attr (DW_AT_rnglists_base
);
18764 if (attr
!= nullptr)
18765 cu
->rnglists_base
= attr
->as_unsigned ();
18767 if (any_need_reprocess
)
18769 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
18771 if (die
->attrs
[i
].requires_reprocessing_p ())
18772 read_attribute_reprocess (reader
, &die
->attrs
[i
], die
->tag
);
18779 /* Read a die and all its attributes.
18780 Set DIEP to point to a newly allocated die with its information,
18781 except for its child, sibling, and parent fields. */
18783 static const gdb_byte
*
18784 read_full_die (const struct die_reader_specs
*reader
,
18785 struct die_info
**diep
, const gdb_byte
*info_ptr
)
18787 const gdb_byte
*result
;
18789 result
= read_full_die_1 (reader
, diep
, info_ptr
, 0);
18791 if (dwarf_die_debug
)
18793 fprintf_unfiltered (gdb_stdlog
,
18794 "Read die from %s@0x%x of %s:\n",
18795 reader
->die_section
->get_name (),
18796 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
18797 bfd_get_filename (reader
->abfd
));
18798 dump_die (*diep
, dwarf_die_debug
);
18805 /* Returns nonzero if TAG represents a type that we might generate a partial
18809 is_type_tag_for_partial (int tag
, enum language lang
)
18814 /* Some types that would be reasonable to generate partial symbols for,
18815 that we don't at present. Note that normally this does not
18816 matter, mainly because C compilers don't give names to these
18817 types, but instead emit DW_TAG_typedef. */
18818 case DW_TAG_file_type
:
18819 case DW_TAG_ptr_to_member_type
:
18820 case DW_TAG_set_type
:
18821 case DW_TAG_string_type
:
18822 case DW_TAG_subroutine_type
:
18825 /* GNAT may emit an array with a name, but no typedef, so we
18826 need to make a symbol in this case. */
18827 case DW_TAG_array_type
:
18828 return lang
== language_ada
;
18830 case DW_TAG_base_type
:
18831 case DW_TAG_class_type
:
18832 case DW_TAG_interface_type
:
18833 case DW_TAG_enumeration_type
:
18834 case DW_TAG_structure_type
:
18835 case DW_TAG_subrange_type
:
18836 case DW_TAG_typedef
:
18837 case DW_TAG_union_type
:
18844 /* Load all DIEs that are interesting for partial symbols into memory. */
18846 static struct partial_die_info
*
18847 load_partial_dies (const struct die_reader_specs
*reader
,
18848 const gdb_byte
*info_ptr
, int building_psymtab
)
18850 struct dwarf2_cu
*cu
= reader
->cu
;
18851 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
18852 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
18853 unsigned int bytes_read
;
18854 unsigned int load_all
= 0;
18855 int nesting_level
= 1;
18860 gdb_assert (cu
->per_cu
!= NULL
);
18861 if (cu
->load_all_dies
)
18865 = htab_create_alloc_ex (cu
->header
.length
/ 12,
18869 &cu
->comp_unit_obstack
,
18870 hashtab_obstack_allocate
,
18871 dummy_obstack_deallocate
);
18875 const abbrev_info
*abbrev
= peek_die_abbrev (*reader
, info_ptr
,
18878 /* A NULL abbrev means the end of a series of children. */
18879 if (abbrev
== NULL
)
18881 if (--nesting_level
== 0)
18884 info_ptr
+= bytes_read
;
18885 last_die
= parent_die
;
18886 parent_die
= parent_die
->die_parent
;
18890 /* Check for template arguments. We never save these; if
18891 they're seen, we just mark the parent, and go on our way. */
18892 if (parent_die
!= NULL
18893 && cu
->per_cu
->lang
== language_cplus
18894 && (abbrev
->tag
== DW_TAG_template_type_param
18895 || abbrev
->tag
== DW_TAG_template_value_param
))
18897 parent_die
->has_template_arguments
= 1;
18901 /* We don't need a partial DIE for the template argument. */
18902 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
18907 /* We only recurse into c++ subprograms looking for template arguments.
18908 Skip their other children. */
18910 && cu
->per_cu
->lang
== language_cplus
18911 && parent_die
!= NULL
18912 && parent_die
->tag
== DW_TAG_subprogram
18913 && abbrev
->tag
!= DW_TAG_inlined_subroutine
)
18915 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
18919 /* Check whether this DIE is interesting enough to save. Normally
18920 we would not be interested in members here, but there may be
18921 later variables referencing them via DW_AT_specification (for
18922 static members). */
18924 && !is_type_tag_for_partial (abbrev
->tag
, cu
->per_cu
->lang
)
18925 && abbrev
->tag
!= DW_TAG_constant
18926 && abbrev
->tag
!= DW_TAG_enumerator
18927 && abbrev
->tag
!= DW_TAG_subprogram
18928 && abbrev
->tag
!= DW_TAG_inlined_subroutine
18929 && abbrev
->tag
!= DW_TAG_lexical_block
18930 && abbrev
->tag
!= DW_TAG_variable
18931 && abbrev
->tag
!= DW_TAG_namespace
18932 && abbrev
->tag
!= DW_TAG_module
18933 && abbrev
->tag
!= DW_TAG_member
18934 && abbrev
->tag
!= DW_TAG_imported_unit
18935 && abbrev
->tag
!= DW_TAG_imported_declaration
)
18937 /* Otherwise we skip to the next sibling, if any. */
18938 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
18942 struct partial_die_info
pdi ((sect_offset
) (info_ptr
- reader
->buffer
),
18945 info_ptr
= pdi
.read (reader
, *abbrev
, info_ptr
+ bytes_read
);
18947 /* This two-pass algorithm for processing partial symbols has a
18948 high cost in cache pressure. Thus, handle some simple cases
18949 here which cover the majority of C partial symbols. DIEs
18950 which neither have specification tags in them, nor could have
18951 specification tags elsewhere pointing at them, can simply be
18952 processed and discarded.
18954 This segment is also optional; scan_partial_symbols and
18955 add_partial_symbol will handle these DIEs if we chain
18956 them in normally. When compilers which do not emit large
18957 quantities of duplicate debug information are more common,
18958 this code can probably be removed. */
18960 /* Any complete simple types at the top level (pretty much all
18961 of them, for a language without namespaces), can be processed
18963 if (parent_die
== NULL
18964 && pdi
.has_specification
== 0
18965 && pdi
.is_declaration
== 0
18966 && ((pdi
.tag
== DW_TAG_typedef
&& !pdi
.has_children
)
18967 || pdi
.tag
== DW_TAG_base_type
18968 || pdi
.tag
== DW_TAG_array_type
18969 || pdi
.tag
== DW_TAG_subrange_type
))
18971 if (building_psymtab
&& pdi
.raw_name
!= NULL
)
18972 add_partial_symbol (&pdi
, cu
);
18974 info_ptr
= locate_pdi_sibling (reader
, &pdi
, info_ptr
);
18978 /* The exception for DW_TAG_typedef with has_children above is
18979 a workaround of GCC PR debug/47510. In the case of this complaint
18980 type_name_or_error will error on such types later.
18982 GDB skipped children of DW_TAG_typedef by the shortcut above and then
18983 it could not find the child DIEs referenced later, this is checked
18984 above. In correct DWARF DW_TAG_typedef should have no children. */
18986 if (pdi
.tag
== DW_TAG_typedef
&& pdi
.has_children
)
18987 complaint (_("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
18988 "- DIE at %s [in module %s]"),
18989 sect_offset_str (pdi
.sect_off
), objfile_name (objfile
));
18991 /* If we're at the second level, and we're an enumerator, and
18992 our parent has no specification (meaning possibly lives in a
18993 namespace elsewhere), then we can add the partial symbol now
18994 instead of queueing it. */
18995 if (pdi
.tag
== DW_TAG_enumerator
18996 && parent_die
!= NULL
18997 && parent_die
->die_parent
== NULL
18998 && parent_die
->tag
== DW_TAG_enumeration_type
18999 && parent_die
->has_specification
== 0)
19001 if (pdi
.raw_name
== NULL
)
19002 complaint (_("malformed enumerator DIE ignored"));
19003 else if (building_psymtab
)
19004 add_partial_symbol (&pdi
, cu
);
19006 info_ptr
= locate_pdi_sibling (reader
, &pdi
, info_ptr
);
19010 struct partial_die_info
*part_die
19011 = new (&cu
->comp_unit_obstack
) partial_die_info (pdi
);
19013 /* We'll save this DIE so link it in. */
19014 part_die
->die_parent
= parent_die
;
19015 part_die
->die_sibling
= NULL
;
19016 part_die
->die_child
= NULL
;
19018 if (last_die
&& last_die
== parent_die
)
19019 last_die
->die_child
= part_die
;
19021 last_die
->die_sibling
= part_die
;
19023 last_die
= part_die
;
19025 if (first_die
== NULL
)
19026 first_die
= part_die
;
19028 /* Maybe add the DIE to the hash table. Not all DIEs that we
19029 find interesting need to be in the hash table, because we
19030 also have the parent/sibling/child chains; only those that we
19031 might refer to by offset later during partial symbol reading.
19033 For now this means things that might have be the target of a
19034 DW_AT_specification, DW_AT_abstract_origin, or
19035 DW_AT_extension. DW_AT_extension will refer only to
19036 namespaces; DW_AT_abstract_origin refers to functions (and
19037 many things under the function DIE, but we do not recurse
19038 into function DIEs during partial symbol reading) and
19039 possibly variables as well; DW_AT_specification refers to
19040 declarations. Declarations ought to have the DW_AT_declaration
19041 flag. It happens that GCC forgets to put it in sometimes, but
19042 only for functions, not for types.
19044 Adding more things than necessary to the hash table is harmless
19045 except for the performance cost. Adding too few will result in
19046 wasted time in find_partial_die, when we reread the compilation
19047 unit with load_all_dies set. */
19050 || abbrev
->tag
== DW_TAG_constant
19051 || abbrev
->tag
== DW_TAG_subprogram
19052 || abbrev
->tag
== DW_TAG_variable
19053 || abbrev
->tag
== DW_TAG_namespace
19054 || part_die
->is_declaration
)
19058 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
19059 to_underlying (part_die
->sect_off
),
19064 /* For some DIEs we want to follow their children (if any). For C
19065 we have no reason to follow the children of structures; for other
19066 languages we have to, so that we can get at method physnames
19067 to infer fully qualified class names, for DW_AT_specification,
19068 and for C++ template arguments. For C++, we also look one level
19069 inside functions to find template arguments (if the name of the
19070 function does not already contain the template arguments).
19072 For Ada and Fortran, we need to scan the children of subprograms
19073 and lexical blocks as well because these languages allow the
19074 definition of nested entities that could be interesting for the
19075 debugger, such as nested subprograms for instance. */
19076 if (last_die
->has_children
19078 || last_die
->tag
== DW_TAG_namespace
19079 || last_die
->tag
== DW_TAG_module
19080 || last_die
->tag
== DW_TAG_enumeration_type
19081 || (cu
->per_cu
->lang
== language_cplus
19082 && last_die
->tag
== DW_TAG_subprogram
19083 && (last_die
->raw_name
== NULL
19084 || strchr (last_die
->raw_name
, '<') == NULL
))
19085 || (cu
->per_cu
->lang
!= language_c
19086 && (last_die
->tag
== DW_TAG_class_type
19087 || last_die
->tag
== DW_TAG_interface_type
19088 || last_die
->tag
== DW_TAG_structure_type
19089 || last_die
->tag
== DW_TAG_union_type
))
19090 || ((cu
->per_cu
->lang
== language_ada
19091 || cu
->per_cu
->lang
== language_fortran
)
19092 && (last_die
->tag
== DW_TAG_subprogram
19093 || last_die
->tag
== DW_TAG_lexical_block
))))
19096 parent_die
= last_die
;
19100 /* Otherwise we skip to the next sibling, if any. */
19101 info_ptr
= locate_pdi_sibling (reader
, last_die
, info_ptr
);
19103 /* Back to the top, do it again. */
19107 partial_die_info::partial_die_info (sect_offset sect_off_
,
19108 const struct abbrev_info
*abbrev
)
19109 : partial_die_info (sect_off_
, abbrev
->tag
, abbrev
->has_children
)
19113 /* See class definition. */
19116 partial_die_info::name (dwarf2_cu
*cu
)
19118 if (!canonical_name
&& raw_name
!= nullptr)
19120 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
19121 raw_name
= dwarf2_canonicalize_name (raw_name
, cu
, objfile
);
19122 canonical_name
= 1;
19128 /* Read a minimal amount of information into the minimal die structure.
19129 INFO_PTR should point just after the initial uleb128 of a DIE. */
19132 partial_die_info::read (const struct die_reader_specs
*reader
,
19133 const struct abbrev_info
&abbrev
, const gdb_byte
*info_ptr
)
19135 struct dwarf2_cu
*cu
= reader
->cu
;
19136 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
19138 int has_low_pc_attr
= 0;
19139 int has_high_pc_attr
= 0;
19140 int high_pc_relative
= 0;
19142 for (i
= 0; i
< abbrev
.num_attrs
; ++i
)
19145 info_ptr
= read_attribute (reader
, &attr
, &abbrev
.attrs
[i
], info_ptr
);
19146 /* String and address offsets that need to do the reprocessing have
19147 already been read at this point, so there is no need to wait until
19148 the loop terminates to do the reprocessing. */
19149 if (attr
.requires_reprocessing_p ())
19150 read_attribute_reprocess (reader
, &attr
, tag
);
19151 /* Store the data if it is of an attribute we want to keep in a
19152 partial symbol table. */
19158 case DW_TAG_compile_unit
:
19159 case DW_TAG_partial_unit
:
19160 case DW_TAG_type_unit
:
19161 /* Compilation units have a DW_AT_name that is a filename, not
19162 a source language identifier. */
19163 case DW_TAG_enumeration_type
:
19164 case DW_TAG_enumerator
:
19165 /* These tags always have simple identifiers already; no need
19166 to canonicalize them. */
19167 canonical_name
= 1;
19168 raw_name
= attr
.as_string ();
19171 canonical_name
= 0;
19172 raw_name
= attr
.as_string ();
19176 case DW_AT_linkage_name
:
19177 case DW_AT_MIPS_linkage_name
:
19178 /* Note that both forms of linkage name might appear. We
19179 assume they will be the same, and we only store the last
19181 linkage_name
= attr
.as_string ();
19184 has_low_pc_attr
= 1;
19185 lowpc
= attr
.as_address ();
19187 case DW_AT_high_pc
:
19188 has_high_pc_attr
= 1;
19189 highpc
= attr
.as_address ();
19190 if (cu
->header
.version
>= 4 && attr
.form_is_constant ())
19191 high_pc_relative
= 1;
19193 case DW_AT_location
:
19194 /* Support the .debug_loc offsets. */
19195 if (attr
.form_is_block ())
19197 d
.locdesc
= attr
.as_block ();
19199 else if (attr
.form_is_section_offset ())
19201 dwarf2_complex_location_expr_complaint ();
19205 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
19206 "partial symbol information");
19209 case DW_AT_external
:
19210 is_external
= attr
.as_boolean ();
19212 case DW_AT_declaration
:
19213 is_declaration
= attr
.as_boolean ();
19218 case DW_AT_abstract_origin
:
19219 case DW_AT_specification
:
19220 case DW_AT_extension
:
19221 has_specification
= 1;
19222 spec_offset
= attr
.get_ref_die_offset ();
19223 spec_is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
19224 || cu
->per_cu
->is_dwz
);
19226 case DW_AT_sibling
:
19227 /* Ignore absolute siblings, they might point outside of
19228 the current compile unit. */
19229 if (attr
.form
== DW_FORM_ref_addr
)
19230 complaint (_("ignoring absolute DW_AT_sibling"));
19233 const gdb_byte
*buffer
= reader
->buffer
;
19234 sect_offset off
= attr
.get_ref_die_offset ();
19235 const gdb_byte
*sibling_ptr
= buffer
+ to_underlying (off
);
19237 if (sibling_ptr
< info_ptr
)
19238 complaint (_("DW_AT_sibling points backwards"));
19239 else if (sibling_ptr
> reader
->buffer_end
)
19240 reader
->die_section
->overflow_complaint ();
19242 sibling
= sibling_ptr
;
19245 case DW_AT_byte_size
:
19248 case DW_AT_const_value
:
19249 has_const_value
= 1;
19251 case DW_AT_calling_convention
:
19252 /* DWARF doesn't provide a way to identify a program's source-level
19253 entry point. DW_AT_calling_convention attributes are only meant
19254 to describe functions' calling conventions.
19256 However, because it's a necessary piece of information in
19257 Fortran, and before DWARF 4 DW_CC_program was the only
19258 piece of debugging information whose definition refers to
19259 a 'main program' at all, several compilers marked Fortran
19260 main programs with DW_CC_program --- even when those
19261 functions use the standard calling conventions.
19263 Although DWARF now specifies a way to provide this
19264 information, we support this practice for backward
19266 if (attr
.constant_value (0) == DW_CC_program
19267 && cu
->per_cu
->lang
== language_fortran
)
19268 main_subprogram
= 1;
19272 LONGEST value
= attr
.constant_value (-1);
19273 if (value
== DW_INL_inlined
19274 || value
== DW_INL_declared_inlined
)
19275 may_be_inlined
= 1;
19280 if (tag
== DW_TAG_imported_unit
)
19282 d
.sect_off
= attr
.get_ref_die_offset ();
19283 is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
19284 || cu
->per_cu
->is_dwz
);
19288 case DW_AT_main_subprogram
:
19289 main_subprogram
= attr
.as_boolean ();
19294 /* Offset in the .debug_ranges or .debug_rnglist section (depending
19295 on DWARF version). */
19296 ULONGEST ranges_offset
= attr
.as_unsigned ();
19298 /* See dwarf2_cu::gnu_ranges_base's doc for why we might want to add
19300 if (tag
!= DW_TAG_compile_unit
)
19301 ranges_offset
+= cu
->gnu_ranges_base
;
19303 if (dwarf2_ranges_read (ranges_offset
, &lowpc
, &highpc
, cu
,
19314 /* For Ada, if both the name and the linkage name appear, we prefer
19315 the latter. This lets "catch exception" work better, regardless
19316 of the order in which the name and linkage name were emitted.
19317 Really, though, this is just a workaround for the fact that gdb
19318 doesn't store both the name and the linkage name. */
19319 if (cu
->per_cu
->lang
== language_ada
&& linkage_name
!= nullptr)
19320 raw_name
= linkage_name
;
19322 if (high_pc_relative
)
19325 if (has_low_pc_attr
&& has_high_pc_attr
)
19327 /* When using the GNU linker, .gnu.linkonce. sections are used to
19328 eliminate duplicate copies of functions and vtables and such.
19329 The linker will arbitrarily choose one and discard the others.
19330 The AT_*_pc values for such functions refer to local labels in
19331 these sections. If the section from that file was discarded, the
19332 labels are not in the output, so the relocs get a value of 0.
19333 If this is a discarded function, mark the pc bounds as invalid,
19334 so that GDB will ignore it. */
19335 if (lowpc
== 0 && !per_objfile
->per_bfd
->has_section_at_zero
)
19337 struct objfile
*objfile
= per_objfile
->objfile
;
19338 struct gdbarch
*gdbarch
= objfile
->arch ();
19340 complaint (_("DW_AT_low_pc %s is zero "
19341 "for DIE at %s [in module %s]"),
19342 paddress (gdbarch
, lowpc
),
19343 sect_offset_str (sect_off
),
19344 objfile_name (objfile
));
19346 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
19347 else if (lowpc
>= highpc
)
19349 struct objfile
*objfile
= per_objfile
->objfile
;
19350 struct gdbarch
*gdbarch
= objfile
->arch ();
19352 complaint (_("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
19353 "for DIE at %s [in module %s]"),
19354 paddress (gdbarch
, lowpc
),
19355 paddress (gdbarch
, highpc
),
19356 sect_offset_str (sect_off
),
19357 objfile_name (objfile
));
19366 /* Find a cached partial DIE at OFFSET in CU. */
19368 struct partial_die_info
*
19369 dwarf2_cu::find_partial_die (sect_offset sect_off
)
19371 struct partial_die_info
*lookup_die
= NULL
;
19372 struct partial_die_info
part_die (sect_off
);
19374 lookup_die
= ((struct partial_die_info
*)
19375 htab_find_with_hash (partial_dies
, &part_die
,
19376 to_underlying (sect_off
)));
19381 /* Find a partial DIE at OFFSET, which may or may not be in CU,
19382 except in the case of .debug_types DIEs which do not reference
19383 outside their CU (they do however referencing other types via
19384 DW_FORM_ref_sig8). */
19386 static const struct cu_partial_die_info
19387 find_partial_die (sect_offset sect_off
, int offset_in_dwz
, struct dwarf2_cu
*cu
)
19389 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
19390 struct objfile
*objfile
= per_objfile
->objfile
;
19391 struct partial_die_info
*pd
= NULL
;
19393 if (offset_in_dwz
== cu
->per_cu
->is_dwz
19394 && cu
->header
.offset_in_cu_p (sect_off
))
19396 pd
= cu
->find_partial_die (sect_off
);
19399 /* We missed recording what we needed.
19400 Load all dies and try again. */
19404 /* TUs don't reference other CUs/TUs (except via type signatures). */
19405 if (cu
->per_cu
->is_debug_types
)
19407 error (_("Dwarf Error: Type Unit at offset %s contains"
19408 " external reference to offset %s [in module %s].\n"),
19409 sect_offset_str (cu
->header
.sect_off
), sect_offset_str (sect_off
),
19410 bfd_get_filename (objfile
->obfd
));
19412 dwarf2_per_cu_data
*per_cu
19413 = dwarf2_find_containing_comp_unit (sect_off
, offset_in_dwz
,
19416 cu
= per_objfile
->get_cu (per_cu
);
19417 if (cu
== NULL
|| cu
->partial_dies
== NULL
)
19418 load_partial_comp_unit (per_cu
, per_objfile
, nullptr);
19420 cu
= per_objfile
->get_cu (per_cu
);
19423 pd
= cu
->find_partial_die (sect_off
);
19426 /* If we didn't find it, and not all dies have been loaded,
19427 load them all and try again. */
19429 if (pd
== NULL
&& cu
->load_all_dies
== 0)
19431 cu
->load_all_dies
= 1;
19433 /* This is nasty. When we reread the DIEs, somewhere up the call chain
19434 THIS_CU->cu may already be in use. So we can't just free it and
19435 replace its DIEs with the ones we read in. Instead, we leave those
19436 DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
19437 and clobber THIS_CU->cu->partial_dies with the hash table for the new
19439 load_partial_comp_unit (cu
->per_cu
, per_objfile
, cu
);
19441 pd
= cu
->find_partial_die (sect_off
);
19445 error (_("Dwarf Error: Cannot find DIE at %s [from module %s]\n"),
19446 sect_offset_str (sect_off
), bfd_get_filename (objfile
->obfd
));
19450 /* See if we can figure out if the class lives in a namespace. We do
19451 this by looking for a member function; its demangled name will
19452 contain namespace info, if there is any. */
19455 guess_partial_die_structure_name (struct partial_die_info
*struct_pdi
,
19456 struct dwarf2_cu
*cu
)
19458 /* NOTE: carlton/2003-10-07: Getting the info this way changes
19459 what template types look like, because the demangler
19460 frequently doesn't give the same name as the debug info. We
19461 could fix this by only using the demangled name to get the
19462 prefix (but see comment in read_structure_type). */
19464 struct partial_die_info
*real_pdi
;
19465 struct partial_die_info
*child_pdi
;
19467 /* If this DIE (this DIE's specification, if any) has a parent, then
19468 we should not do this. We'll prepend the parent's fully qualified
19469 name when we create the partial symbol. */
19471 real_pdi
= struct_pdi
;
19472 while (real_pdi
->has_specification
)
19474 auto res
= find_partial_die (real_pdi
->spec_offset
,
19475 real_pdi
->spec_is_dwz
, cu
);
19476 real_pdi
= res
.pdi
;
19480 if (real_pdi
->die_parent
!= NULL
)
19483 for (child_pdi
= struct_pdi
->die_child
;
19485 child_pdi
= child_pdi
->die_sibling
)
19487 if (child_pdi
->tag
== DW_TAG_subprogram
19488 && child_pdi
->linkage_name
!= NULL
)
19490 gdb::unique_xmalloc_ptr
<char> actual_class_name
19491 (cu
->language_defn
->class_name_from_physname
19492 (child_pdi
->linkage_name
));
19493 if (actual_class_name
!= NULL
)
19495 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
19496 struct_pdi
->raw_name
= objfile
->intern (actual_class_name
.get ());
19497 struct_pdi
->canonical_name
= 1;
19504 /* Return true if a DIE with TAG may have the DW_AT_const_value
19508 can_have_DW_AT_const_value_p (enum dwarf_tag tag
)
19512 case DW_TAG_constant
:
19513 case DW_TAG_enumerator
:
19514 case DW_TAG_formal_parameter
:
19515 case DW_TAG_template_value_param
:
19516 case DW_TAG_variable
:
19524 partial_die_info::fixup (struct dwarf2_cu
*cu
)
19526 /* Once we've fixed up a die, there's no point in doing so again.
19527 This also avoids a memory leak if we were to call
19528 guess_partial_die_structure_name multiple times. */
19532 /* If we found a reference attribute and the DIE has no name, try
19533 to find a name in the referred to DIE. */
19535 if (raw_name
== NULL
&& has_specification
)
19537 struct partial_die_info
*spec_die
;
19539 auto res
= find_partial_die (spec_offset
, spec_is_dwz
, cu
);
19540 spec_die
= res
.pdi
;
19543 spec_die
->fixup (cu
);
19545 if (spec_die
->raw_name
)
19547 raw_name
= spec_die
->raw_name
;
19548 canonical_name
= spec_die
->canonical_name
;
19550 /* Copy DW_AT_external attribute if it is set. */
19551 if (spec_die
->is_external
)
19552 is_external
= spec_die
->is_external
;
19556 if (!has_const_value
&& has_specification
19557 && can_have_DW_AT_const_value_p (tag
))
19559 struct partial_die_info
*spec_die
;
19561 auto res
= find_partial_die (spec_offset
, spec_is_dwz
, cu
);
19562 spec_die
= res
.pdi
;
19565 spec_die
->fixup (cu
);
19567 if (spec_die
->has_const_value
)
19569 /* Copy DW_AT_const_value attribute if it is set. */
19570 has_const_value
= spec_die
->has_const_value
;
19574 /* Set default names for some unnamed DIEs. */
19576 if (raw_name
== NULL
&& tag
== DW_TAG_namespace
)
19578 raw_name
= CP_ANONYMOUS_NAMESPACE_STR
;
19579 canonical_name
= 1;
19582 /* If there is no parent die to provide a namespace, and there are
19583 children, see if we can determine the namespace from their linkage
19585 if (cu
->per_cu
->lang
== language_cplus
19586 && !cu
->per_objfile
->per_bfd
->types
.empty ()
19587 && die_parent
== NULL
19589 && (tag
== DW_TAG_class_type
19590 || tag
== DW_TAG_structure_type
19591 || tag
== DW_TAG_union_type
))
19592 guess_partial_die_structure_name (this, cu
);
19594 /* GCC might emit a nameless struct or union that has a linkage
19595 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
19596 if (raw_name
== NULL
19597 && (tag
== DW_TAG_class_type
19598 || tag
== DW_TAG_interface_type
19599 || tag
== DW_TAG_structure_type
19600 || tag
== DW_TAG_union_type
)
19601 && linkage_name
!= NULL
)
19603 gdb::unique_xmalloc_ptr
<char> demangled
19604 (gdb_demangle (linkage_name
, DMGL_TYPES
));
19605 if (demangled
!= nullptr)
19609 /* Strip any leading namespaces/classes, keep only the base name.
19610 DW_AT_name for named DIEs does not contain the prefixes. */
19611 base
= strrchr (demangled
.get (), ':');
19612 if (base
&& base
> demangled
.get () && base
[-1] == ':')
19615 base
= demangled
.get ();
19617 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
19618 raw_name
= objfile
->intern (base
);
19619 canonical_name
= 1;
19626 /* Read the .debug_loclists or .debug_rnglists header (they are the same format)
19627 contents from the given SECTION in the HEADER.
19629 HEADER_OFFSET is the offset of the header in the section. */
19631 read_loclists_rnglists_header (struct loclists_rnglists_header
*header
,
19632 struct dwarf2_section_info
*section
,
19633 sect_offset header_offset
)
19635 unsigned int bytes_read
;
19636 bfd
*abfd
= section
->get_bfd_owner ();
19637 const gdb_byte
*info_ptr
= section
->buffer
+ to_underlying (header_offset
);
19639 header
->length
= read_initial_length (abfd
, info_ptr
, &bytes_read
);
19640 info_ptr
+= bytes_read
;
19642 header
->version
= read_2_bytes (abfd
, info_ptr
);
19645 header
->addr_size
= read_1_byte (abfd
, info_ptr
);
19648 header
->segment_collector_size
= read_1_byte (abfd
, info_ptr
);
19651 header
->offset_entry_count
= read_4_bytes (abfd
, info_ptr
);
19654 /* Return the DW_AT_loclists_base value for the CU. */
19656 lookup_loclist_base (struct dwarf2_cu
*cu
)
19658 /* For the .dwo unit, the loclist_base points to the first offset following
19659 the header. The header consists of the following entities-
19660 1. Unit Length (4 bytes for 32 bit DWARF format, and 12 bytes for the 64
19662 2. version (2 bytes)
19663 3. address size (1 byte)
19664 4. segment selector size (1 byte)
19665 5. offset entry count (4 bytes)
19666 These sizes are derived as per the DWARFv5 standard. */
19667 if (cu
->dwo_unit
!= nullptr)
19669 if (cu
->header
.initial_length_size
== 4)
19670 return LOCLIST_HEADER_SIZE32
;
19671 return LOCLIST_HEADER_SIZE64
;
19673 return cu
->loclist_base
;
19676 /* Given a DW_FORM_loclistx value LOCLIST_INDEX, fetch the offset from the
19677 array of offsets in the .debug_loclists section. */
19680 read_loclist_index (struct dwarf2_cu
*cu
, ULONGEST loclist_index
)
19682 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
19683 struct objfile
*objfile
= per_objfile
->objfile
;
19684 bfd
*abfd
= objfile
->obfd
;
19685 ULONGEST loclist_header_size
=
19686 (cu
->header
.initial_length_size
== 4 ? LOCLIST_HEADER_SIZE32
19687 : LOCLIST_HEADER_SIZE64
);
19688 ULONGEST loclist_base
= lookup_loclist_base (cu
);
19690 /* Offset in .debug_loclists of the offset for LOCLIST_INDEX. */
19691 ULONGEST start_offset
=
19692 loclist_base
+ loclist_index
* cu
->header
.offset_size
;
19694 /* Get loclists section. */
19695 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
19697 /* Read the loclists section content. */
19698 section
->read (objfile
);
19699 if (section
->buffer
== NULL
)
19700 error (_("DW_FORM_loclistx used without .debug_loclists "
19701 "section [in module %s]"), objfile_name (objfile
));
19703 /* DW_AT_loclists_base points after the .debug_loclists contribution header,
19704 so if loclist_base is smaller than the header size, we have a problem. */
19705 if (loclist_base
< loclist_header_size
)
19706 error (_("DW_AT_loclists_base is smaller than header size [in module %s]"),
19707 objfile_name (objfile
));
19709 /* Read the header of the loclists contribution. */
19710 struct loclists_rnglists_header header
;
19711 read_loclists_rnglists_header (&header
, section
,
19712 (sect_offset
) (loclist_base
- loclist_header_size
));
19714 /* Verify the loclist index is valid. */
19715 if (loclist_index
>= header
.offset_entry_count
)
19716 error (_("DW_FORM_loclistx pointing outside of "
19717 ".debug_loclists offset array [in module %s]"),
19718 objfile_name (objfile
));
19720 /* Validate that reading won't go beyond the end of the section. */
19721 if (start_offset
+ cu
->header
.offset_size
> section
->size
)
19722 error (_("Reading DW_FORM_loclistx index beyond end of"
19723 ".debug_loclists section [in module %s]"),
19724 objfile_name (objfile
));
19726 const gdb_byte
*info_ptr
= section
->buffer
+ start_offset
;
19728 if (cu
->header
.offset_size
== 4)
19729 return (sect_offset
) (bfd_get_32 (abfd
, info_ptr
) + loclist_base
);
19731 return (sect_offset
) (bfd_get_64 (abfd
, info_ptr
) + loclist_base
);
19734 /* Given a DW_FORM_rnglistx value RNGLIST_INDEX, fetch the offset from the
19735 array of offsets in the .debug_rnglists section. */
19738 read_rnglist_index (struct dwarf2_cu
*cu
, ULONGEST rnglist_index
,
19741 struct dwarf2_per_objfile
*dwarf2_per_objfile
= cu
->per_objfile
;
19742 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
19743 bfd
*abfd
= objfile
->obfd
;
19744 ULONGEST rnglist_header_size
=
19745 (cu
->header
.initial_length_size
== 4 ? RNGLIST_HEADER_SIZE32
19746 : RNGLIST_HEADER_SIZE64
);
19748 /* When reading a DW_FORM_rnglistx from a DWO, we read from the DWO's
19749 .debug_rnglists.dwo section. The rnglists base given in the skeleton
19751 ULONGEST rnglist_base
=
19752 (cu
->dwo_unit
!= nullptr) ? rnglist_header_size
: cu
->rnglists_base
;
19754 /* Offset in .debug_rnglists of the offset for RNGLIST_INDEX. */
19755 ULONGEST start_offset
=
19756 rnglist_base
+ rnglist_index
* cu
->header
.offset_size
;
19758 /* Get rnglists section. */
19759 struct dwarf2_section_info
*section
= cu_debug_rnglists_section (cu
, tag
);
19761 /* Read the rnglists section content. */
19762 section
->read (objfile
);
19763 if (section
->buffer
== nullptr)
19764 error (_("DW_FORM_rnglistx used without .debug_rnglists section "
19766 objfile_name (objfile
));
19768 /* DW_AT_rnglists_base points after the .debug_rnglists contribution header,
19769 so if rnglist_base is smaller than the header size, we have a problem. */
19770 if (rnglist_base
< rnglist_header_size
)
19771 error (_("DW_AT_rnglists_base is smaller than header size [in module %s]"),
19772 objfile_name (objfile
));
19774 /* Read the header of the rnglists contribution. */
19775 struct loclists_rnglists_header header
;
19776 read_loclists_rnglists_header (&header
, section
,
19777 (sect_offset
) (rnglist_base
- rnglist_header_size
));
19779 /* Verify the rnglist index is valid. */
19780 if (rnglist_index
>= header
.offset_entry_count
)
19781 error (_("DW_FORM_rnglistx index pointing outside of "
19782 ".debug_rnglists offset array [in module %s]"),
19783 objfile_name (objfile
));
19785 /* Validate that reading won't go beyond the end of the section. */
19786 if (start_offset
+ cu
->header
.offset_size
> section
->size
)
19787 error (_("Reading DW_FORM_rnglistx index beyond end of"
19788 ".debug_rnglists section [in module %s]"),
19789 objfile_name (objfile
));
19791 const gdb_byte
*info_ptr
= section
->buffer
+ start_offset
;
19793 if (cu
->header
.offset_size
== 4)
19794 return (sect_offset
) (read_4_bytes (abfd
, info_ptr
) + rnglist_base
);
19796 return (sect_offset
) (read_8_bytes (abfd
, info_ptr
) + rnglist_base
);
19799 /* Process the attributes that had to be skipped in the first round. These
19800 attributes are the ones that need str_offsets_base or addr_base attributes.
19801 They could not have been processed in the first round, because at the time
19802 the values of str_offsets_base or addr_base may not have been known. */
19804 read_attribute_reprocess (const struct die_reader_specs
*reader
,
19805 struct attribute
*attr
, dwarf_tag tag
)
19807 struct dwarf2_cu
*cu
= reader
->cu
;
19808 switch (attr
->form
)
19810 case DW_FORM_addrx
:
19811 case DW_FORM_GNU_addr_index
:
19812 attr
->set_address (read_addr_index (cu
,
19813 attr
->as_unsigned_reprocess ()));
19815 case DW_FORM_loclistx
:
19817 sect_offset loclists_sect_off
19818 = read_loclist_index (cu
, attr
->as_unsigned_reprocess ());
19820 attr
->set_unsigned (to_underlying (loclists_sect_off
));
19823 case DW_FORM_rnglistx
:
19825 sect_offset rnglists_sect_off
19826 = read_rnglist_index (cu
, attr
->as_unsigned_reprocess (), tag
);
19828 attr
->set_unsigned (to_underlying (rnglists_sect_off
));
19832 case DW_FORM_strx1
:
19833 case DW_FORM_strx2
:
19834 case DW_FORM_strx3
:
19835 case DW_FORM_strx4
:
19836 case DW_FORM_GNU_str_index
:
19838 unsigned int str_index
= attr
->as_unsigned_reprocess ();
19839 gdb_assert (!attr
->canonical_string_p ());
19840 if (reader
->dwo_file
!= NULL
)
19841 attr
->set_string_noncanonical (read_dwo_str_index (reader
,
19844 attr
->set_string_noncanonical (read_stub_str_index (cu
,
19849 gdb_assert_not_reached (_("Unexpected DWARF form."));
19853 /* Read an attribute value described by an attribute form. */
19855 static const gdb_byte
*
19856 read_attribute_value (const struct die_reader_specs
*reader
,
19857 struct attribute
*attr
, unsigned form
,
19858 LONGEST implicit_const
, const gdb_byte
*info_ptr
)
19860 struct dwarf2_cu
*cu
= reader
->cu
;
19861 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
19862 struct objfile
*objfile
= per_objfile
->objfile
;
19863 bfd
*abfd
= reader
->abfd
;
19864 struct comp_unit_head
*cu_header
= &cu
->header
;
19865 unsigned int bytes_read
;
19866 struct dwarf_block
*blk
;
19868 attr
->form
= (enum dwarf_form
) form
;
19871 case DW_FORM_ref_addr
:
19872 if (cu_header
->version
== 2)
19873 attr
->set_unsigned (cu_header
->read_address (abfd
, info_ptr
,
19876 attr
->set_unsigned (cu_header
->read_offset (abfd
, info_ptr
,
19878 info_ptr
+= bytes_read
;
19880 case DW_FORM_GNU_ref_alt
:
19881 attr
->set_unsigned (cu_header
->read_offset (abfd
, info_ptr
,
19883 info_ptr
+= bytes_read
;
19887 struct gdbarch
*gdbarch
= objfile
->arch ();
19888 CORE_ADDR addr
= cu_header
->read_address (abfd
, info_ptr
, &bytes_read
);
19889 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, addr
);
19890 attr
->set_address (addr
);
19891 info_ptr
+= bytes_read
;
19894 case DW_FORM_block2
:
19895 blk
= dwarf_alloc_block (cu
);
19896 blk
->size
= read_2_bytes (abfd
, info_ptr
);
19898 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
19899 info_ptr
+= blk
->size
;
19900 attr
->set_block (blk
);
19902 case DW_FORM_block4
:
19903 blk
= dwarf_alloc_block (cu
);
19904 blk
->size
= read_4_bytes (abfd
, info_ptr
);
19906 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
19907 info_ptr
+= blk
->size
;
19908 attr
->set_block (blk
);
19910 case DW_FORM_data2
:
19911 attr
->set_unsigned (read_2_bytes (abfd
, info_ptr
));
19914 case DW_FORM_data4
:
19915 attr
->set_unsigned (read_4_bytes (abfd
, info_ptr
));
19918 case DW_FORM_data8
:
19919 attr
->set_unsigned (read_8_bytes (abfd
, info_ptr
));
19922 case DW_FORM_data16
:
19923 blk
= dwarf_alloc_block (cu
);
19925 blk
->data
= read_n_bytes (abfd
, info_ptr
, 16);
19927 attr
->set_block (blk
);
19929 case DW_FORM_sec_offset
:
19930 attr
->set_unsigned (cu_header
->read_offset (abfd
, info_ptr
,
19932 info_ptr
+= bytes_read
;
19934 case DW_FORM_loclistx
:
19936 attr
->set_unsigned_reprocess (read_unsigned_leb128 (abfd
, info_ptr
,
19938 info_ptr
+= bytes_read
;
19941 case DW_FORM_string
:
19942 attr
->set_string_noncanonical (read_direct_string (abfd
, info_ptr
,
19944 info_ptr
+= bytes_read
;
19947 if (!cu
->per_cu
->is_dwz
)
19949 attr
->set_string_noncanonical
19950 (read_indirect_string (per_objfile
,
19951 abfd
, info_ptr
, cu_header
,
19953 info_ptr
+= bytes_read
;
19957 case DW_FORM_line_strp
:
19958 if (!cu
->per_cu
->is_dwz
)
19960 attr
->set_string_noncanonical
19961 (per_objfile
->read_line_string (info_ptr
, cu_header
,
19963 info_ptr
+= bytes_read
;
19967 case DW_FORM_GNU_strp_alt
:
19969 dwz_file
*dwz
= dwarf2_get_dwz_file (per_objfile
->per_bfd
, true);
19970 LONGEST str_offset
= cu_header
->read_offset (abfd
, info_ptr
,
19973 attr
->set_string_noncanonical
19974 (dwz
->read_string (objfile
, str_offset
));
19975 info_ptr
+= bytes_read
;
19978 case DW_FORM_exprloc
:
19979 case DW_FORM_block
:
19980 blk
= dwarf_alloc_block (cu
);
19981 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
19982 info_ptr
+= bytes_read
;
19983 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
19984 info_ptr
+= blk
->size
;
19985 attr
->set_block (blk
);
19987 case DW_FORM_block1
:
19988 blk
= dwarf_alloc_block (cu
);
19989 blk
->size
= read_1_byte (abfd
, info_ptr
);
19991 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
19992 info_ptr
+= blk
->size
;
19993 attr
->set_block (blk
);
19995 case DW_FORM_data1
:
19997 attr
->set_unsigned (read_1_byte (abfd
, info_ptr
));
20000 case DW_FORM_flag_present
:
20001 attr
->set_unsigned (1);
20003 case DW_FORM_sdata
:
20004 attr
->set_signed (read_signed_leb128 (abfd
, info_ptr
, &bytes_read
));
20005 info_ptr
+= bytes_read
;
20007 case DW_FORM_rnglistx
:
20009 attr
->set_unsigned_reprocess (read_unsigned_leb128 (abfd
, info_ptr
,
20011 info_ptr
+= bytes_read
;
20014 case DW_FORM_udata
:
20015 attr
->set_unsigned (read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
20016 info_ptr
+= bytes_read
;
20019 attr
->set_unsigned ((to_underlying (cu_header
->sect_off
)
20020 + read_1_byte (abfd
, info_ptr
)));
20024 attr
->set_unsigned ((to_underlying (cu_header
->sect_off
)
20025 + read_2_bytes (abfd
, info_ptr
)));
20029 attr
->set_unsigned ((to_underlying (cu_header
->sect_off
)
20030 + read_4_bytes (abfd
, info_ptr
)));
20034 attr
->set_unsigned ((to_underlying (cu_header
->sect_off
)
20035 + read_8_bytes (abfd
, info_ptr
)));
20038 case DW_FORM_ref_sig8
:
20039 attr
->set_signature (read_8_bytes (abfd
, info_ptr
));
20042 case DW_FORM_ref_udata
:
20043 attr
->set_unsigned ((to_underlying (cu_header
->sect_off
)
20044 + read_unsigned_leb128 (abfd
, info_ptr
,
20046 info_ptr
+= bytes_read
;
20048 case DW_FORM_indirect
:
20049 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
20050 info_ptr
+= bytes_read
;
20051 if (form
== DW_FORM_implicit_const
)
20053 implicit_const
= read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
20054 info_ptr
+= bytes_read
;
20056 info_ptr
= read_attribute_value (reader
, attr
, form
, implicit_const
,
20059 case DW_FORM_implicit_const
:
20060 attr
->set_signed (implicit_const
);
20062 case DW_FORM_addrx
:
20063 case DW_FORM_GNU_addr_index
:
20064 attr
->set_unsigned_reprocess (read_unsigned_leb128 (abfd
, info_ptr
,
20066 info_ptr
+= bytes_read
;
20069 case DW_FORM_strx1
:
20070 case DW_FORM_strx2
:
20071 case DW_FORM_strx3
:
20072 case DW_FORM_strx4
:
20073 case DW_FORM_GNU_str_index
:
20075 ULONGEST str_index
;
20076 if (form
== DW_FORM_strx1
)
20078 str_index
= read_1_byte (abfd
, info_ptr
);
20081 else if (form
== DW_FORM_strx2
)
20083 str_index
= read_2_bytes (abfd
, info_ptr
);
20086 else if (form
== DW_FORM_strx3
)
20088 str_index
= read_3_bytes (abfd
, info_ptr
);
20091 else if (form
== DW_FORM_strx4
)
20093 str_index
= read_4_bytes (abfd
, info_ptr
);
20098 str_index
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
20099 info_ptr
+= bytes_read
;
20101 attr
->set_unsigned_reprocess (str_index
);
20105 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
20106 dwarf_form_name (form
),
20107 bfd_get_filename (abfd
));
20111 if (cu
->per_cu
->is_dwz
&& attr
->form_is_ref ())
20112 attr
->form
= DW_FORM_GNU_ref_alt
;
20114 /* We have seen instances where the compiler tried to emit a byte
20115 size attribute of -1 which ended up being encoded as an unsigned
20116 0xffffffff. Although 0xffffffff is technically a valid size value,
20117 an object of this size seems pretty unlikely so we can relatively
20118 safely treat these cases as if the size attribute was invalid and
20119 treat them as zero by default. */
20120 if (attr
->name
== DW_AT_byte_size
20121 && form
== DW_FORM_data4
20122 && attr
->as_unsigned () >= 0xffffffff)
20125 (_("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
20126 hex_string (attr
->as_unsigned ()));
20127 attr
->set_unsigned (0);
20133 /* Read an attribute described by an abbreviated attribute. */
20135 static const gdb_byte
*
20136 read_attribute (const struct die_reader_specs
*reader
,
20137 struct attribute
*attr
, const struct attr_abbrev
*abbrev
,
20138 const gdb_byte
*info_ptr
)
20140 attr
->name
= abbrev
->name
;
20141 attr
->string_is_canonical
= 0;
20142 attr
->requires_reprocessing
= 0;
20143 return read_attribute_value (reader
, attr
, abbrev
->form
,
20144 abbrev
->implicit_const
, info_ptr
);
20147 /* Return pointer to string at .debug_str offset STR_OFFSET. */
20149 static const char *
20150 read_indirect_string_at_offset (dwarf2_per_objfile
*per_objfile
,
20151 LONGEST str_offset
)
20153 return per_objfile
->per_bfd
->str
.read_string (per_objfile
->objfile
,
20154 str_offset
, "DW_FORM_strp");
20157 /* Return pointer to string at .debug_str offset as read from BUF.
20158 BUF is assumed to be in a compilation unit described by CU_HEADER.
20159 Return *BYTES_READ_PTR count of bytes read from BUF. */
20161 static const char *
20162 read_indirect_string (dwarf2_per_objfile
*per_objfile
, bfd
*abfd
,
20163 const gdb_byte
*buf
,
20164 const struct comp_unit_head
*cu_header
,
20165 unsigned int *bytes_read_ptr
)
20167 LONGEST str_offset
= cu_header
->read_offset (abfd
, buf
, bytes_read_ptr
);
20169 return read_indirect_string_at_offset (per_objfile
, str_offset
);
20175 dwarf2_per_objfile::read_line_string (const gdb_byte
*buf
,
20176 const struct comp_unit_head
*cu_header
,
20177 unsigned int *bytes_read_ptr
)
20179 bfd
*abfd
= objfile
->obfd
;
20180 LONGEST str_offset
= cu_header
->read_offset (abfd
, buf
, bytes_read_ptr
);
20182 return per_bfd
->line_str
.read_string (objfile
, str_offset
, "DW_FORM_line_strp");
20185 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
20186 ADDR_BASE is the DW_AT_addr_base (DW_AT_GNU_addr_base) attribute or zero.
20187 ADDR_SIZE is the size of addresses from the CU header. */
20190 read_addr_index_1 (dwarf2_per_objfile
*per_objfile
, unsigned int addr_index
,
20191 gdb::optional
<ULONGEST
> addr_base
, int addr_size
)
20193 struct objfile
*objfile
= per_objfile
->objfile
;
20194 bfd
*abfd
= objfile
->obfd
;
20195 const gdb_byte
*info_ptr
;
20196 ULONGEST addr_base_or_zero
= addr_base
.has_value () ? *addr_base
: 0;
20198 per_objfile
->per_bfd
->addr
.read (objfile
);
20199 if (per_objfile
->per_bfd
->addr
.buffer
== NULL
)
20200 error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
20201 objfile_name (objfile
));
20202 if (addr_base_or_zero
+ addr_index
* addr_size
20203 >= per_objfile
->per_bfd
->addr
.size
)
20204 error (_("DW_FORM_addr_index pointing outside of "
20205 ".debug_addr section [in module %s]"),
20206 objfile_name (objfile
));
20207 info_ptr
= (per_objfile
->per_bfd
->addr
.buffer
+ addr_base_or_zero
20208 + addr_index
* addr_size
);
20209 if (addr_size
== 4)
20210 return bfd_get_32 (abfd
, info_ptr
);
20212 return bfd_get_64 (abfd
, info_ptr
);
20215 /* Given index ADDR_INDEX in .debug_addr, fetch the value. */
20218 read_addr_index (struct dwarf2_cu
*cu
, unsigned int addr_index
)
20220 return read_addr_index_1 (cu
->per_objfile
, addr_index
,
20221 cu
->addr_base
, cu
->header
.addr_size
);
20224 /* Given a pointer to an leb128 value, fetch the value from .debug_addr. */
20227 read_addr_index_from_leb128 (struct dwarf2_cu
*cu
, const gdb_byte
*info_ptr
,
20228 unsigned int *bytes_read
)
20230 bfd
*abfd
= cu
->per_objfile
->objfile
->obfd
;
20231 unsigned int addr_index
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
20233 return read_addr_index (cu
, addr_index
);
20239 dwarf2_read_addr_index (dwarf2_per_cu_data
*per_cu
,
20240 dwarf2_per_objfile
*per_objfile
,
20241 unsigned int addr_index
)
20243 struct dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
20244 gdb::optional
<ULONGEST
> addr_base
;
20247 /* We need addr_base and addr_size.
20248 If we don't have PER_CU->cu, we have to get it.
20249 Nasty, but the alternative is storing the needed info in PER_CU,
20250 which at this point doesn't seem justified: it's not clear how frequently
20251 it would get used and it would increase the size of every PER_CU.
20252 Entry points like dwarf2_per_cu_addr_size do a similar thing
20253 so we're not in uncharted territory here.
20254 Alas we need to be a bit more complicated as addr_base is contained
20257 We don't need to read the entire CU(/TU).
20258 We just need the header and top level die.
20260 IWBN to use the aging mechanism to let us lazily later discard the CU.
20261 For now we skip this optimization. */
20265 addr_base
= cu
->addr_base
;
20266 addr_size
= cu
->header
.addr_size
;
20270 cutu_reader
reader (per_cu
, per_objfile
, nullptr, nullptr, false);
20271 addr_base
= reader
.cu
->addr_base
;
20272 addr_size
= reader
.cu
->header
.addr_size
;
20275 return read_addr_index_1 (per_objfile
, addr_index
, addr_base
, addr_size
);
20278 /* Given a DW_FORM_GNU_str_index value STR_INDEX, fetch the string.
20279 STR_SECTION, STR_OFFSETS_SECTION can be from a Fission stub or a
20282 static const char *
20283 read_str_index (struct dwarf2_cu
*cu
,
20284 struct dwarf2_section_info
*str_section
,
20285 struct dwarf2_section_info
*str_offsets_section
,
20286 ULONGEST str_offsets_base
, ULONGEST str_index
)
20288 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
20289 struct objfile
*objfile
= per_objfile
->objfile
;
20290 const char *objf_name
= objfile_name (objfile
);
20291 bfd
*abfd
= objfile
->obfd
;
20292 const gdb_byte
*info_ptr
;
20293 ULONGEST str_offset
;
20294 static const char form_name
[] = "DW_FORM_GNU_str_index or DW_FORM_strx";
20296 str_section
->read (objfile
);
20297 str_offsets_section
->read (objfile
);
20298 if (str_section
->buffer
== NULL
)
20299 error (_("%s used without %s section"
20300 " in CU at offset %s [in module %s]"),
20301 form_name
, str_section
->get_name (),
20302 sect_offset_str (cu
->header
.sect_off
), objf_name
);
20303 if (str_offsets_section
->buffer
== NULL
)
20304 error (_("%s used without %s section"
20305 " in CU at offset %s [in module %s]"),
20306 form_name
, str_section
->get_name (),
20307 sect_offset_str (cu
->header
.sect_off
), objf_name
);
20308 info_ptr
= (str_offsets_section
->buffer
20310 + str_index
* cu
->header
.offset_size
);
20311 if (cu
->header
.offset_size
== 4)
20312 str_offset
= bfd_get_32 (abfd
, info_ptr
);
20314 str_offset
= bfd_get_64 (abfd
, info_ptr
);
20315 if (str_offset
>= str_section
->size
)
20316 error (_("Offset from %s pointing outside of"
20317 " .debug_str.dwo section in CU at offset %s [in module %s]"),
20318 form_name
, sect_offset_str (cu
->header
.sect_off
), objf_name
);
20319 return (const char *) (str_section
->buffer
+ str_offset
);
20322 /* Given a DW_FORM_GNU_str_index from a DWO file, fetch the string. */
20324 static const char *
20325 read_dwo_str_index (const struct die_reader_specs
*reader
, ULONGEST str_index
)
20327 ULONGEST str_offsets_base
= reader
->cu
->header
.version
>= 5
20328 ? reader
->cu
->header
.addr_size
: 0;
20329 return read_str_index (reader
->cu
,
20330 &reader
->dwo_file
->sections
.str
,
20331 &reader
->dwo_file
->sections
.str_offsets
,
20332 str_offsets_base
, str_index
);
20335 /* Given a DW_FORM_GNU_str_index from a Fission stub, fetch the string. */
20337 static const char *
20338 read_stub_str_index (struct dwarf2_cu
*cu
, ULONGEST str_index
)
20340 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
20341 const char *objf_name
= objfile_name (objfile
);
20342 static const char form_name
[] = "DW_FORM_GNU_str_index";
20343 static const char str_offsets_attr_name
[] = "DW_AT_str_offsets";
20345 if (!cu
->str_offsets_base
.has_value ())
20346 error (_("%s used in Fission stub without %s"
20347 " in CU at offset 0x%lx [in module %s]"),
20348 form_name
, str_offsets_attr_name
,
20349 (long) cu
->header
.offset_size
, objf_name
);
20351 return read_str_index (cu
,
20352 &cu
->per_objfile
->per_bfd
->str
,
20353 &cu
->per_objfile
->per_bfd
->str_offsets
,
20354 *cu
->str_offsets_base
, str_index
);
20357 /* Return the length of an LEB128 number in BUF. */
20360 leb128_size (const gdb_byte
*buf
)
20362 const gdb_byte
*begin
= buf
;
20368 if ((byte
& 128) == 0)
20369 return buf
- begin
;
20373 static enum language
20374 dwarf_lang_to_enum_language (unsigned int lang
)
20376 enum language language
;
20385 language
= language_c
;
20388 case DW_LANG_C_plus_plus
:
20389 case DW_LANG_C_plus_plus_11
:
20390 case DW_LANG_C_plus_plus_14
:
20391 language
= language_cplus
;
20394 language
= language_d
;
20396 case DW_LANG_Fortran77
:
20397 case DW_LANG_Fortran90
:
20398 case DW_LANG_Fortran95
:
20399 case DW_LANG_Fortran03
:
20400 case DW_LANG_Fortran08
:
20401 language
= language_fortran
;
20404 language
= language_go
;
20406 case DW_LANG_Mips_Assembler
:
20407 language
= language_asm
;
20409 case DW_LANG_Ada83
:
20410 case DW_LANG_Ada95
:
20411 language
= language_ada
;
20413 case DW_LANG_Modula2
:
20414 language
= language_m2
;
20416 case DW_LANG_Pascal83
:
20417 language
= language_pascal
;
20420 language
= language_objc
;
20423 case DW_LANG_Rust_old
:
20424 language
= language_rust
;
20426 case DW_LANG_OpenCL
:
20427 language
= language_opencl
;
20429 case DW_LANG_Cobol74
:
20430 case DW_LANG_Cobol85
:
20432 language
= language_minimal
;
20439 /* Return the named attribute or NULL if not there. */
20441 static struct attribute
*
20442 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
20447 struct attribute
*spec
= NULL
;
20449 for (i
= 0; i
< die
->num_attrs
; ++i
)
20451 if (die
->attrs
[i
].name
== name
)
20452 return &die
->attrs
[i
];
20453 if (die
->attrs
[i
].name
== DW_AT_specification
20454 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
20455 spec
= &die
->attrs
[i
];
20461 die
= follow_die_ref (die
, spec
, &cu
);
20467 /* Return the string associated with a string-typed attribute, or NULL if it
20468 is either not found or is of an incorrect type. */
20470 static const char *
20471 dwarf2_string_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
20473 struct attribute
*attr
;
20474 const char *str
= NULL
;
20476 attr
= dwarf2_attr (die
, name
, cu
);
20480 str
= attr
->as_string ();
20481 if (str
== nullptr)
20482 complaint (_("string type expected for attribute %s for "
20483 "DIE at %s in module %s"),
20484 dwarf_attr_name (name
), sect_offset_str (die
->sect_off
),
20485 objfile_name (cu
->per_objfile
->objfile
));
20491 /* Return the dwo name or NULL if not present. If present, it is in either
20492 DW_AT_GNU_dwo_name or DW_AT_dwo_name attribute. */
20493 static const char *
20494 dwarf2_dwo_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
20496 const char *dwo_name
= dwarf2_string_attr (die
, DW_AT_GNU_dwo_name
, cu
);
20497 if (dwo_name
== nullptr)
20498 dwo_name
= dwarf2_string_attr (die
, DW_AT_dwo_name
, cu
);
20502 /* Return non-zero iff the attribute NAME is defined for the given DIE,
20503 and holds a non-zero value. This function should only be used for
20504 DW_FORM_flag or DW_FORM_flag_present attributes. */
20507 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
20509 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
20511 return attr
!= nullptr && attr
->as_boolean ();
20515 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
20517 /* A DIE is a declaration if it has a DW_AT_declaration attribute
20518 which value is non-zero. However, we have to be careful with
20519 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
20520 (via dwarf2_flag_true_p) follows this attribute. So we may
20521 end up accidently finding a declaration attribute that belongs
20522 to a different DIE referenced by the specification attribute,
20523 even though the given DIE does not have a declaration attribute. */
20524 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
20525 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
20528 /* Return the die giving the specification for DIE, if there is
20529 one. *SPEC_CU is the CU containing DIE on input, and the CU
20530 containing the return value on output. If there is no
20531 specification, but there is an abstract origin, that is
20534 static struct die_info
*
20535 die_specification (struct die_info
*die
, struct dwarf2_cu
**spec_cu
)
20537 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
,
20540 if (spec_attr
== NULL
)
20541 spec_attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, *spec_cu
);
20543 if (spec_attr
== NULL
)
20546 return follow_die_ref (die
, spec_attr
, spec_cu
);
20549 /* A convenience function to find the proper .debug_line section for a CU. */
20551 static struct dwarf2_section_info
*
20552 get_debug_line_section (struct dwarf2_cu
*cu
)
20554 struct dwarf2_section_info
*section
;
20555 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
20557 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
20559 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
20560 section
= &cu
->dwo_unit
->dwo_file
->sections
.line
;
20561 else if (cu
->per_cu
->is_dwz
)
20563 dwz_file
*dwz
= dwarf2_get_dwz_file (per_objfile
->per_bfd
, true);
20565 section
= &dwz
->line
;
20568 section
= &per_objfile
->per_bfd
->line
;
20573 /* Read the statement program header starting at OFFSET in
20574 .debug_line, or .debug_line.dwo. Return a pointer
20575 to a struct line_header, allocated using xmalloc.
20576 Returns NULL if there is a problem reading the header, e.g., if it
20577 has a version we don't understand.
20579 NOTE: the strings in the include directory and file name tables of
20580 the returned object point into the dwarf line section buffer,
20581 and must not be freed. */
20583 static line_header_up
20584 dwarf_decode_line_header (sect_offset sect_off
, struct dwarf2_cu
*cu
)
20586 struct dwarf2_section_info
*section
;
20587 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
20589 section
= get_debug_line_section (cu
);
20590 section
->read (per_objfile
->objfile
);
20591 if (section
->buffer
== NULL
)
20593 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
20594 complaint (_("missing .debug_line.dwo section"));
20596 complaint (_("missing .debug_line section"));
20600 return dwarf_decode_line_header (sect_off
, cu
->per_cu
->is_dwz
,
20601 per_objfile
, section
, &cu
->header
);
20604 /* Subroutine of dwarf_decode_lines to simplify it.
20605 Return the file name of the psymtab for the given file_entry.
20606 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
20607 If space for the result is malloc'd, *NAME_HOLDER will be set.
20608 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename. */
20610 static const char *
20611 psymtab_include_file_name (const struct line_header
*lh
, const file_entry
&fe
,
20612 const dwarf2_psymtab
*pst
,
20613 const char *comp_dir
,
20614 gdb::unique_xmalloc_ptr
<char> *name_holder
)
20616 const char *include_name
= fe
.name
;
20617 const char *include_name_to_compare
= include_name
;
20618 const char *pst_filename
;
20621 const char *dir_name
= fe
.include_dir (lh
);
20623 gdb::unique_xmalloc_ptr
<char> hold_compare
;
20624 if (!IS_ABSOLUTE_PATH (include_name
)
20625 && (dir_name
!= NULL
|| comp_dir
!= NULL
))
20627 /* Avoid creating a duplicate psymtab for PST.
20628 We do this by comparing INCLUDE_NAME and PST_FILENAME.
20629 Before we do the comparison, however, we need to account
20630 for DIR_NAME and COMP_DIR.
20631 First prepend dir_name (if non-NULL). If we still don't
20632 have an absolute path prepend comp_dir (if non-NULL).
20633 However, the directory we record in the include-file's
20634 psymtab does not contain COMP_DIR (to match the
20635 corresponding symtab(s)).
20640 bash$ gcc -g ./hello.c
20641 include_name = "hello.c"
20643 DW_AT_comp_dir = comp_dir = "/tmp"
20644 DW_AT_name = "./hello.c"
20648 if (dir_name
!= NULL
)
20650 name_holder
->reset (concat (dir_name
, SLASH_STRING
,
20651 include_name
, (char *) NULL
));
20652 include_name
= name_holder
->get ();
20653 include_name_to_compare
= include_name
;
20655 if (!IS_ABSOLUTE_PATH (include_name
) && comp_dir
!= NULL
)
20657 hold_compare
.reset (concat (comp_dir
, SLASH_STRING
,
20658 include_name
, (char *) NULL
));
20659 include_name_to_compare
= hold_compare
.get ();
20663 pst_filename
= pst
->filename
;
20664 gdb::unique_xmalloc_ptr
<char> copied_name
;
20665 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
20667 copied_name
.reset (concat (pst
->dirname
, SLASH_STRING
,
20668 pst_filename
, (char *) NULL
));
20669 pst_filename
= copied_name
.get ();
20672 file_is_pst
= FILENAME_CMP (include_name_to_compare
, pst_filename
) == 0;
20676 return include_name
;
20679 /* State machine to track the state of the line number program. */
20681 class lnp_state_machine
20684 /* Initialize a machine state for the start of a line number
20686 lnp_state_machine (struct dwarf2_cu
*cu
, gdbarch
*arch
, line_header
*lh
,
20687 bool record_lines_p
);
20689 file_entry
*current_file ()
20691 /* lh->file_names is 0-based, but the file name numbers in the
20692 statement program are 1-based. */
20693 return m_line_header
->file_name_at (m_file
);
20696 /* Record the line in the state machine. END_SEQUENCE is true if
20697 we're processing the end of a sequence. */
20698 void record_line (bool end_sequence
);
20700 /* Check ADDRESS is -1, or zero and less than UNRELOCATED_LOWPC, and if true
20701 nop-out rest of the lines in this sequence. */
20702 void check_line_address (struct dwarf2_cu
*cu
,
20703 const gdb_byte
*line_ptr
,
20704 CORE_ADDR unrelocated_lowpc
, CORE_ADDR address
);
20706 void handle_set_discriminator (unsigned int discriminator
)
20708 m_discriminator
= discriminator
;
20709 m_line_has_non_zero_discriminator
|= discriminator
!= 0;
20712 /* Handle DW_LNE_set_address. */
20713 void handle_set_address (CORE_ADDR baseaddr
, CORE_ADDR address
)
20716 address
+= baseaddr
;
20717 m_address
= gdbarch_adjust_dwarf2_line (m_gdbarch
, address
, false);
20720 /* Handle DW_LNS_advance_pc. */
20721 void handle_advance_pc (CORE_ADDR adjust
);
20723 /* Handle a special opcode. */
20724 void handle_special_opcode (unsigned char op_code
);
20726 /* Handle DW_LNS_advance_line. */
20727 void handle_advance_line (int line_delta
)
20729 advance_line (line_delta
);
20732 /* Handle DW_LNS_set_file. */
20733 void handle_set_file (file_name_index file
);
20735 /* Handle DW_LNS_negate_stmt. */
20736 void handle_negate_stmt ()
20738 m_is_stmt
= !m_is_stmt
;
20741 /* Handle DW_LNS_const_add_pc. */
20742 void handle_const_add_pc ();
20744 /* Handle DW_LNS_fixed_advance_pc. */
20745 void handle_fixed_advance_pc (CORE_ADDR addr_adj
)
20747 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
20751 /* Handle DW_LNS_copy. */
20752 void handle_copy ()
20754 record_line (false);
20755 m_discriminator
= 0;
20758 /* Handle DW_LNE_end_sequence. */
20759 void handle_end_sequence ()
20761 m_currently_recording_lines
= true;
20765 /* Advance the line by LINE_DELTA. */
20766 void advance_line (int line_delta
)
20768 m_line
+= line_delta
;
20770 if (line_delta
!= 0)
20771 m_line_has_non_zero_discriminator
= m_discriminator
!= 0;
20774 struct dwarf2_cu
*m_cu
;
20776 gdbarch
*m_gdbarch
;
20778 /* True if we're recording lines.
20779 Otherwise we're building partial symtabs and are just interested in
20780 finding include files mentioned by the line number program. */
20781 bool m_record_lines_p
;
20783 /* The line number header. */
20784 line_header
*m_line_header
;
20786 /* These are part of the standard DWARF line number state machine,
20787 and initialized according to the DWARF spec. */
20789 unsigned char m_op_index
= 0;
20790 /* The line table index of the current file. */
20791 file_name_index m_file
= 1;
20792 unsigned int m_line
= 1;
20794 /* These are initialized in the constructor. */
20796 CORE_ADDR m_address
;
20798 unsigned int m_discriminator
;
20800 /* Additional bits of state we need to track. */
20802 /* The last file that we called dwarf2_start_subfile for.
20803 This is only used for TLLs. */
20804 unsigned int m_last_file
= 0;
20805 /* The last file a line number was recorded for. */
20806 struct subfile
*m_last_subfile
= NULL
;
20808 /* The address of the last line entry. */
20809 CORE_ADDR m_last_address
;
20811 /* Set to true when a previous line at the same address (using
20812 m_last_address) had m_is_stmt true. This is reset to false when a
20813 line entry at a new address (m_address different to m_last_address) is
20815 bool m_stmt_at_address
= false;
20817 /* When true, record the lines we decode. */
20818 bool m_currently_recording_lines
= false;
20820 /* The last line number that was recorded, used to coalesce
20821 consecutive entries for the same line. This can happen, for
20822 example, when discriminators are present. PR 17276. */
20823 unsigned int m_last_line
= 0;
20824 bool m_line_has_non_zero_discriminator
= false;
20828 lnp_state_machine::handle_advance_pc (CORE_ADDR adjust
)
20830 CORE_ADDR addr_adj
= (((m_op_index
+ adjust
)
20831 / m_line_header
->maximum_ops_per_instruction
)
20832 * m_line_header
->minimum_instruction_length
);
20833 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
20834 m_op_index
= ((m_op_index
+ adjust
)
20835 % m_line_header
->maximum_ops_per_instruction
);
20839 lnp_state_machine::handle_special_opcode (unsigned char op_code
)
20841 unsigned char adj_opcode
= op_code
- m_line_header
->opcode_base
;
20842 unsigned char adj_opcode_d
= adj_opcode
/ m_line_header
->line_range
;
20843 unsigned char adj_opcode_r
= adj_opcode
% m_line_header
->line_range
;
20844 CORE_ADDR addr_adj
= (((m_op_index
+ adj_opcode_d
)
20845 / m_line_header
->maximum_ops_per_instruction
)
20846 * m_line_header
->minimum_instruction_length
);
20847 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
20848 m_op_index
= ((m_op_index
+ adj_opcode_d
)
20849 % m_line_header
->maximum_ops_per_instruction
);
20851 int line_delta
= m_line_header
->line_base
+ adj_opcode_r
;
20852 advance_line (line_delta
);
20853 record_line (false);
20854 m_discriminator
= 0;
20858 lnp_state_machine::handle_set_file (file_name_index file
)
20862 const file_entry
*fe
= current_file ();
20864 dwarf2_debug_line_missing_file_complaint ();
20865 else if (m_record_lines_p
)
20867 const char *dir
= fe
->include_dir (m_line_header
);
20869 m_last_subfile
= m_cu
->get_builder ()->get_current_subfile ();
20870 m_line_has_non_zero_discriminator
= m_discriminator
!= 0;
20871 dwarf2_start_subfile (m_cu
, fe
->name
, dir
);
20876 lnp_state_machine::handle_const_add_pc ()
20879 = (255 - m_line_header
->opcode_base
) / m_line_header
->line_range
;
20882 = (((m_op_index
+ adjust
)
20883 / m_line_header
->maximum_ops_per_instruction
)
20884 * m_line_header
->minimum_instruction_length
);
20886 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
20887 m_op_index
= ((m_op_index
+ adjust
)
20888 % m_line_header
->maximum_ops_per_instruction
);
20891 /* Return non-zero if we should add LINE to the line number table.
20892 LINE is the line to add, LAST_LINE is the last line that was added,
20893 LAST_SUBFILE is the subfile for LAST_LINE.
20894 LINE_HAS_NON_ZERO_DISCRIMINATOR is non-zero if LINE has ever
20895 had a non-zero discriminator.
20897 We have to be careful in the presence of discriminators.
20898 E.g., for this line:
20900 for (i = 0; i < 100000; i++);
20902 clang can emit four line number entries for that one line,
20903 each with a different discriminator.
20904 See gdb.dwarf2/dw2-single-line-discriminators.exp for an example.
20906 However, we want gdb to coalesce all four entries into one.
20907 Otherwise the user could stepi into the middle of the line and
20908 gdb would get confused about whether the pc really was in the
20909 middle of the line.
20911 Things are further complicated by the fact that two consecutive
20912 line number entries for the same line is a heuristic used by gcc
20913 to denote the end of the prologue. So we can't just discard duplicate
20914 entries, we have to be selective about it. The heuristic we use is
20915 that we only collapse consecutive entries for the same line if at least
20916 one of those entries has a non-zero discriminator. PR 17276.
20918 Note: Addresses in the line number state machine can never go backwards
20919 within one sequence, thus this coalescing is ok. */
20922 dwarf_record_line_p (struct dwarf2_cu
*cu
,
20923 unsigned int line
, unsigned int last_line
,
20924 int line_has_non_zero_discriminator
,
20925 struct subfile
*last_subfile
)
20927 if (cu
->get_builder ()->get_current_subfile () != last_subfile
)
20929 if (line
!= last_line
)
20931 /* Same line for the same file that we've seen already.
20932 As a last check, for pr 17276, only record the line if the line
20933 has never had a non-zero discriminator. */
20934 if (!line_has_non_zero_discriminator
)
20939 /* Use the CU's builder to record line number LINE beginning at
20940 address ADDRESS in the line table of subfile SUBFILE. */
20943 dwarf_record_line_1 (struct gdbarch
*gdbarch
, struct subfile
*subfile
,
20944 unsigned int line
, CORE_ADDR address
, bool is_stmt
,
20945 struct dwarf2_cu
*cu
)
20947 CORE_ADDR addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
20949 if (dwarf_line_debug
)
20951 fprintf_unfiltered (gdb_stdlog
,
20952 "Recording line %u, file %s, address %s\n",
20953 line
, lbasename (subfile
->name
),
20954 paddress (gdbarch
, address
));
20958 cu
->get_builder ()->record_line (subfile
, line
, addr
, is_stmt
);
20961 /* Subroutine of dwarf_decode_lines_1 to simplify it.
20962 Mark the end of a set of line number records.
20963 The arguments are the same as for dwarf_record_line_1.
20964 If SUBFILE is NULL the request is ignored. */
20967 dwarf_finish_line (struct gdbarch
*gdbarch
, struct subfile
*subfile
,
20968 CORE_ADDR address
, struct dwarf2_cu
*cu
)
20970 if (subfile
== NULL
)
20973 if (dwarf_line_debug
)
20975 fprintf_unfiltered (gdb_stdlog
,
20976 "Finishing current line, file %s, address %s\n",
20977 lbasename (subfile
->name
),
20978 paddress (gdbarch
, address
));
20981 dwarf_record_line_1 (gdbarch
, subfile
, 0, address
, true, cu
);
20985 lnp_state_machine::record_line (bool end_sequence
)
20987 if (dwarf_line_debug
)
20989 fprintf_unfiltered (gdb_stdlog
,
20990 "Processing actual line %u: file %u,"
20991 " address %s, is_stmt %u, discrim %u%s\n",
20993 paddress (m_gdbarch
, m_address
),
20994 m_is_stmt
, m_discriminator
,
20995 (end_sequence
? "\t(end sequence)" : ""));
20998 file_entry
*fe
= current_file ();
21001 dwarf2_debug_line_missing_file_complaint ();
21002 /* For now we ignore lines not starting on an instruction boundary.
21003 But not when processing end_sequence for compatibility with the
21004 previous version of the code. */
21005 else if (m_op_index
== 0 || end_sequence
)
21007 fe
->included_p
= true;
21008 if (m_record_lines_p
)
21010 /* When we switch files we insert an end maker in the first file,
21011 switch to the second file and add a new line entry. The
21012 problem is that the end marker inserted in the first file will
21013 discard any previous line entries at the same address. If the
21014 line entries in the first file are marked as is-stmt, while
21015 the new line in the second file is non-stmt, then this means
21016 the end marker will discard is-stmt lines so we can have a
21017 non-stmt line. This means that there are less addresses at
21018 which the user can insert a breakpoint.
21020 To improve this we track the last address in m_last_address,
21021 and whether we have seen an is-stmt at this address. Then
21022 when switching files, if we have seen a stmt at the current
21023 address, and we are switching to create a non-stmt line, then
21024 discard the new line. */
21026 = m_last_subfile
!= m_cu
->get_builder ()->get_current_subfile ();
21027 bool ignore_this_line
21028 = ((file_changed
&& !end_sequence
&& m_last_address
== m_address
21029 && !m_is_stmt
&& m_stmt_at_address
)
21030 || (!end_sequence
&& m_line
== 0));
21032 if ((file_changed
&& !ignore_this_line
) || end_sequence
)
21034 dwarf_finish_line (m_gdbarch
, m_last_subfile
, m_address
,
21035 m_currently_recording_lines
? m_cu
: nullptr);
21038 if (!end_sequence
&& !ignore_this_line
)
21040 bool is_stmt
= producer_is_codewarrior (m_cu
) || m_is_stmt
;
21042 if (dwarf_record_line_p (m_cu
, m_line
, m_last_line
,
21043 m_line_has_non_zero_discriminator
,
21046 buildsym_compunit
*builder
= m_cu
->get_builder ();
21047 dwarf_record_line_1 (m_gdbarch
,
21048 builder
->get_current_subfile (),
21049 m_line
, m_address
, is_stmt
,
21050 m_currently_recording_lines
? m_cu
: nullptr);
21052 m_last_subfile
= m_cu
->get_builder ()->get_current_subfile ();
21053 m_last_line
= m_line
;
21058 /* Track whether we have seen any m_is_stmt true at m_address in case we
21059 have multiple line table entries all at m_address. */
21060 if (m_last_address
!= m_address
)
21062 m_stmt_at_address
= false;
21063 m_last_address
= m_address
;
21065 m_stmt_at_address
|= m_is_stmt
;
21068 lnp_state_machine::lnp_state_machine (struct dwarf2_cu
*cu
, gdbarch
*arch
,
21069 line_header
*lh
, bool record_lines_p
)
21073 m_record_lines_p
= record_lines_p
;
21074 m_line_header
= lh
;
21076 m_currently_recording_lines
= true;
21078 /* Call `gdbarch_adjust_dwarf2_line' on the initial 0 address as if there
21079 was a line entry for it so that the backend has a chance to adjust it
21080 and also record it in case it needs it. This is currently used by MIPS
21081 code, cf. `mips_adjust_dwarf2_line'. */
21082 m_address
= gdbarch_adjust_dwarf2_line (arch
, 0, 0);
21083 m_is_stmt
= lh
->default_is_stmt
;
21084 m_discriminator
= 0;
21086 m_last_address
= m_address
;
21087 m_stmt_at_address
= false;
21091 lnp_state_machine::check_line_address (struct dwarf2_cu
*cu
,
21092 const gdb_byte
*line_ptr
,
21093 CORE_ADDR unrelocated_lowpc
, CORE_ADDR address
)
21095 /* Linkers resolve a symbolic relocation referencing a GC'd function to 0 or
21096 -1. If ADDRESS is 0, ignoring the opcode will err if the text section is
21097 located at 0x0. In this case, additionally check that if
21098 ADDRESS < UNRELOCATED_LOWPC. */
21100 if ((address
== 0 && address
< unrelocated_lowpc
)
21101 || address
== (CORE_ADDR
) -1)
21103 /* This line table is for a function which has been
21104 GCd by the linker. Ignore it. PR gdb/12528 */
21106 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
21107 long line_offset
= line_ptr
- get_debug_line_section (cu
)->buffer
;
21109 complaint (_(".debug_line address at offset 0x%lx is 0 [in module %s]"),
21110 line_offset
, objfile_name (objfile
));
21111 m_currently_recording_lines
= false;
21112 /* Note: m_currently_recording_lines is left as false until we see
21113 DW_LNE_end_sequence. */
21117 /* Subroutine of dwarf_decode_lines to simplify it.
21118 Process the line number information in LH.
21119 If DECODE_FOR_PST_P is non-zero, all we do is process the line number
21120 program in order to set included_p for every referenced header. */
21123 dwarf_decode_lines_1 (struct line_header
*lh
, struct dwarf2_cu
*cu
,
21124 const int decode_for_pst_p
, CORE_ADDR lowpc
)
21126 const gdb_byte
*line_ptr
, *extended_end
;
21127 const gdb_byte
*line_end
;
21128 unsigned int bytes_read
, extended_len
;
21129 unsigned char op_code
, extended_op
;
21130 CORE_ADDR baseaddr
;
21131 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
21132 bfd
*abfd
= objfile
->obfd
;
21133 struct gdbarch
*gdbarch
= objfile
->arch ();
21134 /* True if we're recording line info (as opposed to building partial
21135 symtabs and just interested in finding include files mentioned by
21136 the line number program). */
21137 bool record_lines_p
= !decode_for_pst_p
;
21139 baseaddr
= objfile
->text_section_offset ();
21141 line_ptr
= lh
->statement_program_start
;
21142 line_end
= lh
->statement_program_end
;
21144 /* Read the statement sequences until there's nothing left. */
21145 while (line_ptr
< line_end
)
21147 /* The DWARF line number program state machine. Reset the state
21148 machine at the start of each sequence. */
21149 lnp_state_machine
state_machine (cu
, gdbarch
, lh
, record_lines_p
);
21150 bool end_sequence
= false;
21152 if (record_lines_p
)
21154 /* Start a subfile for the current file of the state
21156 const file_entry
*fe
= state_machine
.current_file ();
21159 dwarf2_start_subfile (cu
, fe
->name
, fe
->include_dir (lh
));
21162 /* Decode the table. */
21163 while (line_ptr
< line_end
&& !end_sequence
)
21165 op_code
= read_1_byte (abfd
, line_ptr
);
21168 if (op_code
>= lh
->opcode_base
)
21170 /* Special opcode. */
21171 state_machine
.handle_special_opcode (op_code
);
21173 else switch (op_code
)
21175 case DW_LNS_extended_op
:
21176 extended_len
= read_unsigned_leb128 (abfd
, line_ptr
,
21178 line_ptr
+= bytes_read
;
21179 extended_end
= line_ptr
+ extended_len
;
21180 extended_op
= read_1_byte (abfd
, line_ptr
);
21182 if (DW_LNE_lo_user
<= extended_op
21183 && extended_op
<= DW_LNE_hi_user
)
21185 /* Vendor extension, ignore. */
21186 line_ptr
= extended_end
;
21189 switch (extended_op
)
21191 case DW_LNE_end_sequence
:
21192 state_machine
.handle_end_sequence ();
21193 end_sequence
= true;
21195 case DW_LNE_set_address
:
21198 = cu
->header
.read_address (abfd
, line_ptr
, &bytes_read
);
21199 line_ptr
+= bytes_read
;
21201 state_machine
.check_line_address (cu
, line_ptr
,
21202 lowpc
- baseaddr
, address
);
21203 state_machine
.handle_set_address (baseaddr
, address
);
21206 case DW_LNE_define_file
:
21208 const char *cur_file
;
21209 unsigned int mod_time
, length
;
21212 cur_file
= read_direct_string (abfd
, line_ptr
,
21214 line_ptr
+= bytes_read
;
21215 dindex
= (dir_index
)
21216 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21217 line_ptr
+= bytes_read
;
21219 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21220 line_ptr
+= bytes_read
;
21222 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21223 line_ptr
+= bytes_read
;
21224 lh
->add_file_name (cur_file
, dindex
, mod_time
, length
);
21227 case DW_LNE_set_discriminator
:
21229 /* The discriminator is not interesting to the
21230 debugger; just ignore it. We still need to
21231 check its value though:
21232 if there are consecutive entries for the same
21233 (non-prologue) line we want to coalesce them.
21236 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21237 line_ptr
+= bytes_read
;
21239 state_machine
.handle_set_discriminator (discr
);
21243 complaint (_("mangled .debug_line section"));
21246 /* Make sure that we parsed the extended op correctly. If e.g.
21247 we expected a different address size than the producer used,
21248 we may have read the wrong number of bytes. */
21249 if (line_ptr
!= extended_end
)
21251 complaint (_("mangled .debug_line section"));
21256 state_machine
.handle_copy ();
21258 case DW_LNS_advance_pc
:
21261 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21262 line_ptr
+= bytes_read
;
21264 state_machine
.handle_advance_pc (adjust
);
21267 case DW_LNS_advance_line
:
21270 = read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
21271 line_ptr
+= bytes_read
;
21273 state_machine
.handle_advance_line (line_delta
);
21276 case DW_LNS_set_file
:
21278 file_name_index file
21279 = (file_name_index
) read_unsigned_leb128 (abfd
, line_ptr
,
21281 line_ptr
+= bytes_read
;
21283 state_machine
.handle_set_file (file
);
21286 case DW_LNS_set_column
:
21287 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21288 line_ptr
+= bytes_read
;
21290 case DW_LNS_negate_stmt
:
21291 state_machine
.handle_negate_stmt ();
21293 case DW_LNS_set_basic_block
:
21295 /* Add to the address register of the state machine the
21296 address increment value corresponding to special opcode
21297 255. I.e., this value is scaled by the minimum
21298 instruction length since special opcode 255 would have
21299 scaled the increment. */
21300 case DW_LNS_const_add_pc
:
21301 state_machine
.handle_const_add_pc ();
21303 case DW_LNS_fixed_advance_pc
:
21305 CORE_ADDR addr_adj
= read_2_bytes (abfd
, line_ptr
);
21308 state_machine
.handle_fixed_advance_pc (addr_adj
);
21313 /* Unknown standard opcode, ignore it. */
21316 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
21318 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21319 line_ptr
+= bytes_read
;
21326 dwarf2_debug_line_missing_end_sequence_complaint ();
21328 /* We got a DW_LNE_end_sequence (or we ran off the end of the buffer,
21329 in which case we still finish recording the last line). */
21330 state_machine
.record_line (true);
21334 /* Decode the Line Number Program (LNP) for the given line_header
21335 structure and CU. The actual information extracted and the type
21336 of structures created from the LNP depends on the value of PST.
21338 1. If PST is NULL, then this procedure uses the data from the program
21339 to create all necessary symbol tables, and their linetables.
21341 2. If PST is not NULL, this procedure reads the program to determine
21342 the list of files included by the unit represented by PST, and
21343 builds all the associated partial symbol tables.
21345 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
21346 It is used for relative paths in the line table.
21347 NOTE: When processing partial symtabs (pst != NULL),
21348 comp_dir == pst->dirname.
21350 NOTE: It is important that psymtabs have the same file name (via strcmp)
21351 as the corresponding symtab. Since COMP_DIR is not used in the name of the
21352 symtab we don't use it in the name of the psymtabs we create.
21353 E.g. expand_line_sal requires this when finding psymtabs to expand.
21354 A good testcase for this is mb-inline.exp.
21356 LOWPC is the lowest address in CU (or 0 if not known).
21358 Boolean DECODE_MAPPING specifies we need to fully decode .debug_line
21359 for its PC<->lines mapping information. Otherwise only the filename
21360 table is read in. */
21363 dwarf_decode_lines (struct line_header
*lh
, const char *comp_dir
,
21364 struct dwarf2_cu
*cu
, dwarf2_psymtab
*pst
,
21365 CORE_ADDR lowpc
, int decode_mapping
)
21367 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
21368 const int decode_for_pst_p
= (pst
!= NULL
);
21370 if (decode_mapping
)
21371 dwarf_decode_lines_1 (lh
, cu
, decode_for_pst_p
, lowpc
);
21373 if (decode_for_pst_p
)
21375 /* Now that we're done scanning the Line Header Program, we can
21376 create the psymtab of each included file. */
21377 for (auto &file_entry
: lh
->file_names ())
21378 if (file_entry
.included_p
)
21380 gdb::unique_xmalloc_ptr
<char> name_holder
;
21381 const char *include_name
=
21382 psymtab_include_file_name (lh
, file_entry
, pst
,
21383 comp_dir
, &name_holder
);
21384 if (include_name
!= NULL
)
21385 dwarf2_create_include_psymtab
21386 (cu
->per_objfile
->per_bfd
, include_name
, pst
,
21387 cu
->per_objfile
->per_bfd
->partial_symtabs
.get (),
21393 /* Make sure a symtab is created for every file, even files
21394 which contain only variables (i.e. no code with associated
21396 buildsym_compunit
*builder
= cu
->get_builder ();
21397 struct compunit_symtab
*cust
= builder
->get_compunit_symtab ();
21399 for (auto &fe
: lh
->file_names ())
21401 dwarf2_start_subfile (cu
, fe
.name
, fe
.include_dir (lh
));
21402 if (builder
->get_current_subfile ()->symtab
== NULL
)
21404 builder
->get_current_subfile ()->symtab
21405 = allocate_symtab (cust
,
21406 builder
->get_current_subfile ()->name
);
21408 fe
.symtab
= builder
->get_current_subfile ()->symtab
;
21413 /* Start a subfile for DWARF. FILENAME is the name of the file and
21414 DIRNAME the name of the source directory which contains FILENAME
21415 or NULL if not known.
21416 This routine tries to keep line numbers from identical absolute and
21417 relative file names in a common subfile.
21419 Using the `list' example from the GDB testsuite, which resides in
21420 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
21421 of /srcdir/list0.c yields the following debugging information for list0.c:
21423 DW_AT_name: /srcdir/list0.c
21424 DW_AT_comp_dir: /compdir
21425 files.files[0].name: list0.h
21426 files.files[0].dir: /srcdir
21427 files.files[1].name: list0.c
21428 files.files[1].dir: /srcdir
21430 The line number information for list0.c has to end up in a single
21431 subfile, so that `break /srcdir/list0.c:1' works as expected.
21432 start_subfile will ensure that this happens provided that we pass the
21433 concatenation of files.files[1].dir and files.files[1].name as the
21437 dwarf2_start_subfile (struct dwarf2_cu
*cu
, const char *filename
,
21438 const char *dirname
)
21440 gdb::unique_xmalloc_ptr
<char> copy
;
21442 /* In order not to lose the line information directory,
21443 we concatenate it to the filename when it makes sense.
21444 Note that the Dwarf3 standard says (speaking of filenames in line
21445 information): ``The directory index is ignored for file names
21446 that represent full path names''. Thus ignoring dirname in the
21447 `else' branch below isn't an issue. */
21449 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
21451 copy
.reset (concat (dirname
, SLASH_STRING
, filename
, (char *) NULL
));
21452 filename
= copy
.get ();
21455 cu
->get_builder ()->start_subfile (filename
);
21459 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
21460 struct dwarf2_cu
*cu
)
21462 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
21463 struct comp_unit_head
*cu_header
= &cu
->header
;
21465 /* NOTE drow/2003-01-30: There used to be a comment and some special
21466 code here to turn a symbol with DW_AT_external and a
21467 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
21468 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
21469 with some versions of binutils) where shared libraries could have
21470 relocations against symbols in their debug information - the
21471 minimal symbol would have the right address, but the debug info
21472 would not. It's no longer necessary, because we will explicitly
21473 apply relocations when we read in the debug information now. */
21475 /* A DW_AT_location attribute with no contents indicates that a
21476 variable has been optimized away. */
21477 if (attr
->form_is_block () && attr
->as_block ()->size
== 0)
21479 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
21483 /* Handle one degenerate form of location expression specially, to
21484 preserve GDB's previous behavior when section offsets are
21485 specified. If this is just a DW_OP_addr, DW_OP_addrx, or
21486 DW_OP_GNU_addr_index then mark this symbol as LOC_STATIC. */
21488 if (attr
->form_is_block ())
21490 struct dwarf_block
*block
= attr
->as_block ();
21492 if ((block
->data
[0] == DW_OP_addr
21493 && block
->size
== 1 + cu_header
->addr_size
)
21494 || ((block
->data
[0] == DW_OP_GNU_addr_index
21495 || block
->data
[0] == DW_OP_addrx
)
21497 == 1 + leb128_size (&block
->data
[1]))))
21499 unsigned int dummy
;
21501 if (block
->data
[0] == DW_OP_addr
)
21502 SET_SYMBOL_VALUE_ADDRESS
21503 (sym
, cu
->header
.read_address (objfile
->obfd
,
21507 SET_SYMBOL_VALUE_ADDRESS
21508 (sym
, read_addr_index_from_leb128 (cu
, block
->data
+ 1,
21510 SYMBOL_ACLASS_INDEX (sym
) = LOC_STATIC
;
21511 fixup_symbol_section (sym
, objfile
);
21512 SET_SYMBOL_VALUE_ADDRESS
21514 SYMBOL_VALUE_ADDRESS (sym
)
21515 + objfile
->section_offsets
[sym
->section_index ()]);
21520 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
21521 expression evaluator, and use LOC_COMPUTED only when necessary
21522 (i.e. when the value of a register or memory location is
21523 referenced, or a thread-local block, etc.). Then again, it might
21524 not be worthwhile. I'm assuming that it isn't unless performance
21525 or memory numbers show me otherwise. */
21527 dwarf2_symbol_mark_computed (attr
, sym
, cu
, 0);
21529 if (SYMBOL_COMPUTED_OPS (sym
)->location_has_loclist
)
21530 cu
->has_loclist
= true;
21533 /* Given a pointer to a DWARF information entry, figure out if we need
21534 to make a symbol table entry for it, and if so, create a new entry
21535 and return a pointer to it.
21536 If TYPE is NULL, determine symbol type from the die, otherwise
21537 used the passed type.
21538 If SPACE is not NULL, use it to hold the new symbol. If it is
21539 NULL, allocate a new symbol on the objfile's obstack. */
21541 static struct symbol
*
21542 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
,
21543 struct symbol
*space
)
21545 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
21546 struct objfile
*objfile
= per_objfile
->objfile
;
21547 struct gdbarch
*gdbarch
= objfile
->arch ();
21548 struct symbol
*sym
= NULL
;
21550 struct attribute
*attr
= NULL
;
21551 struct attribute
*attr2
= NULL
;
21552 CORE_ADDR baseaddr
;
21553 struct pending
**list_to_add
= NULL
;
21555 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
21557 baseaddr
= objfile
->text_section_offset ();
21559 name
= dwarf2_name (die
, cu
);
21562 int suppress_add
= 0;
21567 sym
= new (&objfile
->objfile_obstack
) symbol
;
21568 OBJSTAT (objfile
, n_syms
++);
21570 /* Cache this symbol's name and the name's demangled form (if any). */
21571 sym
->set_language (cu
->per_cu
->lang
, &objfile
->objfile_obstack
);
21572 /* Fortran does not have mangling standard and the mangling does differ
21573 between gfortran, iFort etc. */
21574 const char *physname
21575 = (cu
->per_cu
->lang
== language_fortran
21576 ? dwarf2_full_name (name
, die
, cu
)
21577 : dwarf2_physname (name
, die
, cu
));
21578 const char *linkagename
= dw2_linkage_name (die
, cu
);
21580 if (linkagename
== nullptr || cu
->per_cu
->lang
== language_ada
)
21581 sym
->set_linkage_name (physname
);
21584 sym
->set_demangled_name (physname
, &objfile
->objfile_obstack
);
21585 sym
->set_linkage_name (linkagename
);
21588 /* Default assumptions.
21589 Use the passed type or decode it from the die. */
21590 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
21591 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
21593 SYMBOL_TYPE (sym
) = type
;
21595 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
21596 attr
= dwarf2_attr (die
,
21597 inlined_func
? DW_AT_call_line
: DW_AT_decl_line
,
21599 if (attr
!= nullptr)
21600 SYMBOL_LINE (sym
) = attr
->constant_value (0);
21602 attr
= dwarf2_attr (die
,
21603 inlined_func
? DW_AT_call_file
: DW_AT_decl_file
,
21605 if (attr
!= nullptr && attr
->is_nonnegative ())
21607 file_name_index file_index
21608 = (file_name_index
) attr
->as_nonnegative ();
21609 struct file_entry
*fe
;
21611 if (cu
->line_header
!= NULL
)
21612 fe
= cu
->line_header
->file_name_at (file_index
);
21617 complaint (_("file index out of range"));
21619 symbol_set_symtab (sym
, fe
->symtab
);
21625 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
21626 if (attr
!= nullptr)
21630 addr
= attr
->as_address ();
21631 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, addr
+ baseaddr
);
21632 SET_SYMBOL_VALUE_ADDRESS (sym
, addr
);
21633 SYMBOL_ACLASS_INDEX (sym
) = LOC_LABEL
;
21636 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
21637 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_core_addr
;
21638 SYMBOL_DOMAIN (sym
) = LABEL_DOMAIN
;
21639 add_symbol_to_list (sym
, cu
->list_in_scope
);
21641 case DW_TAG_subprogram
:
21642 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21644 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
21645 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
21646 if ((attr2
!= nullptr && attr2
->as_boolean ())
21647 || cu
->per_cu
->lang
== language_ada
21648 || cu
->per_cu
->lang
== language_fortran
)
21650 /* Subprograms marked external are stored as a global symbol.
21651 Ada and Fortran subprograms, whether marked external or
21652 not, are always stored as a global symbol, because we want
21653 to be able to access them globally. For instance, we want
21654 to be able to break on a nested subprogram without having
21655 to specify the context. */
21656 list_to_add
= cu
->get_builder ()->get_global_symbols ();
21660 list_to_add
= cu
->list_in_scope
;
21663 case DW_TAG_inlined_subroutine
:
21664 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21666 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
21667 SYMBOL_INLINED (sym
) = 1;
21668 list_to_add
= cu
->list_in_scope
;
21670 case DW_TAG_template_value_param
:
21672 /* Fall through. */
21673 case DW_TAG_constant
:
21674 case DW_TAG_variable
:
21675 case DW_TAG_member
:
21676 /* Compilation with minimal debug info may result in
21677 variables with missing type entries. Change the
21678 misleading `void' type to something sensible. */
21679 if (SYMBOL_TYPE (sym
)->code () == TYPE_CODE_VOID
)
21680 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_int
;
21682 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
21683 /* In the case of DW_TAG_member, we should only be called for
21684 static const members. */
21685 if (die
->tag
== DW_TAG_member
)
21687 /* dwarf2_add_field uses die_is_declaration,
21688 so we do the same. */
21689 gdb_assert (die_is_declaration (die
, cu
));
21692 if (attr
!= nullptr)
21694 dwarf2_const_value (attr
, sym
, cu
);
21695 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
21698 if (attr2
!= nullptr && attr2
->as_boolean ())
21699 list_to_add
= cu
->get_builder ()->get_global_symbols ();
21701 list_to_add
= cu
->list_in_scope
;
21705 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
21706 if (attr
!= nullptr)
21708 var_decode_location (attr
, sym
, cu
);
21709 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
21711 /* Fortran explicitly imports any global symbols to the local
21712 scope by DW_TAG_common_block. */
21713 if (cu
->per_cu
->lang
== language_fortran
&& die
->parent
21714 && die
->parent
->tag
== DW_TAG_common_block
)
21717 if (SYMBOL_CLASS (sym
) == LOC_STATIC
21718 && SYMBOL_VALUE_ADDRESS (sym
) == 0
21719 && !per_objfile
->per_bfd
->has_section_at_zero
)
21721 /* When a static variable is eliminated by the linker,
21722 the corresponding debug information is not stripped
21723 out, but the variable address is set to null;
21724 do not add such variables into symbol table. */
21726 else if (attr2
!= nullptr && attr2
->as_boolean ())
21728 if (SYMBOL_CLASS (sym
) == LOC_STATIC
21729 && (objfile
->flags
& OBJF_MAINLINE
) == 0
21730 && per_objfile
->per_bfd
->can_copy
)
21732 /* A global static variable might be subject to
21733 copy relocation. We first check for a local
21734 minsym, though, because maybe the symbol was
21735 marked hidden, in which case this would not
21737 bound_minimal_symbol found
21738 = (lookup_minimal_symbol_linkage
21739 (sym
->linkage_name (), objfile
));
21740 if (found
.minsym
!= nullptr)
21741 sym
->maybe_copied
= 1;
21744 /* A variable with DW_AT_external is never static,
21745 but it may be block-scoped. */
21747 = ((cu
->list_in_scope
21748 == cu
->get_builder ()->get_file_symbols ())
21749 ? cu
->get_builder ()->get_global_symbols ()
21750 : cu
->list_in_scope
);
21753 list_to_add
= cu
->list_in_scope
;
21757 /* We do not know the address of this symbol.
21758 If it is an external symbol and we have type information
21759 for it, enter the symbol as a LOC_UNRESOLVED symbol.
21760 The address of the variable will then be determined from
21761 the minimal symbol table whenever the variable is
21763 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
21765 /* Fortran explicitly imports any global symbols to the local
21766 scope by DW_TAG_common_block. */
21767 if (cu
->per_cu
->lang
== language_fortran
&& die
->parent
21768 && die
->parent
->tag
== DW_TAG_common_block
)
21770 /* SYMBOL_CLASS doesn't matter here because
21771 read_common_block is going to reset it. */
21773 list_to_add
= cu
->list_in_scope
;
21775 else if (attr2
!= nullptr && attr2
->as_boolean ()
21776 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
21778 /* A variable with DW_AT_external is never static, but it
21779 may be block-scoped. */
21781 = ((cu
->list_in_scope
21782 == cu
->get_builder ()->get_file_symbols ())
21783 ? cu
->get_builder ()->get_global_symbols ()
21784 : cu
->list_in_scope
);
21786 SYMBOL_ACLASS_INDEX (sym
) = LOC_UNRESOLVED
;
21788 else if (!die_is_declaration (die
, cu
))
21790 /* Use the default LOC_OPTIMIZED_OUT class. */
21791 gdb_assert (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
);
21793 list_to_add
= cu
->list_in_scope
;
21797 case DW_TAG_formal_parameter
:
21799 /* If we are inside a function, mark this as an argument. If
21800 not, we might be looking at an argument to an inlined function
21801 when we do not have enough information to show inlined frames;
21802 pretend it's a local variable in that case so that the user can
21804 struct context_stack
*curr
21805 = cu
->get_builder ()->get_current_context_stack ();
21806 if (curr
!= nullptr && curr
->name
!= nullptr)
21807 SYMBOL_IS_ARGUMENT (sym
) = 1;
21808 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
21809 if (attr
!= nullptr)
21811 var_decode_location (attr
, sym
, cu
);
21813 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
21814 if (attr
!= nullptr)
21816 dwarf2_const_value (attr
, sym
, cu
);
21819 list_to_add
= cu
->list_in_scope
;
21822 case DW_TAG_unspecified_parameters
:
21823 /* From varargs functions; gdb doesn't seem to have any
21824 interest in this information, so just ignore it for now.
21827 case DW_TAG_template_type_param
:
21829 /* Fall through. */
21830 case DW_TAG_class_type
:
21831 case DW_TAG_interface_type
:
21832 case DW_TAG_structure_type
:
21833 case DW_TAG_union_type
:
21834 case DW_TAG_set_type
:
21835 case DW_TAG_enumeration_type
:
21836 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
21837 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
21840 /* NOTE: carlton/2003-11-10: C++ class symbols shouldn't
21841 really ever be static objects: otherwise, if you try
21842 to, say, break of a class's method and you're in a file
21843 which doesn't mention that class, it won't work unless
21844 the check for all static symbols in lookup_symbol_aux
21845 saves you. See the OtherFileClass tests in
21846 gdb.c++/namespace.exp. */
21850 buildsym_compunit
*builder
= cu
->get_builder ();
21852 = (cu
->list_in_scope
== builder
->get_file_symbols ()
21853 && cu
->per_cu
->lang
== language_cplus
21854 ? builder
->get_global_symbols ()
21855 : cu
->list_in_scope
);
21857 /* The semantics of C++ state that "struct foo {
21858 ... }" also defines a typedef for "foo". */
21859 if (cu
->per_cu
->lang
== language_cplus
21860 || cu
->per_cu
->lang
== language_ada
21861 || cu
->per_cu
->lang
== language_d
21862 || cu
->per_cu
->lang
== language_rust
)
21864 /* The symbol's name is already allocated along
21865 with this objfile, so we don't need to
21866 duplicate it for the type. */
21867 if (SYMBOL_TYPE (sym
)->name () == 0)
21868 SYMBOL_TYPE (sym
)->set_name (sym
->search_name ());
21873 case DW_TAG_typedef
:
21874 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
21875 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
21876 list_to_add
= cu
->list_in_scope
;
21878 case DW_TAG_array_type
:
21879 case DW_TAG_base_type
:
21880 case DW_TAG_subrange_type
:
21881 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
21882 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
21883 list_to_add
= cu
->list_in_scope
;
21885 case DW_TAG_enumerator
:
21886 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
21887 if (attr
!= nullptr)
21889 dwarf2_const_value (attr
, sym
, cu
);
21892 /* NOTE: carlton/2003-11-10: See comment above in the
21893 DW_TAG_class_type, etc. block. */
21896 = (cu
->list_in_scope
== cu
->get_builder ()->get_file_symbols ()
21897 && cu
->per_cu
->lang
== language_cplus
21898 ? cu
->get_builder ()->get_global_symbols ()
21899 : cu
->list_in_scope
);
21902 case DW_TAG_imported_declaration
:
21903 case DW_TAG_namespace
:
21904 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
21905 list_to_add
= cu
->get_builder ()->get_global_symbols ();
21907 case DW_TAG_module
:
21908 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
21909 SYMBOL_DOMAIN (sym
) = MODULE_DOMAIN
;
21910 list_to_add
= cu
->get_builder ()->get_global_symbols ();
21912 case DW_TAG_common_block
:
21913 SYMBOL_ACLASS_INDEX (sym
) = LOC_COMMON_BLOCK
;
21914 SYMBOL_DOMAIN (sym
) = COMMON_BLOCK_DOMAIN
;
21915 add_symbol_to_list (sym
, cu
->list_in_scope
);
21918 /* Not a tag we recognize. Hopefully we aren't processing
21919 trash data, but since we must specifically ignore things
21920 we don't recognize, there is nothing else we should do at
21922 complaint (_("unsupported tag: '%s'"),
21923 dwarf_tag_name (die
->tag
));
21929 sym
->hash_next
= objfile
->template_symbols
;
21930 objfile
->template_symbols
= sym
;
21931 list_to_add
= NULL
;
21934 if (list_to_add
!= NULL
)
21935 add_symbol_to_list (sym
, list_to_add
);
21937 /* For the benefit of old versions of GCC, check for anonymous
21938 namespaces based on the demangled name. */
21939 if (!cu
->processing_has_namespace_info
21940 && cu
->per_cu
->lang
== language_cplus
)
21941 cp_scan_for_anonymous_namespaces (cu
->get_builder (), sym
, objfile
);
21946 /* Given an attr with a DW_FORM_dataN value in host byte order,
21947 zero-extend it as appropriate for the symbol's type. The DWARF
21948 standard (v4) is not entirely clear about the meaning of using
21949 DW_FORM_dataN for a constant with a signed type, where the type is
21950 wider than the data. The conclusion of a discussion on the DWARF
21951 list was that this is unspecified. We choose to always zero-extend
21952 because that is the interpretation long in use by GCC. */
21955 dwarf2_const_value_data (const struct attribute
*attr
, struct obstack
*obstack
,
21956 struct dwarf2_cu
*cu
, LONGEST
*value
, int bits
)
21958 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
21959 enum bfd_endian byte_order
= bfd_big_endian (objfile
->obfd
) ?
21960 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
21961 LONGEST l
= attr
->constant_value (0);
21963 if (bits
< sizeof (*value
) * 8)
21965 l
&= ((LONGEST
) 1 << bits
) - 1;
21968 else if (bits
== sizeof (*value
) * 8)
21972 gdb_byte
*bytes
= (gdb_byte
*) obstack_alloc (obstack
, bits
/ 8);
21973 store_unsigned_integer (bytes
, bits
/ 8, byte_order
, l
);
21980 /* Read a constant value from an attribute. Either set *VALUE, or if
21981 the value does not fit in *VALUE, set *BYTES - either already
21982 allocated on the objfile obstack, or newly allocated on OBSTACK,
21983 or, set *BATON, if we translated the constant to a location
21987 dwarf2_const_value_attr (const struct attribute
*attr
, struct type
*type
,
21988 const char *name
, struct obstack
*obstack
,
21989 struct dwarf2_cu
*cu
,
21990 LONGEST
*value
, const gdb_byte
**bytes
,
21991 struct dwarf2_locexpr_baton
**baton
)
21993 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
21994 struct objfile
*objfile
= per_objfile
->objfile
;
21995 struct comp_unit_head
*cu_header
= &cu
->header
;
21996 struct dwarf_block
*blk
;
21997 enum bfd_endian byte_order
= (bfd_big_endian (objfile
->obfd
) ?
21998 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
22004 switch (attr
->form
)
22007 case DW_FORM_addrx
:
22008 case DW_FORM_GNU_addr_index
:
22012 if (TYPE_LENGTH (type
) != cu_header
->addr_size
)
22013 dwarf2_const_value_length_mismatch_complaint (name
,
22014 cu_header
->addr_size
,
22015 TYPE_LENGTH (type
));
22016 /* Symbols of this form are reasonably rare, so we just
22017 piggyback on the existing location code rather than writing
22018 a new implementation of symbol_computed_ops. */
22019 *baton
= XOBNEW (obstack
, struct dwarf2_locexpr_baton
);
22020 (*baton
)->per_objfile
= per_objfile
;
22021 (*baton
)->per_cu
= cu
->per_cu
;
22022 gdb_assert ((*baton
)->per_cu
);
22024 (*baton
)->size
= 2 + cu_header
->addr_size
;
22025 data
= (gdb_byte
*) obstack_alloc (obstack
, (*baton
)->size
);
22026 (*baton
)->data
= data
;
22028 data
[0] = DW_OP_addr
;
22029 store_unsigned_integer (&data
[1], cu_header
->addr_size
,
22030 byte_order
, attr
->as_address ());
22031 data
[cu_header
->addr_size
+ 1] = DW_OP_stack_value
;
22034 case DW_FORM_string
:
22037 case DW_FORM_GNU_str_index
:
22038 case DW_FORM_GNU_strp_alt
:
22039 /* The string is already allocated on the objfile obstack, point
22041 *bytes
= (const gdb_byte
*) attr
->as_string ();
22043 case DW_FORM_block1
:
22044 case DW_FORM_block2
:
22045 case DW_FORM_block4
:
22046 case DW_FORM_block
:
22047 case DW_FORM_exprloc
:
22048 case DW_FORM_data16
:
22049 blk
= attr
->as_block ();
22050 if (TYPE_LENGTH (type
) != blk
->size
)
22051 dwarf2_const_value_length_mismatch_complaint (name
, blk
->size
,
22052 TYPE_LENGTH (type
));
22053 *bytes
= blk
->data
;
22056 /* The DW_AT_const_value attributes are supposed to carry the
22057 symbol's value "represented as it would be on the target
22058 architecture." By the time we get here, it's already been
22059 converted to host endianness, so we just need to sign- or
22060 zero-extend it as appropriate. */
22061 case DW_FORM_data1
:
22062 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 8);
22064 case DW_FORM_data2
:
22065 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 16);
22067 case DW_FORM_data4
:
22068 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 32);
22070 case DW_FORM_data8
:
22071 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 64);
22074 case DW_FORM_sdata
:
22075 case DW_FORM_implicit_const
:
22076 *value
= attr
->as_signed ();
22079 case DW_FORM_udata
:
22080 *value
= attr
->as_unsigned ();
22084 complaint (_("unsupported const value attribute form: '%s'"),
22085 dwarf_form_name (attr
->form
));
22092 /* Copy constant value from an attribute to a symbol. */
22095 dwarf2_const_value (const struct attribute
*attr
, struct symbol
*sym
,
22096 struct dwarf2_cu
*cu
)
22098 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22100 const gdb_byte
*bytes
;
22101 struct dwarf2_locexpr_baton
*baton
;
22103 dwarf2_const_value_attr (attr
, SYMBOL_TYPE (sym
),
22104 sym
->print_name (),
22105 &objfile
->objfile_obstack
, cu
,
22106 &value
, &bytes
, &baton
);
22110 SYMBOL_LOCATION_BATON (sym
) = baton
;
22111 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
22113 else if (bytes
!= NULL
)
22115 SYMBOL_VALUE_BYTES (sym
) = bytes
;
22116 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST_BYTES
;
22120 SYMBOL_VALUE (sym
) = value
;
22121 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST
;
22125 /* Return the type of the die in question using its DW_AT_type attribute. */
22127 static struct type
*
22128 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
22130 struct attribute
*type_attr
;
22132 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
22135 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22136 /* A missing DW_AT_type represents a void type. */
22137 return objfile_type (objfile
)->builtin_void
;
22140 return lookup_die_type (die
, type_attr
, cu
);
22143 /* True iff CU's producer generates GNAT Ada auxiliary information
22144 that allows to find parallel types through that information instead
22145 of having to do expensive parallel lookups by type name. */
22148 need_gnat_info (struct dwarf2_cu
*cu
)
22150 /* Assume that the Ada compiler was GNAT, which always produces
22151 the auxiliary information. */
22152 return (cu
->per_cu
->lang
== language_ada
);
22155 /* Return the auxiliary type of the die in question using its
22156 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
22157 attribute is not present. */
22159 static struct type
*
22160 die_descriptive_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
22162 struct attribute
*type_attr
;
22164 type_attr
= dwarf2_attr (die
, DW_AT_GNAT_descriptive_type
, cu
);
22168 return lookup_die_type (die
, type_attr
, cu
);
22171 /* If DIE has a descriptive_type attribute, then set the TYPE's
22172 descriptive type accordingly. */
22175 set_descriptive_type (struct type
*type
, struct die_info
*die
,
22176 struct dwarf2_cu
*cu
)
22178 struct type
*descriptive_type
= die_descriptive_type (die
, cu
);
22180 if (descriptive_type
)
22182 ALLOCATE_GNAT_AUX_TYPE (type
);
22183 TYPE_DESCRIPTIVE_TYPE (type
) = descriptive_type
;
22187 /* Return the containing type of the die in question using its
22188 DW_AT_containing_type attribute. */
22190 static struct type
*
22191 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
22193 struct attribute
*type_attr
;
22194 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22196 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
22198 error (_("Dwarf Error: Problem turning containing type into gdb type "
22199 "[in module %s]"), objfile_name (objfile
));
22201 return lookup_die_type (die
, type_attr
, cu
);
22204 /* Return an error marker type to use for the ill formed type in DIE/CU. */
22206 static struct type
*
22207 build_error_marker_type (struct dwarf2_cu
*cu
, struct die_info
*die
)
22209 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
22210 struct objfile
*objfile
= per_objfile
->objfile
;
22213 std::string message
22214 = string_printf (_("<unknown type in %s, CU %s, DIE %s>"),
22215 objfile_name (objfile
),
22216 sect_offset_str (cu
->header
.sect_off
),
22217 sect_offset_str (die
->sect_off
));
22218 saved
= obstack_strdup (&objfile
->objfile_obstack
, message
);
22220 return init_type (objfile
, TYPE_CODE_ERROR
, 0, saved
);
22223 /* Look up the type of DIE in CU using its type attribute ATTR.
22224 ATTR must be one of: DW_AT_type, DW_AT_GNAT_descriptive_type,
22225 DW_AT_containing_type.
22226 If there is no type substitute an error marker. */
22228 static struct type
*
22229 lookup_die_type (struct die_info
*die
, const struct attribute
*attr
,
22230 struct dwarf2_cu
*cu
)
22232 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
22233 struct objfile
*objfile
= per_objfile
->objfile
;
22234 struct type
*this_type
;
22236 gdb_assert (attr
->name
== DW_AT_type
22237 || attr
->name
== DW_AT_GNAT_descriptive_type
22238 || attr
->name
== DW_AT_containing_type
);
22240 /* First see if we have it cached. */
22242 if (attr
->form
== DW_FORM_GNU_ref_alt
)
22244 struct dwarf2_per_cu_data
*per_cu
;
22245 sect_offset sect_off
= attr
->get_ref_die_offset ();
22247 per_cu
= dwarf2_find_containing_comp_unit (sect_off
, 1, per_objfile
);
22248 this_type
= get_die_type_at_offset (sect_off
, per_cu
, per_objfile
);
22250 else if (attr
->form_is_ref ())
22252 sect_offset sect_off
= attr
->get_ref_die_offset ();
22254 this_type
= get_die_type_at_offset (sect_off
, cu
->per_cu
, per_objfile
);
22256 else if (attr
->form
== DW_FORM_ref_sig8
)
22258 ULONGEST signature
= attr
->as_signature ();
22260 return get_signatured_type (die
, signature
, cu
);
22264 complaint (_("Dwarf Error: Bad type attribute %s in DIE"
22265 " at %s [in module %s]"),
22266 dwarf_attr_name (attr
->name
), sect_offset_str (die
->sect_off
),
22267 objfile_name (objfile
));
22268 return build_error_marker_type (cu
, die
);
22271 /* If not cached we need to read it in. */
22273 if (this_type
== NULL
)
22275 struct die_info
*type_die
= NULL
;
22276 struct dwarf2_cu
*type_cu
= cu
;
22278 if (attr
->form_is_ref ())
22279 type_die
= follow_die_ref (die
, attr
, &type_cu
);
22280 if (type_die
== NULL
)
22281 return build_error_marker_type (cu
, die
);
22282 /* If we find the type now, it's probably because the type came
22283 from an inter-CU reference and the type's CU got expanded before
22285 this_type
= read_type_die (type_die
, type_cu
);
22288 /* If we still don't have a type use an error marker. */
22290 if (this_type
== NULL
)
22291 return build_error_marker_type (cu
, die
);
22296 /* Return the type in DIE, CU.
22297 Returns NULL for invalid types.
22299 This first does a lookup in die_type_hash,
22300 and only reads the die in if necessary.
22302 NOTE: This can be called when reading in partial or full symbols. */
22304 static struct type
*
22305 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
22307 struct type
*this_type
;
22309 this_type
= get_die_type (die
, cu
);
22313 return read_type_die_1 (die
, cu
);
22316 /* Read the type in DIE, CU.
22317 Returns NULL for invalid types. */
22319 static struct type
*
22320 read_type_die_1 (struct die_info
*die
, struct dwarf2_cu
*cu
)
22322 struct type
*this_type
= NULL
;
22326 case DW_TAG_class_type
:
22327 case DW_TAG_interface_type
:
22328 case DW_TAG_structure_type
:
22329 case DW_TAG_union_type
:
22330 this_type
= read_structure_type (die
, cu
);
22332 case DW_TAG_enumeration_type
:
22333 this_type
= read_enumeration_type (die
, cu
);
22335 case DW_TAG_subprogram
:
22336 case DW_TAG_subroutine_type
:
22337 case DW_TAG_inlined_subroutine
:
22338 this_type
= read_subroutine_type (die
, cu
);
22340 case DW_TAG_array_type
:
22341 this_type
= read_array_type (die
, cu
);
22343 case DW_TAG_set_type
:
22344 this_type
= read_set_type (die
, cu
);
22346 case DW_TAG_pointer_type
:
22347 this_type
= read_tag_pointer_type (die
, cu
);
22349 case DW_TAG_ptr_to_member_type
:
22350 this_type
= read_tag_ptr_to_member_type (die
, cu
);
22352 case DW_TAG_reference_type
:
22353 this_type
= read_tag_reference_type (die
, cu
, TYPE_CODE_REF
);
22355 case DW_TAG_rvalue_reference_type
:
22356 this_type
= read_tag_reference_type (die
, cu
, TYPE_CODE_RVALUE_REF
);
22358 case DW_TAG_const_type
:
22359 this_type
= read_tag_const_type (die
, cu
);
22361 case DW_TAG_volatile_type
:
22362 this_type
= read_tag_volatile_type (die
, cu
);
22364 case DW_TAG_restrict_type
:
22365 this_type
= read_tag_restrict_type (die
, cu
);
22367 case DW_TAG_string_type
:
22368 this_type
= read_tag_string_type (die
, cu
);
22370 case DW_TAG_typedef
:
22371 this_type
= read_typedef (die
, cu
);
22373 case DW_TAG_subrange_type
:
22374 this_type
= read_subrange_type (die
, cu
);
22376 case DW_TAG_base_type
:
22377 this_type
= read_base_type (die
, cu
);
22379 case DW_TAG_unspecified_type
:
22380 this_type
= read_unspecified_type (die
, cu
);
22382 case DW_TAG_namespace
:
22383 this_type
= read_namespace_type (die
, cu
);
22385 case DW_TAG_module
:
22386 this_type
= read_module_type (die
, cu
);
22388 case DW_TAG_atomic_type
:
22389 this_type
= read_tag_atomic_type (die
, cu
);
22392 complaint (_("unexpected tag in read_type_die: '%s'"),
22393 dwarf_tag_name (die
->tag
));
22400 /* See if we can figure out if the class lives in a namespace. We do
22401 this by looking for a member function; its demangled name will
22402 contain namespace info, if there is any.
22403 Return the computed name or NULL.
22404 Space for the result is allocated on the objfile's obstack.
22405 This is the full-die version of guess_partial_die_structure_name.
22406 In this case we know DIE has no useful parent. */
22408 static const char *
22409 guess_full_die_structure_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
22411 struct die_info
*spec_die
;
22412 struct dwarf2_cu
*spec_cu
;
22413 struct die_info
*child
;
22414 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22417 spec_die
= die_specification (die
, &spec_cu
);
22418 if (spec_die
!= NULL
)
22424 for (child
= die
->child
;
22426 child
= child
->sibling
)
22428 if (child
->tag
== DW_TAG_subprogram
)
22430 const char *linkage_name
= dw2_linkage_name (child
, cu
);
22432 if (linkage_name
!= NULL
)
22434 gdb::unique_xmalloc_ptr
<char> actual_name
22435 (cu
->language_defn
->class_name_from_physname (linkage_name
));
22436 const char *name
= NULL
;
22438 if (actual_name
!= NULL
)
22440 const char *die_name
= dwarf2_name (die
, cu
);
22442 if (die_name
!= NULL
22443 && strcmp (die_name
, actual_name
.get ()) != 0)
22445 /* Strip off the class name from the full name.
22446 We want the prefix. */
22447 int die_name_len
= strlen (die_name
);
22448 int actual_name_len
= strlen (actual_name
.get ());
22449 const char *ptr
= actual_name
.get ();
22451 /* Test for '::' as a sanity check. */
22452 if (actual_name_len
> die_name_len
+ 2
22453 && ptr
[actual_name_len
- die_name_len
- 1] == ':')
22454 name
= obstack_strndup (
22455 &objfile
->per_bfd
->storage_obstack
,
22456 ptr
, actual_name_len
- die_name_len
- 2);
22467 /* GCC might emit a nameless typedef that has a linkage name. Determine the
22468 prefix part in such case. See
22469 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
22471 static const char *
22472 anonymous_struct_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
22474 struct attribute
*attr
;
22477 if (die
->tag
!= DW_TAG_class_type
&& die
->tag
!= DW_TAG_interface_type
22478 && die
->tag
!= DW_TAG_structure_type
&& die
->tag
!= DW_TAG_union_type
)
22481 if (dwarf2_string_attr (die
, DW_AT_name
, cu
) != NULL
)
22484 attr
= dw2_linkage_name_attr (die
, cu
);
22485 const char *attr_name
= attr
->as_string ();
22486 if (attr
== NULL
|| attr_name
== NULL
)
22489 /* dwarf2_name had to be already called. */
22490 gdb_assert (attr
->canonical_string_p ());
22492 /* Strip the base name, keep any leading namespaces/classes. */
22493 base
= strrchr (attr_name
, ':');
22494 if (base
== NULL
|| base
== attr_name
|| base
[-1] != ':')
22497 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22498 return obstack_strndup (&objfile
->per_bfd
->storage_obstack
,
22500 &base
[-1] - attr_name
);
22503 /* Return the name of the namespace/class that DIE is defined within,
22504 or "" if we can't tell. The caller should not xfree the result.
22506 For example, if we're within the method foo() in the following
22516 then determine_prefix on foo's die will return "N::C". */
22518 static const char *
22519 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
22521 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
22522 struct die_info
*parent
, *spec_die
;
22523 struct dwarf2_cu
*spec_cu
;
22524 struct type
*parent_type
;
22525 const char *retval
;
22527 if (cu
->per_cu
->lang
!= language_cplus
22528 && cu
->per_cu
->lang
!= language_fortran
22529 && cu
->per_cu
->lang
!= language_d
22530 && cu
->per_cu
->lang
!= language_rust
)
22533 retval
= anonymous_struct_prefix (die
, cu
);
22537 /* We have to be careful in the presence of DW_AT_specification.
22538 For example, with GCC 3.4, given the code
22542 // Definition of N::foo.
22546 then we'll have a tree of DIEs like this:
22548 1: DW_TAG_compile_unit
22549 2: DW_TAG_namespace // N
22550 3: DW_TAG_subprogram // declaration of N::foo
22551 4: DW_TAG_subprogram // definition of N::foo
22552 DW_AT_specification // refers to die #3
22554 Thus, when processing die #4, we have to pretend that we're in
22555 the context of its DW_AT_specification, namely the contex of die
22558 spec_die
= die_specification (die
, &spec_cu
);
22559 if (spec_die
== NULL
)
22560 parent
= die
->parent
;
22563 parent
= spec_die
->parent
;
22567 if (parent
== NULL
)
22569 else if (parent
->building_fullname
)
22572 const char *parent_name
;
22574 /* It has been seen on RealView 2.2 built binaries,
22575 DW_TAG_template_type_param types actually _defined_ as
22576 children of the parent class:
22579 template class <class Enum> Class{};
22580 Class<enum E> class_e;
22582 1: DW_TAG_class_type (Class)
22583 2: DW_TAG_enumeration_type (E)
22584 3: DW_TAG_enumerator (enum1:0)
22585 3: DW_TAG_enumerator (enum2:1)
22587 2: DW_TAG_template_type_param
22588 DW_AT_type DW_FORM_ref_udata (E)
22590 Besides being broken debug info, it can put GDB into an
22591 infinite loop. Consider:
22593 When we're building the full name for Class<E>, we'll start
22594 at Class, and go look over its template type parameters,
22595 finding E. We'll then try to build the full name of E, and
22596 reach here. We're now trying to build the full name of E,
22597 and look over the parent DIE for containing scope. In the
22598 broken case, if we followed the parent DIE of E, we'd again
22599 find Class, and once again go look at its template type
22600 arguments, etc., etc. Simply don't consider such parent die
22601 as source-level parent of this die (it can't be, the language
22602 doesn't allow it), and break the loop here. */
22603 name
= dwarf2_name (die
, cu
);
22604 parent_name
= dwarf2_name (parent
, cu
);
22605 complaint (_("template param type '%s' defined within parent '%s'"),
22606 name
? name
: "<unknown>",
22607 parent_name
? parent_name
: "<unknown>");
22611 switch (parent
->tag
)
22613 case DW_TAG_namespace
:
22614 parent_type
= read_type_die (parent
, cu
);
22615 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
22616 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
22617 Work around this problem here. */
22618 if (cu
->per_cu
->lang
== language_cplus
22619 && strcmp (parent_type
->name (), "::") == 0)
22621 /* We give a name to even anonymous namespaces. */
22622 return parent_type
->name ();
22623 case DW_TAG_class_type
:
22624 case DW_TAG_interface_type
:
22625 case DW_TAG_structure_type
:
22626 case DW_TAG_union_type
:
22627 case DW_TAG_module
:
22628 parent_type
= read_type_die (parent
, cu
);
22629 if (parent_type
->name () != NULL
)
22630 return parent_type
->name ();
22632 /* An anonymous structure is only allowed non-static data
22633 members; no typedefs, no member functions, et cetera.
22634 So it does not need a prefix. */
22636 case DW_TAG_compile_unit
:
22637 case DW_TAG_partial_unit
:
22638 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
22639 if (cu
->per_cu
->lang
== language_cplus
22640 && !per_objfile
->per_bfd
->types
.empty ()
22641 && die
->child
!= NULL
22642 && (die
->tag
== DW_TAG_class_type
22643 || die
->tag
== DW_TAG_structure_type
22644 || die
->tag
== DW_TAG_union_type
))
22646 const char *name
= guess_full_die_structure_name (die
, cu
);
22651 case DW_TAG_subprogram
:
22652 /* Nested subroutines in Fortran get a prefix with the name
22653 of the parent's subroutine. */
22654 if (cu
->per_cu
->lang
== language_fortran
)
22656 if ((die
->tag
== DW_TAG_subprogram
)
22657 && (dwarf2_name (parent
, cu
) != NULL
))
22658 return dwarf2_name (parent
, cu
);
22661 case DW_TAG_enumeration_type
:
22662 parent_type
= read_type_die (parent
, cu
);
22663 if (parent_type
->is_declared_class ())
22665 if (parent_type
->name () != NULL
)
22666 return parent_type
->name ();
22669 /* Fall through. */
22671 return determine_prefix (parent
, cu
);
22675 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
22676 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
22677 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
22678 an obconcat, otherwise allocate storage for the result. The CU argument is
22679 used to determine the language and hence, the appropriate separator. */
22681 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
22684 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
22685 int physname
, struct dwarf2_cu
*cu
)
22687 const char *lead
= "";
22690 if (suffix
== NULL
|| suffix
[0] == '\0'
22691 || prefix
== NULL
|| prefix
[0] == '\0')
22693 else if (cu
->per_cu
->lang
== language_d
)
22695 /* For D, the 'main' function could be defined in any module, but it
22696 should never be prefixed. */
22697 if (strcmp (suffix
, "D main") == 0)
22705 else if (cu
->per_cu
->lang
== language_fortran
&& physname
)
22707 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
22708 DW_AT_MIPS_linkage_name is preferred and used instead. */
22716 if (prefix
== NULL
)
22718 if (suffix
== NULL
)
22725 xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1));
22727 strcpy (retval
, lead
);
22728 strcat (retval
, prefix
);
22729 strcat (retval
, sep
);
22730 strcat (retval
, suffix
);
22735 /* We have an obstack. */
22736 return obconcat (obs
, lead
, prefix
, sep
, suffix
, (char *) NULL
);
22740 /* Get name of a die, return NULL if not found. */
22742 static const char *
22743 dwarf2_canonicalize_name (const char *name
, struct dwarf2_cu
*cu
,
22744 struct objfile
*objfile
)
22746 if (name
&& cu
->per_cu
->lang
== language_cplus
)
22748 gdb::unique_xmalloc_ptr
<char> canon_name
22749 = cp_canonicalize_string (name
);
22751 if (canon_name
!= nullptr)
22752 name
= objfile
->intern (canon_name
.get ());
22758 /* Get name of a die, return NULL if not found.
22759 Anonymous namespaces are converted to their magic string. */
22761 static const char *
22762 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
22764 struct attribute
*attr
;
22765 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22767 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
22768 const char *attr_name
= attr
== nullptr ? nullptr : attr
->as_string ();
22769 if (attr_name
== nullptr
22770 && die
->tag
!= DW_TAG_namespace
22771 && die
->tag
!= DW_TAG_class_type
22772 && die
->tag
!= DW_TAG_interface_type
22773 && die
->tag
!= DW_TAG_structure_type
22774 && die
->tag
!= DW_TAG_union_type
)
22779 case DW_TAG_compile_unit
:
22780 case DW_TAG_partial_unit
:
22781 /* Compilation units have a DW_AT_name that is a filename, not
22782 a source language identifier. */
22783 case DW_TAG_enumeration_type
:
22784 case DW_TAG_enumerator
:
22785 /* These tags always have simple identifiers already; no need
22786 to canonicalize them. */
22789 case DW_TAG_namespace
:
22790 if (attr_name
!= nullptr)
22792 return CP_ANONYMOUS_NAMESPACE_STR
;
22794 case DW_TAG_class_type
:
22795 case DW_TAG_interface_type
:
22796 case DW_TAG_structure_type
:
22797 case DW_TAG_union_type
:
22798 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
22799 structures or unions. These were of the form "._%d" in GCC 4.1,
22800 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
22801 and GCC 4.4. We work around this problem by ignoring these. */
22802 if (attr_name
!= nullptr
22803 && (startswith (attr_name
, "._")
22804 || startswith (attr_name
, "<anonymous")))
22807 /* GCC might emit a nameless typedef that has a linkage name. See
22808 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
22809 if (!attr
|| attr_name
== NULL
)
22811 attr
= dw2_linkage_name_attr (die
, cu
);
22812 attr_name
= attr
== nullptr ? nullptr : attr
->as_string ();
22813 if (attr
== NULL
|| attr_name
== NULL
)
22816 /* Avoid demangling attr_name the second time on a second
22817 call for the same DIE. */
22818 if (!attr
->canonical_string_p ())
22820 gdb::unique_xmalloc_ptr
<char> demangled
22821 (gdb_demangle (attr_name
, DMGL_TYPES
));
22822 if (demangled
== nullptr)
22825 attr
->set_string_canonical (objfile
->intern (demangled
.get ()));
22826 attr_name
= attr
->as_string ();
22829 /* Strip any leading namespaces/classes, keep only the
22830 base name. DW_AT_name for named DIEs does not
22831 contain the prefixes. */
22832 const char *base
= strrchr (attr_name
, ':');
22833 if (base
&& base
> attr_name
&& base
[-1] == ':')
22844 if (!attr
->canonical_string_p ())
22845 attr
->set_string_canonical (dwarf2_canonicalize_name (attr_name
, cu
,
22847 return attr
->as_string ();
22850 /* Return the die that this die in an extension of, or NULL if there
22851 is none. *EXT_CU is the CU containing DIE on input, and the CU
22852 containing the return value on output. */
22854 static struct die_info
*
22855 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
**ext_cu
)
22857 struct attribute
*attr
;
22859 attr
= dwarf2_attr (die
, DW_AT_extension
, *ext_cu
);
22863 return follow_die_ref (die
, attr
, ext_cu
);
22867 dump_die_shallow (struct ui_file
*f
, int indent
, struct die_info
*die
)
22871 print_spaces (indent
, f
);
22872 fprintf_unfiltered (f
, "Die: %s (abbrev %d, offset %s)\n",
22873 dwarf_tag_name (die
->tag
), die
->abbrev
,
22874 sect_offset_str (die
->sect_off
));
22876 if (die
->parent
!= NULL
)
22878 print_spaces (indent
, f
);
22879 fprintf_unfiltered (f
, " parent at offset: %s\n",
22880 sect_offset_str (die
->parent
->sect_off
));
22883 print_spaces (indent
, f
);
22884 fprintf_unfiltered (f
, " has children: %s\n",
22885 dwarf_bool_name (die
->child
!= NULL
));
22887 print_spaces (indent
, f
);
22888 fprintf_unfiltered (f
, " attributes:\n");
22890 for (i
= 0; i
< die
->num_attrs
; ++i
)
22892 print_spaces (indent
, f
);
22893 fprintf_unfiltered (f
, " %s (%s) ",
22894 dwarf_attr_name (die
->attrs
[i
].name
),
22895 dwarf_form_name (die
->attrs
[i
].form
));
22897 switch (die
->attrs
[i
].form
)
22900 case DW_FORM_addrx
:
22901 case DW_FORM_GNU_addr_index
:
22902 fprintf_unfiltered (f
, "address: ");
22903 fputs_filtered (hex_string (die
->attrs
[i
].as_address ()), f
);
22905 case DW_FORM_block2
:
22906 case DW_FORM_block4
:
22907 case DW_FORM_block
:
22908 case DW_FORM_block1
:
22909 fprintf_unfiltered (f
, "block: size %s",
22910 pulongest (die
->attrs
[i
].as_block ()->size
));
22912 case DW_FORM_exprloc
:
22913 fprintf_unfiltered (f
, "expression: size %s",
22914 pulongest (die
->attrs
[i
].as_block ()->size
));
22916 case DW_FORM_data16
:
22917 fprintf_unfiltered (f
, "constant of 16 bytes");
22919 case DW_FORM_ref_addr
:
22920 fprintf_unfiltered (f
, "ref address: ");
22921 fputs_filtered (hex_string (die
->attrs
[i
].as_unsigned ()), f
);
22923 case DW_FORM_GNU_ref_alt
:
22924 fprintf_unfiltered (f
, "alt ref address: ");
22925 fputs_filtered (hex_string (die
->attrs
[i
].as_unsigned ()), f
);
22931 case DW_FORM_ref_udata
:
22932 fprintf_unfiltered (f
, "constant ref: 0x%lx (adjusted)",
22933 (long) (die
->attrs
[i
].as_unsigned ()));
22935 case DW_FORM_data1
:
22936 case DW_FORM_data2
:
22937 case DW_FORM_data4
:
22938 case DW_FORM_data8
:
22939 case DW_FORM_udata
:
22940 fprintf_unfiltered (f
, "constant: %s",
22941 pulongest (die
->attrs
[i
].as_unsigned ()));
22943 case DW_FORM_sec_offset
:
22944 fprintf_unfiltered (f
, "section offset: %s",
22945 pulongest (die
->attrs
[i
].as_unsigned ()));
22947 case DW_FORM_ref_sig8
:
22948 fprintf_unfiltered (f
, "signature: %s",
22949 hex_string (die
->attrs
[i
].as_signature ()));
22951 case DW_FORM_string
:
22953 case DW_FORM_line_strp
:
22955 case DW_FORM_GNU_str_index
:
22956 case DW_FORM_GNU_strp_alt
:
22957 fprintf_unfiltered (f
, "string: \"%s\" (%s canonicalized)",
22958 die
->attrs
[i
].as_string ()
22959 ? die
->attrs
[i
].as_string () : "",
22960 die
->attrs
[i
].canonical_string_p () ? "is" : "not");
22963 if (die
->attrs
[i
].as_boolean ())
22964 fprintf_unfiltered (f
, "flag: TRUE");
22966 fprintf_unfiltered (f
, "flag: FALSE");
22968 case DW_FORM_flag_present
:
22969 fprintf_unfiltered (f
, "flag: TRUE");
22971 case DW_FORM_indirect
:
22972 /* The reader will have reduced the indirect form to
22973 the "base form" so this form should not occur. */
22974 fprintf_unfiltered (f
,
22975 "unexpected attribute form: DW_FORM_indirect");
22977 case DW_FORM_sdata
:
22978 case DW_FORM_implicit_const
:
22979 fprintf_unfiltered (f
, "constant: %s",
22980 plongest (die
->attrs
[i
].as_signed ()));
22983 fprintf_unfiltered (f
, "unsupported attribute form: %d.",
22984 die
->attrs
[i
].form
);
22987 fprintf_unfiltered (f
, "\n");
22992 dump_die_for_error (struct die_info
*die
)
22994 dump_die_shallow (gdb_stderr
, 0, die
);
22998 dump_die_1 (struct ui_file
*f
, int level
, int max_level
, struct die_info
*die
)
23000 int indent
= level
* 4;
23002 gdb_assert (die
!= NULL
);
23004 if (level
>= max_level
)
23007 dump_die_shallow (f
, indent
, die
);
23009 if (die
->child
!= NULL
)
23011 print_spaces (indent
, f
);
23012 fprintf_unfiltered (f
, " Children:");
23013 if (level
+ 1 < max_level
)
23015 fprintf_unfiltered (f
, "\n");
23016 dump_die_1 (f
, level
+ 1, max_level
, die
->child
);
23020 fprintf_unfiltered (f
,
23021 " [not printed, max nesting level reached]\n");
23025 if (die
->sibling
!= NULL
&& level
> 0)
23027 dump_die_1 (f
, level
, max_level
, die
->sibling
);
23031 /* This is called from the pdie macro in gdbinit.in.
23032 It's not static so gcc will keep a copy callable from gdb. */
23035 dump_die (struct die_info
*die
, int max_level
)
23037 dump_die_1 (gdb_stdlog
, 0, max_level
, die
);
23041 store_in_ref_table (struct die_info
*die
, struct dwarf2_cu
*cu
)
23045 slot
= htab_find_slot_with_hash (cu
->die_hash
, die
,
23046 to_underlying (die
->sect_off
),
23052 /* Follow reference or signature attribute ATTR of SRC_DIE.
23053 On entry *REF_CU is the CU of SRC_DIE.
23054 On exit *REF_CU is the CU of the result. */
23056 static struct die_info
*
23057 follow_die_ref_or_sig (struct die_info
*src_die
, const struct attribute
*attr
,
23058 struct dwarf2_cu
**ref_cu
)
23060 struct die_info
*die
;
23062 if (attr
->form_is_ref ())
23063 die
= follow_die_ref (src_die
, attr
, ref_cu
);
23064 else if (attr
->form
== DW_FORM_ref_sig8
)
23065 die
= follow_die_sig (src_die
, attr
, ref_cu
);
23068 dump_die_for_error (src_die
);
23069 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
23070 objfile_name ((*ref_cu
)->per_objfile
->objfile
));
23076 /* Follow reference OFFSET.
23077 On entry *REF_CU is the CU of the source die referencing OFFSET.
23078 On exit *REF_CU is the CU of the result.
23079 Returns NULL if OFFSET is invalid. */
23081 static struct die_info
*
23082 follow_die_offset (sect_offset sect_off
, int offset_in_dwz
,
23083 struct dwarf2_cu
**ref_cu
)
23085 struct die_info temp_die
;
23086 struct dwarf2_cu
*target_cu
, *cu
= *ref_cu
;
23087 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
23089 gdb_assert (cu
->per_cu
!= NULL
);
23093 dwarf_read_debug_printf_v ("source CU offset: %s, target offset: %s, "
23094 "source CU contains target offset: %d",
23095 sect_offset_str (cu
->per_cu
->sect_off
),
23096 sect_offset_str (sect_off
),
23097 cu
->header
.offset_in_cu_p (sect_off
));
23099 if (cu
->per_cu
->is_debug_types
)
23101 /* .debug_types CUs cannot reference anything outside their CU.
23102 If they need to, they have to reference a signatured type via
23103 DW_FORM_ref_sig8. */
23104 if (!cu
->header
.offset_in_cu_p (sect_off
))
23107 else if (offset_in_dwz
!= cu
->per_cu
->is_dwz
23108 || !cu
->header
.offset_in_cu_p (sect_off
))
23110 struct dwarf2_per_cu_data
*per_cu
;
23112 per_cu
= dwarf2_find_containing_comp_unit (sect_off
, offset_in_dwz
,
23115 dwarf_read_debug_printf_v ("target CU offset: %s, "
23116 "target CU DIEs loaded: %d",
23117 sect_offset_str (per_cu
->sect_off
),
23118 per_objfile
->get_cu (per_cu
) != nullptr);
23120 /* If necessary, add it to the queue and load its DIEs.
23122 Even if maybe_queue_comp_unit doesn't require us to load the CU's DIEs,
23123 it doesn't mean they are currently loaded. Since we require them
23124 to be loaded, we must check for ourselves. */
23125 if (maybe_queue_comp_unit (cu
, per_cu
, per_objfile
, cu
->per_cu
->lang
)
23126 || per_objfile
->get_cu (per_cu
) == nullptr)
23127 load_full_comp_unit (per_cu
, per_objfile
, per_objfile
->get_cu (per_cu
),
23128 false, cu
->per_cu
->lang
);
23130 target_cu
= per_objfile
->get_cu (per_cu
);
23131 gdb_assert (target_cu
!= nullptr);
23133 else if (cu
->dies
== NULL
)
23135 /* We're loading full DIEs during partial symbol reading. */
23136 gdb_assert (per_objfile
->per_bfd
->reading_partial_symbols
);
23137 load_full_comp_unit (cu
->per_cu
, per_objfile
, cu
, false,
23141 *ref_cu
= target_cu
;
23142 temp_die
.sect_off
= sect_off
;
23144 return (struct die_info
*) htab_find_with_hash (target_cu
->die_hash
,
23146 to_underlying (sect_off
));
23149 /* Follow reference attribute ATTR of SRC_DIE.
23150 On entry *REF_CU is the CU of SRC_DIE.
23151 On exit *REF_CU is the CU of the result. */
23153 static struct die_info
*
23154 follow_die_ref (struct die_info
*src_die
, const struct attribute
*attr
,
23155 struct dwarf2_cu
**ref_cu
)
23157 sect_offset sect_off
= attr
->get_ref_die_offset ();
23158 struct dwarf2_cu
*cu
= *ref_cu
;
23159 struct die_info
*die
;
23161 die
= follow_die_offset (sect_off
,
23162 (attr
->form
== DW_FORM_GNU_ref_alt
23163 || cu
->per_cu
->is_dwz
),
23166 error (_("Dwarf Error: Cannot find DIE at %s referenced from DIE "
23167 "at %s [in module %s]"),
23168 sect_offset_str (sect_off
), sect_offset_str (src_die
->sect_off
),
23169 objfile_name (cu
->per_objfile
->objfile
));
23176 struct dwarf2_locexpr_baton
23177 dwarf2_fetch_die_loc_sect_off (sect_offset sect_off
,
23178 dwarf2_per_cu_data
*per_cu
,
23179 dwarf2_per_objfile
*per_objfile
,
23180 gdb::function_view
<CORE_ADDR ()> get_frame_pc
,
23181 bool resolve_abstract_p
)
23183 struct die_info
*die
;
23184 struct attribute
*attr
;
23185 struct dwarf2_locexpr_baton retval
;
23186 struct objfile
*objfile
= per_objfile
->objfile
;
23188 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
23190 cu
= load_cu (per_cu
, per_objfile
, false);
23194 /* We shouldn't get here for a dummy CU, but don't crash on the user.
23195 Instead just throw an error, not much else we can do. */
23196 error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23197 sect_offset_str (sect_off
), objfile_name (objfile
));
23200 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
23202 error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23203 sect_offset_str (sect_off
), objfile_name (objfile
));
23205 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
23206 if (!attr
&& resolve_abstract_p
23207 && (per_objfile
->per_bfd
->abstract_to_concrete
.find (die
->sect_off
)
23208 != per_objfile
->per_bfd
->abstract_to_concrete
.end ()))
23210 CORE_ADDR pc
= get_frame_pc ();
23211 CORE_ADDR baseaddr
= objfile
->text_section_offset ();
23212 struct gdbarch
*gdbarch
= objfile
->arch ();
23214 for (const auto &cand_off
23215 : per_objfile
->per_bfd
->abstract_to_concrete
[die
->sect_off
])
23217 struct dwarf2_cu
*cand_cu
= cu
;
23218 struct die_info
*cand
23219 = follow_die_offset (cand_off
, per_cu
->is_dwz
, &cand_cu
);
23222 || cand
->parent
->tag
!= DW_TAG_subprogram
)
23225 CORE_ADDR pc_low
, pc_high
;
23226 get_scope_pc_bounds (cand
->parent
, &pc_low
, &pc_high
, cu
);
23227 if (pc_low
== ((CORE_ADDR
) -1))
23229 pc_low
= gdbarch_adjust_dwarf2_addr (gdbarch
, pc_low
+ baseaddr
);
23230 pc_high
= gdbarch_adjust_dwarf2_addr (gdbarch
, pc_high
+ baseaddr
);
23231 if (!(pc_low
<= pc
&& pc
< pc_high
))
23235 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
23242 /* DWARF: "If there is no such attribute, then there is no effect.".
23243 DATA is ignored if SIZE is 0. */
23245 retval
.data
= NULL
;
23248 else if (attr
->form_is_section_offset ())
23250 struct dwarf2_loclist_baton loclist_baton
;
23251 CORE_ADDR pc
= get_frame_pc ();
23254 fill_in_loclist_baton (cu
, &loclist_baton
, attr
);
23256 retval
.data
= dwarf2_find_location_expression (&loclist_baton
,
23258 retval
.size
= size
;
23262 if (!attr
->form_is_block ())
23263 error (_("Dwarf Error: DIE at %s referenced in module %s "
23264 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
23265 sect_offset_str (sect_off
), objfile_name (objfile
));
23267 struct dwarf_block
*block
= attr
->as_block ();
23268 retval
.data
= block
->data
;
23269 retval
.size
= block
->size
;
23271 retval
.per_objfile
= per_objfile
;
23272 retval
.per_cu
= cu
->per_cu
;
23274 per_objfile
->age_comp_units ();
23281 struct dwarf2_locexpr_baton
23282 dwarf2_fetch_die_loc_cu_off (cu_offset offset_in_cu
,
23283 dwarf2_per_cu_data
*per_cu
,
23284 dwarf2_per_objfile
*per_objfile
,
23285 gdb::function_view
<CORE_ADDR ()> get_frame_pc
)
23287 sect_offset sect_off
= per_cu
->sect_off
+ to_underlying (offset_in_cu
);
23289 return dwarf2_fetch_die_loc_sect_off (sect_off
, per_cu
, per_objfile
,
23293 /* Write a constant of a given type as target-ordered bytes into
23296 static const gdb_byte
*
23297 write_constant_as_bytes (struct obstack
*obstack
,
23298 enum bfd_endian byte_order
,
23305 *len
= TYPE_LENGTH (type
);
23306 result
= (gdb_byte
*) obstack_alloc (obstack
, *len
);
23307 store_unsigned_integer (result
, *len
, byte_order
, value
);
23315 dwarf2_fetch_constant_bytes (sect_offset sect_off
,
23316 dwarf2_per_cu_data
*per_cu
,
23317 dwarf2_per_objfile
*per_objfile
,
23321 struct die_info
*die
;
23322 struct attribute
*attr
;
23323 const gdb_byte
*result
= NULL
;
23326 enum bfd_endian byte_order
;
23327 struct objfile
*objfile
= per_objfile
->objfile
;
23329 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
23331 cu
= load_cu (per_cu
, per_objfile
, false);
23335 /* We shouldn't get here for a dummy CU, but don't crash on the user.
23336 Instead just throw an error, not much else we can do. */
23337 error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23338 sect_offset_str (sect_off
), objfile_name (objfile
));
23341 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
23343 error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23344 sect_offset_str (sect_off
), objfile_name (objfile
));
23346 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
23350 byte_order
= (bfd_big_endian (objfile
->obfd
)
23351 ? BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
23353 switch (attr
->form
)
23356 case DW_FORM_addrx
:
23357 case DW_FORM_GNU_addr_index
:
23361 *len
= cu
->header
.addr_size
;
23362 tem
= (gdb_byte
*) obstack_alloc (obstack
, *len
);
23363 store_unsigned_integer (tem
, *len
, byte_order
, attr
->as_address ());
23367 case DW_FORM_string
:
23370 case DW_FORM_GNU_str_index
:
23371 case DW_FORM_GNU_strp_alt
:
23372 /* The string is already allocated on the objfile obstack, point
23375 const char *attr_name
= attr
->as_string ();
23376 result
= (const gdb_byte
*) attr_name
;
23377 *len
= strlen (attr_name
);
23380 case DW_FORM_block1
:
23381 case DW_FORM_block2
:
23382 case DW_FORM_block4
:
23383 case DW_FORM_block
:
23384 case DW_FORM_exprloc
:
23385 case DW_FORM_data16
:
23387 struct dwarf_block
*block
= attr
->as_block ();
23388 result
= block
->data
;
23389 *len
= block
->size
;
23393 /* The DW_AT_const_value attributes are supposed to carry the
23394 symbol's value "represented as it would be on the target
23395 architecture." By the time we get here, it's already been
23396 converted to host endianness, so we just need to sign- or
23397 zero-extend it as appropriate. */
23398 case DW_FORM_data1
:
23399 type
= die_type (die
, cu
);
23400 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 8);
23401 if (result
== NULL
)
23402 result
= write_constant_as_bytes (obstack
, byte_order
,
23405 case DW_FORM_data2
:
23406 type
= die_type (die
, cu
);
23407 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 16);
23408 if (result
== NULL
)
23409 result
= write_constant_as_bytes (obstack
, byte_order
,
23412 case DW_FORM_data4
:
23413 type
= die_type (die
, cu
);
23414 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 32);
23415 if (result
== NULL
)
23416 result
= write_constant_as_bytes (obstack
, byte_order
,
23419 case DW_FORM_data8
:
23420 type
= die_type (die
, cu
);
23421 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 64);
23422 if (result
== NULL
)
23423 result
= write_constant_as_bytes (obstack
, byte_order
,
23427 case DW_FORM_sdata
:
23428 case DW_FORM_implicit_const
:
23429 type
= die_type (die
, cu
);
23430 result
= write_constant_as_bytes (obstack
, byte_order
,
23431 type
, attr
->as_signed (), len
);
23434 case DW_FORM_udata
:
23435 type
= die_type (die
, cu
);
23436 result
= write_constant_as_bytes (obstack
, byte_order
,
23437 type
, attr
->as_unsigned (), len
);
23441 complaint (_("unsupported const value attribute form: '%s'"),
23442 dwarf_form_name (attr
->form
));
23452 dwarf2_fetch_die_type_sect_off (sect_offset sect_off
,
23453 dwarf2_per_cu_data
*per_cu
,
23454 dwarf2_per_objfile
*per_objfile
,
23455 const char **var_name
)
23457 struct die_info
*die
;
23459 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
23461 cu
= load_cu (per_cu
, per_objfile
, false);
23466 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
23470 if (var_name
!= nullptr)
23471 *var_name
= var_decl_name (die
, cu
);
23472 return die_type (die
, cu
);
23478 dwarf2_get_die_type (cu_offset die_offset
,
23479 dwarf2_per_cu_data
*per_cu
,
23480 dwarf2_per_objfile
*per_objfile
)
23482 sect_offset die_offset_sect
= per_cu
->sect_off
+ to_underlying (die_offset
);
23483 return get_die_type_at_offset (die_offset_sect
, per_cu
, per_objfile
);
23486 /* Follow type unit SIG_TYPE referenced by SRC_DIE.
23487 On entry *REF_CU is the CU of SRC_DIE.
23488 On exit *REF_CU is the CU of the result.
23489 Returns NULL if the referenced DIE isn't found. */
23491 static struct die_info
*
23492 follow_die_sig_1 (struct die_info
*src_die
, struct signatured_type
*sig_type
,
23493 struct dwarf2_cu
**ref_cu
)
23495 struct die_info temp_die
;
23496 struct dwarf2_cu
*sig_cu
;
23497 struct die_info
*die
;
23498 dwarf2_per_objfile
*per_objfile
= (*ref_cu
)->per_objfile
;
23501 /* While it might be nice to assert sig_type->type == NULL here,
23502 we can get here for DW_AT_imported_declaration where we need
23503 the DIE not the type. */
23505 /* If necessary, add it to the queue and load its DIEs.
23507 Even if maybe_queue_comp_unit doesn't require us to load the CU's DIEs,
23508 it doesn't mean they are currently loaded. Since we require them
23509 to be loaded, we must check for ourselves. */
23510 if (maybe_queue_comp_unit (*ref_cu
, sig_type
, per_objfile
,
23512 || per_objfile
->get_cu (sig_type
) == nullptr)
23513 read_signatured_type (sig_type
, per_objfile
);
23515 sig_cu
= per_objfile
->get_cu (sig_type
);
23516 gdb_assert (sig_cu
!= NULL
);
23517 gdb_assert (to_underlying (sig_type
->type_offset_in_section
) != 0);
23518 temp_die
.sect_off
= sig_type
->type_offset_in_section
;
23519 die
= (struct die_info
*) htab_find_with_hash (sig_cu
->die_hash
, &temp_die
,
23520 to_underlying (temp_die
.sect_off
));
23523 /* For .gdb_index version 7 keep track of included TUs.
23524 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
23525 if (per_objfile
->per_bfd
->index_table
!= NULL
23526 && per_objfile
->per_bfd
->index_table
->version
<= 7)
23528 (*ref_cu
)->per_cu
->imported_symtabs_push (sig_cu
->per_cu
);
23538 /* Follow signatured type referenced by ATTR in SRC_DIE.
23539 On entry *REF_CU is the CU of SRC_DIE.
23540 On exit *REF_CU is the CU of the result.
23541 The result is the DIE of the type.
23542 If the referenced type cannot be found an error is thrown. */
23544 static struct die_info
*
23545 follow_die_sig (struct die_info
*src_die
, const struct attribute
*attr
,
23546 struct dwarf2_cu
**ref_cu
)
23548 ULONGEST signature
= attr
->as_signature ();
23549 struct signatured_type
*sig_type
;
23550 struct die_info
*die
;
23552 gdb_assert (attr
->form
== DW_FORM_ref_sig8
);
23554 sig_type
= lookup_signatured_type (*ref_cu
, signature
);
23555 /* sig_type will be NULL if the signatured type is missing from
23557 if (sig_type
== NULL
)
23559 error (_("Dwarf Error: Cannot find signatured DIE %s referenced"
23560 " from DIE at %s [in module %s]"),
23561 hex_string (signature
), sect_offset_str (src_die
->sect_off
),
23562 objfile_name ((*ref_cu
)->per_objfile
->objfile
));
23565 die
= follow_die_sig_1 (src_die
, sig_type
, ref_cu
);
23568 dump_die_for_error (src_die
);
23569 error (_("Dwarf Error: Problem reading signatured DIE %s referenced"
23570 " from DIE at %s [in module %s]"),
23571 hex_string (signature
), sect_offset_str (src_die
->sect_off
),
23572 objfile_name ((*ref_cu
)->per_objfile
->objfile
));
23578 /* Get the type specified by SIGNATURE referenced in DIE/CU,
23579 reading in and processing the type unit if necessary. */
23581 static struct type
*
23582 get_signatured_type (struct die_info
*die
, ULONGEST signature
,
23583 struct dwarf2_cu
*cu
)
23585 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
23586 struct signatured_type
*sig_type
;
23587 struct dwarf2_cu
*type_cu
;
23588 struct die_info
*type_die
;
23591 sig_type
= lookup_signatured_type (cu
, signature
);
23592 /* sig_type will be NULL if the signatured type is missing from
23594 if (sig_type
== NULL
)
23596 complaint (_("Dwarf Error: Cannot find signatured DIE %s referenced"
23597 " from DIE at %s [in module %s]"),
23598 hex_string (signature
), sect_offset_str (die
->sect_off
),
23599 objfile_name (per_objfile
->objfile
));
23600 return build_error_marker_type (cu
, die
);
23603 /* If we already know the type we're done. */
23604 type
= per_objfile
->get_type_for_signatured_type (sig_type
);
23605 if (type
!= nullptr)
23609 type_die
= follow_die_sig_1 (die
, sig_type
, &type_cu
);
23610 if (type_die
!= NULL
)
23612 /* N.B. We need to call get_die_type to ensure only one type for this DIE
23613 is created. This is important, for example, because for c++ classes
23614 we need TYPE_NAME set which is only done by new_symbol. Blech. */
23615 type
= read_type_die (type_die
, type_cu
);
23618 complaint (_("Dwarf Error: Cannot build signatured type %s"
23619 " referenced from DIE at %s [in module %s]"),
23620 hex_string (signature
), sect_offset_str (die
->sect_off
),
23621 objfile_name (per_objfile
->objfile
));
23622 type
= build_error_marker_type (cu
, die
);
23627 complaint (_("Dwarf Error: Problem reading signatured DIE %s referenced"
23628 " from DIE at %s [in module %s]"),
23629 hex_string (signature
), sect_offset_str (die
->sect_off
),
23630 objfile_name (per_objfile
->objfile
));
23631 type
= build_error_marker_type (cu
, die
);
23634 per_objfile
->set_type_for_signatured_type (sig_type
, type
);
23639 /* Get the type specified by the DW_AT_signature ATTR in DIE/CU,
23640 reading in and processing the type unit if necessary. */
23642 static struct type
*
23643 get_DW_AT_signature_type (struct die_info
*die
, const struct attribute
*attr
,
23644 struct dwarf2_cu
*cu
) /* ARI: editCase function */
23646 /* Yes, DW_AT_signature can use a non-ref_sig8 reference. */
23647 if (attr
->form_is_ref ())
23649 struct dwarf2_cu
*type_cu
= cu
;
23650 struct die_info
*type_die
= follow_die_ref (die
, attr
, &type_cu
);
23652 return read_type_die (type_die
, type_cu
);
23654 else if (attr
->form
== DW_FORM_ref_sig8
)
23656 return get_signatured_type (die
, attr
->as_signature (), cu
);
23660 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
23662 complaint (_("Dwarf Error: DW_AT_signature has bad form %s in DIE"
23663 " at %s [in module %s]"),
23664 dwarf_form_name (attr
->form
), sect_offset_str (die
->sect_off
),
23665 objfile_name (per_objfile
->objfile
));
23666 return build_error_marker_type (cu
, die
);
23670 /* Load the DIEs associated with type unit PER_CU into memory. */
23673 load_full_type_unit (dwarf2_per_cu_data
*per_cu
,
23674 dwarf2_per_objfile
*per_objfile
)
23676 struct signatured_type
*sig_type
;
23678 /* Caller is responsible for ensuring type_unit_groups don't get here. */
23679 gdb_assert (! per_cu
->type_unit_group_p ());
23681 /* We have the per_cu, but we need the signatured_type.
23682 Fortunately this is an easy translation. */
23683 gdb_assert (per_cu
->is_debug_types
);
23684 sig_type
= (struct signatured_type
*) per_cu
;
23686 gdb_assert (per_objfile
->get_cu (per_cu
) == nullptr);
23688 read_signatured_type (sig_type
, per_objfile
);
23690 gdb_assert (per_objfile
->get_cu (per_cu
) != nullptr);
23693 /* Read in a signatured type and build its CU and DIEs.
23694 If the type is a stub for the real type in a DWO file,
23695 read in the real type from the DWO file as well. */
23698 read_signatured_type (signatured_type
*sig_type
,
23699 dwarf2_per_objfile
*per_objfile
)
23701 gdb_assert (sig_type
->is_debug_types
);
23702 gdb_assert (per_objfile
->get_cu (sig_type
) == nullptr);
23704 cutu_reader
reader (sig_type
, per_objfile
, nullptr, nullptr, false);
23706 if (!reader
.dummy_p
)
23708 struct dwarf2_cu
*cu
= reader
.cu
;
23709 const gdb_byte
*info_ptr
= reader
.info_ptr
;
23711 gdb_assert (cu
->die_hash
== NULL
);
23713 htab_create_alloc_ex (cu
->header
.length
/ 12,
23717 &cu
->comp_unit_obstack
,
23718 hashtab_obstack_allocate
,
23719 dummy_obstack_deallocate
);
23721 if (reader
.comp_unit_die
->has_children
)
23722 reader
.comp_unit_die
->child
23723 = read_die_and_siblings (&reader
, info_ptr
, &info_ptr
,
23724 reader
.comp_unit_die
);
23725 cu
->dies
= reader
.comp_unit_die
;
23726 /* comp_unit_die is not stored in die_hash, no need. */
23728 /* We try not to read any attributes in this function, because
23729 not all CUs needed for references have been loaded yet, and
23730 symbol table processing isn't initialized. But we have to
23731 set the CU language, or we won't be able to build types
23732 correctly. Similarly, if we do not read the producer, we can
23733 not apply producer-specific interpretation. */
23734 prepare_one_comp_unit (cu
, cu
->dies
, language_minimal
);
23739 sig_type
->tu_read
= 1;
23742 /* Decode simple location descriptions.
23743 Given a pointer to a dwarf block that defines a location, compute
23744 the location and return the value. If COMPUTED is non-null, it is
23745 set to true to indicate that decoding was successful, and false
23746 otherwise. If COMPUTED is null, then this function may emit a
23750 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
, bool *computed
)
23752 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
23754 size_t size
= blk
->size
;
23755 const gdb_byte
*data
= blk
->data
;
23756 CORE_ADDR stack
[64];
23758 unsigned int bytes_read
, unsnd
;
23761 if (computed
!= nullptr)
23767 stack
[++stacki
] = 0;
23806 stack
[++stacki
] = op
- DW_OP_lit0
;
23841 stack
[++stacki
] = op
- DW_OP_reg0
;
23844 if (computed
== nullptr)
23845 dwarf2_complex_location_expr_complaint ();
23852 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
23854 stack
[++stacki
] = unsnd
;
23857 if (computed
== nullptr)
23858 dwarf2_complex_location_expr_complaint ();
23865 stack
[++stacki
] = cu
->header
.read_address (objfile
->obfd
, &data
[i
],
23870 case DW_OP_const1u
:
23871 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
23875 case DW_OP_const1s
:
23876 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
23880 case DW_OP_const2u
:
23881 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
23885 case DW_OP_const2s
:
23886 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
23890 case DW_OP_const4u
:
23891 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
23895 case DW_OP_const4s
:
23896 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
23900 case DW_OP_const8u
:
23901 stack
[++stacki
] = read_8_bytes (objfile
->obfd
, &data
[i
]);
23906 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
23912 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
23917 stack
[stacki
+ 1] = stack
[stacki
];
23922 stack
[stacki
- 1] += stack
[stacki
];
23926 case DW_OP_plus_uconst
:
23927 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
),
23933 stack
[stacki
- 1] -= stack
[stacki
];
23938 /* If we're not the last op, then we definitely can't encode
23939 this using GDB's address_class enum. This is valid for partial
23940 global symbols, although the variable's address will be bogus
23944 if (computed
== nullptr)
23945 dwarf2_complex_location_expr_complaint ();
23951 case DW_OP_GNU_push_tls_address
:
23952 case DW_OP_form_tls_address
:
23953 /* The top of the stack has the offset from the beginning
23954 of the thread control block at which the variable is located. */
23955 /* Nothing should follow this operator, so the top of stack would
23957 /* This is valid for partial global symbols, but the variable's
23958 address will be bogus in the psymtab. Make it always at least
23959 non-zero to not look as a variable garbage collected by linker
23960 which have DW_OP_addr 0. */
23963 if (computed
== nullptr)
23964 dwarf2_complex_location_expr_complaint ();
23971 case DW_OP_GNU_uninit
:
23972 if (computed
!= nullptr)
23977 case DW_OP_GNU_addr_index
:
23978 case DW_OP_GNU_const_index
:
23979 stack
[++stacki
] = read_addr_index_from_leb128 (cu
, &data
[i
],
23985 if (computed
== nullptr)
23987 const char *name
= get_DW_OP_name (op
);
23990 complaint (_("unsupported stack op: '%s'"),
23993 complaint (_("unsupported stack op: '%02x'"),
23997 return (stack
[stacki
]);
24000 /* Enforce maximum stack depth of SIZE-1 to avoid writing
24001 outside of the allocated space. Also enforce minimum>0. */
24002 if (stacki
>= ARRAY_SIZE (stack
) - 1)
24004 if (computed
== nullptr)
24005 complaint (_("location description stack overflow"));
24011 if (computed
== nullptr)
24012 complaint (_("location description stack underflow"));
24017 if (computed
!= nullptr)
24019 return (stack
[stacki
]);
24022 /* memory allocation interface */
24024 static struct dwarf_block
*
24025 dwarf_alloc_block (struct dwarf2_cu
*cu
)
24027 return XOBNEW (&cu
->comp_unit_obstack
, struct dwarf_block
);
24030 static struct die_info
*
24031 dwarf_alloc_die (struct dwarf2_cu
*cu
, int num_attrs
)
24033 struct die_info
*die
;
24034 size_t size
= sizeof (struct die_info
);
24037 size
+= (num_attrs
- 1) * sizeof (struct attribute
);
24039 die
= (struct die_info
*) obstack_alloc (&cu
->comp_unit_obstack
, size
);
24040 memset (die
, 0, sizeof (struct die_info
));
24046 /* Macro support. */
24048 /* An overload of dwarf_decode_macros that finds the correct section
24049 and ensures it is read in before calling the other overload. */
24052 dwarf_decode_macros (struct dwarf2_cu
*cu
, unsigned int offset
,
24053 int section_is_gnu
)
24055 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
24056 struct objfile
*objfile
= per_objfile
->objfile
;
24057 const struct line_header
*lh
= cu
->line_header
;
24058 unsigned int offset_size
= cu
->header
.offset_size
;
24059 struct dwarf2_section_info
*section
;
24060 const char *section_name
;
24062 if (cu
->dwo_unit
!= nullptr)
24064 if (section_is_gnu
)
24066 section
= &cu
->dwo_unit
->dwo_file
->sections
.macro
;
24067 section_name
= ".debug_macro.dwo";
24071 section
= &cu
->dwo_unit
->dwo_file
->sections
.macinfo
;
24072 section_name
= ".debug_macinfo.dwo";
24077 if (section_is_gnu
)
24079 section
= &per_objfile
->per_bfd
->macro
;
24080 section_name
= ".debug_macro";
24084 section
= &per_objfile
->per_bfd
->macinfo
;
24085 section_name
= ".debug_macinfo";
24089 section
->read (objfile
);
24090 if (section
->buffer
== nullptr)
24092 complaint (_("missing %s section"), section_name
);
24096 buildsym_compunit
*builder
= cu
->get_builder ();
24098 struct dwarf2_section_info
*str_offsets_section
;
24099 struct dwarf2_section_info
*str_section
;
24100 ULONGEST str_offsets_base
;
24102 if (cu
->dwo_unit
!= nullptr)
24104 str_offsets_section
= &cu
->dwo_unit
->dwo_file
24105 ->sections
.str_offsets
;
24106 str_section
= &cu
->dwo_unit
->dwo_file
->sections
.str
;
24107 str_offsets_base
= cu
->header
.addr_size
;
24111 str_offsets_section
= &per_objfile
->per_bfd
->str_offsets
;
24112 str_section
= &per_objfile
->per_bfd
->str
;
24113 str_offsets_base
= *cu
->str_offsets_base
;
24116 dwarf_decode_macros (per_objfile
, builder
, section
, lh
,
24117 offset_size
, offset
, str_section
, str_offsets_section
,
24118 str_offsets_base
, section_is_gnu
);
24121 /* Return the .debug_loc section to use for CU.
24122 For DWO files use .debug_loc.dwo. */
24124 static struct dwarf2_section_info
*
24125 cu_debug_loc_section (struct dwarf2_cu
*cu
)
24127 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
24131 struct dwo_sections
*sections
= &cu
->dwo_unit
->dwo_file
->sections
;
24133 return cu
->header
.version
>= 5 ? §ions
->loclists
: §ions
->loc
;
24135 return (cu
->header
.version
>= 5 ? &per_objfile
->per_bfd
->loclists
24136 : &per_objfile
->per_bfd
->loc
);
24139 /* Return the .debug_rnglists section to use for CU. */
24140 static struct dwarf2_section_info
*
24141 cu_debug_rnglists_section (struct dwarf2_cu
*cu
, dwarf_tag tag
)
24143 if (cu
->header
.version
< 5)
24144 error (_(".debug_rnglists section cannot be used in DWARF %d"),
24145 cu
->header
.version
);
24146 struct dwarf2_per_objfile
*dwarf2_per_objfile
= cu
->per_objfile
;
24148 /* Make sure we read the .debug_rnglists section from the file that
24149 contains the DW_AT_ranges attribute we are reading. Normally that
24150 would be the .dwo file, if there is one. However for DW_TAG_compile_unit
24151 or DW_TAG_skeleton unit, we always want to read from objfile/linked
24153 if (cu
->dwo_unit
!= nullptr
24154 && tag
!= DW_TAG_compile_unit
24155 && tag
!= DW_TAG_skeleton_unit
)
24157 struct dwo_sections
*sections
= &cu
->dwo_unit
->dwo_file
->sections
;
24159 if (sections
->rnglists
.size
> 0)
24160 return §ions
->rnglists
;
24162 error (_(".debug_rnglists section is missing from .dwo file."));
24164 return &dwarf2_per_objfile
->per_bfd
->rnglists
;
24167 /* A helper function that fills in a dwarf2_loclist_baton. */
24170 fill_in_loclist_baton (struct dwarf2_cu
*cu
,
24171 struct dwarf2_loclist_baton
*baton
,
24172 const struct attribute
*attr
)
24174 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
24175 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
24177 section
->read (per_objfile
->objfile
);
24179 baton
->per_objfile
= per_objfile
;
24180 baton
->per_cu
= cu
->per_cu
;
24181 gdb_assert (baton
->per_cu
);
24182 /* We don't know how long the location list is, but make sure we
24183 don't run off the edge of the section. */
24184 baton
->size
= section
->size
- attr
->as_unsigned ();
24185 baton
->data
= section
->buffer
+ attr
->as_unsigned ();
24186 if (cu
->base_address
.has_value ())
24187 baton
->base_address
= *cu
->base_address
;
24189 baton
->base_address
= 0;
24190 baton
->from_dwo
= cu
->dwo_unit
!= NULL
;
24194 dwarf2_symbol_mark_computed (const struct attribute
*attr
, struct symbol
*sym
,
24195 struct dwarf2_cu
*cu
, int is_block
)
24197 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
24198 struct objfile
*objfile
= per_objfile
->objfile
;
24199 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
24201 if (attr
->form_is_section_offset ()
24202 /* .debug_loc{,.dwo} may not exist at all, or the offset may be outside
24203 the section. If so, fall through to the complaint in the
24205 && attr
->as_unsigned () < section
->get_size (objfile
))
24207 struct dwarf2_loclist_baton
*baton
;
24209 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_loclist_baton
);
24211 fill_in_loclist_baton (cu
, baton
, attr
);
24213 if (!cu
->base_address
.has_value ())
24214 complaint (_("Location list used without "
24215 "specifying the CU base address."));
24217 SYMBOL_ACLASS_INDEX (sym
) = (is_block
24218 ? dwarf2_loclist_block_index
24219 : dwarf2_loclist_index
);
24220 SYMBOL_LOCATION_BATON (sym
) = baton
;
24224 struct dwarf2_locexpr_baton
*baton
;
24226 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
24227 baton
->per_objfile
= per_objfile
;
24228 baton
->per_cu
= cu
->per_cu
;
24229 gdb_assert (baton
->per_cu
);
24231 if (attr
->form_is_block ())
24233 /* Note that we're just copying the block's data pointer
24234 here, not the actual data. We're still pointing into the
24235 info_buffer for SYM's objfile; right now we never release
24236 that buffer, but when we do clean up properly this may
24238 struct dwarf_block
*block
= attr
->as_block ();
24239 baton
->size
= block
->size
;
24240 baton
->data
= block
->data
;
24244 dwarf2_invalid_attrib_class_complaint ("location description",
24245 sym
->natural_name ());
24249 SYMBOL_ACLASS_INDEX (sym
) = (is_block
24250 ? dwarf2_locexpr_block_index
24251 : dwarf2_locexpr_index
);
24252 SYMBOL_LOCATION_BATON (sym
) = baton
;
24258 const comp_unit_head
*
24259 dwarf2_per_cu_data::get_header () const
24261 if (!m_header_read_in
)
24263 const gdb_byte
*info_ptr
24264 = this->section
->buffer
+ to_underlying (this->sect_off
);
24266 memset (&m_header
, 0, sizeof (m_header
));
24268 read_comp_unit_head (&m_header
, info_ptr
, this->section
,
24269 rcuh_kind::COMPILE
);
24271 m_header_read_in
= true;
24280 dwarf2_per_cu_data::addr_size () const
24282 return this->get_header ()->addr_size
;
24288 dwarf2_per_cu_data::offset_size () const
24290 return this->get_header ()->offset_size
;
24296 dwarf2_per_cu_data::ref_addr_size () const
24298 const comp_unit_head
*header
= this->get_header ();
24300 if (header
->version
== 2)
24301 return header
->addr_size
;
24303 return header
->offset_size
;
24306 /* A helper function for dwarf2_find_containing_comp_unit that returns
24307 the index of the result, and that searches a vector. It will
24308 return a result even if the offset in question does not actually
24309 occur in any CU. This is separate so that it can be unit
24313 dwarf2_find_containing_comp_unit
24314 (sect_offset sect_off
,
24315 unsigned int offset_in_dwz
,
24316 const std::vector
<dwarf2_per_cu_data_up
> &all_comp_units
)
24321 high
= all_comp_units
.size () - 1;
24324 struct dwarf2_per_cu_data
*mid_cu
;
24325 int mid
= low
+ (high
- low
) / 2;
24327 mid_cu
= all_comp_units
[mid
].get ();
24328 if (mid_cu
->is_dwz
> offset_in_dwz
24329 || (mid_cu
->is_dwz
== offset_in_dwz
24330 && mid_cu
->sect_off
+ mid_cu
->length
> sect_off
))
24335 gdb_assert (low
== high
);
24339 /* Locate the .debug_info compilation unit from CU's objfile which contains
24340 the DIE at OFFSET. Raises an error on failure. */
24342 static struct dwarf2_per_cu_data
*
24343 dwarf2_find_containing_comp_unit (sect_offset sect_off
,
24344 unsigned int offset_in_dwz
,
24345 dwarf2_per_objfile
*per_objfile
)
24347 int low
= dwarf2_find_containing_comp_unit
24348 (sect_off
, offset_in_dwz
, per_objfile
->per_bfd
->all_comp_units
);
24349 dwarf2_per_cu_data
*this_cu
24350 = per_objfile
->per_bfd
->all_comp_units
[low
].get ();
24352 if (this_cu
->is_dwz
!= offset_in_dwz
|| this_cu
->sect_off
> sect_off
)
24354 if (low
== 0 || this_cu
->is_dwz
!= offset_in_dwz
)
24355 error (_("Dwarf Error: could not find partial DIE containing "
24356 "offset %s [in module %s]"),
24357 sect_offset_str (sect_off
),
24358 bfd_get_filename (per_objfile
->objfile
->obfd
));
24360 gdb_assert (per_objfile
->per_bfd
->all_comp_units
[low
-1]->sect_off
24362 return per_objfile
->per_bfd
->all_comp_units
[low
- 1].get ();
24366 if (low
== per_objfile
->per_bfd
->all_comp_units
.size () - 1
24367 && sect_off
>= this_cu
->sect_off
+ this_cu
->length
)
24368 error (_("invalid dwarf2 offset %s"), sect_offset_str (sect_off
));
24369 gdb_assert (sect_off
< this_cu
->sect_off
+ this_cu
->length
);
24376 namespace selftests
{
24377 namespace find_containing_comp_unit
{
24382 dwarf2_per_cu_data_up
one (new dwarf2_per_cu_data
);
24383 dwarf2_per_cu_data
*one_ptr
= one
.get ();
24384 dwarf2_per_cu_data_up
two (new dwarf2_per_cu_data
);
24385 dwarf2_per_cu_data
*two_ptr
= two
.get ();
24386 dwarf2_per_cu_data_up
three (new dwarf2_per_cu_data
);
24387 dwarf2_per_cu_data
*three_ptr
= three
.get ();
24388 dwarf2_per_cu_data_up
four (new dwarf2_per_cu_data
);
24389 dwarf2_per_cu_data
*four_ptr
= four
.get ();
24392 two
->sect_off
= sect_offset (one
->length
);
24397 four
->sect_off
= sect_offset (three
->length
);
24401 std::vector
<dwarf2_per_cu_data_up
> units
;
24402 units
.push_back (std::move (one
));
24403 units
.push_back (std::move (two
));
24404 units
.push_back (std::move (three
));
24405 units
.push_back (std::move (four
));
24409 result
= dwarf2_find_containing_comp_unit (sect_offset (0), 0, units
);
24410 SELF_CHECK (units
[result
].get () == one_ptr
);
24411 result
= dwarf2_find_containing_comp_unit (sect_offset (3), 0, units
);
24412 SELF_CHECK (units
[result
].get () == one_ptr
);
24413 result
= dwarf2_find_containing_comp_unit (sect_offset (5), 0, units
);
24414 SELF_CHECK (units
[result
].get () == two_ptr
);
24416 result
= dwarf2_find_containing_comp_unit (sect_offset (0), 1, units
);
24417 SELF_CHECK (units
[result
].get () == three_ptr
);
24418 result
= dwarf2_find_containing_comp_unit (sect_offset (3), 1, units
);
24419 SELF_CHECK (units
[result
].get () == three_ptr
);
24420 result
= dwarf2_find_containing_comp_unit (sect_offset (5), 1, units
);
24421 SELF_CHECK (units
[result
].get () == four_ptr
);
24427 #endif /* GDB_SELF_TEST */
24429 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
24432 prepare_one_comp_unit (struct dwarf2_cu
*cu
, struct die_info
*comp_unit_die
,
24433 enum language pretend_language
)
24435 struct attribute
*attr
;
24437 cu
->producer
= dwarf2_string_attr (comp_unit_die
, DW_AT_producer
, cu
);
24439 /* Set the language we're debugging. */
24440 attr
= dwarf2_attr (comp_unit_die
, DW_AT_language
, cu
);
24441 if (cu
->producer
!= nullptr
24442 && strstr (cu
->producer
, "IBM XL C for OpenCL") != NULL
)
24444 /* The XLCL doesn't generate DW_LANG_OpenCL because this
24445 attribute is not standardised yet. As a workaround for the
24446 language detection we fall back to the DW_AT_producer
24448 cu
->per_cu
->lang
= language_opencl
;
24450 else if (cu
->producer
!= nullptr
24451 && strstr (cu
->producer
, "GNU Go ") != NULL
)
24453 /* Similar hack for Go. */
24454 cu
->per_cu
->lang
= language_go
;
24456 else if (attr
!= nullptr)
24457 cu
->per_cu
->lang
= dwarf_lang_to_enum_language (attr
->constant_value (0));
24459 cu
->per_cu
->lang
= pretend_language
;
24460 cu
->language_defn
= language_def (cu
->per_cu
->lang
);
24466 dwarf2_per_objfile::get_cu (dwarf2_per_cu_data
*per_cu
)
24468 auto it
= m_dwarf2_cus
.find (per_cu
);
24469 if (it
== m_dwarf2_cus
.end ())
24478 dwarf2_per_objfile::set_cu (dwarf2_per_cu_data
*per_cu
, dwarf2_cu
*cu
)
24480 gdb_assert (this->get_cu (per_cu
) == nullptr);
24482 m_dwarf2_cus
[per_cu
] = cu
;
24488 dwarf2_per_objfile::age_comp_units ()
24490 dwarf_read_debug_printf_v ("running");
24492 /* This is not expected to be called in the middle of CU expansion. There is
24493 an invariant that if a CU is in the CUs-to-expand queue, its DIEs are
24494 loaded in memory. Calling age_comp_units while the queue is in use could
24495 make us free the DIEs for a CU that is in the queue and therefore break
24497 gdb_assert (!this->per_bfd
->queue
.has_value ());
24499 /* Start by clearing all marks. */
24500 for (auto pair
: m_dwarf2_cus
)
24501 pair
.second
->clear_mark ();
24503 /* Traverse all CUs, mark them and their dependencies if used recently
24505 for (auto pair
: m_dwarf2_cus
)
24507 dwarf2_cu
*cu
= pair
.second
;
24510 if (cu
->last_used
<= dwarf_max_cache_age
)
24514 /* Delete all CUs still not marked. */
24515 for (auto it
= m_dwarf2_cus
.begin (); it
!= m_dwarf2_cus
.end ();)
24517 dwarf2_cu
*cu
= it
->second
;
24519 if (!cu
->is_marked ())
24521 dwarf_read_debug_printf_v ("deleting old CU %s",
24522 sect_offset_str (cu
->per_cu
->sect_off
));
24524 it
= m_dwarf2_cus
.erase (it
);
24534 dwarf2_per_objfile::remove_cu (dwarf2_per_cu_data
*per_cu
)
24536 auto it
= m_dwarf2_cus
.find (per_cu
);
24537 if (it
== m_dwarf2_cus
.end ())
24542 m_dwarf2_cus
.erase (it
);
24545 dwarf2_per_objfile::~dwarf2_per_objfile ()
24550 /* A set of CU "per_cu" pointer, DIE offset, and GDB type pointer.
24551 We store these in a hash table separate from the DIEs, and preserve them
24552 when the DIEs are flushed out of cache.
24554 The CU "per_cu" pointer is needed because offset alone is not enough to
24555 uniquely identify the type. A file may have multiple .debug_types sections,
24556 or the type may come from a DWO file. Furthermore, while it's more logical
24557 to use per_cu->section+offset, with Fission the section with the data is in
24558 the DWO file but we don't know that section at the point we need it.
24559 We have to use something in dwarf2_per_cu_data (or the pointer to it)
24560 because we can enter the lookup routine, get_die_type_at_offset, from
24561 outside this file, and thus won't necessarily have PER_CU->cu.
24562 Fortunately, PER_CU is stable for the life of the objfile. */
24564 struct dwarf2_per_cu_offset_and_type
24566 const struct dwarf2_per_cu_data
*per_cu
;
24567 sect_offset sect_off
;
24571 /* Hash function for a dwarf2_per_cu_offset_and_type. */
24574 per_cu_offset_and_type_hash (const void *item
)
24576 const struct dwarf2_per_cu_offset_and_type
*ofs
24577 = (const struct dwarf2_per_cu_offset_and_type
*) item
;
24579 return (uintptr_t) ofs
->per_cu
+ to_underlying (ofs
->sect_off
);
24582 /* Equality function for a dwarf2_per_cu_offset_and_type. */
24585 per_cu_offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
24587 const struct dwarf2_per_cu_offset_and_type
*ofs_lhs
24588 = (const struct dwarf2_per_cu_offset_and_type
*) item_lhs
;
24589 const struct dwarf2_per_cu_offset_and_type
*ofs_rhs
24590 = (const struct dwarf2_per_cu_offset_and_type
*) item_rhs
;
24592 return (ofs_lhs
->per_cu
== ofs_rhs
->per_cu
24593 && ofs_lhs
->sect_off
== ofs_rhs
->sect_off
);
24596 /* Set the type associated with DIE to TYPE. Save it in CU's hash
24597 table if necessary. For convenience, return TYPE.
24599 The DIEs reading must have careful ordering to:
24600 * Not cause infinite loops trying to read in DIEs as a prerequisite for
24601 reading current DIE.
24602 * Not trying to dereference contents of still incompletely read in types
24603 while reading in other DIEs.
24604 * Enable referencing still incompletely read in types just by a pointer to
24605 the type without accessing its fields.
24607 Therefore caller should follow these rules:
24608 * Try to fetch any prerequisite types we may need to build this DIE type
24609 before building the type and calling set_die_type.
24610 * After building type call set_die_type for current DIE as soon as
24611 possible before fetching more types to complete the current type.
24612 * Make the type as complete as possible before fetching more types. */
24614 static struct type
*
24615 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
,
24616 bool skip_data_location
)
24618 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
24619 struct dwarf2_per_cu_offset_and_type
**slot
, ofs
;
24620 struct objfile
*objfile
= per_objfile
->objfile
;
24621 struct attribute
*attr
;
24622 struct dynamic_prop prop
;
24624 /* For Ada types, make sure that the gnat-specific data is always
24625 initialized (if not already set). There are a few types where
24626 we should not be doing so, because the type-specific area is
24627 already used to hold some other piece of info (eg: TYPE_CODE_FLT
24628 where the type-specific area is used to store the floatformat).
24629 But this is not a problem, because the gnat-specific information
24630 is actually not needed for these types. */
24631 if (need_gnat_info (cu
)
24632 && type
->code () != TYPE_CODE_FUNC
24633 && type
->code () != TYPE_CODE_FLT
24634 && type
->code () != TYPE_CODE_METHODPTR
24635 && type
->code () != TYPE_CODE_MEMBERPTR
24636 && type
->code () != TYPE_CODE_METHOD
24637 && type
->code () != TYPE_CODE_FIXED_POINT
24638 && !HAVE_GNAT_AUX_INFO (type
))
24639 INIT_GNAT_SPECIFIC (type
);
24641 /* Read DW_AT_allocated and set in type. */
24642 attr
= dwarf2_attr (die
, DW_AT_allocated
, cu
);
24645 struct type
*prop_type
= cu
->addr_sized_int_type (false);
24646 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
, prop_type
))
24647 type
->add_dyn_prop (DYN_PROP_ALLOCATED
, prop
);
24650 /* Read DW_AT_associated and set in type. */
24651 attr
= dwarf2_attr (die
, DW_AT_associated
, cu
);
24654 struct type
*prop_type
= cu
->addr_sized_int_type (false);
24655 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
, prop_type
))
24656 type
->add_dyn_prop (DYN_PROP_ASSOCIATED
, prop
);
24659 /* Read DW_AT_data_location and set in type. */
24660 if (!skip_data_location
)
24662 attr
= dwarf2_attr (die
, DW_AT_data_location
, cu
);
24663 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
, cu
->addr_type ()))
24664 type
->add_dyn_prop (DYN_PROP_DATA_LOCATION
, prop
);
24667 if (per_objfile
->die_type_hash
== NULL
)
24668 per_objfile
->die_type_hash
24669 = htab_up (htab_create_alloc (127,
24670 per_cu_offset_and_type_hash
,
24671 per_cu_offset_and_type_eq
,
24672 NULL
, xcalloc
, xfree
));
24674 ofs
.per_cu
= cu
->per_cu
;
24675 ofs
.sect_off
= die
->sect_off
;
24677 slot
= (struct dwarf2_per_cu_offset_and_type
**)
24678 htab_find_slot (per_objfile
->die_type_hash
.get (), &ofs
, INSERT
);
24680 complaint (_("A problem internal to GDB: DIE %s has type already set"),
24681 sect_offset_str (die
->sect_off
));
24682 *slot
= XOBNEW (&objfile
->objfile_obstack
,
24683 struct dwarf2_per_cu_offset_and_type
);
24688 /* Look up the type for the die at SECT_OFF in PER_CU in die_type_hash,
24689 or return NULL if the die does not have a saved type. */
24691 static struct type
*
24692 get_die_type_at_offset (sect_offset sect_off
,
24693 dwarf2_per_cu_data
*per_cu
,
24694 dwarf2_per_objfile
*per_objfile
)
24696 struct dwarf2_per_cu_offset_and_type
*slot
, ofs
;
24698 if (per_objfile
->die_type_hash
== NULL
)
24701 ofs
.per_cu
= per_cu
;
24702 ofs
.sect_off
= sect_off
;
24703 slot
= ((struct dwarf2_per_cu_offset_and_type
*)
24704 htab_find (per_objfile
->die_type_hash
.get (), &ofs
));
24711 /* Look up the type for DIE in CU in die_type_hash,
24712 or return NULL if DIE does not have a saved type. */
24714 static struct type
*
24715 get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
24717 return get_die_type_at_offset (die
->sect_off
, cu
->per_cu
, cu
->per_objfile
);
24720 /* Trivial hash function for partial_die_info: the hash value of a DIE
24721 is its offset in .debug_info for this objfile. */
24724 partial_die_hash (const void *item
)
24726 const struct partial_die_info
*part_die
24727 = (const struct partial_die_info
*) item
;
24729 return to_underlying (part_die
->sect_off
);
24732 /* Trivial comparison function for partial_die_info structures: two DIEs
24733 are equal if they have the same offset. */
24736 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
24738 const struct partial_die_info
*part_die_lhs
24739 = (const struct partial_die_info
*) item_lhs
;
24740 const struct partial_die_info
*part_die_rhs
24741 = (const struct partial_die_info
*) item_rhs
;
24743 return part_die_lhs
->sect_off
== part_die_rhs
->sect_off
;
24746 struct cmd_list_element
*set_dwarf_cmdlist
;
24747 struct cmd_list_element
*show_dwarf_cmdlist
;
24750 show_check_physname (struct ui_file
*file
, int from_tty
,
24751 struct cmd_list_element
*c
, const char *value
)
24753 fprintf_filtered (file
,
24754 _("Whether to check \"physname\" is %s.\n"),
24758 void _initialize_dwarf2_read ();
24760 _initialize_dwarf2_read ()
24762 add_basic_prefix_cmd ("dwarf", class_maintenance
, _("\
24763 Set DWARF specific variables.\n\
24764 Configure DWARF variables such as the cache size."),
24765 &set_dwarf_cmdlist
,
24766 0/*allow-unknown*/, &maintenance_set_cmdlist
);
24768 add_show_prefix_cmd ("dwarf", class_maintenance
, _("\
24769 Show DWARF specific variables.\n\
24770 Show DWARF variables such as the cache size."),
24771 &show_dwarf_cmdlist
,
24772 0/*allow-unknown*/, &maintenance_show_cmdlist
);
24774 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
24775 &dwarf_max_cache_age
, _("\
24776 Set the upper bound on the age of cached DWARF compilation units."), _("\
24777 Show the upper bound on the age of cached DWARF compilation units."), _("\
24778 A higher limit means that cached compilation units will be stored\n\
24779 in memory longer, and more total memory will be used. Zero disables\n\
24780 caching, which can slow down startup."),
24782 show_dwarf_max_cache_age
,
24783 &set_dwarf_cmdlist
,
24784 &show_dwarf_cmdlist
);
24786 add_setshow_zuinteger_cmd ("dwarf-read", no_class
, &dwarf_read_debug
, _("\
24787 Set debugging of the DWARF reader."), _("\
24788 Show debugging of the DWARF reader."), _("\
24789 When enabled (non-zero), debugging messages are printed during DWARF\n\
24790 reading and symtab expansion. A value of 1 (one) provides basic\n\
24791 information. A value greater than 1 provides more verbose information."),
24794 &setdebuglist
, &showdebuglist
);
24796 add_setshow_zuinteger_cmd ("dwarf-die", no_class
, &dwarf_die_debug
, _("\
24797 Set debugging of the DWARF DIE reader."), _("\
24798 Show debugging of the DWARF DIE reader."), _("\
24799 When enabled (non-zero), DIEs are dumped after they are read in.\n\
24800 The value is the maximum depth to print."),
24803 &setdebuglist
, &showdebuglist
);
24805 add_setshow_zuinteger_cmd ("dwarf-line", no_class
, &dwarf_line_debug
, _("\
24806 Set debugging of the dwarf line reader."), _("\
24807 Show debugging of the dwarf line reader."), _("\
24808 When enabled (non-zero), line number entries are dumped as they are read in.\n\
24809 A value of 1 (one) provides basic information.\n\
24810 A value greater than 1 provides more verbose information."),
24813 &setdebuglist
, &showdebuglist
);
24815 add_setshow_boolean_cmd ("check-physname", no_class
, &check_physname
, _("\
24816 Set cross-checking of \"physname\" code against demangler."), _("\
24817 Show cross-checking of \"physname\" code against demangler."), _("\
24818 When enabled, GDB's internal \"physname\" code is checked against\n\
24820 NULL
, show_check_physname
,
24821 &setdebuglist
, &showdebuglist
);
24823 add_setshow_boolean_cmd ("use-deprecated-index-sections",
24824 no_class
, &use_deprecated_index_sections
, _("\
24825 Set whether to use deprecated gdb_index sections."), _("\
24826 Show whether to use deprecated gdb_index sections."), _("\
24827 When enabled, deprecated .gdb_index sections are used anyway.\n\
24828 Normally they are ignored either because of a missing feature or\n\
24829 performance issue.\n\
24830 Warning: This option must be enabled before gdb reads the file."),
24833 &setlist
, &showlist
);
24835 dwarf2_locexpr_index
= register_symbol_computed_impl (LOC_COMPUTED
,
24836 &dwarf2_locexpr_funcs
);
24837 dwarf2_loclist_index
= register_symbol_computed_impl (LOC_COMPUTED
,
24838 &dwarf2_loclist_funcs
);
24840 dwarf2_locexpr_block_index
= register_symbol_block_impl (LOC_BLOCK
,
24841 &dwarf2_block_frame_base_locexpr_funcs
);
24842 dwarf2_loclist_block_index
= register_symbol_block_impl (LOC_BLOCK
,
24843 &dwarf2_block_frame_base_loclist_funcs
);
24846 selftests::register_test ("dw2_expand_symtabs_matching",
24847 selftests::dw2_expand_symtabs_matching::run_test
);
24848 selftests::register_test ("dwarf2_find_containing_comp_unit",
24849 selftests::find_containing_comp_unit::run_test
);