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 has_range_info
: 1;
867 unsigned int may_be_inlined
: 1;
869 /* This DIE has been marked DW_AT_main_subprogram. */
870 unsigned int main_subprogram
: 1;
872 /* Flag set if the SCOPE field of this structure has been
874 unsigned int scope_set
: 1;
876 /* Flag set if the DIE has a byte_size attribute. */
877 unsigned int has_byte_size
: 1;
879 /* Flag set if the DIE has a DW_AT_const_value attribute. */
880 unsigned int has_const_value
: 1;
882 /* Flag set if any of the DIE's children are template arguments. */
883 unsigned int has_template_arguments
: 1;
885 /* Flag set if fixup has been called on this die. */
886 unsigned int fixup_called
: 1;
888 /* Flag set if DW_TAG_imported_unit uses DW_FORM_GNU_ref_alt. */
889 unsigned int is_dwz
: 1;
891 /* Flag set if spec_offset uses DW_FORM_GNU_ref_alt. */
892 unsigned int spec_is_dwz
: 1;
894 unsigned int canonical_name
: 1;
896 /* The name of this DIE. Normally the value of DW_AT_name, but
897 sometimes a default name for unnamed DIEs. */
898 const char *raw_name
= nullptr;
900 /* The linkage name, if present. */
901 const char *linkage_name
= nullptr;
903 /* The scope to prepend to our children. This is generally
904 allocated on the comp_unit_obstack, so will disappear
905 when this compilation unit leaves the cache. */
906 const char *scope
= nullptr;
908 /* Some data associated with the partial DIE. The tag determines
909 which field is live. */
912 /* The location description associated with this DIE, if any. */
913 struct dwarf_block
*locdesc
;
914 /* The offset of an import, for DW_TAG_imported_unit. */
915 sect_offset sect_off
;
920 /* If HAS_PC_INFO, the PC range associated with this DIE. */
926 /* If HAS_RANGE_INFO, the ranges offset associated with this DIE. */
927 ULONGEST ranges_offset
;
930 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
931 DW_AT_sibling, if any. */
932 /* NOTE: This member isn't strictly necessary, partial_die_info::read
933 could return DW_AT_sibling values to its caller load_partial_dies. */
934 const gdb_byte
*sibling
= nullptr;
936 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
937 DW_AT_specification (or DW_AT_abstract_origin or
939 sect_offset spec_offset
{};
941 /* Pointers to this DIE's parent, first child, and next sibling,
943 struct partial_die_info
*die_parent
= nullptr;
944 struct partial_die_info
*die_child
= nullptr;
945 struct partial_die_info
*die_sibling
= nullptr;
947 friend struct partial_die_info
*
948 dwarf2_cu::find_partial_die (sect_offset sect_off
);
951 /* Only need to do look up in dwarf2_cu::find_partial_die. */
952 partial_die_info (sect_offset sect_off
)
953 : partial_die_info (sect_off
, DW_TAG_padding
, 0)
957 partial_die_info (sect_offset sect_off_
, enum dwarf_tag tag_
,
959 : sect_off (sect_off_
), tag (tag_
), has_children (has_children_
)
964 has_specification
= 0;
972 has_template_arguments
= 0;
977 /* Don't set these using NSDMI (Non-static data member initialisation),
978 because g++-4.8 will error out. */
984 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
985 but this would require a corresponding change in unpack_field_as_long
987 static int bits_per_byte
= 8;
989 struct variant_part_builder
;
991 /* When reading a variant, we track a bit more information about the
992 field, and store it in an object of this type. */
996 int first_field
= -1;
999 /* A variant can contain other variant parts. */
1000 std::vector
<variant_part_builder
> variant_parts
;
1002 /* If we see a DW_TAG_variant, then this will be set if this is the
1004 bool default_branch
= false;
1005 /* If we see a DW_AT_discr_value, then this will be the discriminant
1007 ULONGEST discriminant_value
= 0;
1008 /* If we see a DW_AT_discr_list, then this is a pointer to the list
1010 struct dwarf_block
*discr_list_data
= nullptr;
1013 /* This represents a DW_TAG_variant_part. */
1015 struct variant_part_builder
1017 /* The offset of the discriminant field. */
1018 sect_offset discriminant_offset
{};
1020 /* Variants that are direct children of this variant part. */
1021 std::vector
<variant_field
> variants
;
1023 /* True if we're currently reading a variant. */
1024 bool processing_variant
= false;
1029 int accessibility
= 0;
1031 /* Variant parts need to find the discriminant, which is a DIE
1032 reference. We track the section offset of each field to make
1035 struct field field
{};
1040 const char *name
= nullptr;
1041 std::vector
<struct fn_field
> fnfields
;
1044 /* The routines that read and process dies for a C struct or C++ class
1045 pass lists of data member fields and lists of member function fields
1046 in an instance of a field_info structure, as defined below. */
1049 /* List of data member and baseclasses fields. */
1050 std::vector
<struct nextfield
> fields
;
1051 std::vector
<struct nextfield
> baseclasses
;
1053 /* Set if the accessibility of one of the fields is not public. */
1054 bool non_public_fields
= false;
1056 /* Member function fieldlist array, contains name of possibly overloaded
1057 member function, number of overloaded member functions and a pointer
1058 to the head of the member function field chain. */
1059 std::vector
<struct fnfieldlist
> fnfieldlists
;
1061 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
1062 a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
1063 std::vector
<struct decl_field
> typedef_field_list
;
1065 /* Nested types defined by this class and the number of elements in this
1067 std::vector
<struct decl_field
> nested_types_list
;
1069 /* If non-null, this is the variant part we are currently
1071 variant_part_builder
*current_variant_part
= nullptr;
1072 /* This holds all the top-level variant parts attached to the type
1074 std::vector
<variant_part_builder
> variant_parts
;
1076 /* Return the total number of fields (including baseclasses). */
1077 int nfields () const
1079 return fields
.size () + baseclasses
.size ();
1083 /* Loaded secondary compilation units are kept in memory until they
1084 have not been referenced for the processing of this many
1085 compilation units. Set this to zero to disable caching. Cache
1086 sizes of up to at least twenty will improve startup time for
1087 typical inter-CU-reference binaries, at an obvious memory cost. */
1088 static int dwarf_max_cache_age
= 5;
1090 show_dwarf_max_cache_age (struct ui_file
*file
, int from_tty
,
1091 struct cmd_list_element
*c
, const char *value
)
1093 fprintf_filtered (file
, _("The upper bound on the age of cached "
1094 "DWARF compilation units is %s.\n"),
1098 /* local function prototypes */
1100 static void dwarf2_find_base_address (struct die_info
*die
,
1101 struct dwarf2_cu
*cu
);
1103 static dwarf2_psymtab
*create_partial_symtab
1104 (dwarf2_per_cu_data
*per_cu
, dwarf2_per_objfile
*per_objfile
,
1107 static void build_type_psymtabs_reader (const struct die_reader_specs
*reader
,
1108 const gdb_byte
*info_ptr
,
1109 struct die_info
*type_unit_die
);
1111 static void dwarf2_build_psymtabs_hard (dwarf2_per_objfile
*per_objfile
);
1113 static void scan_partial_symbols (struct partial_die_info
*,
1114 CORE_ADDR
*, CORE_ADDR
*,
1115 int, struct dwarf2_cu
*);
1117 static void add_partial_symbol (struct partial_die_info
*,
1118 struct dwarf2_cu
*);
1120 static void add_partial_namespace (struct partial_die_info
*pdi
,
1121 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1122 int set_addrmap
, struct dwarf2_cu
*cu
);
1124 static void add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
1125 CORE_ADDR
*highpc
, int set_addrmap
,
1126 struct dwarf2_cu
*cu
);
1128 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
1129 struct dwarf2_cu
*cu
);
1131 static void add_partial_subprogram (struct partial_die_info
*pdi
,
1132 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1133 int need_pc
, struct dwarf2_cu
*cu
);
1135 static unsigned int peek_abbrev_code (bfd
*, const gdb_byte
*);
1137 static struct partial_die_info
*load_partial_dies
1138 (const struct die_reader_specs
*, const gdb_byte
*, int);
1140 /* A pair of partial_die_info and compilation unit. */
1141 struct cu_partial_die_info
1143 /* The compilation unit of the partial_die_info. */
1144 struct dwarf2_cu
*cu
;
1145 /* A partial_die_info. */
1146 struct partial_die_info
*pdi
;
1148 cu_partial_die_info (struct dwarf2_cu
*cu
, struct partial_die_info
*pdi
)
1154 cu_partial_die_info () = delete;
1157 static const struct cu_partial_die_info
find_partial_die (sect_offset
, int,
1158 struct dwarf2_cu
*);
1160 static const gdb_byte
*read_attribute (const struct die_reader_specs
*,
1162 const struct attr_abbrev
*,
1165 static void read_attribute_reprocess (const struct die_reader_specs
*reader
,
1166 struct attribute
*attr
, dwarf_tag tag
);
1168 static CORE_ADDR
read_addr_index (struct dwarf2_cu
*cu
, unsigned int addr_index
);
1170 static sect_offset
read_abbrev_offset (dwarf2_per_objfile
*per_objfile
,
1171 dwarf2_section_info
*, sect_offset
);
1173 static const char *read_indirect_string
1174 (dwarf2_per_objfile
*per_objfile
, bfd
*, const gdb_byte
*,
1175 const struct comp_unit_head
*, unsigned int *);
1177 static const char *read_indirect_string_at_offset
1178 (dwarf2_per_objfile
*per_objfile
, LONGEST str_offset
);
1180 static CORE_ADDR
read_addr_index_from_leb128 (struct dwarf2_cu
*,
1184 static const char *read_dwo_str_index (const struct die_reader_specs
*reader
,
1185 ULONGEST str_index
);
1187 static const char *read_stub_str_index (struct dwarf2_cu
*cu
,
1188 ULONGEST str_index
);
1190 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
1191 struct dwarf2_cu
*);
1193 static const char *dwarf2_string_attr (struct die_info
*die
, unsigned int name
,
1194 struct dwarf2_cu
*cu
);
1196 static const char *dwarf2_dwo_name (struct die_info
*die
, struct dwarf2_cu
*cu
);
1198 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
1199 struct dwarf2_cu
*cu
);
1201 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
1203 static struct die_info
*die_specification (struct die_info
*die
,
1204 struct dwarf2_cu
**);
1206 static line_header_up
dwarf_decode_line_header (sect_offset sect_off
,
1207 struct dwarf2_cu
*cu
);
1209 struct file_and_directory
;
1210 static void dwarf_decode_lines (struct line_header
*,
1211 const file_and_directory
&,
1212 struct dwarf2_cu
*, dwarf2_psymtab
*,
1213 CORE_ADDR
, int decode_mapping
);
1215 static void dwarf2_start_subfile (struct dwarf2_cu
*, const char *,
1218 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
1219 struct dwarf2_cu
*, struct symbol
* = NULL
);
1221 static void dwarf2_const_value (const struct attribute
*, struct symbol
*,
1222 struct dwarf2_cu
*);
1224 static void dwarf2_const_value_attr (const struct attribute
*attr
,
1227 struct obstack
*obstack
,
1228 struct dwarf2_cu
*cu
, LONGEST
*value
,
1229 const gdb_byte
**bytes
,
1230 struct dwarf2_locexpr_baton
**baton
);
1232 static struct type
*read_subrange_index_type (struct die_info
*die
,
1233 struct dwarf2_cu
*cu
);
1235 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
1237 static int need_gnat_info (struct dwarf2_cu
*);
1239 static struct type
*die_descriptive_type (struct die_info
*,
1240 struct dwarf2_cu
*);
1242 static void set_descriptive_type (struct type
*, struct die_info
*,
1243 struct dwarf2_cu
*);
1245 static struct type
*die_containing_type (struct die_info
*,
1246 struct dwarf2_cu
*);
1248 static struct type
*lookup_die_type (struct die_info
*, const struct attribute
*,
1249 struct dwarf2_cu
*);
1251 static struct type
*read_type_die (struct die_info
*, struct dwarf2_cu
*);
1253 static struct type
*read_type_die_1 (struct die_info
*, struct dwarf2_cu
*);
1255 static const char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
1257 static char *typename_concat (struct obstack
*obs
, const char *prefix
,
1258 const char *suffix
, int physname
,
1259 struct dwarf2_cu
*cu
);
1261 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
1263 static void read_type_unit_scope (struct die_info
*, struct dwarf2_cu
*);
1265 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
1267 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
1269 static void read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
);
1271 static void read_variable (struct die_info
*die
, struct dwarf2_cu
*cu
);
1273 /* Return the .debug_loclists section to use for cu. */
1274 static struct dwarf2_section_info
*cu_debug_loc_section (struct dwarf2_cu
*cu
);
1276 /* Return the .debug_rnglists section to use for cu. */
1277 static struct dwarf2_section_info
*cu_debug_rnglists_section
1278 (struct dwarf2_cu
*cu
, dwarf_tag tag
);
1280 /* How dwarf2_get_pc_bounds constructed its *LOWPC and *HIGHPC return
1281 values. Keep the items ordered with increasing constraints compliance. */
1284 /* No attribute DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges was found. */
1285 PC_BOUNDS_NOT_PRESENT
,
1287 /* Some of the attributes DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges
1288 were present but they do not form a valid range of PC addresses. */
1291 /* Discontiguous range was found - that is DW_AT_ranges was found. */
1294 /* Contiguous range was found - DW_AT_low_pc and DW_AT_high_pc were found. */
1298 static enum pc_bounds_kind
dwarf2_get_pc_bounds (struct die_info
*,
1299 CORE_ADDR
*, CORE_ADDR
*,
1303 static void get_scope_pc_bounds (struct die_info
*,
1304 CORE_ADDR
*, CORE_ADDR
*,
1305 struct dwarf2_cu
*);
1307 static void dwarf2_record_block_ranges (struct die_info
*, struct block
*,
1308 CORE_ADDR
, struct dwarf2_cu
*);
1310 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
1311 struct dwarf2_cu
*);
1313 static void dwarf2_attach_fields_to_type (struct field_info
*,
1314 struct type
*, struct dwarf2_cu
*);
1316 static void dwarf2_add_member_fn (struct field_info
*,
1317 struct die_info
*, struct type
*,
1318 struct dwarf2_cu
*);
1320 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
1322 struct dwarf2_cu
*);
1324 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
1326 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
1328 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
1330 static void read_module (struct die_info
*die
, struct dwarf2_cu
*cu
);
1332 static struct using_direct
**using_directives (struct dwarf2_cu
*cu
);
1334 static void read_import_statement (struct die_info
*die
, struct dwarf2_cu
*);
1336 static int read_namespace_alias (struct die_info
*die
, struct dwarf2_cu
*cu
);
1338 static struct type
*read_module_type (struct die_info
*die
,
1339 struct dwarf2_cu
*cu
);
1341 static const char *namespace_name (struct die_info
*die
,
1342 int *is_anonymous
, struct dwarf2_cu
*);
1344 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
1346 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*,
1349 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
1350 struct dwarf2_cu
*);
1352 static struct die_info
*read_die_and_siblings_1
1353 (const struct die_reader_specs
*, const gdb_byte
*, const gdb_byte
**,
1356 static struct die_info
*read_die_and_siblings (const struct die_reader_specs
*,
1357 const gdb_byte
*info_ptr
,
1358 const gdb_byte
**new_info_ptr
,
1359 struct die_info
*parent
);
1361 static const gdb_byte
*read_full_die_1 (const struct die_reader_specs
*,
1362 struct die_info
**, const gdb_byte
*,
1365 static const gdb_byte
*read_full_die (const struct die_reader_specs
*,
1366 struct die_info
**, const gdb_byte
*);
1368 static void process_die (struct die_info
*, struct dwarf2_cu
*);
1370 static const char *dwarf2_canonicalize_name (const char *, struct dwarf2_cu
*,
1373 static const char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
1375 static const char *dwarf2_full_name (const char *name
,
1376 struct die_info
*die
,
1377 struct dwarf2_cu
*cu
);
1379 static const char *dwarf2_physname (const char *name
, struct die_info
*die
,
1380 struct dwarf2_cu
*cu
);
1382 static struct die_info
*dwarf2_extension (struct die_info
*die
,
1383 struct dwarf2_cu
**);
1385 static void dump_die_shallow (struct ui_file
*, int indent
, struct die_info
*);
1387 static void dump_die_for_error (struct die_info
*);
1389 static void dump_die_1 (struct ui_file
*, int level
, int max_level
,
1392 /*static*/ void dump_die (struct die_info
*, int max_level
);
1394 static void store_in_ref_table (struct die_info
*,
1395 struct dwarf2_cu
*);
1397 static struct die_info
*follow_die_ref_or_sig (struct die_info
*,
1398 const struct attribute
*,
1399 struct dwarf2_cu
**);
1401 static struct die_info
*follow_die_ref (struct die_info
*,
1402 const struct attribute
*,
1403 struct dwarf2_cu
**);
1405 static struct die_info
*follow_die_sig (struct die_info
*,
1406 const struct attribute
*,
1407 struct dwarf2_cu
**);
1409 static struct type
*get_signatured_type (struct die_info
*, ULONGEST
,
1410 struct dwarf2_cu
*);
1412 static struct type
*get_DW_AT_signature_type (struct die_info
*,
1413 const struct attribute
*,
1414 struct dwarf2_cu
*);
1416 static void load_full_type_unit (dwarf2_per_cu_data
*per_cu
,
1417 dwarf2_per_objfile
*per_objfile
);
1419 static void read_signatured_type (signatured_type
*sig_type
,
1420 dwarf2_per_objfile
*per_objfile
);
1422 static int attr_to_dynamic_prop (const struct attribute
*attr
,
1423 struct die_info
*die
, struct dwarf2_cu
*cu
,
1424 struct dynamic_prop
*prop
, struct type
*type
);
1426 /* memory allocation interface */
1428 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1430 static struct die_info
*dwarf_alloc_die (struct dwarf2_cu
*, int);
1432 static void dwarf_decode_macros (struct dwarf2_cu
*, unsigned int, int);
1434 static void fill_in_loclist_baton (struct dwarf2_cu
*cu
,
1435 struct dwarf2_loclist_baton
*baton
,
1436 const struct attribute
*attr
);
1438 static void dwarf2_symbol_mark_computed (const struct attribute
*attr
,
1440 struct dwarf2_cu
*cu
,
1443 static const gdb_byte
*skip_one_die (const struct die_reader_specs
*reader
,
1444 const gdb_byte
*info_ptr
,
1445 const struct abbrev_info
*abbrev
);
1447 static hashval_t
partial_die_hash (const void *item
);
1449 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1451 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1452 (sect_offset sect_off
, unsigned int offset_in_dwz
,
1453 dwarf2_per_objfile
*per_objfile
);
1455 static void prepare_one_comp_unit (struct dwarf2_cu
*cu
,
1456 struct die_info
*comp_unit_die
,
1457 enum language pretend_language
);
1459 static struct type
*set_die_type (struct die_info
*, struct type
*,
1460 struct dwarf2_cu
*, bool = false);
1462 static void create_all_comp_units (dwarf2_per_objfile
*per_objfile
);
1464 static void load_full_comp_unit (dwarf2_per_cu_data
*per_cu
,
1465 dwarf2_per_objfile
*per_objfile
,
1466 dwarf2_cu
*existing_cu
,
1468 enum language pretend_language
);
1470 static void process_full_comp_unit (dwarf2_cu
*cu
,
1471 enum language pretend_language
);
1473 static void process_full_type_unit (dwarf2_cu
*cu
,
1474 enum language pretend_language
);
1476 static struct type
*get_die_type_at_offset (sect_offset
,
1477 dwarf2_per_cu_data
*per_cu
,
1478 dwarf2_per_objfile
*per_objfile
);
1480 static struct type
*get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
1482 static void queue_comp_unit (dwarf2_per_cu_data
*per_cu
,
1483 dwarf2_per_objfile
*per_objfile
,
1484 enum language pretend_language
);
1486 static void process_queue (dwarf2_per_objfile
*per_objfile
);
1488 /* Class, the destructor of which frees all allocated queue entries. This
1489 will only have work to do if an error was thrown while processing the
1490 dwarf. If no error was thrown then the queue entries should have all
1491 been processed, and freed, as we went along. */
1493 class dwarf2_queue_guard
1496 explicit dwarf2_queue_guard (dwarf2_per_objfile
*per_objfile
)
1497 : m_per_objfile (per_objfile
)
1499 gdb_assert (!m_per_objfile
->per_bfd
->queue
.has_value ());
1501 m_per_objfile
->per_bfd
->queue
.emplace ();
1504 /* Free any entries remaining on the queue. There should only be
1505 entries left if we hit an error while processing the dwarf. */
1506 ~dwarf2_queue_guard ()
1508 gdb_assert (m_per_objfile
->per_bfd
->queue
.has_value ());
1510 m_per_objfile
->per_bfd
->queue
.reset ();
1513 DISABLE_COPY_AND_ASSIGN (dwarf2_queue_guard
);
1516 dwarf2_per_objfile
*m_per_objfile
;
1519 dwarf2_queue_item::~dwarf2_queue_item ()
1521 /* Anything still marked queued is likely to be in an
1522 inconsistent state, so discard it. */
1525 per_objfile
->remove_cu (per_cu
);
1530 /* See dwarf2/read.h. */
1533 dwarf2_per_cu_data_deleter::operator() (dwarf2_per_cu_data
*data
)
1535 if (data
->is_debug_types
)
1536 delete static_cast<signatured_type
*> (data
);
1541 /* The return type of find_file_and_directory. Note, the enclosed
1542 string pointers are only valid while this object is valid. */
1544 struct file_and_directory
1546 /* The filename. This is never NULL. */
1549 /* The compilation directory. NULL if not known. If we needed to
1550 compute a new string, it will be stored in the per-BFD string
1551 bcache; otherwise, points directly to the DW_AT_comp_dir string
1552 attribute owned by the obstack that owns the DIE. */
1553 const char *comp_dir
;
1556 static file_and_directory
find_file_and_directory (struct die_info
*die
,
1557 struct dwarf2_cu
*cu
);
1559 static const char *compute_include_file_name
1560 (const struct line_header
*lh
,
1561 const file_entry
&fe
,
1562 const file_and_directory
&cu_info
,
1563 gdb::unique_xmalloc_ptr
<char> *name_holder
);
1565 static htab_up
allocate_signatured_type_table ();
1567 static htab_up
allocate_dwo_unit_table ();
1569 static struct dwo_unit
*lookup_dwo_unit_in_dwp
1570 (dwarf2_per_objfile
*per_objfile
, struct dwp_file
*dwp_file
,
1571 const char *comp_dir
, ULONGEST signature
, int is_debug_types
);
1573 static struct dwp_file
*get_dwp_file (dwarf2_per_objfile
*per_objfile
);
1575 static struct dwo_unit
*lookup_dwo_comp_unit
1576 (dwarf2_cu
*cu
, const char *dwo_name
, const char *comp_dir
,
1577 ULONGEST signature
);
1579 static struct dwo_unit
*lookup_dwo_type_unit
1580 (dwarf2_cu
*cu
, const char *dwo_name
, const char *comp_dir
);
1582 static void queue_and_load_all_dwo_tus (dwarf2_cu
*cu
);
1584 /* A unique pointer to a dwo_file. */
1586 typedef std::unique_ptr
<struct dwo_file
> dwo_file_up
;
1588 static void process_cu_includes (dwarf2_per_objfile
*per_objfile
);
1590 static void check_producer (struct dwarf2_cu
*cu
);
1592 /* Various complaints about symbol reading that don't abort the process. */
1595 dwarf2_debug_line_missing_file_complaint (void)
1597 complaint (_(".debug_line section has line data without a file"));
1601 dwarf2_debug_line_missing_end_sequence_complaint (void)
1603 complaint (_(".debug_line section has line "
1604 "program sequence without an end"));
1608 dwarf2_complex_location_expr_complaint (void)
1610 complaint (_("location expression too complex"));
1614 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
1617 complaint (_("const value length mismatch for '%s', got %d, expected %d"),
1622 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
1624 complaint (_("invalid attribute class or form for '%s' in '%s'"),
1628 /* Hash function for line_header_hash. */
1631 line_header_hash (const struct line_header
*ofs
)
1633 return to_underlying (ofs
->sect_off
) ^ ofs
->offset_in_dwz
;
1636 /* Hash function for htab_create_alloc_ex for line_header_hash. */
1639 line_header_hash_voidp (const void *item
)
1641 const struct line_header
*ofs
= (const struct line_header
*) item
;
1643 return line_header_hash (ofs
);
1646 /* Equality function for line_header_hash. */
1649 line_header_eq_voidp (const void *item_lhs
, const void *item_rhs
)
1651 const struct line_header
*ofs_lhs
= (const struct line_header
*) item_lhs
;
1652 const struct line_header
*ofs_rhs
= (const struct line_header
*) item_rhs
;
1654 return (ofs_lhs
->sect_off
== ofs_rhs
->sect_off
1655 && ofs_lhs
->offset_in_dwz
== ofs_rhs
->offset_in_dwz
);
1660 /* An iterator for all_comp_units that is based on index. This
1661 approach makes it possible to iterate over all_comp_units safely,
1662 when some caller in the loop may add new units. */
1664 class all_comp_units_iterator
1668 all_comp_units_iterator (dwarf2_per_bfd
*per_bfd
, bool start
)
1669 : m_per_bfd (per_bfd
),
1670 m_index (start
? 0 : per_bfd
->all_comp_units
.size ())
1674 all_comp_units_iterator
&operator++ ()
1680 dwarf2_per_cu_data
*operator* () const
1682 return m_per_bfd
->get_cu (m_index
);
1685 bool operator== (const all_comp_units_iterator
&other
) const
1687 return m_index
== other
.m_index
;
1691 bool operator!= (const all_comp_units_iterator
&other
) const
1693 return m_index
!= other
.m_index
;
1698 dwarf2_per_bfd
*m_per_bfd
;
1702 /* A range adapter for the all_comp_units_iterator. */
1703 class all_comp_units_range
1707 all_comp_units_range (dwarf2_per_bfd
*per_bfd
)
1708 : m_per_bfd (per_bfd
)
1712 all_comp_units_iterator
begin ()
1714 return all_comp_units_iterator (m_per_bfd
, true);
1717 all_comp_units_iterator
end ()
1719 return all_comp_units_iterator (m_per_bfd
, false);
1724 dwarf2_per_bfd
*m_per_bfd
;
1727 /* See declaration. */
1729 dwarf2_per_bfd::dwarf2_per_bfd (bfd
*obfd
, const dwarf2_debug_sections
*names
,
1732 can_copy (can_copy_
)
1735 names
= &dwarf2_elf_names
;
1737 for (asection
*sec
= obfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
1738 locate_sections (obfd
, sec
, *names
);
1741 dwarf2_per_bfd::~dwarf2_per_bfd ()
1743 for (auto &per_cu
: all_comp_units
)
1745 per_cu
->imported_symtabs_free ();
1746 per_cu
->free_cached_file_names ();
1749 /* Everything else should be on this->obstack. */
1755 dwarf2_per_objfile::remove_all_cus ()
1757 gdb_assert (!this->per_bfd
->queue
.has_value ());
1759 for (auto pair
: m_dwarf2_cus
)
1762 m_dwarf2_cus
.clear ();
1765 /* A helper class that calls free_cached_comp_units on
1768 class free_cached_comp_units
1772 explicit free_cached_comp_units (dwarf2_per_objfile
*per_objfile
)
1773 : m_per_objfile (per_objfile
)
1777 ~free_cached_comp_units ()
1779 m_per_objfile
->remove_all_cus ();
1782 DISABLE_COPY_AND_ASSIGN (free_cached_comp_units
);
1786 dwarf2_per_objfile
*m_per_objfile
;
1792 dwarf2_per_objfile::symtab_set_p (const dwarf2_per_cu_data
*per_cu
) const
1794 if (per_cu
->index
< this->m_symtabs
.size ())
1795 return this->m_symtabs
[per_cu
->index
] != nullptr;
1802 dwarf2_per_objfile::get_symtab (const dwarf2_per_cu_data
*per_cu
) const
1804 if (per_cu
->index
< this->m_symtabs
.size ())
1805 return this->m_symtabs
[per_cu
->index
];
1812 dwarf2_per_objfile::set_symtab (const dwarf2_per_cu_data
*per_cu
,
1813 compunit_symtab
*symtab
)
1815 if (per_cu
->index
>= this->m_symtabs
.size ())
1816 this->m_symtabs
.resize (per_cu
->index
+ 1);
1817 gdb_assert (this->m_symtabs
[per_cu
->index
] == nullptr);
1818 this->m_symtabs
[per_cu
->index
] = symtab
;
1821 /* Try to locate the sections we need for DWARF 2 debugging
1822 information and return true if we have enough to do something.
1823 NAMES points to the dwarf2 section names, or is NULL if the standard
1824 ELF names are used. CAN_COPY is true for formats where symbol
1825 interposition is possible and so symbol values must follow copy
1826 relocation rules. */
1829 dwarf2_has_info (struct objfile
*objfile
,
1830 const struct dwarf2_debug_sections
*names
,
1833 if (objfile
->flags
& OBJF_READNEVER
)
1836 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
1838 if (per_objfile
== NULL
)
1840 dwarf2_per_bfd
*per_bfd
;
1842 /* We can share a "dwarf2_per_bfd" with other objfiles if the
1843 BFD doesn't require relocations.
1845 We don't share with objfiles for which -readnow was requested,
1846 because it would complicate things when loading the same BFD with
1847 -readnow and then without -readnow. */
1848 if (!gdb_bfd_requires_relocations (objfile
->obfd
)
1849 && (objfile
->flags
& OBJF_READNOW
) == 0)
1851 /* See if one has been created for this BFD yet. */
1852 per_bfd
= dwarf2_per_bfd_bfd_data_key
.get (objfile
->obfd
);
1854 if (per_bfd
== nullptr)
1856 /* No, create it now. */
1857 per_bfd
= new dwarf2_per_bfd (objfile
->obfd
, names
, can_copy
);
1858 dwarf2_per_bfd_bfd_data_key
.set (objfile
->obfd
, per_bfd
);
1863 /* No sharing possible, create one specifically for this objfile. */
1864 per_bfd
= new dwarf2_per_bfd (objfile
->obfd
, names
, can_copy
);
1865 dwarf2_per_bfd_objfile_data_key
.set (objfile
, per_bfd
);
1868 per_objfile
= dwarf2_objfile_data_key
.emplace (objfile
, objfile
, per_bfd
);
1871 return (!per_objfile
->per_bfd
->info
.is_virtual
1872 && per_objfile
->per_bfd
->info
.s
.section
!= NULL
1873 && !per_objfile
->per_bfd
->abbrev
.is_virtual
1874 && per_objfile
->per_bfd
->abbrev
.s
.section
!= NULL
);
1877 /* See declaration. */
1880 dwarf2_per_bfd::locate_sections (bfd
*abfd
, asection
*sectp
,
1881 const dwarf2_debug_sections
&names
)
1883 flagword aflag
= bfd_section_flags (sectp
);
1885 if ((aflag
& SEC_HAS_CONTENTS
) == 0)
1888 else if (elf_section_data (sectp
)->this_hdr
.sh_size
1889 > bfd_get_file_size (abfd
))
1891 bfd_size_type size
= elf_section_data (sectp
)->this_hdr
.sh_size
;
1892 warning (_("Discarding section %s which has a section size (%s"
1893 ") larger than the file size [in module %s]"),
1894 bfd_section_name (sectp
), phex_nz (size
, sizeof (size
)),
1895 bfd_get_filename (abfd
));
1897 else if (names
.info
.matches (sectp
->name
))
1899 this->info
.s
.section
= sectp
;
1900 this->info
.size
= bfd_section_size (sectp
);
1902 else if (names
.abbrev
.matches (sectp
->name
))
1904 this->abbrev
.s
.section
= sectp
;
1905 this->abbrev
.size
= bfd_section_size (sectp
);
1907 else if (names
.line
.matches (sectp
->name
))
1909 this->line
.s
.section
= sectp
;
1910 this->line
.size
= bfd_section_size (sectp
);
1912 else if (names
.loc
.matches (sectp
->name
))
1914 this->loc
.s
.section
= sectp
;
1915 this->loc
.size
= bfd_section_size (sectp
);
1917 else if (names
.loclists
.matches (sectp
->name
))
1919 this->loclists
.s
.section
= sectp
;
1920 this->loclists
.size
= bfd_section_size (sectp
);
1922 else if (names
.macinfo
.matches (sectp
->name
))
1924 this->macinfo
.s
.section
= sectp
;
1925 this->macinfo
.size
= bfd_section_size (sectp
);
1927 else if (names
.macro
.matches (sectp
->name
))
1929 this->macro
.s
.section
= sectp
;
1930 this->macro
.size
= bfd_section_size (sectp
);
1932 else if (names
.str
.matches (sectp
->name
))
1934 this->str
.s
.section
= sectp
;
1935 this->str
.size
= bfd_section_size (sectp
);
1937 else if (names
.str_offsets
.matches (sectp
->name
))
1939 this->str_offsets
.s
.section
= sectp
;
1940 this->str_offsets
.size
= bfd_section_size (sectp
);
1942 else if (names
.line_str
.matches (sectp
->name
))
1944 this->line_str
.s
.section
= sectp
;
1945 this->line_str
.size
= bfd_section_size (sectp
);
1947 else if (names
.addr
.matches (sectp
->name
))
1949 this->addr
.s
.section
= sectp
;
1950 this->addr
.size
= bfd_section_size (sectp
);
1952 else if (names
.frame
.matches (sectp
->name
))
1954 this->frame
.s
.section
= sectp
;
1955 this->frame
.size
= bfd_section_size (sectp
);
1957 else if (names
.eh_frame
.matches (sectp
->name
))
1959 this->eh_frame
.s
.section
= sectp
;
1960 this->eh_frame
.size
= bfd_section_size (sectp
);
1962 else if (names
.ranges
.matches (sectp
->name
))
1964 this->ranges
.s
.section
= sectp
;
1965 this->ranges
.size
= bfd_section_size (sectp
);
1967 else if (names
.rnglists
.matches (sectp
->name
))
1969 this->rnglists
.s
.section
= sectp
;
1970 this->rnglists
.size
= bfd_section_size (sectp
);
1972 else if (names
.types
.matches (sectp
->name
))
1974 struct dwarf2_section_info type_section
;
1976 memset (&type_section
, 0, sizeof (type_section
));
1977 type_section
.s
.section
= sectp
;
1978 type_section
.size
= bfd_section_size (sectp
);
1980 this->types
.push_back (type_section
);
1982 else if (names
.gdb_index
.matches (sectp
->name
))
1984 this->gdb_index
.s
.section
= sectp
;
1985 this->gdb_index
.size
= bfd_section_size (sectp
);
1987 else if (names
.debug_names
.matches (sectp
->name
))
1989 this->debug_names
.s
.section
= sectp
;
1990 this->debug_names
.size
= bfd_section_size (sectp
);
1992 else if (names
.debug_aranges
.matches (sectp
->name
))
1994 this->debug_aranges
.s
.section
= sectp
;
1995 this->debug_aranges
.size
= bfd_section_size (sectp
);
1998 if ((bfd_section_flags (sectp
) & (SEC_LOAD
| SEC_ALLOC
))
1999 && bfd_section_vma (sectp
) == 0)
2000 this->has_section_at_zero
= true;
2003 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
2007 dwarf2_get_section_info (struct objfile
*objfile
,
2008 enum dwarf2_section_enum sect
,
2009 asection
**sectp
, const gdb_byte
**bufp
,
2010 bfd_size_type
*sizep
)
2012 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
2013 struct dwarf2_section_info
*info
;
2015 /* We may see an objfile without any DWARF, in which case we just
2017 if (per_objfile
== NULL
)
2026 case DWARF2_DEBUG_FRAME
:
2027 info
= &per_objfile
->per_bfd
->frame
;
2029 case DWARF2_EH_FRAME
:
2030 info
= &per_objfile
->per_bfd
->eh_frame
;
2033 gdb_assert_not_reached ("unexpected section");
2036 info
->read (objfile
);
2038 *sectp
= info
->get_bfd_section ();
2039 *bufp
= info
->buffer
;
2040 *sizep
= info
->size
;
2044 /* DWARF quick_symbol_functions support. */
2046 /* TUs can share .debug_line entries, and there can be a lot more TUs than
2047 unique line tables, so we maintain a separate table of all .debug_line
2048 derived entries to support the sharing.
2049 All the quick functions need is the list of file names. We discard the
2050 line_header when we're done and don't need to record it here. */
2051 struct quick_file_names
2053 /* The data used to construct the hash key. */
2054 struct stmt_list_hash hash
;
2056 /* The number of entries in file_names, real_names. */
2057 unsigned int num_file_names
;
2059 /* The CU directory, as given by DW_AT_comp_dir. May be
2061 const char *comp_dir
;
2063 /* The file names from the line table, after being run through
2065 const char **file_names
;
2067 /* The file names from the line table after being run through
2068 gdb_realpath. These are computed lazily. */
2069 const char **real_names
;
2072 /* When using the index (and thus not using psymtabs), each CU has an
2073 object of this type. This is used to hold information needed by
2074 the various "quick" methods. */
2075 struct dwarf2_per_cu_quick_data
2077 /* The file table. This can be NULL if there was no file table
2078 or it's currently not read in.
2079 NOTE: This points into dwarf2_per_objfile->per_bfd->quick_file_names_table. */
2080 struct quick_file_names
*file_names
;
2082 /* A temporary mark bit used when iterating over all CUs in
2083 expand_symtabs_matching. */
2084 unsigned int mark
: 1;
2086 /* True if we've tried to read the file table. There will be no
2087 point in trying to read it again next time. */
2088 bool files_read
: 1;
2091 /* A subclass of psymbol_functions that arranges to read the DWARF
2092 partial symbols when needed. */
2093 struct lazy_dwarf_reader
: public psymbol_functions
2095 using psymbol_functions::psymbol_functions
;
2097 bool can_lazily_read_symbols () override
2102 void read_partial_symbols (struct objfile
*objfile
) override
2104 if (dwarf2_has_info (objfile
, nullptr))
2105 dwarf2_build_psymtabs (objfile
, this);
2109 static quick_symbol_functions_up
2110 make_lazy_dwarf_reader ()
2112 return quick_symbol_functions_up (new lazy_dwarf_reader
);
2115 struct dwarf2_base_index_functions
: public quick_symbol_functions
2117 bool has_symbols (struct objfile
*objfile
) override
;
2119 bool has_unexpanded_symtabs (struct objfile
*objfile
) override
;
2121 struct symtab
*find_last_source_symtab (struct objfile
*objfile
) override
;
2123 void forget_cached_source_info (struct objfile
*objfile
) override
;
2125 enum language
lookup_global_symbol_language (struct objfile
*objfile
,
2128 bool *symbol_found_p
) override
2130 *symbol_found_p
= false;
2131 return language_unknown
;
2134 void print_stats (struct objfile
*objfile
, bool print_bcache
) override
;
2136 void expand_all_symtabs (struct objfile
*objfile
) override
;
2138 struct compunit_symtab
*find_pc_sect_compunit_symtab
2139 (struct objfile
*objfile
, struct bound_minimal_symbol msymbol
,
2140 CORE_ADDR pc
, struct obj_section
*section
, int warn_if_readin
) override
;
2142 struct compunit_symtab
*find_compunit_symtab_by_address
2143 (struct objfile
*objfile
, CORE_ADDR address
) override
2148 void map_symbol_filenames (struct objfile
*objfile
,
2149 gdb::function_view
<symbol_filename_ftype
> fun
,
2150 bool need_fullname
) override
;
2153 struct dwarf2_gdb_index
: public dwarf2_base_index_functions
2155 void dump (struct objfile
*objfile
) override
;
2157 void expand_matching_symbols
2159 const lookup_name_info
&lookup_name
,
2162 symbol_compare_ftype
*ordered_compare
) override
;
2164 bool expand_symtabs_matching
2165 (struct objfile
*objfile
,
2166 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
2167 const lookup_name_info
*lookup_name
,
2168 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
2169 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
2170 block_search_flags search_flags
,
2172 enum search_domain kind
) override
;
2175 struct dwarf2_debug_names_index
: public dwarf2_base_index_functions
2177 void dump (struct objfile
*objfile
) override
;
2179 void expand_matching_symbols
2181 const lookup_name_info
&lookup_name
,
2184 symbol_compare_ftype
*ordered_compare
) override
;
2186 bool expand_symtabs_matching
2187 (struct objfile
*objfile
,
2188 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
2189 const lookup_name_info
*lookup_name
,
2190 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
2191 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
2192 block_search_flags search_flags
,
2194 enum search_domain kind
) override
;
2197 static quick_symbol_functions_up
2198 make_dwarf_gdb_index ()
2200 return quick_symbol_functions_up (new dwarf2_gdb_index
);
2203 static quick_symbol_functions_up
2204 make_dwarf_debug_names ()
2206 return quick_symbol_functions_up (new dwarf2_debug_names_index
);
2209 /* Utility hash function for a stmt_list_hash. */
2212 hash_stmt_list_entry (const struct stmt_list_hash
*stmt_list_hash
)
2216 if (stmt_list_hash
->dwo_unit
!= NULL
)
2217 v
+= (uintptr_t) stmt_list_hash
->dwo_unit
->dwo_file
;
2218 v
+= to_underlying (stmt_list_hash
->line_sect_off
);
2222 /* Utility equality function for a stmt_list_hash. */
2225 eq_stmt_list_entry (const struct stmt_list_hash
*lhs
,
2226 const struct stmt_list_hash
*rhs
)
2228 if ((lhs
->dwo_unit
!= NULL
) != (rhs
->dwo_unit
!= NULL
))
2230 if (lhs
->dwo_unit
!= NULL
2231 && lhs
->dwo_unit
->dwo_file
!= rhs
->dwo_unit
->dwo_file
)
2234 return lhs
->line_sect_off
== rhs
->line_sect_off
;
2237 /* Hash function for a quick_file_names. */
2240 hash_file_name_entry (const void *e
)
2242 const struct quick_file_names
*file_data
2243 = (const struct quick_file_names
*) e
;
2245 return hash_stmt_list_entry (&file_data
->hash
);
2248 /* Equality function for a quick_file_names. */
2251 eq_file_name_entry (const void *a
, const void *b
)
2253 const struct quick_file_names
*ea
= (const struct quick_file_names
*) a
;
2254 const struct quick_file_names
*eb
= (const struct quick_file_names
*) b
;
2256 return eq_stmt_list_entry (&ea
->hash
, &eb
->hash
);
2259 /* Create a quick_file_names hash table. */
2262 create_quick_file_names_table (unsigned int nr_initial_entries
)
2264 return htab_up (htab_create_alloc (nr_initial_entries
,
2265 hash_file_name_entry
, eq_file_name_entry
,
2266 nullptr, xcalloc
, xfree
));
2269 /* Read in CU (dwarf2_cu object) for PER_CU in the context of PER_OBJFILE. This
2270 function is unrelated to symtabs, symtab would have to be created afterwards.
2271 You should call age_cached_comp_units after processing the CU. */
2274 load_cu (dwarf2_per_cu_data
*per_cu
, dwarf2_per_objfile
*per_objfile
,
2277 if (per_cu
->is_debug_types
)
2278 load_full_type_unit (per_cu
, per_objfile
);
2280 load_full_comp_unit (per_cu
, per_objfile
, per_objfile
->get_cu (per_cu
),
2281 skip_partial
, language_minimal
);
2283 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
2285 return nullptr; /* Dummy CU. */
2287 dwarf2_find_base_address (cu
->dies
, cu
);
2292 /* Read in the symbols for PER_CU in the context of PER_OBJFILE. */
2295 dw2_do_instantiate_symtab (dwarf2_per_cu_data
*per_cu
,
2296 dwarf2_per_objfile
*per_objfile
, bool skip_partial
)
2298 /* Skip type_unit_groups, reading the type units they contain
2299 is handled elsewhere. */
2300 if (per_cu
->type_unit_group_p ())
2304 /* The destructor of dwarf2_queue_guard frees any entries left on
2305 the queue. After this point we're guaranteed to leave this function
2306 with the dwarf queue empty. */
2307 dwarf2_queue_guard
q_guard (per_objfile
);
2309 if (!per_objfile
->symtab_set_p (per_cu
))
2311 queue_comp_unit (per_cu
, per_objfile
, language_minimal
);
2312 dwarf2_cu
*cu
= load_cu (per_cu
, per_objfile
, skip_partial
);
2314 /* If we just loaded a CU from a DWO, and we're working with an index
2315 that may badly handle TUs, load all the TUs in that DWO as well.
2316 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
2317 if (!per_cu
->is_debug_types
2319 && cu
->dwo_unit
!= NULL
2320 && per_objfile
->per_bfd
->index_table
!= NULL
2321 && per_objfile
->per_bfd
->index_table
->version
<= 7
2322 /* DWP files aren't supported yet. */
2323 && get_dwp_file (per_objfile
) == NULL
)
2324 queue_and_load_all_dwo_tus (cu
);
2327 process_queue (per_objfile
);
2330 /* Age the cache, releasing compilation units that have not
2331 been used recently. */
2332 per_objfile
->age_comp_units ();
2335 /* Ensure that the symbols for PER_CU have been read in. DWARF2_PER_OBJFILE is
2336 the per-objfile for which this symtab is instantiated.
2338 Returns the resulting symbol table. */
2340 static struct compunit_symtab
*
2341 dw2_instantiate_symtab (dwarf2_per_cu_data
*per_cu
,
2342 dwarf2_per_objfile
*per_objfile
,
2345 gdb_assert (per_objfile
->per_bfd
->using_index
);
2347 if (!per_objfile
->symtab_set_p (per_cu
))
2349 free_cached_comp_units
freer (per_objfile
);
2350 scoped_restore decrementer
= increment_reading_symtab ();
2351 dw2_do_instantiate_symtab (per_cu
, per_objfile
, skip_partial
);
2352 process_cu_includes (per_objfile
);
2355 return per_objfile
->get_symtab (per_cu
);
2360 dwarf2_per_cu_data_up
2361 dwarf2_per_bfd::allocate_per_cu ()
2363 dwarf2_per_cu_data_up
result (new dwarf2_per_cu_data
);
2364 result
->per_bfd
= this;
2365 result
->index
= all_comp_units
.size ();
2372 dwarf2_per_bfd::allocate_signatured_type (ULONGEST signature
)
2374 signatured_type_up
result (new signatured_type (signature
));
2375 result
->per_bfd
= this;
2376 result
->index
= all_comp_units
.size ();
2377 result
->is_debug_types
= true;
2382 /* Return a new dwarf2_per_cu_data allocated on the per-bfd
2383 obstack, and constructed with the specified field values. */
2385 static dwarf2_per_cu_data_up
2386 create_cu_from_index_list (dwarf2_per_bfd
*per_bfd
,
2387 struct dwarf2_section_info
*section
,
2389 sect_offset sect_off
, ULONGEST length
)
2391 dwarf2_per_cu_data_up the_cu
= per_bfd
->allocate_per_cu ();
2392 the_cu
->sect_off
= sect_off
;
2393 the_cu
->length
= length
;
2394 the_cu
->section
= section
;
2395 the_cu
->v
.quick
= OBSTACK_ZALLOC (&per_bfd
->obstack
,
2396 struct dwarf2_per_cu_quick_data
);
2397 the_cu
->is_dwz
= is_dwz
;
2401 /* A helper for create_cus_from_index that handles a given list of
2405 create_cus_from_index_list (dwarf2_per_bfd
*per_bfd
,
2406 const gdb_byte
*cu_list
, offset_type n_elements
,
2407 struct dwarf2_section_info
*section
,
2410 for (offset_type i
= 0; i
< n_elements
; i
+= 2)
2412 gdb_static_assert (sizeof (ULONGEST
) >= 8);
2414 sect_offset sect_off
2415 = (sect_offset
) extract_unsigned_integer (cu_list
, 8, BFD_ENDIAN_LITTLE
);
2416 ULONGEST length
= extract_unsigned_integer (cu_list
+ 8, 8, BFD_ENDIAN_LITTLE
);
2419 dwarf2_per_cu_data_up per_cu
2420 = create_cu_from_index_list (per_bfd
, section
, is_dwz
, sect_off
,
2422 per_bfd
->all_comp_units
.push_back (std::move (per_cu
));
2426 /* Read the CU list from the mapped index, and use it to create all
2427 the CU objects for PER_BFD. */
2430 create_cus_from_index (dwarf2_per_bfd
*per_bfd
,
2431 const gdb_byte
*cu_list
, offset_type cu_list_elements
,
2432 const gdb_byte
*dwz_list
, offset_type dwz_elements
)
2434 gdb_assert (per_bfd
->all_comp_units
.empty ());
2435 per_bfd
->all_comp_units
.reserve ((cu_list_elements
+ dwz_elements
) / 2);
2437 create_cus_from_index_list (per_bfd
, cu_list
, cu_list_elements
,
2440 if (dwz_elements
== 0)
2443 dwz_file
*dwz
= dwarf2_get_dwz_file (per_bfd
);
2444 create_cus_from_index_list (per_bfd
, dwz_list
, dwz_elements
,
2448 /* Create the signatured type hash table from the index. */
2451 create_signatured_type_table_from_index
2452 (dwarf2_per_bfd
*per_bfd
, struct dwarf2_section_info
*section
,
2453 const gdb_byte
*bytes
, offset_type elements
)
2455 htab_up sig_types_hash
= allocate_signatured_type_table ();
2457 for (offset_type i
= 0; i
< elements
; i
+= 3)
2459 signatured_type_up sig_type
;
2462 cu_offset type_offset_in_tu
;
2464 gdb_static_assert (sizeof (ULONGEST
) >= 8);
2465 sect_offset sect_off
2466 = (sect_offset
) extract_unsigned_integer (bytes
, 8, BFD_ENDIAN_LITTLE
);
2468 = (cu_offset
) extract_unsigned_integer (bytes
+ 8, 8,
2470 signature
= extract_unsigned_integer (bytes
+ 16, 8, BFD_ENDIAN_LITTLE
);
2473 sig_type
= per_bfd
->allocate_signatured_type (signature
);
2474 sig_type
->type_offset_in_tu
= type_offset_in_tu
;
2475 sig_type
->section
= section
;
2476 sig_type
->sect_off
= sect_off
;
2478 = OBSTACK_ZALLOC (&per_bfd
->obstack
,
2479 struct dwarf2_per_cu_quick_data
);
2481 slot
= htab_find_slot (sig_types_hash
.get (), sig_type
.get (), INSERT
);
2482 *slot
= sig_type
.get ();
2484 per_bfd
->all_comp_units
.emplace_back (sig_type
.release ());
2487 per_bfd
->signatured_types
= std::move (sig_types_hash
);
2490 /* Create the signatured type hash table from .debug_names. */
2493 create_signatured_type_table_from_debug_names
2494 (dwarf2_per_objfile
*per_objfile
,
2495 const mapped_debug_names
&map
,
2496 struct dwarf2_section_info
*section
,
2497 struct dwarf2_section_info
*abbrev_section
)
2499 struct objfile
*objfile
= per_objfile
->objfile
;
2501 section
->read (objfile
);
2502 abbrev_section
->read (objfile
);
2504 htab_up sig_types_hash
= allocate_signatured_type_table ();
2506 for (uint32_t i
= 0; i
< map
.tu_count
; ++i
)
2508 signatured_type_up sig_type
;
2511 sect_offset sect_off
2512 = (sect_offset
) (extract_unsigned_integer
2513 (map
.tu_table_reordered
+ i
* map
.offset_size
,
2515 map
.dwarf5_byte_order
));
2517 comp_unit_head cu_header
;
2518 read_and_check_comp_unit_head (per_objfile
, &cu_header
, section
,
2520 section
->buffer
+ to_underlying (sect_off
),
2523 sig_type
= per_objfile
->per_bfd
->allocate_signatured_type
2524 (cu_header
.signature
);
2525 sig_type
->type_offset_in_tu
= cu_header
.type_cu_offset_in_tu
;
2526 sig_type
->section
= section
;
2527 sig_type
->sect_off
= sect_off
;
2529 = OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
,
2530 struct dwarf2_per_cu_quick_data
);
2532 slot
= htab_find_slot (sig_types_hash
.get (), sig_type
.get (), INSERT
);
2533 *slot
= sig_type
.get ();
2535 per_objfile
->per_bfd
->all_comp_units
.emplace_back (sig_type
.release ());
2538 per_objfile
->per_bfd
->signatured_types
= std::move (sig_types_hash
);
2541 /* Read the address map data from the mapped index, and use it to
2542 populate the psymtabs_addrmap. */
2545 create_addrmap_from_index (dwarf2_per_objfile
*per_objfile
,
2546 struct mapped_index
*index
)
2548 struct objfile
*objfile
= per_objfile
->objfile
;
2549 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
2550 struct gdbarch
*gdbarch
= objfile
->arch ();
2551 const gdb_byte
*iter
, *end
;
2552 struct addrmap
*mutable_map
;
2555 auto_obstack temp_obstack
;
2557 mutable_map
= addrmap_create_mutable (&temp_obstack
);
2559 iter
= index
->address_table
.data ();
2560 end
= iter
+ index
->address_table
.size ();
2562 baseaddr
= objfile
->text_section_offset ();
2566 ULONGEST hi
, lo
, cu_index
;
2567 lo
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
2569 hi
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
2571 cu_index
= extract_unsigned_integer (iter
, 4, BFD_ENDIAN_LITTLE
);
2576 complaint (_(".gdb_index address table has invalid range (%s - %s)"),
2577 hex_string (lo
), hex_string (hi
));
2581 if (cu_index
>= per_bfd
->all_comp_units
.size ())
2583 complaint (_(".gdb_index address table has invalid CU number %u"),
2584 (unsigned) cu_index
);
2588 lo
= gdbarch_adjust_dwarf2_addr (gdbarch
, lo
+ baseaddr
) - baseaddr
;
2589 hi
= gdbarch_adjust_dwarf2_addr (gdbarch
, hi
+ baseaddr
) - baseaddr
;
2590 addrmap_set_empty (mutable_map
, lo
, hi
- 1,
2591 per_bfd
->get_cu (cu_index
));
2594 per_bfd
->index_addrmap
= addrmap_create_fixed (mutable_map
,
2598 /* Read the address map data from DWARF-5 .debug_aranges, and use it to
2599 populate the psymtabs_addrmap. */
2602 create_addrmap_from_aranges (dwarf2_per_objfile
*per_objfile
,
2603 struct dwarf2_section_info
*section
)
2605 struct objfile
*objfile
= per_objfile
->objfile
;
2606 bfd
*abfd
= objfile
->obfd
;
2607 struct gdbarch
*gdbarch
= objfile
->arch ();
2608 const CORE_ADDR baseaddr
= objfile
->text_section_offset ();
2609 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
2611 auto_obstack temp_obstack
;
2612 addrmap
*mutable_map
= addrmap_create_mutable (&temp_obstack
);
2614 std::unordered_map
<sect_offset
,
2615 dwarf2_per_cu_data
*,
2616 gdb::hash_enum
<sect_offset
>>
2617 debug_info_offset_to_per_cu
;
2618 for (const auto &per_cu
: per_bfd
->all_comp_units
)
2620 /* A TU will not need aranges, and skipping them here is an easy
2621 way of ignoring .debug_types -- and possibly seeing a
2622 duplicate section offset -- entirely. */
2623 if (per_cu
->is_debug_types
)
2626 const auto insertpair
2627 = debug_info_offset_to_per_cu
.emplace (per_cu
->sect_off
,
2629 if (!insertpair
.second
)
2631 warning (_("Section .debug_aranges in %s has duplicate "
2632 "debug_info_offset %s, ignoring .debug_aranges."),
2633 objfile_name (objfile
), sect_offset_str (per_cu
->sect_off
));
2638 section
->read (objfile
);
2640 const bfd_endian dwarf5_byte_order
= gdbarch_byte_order (gdbarch
);
2642 const gdb_byte
*addr
= section
->buffer
;
2644 while (addr
< section
->buffer
+ section
->size
)
2646 const gdb_byte
*const entry_addr
= addr
;
2647 unsigned int bytes_read
;
2649 const LONGEST entry_length
= read_initial_length (abfd
, addr
,
2653 const gdb_byte
*const entry_end
= addr
+ entry_length
;
2654 const bool dwarf5_is_dwarf64
= bytes_read
!= 4;
2655 const uint8_t offset_size
= dwarf5_is_dwarf64
? 8 : 4;
2656 if (addr
+ entry_length
> section
->buffer
+ section
->size
)
2658 warning (_("Section .debug_aranges in %s entry at offset %s "
2659 "length %s exceeds section length %s, "
2660 "ignoring .debug_aranges."),
2661 objfile_name (objfile
),
2662 plongest (entry_addr
- section
->buffer
),
2663 plongest (bytes_read
+ entry_length
),
2664 pulongest (section
->size
));
2668 /* The version number. */
2669 const uint16_t version
= read_2_bytes (abfd
, addr
);
2673 warning (_("Section .debug_aranges in %s entry at offset %s "
2674 "has unsupported version %d, ignoring .debug_aranges."),
2675 objfile_name (objfile
),
2676 plongest (entry_addr
- section
->buffer
), version
);
2680 const uint64_t debug_info_offset
2681 = extract_unsigned_integer (addr
, offset_size
, dwarf5_byte_order
);
2682 addr
+= offset_size
;
2683 const auto per_cu_it
2684 = debug_info_offset_to_per_cu
.find (sect_offset (debug_info_offset
));
2685 if (per_cu_it
== debug_info_offset_to_per_cu
.cend ())
2687 warning (_("Section .debug_aranges in %s entry at offset %s "
2688 "debug_info_offset %s does not exists, "
2689 "ignoring .debug_aranges."),
2690 objfile_name (objfile
),
2691 plongest (entry_addr
- section
->buffer
),
2692 pulongest (debug_info_offset
));
2695 dwarf2_per_cu_data
*const per_cu
= per_cu_it
->second
;
2697 const uint8_t address_size
= *addr
++;
2698 if (address_size
< 1 || address_size
> 8)
2700 warning (_("Section .debug_aranges in %s entry at offset %s "
2701 "address_size %u is invalid, ignoring .debug_aranges."),
2702 objfile_name (objfile
),
2703 plongest (entry_addr
- section
->buffer
), address_size
);
2707 const uint8_t segment_selector_size
= *addr
++;
2708 if (segment_selector_size
!= 0)
2710 warning (_("Section .debug_aranges in %s entry at offset %s "
2711 "segment_selector_size %u is not supported, "
2712 "ignoring .debug_aranges."),
2713 objfile_name (objfile
),
2714 plongest (entry_addr
- section
->buffer
),
2715 segment_selector_size
);
2719 /* Must pad to an alignment boundary that is twice the address
2720 size. It is undocumented by the DWARF standard but GCC does
2721 use it. However, not every compiler does this. We can see
2722 whether it has happened by looking at the total length of the
2723 contents of the aranges for this CU -- it if isn't a multiple
2724 of twice the address size, then we skip any leftover
2726 addr
+= (entry_end
- addr
) % (2 * address_size
);
2730 if (addr
+ 2 * address_size
> entry_end
)
2732 warning (_("Section .debug_aranges in %s entry at offset %s "
2733 "address list is not properly terminated, "
2734 "ignoring .debug_aranges."),
2735 objfile_name (objfile
),
2736 plongest (entry_addr
- section
->buffer
));
2739 ULONGEST start
= extract_unsigned_integer (addr
, address_size
,
2741 addr
+= address_size
;
2742 ULONGEST length
= extract_unsigned_integer (addr
, address_size
,
2744 addr
+= address_size
;
2745 if (start
== 0 && length
== 0)
2747 if (start
== 0 && !per_bfd
->has_section_at_zero
)
2749 /* Symbol was eliminated due to a COMDAT group. */
2752 ULONGEST end
= start
+ length
;
2753 start
= (gdbarch_adjust_dwarf2_addr (gdbarch
, start
+ baseaddr
)
2755 end
= (gdbarch_adjust_dwarf2_addr (gdbarch
, end
+ baseaddr
)
2757 addrmap_set_empty (mutable_map
, start
, end
- 1, per_cu
);
2761 per_bfd
->index_addrmap
= addrmap_create_fixed (mutable_map
,
2765 /* A helper function that reads the .gdb_index from BUFFER and fills
2766 in MAP. FILENAME is the name of the file containing the data;
2767 it is used for error reporting. DEPRECATED_OK is true if it is
2768 ok to use deprecated sections.
2770 CU_LIST, CU_LIST_ELEMENTS, TYPES_LIST, and TYPES_LIST_ELEMENTS are
2771 out parameters that are filled in with information about the CU and
2772 TU lists in the section.
2774 Returns true if all went well, false otherwise. */
2777 read_gdb_index_from_buffer (const char *filename
,
2779 gdb::array_view
<const gdb_byte
> buffer
,
2780 struct mapped_index
*map
,
2781 const gdb_byte
**cu_list
,
2782 offset_type
*cu_list_elements
,
2783 const gdb_byte
**types_list
,
2784 offset_type
*types_list_elements
)
2786 const gdb_byte
*addr
= &buffer
[0];
2787 offset_view
metadata (buffer
);
2789 /* Version check. */
2790 offset_type version
= metadata
[0];
2791 /* Versions earlier than 3 emitted every copy of a psymbol. This
2792 causes the index to behave very poorly for certain requests. Version 3
2793 contained incomplete addrmap. So, it seems better to just ignore such
2797 static int warning_printed
= 0;
2798 if (!warning_printed
)
2800 warning (_("Skipping obsolete .gdb_index section in %s."),
2802 warning_printed
= 1;
2806 /* Index version 4 uses a different hash function than index version
2809 Versions earlier than 6 did not emit psymbols for inlined
2810 functions. Using these files will cause GDB not to be able to
2811 set breakpoints on inlined functions by name, so we ignore these
2812 indices unless the user has done
2813 "set use-deprecated-index-sections on". */
2814 if (version
< 6 && !deprecated_ok
)
2816 static int warning_printed
= 0;
2817 if (!warning_printed
)
2820 Skipping deprecated .gdb_index section in %s.\n\
2821 Do \"set use-deprecated-index-sections on\" before the file is read\n\
2822 to use the section anyway."),
2824 warning_printed
= 1;
2828 /* Version 7 indices generated by gold refer to the CU for a symbol instead
2829 of the TU (for symbols coming from TUs),
2830 http://sourceware.org/bugzilla/show_bug.cgi?id=15021.
2831 Plus gold-generated indices can have duplicate entries for global symbols,
2832 http://sourceware.org/bugzilla/show_bug.cgi?id=15646.
2833 These are just performance bugs, and we can't distinguish gdb-generated
2834 indices from gold-generated ones, so issue no warning here. */
2836 /* Indexes with higher version than the one supported by GDB may be no
2837 longer backward compatible. */
2841 map
->version
= version
;
2844 *cu_list
= addr
+ metadata
[i
];
2845 *cu_list_elements
= (metadata
[i
+ 1] - metadata
[i
]) / 8;
2848 *types_list
= addr
+ metadata
[i
];
2849 *types_list_elements
= (metadata
[i
+ 1] - metadata
[i
]) / 8;
2852 const gdb_byte
*address_table
= addr
+ metadata
[i
];
2853 const gdb_byte
*address_table_end
= addr
+ metadata
[i
+ 1];
2855 = gdb::array_view
<const gdb_byte
> (address_table
, address_table_end
);
2858 const gdb_byte
*symbol_table
= addr
+ metadata
[i
];
2859 const gdb_byte
*symbol_table_end
= addr
+ metadata
[i
+ 1];
2861 = offset_view (gdb::array_view
<const gdb_byte
> (symbol_table
,
2865 map
->constant_pool
= buffer
.slice (metadata
[i
]);
2867 if (map
->constant_pool
.empty () && !map
->symbol_table
.empty ())
2869 /* An empty constant pool implies that all symbol table entries are
2870 empty. Make map->symbol_table.empty () == true. */
2872 = offset_view (gdb::array_view
<const gdb_byte
> (symbol_table
,
2879 /* Callback types for dwarf2_read_gdb_index. */
2881 typedef gdb::function_view
2882 <gdb::array_view
<const gdb_byte
>(objfile
*, dwarf2_per_bfd
*)>
2883 get_gdb_index_contents_ftype
;
2884 typedef gdb::function_view
2885 <gdb::array_view
<const gdb_byte
>(objfile
*, dwz_file
*)>
2886 get_gdb_index_contents_dwz_ftype
;
2888 /* Read .gdb_index. If everything went ok, initialize the "quick"
2889 elements of all the CUs and return 1. Otherwise, return 0. */
2892 dwarf2_read_gdb_index
2893 (dwarf2_per_objfile
*per_objfile
,
2894 get_gdb_index_contents_ftype get_gdb_index_contents
,
2895 get_gdb_index_contents_dwz_ftype get_gdb_index_contents_dwz
)
2897 const gdb_byte
*cu_list
, *types_list
, *dwz_list
= NULL
;
2898 offset_type cu_list_elements
, types_list_elements
, dwz_list_elements
= 0;
2899 struct dwz_file
*dwz
;
2900 struct objfile
*objfile
= per_objfile
->objfile
;
2901 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
2903 gdb::array_view
<const gdb_byte
> main_index_contents
2904 = get_gdb_index_contents (objfile
, per_bfd
);
2906 if (main_index_contents
.empty ())
2909 std::unique_ptr
<struct mapped_index
> map (new struct mapped_index
);
2910 if (!read_gdb_index_from_buffer (objfile_name (objfile
),
2911 use_deprecated_index_sections
,
2912 main_index_contents
, map
.get (), &cu_list
,
2913 &cu_list_elements
, &types_list
,
2914 &types_list_elements
))
2917 /* Don't use the index if it's empty. */
2918 if (map
->symbol_table
.empty ())
2921 /* If there is a .dwz file, read it so we can get its CU list as
2923 dwz
= dwarf2_get_dwz_file (per_bfd
);
2926 struct mapped_index dwz_map
;
2927 const gdb_byte
*dwz_types_ignore
;
2928 offset_type dwz_types_elements_ignore
;
2930 gdb::array_view
<const gdb_byte
> dwz_index_content
2931 = get_gdb_index_contents_dwz (objfile
, dwz
);
2933 if (dwz_index_content
.empty ())
2936 if (!read_gdb_index_from_buffer (bfd_get_filename (dwz
->dwz_bfd
.get ()),
2937 1, dwz_index_content
, &dwz_map
,
2938 &dwz_list
, &dwz_list_elements
,
2940 &dwz_types_elements_ignore
))
2942 warning (_("could not read '.gdb_index' section from %s; skipping"),
2943 bfd_get_filename (dwz
->dwz_bfd
.get ()));
2948 create_cus_from_index (per_bfd
, cu_list
, cu_list_elements
, dwz_list
,
2951 if (types_list_elements
)
2953 /* We can only handle a single .debug_types when we have an
2955 if (per_bfd
->types
.size () != 1)
2958 dwarf2_section_info
*section
= &per_bfd
->types
[0];
2960 create_signatured_type_table_from_index (per_bfd
, section
, types_list
,
2961 types_list_elements
);
2964 create_addrmap_from_index (per_objfile
, map
.get ());
2966 per_bfd
->index_table
= std::move (map
);
2967 per_bfd
->using_index
= 1;
2968 per_bfd
->quick_file_names_table
=
2969 create_quick_file_names_table (per_bfd
->all_comp_units
.size ());
2974 /* die_reader_func for dw2_get_file_names. */
2977 dw2_get_file_names_reader (const struct die_reader_specs
*reader
,
2978 struct die_info
*comp_unit_die
)
2980 struct dwarf2_cu
*cu
= reader
->cu
;
2981 struct dwarf2_per_cu_data
*this_cu
= cu
->per_cu
;
2982 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
2983 struct dwarf2_per_cu_data
*lh_cu
;
2984 struct attribute
*attr
;
2986 struct quick_file_names
*qfn
;
2988 gdb_assert (! this_cu
->is_debug_types
);
2990 this_cu
->v
.quick
->files_read
= true;
2991 /* Our callers never want to match partial units -- instead they
2992 will match the enclosing full CU. */
2993 if (comp_unit_die
->tag
== DW_TAG_partial_unit
)
3000 sect_offset line_offset
{};
3002 attr
= dwarf2_attr (comp_unit_die
, DW_AT_stmt_list
, cu
);
3003 if (attr
!= nullptr && attr
->form_is_unsigned ())
3005 struct quick_file_names find_entry
;
3007 line_offset
= (sect_offset
) attr
->as_unsigned ();
3009 /* We may have already read in this line header (TU line header sharing).
3010 If we have we're done. */
3011 find_entry
.hash
.dwo_unit
= cu
->dwo_unit
;
3012 find_entry
.hash
.line_sect_off
= line_offset
;
3013 slot
= htab_find_slot (per_objfile
->per_bfd
->quick_file_names_table
.get (),
3014 &find_entry
, INSERT
);
3017 lh_cu
->v
.quick
->file_names
= (struct quick_file_names
*) *slot
;
3021 lh
= dwarf_decode_line_header (line_offset
, cu
);
3024 file_and_directory fnd
= find_file_and_directory (comp_unit_die
, cu
);
3027 if (strcmp (fnd
.name
, "<unknown>") != 0)
3029 else if (lh
== nullptr)
3032 qfn
= XOBNEW (&per_objfile
->per_bfd
->obstack
, struct quick_file_names
);
3033 qfn
->hash
.dwo_unit
= cu
->dwo_unit
;
3034 qfn
->hash
.line_sect_off
= line_offset
;
3035 /* There may not be a DW_AT_stmt_list. */
3036 if (slot
!= nullptr)
3039 std::vector
<const char *> include_names
;
3042 for (const auto &entry
: lh
->file_names ())
3044 gdb::unique_xmalloc_ptr
<char> name_holder
;
3045 const char *include_name
=
3046 compute_include_file_name (lh
.get (), entry
, fnd
, &name_holder
);
3047 if (include_name
!= nullptr)
3049 include_name
= per_objfile
->objfile
->intern (include_name
);
3050 include_names
.push_back (include_name
);
3055 qfn
->num_file_names
= offset
+ include_names
.size ();
3056 qfn
->comp_dir
= fnd
.comp_dir
;
3058 XOBNEWVEC (&per_objfile
->per_bfd
->obstack
, const char *,
3059 qfn
->num_file_names
);
3061 qfn
->file_names
[0] = xstrdup (fnd
.name
);
3063 if (!include_names
.empty ())
3064 memcpy (&qfn
->file_names
[offset
], include_names
.data (),
3065 include_names
.size () * sizeof (const char *));
3067 qfn
->real_names
= NULL
;
3069 lh_cu
->v
.quick
->file_names
= qfn
;
3072 /* A helper for the "quick" functions which attempts to read the line
3073 table for THIS_CU. */
3075 static struct quick_file_names
*
3076 dw2_get_file_names (dwarf2_per_cu_data
*this_cu
,
3077 dwarf2_per_objfile
*per_objfile
)
3079 /* This should never be called for TUs. */
3080 gdb_assert (! this_cu
->is_debug_types
);
3081 /* Nor type unit groups. */
3082 gdb_assert (! this_cu
->type_unit_group_p ());
3084 if (this_cu
->v
.quick
->files_read
)
3085 return this_cu
->v
.quick
->file_names
;
3087 cutu_reader
reader (this_cu
, per_objfile
);
3088 if (!reader
.dummy_p
)
3089 dw2_get_file_names_reader (&reader
, reader
.comp_unit_die
);
3091 return this_cu
->v
.quick
->file_names
;
3094 /* A helper for the "quick" functions which computes and caches the
3095 real path for a given file name from the line table. */
3098 dw2_get_real_path (dwarf2_per_objfile
*per_objfile
,
3099 struct quick_file_names
*qfn
, int index
)
3101 if (qfn
->real_names
== NULL
)
3102 qfn
->real_names
= OBSTACK_CALLOC (&per_objfile
->per_bfd
->obstack
,
3103 qfn
->num_file_names
, const char *);
3105 if (qfn
->real_names
[index
] == NULL
)
3107 const char *dirname
= nullptr;
3109 if (!IS_ABSOLUTE_PATH (qfn
->file_names
[index
]))
3110 dirname
= qfn
->comp_dir
;
3112 gdb::unique_xmalloc_ptr
<char> fullname
;
3113 fullname
= find_source_or_rewrite (qfn
->file_names
[index
], dirname
);
3115 qfn
->real_names
[index
] = fullname
.release ();
3118 return qfn
->real_names
[index
];
3122 dwarf2_base_index_functions::find_last_source_symtab (struct objfile
*objfile
)
3124 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3125 dwarf2_per_cu_data
*dwarf_cu
3126 = per_objfile
->per_bfd
->all_comp_units
.back ().get ();
3127 compunit_symtab
*cust
= dw2_instantiate_symtab (dwarf_cu
, per_objfile
, false);
3132 return compunit_primary_filetab (cust
);
3138 dwarf2_per_cu_data::free_cached_file_names ()
3140 if (per_bfd
== nullptr || !per_bfd
->using_index
|| v
.quick
== nullptr)
3143 struct quick_file_names
*file_data
= v
.quick
->file_names
;
3144 if (file_data
!= nullptr && file_data
->real_names
!= nullptr)
3146 for (int i
= 0; i
< file_data
->num_file_names
; ++i
)
3148 xfree ((void *) file_data
->real_names
[i
]);
3149 file_data
->real_names
[i
] = nullptr;
3155 dwarf2_base_index_functions::forget_cached_source_info
3156 (struct objfile
*objfile
)
3158 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3160 for (auto &per_cu
: per_objfile
->per_bfd
->all_comp_units
)
3161 per_cu
->free_cached_file_names ();
3164 /* Struct used to manage iterating over all CUs looking for a symbol. */
3166 struct dw2_symtab_iterator
3168 /* The dwarf2_per_objfile owning the CUs we are iterating on. */
3169 dwarf2_per_objfile
*per_objfile
;
3170 /* If set, only look for symbols that match that block. Valid values are
3171 GLOBAL_BLOCK and STATIC_BLOCK. */
3172 gdb::optional
<block_enum
> block_index
;
3173 /* The kind of symbol we're looking for. */
3175 /* The list of CUs from the index entry of the symbol,
3176 or NULL if not found. */
3178 /* The next element in VEC to look at. */
3180 /* The number of elements in VEC, or zero if there is no match. */
3182 /* Have we seen a global version of the symbol?
3183 If so we can ignore all further global instances.
3184 This is to work around gold/15646, inefficient gold-generated
3189 /* Initialize the index symtab iterator ITER, offset_type NAMEI variant. */
3192 dw2_symtab_iter_init (struct dw2_symtab_iterator
*iter
,
3193 dwarf2_per_objfile
*per_objfile
,
3194 gdb::optional
<block_enum
> block_index
,
3195 domain_enum domain
, offset_type namei
)
3197 iter
->per_objfile
= per_objfile
;
3198 iter
->block_index
= block_index
;
3199 iter
->domain
= domain
;
3201 iter
->global_seen
= 0;
3205 mapped_index
*index
= per_objfile
->per_bfd
->index_table
.get ();
3206 /* index is NULL if OBJF_READNOW. */
3210 gdb_assert (!index
->symbol_name_slot_invalid (namei
));
3211 offset_type vec_idx
= index
->symbol_vec_index (namei
);
3213 iter
->vec
= offset_view (index
->constant_pool
.slice (vec_idx
));
3214 iter
->length
= iter
->vec
[0];
3217 /* Return the next matching CU or NULL if there are no more. */
3219 static struct dwarf2_per_cu_data
*
3220 dw2_symtab_iter_next (struct dw2_symtab_iterator
*iter
)
3222 dwarf2_per_objfile
*per_objfile
= iter
->per_objfile
;
3224 for ( ; iter
->next
< iter
->length
; ++iter
->next
)
3226 offset_type cu_index_and_attrs
= iter
->vec
[iter
->next
+ 1];
3227 offset_type cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
3228 gdb_index_symbol_kind symbol_kind
=
3229 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
3230 /* Only check the symbol attributes if they're present.
3231 Indices prior to version 7 don't record them,
3232 and indices >= 7 may elide them for certain symbols
3233 (gold does this). */
3235 (per_objfile
->per_bfd
->index_table
->version
>= 7
3236 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_NONE
);
3238 /* Don't crash on bad data. */
3239 if (cu_index
>= per_objfile
->per_bfd
->all_comp_units
.size ())
3241 complaint (_(".gdb_index entry has bad CU index"
3242 " [in module %s]"), objfile_name (per_objfile
->objfile
));
3246 dwarf2_per_cu_data
*per_cu
= per_objfile
->per_bfd
->get_cu (cu_index
);
3248 /* Skip if already read in. */
3249 if (per_objfile
->symtab_set_p (per_cu
))
3252 /* Check static vs global. */
3255 bool is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs
);
3257 if (iter
->block_index
.has_value ())
3259 bool want_static
= *iter
->block_index
== STATIC_BLOCK
;
3261 if (is_static
!= want_static
)
3265 /* Work around gold/15646. */
3267 && symbol_kind
== GDB_INDEX_SYMBOL_KIND_TYPE
)
3269 if (iter
->global_seen
)
3272 iter
->global_seen
= 1;
3276 /* Only check the symbol's kind if it has one. */
3279 switch (iter
->domain
)
3282 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
3283 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
3284 /* Some types are also in VAR_DOMAIN. */
3285 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
3289 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
3293 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_OTHER
)
3297 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_OTHER
)
3313 dwarf2_base_index_functions::print_stats (struct objfile
*objfile
,
3319 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3320 int total
= per_objfile
->per_bfd
->all_comp_units
.size ();
3323 for (int i
= 0; i
< total
; ++i
)
3325 dwarf2_per_cu_data
*per_cu
= per_objfile
->per_bfd
->get_cu (i
);
3327 if (!per_objfile
->symtab_set_p (per_cu
))
3330 printf_filtered (_(" Number of read CUs: %d\n"), total
- count
);
3331 printf_filtered (_(" Number of unread CUs: %d\n"), count
);
3334 /* This dumps minimal information about the index.
3335 It is called via "mt print objfiles".
3336 One use is to verify .gdb_index has been loaded by the
3337 gdb.dwarf2/gdb-index.exp testcase. */
3340 dwarf2_gdb_index::dump (struct objfile
*objfile
)
3342 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3344 gdb_assert (per_objfile
->per_bfd
->using_index
);
3345 printf_filtered (".gdb_index:");
3346 if (per_objfile
->per_bfd
->index_table
!= NULL
)
3348 printf_filtered (" version %d\n",
3349 per_objfile
->per_bfd
->index_table
->version
);
3352 printf_filtered (" faked for \"readnow\"\n");
3353 printf_filtered ("\n");
3357 dwarf2_base_index_functions::expand_all_symtabs (struct objfile
*objfile
)
3359 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3360 int total_units
= per_objfile
->per_bfd
->all_comp_units
.size ();
3362 for (int i
= 0; i
< total_units
; ++i
)
3364 dwarf2_per_cu_data
*per_cu
= per_objfile
->per_bfd
->get_cu (i
);
3366 /* We don't want to directly expand a partial CU, because if we
3367 read it with the wrong language, then assertion failures can
3368 be triggered later on. See PR symtab/23010. So, tell
3369 dw2_instantiate_symtab to skip partial CUs -- any important
3370 partial CU will be read via DW_TAG_imported_unit anyway. */
3371 dw2_instantiate_symtab (per_cu
, per_objfile
, true);
3376 dw2_expand_symtabs_matching_symbol
3377 (mapped_index_base
&index
,
3378 const lookup_name_info
&lookup_name_in
,
3379 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
3380 gdb::function_view
<bool (offset_type
)> match_callback
,
3381 dwarf2_per_objfile
*per_objfile
);
3384 dw2_expand_symtabs_matching_one
3385 (dwarf2_per_cu_data
*per_cu
,
3386 dwarf2_per_objfile
*per_objfile
,
3387 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
3388 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
);
3391 dwarf2_gdb_index::expand_matching_symbols
3392 (struct objfile
*objfile
,
3393 const lookup_name_info
&name
, domain_enum domain
,
3395 symbol_compare_ftype
*ordered_compare
)
3398 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3400 const block_enum block_kind
= global
? GLOBAL_BLOCK
: STATIC_BLOCK
;
3402 if (per_objfile
->per_bfd
->index_table
!= nullptr)
3404 mapped_index
&index
= *per_objfile
->per_bfd
->index_table
;
3406 const char *match_name
= name
.ada ().lookup_name ().c_str ();
3407 auto matcher
= [&] (const char *symname
)
3409 if (ordered_compare
== nullptr)
3411 return ordered_compare (symname
, match_name
) == 0;
3414 dw2_expand_symtabs_matching_symbol (index
, name
, matcher
,
3415 [&] (offset_type namei
)
3417 struct dw2_symtab_iterator iter
;
3418 struct dwarf2_per_cu_data
*per_cu
;
3420 dw2_symtab_iter_init (&iter
, per_objfile
, block_kind
, domain
,
3422 while ((per_cu
= dw2_symtab_iter_next (&iter
)) != NULL
)
3423 dw2_expand_symtabs_matching_one (per_cu
, per_objfile
, nullptr,
3430 /* We have -readnow: no .gdb_index, but no partial symtabs either. So,
3431 proceed assuming all symtabs have been read in. */
3435 /* Starting from a search name, return the string that finds the upper
3436 bound of all strings that start with SEARCH_NAME in a sorted name
3437 list. Returns the empty string to indicate that the upper bound is
3438 the end of the list. */
3441 make_sort_after_prefix_name (const char *search_name
)
3443 /* When looking to complete "func", we find the upper bound of all
3444 symbols that start with "func" by looking for where we'd insert
3445 the closest string that would follow "func" in lexicographical
3446 order. Usually, that's "func"-with-last-character-incremented,
3447 i.e. "fund". Mind non-ASCII characters, though. Usually those
3448 will be UTF-8 multi-byte sequences, but we can't be certain.
3449 Especially mind the 0xff character, which is a valid character in
3450 non-UTF-8 source character sets (e.g. Latin1 'ÿ'), and we can't
3451 rule out compilers allowing it in identifiers. Note that
3452 conveniently, strcmp/strcasecmp are specified to compare
3453 characters interpreted as unsigned char. So what we do is treat
3454 the whole string as a base 256 number composed of a sequence of
3455 base 256 "digits" and add 1 to it. I.e., adding 1 to 0xff wraps
3456 to 0, and carries 1 to the following more-significant position.
3457 If the very first character in SEARCH_NAME ends up incremented
3458 and carries/overflows, then the upper bound is the end of the
3459 list. The string after the empty string is also the empty
3462 Some examples of this operation:
3464 SEARCH_NAME => "+1" RESULT
3468 "\xff" "a" "\xff" => "\xff" "b"
3473 Then, with these symbols for example:
3479 completing "func" looks for symbols between "func" and
3480 "func"-with-last-character-incremented, i.e. "fund" (exclusive),
3481 which finds "func" and "func1", but not "fund".
3485 funcÿ (Latin1 'ÿ' [0xff])
3489 completing "funcÿ" looks for symbols between "funcÿ" and "fund"
3490 (exclusive), which finds "funcÿ" and "funcÿ1", but not "fund".
3494 ÿÿ (Latin1 'ÿ' [0xff])
3497 completing "ÿ" or "ÿÿ" looks for symbols between between "ÿÿ" and
3498 the end of the list.
3500 std::string after
= search_name
;
3501 while (!after
.empty () && (unsigned char) after
.back () == 0xff)
3503 if (!after
.empty ())
3504 after
.back () = (unsigned char) after
.back () + 1;
3508 /* See declaration. */
3510 std::pair
<std::vector
<name_component
>::const_iterator
,
3511 std::vector
<name_component
>::const_iterator
>
3512 mapped_index_base::find_name_components_bounds
3513 (const lookup_name_info
&lookup_name_without_params
, language lang
,
3514 dwarf2_per_objfile
*per_objfile
) const
3517 = this->name_components_casing
== case_sensitive_on
? strcmp
: strcasecmp
;
3519 const char *lang_name
3520 = lookup_name_without_params
.language_lookup_name (lang
);
3522 /* Comparison function object for lower_bound that matches against a
3523 given symbol name. */
3524 auto lookup_compare_lower
= [&] (const name_component
&elem
,
3527 const char *elem_qualified
= this->symbol_name_at (elem
.idx
, per_objfile
);
3528 const char *elem_name
= elem_qualified
+ elem
.name_offset
;
3529 return name_cmp (elem_name
, name
) < 0;
3532 /* Comparison function object for upper_bound that matches against a
3533 given symbol name. */
3534 auto lookup_compare_upper
= [&] (const char *name
,
3535 const name_component
&elem
)
3537 const char *elem_qualified
= this->symbol_name_at (elem
.idx
, per_objfile
);
3538 const char *elem_name
= elem_qualified
+ elem
.name_offset
;
3539 return name_cmp (name
, elem_name
) < 0;
3542 auto begin
= this->name_components
.begin ();
3543 auto end
= this->name_components
.end ();
3545 /* Find the lower bound. */
3548 if (lookup_name_without_params
.completion_mode () && lang_name
[0] == '\0')
3551 return std::lower_bound (begin
, end
, lang_name
, lookup_compare_lower
);
3554 /* Find the upper bound. */
3557 if (lookup_name_without_params
.completion_mode ())
3559 /* In completion mode, we want UPPER to point past all
3560 symbols names that have the same prefix. I.e., with
3561 these symbols, and completing "func":
3563 function << lower bound
3565 other_function << upper bound
3567 We find the upper bound by looking for the insertion
3568 point of "func"-with-last-character-incremented,
3570 std::string after
= make_sort_after_prefix_name (lang_name
);
3573 return std::lower_bound (lower
, end
, after
.c_str (),
3574 lookup_compare_lower
);
3577 return std::upper_bound (lower
, end
, lang_name
, lookup_compare_upper
);
3580 return {lower
, upper
};
3583 /* See declaration. */
3586 mapped_index_base::build_name_components (dwarf2_per_objfile
*per_objfile
)
3588 if (!this->name_components
.empty ())
3591 this->name_components_casing
= case_sensitivity
;
3593 = this->name_components_casing
== case_sensitive_on
? strcmp
: strcasecmp
;
3595 /* The code below only knows how to break apart components of C++
3596 symbol names (and other languages that use '::' as
3597 namespace/module separator) and Ada symbol names. */
3598 auto count
= this->symbol_name_count ();
3599 for (offset_type idx
= 0; idx
< count
; idx
++)
3601 if (this->symbol_name_slot_invalid (idx
))
3604 const char *name
= this->symbol_name_at (idx
, per_objfile
);
3606 /* Add each name component to the name component table. */
3607 unsigned int previous_len
= 0;
3609 if (strstr (name
, "::") != nullptr)
3611 for (unsigned int current_len
= cp_find_first_component (name
);
3612 name
[current_len
] != '\0';
3613 current_len
+= cp_find_first_component (name
+ current_len
))
3615 gdb_assert (name
[current_len
] == ':');
3616 this->name_components
.push_back ({previous_len
, idx
});
3617 /* Skip the '::'. */
3619 previous_len
= current_len
;
3624 /* Handle the Ada encoded (aka mangled) form here. */
3625 for (const char *iter
= strstr (name
, "__");
3627 iter
= strstr (iter
, "__"))
3629 this->name_components
.push_back ({previous_len
, idx
});
3631 previous_len
= iter
- name
;
3635 this->name_components
.push_back ({previous_len
, idx
});
3638 /* Sort name_components elements by name. */
3639 auto name_comp_compare
= [&] (const name_component
&left
,
3640 const name_component
&right
)
3642 const char *left_qualified
3643 = this->symbol_name_at (left
.idx
, per_objfile
);
3644 const char *right_qualified
3645 = this->symbol_name_at (right
.idx
, per_objfile
);
3647 const char *left_name
= left_qualified
+ left
.name_offset
;
3648 const char *right_name
= right_qualified
+ right
.name_offset
;
3650 return name_cmp (left_name
, right_name
) < 0;
3653 std::sort (this->name_components
.begin (),
3654 this->name_components
.end (),
3658 /* Helper for dw2_expand_symtabs_matching that works with a
3659 mapped_index_base instead of the containing objfile. This is split
3660 to a separate function in order to be able to unit test the
3661 name_components matching using a mock mapped_index_base. For each
3662 symbol name that matches, calls MATCH_CALLBACK, passing it the
3663 symbol's index in the mapped_index_base symbol table. */
3666 dw2_expand_symtabs_matching_symbol
3667 (mapped_index_base
&index
,
3668 const lookup_name_info
&lookup_name_in
,
3669 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
3670 gdb::function_view
<bool (offset_type
)> match_callback
,
3671 dwarf2_per_objfile
*per_objfile
)
3673 lookup_name_info lookup_name_without_params
3674 = lookup_name_in
.make_ignore_params ();
3676 /* Build the symbol name component sorted vector, if we haven't
3678 index
.build_name_components (per_objfile
);
3680 /* The same symbol may appear more than once in the range though.
3681 E.g., if we're looking for symbols that complete "w", and we have
3682 a symbol named "w1::w2", we'll find the two name components for
3683 that same symbol in the range. To be sure we only call the
3684 callback once per symbol, we first collect the symbol name
3685 indexes that matched in a temporary vector and ignore
3687 std::vector
<offset_type
> matches
;
3689 struct name_and_matcher
3691 symbol_name_matcher_ftype
*matcher
;
3694 bool operator== (const name_and_matcher
&other
) const
3696 return matcher
== other
.matcher
&& strcmp (name
, other
.name
) == 0;
3700 /* A vector holding all the different symbol name matchers, for all
3702 std::vector
<name_and_matcher
> matchers
;
3704 for (int i
= 0; i
< nr_languages
; i
++)
3706 enum language lang_e
= (enum language
) i
;
3708 const language_defn
*lang
= language_def (lang_e
);
3709 symbol_name_matcher_ftype
*name_matcher
3710 = lang
->get_symbol_name_matcher (lookup_name_without_params
);
3712 name_and_matcher key
{
3714 lookup_name_without_params
.language_lookup_name (lang_e
)
3717 /* Don't insert the same comparison routine more than once.
3718 Note that we do this linear walk. This is not a problem in
3719 practice because the number of supported languages is
3721 if (std::find (matchers
.begin (), matchers
.end (), key
)
3724 matchers
.push_back (std::move (key
));
3727 = index
.find_name_components_bounds (lookup_name_without_params
,
3728 lang_e
, per_objfile
);
3730 /* Now for each symbol name in range, check to see if we have a name
3731 match, and if so, call the MATCH_CALLBACK callback. */
3733 for (; bounds
.first
!= bounds
.second
; ++bounds
.first
)
3735 const char *qualified
3736 = index
.symbol_name_at (bounds
.first
->idx
, per_objfile
);
3738 if (!name_matcher (qualified
, lookup_name_without_params
, NULL
)
3739 || (symbol_matcher
!= NULL
&& !symbol_matcher (qualified
)))
3742 matches
.push_back (bounds
.first
->idx
);
3746 std::sort (matches
.begin (), matches
.end ());
3748 /* Finally call the callback, once per match. */
3751 for (offset_type idx
: matches
)
3755 if (!match_callback (idx
))
3764 /* Above we use a type wider than idx's for 'prev', since 0 and
3765 (offset_type)-1 are both possible values. */
3766 static_assert (sizeof (prev
) > sizeof (offset_type
), "");
3773 namespace selftests
{ namespace dw2_expand_symtabs_matching
{
3775 /* A mock .gdb_index/.debug_names-like name index table, enough to
3776 exercise dw2_expand_symtabs_matching_symbol, which works with the
3777 mapped_index_base interface. Builds an index from the symbol list
3778 passed as parameter to the constructor. */
3779 class mock_mapped_index
: public mapped_index_base
3782 mock_mapped_index (gdb::array_view
<const char *> symbols
)
3783 : m_symbol_table (symbols
)
3786 DISABLE_COPY_AND_ASSIGN (mock_mapped_index
);
3788 /* Return the number of names in the symbol table. */
3789 size_t symbol_name_count () const override
3791 return m_symbol_table
.size ();
3794 /* Get the name of the symbol at IDX in the symbol table. */
3795 const char *symbol_name_at
3796 (offset_type idx
, dwarf2_per_objfile
*per_objfile
) const override
3798 return m_symbol_table
[idx
];
3802 gdb::array_view
<const char *> m_symbol_table
;
3805 /* Convenience function that converts a NULL pointer to a "<null>"
3806 string, to pass to print routines. */
3809 string_or_null (const char *str
)
3811 return str
!= NULL
? str
: "<null>";
3814 /* Check if a lookup_name_info built from
3815 NAME/MATCH_TYPE/COMPLETION_MODE matches the symbols in the mock
3816 index. EXPECTED_LIST is the list of expected matches, in expected
3817 matching order. If no match expected, then an empty list is
3818 specified. Returns true on success. On failure prints a warning
3819 indicating the file:line that failed, and returns false. */
3822 check_match (const char *file
, int line
,
3823 mock_mapped_index
&mock_index
,
3824 const char *name
, symbol_name_match_type match_type
,
3825 bool completion_mode
,
3826 std::initializer_list
<const char *> expected_list
,
3827 dwarf2_per_objfile
*per_objfile
)
3829 lookup_name_info
lookup_name (name
, match_type
, completion_mode
);
3831 bool matched
= true;
3833 auto mismatch
= [&] (const char *expected_str
,
3836 warning (_("%s:%d: match_type=%s, looking-for=\"%s\", "
3837 "expected=\"%s\", got=\"%s\"\n"),
3839 (match_type
== symbol_name_match_type::FULL
3841 name
, string_or_null (expected_str
), string_or_null (got
));
3845 auto expected_it
= expected_list
.begin ();
3846 auto expected_end
= expected_list
.end ();
3848 dw2_expand_symtabs_matching_symbol (mock_index
, lookup_name
,
3850 [&] (offset_type idx
)
3852 const char *matched_name
= mock_index
.symbol_name_at (idx
, per_objfile
);
3853 const char *expected_str
3854 = expected_it
== expected_end
? NULL
: *expected_it
++;
3856 if (expected_str
== NULL
|| strcmp (expected_str
, matched_name
) != 0)
3857 mismatch (expected_str
, matched_name
);
3861 const char *expected_str
3862 = expected_it
== expected_end
? NULL
: *expected_it
++;
3863 if (expected_str
!= NULL
)
3864 mismatch (expected_str
, NULL
);
3869 /* The symbols added to the mock mapped_index for testing (in
3871 static const char *test_symbols
[] = {
3880 "ns2::tmpl<int>::foo2",
3881 "(anonymous namespace)::A::B::C",
3883 /* These are used to check that the increment-last-char in the
3884 matching algorithm for completion doesn't match "t1_fund" when
3885 completing "t1_func". */
3891 /* A UTF-8 name with multi-byte sequences to make sure that
3892 cp-name-parser understands this as a single identifier ("função"
3893 is "function" in PT). */
3896 /* \377 (0xff) is Latin1 'ÿ'. */
3899 /* \377 (0xff) is Latin1 'ÿ'. */
3903 /* A name with all sorts of complications. Starts with "z" to make
3904 it easier for the completion tests below. */
3905 #define Z_SYM_NAME \
3906 "z::std::tuple<(anonymous namespace)::ui*, std::bar<(anonymous namespace)::ui> >" \
3907 "::tuple<(anonymous namespace)::ui*, " \
3908 "std::default_delete<(anonymous namespace)::ui>, void>"
3913 /* Returns true if the mapped_index_base::find_name_component_bounds
3914 method finds EXPECTED_SYMS in INDEX when looking for SEARCH_NAME,
3915 in completion mode. */
3918 check_find_bounds_finds (mapped_index_base
&index
,
3919 const char *search_name
,
3920 gdb::array_view
<const char *> expected_syms
,
3921 dwarf2_per_objfile
*per_objfile
)
3923 lookup_name_info
lookup_name (search_name
,
3924 symbol_name_match_type::FULL
, true);
3926 auto bounds
= index
.find_name_components_bounds (lookup_name
,
3930 size_t distance
= std::distance (bounds
.first
, bounds
.second
);
3931 if (distance
!= expected_syms
.size ())
3934 for (size_t exp_elem
= 0; exp_elem
< distance
; exp_elem
++)
3936 auto nc_elem
= bounds
.first
+ exp_elem
;
3937 const char *qualified
= index
.symbol_name_at (nc_elem
->idx
, per_objfile
);
3938 if (strcmp (qualified
, expected_syms
[exp_elem
]) != 0)
3945 /* Test the lower-level mapped_index::find_name_component_bounds
3949 test_mapped_index_find_name_component_bounds ()
3951 mock_mapped_index
mock_index (test_symbols
);
3953 mock_index
.build_name_components (NULL
/* per_objfile */);
3955 /* Test the lower-level mapped_index::find_name_component_bounds
3956 method in completion mode. */
3958 static const char *expected_syms
[] = {
3963 SELF_CHECK (check_find_bounds_finds
3964 (mock_index
, "t1_func", expected_syms
,
3965 NULL
/* per_objfile */));
3968 /* Check that the increment-last-char in the name matching algorithm
3969 for completion doesn't get confused with Ansi1 'ÿ' / 0xff. */
3971 static const char *expected_syms1
[] = {
3975 SELF_CHECK (check_find_bounds_finds
3976 (mock_index
, "\377", expected_syms1
, NULL
/* per_objfile */));
3978 static const char *expected_syms2
[] = {
3981 SELF_CHECK (check_find_bounds_finds
3982 (mock_index
, "\377\377", expected_syms2
,
3983 NULL
/* per_objfile */));
3987 /* Test dw2_expand_symtabs_matching_symbol. */
3990 test_dw2_expand_symtabs_matching_symbol ()
3992 mock_mapped_index
mock_index (test_symbols
);
3994 /* We let all tests run until the end even if some fails, for debug
3996 bool any_mismatch
= false;
3998 /* Create the expected symbols list (an initializer_list). Needed
3999 because lists have commas, and we need to pass them to CHECK,
4000 which is a macro. */
4001 #define EXPECT(...) { __VA_ARGS__ }
4003 /* Wrapper for check_match that passes down the current
4004 __FILE__/__LINE__. */
4005 #define CHECK_MATCH(NAME, MATCH_TYPE, COMPLETION_MODE, EXPECTED_LIST) \
4006 any_mismatch |= !check_match (__FILE__, __LINE__, \
4008 NAME, MATCH_TYPE, COMPLETION_MODE, \
4009 EXPECTED_LIST, NULL)
4011 /* Identity checks. */
4012 for (const char *sym
: test_symbols
)
4014 /* Should be able to match all existing symbols. */
4015 CHECK_MATCH (sym
, symbol_name_match_type::FULL
, false,
4018 /* Should be able to match all existing symbols with
4020 std::string with_params
= std::string (sym
) + "(int)";
4021 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
4024 /* Should be able to match all existing symbols with
4025 parameters and qualifiers. */
4026 with_params
= std::string (sym
) + " ( int ) const";
4027 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
4030 /* This should really find sym, but cp-name-parser.y doesn't
4031 know about lvalue/rvalue qualifiers yet. */
4032 with_params
= std::string (sym
) + " ( int ) &&";
4033 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
4037 /* Check that the name matching algorithm for completion doesn't get
4038 confused with Latin1 'ÿ' / 0xff. */
4040 static const char str
[] = "\377";
4041 CHECK_MATCH (str
, symbol_name_match_type::FULL
, true,
4042 EXPECT ("\377", "\377\377123"));
4045 /* Check that the increment-last-char in the matching algorithm for
4046 completion doesn't match "t1_fund" when completing "t1_func". */
4048 static const char str
[] = "t1_func";
4049 CHECK_MATCH (str
, symbol_name_match_type::FULL
, true,
4050 EXPECT ("t1_func", "t1_func1"));
4053 /* Check that completion mode works at each prefix of the expected
4056 static const char str
[] = "function(int)";
4057 size_t len
= strlen (str
);
4060 for (size_t i
= 1; i
< len
; i
++)
4062 lookup
.assign (str
, i
);
4063 CHECK_MATCH (lookup
.c_str (), symbol_name_match_type::FULL
, true,
4064 EXPECT ("function"));
4068 /* While "w" is a prefix of both components, the match function
4069 should still only be called once. */
4071 CHECK_MATCH ("w", symbol_name_match_type::FULL
, true,
4073 CHECK_MATCH ("w", symbol_name_match_type::WILD
, true,
4077 /* Same, with a "complicated" symbol. */
4079 static const char str
[] = Z_SYM_NAME
;
4080 size_t len
= strlen (str
);
4083 for (size_t i
= 1; i
< len
; i
++)
4085 lookup
.assign (str
, i
);
4086 CHECK_MATCH (lookup
.c_str (), symbol_name_match_type::FULL
, true,
4087 EXPECT (Z_SYM_NAME
));
4091 /* In FULL mode, an incomplete symbol doesn't match. */
4093 CHECK_MATCH ("std::zfunction(int", symbol_name_match_type::FULL
, false,
4097 /* A complete symbol with parameters matches any overload, since the
4098 index has no overload info. */
4100 CHECK_MATCH ("std::zfunction(int)", symbol_name_match_type::FULL
, true,
4101 EXPECT ("std::zfunction", "std::zfunction2"));
4102 CHECK_MATCH ("zfunction(int)", symbol_name_match_type::WILD
, true,
4103 EXPECT ("std::zfunction", "std::zfunction2"));
4104 CHECK_MATCH ("zfunc", symbol_name_match_type::WILD
, true,
4105 EXPECT ("std::zfunction", "std::zfunction2"));
4108 /* Check that whitespace is ignored appropriately. A symbol with a
4109 template argument list. */
4111 static const char expected
[] = "ns::foo<int>";
4112 CHECK_MATCH ("ns :: foo < int > ", symbol_name_match_type::FULL
, false,
4114 CHECK_MATCH ("foo < int > ", symbol_name_match_type::WILD
, false,
4118 /* Check that whitespace is ignored appropriately. A symbol with a
4119 template argument list that includes a pointer. */
4121 static const char expected
[] = "ns::foo<char*>";
4122 /* Try both completion and non-completion modes. */
4123 static const bool completion_mode
[2] = {false, true};
4124 for (size_t i
= 0; i
< 2; i
++)
4126 CHECK_MATCH ("ns :: foo < char * >", symbol_name_match_type::FULL
,
4127 completion_mode
[i
], EXPECT (expected
));
4128 CHECK_MATCH ("foo < char * >", symbol_name_match_type::WILD
,
4129 completion_mode
[i
], EXPECT (expected
));
4131 CHECK_MATCH ("ns :: foo < char * > (int)", symbol_name_match_type::FULL
,
4132 completion_mode
[i
], EXPECT (expected
));
4133 CHECK_MATCH ("foo < char * > (int)", symbol_name_match_type::WILD
,
4134 completion_mode
[i
], EXPECT (expected
));
4139 /* Check method qualifiers are ignored. */
4140 static const char expected
[] = "ns::foo<char*>";
4141 CHECK_MATCH ("ns :: foo < char * > ( int ) const",
4142 symbol_name_match_type::FULL
, true, EXPECT (expected
));
4143 CHECK_MATCH ("ns :: foo < char * > ( int ) &&",
4144 symbol_name_match_type::FULL
, true, EXPECT (expected
));
4145 CHECK_MATCH ("foo < char * > ( int ) const",
4146 symbol_name_match_type::WILD
, true, EXPECT (expected
));
4147 CHECK_MATCH ("foo < char * > ( int ) &&",
4148 symbol_name_match_type::WILD
, true, EXPECT (expected
));
4151 /* Test lookup names that don't match anything. */
4153 CHECK_MATCH ("bar2", symbol_name_match_type::WILD
, false,
4156 CHECK_MATCH ("doesntexist", symbol_name_match_type::FULL
, false,
4160 /* Some wild matching tests, exercising "(anonymous namespace)",
4161 which should not be confused with a parameter list. */
4163 static const char *syms
[] = {
4167 "A :: B :: C ( int )",
4172 for (const char *s
: syms
)
4174 CHECK_MATCH (s
, symbol_name_match_type::WILD
, false,
4175 EXPECT ("(anonymous namespace)::A::B::C"));
4180 static const char expected
[] = "ns2::tmpl<int>::foo2";
4181 CHECK_MATCH ("tmp", symbol_name_match_type::WILD
, true,
4183 CHECK_MATCH ("tmpl<", symbol_name_match_type::WILD
, true,
4187 SELF_CHECK (!any_mismatch
);
4196 test_mapped_index_find_name_component_bounds ();
4197 test_dw2_expand_symtabs_matching_symbol ();
4200 }} // namespace selftests::dw2_expand_symtabs_matching
4202 #endif /* GDB_SELF_TEST */
4204 /* If FILE_MATCHER is NULL or if PER_CU has
4205 dwarf2_per_cu_quick_data::MARK set (see
4206 dw_expand_symtabs_matching_file_matcher), expand the CU and call
4207 EXPANSION_NOTIFY on it. */
4210 dw2_expand_symtabs_matching_one
4211 (dwarf2_per_cu_data
*per_cu
,
4212 dwarf2_per_objfile
*per_objfile
,
4213 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
4214 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
)
4216 if (file_matcher
== NULL
|| per_cu
->v
.quick
->mark
)
4218 bool symtab_was_null
= !per_objfile
->symtab_set_p (per_cu
);
4220 compunit_symtab
*symtab
4221 = dw2_instantiate_symtab (per_cu
, per_objfile
, false);
4222 gdb_assert (symtab
!= nullptr);
4224 if (expansion_notify
!= NULL
&& symtab_was_null
)
4225 return expansion_notify (symtab
);
4230 /* Helper for dw2_expand_matching symtabs. Called on each symbol
4231 matched, to expand corresponding CUs that were marked. IDX is the
4232 index of the symbol name that matched. */
4235 dw2_expand_marked_cus
4236 (dwarf2_per_objfile
*per_objfile
, offset_type idx
,
4237 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
4238 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
4239 block_search_flags search_flags
,
4242 offset_type vec_len
, vec_idx
;
4243 bool global_seen
= false;
4244 mapped_index
&index
= *per_objfile
->per_bfd
->index_table
;
4246 offset_view
vec (index
.constant_pool
.slice (index
.symbol_vec_index (idx
)));
4248 for (vec_idx
= 0; vec_idx
< vec_len
; ++vec_idx
)
4250 offset_type cu_index_and_attrs
= vec
[vec_idx
+ 1];
4251 /* This value is only valid for index versions >= 7. */
4252 int is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs
);
4253 gdb_index_symbol_kind symbol_kind
=
4254 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
4255 int cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
4256 /* Only check the symbol attributes if they're present.
4257 Indices prior to version 7 don't record them,
4258 and indices >= 7 may elide them for certain symbols
4259 (gold does this). */
4262 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_NONE
);
4264 /* Work around gold/15646. */
4267 && symbol_kind
== GDB_INDEX_SYMBOL_KIND_TYPE
)
4275 /* Only check the symbol's kind if it has one. */
4280 if ((search_flags
& SEARCH_STATIC_BLOCK
) == 0)
4285 if ((search_flags
& SEARCH_GLOBAL_BLOCK
) == 0)
4291 case VARIABLES_DOMAIN
:
4292 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
)
4295 case FUNCTIONS_DOMAIN
:
4296 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
)
4300 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
4303 case MODULES_DOMAIN
:
4304 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_OTHER
)
4312 /* Don't crash on bad data. */
4313 if (cu_index
>= per_objfile
->per_bfd
->all_comp_units
.size ())
4315 complaint (_(".gdb_index entry has bad CU index"
4316 " [in module %s]"), objfile_name (per_objfile
->objfile
));
4320 dwarf2_per_cu_data
*per_cu
= per_objfile
->per_bfd
->get_cu (cu_index
);
4321 if (!dw2_expand_symtabs_matching_one (per_cu
, per_objfile
, file_matcher
,
4329 /* If FILE_MATCHER is non-NULL, set all the
4330 dwarf2_per_cu_quick_data::MARK of the current DWARF2_PER_OBJFILE
4331 that match FILE_MATCHER. */
4334 dw_expand_symtabs_matching_file_matcher
4335 (dwarf2_per_objfile
*per_objfile
,
4336 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
)
4338 if (file_matcher
== NULL
)
4341 htab_up
visited_found (htab_create_alloc (10, htab_hash_pointer
,
4343 NULL
, xcalloc
, xfree
));
4344 htab_up
visited_not_found (htab_create_alloc (10, htab_hash_pointer
,
4346 NULL
, xcalloc
, xfree
));
4348 /* The rule is CUs specify all the files, including those used by
4349 any TU, so there's no need to scan TUs here. */
4351 for (const auto &per_cu
: per_objfile
->per_bfd
->all_comp_units
)
4355 if (per_cu
->is_debug_types
)
4357 per_cu
->v
.quick
->mark
= 0;
4359 /* We only need to look at symtabs not already expanded. */
4360 if (per_objfile
->symtab_set_p (per_cu
.get ()))
4363 quick_file_names
*file_data
= dw2_get_file_names (per_cu
.get (),
4365 if (file_data
== NULL
)
4368 if (htab_find (visited_not_found
.get (), file_data
) != NULL
)
4370 else if (htab_find (visited_found
.get (), file_data
) != NULL
)
4372 per_cu
->v
.quick
->mark
= 1;
4376 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
4378 const char *this_real_name
;
4380 if (file_matcher (file_data
->file_names
[j
], false))
4382 per_cu
->v
.quick
->mark
= 1;
4386 /* Before we invoke realpath, which can get expensive when many
4387 files are involved, do a quick comparison of the basenames. */
4388 if (!basenames_may_differ
4389 && !file_matcher (lbasename (file_data
->file_names
[j
]),
4393 this_real_name
= dw2_get_real_path (per_objfile
, file_data
, j
);
4394 if (file_matcher (this_real_name
, false))
4396 per_cu
->v
.quick
->mark
= 1;
4401 void **slot
= htab_find_slot (per_cu
->v
.quick
->mark
4402 ? visited_found
.get ()
4403 : visited_not_found
.get (),
4410 dwarf2_gdb_index::expand_symtabs_matching
4411 (struct objfile
*objfile
,
4412 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
4413 const lookup_name_info
*lookup_name
,
4414 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
4415 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
4416 block_search_flags search_flags
,
4418 enum search_domain kind
)
4420 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
4422 /* index_table is NULL if OBJF_READNOW. */
4423 if (!per_objfile
->per_bfd
->index_table
)
4426 dw_expand_symtabs_matching_file_matcher (per_objfile
, file_matcher
);
4428 /* This invariant is documented in quick-functions.h. */
4429 gdb_assert (lookup_name
!= nullptr || symbol_matcher
== nullptr);
4430 if (lookup_name
== nullptr)
4432 for (dwarf2_per_cu_data
*per_cu
4433 : all_comp_units_range (per_objfile
->per_bfd
))
4437 if (!dw2_expand_symtabs_matching_one (per_cu
, per_objfile
,
4445 mapped_index
&index
= *per_objfile
->per_bfd
->index_table
;
4448 = dw2_expand_symtabs_matching_symbol (index
, *lookup_name
,
4450 [&] (offset_type idx
)
4452 if (!dw2_expand_marked_cus (per_objfile
, idx
, file_matcher
,
4453 expansion_notify
, search_flags
, kind
))
4461 /* A helper for dw2_find_pc_sect_compunit_symtab which finds the most specific
4464 static struct compunit_symtab
*
4465 recursively_find_pc_sect_compunit_symtab (struct compunit_symtab
*cust
,
4470 if (COMPUNIT_BLOCKVECTOR (cust
) != NULL
4471 && blockvector_contains_pc (COMPUNIT_BLOCKVECTOR (cust
), pc
))
4474 if (cust
->includes
== NULL
)
4477 for (i
= 0; cust
->includes
[i
]; ++i
)
4479 struct compunit_symtab
*s
= cust
->includes
[i
];
4481 s
= recursively_find_pc_sect_compunit_symtab (s
, pc
);
4489 struct compunit_symtab
*
4490 dwarf2_base_index_functions::find_pc_sect_compunit_symtab
4491 (struct objfile
*objfile
,
4492 struct bound_minimal_symbol msymbol
,
4494 struct obj_section
*section
,
4497 struct dwarf2_per_cu_data
*data
;
4498 struct compunit_symtab
*result
;
4500 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
4501 if (per_objfile
->per_bfd
->index_addrmap
== nullptr)
4504 CORE_ADDR baseaddr
= objfile
->text_section_offset ();
4505 data
= ((struct dwarf2_per_cu_data
*)
4506 addrmap_find (per_objfile
->per_bfd
->index_addrmap
,
4511 if (warn_if_readin
&& per_objfile
->symtab_set_p (data
))
4512 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
4513 paddress (objfile
->arch (), pc
));
4515 result
= recursively_find_pc_sect_compunit_symtab
4516 (dw2_instantiate_symtab (data
, per_objfile
, false), pc
);
4518 gdb_assert (result
!= NULL
);
4523 dwarf2_base_index_functions::map_symbol_filenames
4524 (struct objfile
*objfile
,
4525 gdb::function_view
<symbol_filename_ftype
> fun
,
4528 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
4530 /* Use caches to ensure we only call FUN once for each filename. */
4531 filename_seen_cache filenames_cache
;
4532 std::unordered_set
<quick_file_names
*> qfn_cache
;
4534 /* The rule is CUs specify all the files, including those used by any TU,
4535 so there's no need to scan TUs here. We can ignore file names coming
4536 from already-expanded CUs. It is possible that an expanded CU might
4537 reuse the file names data from a currently unexpanded CU, in this
4538 case we don't want to report the files from the unexpanded CU. */
4540 for (const auto &per_cu
: per_objfile
->per_bfd
->all_comp_units
)
4542 if (!per_cu
->is_debug_types
4543 && per_objfile
->symtab_set_p (per_cu
.get ()))
4545 if (per_cu
->v
.quick
->file_names
!= nullptr)
4546 qfn_cache
.insert (per_cu
->v
.quick
->file_names
);
4550 for (dwarf2_per_cu_data
*per_cu
4551 : all_comp_units_range (per_objfile
->per_bfd
))
4553 /* We only need to look at symtabs not already expanded. */
4554 if (per_cu
->is_debug_types
|| per_objfile
->symtab_set_p (per_cu
))
4557 quick_file_names
*file_data
= dw2_get_file_names (per_cu
, per_objfile
);
4558 if (file_data
== nullptr
4559 || qfn_cache
.find (file_data
) != qfn_cache
.end ())
4562 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
4564 const char *filename
= file_data
->file_names
[j
];
4565 const char *key
= filename
;
4566 const char *fullname
= nullptr;
4570 fullname
= dw2_get_real_path (per_objfile
, file_data
, j
);
4574 if (!filenames_cache
.seen (key
))
4575 fun (filename
, fullname
);
4581 dwarf2_base_index_functions::has_symbols (struct objfile
*objfile
)
4586 /* See quick_symbol_functions::has_unexpanded_symtabs in quick-symbol.h. */
4589 dwarf2_base_index_functions::has_unexpanded_symtabs (struct objfile
*objfile
)
4591 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
4593 for (const auto &per_cu
: per_objfile
->per_bfd
->all_comp_units
)
4595 /* Is this already expanded? */
4596 if (per_objfile
->symtab_set_p (per_cu
.get ()))
4599 /* It has not yet been expanded. */
4606 /* DWARF-5 debug_names reader. */
4608 /* DWARF-5 augmentation string for GDB's DW_IDX_GNU_* extension. */
4609 static const gdb_byte dwarf5_augmentation
[] = { 'G', 'D', 'B', 0 };
4611 /* A helper function that reads the .debug_names section in SECTION
4612 and fills in MAP. FILENAME is the name of the file containing the
4613 section; it is used for error reporting.
4615 Returns true if all went well, false otherwise. */
4618 read_debug_names_from_section (struct objfile
*objfile
,
4619 const char *filename
,
4620 struct dwarf2_section_info
*section
,
4621 mapped_debug_names
&map
)
4623 if (section
->empty ())
4626 /* Older elfutils strip versions could keep the section in the main
4627 executable while splitting it for the separate debug info file. */
4628 if ((section
->get_flags () & SEC_HAS_CONTENTS
) == 0)
4631 section
->read (objfile
);
4633 map
.dwarf5_byte_order
= gdbarch_byte_order (objfile
->arch ());
4635 const gdb_byte
*addr
= section
->buffer
;
4637 bfd
*const abfd
= section
->get_bfd_owner ();
4639 unsigned int bytes_read
;
4640 LONGEST length
= read_initial_length (abfd
, addr
, &bytes_read
);
4643 map
.dwarf5_is_dwarf64
= bytes_read
!= 4;
4644 map
.offset_size
= map
.dwarf5_is_dwarf64
? 8 : 4;
4645 if (bytes_read
+ length
!= section
->size
)
4647 /* There may be multiple per-CU indices. */
4648 warning (_("Section .debug_names in %s length %s does not match "
4649 "section length %s, ignoring .debug_names."),
4650 filename
, plongest (bytes_read
+ length
),
4651 pulongest (section
->size
));
4655 /* The version number. */
4656 uint16_t version
= read_2_bytes (abfd
, addr
);
4660 warning (_("Section .debug_names in %s has unsupported version %d, "
4661 "ignoring .debug_names."),
4667 uint16_t padding
= read_2_bytes (abfd
, addr
);
4671 warning (_("Section .debug_names in %s has unsupported padding %d, "
4672 "ignoring .debug_names."),
4677 /* comp_unit_count - The number of CUs in the CU list. */
4678 map
.cu_count
= read_4_bytes (abfd
, addr
);
4681 /* local_type_unit_count - The number of TUs in the local TU
4683 map
.tu_count
= read_4_bytes (abfd
, addr
);
4686 /* foreign_type_unit_count - The number of TUs in the foreign TU
4688 uint32_t foreign_tu_count
= read_4_bytes (abfd
, addr
);
4690 if (foreign_tu_count
!= 0)
4692 warning (_("Section .debug_names in %s has unsupported %lu foreign TUs, "
4693 "ignoring .debug_names."),
4694 filename
, static_cast<unsigned long> (foreign_tu_count
));
4698 /* bucket_count - The number of hash buckets in the hash lookup
4700 map
.bucket_count
= read_4_bytes (abfd
, addr
);
4703 /* name_count - The number of unique names in the index. */
4704 map
.name_count
= read_4_bytes (abfd
, addr
);
4707 /* abbrev_table_size - The size in bytes of the abbreviations
4709 uint32_t abbrev_table_size
= read_4_bytes (abfd
, addr
);
4712 /* augmentation_string_size - The size in bytes of the augmentation
4713 string. This value is rounded up to a multiple of 4. */
4714 uint32_t augmentation_string_size
= read_4_bytes (abfd
, addr
);
4716 map
.augmentation_is_gdb
= ((augmentation_string_size
4717 == sizeof (dwarf5_augmentation
))
4718 && memcmp (addr
, dwarf5_augmentation
,
4719 sizeof (dwarf5_augmentation
)) == 0);
4720 augmentation_string_size
+= (-augmentation_string_size
) & 3;
4721 addr
+= augmentation_string_size
;
4724 map
.cu_table_reordered
= addr
;
4725 addr
+= map
.cu_count
* map
.offset_size
;
4727 /* List of Local TUs */
4728 map
.tu_table_reordered
= addr
;
4729 addr
+= map
.tu_count
* map
.offset_size
;
4731 /* Hash Lookup Table */
4732 map
.bucket_table_reordered
= reinterpret_cast<const uint32_t *> (addr
);
4733 addr
+= map
.bucket_count
* 4;
4734 map
.hash_table_reordered
= reinterpret_cast<const uint32_t *> (addr
);
4735 addr
+= map
.name_count
* 4;
4738 map
.name_table_string_offs_reordered
= addr
;
4739 addr
+= map
.name_count
* map
.offset_size
;
4740 map
.name_table_entry_offs_reordered
= addr
;
4741 addr
+= map
.name_count
* map
.offset_size
;
4743 const gdb_byte
*abbrev_table_start
= addr
;
4746 const ULONGEST index_num
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
4751 const auto insertpair
4752 = map
.abbrev_map
.emplace (index_num
, mapped_debug_names::index_val ());
4753 if (!insertpair
.second
)
4755 warning (_("Section .debug_names in %s has duplicate index %s, "
4756 "ignoring .debug_names."),
4757 filename
, pulongest (index_num
));
4760 mapped_debug_names::index_val
&indexval
= insertpair
.first
->second
;
4761 indexval
.dwarf_tag
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
4766 mapped_debug_names::index_val::attr attr
;
4767 attr
.dw_idx
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
4769 attr
.form
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
4771 if (attr
.form
== DW_FORM_implicit_const
)
4773 attr
.implicit_const
= read_signed_leb128 (abfd
, addr
,
4777 if (attr
.dw_idx
== 0 && attr
.form
== 0)
4779 indexval
.attr_vec
.push_back (std::move (attr
));
4782 if (addr
!= abbrev_table_start
+ abbrev_table_size
)
4784 warning (_("Section .debug_names in %s has abbreviation_table "
4785 "of size %s vs. written as %u, ignoring .debug_names."),
4786 filename
, plongest (addr
- abbrev_table_start
),
4790 map
.entry_pool
= addr
;
4795 /* A helper for create_cus_from_debug_names that handles the MAP's CU
4799 create_cus_from_debug_names_list (dwarf2_per_bfd
*per_bfd
,
4800 const mapped_debug_names
&map
,
4801 dwarf2_section_info
§ion
,
4804 if (!map
.augmentation_is_gdb
)
4806 for (uint32_t i
= 0; i
< map
.cu_count
; ++i
)
4808 sect_offset sect_off
4809 = (sect_offset
) (extract_unsigned_integer
4810 (map
.cu_table_reordered
+ i
* map
.offset_size
,
4812 map
.dwarf5_byte_order
));
4813 /* We don't know the length of the CU, because the CU list in a
4814 .debug_names index can be incomplete, so we can't use the start
4815 of the next CU as end of this CU. We create the CUs here with
4816 length 0, and in cutu_reader::cutu_reader we'll fill in the
4818 dwarf2_per_cu_data_up per_cu
4819 = create_cu_from_index_list (per_bfd
, §ion
, is_dwz
,
4821 per_bfd
->all_comp_units
.push_back (std::move (per_cu
));
4826 sect_offset sect_off_prev
;
4827 for (uint32_t i
= 0; i
<= map
.cu_count
; ++i
)
4829 sect_offset sect_off_next
;
4830 if (i
< map
.cu_count
)
4833 = (sect_offset
) (extract_unsigned_integer
4834 (map
.cu_table_reordered
+ i
* map
.offset_size
,
4836 map
.dwarf5_byte_order
));
4839 sect_off_next
= (sect_offset
) section
.size
;
4842 const ULONGEST length
= sect_off_next
- sect_off_prev
;
4843 dwarf2_per_cu_data_up per_cu
4844 = create_cu_from_index_list (per_bfd
, §ion
, is_dwz
,
4845 sect_off_prev
, length
);
4846 per_bfd
->all_comp_units
.push_back (std::move (per_cu
));
4848 sect_off_prev
= sect_off_next
;
4852 /* Read the CU list from the mapped index, and use it to create all
4853 the CU objects for this dwarf2_per_objfile. */
4856 create_cus_from_debug_names (dwarf2_per_bfd
*per_bfd
,
4857 const mapped_debug_names
&map
,
4858 const mapped_debug_names
&dwz_map
)
4860 gdb_assert (per_bfd
->all_comp_units
.empty ());
4861 per_bfd
->all_comp_units
.reserve (map
.cu_count
+ dwz_map
.cu_count
);
4863 create_cus_from_debug_names_list (per_bfd
, map
, per_bfd
->info
,
4864 false /* is_dwz */);
4866 if (dwz_map
.cu_count
== 0)
4869 dwz_file
*dwz
= dwarf2_get_dwz_file (per_bfd
);
4870 create_cus_from_debug_names_list (per_bfd
, dwz_map
, dwz
->info
,
4874 /* Read .debug_names. If everything went ok, initialize the "quick"
4875 elements of all the CUs and return true. Otherwise, return false. */
4878 dwarf2_read_debug_names (dwarf2_per_objfile
*per_objfile
)
4880 std::unique_ptr
<mapped_debug_names
> map (new mapped_debug_names
);
4881 mapped_debug_names dwz_map
;
4882 struct objfile
*objfile
= per_objfile
->objfile
;
4883 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
4885 if (!read_debug_names_from_section (objfile
, objfile_name (objfile
),
4886 &per_bfd
->debug_names
, *map
))
4889 /* Don't use the index if it's empty. */
4890 if (map
->name_count
== 0)
4893 /* If there is a .dwz file, read it so we can get its CU list as
4895 dwz_file
*dwz
= dwarf2_get_dwz_file (per_bfd
);
4898 if (!read_debug_names_from_section (objfile
,
4899 bfd_get_filename (dwz
->dwz_bfd
.get ()),
4900 &dwz
->debug_names
, dwz_map
))
4902 warning (_("could not read '.debug_names' section from %s; skipping"),
4903 bfd_get_filename (dwz
->dwz_bfd
.get ()));
4908 create_cus_from_debug_names (per_bfd
, *map
, dwz_map
);
4910 if (map
->tu_count
!= 0)
4912 /* We can only handle a single .debug_types when we have an
4914 if (per_bfd
->types
.size () != 1)
4917 dwarf2_section_info
*section
= &per_bfd
->types
[0];
4919 create_signatured_type_table_from_debug_names
4920 (per_objfile
, *map
, section
, &per_bfd
->abbrev
);
4923 create_addrmap_from_aranges (per_objfile
, &per_bfd
->debug_aranges
);
4925 per_bfd
->debug_names_table
= std::move (map
);
4926 per_bfd
->using_index
= 1;
4927 per_bfd
->quick_file_names_table
=
4928 create_quick_file_names_table (per_bfd
->all_comp_units
.size ());
4933 /* Type used to manage iterating over all CUs looking for a symbol for
4936 class dw2_debug_names_iterator
4939 dw2_debug_names_iterator (const mapped_debug_names
&map
,
4940 block_search_flags block_index
,
4942 const char *name
, dwarf2_per_objfile
*per_objfile
)
4943 : m_map (map
), m_block_index (block_index
), m_domain (domain
),
4944 m_addr (find_vec_in_debug_names (map
, name
, per_objfile
)),
4945 m_per_objfile (per_objfile
)
4948 dw2_debug_names_iterator (const mapped_debug_names
&map
,
4949 search_domain search
, uint32_t namei
,
4950 dwarf2_per_objfile
*per_objfile
,
4951 domain_enum domain
= UNDEF_DOMAIN
)
4955 m_addr (find_vec_in_debug_names (map
, namei
, per_objfile
)),
4956 m_per_objfile (per_objfile
)
4959 dw2_debug_names_iterator (const mapped_debug_names
&map
,
4960 block_search_flags block_index
, domain_enum domain
,
4961 uint32_t namei
, dwarf2_per_objfile
*per_objfile
)
4962 : m_map (map
), m_block_index (block_index
), m_domain (domain
),
4963 m_addr (find_vec_in_debug_names (map
, namei
, per_objfile
)),
4964 m_per_objfile (per_objfile
)
4967 /* Return the next matching CU or NULL if there are no more. */
4968 dwarf2_per_cu_data
*next ();
4971 static const gdb_byte
*find_vec_in_debug_names (const mapped_debug_names
&map
,
4973 dwarf2_per_objfile
*per_objfile
);
4974 static const gdb_byte
*find_vec_in_debug_names (const mapped_debug_names
&map
,
4976 dwarf2_per_objfile
*per_objfile
);
4978 /* The internalized form of .debug_names. */
4979 const mapped_debug_names
&m_map
;
4981 /* Restrict the search to these blocks. */
4982 block_search_flags m_block_index
= (SEARCH_GLOBAL_BLOCK
4983 | SEARCH_STATIC_BLOCK
);
4985 /* The kind of symbol we're looking for. */
4986 const domain_enum m_domain
= UNDEF_DOMAIN
;
4987 const search_domain m_search
= ALL_DOMAIN
;
4989 /* The list of CUs from the index entry of the symbol, or NULL if
4991 const gdb_byte
*m_addr
;
4993 dwarf2_per_objfile
*m_per_objfile
;
4997 mapped_debug_names::namei_to_name
4998 (uint32_t namei
, dwarf2_per_objfile
*per_objfile
) const
5000 const ULONGEST namei_string_offs
5001 = extract_unsigned_integer ((name_table_string_offs_reordered
5002 + namei
* offset_size
),
5005 return read_indirect_string_at_offset (per_objfile
, namei_string_offs
);
5008 /* Find a slot in .debug_names for the object named NAME. If NAME is
5009 found, return pointer to its pool data. If NAME cannot be found,
5013 dw2_debug_names_iterator::find_vec_in_debug_names
5014 (const mapped_debug_names
&map
, const char *name
,
5015 dwarf2_per_objfile
*per_objfile
)
5017 int (*cmp
) (const char *, const char *);
5019 gdb::unique_xmalloc_ptr
<char> without_params
;
5020 if (current_language
->la_language
== language_cplus
5021 || current_language
->la_language
== language_fortran
5022 || current_language
->la_language
== language_d
)
5024 /* NAME is already canonical. Drop any qualifiers as
5025 .debug_names does not contain any. */
5027 if (strchr (name
, '(') != NULL
)
5029 without_params
= cp_remove_params (name
);
5030 if (without_params
!= NULL
)
5031 name
= without_params
.get ();
5035 cmp
= (case_sensitivity
== case_sensitive_on
? strcmp
: strcasecmp
);
5037 const uint32_t full_hash
= dwarf5_djb_hash (name
);
5039 = extract_unsigned_integer (reinterpret_cast<const gdb_byte
*>
5040 (map
.bucket_table_reordered
5041 + (full_hash
% map
.bucket_count
)), 4,
5042 map
.dwarf5_byte_order
);
5046 if (namei
>= map
.name_count
)
5048 complaint (_("Wrong .debug_names with name index %u but name_count=%u "
5050 namei
, map
.name_count
,
5051 objfile_name (per_objfile
->objfile
));
5057 const uint32_t namei_full_hash
5058 = extract_unsigned_integer (reinterpret_cast<const gdb_byte
*>
5059 (map
.hash_table_reordered
+ namei
), 4,
5060 map
.dwarf5_byte_order
);
5061 if (full_hash
% map
.bucket_count
!= namei_full_hash
% map
.bucket_count
)
5064 if (full_hash
== namei_full_hash
)
5066 const char *const namei_string
= map
.namei_to_name (namei
, per_objfile
);
5068 #if 0 /* An expensive sanity check. */
5069 if (namei_full_hash
!= dwarf5_djb_hash (namei_string
))
5071 complaint (_("Wrong .debug_names hash for string at index %u "
5073 namei
, objfile_name (dwarf2_per_objfile
->objfile
));
5078 if (cmp (namei_string
, name
) == 0)
5080 const ULONGEST namei_entry_offs
5081 = extract_unsigned_integer ((map
.name_table_entry_offs_reordered
5082 + namei
* map
.offset_size
),
5083 map
.offset_size
, map
.dwarf5_byte_order
);
5084 return map
.entry_pool
+ namei_entry_offs
;
5089 if (namei
>= map
.name_count
)
5095 dw2_debug_names_iterator::find_vec_in_debug_names
5096 (const mapped_debug_names
&map
, uint32_t namei
, dwarf2_per_objfile
*per_objfile
)
5098 if (namei
>= map
.name_count
)
5100 complaint (_("Wrong .debug_names with name index %u but name_count=%u "
5102 namei
, map
.name_count
,
5103 objfile_name (per_objfile
->objfile
));
5107 const ULONGEST namei_entry_offs
5108 = extract_unsigned_integer ((map
.name_table_entry_offs_reordered
5109 + namei
* map
.offset_size
),
5110 map
.offset_size
, map
.dwarf5_byte_order
);
5111 return map
.entry_pool
+ namei_entry_offs
;
5114 /* See dw2_debug_names_iterator. */
5116 dwarf2_per_cu_data
*
5117 dw2_debug_names_iterator::next ()
5122 dwarf2_per_bfd
*per_bfd
= m_per_objfile
->per_bfd
;
5123 struct objfile
*objfile
= m_per_objfile
->objfile
;
5124 bfd
*const abfd
= objfile
->obfd
;
5128 unsigned int bytes_read
;
5129 const ULONGEST abbrev
= read_unsigned_leb128 (abfd
, m_addr
, &bytes_read
);
5130 m_addr
+= bytes_read
;
5134 const auto indexval_it
= m_map
.abbrev_map
.find (abbrev
);
5135 if (indexval_it
== m_map
.abbrev_map
.cend ())
5137 complaint (_("Wrong .debug_names undefined abbrev code %s "
5139 pulongest (abbrev
), objfile_name (objfile
));
5142 const mapped_debug_names::index_val
&indexval
= indexval_it
->second
;
5143 enum class symbol_linkage
{
5147 } symbol_linkage_
= symbol_linkage::unknown
;
5148 dwarf2_per_cu_data
*per_cu
= NULL
;
5149 for (const mapped_debug_names::index_val::attr
&attr
: indexval
.attr_vec
)
5154 case DW_FORM_implicit_const
:
5155 ull
= attr
.implicit_const
;
5157 case DW_FORM_flag_present
:
5161 ull
= read_unsigned_leb128 (abfd
, m_addr
, &bytes_read
);
5162 m_addr
+= bytes_read
;
5165 ull
= read_4_bytes (abfd
, m_addr
);
5169 ull
= read_8_bytes (abfd
, m_addr
);
5172 case DW_FORM_ref_sig8
:
5173 ull
= read_8_bytes (abfd
, m_addr
);
5177 complaint (_("Unsupported .debug_names form %s [in module %s]"),
5178 dwarf_form_name (attr
.form
),
5179 objfile_name (objfile
));
5182 switch (attr
.dw_idx
)
5184 case DW_IDX_compile_unit
:
5185 /* Don't crash on bad data. */
5186 if (ull
>= per_bfd
->all_comp_units
.size ())
5188 complaint (_(".debug_names entry has bad CU index %s"
5191 objfile_name (objfile
));
5194 per_cu
= per_bfd
->get_cu (ull
);
5196 case DW_IDX_type_unit
:
5197 /* Don't crash on bad data. */
5198 if (ull
>= per_bfd
->tu_stats
.nr_tus
)
5200 complaint (_(".debug_names entry has bad TU index %s"
5203 objfile_name (objfile
));
5206 per_cu
= per_bfd
->get_cu (ull
+ per_bfd
->tu_stats
.nr_tus
);
5208 case DW_IDX_die_offset
:
5209 /* In a per-CU index (as opposed to a per-module index), index
5210 entries without CU attribute implicitly refer to the single CU. */
5212 per_cu
= per_bfd
->get_cu (0);
5214 case DW_IDX_GNU_internal
:
5215 if (!m_map
.augmentation_is_gdb
)
5217 symbol_linkage_
= symbol_linkage::static_
;
5219 case DW_IDX_GNU_external
:
5220 if (!m_map
.augmentation_is_gdb
)
5222 symbol_linkage_
= symbol_linkage::extern_
;
5227 /* Skip if already read in. */
5228 if (m_per_objfile
->symtab_set_p (per_cu
))
5231 /* Check static vs global. */
5232 if (symbol_linkage_
!= symbol_linkage::unknown
)
5234 if (symbol_linkage_
== symbol_linkage::static_
)
5236 if ((m_block_index
& SEARCH_STATIC_BLOCK
) == 0)
5241 if ((m_block_index
& SEARCH_GLOBAL_BLOCK
) == 0)
5246 /* Match dw2_symtab_iter_next, symbol_kind
5247 and debug_names::psymbol_tag. */
5251 switch (indexval
.dwarf_tag
)
5253 case DW_TAG_variable
:
5254 case DW_TAG_subprogram
:
5255 /* Some types are also in VAR_DOMAIN. */
5256 case DW_TAG_typedef
:
5257 case DW_TAG_structure_type
:
5264 switch (indexval
.dwarf_tag
)
5266 case DW_TAG_typedef
:
5267 case DW_TAG_structure_type
:
5274 switch (indexval
.dwarf_tag
)
5277 case DW_TAG_variable
:
5284 switch (indexval
.dwarf_tag
)
5296 /* Match dw2_expand_symtabs_matching, symbol_kind and
5297 debug_names::psymbol_tag. */
5300 case VARIABLES_DOMAIN
:
5301 switch (indexval
.dwarf_tag
)
5303 case DW_TAG_variable
:
5309 case FUNCTIONS_DOMAIN
:
5310 switch (indexval
.dwarf_tag
)
5312 case DW_TAG_subprogram
:
5319 switch (indexval
.dwarf_tag
)
5321 case DW_TAG_typedef
:
5322 case DW_TAG_structure_type
:
5328 case MODULES_DOMAIN
:
5329 switch (indexval
.dwarf_tag
)
5343 /* This dumps minimal information about .debug_names. It is called
5344 via "mt print objfiles". The gdb.dwarf2/gdb-index.exp testcase
5345 uses this to verify that .debug_names has been loaded. */
5348 dwarf2_debug_names_index::dump (struct objfile
*objfile
)
5350 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
5352 gdb_assert (per_objfile
->per_bfd
->using_index
);
5353 printf_filtered (".debug_names:");
5354 if (per_objfile
->per_bfd
->debug_names_table
)
5355 printf_filtered (" exists\n");
5357 printf_filtered (" faked for \"readnow\"\n");
5358 printf_filtered ("\n");
5362 dwarf2_debug_names_index::expand_matching_symbols
5363 (struct objfile
*objfile
,
5364 const lookup_name_info
&name
, domain_enum domain
,
5366 symbol_compare_ftype
*ordered_compare
)
5368 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
5370 /* debug_names_table is NULL if OBJF_READNOW. */
5371 if (!per_objfile
->per_bfd
->debug_names_table
)
5374 mapped_debug_names
&map
= *per_objfile
->per_bfd
->debug_names_table
;
5375 const block_search_flags block_flags
5376 = global
? SEARCH_GLOBAL_BLOCK
: SEARCH_STATIC_BLOCK
;
5378 const char *match_name
= name
.ada ().lookup_name ().c_str ();
5379 auto matcher
= [&] (const char *symname
)
5381 if (ordered_compare
== nullptr)
5383 return ordered_compare (symname
, match_name
) == 0;
5386 dw2_expand_symtabs_matching_symbol (map
, name
, matcher
,
5387 [&] (offset_type namei
)
5389 /* The name was matched, now expand corresponding CUs that were
5391 dw2_debug_names_iterator
iter (map
, block_flags
, domain
, namei
,
5394 struct dwarf2_per_cu_data
*per_cu
;
5395 while ((per_cu
= iter
.next ()) != NULL
)
5396 dw2_expand_symtabs_matching_one (per_cu
, per_objfile
, nullptr,
5403 dwarf2_debug_names_index::expand_symtabs_matching
5404 (struct objfile
*objfile
,
5405 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
5406 const lookup_name_info
*lookup_name
,
5407 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
5408 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
5409 block_search_flags search_flags
,
5411 enum search_domain kind
)
5413 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
5415 /* debug_names_table is NULL if OBJF_READNOW. */
5416 if (!per_objfile
->per_bfd
->debug_names_table
)
5419 dw_expand_symtabs_matching_file_matcher (per_objfile
, file_matcher
);
5421 /* This invariant is documented in quick-functions.h. */
5422 gdb_assert (lookup_name
!= nullptr || symbol_matcher
== nullptr);
5423 if (lookup_name
== nullptr)
5425 for (dwarf2_per_cu_data
*per_cu
5426 : all_comp_units_range (per_objfile
->per_bfd
))
5430 if (!dw2_expand_symtabs_matching_one (per_cu
, per_objfile
,
5438 mapped_debug_names
&map
= *per_objfile
->per_bfd
->debug_names_table
;
5441 = dw2_expand_symtabs_matching_symbol (map
, *lookup_name
,
5443 [&] (offset_type namei
)
5445 /* The name was matched, now expand corresponding CUs that were
5447 dw2_debug_names_iterator
iter (map
, kind
, namei
, per_objfile
, domain
);
5449 struct dwarf2_per_cu_data
*per_cu
;
5450 while ((per_cu
= iter
.next ()) != NULL
)
5451 if (!dw2_expand_symtabs_matching_one (per_cu
, per_objfile
,
5461 /* Get the content of the .gdb_index section of OBJ. SECTION_OWNER should point
5462 to either a dwarf2_per_bfd or dwz_file object. */
5464 template <typename T
>
5465 static gdb::array_view
<const gdb_byte
>
5466 get_gdb_index_contents_from_section (objfile
*obj
, T
*section_owner
)
5468 dwarf2_section_info
*section
= §ion_owner
->gdb_index
;
5470 if (section
->empty ())
5473 /* Older elfutils strip versions could keep the section in the main
5474 executable while splitting it for the separate debug info file. */
5475 if ((section
->get_flags () & SEC_HAS_CONTENTS
) == 0)
5478 section
->read (obj
);
5480 /* dwarf2_section_info::size is a bfd_size_type, while
5481 gdb::array_view works with size_t. On 32-bit hosts, with
5482 --enable-64-bit-bfd, bfd_size_type is a 64-bit type, while size_t
5483 is 32-bit. So we need an explicit narrowing conversion here.
5484 This is fine, because it's impossible to allocate or mmap an
5485 array/buffer larger than what size_t can represent. */
5486 return gdb::make_array_view (section
->buffer
, section
->size
);
5489 /* Lookup the index cache for the contents of the index associated to
5492 static gdb::array_view
<const gdb_byte
>
5493 get_gdb_index_contents_from_cache (objfile
*obj
, dwarf2_per_bfd
*dwarf2_per_bfd
)
5495 const bfd_build_id
*build_id
= build_id_bfd_get (obj
->obfd
);
5496 if (build_id
== nullptr)
5499 return global_index_cache
.lookup_gdb_index (build_id
,
5500 &dwarf2_per_bfd
->index_cache_res
);
5503 /* Same as the above, but for DWZ. */
5505 static gdb::array_view
<const gdb_byte
>
5506 get_gdb_index_contents_from_cache_dwz (objfile
*obj
, dwz_file
*dwz
)
5508 const bfd_build_id
*build_id
= build_id_bfd_get (dwz
->dwz_bfd
.get ());
5509 if (build_id
== nullptr)
5512 return global_index_cache
.lookup_gdb_index (build_id
, &dwz
->index_cache_res
);
5515 /* See dwarf2/public.h. */
5518 dwarf2_initialize_objfile (struct objfile
*objfile
)
5520 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
5521 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
5523 dwarf_read_debug_printf ("called");
5525 /* If we're about to read full symbols, don't bother with the
5526 indices. In this case we also don't care if some other debug
5527 format is making psymtabs, because they are all about to be
5529 if ((objfile
->flags
& OBJF_READNOW
))
5531 dwarf_read_debug_printf ("readnow requested");
5533 /* When using READNOW, the using_index flag (set below) indicates that
5534 PER_BFD was already initialized, when we loaded some other objfile. */
5535 if (per_bfd
->using_index
)
5537 dwarf_read_debug_printf ("using_index already set");
5538 objfile
->qf
.push_front (make_dwarf_gdb_index ());
5542 per_bfd
->using_index
= 1;
5543 create_all_comp_units (per_objfile
);
5544 per_bfd
->quick_file_names_table
5545 = create_quick_file_names_table (per_bfd
->all_comp_units
.size ());
5547 for (int i
= 0; i
< per_bfd
->all_comp_units
.size (); ++i
)
5549 dwarf2_per_cu_data
*per_cu
= per_bfd
->get_cu (i
);
5551 per_cu
->v
.quick
= OBSTACK_ZALLOC (&per_bfd
->obstack
,
5552 struct dwarf2_per_cu_quick_data
);
5555 /* Arrange for gdb to see the "quick" functions. However, these
5556 functions will be no-ops because we will have expanded all
5558 objfile
->qf
.push_front (make_dwarf_gdb_index ());
5562 /* Was a debug names index already read when we processed an objfile sharing
5564 if (per_bfd
->debug_names_table
!= nullptr)
5566 dwarf_read_debug_printf ("re-using shared debug names table");
5567 objfile
->qf
.push_front (make_dwarf_debug_names ());
5571 /* Was a GDB index already read when we processed an objfile sharing
5573 if (per_bfd
->index_table
!= nullptr)
5575 dwarf_read_debug_printf ("re-using shared index table");
5576 objfile
->qf
.push_front (make_dwarf_gdb_index ());
5580 /* There might already be partial symtabs built for this BFD. This happens
5581 when loading the same binary twice with the index-cache enabled. If so,
5582 don't try to read an index. The objfile / per_objfile initialization will
5583 be completed in dwarf2_build_psymtabs, in the standard partial symtabs
5585 if (per_bfd
->partial_symtabs
!= nullptr)
5587 dwarf_read_debug_printf ("re-using shared partial symtabs");
5588 objfile
->qf
.push_front (make_lazy_dwarf_reader ());
5592 if (dwarf2_read_debug_names (per_objfile
))
5594 dwarf_read_debug_printf ("found debug names");
5595 objfile
->qf
.push_front (make_dwarf_debug_names ());
5599 if (dwarf2_read_gdb_index (per_objfile
,
5600 get_gdb_index_contents_from_section
<struct dwarf2_per_bfd
>,
5601 get_gdb_index_contents_from_section
<dwz_file
>))
5603 dwarf_read_debug_printf ("found gdb index from file");
5604 objfile
->qf
.push_front (make_dwarf_gdb_index ());
5608 /* ... otherwise, try to find the index in the index cache. */
5609 if (dwarf2_read_gdb_index (per_objfile
,
5610 get_gdb_index_contents_from_cache
,
5611 get_gdb_index_contents_from_cache_dwz
))
5613 dwarf_read_debug_printf ("found gdb index from cache");
5614 global_index_cache
.hit ();
5615 objfile
->qf
.push_front (make_dwarf_gdb_index ());
5619 global_index_cache
.miss ();
5620 objfile
->qf
.push_front (make_lazy_dwarf_reader ());
5625 /* Build a partial symbol table. */
5628 dwarf2_build_psymtabs (struct objfile
*objfile
, psymbol_functions
*psf
)
5630 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
5631 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
5633 if (per_bfd
->partial_symtabs
!= nullptr)
5635 /* Partial symbols were already read, so now we can simply
5639 psf
= new psymbol_functions (per_bfd
->partial_symtabs
);
5640 objfile
->qf
.emplace_front (psf
);
5643 psf
->set_partial_symtabs (per_bfd
->partial_symtabs
);
5649 psf
= new psymbol_functions
;
5650 objfile
->qf
.emplace_front (psf
);
5652 const std::shared_ptr
<psymtab_storage
> &partial_symtabs
5653 = psf
->get_partial_symtabs ();
5655 /* Set the local reference to partial symtabs, so that we don't try
5656 to read them again if reading another objfile with the same BFD.
5657 If we can't in fact share, this won't make a difference anyway as
5658 the dwarf2_per_bfd object won't be shared. */
5659 per_bfd
->partial_symtabs
= partial_symtabs
;
5663 /* This isn't really ideal: all the data we allocate on the
5664 objfile's obstack is still uselessly kept around. However,
5665 freeing it seems unsafe. */
5666 psymtab_discarder
psymtabs (partial_symtabs
.get ());
5667 dwarf2_build_psymtabs_hard (per_objfile
);
5670 /* (maybe) store an index in the cache. */
5671 global_index_cache
.store (per_objfile
);
5673 catch (const gdb_exception_error
&except
)
5675 exception_print (gdb_stderr
, except
);
5679 /* Find the base address of the compilation unit for range lists and
5680 location lists. It will normally be specified by DW_AT_low_pc.
5681 In DWARF-3 draft 4, the base address could be overridden by
5682 DW_AT_entry_pc. It's been removed, but GCC still uses this for
5683 compilation units with discontinuous ranges. */
5686 dwarf2_find_base_address (struct die_info
*die
, struct dwarf2_cu
*cu
)
5688 struct attribute
*attr
;
5690 cu
->base_address
.reset ();
5692 attr
= dwarf2_attr (die
, DW_AT_entry_pc
, cu
);
5693 if (attr
!= nullptr)
5694 cu
->base_address
= attr
->as_address ();
5697 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
5698 if (attr
!= nullptr)
5699 cu
->base_address
= attr
->as_address ();
5703 /* Helper function that returns the proper abbrev section for
5706 static struct dwarf2_section_info
*
5707 get_abbrev_section_for_cu (struct dwarf2_per_cu_data
*this_cu
)
5709 struct dwarf2_section_info
*abbrev
;
5710 dwarf2_per_bfd
*per_bfd
= this_cu
->per_bfd
;
5712 if (this_cu
->is_dwz
)
5713 abbrev
= &dwarf2_get_dwz_file (per_bfd
, true)->abbrev
;
5715 abbrev
= &per_bfd
->abbrev
;
5720 /* Fetch the abbreviation table offset from a comp or type unit header. */
5723 read_abbrev_offset (dwarf2_per_objfile
*per_objfile
,
5724 struct dwarf2_section_info
*section
,
5725 sect_offset sect_off
)
5727 bfd
*abfd
= section
->get_bfd_owner ();
5728 const gdb_byte
*info_ptr
;
5729 unsigned int initial_length_size
, offset_size
;
5732 section
->read (per_objfile
->objfile
);
5733 info_ptr
= section
->buffer
+ to_underlying (sect_off
);
5734 read_initial_length (abfd
, info_ptr
, &initial_length_size
);
5735 offset_size
= initial_length_size
== 4 ? 4 : 8;
5736 info_ptr
+= initial_length_size
;
5738 version
= read_2_bytes (abfd
, info_ptr
);
5742 /* Skip unit type and address size. */
5746 return (sect_offset
) read_offset (abfd
, info_ptr
, offset_size
);
5749 /* A partial symtab that is used only for include files. */
5750 struct dwarf2_include_psymtab
: public partial_symtab
5752 dwarf2_include_psymtab (const char *filename
,
5753 psymtab_storage
*partial_symtabs
,
5754 objfile_per_bfd_storage
*objfile_per_bfd
)
5755 : partial_symtab (filename
, partial_symtabs
, objfile_per_bfd
)
5759 void read_symtab (struct objfile
*objfile
) override
5761 /* It's an include file, no symbols to read for it.
5762 Everything is in the includer symtab. */
5764 /* The expansion of a dwarf2_include_psymtab is just a trigger for
5765 expansion of the includer psymtab. We use the dependencies[0] field to
5766 model the includer. But if we go the regular route of calling
5767 expand_psymtab here, and having expand_psymtab call expand_dependencies
5768 to expand the includer, we'll only use expand_psymtab on the includer
5769 (making it a non-toplevel psymtab), while if we expand the includer via
5770 another path, we'll use read_symtab (making it a toplevel psymtab).
5771 So, don't pretend a dwarf2_include_psymtab is an actual toplevel
5772 psymtab, and trigger read_symtab on the includer here directly. */
5773 includer ()->read_symtab (objfile
);
5776 void expand_psymtab (struct objfile
*objfile
) override
5778 /* This is not called by read_symtab, and should not be called by any
5779 expand_dependencies. */
5783 bool readin_p (struct objfile
*objfile
) const override
5785 return includer ()->readin_p (objfile
);
5788 compunit_symtab
*get_compunit_symtab (struct objfile
*objfile
) const override
5794 partial_symtab
*includer () const
5796 /* An include psymtab has exactly one dependency: the psymtab that
5798 gdb_assert (this->number_of_dependencies
== 1);
5799 return this->dependencies
[0];
5803 /* Allocate a new partial symtab for file named NAME and mark this new
5804 partial symtab as being an include of PST. */
5807 dwarf2_create_include_psymtab (dwarf2_per_bfd
*per_bfd
,
5809 dwarf2_psymtab
*pst
,
5810 psymtab_storage
*partial_symtabs
,
5811 objfile_per_bfd_storage
*objfile_per_bfd
)
5813 dwarf2_include_psymtab
*subpst
5814 = new dwarf2_include_psymtab (name
, partial_symtabs
, objfile_per_bfd
);
5816 if (!IS_ABSOLUTE_PATH (subpst
->filename
))
5817 subpst
->dirname
= pst
->dirname
;
5819 subpst
->dependencies
= per_bfd
->partial_symtabs
->allocate_dependencies (1);
5820 subpst
->dependencies
[0] = pst
;
5821 subpst
->number_of_dependencies
= 1;
5824 /* Read the Line Number Program data and extract the list of files
5825 included by the source file represented by PST. Build an include
5826 partial symtab for each of these included files. */
5829 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
5830 struct die_info
*die
,
5831 const file_and_directory
&fnd
,
5832 dwarf2_psymtab
*pst
)
5835 struct attribute
*attr
;
5837 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
5838 if (attr
!= nullptr && attr
->form_is_unsigned ())
5839 lh
= dwarf_decode_line_header ((sect_offset
) attr
->as_unsigned (), cu
);
5841 return; /* No linetable, so no includes. */
5843 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). Also note
5844 that we pass in the raw text_low here; that is ok because we're
5845 only decoding the line table to make include partial symtabs, and
5846 so the addresses aren't really used. */
5847 dwarf_decode_lines (lh
.get (), fnd
, cu
, pst
,
5848 pst
->raw_text_low (), 1);
5852 hash_signatured_type (const void *item
)
5854 const struct signatured_type
*sig_type
5855 = (const struct signatured_type
*) item
;
5857 /* This drops the top 32 bits of the signature, but is ok for a hash. */
5858 return sig_type
->signature
;
5862 eq_signatured_type (const void *item_lhs
, const void *item_rhs
)
5864 const struct signatured_type
*lhs
= (const struct signatured_type
*) item_lhs
;
5865 const struct signatured_type
*rhs
= (const struct signatured_type
*) item_rhs
;
5867 return lhs
->signature
== rhs
->signature
;
5870 /* Allocate a hash table for signatured types. */
5873 allocate_signatured_type_table ()
5875 return htab_up (htab_create_alloc (41,
5876 hash_signatured_type
,
5878 NULL
, xcalloc
, xfree
));
5881 /* A helper for create_debug_types_hash_table. Read types from SECTION
5882 and fill them into TYPES_HTAB. It will process only type units,
5883 therefore DW_UT_type. */
5886 create_debug_type_hash_table (dwarf2_per_objfile
*per_objfile
,
5887 struct dwo_file
*dwo_file
,
5888 dwarf2_section_info
*section
, htab_up
&types_htab
,
5889 rcuh_kind section_kind
)
5891 struct objfile
*objfile
= per_objfile
->objfile
;
5892 struct dwarf2_section_info
*abbrev_section
;
5894 const gdb_byte
*info_ptr
, *end_ptr
;
5896 abbrev_section
= &dwo_file
->sections
.abbrev
;
5898 dwarf_read_debug_printf ("Reading %s for %s",
5899 section
->get_name (),
5900 abbrev_section
->get_file_name ());
5902 section
->read (objfile
);
5903 info_ptr
= section
->buffer
;
5905 if (info_ptr
== NULL
)
5908 /* We can't set abfd until now because the section may be empty or
5909 not present, in which case the bfd is unknown. */
5910 abfd
= section
->get_bfd_owner ();
5912 /* We don't use cutu_reader here because we don't need to read
5913 any dies: the signature is in the header. */
5915 end_ptr
= info_ptr
+ section
->size
;
5916 while (info_ptr
< end_ptr
)
5918 signatured_type_up sig_type
;
5919 struct dwo_unit
*dwo_tu
;
5921 const gdb_byte
*ptr
= info_ptr
;
5922 struct comp_unit_head header
;
5923 unsigned int length
;
5925 sect_offset sect_off
= (sect_offset
) (ptr
- section
->buffer
);
5927 /* Initialize it due to a false compiler warning. */
5928 header
.signature
= -1;
5929 header
.type_cu_offset_in_tu
= (cu_offset
) -1;
5931 /* We need to read the type's signature in order to build the hash
5932 table, but we don't need anything else just yet. */
5934 ptr
= read_and_check_comp_unit_head (per_objfile
, &header
, section
,
5935 abbrev_section
, ptr
, section_kind
);
5937 length
= header
.get_length ();
5939 /* Skip dummy type units. */
5940 if (ptr
>= info_ptr
+ length
5941 || peek_abbrev_code (abfd
, ptr
) == 0
5942 || (header
.unit_type
!= DW_UT_type
5943 && header
.unit_type
!= DW_UT_split_type
))
5949 if (types_htab
== NULL
)
5950 types_htab
= allocate_dwo_unit_table ();
5952 dwo_tu
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, dwo_unit
);
5953 dwo_tu
->dwo_file
= dwo_file
;
5954 dwo_tu
->signature
= header
.signature
;
5955 dwo_tu
->type_offset_in_tu
= header
.type_cu_offset_in_tu
;
5956 dwo_tu
->section
= section
;
5957 dwo_tu
->sect_off
= sect_off
;
5958 dwo_tu
->length
= length
;
5960 slot
= htab_find_slot (types_htab
.get (), dwo_tu
, INSERT
);
5961 gdb_assert (slot
!= NULL
);
5963 complaint (_("debug type entry at offset %s is duplicate to"
5964 " the entry at offset %s, signature %s"),
5965 sect_offset_str (sect_off
),
5966 sect_offset_str (dwo_tu
->sect_off
),
5967 hex_string (header
.signature
));
5970 dwarf_read_debug_printf_v (" offset %s, signature %s",
5971 sect_offset_str (sect_off
),
5972 hex_string (header
.signature
));
5978 /* Create the hash table of all entries in the .debug_types
5979 (or .debug_types.dwo) section(s).
5980 DWO_FILE is a pointer to the DWO file object.
5982 The result is a pointer to the hash table or NULL if there are no types.
5984 Note: This function processes DWO files only, not DWP files. */
5987 create_debug_types_hash_table (dwarf2_per_objfile
*per_objfile
,
5988 struct dwo_file
*dwo_file
,
5989 gdb::array_view
<dwarf2_section_info
> type_sections
,
5990 htab_up
&types_htab
)
5992 for (dwarf2_section_info
§ion
: type_sections
)
5993 create_debug_type_hash_table (per_objfile
, dwo_file
, §ion
, types_htab
,
5997 /* Add an entry for signature SIG to dwarf2_per_objfile->per_bfd->signatured_types.
5998 If SLOT is non-NULL, it is the entry to use in the hash table.
5999 Otherwise we find one. */
6001 static struct signatured_type
*
6002 add_type_unit (dwarf2_per_objfile
*per_objfile
, ULONGEST sig
, void **slot
)
6004 if (per_objfile
->per_bfd
->all_comp_units
.size ()
6005 == per_objfile
->per_bfd
->all_comp_units
.capacity ())
6006 ++per_objfile
->per_bfd
->tu_stats
.nr_all_type_units_reallocs
;
6008 signatured_type_up sig_type_holder
6009 = per_objfile
->per_bfd
->allocate_signatured_type (sig
);
6010 signatured_type
*sig_type
= sig_type_holder
.get ();
6012 per_objfile
->per_bfd
->all_comp_units
.emplace_back
6013 (sig_type_holder
.release ());
6014 if (per_objfile
->per_bfd
->using_index
)
6017 OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
,
6018 struct dwarf2_per_cu_quick_data
);
6023 slot
= htab_find_slot (per_objfile
->per_bfd
->signatured_types
.get (),
6026 gdb_assert (*slot
== NULL
);
6028 /* The rest of sig_type must be filled in by the caller. */
6032 /* Subroutine of lookup_dwo_signatured_type and lookup_dwp_signatured_type.
6033 Fill in SIG_ENTRY with DWO_ENTRY. */
6036 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile
*per_objfile
,
6037 struct signatured_type
*sig_entry
,
6038 struct dwo_unit
*dwo_entry
)
6040 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
6042 /* Make sure we're not clobbering something we don't expect to. */
6043 gdb_assert (! sig_entry
->queued
);
6044 gdb_assert (per_objfile
->get_cu (sig_entry
) == NULL
);
6045 if (per_bfd
->using_index
)
6047 gdb_assert (sig_entry
->v
.quick
!= NULL
);
6048 gdb_assert (!per_objfile
->symtab_set_p (sig_entry
));
6051 gdb_assert (sig_entry
->v
.psymtab
== NULL
);
6052 gdb_assert (sig_entry
->signature
== dwo_entry
->signature
);
6053 gdb_assert (to_underlying (sig_entry
->type_offset_in_section
) == 0);
6054 gdb_assert (sig_entry
->type_unit_group
== NULL
);
6055 gdb_assert (sig_entry
->dwo_unit
== NULL
);
6057 sig_entry
->section
= dwo_entry
->section
;
6058 sig_entry
->sect_off
= dwo_entry
->sect_off
;
6059 sig_entry
->length
= dwo_entry
->length
;
6060 sig_entry
->reading_dwo_directly
= 1;
6061 sig_entry
->per_bfd
= per_bfd
;
6062 sig_entry
->type_offset_in_tu
= dwo_entry
->type_offset_in_tu
;
6063 sig_entry
->dwo_unit
= dwo_entry
;
6066 /* Subroutine of lookup_signatured_type.
6067 If we haven't read the TU yet, create the signatured_type data structure
6068 for a TU to be read in directly from a DWO file, bypassing the stub.
6069 This is the "Stay in DWO Optimization": When there is no DWP file and we're
6070 using .gdb_index, then when reading a CU we want to stay in the DWO file
6071 containing that CU. Otherwise we could end up reading several other DWO
6072 files (due to comdat folding) to process the transitive closure of all the
6073 mentioned TUs, and that can be slow. The current DWO file will have every
6074 type signature that it needs.
6075 We only do this for .gdb_index because in the psymtab case we already have
6076 to read all the DWOs to build the type unit groups. */
6078 static struct signatured_type
*
6079 lookup_dwo_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
6081 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
6082 struct dwo_file
*dwo_file
;
6083 struct dwo_unit find_dwo_entry
, *dwo_entry
;
6086 gdb_assert (cu
->dwo_unit
&& per_objfile
->per_bfd
->using_index
);
6088 /* If TU skeletons have been removed then we may not have read in any
6090 if (per_objfile
->per_bfd
->signatured_types
== NULL
)
6091 per_objfile
->per_bfd
->signatured_types
= allocate_signatured_type_table ();
6093 /* We only ever need to read in one copy of a signatured type.
6094 Use the global signatured_types array to do our own comdat-folding
6095 of types. If this is the first time we're reading this TU, and
6096 the TU has an entry in .gdb_index, replace the recorded data from
6097 .gdb_index with this TU. */
6099 signatured_type
find_sig_entry (sig
);
6100 slot
= htab_find_slot (per_objfile
->per_bfd
->signatured_types
.get (),
6101 &find_sig_entry
, INSERT
);
6102 signatured_type
*sig_entry
= (struct signatured_type
*) *slot
;
6104 /* We can get here with the TU already read, *or* in the process of being
6105 read. Don't reassign the global entry to point to this DWO if that's
6106 the case. Also note that if the TU is already being read, it may not
6107 have come from a DWO, the program may be a mix of Fission-compiled
6108 code and non-Fission-compiled code. */
6110 /* Have we already tried to read this TU?
6111 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
6112 needn't exist in the global table yet). */
6113 if (sig_entry
!= NULL
&& sig_entry
->tu_read
)
6116 /* Note: cu->dwo_unit is the dwo_unit that references this TU, not the
6117 dwo_unit of the TU itself. */
6118 dwo_file
= cu
->dwo_unit
->dwo_file
;
6120 /* Ok, this is the first time we're reading this TU. */
6121 if (dwo_file
->tus
== NULL
)
6123 find_dwo_entry
.signature
= sig
;
6124 dwo_entry
= (struct dwo_unit
*) htab_find (dwo_file
->tus
.get (),
6126 if (dwo_entry
== NULL
)
6129 /* If the global table doesn't have an entry for this TU, add one. */
6130 if (sig_entry
== NULL
)
6131 sig_entry
= add_type_unit (per_objfile
, sig
, slot
);
6133 fill_in_sig_entry_from_dwo_entry (per_objfile
, sig_entry
, dwo_entry
);
6134 sig_entry
->tu_read
= 1;
6138 /* Subroutine of lookup_signatured_type.
6139 Look up the type for signature SIG, and if we can't find SIG in .gdb_index
6140 then try the DWP file. If the TU stub (skeleton) has been removed then
6141 it won't be in .gdb_index. */
6143 static struct signatured_type
*
6144 lookup_dwp_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
6146 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
6147 struct dwp_file
*dwp_file
= get_dwp_file (per_objfile
);
6148 struct dwo_unit
*dwo_entry
;
6151 gdb_assert (cu
->dwo_unit
&& per_objfile
->per_bfd
->using_index
);
6152 gdb_assert (dwp_file
!= NULL
);
6154 /* If TU skeletons have been removed then we may not have read in any
6156 if (per_objfile
->per_bfd
->signatured_types
== NULL
)
6157 per_objfile
->per_bfd
->signatured_types
= allocate_signatured_type_table ();
6159 signatured_type
find_sig_entry (sig
);
6160 slot
= htab_find_slot (per_objfile
->per_bfd
->signatured_types
.get (),
6161 &find_sig_entry
, INSERT
);
6162 signatured_type
*sig_entry
= (struct signatured_type
*) *slot
;
6164 /* Have we already tried to read this TU?
6165 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
6166 needn't exist in the global table yet). */
6167 if (sig_entry
!= NULL
)
6170 if (dwp_file
->tus
== NULL
)
6172 dwo_entry
= lookup_dwo_unit_in_dwp (per_objfile
, dwp_file
, NULL
, sig
,
6173 1 /* is_debug_types */);
6174 if (dwo_entry
== NULL
)
6177 sig_entry
= add_type_unit (per_objfile
, sig
, slot
);
6178 fill_in_sig_entry_from_dwo_entry (per_objfile
, sig_entry
, dwo_entry
);
6183 /* Lookup a signature based type for DW_FORM_ref_sig8.
6184 Returns NULL if signature SIG is not present in the table.
6185 It is up to the caller to complain about this. */
6187 static struct signatured_type
*
6188 lookup_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
6190 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
6192 if (cu
->dwo_unit
&& per_objfile
->per_bfd
->using_index
)
6194 /* We're in a DWO/DWP file, and we're using .gdb_index.
6195 These cases require special processing. */
6196 if (get_dwp_file (per_objfile
) == NULL
)
6197 return lookup_dwo_signatured_type (cu
, sig
);
6199 return lookup_dwp_signatured_type (cu
, sig
);
6203 if (per_objfile
->per_bfd
->signatured_types
== NULL
)
6205 signatured_type
find_entry (sig
);
6206 return ((struct signatured_type
*)
6207 htab_find (per_objfile
->per_bfd
->signatured_types
.get (),
6212 /* Low level DIE reading support. */
6214 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
6217 init_cu_die_reader (struct die_reader_specs
*reader
,
6218 struct dwarf2_cu
*cu
,
6219 struct dwarf2_section_info
*section
,
6220 struct dwo_file
*dwo_file
,
6221 struct abbrev_table
*abbrev_table
)
6223 gdb_assert (section
->readin
&& section
->buffer
!= NULL
);
6224 reader
->abfd
= section
->get_bfd_owner ();
6226 reader
->dwo_file
= dwo_file
;
6227 reader
->die_section
= section
;
6228 reader
->buffer
= section
->buffer
;
6229 reader
->buffer_end
= section
->buffer
+ section
->size
;
6230 reader
->abbrev_table
= abbrev_table
;
6233 /* Subroutine of cutu_reader to simplify it.
6234 Read in the rest of a CU/TU top level DIE from DWO_UNIT.
6235 There's just a lot of work to do, and cutu_reader is big enough
6238 STUB_COMP_UNIT_DIE is for the stub DIE, we copy over certain attributes
6239 from it to the DIE in the DWO. If NULL we are skipping the stub.
6240 STUB_COMP_DIR is similar to STUB_COMP_UNIT_DIE: When reading a TU directly
6241 from the DWO file, bypassing the stub, it contains the DW_AT_comp_dir
6242 attribute of the referencing CU. At most one of STUB_COMP_UNIT_DIE and
6243 STUB_COMP_DIR may be non-NULL.
6244 *RESULT_READER,*RESULT_INFO_PTR,*RESULT_COMP_UNIT_DIE
6245 are filled in with the info of the DIE from the DWO file.
6246 *RESULT_DWO_ABBREV_TABLE will be filled in with the abbrev table allocated
6247 from the dwo. Since *RESULT_READER references this abbrev table, it must be
6248 kept around for at least as long as *RESULT_READER.
6250 The result is non-zero if a valid (non-dummy) DIE was found. */
6253 read_cutu_die_from_dwo (dwarf2_cu
*cu
,
6254 struct dwo_unit
*dwo_unit
,
6255 struct die_info
*stub_comp_unit_die
,
6256 const char *stub_comp_dir
,
6257 struct die_reader_specs
*result_reader
,
6258 const gdb_byte
**result_info_ptr
,
6259 struct die_info
**result_comp_unit_die
,
6260 abbrev_table_up
*result_dwo_abbrev_table
)
6262 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
6263 dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
6264 struct objfile
*objfile
= per_objfile
->objfile
;
6266 const gdb_byte
*begin_info_ptr
, *info_ptr
;
6267 struct attribute
*comp_dir
, *stmt_list
, *low_pc
, *high_pc
, *ranges
;
6268 int i
,num_extra_attrs
;
6269 struct dwarf2_section_info
*dwo_abbrev_section
;
6270 struct die_info
*comp_unit_die
;
6272 /* At most one of these may be provided. */
6273 gdb_assert ((stub_comp_unit_die
!= NULL
) + (stub_comp_dir
!= NULL
) <= 1);
6275 /* These attributes aren't processed until later:
6276 DW_AT_stmt_list, DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges.
6277 DW_AT_comp_dir is used now, to find the DWO file, but it is also
6278 referenced later. However, these attributes are found in the stub
6279 which we won't have later. In order to not impose this complication
6280 on the rest of the code, we read them here and copy them to the
6289 if (stub_comp_unit_die
!= NULL
)
6291 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
6293 if (!per_cu
->is_debug_types
)
6294 stmt_list
= dwarf2_attr (stub_comp_unit_die
, DW_AT_stmt_list
, cu
);
6295 low_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_low_pc
, cu
);
6296 high_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_high_pc
, cu
);
6297 ranges
= dwarf2_attr (stub_comp_unit_die
, DW_AT_ranges
, cu
);
6298 comp_dir
= dwarf2_attr (stub_comp_unit_die
, DW_AT_comp_dir
, cu
);
6300 cu
->addr_base
= stub_comp_unit_die
->addr_base ();
6302 /* There should be a DW_AT_GNU_ranges_base attribute here (if needed).
6303 We need the value before we can process DW_AT_ranges values from the
6305 cu
->gnu_ranges_base
= stub_comp_unit_die
->gnu_ranges_base ();
6307 /* For DWARF5: record the DW_AT_rnglists_base value from the skeleton. If
6308 there are attributes of form DW_FORM_rnglistx in the skeleton, they'll
6309 need the rnglists base. Attributes of form DW_FORM_rnglistx in the
6310 split unit don't use it, as the DWO has its own .debug_rnglists.dwo
6312 cu
->rnglists_base
= stub_comp_unit_die
->rnglists_base ();
6314 else if (stub_comp_dir
!= NULL
)
6316 /* Reconstruct the comp_dir attribute to simplify the code below. */
6317 comp_dir
= OBSTACK_ZALLOC (&cu
->comp_unit_obstack
, struct attribute
);
6318 comp_dir
->name
= DW_AT_comp_dir
;
6319 comp_dir
->form
= DW_FORM_string
;
6320 comp_dir
->set_string_noncanonical (stub_comp_dir
);
6323 /* Set up for reading the DWO CU/TU. */
6324 cu
->dwo_unit
= dwo_unit
;
6325 dwarf2_section_info
*section
= dwo_unit
->section
;
6326 section
->read (objfile
);
6327 abfd
= section
->get_bfd_owner ();
6328 begin_info_ptr
= info_ptr
= (section
->buffer
6329 + to_underlying (dwo_unit
->sect_off
));
6330 dwo_abbrev_section
= &dwo_unit
->dwo_file
->sections
.abbrev
;
6332 if (per_cu
->is_debug_types
)
6334 signatured_type
*sig_type
= (struct signatured_type
*) per_cu
;
6336 info_ptr
= read_and_check_comp_unit_head (per_objfile
, &cu
->header
,
6337 section
, dwo_abbrev_section
,
6338 info_ptr
, rcuh_kind::TYPE
);
6339 /* This is not an assert because it can be caused by bad debug info. */
6340 if (sig_type
->signature
!= cu
->header
.signature
)
6342 error (_("Dwarf Error: signature mismatch %s vs %s while reading"
6343 " TU at offset %s [in module %s]"),
6344 hex_string (sig_type
->signature
),
6345 hex_string (cu
->header
.signature
),
6346 sect_offset_str (dwo_unit
->sect_off
),
6347 bfd_get_filename (abfd
));
6349 gdb_assert (dwo_unit
->sect_off
== cu
->header
.sect_off
);
6350 /* For DWOs coming from DWP files, we don't know the CU length
6351 nor the type's offset in the TU until now. */
6352 dwo_unit
->length
= cu
->header
.get_length ();
6353 dwo_unit
->type_offset_in_tu
= cu
->header
.type_cu_offset_in_tu
;
6355 /* Establish the type offset that can be used to lookup the type.
6356 For DWO files, we don't know it until now. */
6357 sig_type
->type_offset_in_section
6358 = dwo_unit
->sect_off
+ to_underlying (dwo_unit
->type_offset_in_tu
);
6362 info_ptr
= read_and_check_comp_unit_head (per_objfile
, &cu
->header
,
6363 section
, dwo_abbrev_section
,
6364 info_ptr
, rcuh_kind::COMPILE
);
6365 gdb_assert (dwo_unit
->sect_off
== cu
->header
.sect_off
);
6366 /* For DWOs coming from DWP files, we don't know the CU length
6368 dwo_unit
->length
= cu
->header
.get_length ();
6371 dwo_abbrev_section
->read (objfile
);
6372 *result_dwo_abbrev_table
6373 = abbrev_table::read (dwo_abbrev_section
, cu
->header
.abbrev_sect_off
);
6374 init_cu_die_reader (result_reader
, cu
, section
, dwo_unit
->dwo_file
,
6375 result_dwo_abbrev_table
->get ());
6377 /* Read in the die, but leave space to copy over the attributes
6378 from the stub. This has the benefit of simplifying the rest of
6379 the code - all the work to maintain the illusion of a single
6380 DW_TAG_{compile,type}_unit DIE is done here. */
6381 num_extra_attrs
= ((stmt_list
!= NULL
)
6385 + (comp_dir
!= NULL
));
6386 info_ptr
= read_full_die_1 (result_reader
, result_comp_unit_die
, info_ptr
,
6389 /* Copy over the attributes from the stub to the DIE we just read in. */
6390 comp_unit_die
= *result_comp_unit_die
;
6391 i
= comp_unit_die
->num_attrs
;
6392 if (stmt_list
!= NULL
)
6393 comp_unit_die
->attrs
[i
++] = *stmt_list
;
6395 comp_unit_die
->attrs
[i
++] = *low_pc
;
6396 if (high_pc
!= NULL
)
6397 comp_unit_die
->attrs
[i
++] = *high_pc
;
6399 comp_unit_die
->attrs
[i
++] = *ranges
;
6400 if (comp_dir
!= NULL
)
6401 comp_unit_die
->attrs
[i
++] = *comp_dir
;
6402 comp_unit_die
->num_attrs
+= num_extra_attrs
;
6404 if (dwarf_die_debug
)
6406 fprintf_unfiltered (gdb_stdlog
,
6407 "Read die from %s@0x%x of %s:\n",
6408 section
->get_name (),
6409 (unsigned) (begin_info_ptr
- section
->buffer
),
6410 bfd_get_filename (abfd
));
6411 dump_die (comp_unit_die
, dwarf_die_debug
);
6414 /* Skip dummy compilation units. */
6415 if (info_ptr
>= begin_info_ptr
+ dwo_unit
->length
6416 || peek_abbrev_code (abfd
, info_ptr
) == 0)
6419 *result_info_ptr
= info_ptr
;
6423 /* Return the signature of the compile unit, if found. In DWARF 4 and before,
6424 the signature is in the DW_AT_GNU_dwo_id attribute. In DWARF 5 and later, the
6425 signature is part of the header. */
6426 static gdb::optional
<ULONGEST
>
6427 lookup_dwo_id (struct dwarf2_cu
*cu
, struct die_info
* comp_unit_die
)
6429 if (cu
->header
.version
>= 5)
6430 return cu
->header
.signature
;
6431 struct attribute
*attr
;
6432 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_id
, cu
);
6433 if (attr
== nullptr || !attr
->form_is_unsigned ())
6434 return gdb::optional
<ULONGEST
> ();
6435 return attr
->as_unsigned ();
6438 /* Subroutine of cutu_reader to simplify it.
6439 Look up the DWO unit specified by COMP_UNIT_DIE of THIS_CU.
6440 Returns NULL if the specified DWO unit cannot be found. */
6442 static struct dwo_unit
*
6443 lookup_dwo_unit (dwarf2_cu
*cu
, die_info
*comp_unit_die
, const char *dwo_name
)
6445 dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
6446 struct dwo_unit
*dwo_unit
;
6447 const char *comp_dir
;
6449 gdb_assert (cu
!= NULL
);
6451 /* Yeah, we look dwo_name up again, but it simplifies the code. */
6452 dwo_name
= dwarf2_dwo_name (comp_unit_die
, cu
);
6453 comp_dir
= dwarf2_string_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
6455 if (per_cu
->is_debug_types
)
6456 dwo_unit
= lookup_dwo_type_unit (cu
, dwo_name
, comp_dir
);
6459 gdb::optional
<ULONGEST
> signature
= lookup_dwo_id (cu
, comp_unit_die
);
6461 if (!signature
.has_value ())
6462 error (_("Dwarf Error: missing dwo_id for dwo_name %s"
6464 dwo_name
, bfd_get_filename (per_cu
->per_bfd
->obfd
));
6466 dwo_unit
= lookup_dwo_comp_unit (cu
, dwo_name
, comp_dir
, *signature
);
6472 /* Subroutine of cutu_reader to simplify it.
6473 See it for a description of the parameters.
6474 Read a TU directly from a DWO file, bypassing the stub. */
6477 cutu_reader::init_tu_and_read_dwo_dies (dwarf2_per_cu_data
*this_cu
,
6478 dwarf2_per_objfile
*per_objfile
,
6479 dwarf2_cu
*existing_cu
)
6481 struct signatured_type
*sig_type
;
6483 /* Verify we can do the following downcast, and that we have the
6485 gdb_assert (this_cu
->is_debug_types
&& this_cu
->reading_dwo_directly
);
6486 sig_type
= (struct signatured_type
*) this_cu
;
6487 gdb_assert (sig_type
->dwo_unit
!= NULL
);
6491 if (existing_cu
!= nullptr)
6494 gdb_assert (cu
->dwo_unit
== sig_type
->dwo_unit
);
6495 /* There's no need to do the rereading_dwo_cu handling that
6496 cutu_reader does since we don't read the stub. */
6500 /* If an existing_cu is provided, a dwarf2_cu must not exist for this_cu
6501 in per_objfile yet. */
6502 gdb_assert (per_objfile
->get_cu (this_cu
) == nullptr);
6503 m_new_cu
.reset (new dwarf2_cu (this_cu
, per_objfile
));
6504 cu
= m_new_cu
.get ();
6507 /* A future optimization, if needed, would be to use an existing
6508 abbrev table. When reading DWOs with skeletonless TUs, all the TUs
6509 could share abbrev tables. */
6511 if (read_cutu_die_from_dwo (cu
, sig_type
->dwo_unit
,
6512 NULL
/* stub_comp_unit_die */,
6513 sig_type
->dwo_unit
->dwo_file
->comp_dir
,
6516 &m_dwo_abbrev_table
) == 0)
6523 /* Initialize a CU (or TU) and read its DIEs.
6524 If the CU defers to a DWO file, read the DWO file as well.
6526 ABBREV_TABLE, if non-NULL, is the abbreviation table to use.
6527 Otherwise the table specified in the comp unit header is read in and used.
6528 This is an optimization for when we already have the abbrev table.
6530 If EXISTING_CU is non-NULL, then use it. Otherwise, a new CU is
6533 cutu_reader::cutu_reader (dwarf2_per_cu_data
*this_cu
,
6534 dwarf2_per_objfile
*per_objfile
,
6535 struct abbrev_table
*abbrev_table
,
6536 dwarf2_cu
*existing_cu
,
6538 : die_reader_specs
{},
6541 struct objfile
*objfile
= per_objfile
->objfile
;
6542 struct dwarf2_section_info
*section
= this_cu
->section
;
6543 bfd
*abfd
= section
->get_bfd_owner ();
6544 const gdb_byte
*begin_info_ptr
;
6545 struct signatured_type
*sig_type
= NULL
;
6546 struct dwarf2_section_info
*abbrev_section
;
6547 /* Non-zero if CU currently points to a DWO file and we need to
6548 reread it. When this happens we need to reread the skeleton die
6549 before we can reread the DWO file (this only applies to CUs, not TUs). */
6550 int rereading_dwo_cu
= 0;
6552 if (dwarf_die_debug
)
6553 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset %s\n",
6554 this_cu
->is_debug_types
? "type" : "comp",
6555 sect_offset_str (this_cu
->sect_off
));
6557 /* If we're reading a TU directly from a DWO file, including a virtual DWO
6558 file (instead of going through the stub), short-circuit all of this. */
6559 if (this_cu
->reading_dwo_directly
)
6561 /* Narrow down the scope of possibilities to have to understand. */
6562 gdb_assert (this_cu
->is_debug_types
);
6563 gdb_assert (abbrev_table
== NULL
);
6564 init_tu_and_read_dwo_dies (this_cu
, per_objfile
, existing_cu
);
6568 /* This is cheap if the section is already read in. */
6569 section
->read (objfile
);
6571 begin_info_ptr
= info_ptr
= section
->buffer
+ to_underlying (this_cu
->sect_off
);
6573 abbrev_section
= get_abbrev_section_for_cu (this_cu
);
6577 if (existing_cu
!= nullptr)
6580 /* If this CU is from a DWO file we need to start over, we need to
6581 refetch the attributes from the skeleton CU.
6582 This could be optimized by retrieving those attributes from when we
6583 were here the first time: the previous comp_unit_die was stored in
6584 comp_unit_obstack. But there's no data yet that we need this
6586 if (cu
->dwo_unit
!= NULL
)
6587 rereading_dwo_cu
= 1;
6591 /* If an existing_cu is provided, a dwarf2_cu must not exist for this_cu
6592 in per_objfile yet. */
6593 gdb_assert (per_objfile
->get_cu (this_cu
) == nullptr);
6594 m_new_cu
.reset (new dwarf2_cu (this_cu
, per_objfile
));
6595 cu
= m_new_cu
.get ();
6598 /* Get the header. */
6599 if (to_underlying (cu
->header
.first_die_cu_offset
) != 0 && !rereading_dwo_cu
)
6601 /* We already have the header, there's no need to read it in again. */
6602 info_ptr
+= to_underlying (cu
->header
.first_die_cu_offset
);
6606 if (this_cu
->is_debug_types
)
6608 info_ptr
= read_and_check_comp_unit_head (per_objfile
, &cu
->header
,
6609 section
, abbrev_section
,
6610 info_ptr
, rcuh_kind::TYPE
);
6612 /* Since per_cu is the first member of struct signatured_type,
6613 we can go from a pointer to one to a pointer to the other. */
6614 sig_type
= (struct signatured_type
*) this_cu
;
6615 gdb_assert (sig_type
->signature
== cu
->header
.signature
);
6616 gdb_assert (sig_type
->type_offset_in_tu
6617 == cu
->header
.type_cu_offset_in_tu
);
6618 gdb_assert (this_cu
->sect_off
== cu
->header
.sect_off
);
6620 /* LENGTH has not been set yet for type units if we're
6621 using .gdb_index. */
6622 this_cu
->length
= cu
->header
.get_length ();
6624 /* Establish the type offset that can be used to lookup the type. */
6625 sig_type
->type_offset_in_section
=
6626 this_cu
->sect_off
+ to_underlying (sig_type
->type_offset_in_tu
);
6628 this_cu
->dwarf_version
= cu
->header
.version
;
6632 info_ptr
= read_and_check_comp_unit_head (per_objfile
, &cu
->header
,
6633 section
, abbrev_section
,
6635 rcuh_kind::COMPILE
);
6637 gdb_assert (this_cu
->sect_off
== cu
->header
.sect_off
);
6638 if (this_cu
->length
== 0)
6639 this_cu
->length
= cu
->header
.get_length ();
6641 gdb_assert (this_cu
->length
== cu
->header
.get_length ());
6642 this_cu
->dwarf_version
= cu
->header
.version
;
6646 /* Skip dummy compilation units. */
6647 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
6648 || peek_abbrev_code (abfd
, info_ptr
) == 0)
6654 /* If we don't have them yet, read the abbrevs for this compilation unit.
6655 And if we need to read them now, make sure they're freed when we're
6657 if (abbrev_table
!= NULL
)
6658 gdb_assert (cu
->header
.abbrev_sect_off
== abbrev_table
->sect_off
);
6661 abbrev_section
->read (objfile
);
6662 m_abbrev_table_holder
6663 = abbrev_table::read (abbrev_section
, cu
->header
.abbrev_sect_off
);
6664 abbrev_table
= m_abbrev_table_holder
.get ();
6667 /* Read the top level CU/TU die. */
6668 init_cu_die_reader (this, cu
, section
, NULL
, abbrev_table
);
6669 info_ptr
= read_full_die (this, &comp_unit_die
, info_ptr
);
6671 if (skip_partial
&& comp_unit_die
->tag
== DW_TAG_partial_unit
)
6677 /* If we are in a DWO stub, process it and then read in the "real" CU/TU
6678 from the DWO file. read_cutu_die_from_dwo will allocate the abbreviation
6679 table from the DWO file and pass the ownership over to us. It will be
6680 referenced from READER, so we must make sure to free it after we're done
6683 Note that if USE_EXISTING_OK != 0, and THIS_CU->cu already contains a
6684 DWO CU, that this test will fail (the attribute will not be present). */
6685 const char *dwo_name
= dwarf2_dwo_name (comp_unit_die
, cu
);
6686 if (dwo_name
!= nullptr)
6688 struct dwo_unit
*dwo_unit
;
6689 struct die_info
*dwo_comp_unit_die
;
6691 if (comp_unit_die
->has_children
)
6693 complaint (_("compilation unit with DW_AT_GNU_dwo_name"
6694 " has children (offset %s) [in module %s]"),
6695 sect_offset_str (this_cu
->sect_off
),
6696 bfd_get_filename (abfd
));
6698 dwo_unit
= lookup_dwo_unit (cu
, comp_unit_die
, dwo_name
);
6699 if (dwo_unit
!= NULL
)
6701 if (read_cutu_die_from_dwo (cu
, dwo_unit
,
6702 comp_unit_die
, NULL
,
6705 &m_dwo_abbrev_table
) == 0)
6711 comp_unit_die
= dwo_comp_unit_die
;
6715 /* Yikes, we couldn't find the rest of the DIE, we only have
6716 the stub. A complaint has already been logged. There's
6717 not much more we can do except pass on the stub DIE to
6718 die_reader_func. We don't want to throw an error on bad
6725 cutu_reader::keep ()
6727 /* Done, clean up. */
6728 gdb_assert (!dummy_p
);
6729 if (m_new_cu
!= NULL
)
6731 /* Save this dwarf2_cu in the per_objfile. The per_objfile owns it
6733 dwarf2_per_objfile
*per_objfile
= m_new_cu
->per_objfile
;
6734 per_objfile
->set_cu (m_this_cu
, m_new_cu
.release ());
6738 /* Read CU/TU THIS_CU but do not follow DW_AT_GNU_dwo_name (DW_AT_dwo_name)
6739 if present. DWO_FILE, if non-NULL, is the DWO file to read (the caller is
6740 assumed to have already done the lookup to find the DWO file).
6742 The caller is required to fill in THIS_CU->section, THIS_CU->offset, and
6743 THIS_CU->is_debug_types, but nothing else.
6745 We fill in THIS_CU->length.
6747 THIS_CU->cu is always freed when done.
6748 This is done in order to not leave THIS_CU->cu in a state where we have
6749 to care whether it refers to the "main" CU or the DWO CU.
6751 When parent_cu is passed, it is used to provide a default value for
6752 str_offsets_base and addr_base from the parent. */
6754 cutu_reader::cutu_reader (dwarf2_per_cu_data
*this_cu
,
6755 dwarf2_per_objfile
*per_objfile
,
6756 struct dwarf2_cu
*parent_cu
,
6757 struct dwo_file
*dwo_file
)
6758 : die_reader_specs
{},
6761 struct objfile
*objfile
= per_objfile
->objfile
;
6762 struct dwarf2_section_info
*section
= this_cu
->section
;
6763 bfd
*abfd
= section
->get_bfd_owner ();
6764 struct dwarf2_section_info
*abbrev_section
;
6765 const gdb_byte
*begin_info_ptr
, *info_ptr
;
6767 if (dwarf_die_debug
)
6768 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset %s\n",
6769 this_cu
->is_debug_types
? "type" : "comp",
6770 sect_offset_str (this_cu
->sect_off
));
6772 gdb_assert (per_objfile
->get_cu (this_cu
) == nullptr);
6774 abbrev_section
= (dwo_file
!= NULL
6775 ? &dwo_file
->sections
.abbrev
6776 : get_abbrev_section_for_cu (this_cu
));
6778 /* This is cheap if the section is already read in. */
6779 section
->read (objfile
);
6781 m_new_cu
.reset (new dwarf2_cu (this_cu
, per_objfile
));
6783 begin_info_ptr
= info_ptr
= section
->buffer
+ to_underlying (this_cu
->sect_off
);
6784 info_ptr
= read_and_check_comp_unit_head (per_objfile
, &m_new_cu
->header
,
6785 section
, abbrev_section
, info_ptr
,
6786 (this_cu
->is_debug_types
6788 : rcuh_kind::COMPILE
));
6790 if (parent_cu
!= nullptr)
6792 m_new_cu
->str_offsets_base
= parent_cu
->str_offsets_base
;
6793 m_new_cu
->addr_base
= parent_cu
->addr_base
;
6795 this_cu
->length
= m_new_cu
->header
.get_length ();
6797 /* Skip dummy compilation units. */
6798 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
6799 || peek_abbrev_code (abfd
, info_ptr
) == 0)
6805 abbrev_section
->read (objfile
);
6806 m_abbrev_table_holder
6807 = abbrev_table::read (abbrev_section
, m_new_cu
->header
.abbrev_sect_off
);
6809 init_cu_die_reader (this, m_new_cu
.get (), section
, dwo_file
,
6810 m_abbrev_table_holder
.get ());
6811 info_ptr
= read_full_die (this, &comp_unit_die
, info_ptr
);
6815 /* Type Unit Groups.
6817 Type Unit Groups are a way to collapse the set of all TUs (type units) into
6818 a more manageable set. The grouping is done by DW_AT_stmt_list entry
6819 so that all types coming from the same compilation (.o file) are grouped
6820 together. A future step could be to put the types in the same symtab as
6821 the CU the types ultimately came from. */
6824 hash_type_unit_group (const void *item
)
6826 const struct type_unit_group
*tu_group
6827 = (const struct type_unit_group
*) item
;
6829 return hash_stmt_list_entry (&tu_group
->hash
);
6833 eq_type_unit_group (const void *item_lhs
, const void *item_rhs
)
6835 const struct type_unit_group
*lhs
= (const struct type_unit_group
*) item_lhs
;
6836 const struct type_unit_group
*rhs
= (const struct type_unit_group
*) item_rhs
;
6838 return eq_stmt_list_entry (&lhs
->hash
, &rhs
->hash
);
6841 /* Allocate a hash table for type unit groups. */
6844 allocate_type_unit_groups_table ()
6846 return htab_up (htab_create_alloc (3,
6847 hash_type_unit_group
,
6849 htab_delete_entry
<type_unit_group
>,
6853 /* Type units that don't have DW_AT_stmt_list are grouped into their own
6854 partial symtabs. We combine several TUs per psymtab to not let the size
6855 of any one psymtab grow too big. */
6856 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB (1 << 31)
6857 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE 10
6859 /* Helper routine for get_type_unit_group.
6860 Create the type_unit_group object used to hold one or more TUs. */
6862 static std::unique_ptr
<type_unit_group
>
6863 create_type_unit_group (struct dwarf2_cu
*cu
, sect_offset line_offset_struct
)
6865 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
6866 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
6868 std::unique_ptr
<type_unit_group
> tu_group (new type_unit_group
);
6869 tu_group
->per_bfd
= per_bfd
;
6871 if (per_bfd
->using_index
)
6873 tu_group
->v
.quick
= OBSTACK_ZALLOC (&per_bfd
->obstack
,
6874 struct dwarf2_per_cu_quick_data
);
6878 unsigned int line_offset
= to_underlying (line_offset_struct
);
6879 dwarf2_psymtab
*pst
;
6882 /* Give the symtab a useful name for debug purposes. */
6883 if ((line_offset
& NO_STMT_LIST_TYPE_UNIT_PSYMTAB
) != 0)
6884 name
= string_printf ("<type_units_%d>",
6885 (line_offset
& ~NO_STMT_LIST_TYPE_UNIT_PSYMTAB
));
6887 name
= string_printf ("<type_units_at_0x%x>", line_offset
);
6889 pst
= create_partial_symtab (tu_group
.get (), per_objfile
,
6891 pst
->anonymous
= true;
6894 tu_group
->hash
.dwo_unit
= cu
->dwo_unit
;
6895 tu_group
->hash
.line_sect_off
= line_offset_struct
;
6900 /* Look up the type_unit_group for type unit CU, and create it if necessary.
6901 STMT_LIST is a DW_AT_stmt_list attribute. */
6903 static struct type_unit_group
*
6904 get_type_unit_group (struct dwarf2_cu
*cu
, const struct attribute
*stmt_list
)
6906 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
6907 struct tu_stats
*tu_stats
= &per_objfile
->per_bfd
->tu_stats
;
6908 struct type_unit_group
*tu_group
;
6910 unsigned int line_offset
;
6911 struct type_unit_group type_unit_group_for_lookup
;
6913 if (per_objfile
->per_bfd
->type_unit_groups
== NULL
)
6914 per_objfile
->per_bfd
->type_unit_groups
= allocate_type_unit_groups_table ();
6916 /* Do we need to create a new group, or can we use an existing one? */
6918 if (stmt_list
!= nullptr && stmt_list
->form_is_unsigned ())
6920 line_offset
= stmt_list
->as_unsigned ();
6921 ++tu_stats
->nr_symtab_sharers
;
6925 /* Ugh, no stmt_list. Rare, but we have to handle it.
6926 We can do various things here like create one group per TU or
6927 spread them over multiple groups to split up the expansion work.
6928 To avoid worst case scenarios (too many groups or too large groups)
6929 we, umm, group them in bunches. */
6930 line_offset
= (NO_STMT_LIST_TYPE_UNIT_PSYMTAB
6931 | (tu_stats
->nr_stmt_less_type_units
6932 / NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE
));
6933 ++tu_stats
->nr_stmt_less_type_units
;
6936 type_unit_group_for_lookup
.hash
.dwo_unit
= cu
->dwo_unit
;
6937 type_unit_group_for_lookup
.hash
.line_sect_off
= (sect_offset
) line_offset
;
6938 slot
= htab_find_slot (per_objfile
->per_bfd
->type_unit_groups
.get (),
6939 &type_unit_group_for_lookup
, INSERT
);
6940 if (*slot
== nullptr)
6942 sect_offset line_offset_struct
= (sect_offset
) line_offset
;
6943 std::unique_ptr
<type_unit_group
> grp
6944 = create_type_unit_group (cu
, line_offset_struct
);
6945 *slot
= grp
.release ();
6946 ++tu_stats
->nr_symtabs
;
6949 tu_group
= (struct type_unit_group
*) *slot
;
6950 gdb_assert (tu_group
!= nullptr);
6954 /* Partial symbol tables. */
6956 /* Create a psymtab named NAME and assign it to PER_CU.
6958 The caller must fill in the following details:
6959 dirname, textlow, texthigh. */
6961 static dwarf2_psymtab
*
6962 create_partial_symtab (dwarf2_per_cu_data
*per_cu
,
6963 dwarf2_per_objfile
*per_objfile
,
6967 = new dwarf2_psymtab (name
, per_objfile
->per_bfd
->partial_symtabs
.get (),
6968 per_objfile
->objfile
->per_bfd
, per_cu
);
6970 pst
->psymtabs_addrmap_supported
= true;
6972 /* This is the glue that links PST into GDB's symbol API. */
6973 per_cu
->v
.psymtab
= pst
;
6978 /* DIE reader function for process_psymtab_comp_unit. */
6981 process_psymtab_comp_unit_reader (const struct die_reader_specs
*reader
,
6982 const gdb_byte
*info_ptr
,
6983 struct die_info
*comp_unit_die
,
6984 enum language pretend_language
)
6986 struct dwarf2_cu
*cu
= reader
->cu
;
6987 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
6988 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
6989 struct objfile
*objfile
= per_objfile
->objfile
;
6990 struct gdbarch
*gdbarch
= objfile
->arch ();
6991 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
6993 CORE_ADDR best_lowpc
= 0, best_highpc
= 0;
6994 dwarf2_psymtab
*pst
;
6995 enum pc_bounds_kind cu_bounds_kind
;
6997 gdb_assert (! per_cu
->is_debug_types
);
6999 prepare_one_comp_unit (cu
, comp_unit_die
, pretend_language
);
7001 /* Allocate a new partial symbol table structure. */
7002 gdb::unique_xmalloc_ptr
<char> debug_filename
;
7003 static const char artificial
[] = "<artificial>";
7004 file_and_directory fnd
= find_file_and_directory (comp_unit_die
, cu
);
7005 if (strcmp (fnd
.name
, artificial
) == 0)
7007 debug_filename
.reset (concat (artificial
, "@",
7008 sect_offset_str (per_cu
->sect_off
),
7010 fnd
.name
= debug_filename
.get ();
7013 pst
= create_partial_symtab (per_cu
, per_objfile
, fnd
.name
);
7015 /* This must be done before calling dwarf2_build_include_psymtabs. */
7016 pst
->dirname
= dwarf2_string_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
7018 baseaddr
= objfile
->text_section_offset ();
7020 dwarf2_find_base_address (comp_unit_die
, cu
);
7022 /* Possibly set the default values of LOWPC and HIGHPC from
7024 cu_bounds_kind
= dwarf2_get_pc_bounds (comp_unit_die
, &best_lowpc
,
7025 &best_highpc
, cu
, pst
);
7026 if (cu_bounds_kind
== PC_BOUNDS_HIGH_LOW
&& best_lowpc
< best_highpc
)
7029 = (gdbarch_adjust_dwarf2_addr (gdbarch
, best_lowpc
+ baseaddr
)
7032 = (gdbarch_adjust_dwarf2_addr (gdbarch
, best_highpc
+ baseaddr
)
7034 /* Store the contiguous range if it is not empty; it can be
7035 empty for CUs with no code. */
7036 addrmap_set_empty (per_bfd
->partial_symtabs
->psymtabs_addrmap
,
7040 /* Check if comp unit has_children.
7041 If so, read the rest of the partial symbols from this comp unit.
7042 If not, there's no more debug_info for this comp unit. */
7043 if (comp_unit_die
->has_children
)
7045 struct partial_die_info
*first_die
;
7046 CORE_ADDR lowpc
, highpc
;
7048 lowpc
= ((CORE_ADDR
) -1);
7049 highpc
= ((CORE_ADDR
) 0);
7051 first_die
= load_partial_dies (reader
, info_ptr
, 1);
7053 scan_partial_symbols (first_die
, &lowpc
, &highpc
,
7054 cu_bounds_kind
<= PC_BOUNDS_INVALID
, cu
);
7056 /* If we didn't find a lowpc, set it to highpc to avoid
7057 complaints from `maint check'. */
7058 if (lowpc
== ((CORE_ADDR
) -1))
7061 /* If the compilation unit didn't have an explicit address range,
7062 then use the information extracted from its child dies. */
7063 if (cu_bounds_kind
<= PC_BOUNDS_INVALID
)
7066 best_highpc
= highpc
;
7069 pst
->set_text_low (gdbarch_adjust_dwarf2_addr (gdbarch
,
7070 best_lowpc
+ baseaddr
)
7072 pst
->set_text_high (gdbarch_adjust_dwarf2_addr (gdbarch
,
7073 best_highpc
+ baseaddr
)
7078 if (!cu
->per_cu
->imported_symtabs_empty ())
7081 int len
= cu
->per_cu
->imported_symtabs_size ();
7083 /* Fill in 'dependencies' here; we fill in 'users' in a
7085 pst
->number_of_dependencies
= len
;
7087 = per_bfd
->partial_symtabs
->allocate_dependencies (len
);
7088 for (i
= 0; i
< len
; ++i
)
7090 pst
->dependencies
[i
]
7091 = cu
->per_cu
->imported_symtabs
->at (i
)->v
.psymtab
;
7094 cu
->per_cu
->imported_symtabs_free ();
7097 /* Get the list of files included in the current compilation unit,
7098 and build a psymtab for each of them. */
7099 dwarf2_build_include_psymtabs (cu
, comp_unit_die
, fnd
, pst
);
7101 dwarf_read_debug_printf ("Psymtab for %s unit @%s: %s - %s"
7102 ", %d global, %d static syms",
7103 per_cu
->is_debug_types
? "type" : "comp",
7104 sect_offset_str (per_cu
->sect_off
),
7105 paddress (gdbarch
, pst
->text_low (objfile
)),
7106 paddress (gdbarch
, pst
->text_high (objfile
)),
7107 (int) pst
->global_psymbols
.size (),
7108 (int) pst
->static_psymbols
.size ());
7111 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
7112 Process compilation unit THIS_CU for a psymtab. */
7115 process_psymtab_comp_unit (dwarf2_per_cu_data
*this_cu
,
7116 dwarf2_per_objfile
*per_objfile
,
7117 bool want_partial_unit
,
7118 enum language pretend_language
)
7120 /* If this compilation unit was already read in, free the
7121 cached copy in order to read it in again. This is
7122 necessary because we skipped some symbols when we first
7123 read in the compilation unit (see load_partial_dies).
7124 This problem could be avoided, but the benefit is unclear. */
7125 per_objfile
->remove_cu (this_cu
);
7127 cutu_reader
reader (this_cu
, per_objfile
, nullptr, nullptr, false);
7129 if (reader
.comp_unit_die
== nullptr)
7132 switch (reader
.comp_unit_die
->tag
)
7134 case DW_TAG_compile_unit
:
7135 this_cu
->unit_type
= DW_UT_compile
;
7137 case DW_TAG_partial_unit
:
7138 this_cu
->unit_type
= DW_UT_partial
;
7140 case DW_TAG_type_unit
:
7141 this_cu
->unit_type
= DW_UT_type
;
7144 error (_("Dwarf Error: unexpected tag '%s' at offset %s [in module %s]"),
7145 dwarf_tag_name (reader
.comp_unit_die
->tag
),
7146 sect_offset_str (reader
.cu
->per_cu
->sect_off
),
7147 objfile_name (per_objfile
->objfile
));
7154 else if (this_cu
->is_debug_types
)
7155 build_type_psymtabs_reader (&reader
, reader
.info_ptr
,
7156 reader
.comp_unit_die
);
7157 else if (want_partial_unit
7158 || reader
.comp_unit_die
->tag
!= DW_TAG_partial_unit
)
7159 process_psymtab_comp_unit_reader (&reader
, reader
.info_ptr
,
7160 reader
.comp_unit_die
,
7163 /* Age out any secondary CUs. */
7164 per_objfile
->age_comp_units ();
7167 /* Reader function for build_type_psymtabs. */
7170 build_type_psymtabs_reader (const struct die_reader_specs
*reader
,
7171 const gdb_byte
*info_ptr
,
7172 struct die_info
*type_unit_die
)
7174 dwarf2_per_objfile
*per_objfile
= reader
->cu
->per_objfile
;
7175 struct dwarf2_cu
*cu
= reader
->cu
;
7176 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
7177 struct signatured_type
*sig_type
;
7178 struct type_unit_group
*tu_group
;
7179 struct attribute
*attr
;
7180 struct partial_die_info
*first_die
;
7181 CORE_ADDR lowpc
, highpc
;
7182 dwarf2_psymtab
*pst
;
7184 gdb_assert (per_cu
->is_debug_types
);
7185 sig_type
= (struct signatured_type
*) per_cu
;
7187 if (! type_unit_die
->has_children
)
7190 attr
= type_unit_die
->attr (DW_AT_stmt_list
);
7191 tu_group
= get_type_unit_group (cu
, attr
);
7193 if (tu_group
->tus
== nullptr)
7194 tu_group
->tus
= new std::vector
<signatured_type
*>;
7195 tu_group
->tus
->push_back (sig_type
);
7197 prepare_one_comp_unit (cu
, type_unit_die
, language_minimal
);
7198 pst
= create_partial_symtab (per_cu
, per_objfile
, "");
7199 pst
->anonymous
= true;
7201 first_die
= load_partial_dies (reader
, info_ptr
, 1);
7203 lowpc
= (CORE_ADDR
) -1;
7204 highpc
= (CORE_ADDR
) 0;
7205 scan_partial_symbols (first_die
, &lowpc
, &highpc
, 0, cu
);
7210 /* Struct used to sort TUs by their abbreviation table offset. */
7212 struct tu_abbrev_offset
7214 tu_abbrev_offset (signatured_type
*sig_type_
, sect_offset abbrev_offset_
)
7215 : sig_type (sig_type_
), abbrev_offset (abbrev_offset_
)
7218 /* This is used when sorting. */
7219 bool operator< (const tu_abbrev_offset
&other
) const
7221 return abbrev_offset
< other
.abbrev_offset
;
7224 signatured_type
*sig_type
;
7225 sect_offset abbrev_offset
;
7228 /* Efficiently read all the type units.
7230 The efficiency is because we sort TUs by the abbrev table they use and
7231 only read each abbrev table once. In one program there are 200K TUs
7232 sharing 8K abbrev tables.
7234 The main purpose of this function is to support building the
7235 dwarf2_per_objfile->per_bfd->type_unit_groups table.
7236 TUs typically share the DW_AT_stmt_list of the CU they came from, so we
7237 can collapse the search space by grouping them by stmt_list.
7238 The savings can be significant, in the same program from above the 200K TUs
7239 share 8K stmt_list tables.
7241 FUNC is expected to call get_type_unit_group, which will create the
7242 struct type_unit_group if necessary and add it to
7243 dwarf2_per_objfile->per_bfd->type_unit_groups. */
7246 build_type_psymtabs (dwarf2_per_objfile
*per_objfile
)
7248 struct tu_stats
*tu_stats
= &per_objfile
->per_bfd
->tu_stats
;
7249 abbrev_table_up abbrev_table
;
7250 sect_offset abbrev_offset
;
7252 /* It's up to the caller to not call us multiple times. */
7253 gdb_assert (per_objfile
->per_bfd
->type_unit_groups
== NULL
);
7255 if (per_objfile
->per_bfd
->tu_stats
.nr_tus
== 0)
7258 /* TUs typically share abbrev tables, and there can be way more TUs than
7259 abbrev tables. Sort by abbrev table to reduce the number of times we
7260 read each abbrev table in.
7261 Alternatives are to punt or to maintain a cache of abbrev tables.
7262 This is simpler and efficient enough for now.
7264 Later we group TUs by their DW_AT_stmt_list value (as this defines the
7265 symtab to use). Typically TUs with the same abbrev offset have the same
7266 stmt_list value too so in practice this should work well.
7268 The basic algorithm here is:
7270 sort TUs by abbrev table
7271 for each TU with same abbrev table:
7272 read abbrev table if first user
7273 read TU top level DIE
7274 [IWBN if DWO skeletons had DW_AT_stmt_list]
7277 dwarf_read_debug_printf ("Building type unit groups ...");
7279 /* Sort in a separate table to maintain the order of all_comp_units
7280 for .gdb_index: TU indices directly index all_type_units. */
7281 std::vector
<tu_abbrev_offset
> sorted_by_abbrev
;
7282 sorted_by_abbrev
.reserve (per_objfile
->per_bfd
->tu_stats
.nr_tus
);
7284 for (const auto &cu
: per_objfile
->per_bfd
->all_comp_units
)
7286 if (cu
->is_debug_types
)
7288 auto sig_type
= static_cast<signatured_type
*> (cu
.get ());
7289 sorted_by_abbrev
.emplace_back
7290 (sig_type
, read_abbrev_offset (per_objfile
, sig_type
->section
,
7291 sig_type
->sect_off
));
7295 std::sort (sorted_by_abbrev
.begin (), sorted_by_abbrev
.end ());
7297 abbrev_offset
= (sect_offset
) ~(unsigned) 0;
7299 for (const tu_abbrev_offset
&tu
: sorted_by_abbrev
)
7301 /* Switch to the next abbrev table if necessary. */
7302 if (abbrev_table
== NULL
7303 || tu
.abbrev_offset
!= abbrev_offset
)
7305 abbrev_offset
= tu
.abbrev_offset
;
7306 per_objfile
->per_bfd
->abbrev
.read (per_objfile
->objfile
);
7308 abbrev_table::read (&per_objfile
->per_bfd
->abbrev
, abbrev_offset
);
7309 ++tu_stats
->nr_uniq_abbrev_tables
;
7312 cutu_reader
reader (tu
.sig_type
, per_objfile
,
7313 abbrev_table
.get (), nullptr, false);
7314 if (!reader
.dummy_p
)
7315 build_type_psymtabs_reader (&reader
, reader
.info_ptr
,
7316 reader
.comp_unit_die
);
7320 /* Print collected type unit statistics. */
7323 print_tu_stats (dwarf2_per_objfile
*per_objfile
)
7325 struct tu_stats
*tu_stats
= &per_objfile
->per_bfd
->tu_stats
;
7327 dwarf_read_debug_printf ("Type unit statistics:");
7328 dwarf_read_debug_printf (" %d TUs", tu_stats
->nr_tus
);
7329 dwarf_read_debug_printf (" %d uniq abbrev tables",
7330 tu_stats
->nr_uniq_abbrev_tables
);
7331 dwarf_read_debug_printf (" %d symtabs from stmt_list entries",
7332 tu_stats
->nr_symtabs
);
7333 dwarf_read_debug_printf (" %d symtab sharers",
7334 tu_stats
->nr_symtab_sharers
);
7335 dwarf_read_debug_printf (" %d type units without a stmt_list",
7336 tu_stats
->nr_stmt_less_type_units
);
7337 dwarf_read_debug_printf (" %d all_type_units reallocs",
7338 tu_stats
->nr_all_type_units_reallocs
);
7341 /* Traversal function for build_type_psymtabs. */
7344 build_type_psymtab_dependencies (void **slot
, void *info
)
7346 dwarf2_per_objfile
*per_objfile
= (dwarf2_per_objfile
*) info
;
7347 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
7348 struct type_unit_group
*tu_group
= (struct type_unit_group
*) *slot
;
7349 dwarf2_psymtab
*pst
= tu_group
->v
.psymtab
;
7350 int len
= (tu_group
->tus
== nullptr) ? 0 : tu_group
->tus
->size ();
7353 gdb_assert (len
> 0);
7354 gdb_assert (tu_group
->type_unit_group_p ());
7356 pst
->number_of_dependencies
= len
;
7357 pst
->dependencies
= per_bfd
->partial_symtabs
->allocate_dependencies (len
);
7358 for (i
= 0; i
< len
; ++i
)
7360 struct signatured_type
*iter
= tu_group
->tus
->at (i
);
7361 gdb_assert (iter
->is_debug_types
);
7362 pst
->dependencies
[i
] = iter
->v
.psymtab
;
7363 iter
->type_unit_group
= tu_group
;
7366 delete tu_group
->tus
;
7367 tu_group
->tus
= nullptr;
7372 /* Traversal function for process_skeletonless_type_unit.
7373 Read a TU in a DWO file and build partial symbols for it. */
7376 process_skeletonless_type_unit (void **slot
, void *info
)
7378 struct dwo_unit
*dwo_unit
= (struct dwo_unit
*) *slot
;
7379 dwarf2_per_objfile
*per_objfile
= (dwarf2_per_objfile
*) info
;
7381 /* If this TU doesn't exist in the global table, add it and read it in. */
7383 if (per_objfile
->per_bfd
->signatured_types
== NULL
)
7384 per_objfile
->per_bfd
->signatured_types
= allocate_signatured_type_table ();
7386 signatured_type
find_entry (dwo_unit
->signature
);
7387 slot
= htab_find_slot (per_objfile
->per_bfd
->signatured_types
.get (),
7388 &find_entry
, INSERT
);
7389 /* If we've already seen this type there's nothing to do. What's happening
7390 is we're doing our own version of comdat-folding here. */
7394 /* This does the job that create_all_comp_units would have done for
7396 signatured_type
*entry
7397 = add_type_unit (per_objfile
, dwo_unit
->signature
, slot
);
7398 fill_in_sig_entry_from_dwo_entry (per_objfile
, entry
, dwo_unit
);
7401 /* This does the job that build_type_psymtabs would have done. */
7402 cutu_reader
reader (entry
, per_objfile
, nullptr, nullptr, false);
7403 if (!reader
.dummy_p
)
7404 build_type_psymtabs_reader (&reader
, reader
.info_ptr
,
7405 reader
.comp_unit_die
);
7410 /* Traversal function for process_skeletonless_type_units. */
7413 process_dwo_file_for_skeletonless_type_units (void **slot
, void *info
)
7415 struct dwo_file
*dwo_file
= (struct dwo_file
*) *slot
;
7417 if (dwo_file
->tus
!= NULL
)
7418 htab_traverse_noresize (dwo_file
->tus
.get (),
7419 process_skeletonless_type_unit
, info
);
7424 /* Scan all TUs of DWO files, verifying we've processed them.
7425 This is needed in case a TU was emitted without its skeleton.
7426 Note: This can't be done until we know what all the DWO files are. */
7429 process_skeletonless_type_units (dwarf2_per_objfile
*per_objfile
)
7431 /* Skeletonless TUs in DWP files without .gdb_index is not supported yet. */
7432 if (get_dwp_file (per_objfile
) == NULL
7433 && per_objfile
->per_bfd
->dwo_files
!= NULL
)
7435 htab_traverse_noresize (per_objfile
->per_bfd
->dwo_files
.get (),
7436 process_dwo_file_for_skeletonless_type_units
,
7441 /* Compute the 'user' field for each psymtab in DWARF2_PER_OBJFILE. */
7444 set_partial_user (dwarf2_per_objfile
*per_objfile
)
7446 for (const auto &per_cu
: per_objfile
->per_bfd
->all_comp_units
)
7448 dwarf2_psymtab
*pst
= per_cu
->v
.psymtab
;
7453 for (int j
= 0; j
< pst
->number_of_dependencies
; ++j
)
7455 /* Set the 'user' field only if it is not already set. */
7456 if (pst
->dependencies
[j
]->user
== NULL
)
7457 pst
->dependencies
[j
]->user
= pst
;
7462 /* Build the partial symbol table by doing a quick pass through the
7463 .debug_info and .debug_abbrev sections. */
7466 dwarf2_build_psymtabs_hard (dwarf2_per_objfile
*per_objfile
)
7468 struct objfile
*objfile
= per_objfile
->objfile
;
7469 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
7471 dwarf_read_debug_printf ("Building psymtabs of objfile %s ...",
7472 objfile_name (objfile
));
7474 scoped_restore restore_reading_psyms
7475 = make_scoped_restore (&per_bfd
->reading_partial_symbols
, true);
7477 per_bfd
->info
.read (objfile
);
7479 /* Any cached compilation units will be linked by the per-objfile
7480 read_in_chain. Make sure to free them when we're done. */
7481 free_cached_comp_units
freer (per_objfile
);
7483 create_all_comp_units (per_objfile
);
7484 build_type_psymtabs (per_objfile
);
7486 /* Create a temporary address map on a temporary obstack. We later
7487 copy this to the final obstack. */
7488 auto_obstack temp_obstack
;
7490 scoped_restore save_psymtabs_addrmap
7491 = make_scoped_restore (&per_bfd
->partial_symtabs
->psymtabs_addrmap
,
7492 addrmap_create_mutable (&temp_obstack
));
7494 for (const auto &per_cu
: per_bfd
->all_comp_units
)
7496 if (per_cu
->v
.psymtab
!= NULL
)
7497 /* In case a forward DW_TAG_imported_unit has read the CU already. */
7499 process_psymtab_comp_unit (per_cu
.get (), per_objfile
, false,
7503 /* This has to wait until we read the CUs, we need the list of DWOs. */
7504 process_skeletonless_type_units (per_objfile
);
7506 /* Now that all TUs have been processed we can fill in the dependencies. */
7507 if (per_bfd
->type_unit_groups
!= NULL
)
7509 htab_traverse_noresize (per_bfd
->type_unit_groups
.get (),
7510 build_type_psymtab_dependencies
, per_objfile
);
7513 if (dwarf_read_debug
> 0)
7514 print_tu_stats (per_objfile
);
7516 set_partial_user (per_objfile
);
7518 per_bfd
->partial_symtabs
->psymtabs_addrmap
7519 = addrmap_create_fixed (per_bfd
->partial_symtabs
->psymtabs_addrmap
,
7520 per_bfd
->partial_symtabs
->obstack ());
7521 /* At this point we want to keep the address map. */
7522 save_psymtabs_addrmap
.release ();
7524 dwarf_read_debug_printf ("Done building psymtabs of %s",
7525 objfile_name (objfile
));
7528 /* Load the partial DIEs for a secondary CU into memory.
7529 This is also used when rereading a primary CU with load_all_dies. */
7532 load_partial_comp_unit (dwarf2_per_cu_data
*this_cu
,
7533 dwarf2_per_objfile
*per_objfile
,
7534 dwarf2_cu
*existing_cu
)
7536 cutu_reader
reader (this_cu
, per_objfile
, nullptr, existing_cu
, false);
7538 if (!reader
.dummy_p
)
7540 prepare_one_comp_unit (reader
.cu
, reader
.comp_unit_die
,
7543 /* Check if comp unit has_children.
7544 If so, read the rest of the partial symbols from this comp unit.
7545 If not, there's no more debug_info for this comp unit. */
7546 if (reader
.comp_unit_die
->has_children
)
7547 load_partial_dies (&reader
, reader
.info_ptr
, 0);
7554 read_comp_units_from_section (dwarf2_per_objfile
*per_objfile
,
7555 struct dwarf2_section_info
*section
,
7556 struct dwarf2_section_info
*abbrev_section
,
7557 unsigned int is_dwz
,
7558 htab_up
&types_htab
,
7559 rcuh_kind section_kind
)
7561 const gdb_byte
*info_ptr
;
7562 struct objfile
*objfile
= per_objfile
->objfile
;
7564 dwarf_read_debug_printf ("Reading %s for %s",
7565 section
->get_name (),
7566 section
->get_file_name ());
7568 section
->read (objfile
);
7570 info_ptr
= section
->buffer
;
7572 while (info_ptr
< section
->buffer
+ section
->size
)
7574 dwarf2_per_cu_data_up this_cu
;
7576 sect_offset sect_off
= (sect_offset
) (info_ptr
- section
->buffer
);
7578 comp_unit_head cu_header
;
7579 read_and_check_comp_unit_head (per_objfile
, &cu_header
, section
,
7580 abbrev_section
, info_ptr
,
7583 /* Save the compilation unit for later lookup. */
7584 if (cu_header
.unit_type
!= DW_UT_type
)
7585 this_cu
= per_objfile
->per_bfd
->allocate_per_cu ();
7588 if (types_htab
== nullptr)
7589 types_htab
= allocate_signatured_type_table ();
7591 auto sig_type
= per_objfile
->per_bfd
->allocate_signatured_type
7592 (cu_header
.signature
);
7593 signatured_type
*sig_ptr
= sig_type
.get ();
7594 sig_type
->type_offset_in_tu
= cu_header
.type_cu_offset_in_tu
;
7595 this_cu
.reset (sig_type
.release ());
7597 void **slot
= htab_find_slot (types_htab
.get (), sig_ptr
, INSERT
);
7598 gdb_assert (slot
!= nullptr);
7599 if (*slot
!= nullptr)
7600 complaint (_("debug type entry at offset %s is duplicate to"
7601 " the entry at offset %s, signature %s"),
7602 sect_offset_str (sect_off
),
7603 sect_offset_str (sig_ptr
->sect_off
),
7604 hex_string (sig_ptr
->signature
));
7607 this_cu
->sect_off
= sect_off
;
7608 this_cu
->length
= cu_header
.length
+ cu_header
.initial_length_size
;
7609 this_cu
->is_dwz
= is_dwz
;
7610 this_cu
->section
= section
;
7612 info_ptr
= info_ptr
+ this_cu
->length
;
7613 per_objfile
->per_bfd
->all_comp_units
.push_back (std::move (this_cu
));
7617 /* Create a list of all compilation units in OBJFILE.
7618 This is only done for -readnow and building partial symtabs. */
7621 create_all_comp_units (dwarf2_per_objfile
*per_objfile
)
7625 read_comp_units_from_section (per_objfile
, &per_objfile
->per_bfd
->info
,
7626 &per_objfile
->per_bfd
->abbrev
, 0,
7627 types_htab
, rcuh_kind::COMPILE
);
7628 for (dwarf2_section_info
§ion
: per_objfile
->per_bfd
->types
)
7629 read_comp_units_from_section (per_objfile
, §ion
,
7630 &per_objfile
->per_bfd
->abbrev
, 0,
7631 types_htab
, rcuh_kind::TYPE
);
7633 dwz_file
*dwz
= dwarf2_get_dwz_file (per_objfile
->per_bfd
);
7635 read_comp_units_from_section (per_objfile
, &dwz
->info
, &dwz
->abbrev
, 1,
7636 types_htab
, rcuh_kind::COMPILE
);
7638 per_objfile
->per_bfd
->signatured_types
= std::move (types_htab
);
7641 /* Process all loaded DIEs for compilation unit CU, starting at
7642 FIRST_DIE. The caller should pass SET_ADDRMAP == 1 if the compilation
7643 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
7644 DW_AT_ranges). See the comments of add_partial_subprogram on how
7645 SET_ADDRMAP is used and how *LOWPC and *HIGHPC are updated. */
7648 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
7649 CORE_ADDR
*highpc
, int set_addrmap
,
7650 struct dwarf2_cu
*cu
)
7652 struct partial_die_info
*pdi
;
7654 /* Now, march along the PDI's, descending into ones which have
7655 interesting children but skipping the children of the other ones,
7656 until we reach the end of the compilation unit. */
7664 /* Anonymous namespaces or modules have no name but have interesting
7665 children, so we need to look at them. Ditto for anonymous
7668 if (pdi
->raw_name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
7669 || pdi
->tag
== DW_TAG_module
|| pdi
->tag
== DW_TAG_enumeration_type
7670 || pdi
->tag
== DW_TAG_imported_unit
7671 || pdi
->tag
== DW_TAG_inlined_subroutine
)
7675 case DW_TAG_subprogram
:
7676 case DW_TAG_inlined_subroutine
:
7677 add_partial_subprogram (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
7678 if (cu
->per_cu
->lang
== language_cplus
)
7679 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
,
7682 case DW_TAG_constant
:
7683 case DW_TAG_variable
:
7684 case DW_TAG_typedef
:
7685 case DW_TAG_union_type
:
7686 if (!pdi
->is_declaration
7687 || (pdi
->tag
== DW_TAG_variable
&& pdi
->is_external
))
7689 add_partial_symbol (pdi
, cu
);
7692 case DW_TAG_class_type
:
7693 case DW_TAG_interface_type
:
7694 case DW_TAG_structure_type
:
7695 if (!pdi
->is_declaration
)
7697 add_partial_symbol (pdi
, cu
);
7699 if ((cu
->per_cu
->lang
== language_rust
7700 || cu
->per_cu
->lang
== language_cplus
)
7701 && pdi
->has_children
)
7702 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
,
7705 case DW_TAG_enumeration_type
:
7706 if (!pdi
->is_declaration
)
7707 add_partial_enumeration (pdi
, cu
);
7709 case DW_TAG_base_type
:
7710 case DW_TAG_subrange_type
:
7711 /* File scope base type definitions are added to the partial
7713 add_partial_symbol (pdi
, cu
);
7715 case DW_TAG_namespace
:
7716 add_partial_namespace (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
7719 if (!pdi
->is_declaration
)
7720 add_partial_module (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
7722 case DW_TAG_imported_unit
:
7724 struct dwarf2_per_cu_data
*per_cu
;
7726 /* For now we don't handle imported units in type units. */
7727 if (cu
->per_cu
->is_debug_types
)
7729 error (_("Dwarf Error: DW_TAG_imported_unit is not"
7730 " supported in type units [in module %s]"),
7731 objfile_name (cu
->per_objfile
->objfile
));
7734 per_cu
= dwarf2_find_containing_comp_unit
7735 (pdi
->d
.sect_off
, pdi
->is_dwz
, cu
->per_objfile
);
7737 /* Go read the partial unit, if needed. */
7738 if (per_cu
->v
.psymtab
== NULL
)
7739 process_psymtab_comp_unit (per_cu
, cu
->per_objfile
, true,
7742 if (pdi
->die_parent
== nullptr
7743 && per_cu
->unit_type
== DW_UT_compile
7744 && per_cu
->lang
== language_cplus
)
7745 /* Regard import as hint. See corresponding code in
7746 process_imported_unit_die. */
7749 cu
->per_cu
->imported_symtabs_push (per_cu
);
7752 case DW_TAG_imported_declaration
:
7753 add_partial_symbol (pdi
, cu
);
7760 /* If the die has a sibling, skip to the sibling. */
7762 pdi
= pdi
->die_sibling
;
7766 /* Functions used to compute the fully scoped name of a partial DIE.
7768 Normally, this is simple. For C++, the parent DIE's fully scoped
7769 name is concatenated with "::" and the partial DIE's name.
7770 Enumerators are an exception; they use the scope of their parent
7771 enumeration type, i.e. the name of the enumeration type is not
7772 prepended to the enumerator.
7774 There are two complexities. One is DW_AT_specification; in this
7775 case "parent" means the parent of the target of the specification,
7776 instead of the direct parent of the DIE. The other is compilers
7777 which do not emit DW_TAG_namespace; in this case we try to guess
7778 the fully qualified name of structure types from their members'
7779 linkage names. This must be done using the DIE's children rather
7780 than the children of any DW_AT_specification target. We only need
7781 to do this for structures at the top level, i.e. if the target of
7782 any DW_AT_specification (if any; otherwise the DIE itself) does not
7785 /* Compute the scope prefix associated with PDI's parent, in
7786 compilation unit CU. The result will be allocated on CU's
7787 comp_unit_obstack, or a copy of the already allocated PDI->NAME
7788 field. NULL is returned if no prefix is necessary. */
7790 partial_die_parent_scope (struct partial_die_info
*pdi
,
7791 struct dwarf2_cu
*cu
)
7793 const char *grandparent_scope
;
7794 struct partial_die_info
*parent
, *real_pdi
;
7796 /* We need to look at our parent DIE; if we have a DW_AT_specification,
7797 then this means the parent of the specification DIE. */
7800 while (real_pdi
->has_specification
)
7802 auto res
= find_partial_die (real_pdi
->spec_offset
,
7803 real_pdi
->spec_is_dwz
, cu
);
7808 parent
= real_pdi
->die_parent
;
7812 if (parent
->scope_set
)
7813 return parent
->scope
;
7817 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
7819 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
7820 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
7821 Work around this problem here. */
7822 if (cu
->per_cu
->lang
== language_cplus
7823 && parent
->tag
== DW_TAG_namespace
7824 && strcmp (parent
->name (cu
), "::") == 0
7825 && grandparent_scope
== NULL
)
7827 parent
->scope
= NULL
;
7828 parent
->scope_set
= 1;
7832 /* Nested subroutines in Fortran get a prefix. */
7833 if (pdi
->tag
== DW_TAG_enumerator
)
7834 /* Enumerators should not get the name of the enumeration as a prefix. */
7835 parent
->scope
= grandparent_scope
;
7836 else if (parent
->tag
== DW_TAG_namespace
7837 || parent
->tag
== DW_TAG_module
7838 || parent
->tag
== DW_TAG_structure_type
7839 || parent
->tag
== DW_TAG_class_type
7840 || parent
->tag
== DW_TAG_interface_type
7841 || parent
->tag
== DW_TAG_union_type
7842 || parent
->tag
== DW_TAG_enumeration_type
7843 || (cu
->per_cu
->lang
== language_fortran
7844 && parent
->tag
== DW_TAG_subprogram
7845 && pdi
->tag
== DW_TAG_subprogram
))
7847 if (grandparent_scope
== NULL
)
7848 parent
->scope
= parent
->name (cu
);
7850 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
,
7852 parent
->name (cu
), 0, cu
);
7856 /* FIXME drow/2004-04-01: What should we be doing with
7857 function-local names? For partial symbols, we should probably be
7859 complaint (_("unhandled containing DIE tag %s for DIE at %s"),
7860 dwarf_tag_name (parent
->tag
),
7861 sect_offset_str (pdi
->sect_off
));
7862 parent
->scope
= grandparent_scope
;
7865 parent
->scope_set
= 1;
7866 return parent
->scope
;
7869 /* Return the fully scoped name associated with PDI, from compilation unit
7870 CU. The result will be allocated with malloc. */
7872 static gdb::unique_xmalloc_ptr
<char>
7873 partial_die_full_name (struct partial_die_info
*pdi
,
7874 struct dwarf2_cu
*cu
)
7876 const char *parent_scope
;
7878 /* If this is a template instantiation, we can not work out the
7879 template arguments from partial DIEs. So, unfortunately, we have
7880 to go through the full DIEs. At least any work we do building
7881 types here will be reused if full symbols are loaded later. */
7882 if (pdi
->has_template_arguments
)
7886 if (pdi
->name (cu
) != NULL
&& strchr (pdi
->name (cu
), '<') == NULL
)
7888 struct die_info
*die
;
7889 struct attribute attr
;
7890 struct dwarf2_cu
*ref_cu
= cu
;
7892 /* DW_FORM_ref_addr is using section offset. */
7893 attr
.name
= (enum dwarf_attribute
) 0;
7894 attr
.form
= DW_FORM_ref_addr
;
7895 attr
.u
.unsnd
= to_underlying (pdi
->sect_off
);
7896 die
= follow_die_ref (NULL
, &attr
, &ref_cu
);
7898 return make_unique_xstrdup (dwarf2_full_name (NULL
, die
, ref_cu
));
7902 parent_scope
= partial_die_parent_scope (pdi
, cu
);
7903 if (parent_scope
== NULL
)
7906 return gdb::unique_xmalloc_ptr
<char> (typename_concat (NULL
, parent_scope
,
7912 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
7914 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
7915 struct objfile
*objfile
= per_objfile
->objfile
;
7916 struct gdbarch
*gdbarch
= objfile
->arch ();
7918 const char *actual_name
= NULL
;
7921 baseaddr
= objfile
->text_section_offset ();
7923 gdb::unique_xmalloc_ptr
<char> built_actual_name
7924 = partial_die_full_name (pdi
, cu
);
7925 if (built_actual_name
!= NULL
)
7926 actual_name
= built_actual_name
.get ();
7928 if (actual_name
== NULL
)
7929 actual_name
= pdi
->name (cu
);
7931 partial_symbol psymbol
;
7932 memset (&psymbol
, 0, sizeof (psymbol
));
7933 psymbol
.ginfo
.set_language (cu
->per_cu
->lang
,
7934 &objfile
->objfile_obstack
);
7935 psymbol
.ginfo
.set_section_index (-1);
7937 /* The code below indicates that the psymbol should be installed by
7939 gdb::optional
<psymbol_placement
> where
;
7943 case DW_TAG_inlined_subroutine
:
7944 case DW_TAG_subprogram
:
7945 addr
= (gdbarch_adjust_dwarf2_addr (gdbarch
, pdi
->lowpc
+ baseaddr
)
7947 if (pdi
->is_external
7948 || cu
->per_cu
->lang
== language_ada
7949 || (cu
->per_cu
->lang
== language_fortran
7950 && pdi
->die_parent
!= NULL
7951 && pdi
->die_parent
->tag
== DW_TAG_subprogram
))
7953 /* Normally, only "external" DIEs are part of the global scope.
7954 But in Ada and Fortran, we want to be able to access nested
7955 procedures globally. So all Ada and Fortran subprograms are
7956 stored in the global scope. */
7957 where
= psymbol_placement::GLOBAL
;
7960 where
= psymbol_placement::STATIC
;
7962 psymbol
.domain
= VAR_DOMAIN
;
7963 psymbol
.aclass
= LOC_BLOCK
;
7964 psymbol
.ginfo
.set_section_index (SECT_OFF_TEXT (objfile
));
7965 psymbol
.ginfo
.value
.address
= addr
;
7967 if (pdi
->main_subprogram
&& actual_name
!= NULL
)
7968 set_objfile_main_name (objfile
, actual_name
, cu
->per_cu
->lang
);
7970 case DW_TAG_constant
:
7971 psymbol
.domain
= VAR_DOMAIN
;
7972 psymbol
.aclass
= LOC_STATIC
;
7973 where
= (pdi
->is_external
7974 ? psymbol_placement::GLOBAL
7975 : psymbol_placement::STATIC
);
7977 case DW_TAG_variable
:
7979 addr
= decode_locdesc (pdi
->d
.locdesc
, cu
);
7983 && !per_objfile
->per_bfd
->has_section_at_zero
)
7985 /* A global or static variable may also have been stripped
7986 out by the linker if unused, in which case its address
7987 will be nullified; do not add such variables into partial
7988 symbol table then. */
7990 else if (pdi
->is_external
)
7993 Don't enter into the minimal symbol tables as there is
7994 a minimal symbol table entry from the ELF symbols already.
7995 Enter into partial symbol table if it has a location
7996 descriptor or a type.
7997 If the location descriptor is missing, new_symbol will create
7998 a LOC_UNRESOLVED symbol, the address of the variable will then
7999 be determined from the minimal symbol table whenever the variable
8001 The address for the partial symbol table entry is not
8002 used by GDB, but it comes in handy for debugging partial symbol
8005 if (pdi
->d
.locdesc
|| pdi
->has_type
)
8007 psymbol
.domain
= VAR_DOMAIN
;
8008 psymbol
.aclass
= LOC_STATIC
;
8009 psymbol
.ginfo
.set_section_index (SECT_OFF_TEXT (objfile
));
8010 psymbol
.ginfo
.value
.address
= addr
;
8011 where
= psymbol_placement::GLOBAL
;
8016 int has_loc
= pdi
->d
.locdesc
!= NULL
;
8018 /* Static Variable. Skip symbols whose value we cannot know (those
8019 without location descriptors or constant values). */
8020 if (!has_loc
&& !pdi
->has_const_value
)
8023 psymbol
.domain
= VAR_DOMAIN
;
8024 psymbol
.aclass
= LOC_STATIC
;
8025 psymbol
.ginfo
.set_section_index (SECT_OFF_TEXT (objfile
));
8027 psymbol
.ginfo
.value
.address
= addr
;
8028 where
= psymbol_placement::STATIC
;
8031 case DW_TAG_array_type
:
8032 case DW_TAG_typedef
:
8033 case DW_TAG_base_type
:
8034 case DW_TAG_subrange_type
:
8035 psymbol
.domain
= VAR_DOMAIN
;
8036 psymbol
.aclass
= LOC_TYPEDEF
;
8037 where
= psymbol_placement::STATIC
;
8039 case DW_TAG_imported_declaration
:
8040 case DW_TAG_namespace
:
8041 psymbol
.domain
= VAR_DOMAIN
;
8042 psymbol
.aclass
= LOC_TYPEDEF
;
8043 where
= psymbol_placement::GLOBAL
;
8046 /* With Fortran 77 there might be a "BLOCK DATA" module
8047 available without any name. If so, we skip the module as it
8048 doesn't bring any value. */
8049 if (actual_name
!= nullptr)
8051 psymbol
.domain
= MODULE_DOMAIN
;
8052 psymbol
.aclass
= LOC_TYPEDEF
;
8053 where
= psymbol_placement::GLOBAL
;
8056 case DW_TAG_class_type
:
8057 case DW_TAG_interface_type
:
8058 case DW_TAG_structure_type
:
8059 case DW_TAG_union_type
:
8060 case DW_TAG_enumeration_type
:
8061 /* Skip external references. The DWARF standard says in the section
8062 about "Structure, Union, and Class Type Entries": "An incomplete
8063 structure, union or class type is represented by a structure,
8064 union or class entry that does not have a byte size attribute
8065 and that has a DW_AT_declaration attribute." */
8066 if (!pdi
->has_byte_size
&& pdi
->is_declaration
)
8069 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
8070 static vs. global. */
8071 psymbol
.domain
= STRUCT_DOMAIN
;
8072 psymbol
.aclass
= LOC_TYPEDEF
;
8073 where
= (cu
->per_cu
->lang
== language_cplus
8074 ? psymbol_placement::GLOBAL
8075 : psymbol_placement::STATIC
);
8077 case DW_TAG_enumerator
:
8078 psymbol
.domain
= VAR_DOMAIN
;
8079 psymbol
.aclass
= LOC_CONST
;
8080 where
= (cu
->per_cu
->lang
== language_cplus
8081 ? psymbol_placement::GLOBAL
8082 : psymbol_placement::STATIC
);
8088 if (where
.has_value ())
8090 if (built_actual_name
!= nullptr)
8091 actual_name
= objfile
->intern (actual_name
);
8092 if (pdi
->linkage_name
== nullptr
8093 || cu
->per_cu
->lang
== language_ada
)
8094 psymbol
.ginfo
.set_linkage_name (actual_name
);
8097 psymbol
.ginfo
.set_demangled_name (actual_name
,
8098 &objfile
->objfile_obstack
);
8099 psymbol
.ginfo
.set_linkage_name (pdi
->linkage_name
);
8101 cu
->per_cu
->v
.psymtab
->add_psymbol
8102 (psymbol
, *where
, per_objfile
->per_bfd
->partial_symtabs
.get (),
8107 /* Read a partial die corresponding to a namespace; also, add a symbol
8108 corresponding to that namespace to the symbol table. NAMESPACE is
8109 the name of the enclosing namespace. */
8112 add_partial_namespace (struct partial_die_info
*pdi
,
8113 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
8114 int set_addrmap
, struct dwarf2_cu
*cu
)
8116 /* Add a symbol for the namespace. */
8118 add_partial_symbol (pdi
, cu
);
8120 /* Now scan partial symbols in that namespace. */
8122 if (pdi
->has_children
)
8123 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, set_addrmap
, cu
);
8126 /* Read a partial die corresponding to a Fortran module. */
8129 add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
8130 CORE_ADDR
*highpc
, int set_addrmap
, struct dwarf2_cu
*cu
)
8132 /* Add a symbol for the namespace. */
8134 add_partial_symbol (pdi
, cu
);
8136 /* Now scan partial symbols in that module. */
8138 if (pdi
->has_children
)
8139 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, set_addrmap
, cu
);
8143 dwarf2_ranges_read (unsigned, CORE_ADDR
*, CORE_ADDR
*, struct dwarf2_cu
*,
8144 dwarf2_psymtab
*, dwarf_tag
);
8146 /* Read a partial die corresponding to a subprogram or an inlined
8147 subprogram and create a partial symbol for that subprogram.
8148 When the CU language allows it, this routine also defines a partial
8149 symbol for each nested subprogram that this subprogram contains.
8150 If SET_ADDRMAP is true, record the covered ranges in the addrmap.
8151 Set *LOWPC and *HIGHPC to the lowest and highest PC values found in PDI.
8153 PDI may also be a lexical block, in which case we simply search
8154 recursively for subprograms defined inside that lexical block.
8155 Again, this is only performed when the CU language allows this
8156 type of definitions. */
8159 add_partial_subprogram (struct partial_die_info
*pdi
,
8160 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
8161 int set_addrmap
, struct dwarf2_cu
*cu
)
8163 if (pdi
->tag
== DW_TAG_subprogram
|| pdi
->tag
== DW_TAG_inlined_subroutine
)
8165 if (pdi
->has_pc_info
)
8167 if (pdi
->lowpc
< *lowpc
)
8168 *lowpc
= pdi
->lowpc
;
8169 if (pdi
->highpc
> *highpc
)
8170 *highpc
= pdi
->highpc
;
8173 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
8174 dwarf2_per_bfd
*per_bfd
= cu
->per_objfile
->per_bfd
;
8175 struct gdbarch
*gdbarch
= objfile
->arch ();
8177 CORE_ADDR this_highpc
;
8178 CORE_ADDR this_lowpc
;
8180 baseaddr
= objfile
->text_section_offset ();
8182 = (gdbarch_adjust_dwarf2_addr (gdbarch
,
8183 pdi
->lowpc
+ baseaddr
)
8186 = (gdbarch_adjust_dwarf2_addr (gdbarch
,
8187 pdi
->highpc
+ baseaddr
)
8189 addrmap_set_empty (per_bfd
->partial_symtabs
->psymtabs_addrmap
,
8190 this_lowpc
, this_highpc
- 1,
8191 cu
->per_cu
->v
.psymtab
);
8195 if (pdi
->has_range_info
8196 && dwarf2_ranges_read (pdi
->ranges_offset
, &pdi
->lowpc
, &pdi
->highpc
,
8198 set_addrmap
? cu
->per_cu
->v
.psymtab
: nullptr,
8201 if (pdi
->lowpc
< *lowpc
)
8202 *lowpc
= pdi
->lowpc
;
8203 if (pdi
->highpc
> *highpc
)
8204 *highpc
= pdi
->highpc
;
8207 if (pdi
->has_pc_info
|| pdi
->has_range_info
8208 || (!pdi
->is_external
&& pdi
->may_be_inlined
))
8210 if (!pdi
->is_declaration
)
8211 /* Ignore subprogram DIEs that do not have a name, they are
8212 illegal. Do not emit a complaint at this point, we will
8213 do so when we convert this psymtab into a symtab. */
8215 add_partial_symbol (pdi
, cu
);
8219 if (! pdi
->has_children
)
8222 if (cu
->per_cu
->lang
== language_ada
8223 || cu
->per_cu
->lang
== language_fortran
)
8225 pdi
= pdi
->die_child
;
8229 if (pdi
->tag
== DW_TAG_subprogram
8230 || pdi
->tag
== DW_TAG_inlined_subroutine
8231 || pdi
->tag
== DW_TAG_lexical_block
)
8232 add_partial_subprogram (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
8233 pdi
= pdi
->die_sibling
;
8238 /* Read a partial die corresponding to an enumeration type. */
8241 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
8242 struct dwarf2_cu
*cu
)
8244 struct partial_die_info
*pdi
;
8246 if (enum_pdi
->name (cu
) != NULL
)
8247 add_partial_symbol (enum_pdi
, cu
);
8249 pdi
= enum_pdi
->die_child
;
8252 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->raw_name
== NULL
)
8253 complaint (_("malformed enumerator DIE ignored"));
8255 add_partial_symbol (pdi
, cu
);
8256 pdi
= pdi
->die_sibling
;
8260 /* Return the initial uleb128 in the die at INFO_PTR. */
8263 peek_abbrev_code (bfd
*abfd
, const gdb_byte
*info_ptr
)
8265 unsigned int bytes_read
;
8267 return read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
8270 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit
8271 READER::CU. Use READER::ABBREV_TABLE to lookup any abbreviation.
8273 Return the corresponding abbrev, or NULL if the number is zero (indicating
8274 an empty DIE). In either case *BYTES_READ will be set to the length of
8275 the initial number. */
8277 static const struct abbrev_info
*
8278 peek_die_abbrev (const die_reader_specs
&reader
,
8279 const gdb_byte
*info_ptr
, unsigned int *bytes_read
)
8281 dwarf2_cu
*cu
= reader
.cu
;
8282 bfd
*abfd
= reader
.abfd
;
8283 unsigned int abbrev_number
8284 = read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
8286 if (abbrev_number
== 0)
8289 const abbrev_info
*abbrev
8290 = reader
.abbrev_table
->lookup_abbrev (abbrev_number
);
8293 error (_("Dwarf Error: Could not find abbrev number %d in %s"
8294 " at offset %s [in module %s]"),
8295 abbrev_number
, cu
->per_cu
->is_debug_types
? "TU" : "CU",
8296 sect_offset_str (cu
->header
.sect_off
), bfd_get_filename (abfd
));
8302 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
8303 Returns a pointer to the end of a series of DIEs, terminated by an empty
8304 DIE. Any children of the skipped DIEs will also be skipped. */
8306 static const gdb_byte
*
8307 skip_children (const struct die_reader_specs
*reader
, const gdb_byte
*info_ptr
)
8311 unsigned int bytes_read
;
8312 const abbrev_info
*abbrev
= peek_die_abbrev (*reader
, info_ptr
,
8316 return info_ptr
+ bytes_read
;
8318 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
8322 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
8323 INFO_PTR should point just after the initial uleb128 of a DIE, and the
8324 abbrev corresponding to that skipped uleb128 should be passed in
8325 ABBREV. Returns a pointer to this DIE's sibling, skipping any
8328 static const gdb_byte
*
8329 skip_one_die (const struct die_reader_specs
*reader
, const gdb_byte
*info_ptr
,
8330 const struct abbrev_info
*abbrev
)
8332 unsigned int bytes_read
;
8333 struct attribute attr
;
8334 bfd
*abfd
= reader
->abfd
;
8335 struct dwarf2_cu
*cu
= reader
->cu
;
8336 const gdb_byte
*buffer
= reader
->buffer
;
8337 const gdb_byte
*buffer_end
= reader
->buffer_end
;
8338 unsigned int form
, i
;
8340 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
8342 /* The only abbrev we care about is DW_AT_sibling. */
8343 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
8345 read_attribute (reader
, &attr
, &abbrev
->attrs
[i
], info_ptr
);
8346 if (attr
.form
== DW_FORM_ref_addr
)
8347 complaint (_("ignoring absolute DW_AT_sibling"));
8350 sect_offset off
= attr
.get_ref_die_offset ();
8351 const gdb_byte
*sibling_ptr
= buffer
+ to_underlying (off
);
8353 if (sibling_ptr
< info_ptr
)
8354 complaint (_("DW_AT_sibling points backwards"));
8355 else if (sibling_ptr
> reader
->buffer_end
)
8356 reader
->die_section
->overflow_complaint ();
8362 /* If it isn't DW_AT_sibling, skip this attribute. */
8363 form
= abbrev
->attrs
[i
].form
;
8367 case DW_FORM_ref_addr
:
8368 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
8369 and later it is offset sized. */
8370 if (cu
->header
.version
== 2)
8371 info_ptr
+= cu
->header
.addr_size
;
8373 info_ptr
+= cu
->header
.offset_size
;
8375 case DW_FORM_GNU_ref_alt
:
8376 info_ptr
+= cu
->header
.offset_size
;
8379 info_ptr
+= cu
->header
.addr_size
;
8387 case DW_FORM_flag_present
:
8388 case DW_FORM_implicit_const
:
8405 case DW_FORM_ref_sig8
:
8408 case DW_FORM_data16
:
8411 case DW_FORM_string
:
8412 read_direct_string (abfd
, info_ptr
, &bytes_read
);
8413 info_ptr
+= bytes_read
;
8415 case DW_FORM_sec_offset
:
8417 case DW_FORM_GNU_strp_alt
:
8418 info_ptr
+= cu
->header
.offset_size
;
8420 case DW_FORM_exprloc
:
8422 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
8423 info_ptr
+= bytes_read
;
8425 case DW_FORM_block1
:
8426 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
8428 case DW_FORM_block2
:
8429 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
8431 case DW_FORM_block4
:
8432 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
8438 case DW_FORM_ref_udata
:
8439 case DW_FORM_GNU_addr_index
:
8440 case DW_FORM_GNU_str_index
:
8441 case DW_FORM_rnglistx
:
8442 case DW_FORM_loclistx
:
8443 info_ptr
= safe_skip_leb128 (info_ptr
, buffer_end
);
8445 case DW_FORM_indirect
:
8446 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
8447 info_ptr
+= bytes_read
;
8448 /* We need to continue parsing from here, so just go back to
8450 goto skip_attribute
;
8453 error (_("Dwarf Error: Cannot handle %s "
8454 "in DWARF reader [in module %s]"),
8455 dwarf_form_name (form
),
8456 bfd_get_filename (abfd
));
8460 if (abbrev
->has_children
)
8461 return skip_children (reader
, info_ptr
);
8466 /* Locate ORIG_PDI's sibling.
8467 INFO_PTR should point to the start of the next DIE after ORIG_PDI. */
8469 static const gdb_byte
*
8470 locate_pdi_sibling (const struct die_reader_specs
*reader
,
8471 struct partial_die_info
*orig_pdi
,
8472 const gdb_byte
*info_ptr
)
8474 /* Do we know the sibling already? */
8476 if (orig_pdi
->sibling
)
8477 return orig_pdi
->sibling
;
8479 /* Are there any children to deal with? */
8481 if (!orig_pdi
->has_children
)
8484 /* Skip the children the long way. */
8486 return skip_children (reader
, info_ptr
);
8489 /* Expand this partial symbol table into a full symbol table. SELF is
8493 dwarf2_psymtab::read_symtab (struct objfile
*objfile
)
8495 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
8497 gdb_assert (!per_objfile
->symtab_set_p (per_cu_data
));
8499 /* If this psymtab is constructed from a debug-only objfile, the
8500 has_section_at_zero flag will not necessarily be correct. We
8501 can get the correct value for this flag by looking at the data
8502 associated with the (presumably stripped) associated objfile. */
8503 if (objfile
->separate_debug_objfile_backlink
)
8505 dwarf2_per_objfile
*per_objfile_backlink
8506 = get_dwarf2_per_objfile (objfile
->separate_debug_objfile_backlink
);
8508 per_objfile
->per_bfd
->has_section_at_zero
8509 = per_objfile_backlink
->per_bfd
->has_section_at_zero
;
8512 expand_psymtab (objfile
);
8514 process_cu_includes (per_objfile
);
8517 /* Reading in full CUs. */
8519 /* Add PER_CU to the queue. */
8522 queue_comp_unit (dwarf2_per_cu_data
*per_cu
,
8523 dwarf2_per_objfile
*per_objfile
,
8524 enum language pretend_language
)
8528 gdb_assert (per_objfile
->per_bfd
->queue
.has_value ());
8529 per_cu
->per_bfd
->queue
->emplace (per_cu
, per_objfile
, pretend_language
);
8532 /* If PER_CU is not yet expanded of queued for expansion, add it to the queue.
8534 If DEPENDENT_CU is non-NULL, it has a reference to PER_CU so add a
8537 Return true if maybe_queue_comp_unit requires the caller to load the CU's
8538 DIEs, false otherwise.
8540 Explanation: there is an invariant that if a CU is queued for expansion
8541 (present in `dwarf2_per_bfd::queue`), then its DIEs are loaded
8542 (a dwarf2_cu object exists for this CU, and `dwarf2_per_objfile::get_cu`
8543 returns non-nullptr). If the CU gets enqueued by this function but its DIEs
8544 are not yet loaded, the the caller must load the CU's DIEs to ensure the
8545 invariant is respected.
8547 The caller is therefore not required to load the CU's DIEs (we return false)
8550 - the CU is already expanded, and therefore does not get enqueued
8551 - the CU gets enqueued for expansion, but its DIEs are already loaded
8553 Note that the caller should not use this function's return value as an
8554 indicator of whether the CU's DIEs are loaded right now, it should check
8555 that by calling `dwarf2_per_objfile::get_cu` instead. */
8558 maybe_queue_comp_unit (struct dwarf2_cu
*dependent_cu
,
8559 dwarf2_per_cu_data
*per_cu
,
8560 dwarf2_per_objfile
*per_objfile
,
8561 enum language pretend_language
)
8563 /* We may arrive here during partial symbol reading, if we need full
8564 DIEs to process an unusual case (e.g. template arguments). Do
8565 not queue PER_CU, just tell our caller to load its DIEs. */
8566 if (per_cu
->per_bfd
->reading_partial_symbols
)
8568 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
8570 if (cu
== NULL
|| cu
->dies
== NULL
)
8575 /* Mark the dependence relation so that we don't flush PER_CU
8577 if (dependent_cu
!= NULL
)
8578 dependent_cu
->add_dependence (per_cu
);
8580 /* If it's already on the queue, we have nothing to do. */
8583 /* Verify the invariant that if a CU is queued for expansion, its DIEs are
8585 gdb_assert (per_objfile
->get_cu (per_cu
) != nullptr);
8587 /* If the CU is queued for expansion, it should not already be
8589 gdb_assert (!per_objfile
->symtab_set_p (per_cu
));
8591 /* The DIEs are already loaded, the caller doesn't need to do it. */
8595 bool queued
= false;
8596 if (!per_objfile
->symtab_set_p (per_cu
))
8598 /* Add it to the queue. */
8599 queue_comp_unit (per_cu
, per_objfile
, pretend_language
);
8603 /* If the compilation unit is already loaded, just mark it as
8605 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
8609 /* Ask the caller to load the CU's DIEs if the CU got enqueued for expansion
8610 and the DIEs are not already loaded. */
8611 return queued
&& cu
== nullptr;
8614 /* Process the queue. */
8617 process_queue (dwarf2_per_objfile
*per_objfile
)
8619 dwarf_read_debug_printf ("Expanding one or more symtabs of objfile %s ...",
8620 objfile_name (per_objfile
->objfile
));
8622 /* The queue starts out with one item, but following a DIE reference
8623 may load a new CU, adding it to the end of the queue. */
8624 while (!per_objfile
->per_bfd
->queue
->empty ())
8626 dwarf2_queue_item
&item
= per_objfile
->per_bfd
->queue
->front ();
8627 dwarf2_per_cu_data
*per_cu
= item
.per_cu
;
8629 if (!per_objfile
->symtab_set_p (per_cu
))
8631 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
8633 /* Skip dummy CUs. */
8636 unsigned int debug_print_threshold
;
8639 if (per_cu
->is_debug_types
)
8641 struct signatured_type
*sig_type
=
8642 (struct signatured_type
*) per_cu
;
8644 sprintf (buf
, "TU %s at offset %s",
8645 hex_string (sig_type
->signature
),
8646 sect_offset_str (per_cu
->sect_off
));
8647 /* There can be 100s of TUs.
8648 Only print them in verbose mode. */
8649 debug_print_threshold
= 2;
8653 sprintf (buf
, "CU at offset %s",
8654 sect_offset_str (per_cu
->sect_off
));
8655 debug_print_threshold
= 1;
8658 if (dwarf_read_debug
>= debug_print_threshold
)
8659 dwarf_read_debug_printf ("Expanding symtab of %s", buf
);
8661 if (per_cu
->is_debug_types
)
8662 process_full_type_unit (cu
, item
.pretend_language
);
8664 process_full_comp_unit (cu
, item
.pretend_language
);
8666 if (dwarf_read_debug
>= debug_print_threshold
)
8667 dwarf_read_debug_printf ("Done expanding %s", buf
);
8672 per_objfile
->per_bfd
->queue
->pop ();
8675 dwarf_read_debug_printf ("Done expanding symtabs of %s.",
8676 objfile_name (per_objfile
->objfile
));
8679 /* Read in full symbols for PST, and anything it depends on. */
8682 dwarf2_psymtab::expand_psymtab (struct objfile
*objfile
)
8684 gdb_assert (!readin_p (objfile
));
8686 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
8687 free_cached_comp_units
freer (per_objfile
);
8688 expand_dependencies (objfile
);
8690 dw2_do_instantiate_symtab (per_cu_data
, per_objfile
, false);
8691 gdb_assert (get_compunit_symtab (objfile
) != nullptr);
8694 /* See psympriv.h. */
8697 dwarf2_psymtab::readin_p (struct objfile
*objfile
) const
8699 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
8700 return per_objfile
->symtab_set_p (per_cu_data
);
8703 /* See psympriv.h. */
8706 dwarf2_psymtab::get_compunit_symtab (struct objfile
*objfile
) const
8708 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
8709 return per_objfile
->get_symtab (per_cu_data
);
8712 /* Trivial hash function for die_info: the hash value of a DIE
8713 is its offset in .debug_info for this objfile. */
8716 die_hash (const void *item
)
8718 const struct die_info
*die
= (const struct die_info
*) item
;
8720 return to_underlying (die
->sect_off
);
8723 /* Trivial comparison function for die_info structures: two DIEs
8724 are equal if they have the same offset. */
8727 die_eq (const void *item_lhs
, const void *item_rhs
)
8729 const struct die_info
*die_lhs
= (const struct die_info
*) item_lhs
;
8730 const struct die_info
*die_rhs
= (const struct die_info
*) item_rhs
;
8732 return die_lhs
->sect_off
== die_rhs
->sect_off
;
8735 /* Load the DIEs associated with PER_CU into memory.
8737 In some cases, the caller, while reading partial symbols, will need to load
8738 the full symbols for the CU for some reason. It will already have a
8739 dwarf2_cu object for THIS_CU and pass it as EXISTING_CU, so it can be re-used
8740 rather than creating a new one. */
8743 load_full_comp_unit (dwarf2_per_cu_data
*this_cu
,
8744 dwarf2_per_objfile
*per_objfile
,
8745 dwarf2_cu
*existing_cu
,
8747 enum language pretend_language
)
8749 gdb_assert (! this_cu
->is_debug_types
);
8751 cutu_reader
reader (this_cu
, per_objfile
, NULL
, existing_cu
, skip_partial
);
8755 struct dwarf2_cu
*cu
= reader
.cu
;
8756 const gdb_byte
*info_ptr
= reader
.info_ptr
;
8758 gdb_assert (cu
->die_hash
== NULL
);
8760 htab_create_alloc_ex (cu
->header
.length
/ 12,
8764 &cu
->comp_unit_obstack
,
8765 hashtab_obstack_allocate
,
8766 dummy_obstack_deallocate
);
8768 if (reader
.comp_unit_die
->has_children
)
8769 reader
.comp_unit_die
->child
8770 = read_die_and_siblings (&reader
, reader
.info_ptr
,
8771 &info_ptr
, reader
.comp_unit_die
);
8772 cu
->dies
= reader
.comp_unit_die
;
8773 /* comp_unit_die is not stored in die_hash, no need. */
8775 /* We try not to read any attributes in this function, because not
8776 all CUs needed for references have been loaded yet, and symbol
8777 table processing isn't initialized. But we have to set the CU language,
8778 or we won't be able to build types correctly.
8779 Similarly, if we do not read the producer, we can not apply
8780 producer-specific interpretation. */
8781 prepare_one_comp_unit (cu
, cu
->dies
, pretend_language
);
8786 /* Add a DIE to the delayed physname list. */
8789 add_to_method_list (struct type
*type
, int fnfield_index
, int index
,
8790 const char *name
, struct die_info
*die
,
8791 struct dwarf2_cu
*cu
)
8793 struct delayed_method_info mi
;
8795 mi
.fnfield_index
= fnfield_index
;
8799 cu
->method_list
.push_back (mi
);
8802 /* Check whether [PHYSNAME, PHYSNAME+LEN) ends with a modifier like
8803 "const" / "volatile". If so, decrements LEN by the length of the
8804 modifier and return true. Otherwise return false. */
8808 check_modifier (const char *physname
, size_t &len
, const char (&mod
)[N
])
8810 size_t mod_len
= sizeof (mod
) - 1;
8811 if (len
> mod_len
&& startswith (physname
+ (len
- mod_len
), mod
))
8819 /* Compute the physnames of any methods on the CU's method list.
8821 The computation of method physnames is delayed in order to avoid the
8822 (bad) condition that one of the method's formal parameters is of an as yet
8826 compute_delayed_physnames (struct dwarf2_cu
*cu
)
8828 /* Only C++ delays computing physnames. */
8829 if (cu
->method_list
.empty ())
8831 gdb_assert (cu
->per_cu
->lang
== language_cplus
);
8833 for (const delayed_method_info
&mi
: cu
->method_list
)
8835 const char *physname
;
8836 struct fn_fieldlist
*fn_flp
8837 = &TYPE_FN_FIELDLIST (mi
.type
, mi
.fnfield_index
);
8838 physname
= dwarf2_physname (mi
.name
, mi
.die
, cu
);
8839 TYPE_FN_FIELD_PHYSNAME (fn_flp
->fn_fields
, mi
.index
)
8840 = physname
? physname
: "";
8842 /* Since there's no tag to indicate whether a method is a
8843 const/volatile overload, extract that information out of the
8845 if (physname
!= NULL
)
8847 size_t len
= strlen (physname
);
8851 if (physname
[len
] == ')') /* shortcut */
8853 else if (check_modifier (physname
, len
, " const"))
8854 TYPE_FN_FIELD_CONST (fn_flp
->fn_fields
, mi
.index
) = 1;
8855 else if (check_modifier (physname
, len
, " volatile"))
8856 TYPE_FN_FIELD_VOLATILE (fn_flp
->fn_fields
, mi
.index
) = 1;
8863 /* The list is no longer needed. */
8864 cu
->method_list
.clear ();
8867 /* Go objects should be embedded in a DW_TAG_module DIE,
8868 and it's not clear if/how imported objects will appear.
8869 To keep Go support simple until that's worked out,
8870 go back through what we've read and create something usable.
8871 We could do this while processing each DIE, and feels kinda cleaner,
8872 but that way is more invasive.
8873 This is to, for example, allow the user to type "p var" or "b main"
8874 without having to specify the package name, and allow lookups
8875 of module.object to work in contexts that use the expression
8879 fixup_go_packaging (struct dwarf2_cu
*cu
)
8881 gdb::unique_xmalloc_ptr
<char> package_name
;
8882 struct pending
*list
;
8885 for (list
= *cu
->get_builder ()->get_global_symbols ();
8889 for (i
= 0; i
< list
->nsyms
; ++i
)
8891 struct symbol
*sym
= list
->symbol
[i
];
8893 if (sym
->language () == language_go
8894 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
8896 gdb::unique_xmalloc_ptr
<char> this_package_name
8897 (go_symbol_package_name (sym
));
8899 if (this_package_name
== NULL
)
8901 if (package_name
== NULL
)
8902 package_name
= std::move (this_package_name
);
8905 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
8906 if (strcmp (package_name
.get (), this_package_name
.get ()) != 0)
8907 complaint (_("Symtab %s has objects from two different Go packages: %s and %s"),
8908 (symbol_symtab (sym
) != NULL
8909 ? symtab_to_filename_for_display
8910 (symbol_symtab (sym
))
8911 : objfile_name (objfile
)),
8912 this_package_name
.get (), package_name
.get ());
8918 if (package_name
!= NULL
)
8920 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
8921 const char *saved_package_name
= objfile
->intern (package_name
.get ());
8922 struct type
*type
= init_type (objfile
, TYPE_CODE_MODULE
, 0,
8923 saved_package_name
);
8926 sym
= new (&objfile
->objfile_obstack
) symbol
;
8927 sym
->set_language (language_go
, &objfile
->objfile_obstack
);
8928 sym
->compute_and_set_names (saved_package_name
, false, objfile
->per_bfd
);
8929 /* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
8930 e.g., "main" finds the "main" module and not C's main(). */
8931 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
8932 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
8933 SYMBOL_TYPE (sym
) = type
;
8935 add_symbol_to_list (sym
, cu
->get_builder ()->get_global_symbols ());
8939 /* Allocate a fully-qualified name consisting of the two parts on the
8943 rust_fully_qualify (struct obstack
*obstack
, const char *p1
, const char *p2
)
8945 return obconcat (obstack
, p1
, "::", p2
, (char *) NULL
);
8948 /* A helper that allocates a variant part to attach to a Rust enum
8949 type. OBSTACK is where the results should be allocated. TYPE is
8950 the type we're processing. DISCRIMINANT_INDEX is the index of the
8951 discriminant. It must be the index of one of the fields of TYPE,
8952 or -1 to mean there is no discriminant (univariant enum).
8953 DEFAULT_INDEX is the index of the default field; or -1 if there is
8954 no default. RANGES is indexed by "effective" field number (the
8955 field index, but omitting the discriminant and default fields) and
8956 must hold the discriminant values used by the variants. Note that
8957 RANGES must have a lifetime at least as long as OBSTACK -- either
8958 already allocated on it, or static. */
8961 alloc_rust_variant (struct obstack
*obstack
, struct type
*type
,
8962 int discriminant_index
, int default_index
,
8963 gdb::array_view
<discriminant_range
> ranges
)
8965 /* When DISCRIMINANT_INDEX == -1, we have a univariant enum. */
8966 gdb_assert (discriminant_index
== -1
8967 || (discriminant_index
>= 0
8968 && discriminant_index
< type
->num_fields ()));
8969 gdb_assert (default_index
== -1
8970 || (default_index
>= 0 && default_index
< type
->num_fields ()));
8972 /* We have one variant for each non-discriminant field. */
8973 int n_variants
= type
->num_fields ();
8974 if (discriminant_index
!= -1)
8977 variant
*variants
= new (obstack
) variant
[n_variants
];
8980 for (int i
= 0; i
< type
->num_fields (); ++i
)
8982 if (i
== discriminant_index
)
8985 variants
[var_idx
].first_field
= i
;
8986 variants
[var_idx
].last_field
= i
+ 1;
8988 /* The default field does not need a range, but other fields do.
8989 We skipped the discriminant above. */
8990 if (i
!= default_index
)
8992 variants
[var_idx
].discriminants
= ranges
.slice (range_idx
, 1);
8999 gdb_assert (range_idx
== ranges
.size ());
9000 gdb_assert (var_idx
== n_variants
);
9002 variant_part
*part
= new (obstack
) variant_part
;
9003 part
->discriminant_index
= discriminant_index
;
9004 /* If there is no discriminant, then whether it is signed is of no
9007 = (discriminant_index
== -1
9009 : type
->field (discriminant_index
).type ()->is_unsigned ());
9010 part
->variants
= gdb::array_view
<variant
> (variants
, n_variants
);
9012 void *storage
= obstack_alloc (obstack
, sizeof (gdb::array_view
<variant_part
>));
9013 gdb::array_view
<variant_part
> *prop_value
9014 = new (storage
) gdb::array_view
<variant_part
> (part
, 1);
9016 struct dynamic_prop prop
;
9017 prop
.set_variant_parts (prop_value
);
9019 type
->add_dyn_prop (DYN_PROP_VARIANT_PARTS
, prop
);
9022 /* Some versions of rustc emitted enums in an unusual way.
9024 Ordinary enums were emitted as unions. The first element of each
9025 structure in the union was named "RUST$ENUM$DISR". This element
9026 held the discriminant.
9028 These versions of Rust also implemented the "non-zero"
9029 optimization. When the enum had two values, and one is empty and
9030 the other holds a pointer that cannot be zero, the pointer is used
9031 as the discriminant, with a zero value meaning the empty variant.
9032 Here, the union's first member is of the form
9033 RUST$ENCODED$ENUM$<fieldno>$<fieldno>$...$<variantname>
9034 where the fieldnos are the indices of the fields that should be
9035 traversed in order to find the field (which may be several fields deep)
9036 and the variantname is the name of the variant of the case when the
9039 This function recognizes whether TYPE is of one of these forms,
9040 and, if so, smashes it to be a variant type. */
9043 quirk_rust_enum (struct type
*type
, struct objfile
*objfile
)
9045 gdb_assert (type
->code () == TYPE_CODE_UNION
);
9047 /* We don't need to deal with empty enums. */
9048 if (type
->num_fields () == 0)
9051 #define RUST_ENUM_PREFIX "RUST$ENCODED$ENUM$"
9052 if (type
->num_fields () == 1
9053 && startswith (type
->field (0).name (), RUST_ENUM_PREFIX
))
9055 const char *name
= type
->field (0).name () + strlen (RUST_ENUM_PREFIX
);
9057 /* Decode the field name to find the offset of the
9059 ULONGEST bit_offset
= 0;
9060 struct type
*field_type
= type
->field (0).type ();
9061 while (name
[0] >= '0' && name
[0] <= '9')
9064 unsigned long index
= strtoul (name
, &tail
, 10);
9067 || index
>= field_type
->num_fields ()
9068 || (field_type
->field (index
).loc_kind ()
9069 != FIELD_LOC_KIND_BITPOS
))
9071 complaint (_("Could not parse Rust enum encoding string \"%s\""
9073 type
->field (0).name (),
9074 objfile_name (objfile
));
9079 bit_offset
+= field_type
->field (index
).loc_bitpos ();
9080 field_type
= field_type
->field (index
).type ();
9083 /* Smash this type to be a structure type. We have to do this
9084 because the type has already been recorded. */
9085 type
->set_code (TYPE_CODE_STRUCT
);
9086 type
->set_num_fields (3);
9087 /* Save the field we care about. */
9088 struct field saved_field
= type
->field (0);
9090 ((struct field
*) TYPE_ZALLOC (type
, 3 * sizeof (struct field
)));
9092 /* Put the discriminant at index 0. */
9093 type
->field (0).set_type (field_type
);
9094 TYPE_FIELD_ARTIFICIAL (type
, 0) = 1;
9095 type
->field (0).set_name ("<<discriminant>>");
9096 type
->field (0).set_loc_bitpos (bit_offset
);
9098 /* The order of fields doesn't really matter, so put the real
9099 field at index 1 and the data-less field at index 2. */
9100 type
->field (1) = saved_field
;
9101 type
->field (1).set_name
9102 (rust_last_path_segment (type
->field (1).type ()->name ()));
9103 type
->field (1).type ()->set_name
9104 (rust_fully_qualify (&objfile
->objfile_obstack
, type
->name (),
9105 type
->field (1).name ()));
9107 const char *dataless_name
9108 = rust_fully_qualify (&objfile
->objfile_obstack
, type
->name (),
9110 struct type
*dataless_type
= init_type (objfile
, TYPE_CODE_VOID
, 0,
9112 type
->field (2).set_type (dataless_type
);
9113 /* NAME points into the original discriminant name, which
9114 already has the correct lifetime. */
9115 type
->field (2).set_name (name
);
9116 type
->field (2).set_loc_bitpos (0);
9118 /* Indicate that this is a variant type. */
9119 static discriminant_range ranges
[1] = { { 0, 0 } };
9120 alloc_rust_variant (&objfile
->objfile_obstack
, type
, 0, 1, ranges
);
9122 /* A union with a single anonymous field is probably an old-style
9124 else if (type
->num_fields () == 1 && streq (type
->field (0).name (), ""))
9126 /* Smash this type to be a structure type. We have to do this
9127 because the type has already been recorded. */
9128 type
->set_code (TYPE_CODE_STRUCT
);
9130 struct type
*field_type
= type
->field (0).type ();
9131 const char *variant_name
9132 = rust_last_path_segment (field_type
->name ());
9133 type
->field (0).set_name (variant_name
);
9134 field_type
->set_name
9135 (rust_fully_qualify (&objfile
->objfile_obstack
,
9136 type
->name (), variant_name
));
9138 alloc_rust_variant (&objfile
->objfile_obstack
, type
, -1, 0, {});
9142 struct type
*disr_type
= nullptr;
9143 for (int i
= 0; i
< type
->num_fields (); ++i
)
9145 disr_type
= type
->field (i
).type ();
9147 if (disr_type
->code () != TYPE_CODE_STRUCT
)
9149 /* All fields of a true enum will be structs. */
9152 else if (disr_type
->num_fields () == 0)
9154 /* Could be data-less variant, so keep going. */
9155 disr_type
= nullptr;
9157 else if (strcmp (disr_type
->field (0).name (),
9158 "RUST$ENUM$DISR") != 0)
9160 /* Not a Rust enum. */
9170 /* If we got here without a discriminant, then it's probably
9172 if (disr_type
== nullptr)
9175 /* Smash this type to be a structure type. We have to do this
9176 because the type has already been recorded. */
9177 type
->set_code (TYPE_CODE_STRUCT
);
9179 /* Make space for the discriminant field. */
9180 struct field
*disr_field
= &disr_type
->field (0);
9182 = (struct field
*) TYPE_ZALLOC (type
, ((type
->num_fields () + 1)
9183 * sizeof (struct field
)));
9184 memcpy (new_fields
+ 1, type
->fields (),
9185 type
->num_fields () * sizeof (struct field
));
9186 type
->set_fields (new_fields
);
9187 type
->set_num_fields (type
->num_fields () + 1);
9189 /* Install the discriminant at index 0 in the union. */
9190 type
->field (0) = *disr_field
;
9191 TYPE_FIELD_ARTIFICIAL (type
, 0) = 1;
9192 type
->field (0).set_name ("<<discriminant>>");
9194 /* We need a way to find the correct discriminant given a
9195 variant name. For convenience we build a map here. */
9196 struct type
*enum_type
= disr_field
->type ();
9197 std::unordered_map
<std::string
, ULONGEST
> discriminant_map
;
9198 for (int i
= 0; i
< enum_type
->num_fields (); ++i
)
9200 if (enum_type
->field (i
).loc_kind () == FIELD_LOC_KIND_ENUMVAL
)
9203 = rust_last_path_segment (enum_type
->field (i
).name ());
9204 discriminant_map
[name
] = TYPE_FIELD_ENUMVAL (enum_type
, i
);
9208 int n_fields
= type
->num_fields ();
9209 /* We don't need a range entry for the discriminant, but we do
9210 need one for every other field, as there is no default
9212 discriminant_range
*ranges
= XOBNEWVEC (&objfile
->objfile_obstack
,
9215 /* Skip the discriminant here. */
9216 for (int i
= 1; i
< n_fields
; ++i
)
9218 /* Find the final word in the name of this variant's type.
9219 That name can be used to look up the correct
9221 const char *variant_name
9222 = rust_last_path_segment (type
->field (i
).type ()->name ());
9224 auto iter
= discriminant_map
.find (variant_name
);
9225 if (iter
!= discriminant_map
.end ())
9227 ranges
[i
- 1].low
= iter
->second
;
9228 ranges
[i
- 1].high
= iter
->second
;
9231 /* In Rust, each element should have the size of the
9233 TYPE_LENGTH (type
->field (i
).type ()) = TYPE_LENGTH (type
);
9235 /* Remove the discriminant field, if it exists. */
9236 struct type
*sub_type
= type
->field (i
).type ();
9237 if (sub_type
->num_fields () > 0)
9239 sub_type
->set_num_fields (sub_type
->num_fields () - 1);
9240 sub_type
->set_fields (sub_type
->fields () + 1);
9242 type
->field (i
).set_name (variant_name
);
9244 (rust_fully_qualify (&objfile
->objfile_obstack
,
9245 type
->name (), variant_name
));
9248 /* Indicate that this is a variant type. */
9249 alloc_rust_variant (&objfile
->objfile_obstack
, type
, 0, -1,
9250 gdb::array_view
<discriminant_range
> (ranges
,
9255 /* Rewrite some Rust unions to be structures with variants parts. */
9258 rust_union_quirks (struct dwarf2_cu
*cu
)
9260 gdb_assert (cu
->per_cu
->lang
== language_rust
);
9261 for (type
*type_
: cu
->rust_unions
)
9262 quirk_rust_enum (type_
, cu
->per_objfile
->objfile
);
9263 /* We don't need this any more. */
9264 cu
->rust_unions
.clear ();
9269 type_unit_group_unshareable
*
9270 dwarf2_per_objfile::get_type_unit_group_unshareable (type_unit_group
*tu_group
)
9272 auto iter
= this->m_type_units
.find (tu_group
);
9273 if (iter
!= this->m_type_units
.end ())
9274 return iter
->second
.get ();
9276 type_unit_group_unshareable_up
uniq (new type_unit_group_unshareable
);
9277 type_unit_group_unshareable
*result
= uniq
.get ();
9278 this->m_type_units
[tu_group
] = std::move (uniq
);
9283 dwarf2_per_objfile::get_type_for_signatured_type
9284 (signatured_type
*sig_type
) const
9286 auto iter
= this->m_type_map
.find (sig_type
);
9287 if (iter
== this->m_type_map
.end ())
9290 return iter
->second
;
9293 void dwarf2_per_objfile::set_type_for_signatured_type
9294 (signatured_type
*sig_type
, struct type
*type
)
9296 gdb_assert (this->m_type_map
.find (sig_type
) == this->m_type_map
.end ());
9298 this->m_type_map
[sig_type
] = type
;
9301 /* A helper function for computing the list of all symbol tables
9302 included by PER_CU. */
9305 recursively_compute_inclusions (std::vector
<compunit_symtab
*> *result
,
9306 htab_t all_children
, htab_t all_type_symtabs
,
9307 dwarf2_per_cu_data
*per_cu
,
9308 dwarf2_per_objfile
*per_objfile
,
9309 struct compunit_symtab
*immediate_parent
)
9311 void **slot
= htab_find_slot (all_children
, per_cu
, INSERT
);
9314 /* This inclusion and its children have been processed. */
9320 /* Only add a CU if it has a symbol table. */
9321 compunit_symtab
*cust
= per_objfile
->get_symtab (per_cu
);
9324 /* If this is a type unit only add its symbol table if we haven't
9325 seen it yet (type unit per_cu's can share symtabs). */
9326 if (per_cu
->is_debug_types
)
9328 slot
= htab_find_slot (all_type_symtabs
, cust
, INSERT
);
9332 result
->push_back (cust
);
9333 if (cust
->user
== NULL
)
9334 cust
->user
= immediate_parent
;
9339 result
->push_back (cust
);
9340 if (cust
->user
== NULL
)
9341 cust
->user
= immediate_parent
;
9345 if (!per_cu
->imported_symtabs_empty ())
9346 for (dwarf2_per_cu_data
*ptr
: *per_cu
->imported_symtabs
)
9348 recursively_compute_inclusions (result
, all_children
,
9349 all_type_symtabs
, ptr
, per_objfile
,
9354 /* Compute the compunit_symtab 'includes' fields for the compunit_symtab of
9358 compute_compunit_symtab_includes (dwarf2_per_cu_data
*per_cu
,
9359 dwarf2_per_objfile
*per_objfile
)
9361 gdb_assert (! per_cu
->is_debug_types
);
9363 if (!per_cu
->imported_symtabs_empty ())
9366 std::vector
<compunit_symtab
*> result_symtabs
;
9367 compunit_symtab
*cust
= per_objfile
->get_symtab (per_cu
);
9369 /* If we don't have a symtab, we can just skip this case. */
9373 htab_up
all_children (htab_create_alloc (1, htab_hash_pointer
,
9375 NULL
, xcalloc
, xfree
));
9376 htab_up
all_type_symtabs (htab_create_alloc (1, htab_hash_pointer
,
9378 NULL
, xcalloc
, xfree
));
9380 for (dwarf2_per_cu_data
*ptr
: *per_cu
->imported_symtabs
)
9382 recursively_compute_inclusions (&result_symtabs
, all_children
.get (),
9383 all_type_symtabs
.get (), ptr
,
9387 /* Now we have a transitive closure of all the included symtabs. */
9388 len
= result_symtabs
.size ();
9390 = XOBNEWVEC (&per_objfile
->objfile
->objfile_obstack
,
9391 struct compunit_symtab
*, len
+ 1);
9392 memcpy (cust
->includes
, result_symtabs
.data (),
9393 len
* sizeof (compunit_symtab
*));
9394 cust
->includes
[len
] = NULL
;
9398 /* Compute the 'includes' field for the symtabs of all the CUs we just
9402 process_cu_includes (dwarf2_per_objfile
*per_objfile
)
9404 for (dwarf2_per_cu_data
*iter
: per_objfile
->per_bfd
->just_read_cus
)
9406 if (! iter
->is_debug_types
)
9407 compute_compunit_symtab_includes (iter
, per_objfile
);
9410 per_objfile
->per_bfd
->just_read_cus
.clear ();
9413 /* Generate full symbol information for CU, whose DIEs have
9414 already been loaded into memory. */
9417 process_full_comp_unit (dwarf2_cu
*cu
, enum language pretend_language
)
9419 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
9420 struct objfile
*objfile
= per_objfile
->objfile
;
9421 struct gdbarch
*gdbarch
= objfile
->arch ();
9422 CORE_ADDR lowpc
, highpc
;
9423 struct compunit_symtab
*cust
;
9425 struct block
*static_block
;
9428 baseaddr
= objfile
->text_section_offset ();
9430 /* Clear the list here in case something was left over. */
9431 cu
->method_list
.clear ();
9433 dwarf2_find_base_address (cu
->dies
, cu
);
9435 /* Before we start reading the top-level DIE, ensure it has a valid tag
9437 switch (cu
->dies
->tag
)
9439 case DW_TAG_compile_unit
:
9440 case DW_TAG_partial_unit
:
9441 case DW_TAG_type_unit
:
9444 error (_("Dwarf Error: unexpected tag '%s' at offset %s [in module %s]"),
9445 dwarf_tag_name (cu
->dies
->tag
),
9446 sect_offset_str (cu
->per_cu
->sect_off
),
9447 objfile_name (per_objfile
->objfile
));
9450 /* Do line number decoding in read_file_scope () */
9451 process_die (cu
->dies
, cu
);
9453 /* For now fudge the Go package. */
9454 if (cu
->per_cu
->lang
== language_go
)
9455 fixup_go_packaging (cu
);
9457 /* Now that we have processed all the DIEs in the CU, all the types
9458 should be complete, and it should now be safe to compute all of the
9460 compute_delayed_physnames (cu
);
9462 if (cu
->per_cu
->lang
== language_rust
)
9463 rust_union_quirks (cu
);
9465 /* Some compilers don't define a DW_AT_high_pc attribute for the
9466 compilation unit. If the DW_AT_high_pc is missing, synthesize
9467 it, by scanning the DIE's below the compilation unit. */
9468 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
9470 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
9471 static_block
= cu
->get_builder ()->end_symtab_get_static_block (addr
, 0, 1);
9473 /* If the comp unit has DW_AT_ranges, it may have discontiguous ranges.
9474 Also, DW_AT_ranges may record ranges not belonging to any child DIEs
9475 (such as virtual method tables). Record the ranges in STATIC_BLOCK's
9476 addrmap to help ensure it has an accurate map of pc values belonging to
9478 dwarf2_record_block_ranges (cu
->dies
, static_block
, baseaddr
, cu
);
9480 cust
= cu
->get_builder ()->end_symtab_from_static_block (static_block
,
9481 SECT_OFF_TEXT (objfile
),
9486 int gcc_4_minor
= producer_is_gcc_ge_4 (cu
->producer
);
9488 /* Set symtab language to language from DW_AT_language. If the
9489 compilation is from a C file generated by language preprocessors, do
9490 not set the language if it was already deduced by start_subfile. */
9491 if (!(cu
->per_cu
->lang
== language_c
9492 && COMPUNIT_FILETABS (cust
)->language
!= language_unknown
))
9493 COMPUNIT_FILETABS (cust
)->language
= cu
->per_cu
->lang
;
9495 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
9496 produce DW_AT_location with location lists but it can be possibly
9497 invalid without -fvar-tracking. Still up to GCC-4.4.x incl. 4.4.0
9498 there were bugs in prologue debug info, fixed later in GCC-4.5
9499 by "unwind info for epilogues" patch (which is not directly related).
9501 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
9502 needed, it would be wrong due to missing DW_AT_producer there.
9504 Still one can confuse GDB by using non-standard GCC compilation
9505 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
9507 if (cu
->has_loclist
&& gcc_4_minor
>= 5)
9508 cust
->locations_valid
= 1;
9510 if (gcc_4_minor
>= 5)
9511 cust
->epilogue_unwind_valid
= 1;
9513 cust
->set_call_site_htab (cu
->call_site_htab
);
9516 per_objfile
->set_symtab (cu
->per_cu
, cust
);
9518 /* Push it for inclusion processing later. */
9519 per_objfile
->per_bfd
->just_read_cus
.push_back (cu
->per_cu
);
9521 /* Not needed any more. */
9522 cu
->reset_builder ();
9525 /* Generate full symbol information for type unit CU, whose DIEs have
9526 already been loaded into memory. */
9529 process_full_type_unit (dwarf2_cu
*cu
,
9530 enum language pretend_language
)
9532 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
9533 struct objfile
*objfile
= per_objfile
->objfile
;
9534 struct compunit_symtab
*cust
;
9535 struct signatured_type
*sig_type
;
9537 gdb_assert (cu
->per_cu
->is_debug_types
);
9538 sig_type
= (struct signatured_type
*) cu
->per_cu
;
9540 /* Clear the list here in case something was left over. */
9541 cu
->method_list
.clear ();
9543 /* The symbol tables are set up in read_type_unit_scope. */
9544 process_die (cu
->dies
, cu
);
9546 /* For now fudge the Go package. */
9547 if (cu
->per_cu
->lang
== language_go
)
9548 fixup_go_packaging (cu
);
9550 /* Now that we have processed all the DIEs in the CU, all the types
9551 should be complete, and it should now be safe to compute all of the
9553 compute_delayed_physnames (cu
);
9555 if (cu
->per_cu
->lang
== language_rust
)
9556 rust_union_quirks (cu
);
9558 /* TUs share symbol tables.
9559 If this is the first TU to use this symtab, complete the construction
9560 of it with end_expandable_symtab. Otherwise, complete the addition of
9561 this TU's symbols to the existing symtab. */
9562 type_unit_group_unshareable
*tug_unshare
=
9563 per_objfile
->get_type_unit_group_unshareable (sig_type
->type_unit_group
);
9564 if (tug_unshare
->compunit_symtab
== NULL
)
9566 buildsym_compunit
*builder
= cu
->get_builder ();
9567 cust
= builder
->end_expandable_symtab (0, SECT_OFF_TEXT (objfile
));
9568 tug_unshare
->compunit_symtab
= cust
;
9572 /* Set symtab language to language from DW_AT_language. If the
9573 compilation is from a C file generated by language preprocessors,
9574 do not set the language if it was already deduced by
9576 if (!(cu
->per_cu
->lang
== language_c
9577 && COMPUNIT_FILETABS (cust
)->language
!= language_c
))
9578 COMPUNIT_FILETABS (cust
)->language
= cu
->per_cu
->lang
;
9583 cu
->get_builder ()->augment_type_symtab ();
9584 cust
= tug_unshare
->compunit_symtab
;
9587 per_objfile
->set_symtab (cu
->per_cu
, cust
);
9589 /* Not needed any more. */
9590 cu
->reset_builder ();
9593 /* Process an imported unit DIE. */
9596 process_imported_unit_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
9598 struct attribute
*attr
;
9600 /* For now we don't handle imported units in type units. */
9601 if (cu
->per_cu
->is_debug_types
)
9603 error (_("Dwarf Error: DW_TAG_imported_unit is not"
9604 " supported in type units [in module %s]"),
9605 objfile_name (cu
->per_objfile
->objfile
));
9608 attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
9611 sect_offset sect_off
= attr
->get_ref_die_offset ();
9612 bool is_dwz
= (attr
->form
== DW_FORM_GNU_ref_alt
|| cu
->per_cu
->is_dwz
);
9613 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
9614 dwarf2_per_cu_data
*per_cu
9615 = dwarf2_find_containing_comp_unit (sect_off
, is_dwz
, per_objfile
);
9617 /* We're importing a C++ compilation unit with tag DW_TAG_compile_unit
9618 into another compilation unit, at root level. Regard this as a hint,
9620 if (die
->parent
&& die
->parent
->parent
== NULL
9621 && per_cu
->unit_type
== DW_UT_compile
9622 && per_cu
->lang
== language_cplus
)
9625 /* If necessary, add it to the queue and load its DIEs. */
9626 if (maybe_queue_comp_unit (cu
, per_cu
, per_objfile
,
9628 load_full_comp_unit (per_cu
, per_objfile
, per_objfile
->get_cu (per_cu
),
9629 false, cu
->per_cu
->lang
);
9631 cu
->per_cu
->imported_symtabs_push (per_cu
);
9635 /* RAII object that represents a process_die scope: i.e.,
9636 starts/finishes processing a DIE. */
9637 class process_die_scope
9640 process_die_scope (die_info
*die
, dwarf2_cu
*cu
)
9641 : m_die (die
), m_cu (cu
)
9643 /* We should only be processing DIEs not already in process. */
9644 gdb_assert (!m_die
->in_process
);
9645 m_die
->in_process
= true;
9648 ~process_die_scope ()
9650 m_die
->in_process
= false;
9652 /* If we're done processing the DIE for the CU that owns the line
9653 header, we don't need the line header anymore. */
9654 if (m_cu
->line_header_die_owner
== m_die
)
9656 delete m_cu
->line_header
;
9657 m_cu
->line_header
= NULL
;
9658 m_cu
->line_header_die_owner
= NULL
;
9667 /* Process a die and its children. */
9670 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
9672 process_die_scope
scope (die
, cu
);
9676 case DW_TAG_padding
:
9678 case DW_TAG_compile_unit
:
9679 case DW_TAG_partial_unit
:
9680 read_file_scope (die
, cu
);
9682 case DW_TAG_type_unit
:
9683 read_type_unit_scope (die
, cu
);
9685 case DW_TAG_subprogram
:
9686 /* Nested subprograms in Fortran get a prefix. */
9687 if (cu
->per_cu
->lang
== language_fortran
9688 && die
->parent
!= NULL
9689 && die
->parent
->tag
== DW_TAG_subprogram
)
9690 cu
->processing_has_namespace_info
= true;
9692 case DW_TAG_inlined_subroutine
:
9693 read_func_scope (die
, cu
);
9695 case DW_TAG_lexical_block
:
9696 case DW_TAG_try_block
:
9697 case DW_TAG_catch_block
:
9698 read_lexical_block_scope (die
, cu
);
9700 case DW_TAG_call_site
:
9701 case DW_TAG_GNU_call_site
:
9702 read_call_site_scope (die
, cu
);
9704 case DW_TAG_class_type
:
9705 case DW_TAG_interface_type
:
9706 case DW_TAG_structure_type
:
9707 case DW_TAG_union_type
:
9708 process_structure_scope (die
, cu
);
9710 case DW_TAG_enumeration_type
:
9711 process_enumeration_scope (die
, cu
);
9714 /* These dies have a type, but processing them does not create
9715 a symbol or recurse to process the children. Therefore we can
9716 read them on-demand through read_type_die. */
9717 case DW_TAG_subroutine_type
:
9718 case DW_TAG_set_type
:
9719 case DW_TAG_pointer_type
:
9720 case DW_TAG_ptr_to_member_type
:
9721 case DW_TAG_reference_type
:
9722 case DW_TAG_rvalue_reference_type
:
9723 case DW_TAG_string_type
:
9726 case DW_TAG_array_type
:
9727 /* We only need to handle this case for Ada -- in other
9728 languages, it's normal for the compiler to emit a typedef
9730 if (cu
->per_cu
->lang
!= language_ada
)
9733 case DW_TAG_base_type
:
9734 case DW_TAG_subrange_type
:
9735 case DW_TAG_typedef
:
9736 /* Add a typedef symbol for the type definition, if it has a
9738 new_symbol (die
, read_type_die (die
, cu
), cu
);
9740 case DW_TAG_common_block
:
9741 read_common_block (die
, cu
);
9743 case DW_TAG_common_inclusion
:
9745 case DW_TAG_namespace
:
9746 cu
->processing_has_namespace_info
= true;
9747 read_namespace (die
, cu
);
9750 cu
->processing_has_namespace_info
= true;
9751 read_module (die
, cu
);
9753 case DW_TAG_imported_declaration
:
9754 cu
->processing_has_namespace_info
= true;
9755 if (read_namespace_alias (die
, cu
))
9757 /* The declaration is not a global namespace alias. */
9759 case DW_TAG_imported_module
:
9760 cu
->processing_has_namespace_info
= true;
9761 if (die
->child
!= NULL
&& (die
->tag
== DW_TAG_imported_declaration
9762 || cu
->per_cu
->lang
!= language_fortran
))
9763 complaint (_("Tag '%s' has unexpected children"),
9764 dwarf_tag_name (die
->tag
));
9765 read_import_statement (die
, cu
);
9768 case DW_TAG_imported_unit
:
9769 process_imported_unit_die (die
, cu
);
9772 case DW_TAG_variable
:
9773 read_variable (die
, cu
);
9777 new_symbol (die
, NULL
, cu
);
9782 /* DWARF name computation. */
9784 /* A helper function for dwarf2_compute_name which determines whether DIE
9785 needs to have the name of the scope prepended to the name listed in the
9789 die_needs_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
9791 struct attribute
*attr
;
9795 case DW_TAG_namespace
:
9796 case DW_TAG_typedef
:
9797 case DW_TAG_class_type
:
9798 case DW_TAG_interface_type
:
9799 case DW_TAG_structure_type
:
9800 case DW_TAG_union_type
:
9801 case DW_TAG_enumeration_type
:
9802 case DW_TAG_enumerator
:
9803 case DW_TAG_subprogram
:
9804 case DW_TAG_inlined_subroutine
:
9806 case DW_TAG_imported_declaration
:
9809 case DW_TAG_variable
:
9810 case DW_TAG_constant
:
9811 /* We only need to prefix "globally" visible variables. These include
9812 any variable marked with DW_AT_external or any variable that
9813 lives in a namespace. [Variables in anonymous namespaces
9814 require prefixing, but they are not DW_AT_external.] */
9816 if (dwarf2_attr (die
, DW_AT_specification
, cu
))
9818 struct dwarf2_cu
*spec_cu
= cu
;
9820 return die_needs_namespace (die_specification (die
, &spec_cu
),
9824 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
9825 if (attr
== NULL
&& die
->parent
->tag
!= DW_TAG_namespace
9826 && die
->parent
->tag
!= DW_TAG_module
)
9828 /* A variable in a lexical block of some kind does not need a
9829 namespace, even though in C++ such variables may be external
9830 and have a mangled name. */
9831 if (die
->parent
->tag
== DW_TAG_lexical_block
9832 || die
->parent
->tag
== DW_TAG_try_block
9833 || die
->parent
->tag
== DW_TAG_catch_block
9834 || die
->parent
->tag
== DW_TAG_subprogram
)
9843 /* Return the DIE's linkage name attribute, either DW_AT_linkage_name
9844 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
9845 defined for the given DIE. */
9847 static struct attribute
*
9848 dw2_linkage_name_attr (struct die_info
*die
, struct dwarf2_cu
*cu
)
9850 struct attribute
*attr
;
9852 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
9854 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
9859 /* Return the DIE's linkage name as a string, either DW_AT_linkage_name
9860 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
9861 defined for the given DIE. */
9864 dw2_linkage_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
9866 const char *linkage_name
;
9868 linkage_name
= dwarf2_string_attr (die
, DW_AT_linkage_name
, cu
);
9869 if (linkage_name
== NULL
)
9870 linkage_name
= dwarf2_string_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
9872 /* rustc emits invalid values for DW_AT_linkage_name. Ignore these.
9873 See https://github.com/rust-lang/rust/issues/32925. */
9874 if (cu
->per_cu
->lang
== language_rust
&& linkage_name
!= NULL
9875 && strchr (linkage_name
, '{') != NULL
)
9876 linkage_name
= NULL
;
9878 return linkage_name
;
9881 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
9882 compute the physname for the object, which include a method's:
9883 - formal parameters (C++),
9884 - receiver type (Go),
9886 The term "physname" is a bit confusing.
9887 For C++, for example, it is the demangled name.
9888 For Go, for example, it's the mangled name.
9890 For Ada, return the DIE's linkage name rather than the fully qualified
9891 name. PHYSNAME is ignored..
9893 The result is allocated on the objfile->per_bfd's obstack and
9897 dwarf2_compute_name (const char *name
,
9898 struct die_info
*die
, struct dwarf2_cu
*cu
,
9901 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
9904 name
= dwarf2_name (die
, cu
);
9906 enum language lang
= cu
->per_cu
->lang
;
9908 /* For Fortran GDB prefers DW_AT_*linkage_name for the physname if present
9909 but otherwise compute it by typename_concat inside GDB.
9910 FIXME: Actually this is not really true, or at least not always true.
9911 It's all very confusing. compute_and_set_names doesn't try to demangle
9912 Fortran names because there is no mangling standard. So new_symbol
9913 will set the demangled name to the result of dwarf2_full_name, and it is
9914 the demangled name that GDB uses if it exists. */
9915 if (lang
== language_ada
9916 || (lang
== language_fortran
&& physname
))
9918 /* For Ada unit, we prefer the linkage name over the name, as
9919 the former contains the exported name, which the user expects
9920 to be able to reference. Ideally, we want the user to be able
9921 to reference this entity using either natural or linkage name,
9922 but we haven't started looking at this enhancement yet. */
9923 const char *linkage_name
= dw2_linkage_name (die
, cu
);
9925 if (linkage_name
!= NULL
)
9926 return linkage_name
;
9929 /* These are the only languages we know how to qualify names in. */
9931 && (lang
== language_cplus
9932 || lang
== language_fortran
|| lang
== language_d
9933 || lang
== language_rust
))
9935 if (die_needs_namespace (die
, cu
))
9938 const char *canonical_name
= NULL
;
9942 prefix
= determine_prefix (die
, cu
);
9943 if (*prefix
!= '\0')
9945 gdb::unique_xmalloc_ptr
<char> prefixed_name
9946 (typename_concat (NULL
, prefix
, name
, physname
, cu
));
9948 buf
.puts (prefixed_name
.get ());
9953 /* Template parameters may be specified in the DIE's DW_AT_name, or
9954 as children with DW_TAG_template_type_param or
9955 DW_TAG_value_type_param. If the latter, add them to the name
9956 here. If the name already has template parameters, then
9957 skip this step; some versions of GCC emit both, and
9958 it is more efficient to use the pre-computed name.
9960 Something to keep in mind about this process: it is very
9961 unlikely, or in some cases downright impossible, to produce
9962 something that will match the mangled name of a function.
9963 If the definition of the function has the same debug info,
9964 we should be able to match up with it anyway. But fallbacks
9965 using the minimal symbol, for instance to find a method
9966 implemented in a stripped copy of libstdc++, will not work.
9967 If we do not have debug info for the definition, we will have to
9968 match them up some other way.
9970 When we do name matching there is a related problem with function
9971 templates; two instantiated function templates are allowed to
9972 differ only by their return types, which we do not add here. */
9974 if (lang
== language_cplus
&& strchr (name
, '<') == NULL
)
9976 struct attribute
*attr
;
9977 struct die_info
*child
;
9980 die
->building_fullname
= 1;
9982 for (child
= die
->child
; child
!= NULL
; child
= child
->sibling
)
9986 const gdb_byte
*bytes
;
9987 struct dwarf2_locexpr_baton
*baton
;
9990 if (child
->tag
!= DW_TAG_template_type_param
9991 && child
->tag
!= DW_TAG_template_value_param
)
10002 attr
= dwarf2_attr (child
, DW_AT_type
, cu
);
10005 complaint (_("template parameter missing DW_AT_type"));
10006 buf
.puts ("UNKNOWN_TYPE");
10009 type
= die_type (child
, cu
);
10011 if (child
->tag
== DW_TAG_template_type_param
)
10013 cu
->language_defn
->print_type (type
, "", &buf
, -1, 0,
10014 &type_print_raw_options
);
10018 attr
= dwarf2_attr (child
, DW_AT_const_value
, cu
);
10021 complaint (_("template parameter missing "
10022 "DW_AT_const_value"));
10023 buf
.puts ("UNKNOWN_VALUE");
10027 dwarf2_const_value_attr (attr
, type
, name
,
10028 &cu
->comp_unit_obstack
, cu
,
10029 &value
, &bytes
, &baton
);
10031 if (type
->has_no_signedness ())
10032 /* GDB prints characters as NUMBER 'CHAR'. If that's
10033 changed, this can use value_print instead. */
10034 cu
->language_defn
->printchar (value
, type
, &buf
);
10037 struct value_print_options opts
;
10040 v
= dwarf2_evaluate_loc_desc (type
, NULL
,
10044 baton
->per_objfile
);
10045 else if (bytes
!= NULL
)
10047 v
= allocate_value (type
);
10048 memcpy (value_contents_writeable (v
).data (), bytes
,
10049 TYPE_LENGTH (type
));
10052 v
= value_from_longest (type
, value
);
10054 /* Specify decimal so that we do not depend on
10056 get_formatted_print_options (&opts
, 'd');
10058 value_print (v
, &buf
, &opts
);
10063 die
->building_fullname
= 0;
10067 /* Close the argument list, with a space if necessary
10068 (nested templates). */
10069 if (!buf
.empty () && buf
.string ().back () == '>')
10076 /* For C++ methods, append formal parameter type
10077 information, if PHYSNAME. */
10079 if (physname
&& die
->tag
== DW_TAG_subprogram
10080 && lang
== language_cplus
)
10082 struct type
*type
= read_type_die (die
, cu
);
10084 c_type_print_args (type
, &buf
, 1, lang
,
10085 &type_print_raw_options
);
10087 if (lang
== language_cplus
)
10089 /* Assume that an artificial first parameter is
10090 "this", but do not crash if it is not. RealView
10091 marks unnamed (and thus unused) parameters as
10092 artificial; there is no way to differentiate
10094 if (type
->num_fields () > 0
10095 && TYPE_FIELD_ARTIFICIAL (type
, 0)
10096 && type
->field (0).type ()->code () == TYPE_CODE_PTR
10097 && TYPE_CONST (TYPE_TARGET_TYPE (type
->field (0).type ())))
10098 buf
.puts (" const");
10102 const std::string
&intermediate_name
= buf
.string ();
10104 if (lang
== language_cplus
)
10106 = dwarf2_canonicalize_name (intermediate_name
.c_str (), cu
,
10109 /* If we only computed INTERMEDIATE_NAME, or if
10110 INTERMEDIATE_NAME is already canonical, then we need to
10112 if (canonical_name
== NULL
|| canonical_name
== intermediate_name
.c_str ())
10113 name
= objfile
->intern (intermediate_name
);
10115 name
= canonical_name
;
10122 /* Return the fully qualified name of DIE, based on its DW_AT_name.
10123 If scope qualifiers are appropriate they will be added. The result
10124 will be allocated on the storage_obstack, or NULL if the DIE does
10125 not have a name. NAME may either be from a previous call to
10126 dwarf2_name or NULL.
10128 The output string will be canonicalized (if C++). */
10130 static const char *
10131 dwarf2_full_name (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
10133 return dwarf2_compute_name (name
, die
, cu
, 0);
10136 /* Construct a physname for the given DIE in CU. NAME may either be
10137 from a previous call to dwarf2_name or NULL. The result will be
10138 allocated on the objfile_objstack or NULL if the DIE does not have a
10141 The output string will be canonicalized (if C++). */
10143 static const char *
10144 dwarf2_physname (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
10146 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
10147 const char *retval
, *mangled
= NULL
, *canon
= NULL
;
10150 /* In this case dwarf2_compute_name is just a shortcut not building anything
10152 if (!die_needs_namespace (die
, cu
))
10153 return dwarf2_compute_name (name
, die
, cu
, 1);
10155 if (cu
->per_cu
->lang
!= language_rust
)
10156 mangled
= dw2_linkage_name (die
, cu
);
10158 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
10160 gdb::unique_xmalloc_ptr
<char> demangled
;
10161 if (mangled
!= NULL
)
10163 if (cu
->language_defn
->store_sym_names_in_linkage_form_p ())
10165 /* Do nothing (do not demangle the symbol name). */
10169 /* Use DMGL_RET_DROP for C++ template functions to suppress
10170 their return type. It is easier for GDB users to search
10171 for such functions as `name(params)' than `long name(params)'.
10172 In such case the minimal symbol names do not match the full
10173 symbol names but for template functions there is never a need
10174 to look up their definition from their declaration so
10175 the only disadvantage remains the minimal symbol variant
10176 `long name(params)' does not have the proper inferior type. */
10177 demangled
= gdb_demangle (mangled
, (DMGL_PARAMS
| DMGL_ANSI
10181 canon
= demangled
.get ();
10189 if (canon
== NULL
|| check_physname
)
10191 const char *physname
= dwarf2_compute_name (name
, die
, cu
, 1);
10193 if (canon
!= NULL
&& strcmp (physname
, canon
) != 0)
10195 /* It may not mean a bug in GDB. The compiler could also
10196 compute DW_AT_linkage_name incorrectly. But in such case
10197 GDB would need to be bug-to-bug compatible. */
10199 complaint (_("Computed physname <%s> does not match demangled <%s> "
10200 "(from linkage <%s>) - DIE at %s [in module %s]"),
10201 physname
, canon
, mangled
, sect_offset_str (die
->sect_off
),
10202 objfile_name (objfile
));
10204 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
10205 is available here - over computed PHYSNAME. It is safer
10206 against both buggy GDB and buggy compilers. */
10220 retval
= objfile
->intern (retval
);
10225 /* Inspect DIE in CU for a namespace alias. If one exists, record
10226 a new symbol for it.
10228 Returns 1 if a namespace alias was recorded, 0 otherwise. */
10231 read_namespace_alias (struct die_info
*die
, struct dwarf2_cu
*cu
)
10233 struct attribute
*attr
;
10235 /* If the die does not have a name, this is not a namespace
10237 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
10241 struct die_info
*d
= die
;
10242 struct dwarf2_cu
*imported_cu
= cu
;
10244 /* If the compiler has nested DW_AT_imported_declaration DIEs,
10245 keep inspecting DIEs until we hit the underlying import. */
10246 #define MAX_NESTED_IMPORTED_DECLARATIONS 100
10247 for (num
= 0; num
< MAX_NESTED_IMPORTED_DECLARATIONS
; ++num
)
10249 attr
= dwarf2_attr (d
, DW_AT_import
, cu
);
10253 d
= follow_die_ref (d
, attr
, &imported_cu
);
10254 if (d
->tag
!= DW_TAG_imported_declaration
)
10258 if (num
== MAX_NESTED_IMPORTED_DECLARATIONS
)
10260 complaint (_("DIE at %s has too many recursively imported "
10261 "declarations"), sect_offset_str (d
->sect_off
));
10268 sect_offset sect_off
= attr
->get_ref_die_offset ();
10270 type
= get_die_type_at_offset (sect_off
, cu
->per_cu
, cu
->per_objfile
);
10271 if (type
!= NULL
&& type
->code () == TYPE_CODE_NAMESPACE
)
10273 /* This declaration is a global namespace alias. Add
10274 a symbol for it whose type is the aliased namespace. */
10275 new_symbol (die
, type
, cu
);
10284 /* Return the using directives repository (global or local?) to use in the
10285 current context for CU.
10287 For Ada, imported declarations can materialize renamings, which *may* be
10288 global. However it is impossible (for now?) in DWARF to distinguish
10289 "external" imported declarations and "static" ones. As all imported
10290 declarations seem to be static in all other languages, make them all CU-wide
10291 global only in Ada. */
10293 static struct using_direct
**
10294 using_directives (struct dwarf2_cu
*cu
)
10296 if (cu
->per_cu
->lang
== language_ada
10297 && cu
->get_builder ()->outermost_context_p ())
10298 return cu
->get_builder ()->get_global_using_directives ();
10300 return cu
->get_builder ()->get_local_using_directives ();
10303 /* Read the import statement specified by the given die and record it. */
10306 read_import_statement (struct die_info
*die
, struct dwarf2_cu
*cu
)
10308 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
10309 struct attribute
*import_attr
;
10310 struct die_info
*imported_die
, *child_die
;
10311 struct dwarf2_cu
*imported_cu
;
10312 const char *imported_name
;
10313 const char *imported_name_prefix
;
10314 const char *canonical_name
;
10315 const char *import_alias
;
10316 const char *imported_declaration
= NULL
;
10317 const char *import_prefix
;
10318 std::vector
<const char *> excludes
;
10320 import_attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
10321 if (import_attr
== NULL
)
10323 complaint (_("Tag '%s' has no DW_AT_import"),
10324 dwarf_tag_name (die
->tag
));
10329 imported_die
= follow_die_ref_or_sig (die
, import_attr
, &imported_cu
);
10330 imported_name
= dwarf2_name (imported_die
, imported_cu
);
10331 if (imported_name
== NULL
)
10333 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
10335 The import in the following code:
10349 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
10350 <52> DW_AT_decl_file : 1
10351 <53> DW_AT_decl_line : 6
10352 <54> DW_AT_import : <0x75>
10353 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
10354 <59> DW_AT_name : B
10355 <5b> DW_AT_decl_file : 1
10356 <5c> DW_AT_decl_line : 2
10357 <5d> DW_AT_type : <0x6e>
10359 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
10360 <76> DW_AT_byte_size : 4
10361 <77> DW_AT_encoding : 5 (signed)
10363 imports the wrong die ( 0x75 instead of 0x58 ).
10364 This case will be ignored until the gcc bug is fixed. */
10368 /* Figure out the local name after import. */
10369 import_alias
= dwarf2_name (die
, cu
);
10371 /* Figure out where the statement is being imported to. */
10372 import_prefix
= determine_prefix (die
, cu
);
10374 /* Figure out what the scope of the imported die is and prepend it
10375 to the name of the imported die. */
10376 imported_name_prefix
= determine_prefix (imported_die
, imported_cu
);
10378 if (imported_die
->tag
!= DW_TAG_namespace
10379 && imported_die
->tag
!= DW_TAG_module
)
10381 imported_declaration
= imported_name
;
10382 canonical_name
= imported_name_prefix
;
10384 else if (strlen (imported_name_prefix
) > 0)
10385 canonical_name
= obconcat (&objfile
->objfile_obstack
,
10386 imported_name_prefix
,
10387 (cu
->per_cu
->lang
== language_d
10390 imported_name
, (char *) NULL
);
10392 canonical_name
= imported_name
;
10394 if (die
->tag
== DW_TAG_imported_module
10395 && cu
->per_cu
->lang
== language_fortran
)
10396 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
10397 child_die
= child_die
->sibling
)
10399 /* DWARF-4: A Fortran use statement with a “rename list” may be
10400 represented by an imported module entry with an import attribute
10401 referring to the module and owned entries corresponding to those
10402 entities that are renamed as part of being imported. */
10404 if (child_die
->tag
!= DW_TAG_imported_declaration
)
10406 complaint (_("child DW_TAG_imported_declaration expected "
10407 "- DIE at %s [in module %s]"),
10408 sect_offset_str (child_die
->sect_off
),
10409 objfile_name (objfile
));
10413 import_attr
= dwarf2_attr (child_die
, DW_AT_import
, cu
);
10414 if (import_attr
== NULL
)
10416 complaint (_("Tag '%s' has no DW_AT_import"),
10417 dwarf_tag_name (child_die
->tag
));
10422 imported_die
= follow_die_ref_or_sig (child_die
, import_attr
,
10424 imported_name
= dwarf2_name (imported_die
, imported_cu
);
10425 if (imported_name
== NULL
)
10427 complaint (_("child DW_TAG_imported_declaration has unknown "
10428 "imported name - DIE at %s [in module %s]"),
10429 sect_offset_str (child_die
->sect_off
),
10430 objfile_name (objfile
));
10434 excludes
.push_back (imported_name
);
10436 process_die (child_die
, cu
);
10439 add_using_directive (using_directives (cu
),
10443 imported_declaration
,
10446 &objfile
->objfile_obstack
);
10449 /* ICC<14 does not output the required DW_AT_declaration on incomplete
10450 types, but gives them a size of zero. Starting with version 14,
10451 ICC is compatible with GCC. */
10454 producer_is_icc_lt_14 (struct dwarf2_cu
*cu
)
10456 if (!cu
->checked_producer
)
10457 check_producer (cu
);
10459 return cu
->producer_is_icc_lt_14
;
10462 /* ICC generates a DW_AT_type for C void functions. This was observed on
10463 ICC 14.0.5.212, and appears to be against the DWARF spec (V5 3.3.2)
10464 which says that void functions should not have a DW_AT_type. */
10467 producer_is_icc (struct dwarf2_cu
*cu
)
10469 if (!cu
->checked_producer
)
10470 check_producer (cu
);
10472 return cu
->producer_is_icc
;
10475 /* Check for possibly missing DW_AT_comp_dir with relative .debug_line
10476 directory paths. GCC SVN r127613 (new option -fdebug-prefix-map) fixed
10477 this, it was first present in GCC release 4.3.0. */
10480 producer_is_gcc_lt_4_3 (struct dwarf2_cu
*cu
)
10482 if (!cu
->checked_producer
)
10483 check_producer (cu
);
10485 return cu
->producer_is_gcc_lt_4_3
;
10488 static file_and_directory
10489 find_file_and_directory (struct die_info
*die
, struct dwarf2_cu
*cu
)
10491 file_and_directory res
;
10493 /* Find the filename. Do not use dwarf2_name here, since the filename
10494 is not a source language identifier. */
10495 res
.name
= dwarf2_string_attr (die
, DW_AT_name
, cu
);
10496 res
.comp_dir
= dwarf2_string_attr (die
, DW_AT_comp_dir
, cu
);
10498 if (res
.comp_dir
== NULL
10499 && producer_is_gcc_lt_4_3 (cu
) && res
.name
!= NULL
10500 && IS_ABSOLUTE_PATH (res
.name
))
10502 std::string comp_dir_storage
= ldirname (res
.name
);
10503 if (!comp_dir_storage
.empty ())
10505 = cu
->per_objfile
->objfile
->intern (comp_dir_storage
.c_str ());
10507 if (res
.comp_dir
!= NULL
)
10509 /* Irix 6.2 native cc prepends <machine>.: to the compilation
10510 directory, get rid of it. */
10511 const char *cp
= strchr (res
.comp_dir
, ':');
10513 if (cp
&& cp
!= res
.comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
10514 res
.comp_dir
= cp
+ 1;
10517 if (res
.name
== NULL
)
10518 res
.name
= "<unknown>";
10523 /* Handle DW_AT_stmt_list for a compilation unit.
10524 DIE is the DW_TAG_compile_unit die for CU.
10525 COMP_DIR is the compilation directory. LOWPC is passed to
10526 dwarf_decode_lines. See dwarf_decode_lines comments about it. */
10529 handle_DW_AT_stmt_list (struct die_info
*die
, struct dwarf2_cu
*cu
,
10530 const file_and_directory
&fnd
, CORE_ADDR lowpc
) /* ARI: editCase function */
10532 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
10533 struct attribute
*attr
;
10534 struct line_header line_header_local
;
10535 hashval_t line_header_local_hash
;
10537 int decode_mapping
;
10539 gdb_assert (! cu
->per_cu
->is_debug_types
);
10541 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
10542 if (attr
== NULL
|| !attr
->form_is_unsigned ())
10545 sect_offset line_offset
= (sect_offset
) attr
->as_unsigned ();
10547 /* The line header hash table is only created if needed (it exists to
10548 prevent redundant reading of the line table for partial_units).
10549 If we're given a partial_unit, we'll need it. If we're given a
10550 compile_unit, then use the line header hash table if it's already
10551 created, but don't create one just yet. */
10553 if (per_objfile
->line_header_hash
== NULL
10554 && die
->tag
== DW_TAG_partial_unit
)
10556 per_objfile
->line_header_hash
10557 .reset (htab_create_alloc (127, line_header_hash_voidp
,
10558 line_header_eq_voidp
,
10559 htab_delete_entry
<line_header
>,
10563 line_header_local
.sect_off
= line_offset
;
10564 line_header_local
.offset_in_dwz
= cu
->per_cu
->is_dwz
;
10565 line_header_local_hash
= line_header_hash (&line_header_local
);
10566 if (per_objfile
->line_header_hash
!= NULL
)
10568 slot
= htab_find_slot_with_hash (per_objfile
->line_header_hash
.get (),
10569 &line_header_local
,
10570 line_header_local_hash
, NO_INSERT
);
10572 /* For DW_TAG_compile_unit we need info like symtab::linetable which
10573 is not present in *SLOT (since if there is something in *SLOT then
10574 it will be for a partial_unit). */
10575 if (die
->tag
== DW_TAG_partial_unit
&& slot
!= NULL
)
10577 gdb_assert (*slot
!= NULL
);
10578 cu
->line_header
= (struct line_header
*) *slot
;
10583 /* dwarf_decode_line_header does not yet provide sufficient information.
10584 We always have to call also dwarf_decode_lines for it. */
10585 line_header_up lh
= dwarf_decode_line_header (line_offset
, cu
);
10589 cu
->line_header
= lh
.release ();
10590 cu
->line_header_die_owner
= die
;
10592 if (per_objfile
->line_header_hash
== NULL
)
10596 slot
= htab_find_slot_with_hash (per_objfile
->line_header_hash
.get (),
10597 &line_header_local
,
10598 line_header_local_hash
, INSERT
);
10599 gdb_assert (slot
!= NULL
);
10601 if (slot
!= NULL
&& *slot
== NULL
)
10603 /* This newly decoded line number information unit will be owned
10604 by line_header_hash hash table. */
10605 *slot
= cu
->line_header
;
10606 cu
->line_header_die_owner
= NULL
;
10610 /* We cannot free any current entry in (*slot) as that struct line_header
10611 may be already used by multiple CUs. Create only temporary decoded
10612 line_header for this CU - it may happen at most once for each line
10613 number information unit. And if we're not using line_header_hash
10614 then this is what we want as well. */
10615 gdb_assert (die
->tag
!= DW_TAG_partial_unit
);
10617 decode_mapping
= (die
->tag
!= DW_TAG_partial_unit
);
10618 dwarf_decode_lines (cu
->line_header
, fnd
, cu
, nullptr, lowpc
,
10623 /* Process DW_TAG_compile_unit or DW_TAG_partial_unit. */
10626 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
10628 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
10629 struct objfile
*objfile
= per_objfile
->objfile
;
10630 struct gdbarch
*gdbarch
= objfile
->arch ();
10631 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
10632 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
10633 struct attribute
*attr
;
10634 struct die_info
*child_die
;
10635 CORE_ADDR baseaddr
;
10637 prepare_one_comp_unit (cu
, die
, cu
->per_cu
->lang
);
10638 baseaddr
= objfile
->text_section_offset ();
10640 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
10642 /* If we didn't find a lowpc, set it to highpc to avoid complaints
10643 from finish_block. */
10644 if (lowpc
== ((CORE_ADDR
) -1))
10646 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
10648 file_and_directory fnd
= find_file_and_directory (die
, cu
);
10650 cu
->start_symtab (fnd
.name
, fnd
.comp_dir
, lowpc
);
10652 gdb_assert (per_objfile
->sym_cu
== nullptr);
10653 scoped_restore restore_sym_cu
10654 = make_scoped_restore (&per_objfile
->sym_cu
, cu
);
10656 /* Decode line number information if present. We do this before
10657 processing child DIEs, so that the line header table is available
10658 for DW_AT_decl_file. */
10659 handle_DW_AT_stmt_list (die
, cu
, fnd
, lowpc
);
10661 /* Process all dies in compilation unit. */
10662 if (die
->child
!= NULL
)
10664 child_die
= die
->child
;
10665 while (child_die
&& child_die
->tag
)
10667 process_die (child_die
, cu
);
10668 child_die
= child_die
->sibling
;
10671 per_objfile
->sym_cu
= nullptr;
10673 /* Decode macro information, if present. Dwarf 2 macro information
10674 refers to information in the line number info statement program
10675 header, so we can only read it if we've read the header
10677 attr
= dwarf2_attr (die
, DW_AT_macros
, cu
);
10679 attr
= dwarf2_attr (die
, DW_AT_GNU_macros
, cu
);
10680 if (attr
!= nullptr && attr
->form_is_unsigned () && cu
->line_header
)
10682 if (dwarf2_attr (die
, DW_AT_macro_info
, cu
))
10683 complaint (_("CU refers to both DW_AT_macros and DW_AT_macro_info"));
10685 dwarf_decode_macros (cu
, attr
->as_unsigned (), 1);
10689 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
10690 if (attr
!= nullptr && attr
->form_is_unsigned () && cu
->line_header
)
10692 unsigned int macro_offset
= attr
->as_unsigned ();
10694 dwarf_decode_macros (cu
, macro_offset
, 0);
10700 dwarf2_cu::setup_type_unit_groups (struct die_info
*die
)
10702 struct type_unit_group
*tu_group
;
10704 struct attribute
*attr
;
10706 struct signatured_type
*sig_type
;
10708 gdb_assert (per_cu
->is_debug_types
);
10709 sig_type
= (struct signatured_type
*) per_cu
;
10711 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, this);
10713 /* If we're using .gdb_index (includes -readnow) then
10714 per_cu->type_unit_group may not have been set up yet. */
10715 if (sig_type
->type_unit_group
== NULL
)
10716 sig_type
->type_unit_group
= get_type_unit_group (this, attr
);
10717 tu_group
= sig_type
->type_unit_group
;
10719 /* If we've already processed this stmt_list there's no real need to
10720 do it again, we could fake it and just recreate the part we need
10721 (file name,index -> symtab mapping). If data shows this optimization
10722 is useful we can do it then. */
10723 type_unit_group_unshareable
*tug_unshare
10724 = per_objfile
->get_type_unit_group_unshareable (tu_group
);
10725 first_time
= tug_unshare
->compunit_symtab
== NULL
;
10727 /* We have to handle the case of both a missing DW_AT_stmt_list or bad
10730 if (attr
!= NULL
&& attr
->form_is_unsigned ())
10732 sect_offset line_offset
= (sect_offset
) attr
->as_unsigned ();
10733 lh
= dwarf_decode_line_header (line_offset
, this);
10738 start_symtab ("", NULL
, 0);
10741 gdb_assert (tug_unshare
->symtabs
== NULL
);
10742 gdb_assert (m_builder
== nullptr);
10743 struct compunit_symtab
*cust
= tug_unshare
->compunit_symtab
;
10744 m_builder
.reset (new struct buildsym_compunit
10745 (COMPUNIT_OBJFILE (cust
), "",
10746 COMPUNIT_DIRNAME (cust
),
10747 compunit_language (cust
),
10749 list_in_scope
= get_builder ()->get_file_symbols ();
10754 line_header
= lh
.release ();
10755 line_header_die_owner
= die
;
10759 struct compunit_symtab
*cust
= start_symtab ("", NULL
, 0);
10761 /* Note: We don't assign tu_group->compunit_symtab yet because we're
10762 still initializing it, and our caller (a few levels up)
10763 process_full_type_unit still needs to know if this is the first
10766 tug_unshare
->symtabs
10767 = XOBNEWVEC (&COMPUNIT_OBJFILE (cust
)->objfile_obstack
,
10768 struct symtab
*, line_header
->file_names_size ());
10770 auto &file_names
= line_header
->file_names ();
10771 for (i
= 0; i
< file_names
.size (); ++i
)
10773 file_entry
&fe
= file_names
[i
];
10774 dwarf2_start_subfile (this, fe
.name
,
10775 fe
.include_dir (line_header
));
10776 buildsym_compunit
*b
= get_builder ();
10777 if (b
->get_current_subfile ()->symtab
== NULL
)
10779 /* NOTE: start_subfile will recognize when it's been
10780 passed a file it has already seen. So we can't
10781 assume there's a simple mapping from
10782 cu->line_header->file_names to subfiles, plus
10783 cu->line_header->file_names may contain dups. */
10784 b
->get_current_subfile ()->symtab
10785 = allocate_symtab (cust
, b
->get_current_subfile ()->name
);
10788 fe
.symtab
= b
->get_current_subfile ()->symtab
;
10789 tug_unshare
->symtabs
[i
] = fe
.symtab
;
10794 gdb_assert (m_builder
== nullptr);
10795 struct compunit_symtab
*cust
= tug_unshare
->compunit_symtab
;
10796 m_builder
.reset (new struct buildsym_compunit
10797 (COMPUNIT_OBJFILE (cust
), "",
10798 COMPUNIT_DIRNAME (cust
),
10799 compunit_language (cust
),
10801 list_in_scope
= get_builder ()->get_file_symbols ();
10803 auto &file_names
= line_header
->file_names ();
10804 for (i
= 0; i
< file_names
.size (); ++i
)
10806 file_entry
&fe
= file_names
[i
];
10807 fe
.symtab
= tug_unshare
->symtabs
[i
];
10811 /* The main symtab is allocated last. Type units don't have DW_AT_name
10812 so they don't have a "real" (so to speak) symtab anyway.
10813 There is later code that will assign the main symtab to all symbols
10814 that don't have one. We need to handle the case of a symbol with a
10815 missing symtab (DW_AT_decl_file) anyway. */
10818 /* Process DW_TAG_type_unit.
10819 For TUs we want to skip the first top level sibling if it's not the
10820 actual type being defined by this TU. In this case the first top
10821 level sibling is there to provide context only. */
10824 read_type_unit_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
10826 struct die_info
*child_die
;
10828 prepare_one_comp_unit (cu
, die
, language_minimal
);
10830 /* Initialize (or reinitialize) the machinery for building symtabs.
10831 We do this before processing child DIEs, so that the line header table
10832 is available for DW_AT_decl_file. */
10833 cu
->setup_type_unit_groups (die
);
10835 if (die
->child
!= NULL
)
10837 child_die
= die
->child
;
10838 while (child_die
&& child_die
->tag
)
10840 process_die (child_die
, cu
);
10841 child_die
= child_die
->sibling
;
10848 http://gcc.gnu.org/wiki/DebugFission
10849 http://gcc.gnu.org/wiki/DebugFissionDWP
10851 To simplify handling of both DWO files ("object" files with the DWARF info)
10852 and DWP files (a file with the DWOs packaged up into one file), we treat
10853 DWP files as having a collection of virtual DWO files. */
10856 hash_dwo_file (const void *item
)
10858 const struct dwo_file
*dwo_file
= (const struct dwo_file
*) item
;
10861 hash
= htab_hash_string (dwo_file
->dwo_name
);
10862 if (dwo_file
->comp_dir
!= NULL
)
10863 hash
+= htab_hash_string (dwo_file
->comp_dir
);
10868 eq_dwo_file (const void *item_lhs
, const void *item_rhs
)
10870 const struct dwo_file
*lhs
= (const struct dwo_file
*) item_lhs
;
10871 const struct dwo_file
*rhs
= (const struct dwo_file
*) item_rhs
;
10873 if (strcmp (lhs
->dwo_name
, rhs
->dwo_name
) != 0)
10875 if (lhs
->comp_dir
== NULL
|| rhs
->comp_dir
== NULL
)
10876 return lhs
->comp_dir
== rhs
->comp_dir
;
10877 return strcmp (lhs
->comp_dir
, rhs
->comp_dir
) == 0;
10880 /* Allocate a hash table for DWO files. */
10883 allocate_dwo_file_hash_table ()
10885 return htab_up (htab_create_alloc (41,
10888 htab_delete_entry
<dwo_file
>,
10892 /* Lookup DWO file DWO_NAME. */
10895 lookup_dwo_file_slot (dwarf2_per_objfile
*per_objfile
,
10896 const char *dwo_name
,
10897 const char *comp_dir
)
10899 struct dwo_file find_entry
;
10902 if (per_objfile
->per_bfd
->dwo_files
== NULL
)
10903 per_objfile
->per_bfd
->dwo_files
= allocate_dwo_file_hash_table ();
10905 find_entry
.dwo_name
= dwo_name
;
10906 find_entry
.comp_dir
= comp_dir
;
10907 slot
= htab_find_slot (per_objfile
->per_bfd
->dwo_files
.get (), &find_entry
,
10914 hash_dwo_unit (const void *item
)
10916 const struct dwo_unit
*dwo_unit
= (const struct dwo_unit
*) item
;
10918 /* This drops the top 32 bits of the id, but is ok for a hash. */
10919 return dwo_unit
->signature
;
10923 eq_dwo_unit (const void *item_lhs
, const void *item_rhs
)
10925 const struct dwo_unit
*lhs
= (const struct dwo_unit
*) item_lhs
;
10926 const struct dwo_unit
*rhs
= (const struct dwo_unit
*) item_rhs
;
10928 /* The signature is assumed to be unique within the DWO file.
10929 So while object file CU dwo_id's always have the value zero,
10930 that's OK, assuming each object file DWO file has only one CU,
10931 and that's the rule for now. */
10932 return lhs
->signature
== rhs
->signature
;
10935 /* Allocate a hash table for DWO CUs,TUs.
10936 There is one of these tables for each of CUs,TUs for each DWO file. */
10939 allocate_dwo_unit_table ()
10941 /* Start out with a pretty small number.
10942 Generally DWO files contain only one CU and maybe some TUs. */
10943 return htab_up (htab_create_alloc (3,
10946 NULL
, xcalloc
, xfree
));
10949 /* die_reader_func for create_dwo_cu. */
10952 create_dwo_cu_reader (const struct die_reader_specs
*reader
,
10953 const gdb_byte
*info_ptr
,
10954 struct die_info
*comp_unit_die
,
10955 struct dwo_file
*dwo_file
,
10956 struct dwo_unit
*dwo_unit
)
10958 struct dwarf2_cu
*cu
= reader
->cu
;
10959 sect_offset sect_off
= cu
->per_cu
->sect_off
;
10960 struct dwarf2_section_info
*section
= cu
->per_cu
->section
;
10962 gdb::optional
<ULONGEST
> signature
= lookup_dwo_id (cu
, comp_unit_die
);
10963 if (!signature
.has_value ())
10965 complaint (_("Dwarf Error: debug entry at offset %s is missing"
10966 " its dwo_id [in module %s]"),
10967 sect_offset_str (sect_off
), dwo_file
->dwo_name
);
10971 dwo_unit
->dwo_file
= dwo_file
;
10972 dwo_unit
->signature
= *signature
;
10973 dwo_unit
->section
= section
;
10974 dwo_unit
->sect_off
= sect_off
;
10975 dwo_unit
->length
= cu
->per_cu
->length
;
10977 dwarf_read_debug_printf (" offset %s, dwo_id %s",
10978 sect_offset_str (sect_off
),
10979 hex_string (dwo_unit
->signature
));
10982 /* Create the dwo_units for the CUs in a DWO_FILE.
10983 Note: This function processes DWO files only, not DWP files. */
10986 create_cus_hash_table (dwarf2_per_objfile
*per_objfile
,
10987 dwarf2_cu
*cu
, struct dwo_file
&dwo_file
,
10988 dwarf2_section_info
§ion
, htab_up
&cus_htab
)
10990 struct objfile
*objfile
= per_objfile
->objfile
;
10991 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
10992 const gdb_byte
*info_ptr
, *end_ptr
;
10994 section
.read (objfile
);
10995 info_ptr
= section
.buffer
;
10997 if (info_ptr
== NULL
)
11000 dwarf_read_debug_printf ("Reading %s for %s:",
11001 section
.get_name (),
11002 section
.get_file_name ());
11004 end_ptr
= info_ptr
+ section
.size
;
11005 while (info_ptr
< end_ptr
)
11007 struct dwarf2_per_cu_data per_cu
;
11008 struct dwo_unit read_unit
{};
11009 struct dwo_unit
*dwo_unit
;
11011 sect_offset sect_off
= (sect_offset
) (info_ptr
- section
.buffer
);
11013 per_cu
.per_bfd
= per_bfd
;
11014 per_cu
.is_debug_types
= 0;
11015 per_cu
.sect_off
= sect_offset (info_ptr
- section
.buffer
);
11016 per_cu
.section
= §ion
;
11018 cutu_reader
reader (&per_cu
, per_objfile
, cu
, &dwo_file
);
11019 if (!reader
.dummy_p
)
11020 create_dwo_cu_reader (&reader
, reader
.info_ptr
, reader
.comp_unit_die
,
11021 &dwo_file
, &read_unit
);
11022 info_ptr
+= per_cu
.length
;
11024 // If the unit could not be parsed, skip it.
11025 if (read_unit
.dwo_file
== NULL
)
11028 if (cus_htab
== NULL
)
11029 cus_htab
= allocate_dwo_unit_table ();
11031 dwo_unit
= OBSTACK_ZALLOC (&per_bfd
->obstack
,
11033 *dwo_unit
= read_unit
;
11034 slot
= htab_find_slot (cus_htab
.get (), dwo_unit
, INSERT
);
11035 gdb_assert (slot
!= NULL
);
11038 const struct dwo_unit
*dup_cu
= (const struct dwo_unit
*)*slot
;
11039 sect_offset dup_sect_off
= dup_cu
->sect_off
;
11041 complaint (_("debug cu entry at offset %s is duplicate to"
11042 " the entry at offset %s, signature %s"),
11043 sect_offset_str (sect_off
), sect_offset_str (dup_sect_off
),
11044 hex_string (dwo_unit
->signature
));
11046 *slot
= (void *)dwo_unit
;
11050 /* DWP file .debug_{cu,tu}_index section format:
11051 [ref: http://gcc.gnu.org/wiki/DebugFissionDWP]
11052 [ref: http://dwarfstd.org/doc/DWARF5.pdf, sect 7.3.5 "DWARF Package Files"]
11054 DWP Versions 1 & 2 are older, pre-standard format versions. The first
11055 officially standard DWP format was published with DWARF v5 and is called
11056 Version 5. There are no versions 3 or 4.
11060 Both index sections have the same format, and serve to map a 64-bit
11061 signature to a set of section numbers. Each section begins with a header,
11062 followed by a hash table of 64-bit signatures, a parallel table of 32-bit
11063 indexes, and a pool of 32-bit section numbers. The index sections will be
11064 aligned at 8-byte boundaries in the file.
11066 The index section header consists of:
11068 V, 32 bit version number
11070 N, 32 bit number of compilation units or type units in the index
11071 M, 32 bit number of slots in the hash table
11073 Numbers are recorded using the byte order of the application binary.
11075 The hash table begins at offset 16 in the section, and consists of an array
11076 of M 64-bit slots. Each slot contains a 64-bit signature (using the byte
11077 order of the application binary). Unused slots in the hash table are 0.
11078 (We rely on the extreme unlikeliness of a signature being exactly 0.)
11080 The parallel table begins immediately after the hash table
11081 (at offset 16 + 8 * M from the beginning of the section), and consists of an
11082 array of 32-bit indexes (using the byte order of the application binary),
11083 corresponding 1-1 with slots in the hash table. Each entry in the parallel
11084 table contains a 32-bit index into the pool of section numbers. For unused
11085 hash table slots, the corresponding entry in the parallel table will be 0.
11087 The pool of section numbers begins immediately following the hash table
11088 (at offset 16 + 12 * M from the beginning of the section). The pool of
11089 section numbers consists of an array of 32-bit words (using the byte order
11090 of the application binary). Each item in the array is indexed starting
11091 from 0. The hash table entry provides the index of the first section
11092 number in the set. Additional section numbers in the set follow, and the
11093 set is terminated by a 0 entry (section number 0 is not used in ELF).
11095 In each set of section numbers, the .debug_info.dwo or .debug_types.dwo
11096 section must be the first entry in the set, and the .debug_abbrev.dwo must
11097 be the second entry. Other members of the set may follow in any order.
11101 DWP Versions 2 and 5:
11103 DWP Versions 2 and 5 combine all the .debug_info, etc. sections into one,
11104 and the entries in the index tables are now offsets into these sections.
11105 CU offsets begin at 0. TU offsets begin at the size of the .debug_info
11108 Index Section Contents:
11110 Hash Table of Signatures dwp_hash_table.hash_table
11111 Parallel Table of Indices dwp_hash_table.unit_table
11112 Table of Section Offsets dwp_hash_table.{v2|v5}.{section_ids,offsets}
11113 Table of Section Sizes dwp_hash_table.{v2|v5}.sizes
11115 The index section header consists of:
11117 V, 32 bit version number
11118 L, 32 bit number of columns in the table of section offsets
11119 N, 32 bit number of compilation units or type units in the index
11120 M, 32 bit number of slots in the hash table
11122 Numbers are recorded using the byte order of the application binary.
11124 The hash table has the same format as version 1.
11125 The parallel table of indices has the same format as version 1,
11126 except that the entries are origin-1 indices into the table of sections
11127 offsets and the table of section sizes.
11129 The table of offsets begins immediately following the parallel table
11130 (at offset 16 + 12 * M from the beginning of the section). The table is
11131 a two-dimensional array of 32-bit words (using the byte order of the
11132 application binary), with L columns and N+1 rows, in row-major order.
11133 Each row in the array is indexed starting from 0. The first row provides
11134 a key to the remaining rows: each column in this row provides an identifier
11135 for a debug section, and the offsets in the same column of subsequent rows
11136 refer to that section. The section identifiers for Version 2 are:
11138 DW_SECT_INFO 1 .debug_info.dwo
11139 DW_SECT_TYPES 2 .debug_types.dwo
11140 DW_SECT_ABBREV 3 .debug_abbrev.dwo
11141 DW_SECT_LINE 4 .debug_line.dwo
11142 DW_SECT_LOC 5 .debug_loc.dwo
11143 DW_SECT_STR_OFFSETS 6 .debug_str_offsets.dwo
11144 DW_SECT_MACINFO 7 .debug_macinfo.dwo
11145 DW_SECT_MACRO 8 .debug_macro.dwo
11147 The section identifiers for Version 5 are:
11149 DW_SECT_INFO_V5 1 .debug_info.dwo
11150 DW_SECT_RESERVED_V5 2 --
11151 DW_SECT_ABBREV_V5 3 .debug_abbrev.dwo
11152 DW_SECT_LINE_V5 4 .debug_line.dwo
11153 DW_SECT_LOCLISTS_V5 5 .debug_loclists.dwo
11154 DW_SECT_STR_OFFSETS_V5 6 .debug_str_offsets.dwo
11155 DW_SECT_MACRO_V5 7 .debug_macro.dwo
11156 DW_SECT_RNGLISTS_V5 8 .debug_rnglists.dwo
11158 The offsets provided by the CU and TU index sections are the base offsets
11159 for the contributions made by each CU or TU to the corresponding section
11160 in the package file. Each CU and TU header contains an abbrev_offset
11161 field, used to find the abbreviations table for that CU or TU within the
11162 contribution to the .debug_abbrev.dwo section for that CU or TU, and should
11163 be interpreted as relative to the base offset given in the index section.
11164 Likewise, offsets into .debug_line.dwo from DW_AT_stmt_list attributes
11165 should be interpreted as relative to the base offset for .debug_line.dwo,
11166 and offsets into other debug sections obtained from DWARF attributes should
11167 also be interpreted as relative to the corresponding base offset.
11169 The table of sizes begins immediately following the table of offsets.
11170 Like the table of offsets, it is a two-dimensional array of 32-bit words,
11171 with L columns and N rows, in row-major order. Each row in the array is
11172 indexed starting from 1 (row 0 is shared by the two tables).
11176 Hash table lookup is handled the same in version 1 and 2:
11178 We assume that N and M will not exceed 2^32 - 1.
11179 The size of the hash table, M, must be 2^k such that 2^k > 3*N/2.
11181 Given a 64-bit compilation unit signature or a type signature S, an entry
11182 in the hash table is located as follows:
11184 1) Calculate a primary hash H = S & MASK(k), where MASK(k) is a mask with
11185 the low-order k bits all set to 1.
11187 2) Calculate a secondary hash H' = (((S >> 32) & MASK(k)) | 1).
11189 3) If the hash table entry at index H matches the signature, use that
11190 entry. If the hash table entry at index H is unused (all zeroes),
11191 terminate the search: the signature is not present in the table.
11193 4) Let H = (H + H') modulo M. Repeat at Step 3.
11195 Because M > N and H' and M are relatively prime, the search is guaranteed
11196 to stop at an unused slot or find the match. */
11198 /* Create a hash table to map DWO IDs to their CU/TU entry in
11199 .debug_{info,types}.dwo in DWP_FILE.
11200 Returns NULL if there isn't one.
11201 Note: This function processes DWP files only, not DWO files. */
11203 static struct dwp_hash_table
*
11204 create_dwp_hash_table (dwarf2_per_objfile
*per_objfile
,
11205 struct dwp_file
*dwp_file
, int is_debug_types
)
11207 struct objfile
*objfile
= per_objfile
->objfile
;
11208 bfd
*dbfd
= dwp_file
->dbfd
.get ();
11209 const gdb_byte
*index_ptr
, *index_end
;
11210 struct dwarf2_section_info
*index
;
11211 uint32_t version
, nr_columns
, nr_units
, nr_slots
;
11212 struct dwp_hash_table
*htab
;
11214 if (is_debug_types
)
11215 index
= &dwp_file
->sections
.tu_index
;
11217 index
= &dwp_file
->sections
.cu_index
;
11219 if (index
->empty ())
11221 index
->read (objfile
);
11223 index_ptr
= index
->buffer
;
11224 index_end
= index_ptr
+ index
->size
;
11226 /* For Version 5, the version is really 2 bytes of data & 2 bytes of padding.
11227 For now it's safe to just read 4 bytes (particularly as it's difficult to
11228 tell if you're dealing with Version 5 before you've read the version). */
11229 version
= read_4_bytes (dbfd
, index_ptr
);
11231 if (version
== 2 || version
== 5)
11232 nr_columns
= read_4_bytes (dbfd
, index_ptr
);
11236 nr_units
= read_4_bytes (dbfd
, index_ptr
);
11238 nr_slots
= read_4_bytes (dbfd
, index_ptr
);
11241 if (version
!= 1 && version
!= 2 && version
!= 5)
11243 error (_("Dwarf Error: unsupported DWP file version (%s)"
11244 " [in module %s]"),
11245 pulongest (version
), dwp_file
->name
);
11247 if (nr_slots
!= (nr_slots
& -nr_slots
))
11249 error (_("Dwarf Error: number of slots in DWP hash table (%s)"
11250 " is not power of 2 [in module %s]"),
11251 pulongest (nr_slots
), dwp_file
->name
);
11254 htab
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, struct dwp_hash_table
);
11255 htab
->version
= version
;
11256 htab
->nr_columns
= nr_columns
;
11257 htab
->nr_units
= nr_units
;
11258 htab
->nr_slots
= nr_slots
;
11259 htab
->hash_table
= index_ptr
;
11260 htab
->unit_table
= htab
->hash_table
+ sizeof (uint64_t) * nr_slots
;
11262 /* Exit early if the table is empty. */
11263 if (nr_slots
== 0 || nr_units
== 0
11264 || (version
== 2 && nr_columns
== 0)
11265 || (version
== 5 && nr_columns
== 0))
11267 /* All must be zero. */
11268 if (nr_slots
!= 0 || nr_units
!= 0
11269 || (version
== 2 && nr_columns
!= 0)
11270 || (version
== 5 && nr_columns
!= 0))
11272 complaint (_("Empty DWP but nr_slots,nr_units,nr_columns not"
11273 " all zero [in modules %s]"),
11281 htab
->section_pool
.v1
.indices
=
11282 htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
11283 /* It's harder to decide whether the section is too small in v1.
11284 V1 is deprecated anyway so we punt. */
11286 else if (version
== 2)
11288 const gdb_byte
*ids_ptr
= htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
11289 int *ids
= htab
->section_pool
.v2
.section_ids
;
11290 size_t sizeof_ids
= sizeof (htab
->section_pool
.v2
.section_ids
);
11291 /* Reverse map for error checking. */
11292 int ids_seen
[DW_SECT_MAX
+ 1];
11295 if (nr_columns
< 2)
11297 error (_("Dwarf Error: bad DWP hash table, too few columns"
11298 " in section table [in module %s]"),
11301 if (nr_columns
> MAX_NR_V2_DWO_SECTIONS
)
11303 error (_("Dwarf Error: bad DWP hash table, too many columns"
11304 " in section table [in module %s]"),
11307 memset (ids
, 255, sizeof_ids
);
11308 memset (ids_seen
, 255, sizeof (ids_seen
));
11309 for (i
= 0; i
< nr_columns
; ++i
)
11311 int id
= read_4_bytes (dbfd
, ids_ptr
+ i
* sizeof (uint32_t));
11313 if (id
< DW_SECT_MIN
|| id
> DW_SECT_MAX
)
11315 error (_("Dwarf Error: bad DWP hash table, bad section id %d"
11316 " in section table [in module %s]"),
11317 id
, dwp_file
->name
);
11319 if (ids_seen
[id
] != -1)
11321 error (_("Dwarf Error: bad DWP hash table, duplicate section"
11322 " id %d in section table [in module %s]"),
11323 id
, dwp_file
->name
);
11328 /* Must have exactly one info or types section. */
11329 if (((ids_seen
[DW_SECT_INFO
] != -1)
11330 + (ids_seen
[DW_SECT_TYPES
] != -1))
11333 error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
11334 " DWO info/types section [in module %s]"),
11337 /* Must have an abbrev section. */
11338 if (ids_seen
[DW_SECT_ABBREV
] == -1)
11340 error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
11341 " section [in module %s]"),
11344 htab
->section_pool
.v2
.offsets
= ids_ptr
+ sizeof (uint32_t) * nr_columns
;
11345 htab
->section_pool
.v2
.sizes
=
11346 htab
->section_pool
.v2
.offsets
+ (sizeof (uint32_t)
11347 * nr_units
* nr_columns
);
11348 if ((htab
->section_pool
.v2
.sizes
+ (sizeof (uint32_t)
11349 * nr_units
* nr_columns
))
11352 error (_("Dwarf Error: DWP index section is corrupt (too small)"
11353 " [in module %s]"),
11357 else /* version == 5 */
11359 const gdb_byte
*ids_ptr
= htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
11360 int *ids
= htab
->section_pool
.v5
.section_ids
;
11361 size_t sizeof_ids
= sizeof (htab
->section_pool
.v5
.section_ids
);
11362 /* Reverse map for error checking. */
11363 int ids_seen
[DW_SECT_MAX_V5
+ 1];
11365 if (nr_columns
< 2)
11367 error (_("Dwarf Error: bad DWP hash table, too few columns"
11368 " in section table [in module %s]"),
11371 if (nr_columns
> MAX_NR_V5_DWO_SECTIONS
)
11373 error (_("Dwarf Error: bad DWP hash table, too many columns"
11374 " in section table [in module %s]"),
11377 memset (ids
, 255, sizeof_ids
);
11378 memset (ids_seen
, 255, sizeof (ids_seen
));
11379 for (int i
= 0; i
< nr_columns
; ++i
)
11381 int id
= read_4_bytes (dbfd
, ids_ptr
+ i
* sizeof (uint32_t));
11383 if (id
< DW_SECT_MIN
|| id
> DW_SECT_MAX_V5
)
11385 error (_("Dwarf Error: bad DWP hash table, bad section id %d"
11386 " in section table [in module %s]"),
11387 id
, dwp_file
->name
);
11389 if (ids_seen
[id
] != -1)
11391 error (_("Dwarf Error: bad DWP hash table, duplicate section"
11392 " id %d in section table [in module %s]"),
11393 id
, dwp_file
->name
);
11398 /* Must have seen an info section. */
11399 if (ids_seen
[DW_SECT_INFO_V5
] == -1)
11401 error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
11402 " DWO info/types section [in module %s]"),
11405 /* Must have an abbrev section. */
11406 if (ids_seen
[DW_SECT_ABBREV_V5
] == -1)
11408 error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
11409 " section [in module %s]"),
11412 htab
->section_pool
.v5
.offsets
= ids_ptr
+ sizeof (uint32_t) * nr_columns
;
11413 htab
->section_pool
.v5
.sizes
11414 = htab
->section_pool
.v5
.offsets
+ (sizeof (uint32_t)
11415 * nr_units
* nr_columns
);
11416 if ((htab
->section_pool
.v5
.sizes
+ (sizeof (uint32_t)
11417 * nr_units
* nr_columns
))
11420 error (_("Dwarf Error: DWP index section is corrupt (too small)"
11421 " [in module %s]"),
11429 /* Update SECTIONS with the data from SECTP.
11431 This function is like the other "locate" section routines, but in
11432 this context the sections to read comes from the DWP V1 hash table,
11433 not the full ELF section table.
11435 The result is non-zero for success, or zero if an error was found. */
11438 locate_v1_virtual_dwo_sections (asection
*sectp
,
11439 struct virtual_v1_dwo_sections
*sections
)
11441 const struct dwop_section_names
*names
= &dwop_section_names
;
11443 if (names
->abbrev_dwo
.matches (sectp
->name
))
11445 /* There can be only one. */
11446 if (sections
->abbrev
.s
.section
!= NULL
)
11448 sections
->abbrev
.s
.section
= sectp
;
11449 sections
->abbrev
.size
= bfd_section_size (sectp
);
11451 else if (names
->info_dwo
.matches (sectp
->name
)
11452 || names
->types_dwo
.matches (sectp
->name
))
11454 /* There can be only one. */
11455 if (sections
->info_or_types
.s
.section
!= NULL
)
11457 sections
->info_or_types
.s
.section
= sectp
;
11458 sections
->info_or_types
.size
= bfd_section_size (sectp
);
11460 else if (names
->line_dwo
.matches (sectp
->name
))
11462 /* There can be only one. */
11463 if (sections
->line
.s
.section
!= NULL
)
11465 sections
->line
.s
.section
= sectp
;
11466 sections
->line
.size
= bfd_section_size (sectp
);
11468 else if (names
->loc_dwo
.matches (sectp
->name
))
11470 /* There can be only one. */
11471 if (sections
->loc
.s
.section
!= NULL
)
11473 sections
->loc
.s
.section
= sectp
;
11474 sections
->loc
.size
= bfd_section_size (sectp
);
11476 else if (names
->macinfo_dwo
.matches (sectp
->name
))
11478 /* There can be only one. */
11479 if (sections
->macinfo
.s
.section
!= NULL
)
11481 sections
->macinfo
.s
.section
= sectp
;
11482 sections
->macinfo
.size
= bfd_section_size (sectp
);
11484 else if (names
->macro_dwo
.matches (sectp
->name
))
11486 /* There can be only one. */
11487 if (sections
->macro
.s
.section
!= NULL
)
11489 sections
->macro
.s
.section
= sectp
;
11490 sections
->macro
.size
= bfd_section_size (sectp
);
11492 else if (names
->str_offsets_dwo
.matches (sectp
->name
))
11494 /* There can be only one. */
11495 if (sections
->str_offsets
.s
.section
!= NULL
)
11497 sections
->str_offsets
.s
.section
= sectp
;
11498 sections
->str_offsets
.size
= bfd_section_size (sectp
);
11502 /* No other kind of section is valid. */
11509 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
11510 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
11511 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
11512 This is for DWP version 1 files. */
11514 static struct dwo_unit
*
11515 create_dwo_unit_in_dwp_v1 (dwarf2_per_objfile
*per_objfile
,
11516 struct dwp_file
*dwp_file
,
11517 uint32_t unit_index
,
11518 const char *comp_dir
,
11519 ULONGEST signature
, int is_debug_types
)
11521 const struct dwp_hash_table
*dwp_htab
=
11522 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
11523 bfd
*dbfd
= dwp_file
->dbfd
.get ();
11524 const char *kind
= is_debug_types
? "TU" : "CU";
11525 struct dwo_file
*dwo_file
;
11526 struct dwo_unit
*dwo_unit
;
11527 struct virtual_v1_dwo_sections sections
;
11528 void **dwo_file_slot
;
11531 gdb_assert (dwp_file
->version
== 1);
11533 dwarf_read_debug_printf ("Reading %s %s/%s in DWP V1 file: %s",
11534 kind
, pulongest (unit_index
), hex_string (signature
),
11537 /* Fetch the sections of this DWO unit.
11538 Put a limit on the number of sections we look for so that bad data
11539 doesn't cause us to loop forever. */
11541 #define MAX_NR_V1_DWO_SECTIONS \
11542 (1 /* .debug_info or .debug_types */ \
11543 + 1 /* .debug_abbrev */ \
11544 + 1 /* .debug_line */ \
11545 + 1 /* .debug_loc */ \
11546 + 1 /* .debug_str_offsets */ \
11547 + 1 /* .debug_macro or .debug_macinfo */ \
11548 + 1 /* trailing zero */)
11550 memset (§ions
, 0, sizeof (sections
));
11552 for (i
= 0; i
< MAX_NR_V1_DWO_SECTIONS
; ++i
)
11555 uint32_t section_nr
=
11556 read_4_bytes (dbfd
,
11557 dwp_htab
->section_pool
.v1
.indices
11558 + (unit_index
+ i
) * sizeof (uint32_t));
11560 if (section_nr
== 0)
11562 if (section_nr
>= dwp_file
->num_sections
)
11564 error (_("Dwarf Error: bad DWP hash table, section number too large"
11565 " [in module %s]"),
11569 sectp
= dwp_file
->elf_sections
[section_nr
];
11570 if (! locate_v1_virtual_dwo_sections (sectp
, §ions
))
11572 error (_("Dwarf Error: bad DWP hash table, invalid section found"
11573 " [in module %s]"),
11579 || sections
.info_or_types
.empty ()
11580 || sections
.abbrev
.empty ())
11582 error (_("Dwarf Error: bad DWP hash table, missing DWO sections"
11583 " [in module %s]"),
11586 if (i
== MAX_NR_V1_DWO_SECTIONS
)
11588 error (_("Dwarf Error: bad DWP hash table, too many DWO sections"
11589 " [in module %s]"),
11593 /* It's easier for the rest of the code if we fake a struct dwo_file and
11594 have dwo_unit "live" in that. At least for now.
11596 The DWP file can be made up of a random collection of CUs and TUs.
11597 However, for each CU + set of TUs that came from the same original DWO
11598 file, we can combine them back into a virtual DWO file to save space
11599 (fewer struct dwo_file objects to allocate). Remember that for really
11600 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
11602 std::string virtual_dwo_name
=
11603 string_printf ("virtual-dwo/%d-%d-%d-%d",
11604 sections
.abbrev
.get_id (),
11605 sections
.line
.get_id (),
11606 sections
.loc
.get_id (),
11607 sections
.str_offsets
.get_id ());
11608 /* Can we use an existing virtual DWO file? */
11609 dwo_file_slot
= lookup_dwo_file_slot (per_objfile
, virtual_dwo_name
.c_str (),
11611 /* Create one if necessary. */
11612 if (*dwo_file_slot
== NULL
)
11614 dwarf_read_debug_printf ("Creating virtual DWO: %s",
11615 virtual_dwo_name
.c_str ());
11617 dwo_file
= new struct dwo_file
;
11618 dwo_file
->dwo_name
= per_objfile
->objfile
->intern (virtual_dwo_name
);
11619 dwo_file
->comp_dir
= comp_dir
;
11620 dwo_file
->sections
.abbrev
= sections
.abbrev
;
11621 dwo_file
->sections
.line
= sections
.line
;
11622 dwo_file
->sections
.loc
= sections
.loc
;
11623 dwo_file
->sections
.macinfo
= sections
.macinfo
;
11624 dwo_file
->sections
.macro
= sections
.macro
;
11625 dwo_file
->sections
.str_offsets
= sections
.str_offsets
;
11626 /* The "str" section is global to the entire DWP file. */
11627 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
11628 /* The info or types section is assigned below to dwo_unit,
11629 there's no need to record it in dwo_file.
11630 Also, we can't simply record type sections in dwo_file because
11631 we record a pointer into the vector in dwo_unit. As we collect more
11632 types we'll grow the vector and eventually have to reallocate space
11633 for it, invalidating all copies of pointers into the previous
11635 *dwo_file_slot
= dwo_file
;
11639 dwarf_read_debug_printf ("Using existing virtual DWO: %s",
11640 virtual_dwo_name
.c_str ());
11642 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
11645 dwo_unit
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, struct dwo_unit
);
11646 dwo_unit
->dwo_file
= dwo_file
;
11647 dwo_unit
->signature
= signature
;
11648 dwo_unit
->section
=
11649 XOBNEW (&per_objfile
->per_bfd
->obstack
, struct dwarf2_section_info
);
11650 *dwo_unit
->section
= sections
.info_or_types
;
11651 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
11656 /* Subroutine of create_dwo_unit_in_dwp_v2 and create_dwo_unit_in_dwp_v5 to
11657 simplify them. Given a pointer to the containing section SECTION, and
11658 OFFSET,SIZE of the piece within that section used by a TU/CU, return a
11659 virtual section of just that piece. */
11661 static struct dwarf2_section_info
11662 create_dwp_v2_or_v5_section (dwarf2_per_objfile
*per_objfile
,
11663 struct dwarf2_section_info
*section
,
11664 bfd_size_type offset
, bfd_size_type size
)
11666 struct dwarf2_section_info result
;
11669 gdb_assert (section
!= NULL
);
11670 gdb_assert (!section
->is_virtual
);
11672 memset (&result
, 0, sizeof (result
));
11673 result
.s
.containing_section
= section
;
11674 result
.is_virtual
= true;
11679 sectp
= section
->get_bfd_section ();
11681 /* Flag an error if the piece denoted by OFFSET,SIZE is outside the
11682 bounds of the real section. This is a pretty-rare event, so just
11683 flag an error (easier) instead of a warning and trying to cope. */
11685 || offset
+ size
> bfd_section_size (sectp
))
11687 error (_("Dwarf Error: Bad DWP V2 or V5 section info, doesn't fit"
11688 " in section %s [in module %s]"),
11689 sectp
? bfd_section_name (sectp
) : "<unknown>",
11690 objfile_name (per_objfile
->objfile
));
11693 result
.virtual_offset
= offset
;
11694 result
.size
= size
;
11698 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
11699 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
11700 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
11701 This is for DWP version 2 files. */
11703 static struct dwo_unit
*
11704 create_dwo_unit_in_dwp_v2 (dwarf2_per_objfile
*per_objfile
,
11705 struct dwp_file
*dwp_file
,
11706 uint32_t unit_index
,
11707 const char *comp_dir
,
11708 ULONGEST signature
, int is_debug_types
)
11710 const struct dwp_hash_table
*dwp_htab
=
11711 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
11712 bfd
*dbfd
= dwp_file
->dbfd
.get ();
11713 const char *kind
= is_debug_types
? "TU" : "CU";
11714 struct dwo_file
*dwo_file
;
11715 struct dwo_unit
*dwo_unit
;
11716 struct virtual_v2_or_v5_dwo_sections sections
;
11717 void **dwo_file_slot
;
11720 gdb_assert (dwp_file
->version
== 2);
11722 dwarf_read_debug_printf ("Reading %s %s/%s in DWP V2 file: %s",
11723 kind
, pulongest (unit_index
), hex_string (signature
),
11726 /* Fetch the section offsets of this DWO unit. */
11728 memset (§ions
, 0, sizeof (sections
));
11730 for (i
= 0; i
< dwp_htab
->nr_columns
; ++i
)
11732 uint32_t offset
= read_4_bytes (dbfd
,
11733 dwp_htab
->section_pool
.v2
.offsets
11734 + (((unit_index
- 1) * dwp_htab
->nr_columns
11736 * sizeof (uint32_t)));
11737 uint32_t size
= read_4_bytes (dbfd
,
11738 dwp_htab
->section_pool
.v2
.sizes
11739 + (((unit_index
- 1) * dwp_htab
->nr_columns
11741 * sizeof (uint32_t)));
11743 switch (dwp_htab
->section_pool
.v2
.section_ids
[i
])
11746 case DW_SECT_TYPES
:
11747 sections
.info_or_types_offset
= offset
;
11748 sections
.info_or_types_size
= size
;
11750 case DW_SECT_ABBREV
:
11751 sections
.abbrev_offset
= offset
;
11752 sections
.abbrev_size
= size
;
11755 sections
.line_offset
= offset
;
11756 sections
.line_size
= size
;
11759 sections
.loc_offset
= offset
;
11760 sections
.loc_size
= size
;
11762 case DW_SECT_STR_OFFSETS
:
11763 sections
.str_offsets_offset
= offset
;
11764 sections
.str_offsets_size
= size
;
11766 case DW_SECT_MACINFO
:
11767 sections
.macinfo_offset
= offset
;
11768 sections
.macinfo_size
= size
;
11770 case DW_SECT_MACRO
:
11771 sections
.macro_offset
= offset
;
11772 sections
.macro_size
= size
;
11777 /* It's easier for the rest of the code if we fake a struct dwo_file and
11778 have dwo_unit "live" in that. At least for now.
11780 The DWP file can be made up of a random collection of CUs and TUs.
11781 However, for each CU + set of TUs that came from the same original DWO
11782 file, we can combine them back into a virtual DWO file to save space
11783 (fewer struct dwo_file objects to allocate). Remember that for really
11784 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
11786 std::string virtual_dwo_name
=
11787 string_printf ("virtual-dwo/%ld-%ld-%ld-%ld",
11788 (long) (sections
.abbrev_size
? sections
.abbrev_offset
: 0),
11789 (long) (sections
.line_size
? sections
.line_offset
: 0),
11790 (long) (sections
.loc_size
? sections
.loc_offset
: 0),
11791 (long) (sections
.str_offsets_size
11792 ? sections
.str_offsets_offset
: 0));
11793 /* Can we use an existing virtual DWO file? */
11794 dwo_file_slot
= lookup_dwo_file_slot (per_objfile
, virtual_dwo_name
.c_str (),
11796 /* Create one if necessary. */
11797 if (*dwo_file_slot
== NULL
)
11799 dwarf_read_debug_printf ("Creating virtual DWO: %s",
11800 virtual_dwo_name
.c_str ());
11802 dwo_file
= new struct dwo_file
;
11803 dwo_file
->dwo_name
= per_objfile
->objfile
->intern (virtual_dwo_name
);
11804 dwo_file
->comp_dir
= comp_dir
;
11805 dwo_file
->sections
.abbrev
=
11806 create_dwp_v2_or_v5_section (per_objfile
, &dwp_file
->sections
.abbrev
,
11807 sections
.abbrev_offset
,
11808 sections
.abbrev_size
);
11809 dwo_file
->sections
.line
=
11810 create_dwp_v2_or_v5_section (per_objfile
, &dwp_file
->sections
.line
,
11811 sections
.line_offset
,
11812 sections
.line_size
);
11813 dwo_file
->sections
.loc
=
11814 create_dwp_v2_or_v5_section (per_objfile
, &dwp_file
->sections
.loc
,
11815 sections
.loc_offset
, sections
.loc_size
);
11816 dwo_file
->sections
.macinfo
=
11817 create_dwp_v2_or_v5_section (per_objfile
, &dwp_file
->sections
.macinfo
,
11818 sections
.macinfo_offset
,
11819 sections
.macinfo_size
);
11820 dwo_file
->sections
.macro
=
11821 create_dwp_v2_or_v5_section (per_objfile
, &dwp_file
->sections
.macro
,
11822 sections
.macro_offset
,
11823 sections
.macro_size
);
11824 dwo_file
->sections
.str_offsets
=
11825 create_dwp_v2_or_v5_section (per_objfile
,
11826 &dwp_file
->sections
.str_offsets
,
11827 sections
.str_offsets_offset
,
11828 sections
.str_offsets_size
);
11829 /* The "str" section is global to the entire DWP file. */
11830 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
11831 /* The info or types section is assigned below to dwo_unit,
11832 there's no need to record it in dwo_file.
11833 Also, we can't simply record type sections in dwo_file because
11834 we record a pointer into the vector in dwo_unit. As we collect more
11835 types we'll grow the vector and eventually have to reallocate space
11836 for it, invalidating all copies of pointers into the previous
11838 *dwo_file_slot
= dwo_file
;
11842 dwarf_read_debug_printf ("Using existing virtual DWO: %s",
11843 virtual_dwo_name
.c_str ());
11845 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
11848 dwo_unit
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, struct dwo_unit
);
11849 dwo_unit
->dwo_file
= dwo_file
;
11850 dwo_unit
->signature
= signature
;
11851 dwo_unit
->section
=
11852 XOBNEW (&per_objfile
->per_bfd
->obstack
, struct dwarf2_section_info
);
11853 *dwo_unit
->section
= create_dwp_v2_or_v5_section
11856 ? &dwp_file
->sections
.types
11857 : &dwp_file
->sections
.info
,
11858 sections
.info_or_types_offset
,
11859 sections
.info_or_types_size
);
11860 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
11865 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
11866 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
11867 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
11868 This is for DWP version 5 files. */
11870 static struct dwo_unit
*
11871 create_dwo_unit_in_dwp_v5 (dwarf2_per_objfile
*per_objfile
,
11872 struct dwp_file
*dwp_file
,
11873 uint32_t unit_index
,
11874 const char *comp_dir
,
11875 ULONGEST signature
, int is_debug_types
)
11877 const struct dwp_hash_table
*dwp_htab
11878 = is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
11879 bfd
*dbfd
= dwp_file
->dbfd
.get ();
11880 const char *kind
= is_debug_types
? "TU" : "CU";
11881 struct dwo_file
*dwo_file
;
11882 struct dwo_unit
*dwo_unit
;
11883 struct virtual_v2_or_v5_dwo_sections sections
{};
11884 void **dwo_file_slot
;
11886 gdb_assert (dwp_file
->version
== 5);
11888 dwarf_read_debug_printf ("Reading %s %s/%s in DWP V5 file: %s",
11889 kind
, pulongest (unit_index
), hex_string (signature
),
11892 /* Fetch the section offsets of this DWO unit. */
11894 /* memset (§ions, 0, sizeof (sections)); */
11896 for (int i
= 0; i
< dwp_htab
->nr_columns
; ++i
)
11898 uint32_t offset
= read_4_bytes (dbfd
,
11899 dwp_htab
->section_pool
.v5
.offsets
11900 + (((unit_index
- 1)
11901 * dwp_htab
->nr_columns
11903 * sizeof (uint32_t)));
11904 uint32_t size
= read_4_bytes (dbfd
,
11905 dwp_htab
->section_pool
.v5
.sizes
11906 + (((unit_index
- 1) * dwp_htab
->nr_columns
11908 * sizeof (uint32_t)));
11910 switch (dwp_htab
->section_pool
.v5
.section_ids
[i
])
11912 case DW_SECT_ABBREV_V5
:
11913 sections
.abbrev_offset
= offset
;
11914 sections
.abbrev_size
= size
;
11916 case DW_SECT_INFO_V5
:
11917 sections
.info_or_types_offset
= offset
;
11918 sections
.info_or_types_size
= size
;
11920 case DW_SECT_LINE_V5
:
11921 sections
.line_offset
= offset
;
11922 sections
.line_size
= size
;
11924 case DW_SECT_LOCLISTS_V5
:
11925 sections
.loclists_offset
= offset
;
11926 sections
.loclists_size
= size
;
11928 case DW_SECT_MACRO_V5
:
11929 sections
.macro_offset
= offset
;
11930 sections
.macro_size
= size
;
11932 case DW_SECT_RNGLISTS_V5
:
11933 sections
.rnglists_offset
= offset
;
11934 sections
.rnglists_size
= size
;
11936 case DW_SECT_STR_OFFSETS_V5
:
11937 sections
.str_offsets_offset
= offset
;
11938 sections
.str_offsets_size
= size
;
11940 case DW_SECT_RESERVED_V5
:
11946 /* It's easier for the rest of the code if we fake a struct dwo_file and
11947 have dwo_unit "live" in that. At least for now.
11949 The DWP file can be made up of a random collection of CUs and TUs.
11950 However, for each CU + set of TUs that came from the same original DWO
11951 file, we can combine them back into a virtual DWO file to save space
11952 (fewer struct dwo_file objects to allocate). Remember that for really
11953 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
11955 std::string virtual_dwo_name
=
11956 string_printf ("virtual-dwo/%ld-%ld-%ld-%ld-%ld-%ld",
11957 (long) (sections
.abbrev_size
? sections
.abbrev_offset
: 0),
11958 (long) (sections
.line_size
? sections
.line_offset
: 0),
11959 (long) (sections
.loclists_size
? sections
.loclists_offset
: 0),
11960 (long) (sections
.str_offsets_size
11961 ? sections
.str_offsets_offset
: 0),
11962 (long) (sections
.macro_size
? sections
.macro_offset
: 0),
11963 (long) (sections
.rnglists_size
? sections
.rnglists_offset
: 0));
11964 /* Can we use an existing virtual DWO file? */
11965 dwo_file_slot
= lookup_dwo_file_slot (per_objfile
,
11966 virtual_dwo_name
.c_str (),
11968 /* Create one if necessary. */
11969 if (*dwo_file_slot
== NULL
)
11971 dwarf_read_debug_printf ("Creating virtual DWO: %s",
11972 virtual_dwo_name
.c_str ());
11974 dwo_file
= new struct dwo_file
;
11975 dwo_file
->dwo_name
= per_objfile
->objfile
->intern (virtual_dwo_name
);
11976 dwo_file
->comp_dir
= comp_dir
;
11977 dwo_file
->sections
.abbrev
=
11978 create_dwp_v2_or_v5_section (per_objfile
,
11979 &dwp_file
->sections
.abbrev
,
11980 sections
.abbrev_offset
,
11981 sections
.abbrev_size
);
11982 dwo_file
->sections
.line
=
11983 create_dwp_v2_or_v5_section (per_objfile
,
11984 &dwp_file
->sections
.line
,
11985 sections
.line_offset
, sections
.line_size
);
11986 dwo_file
->sections
.macro
=
11987 create_dwp_v2_or_v5_section (per_objfile
,
11988 &dwp_file
->sections
.macro
,
11989 sections
.macro_offset
,
11990 sections
.macro_size
);
11991 dwo_file
->sections
.loclists
=
11992 create_dwp_v2_or_v5_section (per_objfile
,
11993 &dwp_file
->sections
.loclists
,
11994 sections
.loclists_offset
,
11995 sections
.loclists_size
);
11996 dwo_file
->sections
.rnglists
=
11997 create_dwp_v2_or_v5_section (per_objfile
,
11998 &dwp_file
->sections
.rnglists
,
11999 sections
.rnglists_offset
,
12000 sections
.rnglists_size
);
12001 dwo_file
->sections
.str_offsets
=
12002 create_dwp_v2_or_v5_section (per_objfile
,
12003 &dwp_file
->sections
.str_offsets
,
12004 sections
.str_offsets_offset
,
12005 sections
.str_offsets_size
);
12006 /* The "str" section is global to the entire DWP file. */
12007 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
12008 /* The info or types section is assigned below to dwo_unit,
12009 there's no need to record it in dwo_file.
12010 Also, we can't simply record type sections in dwo_file because
12011 we record a pointer into the vector in dwo_unit. As we collect more
12012 types we'll grow the vector and eventually have to reallocate space
12013 for it, invalidating all copies of pointers into the previous
12015 *dwo_file_slot
= dwo_file
;
12019 dwarf_read_debug_printf ("Using existing virtual DWO: %s",
12020 virtual_dwo_name
.c_str ());
12022 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
12025 dwo_unit
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, struct dwo_unit
);
12026 dwo_unit
->dwo_file
= dwo_file
;
12027 dwo_unit
->signature
= signature
;
12029 = XOBNEW (&per_objfile
->per_bfd
->obstack
, struct dwarf2_section_info
);
12030 *dwo_unit
->section
= create_dwp_v2_or_v5_section (per_objfile
,
12031 &dwp_file
->sections
.info
,
12032 sections
.info_or_types_offset
,
12033 sections
.info_or_types_size
);
12034 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12039 /* Lookup the DWO unit with SIGNATURE in DWP_FILE.
12040 Returns NULL if the signature isn't found. */
12042 static struct dwo_unit
*
12043 lookup_dwo_unit_in_dwp (dwarf2_per_objfile
*per_objfile
,
12044 struct dwp_file
*dwp_file
, const char *comp_dir
,
12045 ULONGEST signature
, int is_debug_types
)
12047 const struct dwp_hash_table
*dwp_htab
=
12048 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12049 bfd
*dbfd
= dwp_file
->dbfd
.get ();
12050 uint32_t mask
= dwp_htab
->nr_slots
- 1;
12051 uint32_t hash
= signature
& mask
;
12052 uint32_t hash2
= ((signature
>> 32) & mask
) | 1;
12055 struct dwo_unit find_dwo_cu
;
12057 memset (&find_dwo_cu
, 0, sizeof (find_dwo_cu
));
12058 find_dwo_cu
.signature
= signature
;
12059 slot
= htab_find_slot (is_debug_types
12060 ? dwp_file
->loaded_tus
.get ()
12061 : dwp_file
->loaded_cus
.get (),
12062 &find_dwo_cu
, INSERT
);
12065 return (struct dwo_unit
*) *slot
;
12067 /* Use a for loop so that we don't loop forever on bad debug info. */
12068 for (i
= 0; i
< dwp_htab
->nr_slots
; ++i
)
12070 ULONGEST signature_in_table
;
12072 signature_in_table
=
12073 read_8_bytes (dbfd
, dwp_htab
->hash_table
+ hash
* sizeof (uint64_t));
12074 if (signature_in_table
== signature
)
12076 uint32_t unit_index
=
12077 read_4_bytes (dbfd
,
12078 dwp_htab
->unit_table
+ hash
* sizeof (uint32_t));
12080 if (dwp_file
->version
== 1)
12082 *slot
= create_dwo_unit_in_dwp_v1 (per_objfile
, dwp_file
,
12083 unit_index
, comp_dir
,
12084 signature
, is_debug_types
);
12086 else if (dwp_file
->version
== 2)
12088 *slot
= create_dwo_unit_in_dwp_v2 (per_objfile
, dwp_file
,
12089 unit_index
, comp_dir
,
12090 signature
, is_debug_types
);
12092 else /* version == 5 */
12094 *slot
= create_dwo_unit_in_dwp_v5 (per_objfile
, dwp_file
,
12095 unit_index
, comp_dir
,
12096 signature
, is_debug_types
);
12098 return (struct dwo_unit
*) *slot
;
12100 if (signature_in_table
== 0)
12102 hash
= (hash
+ hash2
) & mask
;
12105 error (_("Dwarf Error: bad DWP hash table, lookup didn't terminate"
12106 " [in module %s]"),
12110 /* Subroutine of open_dwo_file,open_dwp_file to simplify them.
12111 Open the file specified by FILE_NAME and hand it off to BFD for
12112 preliminary analysis. Return a newly initialized bfd *, which
12113 includes a canonicalized copy of FILE_NAME.
12114 If IS_DWP is TRUE, we're opening a DWP file, otherwise a DWO file.
12115 SEARCH_CWD is true if the current directory is to be searched.
12116 It will be searched before debug-file-directory.
12117 If successful, the file is added to the bfd include table of the
12118 objfile's bfd (see gdb_bfd_record_inclusion).
12119 If unable to find/open the file, return NULL.
12120 NOTE: This function is derived from symfile_bfd_open. */
12122 static gdb_bfd_ref_ptr
12123 try_open_dwop_file (dwarf2_per_objfile
*per_objfile
,
12124 const char *file_name
, int is_dwp
, int search_cwd
)
12127 /* Blech. OPF_TRY_CWD_FIRST also disables searching the path list if
12128 FILE_NAME contains a '/'. So we can't use it. Instead prepend "."
12129 to debug_file_directory. */
12130 const char *search_path
;
12131 static const char dirname_separator_string
[] = { DIRNAME_SEPARATOR
, '\0' };
12133 gdb::unique_xmalloc_ptr
<char> search_path_holder
;
12136 if (!debug_file_directory
.empty ())
12138 search_path_holder
.reset (concat (".", dirname_separator_string
,
12139 debug_file_directory
.c_str (),
12141 search_path
= search_path_holder
.get ();
12147 search_path
= debug_file_directory
.c_str ();
12149 /* Add the path for the executable binary to the list of search paths. */
12150 std::string objfile_dir
= ldirname (objfile_name (per_objfile
->objfile
));
12151 search_path_holder
.reset (concat (objfile_dir
.c_str (),
12152 dirname_separator_string
,
12153 search_path
, nullptr));
12154 search_path
= search_path_holder
.get ();
12156 openp_flags flags
= OPF_RETURN_REALPATH
;
12158 flags
|= OPF_SEARCH_IN_PATH
;
12160 gdb::unique_xmalloc_ptr
<char> absolute_name
;
12161 desc
= openp (search_path
, flags
, file_name
,
12162 O_RDONLY
| O_BINARY
, &absolute_name
);
12166 gdb_bfd_ref_ptr
sym_bfd (gdb_bfd_open (absolute_name
.get (),
12168 if (sym_bfd
== NULL
)
12170 bfd_set_cacheable (sym_bfd
.get (), 1);
12172 if (!bfd_check_format (sym_bfd
.get (), bfd_object
))
12175 /* Success. Record the bfd as having been included by the objfile's bfd.
12176 This is important because things like demangled_names_hash lives in the
12177 objfile's per_bfd space and may have references to things like symbol
12178 names that live in the DWO/DWP file's per_bfd space. PR 16426. */
12179 gdb_bfd_record_inclusion (per_objfile
->objfile
->obfd
, sym_bfd
.get ());
12184 /* Try to open DWO file FILE_NAME.
12185 COMP_DIR is the DW_AT_comp_dir attribute.
12186 The result is the bfd handle of the file.
12187 If there is a problem finding or opening the file, return NULL.
12188 Upon success, the canonicalized path of the file is stored in the bfd,
12189 same as symfile_bfd_open. */
12191 static gdb_bfd_ref_ptr
12192 open_dwo_file (dwarf2_per_objfile
*per_objfile
,
12193 const char *file_name
, const char *comp_dir
)
12195 if (IS_ABSOLUTE_PATH (file_name
))
12196 return try_open_dwop_file (per_objfile
, file_name
,
12197 0 /*is_dwp*/, 0 /*search_cwd*/);
12199 /* Before trying the search path, try DWO_NAME in COMP_DIR. */
12201 if (comp_dir
!= NULL
)
12203 gdb::unique_xmalloc_ptr
<char> path_to_try
12204 (concat (comp_dir
, SLASH_STRING
, file_name
, (char *) NULL
));
12206 /* NOTE: If comp_dir is a relative path, this will also try the
12207 search path, which seems useful. */
12208 gdb_bfd_ref_ptr
abfd (try_open_dwop_file (per_objfile
, path_to_try
.get (),
12210 1 /*search_cwd*/));
12215 /* That didn't work, try debug-file-directory, which, despite its name,
12216 is a list of paths. */
12218 if (debug_file_directory
.empty ())
12221 return try_open_dwop_file (per_objfile
, file_name
,
12222 0 /*is_dwp*/, 1 /*search_cwd*/);
12225 /* This function is mapped across the sections and remembers the offset and
12226 size of each of the DWO debugging sections we are interested in. */
12229 dwarf2_locate_dwo_sections (bfd
*abfd
, asection
*sectp
,
12230 dwo_sections
*dwo_sections
)
12232 const struct dwop_section_names
*names
= &dwop_section_names
;
12234 if (names
->abbrev_dwo
.matches (sectp
->name
))
12236 dwo_sections
->abbrev
.s
.section
= sectp
;
12237 dwo_sections
->abbrev
.size
= bfd_section_size (sectp
);
12239 else if (names
->info_dwo
.matches (sectp
->name
))
12241 dwo_sections
->info
.s
.section
= sectp
;
12242 dwo_sections
->info
.size
= bfd_section_size (sectp
);
12244 else if (names
->line_dwo
.matches (sectp
->name
))
12246 dwo_sections
->line
.s
.section
= sectp
;
12247 dwo_sections
->line
.size
= bfd_section_size (sectp
);
12249 else if (names
->loc_dwo
.matches (sectp
->name
))
12251 dwo_sections
->loc
.s
.section
= sectp
;
12252 dwo_sections
->loc
.size
= bfd_section_size (sectp
);
12254 else if (names
->loclists_dwo
.matches (sectp
->name
))
12256 dwo_sections
->loclists
.s
.section
= sectp
;
12257 dwo_sections
->loclists
.size
= bfd_section_size (sectp
);
12259 else if (names
->macinfo_dwo
.matches (sectp
->name
))
12261 dwo_sections
->macinfo
.s
.section
= sectp
;
12262 dwo_sections
->macinfo
.size
= bfd_section_size (sectp
);
12264 else if (names
->macro_dwo
.matches (sectp
->name
))
12266 dwo_sections
->macro
.s
.section
= sectp
;
12267 dwo_sections
->macro
.size
= bfd_section_size (sectp
);
12269 else if (names
->rnglists_dwo
.matches (sectp
->name
))
12271 dwo_sections
->rnglists
.s
.section
= sectp
;
12272 dwo_sections
->rnglists
.size
= bfd_section_size (sectp
);
12274 else if (names
->str_dwo
.matches (sectp
->name
))
12276 dwo_sections
->str
.s
.section
= sectp
;
12277 dwo_sections
->str
.size
= bfd_section_size (sectp
);
12279 else if (names
->str_offsets_dwo
.matches (sectp
->name
))
12281 dwo_sections
->str_offsets
.s
.section
= sectp
;
12282 dwo_sections
->str_offsets
.size
= bfd_section_size (sectp
);
12284 else if (names
->types_dwo
.matches (sectp
->name
))
12286 struct dwarf2_section_info type_section
;
12288 memset (&type_section
, 0, sizeof (type_section
));
12289 type_section
.s
.section
= sectp
;
12290 type_section
.size
= bfd_section_size (sectp
);
12291 dwo_sections
->types
.push_back (type_section
);
12295 /* Initialize the use of the DWO file specified by DWO_NAME and referenced
12296 by PER_CU. This is for the non-DWP case.
12297 The result is NULL if DWO_NAME can't be found. */
12299 static struct dwo_file
*
12300 open_and_init_dwo_file (dwarf2_cu
*cu
, const char *dwo_name
,
12301 const char *comp_dir
)
12303 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
12305 gdb_bfd_ref_ptr dbfd
= open_dwo_file (per_objfile
, dwo_name
, comp_dir
);
12308 dwarf_read_debug_printf ("DWO file not found: %s", dwo_name
);
12313 dwo_file_up
dwo_file (new struct dwo_file
);
12314 dwo_file
->dwo_name
= dwo_name
;
12315 dwo_file
->comp_dir
= comp_dir
;
12316 dwo_file
->dbfd
= std::move (dbfd
);
12318 for (asection
*sec
: gdb_bfd_sections (dwo_file
->dbfd
))
12319 dwarf2_locate_dwo_sections (dwo_file
->dbfd
.get (), sec
,
12320 &dwo_file
->sections
);
12322 create_cus_hash_table (per_objfile
, cu
, *dwo_file
, dwo_file
->sections
.info
,
12325 if (cu
->per_cu
->dwarf_version
< 5)
12327 create_debug_types_hash_table (per_objfile
, dwo_file
.get (),
12328 dwo_file
->sections
.types
, dwo_file
->tus
);
12332 create_debug_type_hash_table (per_objfile
, dwo_file
.get (),
12333 &dwo_file
->sections
.info
, dwo_file
->tus
,
12334 rcuh_kind::COMPILE
);
12337 dwarf_read_debug_printf ("DWO file found: %s", dwo_name
);
12339 return dwo_file
.release ();
12342 /* This function is mapped across the sections and remembers the offset and
12343 size of each of the DWP debugging sections common to version 1 and 2 that
12344 we are interested in. */
12347 dwarf2_locate_common_dwp_sections (bfd
*abfd
, asection
*sectp
,
12348 dwp_file
*dwp_file
)
12350 const struct dwop_section_names
*names
= &dwop_section_names
;
12351 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
12353 /* Record the ELF section number for later lookup: this is what the
12354 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
12355 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
12356 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
12358 /* Look for specific sections that we need. */
12359 if (names
->str_dwo
.matches (sectp
->name
))
12361 dwp_file
->sections
.str
.s
.section
= sectp
;
12362 dwp_file
->sections
.str
.size
= bfd_section_size (sectp
);
12364 else if (names
->cu_index
.matches (sectp
->name
))
12366 dwp_file
->sections
.cu_index
.s
.section
= sectp
;
12367 dwp_file
->sections
.cu_index
.size
= bfd_section_size (sectp
);
12369 else if (names
->tu_index
.matches (sectp
->name
))
12371 dwp_file
->sections
.tu_index
.s
.section
= sectp
;
12372 dwp_file
->sections
.tu_index
.size
= bfd_section_size (sectp
);
12376 /* This function is mapped across the sections and remembers the offset and
12377 size of each of the DWP version 2 debugging sections that we are interested
12378 in. This is split into a separate function because we don't know if we
12379 have version 1 or 2 or 5 until we parse the cu_index/tu_index sections. */
12382 dwarf2_locate_v2_dwp_sections (bfd
*abfd
, asection
*sectp
, void *dwp_file_ptr
)
12384 struct dwp_file
*dwp_file
= (struct dwp_file
*) dwp_file_ptr
;
12385 const struct dwop_section_names
*names
= &dwop_section_names
;
12386 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
12388 /* Record the ELF section number for later lookup: this is what the
12389 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
12390 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
12391 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
12393 /* Look for specific sections that we need. */
12394 if (names
->abbrev_dwo
.matches (sectp
->name
))
12396 dwp_file
->sections
.abbrev
.s
.section
= sectp
;
12397 dwp_file
->sections
.abbrev
.size
= bfd_section_size (sectp
);
12399 else if (names
->info_dwo
.matches (sectp
->name
))
12401 dwp_file
->sections
.info
.s
.section
= sectp
;
12402 dwp_file
->sections
.info
.size
= bfd_section_size (sectp
);
12404 else if (names
->line_dwo
.matches (sectp
->name
))
12406 dwp_file
->sections
.line
.s
.section
= sectp
;
12407 dwp_file
->sections
.line
.size
= bfd_section_size (sectp
);
12409 else if (names
->loc_dwo
.matches (sectp
->name
))
12411 dwp_file
->sections
.loc
.s
.section
= sectp
;
12412 dwp_file
->sections
.loc
.size
= bfd_section_size (sectp
);
12414 else if (names
->macinfo_dwo
.matches (sectp
->name
))
12416 dwp_file
->sections
.macinfo
.s
.section
= sectp
;
12417 dwp_file
->sections
.macinfo
.size
= bfd_section_size (sectp
);
12419 else if (names
->macro_dwo
.matches (sectp
->name
))
12421 dwp_file
->sections
.macro
.s
.section
= sectp
;
12422 dwp_file
->sections
.macro
.size
= bfd_section_size (sectp
);
12424 else if (names
->str_offsets_dwo
.matches (sectp
->name
))
12426 dwp_file
->sections
.str_offsets
.s
.section
= sectp
;
12427 dwp_file
->sections
.str_offsets
.size
= bfd_section_size (sectp
);
12429 else if (names
->types_dwo
.matches (sectp
->name
))
12431 dwp_file
->sections
.types
.s
.section
= sectp
;
12432 dwp_file
->sections
.types
.size
= bfd_section_size (sectp
);
12436 /* This function is mapped across the sections and remembers the offset and
12437 size of each of the DWP version 5 debugging sections that we are interested
12438 in. This is split into a separate function because we don't know if we
12439 have version 1 or 2 or 5 until we parse the cu_index/tu_index sections. */
12442 dwarf2_locate_v5_dwp_sections (bfd
*abfd
, asection
*sectp
, void *dwp_file_ptr
)
12444 struct dwp_file
*dwp_file
= (struct dwp_file
*) dwp_file_ptr
;
12445 const struct dwop_section_names
*names
= &dwop_section_names
;
12446 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
12448 /* Record the ELF section number for later lookup: this is what the
12449 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
12450 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
12451 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
12453 /* Look for specific sections that we need. */
12454 if (names
->abbrev_dwo
.matches (sectp
->name
))
12456 dwp_file
->sections
.abbrev
.s
.section
= sectp
;
12457 dwp_file
->sections
.abbrev
.size
= bfd_section_size (sectp
);
12459 else if (names
->info_dwo
.matches (sectp
->name
))
12461 dwp_file
->sections
.info
.s
.section
= sectp
;
12462 dwp_file
->sections
.info
.size
= bfd_section_size (sectp
);
12464 else if (names
->line_dwo
.matches (sectp
->name
))
12466 dwp_file
->sections
.line
.s
.section
= sectp
;
12467 dwp_file
->sections
.line
.size
= bfd_section_size (sectp
);
12469 else if (names
->loclists_dwo
.matches (sectp
->name
))
12471 dwp_file
->sections
.loclists
.s
.section
= sectp
;
12472 dwp_file
->sections
.loclists
.size
= bfd_section_size (sectp
);
12474 else if (names
->macro_dwo
.matches (sectp
->name
))
12476 dwp_file
->sections
.macro
.s
.section
= sectp
;
12477 dwp_file
->sections
.macro
.size
= bfd_section_size (sectp
);
12479 else if (names
->rnglists_dwo
.matches (sectp
->name
))
12481 dwp_file
->sections
.rnglists
.s
.section
= sectp
;
12482 dwp_file
->sections
.rnglists
.size
= bfd_section_size (sectp
);
12484 else if (names
->str_offsets_dwo
.matches (sectp
->name
))
12486 dwp_file
->sections
.str_offsets
.s
.section
= sectp
;
12487 dwp_file
->sections
.str_offsets
.size
= bfd_section_size (sectp
);
12491 /* Hash function for dwp_file loaded CUs/TUs. */
12494 hash_dwp_loaded_cutus (const void *item
)
12496 const struct dwo_unit
*dwo_unit
= (const struct dwo_unit
*) item
;
12498 /* This drops the top 32 bits of the signature, but is ok for a hash. */
12499 return dwo_unit
->signature
;
12502 /* Equality function for dwp_file loaded CUs/TUs. */
12505 eq_dwp_loaded_cutus (const void *a
, const void *b
)
12507 const struct dwo_unit
*dua
= (const struct dwo_unit
*) a
;
12508 const struct dwo_unit
*dub
= (const struct dwo_unit
*) b
;
12510 return dua
->signature
== dub
->signature
;
12513 /* Allocate a hash table for dwp_file loaded CUs/TUs. */
12516 allocate_dwp_loaded_cutus_table ()
12518 return htab_up (htab_create_alloc (3,
12519 hash_dwp_loaded_cutus
,
12520 eq_dwp_loaded_cutus
,
12521 NULL
, xcalloc
, xfree
));
12524 /* Try to open DWP file FILE_NAME.
12525 The result is the bfd handle of the file.
12526 If there is a problem finding or opening the file, return NULL.
12527 Upon success, the canonicalized path of the file is stored in the bfd,
12528 same as symfile_bfd_open. */
12530 static gdb_bfd_ref_ptr
12531 open_dwp_file (dwarf2_per_objfile
*per_objfile
, const char *file_name
)
12533 gdb_bfd_ref_ptr
abfd (try_open_dwop_file (per_objfile
, file_name
,
12535 1 /*search_cwd*/));
12539 /* Work around upstream bug 15652.
12540 http://sourceware.org/bugzilla/show_bug.cgi?id=15652
12541 [Whether that's a "bug" is debatable, but it is getting in our way.]
12542 We have no real idea where the dwp file is, because gdb's realpath-ing
12543 of the executable's path may have discarded the needed info.
12544 [IWBN if the dwp file name was recorded in the executable, akin to
12545 .gnu_debuglink, but that doesn't exist yet.]
12546 Strip the directory from FILE_NAME and search again. */
12547 if (!debug_file_directory
.empty ())
12549 /* Don't implicitly search the current directory here.
12550 If the user wants to search "." to handle this case,
12551 it must be added to debug-file-directory. */
12552 return try_open_dwop_file (per_objfile
, lbasename (file_name
),
12560 /* Initialize the use of the DWP file for the current objfile.
12561 By convention the name of the DWP file is ${objfile}.dwp.
12562 The result is NULL if it can't be found. */
12564 static std::unique_ptr
<struct dwp_file
>
12565 open_and_init_dwp_file (dwarf2_per_objfile
*per_objfile
)
12567 struct objfile
*objfile
= per_objfile
->objfile
;
12569 /* Try to find first .dwp for the binary file before any symbolic links
12572 /* If the objfile is a debug file, find the name of the real binary
12573 file and get the name of dwp file from there. */
12574 std::string dwp_name
;
12575 if (objfile
->separate_debug_objfile_backlink
!= NULL
)
12577 struct objfile
*backlink
= objfile
->separate_debug_objfile_backlink
;
12578 const char *backlink_basename
= lbasename (backlink
->original_name
);
12580 dwp_name
= ldirname (objfile
->original_name
) + SLASH_STRING
+ backlink_basename
;
12583 dwp_name
= objfile
->original_name
;
12585 dwp_name
+= ".dwp";
12587 gdb_bfd_ref_ptr
dbfd (open_dwp_file (per_objfile
, dwp_name
.c_str ()));
12589 && strcmp (objfile
->original_name
, objfile_name (objfile
)) != 0)
12591 /* Try to find .dwp for the binary file after gdb_realpath resolving. */
12592 dwp_name
= objfile_name (objfile
);
12593 dwp_name
+= ".dwp";
12594 dbfd
= open_dwp_file (per_objfile
, dwp_name
.c_str ());
12599 dwarf_read_debug_printf ("DWP file not found: %s", dwp_name
.c_str ());
12601 return std::unique_ptr
<dwp_file
> ();
12604 const char *name
= bfd_get_filename (dbfd
.get ());
12605 std::unique_ptr
<struct dwp_file
> dwp_file
12606 (new struct dwp_file (name
, std::move (dbfd
)));
12608 dwp_file
->num_sections
= elf_numsections (dwp_file
->dbfd
);
12609 dwp_file
->elf_sections
=
12610 OBSTACK_CALLOC (&per_objfile
->per_bfd
->obstack
,
12611 dwp_file
->num_sections
, asection
*);
12613 for (asection
*sec
: gdb_bfd_sections (dwp_file
->dbfd
))
12614 dwarf2_locate_common_dwp_sections (dwp_file
->dbfd
.get (), sec
,
12617 dwp_file
->cus
= create_dwp_hash_table (per_objfile
, dwp_file
.get (), 0);
12619 dwp_file
->tus
= create_dwp_hash_table (per_objfile
, dwp_file
.get (), 1);
12621 /* The DWP file version is stored in the hash table. Oh well. */
12622 if (dwp_file
->cus
&& dwp_file
->tus
12623 && dwp_file
->cus
->version
!= dwp_file
->tus
->version
)
12625 /* Technically speaking, we should try to limp along, but this is
12626 pretty bizarre. We use pulongest here because that's the established
12627 portability solution (e.g, we cannot use %u for uint32_t). */
12628 error (_("Dwarf Error: DWP file CU version %s doesn't match"
12629 " TU version %s [in DWP file %s]"),
12630 pulongest (dwp_file
->cus
->version
),
12631 pulongest (dwp_file
->tus
->version
), dwp_name
.c_str ());
12635 dwp_file
->version
= dwp_file
->cus
->version
;
12636 else if (dwp_file
->tus
)
12637 dwp_file
->version
= dwp_file
->tus
->version
;
12639 dwp_file
->version
= 2;
12641 for (asection
*sec
: gdb_bfd_sections (dwp_file
->dbfd
))
12643 if (dwp_file
->version
== 2)
12644 dwarf2_locate_v2_dwp_sections (dwp_file
->dbfd
.get (), sec
,
12647 dwarf2_locate_v5_dwp_sections (dwp_file
->dbfd
.get (), sec
,
12651 dwp_file
->loaded_cus
= allocate_dwp_loaded_cutus_table ();
12652 dwp_file
->loaded_tus
= allocate_dwp_loaded_cutus_table ();
12654 dwarf_read_debug_printf ("DWP file found: %s", dwp_file
->name
);
12655 dwarf_read_debug_printf (" %s CUs, %s TUs",
12656 pulongest (dwp_file
->cus
? dwp_file
->cus
->nr_units
: 0),
12657 pulongest (dwp_file
->tus
? dwp_file
->tus
->nr_units
: 0));
12662 /* Wrapper around open_and_init_dwp_file, only open it once. */
12664 static struct dwp_file
*
12665 get_dwp_file (dwarf2_per_objfile
*per_objfile
)
12667 if (!per_objfile
->per_bfd
->dwp_checked
)
12669 per_objfile
->per_bfd
->dwp_file
= open_and_init_dwp_file (per_objfile
);
12670 per_objfile
->per_bfd
->dwp_checked
= 1;
12672 return per_objfile
->per_bfd
->dwp_file
.get ();
12675 /* Subroutine of lookup_dwo_comp_unit, lookup_dwo_type_unit.
12676 Look up the CU/TU with signature SIGNATURE, either in DWO file DWO_NAME
12677 or in the DWP file for the objfile, referenced by THIS_UNIT.
12678 If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
12679 IS_DEBUG_TYPES is non-zero if reading a TU, otherwise read a CU.
12681 This is called, for example, when wanting to read a variable with a
12682 complex location. Therefore we don't want to do file i/o for every call.
12683 Therefore we don't want to look for a DWO file on every call.
12684 Therefore we first see if we've already seen SIGNATURE in a DWP file,
12685 then we check if we've already seen DWO_NAME, and only THEN do we check
12688 The result is a pointer to the dwo_unit object or NULL if we didn't find it
12689 (dwo_id mismatch or couldn't find the DWO/DWP file). */
12691 static struct dwo_unit
*
12692 lookup_dwo_cutu (dwarf2_cu
*cu
, const char *dwo_name
, const char *comp_dir
,
12693 ULONGEST signature
, int is_debug_types
)
12695 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
12696 struct objfile
*objfile
= per_objfile
->objfile
;
12697 const char *kind
= is_debug_types
? "TU" : "CU";
12698 void **dwo_file_slot
;
12699 struct dwo_file
*dwo_file
;
12700 struct dwp_file
*dwp_file
;
12702 /* First see if there's a DWP file.
12703 If we have a DWP file but didn't find the DWO inside it, don't
12704 look for the original DWO file. It makes gdb behave differently
12705 depending on whether one is debugging in the build tree. */
12707 dwp_file
= get_dwp_file (per_objfile
);
12708 if (dwp_file
!= NULL
)
12710 const struct dwp_hash_table
*dwp_htab
=
12711 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12713 if (dwp_htab
!= NULL
)
12715 struct dwo_unit
*dwo_cutu
=
12716 lookup_dwo_unit_in_dwp (per_objfile
, dwp_file
, comp_dir
, signature
,
12719 if (dwo_cutu
!= NULL
)
12721 dwarf_read_debug_printf ("Virtual DWO %s %s found: @%s",
12722 kind
, hex_string (signature
),
12723 host_address_to_string (dwo_cutu
));
12731 /* No DWP file, look for the DWO file. */
12733 dwo_file_slot
= lookup_dwo_file_slot (per_objfile
, dwo_name
, comp_dir
);
12734 if (*dwo_file_slot
== NULL
)
12736 /* Read in the file and build a table of the CUs/TUs it contains. */
12737 *dwo_file_slot
= open_and_init_dwo_file (cu
, dwo_name
, comp_dir
);
12739 /* NOTE: This will be NULL if unable to open the file. */
12740 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
12742 if (dwo_file
!= NULL
)
12744 struct dwo_unit
*dwo_cutu
= NULL
;
12746 if (is_debug_types
&& dwo_file
->tus
)
12748 struct dwo_unit find_dwo_cutu
;
12750 memset (&find_dwo_cutu
, 0, sizeof (find_dwo_cutu
));
12751 find_dwo_cutu
.signature
= signature
;
12753 = (struct dwo_unit
*) htab_find (dwo_file
->tus
.get (),
12756 else if (!is_debug_types
&& dwo_file
->cus
)
12758 struct dwo_unit find_dwo_cutu
;
12760 memset (&find_dwo_cutu
, 0, sizeof (find_dwo_cutu
));
12761 find_dwo_cutu
.signature
= signature
;
12762 dwo_cutu
= (struct dwo_unit
*)htab_find (dwo_file
->cus
.get (),
12766 if (dwo_cutu
!= NULL
)
12768 dwarf_read_debug_printf ("DWO %s %s(%s) found: @%s",
12769 kind
, dwo_name
, hex_string (signature
),
12770 host_address_to_string (dwo_cutu
));
12777 /* We didn't find it. This could mean a dwo_id mismatch, or
12778 someone deleted the DWO/DWP file, or the search path isn't set up
12779 correctly to find the file. */
12781 dwarf_read_debug_printf ("DWO %s %s(%s) not found",
12782 kind
, dwo_name
, hex_string (signature
));
12784 /* This is a warning and not a complaint because it can be caused by
12785 pilot error (e.g., user accidentally deleting the DWO). */
12787 /* Print the name of the DWP file if we looked there, helps the user
12788 better diagnose the problem. */
12789 std::string dwp_text
;
12791 if (dwp_file
!= NULL
)
12792 dwp_text
= string_printf (" [in DWP file %s]",
12793 lbasename (dwp_file
->name
));
12795 warning (_("Could not find DWO %s %s(%s)%s referenced by %s at offset %s"
12796 " [in module %s]"),
12797 kind
, dwo_name
, hex_string (signature
), dwp_text
.c_str (), kind
,
12798 sect_offset_str (cu
->per_cu
->sect_off
), objfile_name (objfile
));
12803 /* Lookup the DWO CU DWO_NAME/SIGNATURE referenced from THIS_CU.
12804 See lookup_dwo_cutu_unit for details. */
12806 static struct dwo_unit
*
12807 lookup_dwo_comp_unit (dwarf2_cu
*cu
, const char *dwo_name
, const char *comp_dir
,
12808 ULONGEST signature
)
12810 gdb_assert (!cu
->per_cu
->is_debug_types
);
12812 return lookup_dwo_cutu (cu
, dwo_name
, comp_dir
, signature
, 0);
12815 /* Lookup the DWO TU DWO_NAME/SIGNATURE referenced from THIS_TU.
12816 See lookup_dwo_cutu_unit for details. */
12818 static struct dwo_unit
*
12819 lookup_dwo_type_unit (dwarf2_cu
*cu
, const char *dwo_name
, const char *comp_dir
)
12821 gdb_assert (cu
->per_cu
->is_debug_types
);
12823 signatured_type
*sig_type
= (signatured_type
*) cu
->per_cu
;
12825 return lookup_dwo_cutu (cu
, dwo_name
, comp_dir
, sig_type
->signature
, 1);
12828 /* Traversal function for queue_and_load_all_dwo_tus. */
12831 queue_and_load_dwo_tu (void **slot
, void *info
)
12833 struct dwo_unit
*dwo_unit
= (struct dwo_unit
*) *slot
;
12834 dwarf2_cu
*cu
= (dwarf2_cu
*) info
;
12835 ULONGEST signature
= dwo_unit
->signature
;
12836 signatured_type
*sig_type
= lookup_dwo_signatured_type (cu
, signature
);
12838 if (sig_type
!= NULL
)
12840 /* We pass NULL for DEPENDENT_CU because we don't yet know if there's
12841 a real dependency of PER_CU on SIG_TYPE. That is detected later
12842 while processing PER_CU. */
12843 if (maybe_queue_comp_unit (NULL
, sig_type
, cu
->per_objfile
,
12845 load_full_type_unit (sig_type
, cu
->per_objfile
);
12846 cu
->per_cu
->imported_symtabs_push (sig_type
);
12852 /* Queue all TUs contained in the DWO of CU to be read in.
12853 The DWO may have the only definition of the type, though it may not be
12854 referenced anywhere in PER_CU. Thus we have to load *all* its TUs.
12855 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
12858 queue_and_load_all_dwo_tus (dwarf2_cu
*cu
)
12860 struct dwo_unit
*dwo_unit
;
12861 struct dwo_file
*dwo_file
;
12863 gdb_assert (cu
!= nullptr);
12864 gdb_assert (!cu
->per_cu
->is_debug_types
);
12865 gdb_assert (get_dwp_file (cu
->per_objfile
) == nullptr);
12867 dwo_unit
= cu
->dwo_unit
;
12868 gdb_assert (dwo_unit
!= NULL
);
12870 dwo_file
= dwo_unit
->dwo_file
;
12871 if (dwo_file
->tus
!= NULL
)
12872 htab_traverse_noresize (dwo_file
->tus
.get (), queue_and_load_dwo_tu
, cu
);
12875 /* Read in various DIEs. */
12877 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
12878 Inherit only the children of the DW_AT_abstract_origin DIE not being
12879 already referenced by DW_AT_abstract_origin from the children of the
12883 inherit_abstract_dies (struct die_info
*die
, struct dwarf2_cu
*cu
)
12885 struct die_info
*child_die
;
12886 sect_offset
*offsetp
;
12887 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
12888 struct die_info
*origin_die
;
12889 /* Iterator of the ORIGIN_DIE children. */
12890 struct die_info
*origin_child_die
;
12891 struct attribute
*attr
;
12892 struct dwarf2_cu
*origin_cu
;
12893 struct pending
**origin_previous_list_in_scope
;
12895 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
12899 /* Note that following die references may follow to a die in a
12903 origin_die
= follow_die_ref (die
, attr
, &origin_cu
);
12905 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
12907 origin_previous_list_in_scope
= origin_cu
->list_in_scope
;
12908 origin_cu
->list_in_scope
= cu
->list_in_scope
;
12910 if (die
->tag
!= origin_die
->tag
12911 && !(die
->tag
== DW_TAG_inlined_subroutine
12912 && origin_die
->tag
== DW_TAG_subprogram
))
12913 complaint (_("DIE %s and its abstract origin %s have different tags"),
12914 sect_offset_str (die
->sect_off
),
12915 sect_offset_str (origin_die
->sect_off
));
12917 /* Find if the concrete and abstract trees are structurally the
12918 same. This is a shallow traversal and it is not bullet-proof;
12919 the compiler can trick the debugger into believing that the trees
12920 are isomorphic, whereas they actually are not. However, the
12921 likelyhood of this happening is pretty low, and a full-fledged
12922 check would be an overkill. */
12923 bool are_isomorphic
= true;
12924 die_info
*concrete_child
= die
->child
;
12925 die_info
*abstract_child
= origin_die
->child
;
12926 while (concrete_child
!= nullptr || abstract_child
!= nullptr)
12928 if (concrete_child
== nullptr
12929 || abstract_child
== nullptr
12930 || concrete_child
->tag
!= abstract_child
->tag
)
12932 are_isomorphic
= false;
12936 concrete_child
= concrete_child
->sibling
;
12937 abstract_child
= abstract_child
->sibling
;
12940 /* Walk the origin's children in parallel to the concrete children.
12941 This helps match an origin child in case the debug info misses
12942 DW_AT_abstract_origin attributes. Keep in mind that the abstract
12943 origin tree may not have the same tree structure as the concrete
12945 die_info
*corresponding_abstract_child
12946 = are_isomorphic
? origin_die
->child
: nullptr;
12948 std::vector
<sect_offset
> offsets
;
12950 for (child_die
= die
->child
;
12951 child_die
&& child_die
->tag
;
12952 child_die
= child_die
->sibling
)
12954 struct die_info
*child_origin_die
;
12955 struct dwarf2_cu
*child_origin_cu
;
12957 /* We are trying to process concrete instance entries:
12958 DW_TAG_call_site DIEs indeed have a DW_AT_abstract_origin tag, but
12959 it's not relevant to our analysis here. i.e. detecting DIEs that are
12960 present in the abstract instance but not referenced in the concrete
12962 if (child_die
->tag
== DW_TAG_call_site
12963 || child_die
->tag
== DW_TAG_GNU_call_site
)
12965 if (are_isomorphic
)
12966 corresponding_abstract_child
12967 = corresponding_abstract_child
->sibling
;
12971 /* For each CHILD_DIE, find the corresponding child of
12972 ORIGIN_DIE. If there is more than one layer of
12973 DW_AT_abstract_origin, follow them all; there shouldn't be,
12974 but GCC versions at least through 4.4 generate this (GCC PR
12976 child_origin_die
= child_die
;
12977 child_origin_cu
= cu
;
12980 attr
= dwarf2_attr (child_origin_die
, DW_AT_abstract_origin
,
12984 child_origin_die
= follow_die_ref (child_origin_die
, attr
,
12988 /* If missing DW_AT_abstract_origin, try the corresponding child
12989 of the origin. Clang emits such lexical scopes. */
12990 if (child_origin_die
== child_die
12991 && dwarf2_attr (child_die
, DW_AT_abstract_origin
, cu
) == nullptr
12993 && child_die
->tag
== DW_TAG_lexical_block
)
12994 child_origin_die
= corresponding_abstract_child
;
12996 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
12997 counterpart may exist. */
12998 if (child_origin_die
!= child_die
)
13000 if (child_die
->tag
!= child_origin_die
->tag
13001 && !(child_die
->tag
== DW_TAG_inlined_subroutine
13002 && child_origin_die
->tag
== DW_TAG_subprogram
))
13003 complaint (_("Child DIE %s and its abstract origin %s have "
13005 sect_offset_str (child_die
->sect_off
),
13006 sect_offset_str (child_origin_die
->sect_off
));
13007 if (child_origin_die
->parent
!= origin_die
)
13008 complaint (_("Child DIE %s and its abstract origin %s have "
13009 "different parents"),
13010 sect_offset_str (child_die
->sect_off
),
13011 sect_offset_str (child_origin_die
->sect_off
));
13013 offsets
.push_back (child_origin_die
->sect_off
);
13016 if (are_isomorphic
)
13017 corresponding_abstract_child
= corresponding_abstract_child
->sibling
;
13019 std::sort (offsets
.begin (), offsets
.end ());
13020 sect_offset
*offsets_end
= offsets
.data () + offsets
.size ();
13021 for (offsetp
= offsets
.data () + 1; offsetp
< offsets_end
; offsetp
++)
13022 if (offsetp
[-1] == *offsetp
)
13023 complaint (_("Multiple children of DIE %s refer "
13024 "to DIE %s as their abstract origin"),
13025 sect_offset_str (die
->sect_off
), sect_offset_str (*offsetp
));
13027 offsetp
= offsets
.data ();
13028 origin_child_die
= origin_die
->child
;
13029 while (origin_child_die
&& origin_child_die
->tag
)
13031 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
13032 while (offsetp
< offsets_end
13033 && *offsetp
< origin_child_die
->sect_off
)
13035 if (offsetp
>= offsets_end
13036 || *offsetp
> origin_child_die
->sect_off
)
13038 /* Found that ORIGIN_CHILD_DIE is really not referenced.
13039 Check whether we're already processing ORIGIN_CHILD_DIE.
13040 This can happen with mutually referenced abstract_origins.
13042 if (!origin_child_die
->in_process
)
13043 process_die (origin_child_die
, origin_cu
);
13045 origin_child_die
= origin_child_die
->sibling
;
13047 origin_cu
->list_in_scope
= origin_previous_list_in_scope
;
13049 if (cu
!= origin_cu
)
13050 compute_delayed_physnames (origin_cu
);
13054 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13056 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
13057 struct gdbarch
*gdbarch
= objfile
->arch ();
13058 struct context_stack
*newobj
;
13061 struct die_info
*child_die
;
13062 struct attribute
*attr
, *call_line
, *call_file
;
13064 CORE_ADDR baseaddr
;
13065 struct block
*block
;
13066 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
13067 std::vector
<struct symbol
*> template_args
;
13068 struct template_symbol
*templ_func
= NULL
;
13072 /* If we do not have call site information, we can't show the
13073 caller of this inlined function. That's too confusing, so
13074 only use the scope for local variables. */
13075 call_line
= dwarf2_attr (die
, DW_AT_call_line
, cu
);
13076 call_file
= dwarf2_attr (die
, DW_AT_call_file
, cu
);
13077 if (call_line
== NULL
|| call_file
== NULL
)
13079 read_lexical_block_scope (die
, cu
);
13084 baseaddr
= objfile
->text_section_offset ();
13086 name
= dwarf2_name (die
, cu
);
13088 /* Ignore functions with missing or empty names. These are actually
13089 illegal according to the DWARF standard. */
13092 complaint (_("missing name for subprogram DIE at %s"),
13093 sect_offset_str (die
->sect_off
));
13097 /* Ignore functions with missing or invalid low and high pc attributes. */
13098 if (dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
)
13099 <= PC_BOUNDS_INVALID
)
13101 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
13102 if (attr
== nullptr || !attr
->as_boolean ())
13103 complaint (_("cannot get low and high bounds "
13104 "for subprogram DIE at %s"),
13105 sect_offset_str (die
->sect_off
));
13109 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
13110 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
13112 /* If we have any template arguments, then we must allocate a
13113 different sort of symbol. */
13114 for (child_die
= die
->child
; child_die
; child_die
= child_die
->sibling
)
13116 if (child_die
->tag
== DW_TAG_template_type_param
13117 || child_die
->tag
== DW_TAG_template_value_param
)
13119 templ_func
= new (&objfile
->objfile_obstack
) template_symbol
;
13120 templ_func
->subclass
= SYMBOL_TEMPLATE
;
13125 gdb_assert (cu
->get_builder () != nullptr);
13126 newobj
= cu
->get_builder ()->push_context (0, lowpc
);
13127 newobj
->name
= new_symbol (die
, read_type_die (die
, cu
), cu
,
13128 (struct symbol
*) templ_func
);
13130 if (dwarf2_flag_true_p (die
, DW_AT_main_subprogram
, cu
))
13131 set_objfile_main_name (objfile
, newobj
->name
->linkage_name (),
13134 /* If there is a location expression for DW_AT_frame_base, record
13136 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
13137 if (attr
!= nullptr)
13138 dwarf2_symbol_mark_computed (attr
, newobj
->name
, cu
, 1);
13140 /* If there is a location for the static link, record it. */
13141 newobj
->static_link
= NULL
;
13142 attr
= dwarf2_attr (die
, DW_AT_static_link
, cu
);
13143 if (attr
!= nullptr)
13145 newobj
->static_link
13146 = XOBNEW (&objfile
->objfile_obstack
, struct dynamic_prop
);
13147 attr_to_dynamic_prop (attr
, die
, cu
, newobj
->static_link
,
13151 cu
->list_in_scope
= cu
->get_builder ()->get_local_symbols ();
13153 if (die
->child
!= NULL
)
13155 child_die
= die
->child
;
13156 while (child_die
&& child_die
->tag
)
13158 if (child_die
->tag
== DW_TAG_template_type_param
13159 || child_die
->tag
== DW_TAG_template_value_param
)
13161 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
13164 template_args
.push_back (arg
);
13167 process_die (child_die
, cu
);
13168 child_die
= child_die
->sibling
;
13172 inherit_abstract_dies (die
, cu
);
13174 /* If we have a DW_AT_specification, we might need to import using
13175 directives from the context of the specification DIE. See the
13176 comment in determine_prefix. */
13177 if (cu
->per_cu
->lang
== language_cplus
13178 && dwarf2_attr (die
, DW_AT_specification
, cu
))
13180 struct dwarf2_cu
*spec_cu
= cu
;
13181 struct die_info
*spec_die
= die_specification (die
, &spec_cu
);
13185 child_die
= spec_die
->child
;
13186 while (child_die
&& child_die
->tag
)
13188 if (child_die
->tag
== DW_TAG_imported_module
)
13189 process_die (child_die
, spec_cu
);
13190 child_die
= child_die
->sibling
;
13193 /* In some cases, GCC generates specification DIEs that
13194 themselves contain DW_AT_specification attributes. */
13195 spec_die
= die_specification (spec_die
, &spec_cu
);
13199 struct context_stack cstk
= cu
->get_builder ()->pop_context ();
13200 /* Make a block for the local symbols within. */
13201 block
= cu
->get_builder ()->finish_block (cstk
.name
, cstk
.old_blocks
,
13202 cstk
.static_link
, lowpc
, highpc
);
13204 /* For C++, set the block's scope. */
13205 if ((cu
->per_cu
->lang
== language_cplus
13206 || cu
->per_cu
->lang
== language_fortran
13207 || cu
->per_cu
->lang
== language_d
13208 || cu
->per_cu
->lang
== language_rust
)
13209 && cu
->processing_has_namespace_info
)
13210 block_set_scope (block
, determine_prefix (die
, cu
),
13211 &objfile
->objfile_obstack
);
13213 /* If we have address ranges, record them. */
13214 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
13216 gdbarch_make_symbol_special (gdbarch
, cstk
.name
, objfile
);
13218 /* Attach template arguments to function. */
13219 if (!template_args
.empty ())
13221 gdb_assert (templ_func
!= NULL
);
13223 templ_func
->n_template_arguments
= template_args
.size ();
13224 templ_func
->template_arguments
13225 = XOBNEWVEC (&objfile
->objfile_obstack
, struct symbol
*,
13226 templ_func
->n_template_arguments
);
13227 memcpy (templ_func
->template_arguments
,
13228 template_args
.data (),
13229 (templ_func
->n_template_arguments
* sizeof (struct symbol
*)));
13231 /* Make sure that the symtab is set on the new symbols. Even
13232 though they don't appear in this symtab directly, other parts
13233 of gdb assume that symbols do, and this is reasonably
13235 for (symbol
*sym
: template_args
)
13236 symbol_set_symtab (sym
, symbol_symtab (templ_func
));
13239 /* In C++, we can have functions nested inside functions (e.g., when
13240 a function declares a class that has methods). This means that
13241 when we finish processing a function scope, we may need to go
13242 back to building a containing block's symbol lists. */
13243 *cu
->get_builder ()->get_local_symbols () = cstk
.locals
;
13244 cu
->get_builder ()->set_local_using_directives (cstk
.local_using_directives
);
13246 /* If we've finished processing a top-level function, subsequent
13247 symbols go in the file symbol list. */
13248 if (cu
->get_builder ()->outermost_context_p ())
13249 cu
->list_in_scope
= cu
->get_builder ()->get_file_symbols ();
13252 /* Process all the DIES contained within a lexical block scope. Start
13253 a new scope, process the dies, and then close the scope. */
13256 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13258 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
13259 struct gdbarch
*gdbarch
= objfile
->arch ();
13260 CORE_ADDR lowpc
, highpc
;
13261 struct die_info
*child_die
;
13262 CORE_ADDR baseaddr
;
13264 baseaddr
= objfile
->text_section_offset ();
13266 /* Ignore blocks with missing or invalid low and high pc attributes. */
13267 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
13268 as multiple lexical blocks? Handling children in a sane way would
13269 be nasty. Might be easier to properly extend generic blocks to
13270 describe ranges. */
13271 switch (dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
13273 case PC_BOUNDS_NOT_PRESENT
:
13274 /* DW_TAG_lexical_block has no attributes, process its children as if
13275 there was no wrapping by that DW_TAG_lexical_block.
13276 GCC does no longer produces such DWARF since GCC r224161. */
13277 for (child_die
= die
->child
;
13278 child_die
!= NULL
&& child_die
->tag
;
13279 child_die
= child_die
->sibling
)
13281 /* We might already be processing this DIE. This can happen
13282 in an unusual circumstance -- where a subroutine A
13283 appears lexically in another subroutine B, but A actually
13284 inlines B. The recursion is broken here, rather than in
13285 inherit_abstract_dies, because it seems better to simply
13286 drop concrete children here. */
13287 if (!child_die
->in_process
)
13288 process_die (child_die
, cu
);
13291 case PC_BOUNDS_INVALID
:
13294 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
13295 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
13297 cu
->get_builder ()->push_context (0, lowpc
);
13298 if (die
->child
!= NULL
)
13300 child_die
= die
->child
;
13301 while (child_die
&& child_die
->tag
)
13303 process_die (child_die
, cu
);
13304 child_die
= child_die
->sibling
;
13307 inherit_abstract_dies (die
, cu
);
13308 struct context_stack cstk
= cu
->get_builder ()->pop_context ();
13310 if (*cu
->get_builder ()->get_local_symbols () != NULL
13311 || (*cu
->get_builder ()->get_local_using_directives ()) != NULL
)
13313 struct block
*block
13314 = cu
->get_builder ()->finish_block (0, cstk
.old_blocks
, NULL
,
13315 cstk
.start_addr
, highpc
);
13317 /* Note that recording ranges after traversing children, as we
13318 do here, means that recording a parent's ranges entails
13319 walking across all its children's ranges as they appear in
13320 the address map, which is quadratic behavior.
13322 It would be nicer to record the parent's ranges before
13323 traversing its children, simply overriding whatever you find
13324 there. But since we don't even decide whether to create a
13325 block until after we've traversed its children, that's hard
13327 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
13329 *cu
->get_builder ()->get_local_symbols () = cstk
.locals
;
13330 cu
->get_builder ()->set_local_using_directives (cstk
.local_using_directives
);
13333 /* Read in DW_TAG_call_site and insert it to CU->call_site_htab. */
13336 read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13338 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
13339 struct objfile
*objfile
= per_objfile
->objfile
;
13340 struct gdbarch
*gdbarch
= objfile
->arch ();
13341 CORE_ADDR pc
, baseaddr
;
13342 struct attribute
*attr
;
13345 struct die_info
*child_die
;
13347 baseaddr
= objfile
->text_section_offset ();
13349 attr
= dwarf2_attr (die
, DW_AT_call_return_pc
, cu
);
13352 /* This was a pre-DWARF-5 GNU extension alias
13353 for DW_AT_call_return_pc. */
13354 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
13358 complaint (_("missing DW_AT_call_return_pc for DW_TAG_call_site "
13359 "DIE %s [in module %s]"),
13360 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
13363 pc
= attr
->as_address () + baseaddr
;
13364 pc
= gdbarch_adjust_dwarf2_addr (gdbarch
, pc
);
13367 if (cu
->call_site_htab
== NULL
)
13368 cu
->call_site_htab
= htab_create_alloc_ex (16, call_site::hash
,
13369 call_site::eq
, NULL
,
13370 &objfile
->objfile_obstack
,
13371 hashtab_obstack_allocate
, NULL
);
13372 struct call_site
call_site_local (pc
, nullptr, nullptr);
13373 slot
= htab_find_slot (cu
->call_site_htab
, &call_site_local
, INSERT
);
13376 complaint (_("Duplicate PC %s for DW_TAG_call_site "
13377 "DIE %s [in module %s]"),
13378 paddress (gdbarch
, pc
), sect_offset_str (die
->sect_off
),
13379 objfile_name (objfile
));
13383 /* Count parameters at the caller. */
13386 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
13387 child_die
= child_die
->sibling
)
13389 if (child_die
->tag
!= DW_TAG_call_site_parameter
13390 && child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
13392 complaint (_("Tag %d is not DW_TAG_call_site_parameter in "
13393 "DW_TAG_call_site child DIE %s [in module %s]"),
13394 child_die
->tag
, sect_offset_str (child_die
->sect_off
),
13395 objfile_name (objfile
));
13402 struct call_site
*call_site
13403 = new (XOBNEWVAR (&objfile
->objfile_obstack
,
13405 sizeof (*call_site
) + sizeof (call_site
->parameter
[0]) * nparams
))
13406 struct call_site (pc
, cu
->per_cu
, per_objfile
);
13409 /* We never call the destructor of call_site, so we must ensure it is
13410 trivially destructible. */
13411 gdb_static_assert(std::is_trivially_destructible
<struct call_site
>::value
);
13413 if (dwarf2_flag_true_p (die
, DW_AT_call_tail_call
, cu
)
13414 || dwarf2_flag_true_p (die
, DW_AT_GNU_tail_call
, cu
))
13416 struct die_info
*func_die
;
13418 /* Skip also over DW_TAG_inlined_subroutine. */
13419 for (func_die
= die
->parent
;
13420 func_die
&& func_die
->tag
!= DW_TAG_subprogram
13421 && func_die
->tag
!= DW_TAG_subroutine_type
;
13422 func_die
= func_die
->parent
);
13424 /* DW_AT_call_all_calls is a superset
13425 of DW_AT_call_all_tail_calls. */
13427 && !dwarf2_flag_true_p (func_die
, DW_AT_call_all_calls
, cu
)
13428 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_call_sites
, cu
)
13429 && !dwarf2_flag_true_p (func_die
, DW_AT_call_all_tail_calls
, cu
)
13430 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_tail_call_sites
, cu
))
13432 /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
13433 not complete. But keep CALL_SITE for look ups via call_site_htab,
13434 both the initial caller containing the real return address PC and
13435 the final callee containing the current PC of a chain of tail
13436 calls do not need to have the tail call list complete. But any
13437 function candidate for a virtual tail call frame searched via
13438 TYPE_TAIL_CALL_LIST must have the tail call list complete to be
13439 determined unambiguously. */
13443 struct type
*func_type
= NULL
;
13446 func_type
= get_die_type (func_die
, cu
);
13447 if (func_type
!= NULL
)
13449 gdb_assert (func_type
->code () == TYPE_CODE_FUNC
);
13451 /* Enlist this call site to the function. */
13452 call_site
->tail_call_next
= TYPE_TAIL_CALL_LIST (func_type
);
13453 TYPE_TAIL_CALL_LIST (func_type
) = call_site
;
13456 complaint (_("Cannot find function owning DW_TAG_call_site "
13457 "DIE %s [in module %s]"),
13458 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
13462 attr
= dwarf2_attr (die
, DW_AT_call_target
, cu
);
13464 attr
= dwarf2_attr (die
, DW_AT_GNU_call_site_target
, cu
);
13466 attr
= dwarf2_attr (die
, DW_AT_call_origin
, cu
);
13469 /* This was a pre-DWARF-5 GNU extension alias for DW_AT_call_origin. */
13470 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
13473 call_site
->target
.set_loc_dwarf_block (nullptr);
13474 if (!attr
|| (attr
->form_is_block () && attr
->as_block ()->size
== 0))
13475 /* Keep NULL DWARF_BLOCK. */;
13476 else if (attr
->form_is_block ())
13478 struct dwarf2_locexpr_baton
*dlbaton
;
13479 struct dwarf_block
*block
= attr
->as_block ();
13481 dlbaton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
13482 dlbaton
->data
= block
->data
;
13483 dlbaton
->size
= block
->size
;
13484 dlbaton
->per_objfile
= per_objfile
;
13485 dlbaton
->per_cu
= cu
->per_cu
;
13487 call_site
->target
.set_loc_dwarf_block (dlbaton
);
13489 else if (attr
->form_is_ref ())
13491 struct dwarf2_cu
*target_cu
= cu
;
13492 struct die_info
*target_die
;
13494 target_die
= follow_die_ref (die
, attr
, &target_cu
);
13495 gdb_assert (target_cu
->per_objfile
->objfile
== objfile
);
13496 if (die_is_declaration (target_die
, target_cu
))
13498 const char *target_physname
;
13500 /* Prefer the mangled name; otherwise compute the demangled one. */
13501 target_physname
= dw2_linkage_name (target_die
, target_cu
);
13502 if (target_physname
== NULL
)
13503 target_physname
= dwarf2_physname (NULL
, target_die
, target_cu
);
13504 if (target_physname
== NULL
)
13505 complaint (_("DW_AT_call_target target DIE has invalid "
13506 "physname, for referencing DIE %s [in module %s]"),
13507 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
13509 call_site
->target
.set_loc_physname (target_physname
);
13515 /* DW_AT_entry_pc should be preferred. */
13516 if (dwarf2_get_pc_bounds (target_die
, &lowpc
, NULL
, target_cu
, NULL
)
13517 <= PC_BOUNDS_INVALID
)
13518 complaint (_("DW_AT_call_target target DIE has invalid "
13519 "low pc, for referencing DIE %s [in module %s]"),
13520 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
13523 lowpc
= (gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
)
13525 call_site
->target
.set_loc_physaddr (lowpc
);
13530 complaint (_("DW_TAG_call_site DW_AT_call_target is neither "
13531 "block nor reference, for DIE %s [in module %s]"),
13532 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
13534 for (child_die
= die
->child
;
13535 child_die
&& child_die
->tag
;
13536 child_die
= child_die
->sibling
)
13538 struct call_site_parameter
*parameter
;
13539 struct attribute
*loc
, *origin
;
13541 if (child_die
->tag
!= DW_TAG_call_site_parameter
13542 && child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
13544 /* Already printed the complaint above. */
13548 gdb_assert (call_site
->parameter_count
< nparams
);
13549 parameter
= &call_site
->parameter
[call_site
->parameter_count
];
13551 /* DW_AT_location specifies the register number or DW_AT_abstract_origin
13552 specifies DW_TAG_formal_parameter. Value of the data assumed for the
13553 register is contained in DW_AT_call_value. */
13555 loc
= dwarf2_attr (child_die
, DW_AT_location
, cu
);
13556 origin
= dwarf2_attr (child_die
, DW_AT_call_parameter
, cu
);
13557 if (origin
== NULL
)
13559 /* This was a pre-DWARF-5 GNU extension alias
13560 for DW_AT_call_parameter. */
13561 origin
= dwarf2_attr (child_die
, DW_AT_abstract_origin
, cu
);
13563 if (loc
== NULL
&& origin
!= NULL
&& origin
->form_is_ref ())
13565 parameter
->kind
= CALL_SITE_PARAMETER_PARAM_OFFSET
;
13567 sect_offset sect_off
= origin
->get_ref_die_offset ();
13568 if (!cu
->header
.offset_in_cu_p (sect_off
))
13570 /* As DW_OP_GNU_parameter_ref uses CU-relative offset this
13571 binding can be done only inside one CU. Such referenced DIE
13572 therefore cannot be even moved to DW_TAG_partial_unit. */
13573 complaint (_("DW_AT_call_parameter offset is not in CU for "
13574 "DW_TAG_call_site child DIE %s [in module %s]"),
13575 sect_offset_str (child_die
->sect_off
),
13576 objfile_name (objfile
));
13579 parameter
->u
.param_cu_off
13580 = (cu_offset
) (sect_off
- cu
->header
.sect_off
);
13582 else if (loc
== NULL
|| origin
!= NULL
|| !loc
->form_is_block ())
13584 complaint (_("No DW_FORM_block* DW_AT_location for "
13585 "DW_TAG_call_site child DIE %s [in module %s]"),
13586 sect_offset_str (child_die
->sect_off
), objfile_name (objfile
));
13591 struct dwarf_block
*block
= loc
->as_block ();
13593 parameter
->u
.dwarf_reg
= dwarf_block_to_dwarf_reg
13594 (block
->data
, &block
->data
[block
->size
]);
13595 if (parameter
->u
.dwarf_reg
!= -1)
13596 parameter
->kind
= CALL_SITE_PARAMETER_DWARF_REG
;
13597 else if (dwarf_block_to_sp_offset (gdbarch
, block
->data
,
13598 &block
->data
[block
->size
],
13599 ¶meter
->u
.fb_offset
))
13600 parameter
->kind
= CALL_SITE_PARAMETER_FB_OFFSET
;
13603 complaint (_("Only single DW_OP_reg or DW_OP_fbreg is supported "
13604 "for DW_FORM_block* DW_AT_location is supported for "
13605 "DW_TAG_call_site child DIE %s "
13607 sect_offset_str (child_die
->sect_off
),
13608 objfile_name (objfile
));
13613 attr
= dwarf2_attr (child_die
, DW_AT_call_value
, cu
);
13615 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_value
, cu
);
13616 if (attr
== NULL
|| !attr
->form_is_block ())
13618 complaint (_("No DW_FORM_block* DW_AT_call_value for "
13619 "DW_TAG_call_site child DIE %s [in module %s]"),
13620 sect_offset_str (child_die
->sect_off
),
13621 objfile_name (objfile
));
13625 struct dwarf_block
*block
= attr
->as_block ();
13626 parameter
->value
= block
->data
;
13627 parameter
->value_size
= block
->size
;
13629 /* Parameters are not pre-cleared by memset above. */
13630 parameter
->data_value
= NULL
;
13631 parameter
->data_value_size
= 0;
13632 call_site
->parameter_count
++;
13634 attr
= dwarf2_attr (child_die
, DW_AT_call_data_value
, cu
);
13636 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_data_value
, cu
);
13637 if (attr
!= nullptr)
13639 if (!attr
->form_is_block ())
13640 complaint (_("No DW_FORM_block* DW_AT_call_data_value for "
13641 "DW_TAG_call_site child DIE %s [in module %s]"),
13642 sect_offset_str (child_die
->sect_off
),
13643 objfile_name (objfile
));
13646 block
= attr
->as_block ();
13647 parameter
->data_value
= block
->data
;
13648 parameter
->data_value_size
= block
->size
;
13654 /* Helper function for read_variable. If DIE represents a virtual
13655 table, then return the type of the concrete object that is
13656 associated with the virtual table. Otherwise, return NULL. */
13658 static struct type
*
13659 rust_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
13661 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
13665 /* Find the type DIE. */
13666 struct die_info
*type_die
= NULL
;
13667 struct dwarf2_cu
*type_cu
= cu
;
13669 if (attr
->form_is_ref ())
13670 type_die
= follow_die_ref (die
, attr
, &type_cu
);
13671 if (type_die
== NULL
)
13674 if (dwarf2_attr (type_die
, DW_AT_containing_type
, type_cu
) == NULL
)
13676 return die_containing_type (type_die
, type_cu
);
13679 /* Read a variable (DW_TAG_variable) DIE and create a new symbol. */
13682 read_variable (struct die_info
*die
, struct dwarf2_cu
*cu
)
13684 struct rust_vtable_symbol
*storage
= NULL
;
13686 if (cu
->per_cu
->lang
== language_rust
)
13688 struct type
*containing_type
= rust_containing_type (die
, cu
);
13690 if (containing_type
!= NULL
)
13692 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
13694 storage
= new (&objfile
->objfile_obstack
) rust_vtable_symbol
;
13695 storage
->concrete_type
= containing_type
;
13696 storage
->subclass
= SYMBOL_RUST_VTABLE
;
13700 struct symbol
*res
= new_symbol (die
, NULL
, cu
, storage
);
13701 struct attribute
*abstract_origin
13702 = dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
13703 struct attribute
*loc
= dwarf2_attr (die
, DW_AT_location
, cu
);
13704 if (res
== NULL
&& loc
&& abstract_origin
)
13706 /* We have a variable without a name, but with a location and an abstract
13707 origin. This may be a concrete instance of an abstract variable
13708 referenced from an DW_OP_GNU_variable_value, so save it to find it back
13710 struct dwarf2_cu
*origin_cu
= cu
;
13711 struct die_info
*origin_die
13712 = follow_die_ref (die
, abstract_origin
, &origin_cu
);
13713 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
13714 per_objfile
->per_bfd
->abstract_to_concrete
13715 [origin_die
->sect_off
].push_back (die
->sect_off
);
13719 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET
13720 reading .debug_rnglists.
13721 Callback's type should be:
13722 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
13723 Return true if the attributes are present and valid, otherwise,
13726 template <typename Callback
>
13728 dwarf2_rnglists_process (unsigned offset
, struct dwarf2_cu
*cu
,
13729 dwarf_tag tag
, Callback
&&callback
)
13731 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
13732 struct objfile
*objfile
= per_objfile
->objfile
;
13733 bfd
*obfd
= objfile
->obfd
;
13734 /* Base address selection entry. */
13735 gdb::optional
<CORE_ADDR
> base
;
13736 const gdb_byte
*buffer
;
13737 bool overflow
= false;
13738 ULONGEST addr_index
;
13739 struct dwarf2_section_info
*rnglists_section
;
13741 base
= cu
->base_address
;
13742 rnglists_section
= cu_debug_rnglists_section (cu
, tag
);
13743 rnglists_section
->read (objfile
);
13745 if (offset
>= rnglists_section
->size
)
13747 complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
13751 buffer
= rnglists_section
->buffer
+ offset
;
13755 /* Initialize it due to a false compiler warning. */
13756 CORE_ADDR range_beginning
= 0, range_end
= 0;
13757 const gdb_byte
*buf_end
= (rnglists_section
->buffer
13758 + rnglists_section
->size
);
13759 unsigned int bytes_read
;
13761 if (buffer
== buf_end
)
13766 const auto rlet
= static_cast<enum dwarf_range_list_entry
>(*buffer
++);
13769 case DW_RLE_end_of_list
:
13771 case DW_RLE_base_address
:
13772 if (buffer
+ cu
->header
.addr_size
> buf_end
)
13777 base
= cu
->header
.read_address (obfd
, buffer
, &bytes_read
);
13778 buffer
+= bytes_read
;
13780 case DW_RLE_base_addressx
:
13781 addr_index
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
13782 buffer
+= bytes_read
;
13783 base
= read_addr_index (cu
, addr_index
);
13785 case DW_RLE_start_length
:
13786 if (buffer
+ cu
->header
.addr_size
> buf_end
)
13791 range_beginning
= cu
->header
.read_address (obfd
, buffer
,
13793 buffer
+= bytes_read
;
13794 range_end
= (range_beginning
13795 + read_unsigned_leb128 (obfd
, buffer
, &bytes_read
));
13796 buffer
+= bytes_read
;
13797 if (buffer
> buf_end
)
13803 case DW_RLE_startx_length
:
13804 addr_index
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
13805 buffer
+= bytes_read
;
13806 range_beginning
= read_addr_index (cu
, addr_index
);
13807 if (buffer
> buf_end
)
13812 range_end
= (range_beginning
13813 + read_unsigned_leb128 (obfd
, buffer
, &bytes_read
));
13814 buffer
+= bytes_read
;
13816 case DW_RLE_offset_pair
:
13817 range_beginning
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
13818 buffer
+= bytes_read
;
13819 if (buffer
> buf_end
)
13824 range_end
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
13825 buffer
+= bytes_read
;
13826 if (buffer
> buf_end
)
13832 case DW_RLE_start_end
:
13833 if (buffer
+ 2 * cu
->header
.addr_size
> buf_end
)
13838 range_beginning
= cu
->header
.read_address (obfd
, buffer
,
13840 buffer
+= bytes_read
;
13841 range_end
= cu
->header
.read_address (obfd
, buffer
, &bytes_read
);
13842 buffer
+= bytes_read
;
13844 case DW_RLE_startx_endx
:
13845 addr_index
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
13846 buffer
+= bytes_read
;
13847 range_beginning
= read_addr_index (cu
, addr_index
);
13848 if (buffer
> buf_end
)
13853 addr_index
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
13854 buffer
+= bytes_read
;
13855 range_end
= read_addr_index (cu
, addr_index
);
13858 complaint (_("Invalid .debug_rnglists data (no base address)"));
13861 if (rlet
== DW_RLE_end_of_list
|| overflow
)
13863 if (rlet
== DW_RLE_base_address
)
13866 if (range_beginning
> range_end
)
13868 /* Inverted range entries are invalid. */
13869 complaint (_("Invalid .debug_rnglists data (inverted range)"));
13873 /* Empty range entries have no effect. */
13874 if (range_beginning
== range_end
)
13877 /* Only DW_RLE_offset_pair needs the base address added. */
13878 if (rlet
== DW_RLE_offset_pair
)
13880 if (!base
.has_value ())
13882 /* We have no valid base address for the DW_RLE_offset_pair. */
13883 complaint (_("Invalid .debug_rnglists data (no base address for "
13884 "DW_RLE_offset_pair)"));
13888 range_beginning
+= *base
;
13889 range_end
+= *base
;
13892 /* A not-uncommon case of bad debug info.
13893 Don't pollute the addrmap with bad data. */
13894 if (range_beginning
== 0
13895 && !per_objfile
->per_bfd
->has_section_at_zero
)
13897 complaint (_(".debug_rnglists entry has start address of zero"
13898 " [in module %s]"), objfile_name (objfile
));
13902 callback (range_beginning
, range_end
);
13907 complaint (_("Offset %d is not terminated "
13908 "for DW_AT_ranges attribute"),
13916 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET reading .debug_ranges.
13917 Callback's type should be:
13918 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
13919 Return 1 if the attributes are present and valid, otherwise, return 0. */
13921 template <typename Callback
>
13923 dwarf2_ranges_process (unsigned offset
, struct dwarf2_cu
*cu
, dwarf_tag tag
,
13924 Callback
&&callback
)
13926 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
13927 struct objfile
*objfile
= per_objfile
->objfile
;
13928 struct comp_unit_head
*cu_header
= &cu
->header
;
13929 bfd
*obfd
= objfile
->obfd
;
13930 unsigned int addr_size
= cu_header
->addr_size
;
13931 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
13932 /* Base address selection entry. */
13933 gdb::optional
<CORE_ADDR
> base
;
13934 unsigned int dummy
;
13935 const gdb_byte
*buffer
;
13937 if (cu_header
->version
>= 5)
13938 return dwarf2_rnglists_process (offset
, cu
, tag
, callback
);
13940 base
= cu
->base_address
;
13942 per_objfile
->per_bfd
->ranges
.read (objfile
);
13943 if (offset
>= per_objfile
->per_bfd
->ranges
.size
)
13945 complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
13949 buffer
= per_objfile
->per_bfd
->ranges
.buffer
+ offset
;
13953 CORE_ADDR range_beginning
, range_end
;
13955 range_beginning
= cu
->header
.read_address (obfd
, buffer
, &dummy
);
13956 buffer
+= addr_size
;
13957 range_end
= cu
->header
.read_address (obfd
, buffer
, &dummy
);
13958 buffer
+= addr_size
;
13959 offset
+= 2 * addr_size
;
13961 /* An end of list marker is a pair of zero addresses. */
13962 if (range_beginning
== 0 && range_end
== 0)
13963 /* Found the end of list entry. */
13966 /* Each base address selection entry is a pair of 2 values.
13967 The first is the largest possible address, the second is
13968 the base address. Check for a base address here. */
13969 if ((range_beginning
& mask
) == mask
)
13971 /* If we found the largest possible address, then we already
13972 have the base address in range_end. */
13977 if (!base
.has_value ())
13979 /* We have no valid base address for the ranges
13981 complaint (_("Invalid .debug_ranges data (no base address)"));
13985 if (range_beginning
> range_end
)
13987 /* Inverted range entries are invalid. */
13988 complaint (_("Invalid .debug_ranges data (inverted range)"));
13992 /* Empty range entries have no effect. */
13993 if (range_beginning
== range_end
)
13996 range_beginning
+= *base
;
13997 range_end
+= *base
;
13999 /* A not-uncommon case of bad debug info.
14000 Don't pollute the addrmap with bad data. */
14001 if (range_beginning
== 0
14002 && !per_objfile
->per_bfd
->has_section_at_zero
)
14004 complaint (_(".debug_ranges entry has start address of zero"
14005 " [in module %s]"), objfile_name (objfile
));
14009 callback (range_beginning
, range_end
);
14015 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
14016 Return 1 if the attributes are present and valid, otherwise, return 0.
14017 If RANGES_PST is not NULL we should set up the `psymtabs_addrmap'. */
14020 dwarf2_ranges_read (unsigned offset
, CORE_ADDR
*low_return
,
14021 CORE_ADDR
*high_return
, struct dwarf2_cu
*cu
,
14022 dwarf2_psymtab
*ranges_pst
, dwarf_tag tag
)
14024 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
14025 dwarf2_per_bfd
*per_bfd
= cu
->per_objfile
->per_bfd
;
14026 struct gdbarch
*gdbarch
= objfile
->arch ();
14027 const CORE_ADDR baseaddr
= objfile
->text_section_offset ();
14030 CORE_ADDR high
= 0;
14033 retval
= dwarf2_ranges_process (offset
, cu
, tag
,
14034 [&] (CORE_ADDR range_beginning
, CORE_ADDR range_end
)
14036 if (ranges_pst
!= NULL
)
14041 lowpc
= (gdbarch_adjust_dwarf2_addr (gdbarch
,
14042 range_beginning
+ baseaddr
)
14044 highpc
= (gdbarch_adjust_dwarf2_addr (gdbarch
,
14045 range_end
+ baseaddr
)
14047 addrmap_set_empty (per_bfd
->partial_symtabs
->psymtabs_addrmap
,
14048 lowpc
, highpc
- 1, ranges_pst
);
14051 /* FIXME: This is recording everything as a low-high
14052 segment of consecutive addresses. We should have a
14053 data structure for discontiguous block ranges
14057 low
= range_beginning
;
14063 if (range_beginning
< low
)
14064 low
= range_beginning
;
14065 if (range_end
> high
)
14073 /* If the first entry is an end-of-list marker, the range
14074 describes an empty scope, i.e. no instructions. */
14080 *high_return
= high
;
14084 /* Get low and high pc attributes from a die. See enum pc_bounds_kind
14085 definition for the return value. *LOWPC and *HIGHPC are set iff
14086 neither PC_BOUNDS_NOT_PRESENT nor PC_BOUNDS_INVALID are returned. */
14088 static enum pc_bounds_kind
14089 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
14090 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
,
14091 dwarf2_psymtab
*pst
)
14093 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
14094 struct attribute
*attr
;
14095 struct attribute
*attr_high
;
14097 CORE_ADDR high
= 0;
14098 enum pc_bounds_kind ret
;
14100 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
14103 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
14104 if (attr
!= nullptr)
14106 low
= attr
->as_address ();
14107 high
= attr_high
->as_address ();
14108 if (cu
->header
.version
>= 4 && attr_high
->form_is_constant ())
14112 /* Found high w/o low attribute. */
14113 return PC_BOUNDS_INVALID
;
14115 /* Found consecutive range of addresses. */
14116 ret
= PC_BOUNDS_HIGH_LOW
;
14120 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
14121 if (attr
!= nullptr && attr
->form_is_unsigned ())
14123 /* Offset in the .debug_ranges or .debug_rnglist section (depending
14124 on DWARF version). */
14125 ULONGEST ranges_offset
= attr
->as_unsigned ();
14127 /* See dwarf2_cu::gnu_ranges_base's doc for why we might want to add
14129 if (die
->tag
!= DW_TAG_compile_unit
)
14130 ranges_offset
+= cu
->gnu_ranges_base
;
14132 /* Value of the DW_AT_ranges attribute is the offset in the
14133 .debug_ranges section. */
14134 if (!dwarf2_ranges_read (ranges_offset
, &low
, &high
, cu
, pst
,
14136 return PC_BOUNDS_INVALID
;
14137 /* Found discontinuous range of addresses. */
14138 ret
= PC_BOUNDS_RANGES
;
14141 return PC_BOUNDS_NOT_PRESENT
;
14144 /* partial_die_info::read has also the strict LOW < HIGH requirement. */
14146 return PC_BOUNDS_INVALID
;
14148 /* When using the GNU linker, .gnu.linkonce. sections are used to
14149 eliminate duplicate copies of functions and vtables and such.
14150 The linker will arbitrarily choose one and discard the others.
14151 The AT_*_pc values for such functions refer to local labels in
14152 these sections. If the section from that file was discarded, the
14153 labels are not in the output, so the relocs get a value of 0.
14154 If this is a discarded function, mark the pc bounds as invalid,
14155 so that GDB will ignore it. */
14156 if (low
== 0 && !per_objfile
->per_bfd
->has_section_at_zero
)
14157 return PC_BOUNDS_INVALID
;
14165 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
14166 its low and high PC addresses. Do nothing if these addresses could not
14167 be determined. Otherwise, set LOWPC to the low address if it is smaller,
14168 and HIGHPC to the high address if greater than HIGHPC. */
14171 dwarf2_get_subprogram_pc_bounds (struct die_info
*die
,
14172 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
14173 struct dwarf2_cu
*cu
)
14175 CORE_ADDR low
, high
;
14176 struct die_info
*child
= die
->child
;
14178 if (dwarf2_get_pc_bounds (die
, &low
, &high
, cu
, NULL
) >= PC_BOUNDS_RANGES
)
14180 *lowpc
= std::min (*lowpc
, low
);
14181 *highpc
= std::max (*highpc
, high
);
14184 /* If the language does not allow nested subprograms (either inside
14185 subprograms or lexical blocks), we're done. */
14186 if (cu
->per_cu
->lang
!= language_ada
)
14189 /* Check all the children of the given DIE. If it contains nested
14190 subprograms, then check their pc bounds. Likewise, we need to
14191 check lexical blocks as well, as they may also contain subprogram
14193 while (child
&& child
->tag
)
14195 if (child
->tag
== DW_TAG_subprogram
14196 || child
->tag
== DW_TAG_lexical_block
)
14197 dwarf2_get_subprogram_pc_bounds (child
, lowpc
, highpc
, cu
);
14198 child
= child
->sibling
;
14202 /* Get the low and high pc's represented by the scope DIE, and store
14203 them in *LOWPC and *HIGHPC. If the correct values can't be
14204 determined, set *LOWPC to -1 and *HIGHPC to 0. */
14207 get_scope_pc_bounds (struct die_info
*die
,
14208 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
14209 struct dwarf2_cu
*cu
)
14211 CORE_ADDR best_low
= (CORE_ADDR
) -1;
14212 CORE_ADDR best_high
= (CORE_ADDR
) 0;
14213 CORE_ADDR current_low
, current_high
;
14215 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
, NULL
)
14216 >= PC_BOUNDS_RANGES
)
14218 best_low
= current_low
;
14219 best_high
= current_high
;
14223 struct die_info
*child
= die
->child
;
14225 while (child
&& child
->tag
)
14227 switch (child
->tag
) {
14228 case DW_TAG_subprogram
:
14229 dwarf2_get_subprogram_pc_bounds (child
, &best_low
, &best_high
, cu
);
14231 case DW_TAG_namespace
:
14232 case DW_TAG_module
:
14233 /* FIXME: carlton/2004-01-16: Should we do this for
14234 DW_TAG_class_type/DW_TAG_structure_type, too? I think
14235 that current GCC's always emit the DIEs corresponding
14236 to definitions of methods of classes as children of a
14237 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
14238 the DIEs giving the declarations, which could be
14239 anywhere). But I don't see any reason why the
14240 standards says that they have to be there. */
14241 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
14243 if (current_low
!= ((CORE_ADDR
) -1))
14245 best_low
= std::min (best_low
, current_low
);
14246 best_high
= std::max (best_high
, current_high
);
14254 child
= child
->sibling
;
14259 *highpc
= best_high
;
14262 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
14266 dwarf2_record_block_ranges (struct die_info
*die
, struct block
*block
,
14267 CORE_ADDR baseaddr
, struct dwarf2_cu
*cu
)
14269 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
14270 struct gdbarch
*gdbarch
= objfile
->arch ();
14271 struct attribute
*attr
;
14272 struct attribute
*attr_high
;
14274 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
14277 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
14278 if (attr
!= nullptr)
14280 CORE_ADDR low
= attr
->as_address ();
14281 CORE_ADDR high
= attr_high
->as_address ();
14283 if (cu
->header
.version
>= 4 && attr_high
->form_is_constant ())
14286 low
= gdbarch_adjust_dwarf2_addr (gdbarch
, low
+ baseaddr
);
14287 high
= gdbarch_adjust_dwarf2_addr (gdbarch
, high
+ baseaddr
);
14288 cu
->get_builder ()->record_block_range (block
, low
, high
- 1);
14292 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
14293 if (attr
!= nullptr && attr
->form_is_unsigned ())
14295 /* Offset in the .debug_ranges or .debug_rnglist section (depending
14296 on DWARF version). */
14297 ULONGEST ranges_offset
= attr
->as_unsigned ();
14299 /* See dwarf2_cu::gnu_ranges_base's doc for why we might want to add
14301 if (die
->tag
!= DW_TAG_compile_unit
)
14302 ranges_offset
+= cu
->gnu_ranges_base
;
14304 std::vector
<blockrange
> blockvec
;
14305 dwarf2_ranges_process (ranges_offset
, cu
, die
->tag
,
14306 [&] (CORE_ADDR start
, CORE_ADDR end
)
14310 start
= gdbarch_adjust_dwarf2_addr (gdbarch
, start
);
14311 end
= gdbarch_adjust_dwarf2_addr (gdbarch
, end
);
14312 cu
->get_builder ()->record_block_range (block
, start
, end
- 1);
14313 blockvec
.emplace_back (start
, end
);
14316 BLOCK_RANGES(block
) = make_blockranges (objfile
, blockvec
);
14320 /* Check whether the producer field indicates either of GCC < 4.6, or the
14321 Intel C/C++ compiler, and cache the result in CU. */
14324 check_producer (struct dwarf2_cu
*cu
)
14328 if (cu
->producer
== NULL
)
14330 /* For unknown compilers expect their behavior is DWARF version
14333 GCC started to support .debug_types sections by -gdwarf-4 since
14334 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
14335 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
14336 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
14337 interpreted incorrectly by GDB now - GCC PR debug/48229. */
14339 else if (producer_is_gcc (cu
->producer
, &major
, &minor
))
14341 cu
->producer_is_gxx_lt_4_6
= major
< 4 || (major
== 4 && minor
< 6);
14342 cu
->producer_is_gcc_lt_4_3
= major
< 4 || (major
== 4 && minor
< 3);
14344 else if (producer_is_icc (cu
->producer
, &major
, &minor
))
14346 cu
->producer_is_icc
= true;
14347 cu
->producer_is_icc_lt_14
= major
< 14;
14349 else if (startswith (cu
->producer
, "CodeWarrior S12/L-ISA"))
14350 cu
->producer_is_codewarrior
= true;
14353 /* For other non-GCC compilers, expect their behavior is DWARF version
14357 cu
->checked_producer
= true;
14360 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
14361 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
14362 during 4.6.0 experimental. */
14365 producer_is_gxx_lt_4_6 (struct dwarf2_cu
*cu
)
14367 if (!cu
->checked_producer
)
14368 check_producer (cu
);
14370 return cu
->producer_is_gxx_lt_4_6
;
14374 /* Codewarrior (at least as of version 5.0.40) generates dwarf line information
14375 with incorrect is_stmt attributes. */
14378 producer_is_codewarrior (struct dwarf2_cu
*cu
)
14380 if (!cu
->checked_producer
)
14381 check_producer (cu
);
14383 return cu
->producer_is_codewarrior
;
14386 /* Return the accessibility of DIE, as given by DW_AT_accessibility.
14387 If that attribute is not available, return the appropriate
14390 static enum dwarf_access_attribute
14391 dwarf2_access_attribute (struct die_info
*die
, struct dwarf2_cu
*cu
)
14393 attribute
*attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
14394 if (attr
!= nullptr)
14396 LONGEST value
= attr
->constant_value (-1);
14397 if (value
== DW_ACCESS_public
14398 || value
== DW_ACCESS_protected
14399 || value
== DW_ACCESS_private
)
14400 return (dwarf_access_attribute
) value
;
14401 complaint (_("Unhandled DW_AT_accessibility value (%s)"),
14405 if (cu
->header
.version
< 3 || producer_is_gxx_lt_4_6 (cu
))
14407 /* The default DWARF 2 accessibility for members is public, the default
14408 accessibility for inheritance is private. */
14410 if (die
->tag
!= DW_TAG_inheritance
)
14411 return DW_ACCESS_public
;
14413 return DW_ACCESS_private
;
14417 /* DWARF 3+ defines the default accessibility a different way. The same
14418 rules apply now for DW_TAG_inheritance as for the members and it only
14419 depends on the container kind. */
14421 if (die
->parent
->tag
== DW_TAG_class_type
)
14422 return DW_ACCESS_private
;
14424 return DW_ACCESS_public
;
14428 /* Look for DW_AT_data_member_location or DW_AT_data_bit_offset. Set
14429 *OFFSET to the byte offset. If the attribute was not found return
14430 0, otherwise return 1. If it was found but could not properly be
14431 handled, set *OFFSET to 0. */
14434 handle_member_location (struct die_info
*die
, struct dwarf2_cu
*cu
,
14437 struct attribute
*attr
;
14439 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
14444 /* Note that we do not check for a section offset first here.
14445 This is because DW_AT_data_member_location is new in DWARF 4,
14446 so if we see it, we can assume that a constant form is really
14447 a constant and not a section offset. */
14448 if (attr
->form_is_constant ())
14449 *offset
= attr
->constant_value (0);
14450 else if (attr
->form_is_section_offset ())
14451 dwarf2_complex_location_expr_complaint ();
14452 else if (attr
->form_is_block ())
14453 *offset
= decode_locdesc (attr
->as_block (), cu
);
14455 dwarf2_complex_location_expr_complaint ();
14461 attr
= dwarf2_attr (die
, DW_AT_data_bit_offset
, cu
);
14462 if (attr
!= nullptr)
14464 *offset
= attr
->constant_value (0);
14472 /* Look for DW_AT_data_member_location or DW_AT_data_bit_offset and
14473 store the results in FIELD. */
14476 handle_member_location (struct die_info
*die
, struct dwarf2_cu
*cu
,
14477 struct field
*field
)
14479 struct attribute
*attr
;
14481 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
14484 if (attr
->form_is_constant ())
14486 LONGEST offset
= attr
->constant_value (0);
14487 field
->set_loc_bitpos (offset
* bits_per_byte
);
14489 else if (attr
->form_is_section_offset ())
14490 dwarf2_complex_location_expr_complaint ();
14491 else if (attr
->form_is_block ())
14494 CORE_ADDR offset
= decode_locdesc (attr
->as_block (), cu
, &handled
);
14496 field
->set_loc_bitpos (offset
* bits_per_byte
);
14499 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
14500 struct objfile
*objfile
= per_objfile
->objfile
;
14501 struct dwarf2_locexpr_baton
*dlbaton
14502 = XOBNEW (&objfile
->objfile_obstack
,
14503 struct dwarf2_locexpr_baton
);
14504 dlbaton
->data
= attr
->as_block ()->data
;
14505 dlbaton
->size
= attr
->as_block ()->size
;
14506 /* When using this baton, we want to compute the address
14507 of the field, not the value. This is why
14508 is_reference is set to false here. */
14509 dlbaton
->is_reference
= false;
14510 dlbaton
->per_objfile
= per_objfile
;
14511 dlbaton
->per_cu
= cu
->per_cu
;
14513 field
->set_loc_dwarf_block (dlbaton
);
14517 dwarf2_complex_location_expr_complaint ();
14521 attr
= dwarf2_attr (die
, DW_AT_data_bit_offset
, cu
);
14522 if (attr
!= nullptr)
14523 field
->set_loc_bitpos (attr
->constant_value (0));
14527 /* Add an aggregate field to the field list. */
14530 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
14531 struct dwarf2_cu
*cu
)
14533 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
14534 struct gdbarch
*gdbarch
= objfile
->arch ();
14535 struct nextfield
*new_field
;
14536 struct attribute
*attr
;
14538 const char *fieldname
= "";
14540 if (die
->tag
== DW_TAG_inheritance
)
14542 fip
->baseclasses
.emplace_back ();
14543 new_field
= &fip
->baseclasses
.back ();
14547 fip
->fields
.emplace_back ();
14548 new_field
= &fip
->fields
.back ();
14551 new_field
->offset
= die
->sect_off
;
14553 new_field
->accessibility
= dwarf2_access_attribute (die
, cu
);
14554 if (new_field
->accessibility
!= DW_ACCESS_public
)
14555 fip
->non_public_fields
= true;
14557 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
14558 if (attr
!= nullptr)
14559 new_field
->virtuality
= attr
->as_virtuality ();
14561 new_field
->virtuality
= DW_VIRTUALITY_none
;
14563 fp
= &new_field
->field
;
14565 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
14567 /* Data member other than a C++ static data member. */
14569 /* Get type of field. */
14570 fp
->set_type (die_type (die
, cu
));
14572 fp
->set_loc_bitpos (0);
14574 /* Get bit size of field (zero if none). */
14575 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
14576 if (attr
!= nullptr)
14578 FIELD_BITSIZE (*fp
) = attr
->constant_value (0);
14582 FIELD_BITSIZE (*fp
) = 0;
14585 /* Get bit offset of field. */
14586 handle_member_location (die
, cu
, fp
);
14587 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
14588 if (attr
!= nullptr && attr
->form_is_constant ())
14590 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
)
14592 /* For big endian bits, the DW_AT_bit_offset gives the
14593 additional bit offset from the MSB of the containing
14594 anonymous object to the MSB of the field. We don't
14595 have to do anything special since we don't need to
14596 know the size of the anonymous object. */
14597 fp
->set_loc_bitpos (fp
->loc_bitpos () + attr
->constant_value (0));
14601 /* For little endian bits, compute the bit offset to the
14602 MSB of the anonymous object, subtract off the number of
14603 bits from the MSB of the field to the MSB of the
14604 object, and then subtract off the number of bits of
14605 the field itself. The result is the bit offset of
14606 the LSB of the field. */
14607 int anonymous_size
;
14608 int bit_offset
= attr
->constant_value (0);
14610 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
14611 if (attr
!= nullptr && attr
->form_is_constant ())
14613 /* The size of the anonymous object containing
14614 the bit field is explicit, so use the
14615 indicated size (in bytes). */
14616 anonymous_size
= attr
->constant_value (0);
14620 /* The size of the anonymous object containing
14621 the bit field must be inferred from the type
14622 attribute of the data member containing the
14624 anonymous_size
= TYPE_LENGTH (fp
->type ());
14626 fp
->set_loc_bitpos (fp
->loc_bitpos ()
14627 + anonymous_size
* bits_per_byte
14628 - bit_offset
- FIELD_BITSIZE (*fp
));
14632 /* Get name of field. */
14633 fieldname
= dwarf2_name (die
, cu
);
14634 if (fieldname
== NULL
)
14637 /* The name is already allocated along with this objfile, so we don't
14638 need to duplicate it for the type. */
14639 fp
->set_name (fieldname
);
14641 /* Change accessibility for artificial fields (e.g. virtual table
14642 pointer or virtual base class pointer) to private. */
14643 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
14645 FIELD_ARTIFICIAL (*fp
) = 1;
14646 new_field
->accessibility
= DW_ACCESS_private
;
14647 fip
->non_public_fields
= true;
14650 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
14652 /* C++ static member. */
14654 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
14655 is a declaration, but all versions of G++ as of this writing
14656 (so through at least 3.2.1) incorrectly generate
14657 DW_TAG_variable tags. */
14659 const char *physname
;
14661 /* Get name of field. */
14662 fieldname
= dwarf2_name (die
, cu
);
14663 if (fieldname
== NULL
)
14666 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
14668 /* Only create a symbol if this is an external value.
14669 new_symbol checks this and puts the value in the global symbol
14670 table, which we want. If it is not external, new_symbol
14671 will try to put the value in cu->list_in_scope which is wrong. */
14672 && dwarf2_flag_true_p (die
, DW_AT_external
, cu
))
14674 /* A static const member, not much different than an enum as far as
14675 we're concerned, except that we can support more types. */
14676 new_symbol (die
, NULL
, cu
);
14679 /* Get physical name. */
14680 physname
= dwarf2_physname (fieldname
, die
, cu
);
14682 /* The name is already allocated along with this objfile, so we don't
14683 need to duplicate it for the type. */
14684 fp
->set_loc_physname (physname
? physname
: "");
14685 fp
->set_type (die_type (die
, cu
));
14686 fp
->set_name (fieldname
);
14688 else if (die
->tag
== DW_TAG_inheritance
)
14690 /* C++ base class field. */
14691 handle_member_location (die
, cu
, fp
);
14692 FIELD_BITSIZE (*fp
) = 0;
14693 fp
->set_type (die_type (die
, cu
));
14694 fp
->set_name (fp
->type ()->name ());
14697 gdb_assert_not_reached ("missing case in dwarf2_add_field");
14700 /* Can the type given by DIE define another type? */
14703 type_can_define_types (const struct die_info
*die
)
14707 case DW_TAG_typedef
:
14708 case DW_TAG_class_type
:
14709 case DW_TAG_structure_type
:
14710 case DW_TAG_union_type
:
14711 case DW_TAG_enumeration_type
:
14719 /* Add a type definition defined in the scope of the FIP's class. */
14722 dwarf2_add_type_defn (struct field_info
*fip
, struct die_info
*die
,
14723 struct dwarf2_cu
*cu
)
14725 struct decl_field fp
;
14726 memset (&fp
, 0, sizeof (fp
));
14728 gdb_assert (type_can_define_types (die
));
14730 /* Get name of field. NULL is okay here, meaning an anonymous type. */
14731 fp
.name
= dwarf2_name (die
, cu
);
14732 fp
.type
= read_type_die (die
, cu
);
14734 /* Save accessibility. */
14735 dwarf_access_attribute accessibility
= dwarf2_access_attribute (die
, cu
);
14736 switch (accessibility
)
14738 case DW_ACCESS_public
:
14739 /* The assumed value if neither private nor protected. */
14741 case DW_ACCESS_private
:
14744 case DW_ACCESS_protected
:
14745 fp
.is_protected
= 1;
14749 if (die
->tag
== DW_TAG_typedef
)
14750 fip
->typedef_field_list
.push_back (fp
);
14752 fip
->nested_types_list
.push_back (fp
);
14755 /* A convenience typedef that's used when finding the discriminant
14756 field for a variant part. */
14757 typedef std::unordered_map
<sect_offset
, int, gdb::hash_enum
<sect_offset
>>
14760 /* Compute the discriminant range for a given variant. OBSTACK is
14761 where the results will be stored. VARIANT is the variant to
14762 process. IS_UNSIGNED indicates whether the discriminant is signed
14765 static const gdb::array_view
<discriminant_range
>
14766 convert_variant_range (struct obstack
*obstack
, const variant_field
&variant
,
14769 std::vector
<discriminant_range
> ranges
;
14771 if (variant
.default_branch
)
14774 if (variant
.discr_list_data
== nullptr)
14776 discriminant_range r
14777 = {variant
.discriminant_value
, variant
.discriminant_value
};
14778 ranges
.push_back (r
);
14782 gdb::array_view
<const gdb_byte
> data (variant
.discr_list_data
->data
,
14783 variant
.discr_list_data
->size
);
14784 while (!data
.empty ())
14786 if (data
[0] != DW_DSC_range
&& data
[0] != DW_DSC_label
)
14788 complaint (_("invalid discriminant marker: %d"), data
[0]);
14791 bool is_range
= data
[0] == DW_DSC_range
;
14792 data
= data
.slice (1);
14794 ULONGEST low
, high
;
14795 unsigned int bytes_read
;
14799 complaint (_("DW_AT_discr_list missing low value"));
14803 low
= read_unsigned_leb128 (nullptr, data
.data (), &bytes_read
);
14805 low
= (ULONGEST
) read_signed_leb128 (nullptr, data
.data (),
14807 data
= data
.slice (bytes_read
);
14813 complaint (_("DW_AT_discr_list missing high value"));
14817 high
= read_unsigned_leb128 (nullptr, data
.data (),
14820 high
= (LONGEST
) read_signed_leb128 (nullptr, data
.data (),
14822 data
= data
.slice (bytes_read
);
14827 ranges
.push_back ({ low
, high
});
14831 discriminant_range
*result
= XOBNEWVEC (obstack
, discriminant_range
,
14833 std::copy (ranges
.begin (), ranges
.end (), result
);
14834 return gdb::array_view
<discriminant_range
> (result
, ranges
.size ());
14837 static const gdb::array_view
<variant_part
> create_variant_parts
14838 (struct obstack
*obstack
,
14839 const offset_map_type
&offset_map
,
14840 struct field_info
*fi
,
14841 const std::vector
<variant_part_builder
> &variant_parts
);
14843 /* Fill in a "struct variant" for a given variant field. RESULT is
14844 the variant to fill in. OBSTACK is where any needed allocations
14845 will be done. OFFSET_MAP holds the mapping from section offsets to
14846 fields for the type. FI describes the fields of the type we're
14847 processing. FIELD is the variant field we're converting. */
14850 create_one_variant (variant
&result
, struct obstack
*obstack
,
14851 const offset_map_type
&offset_map
,
14852 struct field_info
*fi
, const variant_field
&field
)
14854 result
.discriminants
= convert_variant_range (obstack
, field
, false);
14855 result
.first_field
= field
.first_field
+ fi
->baseclasses
.size ();
14856 result
.last_field
= field
.last_field
+ fi
->baseclasses
.size ();
14857 result
.parts
= create_variant_parts (obstack
, offset_map
, fi
,
14858 field
.variant_parts
);
14861 /* Fill in a "struct variant_part" for a given variant part. RESULT
14862 is the variant part to fill in. OBSTACK is where any needed
14863 allocations will be done. OFFSET_MAP holds the mapping from
14864 section offsets to fields for the type. FI describes the fields of
14865 the type we're processing. BUILDER is the variant part to be
14869 create_one_variant_part (variant_part
&result
,
14870 struct obstack
*obstack
,
14871 const offset_map_type
&offset_map
,
14872 struct field_info
*fi
,
14873 const variant_part_builder
&builder
)
14875 auto iter
= offset_map
.find (builder
.discriminant_offset
);
14876 if (iter
== offset_map
.end ())
14878 result
.discriminant_index
= -1;
14879 /* Doesn't matter. */
14880 result
.is_unsigned
= false;
14884 result
.discriminant_index
= iter
->second
;
14886 = fi
->fields
[result
.discriminant_index
].field
.type ()->is_unsigned ();
14889 size_t n
= builder
.variants
.size ();
14890 variant
*output
= new (obstack
) variant
[n
];
14891 for (size_t i
= 0; i
< n
; ++i
)
14892 create_one_variant (output
[i
], obstack
, offset_map
, fi
,
14893 builder
.variants
[i
]);
14895 result
.variants
= gdb::array_view
<variant
> (output
, n
);
14898 /* Create a vector of variant parts that can be attached to a type.
14899 OBSTACK is where any needed allocations will be done. OFFSET_MAP
14900 holds the mapping from section offsets to fields for the type. FI
14901 describes the fields of the type we're processing. VARIANT_PARTS
14902 is the vector to convert. */
14904 static const gdb::array_view
<variant_part
>
14905 create_variant_parts (struct obstack
*obstack
,
14906 const offset_map_type
&offset_map
,
14907 struct field_info
*fi
,
14908 const std::vector
<variant_part_builder
> &variant_parts
)
14910 if (variant_parts
.empty ())
14913 size_t n
= variant_parts
.size ();
14914 variant_part
*result
= new (obstack
) variant_part
[n
];
14915 for (size_t i
= 0; i
< n
; ++i
)
14916 create_one_variant_part (result
[i
], obstack
, offset_map
, fi
,
14919 return gdb::array_view
<variant_part
> (result
, n
);
14922 /* Compute the variant part vector for FIP, attaching it to TYPE when
14926 add_variant_property (struct field_info
*fip
, struct type
*type
,
14927 struct dwarf2_cu
*cu
)
14929 /* Map section offsets of fields to their field index. Note the
14930 field index here does not take the number of baseclasses into
14932 offset_map_type offset_map
;
14933 for (int i
= 0; i
< fip
->fields
.size (); ++i
)
14934 offset_map
[fip
->fields
[i
].offset
] = i
;
14936 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
14937 gdb::array_view
<variant_part
> parts
14938 = create_variant_parts (&objfile
->objfile_obstack
, offset_map
, fip
,
14939 fip
->variant_parts
);
14941 struct dynamic_prop prop
;
14942 prop
.set_variant_parts ((gdb::array_view
<variant_part
> *)
14943 obstack_copy (&objfile
->objfile_obstack
, &parts
,
14946 type
->add_dyn_prop (DYN_PROP_VARIANT_PARTS
, prop
);
14949 /* Create the vector of fields, and attach it to the type. */
14952 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
14953 struct dwarf2_cu
*cu
)
14955 int nfields
= fip
->nfields ();
14957 /* Record the field count, allocate space for the array of fields,
14958 and create blank accessibility bitfields if necessary. */
14959 type
->set_num_fields (nfields
);
14961 ((struct field
*) TYPE_ZALLOC (type
, sizeof (struct field
) * nfields
));
14963 if (fip
->non_public_fields
&& cu
->per_cu
->lang
!= language_ada
)
14965 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
14967 TYPE_FIELD_PRIVATE_BITS (type
) =
14968 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
14969 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
14971 TYPE_FIELD_PROTECTED_BITS (type
) =
14972 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
14973 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
14975 TYPE_FIELD_IGNORE_BITS (type
) =
14976 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
14977 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
14980 /* If the type has baseclasses, allocate and clear a bit vector for
14981 TYPE_FIELD_VIRTUAL_BITS. */
14982 if (!fip
->baseclasses
.empty () && cu
->per_cu
->lang
!= language_ada
)
14984 int num_bytes
= B_BYTES (fip
->baseclasses
.size ());
14985 unsigned char *pointer
;
14987 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
14988 pointer
= (unsigned char *) TYPE_ALLOC (type
, num_bytes
);
14989 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
14990 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->baseclasses
.size ());
14991 TYPE_N_BASECLASSES (type
) = fip
->baseclasses
.size ();
14994 if (!fip
->variant_parts
.empty ())
14995 add_variant_property (fip
, type
, cu
);
14997 /* Copy the saved-up fields into the field vector. */
14998 for (int i
= 0; i
< nfields
; ++i
)
15000 struct nextfield
&field
15001 = ((i
< fip
->baseclasses
.size ()) ? fip
->baseclasses
[i
]
15002 : fip
->fields
[i
- fip
->baseclasses
.size ()]);
15004 type
->field (i
) = field
.field
;
15005 switch (field
.accessibility
)
15007 case DW_ACCESS_private
:
15008 if (cu
->per_cu
->lang
!= language_ada
)
15009 SET_TYPE_FIELD_PRIVATE (type
, i
);
15012 case DW_ACCESS_protected
:
15013 if (cu
->per_cu
->lang
!= language_ada
)
15014 SET_TYPE_FIELD_PROTECTED (type
, i
);
15017 case DW_ACCESS_public
:
15021 /* Unknown accessibility. Complain and treat it as public. */
15023 complaint (_("unsupported accessibility %d"),
15024 field
.accessibility
);
15028 if (i
< fip
->baseclasses
.size ())
15030 switch (field
.virtuality
)
15032 case DW_VIRTUALITY_virtual
:
15033 case DW_VIRTUALITY_pure_virtual
:
15034 if (cu
->per_cu
->lang
== language_ada
)
15035 error (_("unexpected virtuality in component of Ada type"));
15036 SET_TYPE_FIELD_VIRTUAL (type
, i
);
15043 /* Return true if this member function is a constructor, false
15047 dwarf2_is_constructor (struct die_info
*die
, struct dwarf2_cu
*cu
)
15049 const char *fieldname
;
15050 const char *type_name
;
15053 if (die
->parent
== NULL
)
15056 if (die
->parent
->tag
!= DW_TAG_structure_type
15057 && die
->parent
->tag
!= DW_TAG_union_type
15058 && die
->parent
->tag
!= DW_TAG_class_type
)
15061 fieldname
= dwarf2_name (die
, cu
);
15062 type_name
= dwarf2_name (die
->parent
, cu
);
15063 if (fieldname
== NULL
|| type_name
== NULL
)
15066 len
= strlen (fieldname
);
15067 return (strncmp (fieldname
, type_name
, len
) == 0
15068 && (type_name
[len
] == '\0' || type_name
[len
] == '<'));
15071 /* Add a member function to the proper fieldlist. */
15074 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
15075 struct type
*type
, struct dwarf2_cu
*cu
)
15077 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
15078 struct attribute
*attr
;
15080 struct fnfieldlist
*flp
= nullptr;
15081 struct fn_field
*fnp
;
15082 const char *fieldname
;
15083 struct type
*this_type
;
15085 if (cu
->per_cu
->lang
== language_ada
)
15086 error (_("unexpected member function in Ada type"));
15088 /* Get name of member function. */
15089 fieldname
= dwarf2_name (die
, cu
);
15090 if (fieldname
== NULL
)
15093 /* Look up member function name in fieldlist. */
15094 for (i
= 0; i
< fip
->fnfieldlists
.size (); i
++)
15096 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
15098 flp
= &fip
->fnfieldlists
[i
];
15103 /* Create a new fnfieldlist if necessary. */
15104 if (flp
== nullptr)
15106 fip
->fnfieldlists
.emplace_back ();
15107 flp
= &fip
->fnfieldlists
.back ();
15108 flp
->name
= fieldname
;
15109 i
= fip
->fnfieldlists
.size () - 1;
15112 /* Create a new member function field and add it to the vector of
15114 flp
->fnfields
.emplace_back ();
15115 fnp
= &flp
->fnfields
.back ();
15117 /* Delay processing of the physname until later. */
15118 if (cu
->per_cu
->lang
== language_cplus
)
15119 add_to_method_list (type
, i
, flp
->fnfields
.size () - 1, fieldname
,
15123 const char *physname
= dwarf2_physname (fieldname
, die
, cu
);
15124 fnp
->physname
= physname
? physname
: "";
15127 fnp
->type
= alloc_type (objfile
);
15128 this_type
= read_type_die (die
, cu
);
15129 if (this_type
&& this_type
->code () == TYPE_CODE_FUNC
)
15131 int nparams
= this_type
->num_fields ();
15133 /* TYPE is the domain of this method, and THIS_TYPE is the type
15134 of the method itself (TYPE_CODE_METHOD). */
15135 smash_to_method_type (fnp
->type
, type
,
15136 TYPE_TARGET_TYPE (this_type
),
15137 this_type
->fields (),
15138 this_type
->num_fields (),
15139 this_type
->has_varargs ());
15141 /* Handle static member functions.
15142 Dwarf2 has no clean way to discern C++ static and non-static
15143 member functions. G++ helps GDB by marking the first
15144 parameter for non-static member functions (which is the this
15145 pointer) as artificial. We obtain this information from
15146 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
15147 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (this_type
, 0) == 0)
15148 fnp
->voffset
= VOFFSET_STATIC
;
15151 complaint (_("member function type missing for '%s'"),
15152 dwarf2_full_name (fieldname
, die
, cu
));
15154 /* Get fcontext from DW_AT_containing_type if present. */
15155 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
15156 fnp
->fcontext
= die_containing_type (die
, cu
);
15158 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
15159 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
15161 /* Get accessibility. */
15162 dwarf_access_attribute accessibility
= dwarf2_access_attribute (die
, cu
);
15163 switch (accessibility
)
15165 case DW_ACCESS_private
:
15166 fnp
->is_private
= 1;
15168 case DW_ACCESS_protected
:
15169 fnp
->is_protected
= 1;
15173 /* Check for artificial methods. */
15174 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
15175 if (attr
&& attr
->as_boolean ())
15176 fnp
->is_artificial
= 1;
15178 /* Check for defaulted methods. */
15179 attr
= dwarf2_attr (die
, DW_AT_defaulted
, cu
);
15180 if (attr
!= nullptr)
15181 fnp
->defaulted
= attr
->defaulted ();
15183 /* Check for deleted methods. */
15184 attr
= dwarf2_attr (die
, DW_AT_deleted
, cu
);
15185 if (attr
!= nullptr && attr
->as_boolean ())
15186 fnp
->is_deleted
= 1;
15188 fnp
->is_constructor
= dwarf2_is_constructor (die
, cu
);
15190 /* Get index in virtual function table if it is a virtual member
15191 function. For older versions of GCC, this is an offset in the
15192 appropriate virtual table, as specified by DW_AT_containing_type.
15193 For everyone else, it is an expression to be evaluated relative
15194 to the object address. */
15196 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
15197 if (attr
!= nullptr)
15199 if (attr
->form_is_block () && attr
->as_block ()->size
> 0)
15201 struct dwarf_block
*block
= attr
->as_block ();
15203 if (block
->data
[0] == DW_OP_constu
)
15205 /* Old-style GCC. */
15206 fnp
->voffset
= decode_locdesc (block
, cu
) + 2;
15208 else if (block
->data
[0] == DW_OP_deref
15209 || (block
->size
> 1
15210 && block
->data
[0] == DW_OP_deref_size
15211 && block
->data
[1] == cu
->header
.addr_size
))
15213 fnp
->voffset
= decode_locdesc (block
, cu
);
15214 if ((fnp
->voffset
% cu
->header
.addr_size
) != 0)
15215 dwarf2_complex_location_expr_complaint ();
15217 fnp
->voffset
/= cu
->header
.addr_size
;
15221 dwarf2_complex_location_expr_complaint ();
15223 if (!fnp
->fcontext
)
15225 /* If there is no `this' field and no DW_AT_containing_type,
15226 we cannot actually find a base class context for the
15228 if (this_type
->num_fields () == 0
15229 || !TYPE_FIELD_ARTIFICIAL (this_type
, 0))
15231 complaint (_("cannot determine context for virtual member "
15232 "function \"%s\" (offset %s)"),
15233 fieldname
, sect_offset_str (die
->sect_off
));
15238 = TYPE_TARGET_TYPE (this_type
->field (0).type ());
15242 else if (attr
->form_is_section_offset ())
15244 dwarf2_complex_location_expr_complaint ();
15248 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
15254 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
15255 if (attr
!= nullptr && attr
->as_virtuality () != DW_VIRTUALITY_none
)
15257 /* GCC does this, as of 2008-08-25; PR debug/37237. */
15258 complaint (_("Member function \"%s\" (offset %s) is virtual "
15259 "but the vtable offset is not specified"),
15260 fieldname
, sect_offset_str (die
->sect_off
));
15261 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15262 TYPE_CPLUS_DYNAMIC (type
) = 1;
15267 /* Create the vector of member function fields, and attach it to the type. */
15270 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
15271 struct dwarf2_cu
*cu
)
15273 if (cu
->per_cu
->lang
== language_ada
)
15274 error (_("unexpected member functions in Ada type"));
15276 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15277 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
15279 sizeof (struct fn_fieldlist
) * fip
->fnfieldlists
.size ());
15281 for (int i
= 0; i
< fip
->fnfieldlists
.size (); i
++)
15283 struct fnfieldlist
&nf
= fip
->fnfieldlists
[i
];
15284 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
15286 TYPE_FN_FIELDLIST_NAME (type
, i
) = nf
.name
;
15287 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = nf
.fnfields
.size ();
15288 fn_flp
->fn_fields
= (struct fn_field
*)
15289 TYPE_ALLOC (type
, sizeof (struct fn_field
) * nf
.fnfields
.size ());
15291 for (int k
= 0; k
< nf
.fnfields
.size (); ++k
)
15292 fn_flp
->fn_fields
[k
] = nf
.fnfields
[k
];
15295 TYPE_NFN_FIELDS (type
) = fip
->fnfieldlists
.size ();
15298 /* Returns non-zero if NAME is the name of a vtable member in CU's
15299 language, zero otherwise. */
15301 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
15303 static const char vptr
[] = "_vptr";
15305 /* Look for the C++ form of the vtable. */
15306 if (startswith (name
, vptr
) && is_cplus_marker (name
[sizeof (vptr
) - 1]))
15312 /* GCC outputs unnamed structures that are really pointers to member
15313 functions, with the ABI-specified layout. If TYPE describes
15314 such a structure, smash it into a member function type.
15316 GCC shouldn't do this; it should just output pointer to member DIEs.
15317 This is GCC PR debug/28767. */
15320 quirk_gcc_member_function_pointer (struct type
*type
, struct objfile
*objfile
)
15322 struct type
*pfn_type
, *self_type
, *new_type
;
15324 /* Check for a structure with no name and two children. */
15325 if (type
->code () != TYPE_CODE_STRUCT
|| type
->num_fields () != 2)
15328 /* Check for __pfn and __delta members. */
15329 if (type
->field (0).name () == NULL
15330 || strcmp (type
->field (0).name (), "__pfn") != 0
15331 || type
->field (1).name () == NULL
15332 || strcmp (type
->field (1).name (), "__delta") != 0)
15335 /* Find the type of the method. */
15336 pfn_type
= type
->field (0).type ();
15337 if (pfn_type
== NULL
15338 || pfn_type
->code () != TYPE_CODE_PTR
15339 || TYPE_TARGET_TYPE (pfn_type
)->code () != TYPE_CODE_FUNC
)
15342 /* Look for the "this" argument. */
15343 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
15344 if (pfn_type
->num_fields () == 0
15345 /* || pfn_type->field (0).type () == NULL */
15346 || pfn_type
->field (0).type ()->code () != TYPE_CODE_PTR
)
15349 self_type
= TYPE_TARGET_TYPE (pfn_type
->field (0).type ());
15350 new_type
= alloc_type (objfile
);
15351 smash_to_method_type (new_type
, self_type
, TYPE_TARGET_TYPE (pfn_type
),
15352 pfn_type
->fields (), pfn_type
->num_fields (),
15353 pfn_type
->has_varargs ());
15354 smash_to_methodptr_type (type
, new_type
);
15357 /* Helper for quirk_ada_thick_pointer. If TYPE is an array type that
15358 requires rewriting, then copy it and return the updated copy.
15359 Otherwise return nullptr. */
15361 static struct type
*
15362 rewrite_array_type (struct type
*type
)
15364 if (type
->code () != TYPE_CODE_ARRAY
)
15367 struct type
*index_type
= type
->index_type ();
15368 range_bounds
*current_bounds
= index_type
->bounds ();
15370 /* Handle multi-dimensional arrays. */
15371 struct type
*new_target
= rewrite_array_type (TYPE_TARGET_TYPE (type
));
15372 if (new_target
== nullptr)
15374 /* Maybe we don't need to rewrite this array. */
15375 if (current_bounds
->low
.kind () == PROP_CONST
15376 && current_bounds
->high
.kind () == PROP_CONST
)
15380 /* Either the target type was rewritten, or the bounds have to be
15381 updated. Either way we want to copy the type and update
15383 struct type
*copy
= copy_type (type
);
15384 int nfields
= copy
->num_fields ();
15386 = ((struct field
*) TYPE_ZALLOC (copy
,
15387 nfields
* sizeof (struct field
)));
15388 memcpy (new_fields
, copy
->fields (), nfields
* sizeof (struct field
));
15389 copy
->set_fields (new_fields
);
15390 if (new_target
!= nullptr)
15391 TYPE_TARGET_TYPE (copy
) = new_target
;
15393 struct type
*index_copy
= copy_type (index_type
);
15394 range_bounds
*bounds
15395 = (struct range_bounds
*) TYPE_ZALLOC (index_copy
,
15396 sizeof (range_bounds
));
15397 *bounds
= *current_bounds
;
15398 bounds
->low
.set_const_val (1);
15399 bounds
->high
.set_const_val (0);
15400 index_copy
->set_bounds (bounds
);
15401 copy
->set_index_type (index_copy
);
15406 /* While some versions of GCC will generate complicated DWARF for an
15407 array (see quirk_ada_thick_pointer), more recent versions were
15408 modified to emit an explicit thick pointer structure. However, in
15409 this case, the array still has DWARF expressions for its ranges,
15410 and these must be ignored. */
15413 quirk_ada_thick_pointer_struct (struct die_info
*die
, struct dwarf2_cu
*cu
,
15416 gdb_assert (cu
->per_cu
->lang
== language_ada
);
15418 /* Check for a structure with two children. */
15419 if (type
->code () != TYPE_CODE_STRUCT
|| type
->num_fields () != 2)
15422 /* Check for P_ARRAY and P_BOUNDS members. */
15423 if (type
->field (0).name () == NULL
15424 || strcmp (type
->field (0).name (), "P_ARRAY") != 0
15425 || type
->field (1).name () == NULL
15426 || strcmp (type
->field (1).name (), "P_BOUNDS") != 0)
15429 /* Make sure we're looking at a pointer to an array. */
15430 if (type
->field (0).type ()->code () != TYPE_CODE_PTR
)
15433 /* The Ada code already knows how to handle these types, so all that
15434 we need to do is turn the bounds into static bounds. However, we
15435 don't want to rewrite existing array or index types in-place,
15436 because those may be referenced in other contexts where this
15437 rewriting is undesirable. */
15438 struct type
*new_ary_type
15439 = rewrite_array_type (TYPE_TARGET_TYPE (type
->field (0).type ()));
15440 if (new_ary_type
!= nullptr)
15441 type
->field (0).set_type (lookup_pointer_type (new_ary_type
));
15444 /* If the DIE has a DW_AT_alignment attribute, return its value, doing
15445 appropriate error checking and issuing complaints if there is a
15449 get_alignment (struct dwarf2_cu
*cu
, struct die_info
*die
)
15451 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_alignment
, cu
);
15453 if (attr
== nullptr)
15456 if (!attr
->form_is_constant ())
15458 complaint (_("DW_AT_alignment must have constant form"
15459 " - DIE at %s [in module %s]"),
15460 sect_offset_str (die
->sect_off
),
15461 objfile_name (cu
->per_objfile
->objfile
));
15465 LONGEST val
= attr
->constant_value (0);
15468 complaint (_("DW_AT_alignment value must not be negative"
15469 " - DIE at %s [in module %s]"),
15470 sect_offset_str (die
->sect_off
),
15471 objfile_name (cu
->per_objfile
->objfile
));
15474 ULONGEST align
= val
;
15478 complaint (_("DW_AT_alignment value must not be zero"
15479 " - DIE at %s [in module %s]"),
15480 sect_offset_str (die
->sect_off
),
15481 objfile_name (cu
->per_objfile
->objfile
));
15484 if ((align
& (align
- 1)) != 0)
15486 complaint (_("DW_AT_alignment value must be a power of 2"
15487 " - DIE at %s [in module %s]"),
15488 sect_offset_str (die
->sect_off
),
15489 objfile_name (cu
->per_objfile
->objfile
));
15496 /* If the DIE has a DW_AT_alignment attribute, use its value to set
15497 the alignment for TYPE. */
15500 maybe_set_alignment (struct dwarf2_cu
*cu
, struct die_info
*die
,
15503 if (!set_type_align (type
, get_alignment (cu
, die
)))
15504 complaint (_("DW_AT_alignment value too large"
15505 " - DIE at %s [in module %s]"),
15506 sect_offset_str (die
->sect_off
),
15507 objfile_name (cu
->per_objfile
->objfile
));
15510 /* Check if the given VALUE is a valid enum dwarf_calling_convention
15511 constant for a type, according to DWARF5 spec, Table 5.5. */
15514 is_valid_DW_AT_calling_convention_for_type (ULONGEST value
)
15519 case DW_CC_pass_by_reference
:
15520 case DW_CC_pass_by_value
:
15524 complaint (_("unrecognized DW_AT_calling_convention value "
15525 "(%s) for a type"), pulongest (value
));
15530 /* Check if the given VALUE is a valid enum dwarf_calling_convention
15531 constant for a subroutine, according to DWARF5 spec, Table 3.3, and
15532 also according to GNU-specific values (see include/dwarf2.h). */
15535 is_valid_DW_AT_calling_convention_for_subroutine (ULONGEST value
)
15540 case DW_CC_program
:
15544 case DW_CC_GNU_renesas_sh
:
15545 case DW_CC_GNU_borland_fastcall_i386
:
15546 case DW_CC_GDB_IBM_OpenCL
:
15550 complaint (_("unrecognized DW_AT_calling_convention value "
15551 "(%s) for a subroutine"), pulongest (value
));
15556 /* Called when we find the DIE that starts a structure or union scope
15557 (definition) to create a type for the structure or union. Fill in
15558 the type's name and general properties; the members will not be
15559 processed until process_structure_scope. A symbol table entry for
15560 the type will also not be done until process_structure_scope (assuming
15561 the type has a name).
15563 NOTE: we need to call these functions regardless of whether or not the
15564 DIE has a DW_AT_name attribute, since it might be an anonymous
15565 structure or union. This gets the type entered into our set of
15566 user defined types. */
15568 static struct type
*
15569 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
15571 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
15573 struct attribute
*attr
;
15576 /* If the definition of this type lives in .debug_types, read that type.
15577 Don't follow DW_AT_specification though, that will take us back up
15578 the chain and we want to go down. */
15579 attr
= die
->attr (DW_AT_signature
);
15580 if (attr
!= nullptr)
15582 type
= get_DW_AT_signature_type (die
, attr
, cu
);
15584 /* The type's CU may not be the same as CU.
15585 Ensure TYPE is recorded with CU in die_type_hash. */
15586 return set_die_type (die
, type
, cu
);
15589 type
= alloc_type (objfile
);
15590 INIT_CPLUS_SPECIFIC (type
);
15592 name
= dwarf2_name (die
, cu
);
15595 if (cu
->per_cu
->lang
== language_cplus
15596 || cu
->per_cu
->lang
== language_d
15597 || cu
->per_cu
->lang
== language_rust
)
15599 const char *full_name
= dwarf2_full_name (name
, die
, cu
);
15601 /* dwarf2_full_name might have already finished building the DIE's
15602 type. If so, there is no need to continue. */
15603 if (get_die_type (die
, cu
) != NULL
)
15604 return get_die_type (die
, cu
);
15606 type
->set_name (full_name
);
15610 /* The name is already allocated along with this objfile, so
15611 we don't need to duplicate it for the type. */
15612 type
->set_name (name
);
15616 if (die
->tag
== DW_TAG_structure_type
)
15618 type
->set_code (TYPE_CODE_STRUCT
);
15620 else if (die
->tag
== DW_TAG_union_type
)
15622 type
->set_code (TYPE_CODE_UNION
);
15626 type
->set_code (TYPE_CODE_STRUCT
);
15629 if (cu
->per_cu
->lang
== language_cplus
&& die
->tag
== DW_TAG_class_type
)
15630 type
->set_is_declared_class (true);
15632 /* Store the calling convention in the type if it's available in
15633 the die. Otherwise the calling convention remains set to
15634 the default value DW_CC_normal. */
15635 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
15636 if (attr
!= nullptr
15637 && is_valid_DW_AT_calling_convention_for_type (attr
->constant_value (0)))
15639 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15640 TYPE_CPLUS_CALLING_CONVENTION (type
)
15641 = (enum dwarf_calling_convention
) (attr
->constant_value (0));
15644 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
15645 if (attr
!= nullptr)
15647 if (attr
->form_is_constant ())
15648 TYPE_LENGTH (type
) = attr
->constant_value (0);
15651 struct dynamic_prop prop
;
15652 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
, cu
->addr_type ()))
15653 type
->add_dyn_prop (DYN_PROP_BYTE_SIZE
, prop
);
15654 TYPE_LENGTH (type
) = 0;
15659 TYPE_LENGTH (type
) = 0;
15662 maybe_set_alignment (cu
, die
, type
);
15664 if (producer_is_icc_lt_14 (cu
) && (TYPE_LENGTH (type
) == 0))
15666 /* ICC<14 does not output the required DW_AT_declaration on
15667 incomplete types, but gives them a size of zero. */
15668 type
->set_is_stub (true);
15671 type
->set_stub_is_supported (true);
15673 if (die_is_declaration (die
, cu
))
15674 type
->set_is_stub (true);
15675 else if (attr
== NULL
&& die
->child
== NULL
15676 && producer_is_realview (cu
->producer
))
15677 /* RealView does not output the required DW_AT_declaration
15678 on incomplete types. */
15679 type
->set_is_stub (true);
15681 /* We need to add the type field to the die immediately so we don't
15682 infinitely recurse when dealing with pointers to the structure
15683 type within the structure itself. */
15684 set_die_type (die
, type
, cu
);
15686 /* set_die_type should be already done. */
15687 set_descriptive_type (type
, die
, cu
);
15692 static void handle_struct_member_die
15693 (struct die_info
*child_die
,
15695 struct field_info
*fi
,
15696 std::vector
<struct symbol
*> *template_args
,
15697 struct dwarf2_cu
*cu
);
15699 /* A helper for handle_struct_member_die that handles
15700 DW_TAG_variant_part. */
15703 handle_variant_part (struct die_info
*die
, struct type
*type
,
15704 struct field_info
*fi
,
15705 std::vector
<struct symbol
*> *template_args
,
15706 struct dwarf2_cu
*cu
)
15708 variant_part_builder
*new_part
;
15709 if (fi
->current_variant_part
== nullptr)
15711 fi
->variant_parts
.emplace_back ();
15712 new_part
= &fi
->variant_parts
.back ();
15714 else if (!fi
->current_variant_part
->processing_variant
)
15716 complaint (_("nested DW_TAG_variant_part seen "
15717 "- DIE at %s [in module %s]"),
15718 sect_offset_str (die
->sect_off
),
15719 objfile_name (cu
->per_objfile
->objfile
));
15724 variant_field
¤t
= fi
->current_variant_part
->variants
.back ();
15725 current
.variant_parts
.emplace_back ();
15726 new_part
= ¤t
.variant_parts
.back ();
15729 /* When we recurse, we want callees to add to this new variant
15731 scoped_restore save_current_variant_part
15732 = make_scoped_restore (&fi
->current_variant_part
, new_part
);
15734 struct attribute
*discr
= dwarf2_attr (die
, DW_AT_discr
, cu
);
15737 /* It's a univariant form, an extension we support. */
15739 else if (discr
->form_is_ref ())
15741 struct dwarf2_cu
*target_cu
= cu
;
15742 struct die_info
*target_die
= follow_die_ref (die
, discr
, &target_cu
);
15744 new_part
->discriminant_offset
= target_die
->sect_off
;
15748 complaint (_("DW_AT_discr does not have DIE reference form"
15749 " - DIE at %s [in module %s]"),
15750 sect_offset_str (die
->sect_off
),
15751 objfile_name (cu
->per_objfile
->objfile
));
15754 for (die_info
*child_die
= die
->child
;
15756 child_die
= child_die
->sibling
)
15757 handle_struct_member_die (child_die
, type
, fi
, template_args
, cu
);
15760 /* A helper for handle_struct_member_die that handles
15764 handle_variant (struct die_info
*die
, struct type
*type
,
15765 struct field_info
*fi
,
15766 std::vector
<struct symbol
*> *template_args
,
15767 struct dwarf2_cu
*cu
)
15769 if (fi
->current_variant_part
== nullptr)
15771 complaint (_("saw DW_TAG_variant outside DW_TAG_variant_part "
15772 "- DIE at %s [in module %s]"),
15773 sect_offset_str (die
->sect_off
),
15774 objfile_name (cu
->per_objfile
->objfile
));
15777 if (fi
->current_variant_part
->processing_variant
)
15779 complaint (_("nested DW_TAG_variant seen "
15780 "- DIE at %s [in module %s]"),
15781 sect_offset_str (die
->sect_off
),
15782 objfile_name (cu
->per_objfile
->objfile
));
15786 scoped_restore save_processing_variant
15787 = make_scoped_restore (&fi
->current_variant_part
->processing_variant
,
15790 fi
->current_variant_part
->variants
.emplace_back ();
15791 variant_field
&variant
= fi
->current_variant_part
->variants
.back ();
15792 variant
.first_field
= fi
->fields
.size ();
15794 /* In a variant we want to get the discriminant and also add a
15795 field for our sole member child. */
15796 struct attribute
*discr
= dwarf2_attr (die
, DW_AT_discr_value
, cu
);
15797 if (discr
== nullptr || !discr
->form_is_constant ())
15799 discr
= dwarf2_attr (die
, DW_AT_discr_list
, cu
);
15800 if (discr
== nullptr || discr
->as_block ()->size
== 0)
15801 variant
.default_branch
= true;
15803 variant
.discr_list_data
= discr
->as_block ();
15806 variant
.discriminant_value
= discr
->constant_value (0);
15808 for (die_info
*variant_child
= die
->child
;
15809 variant_child
!= NULL
;
15810 variant_child
= variant_child
->sibling
)
15811 handle_struct_member_die (variant_child
, type
, fi
, template_args
, cu
);
15813 variant
.last_field
= fi
->fields
.size ();
15816 /* A helper for process_structure_scope that handles a single member
15820 handle_struct_member_die (struct die_info
*child_die
, struct type
*type
,
15821 struct field_info
*fi
,
15822 std::vector
<struct symbol
*> *template_args
,
15823 struct dwarf2_cu
*cu
)
15825 if (child_die
->tag
== DW_TAG_member
15826 || child_die
->tag
== DW_TAG_variable
)
15828 /* NOTE: carlton/2002-11-05: A C++ static data member
15829 should be a DW_TAG_member that is a declaration, but
15830 all versions of G++ as of this writing (so through at
15831 least 3.2.1) incorrectly generate DW_TAG_variable
15832 tags for them instead. */
15833 dwarf2_add_field (fi
, child_die
, cu
);
15835 else if (child_die
->tag
== DW_TAG_subprogram
)
15837 /* Rust doesn't have member functions in the C++ sense.
15838 However, it does emit ordinary functions as children
15839 of a struct DIE. */
15840 if (cu
->per_cu
->lang
== language_rust
)
15841 read_func_scope (child_die
, cu
);
15844 /* C++ member function. */
15845 dwarf2_add_member_fn (fi
, child_die
, type
, cu
);
15848 else if (child_die
->tag
== DW_TAG_inheritance
)
15850 /* C++ base class field. */
15851 dwarf2_add_field (fi
, child_die
, cu
);
15853 else if (type_can_define_types (child_die
))
15854 dwarf2_add_type_defn (fi
, child_die
, cu
);
15855 else if (child_die
->tag
== DW_TAG_template_type_param
15856 || child_die
->tag
== DW_TAG_template_value_param
)
15858 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
15861 template_args
->push_back (arg
);
15863 else if (child_die
->tag
== DW_TAG_variant_part
)
15864 handle_variant_part (child_die
, type
, fi
, template_args
, cu
);
15865 else if (child_die
->tag
== DW_TAG_variant
)
15866 handle_variant (child_die
, type
, fi
, template_args
, cu
);
15869 /* Finish creating a structure or union type, including filling in
15870 its members and creating a symbol for it. */
15873 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
15875 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
15876 struct die_info
*child_die
;
15879 type
= get_die_type (die
, cu
);
15881 type
= read_structure_type (die
, cu
);
15883 bool has_template_parameters
= false;
15884 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
15886 struct field_info fi
;
15887 std::vector
<struct symbol
*> template_args
;
15889 child_die
= die
->child
;
15891 while (child_die
&& child_die
->tag
)
15893 handle_struct_member_die (child_die
, type
, &fi
, &template_args
, cu
);
15894 child_die
= child_die
->sibling
;
15897 /* Attach template arguments to type. */
15898 if (!template_args
.empty ())
15900 has_template_parameters
= true;
15901 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15902 TYPE_N_TEMPLATE_ARGUMENTS (type
) = template_args
.size ();
15903 TYPE_TEMPLATE_ARGUMENTS (type
)
15904 = XOBNEWVEC (&objfile
->objfile_obstack
,
15906 TYPE_N_TEMPLATE_ARGUMENTS (type
));
15907 memcpy (TYPE_TEMPLATE_ARGUMENTS (type
),
15908 template_args
.data (),
15909 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
15910 * sizeof (struct symbol
*)));
15913 /* Attach fields and member functions to the type. */
15914 if (fi
.nfields () > 0)
15915 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
15916 if (!fi
.fnfieldlists
.empty ())
15918 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
15920 /* Get the type which refers to the base class (possibly this
15921 class itself) which contains the vtable pointer for the current
15922 class from the DW_AT_containing_type attribute. This use of
15923 DW_AT_containing_type is a GNU extension. */
15925 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
15927 struct type
*t
= die_containing_type (die
, cu
);
15929 set_type_vptr_basetype (type
, t
);
15934 /* Our own class provides vtbl ptr. */
15935 for (i
= t
->num_fields () - 1;
15936 i
>= TYPE_N_BASECLASSES (t
);
15939 const char *fieldname
= t
->field (i
).name ();
15941 if (is_vtable_name (fieldname
, cu
))
15943 set_type_vptr_fieldno (type
, i
);
15948 /* Complain if virtual function table field not found. */
15949 if (i
< TYPE_N_BASECLASSES (t
))
15950 complaint (_("virtual function table pointer "
15951 "not found when defining class '%s'"),
15952 type
->name () ? type
->name () : "");
15956 set_type_vptr_fieldno (type
, TYPE_VPTR_FIELDNO (t
));
15959 else if (cu
->producer
15960 && startswith (cu
->producer
, "IBM(R) XL C/C++ Advanced Edition"))
15962 /* The IBM XLC compiler does not provide direct indication
15963 of the containing type, but the vtable pointer is
15964 always named __vfp. */
15968 for (i
= type
->num_fields () - 1;
15969 i
>= TYPE_N_BASECLASSES (type
);
15972 if (strcmp (type
->field (i
).name (), "__vfp") == 0)
15974 set_type_vptr_fieldno (type
, i
);
15975 set_type_vptr_basetype (type
, type
);
15982 /* Copy fi.typedef_field_list linked list elements content into the
15983 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
15984 if (!fi
.typedef_field_list
.empty ())
15986 int count
= fi
.typedef_field_list
.size ();
15988 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15989 TYPE_TYPEDEF_FIELD_ARRAY (type
)
15990 = ((struct decl_field
*)
15992 sizeof (TYPE_TYPEDEF_FIELD (type
, 0)) * count
));
15993 TYPE_TYPEDEF_FIELD_COUNT (type
) = count
;
15995 for (int i
= 0; i
< fi
.typedef_field_list
.size (); ++i
)
15996 TYPE_TYPEDEF_FIELD (type
, i
) = fi
.typedef_field_list
[i
];
15999 /* Copy fi.nested_types_list linked list elements content into the
16000 allocated array TYPE_NESTED_TYPES_ARRAY (type). */
16001 if (!fi
.nested_types_list
.empty ()
16002 && cu
->per_cu
->lang
!= language_ada
)
16004 int count
= fi
.nested_types_list
.size ();
16006 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
16007 TYPE_NESTED_TYPES_ARRAY (type
)
16008 = ((struct decl_field
*)
16009 TYPE_ALLOC (type
, sizeof (struct decl_field
) * count
));
16010 TYPE_NESTED_TYPES_COUNT (type
) = count
;
16012 for (int i
= 0; i
< fi
.nested_types_list
.size (); ++i
)
16013 TYPE_NESTED_TYPES_FIELD (type
, i
) = fi
.nested_types_list
[i
];
16017 quirk_gcc_member_function_pointer (type
, objfile
);
16018 if (cu
->per_cu
->lang
== language_rust
&& die
->tag
== DW_TAG_union_type
)
16019 cu
->rust_unions
.push_back (type
);
16020 else if (cu
->per_cu
->lang
== language_ada
)
16021 quirk_ada_thick_pointer_struct (die
, cu
, type
);
16023 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
16024 snapshots) has been known to create a die giving a declaration
16025 for a class that has, as a child, a die giving a definition for a
16026 nested class. So we have to process our children even if the
16027 current die is a declaration. Normally, of course, a declaration
16028 won't have any children at all. */
16030 child_die
= die
->child
;
16032 while (child_die
!= NULL
&& child_die
->tag
)
16034 if (child_die
->tag
== DW_TAG_member
16035 || child_die
->tag
== DW_TAG_variable
16036 || child_die
->tag
== DW_TAG_inheritance
16037 || child_die
->tag
== DW_TAG_template_value_param
16038 || child_die
->tag
== DW_TAG_template_type_param
)
16043 process_die (child_die
, cu
);
16045 child_die
= child_die
->sibling
;
16048 /* Do not consider external references. According to the DWARF standard,
16049 these DIEs are identified by the fact that they have no byte_size
16050 attribute, and a declaration attribute. */
16051 if (dwarf2_attr (die
, DW_AT_byte_size
, cu
) != NULL
16052 || !die_is_declaration (die
, cu
)
16053 || dwarf2_attr (die
, DW_AT_signature
, cu
) != NULL
)
16055 struct symbol
*sym
= new_symbol (die
, type
, cu
);
16057 if (has_template_parameters
)
16059 struct symtab
*symtab
;
16060 if (sym
!= nullptr)
16061 symtab
= symbol_symtab (sym
);
16062 else if (cu
->line_header
!= nullptr)
16064 /* Any related symtab will do. */
16066 = cu
->line_header
->file_names ()[0].symtab
;
16071 complaint (_("could not find suitable "
16072 "symtab for template parameter"
16073 " - DIE at %s [in module %s]"),
16074 sect_offset_str (die
->sect_off
),
16075 objfile_name (objfile
));
16078 if (symtab
!= nullptr)
16080 /* Make sure that the symtab is set on the new symbols.
16081 Even though they don't appear in this symtab directly,
16082 other parts of gdb assume that symbols do, and this is
16083 reasonably true. */
16084 for (int i
= 0; i
< TYPE_N_TEMPLATE_ARGUMENTS (type
); ++i
)
16085 symbol_set_symtab (TYPE_TEMPLATE_ARGUMENT (type
, i
), symtab
);
16091 /* Assuming DIE is an enumeration type, and TYPE is its associated
16092 type, update TYPE using some information only available in DIE's
16093 children. In particular, the fields are computed. */
16096 update_enumeration_type_from_children (struct die_info
*die
,
16098 struct dwarf2_cu
*cu
)
16100 struct die_info
*child_die
;
16101 int unsigned_enum
= 1;
16104 auto_obstack obstack
;
16105 std::vector
<struct field
> fields
;
16107 for (child_die
= die
->child
;
16108 child_die
!= NULL
&& child_die
->tag
;
16109 child_die
= child_die
->sibling
)
16111 struct attribute
*attr
;
16113 const gdb_byte
*bytes
;
16114 struct dwarf2_locexpr_baton
*baton
;
16117 if (child_die
->tag
!= DW_TAG_enumerator
)
16120 attr
= dwarf2_attr (child_die
, DW_AT_const_value
, cu
);
16124 name
= dwarf2_name (child_die
, cu
);
16126 name
= "<anonymous enumerator>";
16128 dwarf2_const_value_attr (attr
, type
, name
, &obstack
, cu
,
16129 &value
, &bytes
, &baton
);
16137 if (count_one_bits_ll (value
) >= 2)
16141 fields
.emplace_back ();
16142 struct field
&field
= fields
.back ();
16143 field
.set_name (dwarf2_physname (name
, child_die
, cu
));
16144 field
.set_loc_enumval (value
);
16147 if (!fields
.empty ())
16149 type
->set_num_fields (fields
.size ());
16152 TYPE_ALLOC (type
, sizeof (struct field
) * fields
.size ()));
16153 memcpy (type
->fields (), fields
.data (),
16154 sizeof (struct field
) * fields
.size ());
16158 type
->set_is_unsigned (true);
16161 type
->set_is_flag_enum (true);
16164 /* Given a DW_AT_enumeration_type die, set its type. We do not
16165 complete the type's fields yet, or create any symbols. */
16167 static struct type
*
16168 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16170 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
16172 struct attribute
*attr
;
16175 /* If the definition of this type lives in .debug_types, read that type.
16176 Don't follow DW_AT_specification though, that will take us back up
16177 the chain and we want to go down. */
16178 attr
= die
->attr (DW_AT_signature
);
16179 if (attr
!= nullptr)
16181 type
= get_DW_AT_signature_type (die
, attr
, cu
);
16183 /* The type's CU may not be the same as CU.
16184 Ensure TYPE is recorded with CU in die_type_hash. */
16185 return set_die_type (die
, type
, cu
);
16188 type
= alloc_type (objfile
);
16190 type
->set_code (TYPE_CODE_ENUM
);
16191 name
= dwarf2_full_name (NULL
, die
, cu
);
16193 type
->set_name (name
);
16195 attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
16198 struct type
*underlying_type
= die_type (die
, cu
);
16200 TYPE_TARGET_TYPE (type
) = underlying_type
;
16203 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16204 if (attr
!= nullptr)
16206 TYPE_LENGTH (type
) = attr
->constant_value (0);
16210 TYPE_LENGTH (type
) = 0;
16213 maybe_set_alignment (cu
, die
, type
);
16215 /* The enumeration DIE can be incomplete. In Ada, any type can be
16216 declared as private in the package spec, and then defined only
16217 inside the package body. Such types are known as Taft Amendment
16218 Types. When another package uses such a type, an incomplete DIE
16219 may be generated by the compiler. */
16220 if (die_is_declaration (die
, cu
))
16221 type
->set_is_stub (true);
16223 /* If this type has an underlying type that is not a stub, then we
16224 may use its attributes. We always use the "unsigned" attribute
16225 in this situation, because ordinarily we guess whether the type
16226 is unsigned -- but the guess can be wrong and the underlying type
16227 can tell us the reality. However, we defer to a local size
16228 attribute if one exists, because this lets the compiler override
16229 the underlying type if needed. */
16230 if (TYPE_TARGET_TYPE (type
) != NULL
&& !TYPE_TARGET_TYPE (type
)->is_stub ())
16232 struct type
*underlying_type
= TYPE_TARGET_TYPE (type
);
16233 underlying_type
= check_typedef (underlying_type
);
16235 type
->set_is_unsigned (underlying_type
->is_unsigned ());
16237 if (TYPE_LENGTH (type
) == 0)
16238 TYPE_LENGTH (type
) = TYPE_LENGTH (underlying_type
);
16240 if (TYPE_RAW_ALIGN (type
) == 0
16241 && TYPE_RAW_ALIGN (underlying_type
) != 0)
16242 set_type_align (type
, TYPE_RAW_ALIGN (underlying_type
));
16245 type
->set_is_declared_class (dwarf2_flag_true_p (die
, DW_AT_enum_class
, cu
));
16247 set_die_type (die
, type
, cu
);
16249 /* Finish the creation of this type by using the enum's children.
16250 Note that, as usual, this must come after set_die_type to avoid
16251 infinite recursion when trying to compute the names of the
16253 update_enumeration_type_from_children (die
, type
, cu
);
16258 /* Given a pointer to a die which begins an enumeration, process all
16259 the dies that define the members of the enumeration, and create the
16260 symbol for the enumeration type.
16262 NOTE: We reverse the order of the element list. */
16265 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
16267 struct type
*this_type
;
16269 this_type
= get_die_type (die
, cu
);
16270 if (this_type
== NULL
)
16271 this_type
= read_enumeration_type (die
, cu
);
16273 if (die
->child
!= NULL
)
16275 struct die_info
*child_die
;
16278 child_die
= die
->child
;
16279 while (child_die
&& child_die
->tag
)
16281 if (child_die
->tag
!= DW_TAG_enumerator
)
16283 process_die (child_die
, cu
);
16287 name
= dwarf2_name (child_die
, cu
);
16289 new_symbol (child_die
, this_type
, cu
);
16292 child_die
= child_die
->sibling
;
16296 /* If we are reading an enum from a .debug_types unit, and the enum
16297 is a declaration, and the enum is not the signatured type in the
16298 unit, then we do not want to add a symbol for it. Adding a
16299 symbol would in some cases obscure the true definition of the
16300 enum, giving users an incomplete type when the definition is
16301 actually available. Note that we do not want to do this for all
16302 enums which are just declarations, because C++0x allows forward
16303 enum declarations. */
16304 if (cu
->per_cu
->is_debug_types
16305 && die_is_declaration (die
, cu
))
16307 struct signatured_type
*sig_type
;
16309 sig_type
= (struct signatured_type
*) cu
->per_cu
;
16310 gdb_assert (to_underlying (sig_type
->type_offset_in_section
) != 0);
16311 if (sig_type
->type_offset_in_section
!= die
->sect_off
)
16315 new_symbol (die
, this_type
, cu
);
16318 /* Helper function for quirk_ada_thick_pointer that examines a bounds
16319 expression for an index type and finds the corresponding field
16320 offset in the hidden "P_BOUNDS" structure. Returns true on success
16321 and updates *FIELD, false if it fails to recognize an
16325 recognize_bound_expression (struct die_info
*die
, enum dwarf_attribute name
,
16326 int *bounds_offset
, struct field
*field
,
16327 struct dwarf2_cu
*cu
)
16329 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
16330 if (attr
== nullptr || !attr
->form_is_block ())
16333 const struct dwarf_block
*block
= attr
->as_block ();
16334 const gdb_byte
*start
= block
->data
;
16335 const gdb_byte
*end
= block
->data
+ block
->size
;
16337 /* The expression to recognize generally looks like:
16339 (DW_OP_push_object_address; DW_OP_plus_uconst: 8; DW_OP_deref;
16340 DW_OP_plus_uconst: 4; DW_OP_deref_size: 4)
16342 However, the second "plus_uconst" may be missing:
16344 (DW_OP_push_object_address; DW_OP_plus_uconst: 8; DW_OP_deref;
16345 DW_OP_deref_size: 4)
16347 This happens when the field is at the start of the structure.
16349 Also, the final deref may not be sized:
16351 (DW_OP_push_object_address; DW_OP_plus_uconst: 4; DW_OP_deref;
16354 This happens when the size of the index type happens to be the
16355 same as the architecture's word size. This can occur with or
16356 without the second plus_uconst. */
16358 if (end
- start
< 2)
16360 if (*start
++ != DW_OP_push_object_address
)
16362 if (*start
++ != DW_OP_plus_uconst
)
16365 uint64_t this_bound_off
;
16366 start
= gdb_read_uleb128 (start
, end
, &this_bound_off
);
16367 if (start
== nullptr || (int) this_bound_off
!= this_bound_off
)
16369 /* Update *BOUNDS_OFFSET if needed, or alternatively verify that it
16370 is consistent among all bounds. */
16371 if (*bounds_offset
== -1)
16372 *bounds_offset
= this_bound_off
;
16373 else if (*bounds_offset
!= this_bound_off
)
16376 if (start
== end
|| *start
++ != DW_OP_deref
)
16382 else if (*start
== DW_OP_deref_size
|| *start
== DW_OP_deref
)
16384 /* This means an offset of 0. */
16386 else if (*start
++ != DW_OP_plus_uconst
)
16390 /* The size is the parameter to DW_OP_plus_uconst. */
16392 start
= gdb_read_uleb128 (start
, end
, &val
);
16393 if (start
== nullptr)
16395 if ((int) val
!= val
)
16404 if (*start
== DW_OP_deref_size
)
16406 start
= gdb_read_uleb128 (start
+ 1, end
, &size
);
16407 if (start
== nullptr)
16410 else if (*start
== DW_OP_deref
)
16412 size
= cu
->header
.addr_size
;
16418 field
->set_loc_bitpos (8 * offset
);
16419 if (size
!= TYPE_LENGTH (field
->type ()))
16420 FIELD_BITSIZE (*field
) = 8 * size
;
16425 /* With -fgnat-encodings=minimal, gcc will emit some unusual DWARF for
16426 some kinds of Ada arrays:
16428 <1><11db>: Abbrev Number: 7 (DW_TAG_array_type)
16429 <11dc> DW_AT_name : (indirect string, offset: 0x1bb8): string
16430 <11e0> DW_AT_data_location: 2 byte block: 97 6
16431 (DW_OP_push_object_address; DW_OP_deref)
16432 <11e3> DW_AT_type : <0x1173>
16433 <11e7> DW_AT_sibling : <0x1201>
16434 <2><11eb>: Abbrev Number: 8 (DW_TAG_subrange_type)
16435 <11ec> DW_AT_type : <0x1206>
16436 <11f0> DW_AT_lower_bound : 6 byte block: 97 23 8 6 94 4
16437 (DW_OP_push_object_address; DW_OP_plus_uconst: 8; DW_OP_deref;
16438 DW_OP_deref_size: 4)
16439 <11f7> DW_AT_upper_bound : 8 byte block: 97 23 8 6 23 4 94 4
16440 (DW_OP_push_object_address; DW_OP_plus_uconst: 8; DW_OP_deref;
16441 DW_OP_plus_uconst: 4; DW_OP_deref_size: 4)
16443 This actually represents a "thick pointer", which is a structure
16444 with two elements: one that is a pointer to the array data, and one
16445 that is a pointer to another structure; this second structure holds
16448 This returns a new type on success, or nullptr if this didn't
16449 recognize the type. */
16451 static struct type
*
16452 quirk_ada_thick_pointer (struct die_info
*die
, struct dwarf2_cu
*cu
,
16455 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_data_location
, cu
);
16456 /* So far we've only seen this with block form. */
16457 if (attr
== nullptr || !attr
->form_is_block ())
16460 /* Note that this will fail if the structure layout is changed by
16461 the compiler. However, we have no good way to recognize some
16462 other layout, because we don't know what expression the compiler
16463 might choose to emit should this happen. */
16464 struct dwarf_block
*blk
= attr
->as_block ();
16466 || blk
->data
[0] != DW_OP_push_object_address
16467 || blk
->data
[1] != DW_OP_deref
)
16470 int bounds_offset
= -1;
16471 int max_align
= -1;
16472 std::vector
<struct field
> range_fields
;
16473 for (struct die_info
*child_die
= die
->child
;
16475 child_die
= child_die
->sibling
)
16477 if (child_die
->tag
== DW_TAG_subrange_type
)
16479 struct type
*underlying
= read_subrange_index_type (child_die
, cu
);
16481 int this_align
= type_align (underlying
);
16482 if (this_align
> max_align
)
16483 max_align
= this_align
;
16485 range_fields
.emplace_back ();
16486 range_fields
.emplace_back ();
16488 struct field
&lower
= range_fields
[range_fields
.size () - 2];
16489 struct field
&upper
= range_fields
[range_fields
.size () - 1];
16491 lower
.set_type (underlying
);
16492 FIELD_ARTIFICIAL (lower
) = 1;
16494 upper
.set_type (underlying
);
16495 FIELD_ARTIFICIAL (upper
) = 1;
16497 if (!recognize_bound_expression (child_die
, DW_AT_lower_bound
,
16498 &bounds_offset
, &lower
, cu
)
16499 || !recognize_bound_expression (child_die
, DW_AT_upper_bound
,
16500 &bounds_offset
, &upper
, cu
))
16505 /* This shouldn't really happen, but double-check that we found
16506 where the bounds are stored. */
16507 if (bounds_offset
== -1)
16510 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
16511 for (int i
= 0; i
< range_fields
.size (); i
+= 2)
16515 /* Set the name of each field in the bounds. */
16516 xsnprintf (name
, sizeof (name
), "LB%d", i
/ 2);
16517 range_fields
[i
].set_name (objfile
->intern (name
));
16518 xsnprintf (name
, sizeof (name
), "UB%d", i
/ 2);
16519 range_fields
[i
+ 1].set_name (objfile
->intern (name
));
16522 struct type
*bounds
= alloc_type (objfile
);
16523 bounds
->set_code (TYPE_CODE_STRUCT
);
16525 bounds
->set_num_fields (range_fields
.size ());
16527 ((struct field
*) TYPE_ALLOC (bounds
, (bounds
->num_fields ()
16528 * sizeof (struct field
))));
16529 memcpy (bounds
->fields (), range_fields
.data (),
16530 bounds
->num_fields () * sizeof (struct field
));
16532 int last_fieldno
= range_fields
.size () - 1;
16533 int bounds_size
= (bounds
->field (last_fieldno
).loc_bitpos () / 8
16534 + TYPE_LENGTH (bounds
->field (last_fieldno
).type ()));
16535 TYPE_LENGTH (bounds
) = align_up (bounds_size
, max_align
);
16537 /* Rewrite the existing array type in place. Specifically, we
16538 remove any dynamic properties we might have read, and we replace
16539 the index types. */
16540 struct type
*iter
= type
;
16541 for (int i
= 0; i
< range_fields
.size (); i
+= 2)
16543 gdb_assert (iter
->code () == TYPE_CODE_ARRAY
);
16544 iter
->main_type
->dyn_prop_list
= nullptr;
16545 iter
->set_index_type
16546 (create_static_range_type (NULL
, bounds
->field (i
).type (), 1, 0));
16547 iter
= TYPE_TARGET_TYPE (iter
);
16550 struct type
*result
= alloc_type (objfile
);
16551 result
->set_code (TYPE_CODE_STRUCT
);
16553 result
->set_num_fields (2);
16555 ((struct field
*) TYPE_ZALLOC (result
, (result
->num_fields ()
16556 * sizeof (struct field
))));
16558 /* The names are chosen to coincide with what the compiler does with
16559 -fgnat-encodings=all, which the Ada code in gdb already
16561 result
->field (0).set_name ("P_ARRAY");
16562 result
->field (0).set_type (lookup_pointer_type (type
));
16564 result
->field (1).set_name ("P_BOUNDS");
16565 result
->field (1).set_type (lookup_pointer_type (bounds
));
16566 result
->field (1).set_loc_bitpos (8 * bounds_offset
);
16568 result
->set_name (type
->name ());
16569 TYPE_LENGTH (result
) = (TYPE_LENGTH (result
->field (0).type ())
16570 + TYPE_LENGTH (result
->field (1).type ()));
16575 /* Extract all information from a DW_TAG_array_type DIE and put it in
16576 the DIE's type field. For now, this only handles one dimensional
16579 static struct type
*
16580 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16582 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
16583 struct die_info
*child_die
;
16585 struct type
*element_type
, *range_type
, *index_type
;
16586 struct attribute
*attr
;
16588 struct dynamic_prop
*byte_stride_prop
= NULL
;
16589 unsigned int bit_stride
= 0;
16591 element_type
= die_type (die
, cu
);
16593 /* The die_type call above may have already set the type for this DIE. */
16594 type
= get_die_type (die
, cu
);
16598 attr
= dwarf2_attr (die
, DW_AT_byte_stride
, cu
);
16602 struct type
*prop_type
= cu
->addr_sized_int_type (false);
16605 = (struct dynamic_prop
*) alloca (sizeof (struct dynamic_prop
));
16606 stride_ok
= attr_to_dynamic_prop (attr
, die
, cu
, byte_stride_prop
,
16610 complaint (_("unable to read array DW_AT_byte_stride "
16611 " - DIE at %s [in module %s]"),
16612 sect_offset_str (die
->sect_off
),
16613 objfile_name (cu
->per_objfile
->objfile
));
16614 /* Ignore this attribute. We will likely not be able to print
16615 arrays of this type correctly, but there is little we can do
16616 to help if we cannot read the attribute's value. */
16617 byte_stride_prop
= NULL
;
16621 attr
= dwarf2_attr (die
, DW_AT_bit_stride
, cu
);
16623 bit_stride
= attr
->constant_value (0);
16625 /* Irix 6.2 native cc creates array types without children for
16626 arrays with unspecified length. */
16627 if (die
->child
== NULL
)
16629 index_type
= objfile_type (objfile
)->builtin_int
;
16630 range_type
= create_static_range_type (NULL
, index_type
, 0, -1);
16631 type
= create_array_type_with_stride (NULL
, element_type
, range_type
,
16632 byte_stride_prop
, bit_stride
);
16633 return set_die_type (die
, type
, cu
);
16636 std::vector
<struct type
*> range_types
;
16637 child_die
= die
->child
;
16638 while (child_die
&& child_die
->tag
)
16640 if (child_die
->tag
== DW_TAG_subrange_type
)
16642 struct type
*child_type
= read_type_die (child_die
, cu
);
16644 if (child_type
!= NULL
)
16646 /* The range type was succesfully read. Save it for the
16647 array type creation. */
16648 range_types
.push_back (child_type
);
16651 child_die
= child_die
->sibling
;
16654 if (range_types
.empty ())
16656 complaint (_("unable to find array range - DIE at %s [in module %s]"),
16657 sect_offset_str (die
->sect_off
),
16658 objfile_name (cu
->per_objfile
->objfile
));
16662 /* Dwarf2 dimensions are output from left to right, create the
16663 necessary array types in backwards order. */
16665 type
= element_type
;
16667 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
16671 while (i
< range_types
.size ())
16673 type
= create_array_type_with_stride (NULL
, type
, range_types
[i
++],
16674 byte_stride_prop
, bit_stride
);
16676 byte_stride_prop
= nullptr;
16681 size_t ndim
= range_types
.size ();
16684 type
= create_array_type_with_stride (NULL
, type
, range_types
[ndim
],
16685 byte_stride_prop
, bit_stride
);
16687 byte_stride_prop
= nullptr;
16691 gdb_assert (type
!= element_type
);
16693 /* Understand Dwarf2 support for vector types (like they occur on
16694 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
16695 array type. This is not part of the Dwarf2/3 standard yet, but a
16696 custom vendor extension. The main difference between a regular
16697 array and the vector variant is that vectors are passed by value
16699 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
16700 if (attr
!= nullptr)
16701 make_vector_type (type
);
16703 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
16704 implementation may choose to implement triple vectors using this
16706 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16707 if (attr
!= nullptr && attr
->form_is_unsigned ())
16709 if (attr
->as_unsigned () >= TYPE_LENGTH (type
))
16710 TYPE_LENGTH (type
) = attr
->as_unsigned ();
16712 complaint (_("DW_AT_byte_size for array type smaller "
16713 "than the total size of elements"));
16716 name
= dwarf2_name (die
, cu
);
16718 type
->set_name (name
);
16720 maybe_set_alignment (cu
, die
, type
);
16722 struct type
*replacement_type
= nullptr;
16723 if (cu
->per_cu
->lang
== language_ada
)
16725 replacement_type
= quirk_ada_thick_pointer (die
, cu
, type
);
16726 if (replacement_type
!= nullptr)
16727 type
= replacement_type
;
16730 /* Install the type in the die. */
16731 set_die_type (die
, type
, cu
, replacement_type
!= nullptr);
16733 /* set_die_type should be already done. */
16734 set_descriptive_type (type
, die
, cu
);
16739 static enum dwarf_array_dim_ordering
16740 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
16742 struct attribute
*attr
;
16744 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
16746 if (attr
!= nullptr)
16748 LONGEST val
= attr
->constant_value (-1);
16749 if (val
== DW_ORD_row_major
|| val
== DW_ORD_col_major
)
16750 return (enum dwarf_array_dim_ordering
) val
;
16753 /* GNU F77 is a special case, as at 08/2004 array type info is the
16754 opposite order to the dwarf2 specification, but data is still
16755 laid out as per normal fortran.
16757 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
16758 version checking. */
16760 if (cu
->per_cu
->lang
== language_fortran
16761 && cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
16763 return DW_ORD_row_major
;
16766 switch (cu
->language_defn
->array_ordering ())
16768 case array_column_major
:
16769 return DW_ORD_col_major
;
16770 case array_row_major
:
16772 return DW_ORD_row_major
;
16776 /* Extract all information from a DW_TAG_set_type DIE and put it in
16777 the DIE's type field. */
16779 static struct type
*
16780 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16782 struct type
*domain_type
, *set_type
;
16783 struct attribute
*attr
;
16785 domain_type
= die_type (die
, cu
);
16787 /* The die_type call above may have already set the type for this DIE. */
16788 set_type
= get_die_type (die
, cu
);
16792 set_type
= create_set_type (NULL
, domain_type
);
16794 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16795 if (attr
!= nullptr && attr
->form_is_unsigned ())
16796 TYPE_LENGTH (set_type
) = attr
->as_unsigned ();
16798 maybe_set_alignment (cu
, die
, set_type
);
16800 return set_die_type (die
, set_type
, cu
);
16803 /* A helper for read_common_block that creates a locexpr baton.
16804 SYM is the symbol which we are marking as computed.
16805 COMMON_DIE is the DIE for the common block.
16806 COMMON_LOC is the location expression attribute for the common
16808 MEMBER_LOC is the location expression attribute for the particular
16809 member of the common block that we are processing.
16810 CU is the CU from which the above come. */
16813 mark_common_block_symbol_computed (struct symbol
*sym
,
16814 struct die_info
*common_die
,
16815 struct attribute
*common_loc
,
16816 struct attribute
*member_loc
,
16817 struct dwarf2_cu
*cu
)
16819 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
16820 struct objfile
*objfile
= per_objfile
->objfile
;
16821 struct dwarf2_locexpr_baton
*baton
;
16823 unsigned int cu_off
;
16824 enum bfd_endian byte_order
= gdbarch_byte_order (objfile
->arch ());
16825 LONGEST offset
= 0;
16827 gdb_assert (common_loc
&& member_loc
);
16828 gdb_assert (common_loc
->form_is_block ());
16829 gdb_assert (member_loc
->form_is_block ()
16830 || member_loc
->form_is_constant ());
16832 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
16833 baton
->per_objfile
= per_objfile
;
16834 baton
->per_cu
= cu
->per_cu
;
16835 gdb_assert (baton
->per_cu
);
16837 baton
->size
= 5 /* DW_OP_call4 */ + 1 /* DW_OP_plus */;
16839 if (member_loc
->form_is_constant ())
16841 offset
= member_loc
->constant_value (0);
16842 baton
->size
+= 1 /* DW_OP_addr */ + cu
->header
.addr_size
;
16845 baton
->size
+= member_loc
->as_block ()->size
;
16847 ptr
= (gdb_byte
*) obstack_alloc (&objfile
->objfile_obstack
, baton
->size
);
16850 *ptr
++ = DW_OP_call4
;
16851 cu_off
= common_die
->sect_off
- cu
->per_cu
->sect_off
;
16852 store_unsigned_integer (ptr
, 4, byte_order
, cu_off
);
16855 if (member_loc
->form_is_constant ())
16857 *ptr
++ = DW_OP_addr
;
16858 store_unsigned_integer (ptr
, cu
->header
.addr_size
, byte_order
, offset
);
16859 ptr
+= cu
->header
.addr_size
;
16863 /* We have to copy the data here, because DW_OP_call4 will only
16864 use a DW_AT_location attribute. */
16865 struct dwarf_block
*block
= member_loc
->as_block ();
16866 memcpy (ptr
, block
->data
, block
->size
);
16867 ptr
+= block
->size
;
16870 *ptr
++ = DW_OP_plus
;
16871 gdb_assert (ptr
- baton
->data
== baton
->size
);
16873 SYMBOL_LOCATION_BATON (sym
) = baton
;
16874 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
16877 /* Create appropriate locally-scoped variables for all the
16878 DW_TAG_common_block entries. Also create a struct common_block
16879 listing all such variables for `info common'. COMMON_BLOCK_DOMAIN
16880 is used to separate the common blocks name namespace from regular
16884 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
16886 struct attribute
*attr
;
16888 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
16889 if (attr
!= nullptr)
16891 /* Support the .debug_loc offsets. */
16892 if (attr
->form_is_block ())
16896 else if (attr
->form_is_section_offset ())
16898 dwarf2_complex_location_expr_complaint ();
16903 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
16904 "common block member");
16909 if (die
->child
!= NULL
)
16911 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
16912 struct die_info
*child_die
;
16913 size_t n_entries
= 0, size
;
16914 struct common_block
*common_block
;
16915 struct symbol
*sym
;
16917 for (child_die
= die
->child
;
16918 child_die
&& child_die
->tag
;
16919 child_die
= child_die
->sibling
)
16922 size
= (sizeof (struct common_block
)
16923 + (n_entries
- 1) * sizeof (struct symbol
*));
16925 = (struct common_block
*) obstack_alloc (&objfile
->objfile_obstack
,
16927 memset (common_block
->contents
, 0, n_entries
* sizeof (struct symbol
*));
16928 common_block
->n_entries
= 0;
16930 for (child_die
= die
->child
;
16931 child_die
&& child_die
->tag
;
16932 child_die
= child_die
->sibling
)
16934 /* Create the symbol in the DW_TAG_common_block block in the current
16936 sym
= new_symbol (child_die
, NULL
, cu
);
16939 struct attribute
*member_loc
;
16941 common_block
->contents
[common_block
->n_entries
++] = sym
;
16943 member_loc
= dwarf2_attr (child_die
, DW_AT_data_member_location
,
16947 /* GDB has handled this for a long time, but it is
16948 not specified by DWARF. It seems to have been
16949 emitted by gfortran at least as recently as:
16950 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=23057. */
16951 complaint (_("Variable in common block has "
16952 "DW_AT_data_member_location "
16953 "- DIE at %s [in module %s]"),
16954 sect_offset_str (child_die
->sect_off
),
16955 objfile_name (objfile
));
16957 if (member_loc
->form_is_section_offset ())
16958 dwarf2_complex_location_expr_complaint ();
16959 else if (member_loc
->form_is_constant ()
16960 || member_loc
->form_is_block ())
16962 if (attr
!= nullptr)
16963 mark_common_block_symbol_computed (sym
, die
, attr
,
16967 dwarf2_complex_location_expr_complaint ();
16972 sym
= new_symbol (die
, objfile_type (objfile
)->builtin_void
, cu
);
16973 SYMBOL_VALUE_COMMON_BLOCK (sym
) = common_block
;
16977 /* Create a type for a C++ namespace. */
16979 static struct type
*
16980 read_namespace_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16982 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
16983 const char *previous_prefix
, *name
;
16987 /* For extensions, reuse the type of the original namespace. */
16988 if (dwarf2_attr (die
, DW_AT_extension
, cu
) != NULL
)
16990 struct die_info
*ext_die
;
16991 struct dwarf2_cu
*ext_cu
= cu
;
16993 ext_die
= dwarf2_extension (die
, &ext_cu
);
16994 type
= read_type_die (ext_die
, ext_cu
);
16996 /* EXT_CU may not be the same as CU.
16997 Ensure TYPE is recorded with CU in die_type_hash. */
16998 return set_die_type (die
, type
, cu
);
17001 name
= namespace_name (die
, &is_anonymous
, cu
);
17003 /* Now build the name of the current namespace. */
17005 previous_prefix
= determine_prefix (die
, cu
);
17006 if (previous_prefix
[0] != '\0')
17007 name
= typename_concat (&objfile
->objfile_obstack
,
17008 previous_prefix
, name
, 0, cu
);
17010 /* Create the type. */
17011 type
= init_type (objfile
, TYPE_CODE_NAMESPACE
, 0, name
);
17013 return set_die_type (die
, type
, cu
);
17016 /* Read a namespace scope. */
17019 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
17021 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17024 /* Add a symbol associated to this if we haven't seen the namespace
17025 before. Also, add a using directive if it's an anonymous
17028 if (dwarf2_attr (die
, DW_AT_extension
, cu
) == NULL
)
17032 type
= read_type_die (die
, cu
);
17033 new_symbol (die
, type
, cu
);
17035 namespace_name (die
, &is_anonymous
, cu
);
17038 const char *previous_prefix
= determine_prefix (die
, cu
);
17040 std::vector
<const char *> excludes
;
17041 add_using_directive (using_directives (cu
),
17042 previous_prefix
, type
->name (), NULL
,
17043 NULL
, excludes
, 0, &objfile
->objfile_obstack
);
17047 if (die
->child
!= NULL
)
17049 struct die_info
*child_die
= die
->child
;
17051 while (child_die
&& child_die
->tag
)
17053 process_die (child_die
, cu
);
17054 child_die
= child_die
->sibling
;
17059 /* Read a Fortran module as type. This DIE can be only a declaration used for
17060 imported module. Still we need that type as local Fortran "use ... only"
17061 declaration imports depend on the created type in determine_prefix. */
17063 static struct type
*
17064 read_module_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17066 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17067 const char *module_name
;
17070 module_name
= dwarf2_name (die
, cu
);
17071 type
= init_type (objfile
, TYPE_CODE_MODULE
, 0, module_name
);
17073 return set_die_type (die
, type
, cu
);
17076 /* Read a Fortran module. */
17079 read_module (struct die_info
*die
, struct dwarf2_cu
*cu
)
17081 struct die_info
*child_die
= die
->child
;
17084 type
= read_type_die (die
, cu
);
17085 new_symbol (die
, type
, cu
);
17087 while (child_die
&& child_die
->tag
)
17089 process_die (child_die
, cu
);
17090 child_die
= child_die
->sibling
;
17094 /* Return the name of the namespace represented by DIE. Set
17095 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
17098 static const char *
17099 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
17101 struct die_info
*current_die
;
17102 const char *name
= NULL
;
17104 /* Loop through the extensions until we find a name. */
17106 for (current_die
= die
;
17107 current_die
!= NULL
;
17108 current_die
= dwarf2_extension (die
, &cu
))
17110 /* We don't use dwarf2_name here so that we can detect the absence
17111 of a name -> anonymous namespace. */
17112 name
= dwarf2_string_attr (die
, DW_AT_name
, cu
);
17118 /* Is it an anonymous namespace? */
17120 *is_anonymous
= (name
== NULL
);
17122 name
= CP_ANONYMOUS_NAMESPACE_STR
;
17127 /* Extract all information from a DW_TAG_pointer_type DIE and add to
17128 the user defined type vector. */
17130 static struct type
*
17131 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17133 struct gdbarch
*gdbarch
= cu
->per_objfile
->objfile
->arch ();
17134 struct comp_unit_head
*cu_header
= &cu
->header
;
17136 struct attribute
*attr_byte_size
;
17137 struct attribute
*attr_address_class
;
17138 int byte_size
, addr_class
;
17139 struct type
*target_type
;
17141 target_type
= die_type (die
, cu
);
17143 /* The die_type call above may have already set the type for this DIE. */
17144 type
= get_die_type (die
, cu
);
17148 type
= lookup_pointer_type (target_type
);
17150 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17151 if (attr_byte_size
)
17152 byte_size
= attr_byte_size
->constant_value (cu_header
->addr_size
);
17154 byte_size
= cu_header
->addr_size
;
17156 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
17157 if (attr_address_class
)
17158 addr_class
= attr_address_class
->constant_value (DW_ADDR_none
);
17160 addr_class
= DW_ADDR_none
;
17162 ULONGEST alignment
= get_alignment (cu
, die
);
17164 /* If the pointer size, alignment, or address class is different
17165 than the default, create a type variant marked as such and set
17166 the length accordingly. */
17167 if (TYPE_LENGTH (type
) != byte_size
17168 || (alignment
!= 0 && TYPE_RAW_ALIGN (type
) != 0
17169 && alignment
!= TYPE_RAW_ALIGN (type
))
17170 || addr_class
!= DW_ADDR_none
)
17172 if (gdbarch_address_class_type_flags_p (gdbarch
))
17174 type_instance_flags type_flags
17175 = gdbarch_address_class_type_flags (gdbarch
, byte_size
,
17177 gdb_assert ((type_flags
& ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
17179 type
= make_type_with_address_space (type
, type_flags
);
17181 else if (TYPE_LENGTH (type
) != byte_size
)
17183 complaint (_("invalid pointer size %d"), byte_size
);
17185 else if (TYPE_RAW_ALIGN (type
) != alignment
)
17187 complaint (_("Invalid DW_AT_alignment"
17188 " - DIE at %s [in module %s]"),
17189 sect_offset_str (die
->sect_off
),
17190 objfile_name (cu
->per_objfile
->objfile
));
17194 /* Should we also complain about unhandled address classes? */
17198 TYPE_LENGTH (type
) = byte_size
;
17199 set_type_align (type
, alignment
);
17200 return set_die_type (die
, type
, cu
);
17203 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
17204 the user defined type vector. */
17206 static struct type
*
17207 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17210 struct type
*to_type
;
17211 struct type
*domain
;
17213 to_type
= die_type (die
, cu
);
17214 domain
= die_containing_type (die
, cu
);
17216 /* The calls above may have already set the type for this DIE. */
17217 type
= get_die_type (die
, cu
);
17221 if (check_typedef (to_type
)->code () == TYPE_CODE_METHOD
)
17222 type
= lookup_methodptr_type (to_type
);
17223 else if (check_typedef (to_type
)->code () == TYPE_CODE_FUNC
)
17225 struct type
*new_type
= alloc_type (cu
->per_objfile
->objfile
);
17227 smash_to_method_type (new_type
, domain
, TYPE_TARGET_TYPE (to_type
),
17228 to_type
->fields (), to_type
->num_fields (),
17229 to_type
->has_varargs ());
17230 type
= lookup_methodptr_type (new_type
);
17233 type
= lookup_memberptr_type (to_type
, domain
);
17235 return set_die_type (die
, type
, cu
);
17238 /* Extract all information from a DW_TAG_{rvalue_,}reference_type DIE and add to
17239 the user defined type vector. */
17241 static struct type
*
17242 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
,
17243 enum type_code refcode
)
17245 struct comp_unit_head
*cu_header
= &cu
->header
;
17246 struct type
*type
, *target_type
;
17247 struct attribute
*attr
;
17249 gdb_assert (refcode
== TYPE_CODE_REF
|| refcode
== TYPE_CODE_RVALUE_REF
);
17251 target_type
= die_type (die
, cu
);
17253 /* The die_type call above may have already set the type for this DIE. */
17254 type
= get_die_type (die
, cu
);
17258 type
= lookup_reference_type (target_type
, refcode
);
17259 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17260 if (attr
!= nullptr)
17262 TYPE_LENGTH (type
) = attr
->constant_value (cu_header
->addr_size
);
17266 TYPE_LENGTH (type
) = cu_header
->addr_size
;
17268 maybe_set_alignment (cu
, die
, type
);
17269 return set_die_type (die
, type
, cu
);
17272 /* Add the given cv-qualifiers to the element type of the array. GCC
17273 outputs DWARF type qualifiers that apply to an array, not the
17274 element type. But GDB relies on the array element type to carry
17275 the cv-qualifiers. This mimics section 6.7.3 of the C99
17278 static struct type
*
17279 add_array_cv_type (struct die_info
*die
, struct dwarf2_cu
*cu
,
17280 struct type
*base_type
, int cnst
, int voltl
)
17282 struct type
*el_type
, *inner_array
;
17284 base_type
= copy_type (base_type
);
17285 inner_array
= base_type
;
17287 while (TYPE_TARGET_TYPE (inner_array
)->code () == TYPE_CODE_ARRAY
)
17289 TYPE_TARGET_TYPE (inner_array
) =
17290 copy_type (TYPE_TARGET_TYPE (inner_array
));
17291 inner_array
= TYPE_TARGET_TYPE (inner_array
);
17294 el_type
= TYPE_TARGET_TYPE (inner_array
);
17295 cnst
|= TYPE_CONST (el_type
);
17296 voltl
|= TYPE_VOLATILE (el_type
);
17297 TYPE_TARGET_TYPE (inner_array
) = make_cv_type (cnst
, voltl
, el_type
, NULL
);
17299 return set_die_type (die
, base_type
, cu
);
17302 static struct type
*
17303 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17305 struct type
*base_type
, *cv_type
;
17307 base_type
= die_type (die
, cu
);
17309 /* The die_type call above may have already set the type for this DIE. */
17310 cv_type
= get_die_type (die
, cu
);
17314 /* In case the const qualifier is applied to an array type, the element type
17315 is so qualified, not the array type (section 6.7.3 of C99). */
17316 if (base_type
->code () == TYPE_CODE_ARRAY
)
17317 return add_array_cv_type (die
, cu
, base_type
, 1, 0);
17319 cv_type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
17320 return set_die_type (die
, cv_type
, cu
);
17323 static struct type
*
17324 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17326 struct type
*base_type
, *cv_type
;
17328 base_type
= die_type (die
, cu
);
17330 /* The die_type call above may have already set the type for this DIE. */
17331 cv_type
= get_die_type (die
, cu
);
17335 /* In case the volatile qualifier is applied to an array type, the
17336 element type is so qualified, not the array type (section 6.7.3
17338 if (base_type
->code () == TYPE_CODE_ARRAY
)
17339 return add_array_cv_type (die
, cu
, base_type
, 0, 1);
17341 cv_type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
17342 return set_die_type (die
, cv_type
, cu
);
17345 /* Handle DW_TAG_restrict_type. */
17347 static struct type
*
17348 read_tag_restrict_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17350 struct type
*base_type
, *cv_type
;
17352 base_type
= die_type (die
, cu
);
17354 /* The die_type call above may have already set the type for this DIE. */
17355 cv_type
= get_die_type (die
, cu
);
17359 cv_type
= make_restrict_type (base_type
);
17360 return set_die_type (die
, cv_type
, cu
);
17363 /* Handle DW_TAG_atomic_type. */
17365 static struct type
*
17366 read_tag_atomic_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17368 struct type
*base_type
, *cv_type
;
17370 base_type
= die_type (die
, cu
);
17372 /* The die_type call above may have already set the type for this DIE. */
17373 cv_type
= get_die_type (die
, cu
);
17377 cv_type
= make_atomic_type (base_type
);
17378 return set_die_type (die
, cv_type
, cu
);
17381 /* Extract all information from a DW_TAG_string_type DIE and add to
17382 the user defined type vector. It isn't really a user defined type,
17383 but it behaves like one, with other DIE's using an AT_user_def_type
17384 attribute to reference it. */
17386 static struct type
*
17387 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17389 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17390 struct gdbarch
*gdbarch
= objfile
->arch ();
17391 struct type
*type
, *range_type
, *index_type
, *char_type
;
17392 struct attribute
*attr
;
17393 struct dynamic_prop prop
;
17394 bool length_is_constant
= true;
17397 /* There are a couple of places where bit sizes might be made use of
17398 when parsing a DW_TAG_string_type, however, no producer that we know
17399 of make use of these. Handling bit sizes that are a multiple of the
17400 byte size is easy enough, but what about other bit sizes? Lets deal
17401 with that problem when we have to. Warn about these attributes being
17402 unsupported, then parse the type and ignore them like we always
17404 if (dwarf2_attr (die
, DW_AT_bit_size
, cu
) != nullptr
17405 || dwarf2_attr (die
, DW_AT_string_length_bit_size
, cu
) != nullptr)
17407 static bool warning_printed
= false;
17408 if (!warning_printed
)
17410 warning (_("DW_AT_bit_size and DW_AT_string_length_bit_size not "
17411 "currently supported on DW_TAG_string_type."));
17412 warning_printed
= true;
17416 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
17417 if (attr
!= nullptr && !attr
->form_is_constant ())
17419 /* The string length describes the location at which the length of
17420 the string can be found. The size of the length field can be
17421 specified with one of the attributes below. */
17422 struct type
*prop_type
;
17423 struct attribute
*len
17424 = dwarf2_attr (die
, DW_AT_string_length_byte_size
, cu
);
17425 if (len
== nullptr)
17426 len
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17427 if (len
!= nullptr && len
->form_is_constant ())
17429 /* Pass 0 as the default as we know this attribute is constant
17430 and the default value will not be returned. */
17431 LONGEST sz
= len
->constant_value (0);
17432 prop_type
= objfile_int_type (objfile
, sz
, true);
17436 /* If the size is not specified then we assume it is the size of
17437 an address on this target. */
17438 prop_type
= cu
->addr_sized_int_type (true);
17441 /* Convert the attribute into a dynamic property. */
17442 if (!attr_to_dynamic_prop (attr
, die
, cu
, &prop
, prop_type
))
17445 length_is_constant
= false;
17447 else if (attr
!= nullptr)
17449 /* This DW_AT_string_length just contains the length with no
17450 indirection. There's no need to create a dynamic property in this
17451 case. Pass 0 for the default value as we know it will not be
17452 returned in this case. */
17453 length
= attr
->constant_value (0);
17455 else if ((attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
)) != nullptr)
17457 /* We don't currently support non-constant byte sizes for strings. */
17458 length
= attr
->constant_value (1);
17462 /* Use 1 as a fallback length if we have nothing else. */
17466 index_type
= objfile_type (objfile
)->builtin_int
;
17467 if (length_is_constant
)
17468 range_type
= create_static_range_type (NULL
, index_type
, 1, length
);
17471 struct dynamic_prop low_bound
;
17473 low_bound
.set_const_val (1);
17474 range_type
= create_range_type (NULL
, index_type
, &low_bound
, &prop
, 0);
17476 char_type
= language_string_char_type (cu
->language_defn
, gdbarch
);
17477 type
= create_string_type (NULL
, char_type
, range_type
);
17479 return set_die_type (die
, type
, cu
);
17482 /* Assuming that DIE corresponds to a function, returns nonzero
17483 if the function is prototyped. */
17486 prototyped_function_p (struct die_info
*die
, struct dwarf2_cu
*cu
)
17488 struct attribute
*attr
;
17490 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
17491 if (attr
&& attr
->as_boolean ())
17494 /* The DWARF standard implies that the DW_AT_prototyped attribute
17495 is only meaningful for C, but the concept also extends to other
17496 languages that allow unprototyped functions (Eg: Objective C).
17497 For all other languages, assume that functions are always
17499 if (cu
->per_cu
->lang
!= language_c
17500 && cu
->per_cu
->lang
!= language_objc
17501 && cu
->per_cu
->lang
!= language_opencl
)
17504 /* RealView does not emit DW_AT_prototyped. We can not distinguish
17505 prototyped and unprototyped functions; default to prototyped,
17506 since that is more common in modern code (and RealView warns
17507 about unprototyped functions). */
17508 if (producer_is_realview (cu
->producer
))
17514 /* Handle DIES due to C code like:
17518 int (*funcp)(int a, long l);
17522 ('funcp' generates a DW_TAG_subroutine_type DIE). */
17524 static struct type
*
17525 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17527 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17528 struct type
*type
; /* Type that this function returns. */
17529 struct type
*ftype
; /* Function that returns above type. */
17530 struct attribute
*attr
;
17532 type
= die_type (die
, cu
);
17534 /* The die_type call above may have already set the type for this DIE. */
17535 ftype
= get_die_type (die
, cu
);
17539 ftype
= lookup_function_type (type
);
17541 if (prototyped_function_p (die
, cu
))
17542 ftype
->set_is_prototyped (true);
17544 /* Store the calling convention in the type if it's available in
17545 the subroutine die. Otherwise set the calling convention to
17546 the default value DW_CC_normal. */
17547 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
17548 if (attr
!= nullptr
17549 && is_valid_DW_AT_calling_convention_for_subroutine (attr
->constant_value (0)))
17550 TYPE_CALLING_CONVENTION (ftype
)
17551 = (enum dwarf_calling_convention
) attr
->constant_value (0);
17552 else if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL"))
17553 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_GDB_IBM_OpenCL
;
17555 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_normal
;
17557 /* Record whether the function returns normally to its caller or not
17558 if the DWARF producer set that information. */
17559 attr
= dwarf2_attr (die
, DW_AT_noreturn
, cu
);
17560 if (attr
&& attr
->as_boolean ())
17561 TYPE_NO_RETURN (ftype
) = 1;
17563 /* We need to add the subroutine type to the die immediately so
17564 we don't infinitely recurse when dealing with parameters
17565 declared as the same subroutine type. */
17566 set_die_type (die
, ftype
, cu
);
17568 if (die
->child
!= NULL
)
17570 struct type
*void_type
= objfile_type (objfile
)->builtin_void
;
17571 struct die_info
*child_die
;
17572 int nparams
, iparams
;
17574 /* Count the number of parameters.
17575 FIXME: GDB currently ignores vararg functions, but knows about
17576 vararg member functions. */
17578 child_die
= die
->child
;
17579 while (child_die
&& child_die
->tag
)
17581 if (child_die
->tag
== DW_TAG_formal_parameter
)
17583 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
17584 ftype
->set_has_varargs (true);
17586 child_die
= child_die
->sibling
;
17589 /* Allocate storage for parameters and fill them in. */
17590 ftype
->set_num_fields (nparams
);
17592 ((struct field
*) TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
)));
17594 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
17595 even if we error out during the parameters reading below. */
17596 for (iparams
= 0; iparams
< nparams
; iparams
++)
17597 ftype
->field (iparams
).set_type (void_type
);
17600 child_die
= die
->child
;
17601 while (child_die
&& child_die
->tag
)
17603 if (child_die
->tag
== DW_TAG_formal_parameter
)
17605 struct type
*arg_type
;
17607 /* DWARF version 2 has no clean way to discern C++
17608 static and non-static member functions. G++ helps
17609 GDB by marking the first parameter for non-static
17610 member functions (which is the this pointer) as
17611 artificial. We pass this information to
17612 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
17614 DWARF version 3 added DW_AT_object_pointer, which GCC
17615 4.5 does not yet generate. */
17616 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
17617 if (attr
!= nullptr)
17618 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = attr
->as_boolean ();
17620 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
17621 arg_type
= die_type (child_die
, cu
);
17623 /* RealView does not mark THIS as const, which the testsuite
17624 expects. GCC marks THIS as const in method definitions,
17625 but not in the class specifications (GCC PR 43053). */
17626 if (cu
->per_cu
->lang
== language_cplus
17627 && !TYPE_CONST (arg_type
)
17628 && TYPE_FIELD_ARTIFICIAL (ftype
, iparams
))
17631 struct dwarf2_cu
*arg_cu
= cu
;
17632 const char *name
= dwarf2_name (child_die
, cu
);
17634 attr
= dwarf2_attr (die
, DW_AT_object_pointer
, cu
);
17635 if (attr
!= nullptr)
17637 /* If the compiler emits this, use it. */
17638 if (follow_die_ref (die
, attr
, &arg_cu
) == child_die
)
17641 else if (name
&& strcmp (name
, "this") == 0)
17642 /* Function definitions will have the argument names. */
17644 else if (name
== NULL
&& iparams
== 0)
17645 /* Declarations may not have the names, so like
17646 elsewhere in GDB, assume an artificial first
17647 argument is "this". */
17651 arg_type
= make_cv_type (1, TYPE_VOLATILE (arg_type
),
17655 ftype
->field (iparams
).set_type (arg_type
);
17658 child_die
= child_die
->sibling
;
17665 static struct type
*
17666 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
17668 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17669 const char *name
= NULL
;
17670 struct type
*this_type
, *target_type
;
17672 name
= dwarf2_full_name (NULL
, die
, cu
);
17673 this_type
= init_type (objfile
, TYPE_CODE_TYPEDEF
, 0, name
);
17674 this_type
->set_target_is_stub (true);
17675 set_die_type (die
, this_type
, cu
);
17676 target_type
= die_type (die
, cu
);
17677 if (target_type
!= this_type
)
17678 TYPE_TARGET_TYPE (this_type
) = target_type
;
17681 /* Self-referential typedefs are, it seems, not allowed by the DWARF
17682 spec and cause infinite loops in GDB. */
17683 complaint (_("Self-referential DW_TAG_typedef "
17684 "- DIE at %s [in module %s]"),
17685 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
17686 TYPE_TARGET_TYPE (this_type
) = NULL
;
17690 /* Gcc-7 and before supports -feliminate-dwarf2-dups, which generates
17691 anonymous typedefs, which is, strictly speaking, invalid DWARF.
17692 Handle these by just returning the target type, rather than
17693 constructing an anonymous typedef type and trying to handle this
17695 set_die_type (die
, target_type
, cu
);
17696 return target_type
;
17701 /* Helper for get_dwarf2_rational_constant that computes the value of
17702 a given gmp_mpz given an attribute. */
17705 get_mpz (struct dwarf2_cu
*cu
, gdb_mpz
*value
, struct attribute
*attr
)
17707 /* GCC will sometimes emit a 16-byte constant value as a DWARF
17708 location expression that pushes an implicit value. */
17709 if (attr
->form
== DW_FORM_exprloc
)
17711 dwarf_block
*blk
= attr
->as_block ();
17712 if (blk
->size
> 0 && blk
->data
[0] == DW_OP_implicit_value
)
17715 const gdb_byte
*ptr
= safe_read_uleb128 (blk
->data
+ 1,
17716 blk
->data
+ blk
->size
,
17718 if (ptr
- blk
->data
+ len
<= blk
->size
)
17720 mpz_import (value
->val
, len
,
17721 bfd_big_endian (cu
->per_objfile
->objfile
->obfd
) ? 1 : -1,
17727 /* On failure set it to 1. */
17728 *value
= gdb_mpz (1);
17730 else if (attr
->form_is_block ())
17732 dwarf_block
*blk
= attr
->as_block ();
17733 mpz_import (value
->val
, blk
->size
,
17734 bfd_big_endian (cu
->per_objfile
->objfile
->obfd
) ? 1 : -1,
17735 1, 0, 0, blk
->data
);
17738 *value
= gdb_mpz (attr
->constant_value (1));
17741 /* Assuming DIE is a rational DW_TAG_constant, read the DIE's
17742 numerator and denominator into NUMERATOR and DENOMINATOR (resp).
17744 If the numerator and/or numerator attribute is missing,
17745 a complaint is filed, and NUMERATOR and DENOMINATOR are left
17749 get_dwarf2_rational_constant (struct die_info
*die
, struct dwarf2_cu
*cu
,
17750 gdb_mpz
*numerator
, gdb_mpz
*denominator
)
17752 struct attribute
*num_attr
, *denom_attr
;
17754 num_attr
= dwarf2_attr (die
, DW_AT_GNU_numerator
, cu
);
17755 if (num_attr
== nullptr)
17756 complaint (_("DW_AT_GNU_numerator missing in %s DIE at %s"),
17757 dwarf_tag_name (die
->tag
), sect_offset_str (die
->sect_off
));
17759 denom_attr
= dwarf2_attr (die
, DW_AT_GNU_denominator
, cu
);
17760 if (denom_attr
== nullptr)
17761 complaint (_("DW_AT_GNU_denominator missing in %s DIE at %s"),
17762 dwarf_tag_name (die
->tag
), sect_offset_str (die
->sect_off
));
17764 if (num_attr
== nullptr || denom_attr
== nullptr)
17767 get_mpz (cu
, numerator
, num_attr
);
17768 get_mpz (cu
, denominator
, denom_attr
);
17771 /* Same as get_dwarf2_rational_constant, but extracting an unsigned
17772 rational constant, rather than a signed one.
17774 If the rational constant has a negative value, a complaint
17775 is filed, and NUMERATOR and DENOMINATOR are left untouched. */
17778 get_dwarf2_unsigned_rational_constant (struct die_info
*die
,
17779 struct dwarf2_cu
*cu
,
17780 gdb_mpz
*numerator
,
17781 gdb_mpz
*denominator
)
17786 get_dwarf2_rational_constant (die
, cu
, &num
, &denom
);
17787 if (mpz_sgn (num
.val
) == -1 && mpz_sgn (denom
.val
) == -1)
17789 mpz_neg (num
.val
, num
.val
);
17790 mpz_neg (denom
.val
, denom
.val
);
17792 else if (mpz_sgn (num
.val
) == -1)
17794 complaint (_("unexpected negative value for DW_AT_GNU_numerator"
17796 sect_offset_str (die
->sect_off
));
17799 else if (mpz_sgn (denom
.val
) == -1)
17801 complaint (_("unexpected negative value for DW_AT_GNU_denominator"
17803 sect_offset_str (die
->sect_off
));
17807 *numerator
= std::move (num
);
17808 *denominator
= std::move (denom
);
17811 /* Assuming that ENCODING is a string whose contents starting at the
17812 K'th character is "_nn" where "nn" is a decimal number, scan that
17813 number and set RESULT to the value. K is updated to point to the
17814 character immediately following the number.
17816 If the string does not conform to the format described above, false
17817 is returned, and K may or may not be changed. */
17820 ada_get_gnat_encoded_number (const char *encoding
, int &k
, gdb_mpz
*result
)
17822 /* The next character should be an underscore ('_') followed
17824 if (encoding
[k
] != '_' || !isdigit (encoding
[k
+ 1]))
17827 /* Skip the underscore. */
17831 /* Determine the number of digits for our number. */
17832 while (isdigit (encoding
[k
]))
17837 std::string
copy (&encoding
[start
], k
- start
);
17838 if (mpz_set_str (result
->val
, copy
.c_str (), 10) == -1)
17844 /* Scan two numbers from ENCODING at OFFSET, assuming the string is of
17845 the form _NN_DD, where NN and DD are decimal numbers. Set NUM and
17846 DENOM, update OFFSET, and return true on success. Return false on
17850 ada_get_gnat_encoded_ratio (const char *encoding
, int &offset
,
17851 gdb_mpz
*num
, gdb_mpz
*denom
)
17853 if (!ada_get_gnat_encoded_number (encoding
, offset
, num
))
17855 return ada_get_gnat_encoded_number (encoding
, offset
, denom
);
17858 /* Assuming DIE corresponds to a fixed point type, finish the creation
17859 of the corresponding TYPE by setting its type-specific data. CU is
17860 the DIE's CU. SUFFIX is the "XF" type name suffix coming from GNAT
17861 encodings. It is nullptr if the GNAT encoding should be
17865 finish_fixed_point_type (struct type
*type
, const char *suffix
,
17866 struct die_info
*die
, struct dwarf2_cu
*cu
)
17868 gdb_assert (type
->code () == TYPE_CODE_FIXED_POINT
17869 && TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_FIXED_POINT
);
17871 /* If GNAT encodings are preferred, don't examine the
17873 struct attribute
*attr
= nullptr;
17874 if (suffix
== nullptr)
17876 attr
= dwarf2_attr (die
, DW_AT_binary_scale
, cu
);
17877 if (attr
== nullptr)
17878 attr
= dwarf2_attr (die
, DW_AT_decimal_scale
, cu
);
17879 if (attr
== nullptr)
17880 attr
= dwarf2_attr (die
, DW_AT_small
, cu
);
17883 /* Numerator and denominator of our fixed-point type's scaling factor.
17884 The default is a scaling factor of 1, which we use as a fallback
17885 when we are not able to decode it (problem with the debugging info,
17886 unsupported forms, bug in GDB, etc...). Using that as the default
17887 allows us to at least print the unscaled value, which might still
17888 be useful to a user. */
17889 gdb_mpz
scale_num (1);
17890 gdb_mpz
scale_denom (1);
17892 if (attr
== nullptr)
17895 if (suffix
!= nullptr
17896 && ada_get_gnat_encoded_ratio (suffix
, offset
, &scale_num
,
17898 /* The number might be encoded as _nn_dd_nn_dd, where the
17899 second ratio is the 'small value. In this situation, we
17900 want the second value. */
17901 && (suffix
[offset
] != '_'
17902 || ada_get_gnat_encoded_ratio (suffix
, offset
, &scale_num
,
17909 /* Scaling factor not found. Assume a scaling factor of 1,
17910 and hope for the best. At least the user will be able to
17911 see the encoded value. */
17914 complaint (_("no scale found for fixed-point type (DIE at %s)"),
17915 sect_offset_str (die
->sect_off
));
17918 else if (attr
->name
== DW_AT_binary_scale
)
17920 LONGEST scale_exp
= attr
->constant_value (0);
17921 gdb_mpz
*num_or_denom
= scale_exp
> 0 ? &scale_num
: &scale_denom
;
17923 mpz_mul_2exp (num_or_denom
->val
, num_or_denom
->val
, std::abs (scale_exp
));
17925 else if (attr
->name
== DW_AT_decimal_scale
)
17927 LONGEST scale_exp
= attr
->constant_value (0);
17928 gdb_mpz
*num_or_denom
= scale_exp
> 0 ? &scale_num
: &scale_denom
;
17930 mpz_ui_pow_ui (num_or_denom
->val
, 10, std::abs (scale_exp
));
17932 else if (attr
->name
== DW_AT_small
)
17934 struct die_info
*scale_die
;
17935 struct dwarf2_cu
*scale_cu
= cu
;
17937 scale_die
= follow_die_ref (die
, attr
, &scale_cu
);
17938 if (scale_die
->tag
== DW_TAG_constant
)
17939 get_dwarf2_unsigned_rational_constant (scale_die
, scale_cu
,
17940 &scale_num
, &scale_denom
);
17942 complaint (_("%s DIE not supported as target of DW_AT_small attribute"
17944 dwarf_tag_name (die
->tag
), sect_offset_str (die
->sect_off
));
17948 complaint (_("unsupported scale attribute %s for fixed-point type"
17950 dwarf_attr_name (attr
->name
),
17951 sect_offset_str (die
->sect_off
));
17954 gdb_mpq
&scaling_factor
= type
->fixed_point_info ().scaling_factor
;
17955 mpz_set (mpq_numref (scaling_factor
.val
), scale_num
.val
);
17956 mpz_set (mpq_denref (scaling_factor
.val
), scale_denom
.val
);
17957 mpq_canonicalize (scaling_factor
.val
);
17960 /* The gnat-encoding suffix for fixed point. */
17962 #define GNAT_FIXED_POINT_SUFFIX "___XF_"
17964 /* If NAME encodes an Ada fixed-point type, return a pointer to the
17965 "XF" suffix of the name. The text after this is what encodes the
17966 'small and 'delta information. Otherwise, return nullptr. */
17968 static const char *
17969 gnat_encoded_fixed_point_type_info (const char *name
)
17971 return strstr (name
, GNAT_FIXED_POINT_SUFFIX
);
17974 /* Allocate a floating-point type of size BITS and name NAME. Pass NAME_HINT
17975 (which may be different from NAME) to the architecture back-end to allow
17976 it to guess the correct format if necessary. */
17978 static struct type
*
17979 dwarf2_init_float_type (struct objfile
*objfile
, int bits
, const char *name
,
17980 const char *name_hint
, enum bfd_endian byte_order
)
17982 struct gdbarch
*gdbarch
= objfile
->arch ();
17983 const struct floatformat
**format
;
17986 format
= gdbarch_floatformat_for_type (gdbarch
, name_hint
, bits
);
17988 type
= init_float_type (objfile
, bits
, name
, format
, byte_order
);
17990 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
, name
);
17995 /* Allocate an integer type of size BITS and name NAME. */
17997 static struct type
*
17998 dwarf2_init_integer_type (struct dwarf2_cu
*cu
, struct objfile
*objfile
,
17999 int bits
, int unsigned_p
, const char *name
)
18003 /* Versions of Intel's C Compiler generate an integer type called "void"
18004 instead of using DW_TAG_unspecified_type. This has been seen on
18005 at least versions 14, 17, and 18. */
18006 if (bits
== 0 && producer_is_icc (cu
) && name
!= nullptr
18007 && strcmp (name
, "void") == 0)
18008 type
= objfile_type (objfile
)->builtin_void
;
18010 type
= init_integer_type (objfile
, bits
, unsigned_p
, name
);
18015 /* Return true if DIE has a DW_AT_small attribute whose value is
18016 a constant rational, where both the numerator and denominator
18019 CU is the DIE's Compilation Unit. */
18022 has_zero_over_zero_small_attribute (struct die_info
*die
,
18023 struct dwarf2_cu
*cu
)
18025 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_small
, cu
);
18026 if (attr
== nullptr)
18029 struct dwarf2_cu
*scale_cu
= cu
;
18030 struct die_info
*scale_die
18031 = follow_die_ref (die
, attr
, &scale_cu
);
18033 if (scale_die
->tag
!= DW_TAG_constant
)
18036 gdb_mpz
num (1), denom (1);
18037 get_dwarf2_rational_constant (scale_die
, cu
, &num
, &denom
);
18038 return mpz_sgn (num
.val
) == 0 && mpz_sgn (denom
.val
) == 0;
18041 /* Initialise and return a floating point type of size BITS suitable for
18042 use as a component of a complex number. The NAME_HINT is passed through
18043 when initialising the floating point type and is the name of the complex
18046 As DWARF doesn't currently provide an explicit name for the components
18047 of a complex number, but it can be helpful to have these components
18048 named, we try to select a suitable name based on the size of the
18050 static struct type
*
18051 dwarf2_init_complex_target_type (struct dwarf2_cu
*cu
,
18052 struct objfile
*objfile
,
18053 int bits
, const char *name_hint
,
18054 enum bfd_endian byte_order
)
18056 gdbarch
*gdbarch
= objfile
->arch ();
18057 struct type
*tt
= nullptr;
18059 /* Try to find a suitable floating point builtin type of size BITS.
18060 We're going to use the name of this type as the name for the complex
18061 target type that we are about to create. */
18062 switch (cu
->per_cu
->lang
)
18064 case language_fortran
:
18068 tt
= builtin_f_type (gdbarch
)->builtin_real
;
18071 tt
= builtin_f_type (gdbarch
)->builtin_real_s8
;
18073 case 96: /* The x86-32 ABI specifies 96-bit long double. */
18075 tt
= builtin_f_type (gdbarch
)->builtin_real_s16
;
18083 tt
= builtin_type (gdbarch
)->builtin_float
;
18086 tt
= builtin_type (gdbarch
)->builtin_double
;
18088 case 96: /* The x86-32 ABI specifies 96-bit long double. */
18090 tt
= builtin_type (gdbarch
)->builtin_long_double
;
18096 /* If the type we found doesn't match the size we were looking for, then
18097 pretend we didn't find a type at all, the complex target type we
18098 create will then be nameless. */
18099 if (tt
!= nullptr && TYPE_LENGTH (tt
) * TARGET_CHAR_BIT
!= bits
)
18102 const char *name
= (tt
== nullptr) ? nullptr : tt
->name ();
18103 return dwarf2_init_float_type (objfile
, bits
, name
, name_hint
, byte_order
);
18106 /* Find a representation of a given base type and install
18107 it in the TYPE field of the die. */
18109 static struct type
*
18110 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18112 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
18114 struct attribute
*attr
;
18115 int encoding
= 0, bits
= 0;
18119 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
18120 if (attr
!= nullptr && attr
->form_is_constant ())
18121 encoding
= attr
->constant_value (0);
18122 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
18123 if (attr
!= nullptr)
18124 bits
= attr
->constant_value (0) * TARGET_CHAR_BIT
;
18125 name
= dwarf2_name (die
, cu
);
18127 complaint (_("DW_AT_name missing from DW_TAG_base_type"));
18129 arch
= objfile
->arch ();
18130 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
18132 attr
= dwarf2_attr (die
, DW_AT_endianity
, cu
);
18133 if (attr
!= nullptr && attr
->form_is_constant ())
18135 int endianity
= attr
->constant_value (0);
18140 byte_order
= BFD_ENDIAN_BIG
;
18142 case DW_END_little
:
18143 byte_order
= BFD_ENDIAN_LITTLE
;
18146 complaint (_("DW_AT_endianity has unrecognized value %d"), endianity
);
18151 if ((encoding
== DW_ATE_signed_fixed
|| encoding
== DW_ATE_unsigned_fixed
)
18152 && cu
->per_cu
->lang
== language_ada
18153 && has_zero_over_zero_small_attribute (die
, cu
))
18155 /* brobecker/2018-02-24: This is a fixed point type for which
18156 the scaling factor is represented as fraction whose value
18157 does not make sense (zero divided by zero), so we should
18158 normally never see these. However, there is a small category
18159 of fixed point types for which GNAT is unable to provide
18160 the scaling factor via the standard DWARF mechanisms, and
18161 for which the info is provided via the GNAT encodings instead.
18162 This is likely what this DIE is about. */
18163 encoding
= (encoding
== DW_ATE_signed_fixed
18165 : DW_ATE_unsigned
);
18168 /* With GNAT encodings, fixed-point information will be encoded in
18169 the type name. Note that this can also occur with the above
18170 zero-over-zero case, which is why this is a separate "if" rather
18171 than an "else if". */
18172 const char *gnat_encoding_suffix
= nullptr;
18173 if ((encoding
== DW_ATE_signed
|| encoding
== DW_ATE_unsigned
)
18174 && cu
->per_cu
->lang
== language_ada
18175 && name
!= nullptr)
18177 gnat_encoding_suffix
= gnat_encoded_fixed_point_type_info (name
);
18178 if (gnat_encoding_suffix
!= nullptr)
18180 gdb_assert (startswith (gnat_encoding_suffix
,
18181 GNAT_FIXED_POINT_SUFFIX
));
18182 name
= obstack_strndup (&cu
->per_objfile
->objfile
->objfile_obstack
,
18183 name
, gnat_encoding_suffix
- name
);
18184 /* Use -1 here so that SUFFIX points at the "_" after the
18186 gnat_encoding_suffix
+= strlen (GNAT_FIXED_POINT_SUFFIX
) - 1;
18188 encoding
= (encoding
== DW_ATE_signed
18189 ? DW_ATE_signed_fixed
18190 : DW_ATE_unsigned_fixed
);
18196 case DW_ATE_address
:
18197 /* Turn DW_ATE_address into a void * pointer. */
18198 type
= init_type (objfile
, TYPE_CODE_VOID
, TARGET_CHAR_BIT
, NULL
);
18199 type
= init_pointer_type (objfile
, bits
, name
, type
);
18201 case DW_ATE_boolean
:
18202 type
= init_boolean_type (objfile
, bits
, 1, name
);
18204 case DW_ATE_complex_float
:
18205 type
= dwarf2_init_complex_target_type (cu
, objfile
, bits
/ 2, name
,
18207 if (type
->code () == TYPE_CODE_ERROR
)
18209 if (name
== nullptr)
18211 struct obstack
*obstack
18212 = &cu
->per_objfile
->objfile
->objfile_obstack
;
18213 name
= obconcat (obstack
, "_Complex ", type
->name (),
18216 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
, name
);
18219 type
= init_complex_type (name
, type
);
18221 case DW_ATE_decimal_float
:
18222 type
= init_decfloat_type (objfile
, bits
, name
);
18225 type
= dwarf2_init_float_type (objfile
, bits
, name
, name
, byte_order
);
18227 case DW_ATE_signed
:
18228 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 0, name
);
18230 case DW_ATE_unsigned
:
18231 if (cu
->per_cu
->lang
== language_fortran
18233 && startswith (name
, "character("))
18234 type
= init_character_type (objfile
, bits
, 1, name
);
18236 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 1, name
);
18238 case DW_ATE_signed_char
:
18239 if (cu
->per_cu
->lang
== language_ada
18240 || cu
->per_cu
->lang
== language_m2
18241 || cu
->per_cu
->lang
== language_pascal
18242 || cu
->per_cu
->lang
== language_fortran
)
18243 type
= init_character_type (objfile
, bits
, 0, name
);
18245 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 0, name
);
18247 case DW_ATE_unsigned_char
:
18248 if (cu
->per_cu
->lang
== language_ada
18249 || cu
->per_cu
->lang
== language_m2
18250 || cu
->per_cu
->lang
== language_pascal
18251 || cu
->per_cu
->lang
== language_fortran
18252 || cu
->per_cu
->lang
== language_rust
)
18253 type
= init_character_type (objfile
, bits
, 1, name
);
18255 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 1, name
);
18260 type
= builtin_type (arch
)->builtin_char16
;
18261 else if (bits
== 32)
18262 type
= builtin_type (arch
)->builtin_char32
;
18265 complaint (_("unsupported DW_ATE_UTF bit size: '%d'"),
18267 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 1, name
);
18269 return set_die_type (die
, type
, cu
);
18272 case DW_ATE_signed_fixed
:
18273 type
= init_fixed_point_type (objfile
, bits
, 0, name
);
18274 finish_fixed_point_type (type
, gnat_encoding_suffix
, die
, cu
);
18276 case DW_ATE_unsigned_fixed
:
18277 type
= init_fixed_point_type (objfile
, bits
, 1, name
);
18278 finish_fixed_point_type (type
, gnat_encoding_suffix
, die
, cu
);
18282 complaint (_("unsupported DW_AT_encoding: '%s'"),
18283 dwarf_type_encoding_name (encoding
));
18284 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
, name
);
18288 if (name
&& strcmp (name
, "char") == 0)
18289 type
->set_has_no_signedness (true);
18291 maybe_set_alignment (cu
, die
, type
);
18293 type
->set_endianity_is_not_default (gdbarch_byte_order (arch
) != byte_order
);
18295 if (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_INT
)
18297 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
18298 if (attr
!= nullptr && attr
->as_unsigned () <= 8 * TYPE_LENGTH (type
))
18300 unsigned real_bit_size
= attr
->as_unsigned ();
18301 attr
= dwarf2_attr (die
, DW_AT_data_bit_offset
, cu
);
18302 /* Only use the attributes if they make sense together. */
18303 if (attr
== nullptr
18304 || (attr
->as_unsigned () + real_bit_size
18305 <= 8 * TYPE_LENGTH (type
)))
18307 TYPE_MAIN_TYPE (type
)->type_specific
.int_stuff
.bit_size
18309 if (attr
!= nullptr)
18310 TYPE_MAIN_TYPE (type
)->type_specific
.int_stuff
.bit_offset
18311 = attr
->as_unsigned ();
18316 return set_die_type (die
, type
, cu
);
18319 /* A helper function that returns the name of DIE, if it refers to a
18320 variable declaration. */
18322 static const char *
18323 var_decl_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
18325 if (die
->tag
!= DW_TAG_variable
)
18328 attribute
*attr
= dwarf2_attr (die
, DW_AT_declaration
, cu
);
18329 if (attr
== nullptr || !attr
->as_boolean ())
18332 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
18333 if (attr
== nullptr)
18335 return attr
->as_string ();
18338 /* Parse dwarf attribute if it's a block, reference or constant and put the
18339 resulting value of the attribute into struct bound_prop.
18340 Returns 1 if ATTR could be resolved into PROP, 0 otherwise. */
18343 attr_to_dynamic_prop (const struct attribute
*attr
, struct die_info
*die
,
18344 struct dwarf2_cu
*cu
, struct dynamic_prop
*prop
,
18345 struct type
*default_type
)
18347 struct dwarf2_property_baton
*baton
;
18348 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
18349 struct objfile
*objfile
= per_objfile
->objfile
;
18350 struct obstack
*obstack
= &objfile
->objfile_obstack
;
18352 gdb_assert (default_type
!= NULL
);
18354 if (attr
== NULL
|| prop
== NULL
)
18357 if (attr
->form_is_block ())
18359 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
18360 baton
->property_type
= default_type
;
18361 baton
->locexpr
.per_cu
= cu
->per_cu
;
18362 baton
->locexpr
.per_objfile
= per_objfile
;
18364 struct dwarf_block
*block
;
18365 if (attr
->form
== DW_FORM_data16
)
18367 size_t data_size
= 16;
18368 block
= XOBNEW (obstack
, struct dwarf_block
);
18369 block
->size
= (data_size
18370 + 2 /* Extra bytes for DW_OP and arg. */);
18371 gdb_byte
*data
= XOBNEWVEC (obstack
, gdb_byte
, block
->size
);
18372 data
[0] = DW_OP_implicit_value
;
18373 data
[1] = data_size
;
18374 memcpy (&data
[2], attr
->as_block ()->data
, data_size
);
18375 block
->data
= data
;
18378 block
= attr
->as_block ();
18380 baton
->locexpr
.size
= block
->size
;
18381 baton
->locexpr
.data
= block
->data
;
18382 switch (attr
->name
)
18384 case DW_AT_string_length
:
18385 baton
->locexpr
.is_reference
= true;
18388 baton
->locexpr
.is_reference
= false;
18392 prop
->set_locexpr (baton
);
18393 gdb_assert (prop
->baton () != NULL
);
18395 else if (attr
->form_is_ref ())
18397 struct dwarf2_cu
*target_cu
= cu
;
18398 struct die_info
*target_die
;
18399 struct attribute
*target_attr
;
18401 target_die
= follow_die_ref (die
, attr
, &target_cu
);
18402 target_attr
= dwarf2_attr (target_die
, DW_AT_location
, target_cu
);
18403 if (target_attr
== NULL
)
18404 target_attr
= dwarf2_attr (target_die
, DW_AT_data_member_location
,
18406 if (target_attr
== nullptr)
18407 target_attr
= dwarf2_attr (target_die
, DW_AT_data_bit_offset
,
18409 if (target_attr
== NULL
)
18411 const char *name
= var_decl_name (target_die
, target_cu
);
18412 if (name
!= nullptr)
18414 prop
->set_variable_name (name
);
18420 switch (target_attr
->name
)
18422 case DW_AT_location
:
18423 if (target_attr
->form_is_section_offset ())
18425 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
18426 baton
->property_type
= die_type (target_die
, target_cu
);
18427 fill_in_loclist_baton (cu
, &baton
->loclist
, target_attr
);
18428 prop
->set_loclist (baton
);
18429 gdb_assert (prop
->baton () != NULL
);
18431 else if (target_attr
->form_is_block ())
18433 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
18434 baton
->property_type
= die_type (target_die
, target_cu
);
18435 baton
->locexpr
.per_cu
= cu
->per_cu
;
18436 baton
->locexpr
.per_objfile
= per_objfile
;
18437 struct dwarf_block
*block
= target_attr
->as_block ();
18438 baton
->locexpr
.size
= block
->size
;
18439 baton
->locexpr
.data
= block
->data
;
18440 baton
->locexpr
.is_reference
= true;
18441 prop
->set_locexpr (baton
);
18442 gdb_assert (prop
->baton () != NULL
);
18446 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
18447 "dynamic property");
18451 case DW_AT_data_member_location
:
18452 case DW_AT_data_bit_offset
:
18456 if (!handle_member_location (target_die
, target_cu
, &offset
))
18459 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
18460 baton
->property_type
= read_type_die (target_die
->parent
,
18462 baton
->offset_info
.offset
= offset
;
18463 baton
->offset_info
.type
= die_type (target_die
, target_cu
);
18464 prop
->set_addr_offset (baton
);
18469 else if (attr
->form_is_constant ())
18470 prop
->set_const_val (attr
->constant_value (0));
18471 else if (attr
->form_is_section_offset ())
18473 switch (attr
->name
)
18475 case DW_AT_string_length
:
18476 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
18477 baton
->property_type
= default_type
;
18478 fill_in_loclist_baton (cu
, &baton
->loclist
, attr
);
18479 prop
->set_loclist (baton
);
18480 gdb_assert (prop
->baton () != NULL
);
18492 dwarf2_invalid_attrib_class_complaint (dwarf_form_name (attr
->form
),
18493 dwarf2_name (die
, cu
));
18499 /* Read the DW_AT_type attribute for a sub-range. If this attribute is not
18500 present (which is valid) then compute the default type based on the
18501 compilation units address size. */
18503 static struct type
*
18504 read_subrange_index_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18506 struct type
*index_type
= die_type (die
, cu
);
18508 /* Dwarf-2 specifications explicitly allows to create subrange types
18509 without specifying a base type.
18510 In that case, the base type must be set to the type of
18511 the lower bound, upper bound or count, in that order, if any of these
18512 three attributes references an object that has a type.
18513 If no base type is found, the Dwarf-2 specifications say that
18514 a signed integer type of size equal to the size of an address should
18516 For the following C code: `extern char gdb_int [];'
18517 GCC produces an empty range DIE.
18518 FIXME: muller/2010-05-28: Possible references to object for low bound,
18519 high bound or count are not yet handled by this code. */
18520 if (index_type
->code () == TYPE_CODE_VOID
)
18521 index_type
= cu
->addr_sized_int_type (false);
18526 /* Read the given DW_AT_subrange DIE. */
18528 static struct type
*
18529 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18531 struct type
*base_type
, *orig_base_type
;
18532 struct type
*range_type
;
18533 struct attribute
*attr
;
18534 struct dynamic_prop low
, high
;
18535 int low_default_is_valid
;
18536 int high_bound_is_count
= 0;
18538 ULONGEST negative_mask
;
18540 orig_base_type
= read_subrange_index_type (die
, cu
);
18542 /* If ORIG_BASE_TYPE is a typedef, it will not be TYPE_UNSIGNED,
18543 whereas the real type might be. So, we use ORIG_BASE_TYPE when
18544 creating the range type, but we use the result of check_typedef
18545 when examining properties of the type. */
18546 base_type
= check_typedef (orig_base_type
);
18548 /* The die_type call above may have already set the type for this DIE. */
18549 range_type
= get_die_type (die
, cu
);
18553 high
.set_const_val (0);
18555 /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
18556 omitting DW_AT_lower_bound. */
18557 switch (cu
->per_cu
->lang
)
18560 case language_cplus
:
18561 low
.set_const_val (0);
18562 low_default_is_valid
= 1;
18564 case language_fortran
:
18565 low
.set_const_val (1);
18566 low_default_is_valid
= 1;
18569 case language_objc
:
18570 case language_rust
:
18571 low
.set_const_val (0);
18572 low_default_is_valid
= (cu
->header
.version
>= 4);
18576 case language_pascal
:
18577 low
.set_const_val (1);
18578 low_default_is_valid
= (cu
->header
.version
>= 4);
18581 low
.set_const_val (0);
18582 low_default_is_valid
= 0;
18586 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
18587 if (attr
!= nullptr)
18588 attr_to_dynamic_prop (attr
, die
, cu
, &low
, base_type
);
18589 else if (!low_default_is_valid
)
18590 complaint (_("Missing DW_AT_lower_bound "
18591 "- DIE at %s [in module %s]"),
18592 sect_offset_str (die
->sect_off
),
18593 objfile_name (cu
->per_objfile
->objfile
));
18595 struct attribute
*attr_ub
, *attr_count
;
18596 attr
= attr_ub
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
18597 if (!attr_to_dynamic_prop (attr
, die
, cu
, &high
, base_type
))
18599 attr
= attr_count
= dwarf2_attr (die
, DW_AT_count
, cu
);
18600 if (attr_to_dynamic_prop (attr
, die
, cu
, &high
, base_type
))
18602 /* If bounds are constant do the final calculation here. */
18603 if (low
.kind () == PROP_CONST
&& high
.kind () == PROP_CONST
)
18604 high
.set_const_val (low
.const_val () + high
.const_val () - 1);
18606 high_bound_is_count
= 1;
18610 if (attr_ub
!= NULL
)
18611 complaint (_("Unresolved DW_AT_upper_bound "
18612 "- DIE at %s [in module %s]"),
18613 sect_offset_str (die
->sect_off
),
18614 objfile_name (cu
->per_objfile
->objfile
));
18615 if (attr_count
!= NULL
)
18616 complaint (_("Unresolved DW_AT_count "
18617 "- DIE at %s [in module %s]"),
18618 sect_offset_str (die
->sect_off
),
18619 objfile_name (cu
->per_objfile
->objfile
));
18624 struct attribute
*bias_attr
= dwarf2_attr (die
, DW_AT_GNU_bias
, cu
);
18625 if (bias_attr
!= nullptr && bias_attr
->form_is_constant ())
18626 bias
= bias_attr
->constant_value (0);
18628 /* Normally, the DWARF producers are expected to use a signed
18629 constant form (Eg. DW_FORM_sdata) to express negative bounds.
18630 But this is unfortunately not always the case, as witnessed
18631 with GCC, for instance, where the ambiguous DW_FORM_dataN form
18632 is used instead. To work around that ambiguity, we treat
18633 the bounds as signed, and thus sign-extend their values, when
18634 the base type is signed. */
18636 -((ULONGEST
) 1 << (TYPE_LENGTH (base_type
) * TARGET_CHAR_BIT
- 1));
18637 if (low
.kind () == PROP_CONST
18638 && !base_type
->is_unsigned () && (low
.const_val () & negative_mask
))
18639 low
.set_const_val (low
.const_val () | negative_mask
);
18640 if (high
.kind () == PROP_CONST
18641 && !base_type
->is_unsigned () && (high
.const_val () & negative_mask
))
18642 high
.set_const_val (high
.const_val () | negative_mask
);
18644 /* Check for bit and byte strides. */
18645 struct dynamic_prop byte_stride_prop
;
18646 attribute
*attr_byte_stride
= dwarf2_attr (die
, DW_AT_byte_stride
, cu
);
18647 if (attr_byte_stride
!= nullptr)
18649 struct type
*prop_type
= cu
->addr_sized_int_type (false);
18650 attr_to_dynamic_prop (attr_byte_stride
, die
, cu
, &byte_stride_prop
,
18654 struct dynamic_prop bit_stride_prop
;
18655 attribute
*attr_bit_stride
= dwarf2_attr (die
, DW_AT_bit_stride
, cu
);
18656 if (attr_bit_stride
!= nullptr)
18658 /* It only makes sense to have either a bit or byte stride. */
18659 if (attr_byte_stride
!= nullptr)
18661 complaint (_("Found DW_AT_bit_stride and DW_AT_byte_stride "
18662 "- DIE at %s [in module %s]"),
18663 sect_offset_str (die
->sect_off
),
18664 objfile_name (cu
->per_objfile
->objfile
));
18665 attr_bit_stride
= nullptr;
18669 struct type
*prop_type
= cu
->addr_sized_int_type (false);
18670 attr_to_dynamic_prop (attr_bit_stride
, die
, cu
, &bit_stride_prop
,
18675 if (attr_byte_stride
!= nullptr
18676 || attr_bit_stride
!= nullptr)
18678 bool byte_stride_p
= (attr_byte_stride
!= nullptr);
18679 struct dynamic_prop
*stride
18680 = byte_stride_p
? &byte_stride_prop
: &bit_stride_prop
;
18683 = create_range_type_with_stride (NULL
, orig_base_type
, &low
,
18684 &high
, bias
, stride
, byte_stride_p
);
18687 range_type
= create_range_type (NULL
, orig_base_type
, &low
, &high
, bias
);
18689 if (high_bound_is_count
)
18690 range_type
->bounds ()->flag_upper_bound_is_count
= 1;
18692 /* Ada expects an empty array on no boundary attributes. */
18693 if (attr
== NULL
&& cu
->per_cu
->lang
!= language_ada
)
18694 range_type
->bounds ()->high
.set_undefined ();
18696 name
= dwarf2_name (die
, cu
);
18698 range_type
->set_name (name
);
18700 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
18701 if (attr
!= nullptr)
18702 TYPE_LENGTH (range_type
) = attr
->constant_value (0);
18704 maybe_set_alignment (cu
, die
, range_type
);
18706 set_die_type (die
, range_type
, cu
);
18708 /* set_die_type should be already done. */
18709 set_descriptive_type (range_type
, die
, cu
);
18714 static struct type
*
18715 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18719 type
= init_type (cu
->per_objfile
->objfile
, TYPE_CODE_VOID
, 0, NULL
);
18720 type
->set_name (dwarf2_name (die
, cu
));
18722 /* In Ada, an unspecified type is typically used when the description
18723 of the type is deferred to a different unit. When encountering
18724 such a type, we treat it as a stub, and try to resolve it later on,
18726 if (cu
->per_cu
->lang
== language_ada
)
18727 type
->set_is_stub (true);
18729 return set_die_type (die
, type
, cu
);
18732 /* Read a single die and all its descendents. Set the die's sibling
18733 field to NULL; set other fields in the die correctly, and set all
18734 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
18735 location of the info_ptr after reading all of those dies. PARENT
18736 is the parent of the die in question. */
18738 static struct die_info
*
18739 read_die_and_children (const struct die_reader_specs
*reader
,
18740 const gdb_byte
*info_ptr
,
18741 const gdb_byte
**new_info_ptr
,
18742 struct die_info
*parent
)
18744 struct die_info
*die
;
18745 const gdb_byte
*cur_ptr
;
18747 cur_ptr
= read_full_die_1 (reader
, &die
, info_ptr
, 0);
18750 *new_info_ptr
= cur_ptr
;
18753 store_in_ref_table (die
, reader
->cu
);
18755 if (die
->has_children
)
18756 die
->child
= read_die_and_siblings_1 (reader
, cur_ptr
, new_info_ptr
, die
);
18760 *new_info_ptr
= cur_ptr
;
18763 die
->sibling
= NULL
;
18764 die
->parent
= parent
;
18768 /* Read a die, all of its descendents, and all of its siblings; set
18769 all of the fields of all of the dies correctly. Arguments are as
18770 in read_die_and_children. */
18772 static struct die_info
*
18773 read_die_and_siblings_1 (const struct die_reader_specs
*reader
,
18774 const gdb_byte
*info_ptr
,
18775 const gdb_byte
**new_info_ptr
,
18776 struct die_info
*parent
)
18778 struct die_info
*first_die
, *last_sibling
;
18779 const gdb_byte
*cur_ptr
;
18781 cur_ptr
= info_ptr
;
18782 first_die
= last_sibling
= NULL
;
18786 struct die_info
*die
18787 = read_die_and_children (reader
, cur_ptr
, &cur_ptr
, parent
);
18791 *new_info_ptr
= cur_ptr
;
18798 last_sibling
->sibling
= die
;
18800 last_sibling
= die
;
18804 /* Read a die, all of its descendents, and all of its siblings; set
18805 all of the fields of all of the dies correctly. Arguments are as
18806 in read_die_and_children.
18807 This the main entry point for reading a DIE and all its children. */
18809 static struct die_info
*
18810 read_die_and_siblings (const struct die_reader_specs
*reader
,
18811 const gdb_byte
*info_ptr
,
18812 const gdb_byte
**new_info_ptr
,
18813 struct die_info
*parent
)
18815 struct die_info
*die
= read_die_and_siblings_1 (reader
, info_ptr
,
18816 new_info_ptr
, parent
);
18818 if (dwarf_die_debug
)
18820 fprintf_unfiltered (gdb_stdlog
,
18821 "Read die from %s@0x%x of %s:\n",
18822 reader
->die_section
->get_name (),
18823 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
18824 bfd_get_filename (reader
->abfd
));
18825 dump_die (die
, dwarf_die_debug
);
18831 /* Read a die and all its attributes, leave space for NUM_EXTRA_ATTRS
18833 The caller is responsible for filling in the extra attributes
18834 and updating (*DIEP)->num_attrs.
18835 Set DIEP to point to a newly allocated die with its information,
18836 except for its child, sibling, and parent fields. */
18838 static const gdb_byte
*
18839 read_full_die_1 (const struct die_reader_specs
*reader
,
18840 struct die_info
**diep
, const gdb_byte
*info_ptr
,
18841 int num_extra_attrs
)
18843 unsigned int abbrev_number
, bytes_read
, i
;
18844 const struct abbrev_info
*abbrev
;
18845 struct die_info
*die
;
18846 struct dwarf2_cu
*cu
= reader
->cu
;
18847 bfd
*abfd
= reader
->abfd
;
18849 sect_offset sect_off
= (sect_offset
) (info_ptr
- reader
->buffer
);
18850 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
18851 info_ptr
+= bytes_read
;
18852 if (!abbrev_number
)
18858 abbrev
= reader
->abbrev_table
->lookup_abbrev (abbrev_number
);
18860 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
18862 bfd_get_filename (abfd
));
18864 die
= dwarf_alloc_die (cu
, abbrev
->num_attrs
+ num_extra_attrs
);
18865 die
->sect_off
= sect_off
;
18866 die
->tag
= abbrev
->tag
;
18867 die
->abbrev
= abbrev_number
;
18868 die
->has_children
= abbrev
->has_children
;
18870 /* Make the result usable.
18871 The caller needs to update num_attrs after adding the extra
18873 die
->num_attrs
= abbrev
->num_attrs
;
18875 bool any_need_reprocess
= false;
18876 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
18878 info_ptr
= read_attribute (reader
, &die
->attrs
[i
], &abbrev
->attrs
[i
],
18880 if (die
->attrs
[i
].requires_reprocessing_p ())
18881 any_need_reprocess
= true;
18884 struct attribute
*attr
= die
->attr (DW_AT_str_offsets_base
);
18885 if (attr
!= nullptr && attr
->form_is_unsigned ())
18886 cu
->str_offsets_base
= attr
->as_unsigned ();
18888 attr
= die
->attr (DW_AT_loclists_base
);
18889 if (attr
!= nullptr)
18890 cu
->loclist_base
= attr
->as_unsigned ();
18892 auto maybe_addr_base
= die
->addr_base ();
18893 if (maybe_addr_base
.has_value ())
18894 cu
->addr_base
= *maybe_addr_base
;
18896 attr
= die
->attr (DW_AT_rnglists_base
);
18897 if (attr
!= nullptr)
18898 cu
->rnglists_base
= attr
->as_unsigned ();
18900 if (any_need_reprocess
)
18902 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
18904 if (die
->attrs
[i
].requires_reprocessing_p ())
18905 read_attribute_reprocess (reader
, &die
->attrs
[i
], die
->tag
);
18912 /* Read a die and all its attributes.
18913 Set DIEP to point to a newly allocated die with its information,
18914 except for its child, sibling, and parent fields. */
18916 static const gdb_byte
*
18917 read_full_die (const struct die_reader_specs
*reader
,
18918 struct die_info
**diep
, const gdb_byte
*info_ptr
)
18920 const gdb_byte
*result
;
18922 result
= read_full_die_1 (reader
, diep
, info_ptr
, 0);
18924 if (dwarf_die_debug
)
18926 fprintf_unfiltered (gdb_stdlog
,
18927 "Read die from %s@0x%x of %s:\n",
18928 reader
->die_section
->get_name (),
18929 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
18930 bfd_get_filename (reader
->abfd
));
18931 dump_die (*diep
, dwarf_die_debug
);
18938 /* Returns nonzero if TAG represents a type that we might generate a partial
18942 is_type_tag_for_partial (int tag
, enum language lang
)
18947 /* Some types that would be reasonable to generate partial symbols for,
18948 that we don't at present. Note that normally this does not
18949 matter, mainly because C compilers don't give names to these
18950 types, but instead emit DW_TAG_typedef. */
18951 case DW_TAG_file_type
:
18952 case DW_TAG_ptr_to_member_type
:
18953 case DW_TAG_set_type
:
18954 case DW_TAG_string_type
:
18955 case DW_TAG_subroutine_type
:
18958 /* GNAT may emit an array with a name, but no typedef, so we
18959 need to make a symbol in this case. */
18960 case DW_TAG_array_type
:
18961 return lang
== language_ada
;
18963 case DW_TAG_base_type
:
18964 case DW_TAG_class_type
:
18965 case DW_TAG_interface_type
:
18966 case DW_TAG_enumeration_type
:
18967 case DW_TAG_structure_type
:
18968 case DW_TAG_subrange_type
:
18969 case DW_TAG_typedef
:
18970 case DW_TAG_union_type
:
18977 /* Load all DIEs that are interesting for partial symbols into memory. */
18979 static struct partial_die_info
*
18980 load_partial_dies (const struct die_reader_specs
*reader
,
18981 const gdb_byte
*info_ptr
, int building_psymtab
)
18983 struct dwarf2_cu
*cu
= reader
->cu
;
18984 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
18985 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
18986 unsigned int bytes_read
;
18987 unsigned int load_all
= 0;
18988 int nesting_level
= 1;
18993 gdb_assert (cu
->per_cu
!= NULL
);
18994 if (cu
->load_all_dies
)
18998 = htab_create_alloc_ex (cu
->header
.length
/ 12,
19002 &cu
->comp_unit_obstack
,
19003 hashtab_obstack_allocate
,
19004 dummy_obstack_deallocate
);
19008 const abbrev_info
*abbrev
= peek_die_abbrev (*reader
, info_ptr
,
19011 /* A NULL abbrev means the end of a series of children. */
19012 if (abbrev
== NULL
)
19014 if (--nesting_level
== 0)
19017 info_ptr
+= bytes_read
;
19018 last_die
= parent_die
;
19019 parent_die
= parent_die
->die_parent
;
19023 /* Check for template arguments. We never save these; if
19024 they're seen, we just mark the parent, and go on our way. */
19025 if (parent_die
!= NULL
19026 && cu
->per_cu
->lang
== language_cplus
19027 && (abbrev
->tag
== DW_TAG_template_type_param
19028 || abbrev
->tag
== DW_TAG_template_value_param
))
19030 parent_die
->has_template_arguments
= 1;
19034 /* We don't need a partial DIE for the template argument. */
19035 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
19040 /* We only recurse into c++ subprograms looking for template arguments.
19041 Skip their other children. */
19043 && cu
->per_cu
->lang
== language_cplus
19044 && parent_die
!= NULL
19045 && parent_die
->tag
== DW_TAG_subprogram
19046 && abbrev
->tag
!= DW_TAG_inlined_subroutine
)
19048 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
19052 /* Check whether this DIE is interesting enough to save. Normally
19053 we would not be interested in members here, but there may be
19054 later variables referencing them via DW_AT_specification (for
19055 static members). */
19057 && !is_type_tag_for_partial (abbrev
->tag
, cu
->per_cu
->lang
)
19058 && abbrev
->tag
!= DW_TAG_constant
19059 && abbrev
->tag
!= DW_TAG_enumerator
19060 && abbrev
->tag
!= DW_TAG_subprogram
19061 && abbrev
->tag
!= DW_TAG_inlined_subroutine
19062 && abbrev
->tag
!= DW_TAG_lexical_block
19063 && abbrev
->tag
!= DW_TAG_variable
19064 && abbrev
->tag
!= DW_TAG_namespace
19065 && abbrev
->tag
!= DW_TAG_module
19066 && abbrev
->tag
!= DW_TAG_member
19067 && abbrev
->tag
!= DW_TAG_imported_unit
19068 && abbrev
->tag
!= DW_TAG_imported_declaration
)
19070 /* Otherwise we skip to the next sibling, if any. */
19071 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
19075 struct partial_die_info
pdi ((sect_offset
) (info_ptr
- reader
->buffer
),
19078 info_ptr
= pdi
.read (reader
, *abbrev
, info_ptr
+ bytes_read
);
19080 /* This two-pass algorithm for processing partial symbols has a
19081 high cost in cache pressure. Thus, handle some simple cases
19082 here which cover the majority of C partial symbols. DIEs
19083 which neither have specification tags in them, nor could have
19084 specification tags elsewhere pointing at them, can simply be
19085 processed and discarded.
19087 This segment is also optional; scan_partial_symbols and
19088 add_partial_symbol will handle these DIEs if we chain
19089 them in normally. When compilers which do not emit large
19090 quantities of duplicate debug information are more common,
19091 this code can probably be removed. */
19093 /* Any complete simple types at the top level (pretty much all
19094 of them, for a language without namespaces), can be processed
19096 if (parent_die
== NULL
19097 && pdi
.has_specification
== 0
19098 && pdi
.is_declaration
== 0
19099 && ((pdi
.tag
== DW_TAG_typedef
&& !pdi
.has_children
)
19100 || pdi
.tag
== DW_TAG_base_type
19101 || pdi
.tag
== DW_TAG_array_type
19102 || pdi
.tag
== DW_TAG_subrange_type
))
19104 if (building_psymtab
&& pdi
.raw_name
!= NULL
)
19105 add_partial_symbol (&pdi
, cu
);
19107 info_ptr
= locate_pdi_sibling (reader
, &pdi
, info_ptr
);
19111 /* The exception for DW_TAG_typedef with has_children above is
19112 a workaround of GCC PR debug/47510. In the case of this complaint
19113 type_name_or_error will error on such types later.
19115 GDB skipped children of DW_TAG_typedef by the shortcut above and then
19116 it could not find the child DIEs referenced later, this is checked
19117 above. In correct DWARF DW_TAG_typedef should have no children. */
19119 if (pdi
.tag
== DW_TAG_typedef
&& pdi
.has_children
)
19120 complaint (_("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
19121 "- DIE at %s [in module %s]"),
19122 sect_offset_str (pdi
.sect_off
), objfile_name (objfile
));
19124 /* If we're at the second level, and we're an enumerator, and
19125 our parent has no specification (meaning possibly lives in a
19126 namespace elsewhere), then we can add the partial symbol now
19127 instead of queueing it. */
19128 if (pdi
.tag
== DW_TAG_enumerator
19129 && parent_die
!= NULL
19130 && parent_die
->die_parent
== NULL
19131 && parent_die
->tag
== DW_TAG_enumeration_type
19132 && parent_die
->has_specification
== 0)
19134 if (pdi
.raw_name
== NULL
)
19135 complaint (_("malformed enumerator DIE ignored"));
19136 else if (building_psymtab
)
19137 add_partial_symbol (&pdi
, cu
);
19139 info_ptr
= locate_pdi_sibling (reader
, &pdi
, info_ptr
);
19143 struct partial_die_info
*part_die
19144 = new (&cu
->comp_unit_obstack
) partial_die_info (pdi
);
19146 /* We'll save this DIE so link it in. */
19147 part_die
->die_parent
= parent_die
;
19148 part_die
->die_sibling
= NULL
;
19149 part_die
->die_child
= NULL
;
19151 if (last_die
&& last_die
== parent_die
)
19152 last_die
->die_child
= part_die
;
19154 last_die
->die_sibling
= part_die
;
19156 last_die
= part_die
;
19158 if (first_die
== NULL
)
19159 first_die
= part_die
;
19161 /* Maybe add the DIE to the hash table. Not all DIEs that we
19162 find interesting need to be in the hash table, because we
19163 also have the parent/sibling/child chains; only those that we
19164 might refer to by offset later during partial symbol reading.
19166 For now this means things that might have be the target of a
19167 DW_AT_specification, DW_AT_abstract_origin, or
19168 DW_AT_extension. DW_AT_extension will refer only to
19169 namespaces; DW_AT_abstract_origin refers to functions (and
19170 many things under the function DIE, but we do not recurse
19171 into function DIEs during partial symbol reading) and
19172 possibly variables as well; DW_AT_specification refers to
19173 declarations. Declarations ought to have the DW_AT_declaration
19174 flag. It happens that GCC forgets to put it in sometimes, but
19175 only for functions, not for types.
19177 Adding more things than necessary to the hash table is harmless
19178 except for the performance cost. Adding too few will result in
19179 wasted time in find_partial_die, when we reread the compilation
19180 unit with load_all_dies set. */
19183 || abbrev
->tag
== DW_TAG_constant
19184 || abbrev
->tag
== DW_TAG_subprogram
19185 || abbrev
->tag
== DW_TAG_variable
19186 || abbrev
->tag
== DW_TAG_namespace
19187 || part_die
->is_declaration
)
19191 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
19192 to_underlying (part_die
->sect_off
),
19197 /* For some DIEs we want to follow their children (if any). For C
19198 we have no reason to follow the children of structures; for other
19199 languages we have to, so that we can get at method physnames
19200 to infer fully qualified class names, for DW_AT_specification,
19201 and for C++ template arguments. For C++, we also look one level
19202 inside functions to find template arguments (if the name of the
19203 function does not already contain the template arguments).
19205 For Ada and Fortran, we need to scan the children of subprograms
19206 and lexical blocks as well because these languages allow the
19207 definition of nested entities that could be interesting for the
19208 debugger, such as nested subprograms for instance. */
19209 if (last_die
->has_children
19211 || last_die
->tag
== DW_TAG_namespace
19212 || last_die
->tag
== DW_TAG_module
19213 || last_die
->tag
== DW_TAG_enumeration_type
19214 || (cu
->per_cu
->lang
== language_cplus
19215 && last_die
->tag
== DW_TAG_subprogram
19216 && (last_die
->raw_name
== NULL
19217 || strchr (last_die
->raw_name
, '<') == NULL
))
19218 || (cu
->per_cu
->lang
!= language_c
19219 && (last_die
->tag
== DW_TAG_class_type
19220 || last_die
->tag
== DW_TAG_interface_type
19221 || last_die
->tag
== DW_TAG_structure_type
19222 || last_die
->tag
== DW_TAG_union_type
))
19223 || ((cu
->per_cu
->lang
== language_ada
19224 || cu
->per_cu
->lang
== language_fortran
)
19225 && (last_die
->tag
== DW_TAG_subprogram
19226 || last_die
->tag
== DW_TAG_lexical_block
))))
19229 parent_die
= last_die
;
19233 /* Otherwise we skip to the next sibling, if any. */
19234 info_ptr
= locate_pdi_sibling (reader
, last_die
, info_ptr
);
19236 /* Back to the top, do it again. */
19240 partial_die_info::partial_die_info (sect_offset sect_off_
,
19241 const struct abbrev_info
*abbrev
)
19242 : partial_die_info (sect_off_
, abbrev
->tag
, abbrev
->has_children
)
19246 /* See class definition. */
19249 partial_die_info::name (dwarf2_cu
*cu
)
19251 if (!canonical_name
&& raw_name
!= nullptr)
19253 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
19254 raw_name
= dwarf2_canonicalize_name (raw_name
, cu
, objfile
);
19255 canonical_name
= 1;
19261 /* Read a minimal amount of information into the minimal die structure.
19262 INFO_PTR should point just after the initial uleb128 of a DIE. */
19265 partial_die_info::read (const struct die_reader_specs
*reader
,
19266 const struct abbrev_info
&abbrev
, const gdb_byte
*info_ptr
)
19268 struct dwarf2_cu
*cu
= reader
->cu
;
19269 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
19271 int has_low_pc_attr
= 0;
19272 int has_high_pc_attr
= 0;
19273 int high_pc_relative
= 0;
19275 for (i
= 0; i
< abbrev
.num_attrs
; ++i
)
19278 info_ptr
= read_attribute (reader
, &attr
, &abbrev
.attrs
[i
], info_ptr
);
19279 /* String and address offsets that need to do the reprocessing have
19280 already been read at this point, so there is no need to wait until
19281 the loop terminates to do the reprocessing. */
19282 if (attr
.requires_reprocessing_p ())
19283 read_attribute_reprocess (reader
, &attr
, tag
);
19284 /* Store the data if it is of an attribute we want to keep in a
19285 partial symbol table. */
19291 case DW_TAG_compile_unit
:
19292 case DW_TAG_partial_unit
:
19293 case DW_TAG_type_unit
:
19294 /* Compilation units have a DW_AT_name that is a filename, not
19295 a source language identifier. */
19296 case DW_TAG_enumeration_type
:
19297 case DW_TAG_enumerator
:
19298 /* These tags always have simple identifiers already; no need
19299 to canonicalize them. */
19300 canonical_name
= 1;
19301 raw_name
= attr
.as_string ();
19304 canonical_name
= 0;
19305 raw_name
= attr
.as_string ();
19309 case DW_AT_linkage_name
:
19310 case DW_AT_MIPS_linkage_name
:
19311 /* Note that both forms of linkage name might appear. We
19312 assume they will be the same, and we only store the last
19314 linkage_name
= attr
.as_string ();
19317 has_low_pc_attr
= 1;
19318 lowpc
= attr
.as_address ();
19320 case DW_AT_high_pc
:
19321 has_high_pc_attr
= 1;
19322 highpc
= attr
.as_address ();
19323 if (cu
->header
.version
>= 4 && attr
.form_is_constant ())
19324 high_pc_relative
= 1;
19326 case DW_AT_location
:
19327 /* Support the .debug_loc offsets. */
19328 if (attr
.form_is_block ())
19330 d
.locdesc
= attr
.as_block ();
19332 else if (attr
.form_is_section_offset ())
19334 dwarf2_complex_location_expr_complaint ();
19338 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
19339 "partial symbol information");
19342 case DW_AT_external
:
19343 is_external
= attr
.as_boolean ();
19345 case DW_AT_declaration
:
19346 is_declaration
= attr
.as_boolean ();
19351 case DW_AT_abstract_origin
:
19352 case DW_AT_specification
:
19353 case DW_AT_extension
:
19354 has_specification
= 1;
19355 spec_offset
= attr
.get_ref_die_offset ();
19356 spec_is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
19357 || cu
->per_cu
->is_dwz
);
19359 case DW_AT_sibling
:
19360 /* Ignore absolute siblings, they might point outside of
19361 the current compile unit. */
19362 if (attr
.form
== DW_FORM_ref_addr
)
19363 complaint (_("ignoring absolute DW_AT_sibling"));
19366 const gdb_byte
*buffer
= reader
->buffer
;
19367 sect_offset off
= attr
.get_ref_die_offset ();
19368 const gdb_byte
*sibling_ptr
= buffer
+ to_underlying (off
);
19370 if (sibling_ptr
< info_ptr
)
19371 complaint (_("DW_AT_sibling points backwards"));
19372 else if (sibling_ptr
> reader
->buffer_end
)
19373 reader
->die_section
->overflow_complaint ();
19375 sibling
= sibling_ptr
;
19378 case DW_AT_byte_size
:
19381 case DW_AT_const_value
:
19382 has_const_value
= 1;
19384 case DW_AT_calling_convention
:
19385 /* DWARF doesn't provide a way to identify a program's source-level
19386 entry point. DW_AT_calling_convention attributes are only meant
19387 to describe functions' calling conventions.
19389 However, because it's a necessary piece of information in
19390 Fortran, and before DWARF 4 DW_CC_program was the only
19391 piece of debugging information whose definition refers to
19392 a 'main program' at all, several compilers marked Fortran
19393 main programs with DW_CC_program --- even when those
19394 functions use the standard calling conventions.
19396 Although DWARF now specifies a way to provide this
19397 information, we support this practice for backward
19399 if (attr
.constant_value (0) == DW_CC_program
19400 && cu
->per_cu
->lang
== language_fortran
)
19401 main_subprogram
= 1;
19405 LONGEST value
= attr
.constant_value (-1);
19406 if (value
== DW_INL_inlined
19407 || value
== DW_INL_declared_inlined
)
19408 may_be_inlined
= 1;
19413 if (tag
== DW_TAG_imported_unit
)
19415 d
.sect_off
= attr
.get_ref_die_offset ();
19416 is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
19417 || cu
->per_cu
->is_dwz
);
19421 case DW_AT_main_subprogram
:
19422 main_subprogram
= attr
.as_boolean ();
19427 /* Offset in the .debug_ranges or .debug_rnglist section (depending
19428 on DWARF version). */
19429 ranges_offset
= attr
.as_unsigned ();
19431 /* See dwarf2_cu::gnu_ranges_base's doc for why we might want to add
19433 if (tag
!= DW_TAG_compile_unit
)
19434 ranges_offset
+= cu
->gnu_ranges_base
;
19436 has_range_info
= 1;
19445 /* For Ada, if both the name and the linkage name appear, we prefer
19446 the latter. This lets "catch exception" work better, regardless
19447 of the order in which the name and linkage name were emitted.
19448 Really, though, this is just a workaround for the fact that gdb
19449 doesn't store both the name and the linkage name. */
19450 if (cu
->per_cu
->lang
== language_ada
&& linkage_name
!= nullptr)
19451 raw_name
= linkage_name
;
19453 if (high_pc_relative
)
19456 if (has_low_pc_attr
&& has_high_pc_attr
)
19458 /* When using the GNU linker, .gnu.linkonce. sections are used to
19459 eliminate duplicate copies of functions and vtables and such.
19460 The linker will arbitrarily choose one and discard the others.
19461 The AT_*_pc values for such functions refer to local labels in
19462 these sections. If the section from that file was discarded, the
19463 labels are not in the output, so the relocs get a value of 0.
19464 If this is a discarded function, mark the pc bounds as invalid,
19465 so that GDB will ignore it. */
19466 if (lowpc
== 0 && !per_objfile
->per_bfd
->has_section_at_zero
)
19468 struct objfile
*objfile
= per_objfile
->objfile
;
19469 struct gdbarch
*gdbarch
= objfile
->arch ();
19471 complaint (_("DW_AT_low_pc %s is zero "
19472 "for DIE at %s [in module %s]"),
19473 paddress (gdbarch
, lowpc
),
19474 sect_offset_str (sect_off
),
19475 objfile_name (objfile
));
19477 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
19478 else if (lowpc
>= highpc
)
19480 struct objfile
*objfile
= per_objfile
->objfile
;
19481 struct gdbarch
*gdbarch
= objfile
->arch ();
19483 complaint (_("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
19484 "for DIE at %s [in module %s]"),
19485 paddress (gdbarch
, lowpc
),
19486 paddress (gdbarch
, highpc
),
19487 sect_offset_str (sect_off
),
19488 objfile_name (objfile
));
19497 /* Find a cached partial DIE at OFFSET in CU. */
19499 struct partial_die_info
*
19500 dwarf2_cu::find_partial_die (sect_offset sect_off
)
19502 struct partial_die_info
*lookup_die
= NULL
;
19503 struct partial_die_info
part_die (sect_off
);
19505 lookup_die
= ((struct partial_die_info
*)
19506 htab_find_with_hash (partial_dies
, &part_die
,
19507 to_underlying (sect_off
)));
19512 /* Find a partial DIE at OFFSET, which may or may not be in CU,
19513 except in the case of .debug_types DIEs which do not reference
19514 outside their CU (they do however referencing other types via
19515 DW_FORM_ref_sig8). */
19517 static const struct cu_partial_die_info
19518 find_partial_die (sect_offset sect_off
, int offset_in_dwz
, struct dwarf2_cu
*cu
)
19520 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
19521 struct objfile
*objfile
= per_objfile
->objfile
;
19522 struct partial_die_info
*pd
= NULL
;
19524 if (offset_in_dwz
== cu
->per_cu
->is_dwz
19525 && cu
->header
.offset_in_cu_p (sect_off
))
19527 pd
= cu
->find_partial_die (sect_off
);
19530 /* We missed recording what we needed.
19531 Load all dies and try again. */
19535 /* TUs don't reference other CUs/TUs (except via type signatures). */
19536 if (cu
->per_cu
->is_debug_types
)
19538 error (_("Dwarf Error: Type Unit at offset %s contains"
19539 " external reference to offset %s [in module %s].\n"),
19540 sect_offset_str (cu
->header
.sect_off
), sect_offset_str (sect_off
),
19541 bfd_get_filename (objfile
->obfd
));
19543 dwarf2_per_cu_data
*per_cu
19544 = dwarf2_find_containing_comp_unit (sect_off
, offset_in_dwz
,
19547 cu
= per_objfile
->get_cu (per_cu
);
19548 if (cu
== NULL
|| cu
->partial_dies
== NULL
)
19549 load_partial_comp_unit (per_cu
, per_objfile
, nullptr);
19551 cu
= per_objfile
->get_cu (per_cu
);
19554 pd
= cu
->find_partial_die (sect_off
);
19557 /* If we didn't find it, and not all dies have been loaded,
19558 load them all and try again. */
19560 if (pd
== NULL
&& cu
->load_all_dies
== 0)
19562 cu
->load_all_dies
= 1;
19564 /* This is nasty. When we reread the DIEs, somewhere up the call chain
19565 THIS_CU->cu may already be in use. So we can't just free it and
19566 replace its DIEs with the ones we read in. Instead, we leave those
19567 DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
19568 and clobber THIS_CU->cu->partial_dies with the hash table for the new
19570 load_partial_comp_unit (cu
->per_cu
, per_objfile
, cu
);
19572 pd
= cu
->find_partial_die (sect_off
);
19576 error (_("Dwarf Error: Cannot find DIE at %s [from module %s]\n"),
19577 sect_offset_str (sect_off
), bfd_get_filename (objfile
->obfd
));
19581 /* See if we can figure out if the class lives in a namespace. We do
19582 this by looking for a member function; its demangled name will
19583 contain namespace info, if there is any. */
19586 guess_partial_die_structure_name (struct partial_die_info
*struct_pdi
,
19587 struct dwarf2_cu
*cu
)
19589 /* NOTE: carlton/2003-10-07: Getting the info this way changes
19590 what template types look like, because the demangler
19591 frequently doesn't give the same name as the debug info. We
19592 could fix this by only using the demangled name to get the
19593 prefix (but see comment in read_structure_type). */
19595 struct partial_die_info
*real_pdi
;
19596 struct partial_die_info
*child_pdi
;
19598 /* If this DIE (this DIE's specification, if any) has a parent, then
19599 we should not do this. We'll prepend the parent's fully qualified
19600 name when we create the partial symbol. */
19602 real_pdi
= struct_pdi
;
19603 while (real_pdi
->has_specification
)
19605 auto res
= find_partial_die (real_pdi
->spec_offset
,
19606 real_pdi
->spec_is_dwz
, cu
);
19607 real_pdi
= res
.pdi
;
19611 if (real_pdi
->die_parent
!= NULL
)
19614 for (child_pdi
= struct_pdi
->die_child
;
19616 child_pdi
= child_pdi
->die_sibling
)
19618 if (child_pdi
->tag
== DW_TAG_subprogram
19619 && child_pdi
->linkage_name
!= NULL
)
19621 gdb::unique_xmalloc_ptr
<char> actual_class_name
19622 (cu
->language_defn
->class_name_from_physname
19623 (child_pdi
->linkage_name
));
19624 if (actual_class_name
!= NULL
)
19626 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
19627 struct_pdi
->raw_name
= objfile
->intern (actual_class_name
.get ());
19628 struct_pdi
->canonical_name
= 1;
19635 /* Return true if a DIE with TAG may have the DW_AT_const_value
19639 can_have_DW_AT_const_value_p (enum dwarf_tag tag
)
19643 case DW_TAG_constant
:
19644 case DW_TAG_enumerator
:
19645 case DW_TAG_formal_parameter
:
19646 case DW_TAG_template_value_param
:
19647 case DW_TAG_variable
:
19655 partial_die_info::fixup (struct dwarf2_cu
*cu
)
19657 /* Once we've fixed up a die, there's no point in doing so again.
19658 This also avoids a memory leak if we were to call
19659 guess_partial_die_structure_name multiple times. */
19663 /* If we found a reference attribute and the DIE has no name, try
19664 to find a name in the referred to DIE. */
19666 if (raw_name
== NULL
&& has_specification
)
19668 struct partial_die_info
*spec_die
;
19670 auto res
= find_partial_die (spec_offset
, spec_is_dwz
, cu
);
19671 spec_die
= res
.pdi
;
19674 spec_die
->fixup (cu
);
19676 if (spec_die
->raw_name
)
19678 raw_name
= spec_die
->raw_name
;
19679 canonical_name
= spec_die
->canonical_name
;
19681 /* Copy DW_AT_external attribute if it is set. */
19682 if (spec_die
->is_external
)
19683 is_external
= spec_die
->is_external
;
19687 if (!has_const_value
&& has_specification
19688 && can_have_DW_AT_const_value_p (tag
))
19690 struct partial_die_info
*spec_die
;
19692 auto res
= find_partial_die (spec_offset
, spec_is_dwz
, cu
);
19693 spec_die
= res
.pdi
;
19696 spec_die
->fixup (cu
);
19698 if (spec_die
->has_const_value
)
19700 /* Copy DW_AT_const_value attribute if it is set. */
19701 has_const_value
= spec_die
->has_const_value
;
19705 /* Set default names for some unnamed DIEs. */
19707 if (raw_name
== NULL
&& tag
== DW_TAG_namespace
)
19709 raw_name
= CP_ANONYMOUS_NAMESPACE_STR
;
19710 canonical_name
= 1;
19713 /* If there is no parent die to provide a namespace, and there are
19714 children, see if we can determine the namespace from their linkage
19716 if (cu
->per_cu
->lang
== language_cplus
19717 && !cu
->per_objfile
->per_bfd
->types
.empty ()
19718 && die_parent
== NULL
19720 && (tag
== DW_TAG_class_type
19721 || tag
== DW_TAG_structure_type
19722 || tag
== DW_TAG_union_type
))
19723 guess_partial_die_structure_name (this, cu
);
19725 /* GCC might emit a nameless struct or union that has a linkage
19726 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
19727 if (raw_name
== NULL
19728 && (tag
== DW_TAG_class_type
19729 || tag
== DW_TAG_interface_type
19730 || tag
== DW_TAG_structure_type
19731 || tag
== DW_TAG_union_type
)
19732 && linkage_name
!= NULL
)
19734 gdb::unique_xmalloc_ptr
<char> demangled
19735 (gdb_demangle (linkage_name
, DMGL_TYPES
));
19736 if (demangled
!= nullptr)
19740 /* Strip any leading namespaces/classes, keep only the base name.
19741 DW_AT_name for named DIEs does not contain the prefixes. */
19742 base
= strrchr (demangled
.get (), ':');
19743 if (base
&& base
> demangled
.get () && base
[-1] == ':')
19746 base
= demangled
.get ();
19748 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
19749 raw_name
= objfile
->intern (base
);
19750 canonical_name
= 1;
19757 /* Read the .debug_loclists or .debug_rnglists header (they are the same format)
19758 contents from the given SECTION in the HEADER.
19760 HEADER_OFFSET is the offset of the header in the section. */
19762 read_loclists_rnglists_header (struct loclists_rnglists_header
*header
,
19763 struct dwarf2_section_info
*section
,
19764 sect_offset header_offset
)
19766 unsigned int bytes_read
;
19767 bfd
*abfd
= section
->get_bfd_owner ();
19768 const gdb_byte
*info_ptr
= section
->buffer
+ to_underlying (header_offset
);
19770 header
->length
= read_initial_length (abfd
, info_ptr
, &bytes_read
);
19771 info_ptr
+= bytes_read
;
19773 header
->version
= read_2_bytes (abfd
, info_ptr
);
19776 header
->addr_size
= read_1_byte (abfd
, info_ptr
);
19779 header
->segment_collector_size
= read_1_byte (abfd
, info_ptr
);
19782 header
->offset_entry_count
= read_4_bytes (abfd
, info_ptr
);
19785 /* Return the DW_AT_loclists_base value for the CU. */
19787 lookup_loclist_base (struct dwarf2_cu
*cu
)
19789 /* For the .dwo unit, the loclist_base points to the first offset following
19790 the header. The header consists of the following entities-
19791 1. Unit Length (4 bytes for 32 bit DWARF format, and 12 bytes for the 64
19793 2. version (2 bytes)
19794 3. address size (1 byte)
19795 4. segment selector size (1 byte)
19796 5. offset entry count (4 bytes)
19797 These sizes are derived as per the DWARFv5 standard. */
19798 if (cu
->dwo_unit
!= nullptr)
19800 if (cu
->header
.initial_length_size
== 4)
19801 return LOCLIST_HEADER_SIZE32
;
19802 return LOCLIST_HEADER_SIZE64
;
19804 return cu
->loclist_base
;
19807 /* Given a DW_FORM_loclistx value LOCLIST_INDEX, fetch the offset from the
19808 array of offsets in the .debug_loclists section. */
19811 read_loclist_index (struct dwarf2_cu
*cu
, ULONGEST loclist_index
)
19813 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
19814 struct objfile
*objfile
= per_objfile
->objfile
;
19815 bfd
*abfd
= objfile
->obfd
;
19816 ULONGEST loclist_header_size
=
19817 (cu
->header
.initial_length_size
== 4 ? LOCLIST_HEADER_SIZE32
19818 : LOCLIST_HEADER_SIZE64
);
19819 ULONGEST loclist_base
= lookup_loclist_base (cu
);
19821 /* Offset in .debug_loclists of the offset for LOCLIST_INDEX. */
19822 ULONGEST start_offset
=
19823 loclist_base
+ loclist_index
* cu
->header
.offset_size
;
19825 /* Get loclists section. */
19826 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
19828 /* Read the loclists section content. */
19829 section
->read (objfile
);
19830 if (section
->buffer
== NULL
)
19831 error (_("DW_FORM_loclistx used without .debug_loclists "
19832 "section [in module %s]"), objfile_name (objfile
));
19834 /* DW_AT_loclists_base points after the .debug_loclists contribution header,
19835 so if loclist_base is smaller than the header size, we have a problem. */
19836 if (loclist_base
< loclist_header_size
)
19837 error (_("DW_AT_loclists_base is smaller than header size [in module %s]"),
19838 objfile_name (objfile
));
19840 /* Read the header of the loclists contribution. */
19841 struct loclists_rnglists_header header
;
19842 read_loclists_rnglists_header (&header
, section
,
19843 (sect_offset
) (loclist_base
- loclist_header_size
));
19845 /* Verify the loclist index is valid. */
19846 if (loclist_index
>= header
.offset_entry_count
)
19847 error (_("DW_FORM_loclistx pointing outside of "
19848 ".debug_loclists offset array [in module %s]"),
19849 objfile_name (objfile
));
19851 /* Validate that reading won't go beyond the end of the section. */
19852 if (start_offset
+ cu
->header
.offset_size
> section
->size
)
19853 error (_("Reading DW_FORM_loclistx index beyond end of"
19854 ".debug_loclists section [in module %s]"),
19855 objfile_name (objfile
));
19857 const gdb_byte
*info_ptr
= section
->buffer
+ start_offset
;
19859 if (cu
->header
.offset_size
== 4)
19860 return (sect_offset
) (bfd_get_32 (abfd
, info_ptr
) + loclist_base
);
19862 return (sect_offset
) (bfd_get_64 (abfd
, info_ptr
) + loclist_base
);
19865 /* Given a DW_FORM_rnglistx value RNGLIST_INDEX, fetch the offset from the
19866 array of offsets in the .debug_rnglists section. */
19869 read_rnglist_index (struct dwarf2_cu
*cu
, ULONGEST rnglist_index
,
19872 struct dwarf2_per_objfile
*dwarf2_per_objfile
= cu
->per_objfile
;
19873 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
19874 bfd
*abfd
= objfile
->obfd
;
19875 ULONGEST rnglist_header_size
=
19876 (cu
->header
.initial_length_size
== 4 ? RNGLIST_HEADER_SIZE32
19877 : RNGLIST_HEADER_SIZE64
);
19879 /* When reading a DW_FORM_rnglistx from a DWO, we read from the DWO's
19880 .debug_rnglists.dwo section. The rnglists base given in the skeleton
19882 ULONGEST rnglist_base
=
19883 (cu
->dwo_unit
!= nullptr) ? rnglist_header_size
: cu
->rnglists_base
;
19885 /* Offset in .debug_rnglists of the offset for RNGLIST_INDEX. */
19886 ULONGEST start_offset
=
19887 rnglist_base
+ rnglist_index
* cu
->header
.offset_size
;
19889 /* Get rnglists section. */
19890 struct dwarf2_section_info
*section
= cu_debug_rnglists_section (cu
, tag
);
19892 /* Read the rnglists section content. */
19893 section
->read (objfile
);
19894 if (section
->buffer
== nullptr)
19895 error (_("DW_FORM_rnglistx used without .debug_rnglists section "
19897 objfile_name (objfile
));
19899 /* DW_AT_rnglists_base points after the .debug_rnglists contribution header,
19900 so if rnglist_base is smaller than the header size, we have a problem. */
19901 if (rnglist_base
< rnglist_header_size
)
19902 error (_("DW_AT_rnglists_base is smaller than header size [in module %s]"),
19903 objfile_name (objfile
));
19905 /* Read the header of the rnglists contribution. */
19906 struct loclists_rnglists_header header
;
19907 read_loclists_rnglists_header (&header
, section
,
19908 (sect_offset
) (rnglist_base
- rnglist_header_size
));
19910 /* Verify the rnglist index is valid. */
19911 if (rnglist_index
>= header
.offset_entry_count
)
19912 error (_("DW_FORM_rnglistx index pointing outside of "
19913 ".debug_rnglists offset array [in module %s]"),
19914 objfile_name (objfile
));
19916 /* Validate that reading won't go beyond the end of the section. */
19917 if (start_offset
+ cu
->header
.offset_size
> section
->size
)
19918 error (_("Reading DW_FORM_rnglistx index beyond end of"
19919 ".debug_rnglists section [in module %s]"),
19920 objfile_name (objfile
));
19922 const gdb_byte
*info_ptr
= section
->buffer
+ start_offset
;
19924 if (cu
->header
.offset_size
== 4)
19925 return (sect_offset
) (read_4_bytes (abfd
, info_ptr
) + rnglist_base
);
19927 return (sect_offset
) (read_8_bytes (abfd
, info_ptr
) + rnglist_base
);
19930 /* Process the attributes that had to be skipped in the first round. These
19931 attributes are the ones that need str_offsets_base or addr_base attributes.
19932 They could not have been processed in the first round, because at the time
19933 the values of str_offsets_base or addr_base may not have been known. */
19935 read_attribute_reprocess (const struct die_reader_specs
*reader
,
19936 struct attribute
*attr
, dwarf_tag tag
)
19938 struct dwarf2_cu
*cu
= reader
->cu
;
19939 switch (attr
->form
)
19941 case DW_FORM_addrx
:
19942 case DW_FORM_GNU_addr_index
:
19943 attr
->set_address (read_addr_index (cu
,
19944 attr
->as_unsigned_reprocess ()));
19946 case DW_FORM_loclistx
:
19948 sect_offset loclists_sect_off
19949 = read_loclist_index (cu
, attr
->as_unsigned_reprocess ());
19951 attr
->set_unsigned (to_underlying (loclists_sect_off
));
19954 case DW_FORM_rnglistx
:
19956 sect_offset rnglists_sect_off
19957 = read_rnglist_index (cu
, attr
->as_unsigned_reprocess (), tag
);
19959 attr
->set_unsigned (to_underlying (rnglists_sect_off
));
19963 case DW_FORM_strx1
:
19964 case DW_FORM_strx2
:
19965 case DW_FORM_strx3
:
19966 case DW_FORM_strx4
:
19967 case DW_FORM_GNU_str_index
:
19969 unsigned int str_index
= attr
->as_unsigned_reprocess ();
19970 gdb_assert (!attr
->canonical_string_p ());
19971 if (reader
->dwo_file
!= NULL
)
19972 attr
->set_string_noncanonical (read_dwo_str_index (reader
,
19975 attr
->set_string_noncanonical (read_stub_str_index (cu
,
19980 gdb_assert_not_reached (_("Unexpected DWARF form."));
19984 /* Read an attribute value described by an attribute form. */
19986 static const gdb_byte
*
19987 read_attribute_value (const struct die_reader_specs
*reader
,
19988 struct attribute
*attr
, unsigned form
,
19989 LONGEST implicit_const
, const gdb_byte
*info_ptr
)
19991 struct dwarf2_cu
*cu
= reader
->cu
;
19992 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
19993 struct objfile
*objfile
= per_objfile
->objfile
;
19994 bfd
*abfd
= reader
->abfd
;
19995 struct comp_unit_head
*cu_header
= &cu
->header
;
19996 unsigned int bytes_read
;
19997 struct dwarf_block
*blk
;
19999 attr
->form
= (enum dwarf_form
) form
;
20002 case DW_FORM_ref_addr
:
20003 if (cu_header
->version
== 2)
20004 attr
->set_unsigned (cu_header
->read_address (abfd
, info_ptr
,
20007 attr
->set_unsigned (cu_header
->read_offset (abfd
, info_ptr
,
20009 info_ptr
+= bytes_read
;
20011 case DW_FORM_GNU_ref_alt
:
20012 attr
->set_unsigned (cu_header
->read_offset (abfd
, info_ptr
,
20014 info_ptr
+= bytes_read
;
20018 struct gdbarch
*gdbarch
= objfile
->arch ();
20019 CORE_ADDR addr
= cu_header
->read_address (abfd
, info_ptr
, &bytes_read
);
20020 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, addr
);
20021 attr
->set_address (addr
);
20022 info_ptr
+= bytes_read
;
20025 case DW_FORM_block2
:
20026 blk
= dwarf_alloc_block (cu
);
20027 blk
->size
= read_2_bytes (abfd
, info_ptr
);
20029 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
20030 info_ptr
+= blk
->size
;
20031 attr
->set_block (blk
);
20033 case DW_FORM_block4
:
20034 blk
= dwarf_alloc_block (cu
);
20035 blk
->size
= read_4_bytes (abfd
, info_ptr
);
20037 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
20038 info_ptr
+= blk
->size
;
20039 attr
->set_block (blk
);
20041 case DW_FORM_data2
:
20042 attr
->set_unsigned (read_2_bytes (abfd
, info_ptr
));
20045 case DW_FORM_data4
:
20046 attr
->set_unsigned (read_4_bytes (abfd
, info_ptr
));
20049 case DW_FORM_data8
:
20050 attr
->set_unsigned (read_8_bytes (abfd
, info_ptr
));
20053 case DW_FORM_data16
:
20054 blk
= dwarf_alloc_block (cu
);
20056 blk
->data
= read_n_bytes (abfd
, info_ptr
, 16);
20058 attr
->set_block (blk
);
20060 case DW_FORM_sec_offset
:
20061 attr
->set_unsigned (cu_header
->read_offset (abfd
, info_ptr
,
20063 info_ptr
+= bytes_read
;
20065 case DW_FORM_loclistx
:
20067 attr
->set_unsigned_reprocess (read_unsigned_leb128 (abfd
, info_ptr
,
20069 info_ptr
+= bytes_read
;
20072 case DW_FORM_string
:
20073 attr
->set_string_noncanonical (read_direct_string (abfd
, info_ptr
,
20075 info_ptr
+= bytes_read
;
20078 if (!cu
->per_cu
->is_dwz
)
20080 attr
->set_string_noncanonical
20081 (read_indirect_string (per_objfile
,
20082 abfd
, info_ptr
, cu_header
,
20084 info_ptr
+= bytes_read
;
20088 case DW_FORM_line_strp
:
20089 if (!cu
->per_cu
->is_dwz
)
20091 attr
->set_string_noncanonical
20092 (per_objfile
->read_line_string (info_ptr
, cu_header
,
20094 info_ptr
+= bytes_read
;
20098 case DW_FORM_GNU_strp_alt
:
20100 dwz_file
*dwz
= dwarf2_get_dwz_file (per_objfile
->per_bfd
, true);
20101 LONGEST str_offset
= cu_header
->read_offset (abfd
, info_ptr
,
20104 attr
->set_string_noncanonical
20105 (dwz
->read_string (objfile
, str_offset
));
20106 info_ptr
+= bytes_read
;
20109 case DW_FORM_exprloc
:
20110 case DW_FORM_block
:
20111 blk
= dwarf_alloc_block (cu
);
20112 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
20113 info_ptr
+= bytes_read
;
20114 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
20115 info_ptr
+= blk
->size
;
20116 attr
->set_block (blk
);
20118 case DW_FORM_block1
:
20119 blk
= dwarf_alloc_block (cu
);
20120 blk
->size
= read_1_byte (abfd
, info_ptr
);
20122 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
20123 info_ptr
+= blk
->size
;
20124 attr
->set_block (blk
);
20126 case DW_FORM_data1
:
20128 attr
->set_unsigned (read_1_byte (abfd
, info_ptr
));
20131 case DW_FORM_flag_present
:
20132 attr
->set_unsigned (1);
20134 case DW_FORM_sdata
:
20135 attr
->set_signed (read_signed_leb128 (abfd
, info_ptr
, &bytes_read
));
20136 info_ptr
+= bytes_read
;
20138 case DW_FORM_rnglistx
:
20140 attr
->set_unsigned_reprocess (read_unsigned_leb128 (abfd
, info_ptr
,
20142 info_ptr
+= bytes_read
;
20145 case DW_FORM_udata
:
20146 attr
->set_unsigned (read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
20147 info_ptr
+= bytes_read
;
20150 attr
->set_unsigned ((to_underlying (cu_header
->sect_off
)
20151 + read_1_byte (abfd
, info_ptr
)));
20155 attr
->set_unsigned ((to_underlying (cu_header
->sect_off
)
20156 + read_2_bytes (abfd
, info_ptr
)));
20160 attr
->set_unsigned ((to_underlying (cu_header
->sect_off
)
20161 + read_4_bytes (abfd
, info_ptr
)));
20165 attr
->set_unsigned ((to_underlying (cu_header
->sect_off
)
20166 + read_8_bytes (abfd
, info_ptr
)));
20169 case DW_FORM_ref_sig8
:
20170 attr
->set_signature (read_8_bytes (abfd
, info_ptr
));
20173 case DW_FORM_ref_udata
:
20174 attr
->set_unsigned ((to_underlying (cu_header
->sect_off
)
20175 + read_unsigned_leb128 (abfd
, info_ptr
,
20177 info_ptr
+= bytes_read
;
20179 case DW_FORM_indirect
:
20180 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
20181 info_ptr
+= bytes_read
;
20182 if (form
== DW_FORM_implicit_const
)
20184 implicit_const
= read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
20185 info_ptr
+= bytes_read
;
20187 info_ptr
= read_attribute_value (reader
, attr
, form
, implicit_const
,
20190 case DW_FORM_implicit_const
:
20191 attr
->set_signed (implicit_const
);
20193 case DW_FORM_addrx
:
20194 case DW_FORM_GNU_addr_index
:
20195 attr
->set_unsigned_reprocess (read_unsigned_leb128 (abfd
, info_ptr
,
20197 info_ptr
+= bytes_read
;
20200 case DW_FORM_strx1
:
20201 case DW_FORM_strx2
:
20202 case DW_FORM_strx3
:
20203 case DW_FORM_strx4
:
20204 case DW_FORM_GNU_str_index
:
20206 ULONGEST str_index
;
20207 if (form
== DW_FORM_strx1
)
20209 str_index
= read_1_byte (abfd
, info_ptr
);
20212 else if (form
== DW_FORM_strx2
)
20214 str_index
= read_2_bytes (abfd
, info_ptr
);
20217 else if (form
== DW_FORM_strx3
)
20219 str_index
= read_3_bytes (abfd
, info_ptr
);
20222 else if (form
== DW_FORM_strx4
)
20224 str_index
= read_4_bytes (abfd
, info_ptr
);
20229 str_index
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
20230 info_ptr
+= bytes_read
;
20232 attr
->set_unsigned_reprocess (str_index
);
20236 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
20237 dwarf_form_name (form
),
20238 bfd_get_filename (abfd
));
20242 if (cu
->per_cu
->is_dwz
&& attr
->form_is_ref ())
20243 attr
->form
= DW_FORM_GNU_ref_alt
;
20245 /* We have seen instances where the compiler tried to emit a byte
20246 size attribute of -1 which ended up being encoded as an unsigned
20247 0xffffffff. Although 0xffffffff is technically a valid size value,
20248 an object of this size seems pretty unlikely so we can relatively
20249 safely treat these cases as if the size attribute was invalid and
20250 treat them as zero by default. */
20251 if (attr
->name
== DW_AT_byte_size
20252 && form
== DW_FORM_data4
20253 && attr
->as_unsigned () >= 0xffffffff)
20256 (_("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
20257 hex_string (attr
->as_unsigned ()));
20258 attr
->set_unsigned (0);
20264 /* Read an attribute described by an abbreviated attribute. */
20266 static const gdb_byte
*
20267 read_attribute (const struct die_reader_specs
*reader
,
20268 struct attribute
*attr
, const struct attr_abbrev
*abbrev
,
20269 const gdb_byte
*info_ptr
)
20271 attr
->name
= abbrev
->name
;
20272 attr
->string_is_canonical
= 0;
20273 attr
->requires_reprocessing
= 0;
20274 return read_attribute_value (reader
, attr
, abbrev
->form
,
20275 abbrev
->implicit_const
, info_ptr
);
20278 /* Return pointer to string at .debug_str offset STR_OFFSET. */
20280 static const char *
20281 read_indirect_string_at_offset (dwarf2_per_objfile
*per_objfile
,
20282 LONGEST str_offset
)
20284 return per_objfile
->per_bfd
->str
.read_string (per_objfile
->objfile
,
20285 str_offset
, "DW_FORM_strp");
20288 /* Return pointer to string at .debug_str offset as read from BUF.
20289 BUF is assumed to be in a compilation unit described by CU_HEADER.
20290 Return *BYTES_READ_PTR count of bytes read from BUF. */
20292 static const char *
20293 read_indirect_string (dwarf2_per_objfile
*per_objfile
, bfd
*abfd
,
20294 const gdb_byte
*buf
,
20295 const struct comp_unit_head
*cu_header
,
20296 unsigned int *bytes_read_ptr
)
20298 LONGEST str_offset
= cu_header
->read_offset (abfd
, buf
, bytes_read_ptr
);
20300 return read_indirect_string_at_offset (per_objfile
, str_offset
);
20306 dwarf2_per_objfile::read_line_string (const gdb_byte
*buf
,
20307 const struct comp_unit_head
*cu_header
,
20308 unsigned int *bytes_read_ptr
)
20310 bfd
*abfd
= objfile
->obfd
;
20311 LONGEST str_offset
= cu_header
->read_offset (abfd
, buf
, bytes_read_ptr
);
20313 return per_bfd
->line_str
.read_string (objfile
, str_offset
, "DW_FORM_line_strp");
20316 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
20317 ADDR_BASE is the DW_AT_addr_base (DW_AT_GNU_addr_base) attribute or zero.
20318 ADDR_SIZE is the size of addresses from the CU header. */
20321 read_addr_index_1 (dwarf2_per_objfile
*per_objfile
, unsigned int addr_index
,
20322 gdb::optional
<ULONGEST
> addr_base
, int addr_size
)
20324 struct objfile
*objfile
= per_objfile
->objfile
;
20325 bfd
*abfd
= objfile
->obfd
;
20326 const gdb_byte
*info_ptr
;
20327 ULONGEST addr_base_or_zero
= addr_base
.has_value () ? *addr_base
: 0;
20329 per_objfile
->per_bfd
->addr
.read (objfile
);
20330 if (per_objfile
->per_bfd
->addr
.buffer
== NULL
)
20331 error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
20332 objfile_name (objfile
));
20333 if (addr_base_or_zero
+ addr_index
* addr_size
20334 >= per_objfile
->per_bfd
->addr
.size
)
20335 error (_("DW_FORM_addr_index pointing outside of "
20336 ".debug_addr section [in module %s]"),
20337 objfile_name (objfile
));
20338 info_ptr
= (per_objfile
->per_bfd
->addr
.buffer
+ addr_base_or_zero
20339 + addr_index
* addr_size
);
20340 if (addr_size
== 4)
20341 return bfd_get_32 (abfd
, info_ptr
);
20343 return bfd_get_64 (abfd
, info_ptr
);
20346 /* Given index ADDR_INDEX in .debug_addr, fetch the value. */
20349 read_addr_index (struct dwarf2_cu
*cu
, unsigned int addr_index
)
20351 return read_addr_index_1 (cu
->per_objfile
, addr_index
,
20352 cu
->addr_base
, cu
->header
.addr_size
);
20355 /* Given a pointer to an leb128 value, fetch the value from .debug_addr. */
20358 read_addr_index_from_leb128 (struct dwarf2_cu
*cu
, const gdb_byte
*info_ptr
,
20359 unsigned int *bytes_read
)
20361 bfd
*abfd
= cu
->per_objfile
->objfile
->obfd
;
20362 unsigned int addr_index
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
20364 return read_addr_index (cu
, addr_index
);
20370 dwarf2_read_addr_index (dwarf2_per_cu_data
*per_cu
,
20371 dwarf2_per_objfile
*per_objfile
,
20372 unsigned int addr_index
)
20374 struct dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
20375 gdb::optional
<ULONGEST
> addr_base
;
20378 /* We need addr_base and addr_size.
20379 If we don't have PER_CU->cu, we have to get it.
20380 Nasty, but the alternative is storing the needed info in PER_CU,
20381 which at this point doesn't seem justified: it's not clear how frequently
20382 it would get used and it would increase the size of every PER_CU.
20383 Entry points like dwarf2_per_cu_addr_size do a similar thing
20384 so we're not in uncharted territory here.
20385 Alas we need to be a bit more complicated as addr_base is contained
20388 We don't need to read the entire CU(/TU).
20389 We just need the header and top level die.
20391 IWBN to use the aging mechanism to let us lazily later discard the CU.
20392 For now we skip this optimization. */
20396 addr_base
= cu
->addr_base
;
20397 addr_size
= cu
->header
.addr_size
;
20401 cutu_reader
reader (per_cu
, per_objfile
, nullptr, nullptr, false);
20402 addr_base
= reader
.cu
->addr_base
;
20403 addr_size
= reader
.cu
->header
.addr_size
;
20406 return read_addr_index_1 (per_objfile
, addr_index
, addr_base
, addr_size
);
20409 /* Given a DW_FORM_GNU_str_index value STR_INDEX, fetch the string.
20410 STR_SECTION, STR_OFFSETS_SECTION can be from a Fission stub or a
20413 static const char *
20414 read_str_index (struct dwarf2_cu
*cu
,
20415 struct dwarf2_section_info
*str_section
,
20416 struct dwarf2_section_info
*str_offsets_section
,
20417 ULONGEST str_offsets_base
, ULONGEST str_index
)
20419 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
20420 struct objfile
*objfile
= per_objfile
->objfile
;
20421 const char *objf_name
= objfile_name (objfile
);
20422 bfd
*abfd
= objfile
->obfd
;
20423 const gdb_byte
*info_ptr
;
20424 ULONGEST str_offset
;
20425 static const char form_name
[] = "DW_FORM_GNU_str_index or DW_FORM_strx";
20427 str_section
->read (objfile
);
20428 str_offsets_section
->read (objfile
);
20429 if (str_section
->buffer
== NULL
)
20430 error (_("%s used without %s section"
20431 " in CU at offset %s [in module %s]"),
20432 form_name
, str_section
->get_name (),
20433 sect_offset_str (cu
->header
.sect_off
), objf_name
);
20434 if (str_offsets_section
->buffer
== NULL
)
20435 error (_("%s used without %s section"
20436 " in CU at offset %s [in module %s]"),
20437 form_name
, str_section
->get_name (),
20438 sect_offset_str (cu
->header
.sect_off
), objf_name
);
20439 info_ptr
= (str_offsets_section
->buffer
20441 + str_index
* cu
->header
.offset_size
);
20442 if (cu
->header
.offset_size
== 4)
20443 str_offset
= bfd_get_32 (abfd
, info_ptr
);
20445 str_offset
= bfd_get_64 (abfd
, info_ptr
);
20446 if (str_offset
>= str_section
->size
)
20447 error (_("Offset from %s pointing outside of"
20448 " .debug_str.dwo section in CU at offset %s [in module %s]"),
20449 form_name
, sect_offset_str (cu
->header
.sect_off
), objf_name
);
20450 return (const char *) (str_section
->buffer
+ str_offset
);
20453 /* Given a DW_FORM_GNU_str_index from a DWO file, fetch the string. */
20455 static const char *
20456 read_dwo_str_index (const struct die_reader_specs
*reader
, ULONGEST str_index
)
20458 ULONGEST str_offsets_base
= reader
->cu
->header
.version
>= 5
20459 ? reader
->cu
->header
.addr_size
: 0;
20460 return read_str_index (reader
->cu
,
20461 &reader
->dwo_file
->sections
.str
,
20462 &reader
->dwo_file
->sections
.str_offsets
,
20463 str_offsets_base
, str_index
);
20466 /* Given a DW_FORM_GNU_str_index from a Fission stub, fetch the string. */
20468 static const char *
20469 read_stub_str_index (struct dwarf2_cu
*cu
, ULONGEST str_index
)
20471 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
20472 const char *objf_name
= objfile_name (objfile
);
20473 static const char form_name
[] = "DW_FORM_GNU_str_index";
20474 static const char str_offsets_attr_name
[] = "DW_AT_str_offsets";
20476 if (!cu
->str_offsets_base
.has_value ())
20477 error (_("%s used in Fission stub without %s"
20478 " in CU at offset 0x%lx [in module %s]"),
20479 form_name
, str_offsets_attr_name
,
20480 (long) cu
->header
.offset_size
, objf_name
);
20482 return read_str_index (cu
,
20483 &cu
->per_objfile
->per_bfd
->str
,
20484 &cu
->per_objfile
->per_bfd
->str_offsets
,
20485 *cu
->str_offsets_base
, str_index
);
20488 /* Return the length of an LEB128 number in BUF. */
20491 leb128_size (const gdb_byte
*buf
)
20493 const gdb_byte
*begin
= buf
;
20499 if ((byte
& 128) == 0)
20500 return buf
- begin
;
20504 static enum language
20505 dwarf_lang_to_enum_language (unsigned int lang
)
20507 enum language language
;
20516 language
= language_c
;
20519 case DW_LANG_C_plus_plus
:
20520 case DW_LANG_C_plus_plus_11
:
20521 case DW_LANG_C_plus_plus_14
:
20522 language
= language_cplus
;
20525 language
= language_d
;
20527 case DW_LANG_Fortran77
:
20528 case DW_LANG_Fortran90
:
20529 case DW_LANG_Fortran95
:
20530 case DW_LANG_Fortran03
:
20531 case DW_LANG_Fortran08
:
20532 language
= language_fortran
;
20535 language
= language_go
;
20537 case DW_LANG_Mips_Assembler
:
20538 language
= language_asm
;
20540 case DW_LANG_Ada83
:
20541 case DW_LANG_Ada95
:
20542 language
= language_ada
;
20544 case DW_LANG_Modula2
:
20545 language
= language_m2
;
20547 case DW_LANG_Pascal83
:
20548 language
= language_pascal
;
20551 language
= language_objc
;
20554 case DW_LANG_Rust_old
:
20555 language
= language_rust
;
20557 case DW_LANG_OpenCL
:
20558 language
= language_opencl
;
20560 case DW_LANG_Cobol74
:
20561 case DW_LANG_Cobol85
:
20563 language
= language_minimal
;
20570 /* Return the named attribute or NULL if not there. */
20572 static struct attribute
*
20573 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
20578 struct attribute
*spec
= NULL
;
20580 for (i
= 0; i
< die
->num_attrs
; ++i
)
20582 if (die
->attrs
[i
].name
== name
)
20583 return &die
->attrs
[i
];
20584 if (die
->attrs
[i
].name
== DW_AT_specification
20585 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
20586 spec
= &die
->attrs
[i
];
20592 die
= follow_die_ref (die
, spec
, &cu
);
20598 /* Return the string associated with a string-typed attribute, or NULL if it
20599 is either not found or is of an incorrect type. */
20601 static const char *
20602 dwarf2_string_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
20604 struct attribute
*attr
;
20605 const char *str
= NULL
;
20607 attr
= dwarf2_attr (die
, name
, cu
);
20611 str
= attr
->as_string ();
20612 if (str
== nullptr)
20613 complaint (_("string type expected for attribute %s for "
20614 "DIE at %s in module %s"),
20615 dwarf_attr_name (name
), sect_offset_str (die
->sect_off
),
20616 objfile_name (cu
->per_objfile
->objfile
));
20622 /* Return the dwo name or NULL if not present. If present, it is in either
20623 DW_AT_GNU_dwo_name or DW_AT_dwo_name attribute. */
20624 static const char *
20625 dwarf2_dwo_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
20627 const char *dwo_name
= dwarf2_string_attr (die
, DW_AT_GNU_dwo_name
, cu
);
20628 if (dwo_name
== nullptr)
20629 dwo_name
= dwarf2_string_attr (die
, DW_AT_dwo_name
, cu
);
20633 /* Return non-zero iff the attribute NAME is defined for the given DIE,
20634 and holds a non-zero value. This function should only be used for
20635 DW_FORM_flag or DW_FORM_flag_present attributes. */
20638 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
20640 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
20642 return attr
!= nullptr && attr
->as_boolean ();
20646 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
20648 /* A DIE is a declaration if it has a DW_AT_declaration attribute
20649 which value is non-zero. However, we have to be careful with
20650 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
20651 (via dwarf2_flag_true_p) follows this attribute. So we may
20652 end up accidently finding a declaration attribute that belongs
20653 to a different DIE referenced by the specification attribute,
20654 even though the given DIE does not have a declaration attribute. */
20655 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
20656 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
20659 /* Return the die giving the specification for DIE, if there is
20660 one. *SPEC_CU is the CU containing DIE on input, and the CU
20661 containing the return value on output. If there is no
20662 specification, but there is an abstract origin, that is
20665 static struct die_info
*
20666 die_specification (struct die_info
*die
, struct dwarf2_cu
**spec_cu
)
20668 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
,
20671 if (spec_attr
== NULL
)
20672 spec_attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, *spec_cu
);
20674 if (spec_attr
== NULL
)
20677 return follow_die_ref (die
, spec_attr
, spec_cu
);
20680 /* A convenience function to find the proper .debug_line section for a CU. */
20682 static struct dwarf2_section_info
*
20683 get_debug_line_section (struct dwarf2_cu
*cu
)
20685 struct dwarf2_section_info
*section
;
20686 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
20688 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
20690 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
20691 section
= &cu
->dwo_unit
->dwo_file
->sections
.line
;
20692 else if (cu
->per_cu
->is_dwz
)
20694 dwz_file
*dwz
= dwarf2_get_dwz_file (per_objfile
->per_bfd
, true);
20696 section
= &dwz
->line
;
20699 section
= &per_objfile
->per_bfd
->line
;
20704 /* Read the statement program header starting at OFFSET in
20705 .debug_line, or .debug_line.dwo. Return a pointer
20706 to a struct line_header, allocated using xmalloc.
20707 Returns NULL if there is a problem reading the header, e.g., if it
20708 has a version we don't understand.
20710 NOTE: the strings in the include directory and file name tables of
20711 the returned object point into the dwarf line section buffer,
20712 and must not be freed. */
20714 static line_header_up
20715 dwarf_decode_line_header (sect_offset sect_off
, struct dwarf2_cu
*cu
)
20717 struct dwarf2_section_info
*section
;
20718 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
20720 section
= get_debug_line_section (cu
);
20721 section
->read (per_objfile
->objfile
);
20722 if (section
->buffer
== NULL
)
20724 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
20725 complaint (_("missing .debug_line.dwo section"));
20727 complaint (_("missing .debug_line section"));
20731 return dwarf_decode_line_header (sect_off
, cu
->per_cu
->is_dwz
,
20732 per_objfile
, section
, &cu
->header
);
20735 /* Subroutine of dwarf_decode_lines to simplify it.
20736 Return the file name for the given file_entry.
20737 CU_INFO describes the CU's DW_AT_name and DW_AT_comp_dir.
20738 If space for the result is malloc'd, *NAME_HOLDER will be set.
20739 Returns NULL if FILE_INDEX should be ignored, i.e., it is
20740 equivalent to CU_INFO. */
20742 static const char *
20743 compute_include_file_name (const struct line_header
*lh
, const file_entry
&fe
,
20744 const file_and_directory
&cu_info
,
20745 gdb::unique_xmalloc_ptr
<char> *name_holder
)
20747 const char *include_name
= fe
.name
;
20748 const char *include_name_to_compare
= include_name
;
20750 const char *dir_name
= fe
.include_dir (lh
);
20752 gdb::unique_xmalloc_ptr
<char> hold_compare
;
20753 if (!IS_ABSOLUTE_PATH (include_name
)
20754 && (dir_name
!= NULL
|| cu_info
.comp_dir
!= NULL
))
20756 /* Avoid creating a duplicate name for CU_INFO.
20757 We do this by comparing INCLUDE_NAME and CU_INFO.
20758 Before we do the comparison, however, we need to account
20759 for DIR_NAME and COMP_DIR.
20760 First prepend dir_name (if non-NULL). If we still don't
20761 have an absolute path prepend comp_dir (if non-NULL).
20762 However, the directory we record in the include-file's
20763 psymtab does not contain COMP_DIR (to match the
20764 corresponding symtab(s)).
20769 bash$ gcc -g ./hello.c
20770 include_name = "hello.c"
20772 DW_AT_comp_dir = comp_dir = "/tmp"
20773 DW_AT_name = "./hello.c"
20777 if (dir_name
!= NULL
)
20779 name_holder
->reset (concat (dir_name
, SLASH_STRING
,
20780 include_name
, (char *) NULL
));
20781 include_name
= name_holder
->get ();
20782 include_name_to_compare
= include_name
;
20784 if (!IS_ABSOLUTE_PATH (include_name
) && cu_info
.comp_dir
!= nullptr)
20786 hold_compare
.reset (concat (cu_info
.comp_dir
, SLASH_STRING
,
20787 include_name
, (char *) NULL
));
20788 include_name_to_compare
= hold_compare
.get ();
20792 gdb::unique_xmalloc_ptr
<char> copied_name
;
20793 const char *cu_filename
= cu_info
.name
;
20794 if (!IS_ABSOLUTE_PATH (cu_filename
) && cu_info
.comp_dir
!= nullptr)
20796 copied_name
.reset (concat (cu_info
.comp_dir
, SLASH_STRING
,
20797 cu_filename
, (char *) NULL
));
20798 cu_filename
= copied_name
.get ();
20801 if (FILENAME_CMP (include_name_to_compare
, cu_filename
) == 0)
20803 return include_name
;
20806 /* State machine to track the state of the line number program. */
20808 class lnp_state_machine
20811 /* Initialize a machine state for the start of a line number
20813 lnp_state_machine (struct dwarf2_cu
*cu
, gdbarch
*arch
, line_header
*lh
,
20814 bool record_lines_p
);
20816 file_entry
*current_file ()
20818 /* lh->file_names is 0-based, but the file name numbers in the
20819 statement program are 1-based. */
20820 return m_line_header
->file_name_at (m_file
);
20823 /* Record the line in the state machine. END_SEQUENCE is true if
20824 we're processing the end of a sequence. */
20825 void record_line (bool end_sequence
);
20827 /* Check ADDRESS is -1, or zero and less than UNRELOCATED_LOWPC, and if true
20828 nop-out rest of the lines in this sequence. */
20829 void check_line_address (struct dwarf2_cu
*cu
,
20830 const gdb_byte
*line_ptr
,
20831 CORE_ADDR unrelocated_lowpc
, CORE_ADDR address
);
20833 void handle_set_discriminator (unsigned int discriminator
)
20835 m_discriminator
= discriminator
;
20836 m_line_has_non_zero_discriminator
|= discriminator
!= 0;
20839 /* Handle DW_LNE_set_address. */
20840 void handle_set_address (CORE_ADDR baseaddr
, CORE_ADDR address
)
20843 address
+= baseaddr
;
20844 m_address
= gdbarch_adjust_dwarf2_line (m_gdbarch
, address
, false);
20847 /* Handle DW_LNS_advance_pc. */
20848 void handle_advance_pc (CORE_ADDR adjust
);
20850 /* Handle a special opcode. */
20851 void handle_special_opcode (unsigned char op_code
);
20853 /* Handle DW_LNS_advance_line. */
20854 void handle_advance_line (int line_delta
)
20856 advance_line (line_delta
);
20859 /* Handle DW_LNS_set_file. */
20860 void handle_set_file (file_name_index file
);
20862 /* Handle DW_LNS_negate_stmt. */
20863 void handle_negate_stmt ()
20865 m_is_stmt
= !m_is_stmt
;
20868 /* Handle DW_LNS_const_add_pc. */
20869 void handle_const_add_pc ();
20871 /* Handle DW_LNS_fixed_advance_pc. */
20872 void handle_fixed_advance_pc (CORE_ADDR addr_adj
)
20874 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
20878 /* Handle DW_LNS_copy. */
20879 void handle_copy ()
20881 record_line (false);
20882 m_discriminator
= 0;
20885 /* Handle DW_LNE_end_sequence. */
20886 void handle_end_sequence ()
20888 m_currently_recording_lines
= true;
20892 /* Advance the line by LINE_DELTA. */
20893 void advance_line (int line_delta
)
20895 m_line
+= line_delta
;
20897 if (line_delta
!= 0)
20898 m_line_has_non_zero_discriminator
= m_discriminator
!= 0;
20901 struct dwarf2_cu
*m_cu
;
20903 gdbarch
*m_gdbarch
;
20905 /* True if we're recording lines.
20906 Otherwise we're building partial symtabs and are just interested in
20907 finding include files mentioned by the line number program. */
20908 bool m_record_lines_p
;
20910 /* The line number header. */
20911 line_header
*m_line_header
;
20913 /* These are part of the standard DWARF line number state machine,
20914 and initialized according to the DWARF spec. */
20916 unsigned char m_op_index
= 0;
20917 /* The line table index of the current file. */
20918 file_name_index m_file
= 1;
20919 unsigned int m_line
= 1;
20921 /* These are initialized in the constructor. */
20923 CORE_ADDR m_address
;
20925 unsigned int m_discriminator
;
20927 /* Additional bits of state we need to track. */
20929 /* The last file that we called dwarf2_start_subfile for.
20930 This is only used for TLLs. */
20931 unsigned int m_last_file
= 0;
20932 /* The last file a line number was recorded for. */
20933 struct subfile
*m_last_subfile
= NULL
;
20935 /* The address of the last line entry. */
20936 CORE_ADDR m_last_address
;
20938 /* Set to true when a previous line at the same address (using
20939 m_last_address) had m_is_stmt true. This is reset to false when a
20940 line entry at a new address (m_address different to m_last_address) is
20942 bool m_stmt_at_address
= false;
20944 /* When true, record the lines we decode. */
20945 bool m_currently_recording_lines
= false;
20947 /* The last line number that was recorded, used to coalesce
20948 consecutive entries for the same line. This can happen, for
20949 example, when discriminators are present. PR 17276. */
20950 unsigned int m_last_line
= 0;
20951 bool m_line_has_non_zero_discriminator
= false;
20955 lnp_state_machine::handle_advance_pc (CORE_ADDR adjust
)
20957 CORE_ADDR addr_adj
= (((m_op_index
+ adjust
)
20958 / m_line_header
->maximum_ops_per_instruction
)
20959 * m_line_header
->minimum_instruction_length
);
20960 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
20961 m_op_index
= ((m_op_index
+ adjust
)
20962 % m_line_header
->maximum_ops_per_instruction
);
20966 lnp_state_machine::handle_special_opcode (unsigned char op_code
)
20968 unsigned char adj_opcode
= op_code
- m_line_header
->opcode_base
;
20969 unsigned char adj_opcode_d
= adj_opcode
/ m_line_header
->line_range
;
20970 unsigned char adj_opcode_r
= adj_opcode
% m_line_header
->line_range
;
20971 CORE_ADDR addr_adj
= (((m_op_index
+ adj_opcode_d
)
20972 / m_line_header
->maximum_ops_per_instruction
)
20973 * m_line_header
->minimum_instruction_length
);
20974 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
20975 m_op_index
= ((m_op_index
+ adj_opcode_d
)
20976 % m_line_header
->maximum_ops_per_instruction
);
20978 int line_delta
= m_line_header
->line_base
+ adj_opcode_r
;
20979 advance_line (line_delta
);
20980 record_line (false);
20981 m_discriminator
= 0;
20985 lnp_state_machine::handle_set_file (file_name_index file
)
20989 const file_entry
*fe
= current_file ();
20991 dwarf2_debug_line_missing_file_complaint ();
20992 else if (m_record_lines_p
)
20994 const char *dir
= fe
->include_dir (m_line_header
);
20996 m_last_subfile
= m_cu
->get_builder ()->get_current_subfile ();
20997 m_line_has_non_zero_discriminator
= m_discriminator
!= 0;
20998 dwarf2_start_subfile (m_cu
, fe
->name
, dir
);
21003 lnp_state_machine::handle_const_add_pc ()
21006 = (255 - m_line_header
->opcode_base
) / m_line_header
->line_range
;
21009 = (((m_op_index
+ adjust
)
21010 / m_line_header
->maximum_ops_per_instruction
)
21011 * m_line_header
->minimum_instruction_length
);
21013 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
21014 m_op_index
= ((m_op_index
+ adjust
)
21015 % m_line_header
->maximum_ops_per_instruction
);
21018 /* Return non-zero if we should add LINE to the line number table.
21019 LINE is the line to add, LAST_LINE is the last line that was added,
21020 LAST_SUBFILE is the subfile for LAST_LINE.
21021 LINE_HAS_NON_ZERO_DISCRIMINATOR is non-zero if LINE has ever
21022 had a non-zero discriminator.
21024 We have to be careful in the presence of discriminators.
21025 E.g., for this line:
21027 for (i = 0; i < 100000; i++);
21029 clang can emit four line number entries for that one line,
21030 each with a different discriminator.
21031 See gdb.dwarf2/dw2-single-line-discriminators.exp for an example.
21033 However, we want gdb to coalesce all four entries into one.
21034 Otherwise the user could stepi into the middle of the line and
21035 gdb would get confused about whether the pc really was in the
21036 middle of the line.
21038 Things are further complicated by the fact that two consecutive
21039 line number entries for the same line is a heuristic used by gcc
21040 to denote the end of the prologue. So we can't just discard duplicate
21041 entries, we have to be selective about it. The heuristic we use is
21042 that we only collapse consecutive entries for the same line if at least
21043 one of those entries has a non-zero discriminator. PR 17276.
21045 Note: Addresses in the line number state machine can never go backwards
21046 within one sequence, thus this coalescing is ok. */
21049 dwarf_record_line_p (struct dwarf2_cu
*cu
,
21050 unsigned int line
, unsigned int last_line
,
21051 int line_has_non_zero_discriminator
,
21052 struct subfile
*last_subfile
)
21054 if (cu
->get_builder ()->get_current_subfile () != last_subfile
)
21056 if (line
!= last_line
)
21058 /* Same line for the same file that we've seen already.
21059 As a last check, for pr 17276, only record the line if the line
21060 has never had a non-zero discriminator. */
21061 if (!line_has_non_zero_discriminator
)
21066 /* Use the CU's builder to record line number LINE beginning at
21067 address ADDRESS in the line table of subfile SUBFILE. */
21070 dwarf_record_line_1 (struct gdbarch
*gdbarch
, struct subfile
*subfile
,
21071 unsigned int line
, CORE_ADDR address
, bool is_stmt
,
21072 struct dwarf2_cu
*cu
)
21074 CORE_ADDR addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
21076 if (dwarf_line_debug
)
21078 fprintf_unfiltered (gdb_stdlog
,
21079 "Recording line %u, file %s, address %s\n",
21080 line
, lbasename (subfile
->name
),
21081 paddress (gdbarch
, address
));
21085 cu
->get_builder ()->record_line (subfile
, line
, addr
, is_stmt
);
21088 /* Subroutine of dwarf_decode_lines_1 to simplify it.
21089 Mark the end of a set of line number records.
21090 The arguments are the same as for dwarf_record_line_1.
21091 If SUBFILE is NULL the request is ignored. */
21094 dwarf_finish_line (struct gdbarch
*gdbarch
, struct subfile
*subfile
,
21095 CORE_ADDR address
, struct dwarf2_cu
*cu
)
21097 if (subfile
== NULL
)
21100 if (dwarf_line_debug
)
21102 fprintf_unfiltered (gdb_stdlog
,
21103 "Finishing current line, file %s, address %s\n",
21104 lbasename (subfile
->name
),
21105 paddress (gdbarch
, address
));
21108 dwarf_record_line_1 (gdbarch
, subfile
, 0, address
, true, cu
);
21112 lnp_state_machine::record_line (bool end_sequence
)
21114 if (dwarf_line_debug
)
21116 fprintf_unfiltered (gdb_stdlog
,
21117 "Processing actual line %u: file %u,"
21118 " address %s, is_stmt %u, discrim %u%s\n",
21120 paddress (m_gdbarch
, m_address
),
21121 m_is_stmt
, m_discriminator
,
21122 (end_sequence
? "\t(end sequence)" : ""));
21125 file_entry
*fe
= current_file ();
21128 dwarf2_debug_line_missing_file_complaint ();
21129 /* For now we ignore lines not starting on an instruction boundary.
21130 But not when processing end_sequence for compatibility with the
21131 previous version of the code. */
21132 else if (m_op_index
== 0 || end_sequence
)
21134 fe
->included_p
= true;
21135 if (m_record_lines_p
)
21137 /* When we switch files we insert an end maker in the first file,
21138 switch to the second file and add a new line entry. The
21139 problem is that the end marker inserted in the first file will
21140 discard any previous line entries at the same address. If the
21141 line entries in the first file are marked as is-stmt, while
21142 the new line in the second file is non-stmt, then this means
21143 the end marker will discard is-stmt lines so we can have a
21144 non-stmt line. This means that there are less addresses at
21145 which the user can insert a breakpoint.
21147 To improve this we track the last address in m_last_address,
21148 and whether we have seen an is-stmt at this address. Then
21149 when switching files, if we have seen a stmt at the current
21150 address, and we are switching to create a non-stmt line, then
21151 discard the new line. */
21153 = m_last_subfile
!= m_cu
->get_builder ()->get_current_subfile ();
21154 bool ignore_this_line
21155 = ((file_changed
&& !end_sequence
&& m_last_address
== m_address
21156 && !m_is_stmt
&& m_stmt_at_address
)
21157 || (!end_sequence
&& m_line
== 0));
21159 if ((file_changed
&& !ignore_this_line
) || end_sequence
)
21161 dwarf_finish_line (m_gdbarch
, m_last_subfile
, m_address
,
21162 m_currently_recording_lines
? m_cu
: nullptr);
21165 if (!end_sequence
&& !ignore_this_line
)
21167 bool is_stmt
= producer_is_codewarrior (m_cu
) || m_is_stmt
;
21169 if (dwarf_record_line_p (m_cu
, m_line
, m_last_line
,
21170 m_line_has_non_zero_discriminator
,
21173 buildsym_compunit
*builder
= m_cu
->get_builder ();
21174 dwarf_record_line_1 (m_gdbarch
,
21175 builder
->get_current_subfile (),
21176 m_line
, m_address
, is_stmt
,
21177 m_currently_recording_lines
? m_cu
: nullptr);
21179 m_last_subfile
= m_cu
->get_builder ()->get_current_subfile ();
21180 m_last_line
= m_line
;
21185 /* Track whether we have seen any m_is_stmt true at m_address in case we
21186 have multiple line table entries all at m_address. */
21187 if (m_last_address
!= m_address
)
21189 m_stmt_at_address
= false;
21190 m_last_address
= m_address
;
21192 m_stmt_at_address
|= m_is_stmt
;
21195 lnp_state_machine::lnp_state_machine (struct dwarf2_cu
*cu
, gdbarch
*arch
,
21196 line_header
*lh
, bool record_lines_p
)
21200 m_record_lines_p
= record_lines_p
;
21201 m_line_header
= lh
;
21203 m_currently_recording_lines
= true;
21205 /* Call `gdbarch_adjust_dwarf2_line' on the initial 0 address as if there
21206 was a line entry for it so that the backend has a chance to adjust it
21207 and also record it in case it needs it. This is currently used by MIPS
21208 code, cf. `mips_adjust_dwarf2_line'. */
21209 m_address
= gdbarch_adjust_dwarf2_line (arch
, 0, 0);
21210 m_is_stmt
= lh
->default_is_stmt
;
21211 m_discriminator
= 0;
21213 m_last_address
= m_address
;
21214 m_stmt_at_address
= false;
21218 lnp_state_machine::check_line_address (struct dwarf2_cu
*cu
,
21219 const gdb_byte
*line_ptr
,
21220 CORE_ADDR unrelocated_lowpc
, CORE_ADDR address
)
21222 /* Linkers resolve a symbolic relocation referencing a GC'd function to 0 or
21223 -1. If ADDRESS is 0, ignoring the opcode will err if the text section is
21224 located at 0x0. In this case, additionally check that if
21225 ADDRESS < UNRELOCATED_LOWPC. */
21227 if ((address
== 0 && address
< unrelocated_lowpc
)
21228 || address
== (CORE_ADDR
) -1)
21230 /* This line table is for a function which has been
21231 GCd by the linker. Ignore it. PR gdb/12528 */
21233 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
21234 long line_offset
= line_ptr
- get_debug_line_section (cu
)->buffer
;
21236 complaint (_(".debug_line address at offset 0x%lx is 0 [in module %s]"),
21237 line_offset
, objfile_name (objfile
));
21238 m_currently_recording_lines
= false;
21239 /* Note: m_currently_recording_lines is left as false until we see
21240 DW_LNE_end_sequence. */
21244 /* Subroutine of dwarf_decode_lines to simplify it.
21245 Process the line number information in LH.
21246 If DECODE_FOR_PST_P is non-zero, all we do is process the line number
21247 program in order to set included_p for every referenced header. */
21250 dwarf_decode_lines_1 (struct line_header
*lh
, struct dwarf2_cu
*cu
,
21251 const int decode_for_pst_p
, CORE_ADDR lowpc
)
21253 const gdb_byte
*line_ptr
, *extended_end
;
21254 const gdb_byte
*line_end
;
21255 unsigned int bytes_read
, extended_len
;
21256 unsigned char op_code
, extended_op
;
21257 CORE_ADDR baseaddr
;
21258 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
21259 bfd
*abfd
= objfile
->obfd
;
21260 struct gdbarch
*gdbarch
= objfile
->arch ();
21261 /* True if we're recording line info (as opposed to building partial
21262 symtabs and just interested in finding include files mentioned by
21263 the line number program). */
21264 bool record_lines_p
= !decode_for_pst_p
;
21266 baseaddr
= objfile
->text_section_offset ();
21268 line_ptr
= lh
->statement_program_start
;
21269 line_end
= lh
->statement_program_end
;
21271 /* Read the statement sequences until there's nothing left. */
21272 while (line_ptr
< line_end
)
21274 /* The DWARF line number program state machine. Reset the state
21275 machine at the start of each sequence. */
21276 lnp_state_machine
state_machine (cu
, gdbarch
, lh
, record_lines_p
);
21277 bool end_sequence
= false;
21279 if (record_lines_p
)
21281 /* Start a subfile for the current file of the state
21283 const file_entry
*fe
= state_machine
.current_file ();
21286 dwarf2_start_subfile (cu
, fe
->name
, fe
->include_dir (lh
));
21289 /* Decode the table. */
21290 while (line_ptr
< line_end
&& !end_sequence
)
21292 op_code
= read_1_byte (abfd
, line_ptr
);
21295 if (op_code
>= lh
->opcode_base
)
21297 /* Special opcode. */
21298 state_machine
.handle_special_opcode (op_code
);
21300 else switch (op_code
)
21302 case DW_LNS_extended_op
:
21303 extended_len
= read_unsigned_leb128 (abfd
, line_ptr
,
21305 line_ptr
+= bytes_read
;
21306 extended_end
= line_ptr
+ extended_len
;
21307 extended_op
= read_1_byte (abfd
, line_ptr
);
21309 if (DW_LNE_lo_user
<= extended_op
21310 && extended_op
<= DW_LNE_hi_user
)
21312 /* Vendor extension, ignore. */
21313 line_ptr
= extended_end
;
21316 switch (extended_op
)
21318 case DW_LNE_end_sequence
:
21319 state_machine
.handle_end_sequence ();
21320 end_sequence
= true;
21322 case DW_LNE_set_address
:
21325 = cu
->header
.read_address (abfd
, line_ptr
, &bytes_read
);
21326 line_ptr
+= bytes_read
;
21328 state_machine
.check_line_address (cu
, line_ptr
,
21329 lowpc
- baseaddr
, address
);
21330 state_machine
.handle_set_address (baseaddr
, address
);
21333 case DW_LNE_define_file
:
21335 const char *cur_file
;
21336 unsigned int mod_time
, length
;
21339 cur_file
= read_direct_string (abfd
, line_ptr
,
21341 line_ptr
+= bytes_read
;
21342 dindex
= (dir_index
)
21343 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21344 line_ptr
+= bytes_read
;
21346 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21347 line_ptr
+= bytes_read
;
21349 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21350 line_ptr
+= bytes_read
;
21351 lh
->add_file_name (cur_file
, dindex
, mod_time
, length
);
21354 case DW_LNE_set_discriminator
:
21356 /* The discriminator is not interesting to the
21357 debugger; just ignore it. We still need to
21358 check its value though:
21359 if there are consecutive entries for the same
21360 (non-prologue) line we want to coalesce them.
21363 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21364 line_ptr
+= bytes_read
;
21366 state_machine
.handle_set_discriminator (discr
);
21370 complaint (_("mangled .debug_line section"));
21373 /* Make sure that we parsed the extended op correctly. If e.g.
21374 we expected a different address size than the producer used,
21375 we may have read the wrong number of bytes. */
21376 if (line_ptr
!= extended_end
)
21378 complaint (_("mangled .debug_line section"));
21383 state_machine
.handle_copy ();
21385 case DW_LNS_advance_pc
:
21388 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21389 line_ptr
+= bytes_read
;
21391 state_machine
.handle_advance_pc (adjust
);
21394 case DW_LNS_advance_line
:
21397 = read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
21398 line_ptr
+= bytes_read
;
21400 state_machine
.handle_advance_line (line_delta
);
21403 case DW_LNS_set_file
:
21405 file_name_index file
21406 = (file_name_index
) read_unsigned_leb128 (abfd
, line_ptr
,
21408 line_ptr
+= bytes_read
;
21410 state_machine
.handle_set_file (file
);
21413 case DW_LNS_set_column
:
21414 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21415 line_ptr
+= bytes_read
;
21417 case DW_LNS_negate_stmt
:
21418 state_machine
.handle_negate_stmt ();
21420 case DW_LNS_set_basic_block
:
21422 /* Add to the address register of the state machine the
21423 address increment value corresponding to special opcode
21424 255. I.e., this value is scaled by the minimum
21425 instruction length since special opcode 255 would have
21426 scaled the increment. */
21427 case DW_LNS_const_add_pc
:
21428 state_machine
.handle_const_add_pc ();
21430 case DW_LNS_fixed_advance_pc
:
21432 CORE_ADDR addr_adj
= read_2_bytes (abfd
, line_ptr
);
21435 state_machine
.handle_fixed_advance_pc (addr_adj
);
21440 /* Unknown standard opcode, ignore it. */
21443 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
21445 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21446 line_ptr
+= bytes_read
;
21453 dwarf2_debug_line_missing_end_sequence_complaint ();
21455 /* We got a DW_LNE_end_sequence (or we ran off the end of the buffer,
21456 in which case we still finish recording the last line). */
21457 state_machine
.record_line (true);
21461 /* Decode the Line Number Program (LNP) for the given line_header
21462 structure and CU. The actual information extracted and the type
21463 of structures created from the LNP depends on the value of PST.
21465 1. If PST is NULL, then this procedure uses the data from the program
21466 to create all necessary symbol tables, and their linetables.
21468 2. If PST is not NULL, this procedure reads the program to determine
21469 the list of files included by the unit represented by PST, and
21470 builds all the associated partial symbol tables.
21472 FND holds the CU file name and directory, if known.
21473 It is used for relative paths in the line table.
21475 NOTE: It is important that psymtabs have the same file name (via
21476 strcmp) as the corresponding symtab. Since the directory is not
21477 used in the name of the symtab we don't use it in the name of the
21478 psymtabs we create. E.g. expand_line_sal requires this when
21479 finding psymtabs to expand. A good testcase for this is
21482 LOWPC is the lowest address in CU (or 0 if not known).
21484 Boolean DECODE_MAPPING specifies we need to fully decode .debug_line
21485 for its PC<->lines mapping information. Otherwise only the filename
21486 table is read in. */
21489 dwarf_decode_lines (struct line_header
*lh
, const file_and_directory
&fnd
,
21490 struct dwarf2_cu
*cu
, dwarf2_psymtab
*pst
,
21491 CORE_ADDR lowpc
, int decode_mapping
)
21493 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
21494 const int decode_for_pst_p
= (pst
!= NULL
);
21496 if (decode_mapping
)
21497 dwarf_decode_lines_1 (lh
, cu
, decode_for_pst_p
, lowpc
);
21499 if (decode_for_pst_p
)
21501 /* Now that we're done scanning the Line Header Program, we can
21502 create the psymtab of each included file. */
21503 for (auto &file_entry
: lh
->file_names ())
21504 if (file_entry
.included_p
)
21506 gdb::unique_xmalloc_ptr
<char> name_holder
;
21507 const char *include_name
=
21508 compute_include_file_name (lh
, file_entry
, fnd
, &name_holder
);
21509 if (include_name
!= NULL
)
21510 dwarf2_create_include_psymtab
21511 (cu
->per_objfile
->per_bfd
, include_name
, pst
,
21512 cu
->per_objfile
->per_bfd
->partial_symtabs
.get (),
21518 /* Make sure a symtab is created for every file, even files
21519 which contain only variables (i.e. no code with associated
21521 buildsym_compunit
*builder
= cu
->get_builder ();
21522 struct compunit_symtab
*cust
= builder
->get_compunit_symtab ();
21524 for (auto &fe
: lh
->file_names ())
21526 dwarf2_start_subfile (cu
, fe
.name
, fe
.include_dir (lh
));
21527 if (builder
->get_current_subfile ()->symtab
== NULL
)
21529 builder
->get_current_subfile ()->symtab
21530 = allocate_symtab (cust
,
21531 builder
->get_current_subfile ()->name
);
21533 fe
.symtab
= builder
->get_current_subfile ()->symtab
;
21538 /* Start a subfile for DWARF. FILENAME is the name of the file and
21539 DIRNAME the name of the source directory which contains FILENAME
21540 or NULL if not known.
21541 This routine tries to keep line numbers from identical absolute and
21542 relative file names in a common subfile.
21544 Using the `list' example from the GDB testsuite, which resides in
21545 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
21546 of /srcdir/list0.c yields the following debugging information for list0.c:
21548 DW_AT_name: /srcdir/list0.c
21549 DW_AT_comp_dir: /compdir
21550 files.files[0].name: list0.h
21551 files.files[0].dir: /srcdir
21552 files.files[1].name: list0.c
21553 files.files[1].dir: /srcdir
21555 The line number information for list0.c has to end up in a single
21556 subfile, so that `break /srcdir/list0.c:1' works as expected.
21557 start_subfile will ensure that this happens provided that we pass the
21558 concatenation of files.files[1].dir and files.files[1].name as the
21562 dwarf2_start_subfile (struct dwarf2_cu
*cu
, const char *filename
,
21563 const char *dirname
)
21565 gdb::unique_xmalloc_ptr
<char> copy
;
21567 /* In order not to lose the line information directory,
21568 we concatenate it to the filename when it makes sense.
21569 Note that the Dwarf3 standard says (speaking of filenames in line
21570 information): ``The directory index is ignored for file names
21571 that represent full path names''. Thus ignoring dirname in the
21572 `else' branch below isn't an issue. */
21574 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
21576 copy
.reset (concat (dirname
, SLASH_STRING
, filename
, (char *) NULL
));
21577 filename
= copy
.get ();
21580 cu
->get_builder ()->start_subfile (filename
);
21584 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
21585 struct dwarf2_cu
*cu
)
21587 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
21588 struct comp_unit_head
*cu_header
= &cu
->header
;
21590 /* NOTE drow/2003-01-30: There used to be a comment and some special
21591 code here to turn a symbol with DW_AT_external and a
21592 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
21593 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
21594 with some versions of binutils) where shared libraries could have
21595 relocations against symbols in their debug information - the
21596 minimal symbol would have the right address, but the debug info
21597 would not. It's no longer necessary, because we will explicitly
21598 apply relocations when we read in the debug information now. */
21600 /* A DW_AT_location attribute with no contents indicates that a
21601 variable has been optimized away. */
21602 if (attr
->form_is_block () && attr
->as_block ()->size
== 0)
21604 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
21608 /* Handle one degenerate form of location expression specially, to
21609 preserve GDB's previous behavior when section offsets are
21610 specified. If this is just a DW_OP_addr, DW_OP_addrx, or
21611 DW_OP_GNU_addr_index then mark this symbol as LOC_STATIC. */
21613 if (attr
->form_is_block ())
21615 struct dwarf_block
*block
= attr
->as_block ();
21617 if ((block
->data
[0] == DW_OP_addr
21618 && block
->size
== 1 + cu_header
->addr_size
)
21619 || ((block
->data
[0] == DW_OP_GNU_addr_index
21620 || block
->data
[0] == DW_OP_addrx
)
21622 == 1 + leb128_size (&block
->data
[1]))))
21624 unsigned int dummy
;
21626 if (block
->data
[0] == DW_OP_addr
)
21627 SET_SYMBOL_VALUE_ADDRESS
21628 (sym
, cu
->header
.read_address (objfile
->obfd
,
21632 SET_SYMBOL_VALUE_ADDRESS
21633 (sym
, read_addr_index_from_leb128 (cu
, block
->data
+ 1,
21635 SYMBOL_ACLASS_INDEX (sym
) = LOC_STATIC
;
21636 fixup_symbol_section (sym
, objfile
);
21637 SET_SYMBOL_VALUE_ADDRESS
21639 SYMBOL_VALUE_ADDRESS (sym
)
21640 + objfile
->section_offsets
[sym
->section_index ()]);
21645 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
21646 expression evaluator, and use LOC_COMPUTED only when necessary
21647 (i.e. when the value of a register or memory location is
21648 referenced, or a thread-local block, etc.). Then again, it might
21649 not be worthwhile. I'm assuming that it isn't unless performance
21650 or memory numbers show me otherwise. */
21652 dwarf2_symbol_mark_computed (attr
, sym
, cu
, 0);
21654 if (SYMBOL_COMPUTED_OPS (sym
)->location_has_loclist
)
21655 cu
->has_loclist
= true;
21658 /* Given a pointer to a DWARF information entry, figure out if we need
21659 to make a symbol table entry for it, and if so, create a new entry
21660 and return a pointer to it.
21661 If TYPE is NULL, determine symbol type from the die, otherwise
21662 used the passed type.
21663 If SPACE is not NULL, use it to hold the new symbol. If it is
21664 NULL, allocate a new symbol on the objfile's obstack. */
21666 static struct symbol
*
21667 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
,
21668 struct symbol
*space
)
21670 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
21671 struct objfile
*objfile
= per_objfile
->objfile
;
21672 struct gdbarch
*gdbarch
= objfile
->arch ();
21673 struct symbol
*sym
= NULL
;
21675 struct attribute
*attr
= NULL
;
21676 struct attribute
*attr2
= NULL
;
21677 CORE_ADDR baseaddr
;
21678 struct pending
**list_to_add
= NULL
;
21680 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
21682 baseaddr
= objfile
->text_section_offset ();
21684 name
= dwarf2_name (die
, cu
);
21687 int suppress_add
= 0;
21692 sym
= new (&objfile
->objfile_obstack
) symbol
;
21693 OBJSTAT (objfile
, n_syms
++);
21695 /* Cache this symbol's name and the name's demangled form (if any). */
21696 sym
->set_language (cu
->per_cu
->lang
, &objfile
->objfile_obstack
);
21697 /* Fortran does not have mangling standard and the mangling does differ
21698 between gfortran, iFort etc. */
21699 const char *physname
21700 = (cu
->per_cu
->lang
== language_fortran
21701 ? dwarf2_full_name (name
, die
, cu
)
21702 : dwarf2_physname (name
, die
, cu
));
21703 const char *linkagename
= dw2_linkage_name (die
, cu
);
21705 if (linkagename
== nullptr || cu
->per_cu
->lang
== language_ada
)
21706 sym
->set_linkage_name (physname
);
21709 sym
->set_demangled_name (physname
, &objfile
->objfile_obstack
);
21710 sym
->set_linkage_name (linkagename
);
21713 /* Handle DW_AT_artificial. */
21714 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
21715 if (attr
!= nullptr)
21716 sym
->artificial
= attr
->as_boolean ();
21718 /* Default assumptions.
21719 Use the passed type or decode it from the die. */
21720 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
21721 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
21723 SYMBOL_TYPE (sym
) = type
;
21725 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
21726 attr
= dwarf2_attr (die
,
21727 inlined_func
? DW_AT_call_line
: DW_AT_decl_line
,
21729 if (attr
!= nullptr)
21730 SYMBOL_LINE (sym
) = attr
->constant_value (0);
21732 attr
= dwarf2_attr (die
,
21733 inlined_func
? DW_AT_call_file
: DW_AT_decl_file
,
21735 if (attr
!= nullptr && attr
->is_nonnegative ())
21737 file_name_index file_index
21738 = (file_name_index
) attr
->as_nonnegative ();
21739 struct file_entry
*fe
;
21741 if (cu
->line_header
!= NULL
)
21742 fe
= cu
->line_header
->file_name_at (file_index
);
21747 complaint (_("file index out of range"));
21749 symbol_set_symtab (sym
, fe
->symtab
);
21755 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
21756 if (attr
!= nullptr)
21760 addr
= attr
->as_address ();
21761 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, addr
+ baseaddr
);
21762 SET_SYMBOL_VALUE_ADDRESS (sym
, addr
);
21763 SYMBOL_ACLASS_INDEX (sym
) = LOC_LABEL
;
21766 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
21767 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_core_addr
;
21768 SYMBOL_DOMAIN (sym
) = LABEL_DOMAIN
;
21769 add_symbol_to_list (sym
, cu
->list_in_scope
);
21771 case DW_TAG_subprogram
:
21772 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21774 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
21775 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
21776 if ((attr2
!= nullptr && attr2
->as_boolean ())
21777 || cu
->per_cu
->lang
== language_ada
21778 || cu
->per_cu
->lang
== language_fortran
)
21780 /* Subprograms marked external are stored as a global symbol.
21781 Ada and Fortran subprograms, whether marked external or
21782 not, are always stored as a global symbol, because we want
21783 to be able to access them globally. For instance, we want
21784 to be able to break on a nested subprogram without having
21785 to specify the context. */
21786 list_to_add
= cu
->get_builder ()->get_global_symbols ();
21790 list_to_add
= cu
->list_in_scope
;
21793 case DW_TAG_inlined_subroutine
:
21794 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21796 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
21797 SYMBOL_INLINED (sym
) = 1;
21798 list_to_add
= cu
->list_in_scope
;
21800 case DW_TAG_template_value_param
:
21802 /* Fall through. */
21803 case DW_TAG_constant
:
21804 case DW_TAG_variable
:
21805 case DW_TAG_member
:
21806 /* Compilation with minimal debug info may result in
21807 variables with missing type entries. Change the
21808 misleading `void' type to something sensible. */
21809 if (SYMBOL_TYPE (sym
)->code () == TYPE_CODE_VOID
)
21810 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_int
;
21812 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
21813 /* In the case of DW_TAG_member, we should only be called for
21814 static const members. */
21815 if (die
->tag
== DW_TAG_member
)
21817 /* dwarf2_add_field uses die_is_declaration,
21818 so we do the same. */
21819 gdb_assert (die_is_declaration (die
, cu
));
21822 if (attr
!= nullptr)
21824 dwarf2_const_value (attr
, sym
, cu
);
21825 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
21828 if (attr2
!= nullptr && attr2
->as_boolean ())
21829 list_to_add
= cu
->get_builder ()->get_global_symbols ();
21831 list_to_add
= cu
->list_in_scope
;
21835 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
21836 if (attr
!= nullptr)
21838 var_decode_location (attr
, sym
, cu
);
21839 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
21841 /* Fortran explicitly imports any global symbols to the local
21842 scope by DW_TAG_common_block. */
21843 if (cu
->per_cu
->lang
== language_fortran
&& die
->parent
21844 && die
->parent
->tag
== DW_TAG_common_block
)
21847 if (SYMBOL_CLASS (sym
) == LOC_STATIC
21848 && SYMBOL_VALUE_ADDRESS (sym
) == 0
21849 && !per_objfile
->per_bfd
->has_section_at_zero
)
21851 /* When a static variable is eliminated by the linker,
21852 the corresponding debug information is not stripped
21853 out, but the variable address is set to null;
21854 do not add such variables into symbol table. */
21856 else if (attr2
!= nullptr && attr2
->as_boolean ())
21858 if (SYMBOL_CLASS (sym
) == LOC_STATIC
21859 && (objfile
->flags
& OBJF_MAINLINE
) == 0
21860 && per_objfile
->per_bfd
->can_copy
)
21862 /* A global static variable might be subject to
21863 copy relocation. We first check for a local
21864 minsym, though, because maybe the symbol was
21865 marked hidden, in which case this would not
21867 bound_minimal_symbol found
21868 = (lookup_minimal_symbol_linkage
21869 (sym
->linkage_name (), objfile
));
21870 if (found
.minsym
!= nullptr)
21871 sym
->maybe_copied
= 1;
21874 /* A variable with DW_AT_external is never static,
21875 but it may be block-scoped. */
21877 = ((cu
->list_in_scope
21878 == cu
->get_builder ()->get_file_symbols ())
21879 ? cu
->get_builder ()->get_global_symbols ()
21880 : cu
->list_in_scope
);
21883 list_to_add
= cu
->list_in_scope
;
21887 /* We do not know the address of this symbol.
21888 If it is an external symbol and we have type information
21889 for it, enter the symbol as a LOC_UNRESOLVED symbol.
21890 The address of the variable will then be determined from
21891 the minimal symbol table whenever the variable is
21893 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
21895 /* Fortran explicitly imports any global symbols to the local
21896 scope by DW_TAG_common_block. */
21897 if (cu
->per_cu
->lang
== language_fortran
&& die
->parent
21898 && die
->parent
->tag
== DW_TAG_common_block
)
21900 /* SYMBOL_CLASS doesn't matter here because
21901 read_common_block is going to reset it. */
21903 list_to_add
= cu
->list_in_scope
;
21905 else if (attr2
!= nullptr && attr2
->as_boolean ()
21906 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
21908 /* A variable with DW_AT_external is never static, but it
21909 may be block-scoped. */
21911 = ((cu
->list_in_scope
21912 == cu
->get_builder ()->get_file_symbols ())
21913 ? cu
->get_builder ()->get_global_symbols ()
21914 : cu
->list_in_scope
);
21916 SYMBOL_ACLASS_INDEX (sym
) = LOC_UNRESOLVED
;
21918 else if (!die_is_declaration (die
, cu
))
21920 /* Use the default LOC_OPTIMIZED_OUT class. */
21921 gdb_assert (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
);
21923 list_to_add
= cu
->list_in_scope
;
21927 case DW_TAG_formal_parameter
:
21929 /* If we are inside a function, mark this as an argument. If
21930 not, we might be looking at an argument to an inlined function
21931 when we do not have enough information to show inlined frames;
21932 pretend it's a local variable in that case so that the user can
21934 struct context_stack
*curr
21935 = cu
->get_builder ()->get_current_context_stack ();
21936 if (curr
!= nullptr && curr
->name
!= nullptr)
21937 SYMBOL_IS_ARGUMENT (sym
) = 1;
21938 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
21939 if (attr
!= nullptr)
21941 var_decode_location (attr
, sym
, cu
);
21943 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
21944 if (attr
!= nullptr)
21946 dwarf2_const_value (attr
, sym
, cu
);
21949 list_to_add
= cu
->list_in_scope
;
21952 case DW_TAG_unspecified_parameters
:
21953 /* From varargs functions; gdb doesn't seem to have any
21954 interest in this information, so just ignore it for now.
21957 case DW_TAG_template_type_param
:
21959 /* Fall through. */
21960 case DW_TAG_class_type
:
21961 case DW_TAG_interface_type
:
21962 case DW_TAG_structure_type
:
21963 case DW_TAG_union_type
:
21964 case DW_TAG_set_type
:
21965 case DW_TAG_enumeration_type
:
21966 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
21967 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
21970 /* NOTE: carlton/2003-11-10: C++ class symbols shouldn't
21971 really ever be static objects: otherwise, if you try
21972 to, say, break of a class's method and you're in a file
21973 which doesn't mention that class, it won't work unless
21974 the check for all static symbols in lookup_symbol_aux
21975 saves you. See the OtherFileClass tests in
21976 gdb.c++/namespace.exp. */
21980 buildsym_compunit
*builder
= cu
->get_builder ();
21982 = (cu
->list_in_scope
== builder
->get_file_symbols ()
21983 && cu
->per_cu
->lang
== language_cplus
21984 ? builder
->get_global_symbols ()
21985 : cu
->list_in_scope
);
21987 /* The semantics of C++ state that "struct foo {
21988 ... }" also defines a typedef for "foo". */
21989 if (cu
->per_cu
->lang
== language_cplus
21990 || cu
->per_cu
->lang
== language_ada
21991 || cu
->per_cu
->lang
== language_d
21992 || cu
->per_cu
->lang
== language_rust
)
21994 /* The symbol's name is already allocated along
21995 with this objfile, so we don't need to
21996 duplicate it for the type. */
21997 if (SYMBOL_TYPE (sym
)->name () == 0)
21998 SYMBOL_TYPE (sym
)->set_name (sym
->search_name ());
22003 case DW_TAG_typedef
:
22004 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
22005 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
22006 list_to_add
= cu
->list_in_scope
;
22008 case DW_TAG_array_type
:
22009 case DW_TAG_base_type
:
22010 case DW_TAG_subrange_type
:
22011 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
22012 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
22013 list_to_add
= cu
->list_in_scope
;
22015 case DW_TAG_enumerator
:
22016 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
22017 if (attr
!= nullptr)
22019 dwarf2_const_value (attr
, sym
, cu
);
22022 /* NOTE: carlton/2003-11-10: See comment above in the
22023 DW_TAG_class_type, etc. block. */
22026 = (cu
->list_in_scope
== cu
->get_builder ()->get_file_symbols ()
22027 && cu
->per_cu
->lang
== language_cplus
22028 ? cu
->get_builder ()->get_global_symbols ()
22029 : cu
->list_in_scope
);
22032 case DW_TAG_imported_declaration
:
22033 case DW_TAG_namespace
:
22034 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
22035 list_to_add
= cu
->get_builder ()->get_global_symbols ();
22037 case DW_TAG_module
:
22038 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
22039 SYMBOL_DOMAIN (sym
) = MODULE_DOMAIN
;
22040 list_to_add
= cu
->get_builder ()->get_global_symbols ();
22042 case DW_TAG_common_block
:
22043 SYMBOL_ACLASS_INDEX (sym
) = LOC_COMMON_BLOCK
;
22044 SYMBOL_DOMAIN (sym
) = COMMON_BLOCK_DOMAIN
;
22045 add_symbol_to_list (sym
, cu
->list_in_scope
);
22048 /* Not a tag we recognize. Hopefully we aren't processing
22049 trash data, but since we must specifically ignore things
22050 we don't recognize, there is nothing else we should do at
22052 complaint (_("unsupported tag: '%s'"),
22053 dwarf_tag_name (die
->tag
));
22059 sym
->hash_next
= objfile
->template_symbols
;
22060 objfile
->template_symbols
= sym
;
22061 list_to_add
= NULL
;
22064 if (list_to_add
!= NULL
)
22065 add_symbol_to_list (sym
, list_to_add
);
22067 /* For the benefit of old versions of GCC, check for anonymous
22068 namespaces based on the demangled name. */
22069 if (!cu
->processing_has_namespace_info
22070 && cu
->per_cu
->lang
== language_cplus
)
22071 cp_scan_for_anonymous_namespaces (cu
->get_builder (), sym
, objfile
);
22076 /* Given an attr with a DW_FORM_dataN value in host byte order,
22077 zero-extend it as appropriate for the symbol's type. The DWARF
22078 standard (v4) is not entirely clear about the meaning of using
22079 DW_FORM_dataN for a constant with a signed type, where the type is
22080 wider than the data. The conclusion of a discussion on the DWARF
22081 list was that this is unspecified. We choose to always zero-extend
22082 because that is the interpretation long in use by GCC. */
22085 dwarf2_const_value_data (const struct attribute
*attr
, struct obstack
*obstack
,
22086 struct dwarf2_cu
*cu
, LONGEST
*value
, int bits
)
22088 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22089 enum bfd_endian byte_order
= bfd_big_endian (objfile
->obfd
) ?
22090 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
22091 LONGEST l
= attr
->constant_value (0);
22093 if (bits
< sizeof (*value
) * 8)
22095 l
&= ((LONGEST
) 1 << bits
) - 1;
22098 else if (bits
== sizeof (*value
) * 8)
22102 gdb_byte
*bytes
= (gdb_byte
*) obstack_alloc (obstack
, bits
/ 8);
22103 store_unsigned_integer (bytes
, bits
/ 8, byte_order
, l
);
22110 /* Read a constant value from an attribute. Either set *VALUE, or if
22111 the value does not fit in *VALUE, set *BYTES - either already
22112 allocated on the objfile obstack, or newly allocated on OBSTACK,
22113 or, set *BATON, if we translated the constant to a location
22117 dwarf2_const_value_attr (const struct attribute
*attr
, struct type
*type
,
22118 const char *name
, struct obstack
*obstack
,
22119 struct dwarf2_cu
*cu
,
22120 LONGEST
*value
, const gdb_byte
**bytes
,
22121 struct dwarf2_locexpr_baton
**baton
)
22123 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
22124 struct objfile
*objfile
= per_objfile
->objfile
;
22125 struct comp_unit_head
*cu_header
= &cu
->header
;
22126 struct dwarf_block
*blk
;
22127 enum bfd_endian byte_order
= (bfd_big_endian (objfile
->obfd
) ?
22128 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
22134 switch (attr
->form
)
22137 case DW_FORM_addrx
:
22138 case DW_FORM_GNU_addr_index
:
22142 if (TYPE_LENGTH (type
) != cu_header
->addr_size
)
22143 dwarf2_const_value_length_mismatch_complaint (name
,
22144 cu_header
->addr_size
,
22145 TYPE_LENGTH (type
));
22146 /* Symbols of this form are reasonably rare, so we just
22147 piggyback on the existing location code rather than writing
22148 a new implementation of symbol_computed_ops. */
22149 *baton
= XOBNEW (obstack
, struct dwarf2_locexpr_baton
);
22150 (*baton
)->per_objfile
= per_objfile
;
22151 (*baton
)->per_cu
= cu
->per_cu
;
22152 gdb_assert ((*baton
)->per_cu
);
22154 (*baton
)->size
= 2 + cu_header
->addr_size
;
22155 data
= (gdb_byte
*) obstack_alloc (obstack
, (*baton
)->size
);
22156 (*baton
)->data
= data
;
22158 data
[0] = DW_OP_addr
;
22159 store_unsigned_integer (&data
[1], cu_header
->addr_size
,
22160 byte_order
, attr
->as_address ());
22161 data
[cu_header
->addr_size
+ 1] = DW_OP_stack_value
;
22164 case DW_FORM_string
:
22167 case DW_FORM_GNU_str_index
:
22168 case DW_FORM_GNU_strp_alt
:
22169 /* The string is already allocated on the objfile obstack, point
22171 *bytes
= (const gdb_byte
*) attr
->as_string ();
22173 case DW_FORM_block1
:
22174 case DW_FORM_block2
:
22175 case DW_FORM_block4
:
22176 case DW_FORM_block
:
22177 case DW_FORM_exprloc
:
22178 case DW_FORM_data16
:
22179 blk
= attr
->as_block ();
22180 if (TYPE_LENGTH (type
) != blk
->size
)
22181 dwarf2_const_value_length_mismatch_complaint (name
, blk
->size
,
22182 TYPE_LENGTH (type
));
22183 *bytes
= blk
->data
;
22186 /* The DW_AT_const_value attributes are supposed to carry the
22187 symbol's value "represented as it would be on the target
22188 architecture." By the time we get here, it's already been
22189 converted to host endianness, so we just need to sign- or
22190 zero-extend it as appropriate. */
22191 case DW_FORM_data1
:
22192 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 8);
22194 case DW_FORM_data2
:
22195 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 16);
22197 case DW_FORM_data4
:
22198 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 32);
22200 case DW_FORM_data8
:
22201 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 64);
22204 case DW_FORM_sdata
:
22205 case DW_FORM_implicit_const
:
22206 *value
= attr
->as_signed ();
22209 case DW_FORM_udata
:
22210 *value
= attr
->as_unsigned ();
22214 complaint (_("unsupported const value attribute form: '%s'"),
22215 dwarf_form_name (attr
->form
));
22222 /* Copy constant value from an attribute to a symbol. */
22225 dwarf2_const_value (const struct attribute
*attr
, struct symbol
*sym
,
22226 struct dwarf2_cu
*cu
)
22228 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22230 const gdb_byte
*bytes
;
22231 struct dwarf2_locexpr_baton
*baton
;
22233 dwarf2_const_value_attr (attr
, SYMBOL_TYPE (sym
),
22234 sym
->print_name (),
22235 &objfile
->objfile_obstack
, cu
,
22236 &value
, &bytes
, &baton
);
22240 SYMBOL_LOCATION_BATON (sym
) = baton
;
22241 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
22243 else if (bytes
!= NULL
)
22245 SYMBOL_VALUE_BYTES (sym
) = bytes
;
22246 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST_BYTES
;
22250 SYMBOL_VALUE (sym
) = value
;
22251 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST
;
22255 /* Return the type of the die in question using its DW_AT_type attribute. */
22257 static struct type
*
22258 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
22260 struct attribute
*type_attr
;
22262 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
22265 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22266 /* A missing DW_AT_type represents a void type. */
22267 return objfile_type (objfile
)->builtin_void
;
22270 return lookup_die_type (die
, type_attr
, cu
);
22273 /* True iff CU's producer generates GNAT Ada auxiliary information
22274 that allows to find parallel types through that information instead
22275 of having to do expensive parallel lookups by type name. */
22278 need_gnat_info (struct dwarf2_cu
*cu
)
22280 /* Assume that the Ada compiler was GNAT, which always produces
22281 the auxiliary information. */
22282 return (cu
->per_cu
->lang
== language_ada
);
22285 /* Return the auxiliary type of the die in question using its
22286 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
22287 attribute is not present. */
22289 static struct type
*
22290 die_descriptive_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
22292 struct attribute
*type_attr
;
22294 type_attr
= dwarf2_attr (die
, DW_AT_GNAT_descriptive_type
, cu
);
22298 return lookup_die_type (die
, type_attr
, cu
);
22301 /* If DIE has a descriptive_type attribute, then set the TYPE's
22302 descriptive type accordingly. */
22305 set_descriptive_type (struct type
*type
, struct die_info
*die
,
22306 struct dwarf2_cu
*cu
)
22308 struct type
*descriptive_type
= die_descriptive_type (die
, cu
);
22310 if (descriptive_type
)
22312 ALLOCATE_GNAT_AUX_TYPE (type
);
22313 TYPE_DESCRIPTIVE_TYPE (type
) = descriptive_type
;
22317 /* Return the containing type of the die in question using its
22318 DW_AT_containing_type attribute. */
22320 static struct type
*
22321 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
22323 struct attribute
*type_attr
;
22324 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22326 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
22328 error (_("Dwarf Error: Problem turning containing type into gdb type "
22329 "[in module %s]"), objfile_name (objfile
));
22331 return lookup_die_type (die
, type_attr
, cu
);
22334 /* Return an error marker type to use for the ill formed type in DIE/CU. */
22336 static struct type
*
22337 build_error_marker_type (struct dwarf2_cu
*cu
, struct die_info
*die
)
22339 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
22340 struct objfile
*objfile
= per_objfile
->objfile
;
22343 std::string message
22344 = string_printf (_("<unknown type in %s, CU %s, DIE %s>"),
22345 objfile_name (objfile
),
22346 sect_offset_str (cu
->header
.sect_off
),
22347 sect_offset_str (die
->sect_off
));
22348 saved
= obstack_strdup (&objfile
->objfile_obstack
, message
);
22350 return init_type (objfile
, TYPE_CODE_ERROR
, 0, saved
);
22353 /* Look up the type of DIE in CU using its type attribute ATTR.
22354 ATTR must be one of: DW_AT_type, DW_AT_GNAT_descriptive_type,
22355 DW_AT_containing_type.
22356 If there is no type substitute an error marker. */
22358 static struct type
*
22359 lookup_die_type (struct die_info
*die
, const struct attribute
*attr
,
22360 struct dwarf2_cu
*cu
)
22362 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
22363 struct objfile
*objfile
= per_objfile
->objfile
;
22364 struct type
*this_type
;
22366 gdb_assert (attr
->name
== DW_AT_type
22367 || attr
->name
== DW_AT_GNAT_descriptive_type
22368 || attr
->name
== DW_AT_containing_type
);
22370 /* First see if we have it cached. */
22372 if (attr
->form
== DW_FORM_GNU_ref_alt
)
22374 struct dwarf2_per_cu_data
*per_cu
;
22375 sect_offset sect_off
= attr
->get_ref_die_offset ();
22377 per_cu
= dwarf2_find_containing_comp_unit (sect_off
, 1, per_objfile
);
22378 this_type
= get_die_type_at_offset (sect_off
, per_cu
, per_objfile
);
22380 else if (attr
->form_is_ref ())
22382 sect_offset sect_off
= attr
->get_ref_die_offset ();
22384 this_type
= get_die_type_at_offset (sect_off
, cu
->per_cu
, per_objfile
);
22386 else if (attr
->form
== DW_FORM_ref_sig8
)
22388 ULONGEST signature
= attr
->as_signature ();
22390 return get_signatured_type (die
, signature
, cu
);
22394 complaint (_("Dwarf Error: Bad type attribute %s in DIE"
22395 " at %s [in module %s]"),
22396 dwarf_attr_name (attr
->name
), sect_offset_str (die
->sect_off
),
22397 objfile_name (objfile
));
22398 return build_error_marker_type (cu
, die
);
22401 /* If not cached we need to read it in. */
22403 if (this_type
== NULL
)
22405 struct die_info
*type_die
= NULL
;
22406 struct dwarf2_cu
*type_cu
= cu
;
22408 if (attr
->form_is_ref ())
22409 type_die
= follow_die_ref (die
, attr
, &type_cu
);
22410 if (type_die
== NULL
)
22411 return build_error_marker_type (cu
, die
);
22412 /* If we find the type now, it's probably because the type came
22413 from an inter-CU reference and the type's CU got expanded before
22415 this_type
= read_type_die (type_die
, type_cu
);
22418 /* If we still don't have a type use an error marker. */
22420 if (this_type
== NULL
)
22421 return build_error_marker_type (cu
, die
);
22426 /* Return the type in DIE, CU.
22427 Returns NULL for invalid types.
22429 This first does a lookup in die_type_hash,
22430 and only reads the die in if necessary.
22432 NOTE: This can be called when reading in partial or full symbols. */
22434 static struct type
*
22435 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
22437 struct type
*this_type
;
22439 this_type
= get_die_type (die
, cu
);
22443 return read_type_die_1 (die
, cu
);
22446 /* Read the type in DIE, CU.
22447 Returns NULL for invalid types. */
22449 static struct type
*
22450 read_type_die_1 (struct die_info
*die
, struct dwarf2_cu
*cu
)
22452 struct type
*this_type
= NULL
;
22456 case DW_TAG_class_type
:
22457 case DW_TAG_interface_type
:
22458 case DW_TAG_structure_type
:
22459 case DW_TAG_union_type
:
22460 this_type
= read_structure_type (die
, cu
);
22462 case DW_TAG_enumeration_type
:
22463 this_type
= read_enumeration_type (die
, cu
);
22465 case DW_TAG_subprogram
:
22466 case DW_TAG_subroutine_type
:
22467 case DW_TAG_inlined_subroutine
:
22468 this_type
= read_subroutine_type (die
, cu
);
22470 case DW_TAG_array_type
:
22471 this_type
= read_array_type (die
, cu
);
22473 case DW_TAG_set_type
:
22474 this_type
= read_set_type (die
, cu
);
22476 case DW_TAG_pointer_type
:
22477 this_type
= read_tag_pointer_type (die
, cu
);
22479 case DW_TAG_ptr_to_member_type
:
22480 this_type
= read_tag_ptr_to_member_type (die
, cu
);
22482 case DW_TAG_reference_type
:
22483 this_type
= read_tag_reference_type (die
, cu
, TYPE_CODE_REF
);
22485 case DW_TAG_rvalue_reference_type
:
22486 this_type
= read_tag_reference_type (die
, cu
, TYPE_CODE_RVALUE_REF
);
22488 case DW_TAG_const_type
:
22489 this_type
= read_tag_const_type (die
, cu
);
22491 case DW_TAG_volatile_type
:
22492 this_type
= read_tag_volatile_type (die
, cu
);
22494 case DW_TAG_restrict_type
:
22495 this_type
= read_tag_restrict_type (die
, cu
);
22497 case DW_TAG_string_type
:
22498 this_type
= read_tag_string_type (die
, cu
);
22500 case DW_TAG_typedef
:
22501 this_type
= read_typedef (die
, cu
);
22503 case DW_TAG_subrange_type
:
22504 this_type
= read_subrange_type (die
, cu
);
22506 case DW_TAG_base_type
:
22507 this_type
= read_base_type (die
, cu
);
22509 case DW_TAG_unspecified_type
:
22510 this_type
= read_unspecified_type (die
, cu
);
22512 case DW_TAG_namespace
:
22513 this_type
= read_namespace_type (die
, cu
);
22515 case DW_TAG_module
:
22516 this_type
= read_module_type (die
, cu
);
22518 case DW_TAG_atomic_type
:
22519 this_type
= read_tag_atomic_type (die
, cu
);
22522 complaint (_("unexpected tag in read_type_die: '%s'"),
22523 dwarf_tag_name (die
->tag
));
22530 /* See if we can figure out if the class lives in a namespace. We do
22531 this by looking for a member function; its demangled name will
22532 contain namespace info, if there is any.
22533 Return the computed name or NULL.
22534 Space for the result is allocated on the objfile's obstack.
22535 This is the full-die version of guess_partial_die_structure_name.
22536 In this case we know DIE has no useful parent. */
22538 static const char *
22539 guess_full_die_structure_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
22541 struct die_info
*spec_die
;
22542 struct dwarf2_cu
*spec_cu
;
22543 struct die_info
*child
;
22544 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22547 spec_die
= die_specification (die
, &spec_cu
);
22548 if (spec_die
!= NULL
)
22554 for (child
= die
->child
;
22556 child
= child
->sibling
)
22558 if (child
->tag
== DW_TAG_subprogram
)
22560 const char *linkage_name
= dw2_linkage_name (child
, cu
);
22562 if (linkage_name
!= NULL
)
22564 gdb::unique_xmalloc_ptr
<char> actual_name
22565 (cu
->language_defn
->class_name_from_physname (linkage_name
));
22566 const char *name
= NULL
;
22568 if (actual_name
!= NULL
)
22570 const char *die_name
= dwarf2_name (die
, cu
);
22572 if (die_name
!= NULL
22573 && strcmp (die_name
, actual_name
.get ()) != 0)
22575 /* Strip off the class name from the full name.
22576 We want the prefix. */
22577 int die_name_len
= strlen (die_name
);
22578 int actual_name_len
= strlen (actual_name
.get ());
22579 const char *ptr
= actual_name
.get ();
22581 /* Test for '::' as a sanity check. */
22582 if (actual_name_len
> die_name_len
+ 2
22583 && ptr
[actual_name_len
- die_name_len
- 1] == ':')
22584 name
= obstack_strndup (
22585 &objfile
->per_bfd
->storage_obstack
,
22586 ptr
, actual_name_len
- die_name_len
- 2);
22597 /* GCC might emit a nameless typedef that has a linkage name. Determine the
22598 prefix part in such case. See
22599 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
22601 static const char *
22602 anonymous_struct_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
22604 struct attribute
*attr
;
22607 if (die
->tag
!= DW_TAG_class_type
&& die
->tag
!= DW_TAG_interface_type
22608 && die
->tag
!= DW_TAG_structure_type
&& die
->tag
!= DW_TAG_union_type
)
22611 if (dwarf2_string_attr (die
, DW_AT_name
, cu
) != NULL
)
22614 attr
= dw2_linkage_name_attr (die
, cu
);
22615 const char *attr_name
= attr
->as_string ();
22616 if (attr
== NULL
|| attr_name
== NULL
)
22619 /* dwarf2_name had to be already called. */
22620 gdb_assert (attr
->canonical_string_p ());
22622 /* Strip the base name, keep any leading namespaces/classes. */
22623 base
= strrchr (attr_name
, ':');
22624 if (base
== NULL
|| base
== attr_name
|| base
[-1] != ':')
22627 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22628 return obstack_strndup (&objfile
->per_bfd
->storage_obstack
,
22630 &base
[-1] - attr_name
);
22633 /* Return the name of the namespace/class that DIE is defined within,
22634 or "" if we can't tell. The caller should not xfree the result.
22636 For example, if we're within the method foo() in the following
22646 then determine_prefix on foo's die will return "N::C". */
22648 static const char *
22649 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
22651 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
22652 struct die_info
*parent
, *spec_die
;
22653 struct dwarf2_cu
*spec_cu
;
22654 struct type
*parent_type
;
22655 const char *retval
;
22657 if (cu
->per_cu
->lang
!= language_cplus
22658 && cu
->per_cu
->lang
!= language_fortran
22659 && cu
->per_cu
->lang
!= language_d
22660 && cu
->per_cu
->lang
!= language_rust
)
22663 retval
= anonymous_struct_prefix (die
, cu
);
22667 /* We have to be careful in the presence of DW_AT_specification.
22668 For example, with GCC 3.4, given the code
22672 // Definition of N::foo.
22676 then we'll have a tree of DIEs like this:
22678 1: DW_TAG_compile_unit
22679 2: DW_TAG_namespace // N
22680 3: DW_TAG_subprogram // declaration of N::foo
22681 4: DW_TAG_subprogram // definition of N::foo
22682 DW_AT_specification // refers to die #3
22684 Thus, when processing die #4, we have to pretend that we're in
22685 the context of its DW_AT_specification, namely the contex of die
22688 spec_die
= die_specification (die
, &spec_cu
);
22689 if (spec_die
== NULL
)
22690 parent
= die
->parent
;
22693 parent
= spec_die
->parent
;
22697 if (parent
== NULL
)
22699 else if (parent
->building_fullname
)
22702 const char *parent_name
;
22704 /* It has been seen on RealView 2.2 built binaries,
22705 DW_TAG_template_type_param types actually _defined_ as
22706 children of the parent class:
22709 template class <class Enum> Class{};
22710 Class<enum E> class_e;
22712 1: DW_TAG_class_type (Class)
22713 2: DW_TAG_enumeration_type (E)
22714 3: DW_TAG_enumerator (enum1:0)
22715 3: DW_TAG_enumerator (enum2:1)
22717 2: DW_TAG_template_type_param
22718 DW_AT_type DW_FORM_ref_udata (E)
22720 Besides being broken debug info, it can put GDB into an
22721 infinite loop. Consider:
22723 When we're building the full name for Class<E>, we'll start
22724 at Class, and go look over its template type parameters,
22725 finding E. We'll then try to build the full name of E, and
22726 reach here. We're now trying to build the full name of E,
22727 and look over the parent DIE for containing scope. In the
22728 broken case, if we followed the parent DIE of E, we'd again
22729 find Class, and once again go look at its template type
22730 arguments, etc., etc. Simply don't consider such parent die
22731 as source-level parent of this die (it can't be, the language
22732 doesn't allow it), and break the loop here. */
22733 name
= dwarf2_name (die
, cu
);
22734 parent_name
= dwarf2_name (parent
, cu
);
22735 complaint (_("template param type '%s' defined within parent '%s'"),
22736 name
? name
: "<unknown>",
22737 parent_name
? parent_name
: "<unknown>");
22741 switch (parent
->tag
)
22743 case DW_TAG_namespace
:
22744 parent_type
= read_type_die (parent
, cu
);
22745 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
22746 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
22747 Work around this problem here. */
22748 if (cu
->per_cu
->lang
== language_cplus
22749 && strcmp (parent_type
->name (), "::") == 0)
22751 /* We give a name to even anonymous namespaces. */
22752 return parent_type
->name ();
22753 case DW_TAG_class_type
:
22754 case DW_TAG_interface_type
:
22755 case DW_TAG_structure_type
:
22756 case DW_TAG_union_type
:
22757 case DW_TAG_module
:
22758 parent_type
= read_type_die (parent
, cu
);
22759 if (parent_type
->name () != NULL
)
22760 return parent_type
->name ();
22762 /* An anonymous structure is only allowed non-static data
22763 members; no typedefs, no member functions, et cetera.
22764 So it does not need a prefix. */
22766 case DW_TAG_compile_unit
:
22767 case DW_TAG_partial_unit
:
22768 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
22769 if (cu
->per_cu
->lang
== language_cplus
22770 && !per_objfile
->per_bfd
->types
.empty ()
22771 && die
->child
!= NULL
22772 && (die
->tag
== DW_TAG_class_type
22773 || die
->tag
== DW_TAG_structure_type
22774 || die
->tag
== DW_TAG_union_type
))
22776 const char *name
= guess_full_die_structure_name (die
, cu
);
22781 case DW_TAG_subprogram
:
22782 /* Nested subroutines in Fortran get a prefix with the name
22783 of the parent's subroutine. */
22784 if (cu
->per_cu
->lang
== language_fortran
)
22786 if ((die
->tag
== DW_TAG_subprogram
)
22787 && (dwarf2_name (parent
, cu
) != NULL
))
22788 return dwarf2_name (parent
, cu
);
22791 case DW_TAG_enumeration_type
:
22792 parent_type
= read_type_die (parent
, cu
);
22793 if (parent_type
->is_declared_class ())
22795 if (parent_type
->name () != NULL
)
22796 return parent_type
->name ();
22799 /* Fall through. */
22801 return determine_prefix (parent
, cu
);
22805 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
22806 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
22807 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
22808 an obconcat, otherwise allocate storage for the result. The CU argument is
22809 used to determine the language and hence, the appropriate separator. */
22811 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
22814 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
22815 int physname
, struct dwarf2_cu
*cu
)
22817 const char *lead
= "";
22820 if (suffix
== NULL
|| suffix
[0] == '\0'
22821 || prefix
== NULL
|| prefix
[0] == '\0')
22823 else if (cu
->per_cu
->lang
== language_d
)
22825 /* For D, the 'main' function could be defined in any module, but it
22826 should never be prefixed. */
22827 if (strcmp (suffix
, "D main") == 0)
22835 else if (cu
->per_cu
->lang
== language_fortran
&& physname
)
22837 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
22838 DW_AT_MIPS_linkage_name is preferred and used instead. */
22846 if (prefix
== NULL
)
22848 if (suffix
== NULL
)
22855 xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1));
22857 strcpy (retval
, lead
);
22858 strcat (retval
, prefix
);
22859 strcat (retval
, sep
);
22860 strcat (retval
, suffix
);
22865 /* We have an obstack. */
22866 return obconcat (obs
, lead
, prefix
, sep
, suffix
, (char *) NULL
);
22870 /* Get name of a die, return NULL if not found. */
22872 static const char *
22873 dwarf2_canonicalize_name (const char *name
, struct dwarf2_cu
*cu
,
22874 struct objfile
*objfile
)
22876 if (name
&& cu
->per_cu
->lang
== language_cplus
)
22878 gdb::unique_xmalloc_ptr
<char> canon_name
22879 = cp_canonicalize_string (name
);
22881 if (canon_name
!= nullptr)
22882 name
= objfile
->intern (canon_name
.get ());
22888 /* Get name of a die, return NULL if not found.
22889 Anonymous namespaces are converted to their magic string. */
22891 static const char *
22892 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
22894 struct attribute
*attr
;
22895 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22897 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
22898 const char *attr_name
= attr
== nullptr ? nullptr : attr
->as_string ();
22899 if (attr_name
== nullptr
22900 && die
->tag
!= DW_TAG_namespace
22901 && die
->tag
!= DW_TAG_class_type
22902 && die
->tag
!= DW_TAG_interface_type
22903 && die
->tag
!= DW_TAG_structure_type
22904 && die
->tag
!= DW_TAG_union_type
)
22909 case DW_TAG_compile_unit
:
22910 case DW_TAG_partial_unit
:
22911 /* Compilation units have a DW_AT_name that is a filename, not
22912 a source language identifier. */
22913 case DW_TAG_enumeration_type
:
22914 case DW_TAG_enumerator
:
22915 /* These tags always have simple identifiers already; no need
22916 to canonicalize them. */
22919 case DW_TAG_namespace
:
22920 if (attr_name
!= nullptr)
22922 return CP_ANONYMOUS_NAMESPACE_STR
;
22924 case DW_TAG_class_type
:
22925 case DW_TAG_interface_type
:
22926 case DW_TAG_structure_type
:
22927 case DW_TAG_union_type
:
22928 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
22929 structures or unions. These were of the form "._%d" in GCC 4.1,
22930 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
22931 and GCC 4.4. We work around this problem by ignoring these. */
22932 if (attr_name
!= nullptr
22933 && (startswith (attr_name
, "._")
22934 || startswith (attr_name
, "<anonymous")))
22937 /* GCC might emit a nameless typedef that has a linkage name. See
22938 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
22939 if (!attr
|| attr_name
== NULL
)
22941 attr
= dw2_linkage_name_attr (die
, cu
);
22942 attr_name
= attr
== nullptr ? nullptr : attr
->as_string ();
22943 if (attr
== NULL
|| attr_name
== NULL
)
22946 /* Avoid demangling attr_name the second time on a second
22947 call for the same DIE. */
22948 if (!attr
->canonical_string_p ())
22950 gdb::unique_xmalloc_ptr
<char> demangled
22951 (gdb_demangle (attr_name
, DMGL_TYPES
));
22952 if (demangled
== nullptr)
22955 attr
->set_string_canonical (objfile
->intern (demangled
.get ()));
22956 attr_name
= attr
->as_string ();
22959 /* Strip any leading namespaces/classes, keep only the
22960 base name. DW_AT_name for named DIEs does not
22961 contain the prefixes. */
22962 const char *base
= strrchr (attr_name
, ':');
22963 if (base
&& base
> attr_name
&& base
[-1] == ':')
22974 if (!attr
->canonical_string_p ())
22975 attr
->set_string_canonical (dwarf2_canonicalize_name (attr_name
, cu
,
22977 return attr
->as_string ();
22980 /* Return the die that this die in an extension of, or NULL if there
22981 is none. *EXT_CU is the CU containing DIE on input, and the CU
22982 containing the return value on output. */
22984 static struct die_info
*
22985 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
**ext_cu
)
22987 struct attribute
*attr
;
22989 attr
= dwarf2_attr (die
, DW_AT_extension
, *ext_cu
);
22993 return follow_die_ref (die
, attr
, ext_cu
);
22997 dump_die_shallow (struct ui_file
*f
, int indent
, struct die_info
*die
)
23001 print_spaces (indent
, f
);
23002 fprintf_unfiltered (f
, "Die: %s (abbrev %d, offset %s)\n",
23003 dwarf_tag_name (die
->tag
), die
->abbrev
,
23004 sect_offset_str (die
->sect_off
));
23006 if (die
->parent
!= NULL
)
23008 print_spaces (indent
, f
);
23009 fprintf_unfiltered (f
, " parent at offset: %s\n",
23010 sect_offset_str (die
->parent
->sect_off
));
23013 print_spaces (indent
, f
);
23014 fprintf_unfiltered (f
, " has children: %s\n",
23015 dwarf_bool_name (die
->child
!= NULL
));
23017 print_spaces (indent
, f
);
23018 fprintf_unfiltered (f
, " attributes:\n");
23020 for (i
= 0; i
< die
->num_attrs
; ++i
)
23022 print_spaces (indent
, f
);
23023 fprintf_unfiltered (f
, " %s (%s) ",
23024 dwarf_attr_name (die
->attrs
[i
].name
),
23025 dwarf_form_name (die
->attrs
[i
].form
));
23027 switch (die
->attrs
[i
].form
)
23030 case DW_FORM_addrx
:
23031 case DW_FORM_GNU_addr_index
:
23032 fprintf_unfiltered (f
, "address: ");
23033 fputs_filtered (hex_string (die
->attrs
[i
].as_address ()), f
);
23035 case DW_FORM_block2
:
23036 case DW_FORM_block4
:
23037 case DW_FORM_block
:
23038 case DW_FORM_block1
:
23039 fprintf_unfiltered (f
, "block: size %s",
23040 pulongest (die
->attrs
[i
].as_block ()->size
));
23042 case DW_FORM_exprloc
:
23043 fprintf_unfiltered (f
, "expression: size %s",
23044 pulongest (die
->attrs
[i
].as_block ()->size
));
23046 case DW_FORM_data16
:
23047 fprintf_unfiltered (f
, "constant of 16 bytes");
23049 case DW_FORM_ref_addr
:
23050 fprintf_unfiltered (f
, "ref address: ");
23051 fputs_filtered (hex_string (die
->attrs
[i
].as_unsigned ()), f
);
23053 case DW_FORM_GNU_ref_alt
:
23054 fprintf_unfiltered (f
, "alt ref address: ");
23055 fputs_filtered (hex_string (die
->attrs
[i
].as_unsigned ()), f
);
23061 case DW_FORM_ref_udata
:
23062 fprintf_unfiltered (f
, "constant ref: 0x%lx (adjusted)",
23063 (long) (die
->attrs
[i
].as_unsigned ()));
23065 case DW_FORM_data1
:
23066 case DW_FORM_data2
:
23067 case DW_FORM_data4
:
23068 case DW_FORM_data8
:
23069 case DW_FORM_udata
:
23070 fprintf_unfiltered (f
, "constant: %s",
23071 pulongest (die
->attrs
[i
].as_unsigned ()));
23073 case DW_FORM_sec_offset
:
23074 fprintf_unfiltered (f
, "section offset: %s",
23075 pulongest (die
->attrs
[i
].as_unsigned ()));
23077 case DW_FORM_ref_sig8
:
23078 fprintf_unfiltered (f
, "signature: %s",
23079 hex_string (die
->attrs
[i
].as_signature ()));
23081 case DW_FORM_string
:
23083 case DW_FORM_line_strp
:
23085 case DW_FORM_GNU_str_index
:
23086 case DW_FORM_GNU_strp_alt
:
23087 fprintf_unfiltered (f
, "string: \"%s\" (%s canonicalized)",
23088 die
->attrs
[i
].as_string ()
23089 ? die
->attrs
[i
].as_string () : "",
23090 die
->attrs
[i
].canonical_string_p () ? "is" : "not");
23093 if (die
->attrs
[i
].as_boolean ())
23094 fprintf_unfiltered (f
, "flag: TRUE");
23096 fprintf_unfiltered (f
, "flag: FALSE");
23098 case DW_FORM_flag_present
:
23099 fprintf_unfiltered (f
, "flag: TRUE");
23101 case DW_FORM_indirect
:
23102 /* The reader will have reduced the indirect form to
23103 the "base form" so this form should not occur. */
23104 fprintf_unfiltered (f
,
23105 "unexpected attribute form: DW_FORM_indirect");
23107 case DW_FORM_sdata
:
23108 case DW_FORM_implicit_const
:
23109 fprintf_unfiltered (f
, "constant: %s",
23110 plongest (die
->attrs
[i
].as_signed ()));
23113 fprintf_unfiltered (f
, "unsupported attribute form: %d.",
23114 die
->attrs
[i
].form
);
23117 fprintf_unfiltered (f
, "\n");
23122 dump_die_for_error (struct die_info
*die
)
23124 dump_die_shallow (gdb_stderr
, 0, die
);
23128 dump_die_1 (struct ui_file
*f
, int level
, int max_level
, struct die_info
*die
)
23130 int indent
= level
* 4;
23132 gdb_assert (die
!= NULL
);
23134 if (level
>= max_level
)
23137 dump_die_shallow (f
, indent
, die
);
23139 if (die
->child
!= NULL
)
23141 print_spaces (indent
, f
);
23142 fprintf_unfiltered (f
, " Children:");
23143 if (level
+ 1 < max_level
)
23145 fprintf_unfiltered (f
, "\n");
23146 dump_die_1 (f
, level
+ 1, max_level
, die
->child
);
23150 fprintf_unfiltered (f
,
23151 " [not printed, max nesting level reached]\n");
23155 if (die
->sibling
!= NULL
&& level
> 0)
23157 dump_die_1 (f
, level
, max_level
, die
->sibling
);
23161 /* This is called from the pdie macro in gdbinit.in.
23162 It's not static so gcc will keep a copy callable from gdb. */
23165 dump_die (struct die_info
*die
, int max_level
)
23167 dump_die_1 (gdb_stdlog
, 0, max_level
, die
);
23171 store_in_ref_table (struct die_info
*die
, struct dwarf2_cu
*cu
)
23175 slot
= htab_find_slot_with_hash (cu
->die_hash
, die
,
23176 to_underlying (die
->sect_off
),
23182 /* Follow reference or signature attribute ATTR of SRC_DIE.
23183 On entry *REF_CU is the CU of SRC_DIE.
23184 On exit *REF_CU is the CU of the result. */
23186 static struct die_info
*
23187 follow_die_ref_or_sig (struct die_info
*src_die
, const struct attribute
*attr
,
23188 struct dwarf2_cu
**ref_cu
)
23190 struct die_info
*die
;
23192 if (attr
->form_is_ref ())
23193 die
= follow_die_ref (src_die
, attr
, ref_cu
);
23194 else if (attr
->form
== DW_FORM_ref_sig8
)
23195 die
= follow_die_sig (src_die
, attr
, ref_cu
);
23198 dump_die_for_error (src_die
);
23199 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
23200 objfile_name ((*ref_cu
)->per_objfile
->objfile
));
23206 /* Follow reference OFFSET.
23207 On entry *REF_CU is the CU of the source die referencing OFFSET.
23208 On exit *REF_CU is the CU of the result.
23209 Returns NULL if OFFSET is invalid. */
23211 static struct die_info
*
23212 follow_die_offset (sect_offset sect_off
, int offset_in_dwz
,
23213 struct dwarf2_cu
**ref_cu
)
23215 struct die_info temp_die
;
23216 struct dwarf2_cu
*target_cu
, *cu
= *ref_cu
;
23217 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
23219 gdb_assert (cu
->per_cu
!= NULL
);
23223 dwarf_read_debug_printf_v ("source CU offset: %s, target offset: %s, "
23224 "source CU contains target offset: %d",
23225 sect_offset_str (cu
->per_cu
->sect_off
),
23226 sect_offset_str (sect_off
),
23227 cu
->header
.offset_in_cu_p (sect_off
));
23229 if (cu
->per_cu
->is_debug_types
)
23231 /* .debug_types CUs cannot reference anything outside their CU.
23232 If they need to, they have to reference a signatured type via
23233 DW_FORM_ref_sig8. */
23234 if (!cu
->header
.offset_in_cu_p (sect_off
))
23237 else if (offset_in_dwz
!= cu
->per_cu
->is_dwz
23238 || !cu
->header
.offset_in_cu_p (sect_off
))
23240 struct dwarf2_per_cu_data
*per_cu
;
23242 per_cu
= dwarf2_find_containing_comp_unit (sect_off
, offset_in_dwz
,
23245 dwarf_read_debug_printf_v ("target CU offset: %s, "
23246 "target CU DIEs loaded: %d",
23247 sect_offset_str (per_cu
->sect_off
),
23248 per_objfile
->get_cu (per_cu
) != nullptr);
23250 /* If necessary, add it to the queue and load its DIEs.
23252 Even if maybe_queue_comp_unit doesn't require us to load the CU's DIEs,
23253 it doesn't mean they are currently loaded. Since we require them
23254 to be loaded, we must check for ourselves. */
23255 if (maybe_queue_comp_unit (cu
, per_cu
, per_objfile
, cu
->per_cu
->lang
)
23256 || per_objfile
->get_cu (per_cu
) == nullptr)
23257 load_full_comp_unit (per_cu
, per_objfile
, per_objfile
->get_cu (per_cu
),
23258 false, cu
->per_cu
->lang
);
23260 target_cu
= per_objfile
->get_cu (per_cu
);
23261 gdb_assert (target_cu
!= nullptr);
23263 else if (cu
->dies
== NULL
)
23265 /* We're loading full DIEs during partial symbol reading. */
23266 gdb_assert (per_objfile
->per_bfd
->reading_partial_symbols
);
23267 load_full_comp_unit (cu
->per_cu
, per_objfile
, cu
, false,
23271 *ref_cu
= target_cu
;
23272 temp_die
.sect_off
= sect_off
;
23274 return (struct die_info
*) htab_find_with_hash (target_cu
->die_hash
,
23276 to_underlying (sect_off
));
23279 /* Follow reference attribute ATTR of SRC_DIE.
23280 On entry *REF_CU is the CU of SRC_DIE.
23281 On exit *REF_CU is the CU of the result. */
23283 static struct die_info
*
23284 follow_die_ref (struct die_info
*src_die
, const struct attribute
*attr
,
23285 struct dwarf2_cu
**ref_cu
)
23287 sect_offset sect_off
= attr
->get_ref_die_offset ();
23288 struct dwarf2_cu
*cu
= *ref_cu
;
23289 struct die_info
*die
;
23291 die
= follow_die_offset (sect_off
,
23292 (attr
->form
== DW_FORM_GNU_ref_alt
23293 || cu
->per_cu
->is_dwz
),
23296 error (_("Dwarf Error: Cannot find DIE at %s referenced from DIE "
23297 "at %s [in module %s]"),
23298 sect_offset_str (sect_off
), sect_offset_str (src_die
->sect_off
),
23299 objfile_name (cu
->per_objfile
->objfile
));
23306 struct dwarf2_locexpr_baton
23307 dwarf2_fetch_die_loc_sect_off (sect_offset sect_off
,
23308 dwarf2_per_cu_data
*per_cu
,
23309 dwarf2_per_objfile
*per_objfile
,
23310 gdb::function_view
<CORE_ADDR ()> get_frame_pc
,
23311 bool resolve_abstract_p
)
23313 struct die_info
*die
;
23314 struct attribute
*attr
;
23315 struct dwarf2_locexpr_baton retval
;
23316 struct objfile
*objfile
= per_objfile
->objfile
;
23318 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
23320 cu
= load_cu (per_cu
, per_objfile
, false);
23324 /* We shouldn't get here for a dummy CU, but don't crash on the user.
23325 Instead just throw an error, not much else we can do. */
23326 error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23327 sect_offset_str (sect_off
), objfile_name (objfile
));
23330 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
23332 error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23333 sect_offset_str (sect_off
), objfile_name (objfile
));
23335 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
23336 if (!attr
&& resolve_abstract_p
23337 && (per_objfile
->per_bfd
->abstract_to_concrete
.find (die
->sect_off
)
23338 != per_objfile
->per_bfd
->abstract_to_concrete
.end ()))
23340 CORE_ADDR pc
= get_frame_pc ();
23341 CORE_ADDR baseaddr
= objfile
->text_section_offset ();
23342 struct gdbarch
*gdbarch
= objfile
->arch ();
23344 for (const auto &cand_off
23345 : per_objfile
->per_bfd
->abstract_to_concrete
[die
->sect_off
])
23347 struct dwarf2_cu
*cand_cu
= cu
;
23348 struct die_info
*cand
23349 = follow_die_offset (cand_off
, per_cu
->is_dwz
, &cand_cu
);
23352 || cand
->parent
->tag
!= DW_TAG_subprogram
)
23355 CORE_ADDR pc_low
, pc_high
;
23356 get_scope_pc_bounds (cand
->parent
, &pc_low
, &pc_high
, cu
);
23357 if (pc_low
== ((CORE_ADDR
) -1))
23359 pc_low
= gdbarch_adjust_dwarf2_addr (gdbarch
, pc_low
+ baseaddr
);
23360 pc_high
= gdbarch_adjust_dwarf2_addr (gdbarch
, pc_high
+ baseaddr
);
23361 if (!(pc_low
<= pc
&& pc
< pc_high
))
23365 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
23372 /* DWARF: "If there is no such attribute, then there is no effect.".
23373 DATA is ignored if SIZE is 0. */
23375 retval
.data
= NULL
;
23378 else if (attr
->form_is_section_offset ())
23380 struct dwarf2_loclist_baton loclist_baton
;
23381 CORE_ADDR pc
= get_frame_pc ();
23384 fill_in_loclist_baton (cu
, &loclist_baton
, attr
);
23386 retval
.data
= dwarf2_find_location_expression (&loclist_baton
,
23388 retval
.size
= size
;
23392 if (!attr
->form_is_block ())
23393 error (_("Dwarf Error: DIE at %s referenced in module %s "
23394 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
23395 sect_offset_str (sect_off
), objfile_name (objfile
));
23397 struct dwarf_block
*block
= attr
->as_block ();
23398 retval
.data
= block
->data
;
23399 retval
.size
= block
->size
;
23401 retval
.per_objfile
= per_objfile
;
23402 retval
.per_cu
= cu
->per_cu
;
23404 per_objfile
->age_comp_units ();
23411 struct dwarf2_locexpr_baton
23412 dwarf2_fetch_die_loc_cu_off (cu_offset offset_in_cu
,
23413 dwarf2_per_cu_data
*per_cu
,
23414 dwarf2_per_objfile
*per_objfile
,
23415 gdb::function_view
<CORE_ADDR ()> get_frame_pc
)
23417 sect_offset sect_off
= per_cu
->sect_off
+ to_underlying (offset_in_cu
);
23419 return dwarf2_fetch_die_loc_sect_off (sect_off
, per_cu
, per_objfile
,
23423 /* Write a constant of a given type as target-ordered bytes into
23426 static const gdb_byte
*
23427 write_constant_as_bytes (struct obstack
*obstack
,
23428 enum bfd_endian byte_order
,
23435 *len
= TYPE_LENGTH (type
);
23436 result
= (gdb_byte
*) obstack_alloc (obstack
, *len
);
23437 store_unsigned_integer (result
, *len
, byte_order
, value
);
23445 dwarf2_fetch_constant_bytes (sect_offset sect_off
,
23446 dwarf2_per_cu_data
*per_cu
,
23447 dwarf2_per_objfile
*per_objfile
,
23451 struct die_info
*die
;
23452 struct attribute
*attr
;
23453 const gdb_byte
*result
= NULL
;
23456 enum bfd_endian byte_order
;
23457 struct objfile
*objfile
= per_objfile
->objfile
;
23459 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
23461 cu
= load_cu (per_cu
, per_objfile
, false);
23465 /* We shouldn't get here for a dummy CU, but don't crash on the user.
23466 Instead just throw an error, not much else we can do. */
23467 error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23468 sect_offset_str (sect_off
), objfile_name (objfile
));
23471 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
23473 error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23474 sect_offset_str (sect_off
), objfile_name (objfile
));
23476 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
23480 byte_order
= (bfd_big_endian (objfile
->obfd
)
23481 ? BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
23483 switch (attr
->form
)
23486 case DW_FORM_addrx
:
23487 case DW_FORM_GNU_addr_index
:
23491 *len
= cu
->header
.addr_size
;
23492 tem
= (gdb_byte
*) obstack_alloc (obstack
, *len
);
23493 store_unsigned_integer (tem
, *len
, byte_order
, attr
->as_address ());
23497 case DW_FORM_string
:
23500 case DW_FORM_GNU_str_index
:
23501 case DW_FORM_GNU_strp_alt
:
23502 /* The string is already allocated on the objfile obstack, point
23505 const char *attr_name
= attr
->as_string ();
23506 result
= (const gdb_byte
*) attr_name
;
23507 *len
= strlen (attr_name
);
23510 case DW_FORM_block1
:
23511 case DW_FORM_block2
:
23512 case DW_FORM_block4
:
23513 case DW_FORM_block
:
23514 case DW_FORM_exprloc
:
23515 case DW_FORM_data16
:
23517 struct dwarf_block
*block
= attr
->as_block ();
23518 result
= block
->data
;
23519 *len
= block
->size
;
23523 /* The DW_AT_const_value attributes are supposed to carry the
23524 symbol's value "represented as it would be on the target
23525 architecture." By the time we get here, it's already been
23526 converted to host endianness, so we just need to sign- or
23527 zero-extend it as appropriate. */
23528 case DW_FORM_data1
:
23529 type
= die_type (die
, cu
);
23530 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 8);
23531 if (result
== NULL
)
23532 result
= write_constant_as_bytes (obstack
, byte_order
,
23535 case DW_FORM_data2
:
23536 type
= die_type (die
, cu
);
23537 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 16);
23538 if (result
== NULL
)
23539 result
= write_constant_as_bytes (obstack
, byte_order
,
23542 case DW_FORM_data4
:
23543 type
= die_type (die
, cu
);
23544 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 32);
23545 if (result
== NULL
)
23546 result
= write_constant_as_bytes (obstack
, byte_order
,
23549 case DW_FORM_data8
:
23550 type
= die_type (die
, cu
);
23551 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 64);
23552 if (result
== NULL
)
23553 result
= write_constant_as_bytes (obstack
, byte_order
,
23557 case DW_FORM_sdata
:
23558 case DW_FORM_implicit_const
:
23559 type
= die_type (die
, cu
);
23560 result
= write_constant_as_bytes (obstack
, byte_order
,
23561 type
, attr
->as_signed (), len
);
23564 case DW_FORM_udata
:
23565 type
= die_type (die
, cu
);
23566 result
= write_constant_as_bytes (obstack
, byte_order
,
23567 type
, attr
->as_unsigned (), len
);
23571 complaint (_("unsupported const value attribute form: '%s'"),
23572 dwarf_form_name (attr
->form
));
23582 dwarf2_fetch_die_type_sect_off (sect_offset sect_off
,
23583 dwarf2_per_cu_data
*per_cu
,
23584 dwarf2_per_objfile
*per_objfile
,
23585 const char **var_name
)
23587 struct die_info
*die
;
23589 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
23591 cu
= load_cu (per_cu
, per_objfile
, false);
23596 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
23600 if (var_name
!= nullptr)
23601 *var_name
= var_decl_name (die
, cu
);
23602 return die_type (die
, cu
);
23608 dwarf2_get_die_type (cu_offset die_offset
,
23609 dwarf2_per_cu_data
*per_cu
,
23610 dwarf2_per_objfile
*per_objfile
)
23612 sect_offset die_offset_sect
= per_cu
->sect_off
+ to_underlying (die_offset
);
23613 return get_die_type_at_offset (die_offset_sect
, per_cu
, per_objfile
);
23616 /* Follow type unit SIG_TYPE referenced by SRC_DIE.
23617 On entry *REF_CU is the CU of SRC_DIE.
23618 On exit *REF_CU is the CU of the result.
23619 Returns NULL if the referenced DIE isn't found. */
23621 static struct die_info
*
23622 follow_die_sig_1 (struct die_info
*src_die
, struct signatured_type
*sig_type
,
23623 struct dwarf2_cu
**ref_cu
)
23625 struct die_info temp_die
;
23626 struct dwarf2_cu
*sig_cu
;
23627 struct die_info
*die
;
23628 dwarf2_per_objfile
*per_objfile
= (*ref_cu
)->per_objfile
;
23631 /* While it might be nice to assert sig_type->type == NULL here,
23632 we can get here for DW_AT_imported_declaration where we need
23633 the DIE not the type. */
23635 /* If necessary, add it to the queue and load its DIEs.
23637 Even if maybe_queue_comp_unit doesn't require us to load the CU's DIEs,
23638 it doesn't mean they are currently loaded. Since we require them
23639 to be loaded, we must check for ourselves. */
23640 if (maybe_queue_comp_unit (*ref_cu
, sig_type
, per_objfile
,
23642 || per_objfile
->get_cu (sig_type
) == nullptr)
23643 read_signatured_type (sig_type
, per_objfile
);
23645 sig_cu
= per_objfile
->get_cu (sig_type
);
23646 gdb_assert (sig_cu
!= NULL
);
23647 gdb_assert (to_underlying (sig_type
->type_offset_in_section
) != 0);
23648 temp_die
.sect_off
= sig_type
->type_offset_in_section
;
23649 die
= (struct die_info
*) htab_find_with_hash (sig_cu
->die_hash
, &temp_die
,
23650 to_underlying (temp_die
.sect_off
));
23653 /* For .gdb_index version 7 keep track of included TUs.
23654 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
23655 if (per_objfile
->per_bfd
->index_table
!= NULL
23656 && per_objfile
->per_bfd
->index_table
->version
<= 7)
23658 (*ref_cu
)->per_cu
->imported_symtabs_push (sig_cu
->per_cu
);
23668 /* Follow signatured type referenced by ATTR in SRC_DIE.
23669 On entry *REF_CU is the CU of SRC_DIE.
23670 On exit *REF_CU is the CU of the result.
23671 The result is the DIE of the type.
23672 If the referenced type cannot be found an error is thrown. */
23674 static struct die_info
*
23675 follow_die_sig (struct die_info
*src_die
, const struct attribute
*attr
,
23676 struct dwarf2_cu
**ref_cu
)
23678 ULONGEST signature
= attr
->as_signature ();
23679 struct signatured_type
*sig_type
;
23680 struct die_info
*die
;
23682 gdb_assert (attr
->form
== DW_FORM_ref_sig8
);
23684 sig_type
= lookup_signatured_type (*ref_cu
, signature
);
23685 /* sig_type will be NULL if the signatured type is missing from
23687 if (sig_type
== NULL
)
23689 error (_("Dwarf Error: Cannot find signatured DIE %s referenced"
23690 " from DIE at %s [in module %s]"),
23691 hex_string (signature
), sect_offset_str (src_die
->sect_off
),
23692 objfile_name ((*ref_cu
)->per_objfile
->objfile
));
23695 die
= follow_die_sig_1 (src_die
, sig_type
, ref_cu
);
23698 dump_die_for_error (src_die
);
23699 error (_("Dwarf Error: Problem reading signatured DIE %s referenced"
23700 " from DIE at %s [in module %s]"),
23701 hex_string (signature
), sect_offset_str (src_die
->sect_off
),
23702 objfile_name ((*ref_cu
)->per_objfile
->objfile
));
23708 /* Get the type specified by SIGNATURE referenced in DIE/CU,
23709 reading in and processing the type unit if necessary. */
23711 static struct type
*
23712 get_signatured_type (struct die_info
*die
, ULONGEST signature
,
23713 struct dwarf2_cu
*cu
)
23715 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
23716 struct signatured_type
*sig_type
;
23717 struct dwarf2_cu
*type_cu
;
23718 struct die_info
*type_die
;
23721 sig_type
= lookup_signatured_type (cu
, signature
);
23722 /* sig_type will be NULL if the signatured type is missing from
23724 if (sig_type
== NULL
)
23726 complaint (_("Dwarf Error: Cannot find signatured DIE %s referenced"
23727 " from DIE at %s [in module %s]"),
23728 hex_string (signature
), sect_offset_str (die
->sect_off
),
23729 objfile_name (per_objfile
->objfile
));
23730 return build_error_marker_type (cu
, die
);
23733 /* If we already know the type we're done. */
23734 type
= per_objfile
->get_type_for_signatured_type (sig_type
);
23735 if (type
!= nullptr)
23739 type_die
= follow_die_sig_1 (die
, sig_type
, &type_cu
);
23740 if (type_die
!= NULL
)
23742 /* N.B. We need to call get_die_type to ensure only one type for this DIE
23743 is created. This is important, for example, because for c++ classes
23744 we need TYPE_NAME set which is only done by new_symbol. Blech. */
23745 type
= read_type_die (type_die
, type_cu
);
23748 complaint (_("Dwarf Error: Cannot build signatured type %s"
23749 " referenced from DIE at %s [in module %s]"),
23750 hex_string (signature
), sect_offset_str (die
->sect_off
),
23751 objfile_name (per_objfile
->objfile
));
23752 type
= build_error_marker_type (cu
, die
);
23757 complaint (_("Dwarf Error: Problem reading signatured DIE %s referenced"
23758 " from DIE at %s [in module %s]"),
23759 hex_string (signature
), sect_offset_str (die
->sect_off
),
23760 objfile_name (per_objfile
->objfile
));
23761 type
= build_error_marker_type (cu
, die
);
23764 per_objfile
->set_type_for_signatured_type (sig_type
, type
);
23769 /* Get the type specified by the DW_AT_signature ATTR in DIE/CU,
23770 reading in and processing the type unit if necessary. */
23772 static struct type
*
23773 get_DW_AT_signature_type (struct die_info
*die
, const struct attribute
*attr
,
23774 struct dwarf2_cu
*cu
) /* ARI: editCase function */
23776 /* Yes, DW_AT_signature can use a non-ref_sig8 reference. */
23777 if (attr
->form_is_ref ())
23779 struct dwarf2_cu
*type_cu
= cu
;
23780 struct die_info
*type_die
= follow_die_ref (die
, attr
, &type_cu
);
23782 return read_type_die (type_die
, type_cu
);
23784 else if (attr
->form
== DW_FORM_ref_sig8
)
23786 return get_signatured_type (die
, attr
->as_signature (), cu
);
23790 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
23792 complaint (_("Dwarf Error: DW_AT_signature has bad form %s in DIE"
23793 " at %s [in module %s]"),
23794 dwarf_form_name (attr
->form
), sect_offset_str (die
->sect_off
),
23795 objfile_name (per_objfile
->objfile
));
23796 return build_error_marker_type (cu
, die
);
23800 /* Load the DIEs associated with type unit PER_CU into memory. */
23803 load_full_type_unit (dwarf2_per_cu_data
*per_cu
,
23804 dwarf2_per_objfile
*per_objfile
)
23806 struct signatured_type
*sig_type
;
23808 /* Caller is responsible for ensuring type_unit_groups don't get here. */
23809 gdb_assert (! per_cu
->type_unit_group_p ());
23811 /* We have the per_cu, but we need the signatured_type.
23812 Fortunately this is an easy translation. */
23813 gdb_assert (per_cu
->is_debug_types
);
23814 sig_type
= (struct signatured_type
*) per_cu
;
23816 gdb_assert (per_objfile
->get_cu (per_cu
) == nullptr);
23818 read_signatured_type (sig_type
, per_objfile
);
23820 gdb_assert (per_objfile
->get_cu (per_cu
) != nullptr);
23823 /* Read in a signatured type and build its CU and DIEs.
23824 If the type is a stub for the real type in a DWO file,
23825 read in the real type from the DWO file as well. */
23828 read_signatured_type (signatured_type
*sig_type
,
23829 dwarf2_per_objfile
*per_objfile
)
23831 gdb_assert (sig_type
->is_debug_types
);
23832 gdb_assert (per_objfile
->get_cu (sig_type
) == nullptr);
23834 cutu_reader
reader (sig_type
, per_objfile
, nullptr, nullptr, false);
23836 if (!reader
.dummy_p
)
23838 struct dwarf2_cu
*cu
= reader
.cu
;
23839 const gdb_byte
*info_ptr
= reader
.info_ptr
;
23841 gdb_assert (cu
->die_hash
== NULL
);
23843 htab_create_alloc_ex (cu
->header
.length
/ 12,
23847 &cu
->comp_unit_obstack
,
23848 hashtab_obstack_allocate
,
23849 dummy_obstack_deallocate
);
23851 if (reader
.comp_unit_die
->has_children
)
23852 reader
.comp_unit_die
->child
23853 = read_die_and_siblings (&reader
, info_ptr
, &info_ptr
,
23854 reader
.comp_unit_die
);
23855 cu
->dies
= reader
.comp_unit_die
;
23856 /* comp_unit_die is not stored in die_hash, no need. */
23858 /* We try not to read any attributes in this function, because
23859 not all CUs needed for references have been loaded yet, and
23860 symbol table processing isn't initialized. But we have to
23861 set the CU language, or we won't be able to build types
23862 correctly. Similarly, if we do not read the producer, we can
23863 not apply producer-specific interpretation. */
23864 prepare_one_comp_unit (cu
, cu
->dies
, language_minimal
);
23869 sig_type
->tu_read
= 1;
23872 /* Decode simple location descriptions.
23873 Given a pointer to a dwarf block that defines a location, compute
23874 the location and return the value. If COMPUTED is non-null, it is
23875 set to true to indicate that decoding was successful, and false
23876 otherwise. If COMPUTED is null, then this function may emit a
23880 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
, bool *computed
)
23882 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
23884 size_t size
= blk
->size
;
23885 const gdb_byte
*data
= blk
->data
;
23886 CORE_ADDR stack
[64];
23888 unsigned int bytes_read
, unsnd
;
23891 if (computed
!= nullptr)
23897 stack
[++stacki
] = 0;
23936 stack
[++stacki
] = op
- DW_OP_lit0
;
23971 stack
[++stacki
] = op
- DW_OP_reg0
;
23974 if (computed
== nullptr)
23975 dwarf2_complex_location_expr_complaint ();
23982 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
23984 stack
[++stacki
] = unsnd
;
23987 if (computed
== nullptr)
23988 dwarf2_complex_location_expr_complaint ();
23995 stack
[++stacki
] = cu
->header
.read_address (objfile
->obfd
, &data
[i
],
24000 case DW_OP_const1u
:
24001 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
24005 case DW_OP_const1s
:
24006 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
24010 case DW_OP_const2u
:
24011 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
24015 case DW_OP_const2s
:
24016 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
24020 case DW_OP_const4u
:
24021 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
24025 case DW_OP_const4s
:
24026 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
24030 case DW_OP_const8u
:
24031 stack
[++stacki
] = read_8_bytes (objfile
->obfd
, &data
[i
]);
24036 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
24042 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
24047 stack
[stacki
+ 1] = stack
[stacki
];
24052 stack
[stacki
- 1] += stack
[stacki
];
24056 case DW_OP_plus_uconst
:
24057 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
),
24063 stack
[stacki
- 1] -= stack
[stacki
];
24068 /* If we're not the last op, then we definitely can't encode
24069 this using GDB's address_class enum. This is valid for partial
24070 global symbols, although the variable's address will be bogus
24074 if (computed
== nullptr)
24075 dwarf2_complex_location_expr_complaint ();
24081 case DW_OP_GNU_push_tls_address
:
24082 case DW_OP_form_tls_address
:
24083 /* The top of the stack has the offset from the beginning
24084 of the thread control block at which the variable is located. */
24085 /* Nothing should follow this operator, so the top of stack would
24087 /* This is valid for partial global symbols, but the variable's
24088 address will be bogus in the psymtab. Make it always at least
24089 non-zero to not look as a variable garbage collected by linker
24090 which have DW_OP_addr 0. */
24093 if (computed
== nullptr)
24094 dwarf2_complex_location_expr_complaint ();
24101 case DW_OP_GNU_uninit
:
24102 if (computed
!= nullptr)
24107 case DW_OP_GNU_addr_index
:
24108 case DW_OP_GNU_const_index
:
24109 stack
[++stacki
] = read_addr_index_from_leb128 (cu
, &data
[i
],
24115 if (computed
== nullptr)
24117 const char *name
= get_DW_OP_name (op
);
24120 complaint (_("unsupported stack op: '%s'"),
24123 complaint (_("unsupported stack op: '%02x'"),
24127 return (stack
[stacki
]);
24130 /* Enforce maximum stack depth of SIZE-1 to avoid writing
24131 outside of the allocated space. Also enforce minimum>0. */
24132 if (stacki
>= ARRAY_SIZE (stack
) - 1)
24134 if (computed
== nullptr)
24135 complaint (_("location description stack overflow"));
24141 if (computed
== nullptr)
24142 complaint (_("location description stack underflow"));
24147 if (computed
!= nullptr)
24149 return (stack
[stacki
]);
24152 /* memory allocation interface */
24154 static struct dwarf_block
*
24155 dwarf_alloc_block (struct dwarf2_cu
*cu
)
24157 return XOBNEW (&cu
->comp_unit_obstack
, struct dwarf_block
);
24160 static struct die_info
*
24161 dwarf_alloc_die (struct dwarf2_cu
*cu
, int num_attrs
)
24163 struct die_info
*die
;
24164 size_t size
= sizeof (struct die_info
);
24167 size
+= (num_attrs
- 1) * sizeof (struct attribute
);
24169 die
= (struct die_info
*) obstack_alloc (&cu
->comp_unit_obstack
, size
);
24170 memset (die
, 0, sizeof (struct die_info
));
24176 /* Macro support. */
24178 /* An overload of dwarf_decode_macros that finds the correct section
24179 and ensures it is read in before calling the other overload. */
24182 dwarf_decode_macros (struct dwarf2_cu
*cu
, unsigned int offset
,
24183 int section_is_gnu
)
24185 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
24186 struct objfile
*objfile
= per_objfile
->objfile
;
24187 const struct line_header
*lh
= cu
->line_header
;
24188 unsigned int offset_size
= cu
->header
.offset_size
;
24189 struct dwarf2_section_info
*section
;
24190 const char *section_name
;
24192 if (cu
->dwo_unit
!= nullptr)
24194 if (section_is_gnu
)
24196 section
= &cu
->dwo_unit
->dwo_file
->sections
.macro
;
24197 section_name
= ".debug_macro.dwo";
24201 section
= &cu
->dwo_unit
->dwo_file
->sections
.macinfo
;
24202 section_name
= ".debug_macinfo.dwo";
24207 if (section_is_gnu
)
24209 section
= &per_objfile
->per_bfd
->macro
;
24210 section_name
= ".debug_macro";
24214 section
= &per_objfile
->per_bfd
->macinfo
;
24215 section_name
= ".debug_macinfo";
24219 section
->read (objfile
);
24220 if (section
->buffer
== nullptr)
24222 complaint (_("missing %s section"), section_name
);
24226 buildsym_compunit
*builder
= cu
->get_builder ();
24228 struct dwarf2_section_info
*str_offsets_section
;
24229 struct dwarf2_section_info
*str_section
;
24230 gdb::optional
<ULONGEST
> str_offsets_base
;
24232 if (cu
->dwo_unit
!= nullptr)
24234 str_offsets_section
= &cu
->dwo_unit
->dwo_file
24235 ->sections
.str_offsets
;
24236 str_section
= &cu
->dwo_unit
->dwo_file
->sections
.str
;
24237 str_offsets_base
= cu
->header
.addr_size
;
24241 str_offsets_section
= &per_objfile
->per_bfd
->str_offsets
;
24242 str_section
= &per_objfile
->per_bfd
->str
;
24243 str_offsets_base
= cu
->str_offsets_base
;
24246 dwarf_decode_macros (per_objfile
, builder
, section
, lh
,
24247 offset_size
, offset
, str_section
, str_offsets_section
,
24248 str_offsets_base
, section_is_gnu
);
24251 /* Return the .debug_loc section to use for CU.
24252 For DWO files use .debug_loc.dwo. */
24254 static struct dwarf2_section_info
*
24255 cu_debug_loc_section (struct dwarf2_cu
*cu
)
24257 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
24261 struct dwo_sections
*sections
= &cu
->dwo_unit
->dwo_file
->sections
;
24263 return cu
->header
.version
>= 5 ? §ions
->loclists
: §ions
->loc
;
24265 return (cu
->header
.version
>= 5 ? &per_objfile
->per_bfd
->loclists
24266 : &per_objfile
->per_bfd
->loc
);
24269 /* Return the .debug_rnglists section to use for CU. */
24270 static struct dwarf2_section_info
*
24271 cu_debug_rnglists_section (struct dwarf2_cu
*cu
, dwarf_tag tag
)
24273 if (cu
->header
.version
< 5)
24274 error (_(".debug_rnglists section cannot be used in DWARF %d"),
24275 cu
->header
.version
);
24276 struct dwarf2_per_objfile
*dwarf2_per_objfile
= cu
->per_objfile
;
24278 /* Make sure we read the .debug_rnglists section from the file that
24279 contains the DW_AT_ranges attribute we are reading. Normally that
24280 would be the .dwo file, if there is one. However for DW_TAG_compile_unit
24281 or DW_TAG_skeleton unit, we always want to read from objfile/linked
24283 if (cu
->dwo_unit
!= nullptr
24284 && tag
!= DW_TAG_compile_unit
24285 && tag
!= DW_TAG_skeleton_unit
)
24287 struct dwo_sections
*sections
= &cu
->dwo_unit
->dwo_file
->sections
;
24289 if (sections
->rnglists
.size
> 0)
24290 return §ions
->rnglists
;
24292 error (_(".debug_rnglists section is missing from .dwo file."));
24294 return &dwarf2_per_objfile
->per_bfd
->rnglists
;
24297 /* A helper function that fills in a dwarf2_loclist_baton. */
24300 fill_in_loclist_baton (struct dwarf2_cu
*cu
,
24301 struct dwarf2_loclist_baton
*baton
,
24302 const struct attribute
*attr
)
24304 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
24305 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
24307 section
->read (per_objfile
->objfile
);
24309 baton
->per_objfile
= per_objfile
;
24310 baton
->per_cu
= cu
->per_cu
;
24311 gdb_assert (baton
->per_cu
);
24312 /* We don't know how long the location list is, but make sure we
24313 don't run off the edge of the section. */
24314 baton
->size
= section
->size
- attr
->as_unsigned ();
24315 baton
->data
= section
->buffer
+ attr
->as_unsigned ();
24316 if (cu
->base_address
.has_value ())
24317 baton
->base_address
= *cu
->base_address
;
24319 baton
->base_address
= 0;
24320 baton
->from_dwo
= cu
->dwo_unit
!= NULL
;
24324 dwarf2_symbol_mark_computed (const struct attribute
*attr
, struct symbol
*sym
,
24325 struct dwarf2_cu
*cu
, int is_block
)
24327 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
24328 struct objfile
*objfile
= per_objfile
->objfile
;
24329 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
24331 if (attr
->form_is_section_offset ()
24332 /* .debug_loc{,.dwo} may not exist at all, or the offset may be outside
24333 the section. If so, fall through to the complaint in the
24335 && attr
->as_unsigned () < section
->get_size (objfile
))
24337 struct dwarf2_loclist_baton
*baton
;
24339 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_loclist_baton
);
24341 fill_in_loclist_baton (cu
, baton
, attr
);
24343 if (!cu
->base_address
.has_value ())
24344 complaint (_("Location list used without "
24345 "specifying the CU base address."));
24347 SYMBOL_ACLASS_INDEX (sym
) = (is_block
24348 ? dwarf2_loclist_block_index
24349 : dwarf2_loclist_index
);
24350 SYMBOL_LOCATION_BATON (sym
) = baton
;
24354 struct dwarf2_locexpr_baton
*baton
;
24356 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
24357 baton
->per_objfile
= per_objfile
;
24358 baton
->per_cu
= cu
->per_cu
;
24359 gdb_assert (baton
->per_cu
);
24361 if (attr
->form_is_block ())
24363 /* Note that we're just copying the block's data pointer
24364 here, not the actual data. We're still pointing into the
24365 info_buffer for SYM's objfile; right now we never release
24366 that buffer, but when we do clean up properly this may
24368 struct dwarf_block
*block
= attr
->as_block ();
24369 baton
->size
= block
->size
;
24370 baton
->data
= block
->data
;
24374 dwarf2_invalid_attrib_class_complaint ("location description",
24375 sym
->natural_name ());
24379 SYMBOL_ACLASS_INDEX (sym
) = (is_block
24380 ? dwarf2_locexpr_block_index
24381 : dwarf2_locexpr_index
);
24382 SYMBOL_LOCATION_BATON (sym
) = baton
;
24388 const comp_unit_head
*
24389 dwarf2_per_cu_data::get_header () const
24391 if (!m_header_read_in
)
24393 const gdb_byte
*info_ptr
24394 = this->section
->buffer
+ to_underlying (this->sect_off
);
24396 memset (&m_header
, 0, sizeof (m_header
));
24398 read_comp_unit_head (&m_header
, info_ptr
, this->section
,
24399 rcuh_kind::COMPILE
);
24401 m_header_read_in
= true;
24410 dwarf2_per_cu_data::addr_size () const
24412 return this->get_header ()->addr_size
;
24418 dwarf2_per_cu_data::offset_size () const
24420 return this->get_header ()->offset_size
;
24426 dwarf2_per_cu_data::ref_addr_size () const
24428 const comp_unit_head
*header
= this->get_header ();
24430 if (header
->version
== 2)
24431 return header
->addr_size
;
24433 return header
->offset_size
;
24436 /* A helper function for dwarf2_find_containing_comp_unit that returns
24437 the index of the result, and that searches a vector. It will
24438 return a result even if the offset in question does not actually
24439 occur in any CU. This is separate so that it can be unit
24443 dwarf2_find_containing_comp_unit
24444 (sect_offset sect_off
,
24445 unsigned int offset_in_dwz
,
24446 const std::vector
<dwarf2_per_cu_data_up
> &all_comp_units
)
24451 high
= all_comp_units
.size () - 1;
24454 struct dwarf2_per_cu_data
*mid_cu
;
24455 int mid
= low
+ (high
- low
) / 2;
24457 mid_cu
= all_comp_units
[mid
].get ();
24458 if (mid_cu
->is_dwz
> offset_in_dwz
24459 || (mid_cu
->is_dwz
== offset_in_dwz
24460 && mid_cu
->sect_off
+ mid_cu
->length
> sect_off
))
24465 gdb_assert (low
== high
);
24469 /* Locate the .debug_info compilation unit from CU's objfile which contains
24470 the DIE at OFFSET. Raises an error on failure. */
24472 static struct dwarf2_per_cu_data
*
24473 dwarf2_find_containing_comp_unit (sect_offset sect_off
,
24474 unsigned int offset_in_dwz
,
24475 dwarf2_per_objfile
*per_objfile
)
24477 int low
= dwarf2_find_containing_comp_unit
24478 (sect_off
, offset_in_dwz
, per_objfile
->per_bfd
->all_comp_units
);
24479 dwarf2_per_cu_data
*this_cu
24480 = per_objfile
->per_bfd
->all_comp_units
[low
].get ();
24482 if (this_cu
->is_dwz
!= offset_in_dwz
|| this_cu
->sect_off
> sect_off
)
24484 if (low
== 0 || this_cu
->is_dwz
!= offset_in_dwz
)
24485 error (_("Dwarf Error: could not find partial DIE containing "
24486 "offset %s [in module %s]"),
24487 sect_offset_str (sect_off
),
24488 bfd_get_filename (per_objfile
->objfile
->obfd
));
24490 gdb_assert (per_objfile
->per_bfd
->all_comp_units
[low
-1]->sect_off
24492 return per_objfile
->per_bfd
->all_comp_units
[low
- 1].get ();
24496 if (low
== per_objfile
->per_bfd
->all_comp_units
.size () - 1
24497 && sect_off
>= this_cu
->sect_off
+ this_cu
->length
)
24498 error (_("invalid dwarf2 offset %s"), sect_offset_str (sect_off
));
24499 gdb_assert (sect_off
< this_cu
->sect_off
+ this_cu
->length
);
24506 namespace selftests
{
24507 namespace find_containing_comp_unit
{
24512 dwarf2_per_cu_data_up
one (new dwarf2_per_cu_data
);
24513 dwarf2_per_cu_data
*one_ptr
= one
.get ();
24514 dwarf2_per_cu_data_up
two (new dwarf2_per_cu_data
);
24515 dwarf2_per_cu_data
*two_ptr
= two
.get ();
24516 dwarf2_per_cu_data_up
three (new dwarf2_per_cu_data
);
24517 dwarf2_per_cu_data
*three_ptr
= three
.get ();
24518 dwarf2_per_cu_data_up
four (new dwarf2_per_cu_data
);
24519 dwarf2_per_cu_data
*four_ptr
= four
.get ();
24522 two
->sect_off
= sect_offset (one
->length
);
24527 four
->sect_off
= sect_offset (three
->length
);
24531 std::vector
<dwarf2_per_cu_data_up
> units
;
24532 units
.push_back (std::move (one
));
24533 units
.push_back (std::move (two
));
24534 units
.push_back (std::move (three
));
24535 units
.push_back (std::move (four
));
24539 result
= dwarf2_find_containing_comp_unit (sect_offset (0), 0, units
);
24540 SELF_CHECK (units
[result
].get () == one_ptr
);
24541 result
= dwarf2_find_containing_comp_unit (sect_offset (3), 0, units
);
24542 SELF_CHECK (units
[result
].get () == one_ptr
);
24543 result
= dwarf2_find_containing_comp_unit (sect_offset (5), 0, units
);
24544 SELF_CHECK (units
[result
].get () == two_ptr
);
24546 result
= dwarf2_find_containing_comp_unit (sect_offset (0), 1, units
);
24547 SELF_CHECK (units
[result
].get () == three_ptr
);
24548 result
= dwarf2_find_containing_comp_unit (sect_offset (3), 1, units
);
24549 SELF_CHECK (units
[result
].get () == three_ptr
);
24550 result
= dwarf2_find_containing_comp_unit (sect_offset (5), 1, units
);
24551 SELF_CHECK (units
[result
].get () == four_ptr
);
24557 #endif /* GDB_SELF_TEST */
24559 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
24562 prepare_one_comp_unit (struct dwarf2_cu
*cu
, struct die_info
*comp_unit_die
,
24563 enum language pretend_language
)
24565 struct attribute
*attr
;
24567 cu
->producer
= dwarf2_string_attr (comp_unit_die
, DW_AT_producer
, cu
);
24569 /* Set the language we're debugging. */
24570 attr
= dwarf2_attr (comp_unit_die
, DW_AT_language
, cu
);
24571 if (cu
->producer
!= nullptr
24572 && strstr (cu
->producer
, "IBM XL C for OpenCL") != NULL
)
24574 /* The XLCL doesn't generate DW_LANG_OpenCL because this
24575 attribute is not standardised yet. As a workaround for the
24576 language detection we fall back to the DW_AT_producer
24578 cu
->per_cu
->lang
= language_opencl
;
24580 else if (cu
->producer
!= nullptr
24581 && strstr (cu
->producer
, "GNU Go ") != NULL
)
24583 /* Similar hack for Go. */
24584 cu
->per_cu
->lang
= language_go
;
24586 else if (attr
!= nullptr)
24587 cu
->per_cu
->lang
= dwarf_lang_to_enum_language (attr
->constant_value (0));
24589 cu
->per_cu
->lang
= pretend_language
;
24590 cu
->language_defn
= language_def (cu
->per_cu
->lang
);
24596 dwarf2_per_objfile::get_cu (dwarf2_per_cu_data
*per_cu
)
24598 auto it
= m_dwarf2_cus
.find (per_cu
);
24599 if (it
== m_dwarf2_cus
.end ())
24608 dwarf2_per_objfile::set_cu (dwarf2_per_cu_data
*per_cu
, dwarf2_cu
*cu
)
24610 gdb_assert (this->get_cu (per_cu
) == nullptr);
24612 m_dwarf2_cus
[per_cu
] = cu
;
24618 dwarf2_per_objfile::age_comp_units ()
24620 dwarf_read_debug_printf_v ("running");
24622 /* This is not expected to be called in the middle of CU expansion. There is
24623 an invariant that if a CU is in the CUs-to-expand queue, its DIEs are
24624 loaded in memory. Calling age_comp_units while the queue is in use could
24625 make us free the DIEs for a CU that is in the queue and therefore break
24627 gdb_assert (!this->per_bfd
->queue
.has_value ());
24629 /* Start by clearing all marks. */
24630 for (auto pair
: m_dwarf2_cus
)
24631 pair
.second
->clear_mark ();
24633 /* Traverse all CUs, mark them and their dependencies if used recently
24635 for (auto pair
: m_dwarf2_cus
)
24637 dwarf2_cu
*cu
= pair
.second
;
24640 if (cu
->last_used
<= dwarf_max_cache_age
)
24644 /* Delete all CUs still not marked. */
24645 for (auto it
= m_dwarf2_cus
.begin (); it
!= m_dwarf2_cus
.end ();)
24647 dwarf2_cu
*cu
= it
->second
;
24649 if (!cu
->is_marked ())
24651 dwarf_read_debug_printf_v ("deleting old CU %s",
24652 sect_offset_str (cu
->per_cu
->sect_off
));
24654 it
= m_dwarf2_cus
.erase (it
);
24664 dwarf2_per_objfile::remove_cu (dwarf2_per_cu_data
*per_cu
)
24666 auto it
= m_dwarf2_cus
.find (per_cu
);
24667 if (it
== m_dwarf2_cus
.end ())
24672 m_dwarf2_cus
.erase (it
);
24675 dwarf2_per_objfile::~dwarf2_per_objfile ()
24680 /* A set of CU "per_cu" pointer, DIE offset, and GDB type pointer.
24681 We store these in a hash table separate from the DIEs, and preserve them
24682 when the DIEs are flushed out of cache.
24684 The CU "per_cu" pointer is needed because offset alone is not enough to
24685 uniquely identify the type. A file may have multiple .debug_types sections,
24686 or the type may come from a DWO file. Furthermore, while it's more logical
24687 to use per_cu->section+offset, with Fission the section with the data is in
24688 the DWO file but we don't know that section at the point we need it.
24689 We have to use something in dwarf2_per_cu_data (or the pointer to it)
24690 because we can enter the lookup routine, get_die_type_at_offset, from
24691 outside this file, and thus won't necessarily have PER_CU->cu.
24692 Fortunately, PER_CU is stable for the life of the objfile. */
24694 struct dwarf2_per_cu_offset_and_type
24696 const struct dwarf2_per_cu_data
*per_cu
;
24697 sect_offset sect_off
;
24701 /* Hash function for a dwarf2_per_cu_offset_and_type. */
24704 per_cu_offset_and_type_hash (const void *item
)
24706 const struct dwarf2_per_cu_offset_and_type
*ofs
24707 = (const struct dwarf2_per_cu_offset_and_type
*) item
;
24709 return (uintptr_t) ofs
->per_cu
+ to_underlying (ofs
->sect_off
);
24712 /* Equality function for a dwarf2_per_cu_offset_and_type. */
24715 per_cu_offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
24717 const struct dwarf2_per_cu_offset_and_type
*ofs_lhs
24718 = (const struct dwarf2_per_cu_offset_and_type
*) item_lhs
;
24719 const struct dwarf2_per_cu_offset_and_type
*ofs_rhs
24720 = (const struct dwarf2_per_cu_offset_and_type
*) item_rhs
;
24722 return (ofs_lhs
->per_cu
== ofs_rhs
->per_cu
24723 && ofs_lhs
->sect_off
== ofs_rhs
->sect_off
);
24726 /* Set the type associated with DIE to TYPE. Save it in CU's hash
24727 table if necessary. For convenience, return TYPE.
24729 The DIEs reading must have careful ordering to:
24730 * Not cause infinite loops trying to read in DIEs as a prerequisite for
24731 reading current DIE.
24732 * Not trying to dereference contents of still incompletely read in types
24733 while reading in other DIEs.
24734 * Enable referencing still incompletely read in types just by a pointer to
24735 the type without accessing its fields.
24737 Therefore caller should follow these rules:
24738 * Try to fetch any prerequisite types we may need to build this DIE type
24739 before building the type and calling set_die_type.
24740 * After building type call set_die_type for current DIE as soon as
24741 possible before fetching more types to complete the current type.
24742 * Make the type as complete as possible before fetching more types. */
24744 static struct type
*
24745 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
,
24746 bool skip_data_location
)
24748 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
24749 struct dwarf2_per_cu_offset_and_type
**slot
, ofs
;
24750 struct objfile
*objfile
= per_objfile
->objfile
;
24751 struct attribute
*attr
;
24752 struct dynamic_prop prop
;
24754 /* For Ada types, make sure that the gnat-specific data is always
24755 initialized (if not already set). There are a few types where
24756 we should not be doing so, because the type-specific area is
24757 already used to hold some other piece of info (eg: TYPE_CODE_FLT
24758 where the type-specific area is used to store the floatformat).
24759 But this is not a problem, because the gnat-specific information
24760 is actually not needed for these types. */
24761 if (need_gnat_info (cu
)
24762 && type
->code () != TYPE_CODE_FUNC
24763 && type
->code () != TYPE_CODE_FLT
24764 && type
->code () != TYPE_CODE_METHODPTR
24765 && type
->code () != TYPE_CODE_MEMBERPTR
24766 && type
->code () != TYPE_CODE_METHOD
24767 && type
->code () != TYPE_CODE_FIXED_POINT
24768 && !HAVE_GNAT_AUX_INFO (type
))
24769 INIT_GNAT_SPECIFIC (type
);
24771 /* Read DW_AT_allocated and set in type. */
24772 attr
= dwarf2_attr (die
, DW_AT_allocated
, cu
);
24775 struct type
*prop_type
= cu
->addr_sized_int_type (false);
24776 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
, prop_type
))
24777 type
->add_dyn_prop (DYN_PROP_ALLOCATED
, prop
);
24780 /* Read DW_AT_associated and set in type. */
24781 attr
= dwarf2_attr (die
, DW_AT_associated
, cu
);
24784 struct type
*prop_type
= cu
->addr_sized_int_type (false);
24785 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
, prop_type
))
24786 type
->add_dyn_prop (DYN_PROP_ASSOCIATED
, prop
);
24789 /* Read DW_AT_data_location and set in type. */
24790 if (!skip_data_location
)
24792 attr
= dwarf2_attr (die
, DW_AT_data_location
, cu
);
24793 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
, cu
->addr_type ()))
24794 type
->add_dyn_prop (DYN_PROP_DATA_LOCATION
, prop
);
24797 if (per_objfile
->die_type_hash
== NULL
)
24798 per_objfile
->die_type_hash
24799 = htab_up (htab_create_alloc (127,
24800 per_cu_offset_and_type_hash
,
24801 per_cu_offset_and_type_eq
,
24802 NULL
, xcalloc
, xfree
));
24804 ofs
.per_cu
= cu
->per_cu
;
24805 ofs
.sect_off
= die
->sect_off
;
24807 slot
= (struct dwarf2_per_cu_offset_and_type
**)
24808 htab_find_slot (per_objfile
->die_type_hash
.get (), &ofs
, INSERT
);
24810 complaint (_("A problem internal to GDB: DIE %s has type already set"),
24811 sect_offset_str (die
->sect_off
));
24812 *slot
= XOBNEW (&objfile
->objfile_obstack
,
24813 struct dwarf2_per_cu_offset_and_type
);
24818 /* Look up the type for the die at SECT_OFF in PER_CU in die_type_hash,
24819 or return NULL if the die does not have a saved type. */
24821 static struct type
*
24822 get_die_type_at_offset (sect_offset sect_off
,
24823 dwarf2_per_cu_data
*per_cu
,
24824 dwarf2_per_objfile
*per_objfile
)
24826 struct dwarf2_per_cu_offset_and_type
*slot
, ofs
;
24828 if (per_objfile
->die_type_hash
== NULL
)
24831 ofs
.per_cu
= per_cu
;
24832 ofs
.sect_off
= sect_off
;
24833 slot
= ((struct dwarf2_per_cu_offset_and_type
*)
24834 htab_find (per_objfile
->die_type_hash
.get (), &ofs
));
24841 /* Look up the type for DIE in CU in die_type_hash,
24842 or return NULL if DIE does not have a saved type. */
24844 static struct type
*
24845 get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
24847 return get_die_type_at_offset (die
->sect_off
, cu
->per_cu
, cu
->per_objfile
);
24850 /* Trivial hash function for partial_die_info: the hash value of a DIE
24851 is its offset in .debug_info for this objfile. */
24854 partial_die_hash (const void *item
)
24856 const struct partial_die_info
*part_die
24857 = (const struct partial_die_info
*) item
;
24859 return to_underlying (part_die
->sect_off
);
24862 /* Trivial comparison function for partial_die_info structures: two DIEs
24863 are equal if they have the same offset. */
24866 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
24868 const struct partial_die_info
*part_die_lhs
24869 = (const struct partial_die_info
*) item_lhs
;
24870 const struct partial_die_info
*part_die_rhs
24871 = (const struct partial_die_info
*) item_rhs
;
24873 return part_die_lhs
->sect_off
== part_die_rhs
->sect_off
;
24876 struct cmd_list_element
*set_dwarf_cmdlist
;
24877 struct cmd_list_element
*show_dwarf_cmdlist
;
24880 show_check_physname (struct ui_file
*file
, int from_tty
,
24881 struct cmd_list_element
*c
, const char *value
)
24883 fprintf_filtered (file
,
24884 _("Whether to check \"physname\" is %s.\n"),
24888 void _initialize_dwarf2_read ();
24890 _initialize_dwarf2_read ()
24892 add_setshow_prefix_cmd ("dwarf", class_maintenance
,
24894 Set DWARF specific variables.\n\
24895 Configure DWARF variables such as the cache size."),
24897 Show DWARF specific variables.\n\
24898 Show DWARF variables such as the cache size."),
24899 &set_dwarf_cmdlist
, &show_dwarf_cmdlist
,
24900 &maintenance_set_cmdlist
, &maintenance_show_cmdlist
);
24902 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
24903 &dwarf_max_cache_age
, _("\
24904 Set the upper bound on the age of cached DWARF compilation units."), _("\
24905 Show the upper bound on the age of cached DWARF compilation units."), _("\
24906 A higher limit means that cached compilation units will be stored\n\
24907 in memory longer, and more total memory will be used. Zero disables\n\
24908 caching, which can slow down startup."),
24910 show_dwarf_max_cache_age
,
24911 &set_dwarf_cmdlist
,
24912 &show_dwarf_cmdlist
);
24914 add_setshow_zuinteger_cmd ("dwarf-read", no_class
, &dwarf_read_debug
, _("\
24915 Set debugging of the DWARF reader."), _("\
24916 Show debugging of the DWARF reader."), _("\
24917 When enabled (non-zero), debugging messages are printed during DWARF\n\
24918 reading and symtab expansion. A value of 1 (one) provides basic\n\
24919 information. A value greater than 1 provides more verbose information."),
24922 &setdebuglist
, &showdebuglist
);
24924 add_setshow_zuinteger_cmd ("dwarf-die", no_class
, &dwarf_die_debug
, _("\
24925 Set debugging of the DWARF DIE reader."), _("\
24926 Show debugging of the DWARF DIE reader."), _("\
24927 When enabled (non-zero), DIEs are dumped after they are read in.\n\
24928 The value is the maximum depth to print."),
24931 &setdebuglist
, &showdebuglist
);
24933 add_setshow_zuinteger_cmd ("dwarf-line", no_class
, &dwarf_line_debug
, _("\
24934 Set debugging of the dwarf line reader."), _("\
24935 Show debugging of the dwarf line reader."), _("\
24936 When enabled (non-zero), line number entries are dumped as they are read in.\n\
24937 A value of 1 (one) provides basic information.\n\
24938 A value greater than 1 provides more verbose information."),
24941 &setdebuglist
, &showdebuglist
);
24943 add_setshow_boolean_cmd ("check-physname", no_class
, &check_physname
, _("\
24944 Set cross-checking of \"physname\" code against demangler."), _("\
24945 Show cross-checking of \"physname\" code against demangler."), _("\
24946 When enabled, GDB's internal \"physname\" code is checked against\n\
24948 NULL
, show_check_physname
,
24949 &setdebuglist
, &showdebuglist
);
24951 add_setshow_boolean_cmd ("use-deprecated-index-sections",
24952 no_class
, &use_deprecated_index_sections
, _("\
24953 Set whether to use deprecated gdb_index sections."), _("\
24954 Show whether to use deprecated gdb_index sections."), _("\
24955 When enabled, deprecated .gdb_index sections are used anyway.\n\
24956 Normally they are ignored either because of a missing feature or\n\
24957 performance issue.\n\
24958 Warning: This option must be enabled before gdb reads the file."),
24961 &setlist
, &showlist
);
24963 dwarf2_locexpr_index
= register_symbol_computed_impl (LOC_COMPUTED
,
24964 &dwarf2_locexpr_funcs
);
24965 dwarf2_loclist_index
= register_symbol_computed_impl (LOC_COMPUTED
,
24966 &dwarf2_loclist_funcs
);
24968 dwarf2_locexpr_block_index
= register_symbol_block_impl (LOC_BLOCK
,
24969 &dwarf2_block_frame_base_locexpr_funcs
);
24970 dwarf2_loclist_block_index
= register_symbol_block_impl (LOC_BLOCK
,
24971 &dwarf2_block_frame_base_loclist_funcs
);
24974 selftests::register_test ("dw2_expand_symtabs_matching",
24975 selftests::dw2_expand_symtabs_matching::run_test
);
24976 selftests::register_test ("dwarf2_find_containing_comp_unit",
24977 selftests::find_containing_comp_unit::run_test
);