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.h"
36 #include "dwarf2/index-cache.h"
37 #include "dwarf2/index-common.h"
38 #include "dwarf2/leb.h"
39 #include "dwarf2/line-header.h"
40 #include "dwarf2/dwz.h"
41 #include "dwarf2/macro.h"
42 #include "dwarf2/die.h"
43 #include "dwarf2/stringify.h"
52 #include "gdb-demangle.h"
53 #include "filenames.h" /* for DOSish file names */
55 #include "complaints.h"
56 #include "dwarf2/expr.h"
57 #include "dwarf2/loc.h"
58 #include "cp-support.h"
64 #include "typeprint.h"
69 #include "gdbcore.h" /* for gnutarget */
70 #include "gdb/gdb-index.h"
75 #include "namespace.h"
76 #include "gdbsupport/function-view.h"
77 #include "gdbsupport/gdb_optional.h"
78 #include "gdbsupport/underlying.h"
79 #include "gdbsupport/hash_enum.h"
80 #include "filename-seen-cache.h"
84 #include <unordered_map>
85 #include "gdbsupport/selftest.h"
86 #include "rust-lang.h"
87 #include "gdbsupport/pathstuff.h"
88 #include "count-one-bits.h"
89 #include "debuginfod-support.h"
91 /* When == 1, print basic high level tracing messages.
92 When > 1, be more verbose.
93 This is in contrast to the low level DIE reading of dwarf_die_debug. */
94 static unsigned int dwarf_read_debug
= 0;
96 /* Print a "dwarf-read" debug statement if dwarf_read_debug is >= 1. */
98 #define dwarf_read_debug_printf(fmt, ...) \
99 debug_prefixed_printf_cond (dwarf_read_debug >= 1, "dwarf-read", fmt, \
102 /* Print a "dwarf-read" debug statement if dwarf_read_debug is >= 2. */
104 #define dwarf_read_debug_printf_v(fmt, ...) \
105 debug_prefixed_printf_cond (dwarf_read_debug >= 2, "dwarf-read", fmt, \
108 /* When non-zero, dump DIEs after they are read in. */
109 static unsigned int dwarf_die_debug
= 0;
111 /* When non-zero, dump line number entries as they are read in. */
112 unsigned int dwarf_line_debug
= 0;
114 /* When true, cross-check physname against demangler. */
115 static bool check_physname
= false;
117 /* When true, do not reject deprecated .gdb_index sections. */
118 static bool use_deprecated_index_sections
= false;
120 /* This is used to store the data that is always per objfile. */
121 static const objfile_key
<dwarf2_per_objfile
> dwarf2_objfile_data_key
;
123 /* These are used to store the dwarf2_per_bfd objects.
125 objfiles having the same BFD, which doesn't require relocations, are going to
126 share a dwarf2_per_bfd object, which is held in the _bfd_data_key version.
128 Other objfiles are not going to share a dwarf2_per_bfd with any other
129 objfiles, so they'll have their own version kept in the _objfile_data_key
131 static const struct bfd_key
<dwarf2_per_bfd
> dwarf2_per_bfd_bfd_data_key
;
132 static const struct objfile_key
<dwarf2_per_bfd
> dwarf2_per_bfd_objfile_data_key
;
134 /* The "aclass" indices for various kinds of computed DWARF symbols. */
136 static int dwarf2_locexpr_index
;
137 static int dwarf2_loclist_index
;
138 static int dwarf2_locexpr_block_index
;
139 static int dwarf2_loclist_block_index
;
141 /* Size of .debug_loclists section header for 32-bit DWARF format. */
142 #define LOCLIST_HEADER_SIZE32 12
144 /* Size of .debug_loclists section header for 64-bit DWARF format. */
145 #define LOCLIST_HEADER_SIZE64 20
147 /* Size of .debug_rnglists section header for 32-bit DWARF format. */
148 #define RNGLIST_HEADER_SIZE32 12
150 /* Size of .debug_rnglists section header for 64-bit DWARF format. */
151 #define RNGLIST_HEADER_SIZE64 20
153 /* An index into a (C++) symbol name component in a symbol name as
154 recorded in the mapped_index's symbol table. For each C++ symbol
155 in the symbol table, we record one entry for the start of each
156 component in the symbol in a table of name components, and then
157 sort the table, in order to be able to binary search symbol names,
158 ignoring leading namespaces, both completion and regular look up.
159 For example, for symbol "A::B::C", we'll have an entry that points
160 to "A::B::C", another that points to "B::C", and another for "C".
161 Note that function symbols in GDB index have no parameter
162 information, just the function/method names. You can convert a
163 name_component to a "const char *" using the
164 'mapped_index::symbol_name_at(offset_type)' method. */
166 struct name_component
168 /* Offset in the symbol name where the component starts. Stored as
169 a (32-bit) offset instead of a pointer to save memory and improve
170 locality on 64-bit architectures. */
171 offset_type name_offset
;
173 /* The symbol's index in the symbol and constant pool tables of a
178 /* Base class containing bits shared by both .gdb_index and
179 .debug_name indexes. */
181 struct mapped_index_base
183 mapped_index_base () = default;
184 DISABLE_COPY_AND_ASSIGN (mapped_index_base
);
186 /* The name_component table (a sorted vector). See name_component's
187 description above. */
188 std::vector
<name_component
> name_components
;
190 /* How NAME_COMPONENTS is sorted. */
191 enum case_sensitivity name_components_casing
;
193 /* Return the number of names in the symbol table. */
194 virtual size_t symbol_name_count () const = 0;
196 /* Get the name of the symbol at IDX in the symbol table. */
197 virtual const char *symbol_name_at
198 (offset_type idx
, dwarf2_per_objfile
*per_objfile
) const = 0;
200 /* Return whether the name at IDX in the symbol table should be
202 virtual bool symbol_name_slot_invalid (offset_type idx
) const
207 /* Build the symbol name component sorted vector, if we haven't
209 void build_name_components (dwarf2_per_objfile
*per_objfile
);
211 /* Returns the lower (inclusive) and upper (exclusive) bounds of the
212 possible matches for LN_NO_PARAMS in the name component
214 std::pair
<std::vector
<name_component
>::const_iterator
,
215 std::vector
<name_component
>::const_iterator
>
216 find_name_components_bounds (const lookup_name_info
&ln_no_params
,
218 dwarf2_per_objfile
*per_objfile
) const;
220 /* Prevent deleting/destroying via a base class pointer. */
222 ~mapped_index_base() = default;
225 /* A description of the mapped index. The file format is described in
226 a comment by the code that writes the index. */
227 struct mapped_index final
: public mapped_index_base
229 /* A slot/bucket in the symbol table hash. */
230 struct symbol_table_slot
232 const offset_type name
;
233 const offset_type vec
;
236 /* Index data format version. */
239 /* The address table data. */
240 gdb::array_view
<const gdb_byte
> address_table
;
242 /* The symbol table, implemented as a hash table. */
243 gdb::array_view
<symbol_table_slot
> symbol_table
;
245 /* A pointer to the constant pool. */
246 const char *constant_pool
= nullptr;
248 bool symbol_name_slot_invalid (offset_type idx
) const override
250 const auto &bucket
= this->symbol_table
[idx
];
251 return bucket
.name
== 0 && bucket
.vec
== 0;
254 /* Convenience method to get at the name of the symbol at IDX in the
256 const char *symbol_name_at
257 (offset_type idx
, dwarf2_per_objfile
*per_objfile
) const override
258 { return this->constant_pool
+ MAYBE_SWAP (this->symbol_table
[idx
].name
); }
260 size_t symbol_name_count () const override
261 { return this->symbol_table
.size (); }
264 /* A description of the mapped .debug_names.
265 Uninitialized map has CU_COUNT 0. */
266 struct mapped_debug_names final
: public mapped_index_base
268 bfd_endian dwarf5_byte_order
;
269 bool dwarf5_is_dwarf64
;
270 bool augmentation_is_gdb
;
272 uint32_t cu_count
= 0;
273 uint32_t tu_count
, bucket_count
, name_count
;
274 const gdb_byte
*cu_table_reordered
, *tu_table_reordered
;
275 const uint32_t *bucket_table_reordered
, *hash_table_reordered
;
276 const gdb_byte
*name_table_string_offs_reordered
;
277 const gdb_byte
*name_table_entry_offs_reordered
;
278 const gdb_byte
*entry_pool
;
285 /* Attribute name DW_IDX_*. */
288 /* Attribute form DW_FORM_*. */
291 /* Value if FORM is DW_FORM_implicit_const. */
292 LONGEST implicit_const
;
294 std::vector
<attr
> attr_vec
;
297 std::unordered_map
<ULONGEST
, index_val
> abbrev_map
;
299 const char *namei_to_name
300 (uint32_t namei
, dwarf2_per_objfile
*per_objfile
) const;
302 /* Implementation of the mapped_index_base virtual interface, for
303 the name_components cache. */
305 const char *symbol_name_at
306 (offset_type idx
, dwarf2_per_objfile
*per_objfile
) const override
307 { return namei_to_name (idx
, per_objfile
); }
309 size_t symbol_name_count () const override
310 { return this->name_count
; }
313 /* See dwarf2read.h. */
316 get_dwarf2_per_objfile (struct objfile
*objfile
)
318 return dwarf2_objfile_data_key
.get (objfile
);
321 /* Default names of the debugging sections. */
323 /* Note that if the debugging section has been compressed, it might
324 have a name like .zdebug_info. */
326 static const struct dwarf2_debug_sections dwarf2_elf_names
=
328 { ".debug_info", ".zdebug_info" },
329 { ".debug_abbrev", ".zdebug_abbrev" },
330 { ".debug_line", ".zdebug_line" },
331 { ".debug_loc", ".zdebug_loc" },
332 { ".debug_loclists", ".zdebug_loclists" },
333 { ".debug_macinfo", ".zdebug_macinfo" },
334 { ".debug_macro", ".zdebug_macro" },
335 { ".debug_str", ".zdebug_str" },
336 { ".debug_str_offsets", ".zdebug_str_offsets" },
337 { ".debug_line_str", ".zdebug_line_str" },
338 { ".debug_ranges", ".zdebug_ranges" },
339 { ".debug_rnglists", ".zdebug_rnglists" },
340 { ".debug_types", ".zdebug_types" },
341 { ".debug_addr", ".zdebug_addr" },
342 { ".debug_frame", ".zdebug_frame" },
343 { ".eh_frame", NULL
},
344 { ".gdb_index", ".zgdb_index" },
345 { ".debug_names", ".zdebug_names" },
346 { ".debug_aranges", ".zdebug_aranges" },
350 /* List of DWO/DWP sections. */
352 static const struct dwop_section_names
354 struct dwarf2_section_names abbrev_dwo
;
355 struct dwarf2_section_names info_dwo
;
356 struct dwarf2_section_names line_dwo
;
357 struct dwarf2_section_names loc_dwo
;
358 struct dwarf2_section_names loclists_dwo
;
359 struct dwarf2_section_names macinfo_dwo
;
360 struct dwarf2_section_names macro_dwo
;
361 struct dwarf2_section_names rnglists_dwo
;
362 struct dwarf2_section_names str_dwo
;
363 struct dwarf2_section_names str_offsets_dwo
;
364 struct dwarf2_section_names types_dwo
;
365 struct dwarf2_section_names cu_index
;
366 struct dwarf2_section_names tu_index
;
370 { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo" },
371 { ".debug_info.dwo", ".zdebug_info.dwo" },
372 { ".debug_line.dwo", ".zdebug_line.dwo" },
373 { ".debug_loc.dwo", ".zdebug_loc.dwo" },
374 { ".debug_loclists.dwo", ".zdebug_loclists.dwo" },
375 { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo" },
376 { ".debug_macro.dwo", ".zdebug_macro.dwo" },
377 { ".debug_rnglists.dwo", ".zdebug_rnglists.dwo" },
378 { ".debug_str.dwo", ".zdebug_str.dwo" },
379 { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo" },
380 { ".debug_types.dwo", ".zdebug_types.dwo" },
381 { ".debug_cu_index", ".zdebug_cu_index" },
382 { ".debug_tu_index", ".zdebug_tu_index" },
385 /* local data types */
387 /* The location list and range list sections (.debug_loclists & .debug_rnglists)
388 begin with a header, which contains the following information. */
389 struct loclists_rnglists_header
391 /* A 4-byte or 12-byte length containing the length of the
392 set of entries for this compilation unit, not including the
393 length field itself. */
396 /* A 2-byte version identifier. */
399 /* A 1-byte unsigned integer containing the size in bytes of an address on
400 the target system. */
401 unsigned char addr_size
;
403 /* A 1-byte unsigned integer containing the size in bytes of a segment selector
404 on the target system. */
405 unsigned char segment_collector_size
;
407 /* A 4-byte count of the number of offsets that follow the header. */
408 unsigned int offset_entry_count
;
411 /* Type used for delaying computation of method physnames.
412 See comments for compute_delayed_physnames. */
413 struct delayed_method_info
415 /* The type to which the method is attached, i.e., its parent class. */
418 /* The index of the method in the type's function fieldlists. */
421 /* The index of the method in the fieldlist. */
424 /* The name of the DIE. */
427 /* The DIE associated with this method. */
428 struct die_info
*die
;
431 /* Internal state when decoding a particular compilation unit. */
434 explicit dwarf2_cu (dwarf2_per_cu_data
*per_cu
,
435 dwarf2_per_objfile
*per_objfile
);
437 DISABLE_COPY_AND_ASSIGN (dwarf2_cu
);
439 /* TU version of handle_DW_AT_stmt_list for read_type_unit_scope.
440 Create the set of symtabs used by this TU, or if this TU is sharing
441 symtabs with another TU and the symtabs have already been created
442 then restore those symtabs in the line header.
443 We don't need the pc/line-number mapping for type units. */
444 void setup_type_unit_groups (struct die_info
*die
);
446 /* Start a symtab for DWARF. NAME, COMP_DIR, LOW_PC are passed to the
447 buildsym_compunit constructor. */
448 struct compunit_symtab
*start_symtab (const char *name
,
449 const char *comp_dir
,
452 /* Reset the builder. */
453 void reset_builder () { m_builder
.reset (); }
455 /* Return a type that is a generic pointer type, the size of which
456 matches the address size given in the compilation unit header for
458 struct type
*addr_type () const;
460 /* Find an integer type the same size as the address size given in
461 the compilation unit header for this CU. UNSIGNED_P controls if
462 the integer is unsigned or not. */
463 struct type
*addr_sized_int_type (bool unsigned_p
) const;
465 /* The header of the compilation unit. */
466 struct comp_unit_head header
{};
468 /* Base address of this compilation unit. */
469 gdb::optional
<CORE_ADDR
> base_address
;
471 /* The language we are debugging. */
472 enum language language
= language_unknown
;
473 const struct language_defn
*language_defn
= nullptr;
475 const char *producer
= nullptr;
478 /* The symtab builder for this CU. This is only non-NULL when full
479 symbols are being read. */
480 std::unique_ptr
<buildsym_compunit
> m_builder
;
483 /* The generic symbol table building routines have separate lists for
484 file scope symbols and all all other scopes (local scopes). So
485 we need to select the right one to pass to add_symbol_to_list().
486 We do it by keeping a pointer to the correct list in list_in_scope.
488 FIXME: The original dwarf code just treated the file scope as the
489 first local scope, and all other local scopes as nested local
490 scopes, and worked fine. Check to see if we really need to
491 distinguish these in buildsym.c. */
492 struct pending
**list_in_scope
= nullptr;
494 /* Hash table holding all the loaded partial DIEs
495 with partial_die->offset.SECT_OFF as hash. */
496 htab_t partial_dies
= nullptr;
498 /* Storage for things with the same lifetime as this read-in compilation
499 unit, including partial DIEs. */
500 auto_obstack comp_unit_obstack
;
502 /* Backlink to our per_cu entry. */
503 struct dwarf2_per_cu_data
*per_cu
;
505 /* The dwarf2_per_objfile that owns this. */
506 dwarf2_per_objfile
*per_objfile
;
508 /* How many compilation units ago was this CU last referenced? */
511 /* A hash table of DIE cu_offset for following references with
512 die_info->offset.sect_off as hash. */
513 htab_t die_hash
= nullptr;
515 /* Full DIEs if read in. */
516 struct die_info
*dies
= nullptr;
518 /* A set of pointers to dwarf2_per_cu_data objects for compilation
519 units referenced by this one. Only set during full symbol processing;
520 partial symbol tables do not have dependencies. */
521 htab_t dependencies
= nullptr;
523 /* Header data from the line table, during full symbol processing. */
524 struct line_header
*line_header
= nullptr;
525 /* Non-NULL if LINE_HEADER is owned by this DWARF_CU. Otherwise,
526 it's owned by dwarf2_per_bfd::line_header_hash. If non-NULL,
527 this is the DW_TAG_compile_unit die for this CU. We'll hold on
528 to the line header as long as this DIE is being processed. See
529 process_die_scope. */
530 die_info
*line_header_die_owner
= nullptr;
532 /* A list of methods which need to have physnames computed
533 after all type information has been read. */
534 std::vector
<delayed_method_info
> method_list
;
536 /* To be copied to symtab->call_site_htab. */
537 htab_t call_site_htab
= nullptr;
539 /* Non-NULL if this CU came from a DWO file.
540 There is an invariant here that is important to remember:
541 Except for attributes copied from the top level DIE in the "main"
542 (or "stub") file in preparation for reading the DWO file
543 (e.g., DW_AT_addr_base), we KISS: there is only *one* CU.
544 Either there isn't a DWO file (in which case this is NULL and the point
545 is moot), or there is and either we're not going to read it (in which
546 case this is NULL) or there is and we are reading it (in which case this
548 struct dwo_unit
*dwo_unit
= nullptr;
550 /* The DW_AT_addr_base (DW_AT_GNU_addr_base) attribute if present.
551 Note this value comes from the Fission stub CU/TU's DIE. */
552 gdb::optional
<ULONGEST
> addr_base
;
554 /* The DW_AT_GNU_ranges_base attribute, if present.
556 This is only relevant in the context of pre-DWARF 5 split units. In this
557 context, there is a .debug_ranges section in the linked executable,
558 containing all the ranges data for all the compilation units. Each
559 skeleton/stub unit has (if needed) a DW_AT_GNU_ranges_base attribute that
560 indicates the base of its contribution to that section. The DW_AT_ranges
561 attributes in the split-unit are of the form DW_FORM_sec_offset and point
562 into the .debug_ranges section of the linked file. However, they are not
563 "true" DW_FORM_sec_offset, because they are relative to the base of their
564 compilation unit's contribution, rather than relative to the beginning of
565 the section. The DW_AT_GNU_ranges_base value must be added to it to make
566 it relative to the beginning of the section.
568 Note that the value is zero when we are not in a pre-DWARF 5 split-unit
569 case, so this value can be added without needing to know whether we are in
572 N.B. If a DW_AT_ranges attribute is found on the DW_TAG_compile_unit in the
573 skeleton/stub, it must not have the base added, as it already points to the
574 right place. And since the DW_TAG_compile_unit DIE in the split-unit can't
575 have a DW_AT_ranges attribute, we can use the
577 die->tag != DW_AT_compile_unit
579 to determine whether the base should be added or not. */
580 ULONGEST gnu_ranges_base
= 0;
582 /* The DW_AT_rnglists_base attribute, if present.
584 This is used when processing attributes of form DW_FORM_rnglistx in
585 non-split units. Attributes of this form found in a split unit don't
586 use it, as split-unit files have their own non-shared .debug_rnglists.dwo
588 ULONGEST rnglists_base
= 0;
590 /* The DW_AT_loclists_base attribute if present. */
591 ULONGEST loclist_base
= 0;
593 /* When reading debug info generated by older versions of rustc, we
594 have to rewrite some union types to be struct types with a
595 variant part. This rewriting must be done after the CU is fully
596 read in, because otherwise at the point of rewriting some struct
597 type might not have been fully processed. So, we keep a list of
598 all such types here and process them after expansion. */
599 std::vector
<struct type
*> rust_unions
;
601 /* The DW_AT_str_offsets_base attribute if present. For DWARF 4 version DWO
602 files, the value is implicitly zero. For DWARF 5 version DWO files, the
603 value is often implicit and is the size of the header of
604 .debug_str_offsets section (8 or 4, depending on the address size). */
605 gdb::optional
<ULONGEST
> str_offsets_base
;
607 /* Mark used when releasing cached dies. */
610 /* This CU references .debug_loc. See the symtab->locations_valid field.
611 This test is imperfect as there may exist optimized debug code not using
612 any location list and still facing inlining issues if handled as
613 unoptimized code. For a future better test see GCC PR other/32998. */
614 bool has_loclist
: 1;
616 /* These cache the results for producer_is_* fields. CHECKED_PRODUCER is true
617 if all the producer_is_* fields are valid. This information is cached
618 because profiling CU expansion showed excessive time spent in
619 producer_is_gxx_lt_4_6. */
620 bool checked_producer
: 1;
621 bool producer_is_gxx_lt_4_6
: 1;
622 bool producer_is_gcc_lt_4_3
: 1;
623 bool producer_is_icc
: 1;
624 bool producer_is_icc_lt_14
: 1;
625 bool producer_is_codewarrior
: 1;
627 /* When true, the file that we're processing is known to have
628 debugging info for C++ namespaces. GCC 3.3.x did not produce
629 this information, but later versions do. */
631 bool processing_has_namespace_info
: 1;
633 struct partial_die_info
*find_partial_die (sect_offset sect_off
);
635 /* If this CU was inherited by another CU (via specification,
636 abstract_origin, etc), this is the ancestor CU. */
639 /* Get the buildsym_compunit for this CU. */
640 buildsym_compunit
*get_builder ()
642 /* If this CU has a builder associated with it, use that. */
643 if (m_builder
!= nullptr)
644 return m_builder
.get ();
646 /* Otherwise, search ancestors for a valid builder. */
647 if (ancestor
!= nullptr)
648 return ancestor
->get_builder ();
654 /* A struct that can be used as a hash key for tables based on DW_AT_stmt_list.
655 This includes type_unit_group and quick_file_names. */
657 struct stmt_list_hash
659 /* The DWO unit this table is from or NULL if there is none. */
660 struct dwo_unit
*dwo_unit
;
662 /* Offset in .debug_line or .debug_line.dwo. */
663 sect_offset line_sect_off
;
666 /* Each element of dwarf2_per_bfd->type_unit_groups is a pointer to
667 an object of this type. This contains elements of type unit groups
668 that can be shared across objfiles. The non-shareable parts are in
669 type_unit_group_unshareable. */
671 struct type_unit_group
673 /* dwarf2read.c's main "handle" on a TU symtab.
674 To simplify things we create an artificial CU that "includes" all the
675 type units using this stmt_list so that the rest of the code still has
676 a "per_cu" handle on the symtab. */
677 struct dwarf2_per_cu_data per_cu
;
679 /* The TUs that share this DW_AT_stmt_list entry.
680 This is added to while parsing type units to build partial symtabs,
681 and is deleted afterwards and not used again. */
682 std::vector
<signatured_type
*> *tus
;
684 /* The data used to construct the hash key. */
685 struct stmt_list_hash hash
;
688 /* These sections are what may appear in a (real or virtual) DWO file. */
692 struct dwarf2_section_info abbrev
;
693 struct dwarf2_section_info line
;
694 struct dwarf2_section_info loc
;
695 struct dwarf2_section_info loclists
;
696 struct dwarf2_section_info macinfo
;
697 struct dwarf2_section_info macro
;
698 struct dwarf2_section_info rnglists
;
699 struct dwarf2_section_info str
;
700 struct dwarf2_section_info str_offsets
;
701 /* In the case of a virtual DWO file, these two are unused. */
702 struct dwarf2_section_info info
;
703 std::vector
<dwarf2_section_info
> types
;
706 /* CUs/TUs in DWP/DWO files. */
710 /* Backlink to the containing struct dwo_file. */
711 struct dwo_file
*dwo_file
;
713 /* The "id" that distinguishes this CU/TU.
714 .debug_info calls this "dwo_id", .debug_types calls this "signature".
715 Since signatures came first, we stick with it for consistency. */
718 /* The section this CU/TU lives in, in the DWO file. */
719 struct dwarf2_section_info
*section
;
721 /* Same as dwarf2_per_cu_data:{sect_off,length} but in the DWO section. */
722 sect_offset sect_off
;
725 /* For types, offset in the type's DIE of the type defined by this TU. */
726 cu_offset type_offset_in_tu
;
729 /* include/dwarf2.h defines the DWP section codes.
730 It defines a max value but it doesn't define a min value, which we
731 use for error checking, so provide one. */
733 enum dwp_v2_section_ids
738 /* Data for one DWO file.
740 This includes virtual DWO files (a virtual DWO file is a DWO file as it
741 appears in a DWP file). DWP files don't really have DWO files per se -
742 comdat folding of types "loses" the DWO file they came from, and from
743 a high level view DWP files appear to contain a mass of random types.
744 However, to maintain consistency with the non-DWP case we pretend DWP
745 files contain virtual DWO files, and we assign each TU with one virtual
746 DWO file (generally based on the line and abbrev section offsets -
747 a heuristic that seems to work in practice). */
751 dwo_file () = default;
752 DISABLE_COPY_AND_ASSIGN (dwo_file
);
754 /* The DW_AT_GNU_dwo_name or DW_AT_dwo_name attribute.
755 For virtual DWO files the name is constructed from the section offsets
756 of abbrev,line,loc,str_offsets so that we combine virtual DWO files
757 from related CU+TUs. */
758 const char *dwo_name
= nullptr;
760 /* The DW_AT_comp_dir attribute. */
761 const char *comp_dir
= nullptr;
763 /* The bfd, when the file is open. Otherwise this is NULL.
764 This is unused(NULL) for virtual DWO files where we use dwp_file.dbfd. */
765 gdb_bfd_ref_ptr dbfd
;
767 /* The sections that make up this DWO file.
768 Remember that for virtual DWO files in DWP V2 or DWP V5, these are virtual
769 sections (for lack of a better name). */
770 struct dwo_sections sections
{};
772 /* The CUs in the file.
773 Each element is a struct dwo_unit. Multiple CUs per DWO are supported as
774 an extension to handle LLVM's Link Time Optimization output (where
775 multiple source files may be compiled into a single object/dwo pair). */
778 /* Table of TUs in the file.
779 Each element is a struct dwo_unit. */
783 /* These sections are what may appear in a DWP file. */
787 /* These are used by all DWP versions (1, 2 and 5). */
788 struct dwarf2_section_info str
;
789 struct dwarf2_section_info cu_index
;
790 struct dwarf2_section_info tu_index
;
792 /* These are only used by DWP version 2 and version 5 files.
793 In DWP version 1 the .debug_info.dwo, .debug_types.dwo, and other
794 sections are referenced by section number, and are not recorded here.
795 In DWP version 2 or 5 there is at most one copy of all these sections,
796 each section being (effectively) comprised of the concatenation of all of
797 the individual sections that exist in the version 1 format.
798 To keep the code simple we treat each of these concatenated pieces as a
799 section itself (a virtual section?). */
800 struct dwarf2_section_info abbrev
;
801 struct dwarf2_section_info info
;
802 struct dwarf2_section_info line
;
803 struct dwarf2_section_info loc
;
804 struct dwarf2_section_info loclists
;
805 struct dwarf2_section_info macinfo
;
806 struct dwarf2_section_info macro
;
807 struct dwarf2_section_info rnglists
;
808 struct dwarf2_section_info str_offsets
;
809 struct dwarf2_section_info types
;
812 /* These sections are what may appear in a virtual DWO file in DWP version 1.
813 A virtual DWO file is a DWO file as it appears in a DWP file. */
815 struct virtual_v1_dwo_sections
817 struct dwarf2_section_info abbrev
;
818 struct dwarf2_section_info line
;
819 struct dwarf2_section_info loc
;
820 struct dwarf2_section_info macinfo
;
821 struct dwarf2_section_info macro
;
822 struct dwarf2_section_info str_offsets
;
823 /* Each DWP hash table entry records one CU or one TU.
824 That is recorded here, and copied to dwo_unit.section. */
825 struct dwarf2_section_info info_or_types
;
828 /* Similar to virtual_v1_dwo_sections, but for DWP version 2 or 5.
829 In version 2, the sections of the DWO files are concatenated together
830 and stored in one section of that name. Thus each ELF section contains
831 several "virtual" sections. */
833 struct virtual_v2_or_v5_dwo_sections
835 bfd_size_type abbrev_offset
;
836 bfd_size_type abbrev_size
;
838 bfd_size_type line_offset
;
839 bfd_size_type line_size
;
841 bfd_size_type loc_offset
;
842 bfd_size_type loc_size
;
844 bfd_size_type loclists_offset
;
845 bfd_size_type loclists_size
;
847 bfd_size_type macinfo_offset
;
848 bfd_size_type macinfo_size
;
850 bfd_size_type macro_offset
;
851 bfd_size_type macro_size
;
853 bfd_size_type rnglists_offset
;
854 bfd_size_type rnglists_size
;
856 bfd_size_type str_offsets_offset
;
857 bfd_size_type str_offsets_size
;
859 /* Each DWP hash table entry records one CU or one TU.
860 That is recorded here, and copied to dwo_unit.section. */
861 bfd_size_type info_or_types_offset
;
862 bfd_size_type info_or_types_size
;
865 /* Contents of DWP hash tables. */
867 struct dwp_hash_table
869 uint32_t version
, nr_columns
;
870 uint32_t nr_units
, nr_slots
;
871 const gdb_byte
*hash_table
, *unit_table
;
876 const gdb_byte
*indices
;
880 /* This is indexed by column number and gives the id of the section
882 #define MAX_NR_V2_DWO_SECTIONS \
883 (1 /* .debug_info or .debug_types */ \
884 + 1 /* .debug_abbrev */ \
885 + 1 /* .debug_line */ \
886 + 1 /* .debug_loc */ \
887 + 1 /* .debug_str_offsets */ \
888 + 1 /* .debug_macro or .debug_macinfo */)
889 int section_ids
[MAX_NR_V2_DWO_SECTIONS
];
890 const gdb_byte
*offsets
;
891 const gdb_byte
*sizes
;
895 /* This is indexed by column number and gives the id of the section
897 #define MAX_NR_V5_DWO_SECTIONS \
898 (1 /* .debug_info */ \
899 + 1 /* .debug_abbrev */ \
900 + 1 /* .debug_line */ \
901 + 1 /* .debug_loclists */ \
902 + 1 /* .debug_str_offsets */ \
903 + 1 /* .debug_macro */ \
904 + 1 /* .debug_rnglists */)
905 int section_ids
[MAX_NR_V5_DWO_SECTIONS
];
906 const gdb_byte
*offsets
;
907 const gdb_byte
*sizes
;
912 /* Data for one DWP file. */
916 dwp_file (const char *name_
, gdb_bfd_ref_ptr
&&abfd
)
918 dbfd (std::move (abfd
))
922 /* Name of the file. */
925 /* File format version. */
929 gdb_bfd_ref_ptr dbfd
;
931 /* Section info for this file. */
932 struct dwp_sections sections
{};
934 /* Table of CUs in the file. */
935 const struct dwp_hash_table
*cus
= nullptr;
937 /* Table of TUs in the file. */
938 const struct dwp_hash_table
*tus
= nullptr;
940 /* Tables of loaded CUs/TUs. Each entry is a struct dwo_unit *. */
944 /* Table to map ELF section numbers to their sections.
945 This is only needed for the DWP V1 file format. */
946 unsigned int num_sections
= 0;
947 asection
**elf_sections
= nullptr;
950 /* Struct used to pass misc. parameters to read_die_and_children, et
951 al. which are used for both .debug_info and .debug_types dies.
952 All parameters here are unchanging for the life of the call. This
953 struct exists to abstract away the constant parameters of die reading. */
955 struct die_reader_specs
957 /* The bfd of die_section. */
960 /* The CU of the DIE we are parsing. */
961 struct dwarf2_cu
*cu
;
963 /* Non-NULL if reading a DWO file (including one packaged into a DWP). */
964 struct dwo_file
*dwo_file
;
966 /* The section the die comes from.
967 This is either .debug_info or .debug_types, or the .dwo variants. */
968 struct dwarf2_section_info
*die_section
;
970 /* die_section->buffer. */
971 const gdb_byte
*buffer
;
973 /* The end of the buffer. */
974 const gdb_byte
*buffer_end
;
976 /* The abbreviation table to use when reading the DIEs. */
977 struct abbrev_table
*abbrev_table
;
980 /* A subclass of die_reader_specs that holds storage and has complex
981 constructor and destructor behavior. */
983 class cutu_reader
: public die_reader_specs
987 cutu_reader (dwarf2_per_cu_data
*this_cu
,
988 dwarf2_per_objfile
*per_objfile
,
989 struct abbrev_table
*abbrev_table
,
990 dwarf2_cu
*existing_cu
,
993 explicit cutu_reader (struct dwarf2_per_cu_data
*this_cu
,
994 dwarf2_per_objfile
*per_objfile
,
995 struct dwarf2_cu
*parent_cu
= nullptr,
996 struct dwo_file
*dwo_file
= nullptr);
998 DISABLE_COPY_AND_ASSIGN (cutu_reader
);
1000 const gdb_byte
*info_ptr
= nullptr;
1001 struct die_info
*comp_unit_die
= nullptr;
1002 bool dummy_p
= false;
1004 /* Release the new CU, putting it on the chain. This cannot be done
1009 void init_tu_and_read_dwo_dies (dwarf2_per_cu_data
*this_cu
,
1010 dwarf2_per_objfile
*per_objfile
,
1011 dwarf2_cu
*existing_cu
);
1013 struct dwarf2_per_cu_data
*m_this_cu
;
1014 std::unique_ptr
<dwarf2_cu
> m_new_cu
;
1016 /* The ordinary abbreviation table. */
1017 abbrev_table_up m_abbrev_table_holder
;
1019 /* The DWO abbreviation table. */
1020 abbrev_table_up m_dwo_abbrev_table
;
1023 /* When we construct a partial symbol table entry we only
1024 need this much information. */
1025 struct partial_die_info
: public allocate_on_obstack
1027 partial_die_info (sect_offset sect_off
, struct abbrev_info
*abbrev
);
1029 /* Disable assign but still keep copy ctor, which is needed
1030 load_partial_dies. */
1031 partial_die_info
& operator=(const partial_die_info
& rhs
) = delete;
1033 /* Adjust the partial die before generating a symbol for it. This
1034 function may set the is_external flag or change the DIE's
1036 void fixup (struct dwarf2_cu
*cu
);
1038 /* Read a minimal amount of information into the minimal die
1040 const gdb_byte
*read (const struct die_reader_specs
*reader
,
1041 const struct abbrev_info
&abbrev
,
1042 const gdb_byte
*info_ptr
);
1044 /* Compute the name of this partial DIE. This memoizes the
1045 result, so it is safe to call multiple times. */
1046 const char *name (dwarf2_cu
*cu
);
1048 /* Offset of this DIE. */
1049 const sect_offset sect_off
;
1051 /* DWARF-2 tag for this DIE. */
1052 const ENUM_BITFIELD(dwarf_tag
) tag
: 16;
1054 /* Assorted flags describing the data found in this DIE. */
1055 const unsigned int has_children
: 1;
1057 unsigned int is_external
: 1;
1058 unsigned int is_declaration
: 1;
1059 unsigned int has_type
: 1;
1060 unsigned int has_specification
: 1;
1061 unsigned int has_pc_info
: 1;
1062 unsigned int may_be_inlined
: 1;
1064 /* This DIE has been marked DW_AT_main_subprogram. */
1065 unsigned int main_subprogram
: 1;
1067 /* Flag set if the SCOPE field of this structure has been
1069 unsigned int scope_set
: 1;
1071 /* Flag set if the DIE has a byte_size attribute. */
1072 unsigned int has_byte_size
: 1;
1074 /* Flag set if the DIE has a DW_AT_const_value attribute. */
1075 unsigned int has_const_value
: 1;
1077 /* Flag set if any of the DIE's children are template arguments. */
1078 unsigned int has_template_arguments
: 1;
1080 /* Flag set if fixup has been called on this die. */
1081 unsigned int fixup_called
: 1;
1083 /* Flag set if DW_TAG_imported_unit uses DW_FORM_GNU_ref_alt. */
1084 unsigned int is_dwz
: 1;
1086 /* Flag set if spec_offset uses DW_FORM_GNU_ref_alt. */
1087 unsigned int spec_is_dwz
: 1;
1089 unsigned int canonical_name
: 1;
1091 /* The name of this DIE. Normally the value of DW_AT_name, but
1092 sometimes a default name for unnamed DIEs. */
1093 const char *raw_name
= nullptr;
1095 /* The linkage name, if present. */
1096 const char *linkage_name
= nullptr;
1098 /* The scope to prepend to our children. This is generally
1099 allocated on the comp_unit_obstack, so will disappear
1100 when this compilation unit leaves the cache. */
1101 const char *scope
= nullptr;
1103 /* Some data associated with the partial DIE. The tag determines
1104 which field is live. */
1107 /* The location description associated with this DIE, if any. */
1108 struct dwarf_block
*locdesc
;
1109 /* The offset of an import, for DW_TAG_imported_unit. */
1110 sect_offset sect_off
;
1113 /* If HAS_PC_INFO, the PC range associated with this DIE. */
1114 CORE_ADDR lowpc
= 0;
1115 CORE_ADDR highpc
= 0;
1117 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
1118 DW_AT_sibling, if any. */
1119 /* NOTE: This member isn't strictly necessary, partial_die_info::read
1120 could return DW_AT_sibling values to its caller load_partial_dies. */
1121 const gdb_byte
*sibling
= nullptr;
1123 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
1124 DW_AT_specification (or DW_AT_abstract_origin or
1125 DW_AT_extension). */
1126 sect_offset spec_offset
{};
1128 /* Pointers to this DIE's parent, first child, and next sibling,
1130 struct partial_die_info
*die_parent
= nullptr;
1131 struct partial_die_info
*die_child
= nullptr;
1132 struct partial_die_info
*die_sibling
= nullptr;
1134 friend struct partial_die_info
*
1135 dwarf2_cu::find_partial_die (sect_offset sect_off
);
1138 /* Only need to do look up in dwarf2_cu::find_partial_die. */
1139 partial_die_info (sect_offset sect_off
)
1140 : partial_die_info (sect_off
, DW_TAG_padding
, 0)
1144 partial_die_info (sect_offset sect_off_
, enum dwarf_tag tag_
,
1146 : sect_off (sect_off_
), tag (tag_
), has_children (has_children_
)
1151 has_specification
= 0;
1154 main_subprogram
= 0;
1157 has_const_value
= 0;
1158 has_template_arguments
= 0;
1166 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
1167 but this would require a corresponding change in unpack_field_as_long
1169 static int bits_per_byte
= 8;
1171 struct variant_part_builder
;
1173 /* When reading a variant, we track a bit more information about the
1174 field, and store it in an object of this type. */
1176 struct variant_field
1178 int first_field
= -1;
1179 int last_field
= -1;
1181 /* A variant can contain other variant parts. */
1182 std::vector
<variant_part_builder
> variant_parts
;
1184 /* If we see a DW_TAG_variant, then this will be set if this is the
1186 bool default_branch
= false;
1187 /* If we see a DW_AT_discr_value, then this will be the discriminant
1189 ULONGEST discriminant_value
= 0;
1190 /* If we see a DW_AT_discr_list, then this is a pointer to the list
1192 struct dwarf_block
*discr_list_data
= nullptr;
1195 /* This represents a DW_TAG_variant_part. */
1197 struct variant_part_builder
1199 /* The offset of the discriminant field. */
1200 sect_offset discriminant_offset
{};
1202 /* Variants that are direct children of this variant part. */
1203 std::vector
<variant_field
> variants
;
1205 /* True if we're currently reading a variant. */
1206 bool processing_variant
= false;
1211 int accessibility
= 0;
1213 /* Variant parts need to find the discriminant, which is a DIE
1214 reference. We track the section offset of each field to make
1217 struct field field
{};
1222 const char *name
= nullptr;
1223 std::vector
<struct fn_field
> fnfields
;
1226 /* The routines that read and process dies for a C struct or C++ class
1227 pass lists of data member fields and lists of member function fields
1228 in an instance of a field_info structure, as defined below. */
1231 /* List of data member and baseclasses fields. */
1232 std::vector
<struct nextfield
> fields
;
1233 std::vector
<struct nextfield
> baseclasses
;
1235 /* Set if the accessibility of one of the fields is not public. */
1236 bool non_public_fields
= false;
1238 /* Member function fieldlist array, contains name of possibly overloaded
1239 member function, number of overloaded member functions and a pointer
1240 to the head of the member function field chain. */
1241 std::vector
<struct fnfieldlist
> fnfieldlists
;
1243 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
1244 a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
1245 std::vector
<struct decl_field
> typedef_field_list
;
1247 /* Nested types defined by this class and the number of elements in this
1249 std::vector
<struct decl_field
> nested_types_list
;
1251 /* If non-null, this is the variant part we are currently
1253 variant_part_builder
*current_variant_part
= nullptr;
1254 /* This holds all the top-level variant parts attached to the type
1256 std::vector
<variant_part_builder
> variant_parts
;
1258 /* Return the total number of fields (including baseclasses). */
1259 int nfields () const
1261 return fields
.size () + baseclasses
.size ();
1265 /* Loaded secondary compilation units are kept in memory until they
1266 have not been referenced for the processing of this many
1267 compilation units. Set this to zero to disable caching. Cache
1268 sizes of up to at least twenty will improve startup time for
1269 typical inter-CU-reference binaries, at an obvious memory cost. */
1270 static int dwarf_max_cache_age
= 5;
1272 show_dwarf_max_cache_age (struct ui_file
*file
, int from_tty
,
1273 struct cmd_list_element
*c
, const char *value
)
1275 fprintf_filtered (file
, _("The upper bound on the age of cached "
1276 "DWARF compilation units is %s.\n"),
1280 /* local function prototypes */
1282 static void dwarf2_find_base_address (struct die_info
*die
,
1283 struct dwarf2_cu
*cu
);
1285 static dwarf2_psymtab
*create_partial_symtab
1286 (dwarf2_per_cu_data
*per_cu
, dwarf2_per_objfile
*per_objfile
,
1289 static void build_type_psymtabs_reader (const struct die_reader_specs
*reader
,
1290 const gdb_byte
*info_ptr
,
1291 struct die_info
*type_unit_die
);
1293 static void dwarf2_build_psymtabs_hard (dwarf2_per_objfile
*per_objfile
);
1295 static void scan_partial_symbols (struct partial_die_info
*,
1296 CORE_ADDR
*, CORE_ADDR
*,
1297 int, struct dwarf2_cu
*);
1299 static void add_partial_symbol (struct partial_die_info
*,
1300 struct dwarf2_cu
*);
1302 static void add_partial_namespace (struct partial_die_info
*pdi
,
1303 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1304 int set_addrmap
, struct dwarf2_cu
*cu
);
1306 static void add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
1307 CORE_ADDR
*highpc
, int set_addrmap
,
1308 struct dwarf2_cu
*cu
);
1310 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
1311 struct dwarf2_cu
*cu
);
1313 static void add_partial_subprogram (struct partial_die_info
*pdi
,
1314 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1315 int need_pc
, struct dwarf2_cu
*cu
);
1317 static unsigned int peek_abbrev_code (bfd
*, const gdb_byte
*);
1319 static struct partial_die_info
*load_partial_dies
1320 (const struct die_reader_specs
*, const gdb_byte
*, int);
1322 /* A pair of partial_die_info and compilation unit. */
1323 struct cu_partial_die_info
1325 /* The compilation unit of the partial_die_info. */
1326 struct dwarf2_cu
*cu
;
1327 /* A partial_die_info. */
1328 struct partial_die_info
*pdi
;
1330 cu_partial_die_info (struct dwarf2_cu
*cu
, struct partial_die_info
*pdi
)
1336 cu_partial_die_info () = delete;
1339 static const struct cu_partial_die_info
find_partial_die (sect_offset
, int,
1340 struct dwarf2_cu
*);
1342 static const gdb_byte
*read_attribute (const struct die_reader_specs
*,
1343 struct attribute
*, struct attr_abbrev
*,
1346 static void read_attribute_reprocess (const struct die_reader_specs
*reader
,
1347 struct attribute
*attr
, dwarf_tag tag
);
1349 static CORE_ADDR
read_addr_index (struct dwarf2_cu
*cu
, unsigned int addr_index
);
1351 static sect_offset
read_abbrev_offset (dwarf2_per_objfile
*per_objfile
,
1352 dwarf2_section_info
*, sect_offset
);
1354 static const char *read_indirect_string
1355 (dwarf2_per_objfile
*per_objfile
, bfd
*, const gdb_byte
*,
1356 const struct comp_unit_head
*, unsigned int *);
1358 static const char *read_indirect_string_at_offset
1359 (dwarf2_per_objfile
*per_objfile
, LONGEST str_offset
);
1361 static CORE_ADDR
read_addr_index_from_leb128 (struct dwarf2_cu
*,
1365 static const char *read_dwo_str_index (const struct die_reader_specs
*reader
,
1366 ULONGEST str_index
);
1368 static const char *read_stub_str_index (struct dwarf2_cu
*cu
,
1369 ULONGEST str_index
);
1371 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
1373 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
1374 struct dwarf2_cu
*);
1376 static const char *dwarf2_string_attr (struct die_info
*die
, unsigned int name
,
1377 struct dwarf2_cu
*cu
);
1379 static const char *dwarf2_dwo_name (struct die_info
*die
, struct dwarf2_cu
*cu
);
1381 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
1382 struct dwarf2_cu
*cu
);
1384 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
1386 static struct die_info
*die_specification (struct die_info
*die
,
1387 struct dwarf2_cu
**);
1389 static line_header_up
dwarf_decode_line_header (sect_offset sect_off
,
1390 struct dwarf2_cu
*cu
);
1392 static void dwarf_decode_lines (struct line_header
*, const char *,
1393 struct dwarf2_cu
*, dwarf2_psymtab
*,
1394 CORE_ADDR
, int decode_mapping
);
1396 static void dwarf2_start_subfile (struct dwarf2_cu
*, const char *,
1399 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
1400 struct dwarf2_cu
*, struct symbol
* = NULL
);
1402 static void dwarf2_const_value (const struct attribute
*, struct symbol
*,
1403 struct dwarf2_cu
*);
1405 static void dwarf2_const_value_attr (const struct attribute
*attr
,
1408 struct obstack
*obstack
,
1409 struct dwarf2_cu
*cu
, LONGEST
*value
,
1410 const gdb_byte
**bytes
,
1411 struct dwarf2_locexpr_baton
**baton
);
1413 static struct type
*read_subrange_index_type (struct die_info
*die
,
1414 struct dwarf2_cu
*cu
);
1416 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
1418 static int need_gnat_info (struct dwarf2_cu
*);
1420 static struct type
*die_descriptive_type (struct die_info
*,
1421 struct dwarf2_cu
*);
1423 static void set_descriptive_type (struct type
*, struct die_info
*,
1424 struct dwarf2_cu
*);
1426 static struct type
*die_containing_type (struct die_info
*,
1427 struct dwarf2_cu
*);
1429 static struct type
*lookup_die_type (struct die_info
*, const struct attribute
*,
1430 struct dwarf2_cu
*);
1432 static struct type
*read_type_die (struct die_info
*, struct dwarf2_cu
*);
1434 static struct type
*read_type_die_1 (struct die_info
*, struct dwarf2_cu
*);
1436 static const char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
1438 static char *typename_concat (struct obstack
*obs
, const char *prefix
,
1439 const char *suffix
, int physname
,
1440 struct dwarf2_cu
*cu
);
1442 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
1444 static void read_type_unit_scope (struct die_info
*, struct dwarf2_cu
*);
1446 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
1448 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
1450 static void read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
);
1452 static void read_variable (struct die_info
*die
, struct dwarf2_cu
*cu
);
1454 /* Return the .debug_loclists section to use for cu. */
1455 static struct dwarf2_section_info
*cu_debug_loc_section (struct dwarf2_cu
*cu
);
1457 /* Return the .debug_rnglists section to use for cu. */
1458 static struct dwarf2_section_info
*cu_debug_rnglists_section
1459 (struct dwarf2_cu
*cu
, dwarf_tag tag
);
1461 /* How dwarf2_get_pc_bounds constructed its *LOWPC and *HIGHPC return
1462 values. Keep the items ordered with increasing constraints compliance. */
1465 /* No attribute DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges was found. */
1466 PC_BOUNDS_NOT_PRESENT
,
1468 /* Some of the attributes DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges
1469 were present but they do not form a valid range of PC addresses. */
1472 /* Discontiguous range was found - that is DW_AT_ranges was found. */
1475 /* Contiguous range was found - DW_AT_low_pc and DW_AT_high_pc were found. */
1479 static enum pc_bounds_kind
dwarf2_get_pc_bounds (struct die_info
*,
1480 CORE_ADDR
*, CORE_ADDR
*,
1484 static void get_scope_pc_bounds (struct die_info
*,
1485 CORE_ADDR
*, CORE_ADDR
*,
1486 struct dwarf2_cu
*);
1488 static void dwarf2_record_block_ranges (struct die_info
*, struct block
*,
1489 CORE_ADDR
, struct dwarf2_cu
*);
1491 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
1492 struct dwarf2_cu
*);
1494 static void dwarf2_attach_fields_to_type (struct field_info
*,
1495 struct type
*, struct dwarf2_cu
*);
1497 static void dwarf2_add_member_fn (struct field_info
*,
1498 struct die_info
*, struct type
*,
1499 struct dwarf2_cu
*);
1501 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
1503 struct dwarf2_cu
*);
1505 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
1507 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
1509 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
1511 static void read_module (struct die_info
*die
, struct dwarf2_cu
*cu
);
1513 static struct using_direct
**using_directives (struct dwarf2_cu
*cu
);
1515 static void read_import_statement (struct die_info
*die
, struct dwarf2_cu
*);
1517 static int read_namespace_alias (struct die_info
*die
, struct dwarf2_cu
*cu
);
1519 static struct type
*read_module_type (struct die_info
*die
,
1520 struct dwarf2_cu
*cu
);
1522 static const char *namespace_name (struct die_info
*die
,
1523 int *is_anonymous
, struct dwarf2_cu
*);
1525 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
1527 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*,
1530 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
1531 struct dwarf2_cu
*);
1533 static struct die_info
*read_die_and_siblings_1
1534 (const struct die_reader_specs
*, const gdb_byte
*, const gdb_byte
**,
1537 static struct die_info
*read_die_and_siblings (const struct die_reader_specs
*,
1538 const gdb_byte
*info_ptr
,
1539 const gdb_byte
**new_info_ptr
,
1540 struct die_info
*parent
);
1542 static const gdb_byte
*read_full_die_1 (const struct die_reader_specs
*,
1543 struct die_info
**, const gdb_byte
*,
1546 static const gdb_byte
*read_full_die (const struct die_reader_specs
*,
1547 struct die_info
**, const gdb_byte
*);
1549 static void process_die (struct die_info
*, struct dwarf2_cu
*);
1551 static const char *dwarf2_canonicalize_name (const char *, struct dwarf2_cu
*,
1554 static const char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
1556 static const char *dwarf2_full_name (const char *name
,
1557 struct die_info
*die
,
1558 struct dwarf2_cu
*cu
);
1560 static const char *dwarf2_physname (const char *name
, struct die_info
*die
,
1561 struct dwarf2_cu
*cu
);
1563 static struct die_info
*dwarf2_extension (struct die_info
*die
,
1564 struct dwarf2_cu
**);
1566 static void dump_die_shallow (struct ui_file
*, int indent
, struct die_info
*);
1568 static void dump_die_for_error (struct die_info
*);
1570 static void dump_die_1 (struct ui_file
*, int level
, int max_level
,
1573 /*static*/ void dump_die (struct die_info
*, int max_level
);
1575 static void store_in_ref_table (struct die_info
*,
1576 struct dwarf2_cu
*);
1578 static struct die_info
*follow_die_ref_or_sig (struct die_info
*,
1579 const struct attribute
*,
1580 struct dwarf2_cu
**);
1582 static struct die_info
*follow_die_ref (struct die_info
*,
1583 const struct attribute
*,
1584 struct dwarf2_cu
**);
1586 static struct die_info
*follow_die_sig (struct die_info
*,
1587 const struct attribute
*,
1588 struct dwarf2_cu
**);
1590 static struct type
*get_signatured_type (struct die_info
*, ULONGEST
,
1591 struct dwarf2_cu
*);
1593 static struct type
*get_DW_AT_signature_type (struct die_info
*,
1594 const struct attribute
*,
1595 struct dwarf2_cu
*);
1597 static void load_full_type_unit (dwarf2_per_cu_data
*per_cu
,
1598 dwarf2_per_objfile
*per_objfile
);
1600 static void read_signatured_type (signatured_type
*sig_type
,
1601 dwarf2_per_objfile
*per_objfile
);
1603 static int attr_to_dynamic_prop (const struct attribute
*attr
,
1604 struct die_info
*die
, struct dwarf2_cu
*cu
,
1605 struct dynamic_prop
*prop
, struct type
*type
);
1607 /* memory allocation interface */
1609 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1611 static struct die_info
*dwarf_alloc_die (struct dwarf2_cu
*, int);
1613 static void dwarf_decode_macros (struct dwarf2_cu
*, unsigned int, int);
1615 static void fill_in_loclist_baton (struct dwarf2_cu
*cu
,
1616 struct dwarf2_loclist_baton
*baton
,
1617 const struct attribute
*attr
);
1619 static void dwarf2_symbol_mark_computed (const struct attribute
*attr
,
1621 struct dwarf2_cu
*cu
,
1624 static const gdb_byte
*skip_one_die (const struct die_reader_specs
*reader
,
1625 const gdb_byte
*info_ptr
,
1626 struct abbrev_info
*abbrev
);
1628 static hashval_t
partial_die_hash (const void *item
);
1630 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1632 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1633 (sect_offset sect_off
, unsigned int offset_in_dwz
,
1634 dwarf2_per_objfile
*per_objfile
);
1636 static void prepare_one_comp_unit (struct dwarf2_cu
*cu
,
1637 struct die_info
*comp_unit_die
,
1638 enum language pretend_language
);
1640 static struct type
*set_die_type (struct die_info
*, struct type
*,
1641 struct dwarf2_cu
*, bool = false);
1643 static void create_all_comp_units (dwarf2_per_objfile
*per_objfile
);
1645 static int create_all_type_units (dwarf2_per_objfile
*per_objfile
);
1647 static void load_full_comp_unit (dwarf2_per_cu_data
*per_cu
,
1648 dwarf2_per_objfile
*per_objfile
,
1649 dwarf2_cu
*existing_cu
,
1651 enum language pretend_language
);
1653 static void process_full_comp_unit (dwarf2_cu
*cu
,
1654 enum language pretend_language
);
1656 static void process_full_type_unit (dwarf2_cu
*cu
,
1657 enum language pretend_language
);
1659 static void dwarf2_add_dependence (struct dwarf2_cu
*,
1660 struct dwarf2_per_cu_data
*);
1662 static void dwarf2_mark (struct dwarf2_cu
*);
1664 static struct type
*get_die_type_at_offset (sect_offset
,
1665 dwarf2_per_cu_data
*per_cu
,
1666 dwarf2_per_objfile
*per_objfile
);
1668 static struct type
*get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
1670 static void queue_comp_unit (dwarf2_per_cu_data
*per_cu
,
1671 dwarf2_per_objfile
*per_objfile
,
1672 enum language pretend_language
);
1674 static void process_queue (dwarf2_per_objfile
*per_objfile
);
1676 /* Class, the destructor of which frees all allocated queue entries. This
1677 will only have work to do if an error was thrown while processing the
1678 dwarf. If no error was thrown then the queue entries should have all
1679 been processed, and freed, as we went along. */
1681 class dwarf2_queue_guard
1684 explicit dwarf2_queue_guard (dwarf2_per_objfile
*per_objfile
)
1685 : m_per_objfile (per_objfile
)
1689 /* Free any entries remaining on the queue. There should only be
1690 entries left if we hit an error while processing the dwarf. */
1691 ~dwarf2_queue_guard ()
1693 /* Ensure that no memory is allocated by the queue. */
1694 std::queue
<dwarf2_queue_item
> empty
;
1695 std::swap (m_per_objfile
->per_bfd
->queue
, empty
);
1698 DISABLE_COPY_AND_ASSIGN (dwarf2_queue_guard
);
1701 dwarf2_per_objfile
*m_per_objfile
;
1704 dwarf2_queue_item::~dwarf2_queue_item ()
1706 /* Anything still marked queued is likely to be in an
1707 inconsistent state, so discard it. */
1710 per_objfile
->remove_cu (per_cu
);
1715 /* The return type of find_file_and_directory. Note, the enclosed
1716 string pointers are only valid while this object is valid. */
1718 struct file_and_directory
1720 /* The filename. This is never NULL. */
1723 /* The compilation directory. NULL if not known. If we needed to
1724 compute a new string, this points to COMP_DIR_STORAGE, otherwise,
1725 points directly to the DW_AT_comp_dir string attribute owned by
1726 the obstack that owns the DIE. */
1727 const char *comp_dir
;
1729 /* If we needed to build a new string for comp_dir, this is what
1730 owns the storage. */
1731 std::string comp_dir_storage
;
1734 static file_and_directory
find_file_and_directory (struct die_info
*die
,
1735 struct dwarf2_cu
*cu
);
1737 static htab_up
allocate_signatured_type_table ();
1739 static htab_up
allocate_dwo_unit_table ();
1741 static struct dwo_unit
*lookup_dwo_unit_in_dwp
1742 (dwarf2_per_objfile
*per_objfile
, struct dwp_file
*dwp_file
,
1743 const char *comp_dir
, ULONGEST signature
, int is_debug_types
);
1745 static struct dwp_file
*get_dwp_file (dwarf2_per_objfile
*per_objfile
);
1747 static struct dwo_unit
*lookup_dwo_comp_unit
1748 (dwarf2_cu
*cu
, const char *dwo_name
, const char *comp_dir
,
1749 ULONGEST signature
);
1751 static struct dwo_unit
*lookup_dwo_type_unit
1752 (dwarf2_cu
*cu
, const char *dwo_name
, const char *comp_dir
);
1754 static void queue_and_load_all_dwo_tus (dwarf2_cu
*cu
);
1756 /* A unique pointer to a dwo_file. */
1758 typedef std::unique_ptr
<struct dwo_file
> dwo_file_up
;
1760 static void process_cu_includes (dwarf2_per_objfile
*per_objfile
);
1762 static void check_producer (struct dwarf2_cu
*cu
);
1764 static void free_line_header_voidp (void *arg
);
1766 /* Various complaints about symbol reading that don't abort the process. */
1769 dwarf2_debug_line_missing_file_complaint (void)
1771 complaint (_(".debug_line section has line data without a file"));
1775 dwarf2_debug_line_missing_end_sequence_complaint (void)
1777 complaint (_(".debug_line section has line "
1778 "program sequence without an end"));
1782 dwarf2_complex_location_expr_complaint (void)
1784 complaint (_("location expression too complex"));
1788 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
1791 complaint (_("const value length mismatch for '%s', got %d, expected %d"),
1796 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
1798 complaint (_("invalid attribute class or form for '%s' in '%s'"),
1802 /* Hash function for line_header_hash. */
1805 line_header_hash (const struct line_header
*ofs
)
1807 return to_underlying (ofs
->sect_off
) ^ ofs
->offset_in_dwz
;
1810 /* Hash function for htab_create_alloc_ex for line_header_hash. */
1813 line_header_hash_voidp (const void *item
)
1815 const struct line_header
*ofs
= (const struct line_header
*) item
;
1817 return line_header_hash (ofs
);
1820 /* Equality function for line_header_hash. */
1823 line_header_eq_voidp (const void *item_lhs
, const void *item_rhs
)
1825 const struct line_header
*ofs_lhs
= (const struct line_header
*) item_lhs
;
1826 const struct line_header
*ofs_rhs
= (const struct line_header
*) item_rhs
;
1828 return (ofs_lhs
->sect_off
== ofs_rhs
->sect_off
1829 && ofs_lhs
->offset_in_dwz
== ofs_rhs
->offset_in_dwz
);
1834 /* See declaration. */
1836 dwarf2_per_bfd::dwarf2_per_bfd (bfd
*obfd
, const dwarf2_debug_sections
*names
,
1839 can_copy (can_copy_
)
1842 names
= &dwarf2_elf_names
;
1844 for (asection
*sec
= obfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
1845 locate_sections (obfd
, sec
, *names
);
1848 dwarf2_per_bfd::~dwarf2_per_bfd ()
1850 for (dwarf2_per_cu_data
*per_cu
: all_comp_units
)
1851 per_cu
->imported_symtabs_free ();
1853 for (signatured_type
*sig_type
: all_type_units
)
1854 sig_type
->per_cu
.imported_symtabs_free ();
1856 /* Everything else should be on this->obstack. */
1862 dwarf2_per_objfile::remove_all_cus ()
1864 for (auto pair
: m_dwarf2_cus
)
1867 m_dwarf2_cus
.clear ();
1870 /* A helper class that calls free_cached_comp_units on
1873 class free_cached_comp_units
1877 explicit free_cached_comp_units (dwarf2_per_objfile
*per_objfile
)
1878 : m_per_objfile (per_objfile
)
1882 ~free_cached_comp_units ()
1884 m_per_objfile
->remove_all_cus ();
1887 DISABLE_COPY_AND_ASSIGN (free_cached_comp_units
);
1891 dwarf2_per_objfile
*m_per_objfile
;
1897 dwarf2_per_objfile::symtab_set_p (const dwarf2_per_cu_data
*per_cu
) const
1899 gdb_assert (per_cu
->index
< this->m_symtabs
.size ());
1901 return this->m_symtabs
[per_cu
->index
] != nullptr;
1907 dwarf2_per_objfile::get_symtab (const dwarf2_per_cu_data
*per_cu
) const
1909 gdb_assert (per_cu
->index
< this->m_symtabs
.size ());
1911 return this->m_symtabs
[per_cu
->index
];
1917 dwarf2_per_objfile::set_symtab (const dwarf2_per_cu_data
*per_cu
,
1918 compunit_symtab
*symtab
)
1920 gdb_assert (per_cu
->index
< this->m_symtabs
.size ());
1921 gdb_assert (this->m_symtabs
[per_cu
->index
] == nullptr);
1923 this->m_symtabs
[per_cu
->index
] = symtab
;
1926 /* Try to locate the sections we need for DWARF 2 debugging
1927 information and return true if we have enough to do something.
1928 NAMES points to the dwarf2 section names, or is NULL if the standard
1929 ELF names are used. CAN_COPY is true for formats where symbol
1930 interposition is possible and so symbol values must follow copy
1931 relocation rules. */
1934 dwarf2_has_info (struct objfile
*objfile
,
1935 const struct dwarf2_debug_sections
*names
,
1938 if (objfile
->flags
& OBJF_READNEVER
)
1941 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
1943 if (per_objfile
== NULL
)
1945 dwarf2_per_bfd
*per_bfd
;
1947 /* We can share a "dwarf2_per_bfd" with other objfiles if the BFD
1948 doesn't require relocations and if there aren't partial symbols
1949 from some other reader. */
1950 if (!objfile_has_partial_symbols (objfile
)
1951 && !gdb_bfd_requires_relocations (objfile
->obfd
))
1953 /* See if one has been created for this BFD yet. */
1954 per_bfd
= dwarf2_per_bfd_bfd_data_key
.get (objfile
->obfd
);
1956 if (per_bfd
== nullptr)
1958 /* No, create it now. */
1959 per_bfd
= new dwarf2_per_bfd (objfile
->obfd
, names
, can_copy
);
1960 dwarf2_per_bfd_bfd_data_key
.set (objfile
->obfd
, per_bfd
);
1965 /* No sharing possible, create one specifically for this objfile. */
1966 per_bfd
= new dwarf2_per_bfd (objfile
->obfd
, names
, can_copy
);
1967 dwarf2_per_bfd_objfile_data_key
.set (objfile
, per_bfd
);
1970 per_objfile
= dwarf2_objfile_data_key
.emplace (objfile
, objfile
, per_bfd
);
1973 return (!per_objfile
->per_bfd
->info
.is_virtual
1974 && per_objfile
->per_bfd
->info
.s
.section
!= NULL
1975 && !per_objfile
->per_bfd
->abbrev
.is_virtual
1976 && per_objfile
->per_bfd
->abbrev
.s
.section
!= NULL
);
1979 /* When loading sections, we look either for uncompressed section or for
1980 compressed section names. */
1983 section_is_p (const char *section_name
,
1984 const struct dwarf2_section_names
*names
)
1986 if (names
->normal
!= NULL
1987 && strcmp (section_name
, names
->normal
) == 0)
1989 if (names
->compressed
!= NULL
1990 && strcmp (section_name
, names
->compressed
) == 0)
1995 /* See declaration. */
1998 dwarf2_per_bfd::locate_sections (bfd
*abfd
, asection
*sectp
,
1999 const dwarf2_debug_sections
&names
)
2001 flagword aflag
= bfd_section_flags (sectp
);
2003 if ((aflag
& SEC_HAS_CONTENTS
) == 0)
2006 else if (elf_section_data (sectp
)->this_hdr
.sh_size
2007 > bfd_get_file_size (abfd
))
2009 bfd_size_type size
= elf_section_data (sectp
)->this_hdr
.sh_size
;
2010 warning (_("Discarding section %s which has a section size (%s"
2011 ") larger than the file size [in module %s]"),
2012 bfd_section_name (sectp
), phex_nz (size
, sizeof (size
)),
2013 bfd_get_filename (abfd
));
2015 else if (section_is_p (sectp
->name
, &names
.info
))
2017 this->info
.s
.section
= sectp
;
2018 this->info
.size
= bfd_section_size (sectp
);
2020 else if (section_is_p (sectp
->name
, &names
.abbrev
))
2022 this->abbrev
.s
.section
= sectp
;
2023 this->abbrev
.size
= bfd_section_size (sectp
);
2025 else if (section_is_p (sectp
->name
, &names
.line
))
2027 this->line
.s
.section
= sectp
;
2028 this->line
.size
= bfd_section_size (sectp
);
2030 else if (section_is_p (sectp
->name
, &names
.loc
))
2032 this->loc
.s
.section
= sectp
;
2033 this->loc
.size
= bfd_section_size (sectp
);
2035 else if (section_is_p (sectp
->name
, &names
.loclists
))
2037 this->loclists
.s
.section
= sectp
;
2038 this->loclists
.size
= bfd_section_size (sectp
);
2040 else if (section_is_p (sectp
->name
, &names
.macinfo
))
2042 this->macinfo
.s
.section
= sectp
;
2043 this->macinfo
.size
= bfd_section_size (sectp
);
2045 else if (section_is_p (sectp
->name
, &names
.macro
))
2047 this->macro
.s
.section
= sectp
;
2048 this->macro
.size
= bfd_section_size (sectp
);
2050 else if (section_is_p (sectp
->name
, &names
.str
))
2052 this->str
.s
.section
= sectp
;
2053 this->str
.size
= bfd_section_size (sectp
);
2055 else if (section_is_p (sectp
->name
, &names
.str_offsets
))
2057 this->str_offsets
.s
.section
= sectp
;
2058 this->str_offsets
.size
= bfd_section_size (sectp
);
2060 else if (section_is_p (sectp
->name
, &names
.line_str
))
2062 this->line_str
.s
.section
= sectp
;
2063 this->line_str
.size
= bfd_section_size (sectp
);
2065 else if (section_is_p (sectp
->name
, &names
.addr
))
2067 this->addr
.s
.section
= sectp
;
2068 this->addr
.size
= bfd_section_size (sectp
);
2070 else if (section_is_p (sectp
->name
, &names
.frame
))
2072 this->frame
.s
.section
= sectp
;
2073 this->frame
.size
= bfd_section_size (sectp
);
2075 else if (section_is_p (sectp
->name
, &names
.eh_frame
))
2077 this->eh_frame
.s
.section
= sectp
;
2078 this->eh_frame
.size
= bfd_section_size (sectp
);
2080 else if (section_is_p (sectp
->name
, &names
.ranges
))
2082 this->ranges
.s
.section
= sectp
;
2083 this->ranges
.size
= bfd_section_size (sectp
);
2085 else if (section_is_p (sectp
->name
, &names
.rnglists
))
2087 this->rnglists
.s
.section
= sectp
;
2088 this->rnglists
.size
= bfd_section_size (sectp
);
2090 else if (section_is_p (sectp
->name
, &names
.types
))
2092 struct dwarf2_section_info type_section
;
2094 memset (&type_section
, 0, sizeof (type_section
));
2095 type_section
.s
.section
= sectp
;
2096 type_section
.size
= bfd_section_size (sectp
);
2098 this->types
.push_back (type_section
);
2100 else if (section_is_p (sectp
->name
, &names
.gdb_index
))
2102 this->gdb_index
.s
.section
= sectp
;
2103 this->gdb_index
.size
= bfd_section_size (sectp
);
2105 else if (section_is_p (sectp
->name
, &names
.debug_names
))
2107 this->debug_names
.s
.section
= sectp
;
2108 this->debug_names
.size
= bfd_section_size (sectp
);
2110 else if (section_is_p (sectp
->name
, &names
.debug_aranges
))
2112 this->debug_aranges
.s
.section
= sectp
;
2113 this->debug_aranges
.size
= bfd_section_size (sectp
);
2116 if ((bfd_section_flags (sectp
) & (SEC_LOAD
| SEC_ALLOC
))
2117 && bfd_section_vma (sectp
) == 0)
2118 this->has_section_at_zero
= true;
2121 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
2125 dwarf2_get_section_info (struct objfile
*objfile
,
2126 enum dwarf2_section_enum sect
,
2127 asection
**sectp
, const gdb_byte
**bufp
,
2128 bfd_size_type
*sizep
)
2130 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
2131 struct dwarf2_section_info
*info
;
2133 /* We may see an objfile without any DWARF, in which case we just
2135 if (per_objfile
== NULL
)
2144 case DWARF2_DEBUG_FRAME
:
2145 info
= &per_objfile
->per_bfd
->frame
;
2147 case DWARF2_EH_FRAME
:
2148 info
= &per_objfile
->per_bfd
->eh_frame
;
2151 gdb_assert_not_reached ("unexpected section");
2154 info
->read (objfile
);
2156 *sectp
= info
->get_bfd_section ();
2157 *bufp
= info
->buffer
;
2158 *sizep
= info
->size
;
2161 /* A helper function to find the sections for a .dwz file. */
2164 locate_dwz_sections (bfd
*abfd
, asection
*sectp
, dwz_file
*dwz_file
)
2166 /* Note that we only support the standard ELF names, because .dwz
2167 is ELF-only (at the time of writing). */
2168 if (section_is_p (sectp
->name
, &dwarf2_elf_names
.abbrev
))
2170 dwz_file
->abbrev
.s
.section
= sectp
;
2171 dwz_file
->abbrev
.size
= bfd_section_size (sectp
);
2173 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.info
))
2175 dwz_file
->info
.s
.section
= sectp
;
2176 dwz_file
->info
.size
= bfd_section_size (sectp
);
2178 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.str
))
2180 dwz_file
->str
.s
.section
= sectp
;
2181 dwz_file
->str
.size
= bfd_section_size (sectp
);
2183 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.line
))
2185 dwz_file
->line
.s
.section
= sectp
;
2186 dwz_file
->line
.size
= bfd_section_size (sectp
);
2188 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.macro
))
2190 dwz_file
->macro
.s
.section
= sectp
;
2191 dwz_file
->macro
.size
= bfd_section_size (sectp
);
2193 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.gdb_index
))
2195 dwz_file
->gdb_index
.s
.section
= sectp
;
2196 dwz_file
->gdb_index
.size
= bfd_section_size (sectp
);
2198 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.debug_names
))
2200 dwz_file
->debug_names
.s
.section
= sectp
;
2201 dwz_file
->debug_names
.size
= bfd_section_size (sectp
);
2205 /* Attempt to find a .dwz file (whose full path is represented by
2206 FILENAME) in all of the specified debug file directories provided.
2208 Return the equivalent gdb_bfd_ref_ptr of the .dwz file found, or
2209 nullptr if it could not find anything. */
2211 static gdb_bfd_ref_ptr
2212 dwz_search_other_debugdirs (std::string
&filename
, bfd_byte
*buildid
,
2215 /* Let's assume that the path represented by FILENAME has the
2216 "/.dwz/" subpath in it. This is what (most) GNU/Linux
2217 distributions do, anyway. */
2218 size_t dwz_pos
= filename
.find ("/.dwz/");
2220 if (dwz_pos
== std::string::npos
)
2223 /* This is an obvious assertion, but it's here more to educate
2224 future readers of this code that FILENAME at DWZ_POS *must*
2225 contain a directory separator. */
2226 gdb_assert (IS_DIR_SEPARATOR (filename
[dwz_pos
]));
2228 gdb_bfd_ref_ptr dwz_bfd
;
2229 std::vector
<gdb::unique_xmalloc_ptr
<char>> debugdir_vec
2230 = dirnames_to_char_ptr_vec (debug_file_directory
);
2232 for (const gdb::unique_xmalloc_ptr
<char> &debugdir
: debugdir_vec
)
2234 /* The idea is to iterate over the
2235 debug file directories provided by the user and
2236 replace the hard-coded path in the "filename" by each
2237 debug-file-directory.
2239 For example, suppose that filename is:
2241 /usr/lib/debug/.dwz/foo.dwz
2243 And suppose that we have "$HOME/bar" as the
2244 debug-file-directory. We would then adjust filename
2247 $HOME/bar/.dwz/foo.dwz
2249 which would hopefully allow us to find the alt debug
2251 std::string ddir
= debugdir
.get ();
2256 /* Make sure the current debug-file-directory ends with a
2257 directory separator. This is needed because, if FILENAME
2258 contains something like "/usr/lib/abcde/.dwz/foo.dwz" and
2259 DDIR is "/usr/lib/abc", then could wrongfully skip it
2261 if (!IS_DIR_SEPARATOR (ddir
.back ()))
2262 ddir
+= SLASH_STRING
;
2264 /* Check whether the beginning of FILENAME is DDIR. If it is,
2265 then we are dealing with a file which we already attempted to
2266 open before, so we just skip it and continue processing the
2267 remaining debug file directories. */
2268 if (filename
.size () > ddir
.size ()
2269 && filename
.compare (0, ddir
.size (), ddir
) == 0)
2272 /* Replace FILENAME's default debug-file-directory with
2274 std::string new_filename
= ddir
+ &filename
[dwz_pos
+ 1];
2276 dwz_bfd
= gdb_bfd_open (new_filename
.c_str (), gnutarget
);
2278 if (dwz_bfd
== nullptr)
2281 if (!build_id_verify (dwz_bfd
.get (), buildid_len
, buildid
))
2283 dwz_bfd
.reset (nullptr);
2294 /* See dwarf2read.h. */
2297 dwarf2_get_dwz_file (dwarf2_per_bfd
*per_bfd
)
2299 bfd_size_type buildid_len_arg
;
2303 if (per_bfd
->dwz_file
!= NULL
)
2304 return per_bfd
->dwz_file
.get ();
2306 bfd_set_error (bfd_error_no_error
);
2307 gdb::unique_xmalloc_ptr
<char> data
2308 (bfd_get_alt_debug_link_info (per_bfd
->obfd
,
2309 &buildid_len_arg
, &buildid
));
2312 if (bfd_get_error () == bfd_error_no_error
)
2314 error (_("could not read '.gnu_debugaltlink' section: %s"),
2315 bfd_errmsg (bfd_get_error ()));
2318 gdb::unique_xmalloc_ptr
<bfd_byte
> buildid_holder (buildid
);
2320 buildid_len
= (size_t) buildid_len_arg
;
2322 std::string filename
= data
.get ();
2324 if (!IS_ABSOLUTE_PATH (filename
.c_str ()))
2326 gdb::unique_xmalloc_ptr
<char> abs
2327 = gdb_realpath (bfd_get_filename (per_bfd
->obfd
));
2329 filename
= ldirname (abs
.get ()) + SLASH_STRING
+ filename
;
2332 /* First try the file name given in the section. If that doesn't
2333 work, try to use the build-id instead. */
2334 gdb_bfd_ref_ptr
dwz_bfd (gdb_bfd_open (filename
.c_str (), gnutarget
));
2335 if (dwz_bfd
!= NULL
)
2337 if (!build_id_verify (dwz_bfd
.get (), buildid_len
, buildid
))
2338 dwz_bfd
.reset (nullptr);
2341 if (dwz_bfd
== NULL
)
2342 dwz_bfd
= build_id_to_debug_bfd (buildid_len
, buildid
);
2344 if (dwz_bfd
== nullptr)
2346 /* If the user has provided us with different
2347 debug file directories, we can try them in order. */
2348 dwz_bfd
= dwz_search_other_debugdirs (filename
, buildid
, buildid_len
);
2351 if (dwz_bfd
== nullptr)
2353 gdb::unique_xmalloc_ptr
<char> alt_filename
;
2354 const char *origname
= bfd_get_filename (per_bfd
->obfd
);
2356 scoped_fd
fd (debuginfod_debuginfo_query (buildid
,
2363 /* File successfully retrieved from server. */
2364 dwz_bfd
= gdb_bfd_open (alt_filename
.get (), gnutarget
);
2366 if (dwz_bfd
== nullptr)
2367 warning (_("File \"%s\" from debuginfod cannot be opened as bfd"),
2368 alt_filename
.get ());
2369 else if (!build_id_verify (dwz_bfd
.get (), buildid_len
, buildid
))
2370 dwz_bfd
.reset (nullptr);
2374 if (dwz_bfd
== NULL
)
2375 error (_("could not find '.gnu_debugaltlink' file for %s"),
2376 bfd_get_filename (per_bfd
->obfd
));
2378 std::unique_ptr
<struct dwz_file
> result
2379 (new struct dwz_file (std::move (dwz_bfd
)));
2381 for (asection
*sec
: gdb_bfd_sections (result
->dwz_bfd
))
2382 locate_dwz_sections (result
->dwz_bfd
.get (), sec
, result
.get ());
2384 gdb_bfd_record_inclusion (per_bfd
->obfd
, result
->dwz_bfd
.get ());
2385 per_bfd
->dwz_file
= std::move (result
);
2386 return per_bfd
->dwz_file
.get ();
2389 /* DWARF quick_symbols_functions support. */
2391 /* TUs can share .debug_line entries, and there can be a lot more TUs than
2392 unique line tables, so we maintain a separate table of all .debug_line
2393 derived entries to support the sharing.
2394 All the quick functions need is the list of file names. We discard the
2395 line_header when we're done and don't need to record it here. */
2396 struct quick_file_names
2398 /* The data used to construct the hash key. */
2399 struct stmt_list_hash hash
;
2401 /* The number of entries in file_names, real_names. */
2402 unsigned int num_file_names
;
2404 /* The file names from the line table, after being run through
2406 const char **file_names
;
2408 /* The file names from the line table after being run through
2409 gdb_realpath. These are computed lazily. */
2410 const char **real_names
;
2413 /* When using the index (and thus not using psymtabs), each CU has an
2414 object of this type. This is used to hold information needed by
2415 the various "quick" methods. */
2416 struct dwarf2_per_cu_quick_data
2418 /* The file table. This can be NULL if there was no file table
2419 or it's currently not read in.
2420 NOTE: This points into dwarf2_per_objfile->per_bfd->quick_file_names_table. */
2421 struct quick_file_names
*file_names
;
2423 /* A temporary mark bit used when iterating over all CUs in
2424 expand_symtabs_matching. */
2425 unsigned int mark
: 1;
2427 /* True if we've tried to read the file table and found there isn't one.
2428 There will be no point in trying to read it again next time. */
2429 unsigned int no_file_data
: 1;
2432 /* Utility hash function for a stmt_list_hash. */
2435 hash_stmt_list_entry (const struct stmt_list_hash
*stmt_list_hash
)
2439 if (stmt_list_hash
->dwo_unit
!= NULL
)
2440 v
+= (uintptr_t) stmt_list_hash
->dwo_unit
->dwo_file
;
2441 v
+= to_underlying (stmt_list_hash
->line_sect_off
);
2445 /* Utility equality function for a stmt_list_hash. */
2448 eq_stmt_list_entry (const struct stmt_list_hash
*lhs
,
2449 const struct stmt_list_hash
*rhs
)
2451 if ((lhs
->dwo_unit
!= NULL
) != (rhs
->dwo_unit
!= NULL
))
2453 if (lhs
->dwo_unit
!= NULL
2454 && lhs
->dwo_unit
->dwo_file
!= rhs
->dwo_unit
->dwo_file
)
2457 return lhs
->line_sect_off
== rhs
->line_sect_off
;
2460 /* Hash function for a quick_file_names. */
2463 hash_file_name_entry (const void *e
)
2465 const struct quick_file_names
*file_data
2466 = (const struct quick_file_names
*) e
;
2468 return hash_stmt_list_entry (&file_data
->hash
);
2471 /* Equality function for a quick_file_names. */
2474 eq_file_name_entry (const void *a
, const void *b
)
2476 const struct quick_file_names
*ea
= (const struct quick_file_names
*) a
;
2477 const struct quick_file_names
*eb
= (const struct quick_file_names
*) b
;
2479 return eq_stmt_list_entry (&ea
->hash
, &eb
->hash
);
2482 /* Delete function for a quick_file_names. */
2485 delete_file_name_entry (void *e
)
2487 struct quick_file_names
*file_data
= (struct quick_file_names
*) e
;
2490 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
2492 xfree ((void*) file_data
->file_names
[i
]);
2493 if (file_data
->real_names
)
2494 xfree ((void*) file_data
->real_names
[i
]);
2497 /* The space for the struct itself lives on the obstack, so we don't
2501 /* Create a quick_file_names hash table. */
2504 create_quick_file_names_table (unsigned int nr_initial_entries
)
2506 return htab_up (htab_create_alloc (nr_initial_entries
,
2507 hash_file_name_entry
, eq_file_name_entry
,
2508 delete_file_name_entry
, xcalloc
, xfree
));
2511 /* Read in CU (dwarf2_cu object) for PER_CU in the context of PER_OBJFILE. This
2512 function is unrelated to symtabs, symtab would have to be created afterwards.
2513 You should call age_cached_comp_units after processing the CU. */
2516 load_cu (dwarf2_per_cu_data
*per_cu
, dwarf2_per_objfile
*per_objfile
,
2519 if (per_cu
->is_debug_types
)
2520 load_full_type_unit (per_cu
, per_objfile
);
2522 load_full_comp_unit (per_cu
, per_objfile
, per_objfile
->get_cu (per_cu
),
2523 skip_partial
, language_minimal
);
2525 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
2527 return nullptr; /* Dummy CU. */
2529 dwarf2_find_base_address (cu
->dies
, cu
);
2534 /* Read in the symbols for PER_CU in the context of PER_OBJFILE. */
2537 dw2_do_instantiate_symtab (dwarf2_per_cu_data
*per_cu
,
2538 dwarf2_per_objfile
*per_objfile
, bool skip_partial
)
2540 /* Skip type_unit_groups, reading the type units they contain
2541 is handled elsewhere. */
2542 if (per_cu
->type_unit_group_p ())
2545 /* The destructor of dwarf2_queue_guard frees any entries left on
2546 the queue. After this point we're guaranteed to leave this function
2547 with the dwarf queue empty. */
2548 dwarf2_queue_guard
q_guard (per_objfile
);
2550 if (!per_objfile
->symtab_set_p (per_cu
))
2552 queue_comp_unit (per_cu
, per_objfile
, language_minimal
);
2553 dwarf2_cu
*cu
= load_cu (per_cu
, per_objfile
, skip_partial
);
2555 /* If we just loaded a CU from a DWO, and we're working with an index
2556 that may badly handle TUs, load all the TUs in that DWO as well.
2557 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
2558 if (!per_cu
->is_debug_types
2560 && cu
->dwo_unit
!= NULL
2561 && per_objfile
->per_bfd
->index_table
!= NULL
2562 && per_objfile
->per_bfd
->index_table
->version
<= 7
2563 /* DWP files aren't supported yet. */
2564 && get_dwp_file (per_objfile
) == NULL
)
2565 queue_and_load_all_dwo_tus (cu
);
2568 process_queue (per_objfile
);
2570 /* Age the cache, releasing compilation units that have not
2571 been used recently. */
2572 per_objfile
->age_comp_units ();
2575 /* Ensure that the symbols for PER_CU have been read in. DWARF2_PER_OBJFILE is
2576 the per-objfile for which this symtab is instantiated.
2578 Returns the resulting symbol table. */
2580 static struct compunit_symtab
*
2581 dw2_instantiate_symtab (dwarf2_per_cu_data
*per_cu
,
2582 dwarf2_per_objfile
*per_objfile
,
2585 gdb_assert (per_objfile
->per_bfd
->using_index
);
2587 if (!per_objfile
->symtab_set_p (per_cu
))
2589 free_cached_comp_units
freer (per_objfile
);
2590 scoped_restore decrementer
= increment_reading_symtab ();
2591 dw2_do_instantiate_symtab (per_cu
, per_objfile
, skip_partial
);
2592 process_cu_includes (per_objfile
);
2595 return per_objfile
->get_symtab (per_cu
);
2598 /* See declaration. */
2600 dwarf2_per_cu_data
*
2601 dwarf2_per_bfd::get_cutu (int index
)
2603 if (index
>= this->all_comp_units
.size ())
2605 index
-= this->all_comp_units
.size ();
2606 gdb_assert (index
< this->all_type_units
.size ());
2607 return &this->all_type_units
[index
]->per_cu
;
2610 return this->all_comp_units
[index
];
2613 /* See declaration. */
2615 dwarf2_per_cu_data
*
2616 dwarf2_per_bfd::get_cu (int index
)
2618 gdb_assert (index
>= 0 && index
< this->all_comp_units
.size ());
2620 return this->all_comp_units
[index
];
2623 /* See declaration. */
2626 dwarf2_per_bfd::get_tu (int index
)
2628 gdb_assert (index
>= 0 && index
< this->all_type_units
.size ());
2630 return this->all_type_units
[index
];
2635 dwarf2_per_cu_data
*
2636 dwarf2_per_bfd::allocate_per_cu ()
2638 dwarf2_per_cu_data
*result
= OBSTACK_ZALLOC (&obstack
, dwarf2_per_cu_data
);
2639 result
->per_bfd
= this;
2640 result
->index
= m_num_psymtabs
++;
2647 dwarf2_per_bfd::allocate_signatured_type ()
2649 signatured_type
*result
= OBSTACK_ZALLOC (&obstack
, signatured_type
);
2650 result
->per_cu
.per_bfd
= this;
2651 result
->per_cu
.index
= m_num_psymtabs
++;
2655 /* Return a new dwarf2_per_cu_data allocated on the per-bfd
2656 obstack, and constructed with the specified field values. */
2658 static dwarf2_per_cu_data
*
2659 create_cu_from_index_list (dwarf2_per_bfd
*per_bfd
,
2660 struct dwarf2_section_info
*section
,
2662 sect_offset sect_off
, ULONGEST length
)
2664 dwarf2_per_cu_data
*the_cu
= per_bfd
->allocate_per_cu ();
2665 the_cu
->sect_off
= sect_off
;
2666 the_cu
->length
= length
;
2667 the_cu
->section
= section
;
2668 the_cu
->v
.quick
= OBSTACK_ZALLOC (&per_bfd
->obstack
,
2669 struct dwarf2_per_cu_quick_data
);
2670 the_cu
->is_dwz
= is_dwz
;
2674 /* A helper for create_cus_from_index that handles a given list of
2678 create_cus_from_index_list (dwarf2_per_bfd
*per_bfd
,
2679 const gdb_byte
*cu_list
, offset_type n_elements
,
2680 struct dwarf2_section_info
*section
,
2683 for (offset_type i
= 0; i
< n_elements
; i
+= 2)
2685 gdb_static_assert (sizeof (ULONGEST
) >= 8);
2687 sect_offset sect_off
2688 = (sect_offset
) extract_unsigned_integer (cu_list
, 8, BFD_ENDIAN_LITTLE
);
2689 ULONGEST length
= extract_unsigned_integer (cu_list
+ 8, 8, BFD_ENDIAN_LITTLE
);
2692 dwarf2_per_cu_data
*per_cu
2693 = create_cu_from_index_list (per_bfd
, section
, is_dwz
, sect_off
,
2695 per_bfd
->all_comp_units
.push_back (per_cu
);
2699 /* Read the CU list from the mapped index, and use it to create all
2700 the CU objects for PER_BFD. */
2703 create_cus_from_index (dwarf2_per_bfd
*per_bfd
,
2704 const gdb_byte
*cu_list
, offset_type cu_list_elements
,
2705 const gdb_byte
*dwz_list
, offset_type dwz_elements
)
2707 gdb_assert (per_bfd
->all_comp_units
.empty ());
2708 per_bfd
->all_comp_units
.reserve ((cu_list_elements
+ dwz_elements
) / 2);
2710 create_cus_from_index_list (per_bfd
, cu_list
, cu_list_elements
,
2713 if (dwz_elements
== 0)
2716 dwz_file
*dwz
= dwarf2_get_dwz_file (per_bfd
);
2717 create_cus_from_index_list (per_bfd
, dwz_list
, dwz_elements
,
2721 /* Create the signatured type hash table from the index. */
2724 create_signatured_type_table_from_index
2725 (dwarf2_per_bfd
*per_bfd
, struct dwarf2_section_info
*section
,
2726 const gdb_byte
*bytes
, offset_type elements
)
2728 gdb_assert (per_bfd
->all_type_units
.empty ());
2729 per_bfd
->all_type_units
.reserve (elements
/ 3);
2731 htab_up sig_types_hash
= allocate_signatured_type_table ();
2733 for (offset_type i
= 0; i
< elements
; i
+= 3)
2735 struct signatured_type
*sig_type
;
2738 cu_offset type_offset_in_tu
;
2740 gdb_static_assert (sizeof (ULONGEST
) >= 8);
2741 sect_offset sect_off
2742 = (sect_offset
) extract_unsigned_integer (bytes
, 8, BFD_ENDIAN_LITTLE
);
2744 = (cu_offset
) extract_unsigned_integer (bytes
+ 8, 8,
2746 signature
= extract_unsigned_integer (bytes
+ 16, 8, BFD_ENDIAN_LITTLE
);
2749 sig_type
= per_bfd
->allocate_signatured_type ();
2750 sig_type
->signature
= signature
;
2751 sig_type
->type_offset_in_tu
= type_offset_in_tu
;
2752 sig_type
->per_cu
.is_debug_types
= 1;
2753 sig_type
->per_cu
.section
= section
;
2754 sig_type
->per_cu
.sect_off
= sect_off
;
2755 sig_type
->per_cu
.v
.quick
2756 = OBSTACK_ZALLOC (&per_bfd
->obstack
,
2757 struct dwarf2_per_cu_quick_data
);
2759 slot
= htab_find_slot (sig_types_hash
.get (), sig_type
, INSERT
);
2762 per_bfd
->all_type_units
.push_back (sig_type
);
2765 per_bfd
->signatured_types
= std::move (sig_types_hash
);
2768 /* Create the signatured type hash table from .debug_names. */
2771 create_signatured_type_table_from_debug_names
2772 (dwarf2_per_objfile
*per_objfile
,
2773 const mapped_debug_names
&map
,
2774 struct dwarf2_section_info
*section
,
2775 struct dwarf2_section_info
*abbrev_section
)
2777 struct objfile
*objfile
= per_objfile
->objfile
;
2779 section
->read (objfile
);
2780 abbrev_section
->read (objfile
);
2782 gdb_assert (per_objfile
->per_bfd
->all_type_units
.empty ());
2783 per_objfile
->per_bfd
->all_type_units
.reserve (map
.tu_count
);
2785 htab_up sig_types_hash
= allocate_signatured_type_table ();
2787 for (uint32_t i
= 0; i
< map
.tu_count
; ++i
)
2789 struct signatured_type
*sig_type
;
2792 sect_offset sect_off
2793 = (sect_offset
) (extract_unsigned_integer
2794 (map
.tu_table_reordered
+ i
* map
.offset_size
,
2796 map
.dwarf5_byte_order
));
2798 comp_unit_head cu_header
;
2799 read_and_check_comp_unit_head (per_objfile
, &cu_header
, section
,
2801 section
->buffer
+ to_underlying (sect_off
),
2804 sig_type
= per_objfile
->per_bfd
->allocate_signatured_type ();
2805 sig_type
->signature
= cu_header
.signature
;
2806 sig_type
->type_offset_in_tu
= cu_header
.type_cu_offset_in_tu
;
2807 sig_type
->per_cu
.is_debug_types
= 1;
2808 sig_type
->per_cu
.section
= section
;
2809 sig_type
->per_cu
.sect_off
= sect_off
;
2810 sig_type
->per_cu
.v
.quick
2811 = OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
,
2812 struct dwarf2_per_cu_quick_data
);
2814 slot
= htab_find_slot (sig_types_hash
.get (), sig_type
, INSERT
);
2817 per_objfile
->per_bfd
->all_type_units
.push_back (sig_type
);
2820 per_objfile
->per_bfd
->signatured_types
= std::move (sig_types_hash
);
2823 /* Read the address map data from the mapped index, and use it to
2824 populate the objfile's psymtabs_addrmap. */
2827 create_addrmap_from_index (dwarf2_per_objfile
*per_objfile
,
2828 struct mapped_index
*index
)
2830 struct objfile
*objfile
= per_objfile
->objfile
;
2831 struct gdbarch
*gdbarch
= objfile
->arch ();
2832 const gdb_byte
*iter
, *end
;
2833 struct addrmap
*mutable_map
;
2836 auto_obstack temp_obstack
;
2838 mutable_map
= addrmap_create_mutable (&temp_obstack
);
2840 iter
= index
->address_table
.data ();
2841 end
= iter
+ index
->address_table
.size ();
2843 baseaddr
= objfile
->text_section_offset ();
2847 ULONGEST hi
, lo
, cu_index
;
2848 lo
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
2850 hi
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
2852 cu_index
= extract_unsigned_integer (iter
, 4, BFD_ENDIAN_LITTLE
);
2857 complaint (_(".gdb_index address table has invalid range (%s - %s)"),
2858 hex_string (lo
), hex_string (hi
));
2862 if (cu_index
>= per_objfile
->per_bfd
->all_comp_units
.size ())
2864 complaint (_(".gdb_index address table has invalid CU number %u"),
2865 (unsigned) cu_index
);
2869 lo
= gdbarch_adjust_dwarf2_addr (gdbarch
, lo
+ baseaddr
) - baseaddr
;
2870 hi
= gdbarch_adjust_dwarf2_addr (gdbarch
, hi
+ baseaddr
) - baseaddr
;
2871 addrmap_set_empty (mutable_map
, lo
, hi
- 1,
2872 per_objfile
->per_bfd
->get_cu (cu_index
));
2875 objfile
->partial_symtabs
->psymtabs_addrmap
2876 = addrmap_create_fixed (mutable_map
, objfile
->partial_symtabs
->obstack ());
2879 /* Read the address map data from DWARF-5 .debug_aranges, and use it to
2880 populate the objfile's psymtabs_addrmap. */
2883 create_addrmap_from_aranges (dwarf2_per_objfile
*per_objfile
,
2884 struct dwarf2_section_info
*section
)
2886 struct objfile
*objfile
= per_objfile
->objfile
;
2887 bfd
*abfd
= objfile
->obfd
;
2888 struct gdbarch
*gdbarch
= objfile
->arch ();
2889 const CORE_ADDR baseaddr
= objfile
->text_section_offset ();
2891 auto_obstack temp_obstack
;
2892 addrmap
*mutable_map
= addrmap_create_mutable (&temp_obstack
);
2894 std::unordered_map
<sect_offset
,
2895 dwarf2_per_cu_data
*,
2896 gdb::hash_enum
<sect_offset
>>
2897 debug_info_offset_to_per_cu
;
2898 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
2900 const auto insertpair
2901 = debug_info_offset_to_per_cu
.emplace (per_cu
->sect_off
, per_cu
);
2902 if (!insertpair
.second
)
2904 warning (_("Section .debug_aranges in %s has duplicate "
2905 "debug_info_offset %s, ignoring .debug_aranges."),
2906 objfile_name (objfile
), sect_offset_str (per_cu
->sect_off
));
2911 section
->read (objfile
);
2913 const bfd_endian dwarf5_byte_order
= gdbarch_byte_order (gdbarch
);
2915 const gdb_byte
*addr
= section
->buffer
;
2917 while (addr
< section
->buffer
+ section
->size
)
2919 const gdb_byte
*const entry_addr
= addr
;
2920 unsigned int bytes_read
;
2922 const LONGEST entry_length
= read_initial_length (abfd
, addr
,
2926 const gdb_byte
*const entry_end
= addr
+ entry_length
;
2927 const bool dwarf5_is_dwarf64
= bytes_read
!= 4;
2928 const uint8_t offset_size
= dwarf5_is_dwarf64
? 8 : 4;
2929 if (addr
+ entry_length
> section
->buffer
+ section
->size
)
2931 warning (_("Section .debug_aranges in %s entry at offset %s "
2932 "length %s exceeds section length %s, "
2933 "ignoring .debug_aranges."),
2934 objfile_name (objfile
),
2935 plongest (entry_addr
- section
->buffer
),
2936 plongest (bytes_read
+ entry_length
),
2937 pulongest (section
->size
));
2941 /* The version number. */
2942 const uint16_t version
= read_2_bytes (abfd
, addr
);
2946 warning (_("Section .debug_aranges in %s entry at offset %s "
2947 "has unsupported version %d, ignoring .debug_aranges."),
2948 objfile_name (objfile
),
2949 plongest (entry_addr
- section
->buffer
), version
);
2953 const uint64_t debug_info_offset
2954 = extract_unsigned_integer (addr
, offset_size
, dwarf5_byte_order
);
2955 addr
+= offset_size
;
2956 const auto per_cu_it
2957 = debug_info_offset_to_per_cu
.find (sect_offset (debug_info_offset
));
2958 if (per_cu_it
== debug_info_offset_to_per_cu
.cend ())
2960 warning (_("Section .debug_aranges in %s entry at offset %s "
2961 "debug_info_offset %s does not exists, "
2962 "ignoring .debug_aranges."),
2963 objfile_name (objfile
),
2964 plongest (entry_addr
- section
->buffer
),
2965 pulongest (debug_info_offset
));
2968 dwarf2_per_cu_data
*const per_cu
= per_cu_it
->second
;
2970 const uint8_t address_size
= *addr
++;
2971 if (address_size
< 1 || address_size
> 8)
2973 warning (_("Section .debug_aranges in %s entry at offset %s "
2974 "address_size %u is invalid, ignoring .debug_aranges."),
2975 objfile_name (objfile
),
2976 plongest (entry_addr
- section
->buffer
), address_size
);
2980 const uint8_t segment_selector_size
= *addr
++;
2981 if (segment_selector_size
!= 0)
2983 warning (_("Section .debug_aranges in %s entry at offset %s "
2984 "segment_selector_size %u is not supported, "
2985 "ignoring .debug_aranges."),
2986 objfile_name (objfile
),
2987 plongest (entry_addr
- section
->buffer
),
2988 segment_selector_size
);
2992 /* Must pad to an alignment boundary that is twice the address
2993 size. It is undocumented by the DWARF standard but GCC does
2995 for (size_t padding
= ((-(addr
- section
->buffer
))
2996 & (2 * address_size
- 1));
2997 padding
> 0; padding
--)
3000 warning (_("Section .debug_aranges in %s entry at offset %s "
3001 "padding is not zero, ignoring .debug_aranges."),
3002 objfile_name (objfile
),
3003 plongest (entry_addr
- section
->buffer
));
3009 if (addr
+ 2 * address_size
> entry_end
)
3011 warning (_("Section .debug_aranges in %s entry at offset %s "
3012 "address list is not properly terminated, "
3013 "ignoring .debug_aranges."),
3014 objfile_name (objfile
),
3015 plongest (entry_addr
- section
->buffer
));
3018 ULONGEST start
= extract_unsigned_integer (addr
, address_size
,
3020 addr
+= address_size
;
3021 ULONGEST length
= extract_unsigned_integer (addr
, address_size
,
3023 addr
+= address_size
;
3024 if (start
== 0 && length
== 0)
3026 if (start
== 0 && !per_objfile
->per_bfd
->has_section_at_zero
)
3028 /* Symbol was eliminated due to a COMDAT group. */
3031 ULONGEST end
= start
+ length
;
3032 start
= (gdbarch_adjust_dwarf2_addr (gdbarch
, start
+ baseaddr
)
3034 end
= (gdbarch_adjust_dwarf2_addr (gdbarch
, end
+ baseaddr
)
3036 addrmap_set_empty (mutable_map
, start
, end
- 1, per_cu
);
3040 objfile
->partial_symtabs
->psymtabs_addrmap
3041 = addrmap_create_fixed (mutable_map
, objfile
->partial_symtabs
->obstack ());
3044 /* Find a slot in the mapped index INDEX for the object named NAME.
3045 If NAME is found, set *VEC_OUT to point to the CU vector in the
3046 constant pool and return true. If NAME cannot be found, return
3050 find_slot_in_mapped_hash (struct mapped_index
*index
, const char *name
,
3051 offset_type
**vec_out
)
3054 offset_type slot
, step
;
3055 int (*cmp
) (const char *, const char *);
3057 gdb::unique_xmalloc_ptr
<char> without_params
;
3058 if (current_language
->la_language
== language_cplus
3059 || current_language
->la_language
== language_fortran
3060 || current_language
->la_language
== language_d
)
3062 /* NAME is already canonical. Drop any qualifiers as .gdb_index does
3065 if (strchr (name
, '(') != NULL
)
3067 without_params
= cp_remove_params (name
);
3069 if (without_params
!= NULL
)
3070 name
= without_params
.get ();
3074 /* Index version 4 did not support case insensitive searches. But the
3075 indices for case insensitive languages are built in lowercase, therefore
3076 simulate our NAME being searched is also lowercased. */
3077 hash
= mapped_index_string_hash ((index
->version
== 4
3078 && case_sensitivity
== case_sensitive_off
3079 ? 5 : index
->version
),
3082 slot
= hash
& (index
->symbol_table
.size () - 1);
3083 step
= ((hash
* 17) & (index
->symbol_table
.size () - 1)) | 1;
3084 cmp
= (case_sensitivity
== case_sensitive_on
? strcmp
: strcasecmp
);
3090 const auto &bucket
= index
->symbol_table
[slot
];
3091 if (bucket
.name
== 0 && bucket
.vec
== 0)
3094 str
= index
->constant_pool
+ MAYBE_SWAP (bucket
.name
);
3095 if (!cmp (name
, str
))
3097 *vec_out
= (offset_type
*) (index
->constant_pool
3098 + MAYBE_SWAP (bucket
.vec
));
3102 slot
= (slot
+ step
) & (index
->symbol_table
.size () - 1);
3106 /* A helper function that reads the .gdb_index from BUFFER and fills
3107 in MAP. FILENAME is the name of the file containing the data;
3108 it is used for error reporting. DEPRECATED_OK is true if it is
3109 ok to use deprecated sections.
3111 CU_LIST, CU_LIST_ELEMENTS, TYPES_LIST, and TYPES_LIST_ELEMENTS are
3112 out parameters that are filled in with information about the CU and
3113 TU lists in the section.
3115 Returns true if all went well, false otherwise. */
3118 read_gdb_index_from_buffer (const char *filename
,
3120 gdb::array_view
<const gdb_byte
> buffer
,
3121 struct mapped_index
*map
,
3122 const gdb_byte
**cu_list
,
3123 offset_type
*cu_list_elements
,
3124 const gdb_byte
**types_list
,
3125 offset_type
*types_list_elements
)
3127 const gdb_byte
*addr
= &buffer
[0];
3129 /* Version check. */
3130 offset_type version
= MAYBE_SWAP (*(offset_type
*) addr
);
3131 /* Versions earlier than 3 emitted every copy of a psymbol. This
3132 causes the index to behave very poorly for certain requests. Version 3
3133 contained incomplete addrmap. So, it seems better to just ignore such
3137 static int warning_printed
= 0;
3138 if (!warning_printed
)
3140 warning (_("Skipping obsolete .gdb_index section in %s."),
3142 warning_printed
= 1;
3146 /* Index version 4 uses a different hash function than index version
3149 Versions earlier than 6 did not emit psymbols for inlined
3150 functions. Using these files will cause GDB not to be able to
3151 set breakpoints on inlined functions by name, so we ignore these
3152 indices unless the user has done
3153 "set use-deprecated-index-sections on". */
3154 if (version
< 6 && !deprecated_ok
)
3156 static int warning_printed
= 0;
3157 if (!warning_printed
)
3160 Skipping deprecated .gdb_index section in %s.\n\
3161 Do \"set use-deprecated-index-sections on\" before the file is read\n\
3162 to use the section anyway."),
3164 warning_printed
= 1;
3168 /* Version 7 indices generated by gold refer to the CU for a symbol instead
3169 of the TU (for symbols coming from TUs),
3170 http://sourceware.org/bugzilla/show_bug.cgi?id=15021.
3171 Plus gold-generated indices can have duplicate entries for global symbols,
3172 http://sourceware.org/bugzilla/show_bug.cgi?id=15646.
3173 These are just performance bugs, and we can't distinguish gdb-generated
3174 indices from gold-generated ones, so issue no warning here. */
3176 /* Indexes with higher version than the one supported by GDB may be no
3177 longer backward compatible. */
3181 map
->version
= version
;
3183 offset_type
*metadata
= (offset_type
*) (addr
+ sizeof (offset_type
));
3186 *cu_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
3187 *cu_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1]) - MAYBE_SWAP (metadata
[i
]))
3191 *types_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
3192 *types_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1])
3193 - MAYBE_SWAP (metadata
[i
]))
3197 const gdb_byte
*address_table
= addr
+ MAYBE_SWAP (metadata
[i
]);
3198 const gdb_byte
*address_table_end
= addr
+ MAYBE_SWAP (metadata
[i
+ 1]);
3200 = gdb::array_view
<const gdb_byte
> (address_table
, address_table_end
);
3203 const gdb_byte
*symbol_table
= addr
+ MAYBE_SWAP (metadata
[i
]);
3204 const gdb_byte
*symbol_table_end
= addr
+ MAYBE_SWAP (metadata
[i
+ 1]);
3206 = gdb::array_view
<mapped_index::symbol_table_slot
>
3207 ((mapped_index::symbol_table_slot
*) symbol_table
,
3208 (mapped_index::symbol_table_slot
*) symbol_table_end
);
3211 map
->constant_pool
= (char *) (addr
+ MAYBE_SWAP (metadata
[i
]));
3216 /* Callback types for dwarf2_read_gdb_index. */
3218 typedef gdb::function_view
3219 <gdb::array_view
<const gdb_byte
>(objfile
*, dwarf2_per_bfd
*)>
3220 get_gdb_index_contents_ftype
;
3221 typedef gdb::function_view
3222 <gdb::array_view
<const gdb_byte
>(objfile
*, dwz_file
*)>
3223 get_gdb_index_contents_dwz_ftype
;
3225 /* Read .gdb_index. If everything went ok, initialize the "quick"
3226 elements of all the CUs and return 1. Otherwise, return 0. */
3229 dwarf2_read_gdb_index
3230 (dwarf2_per_objfile
*per_objfile
,
3231 get_gdb_index_contents_ftype get_gdb_index_contents
,
3232 get_gdb_index_contents_dwz_ftype get_gdb_index_contents_dwz
)
3234 const gdb_byte
*cu_list
, *types_list
, *dwz_list
= NULL
;
3235 offset_type cu_list_elements
, types_list_elements
, dwz_list_elements
= 0;
3236 struct dwz_file
*dwz
;
3237 struct objfile
*objfile
= per_objfile
->objfile
;
3238 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
3240 gdb::array_view
<const gdb_byte
> main_index_contents
3241 = get_gdb_index_contents (objfile
, per_bfd
);
3243 if (main_index_contents
.empty ())
3246 std::unique_ptr
<struct mapped_index
> map (new struct mapped_index
);
3247 if (!read_gdb_index_from_buffer (objfile_name (objfile
),
3248 use_deprecated_index_sections
,
3249 main_index_contents
, map
.get (), &cu_list
,
3250 &cu_list_elements
, &types_list
,
3251 &types_list_elements
))
3254 /* Don't use the index if it's empty. */
3255 if (map
->symbol_table
.empty ())
3258 /* If there is a .dwz file, read it so we can get its CU list as
3260 dwz
= dwarf2_get_dwz_file (per_bfd
);
3263 struct mapped_index dwz_map
;
3264 const gdb_byte
*dwz_types_ignore
;
3265 offset_type dwz_types_elements_ignore
;
3267 gdb::array_view
<const gdb_byte
> dwz_index_content
3268 = get_gdb_index_contents_dwz (objfile
, dwz
);
3270 if (dwz_index_content
.empty ())
3273 if (!read_gdb_index_from_buffer (bfd_get_filename (dwz
->dwz_bfd
.get ()),
3274 1, dwz_index_content
, &dwz_map
,
3275 &dwz_list
, &dwz_list_elements
,
3277 &dwz_types_elements_ignore
))
3279 warning (_("could not read '.gdb_index' section from %s; skipping"),
3280 bfd_get_filename (dwz
->dwz_bfd
.get ()));
3285 create_cus_from_index (per_bfd
, cu_list
, cu_list_elements
, dwz_list
,
3288 if (types_list_elements
)
3290 /* We can only handle a single .debug_types when we have an
3292 if (per_bfd
->types
.size () != 1)
3295 dwarf2_section_info
*section
= &per_bfd
->types
[0];
3297 create_signatured_type_table_from_index (per_bfd
, section
, types_list
,
3298 types_list_elements
);
3301 create_addrmap_from_index (per_objfile
, map
.get ());
3303 per_bfd
->index_table
= std::move (map
);
3304 per_bfd
->using_index
= 1;
3305 per_bfd
->quick_file_names_table
=
3306 create_quick_file_names_table (per_bfd
->all_comp_units
.size ());
3308 /* Save partial symtabs in the per_bfd object, for the benefit of subsequent
3309 objfiles using the same BFD. */
3310 gdb_assert (per_bfd
->partial_symtabs
== nullptr);
3311 per_bfd
->partial_symtabs
= objfile
->partial_symtabs
;
3316 /* die_reader_func for dw2_get_file_names. */
3319 dw2_get_file_names_reader (const struct die_reader_specs
*reader
,
3320 const gdb_byte
*info_ptr
,
3321 struct die_info
*comp_unit_die
)
3323 struct dwarf2_cu
*cu
= reader
->cu
;
3324 struct dwarf2_per_cu_data
*this_cu
= cu
->per_cu
;
3325 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
3326 struct dwarf2_per_cu_data
*lh_cu
;
3327 struct attribute
*attr
;
3329 struct quick_file_names
*qfn
;
3331 gdb_assert (! this_cu
->is_debug_types
);
3333 /* Our callers never want to match partial units -- instead they
3334 will match the enclosing full CU. */
3335 if (comp_unit_die
->tag
== DW_TAG_partial_unit
)
3337 this_cu
->v
.quick
->no_file_data
= 1;
3345 sect_offset line_offset
{};
3347 attr
= dwarf2_attr (comp_unit_die
, DW_AT_stmt_list
, cu
);
3348 if (attr
!= nullptr && attr
->form_is_unsigned ())
3350 struct quick_file_names find_entry
;
3352 line_offset
= (sect_offset
) attr
->as_unsigned ();
3354 /* We may have already read in this line header (TU line header sharing).
3355 If we have we're done. */
3356 find_entry
.hash
.dwo_unit
= cu
->dwo_unit
;
3357 find_entry
.hash
.line_sect_off
= line_offset
;
3358 slot
= htab_find_slot (per_objfile
->per_bfd
->quick_file_names_table
.get (),
3359 &find_entry
, INSERT
);
3362 lh_cu
->v
.quick
->file_names
= (struct quick_file_names
*) *slot
;
3366 lh
= dwarf_decode_line_header (line_offset
, cu
);
3370 lh_cu
->v
.quick
->no_file_data
= 1;
3374 qfn
= XOBNEW (&per_objfile
->per_bfd
->obstack
, struct quick_file_names
);
3375 qfn
->hash
.dwo_unit
= cu
->dwo_unit
;
3376 qfn
->hash
.line_sect_off
= line_offset
;
3377 gdb_assert (slot
!= NULL
);
3380 file_and_directory fnd
= find_file_and_directory (comp_unit_die
, cu
);
3383 if (strcmp (fnd
.name
, "<unknown>") != 0)
3386 qfn
->num_file_names
= offset
+ lh
->file_names_size ();
3388 XOBNEWVEC (&per_objfile
->per_bfd
->obstack
, const char *,
3389 qfn
->num_file_names
);
3391 qfn
->file_names
[0] = xstrdup (fnd
.name
);
3392 for (int i
= 0; i
< lh
->file_names_size (); ++i
)
3393 qfn
->file_names
[i
+ offset
] = lh
->file_full_name (i
+ 1,
3394 fnd
.comp_dir
).release ();
3395 qfn
->real_names
= NULL
;
3397 lh_cu
->v
.quick
->file_names
= qfn
;
3400 /* A helper for the "quick" functions which attempts to read the line
3401 table for THIS_CU. */
3403 static struct quick_file_names
*
3404 dw2_get_file_names (dwarf2_per_cu_data
*this_cu
,
3405 dwarf2_per_objfile
*per_objfile
)
3407 /* This should never be called for TUs. */
3408 gdb_assert (! this_cu
->is_debug_types
);
3409 /* Nor type unit groups. */
3410 gdb_assert (! this_cu
->type_unit_group_p ());
3412 if (this_cu
->v
.quick
->file_names
!= NULL
)
3413 return this_cu
->v
.quick
->file_names
;
3414 /* If we know there is no line data, no point in looking again. */
3415 if (this_cu
->v
.quick
->no_file_data
)
3418 cutu_reader
reader (this_cu
, per_objfile
);
3419 if (!reader
.dummy_p
)
3420 dw2_get_file_names_reader (&reader
, reader
.info_ptr
, reader
.comp_unit_die
);
3422 if (this_cu
->v
.quick
->no_file_data
)
3424 return this_cu
->v
.quick
->file_names
;
3427 /* A helper for the "quick" functions which computes and caches the
3428 real path for a given file name from the line table. */
3431 dw2_get_real_path (dwarf2_per_objfile
*per_objfile
,
3432 struct quick_file_names
*qfn
, int index
)
3434 if (qfn
->real_names
== NULL
)
3435 qfn
->real_names
= OBSTACK_CALLOC (&per_objfile
->per_bfd
->obstack
,
3436 qfn
->num_file_names
, const char *);
3438 if (qfn
->real_names
[index
] == NULL
)
3439 qfn
->real_names
[index
] = gdb_realpath (qfn
->file_names
[index
]).release ();
3441 return qfn
->real_names
[index
];
3444 static struct symtab
*
3445 dw2_find_last_source_symtab (struct objfile
*objfile
)
3447 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3448 dwarf2_per_cu_data
*dwarf_cu
= per_objfile
->per_bfd
->all_comp_units
.back ();
3449 compunit_symtab
*cust
= dw2_instantiate_symtab (dwarf_cu
, per_objfile
, false);
3454 return compunit_primary_filetab (cust
);
3457 /* Traversal function for dw2_forget_cached_source_info. */
3460 dw2_free_cached_file_names (void **slot
, void *info
)
3462 struct quick_file_names
*file_data
= (struct quick_file_names
*) *slot
;
3464 if (file_data
->real_names
)
3468 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
3470 xfree ((void*) file_data
->real_names
[i
]);
3471 file_data
->real_names
[i
] = NULL
;
3479 dw2_forget_cached_source_info (struct objfile
*objfile
)
3481 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3483 htab_traverse_noresize (per_objfile
->per_bfd
->quick_file_names_table
.get (),
3484 dw2_free_cached_file_names
, NULL
);
3487 /* Helper function for dw2_map_symtabs_matching_filename that expands
3488 the symtabs and calls the iterator. */
3491 dw2_map_expand_apply (struct objfile
*objfile
,
3492 struct dwarf2_per_cu_data
*per_cu
,
3493 const char *name
, const char *real_path
,
3494 gdb::function_view
<bool (symtab
*)> callback
)
3496 struct compunit_symtab
*last_made
= objfile
->compunit_symtabs
;
3498 /* Don't visit already-expanded CUs. */
3499 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3500 if (per_objfile
->symtab_set_p (per_cu
))
3503 /* This may expand more than one symtab, and we want to iterate over
3505 dw2_instantiate_symtab (per_cu
, per_objfile
, false);
3507 return iterate_over_some_symtabs (name
, real_path
, objfile
->compunit_symtabs
,
3508 last_made
, callback
);
3511 /* Implementation of the map_symtabs_matching_filename method. */
3514 dw2_map_symtabs_matching_filename
3515 (struct objfile
*objfile
, const char *name
, const char *real_path
,
3516 gdb::function_view
<bool (symtab
*)> callback
)
3518 const char *name_basename
= lbasename (name
);
3519 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3521 /* The rule is CUs specify all the files, including those used by
3522 any TU, so there's no need to scan TUs here. */
3524 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
3526 /* We only need to look at symtabs not already expanded. */
3527 if (per_objfile
->symtab_set_p (per_cu
))
3530 quick_file_names
*file_data
= dw2_get_file_names (per_cu
, per_objfile
);
3531 if (file_data
== NULL
)
3534 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
3536 const char *this_name
= file_data
->file_names
[j
];
3537 const char *this_real_name
;
3539 if (compare_filenames_for_search (this_name
, name
))
3541 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3547 /* Before we invoke realpath, which can get expensive when many
3548 files are involved, do a quick comparison of the basenames. */
3549 if (! basenames_may_differ
3550 && FILENAME_CMP (lbasename (this_name
), name_basename
) != 0)
3553 this_real_name
= dw2_get_real_path (per_objfile
, file_data
, j
);
3554 if (compare_filenames_for_search (this_real_name
, name
))
3556 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3562 if (real_path
!= NULL
)
3564 gdb_assert (IS_ABSOLUTE_PATH (real_path
));
3565 gdb_assert (IS_ABSOLUTE_PATH (name
));
3566 if (this_real_name
!= NULL
3567 && FILENAME_CMP (real_path
, this_real_name
) == 0)
3569 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3581 /* Struct used to manage iterating over all CUs looking for a symbol. */
3583 struct dw2_symtab_iterator
3585 /* The dwarf2_per_objfile owning the CUs we are iterating on. */
3586 dwarf2_per_objfile
*per_objfile
;
3587 /* If set, only look for symbols that match that block. Valid values are
3588 GLOBAL_BLOCK and STATIC_BLOCK. */
3589 gdb::optional
<block_enum
> block_index
;
3590 /* The kind of symbol we're looking for. */
3592 /* The list of CUs from the index entry of the symbol,
3593 or NULL if not found. */
3595 /* The next element in VEC to look at. */
3597 /* The number of elements in VEC, or zero if there is no match. */
3599 /* Have we seen a global version of the symbol?
3600 If so we can ignore all further global instances.
3601 This is to work around gold/15646, inefficient gold-generated
3606 /* Initialize the index symtab iterator ITER, common part. */
3609 dw2_symtab_iter_init_common (struct dw2_symtab_iterator
*iter
,
3610 dwarf2_per_objfile
*per_objfile
,
3611 gdb::optional
<block_enum
> block_index
,
3614 iter
->per_objfile
= per_objfile
;
3615 iter
->block_index
= block_index
;
3616 iter
->domain
= domain
;
3618 iter
->global_seen
= 0;
3623 /* Initialize the index symtab iterator ITER, const char *NAME variant. */
3626 dw2_symtab_iter_init (struct dw2_symtab_iterator
*iter
,
3627 dwarf2_per_objfile
*per_objfile
,
3628 gdb::optional
<block_enum
> block_index
,
3632 dw2_symtab_iter_init_common (iter
, per_objfile
, block_index
, domain
);
3634 mapped_index
*index
= per_objfile
->per_bfd
->index_table
.get ();
3635 /* index is NULL if OBJF_READNOW. */
3639 if (find_slot_in_mapped_hash (index
, name
, &iter
->vec
))
3640 iter
->length
= MAYBE_SWAP (*iter
->vec
);
3643 /* Initialize the index symtab iterator ITER, offset_type NAMEI variant. */
3646 dw2_symtab_iter_init (struct dw2_symtab_iterator
*iter
,
3647 dwarf2_per_objfile
*per_objfile
,
3648 gdb::optional
<block_enum
> block_index
,
3649 domain_enum domain
, offset_type namei
)
3651 dw2_symtab_iter_init_common (iter
, per_objfile
, block_index
, domain
);
3653 mapped_index
*index
= per_objfile
->per_bfd
->index_table
.get ();
3654 /* index is NULL if OBJF_READNOW. */
3658 gdb_assert (!index
->symbol_name_slot_invalid (namei
));
3659 const auto &bucket
= index
->symbol_table
[namei
];
3661 iter
->vec
= (offset_type
*) (index
->constant_pool
3662 + MAYBE_SWAP (bucket
.vec
));
3663 iter
->length
= MAYBE_SWAP (*iter
->vec
);
3666 /* Return the next matching CU or NULL if there are no more. */
3668 static struct dwarf2_per_cu_data
*
3669 dw2_symtab_iter_next (struct dw2_symtab_iterator
*iter
)
3671 dwarf2_per_objfile
*per_objfile
= iter
->per_objfile
;
3673 for ( ; iter
->next
< iter
->length
; ++iter
->next
)
3675 offset_type cu_index_and_attrs
=
3676 MAYBE_SWAP (iter
->vec
[iter
->next
+ 1]);
3677 offset_type cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
3678 gdb_index_symbol_kind symbol_kind
=
3679 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
3680 /* Only check the symbol attributes if they're present.
3681 Indices prior to version 7 don't record them,
3682 and indices >= 7 may elide them for certain symbols
3683 (gold does this). */
3685 (per_objfile
->per_bfd
->index_table
->version
>= 7
3686 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_NONE
);
3688 /* Don't crash on bad data. */
3689 if (cu_index
>= (per_objfile
->per_bfd
->all_comp_units
.size ()
3690 + per_objfile
->per_bfd
->all_type_units
.size ()))
3692 complaint (_(".gdb_index entry has bad CU index"
3693 " [in module %s]"), objfile_name (per_objfile
->objfile
));
3697 dwarf2_per_cu_data
*per_cu
= per_objfile
->per_bfd
->get_cutu (cu_index
);
3699 /* Skip if already read in. */
3700 if (per_objfile
->symtab_set_p (per_cu
))
3703 /* Check static vs global. */
3706 bool is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs
);
3708 if (iter
->block_index
.has_value ())
3710 bool want_static
= *iter
->block_index
== STATIC_BLOCK
;
3712 if (is_static
!= want_static
)
3716 /* Work around gold/15646. */
3718 && symbol_kind
== GDB_INDEX_SYMBOL_KIND_TYPE
)
3720 if (iter
->global_seen
)
3723 iter
->global_seen
= 1;
3727 /* Only check the symbol's kind if it has one. */
3730 switch (iter
->domain
)
3733 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
3734 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
3735 /* Some types are also in VAR_DOMAIN. */
3736 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
3740 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
3744 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_OTHER
)
3748 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_OTHER
)
3763 static struct compunit_symtab
*
3764 dw2_lookup_symbol (struct objfile
*objfile
, block_enum block_index
,
3765 const char *name
, domain_enum domain
)
3767 struct compunit_symtab
*stab_best
= NULL
;
3768 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3770 lookup_name_info
lookup_name (name
, symbol_name_match_type::FULL
);
3772 struct dw2_symtab_iterator iter
;
3773 struct dwarf2_per_cu_data
*per_cu
;
3775 dw2_symtab_iter_init (&iter
, per_objfile
, block_index
, domain
, name
);
3777 while ((per_cu
= dw2_symtab_iter_next (&iter
)) != NULL
)
3779 struct symbol
*sym
, *with_opaque
= NULL
;
3780 struct compunit_symtab
*stab
3781 = dw2_instantiate_symtab (per_cu
, per_objfile
, false);
3782 const struct blockvector
*bv
= COMPUNIT_BLOCKVECTOR (stab
);
3783 const struct block
*block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
3785 sym
= block_find_symbol (block
, name
, domain
,
3786 block_find_non_opaque_type_preferred
,
3789 /* Some caution must be observed with overloaded functions
3790 and methods, since the index will not contain any overload
3791 information (but NAME might contain it). */
3794 && SYMBOL_MATCHES_SEARCH_NAME (sym
, lookup_name
))
3796 if (with_opaque
!= NULL
3797 && SYMBOL_MATCHES_SEARCH_NAME (with_opaque
, lookup_name
))
3800 /* Keep looking through other CUs. */
3807 dw2_print_stats (struct objfile
*objfile
)
3809 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3810 int total
= (per_objfile
->per_bfd
->all_comp_units
.size ()
3811 + per_objfile
->per_bfd
->all_type_units
.size ());
3814 for (int i
= 0; i
< total
; ++i
)
3816 dwarf2_per_cu_data
*per_cu
= per_objfile
->per_bfd
->get_cutu (i
);
3818 if (!per_objfile
->symtab_set_p (per_cu
))
3821 printf_filtered (_(" Number of read CUs: %d\n"), total
- count
);
3822 printf_filtered (_(" Number of unread CUs: %d\n"), count
);
3825 /* This dumps minimal information about the index.
3826 It is called via "mt print objfiles".
3827 One use is to verify .gdb_index has been loaded by the
3828 gdb.dwarf2/gdb-index.exp testcase. */
3831 dw2_dump (struct objfile
*objfile
)
3833 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3835 gdb_assert (per_objfile
->per_bfd
->using_index
);
3836 printf_filtered (".gdb_index:");
3837 if (per_objfile
->per_bfd
->index_table
!= NULL
)
3839 printf_filtered (" version %d\n",
3840 per_objfile
->per_bfd
->index_table
->version
);
3843 printf_filtered (" faked for \"readnow\"\n");
3844 printf_filtered ("\n");
3848 dw2_expand_symtabs_for_function (struct objfile
*objfile
,
3849 const char *func_name
)
3851 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3853 struct dw2_symtab_iterator iter
;
3854 struct dwarf2_per_cu_data
*per_cu
;
3856 dw2_symtab_iter_init (&iter
, per_objfile
, {}, VAR_DOMAIN
, func_name
);
3858 while ((per_cu
= dw2_symtab_iter_next (&iter
)) != NULL
)
3859 dw2_instantiate_symtab (per_cu
, per_objfile
, false);
3864 dw2_expand_all_symtabs (struct objfile
*objfile
)
3866 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3867 int total_units
= (per_objfile
->per_bfd
->all_comp_units
.size ()
3868 + per_objfile
->per_bfd
->all_type_units
.size ());
3870 for (int i
= 0; i
< total_units
; ++i
)
3872 dwarf2_per_cu_data
*per_cu
= per_objfile
->per_bfd
->get_cutu (i
);
3874 /* We don't want to directly expand a partial CU, because if we
3875 read it with the wrong language, then assertion failures can
3876 be triggered later on. See PR symtab/23010. So, tell
3877 dw2_instantiate_symtab to skip partial CUs -- any important
3878 partial CU will be read via DW_TAG_imported_unit anyway. */
3879 dw2_instantiate_symtab (per_cu
, per_objfile
, true);
3884 dw2_expand_symtabs_with_fullname (struct objfile
*objfile
,
3885 const char *fullname
)
3887 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3889 /* We don't need to consider type units here.
3890 This is only called for examining code, e.g. expand_line_sal.
3891 There can be an order of magnitude (or more) more type units
3892 than comp units, and we avoid them if we can. */
3894 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
3896 /* We only need to look at symtabs not already expanded. */
3897 if (per_objfile
->symtab_set_p (per_cu
))
3900 quick_file_names
*file_data
= dw2_get_file_names (per_cu
, per_objfile
);
3901 if (file_data
== NULL
)
3904 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
3906 const char *this_fullname
= file_data
->file_names
[j
];
3908 if (filename_cmp (this_fullname
, fullname
) == 0)
3910 dw2_instantiate_symtab (per_cu
, per_objfile
, false);
3918 dw2_expand_symtabs_matching_symbol
3919 (mapped_index_base
&index
,
3920 const lookup_name_info
&lookup_name_in
,
3921 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
3922 enum search_domain kind
,
3923 gdb::function_view
<bool (offset_type
)> match_callback
,
3924 dwarf2_per_objfile
*per_objfile
);
3927 dw2_expand_symtabs_matching_one
3928 (dwarf2_per_cu_data
*per_cu
,
3929 dwarf2_per_objfile
*per_objfile
,
3930 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
3931 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
);
3934 dw2_map_matching_symbols
3935 (struct objfile
*objfile
,
3936 const lookup_name_info
&name
, domain_enum domain
,
3938 gdb::function_view
<symbol_found_callback_ftype
> callback
,
3939 symbol_compare_ftype
*ordered_compare
)
3942 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3944 const block_enum block_kind
= global
? GLOBAL_BLOCK
: STATIC_BLOCK
;
3946 if (per_objfile
->per_bfd
->index_table
!= nullptr)
3948 mapped_index
&index
= *per_objfile
->per_bfd
->index_table
;
3950 const char *match_name
= name
.ada ().lookup_name ().c_str ();
3951 auto matcher
= [&] (const char *symname
)
3953 if (ordered_compare
== nullptr)
3955 return ordered_compare (symname
, match_name
) == 0;
3958 dw2_expand_symtabs_matching_symbol (index
, name
, matcher
, ALL_DOMAIN
,
3959 [&] (offset_type namei
)
3961 struct dw2_symtab_iterator iter
;
3962 struct dwarf2_per_cu_data
*per_cu
;
3964 dw2_symtab_iter_init (&iter
, per_objfile
, block_kind
, domain
,
3966 while ((per_cu
= dw2_symtab_iter_next (&iter
)) != NULL
)
3967 dw2_expand_symtabs_matching_one (per_cu
, per_objfile
, nullptr,
3974 /* We have -readnow: no .gdb_index, but no partial symtabs either. So,
3975 proceed assuming all symtabs have been read in. */
3978 for (compunit_symtab
*cust
: objfile
->compunits ())
3980 const struct block
*block
;
3984 block
= BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust
), block_kind
);
3985 if (!iterate_over_symbols_terminated (block
, name
,
3991 /* Starting from a search name, return the string that finds the upper
3992 bound of all strings that start with SEARCH_NAME in a sorted name
3993 list. Returns the empty string to indicate that the upper bound is
3994 the end of the list. */
3997 make_sort_after_prefix_name (const char *search_name
)
3999 /* When looking to complete "func", we find the upper bound of all
4000 symbols that start with "func" by looking for where we'd insert
4001 the closest string that would follow "func" in lexicographical
4002 order. Usually, that's "func"-with-last-character-incremented,
4003 i.e. "fund". Mind non-ASCII characters, though. Usually those
4004 will be UTF-8 multi-byte sequences, but we can't be certain.
4005 Especially mind the 0xff character, which is a valid character in
4006 non-UTF-8 source character sets (e.g. Latin1 'ÿ'), and we can't
4007 rule out compilers allowing it in identifiers. Note that
4008 conveniently, strcmp/strcasecmp are specified to compare
4009 characters interpreted as unsigned char. So what we do is treat
4010 the whole string as a base 256 number composed of a sequence of
4011 base 256 "digits" and add 1 to it. I.e., adding 1 to 0xff wraps
4012 to 0, and carries 1 to the following more-significant position.
4013 If the very first character in SEARCH_NAME ends up incremented
4014 and carries/overflows, then the upper bound is the end of the
4015 list. The string after the empty string is also the empty
4018 Some examples of this operation:
4020 SEARCH_NAME => "+1" RESULT
4024 "\xff" "a" "\xff" => "\xff" "b"
4029 Then, with these symbols for example:
4035 completing "func" looks for symbols between "func" and
4036 "func"-with-last-character-incremented, i.e. "fund" (exclusive),
4037 which finds "func" and "func1", but not "fund".
4041 funcÿ (Latin1 'ÿ' [0xff])
4045 completing "funcÿ" looks for symbols between "funcÿ" and "fund"
4046 (exclusive), which finds "funcÿ" and "funcÿ1", but not "fund".
4050 ÿÿ (Latin1 'ÿ' [0xff])
4053 completing "ÿ" or "ÿÿ" looks for symbols between between "ÿÿ" and
4054 the end of the list.
4056 std::string after
= search_name
;
4057 while (!after
.empty () && (unsigned char) after
.back () == 0xff)
4059 if (!after
.empty ())
4060 after
.back () = (unsigned char) after
.back () + 1;
4064 /* See declaration. */
4066 std::pair
<std::vector
<name_component
>::const_iterator
,
4067 std::vector
<name_component
>::const_iterator
>
4068 mapped_index_base::find_name_components_bounds
4069 (const lookup_name_info
&lookup_name_without_params
, language lang
,
4070 dwarf2_per_objfile
*per_objfile
) const
4073 = this->name_components_casing
== case_sensitive_on
? strcmp
: strcasecmp
;
4075 const char *lang_name
4076 = lookup_name_without_params
.language_lookup_name (lang
);
4078 /* Comparison function object for lower_bound that matches against a
4079 given symbol name. */
4080 auto lookup_compare_lower
= [&] (const name_component
&elem
,
4083 const char *elem_qualified
= this->symbol_name_at (elem
.idx
, per_objfile
);
4084 const char *elem_name
= elem_qualified
+ elem
.name_offset
;
4085 return name_cmp (elem_name
, name
) < 0;
4088 /* Comparison function object for upper_bound that matches against a
4089 given symbol name. */
4090 auto lookup_compare_upper
= [&] (const char *name
,
4091 const name_component
&elem
)
4093 const char *elem_qualified
= this->symbol_name_at (elem
.idx
, per_objfile
);
4094 const char *elem_name
= elem_qualified
+ elem
.name_offset
;
4095 return name_cmp (name
, elem_name
) < 0;
4098 auto begin
= this->name_components
.begin ();
4099 auto end
= this->name_components
.end ();
4101 /* Find the lower bound. */
4104 if (lookup_name_without_params
.completion_mode () && lang_name
[0] == '\0')
4107 return std::lower_bound (begin
, end
, lang_name
, lookup_compare_lower
);
4110 /* Find the upper bound. */
4113 if (lookup_name_without_params
.completion_mode ())
4115 /* In completion mode, we want UPPER to point past all
4116 symbols names that have the same prefix. I.e., with
4117 these symbols, and completing "func":
4119 function << lower bound
4121 other_function << upper bound
4123 We find the upper bound by looking for the insertion
4124 point of "func"-with-last-character-incremented,
4126 std::string after
= make_sort_after_prefix_name (lang_name
);
4129 return std::lower_bound (lower
, end
, after
.c_str (),
4130 lookup_compare_lower
);
4133 return std::upper_bound (lower
, end
, lang_name
, lookup_compare_upper
);
4136 return {lower
, upper
};
4139 /* See declaration. */
4142 mapped_index_base::build_name_components (dwarf2_per_objfile
*per_objfile
)
4144 if (!this->name_components
.empty ())
4147 this->name_components_casing
= case_sensitivity
;
4149 = this->name_components_casing
== case_sensitive_on
? strcmp
: strcasecmp
;
4151 /* The code below only knows how to break apart components of C++
4152 symbol names (and other languages that use '::' as
4153 namespace/module separator) and Ada symbol names. */
4154 auto count
= this->symbol_name_count ();
4155 for (offset_type idx
= 0; idx
< count
; idx
++)
4157 if (this->symbol_name_slot_invalid (idx
))
4160 const char *name
= this->symbol_name_at (idx
, per_objfile
);
4162 /* Add each name component to the name component table. */
4163 unsigned int previous_len
= 0;
4165 if (strstr (name
, "::") != nullptr)
4167 for (unsigned int current_len
= cp_find_first_component (name
);
4168 name
[current_len
] != '\0';
4169 current_len
+= cp_find_first_component (name
+ current_len
))
4171 gdb_assert (name
[current_len
] == ':');
4172 this->name_components
.push_back ({previous_len
, idx
});
4173 /* Skip the '::'. */
4175 previous_len
= current_len
;
4180 /* Handle the Ada encoded (aka mangled) form here. */
4181 for (const char *iter
= strstr (name
, "__");
4183 iter
= strstr (iter
, "__"))
4185 this->name_components
.push_back ({previous_len
, idx
});
4187 previous_len
= iter
- name
;
4191 this->name_components
.push_back ({previous_len
, idx
});
4194 /* Sort name_components elements by name. */
4195 auto name_comp_compare
= [&] (const name_component
&left
,
4196 const name_component
&right
)
4198 const char *left_qualified
4199 = this->symbol_name_at (left
.idx
, per_objfile
);
4200 const char *right_qualified
4201 = this->symbol_name_at (right
.idx
, per_objfile
);
4203 const char *left_name
= left_qualified
+ left
.name_offset
;
4204 const char *right_name
= right_qualified
+ right
.name_offset
;
4206 return name_cmp (left_name
, right_name
) < 0;
4209 std::sort (this->name_components
.begin (),
4210 this->name_components
.end (),
4214 /* Helper for dw2_expand_symtabs_matching that works with a
4215 mapped_index_base instead of the containing objfile. This is split
4216 to a separate function in order to be able to unit test the
4217 name_components matching using a mock mapped_index_base. For each
4218 symbol name that matches, calls MATCH_CALLBACK, passing it the
4219 symbol's index in the mapped_index_base symbol table. */
4222 dw2_expand_symtabs_matching_symbol
4223 (mapped_index_base
&index
,
4224 const lookup_name_info
&lookup_name_in
,
4225 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
4226 enum search_domain kind
,
4227 gdb::function_view
<bool (offset_type
)> match_callback
,
4228 dwarf2_per_objfile
*per_objfile
)
4230 lookup_name_info lookup_name_without_params
4231 = lookup_name_in
.make_ignore_params ();
4233 /* Build the symbol name component sorted vector, if we haven't
4235 index
.build_name_components (per_objfile
);
4237 /* The same symbol may appear more than once in the range though.
4238 E.g., if we're looking for symbols that complete "w", and we have
4239 a symbol named "w1::w2", we'll find the two name components for
4240 that same symbol in the range. To be sure we only call the
4241 callback once per symbol, we first collect the symbol name
4242 indexes that matched in a temporary vector and ignore
4244 std::vector
<offset_type
> matches
;
4246 struct name_and_matcher
4248 symbol_name_matcher_ftype
*matcher
;
4251 bool operator== (const name_and_matcher
&other
) const
4253 return matcher
== other
.matcher
&& strcmp (name
, other
.name
) == 0;
4257 /* A vector holding all the different symbol name matchers, for all
4259 std::vector
<name_and_matcher
> matchers
;
4261 for (int i
= 0; i
< nr_languages
; i
++)
4263 enum language lang_e
= (enum language
) i
;
4265 const language_defn
*lang
= language_def (lang_e
);
4266 symbol_name_matcher_ftype
*name_matcher
4267 = lang
->get_symbol_name_matcher (lookup_name_without_params
);
4269 name_and_matcher key
{
4271 lookup_name_without_params
.language_lookup_name (lang_e
)
4274 /* Don't insert the same comparison routine more than once.
4275 Note that we do this linear walk. This is not a problem in
4276 practice because the number of supported languages is
4278 if (std::find (matchers
.begin (), matchers
.end (), key
)
4281 matchers
.push_back (std::move (key
));
4284 = index
.find_name_components_bounds (lookup_name_without_params
,
4285 lang_e
, per_objfile
);
4287 /* Now for each symbol name in range, check to see if we have a name
4288 match, and if so, call the MATCH_CALLBACK callback. */
4290 for (; bounds
.first
!= bounds
.second
; ++bounds
.first
)
4292 const char *qualified
4293 = index
.symbol_name_at (bounds
.first
->idx
, per_objfile
);
4295 if (!name_matcher (qualified
, lookup_name_without_params
, NULL
)
4296 || (symbol_matcher
!= NULL
&& !symbol_matcher (qualified
)))
4299 matches
.push_back (bounds
.first
->idx
);
4303 std::sort (matches
.begin (), matches
.end ());
4305 /* Finally call the callback, once per match. */
4307 for (offset_type idx
: matches
)
4311 if (!match_callback (idx
))
4317 /* Above we use a type wider than idx's for 'prev', since 0 and
4318 (offset_type)-1 are both possible values. */
4319 static_assert (sizeof (prev
) > sizeof (offset_type
), "");
4324 namespace selftests
{ namespace dw2_expand_symtabs_matching
{
4326 /* A mock .gdb_index/.debug_names-like name index table, enough to
4327 exercise dw2_expand_symtabs_matching_symbol, which works with the
4328 mapped_index_base interface. Builds an index from the symbol list
4329 passed as parameter to the constructor. */
4330 class mock_mapped_index
: public mapped_index_base
4333 mock_mapped_index (gdb::array_view
<const char *> symbols
)
4334 : m_symbol_table (symbols
)
4337 DISABLE_COPY_AND_ASSIGN (mock_mapped_index
);
4339 /* Return the number of names in the symbol table. */
4340 size_t symbol_name_count () const override
4342 return m_symbol_table
.size ();
4345 /* Get the name of the symbol at IDX in the symbol table. */
4346 const char *symbol_name_at
4347 (offset_type idx
, dwarf2_per_objfile
*per_objfile
) const override
4349 return m_symbol_table
[idx
];
4353 gdb::array_view
<const char *> m_symbol_table
;
4356 /* Convenience function that converts a NULL pointer to a "<null>"
4357 string, to pass to print routines. */
4360 string_or_null (const char *str
)
4362 return str
!= NULL
? str
: "<null>";
4365 /* Check if a lookup_name_info built from
4366 NAME/MATCH_TYPE/COMPLETION_MODE matches the symbols in the mock
4367 index. EXPECTED_LIST is the list of expected matches, in expected
4368 matching order. If no match expected, then an empty list is
4369 specified. Returns true on success. On failure prints a warning
4370 indicating the file:line that failed, and returns false. */
4373 check_match (const char *file
, int line
,
4374 mock_mapped_index
&mock_index
,
4375 const char *name
, symbol_name_match_type match_type
,
4376 bool completion_mode
,
4377 std::initializer_list
<const char *> expected_list
,
4378 dwarf2_per_objfile
*per_objfile
)
4380 lookup_name_info
lookup_name (name
, match_type
, completion_mode
);
4382 bool matched
= true;
4384 auto mismatch
= [&] (const char *expected_str
,
4387 warning (_("%s:%d: match_type=%s, looking-for=\"%s\", "
4388 "expected=\"%s\", got=\"%s\"\n"),
4390 (match_type
== symbol_name_match_type::FULL
4392 name
, string_or_null (expected_str
), string_or_null (got
));
4396 auto expected_it
= expected_list
.begin ();
4397 auto expected_end
= expected_list
.end ();
4399 dw2_expand_symtabs_matching_symbol (mock_index
, lookup_name
,
4401 [&] (offset_type idx
)
4403 const char *matched_name
= mock_index
.symbol_name_at (idx
, per_objfile
);
4404 const char *expected_str
4405 = expected_it
== expected_end
? NULL
: *expected_it
++;
4407 if (expected_str
== NULL
|| strcmp (expected_str
, matched_name
) != 0)
4408 mismatch (expected_str
, matched_name
);
4412 const char *expected_str
4413 = expected_it
== expected_end
? NULL
: *expected_it
++;
4414 if (expected_str
!= NULL
)
4415 mismatch (expected_str
, NULL
);
4420 /* The symbols added to the mock mapped_index for testing (in
4422 static const char *test_symbols
[] = {
4431 "ns2::tmpl<int>::foo2",
4432 "(anonymous namespace)::A::B::C",
4434 /* These are used to check that the increment-last-char in the
4435 matching algorithm for completion doesn't match "t1_fund" when
4436 completing "t1_func". */
4442 /* A UTF-8 name with multi-byte sequences to make sure that
4443 cp-name-parser understands this as a single identifier ("função"
4444 is "function" in PT). */
4447 /* \377 (0xff) is Latin1 'ÿ'. */
4450 /* \377 (0xff) is Latin1 'ÿ'. */
4454 /* A name with all sorts of complications. Starts with "z" to make
4455 it easier for the completion tests below. */
4456 #define Z_SYM_NAME \
4457 "z::std::tuple<(anonymous namespace)::ui*, std::bar<(anonymous namespace)::ui> >" \
4458 "::tuple<(anonymous namespace)::ui*, " \
4459 "std::default_delete<(anonymous namespace)::ui>, void>"
4464 /* Returns true if the mapped_index_base::find_name_component_bounds
4465 method finds EXPECTED_SYMS in INDEX when looking for SEARCH_NAME,
4466 in completion mode. */
4469 check_find_bounds_finds (mapped_index_base
&index
,
4470 const char *search_name
,
4471 gdb::array_view
<const char *> expected_syms
,
4472 dwarf2_per_objfile
*per_objfile
)
4474 lookup_name_info
lookup_name (search_name
,
4475 symbol_name_match_type::FULL
, true);
4477 auto bounds
= index
.find_name_components_bounds (lookup_name
,
4481 size_t distance
= std::distance (bounds
.first
, bounds
.second
);
4482 if (distance
!= expected_syms
.size ())
4485 for (size_t exp_elem
= 0; exp_elem
< distance
; exp_elem
++)
4487 auto nc_elem
= bounds
.first
+ exp_elem
;
4488 const char *qualified
= index
.symbol_name_at (nc_elem
->idx
, per_objfile
);
4489 if (strcmp (qualified
, expected_syms
[exp_elem
]) != 0)
4496 /* Test the lower-level mapped_index::find_name_component_bounds
4500 test_mapped_index_find_name_component_bounds ()
4502 mock_mapped_index
mock_index (test_symbols
);
4504 mock_index
.build_name_components (NULL
/* per_objfile */);
4506 /* Test the lower-level mapped_index::find_name_component_bounds
4507 method in completion mode. */
4509 static const char *expected_syms
[] = {
4514 SELF_CHECK (check_find_bounds_finds
4515 (mock_index
, "t1_func", expected_syms
,
4516 NULL
/* per_objfile */));
4519 /* Check that the increment-last-char in the name matching algorithm
4520 for completion doesn't get confused with Ansi1 'ÿ' / 0xff. */
4522 static const char *expected_syms1
[] = {
4526 SELF_CHECK (check_find_bounds_finds
4527 (mock_index
, "\377", expected_syms1
, NULL
/* per_objfile */));
4529 static const char *expected_syms2
[] = {
4532 SELF_CHECK (check_find_bounds_finds
4533 (mock_index
, "\377\377", expected_syms2
,
4534 NULL
/* per_objfile */));
4538 /* Test dw2_expand_symtabs_matching_symbol. */
4541 test_dw2_expand_symtabs_matching_symbol ()
4543 mock_mapped_index
mock_index (test_symbols
);
4545 /* We let all tests run until the end even if some fails, for debug
4547 bool any_mismatch
= false;
4549 /* Create the expected symbols list (an initializer_list). Needed
4550 because lists have commas, and we need to pass them to CHECK,
4551 which is a macro. */
4552 #define EXPECT(...) { __VA_ARGS__ }
4554 /* Wrapper for check_match that passes down the current
4555 __FILE__/__LINE__. */
4556 #define CHECK_MATCH(NAME, MATCH_TYPE, COMPLETION_MODE, EXPECTED_LIST) \
4557 any_mismatch |= !check_match (__FILE__, __LINE__, \
4559 NAME, MATCH_TYPE, COMPLETION_MODE, \
4560 EXPECTED_LIST, NULL)
4562 /* Identity checks. */
4563 for (const char *sym
: test_symbols
)
4565 /* Should be able to match all existing symbols. */
4566 CHECK_MATCH (sym
, symbol_name_match_type::FULL
, false,
4569 /* Should be able to match all existing symbols with
4571 std::string with_params
= std::string (sym
) + "(int)";
4572 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
4575 /* Should be able to match all existing symbols with
4576 parameters and qualifiers. */
4577 with_params
= std::string (sym
) + " ( int ) const";
4578 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
4581 /* This should really find sym, but cp-name-parser.y doesn't
4582 know about lvalue/rvalue qualifiers yet. */
4583 with_params
= std::string (sym
) + " ( int ) &&";
4584 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
4588 /* Check that the name matching algorithm for completion doesn't get
4589 confused with Latin1 'ÿ' / 0xff. */
4591 static const char str
[] = "\377";
4592 CHECK_MATCH (str
, symbol_name_match_type::FULL
, true,
4593 EXPECT ("\377", "\377\377123"));
4596 /* Check that the increment-last-char in the matching algorithm for
4597 completion doesn't match "t1_fund" when completing "t1_func". */
4599 static const char str
[] = "t1_func";
4600 CHECK_MATCH (str
, symbol_name_match_type::FULL
, true,
4601 EXPECT ("t1_func", "t1_func1"));
4604 /* Check that completion mode works at each prefix of the expected
4607 static const char str
[] = "function(int)";
4608 size_t len
= strlen (str
);
4611 for (size_t i
= 1; i
< len
; i
++)
4613 lookup
.assign (str
, i
);
4614 CHECK_MATCH (lookup
.c_str (), symbol_name_match_type::FULL
, true,
4615 EXPECT ("function"));
4619 /* While "w" is a prefix of both components, the match function
4620 should still only be called once. */
4622 CHECK_MATCH ("w", symbol_name_match_type::FULL
, true,
4624 CHECK_MATCH ("w", symbol_name_match_type::WILD
, true,
4628 /* Same, with a "complicated" symbol. */
4630 static const char str
[] = Z_SYM_NAME
;
4631 size_t len
= strlen (str
);
4634 for (size_t i
= 1; i
< len
; i
++)
4636 lookup
.assign (str
, i
);
4637 CHECK_MATCH (lookup
.c_str (), symbol_name_match_type::FULL
, true,
4638 EXPECT (Z_SYM_NAME
));
4642 /* In FULL mode, an incomplete symbol doesn't match. */
4644 CHECK_MATCH ("std::zfunction(int", symbol_name_match_type::FULL
, false,
4648 /* A complete symbol with parameters matches any overload, since the
4649 index has no overload info. */
4651 CHECK_MATCH ("std::zfunction(int)", symbol_name_match_type::FULL
, true,
4652 EXPECT ("std::zfunction", "std::zfunction2"));
4653 CHECK_MATCH ("zfunction(int)", symbol_name_match_type::WILD
, true,
4654 EXPECT ("std::zfunction", "std::zfunction2"));
4655 CHECK_MATCH ("zfunc", symbol_name_match_type::WILD
, true,
4656 EXPECT ("std::zfunction", "std::zfunction2"));
4659 /* Check that whitespace is ignored appropriately. A symbol with a
4660 template argument list. */
4662 static const char expected
[] = "ns::foo<int>";
4663 CHECK_MATCH ("ns :: foo < int > ", symbol_name_match_type::FULL
, false,
4665 CHECK_MATCH ("foo < int > ", symbol_name_match_type::WILD
, false,
4669 /* Check that whitespace is ignored appropriately. A symbol with a
4670 template argument list that includes a pointer. */
4672 static const char expected
[] = "ns::foo<char*>";
4673 /* Try both completion and non-completion modes. */
4674 static const bool completion_mode
[2] = {false, true};
4675 for (size_t i
= 0; i
< 2; i
++)
4677 CHECK_MATCH ("ns :: foo < char * >", symbol_name_match_type::FULL
,
4678 completion_mode
[i
], EXPECT (expected
));
4679 CHECK_MATCH ("foo < char * >", symbol_name_match_type::WILD
,
4680 completion_mode
[i
], EXPECT (expected
));
4682 CHECK_MATCH ("ns :: foo < char * > (int)", symbol_name_match_type::FULL
,
4683 completion_mode
[i
], EXPECT (expected
));
4684 CHECK_MATCH ("foo < char * > (int)", symbol_name_match_type::WILD
,
4685 completion_mode
[i
], EXPECT (expected
));
4690 /* Check method qualifiers are ignored. */
4691 static const char expected
[] = "ns::foo<char*>";
4692 CHECK_MATCH ("ns :: foo < char * > ( int ) const",
4693 symbol_name_match_type::FULL
, true, EXPECT (expected
));
4694 CHECK_MATCH ("ns :: foo < char * > ( int ) &&",
4695 symbol_name_match_type::FULL
, true, EXPECT (expected
));
4696 CHECK_MATCH ("foo < char * > ( int ) const",
4697 symbol_name_match_type::WILD
, true, EXPECT (expected
));
4698 CHECK_MATCH ("foo < char * > ( int ) &&",
4699 symbol_name_match_type::WILD
, true, EXPECT (expected
));
4702 /* Test lookup names that don't match anything. */
4704 CHECK_MATCH ("bar2", symbol_name_match_type::WILD
, false,
4707 CHECK_MATCH ("doesntexist", symbol_name_match_type::FULL
, false,
4711 /* Some wild matching tests, exercising "(anonymous namespace)",
4712 which should not be confused with a parameter list. */
4714 static const char *syms
[] = {
4718 "A :: B :: C ( int )",
4723 for (const char *s
: syms
)
4725 CHECK_MATCH (s
, symbol_name_match_type::WILD
, false,
4726 EXPECT ("(anonymous namespace)::A::B::C"));
4731 static const char expected
[] = "ns2::tmpl<int>::foo2";
4732 CHECK_MATCH ("tmp", symbol_name_match_type::WILD
, true,
4734 CHECK_MATCH ("tmpl<", symbol_name_match_type::WILD
, true,
4738 SELF_CHECK (!any_mismatch
);
4747 test_mapped_index_find_name_component_bounds ();
4748 test_dw2_expand_symtabs_matching_symbol ();
4751 }} // namespace selftests::dw2_expand_symtabs_matching
4753 #endif /* GDB_SELF_TEST */
4755 /* If FILE_MATCHER is NULL or if PER_CU has
4756 dwarf2_per_cu_quick_data::MARK set (see
4757 dw_expand_symtabs_matching_file_matcher), expand the CU and call
4758 EXPANSION_NOTIFY on it. */
4761 dw2_expand_symtabs_matching_one
4762 (dwarf2_per_cu_data
*per_cu
,
4763 dwarf2_per_objfile
*per_objfile
,
4764 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
4765 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
)
4767 if (file_matcher
== NULL
|| per_cu
->v
.quick
->mark
)
4769 bool symtab_was_null
= !per_objfile
->symtab_set_p (per_cu
);
4771 compunit_symtab
*symtab
4772 = dw2_instantiate_symtab (per_cu
, per_objfile
, false);
4773 gdb_assert (symtab
!= nullptr);
4775 if (expansion_notify
!= NULL
&& symtab_was_null
)
4776 expansion_notify (symtab
);
4780 /* Helper for dw2_expand_matching symtabs. Called on each symbol
4781 matched, to expand corresponding CUs that were marked. IDX is the
4782 index of the symbol name that matched. */
4785 dw2_expand_marked_cus
4786 (dwarf2_per_objfile
*per_objfile
, offset_type idx
,
4787 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
4788 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
4791 offset_type
*vec
, vec_len
, vec_idx
;
4792 bool global_seen
= false;
4793 mapped_index
&index
= *per_objfile
->per_bfd
->index_table
;
4795 vec
= (offset_type
*) (index
.constant_pool
4796 + MAYBE_SWAP (index
.symbol_table
[idx
].vec
));
4797 vec_len
= MAYBE_SWAP (vec
[0]);
4798 for (vec_idx
= 0; vec_idx
< vec_len
; ++vec_idx
)
4800 offset_type cu_index_and_attrs
= MAYBE_SWAP (vec
[vec_idx
+ 1]);
4801 /* This value is only valid for index versions >= 7. */
4802 int is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs
);
4803 gdb_index_symbol_kind symbol_kind
=
4804 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
4805 int cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
4806 /* Only check the symbol attributes if they're present.
4807 Indices prior to version 7 don't record them,
4808 and indices >= 7 may elide them for certain symbols
4809 (gold does this). */
4812 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_NONE
);
4814 /* Work around gold/15646. */
4817 && symbol_kind
== GDB_INDEX_SYMBOL_KIND_TYPE
)
4825 /* Only check the symbol's kind if it has one. */
4830 case VARIABLES_DOMAIN
:
4831 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
)
4834 case FUNCTIONS_DOMAIN
:
4835 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
)
4839 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
4842 case MODULES_DOMAIN
:
4843 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_OTHER
)
4851 /* Don't crash on bad data. */
4852 if (cu_index
>= (per_objfile
->per_bfd
->all_comp_units
.size ()
4853 + per_objfile
->per_bfd
->all_type_units
.size ()))
4855 complaint (_(".gdb_index entry has bad CU index"
4856 " [in module %s]"), objfile_name (per_objfile
->objfile
));
4860 dwarf2_per_cu_data
*per_cu
= per_objfile
->per_bfd
->get_cutu (cu_index
);
4861 dw2_expand_symtabs_matching_one (per_cu
, per_objfile
, file_matcher
,
4866 /* If FILE_MATCHER is non-NULL, set all the
4867 dwarf2_per_cu_quick_data::MARK of the current DWARF2_PER_OBJFILE
4868 that match FILE_MATCHER. */
4871 dw_expand_symtabs_matching_file_matcher
4872 (dwarf2_per_objfile
*per_objfile
,
4873 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
)
4875 if (file_matcher
== NULL
)
4878 htab_up
visited_found (htab_create_alloc (10, htab_hash_pointer
,
4880 NULL
, xcalloc
, xfree
));
4881 htab_up
visited_not_found (htab_create_alloc (10, htab_hash_pointer
,
4883 NULL
, xcalloc
, xfree
));
4885 /* The rule is CUs specify all the files, including those used by
4886 any TU, so there's no need to scan TUs here. */
4888 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
4892 per_cu
->v
.quick
->mark
= 0;
4894 /* We only need to look at symtabs not already expanded. */
4895 if (per_objfile
->symtab_set_p (per_cu
))
4898 quick_file_names
*file_data
= dw2_get_file_names (per_cu
, per_objfile
);
4899 if (file_data
== NULL
)
4902 if (htab_find (visited_not_found
.get (), file_data
) != NULL
)
4904 else if (htab_find (visited_found
.get (), file_data
) != NULL
)
4906 per_cu
->v
.quick
->mark
= 1;
4910 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
4912 const char *this_real_name
;
4914 if (file_matcher (file_data
->file_names
[j
], false))
4916 per_cu
->v
.quick
->mark
= 1;
4920 /* Before we invoke realpath, which can get expensive when many
4921 files are involved, do a quick comparison of the basenames. */
4922 if (!basenames_may_differ
4923 && !file_matcher (lbasename (file_data
->file_names
[j
]),
4927 this_real_name
= dw2_get_real_path (per_objfile
, file_data
, j
);
4928 if (file_matcher (this_real_name
, false))
4930 per_cu
->v
.quick
->mark
= 1;
4935 void **slot
= htab_find_slot (per_cu
->v
.quick
->mark
4936 ? visited_found
.get ()
4937 : visited_not_found
.get (),
4944 dw2_expand_symtabs_matching
4945 (struct objfile
*objfile
,
4946 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
4947 const lookup_name_info
*lookup_name
,
4948 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
4949 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
4950 enum search_domain kind
)
4952 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
4954 /* index_table is NULL if OBJF_READNOW. */
4955 if (!per_objfile
->per_bfd
->index_table
)
4958 dw_expand_symtabs_matching_file_matcher (per_objfile
, file_matcher
);
4960 if (symbol_matcher
== NULL
&& lookup_name
== NULL
)
4962 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
4966 dw2_expand_symtabs_matching_one (per_cu
, per_objfile
,
4967 file_matcher
, expansion_notify
);
4972 mapped_index
&index
= *per_objfile
->per_bfd
->index_table
;
4974 dw2_expand_symtabs_matching_symbol (index
, *lookup_name
,
4976 kind
, [&] (offset_type idx
)
4978 dw2_expand_marked_cus (per_objfile
, idx
, file_matcher
, expansion_notify
,
4984 /* A helper for dw2_find_pc_sect_compunit_symtab which finds the most specific
4987 static struct compunit_symtab
*
4988 recursively_find_pc_sect_compunit_symtab (struct compunit_symtab
*cust
,
4993 if (COMPUNIT_BLOCKVECTOR (cust
) != NULL
4994 && blockvector_contains_pc (COMPUNIT_BLOCKVECTOR (cust
), pc
))
4997 if (cust
->includes
== NULL
)
5000 for (i
= 0; cust
->includes
[i
]; ++i
)
5002 struct compunit_symtab
*s
= cust
->includes
[i
];
5004 s
= recursively_find_pc_sect_compunit_symtab (s
, pc
);
5012 static struct compunit_symtab
*
5013 dw2_find_pc_sect_compunit_symtab (struct objfile
*objfile
,
5014 struct bound_minimal_symbol msymbol
,
5016 struct obj_section
*section
,
5019 struct dwarf2_per_cu_data
*data
;
5020 struct compunit_symtab
*result
;
5022 if (!objfile
->partial_symtabs
->psymtabs_addrmap
)
5025 CORE_ADDR baseaddr
= objfile
->text_section_offset ();
5026 data
= (struct dwarf2_per_cu_data
*) addrmap_find
5027 (objfile
->partial_symtabs
->psymtabs_addrmap
, pc
- baseaddr
);
5031 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
5032 if (warn_if_readin
&& per_objfile
->symtab_set_p (data
))
5033 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
5034 paddress (objfile
->arch (), pc
));
5036 result
= recursively_find_pc_sect_compunit_symtab
5037 (dw2_instantiate_symtab (data
, per_objfile
, false), pc
);
5039 gdb_assert (result
!= NULL
);
5044 dw2_map_symbol_filenames (struct objfile
*objfile
, symbol_filename_ftype
*fun
,
5045 void *data
, int need_fullname
)
5047 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
5049 if (!per_objfile
->per_bfd
->filenames_cache
)
5051 per_objfile
->per_bfd
->filenames_cache
.emplace ();
5053 htab_up
visited (htab_create_alloc (10,
5054 htab_hash_pointer
, htab_eq_pointer
,
5055 NULL
, xcalloc
, xfree
));
5057 /* The rule is CUs specify all the files, including those used
5058 by any TU, so there's no need to scan TUs here. We can
5059 ignore file names coming from already-expanded CUs. */
5061 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
5063 if (per_objfile
->symtab_set_p (per_cu
))
5065 void **slot
= htab_find_slot (visited
.get (),
5066 per_cu
->v
.quick
->file_names
,
5069 *slot
= per_cu
->v
.quick
->file_names
;
5073 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
5075 /* We only need to look at symtabs not already expanded. */
5076 if (per_objfile
->symtab_set_p (per_cu
))
5079 quick_file_names
*file_data
5080 = dw2_get_file_names (per_cu
, per_objfile
);
5081 if (file_data
== NULL
)
5084 void **slot
= htab_find_slot (visited
.get (), file_data
, INSERT
);
5087 /* Already visited. */
5092 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
5094 const char *filename
= file_data
->file_names
[j
];
5095 per_objfile
->per_bfd
->filenames_cache
->seen (filename
);
5100 per_objfile
->per_bfd
->filenames_cache
->traverse ([&] (const char *filename
)
5102 gdb::unique_xmalloc_ptr
<char> this_real_name
;
5105 this_real_name
= gdb_realpath (filename
);
5106 (*fun
) (filename
, this_real_name
.get (), data
);
5111 dw2_has_symbols (struct objfile
*objfile
)
5116 const struct quick_symbol_functions dwarf2_gdb_index_functions
=
5119 dw2_find_last_source_symtab
,
5120 dw2_forget_cached_source_info
,
5121 dw2_map_symtabs_matching_filename
,
5126 dw2_expand_symtabs_for_function
,
5127 dw2_expand_all_symtabs
,
5128 dw2_expand_symtabs_with_fullname
,
5129 dw2_map_matching_symbols
,
5130 dw2_expand_symtabs_matching
,
5131 dw2_find_pc_sect_compunit_symtab
,
5133 dw2_map_symbol_filenames
5136 /* DWARF-5 debug_names reader. */
5138 /* DWARF-5 augmentation string for GDB's DW_IDX_GNU_* extension. */
5139 static const gdb_byte dwarf5_augmentation
[] = { 'G', 'D', 'B', 0 };
5141 /* A helper function that reads the .debug_names section in SECTION
5142 and fills in MAP. FILENAME is the name of the file containing the
5143 section; it is used for error reporting.
5145 Returns true if all went well, false otherwise. */
5148 read_debug_names_from_section (struct objfile
*objfile
,
5149 const char *filename
,
5150 struct dwarf2_section_info
*section
,
5151 mapped_debug_names
&map
)
5153 if (section
->empty ())
5156 /* Older elfutils strip versions could keep the section in the main
5157 executable while splitting it for the separate debug info file. */
5158 if ((section
->get_flags () & SEC_HAS_CONTENTS
) == 0)
5161 section
->read (objfile
);
5163 map
.dwarf5_byte_order
= gdbarch_byte_order (objfile
->arch ());
5165 const gdb_byte
*addr
= section
->buffer
;
5167 bfd
*const abfd
= section
->get_bfd_owner ();
5169 unsigned int bytes_read
;
5170 LONGEST length
= read_initial_length (abfd
, addr
, &bytes_read
);
5173 map
.dwarf5_is_dwarf64
= bytes_read
!= 4;
5174 map
.offset_size
= map
.dwarf5_is_dwarf64
? 8 : 4;
5175 if (bytes_read
+ length
!= section
->size
)
5177 /* There may be multiple per-CU indices. */
5178 warning (_("Section .debug_names in %s length %s does not match "
5179 "section length %s, ignoring .debug_names."),
5180 filename
, plongest (bytes_read
+ length
),
5181 pulongest (section
->size
));
5185 /* The version number. */
5186 uint16_t version
= read_2_bytes (abfd
, addr
);
5190 warning (_("Section .debug_names in %s has unsupported version %d, "
5191 "ignoring .debug_names."),
5197 uint16_t padding
= read_2_bytes (abfd
, addr
);
5201 warning (_("Section .debug_names in %s has unsupported padding %d, "
5202 "ignoring .debug_names."),
5207 /* comp_unit_count - The number of CUs in the CU list. */
5208 map
.cu_count
= read_4_bytes (abfd
, addr
);
5211 /* local_type_unit_count - The number of TUs in the local TU
5213 map
.tu_count
= read_4_bytes (abfd
, addr
);
5216 /* foreign_type_unit_count - The number of TUs in the foreign TU
5218 uint32_t foreign_tu_count
= read_4_bytes (abfd
, addr
);
5220 if (foreign_tu_count
!= 0)
5222 warning (_("Section .debug_names in %s has unsupported %lu foreign TUs, "
5223 "ignoring .debug_names."),
5224 filename
, static_cast<unsigned long> (foreign_tu_count
));
5228 /* bucket_count - The number of hash buckets in the hash lookup
5230 map
.bucket_count
= read_4_bytes (abfd
, addr
);
5233 /* name_count - The number of unique names in the index. */
5234 map
.name_count
= read_4_bytes (abfd
, addr
);
5237 /* abbrev_table_size - The size in bytes of the abbreviations
5239 uint32_t abbrev_table_size
= read_4_bytes (abfd
, addr
);
5242 /* augmentation_string_size - The size in bytes of the augmentation
5243 string. This value is rounded up to a multiple of 4. */
5244 uint32_t augmentation_string_size
= read_4_bytes (abfd
, addr
);
5246 map
.augmentation_is_gdb
= ((augmentation_string_size
5247 == sizeof (dwarf5_augmentation
))
5248 && memcmp (addr
, dwarf5_augmentation
,
5249 sizeof (dwarf5_augmentation
)) == 0);
5250 augmentation_string_size
+= (-augmentation_string_size
) & 3;
5251 addr
+= augmentation_string_size
;
5254 map
.cu_table_reordered
= addr
;
5255 addr
+= map
.cu_count
* map
.offset_size
;
5257 /* List of Local TUs */
5258 map
.tu_table_reordered
= addr
;
5259 addr
+= map
.tu_count
* map
.offset_size
;
5261 /* Hash Lookup Table */
5262 map
.bucket_table_reordered
= reinterpret_cast<const uint32_t *> (addr
);
5263 addr
+= map
.bucket_count
* 4;
5264 map
.hash_table_reordered
= reinterpret_cast<const uint32_t *> (addr
);
5265 addr
+= map
.name_count
* 4;
5268 map
.name_table_string_offs_reordered
= addr
;
5269 addr
+= map
.name_count
* map
.offset_size
;
5270 map
.name_table_entry_offs_reordered
= addr
;
5271 addr
+= map
.name_count
* map
.offset_size
;
5273 const gdb_byte
*abbrev_table_start
= addr
;
5276 const ULONGEST index_num
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
5281 const auto insertpair
5282 = map
.abbrev_map
.emplace (index_num
, mapped_debug_names::index_val ());
5283 if (!insertpair
.second
)
5285 warning (_("Section .debug_names in %s has duplicate index %s, "
5286 "ignoring .debug_names."),
5287 filename
, pulongest (index_num
));
5290 mapped_debug_names::index_val
&indexval
= insertpair
.first
->second
;
5291 indexval
.dwarf_tag
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
5296 mapped_debug_names::index_val::attr attr
;
5297 attr
.dw_idx
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
5299 attr
.form
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
5301 if (attr
.form
== DW_FORM_implicit_const
)
5303 attr
.implicit_const
= read_signed_leb128 (abfd
, addr
,
5307 if (attr
.dw_idx
== 0 && attr
.form
== 0)
5309 indexval
.attr_vec
.push_back (std::move (attr
));
5312 if (addr
!= abbrev_table_start
+ abbrev_table_size
)
5314 warning (_("Section .debug_names in %s has abbreviation_table "
5315 "of size %s vs. written as %u, ignoring .debug_names."),
5316 filename
, plongest (addr
- abbrev_table_start
),
5320 map
.entry_pool
= addr
;
5325 /* A helper for create_cus_from_debug_names that handles the MAP's CU
5329 create_cus_from_debug_names_list (dwarf2_per_bfd
*per_bfd
,
5330 const mapped_debug_names
&map
,
5331 dwarf2_section_info
§ion
,
5334 if (!map
.augmentation_is_gdb
)
5336 for (uint32_t i
= 0; i
< map
.cu_count
; ++i
)
5338 sect_offset sect_off
5339 = (sect_offset
) (extract_unsigned_integer
5340 (map
.cu_table_reordered
+ i
* map
.offset_size
,
5342 map
.dwarf5_byte_order
));
5343 /* We don't know the length of the CU, because the CU list in a
5344 .debug_names index can be incomplete, so we can't use the start of
5345 the next CU as end of this CU. We create the CUs here with length 0,
5346 and in cutu_reader::cutu_reader we'll fill in the actual length. */
5347 dwarf2_per_cu_data
*per_cu
5348 = create_cu_from_index_list (per_bfd
, §ion
, is_dwz
, sect_off
, 0);
5349 per_bfd
->all_comp_units
.push_back (per_cu
);
5353 sect_offset sect_off_prev
;
5354 for (uint32_t i
= 0; i
<= map
.cu_count
; ++i
)
5356 sect_offset sect_off_next
;
5357 if (i
< map
.cu_count
)
5360 = (sect_offset
) (extract_unsigned_integer
5361 (map
.cu_table_reordered
+ i
* map
.offset_size
,
5363 map
.dwarf5_byte_order
));
5366 sect_off_next
= (sect_offset
) section
.size
;
5369 const ULONGEST length
= sect_off_next
- sect_off_prev
;
5370 dwarf2_per_cu_data
*per_cu
5371 = create_cu_from_index_list (per_bfd
, §ion
, is_dwz
,
5372 sect_off_prev
, length
);
5373 per_bfd
->all_comp_units
.push_back (per_cu
);
5375 sect_off_prev
= sect_off_next
;
5379 /* Read the CU list from the mapped index, and use it to create all
5380 the CU objects for this dwarf2_per_objfile. */
5383 create_cus_from_debug_names (dwarf2_per_bfd
*per_bfd
,
5384 const mapped_debug_names
&map
,
5385 const mapped_debug_names
&dwz_map
)
5387 gdb_assert (per_bfd
->all_comp_units
.empty ());
5388 per_bfd
->all_comp_units
.reserve (map
.cu_count
+ dwz_map
.cu_count
);
5390 create_cus_from_debug_names_list (per_bfd
, map
, per_bfd
->info
,
5391 false /* is_dwz */);
5393 if (dwz_map
.cu_count
== 0)
5396 dwz_file
*dwz
= dwarf2_get_dwz_file (per_bfd
);
5397 create_cus_from_debug_names_list (per_bfd
, dwz_map
, dwz
->info
,
5401 /* Read .debug_names. If everything went ok, initialize the "quick"
5402 elements of all the CUs and return true. Otherwise, return false. */
5405 dwarf2_read_debug_names (dwarf2_per_objfile
*per_objfile
)
5407 std::unique_ptr
<mapped_debug_names
> map (new mapped_debug_names
);
5408 mapped_debug_names dwz_map
;
5409 struct objfile
*objfile
= per_objfile
->objfile
;
5410 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
5412 if (!read_debug_names_from_section (objfile
, objfile_name (objfile
),
5413 &per_objfile
->per_bfd
->debug_names
, *map
))
5416 /* Don't use the index if it's empty. */
5417 if (map
->name_count
== 0)
5420 /* If there is a .dwz file, read it so we can get its CU list as
5422 dwz_file
*dwz
= dwarf2_get_dwz_file (per_bfd
);
5425 if (!read_debug_names_from_section (objfile
,
5426 bfd_get_filename (dwz
->dwz_bfd
.get ()),
5427 &dwz
->debug_names
, dwz_map
))
5429 warning (_("could not read '.debug_names' section from %s; skipping"),
5430 bfd_get_filename (dwz
->dwz_bfd
.get ()));
5435 create_cus_from_debug_names (per_bfd
, *map
, dwz_map
);
5437 if (map
->tu_count
!= 0)
5439 /* We can only handle a single .debug_types when we have an
5441 if (per_bfd
->types
.size () != 1)
5444 dwarf2_section_info
*section
= &per_bfd
->types
[0];
5446 create_signatured_type_table_from_debug_names
5447 (per_objfile
, *map
, section
, &per_bfd
->abbrev
);
5450 create_addrmap_from_aranges (per_objfile
, &per_bfd
->debug_aranges
);
5452 per_bfd
->debug_names_table
= std::move (map
);
5453 per_bfd
->using_index
= 1;
5454 per_bfd
->quick_file_names_table
=
5455 create_quick_file_names_table (per_objfile
->per_bfd
->all_comp_units
.size ());
5457 /* Save partial symtabs in the per_bfd object, for the benefit of subsequent
5458 objfiles using the same BFD. */
5459 gdb_assert (per_bfd
->partial_symtabs
== nullptr);
5460 per_bfd
->partial_symtabs
= objfile
->partial_symtabs
;
5465 /* Type used to manage iterating over all CUs looking for a symbol for
5468 class dw2_debug_names_iterator
5471 dw2_debug_names_iterator (const mapped_debug_names
&map
,
5472 gdb::optional
<block_enum
> block_index
,
5474 const char *name
, dwarf2_per_objfile
*per_objfile
)
5475 : m_map (map
), m_block_index (block_index
), m_domain (domain
),
5476 m_addr (find_vec_in_debug_names (map
, name
, per_objfile
)),
5477 m_per_objfile (per_objfile
)
5480 dw2_debug_names_iterator (const mapped_debug_names
&map
,
5481 search_domain search
, uint32_t namei
, dwarf2_per_objfile
*per_objfile
)
5484 m_addr (find_vec_in_debug_names (map
, namei
, per_objfile
)),
5485 m_per_objfile (per_objfile
)
5488 dw2_debug_names_iterator (const mapped_debug_names
&map
,
5489 block_enum block_index
, domain_enum domain
,
5490 uint32_t namei
, dwarf2_per_objfile
*per_objfile
)
5491 : m_map (map
), m_block_index (block_index
), m_domain (domain
),
5492 m_addr (find_vec_in_debug_names (map
, namei
, per_objfile
)),
5493 m_per_objfile (per_objfile
)
5496 /* Return the next matching CU or NULL if there are no more. */
5497 dwarf2_per_cu_data
*next ();
5500 static const gdb_byte
*find_vec_in_debug_names (const mapped_debug_names
&map
,
5502 dwarf2_per_objfile
*per_objfile
);
5503 static const gdb_byte
*find_vec_in_debug_names (const mapped_debug_names
&map
,
5505 dwarf2_per_objfile
*per_objfile
);
5507 /* The internalized form of .debug_names. */
5508 const mapped_debug_names
&m_map
;
5510 /* If set, only look for symbols that match that block. Valid values are
5511 GLOBAL_BLOCK and STATIC_BLOCK. */
5512 const gdb::optional
<block_enum
> m_block_index
;
5514 /* The kind of symbol we're looking for. */
5515 const domain_enum m_domain
= UNDEF_DOMAIN
;
5516 const search_domain m_search
= ALL_DOMAIN
;
5518 /* The list of CUs from the index entry of the symbol, or NULL if
5520 const gdb_byte
*m_addr
;
5522 dwarf2_per_objfile
*m_per_objfile
;
5526 mapped_debug_names::namei_to_name
5527 (uint32_t namei
, dwarf2_per_objfile
*per_objfile
) const
5529 const ULONGEST namei_string_offs
5530 = extract_unsigned_integer ((name_table_string_offs_reordered
5531 + namei
* offset_size
),
5534 return read_indirect_string_at_offset (per_objfile
, namei_string_offs
);
5537 /* Find a slot in .debug_names for the object named NAME. If NAME is
5538 found, return pointer to its pool data. If NAME cannot be found,
5542 dw2_debug_names_iterator::find_vec_in_debug_names
5543 (const mapped_debug_names
&map
, const char *name
,
5544 dwarf2_per_objfile
*per_objfile
)
5546 int (*cmp
) (const char *, const char *);
5548 gdb::unique_xmalloc_ptr
<char> without_params
;
5549 if (current_language
->la_language
== language_cplus
5550 || current_language
->la_language
== language_fortran
5551 || current_language
->la_language
== language_d
)
5553 /* NAME is already canonical. Drop any qualifiers as
5554 .debug_names does not contain any. */
5556 if (strchr (name
, '(') != NULL
)
5558 without_params
= cp_remove_params (name
);
5559 if (without_params
!= NULL
)
5560 name
= without_params
.get ();
5564 cmp
= (case_sensitivity
== case_sensitive_on
? strcmp
: strcasecmp
);
5566 const uint32_t full_hash
= dwarf5_djb_hash (name
);
5568 = extract_unsigned_integer (reinterpret_cast<const gdb_byte
*>
5569 (map
.bucket_table_reordered
5570 + (full_hash
% map
.bucket_count
)), 4,
5571 map
.dwarf5_byte_order
);
5575 if (namei
>= map
.name_count
)
5577 complaint (_("Wrong .debug_names with name index %u but name_count=%u "
5579 namei
, map
.name_count
,
5580 objfile_name (per_objfile
->objfile
));
5586 const uint32_t namei_full_hash
5587 = extract_unsigned_integer (reinterpret_cast<const gdb_byte
*>
5588 (map
.hash_table_reordered
+ namei
), 4,
5589 map
.dwarf5_byte_order
);
5590 if (full_hash
% map
.bucket_count
!= namei_full_hash
% map
.bucket_count
)
5593 if (full_hash
== namei_full_hash
)
5595 const char *const namei_string
= map
.namei_to_name (namei
, per_objfile
);
5597 #if 0 /* An expensive sanity check. */
5598 if (namei_full_hash
!= dwarf5_djb_hash (namei_string
))
5600 complaint (_("Wrong .debug_names hash for string at index %u "
5602 namei
, objfile_name (dwarf2_per_objfile
->objfile
));
5607 if (cmp (namei_string
, name
) == 0)
5609 const ULONGEST namei_entry_offs
5610 = extract_unsigned_integer ((map
.name_table_entry_offs_reordered
5611 + namei
* map
.offset_size
),
5612 map
.offset_size
, map
.dwarf5_byte_order
);
5613 return map
.entry_pool
+ namei_entry_offs
;
5618 if (namei
>= map
.name_count
)
5624 dw2_debug_names_iterator::find_vec_in_debug_names
5625 (const mapped_debug_names
&map
, uint32_t namei
, dwarf2_per_objfile
*per_objfile
)
5627 if (namei
>= map
.name_count
)
5629 complaint (_("Wrong .debug_names with name index %u but name_count=%u "
5631 namei
, map
.name_count
,
5632 objfile_name (per_objfile
->objfile
));
5636 const ULONGEST namei_entry_offs
5637 = extract_unsigned_integer ((map
.name_table_entry_offs_reordered
5638 + namei
* map
.offset_size
),
5639 map
.offset_size
, map
.dwarf5_byte_order
);
5640 return map
.entry_pool
+ namei_entry_offs
;
5643 /* See dw2_debug_names_iterator. */
5645 dwarf2_per_cu_data
*
5646 dw2_debug_names_iterator::next ()
5651 dwarf2_per_bfd
*per_bfd
= m_per_objfile
->per_bfd
;
5652 struct objfile
*objfile
= m_per_objfile
->objfile
;
5653 bfd
*const abfd
= objfile
->obfd
;
5657 unsigned int bytes_read
;
5658 const ULONGEST abbrev
= read_unsigned_leb128 (abfd
, m_addr
, &bytes_read
);
5659 m_addr
+= bytes_read
;
5663 const auto indexval_it
= m_map
.abbrev_map
.find (abbrev
);
5664 if (indexval_it
== m_map
.abbrev_map
.cend ())
5666 complaint (_("Wrong .debug_names undefined abbrev code %s "
5668 pulongest (abbrev
), objfile_name (objfile
));
5671 const mapped_debug_names::index_val
&indexval
= indexval_it
->second
;
5672 enum class symbol_linkage
{
5676 } symbol_linkage_
= symbol_linkage::unknown
;
5677 dwarf2_per_cu_data
*per_cu
= NULL
;
5678 for (const mapped_debug_names::index_val::attr
&attr
: indexval
.attr_vec
)
5683 case DW_FORM_implicit_const
:
5684 ull
= attr
.implicit_const
;
5686 case DW_FORM_flag_present
:
5690 ull
= read_unsigned_leb128 (abfd
, m_addr
, &bytes_read
);
5691 m_addr
+= bytes_read
;
5694 ull
= read_4_bytes (abfd
, m_addr
);
5698 ull
= read_8_bytes (abfd
, m_addr
);
5701 case DW_FORM_ref_sig8
:
5702 ull
= read_8_bytes (abfd
, m_addr
);
5706 complaint (_("Unsupported .debug_names form %s [in module %s]"),
5707 dwarf_form_name (attr
.form
),
5708 objfile_name (objfile
));
5711 switch (attr
.dw_idx
)
5713 case DW_IDX_compile_unit
:
5714 /* Don't crash on bad data. */
5715 if (ull
>= m_per_objfile
->per_bfd
->all_comp_units
.size ())
5717 complaint (_(".debug_names entry has bad CU index %s"
5720 objfile_name (objfile
));
5723 per_cu
= per_bfd
->get_cutu (ull
);
5725 case DW_IDX_type_unit
:
5726 /* Don't crash on bad data. */
5727 if (ull
>= per_bfd
->all_type_units
.size ())
5729 complaint (_(".debug_names entry has bad TU index %s"
5732 objfile_name (objfile
));
5735 per_cu
= &per_bfd
->get_tu (ull
)->per_cu
;
5737 case DW_IDX_die_offset
:
5738 /* In a per-CU index (as opposed to a per-module index), index
5739 entries without CU attribute implicitly refer to the single CU. */
5741 per_cu
= per_bfd
->get_cu (0);
5743 case DW_IDX_GNU_internal
:
5744 if (!m_map
.augmentation_is_gdb
)
5746 symbol_linkage_
= symbol_linkage::static_
;
5748 case DW_IDX_GNU_external
:
5749 if (!m_map
.augmentation_is_gdb
)
5751 symbol_linkage_
= symbol_linkage::extern_
;
5756 /* Skip if already read in. */
5757 if (m_per_objfile
->symtab_set_p (per_cu
))
5760 /* Check static vs global. */
5761 if (symbol_linkage_
!= symbol_linkage::unknown
&& m_block_index
.has_value ())
5763 const bool want_static
= *m_block_index
== STATIC_BLOCK
;
5764 const bool symbol_is_static
=
5765 symbol_linkage_
== symbol_linkage::static_
;
5766 if (want_static
!= symbol_is_static
)
5770 /* Match dw2_symtab_iter_next, symbol_kind
5771 and debug_names::psymbol_tag. */
5775 switch (indexval
.dwarf_tag
)
5777 case DW_TAG_variable
:
5778 case DW_TAG_subprogram
:
5779 /* Some types are also in VAR_DOMAIN. */
5780 case DW_TAG_typedef
:
5781 case DW_TAG_structure_type
:
5788 switch (indexval
.dwarf_tag
)
5790 case DW_TAG_typedef
:
5791 case DW_TAG_structure_type
:
5798 switch (indexval
.dwarf_tag
)
5801 case DW_TAG_variable
:
5808 switch (indexval
.dwarf_tag
)
5820 /* Match dw2_expand_symtabs_matching, symbol_kind and
5821 debug_names::psymbol_tag. */
5824 case VARIABLES_DOMAIN
:
5825 switch (indexval
.dwarf_tag
)
5827 case DW_TAG_variable
:
5833 case FUNCTIONS_DOMAIN
:
5834 switch (indexval
.dwarf_tag
)
5836 case DW_TAG_subprogram
:
5843 switch (indexval
.dwarf_tag
)
5845 case DW_TAG_typedef
:
5846 case DW_TAG_structure_type
:
5852 case MODULES_DOMAIN
:
5853 switch (indexval
.dwarf_tag
)
5867 static struct compunit_symtab
*
5868 dw2_debug_names_lookup_symbol (struct objfile
*objfile
, block_enum block_index
,
5869 const char *name
, domain_enum domain
)
5871 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
5873 const auto &mapp
= per_objfile
->per_bfd
->debug_names_table
;
5876 /* index is NULL if OBJF_READNOW. */
5879 const auto &map
= *mapp
;
5881 dw2_debug_names_iterator
iter (map
, block_index
, domain
, name
, per_objfile
);
5883 struct compunit_symtab
*stab_best
= NULL
;
5884 struct dwarf2_per_cu_data
*per_cu
;
5885 while ((per_cu
= iter
.next ()) != NULL
)
5887 struct symbol
*sym
, *with_opaque
= NULL
;
5888 compunit_symtab
*stab
5889 = dw2_instantiate_symtab (per_cu
, per_objfile
, false);
5890 const struct blockvector
*bv
= COMPUNIT_BLOCKVECTOR (stab
);
5891 const struct block
*block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
5893 sym
= block_find_symbol (block
, name
, domain
,
5894 block_find_non_opaque_type_preferred
,
5897 /* Some caution must be observed with overloaded functions and
5898 methods, since the index will not contain any overload
5899 information (but NAME might contain it). */
5902 && strcmp_iw (sym
->search_name (), name
) == 0)
5904 if (with_opaque
!= NULL
5905 && strcmp_iw (with_opaque
->search_name (), name
) == 0)
5908 /* Keep looking through other CUs. */
5914 /* This dumps minimal information about .debug_names. It is called
5915 via "mt print objfiles". The gdb.dwarf2/gdb-index.exp testcase
5916 uses this to verify that .debug_names has been loaded. */
5919 dw2_debug_names_dump (struct objfile
*objfile
)
5921 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
5923 gdb_assert (per_objfile
->per_bfd
->using_index
);
5924 printf_filtered (".debug_names:");
5925 if (per_objfile
->per_bfd
->debug_names_table
)
5926 printf_filtered (" exists\n");
5928 printf_filtered (" faked for \"readnow\"\n");
5929 printf_filtered ("\n");
5933 dw2_debug_names_expand_symtabs_for_function (struct objfile
*objfile
,
5934 const char *func_name
)
5936 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
5938 /* per_objfile->per_bfd->debug_names_table is NULL if OBJF_READNOW. */
5939 if (per_objfile
->per_bfd
->debug_names_table
)
5941 const mapped_debug_names
&map
= *per_objfile
->per_bfd
->debug_names_table
;
5943 dw2_debug_names_iterator
iter (map
, {}, VAR_DOMAIN
, func_name
,
5946 struct dwarf2_per_cu_data
*per_cu
;
5947 while ((per_cu
= iter
.next ()) != NULL
)
5948 dw2_instantiate_symtab (per_cu
, per_objfile
, false);
5953 dw2_debug_names_map_matching_symbols
5954 (struct objfile
*objfile
,
5955 const lookup_name_info
&name
, domain_enum domain
,
5957 gdb::function_view
<symbol_found_callback_ftype
> callback
,
5958 symbol_compare_ftype
*ordered_compare
)
5960 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
5962 /* debug_names_table is NULL if OBJF_READNOW. */
5963 if (!per_objfile
->per_bfd
->debug_names_table
)
5966 mapped_debug_names
&map
= *per_objfile
->per_bfd
->debug_names_table
;
5967 const block_enum block_kind
= global
? GLOBAL_BLOCK
: STATIC_BLOCK
;
5969 const char *match_name
= name
.ada ().lookup_name ().c_str ();
5970 auto matcher
= [&] (const char *symname
)
5972 if (ordered_compare
== nullptr)
5974 return ordered_compare (symname
, match_name
) == 0;
5977 dw2_expand_symtabs_matching_symbol (map
, name
, matcher
, ALL_DOMAIN
,
5978 [&] (offset_type namei
)
5980 /* The name was matched, now expand corresponding CUs that were
5982 dw2_debug_names_iterator
iter (map
, block_kind
, domain
, namei
,
5985 struct dwarf2_per_cu_data
*per_cu
;
5986 while ((per_cu
= iter
.next ()) != NULL
)
5987 dw2_expand_symtabs_matching_one (per_cu
, per_objfile
, nullptr,
5992 /* It's a shame we couldn't do this inside the
5993 dw2_expand_symtabs_matching_symbol callback, but that skips CUs
5994 that have already been expanded. Instead, this loop matches what
5995 the psymtab code does. */
5996 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
5998 compunit_symtab
*symtab
= per_objfile
->get_symtab (per_cu
);
5999 if (symtab
!= nullptr)
6001 const struct block
*block
6002 = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (symtab
), block_kind
);
6003 if (!iterate_over_symbols_terminated (block
, name
,
6011 dw2_debug_names_expand_symtabs_matching
6012 (struct objfile
*objfile
,
6013 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
6014 const lookup_name_info
*lookup_name
,
6015 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
6016 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
6017 enum search_domain kind
)
6019 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
6021 /* debug_names_table is NULL if OBJF_READNOW. */
6022 if (!per_objfile
->per_bfd
->debug_names_table
)
6025 dw_expand_symtabs_matching_file_matcher (per_objfile
, file_matcher
);
6027 if (symbol_matcher
== NULL
&& lookup_name
== NULL
)
6029 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
6033 dw2_expand_symtabs_matching_one (per_cu
, per_objfile
, file_matcher
,
6039 mapped_debug_names
&map
= *per_objfile
->per_bfd
->debug_names_table
;
6041 dw2_expand_symtabs_matching_symbol (map
, *lookup_name
,
6043 kind
, [&] (offset_type namei
)
6045 /* The name was matched, now expand corresponding CUs that were
6047 dw2_debug_names_iterator
iter (map
, kind
, namei
, per_objfile
);
6049 struct dwarf2_per_cu_data
*per_cu
;
6050 while ((per_cu
= iter
.next ()) != NULL
)
6051 dw2_expand_symtabs_matching_one (per_cu
, per_objfile
, file_matcher
,
6057 const struct quick_symbol_functions dwarf2_debug_names_functions
=
6060 dw2_find_last_source_symtab
,
6061 dw2_forget_cached_source_info
,
6062 dw2_map_symtabs_matching_filename
,
6063 dw2_debug_names_lookup_symbol
,
6066 dw2_debug_names_dump
,
6067 dw2_debug_names_expand_symtabs_for_function
,
6068 dw2_expand_all_symtabs
,
6069 dw2_expand_symtabs_with_fullname
,
6070 dw2_debug_names_map_matching_symbols
,
6071 dw2_debug_names_expand_symtabs_matching
,
6072 dw2_find_pc_sect_compunit_symtab
,
6074 dw2_map_symbol_filenames
6077 /* Get the content of the .gdb_index section of OBJ. SECTION_OWNER should point
6078 to either a dwarf2_per_bfd or dwz_file object. */
6080 template <typename T
>
6081 static gdb::array_view
<const gdb_byte
>
6082 get_gdb_index_contents_from_section (objfile
*obj
, T
*section_owner
)
6084 dwarf2_section_info
*section
= §ion_owner
->gdb_index
;
6086 if (section
->empty ())
6089 /* Older elfutils strip versions could keep the section in the main
6090 executable while splitting it for the separate debug info file. */
6091 if ((section
->get_flags () & SEC_HAS_CONTENTS
) == 0)
6094 section
->read (obj
);
6096 /* dwarf2_section_info::size is a bfd_size_type, while
6097 gdb::array_view works with size_t. On 32-bit hosts, with
6098 --enable-64-bit-bfd, bfd_size_type is a 64-bit type, while size_t
6099 is 32-bit. So we need an explicit narrowing conversion here.
6100 This is fine, because it's impossible to allocate or mmap an
6101 array/buffer larger than what size_t can represent. */
6102 return gdb::make_array_view (section
->buffer
, section
->size
);
6105 /* Lookup the index cache for the contents of the index associated to
6108 static gdb::array_view
<const gdb_byte
>
6109 get_gdb_index_contents_from_cache (objfile
*obj
, dwarf2_per_bfd
*dwarf2_per_bfd
)
6111 const bfd_build_id
*build_id
= build_id_bfd_get (obj
->obfd
);
6112 if (build_id
== nullptr)
6115 return global_index_cache
.lookup_gdb_index (build_id
,
6116 &dwarf2_per_bfd
->index_cache_res
);
6119 /* Same as the above, but for DWZ. */
6121 static gdb::array_view
<const gdb_byte
>
6122 get_gdb_index_contents_from_cache_dwz (objfile
*obj
, dwz_file
*dwz
)
6124 const bfd_build_id
*build_id
= build_id_bfd_get (dwz
->dwz_bfd
.get ());
6125 if (build_id
== nullptr)
6128 return global_index_cache
.lookup_gdb_index (build_id
, &dwz
->index_cache_res
);
6131 /* See symfile.h. */
6134 dwarf2_initialize_objfile (struct objfile
*objfile
, dw_index_kind
*index_kind
)
6136 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
6137 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
6139 /* If we're about to read full symbols, don't bother with the
6140 indices. In this case we also don't care if some other debug
6141 format is making psymtabs, because they are all about to be
6143 if ((objfile
->flags
& OBJF_READNOW
))
6145 /* When using READNOW, the using_index flag (set below) indicates that
6146 PER_BFD was already initialized, when we loaded some other objfile. */
6147 if (per_bfd
->using_index
)
6149 *index_kind
= dw_index_kind::GDB_INDEX
;
6150 per_objfile
->resize_symtabs ();
6154 per_bfd
->using_index
= 1;
6155 create_all_comp_units (per_objfile
);
6156 create_all_type_units (per_objfile
);
6157 per_bfd
->quick_file_names_table
6158 = create_quick_file_names_table (per_bfd
->all_comp_units
.size ());
6159 per_objfile
->resize_symtabs ();
6161 for (int i
= 0; i
< (per_bfd
->all_comp_units
.size ()
6162 + per_bfd
->all_type_units
.size ()); ++i
)
6164 dwarf2_per_cu_data
*per_cu
= per_bfd
->get_cutu (i
);
6166 per_cu
->v
.quick
= OBSTACK_ZALLOC (&per_bfd
->obstack
,
6167 struct dwarf2_per_cu_quick_data
);
6170 /* Return 1 so that gdb sees the "quick" functions. However,
6171 these functions will be no-ops because we will have expanded
6173 *index_kind
= dw_index_kind::GDB_INDEX
;
6177 /* Was a debug names index already read when we processed an objfile sharing
6179 if (per_bfd
->debug_names_table
!= nullptr)
6181 *index_kind
= dw_index_kind::DEBUG_NAMES
;
6182 per_objfile
->objfile
->partial_symtabs
= per_bfd
->partial_symtabs
;
6183 per_objfile
->resize_symtabs ();
6187 /* Was a GDB index already read when we processed an objfile sharing
6189 if (per_bfd
->index_table
!= nullptr)
6191 *index_kind
= dw_index_kind::GDB_INDEX
;
6192 per_objfile
->objfile
->partial_symtabs
= per_bfd
->partial_symtabs
;
6193 per_objfile
->resize_symtabs ();
6197 /* There might already be partial symtabs built for this BFD. This happens
6198 when loading the same binary twice with the index-cache enabled. If so,
6199 don't try to read an index. The objfile / per_objfile initialization will
6200 be completed in dwarf2_build_psymtabs, in the standard partial symtabs
6202 if (per_bfd
->partial_symtabs
!= nullptr)
6205 if (dwarf2_read_debug_names (per_objfile
))
6207 *index_kind
= dw_index_kind::DEBUG_NAMES
;
6208 per_objfile
->resize_symtabs ();
6212 if (dwarf2_read_gdb_index (per_objfile
,
6213 get_gdb_index_contents_from_section
<struct dwarf2_per_bfd
>,
6214 get_gdb_index_contents_from_section
<dwz_file
>))
6216 *index_kind
= dw_index_kind::GDB_INDEX
;
6217 per_objfile
->resize_symtabs ();
6221 /* ... otherwise, try to find the index in the index cache. */
6222 if (dwarf2_read_gdb_index (per_objfile
,
6223 get_gdb_index_contents_from_cache
,
6224 get_gdb_index_contents_from_cache_dwz
))
6226 global_index_cache
.hit ();
6227 *index_kind
= dw_index_kind::GDB_INDEX
;
6228 per_objfile
->resize_symtabs ();
6232 global_index_cache
.miss ();
6238 /* Build a partial symbol table. */
6241 dwarf2_build_psymtabs (struct objfile
*objfile
)
6243 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
6244 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
6246 if (per_bfd
->partial_symtabs
!= nullptr)
6248 /* Partial symbols were already read, so now we can simply
6250 objfile
->partial_symtabs
= per_bfd
->partial_symtabs
;
6251 per_objfile
->resize_symtabs ();
6257 /* This isn't really ideal: all the data we allocate on the
6258 objfile's obstack is still uselessly kept around. However,
6259 freeing it seems unsafe. */
6260 psymtab_discarder
psymtabs (objfile
);
6261 dwarf2_build_psymtabs_hard (per_objfile
);
6264 per_objfile
->resize_symtabs ();
6266 /* (maybe) store an index in the cache. */
6267 global_index_cache
.store (per_objfile
);
6269 catch (const gdb_exception_error
&except
)
6271 exception_print (gdb_stderr
, except
);
6274 /* Finish by setting the local reference to partial symtabs, so that
6275 we don't try to read them again if reading another objfile with the same
6276 BFD. If we can't in fact share, this won't make a difference anyway as
6277 the dwarf2_per_bfd object won't be shared. */
6278 per_bfd
->partial_symtabs
= objfile
->partial_symtabs
;
6281 /* Find the base address of the compilation unit for range lists and
6282 location lists. It will normally be specified by DW_AT_low_pc.
6283 In DWARF-3 draft 4, the base address could be overridden by
6284 DW_AT_entry_pc. It's been removed, but GCC still uses this for
6285 compilation units with discontinuous ranges. */
6288 dwarf2_find_base_address (struct die_info
*die
, struct dwarf2_cu
*cu
)
6290 struct attribute
*attr
;
6292 cu
->base_address
.reset ();
6294 attr
= dwarf2_attr (die
, DW_AT_entry_pc
, cu
);
6295 if (attr
!= nullptr)
6296 cu
->base_address
= attr
->as_address ();
6299 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
6300 if (attr
!= nullptr)
6301 cu
->base_address
= attr
->as_address ();
6305 /* Helper function that returns the proper abbrev section for
6308 static struct dwarf2_section_info
*
6309 get_abbrev_section_for_cu (struct dwarf2_per_cu_data
*this_cu
)
6311 struct dwarf2_section_info
*abbrev
;
6312 dwarf2_per_bfd
*per_bfd
= this_cu
->per_bfd
;
6314 if (this_cu
->is_dwz
)
6315 abbrev
= &dwarf2_get_dwz_file (per_bfd
)->abbrev
;
6317 abbrev
= &per_bfd
->abbrev
;
6322 /* Fetch the abbreviation table offset from a comp or type unit header. */
6325 read_abbrev_offset (dwarf2_per_objfile
*per_objfile
,
6326 struct dwarf2_section_info
*section
,
6327 sect_offset sect_off
)
6329 bfd
*abfd
= section
->get_bfd_owner ();
6330 const gdb_byte
*info_ptr
;
6331 unsigned int initial_length_size
, offset_size
;
6334 section
->read (per_objfile
->objfile
);
6335 info_ptr
= section
->buffer
+ to_underlying (sect_off
);
6336 read_initial_length (abfd
, info_ptr
, &initial_length_size
);
6337 offset_size
= initial_length_size
== 4 ? 4 : 8;
6338 info_ptr
+= initial_length_size
;
6340 version
= read_2_bytes (abfd
, info_ptr
);
6344 /* Skip unit type and address size. */
6348 return (sect_offset
) read_offset (abfd
, info_ptr
, offset_size
);
6351 /* A partial symtab that is used only for include files. */
6352 struct dwarf2_include_psymtab
: public partial_symtab
6354 dwarf2_include_psymtab (const char *filename
, struct objfile
*objfile
)
6355 : partial_symtab (filename
, objfile
)
6359 void read_symtab (struct objfile
*objfile
) override
6361 /* It's an include file, no symbols to read for it.
6362 Everything is in the includer symtab. */
6364 /* The expansion of a dwarf2_include_psymtab is just a trigger for
6365 expansion of the includer psymtab. We use the dependencies[0] field to
6366 model the includer. But if we go the regular route of calling
6367 expand_psymtab here, and having expand_psymtab call expand_dependencies
6368 to expand the includer, we'll only use expand_psymtab on the includer
6369 (making it a non-toplevel psymtab), while if we expand the includer via
6370 another path, we'll use read_symtab (making it a toplevel psymtab).
6371 So, don't pretend a dwarf2_include_psymtab is an actual toplevel
6372 psymtab, and trigger read_symtab on the includer here directly. */
6373 includer ()->read_symtab (objfile
);
6376 void expand_psymtab (struct objfile
*objfile
) override
6378 /* This is not called by read_symtab, and should not be called by any
6379 expand_dependencies. */
6383 bool readin_p (struct objfile
*objfile
) const override
6385 return includer ()->readin_p (objfile
);
6388 compunit_symtab
*get_compunit_symtab (struct objfile
*objfile
) const override
6394 partial_symtab
*includer () const
6396 /* An include psymtab has exactly one dependency: the psymtab that
6398 gdb_assert (this->number_of_dependencies
== 1);
6399 return this->dependencies
[0];
6403 /* Allocate a new partial symtab for file named NAME and mark this new
6404 partial symtab as being an include of PST. */
6407 dwarf2_create_include_psymtab (const char *name
, dwarf2_psymtab
*pst
,
6408 struct objfile
*objfile
)
6410 dwarf2_include_psymtab
*subpst
= new dwarf2_include_psymtab (name
, objfile
);
6412 if (!IS_ABSOLUTE_PATH (subpst
->filename
))
6413 subpst
->dirname
= pst
->dirname
;
6415 subpst
->dependencies
= objfile
->partial_symtabs
->allocate_dependencies (1);
6416 subpst
->dependencies
[0] = pst
;
6417 subpst
->number_of_dependencies
= 1;
6420 /* Read the Line Number Program data and extract the list of files
6421 included by the source file represented by PST. Build an include
6422 partial symtab for each of these included files. */
6425 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
6426 struct die_info
*die
,
6427 dwarf2_psymtab
*pst
)
6430 struct attribute
*attr
;
6432 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
6433 if (attr
!= nullptr && attr
->form_is_unsigned ())
6434 lh
= dwarf_decode_line_header ((sect_offset
) attr
->as_unsigned (), cu
);
6436 return; /* No linetable, so no includes. */
6438 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). Also note
6439 that we pass in the raw text_low here; that is ok because we're
6440 only decoding the line table to make include partial symtabs, and
6441 so the addresses aren't really used. */
6442 dwarf_decode_lines (lh
.get (), pst
->dirname
, cu
, pst
,
6443 pst
->raw_text_low (), 1);
6447 hash_signatured_type (const void *item
)
6449 const struct signatured_type
*sig_type
6450 = (const struct signatured_type
*) item
;
6452 /* This drops the top 32 bits of the signature, but is ok for a hash. */
6453 return sig_type
->signature
;
6457 eq_signatured_type (const void *item_lhs
, const void *item_rhs
)
6459 const struct signatured_type
*lhs
= (const struct signatured_type
*) item_lhs
;
6460 const struct signatured_type
*rhs
= (const struct signatured_type
*) item_rhs
;
6462 return lhs
->signature
== rhs
->signature
;
6465 /* Allocate a hash table for signatured types. */
6468 allocate_signatured_type_table ()
6470 return htab_up (htab_create_alloc (41,
6471 hash_signatured_type
,
6473 NULL
, xcalloc
, xfree
));
6476 /* A helper function to add a signatured type CU to a table. */
6479 add_signatured_type_cu_to_table (void **slot
, void *datum
)
6481 struct signatured_type
*sigt
= (struct signatured_type
*) *slot
;
6482 std::vector
<signatured_type
*> *all_type_units
6483 = (std::vector
<signatured_type
*> *) datum
;
6485 all_type_units
->push_back (sigt
);
6490 /* A helper for create_debug_types_hash_table. Read types from SECTION
6491 and fill them into TYPES_HTAB. It will process only type units,
6492 therefore DW_UT_type. */
6495 create_debug_type_hash_table (dwarf2_per_objfile
*per_objfile
,
6496 struct dwo_file
*dwo_file
,
6497 dwarf2_section_info
*section
, htab_up
&types_htab
,
6498 rcuh_kind section_kind
)
6500 struct objfile
*objfile
= per_objfile
->objfile
;
6501 struct dwarf2_section_info
*abbrev_section
;
6503 const gdb_byte
*info_ptr
, *end_ptr
;
6505 abbrev_section
= (dwo_file
!= NULL
6506 ? &dwo_file
->sections
.abbrev
6507 : &per_objfile
->per_bfd
->abbrev
);
6509 dwarf_read_debug_printf ("Reading %s for %s:",
6510 section
->get_name (),
6511 abbrev_section
->get_file_name ());
6513 section
->read (objfile
);
6514 info_ptr
= section
->buffer
;
6516 if (info_ptr
== NULL
)
6519 /* We can't set abfd until now because the section may be empty or
6520 not present, in which case the bfd is unknown. */
6521 abfd
= section
->get_bfd_owner ();
6523 /* We don't use cutu_reader here because we don't need to read
6524 any dies: the signature is in the header. */
6526 end_ptr
= info_ptr
+ section
->size
;
6527 while (info_ptr
< end_ptr
)
6529 struct signatured_type
*sig_type
;
6530 struct dwo_unit
*dwo_tu
;
6532 const gdb_byte
*ptr
= info_ptr
;
6533 struct comp_unit_head header
;
6534 unsigned int length
;
6536 sect_offset sect_off
= (sect_offset
) (ptr
- section
->buffer
);
6538 /* Initialize it due to a false compiler warning. */
6539 header
.signature
= -1;
6540 header
.type_cu_offset_in_tu
= (cu_offset
) -1;
6542 /* We need to read the type's signature in order to build the hash
6543 table, but we don't need anything else just yet. */
6545 ptr
= read_and_check_comp_unit_head (per_objfile
, &header
, section
,
6546 abbrev_section
, ptr
, section_kind
);
6548 length
= header
.get_length ();
6550 /* Skip dummy type units. */
6551 if (ptr
>= info_ptr
+ length
6552 || peek_abbrev_code (abfd
, ptr
) == 0
6553 || (header
.unit_type
!= DW_UT_type
6554 && header
.unit_type
!= DW_UT_split_type
))
6560 if (types_htab
== NULL
)
6563 types_htab
= allocate_dwo_unit_table ();
6565 types_htab
= allocate_signatured_type_table ();
6571 dwo_tu
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, dwo_unit
);
6572 dwo_tu
->dwo_file
= dwo_file
;
6573 dwo_tu
->signature
= header
.signature
;
6574 dwo_tu
->type_offset_in_tu
= header
.type_cu_offset_in_tu
;
6575 dwo_tu
->section
= section
;
6576 dwo_tu
->sect_off
= sect_off
;
6577 dwo_tu
->length
= length
;
6581 /* N.B.: type_offset is not usable if this type uses a DWO file.
6582 The real type_offset is in the DWO file. */
6584 sig_type
= per_objfile
->per_bfd
->allocate_signatured_type ();
6585 sig_type
->signature
= header
.signature
;
6586 sig_type
->type_offset_in_tu
= header
.type_cu_offset_in_tu
;
6587 sig_type
->per_cu
.is_debug_types
= 1;
6588 sig_type
->per_cu
.section
= section
;
6589 sig_type
->per_cu
.sect_off
= sect_off
;
6590 sig_type
->per_cu
.length
= length
;
6593 slot
= htab_find_slot (types_htab
.get (),
6594 dwo_file
? (void*) dwo_tu
: (void *) sig_type
,
6596 gdb_assert (slot
!= NULL
);
6599 sect_offset dup_sect_off
;
6603 const struct dwo_unit
*dup_tu
6604 = (const struct dwo_unit
*) *slot
;
6606 dup_sect_off
= dup_tu
->sect_off
;
6610 const struct signatured_type
*dup_tu
6611 = (const struct signatured_type
*) *slot
;
6613 dup_sect_off
= dup_tu
->per_cu
.sect_off
;
6616 complaint (_("debug type entry at offset %s is duplicate to"
6617 " the entry at offset %s, signature %s"),
6618 sect_offset_str (sect_off
), sect_offset_str (dup_sect_off
),
6619 hex_string (header
.signature
));
6621 *slot
= dwo_file
? (void *) dwo_tu
: (void *) sig_type
;
6623 dwarf_read_debug_printf_v (" offset %s, signature %s",
6624 sect_offset_str (sect_off
),
6625 hex_string (header
.signature
));
6631 /* Create the hash table of all entries in the .debug_types
6632 (or .debug_types.dwo) section(s).
6633 If reading a DWO file, then DWO_FILE is a pointer to the DWO file object,
6634 otherwise it is NULL.
6636 The result is a pointer to the hash table or NULL if there are no types.
6638 Note: This function processes DWO files only, not DWP files. */
6641 create_debug_types_hash_table (dwarf2_per_objfile
*per_objfile
,
6642 struct dwo_file
*dwo_file
,
6643 gdb::array_view
<dwarf2_section_info
> type_sections
,
6644 htab_up
&types_htab
)
6646 for (dwarf2_section_info
§ion
: type_sections
)
6647 create_debug_type_hash_table (per_objfile
, dwo_file
, §ion
, types_htab
,
6651 /* Create the hash table of all entries in the .debug_types section,
6652 and initialize all_type_units.
6653 The result is zero if there is an error (e.g. missing .debug_types section),
6654 otherwise non-zero. */
6657 create_all_type_units (dwarf2_per_objfile
*per_objfile
)
6661 create_debug_type_hash_table (per_objfile
, NULL
, &per_objfile
->per_bfd
->info
,
6662 types_htab
, rcuh_kind::COMPILE
);
6663 create_debug_types_hash_table (per_objfile
, NULL
, per_objfile
->per_bfd
->types
,
6665 if (types_htab
== NULL
)
6667 per_objfile
->per_bfd
->signatured_types
= NULL
;
6671 per_objfile
->per_bfd
->signatured_types
= std::move (types_htab
);
6673 gdb_assert (per_objfile
->per_bfd
->all_type_units
.empty ());
6674 per_objfile
->per_bfd
->all_type_units
.reserve
6675 (htab_elements (per_objfile
->per_bfd
->signatured_types
.get ()));
6677 htab_traverse_noresize (per_objfile
->per_bfd
->signatured_types
.get (),
6678 add_signatured_type_cu_to_table
,
6679 &per_objfile
->per_bfd
->all_type_units
);
6684 /* Add an entry for signature SIG to dwarf2_per_objfile->per_bfd->signatured_types.
6685 If SLOT is non-NULL, it is the entry to use in the hash table.
6686 Otherwise we find one. */
6688 static struct signatured_type
*
6689 add_type_unit (dwarf2_per_objfile
*per_objfile
, ULONGEST sig
, void **slot
)
6691 if (per_objfile
->per_bfd
->all_type_units
.size ()
6692 == per_objfile
->per_bfd
->all_type_units
.capacity ())
6693 ++per_objfile
->per_bfd
->tu_stats
.nr_all_type_units_reallocs
;
6695 signatured_type
*sig_type
= per_objfile
->per_bfd
->allocate_signatured_type ();
6697 per_objfile
->resize_symtabs ();
6699 per_objfile
->per_bfd
->all_type_units
.push_back (sig_type
);
6700 sig_type
->signature
= sig
;
6701 sig_type
->per_cu
.is_debug_types
= 1;
6702 if (per_objfile
->per_bfd
->using_index
)
6704 sig_type
->per_cu
.v
.quick
=
6705 OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
,
6706 struct dwarf2_per_cu_quick_data
);
6711 slot
= htab_find_slot (per_objfile
->per_bfd
->signatured_types
.get (),
6714 gdb_assert (*slot
== NULL
);
6716 /* The rest of sig_type must be filled in by the caller. */
6720 /* Subroutine of lookup_dwo_signatured_type and lookup_dwp_signatured_type.
6721 Fill in SIG_ENTRY with DWO_ENTRY. */
6724 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile
*per_objfile
,
6725 struct signatured_type
*sig_entry
,
6726 struct dwo_unit
*dwo_entry
)
6728 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
6730 /* Make sure we're not clobbering something we don't expect to. */
6731 gdb_assert (! sig_entry
->per_cu
.queued
);
6732 gdb_assert (per_objfile
->get_cu (&sig_entry
->per_cu
) == NULL
);
6733 if (per_bfd
->using_index
)
6735 gdb_assert (sig_entry
->per_cu
.v
.quick
!= NULL
);
6736 gdb_assert (!per_objfile
->symtab_set_p (&sig_entry
->per_cu
));
6739 gdb_assert (sig_entry
->per_cu
.v
.psymtab
== NULL
);
6740 gdb_assert (sig_entry
->signature
== dwo_entry
->signature
);
6741 gdb_assert (to_underlying (sig_entry
->type_offset_in_section
) == 0);
6742 gdb_assert (sig_entry
->type_unit_group
== NULL
);
6743 gdb_assert (sig_entry
->dwo_unit
== NULL
);
6745 sig_entry
->per_cu
.section
= dwo_entry
->section
;
6746 sig_entry
->per_cu
.sect_off
= dwo_entry
->sect_off
;
6747 sig_entry
->per_cu
.length
= dwo_entry
->length
;
6748 sig_entry
->per_cu
.reading_dwo_directly
= 1;
6749 sig_entry
->per_cu
.per_bfd
= per_bfd
;
6750 sig_entry
->type_offset_in_tu
= dwo_entry
->type_offset_in_tu
;
6751 sig_entry
->dwo_unit
= dwo_entry
;
6754 /* Subroutine of lookup_signatured_type.
6755 If we haven't read the TU yet, create the signatured_type data structure
6756 for a TU to be read in directly from a DWO file, bypassing the stub.
6757 This is the "Stay in DWO Optimization": When there is no DWP file and we're
6758 using .gdb_index, then when reading a CU we want to stay in the DWO file
6759 containing that CU. Otherwise we could end up reading several other DWO
6760 files (due to comdat folding) to process the transitive closure of all the
6761 mentioned TUs, and that can be slow. The current DWO file will have every
6762 type signature that it needs.
6763 We only do this for .gdb_index because in the psymtab case we already have
6764 to read all the DWOs to build the type unit groups. */
6766 static struct signatured_type
*
6767 lookup_dwo_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
6769 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
6770 struct dwo_file
*dwo_file
;
6771 struct dwo_unit find_dwo_entry
, *dwo_entry
;
6772 struct signatured_type find_sig_entry
, *sig_entry
;
6775 gdb_assert (cu
->dwo_unit
&& per_objfile
->per_bfd
->using_index
);
6777 /* If TU skeletons have been removed then we may not have read in any
6779 if (per_objfile
->per_bfd
->signatured_types
== NULL
)
6780 per_objfile
->per_bfd
->signatured_types
= allocate_signatured_type_table ();
6782 /* We only ever need to read in one copy of a signatured type.
6783 Use the global signatured_types array to do our own comdat-folding
6784 of types. If this is the first time we're reading this TU, and
6785 the TU has an entry in .gdb_index, replace the recorded data from
6786 .gdb_index with this TU. */
6788 find_sig_entry
.signature
= sig
;
6789 slot
= htab_find_slot (per_objfile
->per_bfd
->signatured_types
.get (),
6790 &find_sig_entry
, INSERT
);
6791 sig_entry
= (struct signatured_type
*) *slot
;
6793 /* We can get here with the TU already read, *or* in the process of being
6794 read. Don't reassign the global entry to point to this DWO if that's
6795 the case. Also note that if the TU is already being read, it may not
6796 have come from a DWO, the program may be a mix of Fission-compiled
6797 code and non-Fission-compiled code. */
6799 /* Have we already tried to read this TU?
6800 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
6801 needn't exist in the global table yet). */
6802 if (sig_entry
!= NULL
&& sig_entry
->per_cu
.tu_read
)
6805 /* Note: cu->dwo_unit is the dwo_unit that references this TU, not the
6806 dwo_unit of the TU itself. */
6807 dwo_file
= cu
->dwo_unit
->dwo_file
;
6809 /* Ok, this is the first time we're reading this TU. */
6810 if (dwo_file
->tus
== NULL
)
6812 find_dwo_entry
.signature
= sig
;
6813 dwo_entry
= (struct dwo_unit
*) htab_find (dwo_file
->tus
.get (),
6815 if (dwo_entry
== NULL
)
6818 /* If the global table doesn't have an entry for this TU, add one. */
6819 if (sig_entry
== NULL
)
6820 sig_entry
= add_type_unit (per_objfile
, sig
, slot
);
6822 fill_in_sig_entry_from_dwo_entry (per_objfile
, sig_entry
, dwo_entry
);
6823 sig_entry
->per_cu
.tu_read
= 1;
6827 /* Subroutine of lookup_signatured_type.
6828 Look up the type for signature SIG, and if we can't find SIG in .gdb_index
6829 then try the DWP file. If the TU stub (skeleton) has been removed then
6830 it won't be in .gdb_index. */
6832 static struct signatured_type
*
6833 lookup_dwp_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
6835 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
6836 struct dwp_file
*dwp_file
= get_dwp_file (per_objfile
);
6837 struct dwo_unit
*dwo_entry
;
6838 struct signatured_type find_sig_entry
, *sig_entry
;
6841 gdb_assert (cu
->dwo_unit
&& per_objfile
->per_bfd
->using_index
);
6842 gdb_assert (dwp_file
!= NULL
);
6844 /* If TU skeletons have been removed then we may not have read in any
6846 if (per_objfile
->per_bfd
->signatured_types
== NULL
)
6847 per_objfile
->per_bfd
->signatured_types
= allocate_signatured_type_table ();
6849 find_sig_entry
.signature
= sig
;
6850 slot
= htab_find_slot (per_objfile
->per_bfd
->signatured_types
.get (),
6851 &find_sig_entry
, INSERT
);
6852 sig_entry
= (struct signatured_type
*) *slot
;
6854 /* Have we already tried to read this TU?
6855 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
6856 needn't exist in the global table yet). */
6857 if (sig_entry
!= NULL
)
6860 if (dwp_file
->tus
== NULL
)
6862 dwo_entry
= lookup_dwo_unit_in_dwp (per_objfile
, dwp_file
, NULL
, sig
,
6863 1 /* is_debug_types */);
6864 if (dwo_entry
== NULL
)
6867 sig_entry
= add_type_unit (per_objfile
, sig
, slot
);
6868 fill_in_sig_entry_from_dwo_entry (per_objfile
, sig_entry
, dwo_entry
);
6873 /* Lookup a signature based type for DW_FORM_ref_sig8.
6874 Returns NULL if signature SIG is not present in the table.
6875 It is up to the caller to complain about this. */
6877 static struct signatured_type
*
6878 lookup_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
6880 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
6882 if (cu
->dwo_unit
&& per_objfile
->per_bfd
->using_index
)
6884 /* We're in a DWO/DWP file, and we're using .gdb_index.
6885 These cases require special processing. */
6886 if (get_dwp_file (per_objfile
) == NULL
)
6887 return lookup_dwo_signatured_type (cu
, sig
);
6889 return lookup_dwp_signatured_type (cu
, sig
);
6893 struct signatured_type find_entry
, *entry
;
6895 if (per_objfile
->per_bfd
->signatured_types
== NULL
)
6897 find_entry
.signature
= sig
;
6898 entry
= ((struct signatured_type
*)
6899 htab_find (per_objfile
->per_bfd
->signatured_types
.get (),
6905 /* Low level DIE reading support. */
6907 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
6910 init_cu_die_reader (struct die_reader_specs
*reader
,
6911 struct dwarf2_cu
*cu
,
6912 struct dwarf2_section_info
*section
,
6913 struct dwo_file
*dwo_file
,
6914 struct abbrev_table
*abbrev_table
)
6916 gdb_assert (section
->readin
&& section
->buffer
!= NULL
);
6917 reader
->abfd
= section
->get_bfd_owner ();
6919 reader
->dwo_file
= dwo_file
;
6920 reader
->die_section
= section
;
6921 reader
->buffer
= section
->buffer
;
6922 reader
->buffer_end
= section
->buffer
+ section
->size
;
6923 reader
->abbrev_table
= abbrev_table
;
6926 /* Subroutine of cutu_reader to simplify it.
6927 Read in the rest of a CU/TU top level DIE from DWO_UNIT.
6928 There's just a lot of work to do, and cutu_reader is big enough
6931 STUB_COMP_UNIT_DIE is for the stub DIE, we copy over certain attributes
6932 from it to the DIE in the DWO. If NULL we are skipping the stub.
6933 STUB_COMP_DIR is similar to STUB_COMP_UNIT_DIE: When reading a TU directly
6934 from the DWO file, bypassing the stub, it contains the DW_AT_comp_dir
6935 attribute of the referencing CU. At most one of STUB_COMP_UNIT_DIE and
6936 STUB_COMP_DIR may be non-NULL.
6937 *RESULT_READER,*RESULT_INFO_PTR,*RESULT_COMP_UNIT_DIE
6938 are filled in with the info of the DIE from the DWO file.
6939 *RESULT_DWO_ABBREV_TABLE will be filled in with the abbrev table allocated
6940 from the dwo. Since *RESULT_READER references this abbrev table, it must be
6941 kept around for at least as long as *RESULT_READER.
6943 The result is non-zero if a valid (non-dummy) DIE was found. */
6946 read_cutu_die_from_dwo (dwarf2_cu
*cu
,
6947 struct dwo_unit
*dwo_unit
,
6948 struct die_info
*stub_comp_unit_die
,
6949 const char *stub_comp_dir
,
6950 struct die_reader_specs
*result_reader
,
6951 const gdb_byte
**result_info_ptr
,
6952 struct die_info
**result_comp_unit_die
,
6953 abbrev_table_up
*result_dwo_abbrev_table
)
6955 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
6956 dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
6957 struct objfile
*objfile
= per_objfile
->objfile
;
6959 const gdb_byte
*begin_info_ptr
, *info_ptr
;
6960 struct attribute
*comp_dir
, *stmt_list
, *low_pc
, *high_pc
, *ranges
;
6961 int i
,num_extra_attrs
;
6962 struct dwarf2_section_info
*dwo_abbrev_section
;
6963 struct die_info
*comp_unit_die
;
6965 /* At most one of these may be provided. */
6966 gdb_assert ((stub_comp_unit_die
!= NULL
) + (stub_comp_dir
!= NULL
) <= 1);
6968 /* These attributes aren't processed until later:
6969 DW_AT_stmt_list, DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges.
6970 DW_AT_comp_dir is used now, to find the DWO file, but it is also
6971 referenced later. However, these attributes are found in the stub
6972 which we won't have later. In order to not impose this complication
6973 on the rest of the code, we read them here and copy them to the
6982 if (stub_comp_unit_die
!= NULL
)
6984 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
6986 if (!per_cu
->is_debug_types
)
6987 stmt_list
= dwarf2_attr (stub_comp_unit_die
, DW_AT_stmt_list
, cu
);
6988 low_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_low_pc
, cu
);
6989 high_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_high_pc
, cu
);
6990 ranges
= dwarf2_attr (stub_comp_unit_die
, DW_AT_ranges
, cu
);
6991 comp_dir
= dwarf2_attr (stub_comp_unit_die
, DW_AT_comp_dir
, cu
);
6993 cu
->addr_base
= stub_comp_unit_die
->addr_base ();
6995 /* There should be a DW_AT_GNU_ranges_base attribute here (if needed).
6996 We need the value before we can process DW_AT_ranges values from the
6998 cu
->gnu_ranges_base
= stub_comp_unit_die
->gnu_ranges_base ();
7000 /* For DWARF5: record the DW_AT_rnglists_base value from the skeleton. If
7001 there are attributes of form DW_FORM_rnglistx in the skeleton, they'll
7002 need the rnglists base. Attributes of form DW_FORM_rnglistx in the
7003 split unit don't use it, as the DWO has its own .debug_rnglists.dwo
7005 cu
->rnglists_base
= stub_comp_unit_die
->rnglists_base ();
7007 else if (stub_comp_dir
!= NULL
)
7009 /* Reconstruct the comp_dir attribute to simplify the code below. */
7010 comp_dir
= OBSTACK_ZALLOC (&cu
->comp_unit_obstack
, struct attribute
);
7011 comp_dir
->name
= DW_AT_comp_dir
;
7012 comp_dir
->form
= DW_FORM_string
;
7013 comp_dir
->set_string_noncanonical (stub_comp_dir
);
7016 /* Set up for reading the DWO CU/TU. */
7017 cu
->dwo_unit
= dwo_unit
;
7018 dwarf2_section_info
*section
= dwo_unit
->section
;
7019 section
->read (objfile
);
7020 abfd
= section
->get_bfd_owner ();
7021 begin_info_ptr
= info_ptr
= (section
->buffer
7022 + to_underlying (dwo_unit
->sect_off
));
7023 dwo_abbrev_section
= &dwo_unit
->dwo_file
->sections
.abbrev
;
7025 if (per_cu
->is_debug_types
)
7027 signatured_type
*sig_type
= (struct signatured_type
*) per_cu
;
7029 info_ptr
= read_and_check_comp_unit_head (per_objfile
, &cu
->header
,
7030 section
, dwo_abbrev_section
,
7031 info_ptr
, rcuh_kind::TYPE
);
7032 /* This is not an assert because it can be caused by bad debug info. */
7033 if (sig_type
->signature
!= cu
->header
.signature
)
7035 error (_("Dwarf Error: signature mismatch %s vs %s while reading"
7036 " TU at offset %s [in module %s]"),
7037 hex_string (sig_type
->signature
),
7038 hex_string (cu
->header
.signature
),
7039 sect_offset_str (dwo_unit
->sect_off
),
7040 bfd_get_filename (abfd
));
7042 gdb_assert (dwo_unit
->sect_off
== cu
->header
.sect_off
);
7043 /* For DWOs coming from DWP files, we don't know the CU length
7044 nor the type's offset in the TU until now. */
7045 dwo_unit
->length
= cu
->header
.get_length ();
7046 dwo_unit
->type_offset_in_tu
= cu
->header
.type_cu_offset_in_tu
;
7048 /* Establish the type offset that can be used to lookup the type.
7049 For DWO files, we don't know it until now. */
7050 sig_type
->type_offset_in_section
7051 = dwo_unit
->sect_off
+ to_underlying (dwo_unit
->type_offset_in_tu
);
7055 info_ptr
= read_and_check_comp_unit_head (per_objfile
, &cu
->header
,
7056 section
, dwo_abbrev_section
,
7057 info_ptr
, rcuh_kind::COMPILE
);
7058 gdb_assert (dwo_unit
->sect_off
== cu
->header
.sect_off
);
7059 /* For DWOs coming from DWP files, we don't know the CU length
7061 dwo_unit
->length
= cu
->header
.get_length ();
7064 dwo_abbrev_section
->read (objfile
);
7065 *result_dwo_abbrev_table
7066 = abbrev_table::read (dwo_abbrev_section
, cu
->header
.abbrev_sect_off
);
7067 init_cu_die_reader (result_reader
, cu
, section
, dwo_unit
->dwo_file
,
7068 result_dwo_abbrev_table
->get ());
7070 /* Read in the die, but leave space to copy over the attributes
7071 from the stub. This has the benefit of simplifying the rest of
7072 the code - all the work to maintain the illusion of a single
7073 DW_TAG_{compile,type}_unit DIE is done here. */
7074 num_extra_attrs
= ((stmt_list
!= NULL
)
7078 + (comp_dir
!= NULL
));
7079 info_ptr
= read_full_die_1 (result_reader
, result_comp_unit_die
, info_ptr
,
7082 /* Copy over the attributes from the stub to the DIE we just read in. */
7083 comp_unit_die
= *result_comp_unit_die
;
7084 i
= comp_unit_die
->num_attrs
;
7085 if (stmt_list
!= NULL
)
7086 comp_unit_die
->attrs
[i
++] = *stmt_list
;
7088 comp_unit_die
->attrs
[i
++] = *low_pc
;
7089 if (high_pc
!= NULL
)
7090 comp_unit_die
->attrs
[i
++] = *high_pc
;
7092 comp_unit_die
->attrs
[i
++] = *ranges
;
7093 if (comp_dir
!= NULL
)
7094 comp_unit_die
->attrs
[i
++] = *comp_dir
;
7095 comp_unit_die
->num_attrs
+= num_extra_attrs
;
7097 if (dwarf_die_debug
)
7099 fprintf_unfiltered (gdb_stdlog
,
7100 "Read die from %s@0x%x of %s:\n",
7101 section
->get_name (),
7102 (unsigned) (begin_info_ptr
- section
->buffer
),
7103 bfd_get_filename (abfd
));
7104 dump_die (comp_unit_die
, dwarf_die_debug
);
7107 /* Skip dummy compilation units. */
7108 if (info_ptr
>= begin_info_ptr
+ dwo_unit
->length
7109 || peek_abbrev_code (abfd
, info_ptr
) == 0)
7112 *result_info_ptr
= info_ptr
;
7116 /* Return the signature of the compile unit, if found. In DWARF 4 and before,
7117 the signature is in the DW_AT_GNU_dwo_id attribute. In DWARF 5 and later, the
7118 signature is part of the header. */
7119 static gdb::optional
<ULONGEST
>
7120 lookup_dwo_id (struct dwarf2_cu
*cu
, struct die_info
* comp_unit_die
)
7122 if (cu
->header
.version
>= 5)
7123 return cu
->header
.signature
;
7124 struct attribute
*attr
;
7125 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_id
, cu
);
7126 if (attr
== nullptr || !attr
->form_is_unsigned ())
7127 return gdb::optional
<ULONGEST
> ();
7128 return attr
->as_unsigned ();
7131 /* Subroutine of cutu_reader to simplify it.
7132 Look up the DWO unit specified by COMP_UNIT_DIE of THIS_CU.
7133 Returns NULL if the specified DWO unit cannot be found. */
7135 static struct dwo_unit
*
7136 lookup_dwo_unit (dwarf2_cu
*cu
, die_info
*comp_unit_die
, const char *dwo_name
)
7138 dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
7139 struct dwo_unit
*dwo_unit
;
7140 const char *comp_dir
;
7142 gdb_assert (cu
!= NULL
);
7144 /* Yeah, we look dwo_name up again, but it simplifies the code. */
7145 dwo_name
= dwarf2_dwo_name (comp_unit_die
, cu
);
7146 comp_dir
= dwarf2_string_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
7148 if (per_cu
->is_debug_types
)
7149 dwo_unit
= lookup_dwo_type_unit (cu
, dwo_name
, comp_dir
);
7152 gdb::optional
<ULONGEST
> signature
= lookup_dwo_id (cu
, comp_unit_die
);
7154 if (!signature
.has_value ())
7155 error (_("Dwarf Error: missing dwo_id for dwo_name %s"
7157 dwo_name
, bfd_get_filename (per_cu
->per_bfd
->obfd
));
7159 dwo_unit
= lookup_dwo_comp_unit (cu
, dwo_name
, comp_dir
, *signature
);
7165 /* Subroutine of cutu_reader to simplify it.
7166 See it for a description of the parameters.
7167 Read a TU directly from a DWO file, bypassing the stub. */
7170 cutu_reader::init_tu_and_read_dwo_dies (dwarf2_per_cu_data
*this_cu
,
7171 dwarf2_per_objfile
*per_objfile
,
7172 dwarf2_cu
*existing_cu
)
7174 struct signatured_type
*sig_type
;
7176 /* Verify we can do the following downcast, and that we have the
7178 gdb_assert (this_cu
->is_debug_types
&& this_cu
->reading_dwo_directly
);
7179 sig_type
= (struct signatured_type
*) this_cu
;
7180 gdb_assert (sig_type
->dwo_unit
!= NULL
);
7184 if (existing_cu
!= nullptr)
7187 gdb_assert (cu
->dwo_unit
== sig_type
->dwo_unit
);
7188 /* There's no need to do the rereading_dwo_cu handling that
7189 cutu_reader does since we don't read the stub. */
7193 /* If an existing_cu is provided, a dwarf2_cu must not exist for this_cu
7194 in per_objfile yet. */
7195 gdb_assert (per_objfile
->get_cu (this_cu
) == nullptr);
7196 m_new_cu
.reset (new dwarf2_cu (this_cu
, per_objfile
));
7197 cu
= m_new_cu
.get ();
7200 /* A future optimization, if needed, would be to use an existing
7201 abbrev table. When reading DWOs with skeletonless TUs, all the TUs
7202 could share abbrev tables. */
7204 if (read_cutu_die_from_dwo (cu
, sig_type
->dwo_unit
,
7205 NULL
/* stub_comp_unit_die */,
7206 sig_type
->dwo_unit
->dwo_file
->comp_dir
,
7209 &m_dwo_abbrev_table
) == 0)
7216 /* Initialize a CU (or TU) and read its DIEs.
7217 If the CU defers to a DWO file, read the DWO file as well.
7219 ABBREV_TABLE, if non-NULL, is the abbreviation table to use.
7220 Otherwise the table specified in the comp unit header is read in and used.
7221 This is an optimization for when we already have the abbrev table.
7223 If EXISTING_CU is non-NULL, then use it. Otherwise, a new CU is
7226 cutu_reader::cutu_reader (dwarf2_per_cu_data
*this_cu
,
7227 dwarf2_per_objfile
*per_objfile
,
7228 struct abbrev_table
*abbrev_table
,
7229 dwarf2_cu
*existing_cu
,
7231 : die_reader_specs
{},
7234 struct objfile
*objfile
= per_objfile
->objfile
;
7235 struct dwarf2_section_info
*section
= this_cu
->section
;
7236 bfd
*abfd
= section
->get_bfd_owner ();
7237 const gdb_byte
*begin_info_ptr
;
7238 struct signatured_type
*sig_type
= NULL
;
7239 struct dwarf2_section_info
*abbrev_section
;
7240 /* Non-zero if CU currently points to a DWO file and we need to
7241 reread it. When this happens we need to reread the skeleton die
7242 before we can reread the DWO file (this only applies to CUs, not TUs). */
7243 int rereading_dwo_cu
= 0;
7245 if (dwarf_die_debug
)
7246 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset %s\n",
7247 this_cu
->is_debug_types
? "type" : "comp",
7248 sect_offset_str (this_cu
->sect_off
));
7250 /* If we're reading a TU directly from a DWO file, including a virtual DWO
7251 file (instead of going through the stub), short-circuit all of this. */
7252 if (this_cu
->reading_dwo_directly
)
7254 /* Narrow down the scope of possibilities to have to understand. */
7255 gdb_assert (this_cu
->is_debug_types
);
7256 gdb_assert (abbrev_table
== NULL
);
7257 init_tu_and_read_dwo_dies (this_cu
, per_objfile
, existing_cu
);
7261 /* This is cheap if the section is already read in. */
7262 section
->read (objfile
);
7264 begin_info_ptr
= info_ptr
= section
->buffer
+ to_underlying (this_cu
->sect_off
);
7266 abbrev_section
= get_abbrev_section_for_cu (this_cu
);
7270 if (existing_cu
!= nullptr)
7273 /* If this CU is from a DWO file we need to start over, we need to
7274 refetch the attributes from the skeleton CU.
7275 This could be optimized by retrieving those attributes from when we
7276 were here the first time: the previous comp_unit_die was stored in
7277 comp_unit_obstack. But there's no data yet that we need this
7279 if (cu
->dwo_unit
!= NULL
)
7280 rereading_dwo_cu
= 1;
7284 /* If an existing_cu is provided, a dwarf2_cu must not exist for this_cu
7285 in per_objfile yet. */
7286 gdb_assert (per_objfile
->get_cu (this_cu
) == nullptr);
7287 m_new_cu
.reset (new dwarf2_cu (this_cu
, per_objfile
));
7288 cu
= m_new_cu
.get ();
7291 /* Get the header. */
7292 if (to_underlying (cu
->header
.first_die_cu_offset
) != 0 && !rereading_dwo_cu
)
7294 /* We already have the header, there's no need to read it in again. */
7295 info_ptr
+= to_underlying (cu
->header
.first_die_cu_offset
);
7299 if (this_cu
->is_debug_types
)
7301 info_ptr
= read_and_check_comp_unit_head (per_objfile
, &cu
->header
,
7302 section
, abbrev_section
,
7303 info_ptr
, rcuh_kind::TYPE
);
7305 /* Since per_cu is the first member of struct signatured_type,
7306 we can go from a pointer to one to a pointer to the other. */
7307 sig_type
= (struct signatured_type
*) this_cu
;
7308 gdb_assert (sig_type
->signature
== cu
->header
.signature
);
7309 gdb_assert (sig_type
->type_offset_in_tu
7310 == cu
->header
.type_cu_offset_in_tu
);
7311 gdb_assert (this_cu
->sect_off
== cu
->header
.sect_off
);
7313 /* LENGTH has not been set yet for type units if we're
7314 using .gdb_index. */
7315 this_cu
->length
= cu
->header
.get_length ();
7317 /* Establish the type offset that can be used to lookup the type. */
7318 sig_type
->type_offset_in_section
=
7319 this_cu
->sect_off
+ to_underlying (sig_type
->type_offset_in_tu
);
7321 this_cu
->dwarf_version
= cu
->header
.version
;
7325 info_ptr
= read_and_check_comp_unit_head (per_objfile
, &cu
->header
,
7326 section
, abbrev_section
,
7328 rcuh_kind::COMPILE
);
7330 gdb_assert (this_cu
->sect_off
== cu
->header
.sect_off
);
7331 if (this_cu
->length
== 0)
7332 this_cu
->length
= cu
->header
.get_length ();
7334 gdb_assert (this_cu
->length
== cu
->header
.get_length ());
7335 this_cu
->dwarf_version
= cu
->header
.version
;
7339 /* Skip dummy compilation units. */
7340 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
7341 || peek_abbrev_code (abfd
, info_ptr
) == 0)
7347 /* If we don't have them yet, read the abbrevs for this compilation unit.
7348 And if we need to read them now, make sure they're freed when we're
7350 if (abbrev_table
!= NULL
)
7351 gdb_assert (cu
->header
.abbrev_sect_off
== abbrev_table
->sect_off
);
7354 abbrev_section
->read (objfile
);
7355 m_abbrev_table_holder
7356 = abbrev_table::read (abbrev_section
, cu
->header
.abbrev_sect_off
);
7357 abbrev_table
= m_abbrev_table_holder
.get ();
7360 /* Read the top level CU/TU die. */
7361 init_cu_die_reader (this, cu
, section
, NULL
, abbrev_table
);
7362 info_ptr
= read_full_die (this, &comp_unit_die
, info_ptr
);
7364 if (skip_partial
&& comp_unit_die
->tag
== DW_TAG_partial_unit
)
7370 /* If we are in a DWO stub, process it and then read in the "real" CU/TU
7371 from the DWO file. read_cutu_die_from_dwo will allocate the abbreviation
7372 table from the DWO file and pass the ownership over to us. It will be
7373 referenced from READER, so we must make sure to free it after we're done
7376 Note that if USE_EXISTING_OK != 0, and THIS_CU->cu already contains a
7377 DWO CU, that this test will fail (the attribute will not be present). */
7378 const char *dwo_name
= dwarf2_dwo_name (comp_unit_die
, cu
);
7379 if (dwo_name
!= nullptr)
7381 struct dwo_unit
*dwo_unit
;
7382 struct die_info
*dwo_comp_unit_die
;
7384 if (comp_unit_die
->has_children
)
7386 complaint (_("compilation unit with DW_AT_GNU_dwo_name"
7387 " has children (offset %s) [in module %s]"),
7388 sect_offset_str (this_cu
->sect_off
),
7389 bfd_get_filename (abfd
));
7391 dwo_unit
= lookup_dwo_unit (cu
, comp_unit_die
, dwo_name
);
7392 if (dwo_unit
!= NULL
)
7394 if (read_cutu_die_from_dwo (cu
, dwo_unit
,
7395 comp_unit_die
, NULL
,
7398 &m_dwo_abbrev_table
) == 0)
7404 comp_unit_die
= dwo_comp_unit_die
;
7408 /* Yikes, we couldn't find the rest of the DIE, we only have
7409 the stub. A complaint has already been logged. There's
7410 not much more we can do except pass on the stub DIE to
7411 die_reader_func. We don't want to throw an error on bad
7418 cutu_reader::keep ()
7420 /* Done, clean up. */
7421 gdb_assert (!dummy_p
);
7422 if (m_new_cu
!= NULL
)
7424 /* Save this dwarf2_cu in the per_objfile. The per_objfile owns it
7426 dwarf2_per_objfile
*per_objfile
= m_new_cu
->per_objfile
;
7427 per_objfile
->set_cu (m_this_cu
, m_new_cu
.release ());
7431 /* Read CU/TU THIS_CU but do not follow DW_AT_GNU_dwo_name (DW_AT_dwo_name)
7432 if present. DWO_FILE, if non-NULL, is the DWO file to read (the caller is
7433 assumed to have already done the lookup to find the DWO file).
7435 The caller is required to fill in THIS_CU->section, THIS_CU->offset, and
7436 THIS_CU->is_debug_types, but nothing else.
7438 We fill in THIS_CU->length.
7440 THIS_CU->cu is always freed when done.
7441 This is done in order to not leave THIS_CU->cu in a state where we have
7442 to care whether it refers to the "main" CU or the DWO CU.
7444 When parent_cu is passed, it is used to provide a default value for
7445 str_offsets_base and addr_base from the parent. */
7447 cutu_reader::cutu_reader (dwarf2_per_cu_data
*this_cu
,
7448 dwarf2_per_objfile
*per_objfile
,
7449 struct dwarf2_cu
*parent_cu
,
7450 struct dwo_file
*dwo_file
)
7451 : die_reader_specs
{},
7454 struct objfile
*objfile
= per_objfile
->objfile
;
7455 struct dwarf2_section_info
*section
= this_cu
->section
;
7456 bfd
*abfd
= section
->get_bfd_owner ();
7457 struct dwarf2_section_info
*abbrev_section
;
7458 const gdb_byte
*begin_info_ptr
, *info_ptr
;
7460 if (dwarf_die_debug
)
7461 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset %s\n",
7462 this_cu
->is_debug_types
? "type" : "comp",
7463 sect_offset_str (this_cu
->sect_off
));
7465 gdb_assert (per_objfile
->get_cu (this_cu
) == nullptr);
7467 abbrev_section
= (dwo_file
!= NULL
7468 ? &dwo_file
->sections
.abbrev
7469 : get_abbrev_section_for_cu (this_cu
));
7471 /* This is cheap if the section is already read in. */
7472 section
->read (objfile
);
7474 m_new_cu
.reset (new dwarf2_cu (this_cu
, per_objfile
));
7476 begin_info_ptr
= info_ptr
= section
->buffer
+ to_underlying (this_cu
->sect_off
);
7477 info_ptr
= read_and_check_comp_unit_head (per_objfile
, &m_new_cu
->header
,
7478 section
, abbrev_section
, info_ptr
,
7479 (this_cu
->is_debug_types
7481 : rcuh_kind::COMPILE
));
7483 if (parent_cu
!= nullptr)
7485 m_new_cu
->str_offsets_base
= parent_cu
->str_offsets_base
;
7486 m_new_cu
->addr_base
= parent_cu
->addr_base
;
7488 this_cu
->length
= m_new_cu
->header
.get_length ();
7490 /* Skip dummy compilation units. */
7491 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
7492 || peek_abbrev_code (abfd
, info_ptr
) == 0)
7498 abbrev_section
->read (objfile
);
7499 m_abbrev_table_holder
7500 = abbrev_table::read (abbrev_section
, m_new_cu
->header
.abbrev_sect_off
);
7502 init_cu_die_reader (this, m_new_cu
.get (), section
, dwo_file
,
7503 m_abbrev_table_holder
.get ());
7504 info_ptr
= read_full_die (this, &comp_unit_die
, info_ptr
);
7508 /* Type Unit Groups.
7510 Type Unit Groups are a way to collapse the set of all TUs (type units) into
7511 a more manageable set. The grouping is done by DW_AT_stmt_list entry
7512 so that all types coming from the same compilation (.o file) are grouped
7513 together. A future step could be to put the types in the same symtab as
7514 the CU the types ultimately came from. */
7517 hash_type_unit_group (const void *item
)
7519 const struct type_unit_group
*tu_group
7520 = (const struct type_unit_group
*) item
;
7522 return hash_stmt_list_entry (&tu_group
->hash
);
7526 eq_type_unit_group (const void *item_lhs
, const void *item_rhs
)
7528 const struct type_unit_group
*lhs
= (const struct type_unit_group
*) item_lhs
;
7529 const struct type_unit_group
*rhs
= (const struct type_unit_group
*) item_rhs
;
7531 return eq_stmt_list_entry (&lhs
->hash
, &rhs
->hash
);
7534 /* Allocate a hash table for type unit groups. */
7537 allocate_type_unit_groups_table ()
7539 return htab_up (htab_create_alloc (3,
7540 hash_type_unit_group
,
7542 NULL
, xcalloc
, xfree
));
7545 /* Type units that don't have DW_AT_stmt_list are grouped into their own
7546 partial symtabs. We combine several TUs per psymtab to not let the size
7547 of any one psymtab grow too big. */
7548 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB (1 << 31)
7549 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE 10
7551 /* Helper routine for get_type_unit_group.
7552 Create the type_unit_group object used to hold one or more TUs. */
7554 static struct type_unit_group
*
7555 create_type_unit_group (struct dwarf2_cu
*cu
, sect_offset line_offset_struct
)
7557 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
7558 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
7559 struct dwarf2_per_cu_data
*per_cu
;
7560 struct type_unit_group
*tu_group
;
7562 tu_group
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, type_unit_group
);
7563 per_cu
= &tu_group
->per_cu
;
7564 per_cu
->per_bfd
= per_bfd
;
7566 if (per_bfd
->using_index
)
7568 per_cu
->v
.quick
= OBSTACK_ZALLOC (&per_bfd
->obstack
,
7569 struct dwarf2_per_cu_quick_data
);
7573 unsigned int line_offset
= to_underlying (line_offset_struct
);
7574 dwarf2_psymtab
*pst
;
7577 /* Give the symtab a useful name for debug purposes. */
7578 if ((line_offset
& NO_STMT_LIST_TYPE_UNIT_PSYMTAB
) != 0)
7579 name
= string_printf ("<type_units_%d>",
7580 (line_offset
& ~NO_STMT_LIST_TYPE_UNIT_PSYMTAB
));
7582 name
= string_printf ("<type_units_at_0x%x>", line_offset
);
7584 pst
= create_partial_symtab (per_cu
, per_objfile
, name
.c_str ());
7585 pst
->anonymous
= true;
7588 tu_group
->hash
.dwo_unit
= cu
->dwo_unit
;
7589 tu_group
->hash
.line_sect_off
= line_offset_struct
;
7594 /* Look up the type_unit_group for type unit CU, and create it if necessary.
7595 STMT_LIST is a DW_AT_stmt_list attribute. */
7597 static struct type_unit_group
*
7598 get_type_unit_group (struct dwarf2_cu
*cu
, const struct attribute
*stmt_list
)
7600 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
7601 struct tu_stats
*tu_stats
= &per_objfile
->per_bfd
->tu_stats
;
7602 struct type_unit_group
*tu_group
;
7604 unsigned int line_offset
;
7605 struct type_unit_group type_unit_group_for_lookup
;
7607 if (per_objfile
->per_bfd
->type_unit_groups
== NULL
)
7608 per_objfile
->per_bfd
->type_unit_groups
= allocate_type_unit_groups_table ();
7610 /* Do we need to create a new group, or can we use an existing one? */
7612 if (stmt_list
!= nullptr && stmt_list
->form_is_unsigned ())
7614 line_offset
= stmt_list
->as_unsigned ();
7615 ++tu_stats
->nr_symtab_sharers
;
7619 /* Ugh, no stmt_list. Rare, but we have to handle it.
7620 We can do various things here like create one group per TU or
7621 spread them over multiple groups to split up the expansion work.
7622 To avoid worst case scenarios (too many groups or too large groups)
7623 we, umm, group them in bunches. */
7624 line_offset
= (NO_STMT_LIST_TYPE_UNIT_PSYMTAB
7625 | (tu_stats
->nr_stmt_less_type_units
7626 / NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE
));
7627 ++tu_stats
->nr_stmt_less_type_units
;
7630 type_unit_group_for_lookup
.hash
.dwo_unit
= cu
->dwo_unit
;
7631 type_unit_group_for_lookup
.hash
.line_sect_off
= (sect_offset
) line_offset
;
7632 slot
= htab_find_slot (per_objfile
->per_bfd
->type_unit_groups
.get (),
7633 &type_unit_group_for_lookup
, INSERT
);
7636 tu_group
= (struct type_unit_group
*) *slot
;
7637 gdb_assert (tu_group
!= NULL
);
7641 sect_offset line_offset_struct
= (sect_offset
) line_offset
;
7642 tu_group
= create_type_unit_group (cu
, line_offset_struct
);
7644 ++tu_stats
->nr_symtabs
;
7650 /* Partial symbol tables. */
7652 /* Create a psymtab named NAME and assign it to PER_CU.
7654 The caller must fill in the following details:
7655 dirname, textlow, texthigh. */
7657 static dwarf2_psymtab
*
7658 create_partial_symtab (dwarf2_per_cu_data
*per_cu
,
7659 dwarf2_per_objfile
*per_objfile
,
7662 struct objfile
*objfile
= per_objfile
->objfile
;
7663 dwarf2_psymtab
*pst
;
7665 pst
= new dwarf2_psymtab (name
, objfile
, per_cu
);
7667 pst
->psymtabs_addrmap_supported
= true;
7669 /* This is the glue that links PST into GDB's symbol API. */
7670 per_cu
->v
.psymtab
= pst
;
7675 /* DIE reader function for process_psymtab_comp_unit. */
7678 process_psymtab_comp_unit_reader (const struct die_reader_specs
*reader
,
7679 const gdb_byte
*info_ptr
,
7680 struct die_info
*comp_unit_die
,
7681 enum language pretend_language
)
7683 struct dwarf2_cu
*cu
= reader
->cu
;
7684 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
7685 struct objfile
*objfile
= per_objfile
->objfile
;
7686 struct gdbarch
*gdbarch
= objfile
->arch ();
7687 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
7689 CORE_ADDR best_lowpc
= 0, best_highpc
= 0;
7690 dwarf2_psymtab
*pst
;
7691 enum pc_bounds_kind cu_bounds_kind
;
7692 const char *filename
;
7694 gdb_assert (! per_cu
->is_debug_types
);
7696 prepare_one_comp_unit (cu
, comp_unit_die
, pretend_language
);
7698 /* Allocate a new partial symbol table structure. */
7699 gdb::unique_xmalloc_ptr
<char> debug_filename
;
7700 static const char artificial
[] = "<artificial>";
7701 filename
= dwarf2_string_attr (comp_unit_die
, DW_AT_name
, cu
);
7702 if (filename
== NULL
)
7704 else if (strcmp (filename
, artificial
) == 0)
7706 debug_filename
.reset (concat (artificial
, "@",
7707 sect_offset_str (per_cu
->sect_off
),
7709 filename
= debug_filename
.get ();
7712 pst
= create_partial_symtab (per_cu
, per_objfile
, filename
);
7714 /* This must be done before calling dwarf2_build_include_psymtabs. */
7715 pst
->dirname
= dwarf2_string_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
7717 baseaddr
= objfile
->text_section_offset ();
7719 dwarf2_find_base_address (comp_unit_die
, cu
);
7721 /* Possibly set the default values of LOWPC and HIGHPC from
7723 cu_bounds_kind
= dwarf2_get_pc_bounds (comp_unit_die
, &best_lowpc
,
7724 &best_highpc
, cu
, pst
);
7725 if (cu_bounds_kind
== PC_BOUNDS_HIGH_LOW
&& best_lowpc
< best_highpc
)
7728 = (gdbarch_adjust_dwarf2_addr (gdbarch
, best_lowpc
+ baseaddr
)
7731 = (gdbarch_adjust_dwarf2_addr (gdbarch
, best_highpc
+ baseaddr
)
7733 /* Store the contiguous range if it is not empty; it can be
7734 empty for CUs with no code. */
7735 addrmap_set_empty (objfile
->partial_symtabs
->psymtabs_addrmap
,
7739 /* Check if comp unit has_children.
7740 If so, read the rest of the partial symbols from this comp unit.
7741 If not, there's no more debug_info for this comp unit. */
7742 if (comp_unit_die
->has_children
)
7744 struct partial_die_info
*first_die
;
7745 CORE_ADDR lowpc
, highpc
;
7747 lowpc
= ((CORE_ADDR
) -1);
7748 highpc
= ((CORE_ADDR
) 0);
7750 first_die
= load_partial_dies (reader
, info_ptr
, 1);
7752 scan_partial_symbols (first_die
, &lowpc
, &highpc
,
7753 cu_bounds_kind
<= PC_BOUNDS_INVALID
, cu
);
7755 /* If we didn't find a lowpc, set it to highpc to avoid
7756 complaints from `maint check'. */
7757 if (lowpc
== ((CORE_ADDR
) -1))
7760 /* If the compilation unit didn't have an explicit address range,
7761 then use the information extracted from its child dies. */
7762 if (cu_bounds_kind
<= PC_BOUNDS_INVALID
)
7765 best_highpc
= highpc
;
7768 pst
->set_text_low (gdbarch_adjust_dwarf2_addr (gdbarch
,
7769 best_lowpc
+ baseaddr
)
7771 pst
->set_text_high (gdbarch_adjust_dwarf2_addr (gdbarch
,
7772 best_highpc
+ baseaddr
)
7777 if (!cu
->per_cu
->imported_symtabs_empty ())
7780 int len
= cu
->per_cu
->imported_symtabs_size ();
7782 /* Fill in 'dependencies' here; we fill in 'users' in a
7784 pst
->number_of_dependencies
= len
;
7786 = objfile
->partial_symtabs
->allocate_dependencies (len
);
7787 for (i
= 0; i
< len
; ++i
)
7789 pst
->dependencies
[i
]
7790 = cu
->per_cu
->imported_symtabs
->at (i
)->v
.psymtab
;
7793 cu
->per_cu
->imported_symtabs_free ();
7796 /* Get the list of files included in the current compilation unit,
7797 and build a psymtab for each of them. */
7798 dwarf2_build_include_psymtabs (cu
, comp_unit_die
, pst
);
7800 dwarf_read_debug_printf ("Psymtab for %s unit @%s: %s - %s"
7801 ", %d global, %d static syms",
7802 per_cu
->is_debug_types
? "type" : "comp",
7803 sect_offset_str (per_cu
->sect_off
),
7804 paddress (gdbarch
, pst
->text_low (objfile
)),
7805 paddress (gdbarch
, pst
->text_high (objfile
)),
7806 (int) pst
->global_psymbols
.size (),
7807 (int) pst
->static_psymbols
.size ());
7810 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
7811 Process compilation unit THIS_CU for a psymtab. */
7814 process_psymtab_comp_unit (dwarf2_per_cu_data
*this_cu
,
7815 dwarf2_per_objfile
*per_objfile
,
7816 bool want_partial_unit
,
7817 enum language pretend_language
)
7819 /* If this compilation unit was already read in, free the
7820 cached copy in order to read it in again. This is
7821 necessary because we skipped some symbols when we first
7822 read in the compilation unit (see load_partial_dies).
7823 This problem could be avoided, but the benefit is unclear. */
7824 per_objfile
->remove_cu (this_cu
);
7826 cutu_reader
reader (this_cu
, per_objfile
, nullptr, nullptr, false);
7828 switch (reader
.comp_unit_die
->tag
)
7830 case DW_TAG_compile_unit
:
7831 this_cu
->unit_type
= DW_UT_compile
;
7833 case DW_TAG_partial_unit
:
7834 this_cu
->unit_type
= DW_UT_partial
;
7844 else if (this_cu
->is_debug_types
)
7845 build_type_psymtabs_reader (&reader
, reader
.info_ptr
,
7846 reader
.comp_unit_die
);
7847 else if (want_partial_unit
7848 || reader
.comp_unit_die
->tag
!= DW_TAG_partial_unit
)
7849 process_psymtab_comp_unit_reader (&reader
, reader
.info_ptr
,
7850 reader
.comp_unit_die
,
7853 this_cu
->lang
= reader
.cu
->language
;
7855 /* Age out any secondary CUs. */
7856 per_objfile
->age_comp_units ();
7859 /* Reader function for build_type_psymtabs. */
7862 build_type_psymtabs_reader (const struct die_reader_specs
*reader
,
7863 const gdb_byte
*info_ptr
,
7864 struct die_info
*type_unit_die
)
7866 dwarf2_per_objfile
*per_objfile
= reader
->cu
->per_objfile
;
7867 struct dwarf2_cu
*cu
= reader
->cu
;
7868 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
7869 struct signatured_type
*sig_type
;
7870 struct type_unit_group
*tu_group
;
7871 struct attribute
*attr
;
7872 struct partial_die_info
*first_die
;
7873 CORE_ADDR lowpc
, highpc
;
7874 dwarf2_psymtab
*pst
;
7876 gdb_assert (per_cu
->is_debug_types
);
7877 sig_type
= (struct signatured_type
*) per_cu
;
7879 if (! type_unit_die
->has_children
)
7882 attr
= type_unit_die
->attr (DW_AT_stmt_list
);
7883 tu_group
= get_type_unit_group (cu
, attr
);
7885 if (tu_group
->tus
== nullptr)
7886 tu_group
->tus
= new std::vector
<signatured_type
*>;
7887 tu_group
->tus
->push_back (sig_type
);
7889 prepare_one_comp_unit (cu
, type_unit_die
, language_minimal
);
7890 pst
= create_partial_symtab (per_cu
, per_objfile
, "");
7891 pst
->anonymous
= true;
7893 first_die
= load_partial_dies (reader
, info_ptr
, 1);
7895 lowpc
= (CORE_ADDR
) -1;
7896 highpc
= (CORE_ADDR
) 0;
7897 scan_partial_symbols (first_die
, &lowpc
, &highpc
, 0, cu
);
7902 /* Struct used to sort TUs by their abbreviation table offset. */
7904 struct tu_abbrev_offset
7906 tu_abbrev_offset (signatured_type
*sig_type_
, sect_offset abbrev_offset_
)
7907 : sig_type (sig_type_
), abbrev_offset (abbrev_offset_
)
7910 signatured_type
*sig_type
;
7911 sect_offset abbrev_offset
;
7914 /* Helper routine for build_type_psymtabs_1, passed to std::sort. */
7917 sort_tu_by_abbrev_offset (const struct tu_abbrev_offset
&a
,
7918 const struct tu_abbrev_offset
&b
)
7920 return a
.abbrev_offset
< b
.abbrev_offset
;
7923 /* Efficiently read all the type units.
7924 This does the bulk of the work for build_type_psymtabs.
7926 The efficiency is because we sort TUs by the abbrev table they use and
7927 only read each abbrev table once. In one program there are 200K TUs
7928 sharing 8K abbrev tables.
7930 The main purpose of this function is to support building the
7931 dwarf2_per_objfile->per_bfd->type_unit_groups table.
7932 TUs typically share the DW_AT_stmt_list of the CU they came from, so we
7933 can collapse the search space by grouping them by stmt_list.
7934 The savings can be significant, in the same program from above the 200K TUs
7935 share 8K stmt_list tables.
7937 FUNC is expected to call get_type_unit_group, which will create the
7938 struct type_unit_group if necessary and add it to
7939 dwarf2_per_objfile->per_bfd->type_unit_groups. */
7942 build_type_psymtabs_1 (dwarf2_per_objfile
*per_objfile
)
7944 struct tu_stats
*tu_stats
= &per_objfile
->per_bfd
->tu_stats
;
7945 abbrev_table_up abbrev_table
;
7946 sect_offset abbrev_offset
;
7948 /* It's up to the caller to not call us multiple times. */
7949 gdb_assert (per_objfile
->per_bfd
->type_unit_groups
== NULL
);
7951 if (per_objfile
->per_bfd
->all_type_units
.empty ())
7954 /* TUs typically share abbrev tables, and there can be way more TUs than
7955 abbrev tables. Sort by abbrev table to reduce the number of times we
7956 read each abbrev table in.
7957 Alternatives are to punt or to maintain a cache of abbrev tables.
7958 This is simpler and efficient enough for now.
7960 Later we group TUs by their DW_AT_stmt_list value (as this defines the
7961 symtab to use). Typically TUs with the same abbrev offset have the same
7962 stmt_list value too so in practice this should work well.
7964 The basic algorithm here is:
7966 sort TUs by abbrev table
7967 for each TU with same abbrev table:
7968 read abbrev table if first user
7969 read TU top level DIE
7970 [IWBN if DWO skeletons had DW_AT_stmt_list]
7973 dwarf_read_debug_printf ("Building type unit groups ...");
7975 /* Sort in a separate table to maintain the order of all_type_units
7976 for .gdb_index: TU indices directly index all_type_units. */
7977 std::vector
<tu_abbrev_offset
> sorted_by_abbrev
;
7978 sorted_by_abbrev
.reserve (per_objfile
->per_bfd
->all_type_units
.size ());
7980 for (signatured_type
*sig_type
: per_objfile
->per_bfd
->all_type_units
)
7981 sorted_by_abbrev
.emplace_back
7982 (sig_type
, read_abbrev_offset (per_objfile
, sig_type
->per_cu
.section
,
7983 sig_type
->per_cu
.sect_off
));
7985 std::sort (sorted_by_abbrev
.begin (), sorted_by_abbrev
.end (),
7986 sort_tu_by_abbrev_offset
);
7988 abbrev_offset
= (sect_offset
) ~(unsigned) 0;
7990 for (const tu_abbrev_offset
&tu
: sorted_by_abbrev
)
7992 /* Switch to the next abbrev table if necessary. */
7993 if (abbrev_table
== NULL
7994 || tu
.abbrev_offset
!= abbrev_offset
)
7996 abbrev_offset
= tu
.abbrev_offset
;
7997 per_objfile
->per_bfd
->abbrev
.read (per_objfile
->objfile
);
7999 abbrev_table::read (&per_objfile
->per_bfd
->abbrev
, abbrev_offset
);
8000 ++tu_stats
->nr_uniq_abbrev_tables
;
8003 cutu_reader
reader (&tu
.sig_type
->per_cu
, per_objfile
,
8004 abbrev_table
.get (), nullptr, false);
8005 if (!reader
.dummy_p
)
8006 build_type_psymtabs_reader (&reader
, reader
.info_ptr
,
8007 reader
.comp_unit_die
);
8011 /* Print collected type unit statistics. */
8014 print_tu_stats (dwarf2_per_objfile
*per_objfile
)
8016 struct tu_stats
*tu_stats
= &per_objfile
->per_bfd
->tu_stats
;
8018 dwarf_read_debug_printf ("Type unit statistics:");
8019 dwarf_read_debug_printf (" %zu TUs",
8020 per_objfile
->per_bfd
->all_type_units
.size ());
8021 dwarf_read_debug_printf (" %d uniq abbrev tables",
8022 tu_stats
->nr_uniq_abbrev_tables
);
8023 dwarf_read_debug_printf (" %d symtabs from stmt_list entries",
8024 tu_stats
->nr_symtabs
);
8025 dwarf_read_debug_printf (" %d symtab sharers",
8026 tu_stats
->nr_symtab_sharers
);
8027 dwarf_read_debug_printf (" %d type units without a stmt_list",
8028 tu_stats
->nr_stmt_less_type_units
);
8029 dwarf_read_debug_printf (" %d all_type_units reallocs",
8030 tu_stats
->nr_all_type_units_reallocs
);
8033 /* Traversal function for build_type_psymtabs. */
8036 build_type_psymtab_dependencies (void **slot
, void *info
)
8038 dwarf2_per_objfile
*per_objfile
= (dwarf2_per_objfile
*) info
;
8039 struct objfile
*objfile
= per_objfile
->objfile
;
8040 struct type_unit_group
*tu_group
= (struct type_unit_group
*) *slot
;
8041 struct dwarf2_per_cu_data
*per_cu
= &tu_group
->per_cu
;
8042 dwarf2_psymtab
*pst
= per_cu
->v
.psymtab
;
8043 int len
= (tu_group
->tus
== nullptr) ? 0 : tu_group
->tus
->size ();
8046 gdb_assert (len
> 0);
8047 gdb_assert (per_cu
->type_unit_group_p ());
8049 pst
->number_of_dependencies
= len
;
8050 pst
->dependencies
= objfile
->partial_symtabs
->allocate_dependencies (len
);
8051 for (i
= 0; i
< len
; ++i
)
8053 struct signatured_type
*iter
= tu_group
->tus
->at (i
);
8054 gdb_assert (iter
->per_cu
.is_debug_types
);
8055 pst
->dependencies
[i
] = iter
->per_cu
.v
.psymtab
;
8056 iter
->type_unit_group
= tu_group
;
8059 delete tu_group
->tus
;
8060 tu_group
->tus
= nullptr;
8065 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
8066 Build partial symbol tables for the .debug_types comp-units. */
8069 build_type_psymtabs (dwarf2_per_objfile
*per_objfile
)
8071 if (! create_all_type_units (per_objfile
))
8074 build_type_psymtabs_1 (per_objfile
);
8077 /* Traversal function for process_skeletonless_type_unit.
8078 Read a TU in a DWO file and build partial symbols for it. */
8081 process_skeletonless_type_unit (void **slot
, void *info
)
8083 struct dwo_unit
*dwo_unit
= (struct dwo_unit
*) *slot
;
8084 dwarf2_per_objfile
*per_objfile
= (dwarf2_per_objfile
*) info
;
8085 struct signatured_type find_entry
, *entry
;
8087 /* If this TU doesn't exist in the global table, add it and read it in. */
8089 if (per_objfile
->per_bfd
->signatured_types
== NULL
)
8090 per_objfile
->per_bfd
->signatured_types
= allocate_signatured_type_table ();
8092 find_entry
.signature
= dwo_unit
->signature
;
8093 slot
= htab_find_slot (per_objfile
->per_bfd
->signatured_types
.get (),
8094 &find_entry
, INSERT
);
8095 /* If we've already seen this type there's nothing to do. What's happening
8096 is we're doing our own version of comdat-folding here. */
8100 /* This does the job that create_all_type_units would have done for
8102 entry
= add_type_unit (per_objfile
, dwo_unit
->signature
, slot
);
8103 fill_in_sig_entry_from_dwo_entry (per_objfile
, entry
, dwo_unit
);
8106 /* This does the job that build_type_psymtabs_1 would have done. */
8107 cutu_reader
reader (&entry
->per_cu
, per_objfile
, nullptr, nullptr, false);
8108 if (!reader
.dummy_p
)
8109 build_type_psymtabs_reader (&reader
, reader
.info_ptr
,
8110 reader
.comp_unit_die
);
8115 /* Traversal function for process_skeletonless_type_units. */
8118 process_dwo_file_for_skeletonless_type_units (void **slot
, void *info
)
8120 struct dwo_file
*dwo_file
= (struct dwo_file
*) *slot
;
8122 if (dwo_file
->tus
!= NULL
)
8123 htab_traverse_noresize (dwo_file
->tus
.get (),
8124 process_skeletonless_type_unit
, info
);
8129 /* Scan all TUs of DWO files, verifying we've processed them.
8130 This is needed in case a TU was emitted without its skeleton.
8131 Note: This can't be done until we know what all the DWO files are. */
8134 process_skeletonless_type_units (dwarf2_per_objfile
*per_objfile
)
8136 /* Skeletonless TUs in DWP files without .gdb_index is not supported yet. */
8137 if (get_dwp_file (per_objfile
) == NULL
8138 && per_objfile
->per_bfd
->dwo_files
!= NULL
)
8140 htab_traverse_noresize (per_objfile
->per_bfd
->dwo_files
.get (),
8141 process_dwo_file_for_skeletonless_type_units
,
8146 /* Compute the 'user' field for each psymtab in DWARF2_PER_OBJFILE. */
8149 set_partial_user (dwarf2_per_objfile
*per_objfile
)
8151 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
8153 dwarf2_psymtab
*pst
= per_cu
->v
.psymtab
;
8158 for (int j
= 0; j
< pst
->number_of_dependencies
; ++j
)
8160 /* Set the 'user' field only if it is not already set. */
8161 if (pst
->dependencies
[j
]->user
== NULL
)
8162 pst
->dependencies
[j
]->user
= pst
;
8167 /* Build the partial symbol table by doing a quick pass through the
8168 .debug_info and .debug_abbrev sections. */
8171 dwarf2_build_psymtabs_hard (dwarf2_per_objfile
*per_objfile
)
8173 struct objfile
*objfile
= per_objfile
->objfile
;
8175 dwarf_read_debug_printf ("Building psymtabs of objfile %s ...",
8176 objfile_name (objfile
));
8178 scoped_restore restore_reading_psyms
8179 = make_scoped_restore (&per_objfile
->per_bfd
->reading_partial_symbols
,
8182 per_objfile
->per_bfd
->info
.read (objfile
);
8184 /* Any cached compilation units will be linked by the per-objfile
8185 read_in_chain. Make sure to free them when we're done. */
8186 free_cached_comp_units
freer (per_objfile
);
8188 build_type_psymtabs (per_objfile
);
8190 create_all_comp_units (per_objfile
);
8192 /* Create a temporary address map on a temporary obstack. We later
8193 copy this to the final obstack. */
8194 auto_obstack temp_obstack
;
8196 scoped_restore save_psymtabs_addrmap
8197 = make_scoped_restore (&objfile
->partial_symtabs
->psymtabs_addrmap
,
8198 addrmap_create_mutable (&temp_obstack
));
8200 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
8202 if (per_cu
->v
.psymtab
!= NULL
)
8203 /* In case a forward DW_TAG_imported_unit has read the CU already. */
8205 process_psymtab_comp_unit (per_cu
, per_objfile
, false,
8209 /* This has to wait until we read the CUs, we need the list of DWOs. */
8210 process_skeletonless_type_units (per_objfile
);
8212 /* Now that all TUs have been processed we can fill in the dependencies. */
8213 if (per_objfile
->per_bfd
->type_unit_groups
!= NULL
)
8215 htab_traverse_noresize (per_objfile
->per_bfd
->type_unit_groups
.get (),
8216 build_type_psymtab_dependencies
, per_objfile
);
8219 if (dwarf_read_debug
> 0)
8220 print_tu_stats (per_objfile
);
8222 set_partial_user (per_objfile
);
8224 objfile
->partial_symtabs
->psymtabs_addrmap
8225 = addrmap_create_fixed (objfile
->partial_symtabs
->psymtabs_addrmap
,
8226 objfile
->partial_symtabs
->obstack ());
8227 /* At this point we want to keep the address map. */
8228 save_psymtabs_addrmap
.release ();
8230 dwarf_read_debug_printf ("Done building psymtabs of %s",
8231 objfile_name (objfile
));
8234 /* Load the partial DIEs for a secondary CU into memory.
8235 This is also used when rereading a primary CU with load_all_dies. */
8238 load_partial_comp_unit (dwarf2_per_cu_data
*this_cu
,
8239 dwarf2_per_objfile
*per_objfile
,
8240 dwarf2_cu
*existing_cu
)
8242 cutu_reader
reader (this_cu
, per_objfile
, nullptr, existing_cu
, false);
8244 if (!reader
.dummy_p
)
8246 prepare_one_comp_unit (reader
.cu
, reader
.comp_unit_die
,
8249 /* Check if comp unit has_children.
8250 If so, read the rest of the partial symbols from this comp unit.
8251 If not, there's no more debug_info for this comp unit. */
8252 if (reader
.comp_unit_die
->has_children
)
8253 load_partial_dies (&reader
, reader
.info_ptr
, 0);
8260 read_comp_units_from_section (dwarf2_per_objfile
*per_objfile
,
8261 struct dwarf2_section_info
*section
,
8262 struct dwarf2_section_info
*abbrev_section
,
8263 unsigned int is_dwz
)
8265 const gdb_byte
*info_ptr
;
8266 struct objfile
*objfile
= per_objfile
->objfile
;
8268 dwarf_read_debug_printf ("Reading %s for %s",
8269 section
->get_name (),
8270 section
->get_file_name ());
8272 section
->read (objfile
);
8274 info_ptr
= section
->buffer
;
8276 while (info_ptr
< section
->buffer
+ section
->size
)
8278 struct dwarf2_per_cu_data
*this_cu
;
8280 sect_offset sect_off
= (sect_offset
) (info_ptr
- section
->buffer
);
8282 comp_unit_head cu_header
;
8283 read_and_check_comp_unit_head (per_objfile
, &cu_header
, section
,
8284 abbrev_section
, info_ptr
,
8285 rcuh_kind::COMPILE
);
8287 /* Save the compilation unit for later lookup. */
8288 if (cu_header
.unit_type
!= DW_UT_type
)
8289 this_cu
= per_objfile
->per_bfd
->allocate_per_cu ();
8292 auto sig_type
= per_objfile
->per_bfd
->allocate_signatured_type ();
8293 sig_type
->signature
= cu_header
.signature
;
8294 sig_type
->type_offset_in_tu
= cu_header
.type_cu_offset_in_tu
;
8295 this_cu
= &sig_type
->per_cu
;
8297 this_cu
->is_debug_types
= (cu_header
.unit_type
== DW_UT_type
);
8298 this_cu
->sect_off
= sect_off
;
8299 this_cu
->length
= cu_header
.length
+ cu_header
.initial_length_size
;
8300 this_cu
->is_dwz
= is_dwz
;
8301 this_cu
->section
= section
;
8303 per_objfile
->per_bfd
->all_comp_units
.push_back (this_cu
);
8305 info_ptr
= info_ptr
+ this_cu
->length
;
8309 /* Create a list of all compilation units in OBJFILE.
8310 This is only done for -readnow and building partial symtabs. */
8313 create_all_comp_units (dwarf2_per_objfile
*per_objfile
)
8315 gdb_assert (per_objfile
->per_bfd
->all_comp_units
.empty ());
8316 read_comp_units_from_section (per_objfile
, &per_objfile
->per_bfd
->info
,
8317 &per_objfile
->per_bfd
->abbrev
, 0);
8319 dwz_file
*dwz
= dwarf2_get_dwz_file (per_objfile
->per_bfd
);
8321 read_comp_units_from_section (per_objfile
, &dwz
->info
, &dwz
->abbrev
, 1);
8324 /* Process all loaded DIEs for compilation unit CU, starting at
8325 FIRST_DIE. The caller should pass SET_ADDRMAP == 1 if the compilation
8326 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
8327 DW_AT_ranges). See the comments of add_partial_subprogram on how
8328 SET_ADDRMAP is used and how *LOWPC and *HIGHPC are updated. */
8331 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
8332 CORE_ADDR
*highpc
, int set_addrmap
,
8333 struct dwarf2_cu
*cu
)
8335 struct partial_die_info
*pdi
;
8337 /* Now, march along the PDI's, descending into ones which have
8338 interesting children but skipping the children of the other ones,
8339 until we reach the end of the compilation unit. */
8347 /* Anonymous namespaces or modules have no name but have interesting
8348 children, so we need to look at them. Ditto for anonymous
8351 if (pdi
->raw_name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
8352 || pdi
->tag
== DW_TAG_module
|| pdi
->tag
== DW_TAG_enumeration_type
8353 || pdi
->tag
== DW_TAG_imported_unit
8354 || pdi
->tag
== DW_TAG_inlined_subroutine
)
8358 case DW_TAG_subprogram
:
8359 case DW_TAG_inlined_subroutine
:
8360 add_partial_subprogram (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
8361 if (cu
->language
== language_cplus
)
8362 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
,
8365 case DW_TAG_constant
:
8366 case DW_TAG_variable
:
8367 case DW_TAG_typedef
:
8368 case DW_TAG_union_type
:
8369 if (!pdi
->is_declaration
8370 || (pdi
->tag
== DW_TAG_variable
&& pdi
->is_external
))
8372 add_partial_symbol (pdi
, cu
);
8375 case DW_TAG_class_type
:
8376 case DW_TAG_interface_type
:
8377 case DW_TAG_structure_type
:
8378 if (!pdi
->is_declaration
)
8380 add_partial_symbol (pdi
, cu
);
8382 if ((cu
->language
== language_rust
8383 || cu
->language
== language_cplus
) && pdi
->has_children
)
8384 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
,
8387 case DW_TAG_enumeration_type
:
8388 if (!pdi
->is_declaration
)
8389 add_partial_enumeration (pdi
, cu
);
8391 case DW_TAG_base_type
:
8392 case DW_TAG_subrange_type
:
8393 /* File scope base type definitions are added to the partial
8395 add_partial_symbol (pdi
, cu
);
8397 case DW_TAG_namespace
:
8398 add_partial_namespace (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
8401 if (!pdi
->is_declaration
)
8402 add_partial_module (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
8404 case DW_TAG_imported_unit
:
8406 struct dwarf2_per_cu_data
*per_cu
;
8408 /* For now we don't handle imported units in type units. */
8409 if (cu
->per_cu
->is_debug_types
)
8411 error (_("Dwarf Error: DW_TAG_imported_unit is not"
8412 " supported in type units [in module %s]"),
8413 objfile_name (cu
->per_objfile
->objfile
));
8416 per_cu
= dwarf2_find_containing_comp_unit
8417 (pdi
->d
.sect_off
, pdi
->is_dwz
, cu
->per_objfile
);
8419 /* Go read the partial unit, if needed. */
8420 if (per_cu
->v
.psymtab
== NULL
)
8421 process_psymtab_comp_unit (per_cu
, cu
->per_objfile
, true,
8424 cu
->per_cu
->imported_symtabs_push (per_cu
);
8427 case DW_TAG_imported_declaration
:
8428 add_partial_symbol (pdi
, cu
);
8435 /* If the die has a sibling, skip to the sibling. */
8437 pdi
= pdi
->die_sibling
;
8441 /* Functions used to compute the fully scoped name of a partial DIE.
8443 Normally, this is simple. For C++, the parent DIE's fully scoped
8444 name is concatenated with "::" and the partial DIE's name.
8445 Enumerators are an exception; they use the scope of their parent
8446 enumeration type, i.e. the name of the enumeration type is not
8447 prepended to the enumerator.
8449 There are two complexities. One is DW_AT_specification; in this
8450 case "parent" means the parent of the target of the specification,
8451 instead of the direct parent of the DIE. The other is compilers
8452 which do not emit DW_TAG_namespace; in this case we try to guess
8453 the fully qualified name of structure types from their members'
8454 linkage names. This must be done using the DIE's children rather
8455 than the children of any DW_AT_specification target. We only need
8456 to do this for structures at the top level, i.e. if the target of
8457 any DW_AT_specification (if any; otherwise the DIE itself) does not
8460 /* Compute the scope prefix associated with PDI's parent, in
8461 compilation unit CU. The result will be allocated on CU's
8462 comp_unit_obstack, or a copy of the already allocated PDI->NAME
8463 field. NULL is returned if no prefix is necessary. */
8465 partial_die_parent_scope (struct partial_die_info
*pdi
,
8466 struct dwarf2_cu
*cu
)
8468 const char *grandparent_scope
;
8469 struct partial_die_info
*parent
, *real_pdi
;
8471 /* We need to look at our parent DIE; if we have a DW_AT_specification,
8472 then this means the parent of the specification DIE. */
8475 while (real_pdi
->has_specification
)
8477 auto res
= find_partial_die (real_pdi
->spec_offset
,
8478 real_pdi
->spec_is_dwz
, cu
);
8483 parent
= real_pdi
->die_parent
;
8487 if (parent
->scope_set
)
8488 return parent
->scope
;
8492 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
8494 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
8495 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
8496 Work around this problem here. */
8497 if (cu
->language
== language_cplus
8498 && parent
->tag
== DW_TAG_namespace
8499 && strcmp (parent
->name (cu
), "::") == 0
8500 && grandparent_scope
== NULL
)
8502 parent
->scope
= NULL
;
8503 parent
->scope_set
= 1;
8507 /* Nested subroutines in Fortran get a prefix. */
8508 if (pdi
->tag
== DW_TAG_enumerator
)
8509 /* Enumerators should not get the name of the enumeration as a prefix. */
8510 parent
->scope
= grandparent_scope
;
8511 else if (parent
->tag
== DW_TAG_namespace
8512 || parent
->tag
== DW_TAG_module
8513 || parent
->tag
== DW_TAG_structure_type
8514 || parent
->tag
== DW_TAG_class_type
8515 || parent
->tag
== DW_TAG_interface_type
8516 || parent
->tag
== DW_TAG_union_type
8517 || parent
->tag
== DW_TAG_enumeration_type
8518 || (cu
->language
== language_fortran
8519 && parent
->tag
== DW_TAG_subprogram
8520 && pdi
->tag
== DW_TAG_subprogram
))
8522 if (grandparent_scope
== NULL
)
8523 parent
->scope
= parent
->name (cu
);
8525 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
,
8527 parent
->name (cu
), 0, cu
);
8531 /* FIXME drow/2004-04-01: What should we be doing with
8532 function-local names? For partial symbols, we should probably be
8534 complaint (_("unhandled containing DIE tag %s for DIE at %s"),
8535 dwarf_tag_name (parent
->tag
),
8536 sect_offset_str (pdi
->sect_off
));
8537 parent
->scope
= grandparent_scope
;
8540 parent
->scope_set
= 1;
8541 return parent
->scope
;
8544 /* Return the fully scoped name associated with PDI, from compilation unit
8545 CU. The result will be allocated with malloc. */
8547 static gdb::unique_xmalloc_ptr
<char>
8548 partial_die_full_name (struct partial_die_info
*pdi
,
8549 struct dwarf2_cu
*cu
)
8551 const char *parent_scope
;
8553 /* If this is a template instantiation, we can not work out the
8554 template arguments from partial DIEs. So, unfortunately, we have
8555 to go through the full DIEs. At least any work we do building
8556 types here will be reused if full symbols are loaded later. */
8557 if (pdi
->has_template_arguments
)
8561 if (pdi
->name (cu
) != NULL
&& strchr (pdi
->name (cu
), '<') == NULL
)
8563 struct die_info
*die
;
8564 struct attribute attr
;
8565 struct dwarf2_cu
*ref_cu
= cu
;
8567 /* DW_FORM_ref_addr is using section offset. */
8568 attr
.name
= (enum dwarf_attribute
) 0;
8569 attr
.form
= DW_FORM_ref_addr
;
8570 attr
.u
.unsnd
= to_underlying (pdi
->sect_off
);
8571 die
= follow_die_ref (NULL
, &attr
, &ref_cu
);
8573 return make_unique_xstrdup (dwarf2_full_name (NULL
, die
, ref_cu
));
8577 parent_scope
= partial_die_parent_scope (pdi
, cu
);
8578 if (parent_scope
== NULL
)
8581 return gdb::unique_xmalloc_ptr
<char> (typename_concat (NULL
, parent_scope
,
8587 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
8589 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
8590 struct objfile
*objfile
= per_objfile
->objfile
;
8591 struct gdbarch
*gdbarch
= objfile
->arch ();
8593 const char *actual_name
= NULL
;
8596 baseaddr
= objfile
->text_section_offset ();
8598 gdb::unique_xmalloc_ptr
<char> built_actual_name
8599 = partial_die_full_name (pdi
, cu
);
8600 if (built_actual_name
!= NULL
)
8601 actual_name
= built_actual_name
.get ();
8603 if (actual_name
== NULL
)
8604 actual_name
= pdi
->name (cu
);
8606 partial_symbol psymbol
;
8607 memset (&psymbol
, 0, sizeof (psymbol
));
8608 psymbol
.ginfo
.set_language (cu
->language
, &objfile
->objfile_obstack
);
8609 psymbol
.ginfo
.section
= -1;
8611 /* The code below indicates that the psymbol should be installed by
8613 gdb::optional
<psymbol_placement
> where
;
8617 case DW_TAG_inlined_subroutine
:
8618 case DW_TAG_subprogram
:
8619 addr
= (gdbarch_adjust_dwarf2_addr (gdbarch
, pdi
->lowpc
+ baseaddr
)
8621 if (pdi
->is_external
8622 || cu
->language
== language_ada
8623 || (cu
->language
== language_fortran
8624 && pdi
->die_parent
!= NULL
8625 && pdi
->die_parent
->tag
== DW_TAG_subprogram
))
8627 /* Normally, only "external" DIEs are part of the global scope.
8628 But in Ada and Fortran, we want to be able to access nested
8629 procedures globally. So all Ada and Fortran subprograms are
8630 stored in the global scope. */
8631 where
= psymbol_placement::GLOBAL
;
8634 where
= psymbol_placement::STATIC
;
8636 psymbol
.domain
= VAR_DOMAIN
;
8637 psymbol
.aclass
= LOC_BLOCK
;
8638 psymbol
.ginfo
.section
= SECT_OFF_TEXT (objfile
);
8639 psymbol
.ginfo
.value
.address
= addr
;
8641 if (pdi
->main_subprogram
&& actual_name
!= NULL
)
8642 set_objfile_main_name (objfile
, actual_name
, cu
->language
);
8644 case DW_TAG_constant
:
8645 psymbol
.domain
= VAR_DOMAIN
;
8646 psymbol
.aclass
= LOC_STATIC
;
8647 where
= (pdi
->is_external
8648 ? psymbol_placement::GLOBAL
8649 : psymbol_placement::STATIC
);
8651 case DW_TAG_variable
:
8653 addr
= decode_locdesc (pdi
->d
.locdesc
, cu
);
8657 && !per_objfile
->per_bfd
->has_section_at_zero
)
8659 /* A global or static variable may also have been stripped
8660 out by the linker if unused, in which case its address
8661 will be nullified; do not add such variables into partial
8662 symbol table then. */
8664 else if (pdi
->is_external
)
8667 Don't enter into the minimal symbol tables as there is
8668 a minimal symbol table entry from the ELF symbols already.
8669 Enter into partial symbol table if it has a location
8670 descriptor or a type.
8671 If the location descriptor is missing, new_symbol will create
8672 a LOC_UNRESOLVED symbol, the address of the variable will then
8673 be determined from the minimal symbol table whenever the variable
8675 The address for the partial symbol table entry is not
8676 used by GDB, but it comes in handy for debugging partial symbol
8679 if (pdi
->d
.locdesc
|| pdi
->has_type
)
8681 psymbol
.domain
= VAR_DOMAIN
;
8682 psymbol
.aclass
= LOC_STATIC
;
8683 psymbol
.ginfo
.section
= SECT_OFF_TEXT (objfile
);
8684 psymbol
.ginfo
.value
.address
= addr
;
8685 where
= psymbol_placement::GLOBAL
;
8690 int has_loc
= pdi
->d
.locdesc
!= NULL
;
8692 /* Static Variable. Skip symbols whose value we cannot know (those
8693 without location descriptors or constant values). */
8694 if (!has_loc
&& !pdi
->has_const_value
)
8697 psymbol
.domain
= VAR_DOMAIN
;
8698 psymbol
.aclass
= LOC_STATIC
;
8699 psymbol
.ginfo
.section
= SECT_OFF_TEXT (objfile
);
8701 psymbol
.ginfo
.value
.address
= addr
;
8702 where
= psymbol_placement::STATIC
;
8705 case DW_TAG_array_type
:
8706 case DW_TAG_typedef
:
8707 case DW_TAG_base_type
:
8708 case DW_TAG_subrange_type
:
8709 psymbol
.domain
= VAR_DOMAIN
;
8710 psymbol
.aclass
= LOC_TYPEDEF
;
8711 where
= psymbol_placement::STATIC
;
8713 case DW_TAG_imported_declaration
:
8714 case DW_TAG_namespace
:
8715 psymbol
.domain
= VAR_DOMAIN
;
8716 psymbol
.aclass
= LOC_TYPEDEF
;
8717 where
= psymbol_placement::GLOBAL
;
8720 /* With Fortran 77 there might be a "BLOCK DATA" module
8721 available without any name. If so, we skip the module as it
8722 doesn't bring any value. */
8723 if (actual_name
!= nullptr)
8725 psymbol
.domain
= MODULE_DOMAIN
;
8726 psymbol
.aclass
= LOC_TYPEDEF
;
8727 where
= psymbol_placement::GLOBAL
;
8730 case DW_TAG_class_type
:
8731 case DW_TAG_interface_type
:
8732 case DW_TAG_structure_type
:
8733 case DW_TAG_union_type
:
8734 case DW_TAG_enumeration_type
:
8735 /* Skip external references. The DWARF standard says in the section
8736 about "Structure, Union, and Class Type Entries": "An incomplete
8737 structure, union or class type is represented by a structure,
8738 union or class entry that does not have a byte size attribute
8739 and that has a DW_AT_declaration attribute." */
8740 if (!pdi
->has_byte_size
&& pdi
->is_declaration
)
8743 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
8744 static vs. global. */
8745 psymbol
.domain
= STRUCT_DOMAIN
;
8746 psymbol
.aclass
= LOC_TYPEDEF
;
8747 where
= (cu
->language
== language_cplus
8748 ? psymbol_placement::GLOBAL
8749 : psymbol_placement::STATIC
);
8751 case DW_TAG_enumerator
:
8752 psymbol
.domain
= VAR_DOMAIN
;
8753 psymbol
.aclass
= LOC_CONST
;
8754 where
= (cu
->language
== language_cplus
8755 ? psymbol_placement::GLOBAL
8756 : psymbol_placement::STATIC
);
8762 if (where
.has_value ())
8764 if (built_actual_name
!= nullptr)
8765 actual_name
= objfile
->intern (actual_name
);
8766 if (pdi
->linkage_name
== nullptr || cu
->language
== language_ada
)
8767 psymbol
.ginfo
.set_linkage_name (actual_name
);
8770 psymbol
.ginfo
.set_demangled_name (actual_name
,
8771 &objfile
->objfile_obstack
);
8772 psymbol
.ginfo
.set_linkage_name (pdi
->linkage_name
);
8774 cu
->per_cu
->v
.psymtab
->add_psymbol (psymbol
, *where
, objfile
);
8778 /* Read a partial die corresponding to a namespace; also, add a symbol
8779 corresponding to that namespace to the symbol table. NAMESPACE is
8780 the name of the enclosing namespace. */
8783 add_partial_namespace (struct partial_die_info
*pdi
,
8784 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
8785 int set_addrmap
, struct dwarf2_cu
*cu
)
8787 /* Add a symbol for the namespace. */
8789 add_partial_symbol (pdi
, cu
);
8791 /* Now scan partial symbols in that namespace. */
8793 if (pdi
->has_children
)
8794 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, set_addrmap
, cu
);
8797 /* Read a partial die corresponding to a Fortran module. */
8800 add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
8801 CORE_ADDR
*highpc
, int set_addrmap
, struct dwarf2_cu
*cu
)
8803 /* Add a symbol for the namespace. */
8805 add_partial_symbol (pdi
, cu
);
8807 /* Now scan partial symbols in that module. */
8809 if (pdi
->has_children
)
8810 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, set_addrmap
, cu
);
8813 /* Read a partial die corresponding to a subprogram or an inlined
8814 subprogram and create a partial symbol for that subprogram.
8815 When the CU language allows it, this routine also defines a partial
8816 symbol for each nested subprogram that this subprogram contains.
8817 If SET_ADDRMAP is true, record the covered ranges in the addrmap.
8818 Set *LOWPC and *HIGHPC to the lowest and highest PC values found in PDI.
8820 PDI may also be a lexical block, in which case we simply search
8821 recursively for subprograms defined inside that lexical block.
8822 Again, this is only performed when the CU language allows this
8823 type of definitions. */
8826 add_partial_subprogram (struct partial_die_info
*pdi
,
8827 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
8828 int set_addrmap
, struct dwarf2_cu
*cu
)
8830 if (pdi
->tag
== DW_TAG_subprogram
|| pdi
->tag
== DW_TAG_inlined_subroutine
)
8832 if (pdi
->has_pc_info
)
8834 if (pdi
->lowpc
< *lowpc
)
8835 *lowpc
= pdi
->lowpc
;
8836 if (pdi
->highpc
> *highpc
)
8837 *highpc
= pdi
->highpc
;
8840 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
8841 struct gdbarch
*gdbarch
= objfile
->arch ();
8843 CORE_ADDR this_highpc
;
8844 CORE_ADDR this_lowpc
;
8846 baseaddr
= objfile
->text_section_offset ();
8848 = (gdbarch_adjust_dwarf2_addr (gdbarch
,
8849 pdi
->lowpc
+ baseaddr
)
8852 = (gdbarch_adjust_dwarf2_addr (gdbarch
,
8853 pdi
->highpc
+ baseaddr
)
8855 addrmap_set_empty (objfile
->partial_symtabs
->psymtabs_addrmap
,
8856 this_lowpc
, this_highpc
- 1,
8857 cu
->per_cu
->v
.psymtab
);
8861 if (pdi
->has_pc_info
|| (!pdi
->is_external
&& pdi
->may_be_inlined
))
8863 if (!pdi
->is_declaration
)
8864 /* Ignore subprogram DIEs that do not have a name, they are
8865 illegal. Do not emit a complaint at this point, we will
8866 do so when we convert this psymtab into a symtab. */
8868 add_partial_symbol (pdi
, cu
);
8872 if (! pdi
->has_children
)
8875 if (cu
->language
== language_ada
|| cu
->language
== language_fortran
)
8877 pdi
= pdi
->die_child
;
8881 if (pdi
->tag
== DW_TAG_subprogram
8882 || pdi
->tag
== DW_TAG_inlined_subroutine
8883 || pdi
->tag
== DW_TAG_lexical_block
)
8884 add_partial_subprogram (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
8885 pdi
= pdi
->die_sibling
;
8890 /* Read a partial die corresponding to an enumeration type. */
8893 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
8894 struct dwarf2_cu
*cu
)
8896 struct partial_die_info
*pdi
;
8898 if (enum_pdi
->name (cu
) != NULL
)
8899 add_partial_symbol (enum_pdi
, cu
);
8901 pdi
= enum_pdi
->die_child
;
8904 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->raw_name
== NULL
)
8905 complaint (_("malformed enumerator DIE ignored"));
8907 add_partial_symbol (pdi
, cu
);
8908 pdi
= pdi
->die_sibling
;
8912 /* Return the initial uleb128 in the die at INFO_PTR. */
8915 peek_abbrev_code (bfd
*abfd
, const gdb_byte
*info_ptr
)
8917 unsigned int bytes_read
;
8919 return read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
8922 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit
8923 READER::CU. Use READER::ABBREV_TABLE to lookup any abbreviation.
8925 Return the corresponding abbrev, or NULL if the number is zero (indicating
8926 an empty DIE). In either case *BYTES_READ will be set to the length of
8927 the initial number. */
8929 static struct abbrev_info
*
8930 peek_die_abbrev (const die_reader_specs
&reader
,
8931 const gdb_byte
*info_ptr
, unsigned int *bytes_read
)
8933 dwarf2_cu
*cu
= reader
.cu
;
8934 bfd
*abfd
= cu
->per_objfile
->objfile
->obfd
;
8935 unsigned int abbrev_number
8936 = read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
8938 if (abbrev_number
== 0)
8941 abbrev_info
*abbrev
= reader
.abbrev_table
->lookup_abbrev (abbrev_number
);
8944 error (_("Dwarf Error: Could not find abbrev number %d in %s"
8945 " at offset %s [in module %s]"),
8946 abbrev_number
, cu
->per_cu
->is_debug_types
? "TU" : "CU",
8947 sect_offset_str (cu
->header
.sect_off
), bfd_get_filename (abfd
));
8953 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
8954 Returns a pointer to the end of a series of DIEs, terminated by an empty
8955 DIE. Any children of the skipped DIEs will also be skipped. */
8957 static const gdb_byte
*
8958 skip_children (const struct die_reader_specs
*reader
, const gdb_byte
*info_ptr
)
8962 unsigned int bytes_read
;
8963 abbrev_info
*abbrev
= peek_die_abbrev (*reader
, info_ptr
, &bytes_read
);
8966 return info_ptr
+ bytes_read
;
8968 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
8972 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
8973 INFO_PTR should point just after the initial uleb128 of a DIE, and the
8974 abbrev corresponding to that skipped uleb128 should be passed in
8975 ABBREV. Returns a pointer to this DIE's sibling, skipping any
8978 static const gdb_byte
*
8979 skip_one_die (const struct die_reader_specs
*reader
, const gdb_byte
*info_ptr
,
8980 struct abbrev_info
*abbrev
)
8982 unsigned int bytes_read
;
8983 struct attribute attr
;
8984 bfd
*abfd
= reader
->abfd
;
8985 struct dwarf2_cu
*cu
= reader
->cu
;
8986 const gdb_byte
*buffer
= reader
->buffer
;
8987 const gdb_byte
*buffer_end
= reader
->buffer_end
;
8988 unsigned int form
, i
;
8990 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
8992 /* The only abbrev we care about is DW_AT_sibling. */
8993 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
8995 read_attribute (reader
, &attr
, &abbrev
->attrs
[i
], info_ptr
);
8996 if (attr
.form
== DW_FORM_ref_addr
)
8997 complaint (_("ignoring absolute DW_AT_sibling"));
9000 sect_offset off
= attr
.get_ref_die_offset ();
9001 const gdb_byte
*sibling_ptr
= buffer
+ to_underlying (off
);
9003 if (sibling_ptr
< info_ptr
)
9004 complaint (_("DW_AT_sibling points backwards"));
9005 else if (sibling_ptr
> reader
->buffer_end
)
9006 reader
->die_section
->overflow_complaint ();
9012 /* If it isn't DW_AT_sibling, skip this attribute. */
9013 form
= abbrev
->attrs
[i
].form
;
9017 case DW_FORM_ref_addr
:
9018 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
9019 and later it is offset sized. */
9020 if (cu
->header
.version
== 2)
9021 info_ptr
+= cu
->header
.addr_size
;
9023 info_ptr
+= cu
->header
.offset_size
;
9025 case DW_FORM_GNU_ref_alt
:
9026 info_ptr
+= cu
->header
.offset_size
;
9029 info_ptr
+= cu
->header
.addr_size
;
9037 case DW_FORM_flag_present
:
9038 case DW_FORM_implicit_const
:
9055 case DW_FORM_ref_sig8
:
9058 case DW_FORM_data16
:
9061 case DW_FORM_string
:
9062 read_direct_string (abfd
, info_ptr
, &bytes_read
);
9063 info_ptr
+= bytes_read
;
9065 case DW_FORM_sec_offset
:
9067 case DW_FORM_GNU_strp_alt
:
9068 info_ptr
+= cu
->header
.offset_size
;
9070 case DW_FORM_exprloc
:
9072 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
9073 info_ptr
+= bytes_read
;
9075 case DW_FORM_block1
:
9076 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
9078 case DW_FORM_block2
:
9079 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
9081 case DW_FORM_block4
:
9082 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
9088 case DW_FORM_ref_udata
:
9089 case DW_FORM_GNU_addr_index
:
9090 case DW_FORM_GNU_str_index
:
9091 case DW_FORM_rnglistx
:
9092 case DW_FORM_loclistx
:
9093 info_ptr
= safe_skip_leb128 (info_ptr
, buffer_end
);
9095 case DW_FORM_indirect
:
9096 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
9097 info_ptr
+= bytes_read
;
9098 /* We need to continue parsing from here, so just go back to
9100 goto skip_attribute
;
9103 error (_("Dwarf Error: Cannot handle %s "
9104 "in DWARF reader [in module %s]"),
9105 dwarf_form_name (form
),
9106 bfd_get_filename (abfd
));
9110 if (abbrev
->has_children
)
9111 return skip_children (reader
, info_ptr
);
9116 /* Locate ORIG_PDI's sibling.
9117 INFO_PTR should point to the start of the next DIE after ORIG_PDI. */
9119 static const gdb_byte
*
9120 locate_pdi_sibling (const struct die_reader_specs
*reader
,
9121 struct partial_die_info
*orig_pdi
,
9122 const gdb_byte
*info_ptr
)
9124 /* Do we know the sibling already? */
9126 if (orig_pdi
->sibling
)
9127 return orig_pdi
->sibling
;
9129 /* Are there any children to deal with? */
9131 if (!orig_pdi
->has_children
)
9134 /* Skip the children the long way. */
9136 return skip_children (reader
, info_ptr
);
9139 /* Expand this partial symbol table into a full symbol table. SELF is
9143 dwarf2_psymtab::read_symtab (struct objfile
*objfile
)
9145 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
9147 gdb_assert (!per_objfile
->symtab_set_p (per_cu_data
));
9149 /* If this psymtab is constructed from a debug-only objfile, the
9150 has_section_at_zero flag will not necessarily be correct. We
9151 can get the correct value for this flag by looking at the data
9152 associated with the (presumably stripped) associated objfile. */
9153 if (objfile
->separate_debug_objfile_backlink
)
9155 dwarf2_per_objfile
*per_objfile_backlink
9156 = get_dwarf2_per_objfile (objfile
->separate_debug_objfile_backlink
);
9158 per_objfile
->per_bfd
->has_section_at_zero
9159 = per_objfile_backlink
->per_bfd
->has_section_at_zero
;
9162 expand_psymtab (objfile
);
9164 process_cu_includes (per_objfile
);
9167 /* Reading in full CUs. */
9169 /* Add PER_CU to the queue. */
9172 queue_comp_unit (dwarf2_per_cu_data
*per_cu
,
9173 dwarf2_per_objfile
*per_objfile
,
9174 enum language pretend_language
)
9177 per_cu
->per_bfd
->queue
.emplace (per_cu
, per_objfile
, pretend_language
);
9180 /* If PER_CU is not yet queued, add it to the queue.
9181 If DEPENDENT_CU is non-NULL, it has a reference to PER_CU so add a
9183 The result is non-zero if PER_CU was queued, otherwise the result is zero
9184 meaning either PER_CU is already queued or it is already loaded.
9186 N.B. There is an invariant here that if a CU is queued then it is loaded.
9187 The caller is required to load PER_CU if we return non-zero. */
9190 maybe_queue_comp_unit (struct dwarf2_cu
*dependent_cu
,
9191 dwarf2_per_cu_data
*per_cu
,
9192 dwarf2_per_objfile
*per_objfile
,
9193 enum language pretend_language
)
9195 /* We may arrive here during partial symbol reading, if we need full
9196 DIEs to process an unusual case (e.g. template arguments). Do
9197 not queue PER_CU, just tell our caller to load its DIEs. */
9198 if (per_cu
->per_bfd
->reading_partial_symbols
)
9200 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
9202 if (cu
== NULL
|| cu
->dies
== NULL
)
9207 /* Mark the dependence relation so that we don't flush PER_CU
9209 if (dependent_cu
!= NULL
)
9210 dwarf2_add_dependence (dependent_cu
, per_cu
);
9212 /* If it's already on the queue, we have nothing to do. */
9215 /* Verify the invariant that if a CU is queued for expansion, its DIEs are
9217 gdb_assert (per_objfile
->get_cu (per_cu
) != nullptr);
9221 /* If the compilation unit is already loaded, just mark it as
9223 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
9230 /* Add it to the queue. */
9231 queue_comp_unit (per_cu
, per_objfile
, pretend_language
);
9236 /* Process the queue. */
9239 process_queue (dwarf2_per_objfile
*per_objfile
)
9241 dwarf_read_debug_printf ("Expanding one or more symtabs of objfile %s ...",
9242 objfile_name (per_objfile
->objfile
));
9244 /* The queue starts out with one item, but following a DIE reference
9245 may load a new CU, adding it to the end of the queue. */
9246 while (!per_objfile
->per_bfd
->queue
.empty ())
9248 dwarf2_queue_item
&item
= per_objfile
->per_bfd
->queue
.front ();
9249 dwarf2_per_cu_data
*per_cu
= item
.per_cu
;
9251 if (!per_objfile
->symtab_set_p (per_cu
))
9253 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
9255 /* Skip dummy CUs. */
9258 unsigned int debug_print_threshold
;
9261 if (per_cu
->is_debug_types
)
9263 struct signatured_type
*sig_type
=
9264 (struct signatured_type
*) per_cu
;
9266 sprintf (buf
, "TU %s at offset %s",
9267 hex_string (sig_type
->signature
),
9268 sect_offset_str (per_cu
->sect_off
));
9269 /* There can be 100s of TUs.
9270 Only print them in verbose mode. */
9271 debug_print_threshold
= 2;
9275 sprintf (buf
, "CU at offset %s",
9276 sect_offset_str (per_cu
->sect_off
));
9277 debug_print_threshold
= 1;
9280 if (dwarf_read_debug
>= debug_print_threshold
)
9281 dwarf_read_debug_printf ("Expanding symtab of %s", buf
);
9283 if (per_cu
->is_debug_types
)
9284 process_full_type_unit (cu
, item
.pretend_language
);
9286 process_full_comp_unit (cu
, item
.pretend_language
);
9288 if (dwarf_read_debug
>= debug_print_threshold
)
9289 dwarf_read_debug_printf ("Done expanding %s", buf
);
9294 per_objfile
->per_bfd
->queue
.pop ();
9297 dwarf_read_debug_printf ("Done expanding symtabs of %s.",
9298 objfile_name (per_objfile
->objfile
));
9301 /* Read in full symbols for PST, and anything it depends on. */
9304 dwarf2_psymtab::expand_psymtab (struct objfile
*objfile
)
9306 gdb_assert (!readin_p (objfile
));
9308 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
9309 free_cached_comp_units
freer (per_objfile
);
9310 expand_dependencies (objfile
);
9312 dw2_do_instantiate_symtab (per_cu_data
, per_objfile
, false);
9313 gdb_assert (get_compunit_symtab (objfile
) != nullptr);
9316 /* See psympriv.h. */
9319 dwarf2_psymtab::readin_p (struct objfile
*objfile
) const
9321 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
9322 return per_objfile
->symtab_set_p (per_cu_data
);
9325 /* See psympriv.h. */
9328 dwarf2_psymtab::get_compunit_symtab (struct objfile
*objfile
) const
9330 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
9331 return per_objfile
->get_symtab (per_cu_data
);
9334 /* Trivial hash function for die_info: the hash value of a DIE
9335 is its offset in .debug_info for this objfile. */
9338 die_hash (const void *item
)
9340 const struct die_info
*die
= (const struct die_info
*) item
;
9342 return to_underlying (die
->sect_off
);
9345 /* Trivial comparison function for die_info structures: two DIEs
9346 are equal if they have the same offset. */
9349 die_eq (const void *item_lhs
, const void *item_rhs
)
9351 const struct die_info
*die_lhs
= (const struct die_info
*) item_lhs
;
9352 const struct die_info
*die_rhs
= (const struct die_info
*) item_rhs
;
9354 return die_lhs
->sect_off
== die_rhs
->sect_off
;
9357 /* Load the DIEs associated with PER_CU into memory.
9359 In some cases, the caller, while reading partial symbols, will need to load
9360 the full symbols for the CU for some reason. It will already have a
9361 dwarf2_cu object for THIS_CU and pass it as EXISTING_CU, so it can be re-used
9362 rather than creating a new one. */
9365 load_full_comp_unit (dwarf2_per_cu_data
*this_cu
,
9366 dwarf2_per_objfile
*per_objfile
,
9367 dwarf2_cu
*existing_cu
,
9369 enum language pretend_language
)
9371 gdb_assert (! this_cu
->is_debug_types
);
9373 cutu_reader
reader (this_cu
, per_objfile
, NULL
, existing_cu
, skip_partial
);
9377 struct dwarf2_cu
*cu
= reader
.cu
;
9378 const gdb_byte
*info_ptr
= reader
.info_ptr
;
9380 gdb_assert (cu
->die_hash
== NULL
);
9382 htab_create_alloc_ex (cu
->header
.length
/ 12,
9386 &cu
->comp_unit_obstack
,
9387 hashtab_obstack_allocate
,
9388 dummy_obstack_deallocate
);
9390 if (reader
.comp_unit_die
->has_children
)
9391 reader
.comp_unit_die
->child
9392 = read_die_and_siblings (&reader
, reader
.info_ptr
,
9393 &info_ptr
, reader
.comp_unit_die
);
9394 cu
->dies
= reader
.comp_unit_die
;
9395 /* comp_unit_die is not stored in die_hash, no need. */
9397 /* We try not to read any attributes in this function, because not
9398 all CUs needed for references have been loaded yet, and symbol
9399 table processing isn't initialized. But we have to set the CU language,
9400 or we won't be able to build types correctly.
9401 Similarly, if we do not read the producer, we can not apply
9402 producer-specific interpretation. */
9403 prepare_one_comp_unit (cu
, cu
->dies
, pretend_language
);
9408 /* Add a DIE to the delayed physname list. */
9411 add_to_method_list (struct type
*type
, int fnfield_index
, int index
,
9412 const char *name
, struct die_info
*die
,
9413 struct dwarf2_cu
*cu
)
9415 struct delayed_method_info mi
;
9417 mi
.fnfield_index
= fnfield_index
;
9421 cu
->method_list
.push_back (mi
);
9424 /* Check whether [PHYSNAME, PHYSNAME+LEN) ends with a modifier like
9425 "const" / "volatile". If so, decrements LEN by the length of the
9426 modifier and return true. Otherwise return false. */
9430 check_modifier (const char *physname
, size_t &len
, const char (&mod
)[N
])
9432 size_t mod_len
= sizeof (mod
) - 1;
9433 if (len
> mod_len
&& startswith (physname
+ (len
- mod_len
), mod
))
9441 /* Compute the physnames of any methods on the CU's method list.
9443 The computation of method physnames is delayed in order to avoid the
9444 (bad) condition that one of the method's formal parameters is of an as yet
9448 compute_delayed_physnames (struct dwarf2_cu
*cu
)
9450 /* Only C++ delays computing physnames. */
9451 if (cu
->method_list
.empty ())
9453 gdb_assert (cu
->language
== language_cplus
);
9455 for (const delayed_method_info
&mi
: cu
->method_list
)
9457 const char *physname
;
9458 struct fn_fieldlist
*fn_flp
9459 = &TYPE_FN_FIELDLIST (mi
.type
, mi
.fnfield_index
);
9460 physname
= dwarf2_physname (mi
.name
, mi
.die
, cu
);
9461 TYPE_FN_FIELD_PHYSNAME (fn_flp
->fn_fields
, mi
.index
)
9462 = physname
? physname
: "";
9464 /* Since there's no tag to indicate whether a method is a
9465 const/volatile overload, extract that information out of the
9467 if (physname
!= NULL
)
9469 size_t len
= strlen (physname
);
9473 if (physname
[len
] == ')') /* shortcut */
9475 else if (check_modifier (physname
, len
, " const"))
9476 TYPE_FN_FIELD_CONST (fn_flp
->fn_fields
, mi
.index
) = 1;
9477 else if (check_modifier (physname
, len
, " volatile"))
9478 TYPE_FN_FIELD_VOLATILE (fn_flp
->fn_fields
, mi
.index
) = 1;
9485 /* The list is no longer needed. */
9486 cu
->method_list
.clear ();
9489 /* Go objects should be embedded in a DW_TAG_module DIE,
9490 and it's not clear if/how imported objects will appear.
9491 To keep Go support simple until that's worked out,
9492 go back through what we've read and create something usable.
9493 We could do this while processing each DIE, and feels kinda cleaner,
9494 but that way is more invasive.
9495 This is to, for example, allow the user to type "p var" or "b main"
9496 without having to specify the package name, and allow lookups
9497 of module.object to work in contexts that use the expression
9501 fixup_go_packaging (struct dwarf2_cu
*cu
)
9503 gdb::unique_xmalloc_ptr
<char> package_name
;
9504 struct pending
*list
;
9507 for (list
= *cu
->get_builder ()->get_global_symbols ();
9511 for (i
= 0; i
< list
->nsyms
; ++i
)
9513 struct symbol
*sym
= list
->symbol
[i
];
9515 if (sym
->language () == language_go
9516 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
9518 gdb::unique_xmalloc_ptr
<char> this_package_name
9519 (go_symbol_package_name (sym
));
9521 if (this_package_name
== NULL
)
9523 if (package_name
== NULL
)
9524 package_name
= std::move (this_package_name
);
9527 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
9528 if (strcmp (package_name
.get (), this_package_name
.get ()) != 0)
9529 complaint (_("Symtab %s has objects from two different Go packages: %s and %s"),
9530 (symbol_symtab (sym
) != NULL
9531 ? symtab_to_filename_for_display
9532 (symbol_symtab (sym
))
9533 : objfile_name (objfile
)),
9534 this_package_name
.get (), package_name
.get ());
9540 if (package_name
!= NULL
)
9542 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
9543 const char *saved_package_name
= objfile
->intern (package_name
.get ());
9544 struct type
*type
= init_type (objfile
, TYPE_CODE_MODULE
, 0,
9545 saved_package_name
);
9548 sym
= new (&objfile
->objfile_obstack
) symbol
;
9549 sym
->set_language (language_go
, &objfile
->objfile_obstack
);
9550 sym
->compute_and_set_names (saved_package_name
, false, objfile
->per_bfd
);
9551 /* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
9552 e.g., "main" finds the "main" module and not C's main(). */
9553 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
9554 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
9555 SYMBOL_TYPE (sym
) = type
;
9557 add_symbol_to_list (sym
, cu
->get_builder ()->get_global_symbols ());
9561 /* Allocate a fully-qualified name consisting of the two parts on the
9565 rust_fully_qualify (struct obstack
*obstack
, const char *p1
, const char *p2
)
9567 return obconcat (obstack
, p1
, "::", p2
, (char *) NULL
);
9570 /* A helper that allocates a variant part to attach to a Rust enum
9571 type. OBSTACK is where the results should be allocated. TYPE is
9572 the type we're processing. DISCRIMINANT_INDEX is the index of the
9573 discriminant. It must be the index of one of the fields of TYPE,
9574 or -1 to mean there is no discriminant (univariant enum).
9575 DEFAULT_INDEX is the index of the default field; or -1 if there is
9576 no default. RANGES is indexed by "effective" field number (the
9577 field index, but omitting the discriminant and default fields) and
9578 must hold the discriminant values used by the variants. Note that
9579 RANGES must have a lifetime at least as long as OBSTACK -- either
9580 already allocated on it, or static. */
9583 alloc_rust_variant (struct obstack
*obstack
, struct type
*type
,
9584 int discriminant_index
, int default_index
,
9585 gdb::array_view
<discriminant_range
> ranges
)
9587 /* When DISCRIMINANT_INDEX == -1, we have a univariant enum. */
9588 gdb_assert (discriminant_index
== -1
9589 || (discriminant_index
>= 0
9590 && discriminant_index
< type
->num_fields ()));
9591 gdb_assert (default_index
== -1
9592 || (default_index
>= 0 && default_index
< type
->num_fields ()));
9594 /* We have one variant for each non-discriminant field. */
9595 int n_variants
= type
->num_fields ();
9596 if (discriminant_index
!= -1)
9599 variant
*variants
= new (obstack
) variant
[n_variants
];
9602 for (int i
= 0; i
< type
->num_fields (); ++i
)
9604 if (i
== discriminant_index
)
9607 variants
[var_idx
].first_field
= i
;
9608 variants
[var_idx
].last_field
= i
+ 1;
9610 /* The default field does not need a range, but other fields do.
9611 We skipped the discriminant above. */
9612 if (i
!= default_index
)
9614 variants
[var_idx
].discriminants
= ranges
.slice (range_idx
, 1);
9621 gdb_assert (range_idx
== ranges
.size ());
9622 gdb_assert (var_idx
== n_variants
);
9624 variant_part
*part
= new (obstack
) variant_part
;
9625 part
->discriminant_index
= discriminant_index
;
9626 /* If there is no discriminant, then whether it is signed is of no
9629 = (discriminant_index
== -1
9631 : type
->field (discriminant_index
).type ()->is_unsigned ());
9632 part
->variants
= gdb::array_view
<variant
> (variants
, n_variants
);
9634 void *storage
= obstack_alloc (obstack
, sizeof (gdb::array_view
<variant_part
>));
9635 gdb::array_view
<variant_part
> *prop_value
9636 = new (storage
) gdb::array_view
<variant_part
> (part
, 1);
9638 struct dynamic_prop prop
;
9639 prop
.set_variant_parts (prop_value
);
9641 type
->add_dyn_prop (DYN_PROP_VARIANT_PARTS
, prop
);
9644 /* Some versions of rustc emitted enums in an unusual way.
9646 Ordinary enums were emitted as unions. The first element of each
9647 structure in the union was named "RUST$ENUM$DISR". This element
9648 held the discriminant.
9650 These versions of Rust also implemented the "non-zero"
9651 optimization. When the enum had two values, and one is empty and
9652 the other holds a pointer that cannot be zero, the pointer is used
9653 as the discriminant, with a zero value meaning the empty variant.
9654 Here, the union's first member is of the form
9655 RUST$ENCODED$ENUM$<fieldno>$<fieldno>$...$<variantname>
9656 where the fieldnos are the indices of the fields that should be
9657 traversed in order to find the field (which may be several fields deep)
9658 and the variantname is the name of the variant of the case when the
9661 This function recognizes whether TYPE is of one of these forms,
9662 and, if so, smashes it to be a variant type. */
9665 quirk_rust_enum (struct type
*type
, struct objfile
*objfile
)
9667 gdb_assert (type
->code () == TYPE_CODE_UNION
);
9669 /* We don't need to deal with empty enums. */
9670 if (type
->num_fields () == 0)
9673 #define RUST_ENUM_PREFIX "RUST$ENCODED$ENUM$"
9674 if (type
->num_fields () == 1
9675 && startswith (TYPE_FIELD_NAME (type
, 0), RUST_ENUM_PREFIX
))
9677 const char *name
= TYPE_FIELD_NAME (type
, 0) + strlen (RUST_ENUM_PREFIX
);
9679 /* Decode the field name to find the offset of the
9681 ULONGEST bit_offset
= 0;
9682 struct type
*field_type
= type
->field (0).type ();
9683 while (name
[0] >= '0' && name
[0] <= '9')
9686 unsigned long index
= strtoul (name
, &tail
, 10);
9689 || index
>= field_type
->num_fields ()
9690 || (TYPE_FIELD_LOC_KIND (field_type
, index
)
9691 != FIELD_LOC_KIND_BITPOS
))
9693 complaint (_("Could not parse Rust enum encoding string \"%s\""
9695 TYPE_FIELD_NAME (type
, 0),
9696 objfile_name (objfile
));
9701 bit_offset
+= TYPE_FIELD_BITPOS (field_type
, index
);
9702 field_type
= field_type
->field (index
).type ();
9705 /* Smash this type to be a structure type. We have to do this
9706 because the type has already been recorded. */
9707 type
->set_code (TYPE_CODE_STRUCT
);
9708 type
->set_num_fields (3);
9709 /* Save the field we care about. */
9710 struct field saved_field
= type
->field (0);
9712 ((struct field
*) TYPE_ZALLOC (type
, 3 * sizeof (struct field
)));
9714 /* Put the discriminant at index 0. */
9715 type
->field (0).set_type (field_type
);
9716 TYPE_FIELD_ARTIFICIAL (type
, 0) = 1;
9717 TYPE_FIELD_NAME (type
, 0) = "<<discriminant>>";
9718 SET_FIELD_BITPOS (type
->field (0), bit_offset
);
9720 /* The order of fields doesn't really matter, so put the real
9721 field at index 1 and the data-less field at index 2. */
9722 type
->field (1) = saved_field
;
9723 TYPE_FIELD_NAME (type
, 1)
9724 = rust_last_path_segment (type
->field (1).type ()->name ());
9725 type
->field (1).type ()->set_name
9726 (rust_fully_qualify (&objfile
->objfile_obstack
, type
->name (),
9727 TYPE_FIELD_NAME (type
, 1)));
9729 const char *dataless_name
9730 = rust_fully_qualify (&objfile
->objfile_obstack
, type
->name (),
9732 struct type
*dataless_type
= init_type (objfile
, TYPE_CODE_VOID
, 0,
9734 type
->field (2).set_type (dataless_type
);
9735 /* NAME points into the original discriminant name, which
9736 already has the correct lifetime. */
9737 TYPE_FIELD_NAME (type
, 2) = name
;
9738 SET_FIELD_BITPOS (type
->field (2), 0);
9740 /* Indicate that this is a variant type. */
9741 static discriminant_range ranges
[1] = { { 0, 0 } };
9742 alloc_rust_variant (&objfile
->objfile_obstack
, type
, 0, 1, ranges
);
9744 /* A union with a single anonymous field is probably an old-style
9746 else if (type
->num_fields () == 1 && streq (TYPE_FIELD_NAME (type
, 0), ""))
9748 /* Smash this type to be a structure type. We have to do this
9749 because the type has already been recorded. */
9750 type
->set_code (TYPE_CODE_STRUCT
);
9752 struct type
*field_type
= type
->field (0).type ();
9753 const char *variant_name
9754 = rust_last_path_segment (field_type
->name ());
9755 TYPE_FIELD_NAME (type
, 0) = variant_name
;
9756 field_type
->set_name
9757 (rust_fully_qualify (&objfile
->objfile_obstack
,
9758 type
->name (), variant_name
));
9760 alloc_rust_variant (&objfile
->objfile_obstack
, type
, -1, 0, {});
9764 struct type
*disr_type
= nullptr;
9765 for (int i
= 0; i
< type
->num_fields (); ++i
)
9767 disr_type
= type
->field (i
).type ();
9769 if (disr_type
->code () != TYPE_CODE_STRUCT
)
9771 /* All fields of a true enum will be structs. */
9774 else if (disr_type
->num_fields () == 0)
9776 /* Could be data-less variant, so keep going. */
9777 disr_type
= nullptr;
9779 else if (strcmp (TYPE_FIELD_NAME (disr_type
, 0),
9780 "RUST$ENUM$DISR") != 0)
9782 /* Not a Rust enum. */
9792 /* If we got here without a discriminant, then it's probably
9794 if (disr_type
== nullptr)
9797 /* Smash this type to be a structure type. We have to do this
9798 because the type has already been recorded. */
9799 type
->set_code (TYPE_CODE_STRUCT
);
9801 /* Make space for the discriminant field. */
9802 struct field
*disr_field
= &disr_type
->field (0);
9804 = (struct field
*) TYPE_ZALLOC (type
, ((type
->num_fields () + 1)
9805 * sizeof (struct field
)));
9806 memcpy (new_fields
+ 1, type
->fields (),
9807 type
->num_fields () * sizeof (struct field
));
9808 type
->set_fields (new_fields
);
9809 type
->set_num_fields (type
->num_fields () + 1);
9811 /* Install the discriminant at index 0 in the union. */
9812 type
->field (0) = *disr_field
;
9813 TYPE_FIELD_ARTIFICIAL (type
, 0) = 1;
9814 TYPE_FIELD_NAME (type
, 0) = "<<discriminant>>";
9816 /* We need a way to find the correct discriminant given a
9817 variant name. For convenience we build a map here. */
9818 struct type
*enum_type
= disr_field
->type ();
9819 std::unordered_map
<std::string
, ULONGEST
> discriminant_map
;
9820 for (int i
= 0; i
< enum_type
->num_fields (); ++i
)
9822 if (TYPE_FIELD_LOC_KIND (enum_type
, i
) == FIELD_LOC_KIND_ENUMVAL
)
9825 = rust_last_path_segment (TYPE_FIELD_NAME (enum_type
, i
));
9826 discriminant_map
[name
] = TYPE_FIELD_ENUMVAL (enum_type
, i
);
9830 int n_fields
= type
->num_fields ();
9831 /* We don't need a range entry for the discriminant, but we do
9832 need one for every other field, as there is no default
9834 discriminant_range
*ranges
= XOBNEWVEC (&objfile
->objfile_obstack
,
9837 /* Skip the discriminant here. */
9838 for (int i
= 1; i
< n_fields
; ++i
)
9840 /* Find the final word in the name of this variant's type.
9841 That name can be used to look up the correct
9843 const char *variant_name
9844 = rust_last_path_segment (type
->field (i
).type ()->name ());
9846 auto iter
= discriminant_map
.find (variant_name
);
9847 if (iter
!= discriminant_map
.end ())
9849 ranges
[i
- 1].low
= iter
->second
;
9850 ranges
[i
- 1].high
= iter
->second
;
9853 /* In Rust, each element should have the size of the
9855 TYPE_LENGTH (type
->field (i
).type ()) = TYPE_LENGTH (type
);
9857 /* Remove the discriminant field, if it exists. */
9858 struct type
*sub_type
= type
->field (i
).type ();
9859 if (sub_type
->num_fields () > 0)
9861 sub_type
->set_num_fields (sub_type
->num_fields () - 1);
9862 sub_type
->set_fields (sub_type
->fields () + 1);
9864 TYPE_FIELD_NAME (type
, i
) = variant_name
;
9866 (rust_fully_qualify (&objfile
->objfile_obstack
,
9867 type
->name (), variant_name
));
9870 /* Indicate that this is a variant type. */
9871 alloc_rust_variant (&objfile
->objfile_obstack
, type
, 0, -1,
9872 gdb::array_view
<discriminant_range
> (ranges
,
9877 /* Rewrite some Rust unions to be structures with variants parts. */
9880 rust_union_quirks (struct dwarf2_cu
*cu
)
9882 gdb_assert (cu
->language
== language_rust
);
9883 for (type
*type_
: cu
->rust_unions
)
9884 quirk_rust_enum (type_
, cu
->per_objfile
->objfile
);
9885 /* We don't need this any more. */
9886 cu
->rust_unions
.clear ();
9891 type_unit_group_unshareable
*
9892 dwarf2_per_objfile::get_type_unit_group_unshareable (type_unit_group
*tu_group
)
9894 auto iter
= this->m_type_units
.find (tu_group
);
9895 if (iter
!= this->m_type_units
.end ())
9896 return iter
->second
.get ();
9898 type_unit_group_unshareable_up
uniq (new type_unit_group_unshareable
);
9899 type_unit_group_unshareable
*result
= uniq
.get ();
9900 this->m_type_units
[tu_group
] = std::move (uniq
);
9905 dwarf2_per_objfile::get_type_for_signatured_type
9906 (signatured_type
*sig_type
) const
9908 auto iter
= this->m_type_map
.find (sig_type
);
9909 if (iter
== this->m_type_map
.end ())
9912 return iter
->second
;
9915 void dwarf2_per_objfile::set_type_for_signatured_type
9916 (signatured_type
*sig_type
, struct type
*type
)
9918 gdb_assert (this->m_type_map
.find (sig_type
) == this->m_type_map
.end ());
9920 this->m_type_map
[sig_type
] = type
;
9923 /* A helper function for computing the list of all symbol tables
9924 included by PER_CU. */
9927 recursively_compute_inclusions (std::vector
<compunit_symtab
*> *result
,
9928 htab_t all_children
, htab_t all_type_symtabs
,
9929 dwarf2_per_cu_data
*per_cu
,
9930 dwarf2_per_objfile
*per_objfile
,
9931 struct compunit_symtab
*immediate_parent
)
9933 void **slot
= htab_find_slot (all_children
, per_cu
, INSERT
);
9936 /* This inclusion and its children have been processed. */
9942 /* Only add a CU if it has a symbol table. */
9943 compunit_symtab
*cust
= per_objfile
->get_symtab (per_cu
);
9946 /* If this is a type unit only add its symbol table if we haven't
9947 seen it yet (type unit per_cu's can share symtabs). */
9948 if (per_cu
->is_debug_types
)
9950 slot
= htab_find_slot (all_type_symtabs
, cust
, INSERT
);
9954 result
->push_back (cust
);
9955 if (cust
->user
== NULL
)
9956 cust
->user
= immediate_parent
;
9961 result
->push_back (cust
);
9962 if (cust
->user
== NULL
)
9963 cust
->user
= immediate_parent
;
9967 if (!per_cu
->imported_symtabs_empty ())
9968 for (dwarf2_per_cu_data
*ptr
: *per_cu
->imported_symtabs
)
9970 recursively_compute_inclusions (result
, all_children
,
9971 all_type_symtabs
, ptr
, per_objfile
,
9976 /* Compute the compunit_symtab 'includes' fields for the compunit_symtab of
9980 compute_compunit_symtab_includes (dwarf2_per_cu_data
*per_cu
,
9981 dwarf2_per_objfile
*per_objfile
)
9983 gdb_assert (! per_cu
->is_debug_types
);
9985 if (!per_cu
->imported_symtabs_empty ())
9988 std::vector
<compunit_symtab
*> result_symtabs
;
9989 compunit_symtab
*cust
= per_objfile
->get_symtab (per_cu
);
9991 /* If we don't have a symtab, we can just skip this case. */
9995 htab_up
all_children (htab_create_alloc (1, htab_hash_pointer
,
9997 NULL
, xcalloc
, xfree
));
9998 htab_up
all_type_symtabs (htab_create_alloc (1, htab_hash_pointer
,
10000 NULL
, xcalloc
, xfree
));
10002 for (dwarf2_per_cu_data
*ptr
: *per_cu
->imported_symtabs
)
10004 recursively_compute_inclusions (&result_symtabs
, all_children
.get (),
10005 all_type_symtabs
.get (), ptr
,
10006 per_objfile
, cust
);
10009 /* Now we have a transitive closure of all the included symtabs. */
10010 len
= result_symtabs
.size ();
10012 = XOBNEWVEC (&per_objfile
->objfile
->objfile_obstack
,
10013 struct compunit_symtab
*, len
+ 1);
10014 memcpy (cust
->includes
, result_symtabs
.data (),
10015 len
* sizeof (compunit_symtab
*));
10016 cust
->includes
[len
] = NULL
;
10020 /* Compute the 'includes' field for the symtabs of all the CUs we just
10024 process_cu_includes (dwarf2_per_objfile
*per_objfile
)
10026 for (dwarf2_per_cu_data
*iter
: per_objfile
->per_bfd
->just_read_cus
)
10028 if (! iter
->is_debug_types
)
10029 compute_compunit_symtab_includes (iter
, per_objfile
);
10032 per_objfile
->per_bfd
->just_read_cus
.clear ();
10035 /* Generate full symbol information for CU, whose DIEs have
10036 already been loaded into memory. */
10039 process_full_comp_unit (dwarf2_cu
*cu
, enum language pretend_language
)
10041 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
10042 struct objfile
*objfile
= per_objfile
->objfile
;
10043 struct gdbarch
*gdbarch
= objfile
->arch ();
10044 CORE_ADDR lowpc
, highpc
;
10045 struct compunit_symtab
*cust
;
10046 CORE_ADDR baseaddr
;
10047 struct block
*static_block
;
10050 baseaddr
= objfile
->text_section_offset ();
10052 /* Clear the list here in case something was left over. */
10053 cu
->method_list
.clear ();
10055 cu
->language
= pretend_language
;
10056 cu
->language_defn
= language_def (cu
->language
);
10058 dwarf2_find_base_address (cu
->dies
, cu
);
10060 /* Do line number decoding in read_file_scope () */
10061 process_die (cu
->dies
, cu
);
10063 /* For now fudge the Go package. */
10064 if (cu
->language
== language_go
)
10065 fixup_go_packaging (cu
);
10067 /* Now that we have processed all the DIEs in the CU, all the types
10068 should be complete, and it should now be safe to compute all of the
10070 compute_delayed_physnames (cu
);
10072 if (cu
->language
== language_rust
)
10073 rust_union_quirks (cu
);
10075 /* Some compilers don't define a DW_AT_high_pc attribute for the
10076 compilation unit. If the DW_AT_high_pc is missing, synthesize
10077 it, by scanning the DIE's below the compilation unit. */
10078 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
10080 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
10081 static_block
= cu
->get_builder ()->end_symtab_get_static_block (addr
, 0, 1);
10083 /* If the comp unit has DW_AT_ranges, it may have discontiguous ranges.
10084 Also, DW_AT_ranges may record ranges not belonging to any child DIEs
10085 (such as virtual method tables). Record the ranges in STATIC_BLOCK's
10086 addrmap to help ensure it has an accurate map of pc values belonging to
10088 dwarf2_record_block_ranges (cu
->dies
, static_block
, baseaddr
, cu
);
10090 cust
= cu
->get_builder ()->end_symtab_from_static_block (static_block
,
10091 SECT_OFF_TEXT (objfile
),
10096 int gcc_4_minor
= producer_is_gcc_ge_4 (cu
->producer
);
10098 /* Set symtab language to language from DW_AT_language. If the
10099 compilation is from a C file generated by language preprocessors, do
10100 not set the language if it was already deduced by start_subfile. */
10101 if (!(cu
->language
== language_c
10102 && COMPUNIT_FILETABS (cust
)->language
!= language_unknown
))
10103 COMPUNIT_FILETABS (cust
)->language
= cu
->language
;
10105 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
10106 produce DW_AT_location with location lists but it can be possibly
10107 invalid without -fvar-tracking. Still up to GCC-4.4.x incl. 4.4.0
10108 there were bugs in prologue debug info, fixed later in GCC-4.5
10109 by "unwind info for epilogues" patch (which is not directly related).
10111 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
10112 needed, it would be wrong due to missing DW_AT_producer there.
10114 Still one can confuse GDB by using non-standard GCC compilation
10115 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
10117 if (cu
->has_loclist
&& gcc_4_minor
>= 5)
10118 cust
->locations_valid
= 1;
10120 if (gcc_4_minor
>= 5)
10121 cust
->epilogue_unwind_valid
= 1;
10123 cust
->call_site_htab
= cu
->call_site_htab
;
10126 per_objfile
->set_symtab (cu
->per_cu
, cust
);
10128 /* Push it for inclusion processing later. */
10129 per_objfile
->per_bfd
->just_read_cus
.push_back (cu
->per_cu
);
10131 /* Not needed any more. */
10132 cu
->reset_builder ();
10135 /* Generate full symbol information for type unit CU, whose DIEs have
10136 already been loaded into memory. */
10139 process_full_type_unit (dwarf2_cu
*cu
,
10140 enum language pretend_language
)
10142 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
10143 struct objfile
*objfile
= per_objfile
->objfile
;
10144 struct compunit_symtab
*cust
;
10145 struct signatured_type
*sig_type
;
10147 gdb_assert (cu
->per_cu
->is_debug_types
);
10148 sig_type
= (struct signatured_type
*) cu
->per_cu
;
10150 /* Clear the list here in case something was left over. */
10151 cu
->method_list
.clear ();
10153 cu
->language
= pretend_language
;
10154 cu
->language_defn
= language_def (cu
->language
);
10156 /* The symbol tables are set up in read_type_unit_scope. */
10157 process_die (cu
->dies
, cu
);
10159 /* For now fudge the Go package. */
10160 if (cu
->language
== language_go
)
10161 fixup_go_packaging (cu
);
10163 /* Now that we have processed all the DIEs in the CU, all the types
10164 should be complete, and it should now be safe to compute all of the
10166 compute_delayed_physnames (cu
);
10168 if (cu
->language
== language_rust
)
10169 rust_union_quirks (cu
);
10171 /* TUs share symbol tables.
10172 If this is the first TU to use this symtab, complete the construction
10173 of it with end_expandable_symtab. Otherwise, complete the addition of
10174 this TU's symbols to the existing symtab. */
10175 type_unit_group_unshareable
*tug_unshare
=
10176 per_objfile
->get_type_unit_group_unshareable (sig_type
->type_unit_group
);
10177 if (tug_unshare
->compunit_symtab
== NULL
)
10179 buildsym_compunit
*builder
= cu
->get_builder ();
10180 cust
= builder
->end_expandable_symtab (0, SECT_OFF_TEXT (objfile
));
10181 tug_unshare
->compunit_symtab
= cust
;
10185 /* Set symtab language to language from DW_AT_language. If the
10186 compilation is from a C file generated by language preprocessors,
10187 do not set the language if it was already deduced by
10189 if (!(cu
->language
== language_c
10190 && COMPUNIT_FILETABS (cust
)->language
!= language_c
))
10191 COMPUNIT_FILETABS (cust
)->language
= cu
->language
;
10196 cu
->get_builder ()->augment_type_symtab ();
10197 cust
= tug_unshare
->compunit_symtab
;
10200 per_objfile
->set_symtab (cu
->per_cu
, cust
);
10202 /* Not needed any more. */
10203 cu
->reset_builder ();
10206 /* Process an imported unit DIE. */
10209 process_imported_unit_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
10211 struct attribute
*attr
;
10213 /* For now we don't handle imported units in type units. */
10214 if (cu
->per_cu
->is_debug_types
)
10216 error (_("Dwarf Error: DW_TAG_imported_unit is not"
10217 " supported in type units [in module %s]"),
10218 objfile_name (cu
->per_objfile
->objfile
));
10221 attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
10224 sect_offset sect_off
= attr
->get_ref_die_offset ();
10225 bool is_dwz
= (attr
->form
== DW_FORM_GNU_ref_alt
|| cu
->per_cu
->is_dwz
);
10226 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
10227 dwarf2_per_cu_data
*per_cu
10228 = dwarf2_find_containing_comp_unit (sect_off
, is_dwz
, per_objfile
);
10230 /* We're importing a C++ compilation unit with tag DW_TAG_compile_unit
10231 into another compilation unit, at root level. Regard this as a hint,
10233 if (die
->parent
&& die
->parent
->parent
== NULL
10234 && per_cu
->unit_type
== DW_UT_compile
10235 && per_cu
->lang
== language_cplus
)
10238 /* If necessary, add it to the queue and load its DIEs. */
10239 if (maybe_queue_comp_unit (cu
, per_cu
, per_objfile
, cu
->language
))
10240 load_full_comp_unit (per_cu
, per_objfile
, per_objfile
->get_cu (per_cu
),
10241 false, cu
->language
);
10243 cu
->per_cu
->imported_symtabs_push (per_cu
);
10247 /* RAII object that represents a process_die scope: i.e.,
10248 starts/finishes processing a DIE. */
10249 class process_die_scope
10252 process_die_scope (die_info
*die
, dwarf2_cu
*cu
)
10253 : m_die (die
), m_cu (cu
)
10255 /* We should only be processing DIEs not already in process. */
10256 gdb_assert (!m_die
->in_process
);
10257 m_die
->in_process
= true;
10260 ~process_die_scope ()
10262 m_die
->in_process
= false;
10264 /* If we're done processing the DIE for the CU that owns the line
10265 header, we don't need the line header anymore. */
10266 if (m_cu
->line_header_die_owner
== m_die
)
10268 delete m_cu
->line_header
;
10269 m_cu
->line_header
= NULL
;
10270 m_cu
->line_header_die_owner
= NULL
;
10279 /* Process a die and its children. */
10282 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
10284 process_die_scope
scope (die
, cu
);
10288 case DW_TAG_padding
:
10290 case DW_TAG_compile_unit
:
10291 case DW_TAG_partial_unit
:
10292 read_file_scope (die
, cu
);
10294 case DW_TAG_type_unit
:
10295 read_type_unit_scope (die
, cu
);
10297 case DW_TAG_subprogram
:
10298 /* Nested subprograms in Fortran get a prefix. */
10299 if (cu
->language
== language_fortran
10300 && die
->parent
!= NULL
10301 && die
->parent
->tag
== DW_TAG_subprogram
)
10302 cu
->processing_has_namespace_info
= true;
10303 /* Fall through. */
10304 case DW_TAG_inlined_subroutine
:
10305 read_func_scope (die
, cu
);
10307 case DW_TAG_lexical_block
:
10308 case DW_TAG_try_block
:
10309 case DW_TAG_catch_block
:
10310 read_lexical_block_scope (die
, cu
);
10312 case DW_TAG_call_site
:
10313 case DW_TAG_GNU_call_site
:
10314 read_call_site_scope (die
, cu
);
10316 case DW_TAG_class_type
:
10317 case DW_TAG_interface_type
:
10318 case DW_TAG_structure_type
:
10319 case DW_TAG_union_type
:
10320 process_structure_scope (die
, cu
);
10322 case DW_TAG_enumeration_type
:
10323 process_enumeration_scope (die
, cu
);
10326 /* These dies have a type, but processing them does not create
10327 a symbol or recurse to process the children. Therefore we can
10328 read them on-demand through read_type_die. */
10329 case DW_TAG_subroutine_type
:
10330 case DW_TAG_set_type
:
10331 case DW_TAG_pointer_type
:
10332 case DW_TAG_ptr_to_member_type
:
10333 case DW_TAG_reference_type
:
10334 case DW_TAG_rvalue_reference_type
:
10335 case DW_TAG_string_type
:
10338 case DW_TAG_array_type
:
10339 /* We only need to handle this case for Ada -- in other
10340 languages, it's normal for the compiler to emit a typedef
10342 if (cu
->language
!= language_ada
)
10345 case DW_TAG_base_type
:
10346 case DW_TAG_subrange_type
:
10347 case DW_TAG_typedef
:
10348 /* Add a typedef symbol for the type definition, if it has a
10350 new_symbol (die
, read_type_die (die
, cu
), cu
);
10352 case DW_TAG_common_block
:
10353 read_common_block (die
, cu
);
10355 case DW_TAG_common_inclusion
:
10357 case DW_TAG_namespace
:
10358 cu
->processing_has_namespace_info
= true;
10359 read_namespace (die
, cu
);
10361 case DW_TAG_module
:
10362 cu
->processing_has_namespace_info
= true;
10363 read_module (die
, cu
);
10365 case DW_TAG_imported_declaration
:
10366 cu
->processing_has_namespace_info
= true;
10367 if (read_namespace_alias (die
, cu
))
10369 /* The declaration is not a global namespace alias. */
10370 /* Fall through. */
10371 case DW_TAG_imported_module
:
10372 cu
->processing_has_namespace_info
= true;
10373 if (die
->child
!= NULL
&& (die
->tag
== DW_TAG_imported_declaration
10374 || cu
->language
!= language_fortran
))
10375 complaint (_("Tag '%s' has unexpected children"),
10376 dwarf_tag_name (die
->tag
));
10377 read_import_statement (die
, cu
);
10380 case DW_TAG_imported_unit
:
10381 process_imported_unit_die (die
, cu
);
10384 case DW_TAG_variable
:
10385 read_variable (die
, cu
);
10389 new_symbol (die
, NULL
, cu
);
10394 /* DWARF name computation. */
10396 /* A helper function for dwarf2_compute_name which determines whether DIE
10397 needs to have the name of the scope prepended to the name listed in the
10401 die_needs_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
10403 struct attribute
*attr
;
10407 case DW_TAG_namespace
:
10408 case DW_TAG_typedef
:
10409 case DW_TAG_class_type
:
10410 case DW_TAG_interface_type
:
10411 case DW_TAG_structure_type
:
10412 case DW_TAG_union_type
:
10413 case DW_TAG_enumeration_type
:
10414 case DW_TAG_enumerator
:
10415 case DW_TAG_subprogram
:
10416 case DW_TAG_inlined_subroutine
:
10417 case DW_TAG_member
:
10418 case DW_TAG_imported_declaration
:
10421 case DW_TAG_variable
:
10422 case DW_TAG_constant
:
10423 /* We only need to prefix "globally" visible variables. These include
10424 any variable marked with DW_AT_external or any variable that
10425 lives in a namespace. [Variables in anonymous namespaces
10426 require prefixing, but they are not DW_AT_external.] */
10428 if (dwarf2_attr (die
, DW_AT_specification
, cu
))
10430 struct dwarf2_cu
*spec_cu
= cu
;
10432 return die_needs_namespace (die_specification (die
, &spec_cu
),
10436 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
10437 if (attr
== NULL
&& die
->parent
->tag
!= DW_TAG_namespace
10438 && die
->parent
->tag
!= DW_TAG_module
)
10440 /* A variable in a lexical block of some kind does not need a
10441 namespace, even though in C++ such variables may be external
10442 and have a mangled name. */
10443 if (die
->parent
->tag
== DW_TAG_lexical_block
10444 || die
->parent
->tag
== DW_TAG_try_block
10445 || die
->parent
->tag
== DW_TAG_catch_block
10446 || die
->parent
->tag
== DW_TAG_subprogram
)
10455 /* Return the DIE's linkage name attribute, either DW_AT_linkage_name
10456 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
10457 defined for the given DIE. */
10459 static struct attribute
*
10460 dw2_linkage_name_attr (struct die_info
*die
, struct dwarf2_cu
*cu
)
10462 struct attribute
*attr
;
10464 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
10466 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
10471 /* Return the DIE's linkage name as a string, either DW_AT_linkage_name
10472 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
10473 defined for the given DIE. */
10475 static const char *
10476 dw2_linkage_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
10478 const char *linkage_name
;
10480 linkage_name
= dwarf2_string_attr (die
, DW_AT_linkage_name
, cu
);
10481 if (linkage_name
== NULL
)
10482 linkage_name
= dwarf2_string_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
10484 /* rustc emits invalid values for DW_AT_linkage_name. Ignore these.
10485 See https://github.com/rust-lang/rust/issues/32925. */
10486 if (cu
->language
== language_rust
&& linkage_name
!= NULL
10487 && strchr (linkage_name
, '{') != NULL
)
10488 linkage_name
= NULL
;
10490 return linkage_name
;
10493 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
10494 compute the physname for the object, which include a method's:
10495 - formal parameters (C++),
10496 - receiver type (Go),
10498 The term "physname" is a bit confusing.
10499 For C++, for example, it is the demangled name.
10500 For Go, for example, it's the mangled name.
10502 For Ada, return the DIE's linkage name rather than the fully qualified
10503 name. PHYSNAME is ignored..
10505 The result is allocated on the objfile->per_bfd's obstack and
10508 static const char *
10509 dwarf2_compute_name (const char *name
,
10510 struct die_info
*die
, struct dwarf2_cu
*cu
,
10513 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
10516 name
= dwarf2_name (die
, cu
);
10518 /* For Fortran GDB prefers DW_AT_*linkage_name for the physname if present
10519 but otherwise compute it by typename_concat inside GDB.
10520 FIXME: Actually this is not really true, or at least not always true.
10521 It's all very confusing. compute_and_set_names doesn't try to demangle
10522 Fortran names because there is no mangling standard. So new_symbol
10523 will set the demangled name to the result of dwarf2_full_name, and it is
10524 the demangled name that GDB uses if it exists. */
10525 if (cu
->language
== language_ada
10526 || (cu
->language
== language_fortran
&& physname
))
10528 /* For Ada unit, we prefer the linkage name over the name, as
10529 the former contains the exported name, which the user expects
10530 to be able to reference. Ideally, we want the user to be able
10531 to reference this entity using either natural or linkage name,
10532 but we haven't started looking at this enhancement yet. */
10533 const char *linkage_name
= dw2_linkage_name (die
, cu
);
10535 if (linkage_name
!= NULL
)
10536 return linkage_name
;
10539 /* These are the only languages we know how to qualify names in. */
10541 && (cu
->language
== language_cplus
10542 || cu
->language
== language_fortran
|| cu
->language
== language_d
10543 || cu
->language
== language_rust
))
10545 if (die_needs_namespace (die
, cu
))
10547 const char *prefix
;
10548 const char *canonical_name
= NULL
;
10552 prefix
= determine_prefix (die
, cu
);
10553 if (*prefix
!= '\0')
10555 gdb::unique_xmalloc_ptr
<char> prefixed_name
10556 (typename_concat (NULL
, prefix
, name
, physname
, cu
));
10558 buf
.puts (prefixed_name
.get ());
10563 /* Template parameters may be specified in the DIE's DW_AT_name, or
10564 as children with DW_TAG_template_type_param or
10565 DW_TAG_value_type_param. If the latter, add them to the name
10566 here. If the name already has template parameters, then
10567 skip this step; some versions of GCC emit both, and
10568 it is more efficient to use the pre-computed name.
10570 Something to keep in mind about this process: it is very
10571 unlikely, or in some cases downright impossible, to produce
10572 something that will match the mangled name of a function.
10573 If the definition of the function has the same debug info,
10574 we should be able to match up with it anyway. But fallbacks
10575 using the minimal symbol, for instance to find a method
10576 implemented in a stripped copy of libstdc++, will not work.
10577 If we do not have debug info for the definition, we will have to
10578 match them up some other way.
10580 When we do name matching there is a related problem with function
10581 templates; two instantiated function templates are allowed to
10582 differ only by their return types, which we do not add here. */
10584 if (cu
->language
== language_cplus
&& strchr (name
, '<') == NULL
)
10586 struct attribute
*attr
;
10587 struct die_info
*child
;
10589 const language_defn
*cplus_lang
= language_def (cu
->language
);
10591 die
->building_fullname
= 1;
10593 for (child
= die
->child
; child
!= NULL
; child
= child
->sibling
)
10597 const gdb_byte
*bytes
;
10598 struct dwarf2_locexpr_baton
*baton
;
10601 if (child
->tag
!= DW_TAG_template_type_param
10602 && child
->tag
!= DW_TAG_template_value_param
)
10613 attr
= dwarf2_attr (child
, DW_AT_type
, cu
);
10616 complaint (_("template parameter missing DW_AT_type"));
10617 buf
.puts ("UNKNOWN_TYPE");
10620 type
= die_type (child
, cu
);
10622 if (child
->tag
== DW_TAG_template_type_param
)
10624 cplus_lang
->print_type (type
, "", &buf
, -1, 0,
10625 &type_print_raw_options
);
10629 attr
= dwarf2_attr (child
, DW_AT_const_value
, cu
);
10632 complaint (_("template parameter missing "
10633 "DW_AT_const_value"));
10634 buf
.puts ("UNKNOWN_VALUE");
10638 dwarf2_const_value_attr (attr
, type
, name
,
10639 &cu
->comp_unit_obstack
, cu
,
10640 &value
, &bytes
, &baton
);
10642 if (type
->has_no_signedness ())
10643 /* GDB prints characters as NUMBER 'CHAR'. If that's
10644 changed, this can use value_print instead. */
10645 cplus_lang
->printchar (value
, type
, &buf
);
10648 struct value_print_options opts
;
10651 v
= dwarf2_evaluate_loc_desc (type
, NULL
,
10655 baton
->per_objfile
);
10656 else if (bytes
!= NULL
)
10658 v
= allocate_value (type
);
10659 memcpy (value_contents_writeable (v
), bytes
,
10660 TYPE_LENGTH (type
));
10663 v
= value_from_longest (type
, value
);
10665 /* Specify decimal so that we do not depend on
10667 get_formatted_print_options (&opts
, 'd');
10669 value_print (v
, &buf
, &opts
);
10674 die
->building_fullname
= 0;
10678 /* Close the argument list, with a space if necessary
10679 (nested templates). */
10680 if (!buf
.empty () && buf
.string ().back () == '>')
10687 /* For C++ methods, append formal parameter type
10688 information, if PHYSNAME. */
10690 if (physname
&& die
->tag
== DW_TAG_subprogram
10691 && cu
->language
== language_cplus
)
10693 struct type
*type
= read_type_die (die
, cu
);
10695 c_type_print_args (type
, &buf
, 1, cu
->language
,
10696 &type_print_raw_options
);
10698 if (cu
->language
== language_cplus
)
10700 /* Assume that an artificial first parameter is
10701 "this", but do not crash if it is not. RealView
10702 marks unnamed (and thus unused) parameters as
10703 artificial; there is no way to differentiate
10705 if (type
->num_fields () > 0
10706 && TYPE_FIELD_ARTIFICIAL (type
, 0)
10707 && type
->field (0).type ()->code () == TYPE_CODE_PTR
10708 && TYPE_CONST (TYPE_TARGET_TYPE (type
->field (0).type ())))
10709 buf
.puts (" const");
10713 const std::string
&intermediate_name
= buf
.string ();
10715 if (cu
->language
== language_cplus
)
10717 = dwarf2_canonicalize_name (intermediate_name
.c_str (), cu
,
10720 /* If we only computed INTERMEDIATE_NAME, or if
10721 INTERMEDIATE_NAME is already canonical, then we need to
10723 if (canonical_name
== NULL
|| canonical_name
== intermediate_name
.c_str ())
10724 name
= objfile
->intern (intermediate_name
);
10726 name
= canonical_name
;
10733 /* Return the fully qualified name of DIE, based on its DW_AT_name.
10734 If scope qualifiers are appropriate they will be added. The result
10735 will be allocated on the storage_obstack, or NULL if the DIE does
10736 not have a name. NAME may either be from a previous call to
10737 dwarf2_name or NULL.
10739 The output string will be canonicalized (if C++). */
10741 static const char *
10742 dwarf2_full_name (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
10744 return dwarf2_compute_name (name
, die
, cu
, 0);
10747 /* Construct a physname for the given DIE in CU. NAME may either be
10748 from a previous call to dwarf2_name or NULL. The result will be
10749 allocated on the objfile_objstack or NULL if the DIE does not have a
10752 The output string will be canonicalized (if C++). */
10754 static const char *
10755 dwarf2_physname (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
10757 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
10758 const char *retval
, *mangled
= NULL
, *canon
= NULL
;
10761 /* In this case dwarf2_compute_name is just a shortcut not building anything
10763 if (!die_needs_namespace (die
, cu
))
10764 return dwarf2_compute_name (name
, die
, cu
, 1);
10766 if (cu
->language
!= language_rust
)
10767 mangled
= dw2_linkage_name (die
, cu
);
10769 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
10771 gdb::unique_xmalloc_ptr
<char> demangled
;
10772 if (mangled
!= NULL
)
10775 if (language_def (cu
->language
)->store_sym_names_in_linkage_form_p ())
10777 /* Do nothing (do not demangle the symbol name). */
10781 /* Use DMGL_RET_DROP for C++ template functions to suppress
10782 their return type. It is easier for GDB users to search
10783 for such functions as `name(params)' than `long name(params)'.
10784 In such case the minimal symbol names do not match the full
10785 symbol names but for template functions there is never a need
10786 to look up their definition from their declaration so
10787 the only disadvantage remains the minimal symbol variant
10788 `long name(params)' does not have the proper inferior type. */
10789 demangled
.reset (gdb_demangle (mangled
,
10790 (DMGL_PARAMS
| DMGL_ANSI
10791 | DMGL_RET_DROP
)));
10794 canon
= demangled
.get ();
10802 if (canon
== NULL
|| check_physname
)
10804 const char *physname
= dwarf2_compute_name (name
, die
, cu
, 1);
10806 if (canon
!= NULL
&& strcmp (physname
, canon
) != 0)
10808 /* It may not mean a bug in GDB. The compiler could also
10809 compute DW_AT_linkage_name incorrectly. But in such case
10810 GDB would need to be bug-to-bug compatible. */
10812 complaint (_("Computed physname <%s> does not match demangled <%s> "
10813 "(from linkage <%s>) - DIE at %s [in module %s]"),
10814 physname
, canon
, mangled
, sect_offset_str (die
->sect_off
),
10815 objfile_name (objfile
));
10817 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
10818 is available here - over computed PHYSNAME. It is safer
10819 against both buggy GDB and buggy compilers. */
10833 retval
= objfile
->intern (retval
);
10838 /* Inspect DIE in CU for a namespace alias. If one exists, record
10839 a new symbol for it.
10841 Returns 1 if a namespace alias was recorded, 0 otherwise. */
10844 read_namespace_alias (struct die_info
*die
, struct dwarf2_cu
*cu
)
10846 struct attribute
*attr
;
10848 /* If the die does not have a name, this is not a namespace
10850 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
10854 struct die_info
*d
= die
;
10855 struct dwarf2_cu
*imported_cu
= cu
;
10857 /* If the compiler has nested DW_AT_imported_declaration DIEs,
10858 keep inspecting DIEs until we hit the underlying import. */
10859 #define MAX_NESTED_IMPORTED_DECLARATIONS 100
10860 for (num
= 0; num
< MAX_NESTED_IMPORTED_DECLARATIONS
; ++num
)
10862 attr
= dwarf2_attr (d
, DW_AT_import
, cu
);
10866 d
= follow_die_ref (d
, attr
, &imported_cu
);
10867 if (d
->tag
!= DW_TAG_imported_declaration
)
10871 if (num
== MAX_NESTED_IMPORTED_DECLARATIONS
)
10873 complaint (_("DIE at %s has too many recursively imported "
10874 "declarations"), sect_offset_str (d
->sect_off
));
10881 sect_offset sect_off
= attr
->get_ref_die_offset ();
10883 type
= get_die_type_at_offset (sect_off
, cu
->per_cu
, cu
->per_objfile
);
10884 if (type
!= NULL
&& type
->code () == TYPE_CODE_NAMESPACE
)
10886 /* This declaration is a global namespace alias. Add
10887 a symbol for it whose type is the aliased namespace. */
10888 new_symbol (die
, type
, cu
);
10897 /* Return the using directives repository (global or local?) to use in the
10898 current context for CU.
10900 For Ada, imported declarations can materialize renamings, which *may* be
10901 global. However it is impossible (for now?) in DWARF to distinguish
10902 "external" imported declarations and "static" ones. As all imported
10903 declarations seem to be static in all other languages, make them all CU-wide
10904 global only in Ada. */
10906 static struct using_direct
**
10907 using_directives (struct dwarf2_cu
*cu
)
10909 if (cu
->language
== language_ada
10910 && cu
->get_builder ()->outermost_context_p ())
10911 return cu
->get_builder ()->get_global_using_directives ();
10913 return cu
->get_builder ()->get_local_using_directives ();
10916 /* Read the import statement specified by the given die and record it. */
10919 read_import_statement (struct die_info
*die
, struct dwarf2_cu
*cu
)
10921 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
10922 struct attribute
*import_attr
;
10923 struct die_info
*imported_die
, *child_die
;
10924 struct dwarf2_cu
*imported_cu
;
10925 const char *imported_name
;
10926 const char *imported_name_prefix
;
10927 const char *canonical_name
;
10928 const char *import_alias
;
10929 const char *imported_declaration
= NULL
;
10930 const char *import_prefix
;
10931 std::vector
<const char *> excludes
;
10933 import_attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
10934 if (import_attr
== NULL
)
10936 complaint (_("Tag '%s' has no DW_AT_import"),
10937 dwarf_tag_name (die
->tag
));
10942 imported_die
= follow_die_ref_or_sig (die
, import_attr
, &imported_cu
);
10943 imported_name
= dwarf2_name (imported_die
, imported_cu
);
10944 if (imported_name
== NULL
)
10946 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
10948 The import in the following code:
10962 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
10963 <52> DW_AT_decl_file : 1
10964 <53> DW_AT_decl_line : 6
10965 <54> DW_AT_import : <0x75>
10966 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
10967 <59> DW_AT_name : B
10968 <5b> DW_AT_decl_file : 1
10969 <5c> DW_AT_decl_line : 2
10970 <5d> DW_AT_type : <0x6e>
10972 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
10973 <76> DW_AT_byte_size : 4
10974 <77> DW_AT_encoding : 5 (signed)
10976 imports the wrong die ( 0x75 instead of 0x58 ).
10977 This case will be ignored until the gcc bug is fixed. */
10981 /* Figure out the local name after import. */
10982 import_alias
= dwarf2_name (die
, cu
);
10984 /* Figure out where the statement is being imported to. */
10985 import_prefix
= determine_prefix (die
, cu
);
10987 /* Figure out what the scope of the imported die is and prepend it
10988 to the name of the imported die. */
10989 imported_name_prefix
= determine_prefix (imported_die
, imported_cu
);
10991 if (imported_die
->tag
!= DW_TAG_namespace
10992 && imported_die
->tag
!= DW_TAG_module
)
10994 imported_declaration
= imported_name
;
10995 canonical_name
= imported_name_prefix
;
10997 else if (strlen (imported_name_prefix
) > 0)
10998 canonical_name
= obconcat (&objfile
->objfile_obstack
,
10999 imported_name_prefix
,
11000 (cu
->language
== language_d
? "." : "::"),
11001 imported_name
, (char *) NULL
);
11003 canonical_name
= imported_name
;
11005 if (die
->tag
== DW_TAG_imported_module
&& cu
->language
== language_fortran
)
11006 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
11007 child_die
= child_die
->sibling
)
11009 /* DWARF-4: A Fortran use statement with a “rename list” may be
11010 represented by an imported module entry with an import attribute
11011 referring to the module and owned entries corresponding to those
11012 entities that are renamed as part of being imported. */
11014 if (child_die
->tag
!= DW_TAG_imported_declaration
)
11016 complaint (_("child DW_TAG_imported_declaration expected "
11017 "- DIE at %s [in module %s]"),
11018 sect_offset_str (child_die
->sect_off
),
11019 objfile_name (objfile
));
11023 import_attr
= dwarf2_attr (child_die
, DW_AT_import
, cu
);
11024 if (import_attr
== NULL
)
11026 complaint (_("Tag '%s' has no DW_AT_import"),
11027 dwarf_tag_name (child_die
->tag
));
11032 imported_die
= follow_die_ref_or_sig (child_die
, import_attr
,
11034 imported_name
= dwarf2_name (imported_die
, imported_cu
);
11035 if (imported_name
== NULL
)
11037 complaint (_("child DW_TAG_imported_declaration has unknown "
11038 "imported name - DIE at %s [in module %s]"),
11039 sect_offset_str (child_die
->sect_off
),
11040 objfile_name (objfile
));
11044 excludes
.push_back (imported_name
);
11046 process_die (child_die
, cu
);
11049 add_using_directive (using_directives (cu
),
11053 imported_declaration
,
11056 &objfile
->objfile_obstack
);
11059 /* ICC<14 does not output the required DW_AT_declaration on incomplete
11060 types, but gives them a size of zero. Starting with version 14,
11061 ICC is compatible with GCC. */
11064 producer_is_icc_lt_14 (struct dwarf2_cu
*cu
)
11066 if (!cu
->checked_producer
)
11067 check_producer (cu
);
11069 return cu
->producer_is_icc_lt_14
;
11072 /* ICC generates a DW_AT_type for C void functions. This was observed on
11073 ICC 14.0.5.212, and appears to be against the DWARF spec (V5 3.3.2)
11074 which says that void functions should not have a DW_AT_type. */
11077 producer_is_icc (struct dwarf2_cu
*cu
)
11079 if (!cu
->checked_producer
)
11080 check_producer (cu
);
11082 return cu
->producer_is_icc
;
11085 /* Check for possibly missing DW_AT_comp_dir with relative .debug_line
11086 directory paths. GCC SVN r127613 (new option -fdebug-prefix-map) fixed
11087 this, it was first present in GCC release 4.3.0. */
11090 producer_is_gcc_lt_4_3 (struct dwarf2_cu
*cu
)
11092 if (!cu
->checked_producer
)
11093 check_producer (cu
);
11095 return cu
->producer_is_gcc_lt_4_3
;
11098 static file_and_directory
11099 find_file_and_directory (struct die_info
*die
, struct dwarf2_cu
*cu
)
11101 file_and_directory res
;
11103 /* Find the filename. Do not use dwarf2_name here, since the filename
11104 is not a source language identifier. */
11105 res
.name
= dwarf2_string_attr (die
, DW_AT_name
, cu
);
11106 res
.comp_dir
= dwarf2_string_attr (die
, DW_AT_comp_dir
, cu
);
11108 if (res
.comp_dir
== NULL
11109 && producer_is_gcc_lt_4_3 (cu
) && res
.name
!= NULL
11110 && IS_ABSOLUTE_PATH (res
.name
))
11112 res
.comp_dir_storage
= ldirname (res
.name
);
11113 if (!res
.comp_dir_storage
.empty ())
11114 res
.comp_dir
= res
.comp_dir_storage
.c_str ();
11116 if (res
.comp_dir
!= NULL
)
11118 /* Irix 6.2 native cc prepends <machine>.: to the compilation
11119 directory, get rid of it. */
11120 const char *cp
= strchr (res
.comp_dir
, ':');
11122 if (cp
&& cp
!= res
.comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
11123 res
.comp_dir
= cp
+ 1;
11126 if (res
.name
== NULL
)
11127 res
.name
= "<unknown>";
11132 /* Handle DW_AT_stmt_list for a compilation unit.
11133 DIE is the DW_TAG_compile_unit die for CU.
11134 COMP_DIR is the compilation directory. LOWPC is passed to
11135 dwarf_decode_lines. See dwarf_decode_lines comments about it. */
11138 handle_DW_AT_stmt_list (struct die_info
*die
, struct dwarf2_cu
*cu
,
11139 const char *comp_dir
, CORE_ADDR lowpc
) /* ARI: editCase function */
11141 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
11142 struct attribute
*attr
;
11143 struct line_header line_header_local
;
11144 hashval_t line_header_local_hash
;
11146 int decode_mapping
;
11148 gdb_assert (! cu
->per_cu
->is_debug_types
);
11150 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
11151 if (attr
== NULL
|| !attr
->form_is_unsigned ())
11154 sect_offset line_offset
= (sect_offset
) attr
->as_unsigned ();
11156 /* The line header hash table is only created if needed (it exists to
11157 prevent redundant reading of the line table for partial_units).
11158 If we're given a partial_unit, we'll need it. If we're given a
11159 compile_unit, then use the line header hash table if it's already
11160 created, but don't create one just yet. */
11162 if (per_objfile
->line_header_hash
== NULL
11163 && die
->tag
== DW_TAG_partial_unit
)
11165 per_objfile
->line_header_hash
11166 .reset (htab_create_alloc (127, line_header_hash_voidp
,
11167 line_header_eq_voidp
,
11168 free_line_header_voidp
,
11172 line_header_local
.sect_off
= line_offset
;
11173 line_header_local
.offset_in_dwz
= cu
->per_cu
->is_dwz
;
11174 line_header_local_hash
= line_header_hash (&line_header_local
);
11175 if (per_objfile
->line_header_hash
!= NULL
)
11177 slot
= htab_find_slot_with_hash (per_objfile
->line_header_hash
.get (),
11178 &line_header_local
,
11179 line_header_local_hash
, NO_INSERT
);
11181 /* For DW_TAG_compile_unit we need info like symtab::linetable which
11182 is not present in *SLOT (since if there is something in *SLOT then
11183 it will be for a partial_unit). */
11184 if (die
->tag
== DW_TAG_partial_unit
&& slot
!= NULL
)
11186 gdb_assert (*slot
!= NULL
);
11187 cu
->line_header
= (struct line_header
*) *slot
;
11192 /* dwarf_decode_line_header does not yet provide sufficient information.
11193 We always have to call also dwarf_decode_lines for it. */
11194 line_header_up lh
= dwarf_decode_line_header (line_offset
, cu
);
11198 cu
->line_header
= lh
.release ();
11199 cu
->line_header_die_owner
= die
;
11201 if (per_objfile
->line_header_hash
== NULL
)
11205 slot
= htab_find_slot_with_hash (per_objfile
->line_header_hash
.get (),
11206 &line_header_local
,
11207 line_header_local_hash
, INSERT
);
11208 gdb_assert (slot
!= NULL
);
11210 if (slot
!= NULL
&& *slot
== NULL
)
11212 /* This newly decoded line number information unit will be owned
11213 by line_header_hash hash table. */
11214 *slot
= cu
->line_header
;
11215 cu
->line_header_die_owner
= NULL
;
11219 /* We cannot free any current entry in (*slot) as that struct line_header
11220 may be already used by multiple CUs. Create only temporary decoded
11221 line_header for this CU - it may happen at most once for each line
11222 number information unit. And if we're not using line_header_hash
11223 then this is what we want as well. */
11224 gdb_assert (die
->tag
!= DW_TAG_partial_unit
);
11226 decode_mapping
= (die
->tag
!= DW_TAG_partial_unit
);
11227 dwarf_decode_lines (cu
->line_header
, comp_dir
, cu
, NULL
, lowpc
,
11232 /* Process DW_TAG_compile_unit or DW_TAG_partial_unit. */
11235 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
11237 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
11238 struct objfile
*objfile
= per_objfile
->objfile
;
11239 struct gdbarch
*gdbarch
= objfile
->arch ();
11240 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
11241 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
11242 struct attribute
*attr
;
11243 struct die_info
*child_die
;
11244 CORE_ADDR baseaddr
;
11246 prepare_one_comp_unit (cu
, die
, cu
->language
);
11247 baseaddr
= objfile
->text_section_offset ();
11249 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
11251 /* If we didn't find a lowpc, set it to highpc to avoid complaints
11252 from finish_block. */
11253 if (lowpc
== ((CORE_ADDR
) -1))
11255 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
11257 file_and_directory fnd
= find_file_and_directory (die
, cu
);
11259 /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
11260 standardised yet. As a workaround for the language detection we fall
11261 back to the DW_AT_producer string. */
11262 if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL") != NULL
)
11263 cu
->language
= language_opencl
;
11265 /* Similar hack for Go. */
11266 if (cu
->producer
&& strstr (cu
->producer
, "GNU Go ") != NULL
)
11267 set_cu_language (DW_LANG_Go
, cu
);
11269 cu
->start_symtab (fnd
.name
, fnd
.comp_dir
, lowpc
);
11271 /* Decode line number information if present. We do this before
11272 processing child DIEs, so that the line header table is available
11273 for DW_AT_decl_file. */
11274 handle_DW_AT_stmt_list (die
, cu
, fnd
.comp_dir
, lowpc
);
11276 /* Process all dies in compilation unit. */
11277 if (die
->child
!= NULL
)
11279 child_die
= die
->child
;
11280 while (child_die
&& child_die
->tag
)
11282 process_die (child_die
, cu
);
11283 child_die
= child_die
->sibling
;
11287 /* Decode macro information, if present. Dwarf 2 macro information
11288 refers to information in the line number info statement program
11289 header, so we can only read it if we've read the header
11291 attr
= dwarf2_attr (die
, DW_AT_macros
, cu
);
11293 attr
= dwarf2_attr (die
, DW_AT_GNU_macros
, cu
);
11294 if (attr
!= nullptr && attr
->form_is_unsigned () && cu
->line_header
)
11296 if (dwarf2_attr (die
, DW_AT_macro_info
, cu
))
11297 complaint (_("CU refers to both DW_AT_macros and DW_AT_macro_info"));
11299 dwarf_decode_macros (cu
, attr
->as_unsigned (), 1);
11303 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
11304 if (attr
!= nullptr && attr
->form_is_unsigned () && cu
->line_header
)
11306 unsigned int macro_offset
= attr
->as_unsigned ();
11308 dwarf_decode_macros (cu
, macro_offset
, 0);
11314 dwarf2_cu::setup_type_unit_groups (struct die_info
*die
)
11316 struct type_unit_group
*tu_group
;
11318 struct attribute
*attr
;
11320 struct signatured_type
*sig_type
;
11322 gdb_assert (per_cu
->is_debug_types
);
11323 sig_type
= (struct signatured_type
*) per_cu
;
11325 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, this);
11327 /* If we're using .gdb_index (includes -readnow) then
11328 per_cu->type_unit_group may not have been set up yet. */
11329 if (sig_type
->type_unit_group
== NULL
)
11330 sig_type
->type_unit_group
= get_type_unit_group (this, attr
);
11331 tu_group
= sig_type
->type_unit_group
;
11333 /* If we've already processed this stmt_list there's no real need to
11334 do it again, we could fake it and just recreate the part we need
11335 (file name,index -> symtab mapping). If data shows this optimization
11336 is useful we can do it then. */
11337 type_unit_group_unshareable
*tug_unshare
11338 = per_objfile
->get_type_unit_group_unshareable (tu_group
);
11339 first_time
= tug_unshare
->compunit_symtab
== NULL
;
11341 /* We have to handle the case of both a missing DW_AT_stmt_list or bad
11344 if (attr
!= NULL
&& attr
->form_is_unsigned ())
11346 sect_offset line_offset
= (sect_offset
) attr
->as_unsigned ();
11347 lh
= dwarf_decode_line_header (line_offset
, this);
11352 start_symtab ("", NULL
, 0);
11355 gdb_assert (tug_unshare
->symtabs
== NULL
);
11356 gdb_assert (m_builder
== nullptr);
11357 struct compunit_symtab
*cust
= tug_unshare
->compunit_symtab
;
11358 m_builder
.reset (new struct buildsym_compunit
11359 (COMPUNIT_OBJFILE (cust
), "",
11360 COMPUNIT_DIRNAME (cust
),
11361 compunit_language (cust
),
11363 list_in_scope
= get_builder ()->get_file_symbols ();
11368 line_header
= lh
.release ();
11369 line_header_die_owner
= die
;
11373 struct compunit_symtab
*cust
= start_symtab ("", NULL
, 0);
11375 /* Note: We don't assign tu_group->compunit_symtab yet because we're
11376 still initializing it, and our caller (a few levels up)
11377 process_full_type_unit still needs to know if this is the first
11380 tug_unshare
->symtabs
11381 = XOBNEWVEC (&COMPUNIT_OBJFILE (cust
)->objfile_obstack
,
11382 struct symtab
*, line_header
->file_names_size ());
11384 auto &file_names
= line_header
->file_names ();
11385 for (i
= 0; i
< file_names
.size (); ++i
)
11387 file_entry
&fe
= file_names
[i
];
11388 dwarf2_start_subfile (this, fe
.name
,
11389 fe
.include_dir (line_header
));
11390 buildsym_compunit
*b
= get_builder ();
11391 if (b
->get_current_subfile ()->symtab
== NULL
)
11393 /* NOTE: start_subfile will recognize when it's been
11394 passed a file it has already seen. So we can't
11395 assume there's a simple mapping from
11396 cu->line_header->file_names to subfiles, plus
11397 cu->line_header->file_names may contain dups. */
11398 b
->get_current_subfile ()->symtab
11399 = allocate_symtab (cust
, b
->get_current_subfile ()->name
);
11402 fe
.symtab
= b
->get_current_subfile ()->symtab
;
11403 tug_unshare
->symtabs
[i
] = fe
.symtab
;
11408 gdb_assert (m_builder
== nullptr);
11409 struct compunit_symtab
*cust
= tug_unshare
->compunit_symtab
;
11410 m_builder
.reset (new struct buildsym_compunit
11411 (COMPUNIT_OBJFILE (cust
), "",
11412 COMPUNIT_DIRNAME (cust
),
11413 compunit_language (cust
),
11415 list_in_scope
= get_builder ()->get_file_symbols ();
11417 auto &file_names
= line_header
->file_names ();
11418 for (i
= 0; i
< file_names
.size (); ++i
)
11420 file_entry
&fe
= file_names
[i
];
11421 fe
.symtab
= tug_unshare
->symtabs
[i
];
11425 /* The main symtab is allocated last. Type units don't have DW_AT_name
11426 so they don't have a "real" (so to speak) symtab anyway.
11427 There is later code that will assign the main symtab to all symbols
11428 that don't have one. We need to handle the case of a symbol with a
11429 missing symtab (DW_AT_decl_file) anyway. */
11432 /* Process DW_TAG_type_unit.
11433 For TUs we want to skip the first top level sibling if it's not the
11434 actual type being defined by this TU. In this case the first top
11435 level sibling is there to provide context only. */
11438 read_type_unit_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
11440 struct die_info
*child_die
;
11442 prepare_one_comp_unit (cu
, die
, language_minimal
);
11444 /* Initialize (or reinitialize) the machinery for building symtabs.
11445 We do this before processing child DIEs, so that the line header table
11446 is available for DW_AT_decl_file. */
11447 cu
->setup_type_unit_groups (die
);
11449 if (die
->child
!= NULL
)
11451 child_die
= die
->child
;
11452 while (child_die
&& child_die
->tag
)
11454 process_die (child_die
, cu
);
11455 child_die
= child_die
->sibling
;
11462 http://gcc.gnu.org/wiki/DebugFission
11463 http://gcc.gnu.org/wiki/DebugFissionDWP
11465 To simplify handling of both DWO files ("object" files with the DWARF info)
11466 and DWP files (a file with the DWOs packaged up into one file), we treat
11467 DWP files as having a collection of virtual DWO files. */
11470 hash_dwo_file (const void *item
)
11472 const struct dwo_file
*dwo_file
= (const struct dwo_file
*) item
;
11475 hash
= htab_hash_string (dwo_file
->dwo_name
);
11476 if (dwo_file
->comp_dir
!= NULL
)
11477 hash
+= htab_hash_string (dwo_file
->comp_dir
);
11482 eq_dwo_file (const void *item_lhs
, const void *item_rhs
)
11484 const struct dwo_file
*lhs
= (const struct dwo_file
*) item_lhs
;
11485 const struct dwo_file
*rhs
= (const struct dwo_file
*) item_rhs
;
11487 if (strcmp (lhs
->dwo_name
, rhs
->dwo_name
) != 0)
11489 if (lhs
->comp_dir
== NULL
|| rhs
->comp_dir
== NULL
)
11490 return lhs
->comp_dir
== rhs
->comp_dir
;
11491 return strcmp (lhs
->comp_dir
, rhs
->comp_dir
) == 0;
11494 /* Allocate a hash table for DWO files. */
11497 allocate_dwo_file_hash_table ()
11499 auto delete_dwo_file
= [] (void *item
)
11501 struct dwo_file
*dwo_file
= (struct dwo_file
*) item
;
11506 return htab_up (htab_create_alloc (41,
11513 /* Lookup DWO file DWO_NAME. */
11516 lookup_dwo_file_slot (dwarf2_per_objfile
*per_objfile
,
11517 const char *dwo_name
,
11518 const char *comp_dir
)
11520 struct dwo_file find_entry
;
11523 if (per_objfile
->per_bfd
->dwo_files
== NULL
)
11524 per_objfile
->per_bfd
->dwo_files
= allocate_dwo_file_hash_table ();
11526 find_entry
.dwo_name
= dwo_name
;
11527 find_entry
.comp_dir
= comp_dir
;
11528 slot
= htab_find_slot (per_objfile
->per_bfd
->dwo_files
.get (), &find_entry
,
11535 hash_dwo_unit (const void *item
)
11537 const struct dwo_unit
*dwo_unit
= (const struct dwo_unit
*) item
;
11539 /* This drops the top 32 bits of the id, but is ok for a hash. */
11540 return dwo_unit
->signature
;
11544 eq_dwo_unit (const void *item_lhs
, const void *item_rhs
)
11546 const struct dwo_unit
*lhs
= (const struct dwo_unit
*) item_lhs
;
11547 const struct dwo_unit
*rhs
= (const struct dwo_unit
*) item_rhs
;
11549 /* The signature is assumed to be unique within the DWO file.
11550 So while object file CU dwo_id's always have the value zero,
11551 that's OK, assuming each object file DWO file has only one CU,
11552 and that's the rule for now. */
11553 return lhs
->signature
== rhs
->signature
;
11556 /* Allocate a hash table for DWO CUs,TUs.
11557 There is one of these tables for each of CUs,TUs for each DWO file. */
11560 allocate_dwo_unit_table ()
11562 /* Start out with a pretty small number.
11563 Generally DWO files contain only one CU and maybe some TUs. */
11564 return htab_up (htab_create_alloc (3,
11567 NULL
, xcalloc
, xfree
));
11570 /* die_reader_func for create_dwo_cu. */
11573 create_dwo_cu_reader (const struct die_reader_specs
*reader
,
11574 const gdb_byte
*info_ptr
,
11575 struct die_info
*comp_unit_die
,
11576 struct dwo_file
*dwo_file
,
11577 struct dwo_unit
*dwo_unit
)
11579 struct dwarf2_cu
*cu
= reader
->cu
;
11580 sect_offset sect_off
= cu
->per_cu
->sect_off
;
11581 struct dwarf2_section_info
*section
= cu
->per_cu
->section
;
11583 gdb::optional
<ULONGEST
> signature
= lookup_dwo_id (cu
, comp_unit_die
);
11584 if (!signature
.has_value ())
11586 complaint (_("Dwarf Error: debug entry at offset %s is missing"
11587 " its dwo_id [in module %s]"),
11588 sect_offset_str (sect_off
), dwo_file
->dwo_name
);
11592 dwo_unit
->dwo_file
= dwo_file
;
11593 dwo_unit
->signature
= *signature
;
11594 dwo_unit
->section
= section
;
11595 dwo_unit
->sect_off
= sect_off
;
11596 dwo_unit
->length
= cu
->per_cu
->length
;
11598 dwarf_read_debug_printf (" offset %s, dwo_id %s",
11599 sect_offset_str (sect_off
),
11600 hex_string (dwo_unit
->signature
));
11603 /* Create the dwo_units for the CUs in a DWO_FILE.
11604 Note: This function processes DWO files only, not DWP files. */
11607 create_cus_hash_table (dwarf2_per_objfile
*per_objfile
,
11608 dwarf2_cu
*cu
, struct dwo_file
&dwo_file
,
11609 dwarf2_section_info
§ion
, htab_up
&cus_htab
)
11611 struct objfile
*objfile
= per_objfile
->objfile
;
11612 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
11613 const gdb_byte
*info_ptr
, *end_ptr
;
11615 section
.read (objfile
);
11616 info_ptr
= section
.buffer
;
11618 if (info_ptr
== NULL
)
11621 dwarf_read_debug_printf ("Reading %s for %s:",
11622 section
.get_name (),
11623 section
.get_file_name ());
11625 end_ptr
= info_ptr
+ section
.size
;
11626 while (info_ptr
< end_ptr
)
11628 struct dwarf2_per_cu_data per_cu
;
11629 struct dwo_unit read_unit
{};
11630 struct dwo_unit
*dwo_unit
;
11632 sect_offset sect_off
= (sect_offset
) (info_ptr
- section
.buffer
);
11634 memset (&per_cu
, 0, sizeof (per_cu
));
11635 per_cu
.per_bfd
= per_bfd
;
11636 per_cu
.is_debug_types
= 0;
11637 per_cu
.sect_off
= sect_offset (info_ptr
- section
.buffer
);
11638 per_cu
.section
= §ion
;
11640 cutu_reader
reader (&per_cu
, per_objfile
, cu
, &dwo_file
);
11641 if (!reader
.dummy_p
)
11642 create_dwo_cu_reader (&reader
, reader
.info_ptr
, reader
.comp_unit_die
,
11643 &dwo_file
, &read_unit
);
11644 info_ptr
+= per_cu
.length
;
11646 // If the unit could not be parsed, skip it.
11647 if (read_unit
.dwo_file
== NULL
)
11650 if (cus_htab
== NULL
)
11651 cus_htab
= allocate_dwo_unit_table ();
11653 dwo_unit
= OBSTACK_ZALLOC (&per_bfd
->obstack
,
11655 *dwo_unit
= read_unit
;
11656 slot
= htab_find_slot (cus_htab
.get (), dwo_unit
, INSERT
);
11657 gdb_assert (slot
!= NULL
);
11660 const struct dwo_unit
*dup_cu
= (const struct dwo_unit
*)*slot
;
11661 sect_offset dup_sect_off
= dup_cu
->sect_off
;
11663 complaint (_("debug cu entry at offset %s is duplicate to"
11664 " the entry at offset %s, signature %s"),
11665 sect_offset_str (sect_off
), sect_offset_str (dup_sect_off
),
11666 hex_string (dwo_unit
->signature
));
11668 *slot
= (void *)dwo_unit
;
11672 /* DWP file .debug_{cu,tu}_index section format:
11673 [ref: http://gcc.gnu.org/wiki/DebugFissionDWP]
11674 [ref: http://dwarfstd.org/doc/DWARF5.pdf, sect 7.3.5 "DWARF Package Files"]
11676 DWP Versions 1 & 2 are older, pre-standard format versions. The first
11677 officially standard DWP format was published with DWARF v5 and is called
11678 Version 5. There are no versions 3 or 4.
11682 Both index sections have the same format, and serve to map a 64-bit
11683 signature to a set of section numbers. Each section begins with a header,
11684 followed by a hash table of 64-bit signatures, a parallel table of 32-bit
11685 indexes, and a pool of 32-bit section numbers. The index sections will be
11686 aligned at 8-byte boundaries in the file.
11688 The index section header consists of:
11690 V, 32 bit version number
11692 N, 32 bit number of compilation units or type units in the index
11693 M, 32 bit number of slots in the hash table
11695 Numbers are recorded using the byte order of the application binary.
11697 The hash table begins at offset 16 in the section, and consists of an array
11698 of M 64-bit slots. Each slot contains a 64-bit signature (using the byte
11699 order of the application binary). Unused slots in the hash table are 0.
11700 (We rely on the extreme unlikeliness of a signature being exactly 0.)
11702 The parallel table begins immediately after the hash table
11703 (at offset 16 + 8 * M from the beginning of the section), and consists of an
11704 array of 32-bit indexes (using the byte order of the application binary),
11705 corresponding 1-1 with slots in the hash table. Each entry in the parallel
11706 table contains a 32-bit index into the pool of section numbers. For unused
11707 hash table slots, the corresponding entry in the parallel table will be 0.
11709 The pool of section numbers begins immediately following the hash table
11710 (at offset 16 + 12 * M from the beginning of the section). The pool of
11711 section numbers consists of an array of 32-bit words (using the byte order
11712 of the application binary). Each item in the array is indexed starting
11713 from 0. The hash table entry provides the index of the first section
11714 number in the set. Additional section numbers in the set follow, and the
11715 set is terminated by a 0 entry (section number 0 is not used in ELF).
11717 In each set of section numbers, the .debug_info.dwo or .debug_types.dwo
11718 section must be the first entry in the set, and the .debug_abbrev.dwo must
11719 be the second entry. Other members of the set may follow in any order.
11723 DWP Versions 2 and 5:
11725 DWP Versions 2 and 5 combine all the .debug_info, etc. sections into one,
11726 and the entries in the index tables are now offsets into these sections.
11727 CU offsets begin at 0. TU offsets begin at the size of the .debug_info
11730 Index Section Contents:
11732 Hash Table of Signatures dwp_hash_table.hash_table
11733 Parallel Table of Indices dwp_hash_table.unit_table
11734 Table of Section Offsets dwp_hash_table.{v2|v5}.{section_ids,offsets}
11735 Table of Section Sizes dwp_hash_table.{v2|v5}.sizes
11737 The index section header consists of:
11739 V, 32 bit version number
11740 L, 32 bit number of columns in the table of section offsets
11741 N, 32 bit number of compilation units or type units in the index
11742 M, 32 bit number of slots in the hash table
11744 Numbers are recorded using the byte order of the application binary.
11746 The hash table has the same format as version 1.
11747 The parallel table of indices has the same format as version 1,
11748 except that the entries are origin-1 indices into the table of sections
11749 offsets and the table of section sizes.
11751 The table of offsets begins immediately following the parallel table
11752 (at offset 16 + 12 * M from the beginning of the section). The table is
11753 a two-dimensional array of 32-bit words (using the byte order of the
11754 application binary), with L columns and N+1 rows, in row-major order.
11755 Each row in the array is indexed starting from 0. The first row provides
11756 a key to the remaining rows: each column in this row provides an identifier
11757 for a debug section, and the offsets in the same column of subsequent rows
11758 refer to that section. The section identifiers for Version 2 are:
11760 DW_SECT_INFO 1 .debug_info.dwo
11761 DW_SECT_TYPES 2 .debug_types.dwo
11762 DW_SECT_ABBREV 3 .debug_abbrev.dwo
11763 DW_SECT_LINE 4 .debug_line.dwo
11764 DW_SECT_LOC 5 .debug_loc.dwo
11765 DW_SECT_STR_OFFSETS 6 .debug_str_offsets.dwo
11766 DW_SECT_MACINFO 7 .debug_macinfo.dwo
11767 DW_SECT_MACRO 8 .debug_macro.dwo
11769 The section identifiers for Version 5 are:
11771 DW_SECT_INFO_V5 1 .debug_info.dwo
11772 DW_SECT_RESERVED_V5 2 --
11773 DW_SECT_ABBREV_V5 3 .debug_abbrev.dwo
11774 DW_SECT_LINE_V5 4 .debug_line.dwo
11775 DW_SECT_LOCLISTS_V5 5 .debug_loclists.dwo
11776 DW_SECT_STR_OFFSETS_V5 6 .debug_str_offsets.dwo
11777 DW_SECT_MACRO_V5 7 .debug_macro.dwo
11778 DW_SECT_RNGLISTS_V5 8 .debug_rnglists.dwo
11780 The offsets provided by the CU and TU index sections are the base offsets
11781 for the contributions made by each CU or TU to the corresponding section
11782 in the package file. Each CU and TU header contains an abbrev_offset
11783 field, used to find the abbreviations table for that CU or TU within the
11784 contribution to the .debug_abbrev.dwo section for that CU or TU, and should
11785 be interpreted as relative to the base offset given in the index section.
11786 Likewise, offsets into .debug_line.dwo from DW_AT_stmt_list attributes
11787 should be interpreted as relative to the base offset for .debug_line.dwo,
11788 and offsets into other debug sections obtained from DWARF attributes should
11789 also be interpreted as relative to the corresponding base offset.
11791 The table of sizes begins immediately following the table of offsets.
11792 Like the table of offsets, it is a two-dimensional array of 32-bit words,
11793 with L columns and N rows, in row-major order. Each row in the array is
11794 indexed starting from 1 (row 0 is shared by the two tables).
11798 Hash table lookup is handled the same in version 1 and 2:
11800 We assume that N and M will not exceed 2^32 - 1.
11801 The size of the hash table, M, must be 2^k such that 2^k > 3*N/2.
11803 Given a 64-bit compilation unit signature or a type signature S, an entry
11804 in the hash table is located as follows:
11806 1) Calculate a primary hash H = S & MASK(k), where MASK(k) is a mask with
11807 the low-order k bits all set to 1.
11809 2) Calculate a secondary hash H' = (((S >> 32) & MASK(k)) | 1).
11811 3) If the hash table entry at index H matches the signature, use that
11812 entry. If the hash table entry at index H is unused (all zeroes),
11813 terminate the search: the signature is not present in the table.
11815 4) Let H = (H + H') modulo M. Repeat at Step 3.
11817 Because M > N and H' and M are relatively prime, the search is guaranteed
11818 to stop at an unused slot or find the match. */
11820 /* Create a hash table to map DWO IDs to their CU/TU entry in
11821 .debug_{info,types}.dwo in DWP_FILE.
11822 Returns NULL if there isn't one.
11823 Note: This function processes DWP files only, not DWO files. */
11825 static struct dwp_hash_table
*
11826 create_dwp_hash_table (dwarf2_per_objfile
*per_objfile
,
11827 struct dwp_file
*dwp_file
, int is_debug_types
)
11829 struct objfile
*objfile
= per_objfile
->objfile
;
11830 bfd
*dbfd
= dwp_file
->dbfd
.get ();
11831 const gdb_byte
*index_ptr
, *index_end
;
11832 struct dwarf2_section_info
*index
;
11833 uint32_t version
, nr_columns
, nr_units
, nr_slots
;
11834 struct dwp_hash_table
*htab
;
11836 if (is_debug_types
)
11837 index
= &dwp_file
->sections
.tu_index
;
11839 index
= &dwp_file
->sections
.cu_index
;
11841 if (index
->empty ())
11843 index
->read (objfile
);
11845 index_ptr
= index
->buffer
;
11846 index_end
= index_ptr
+ index
->size
;
11848 /* For Version 5, the version is really 2 bytes of data & 2 bytes of padding.
11849 For now it's safe to just read 4 bytes (particularly as it's difficult to
11850 tell if you're dealing with Version 5 before you've read the version). */
11851 version
= read_4_bytes (dbfd
, index_ptr
);
11853 if (version
== 2 || version
== 5)
11854 nr_columns
= read_4_bytes (dbfd
, index_ptr
);
11858 nr_units
= read_4_bytes (dbfd
, index_ptr
);
11860 nr_slots
= read_4_bytes (dbfd
, index_ptr
);
11863 if (version
!= 1 && version
!= 2 && version
!= 5)
11865 error (_("Dwarf Error: unsupported DWP file version (%s)"
11866 " [in module %s]"),
11867 pulongest (version
), dwp_file
->name
);
11869 if (nr_slots
!= (nr_slots
& -nr_slots
))
11871 error (_("Dwarf Error: number of slots in DWP hash table (%s)"
11872 " is not power of 2 [in module %s]"),
11873 pulongest (nr_slots
), dwp_file
->name
);
11876 htab
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, struct dwp_hash_table
);
11877 htab
->version
= version
;
11878 htab
->nr_columns
= nr_columns
;
11879 htab
->nr_units
= nr_units
;
11880 htab
->nr_slots
= nr_slots
;
11881 htab
->hash_table
= index_ptr
;
11882 htab
->unit_table
= htab
->hash_table
+ sizeof (uint64_t) * nr_slots
;
11884 /* Exit early if the table is empty. */
11885 if (nr_slots
== 0 || nr_units
== 0
11886 || (version
== 2 && nr_columns
== 0)
11887 || (version
== 5 && nr_columns
== 0))
11889 /* All must be zero. */
11890 if (nr_slots
!= 0 || nr_units
!= 0
11891 || (version
== 2 && nr_columns
!= 0)
11892 || (version
== 5 && nr_columns
!= 0))
11894 complaint (_("Empty DWP but nr_slots,nr_units,nr_columns not"
11895 " all zero [in modules %s]"),
11903 htab
->section_pool
.v1
.indices
=
11904 htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
11905 /* It's harder to decide whether the section is too small in v1.
11906 V1 is deprecated anyway so we punt. */
11908 else if (version
== 2)
11910 const gdb_byte
*ids_ptr
= htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
11911 int *ids
= htab
->section_pool
.v2
.section_ids
;
11912 size_t sizeof_ids
= sizeof (htab
->section_pool
.v2
.section_ids
);
11913 /* Reverse map for error checking. */
11914 int ids_seen
[DW_SECT_MAX
+ 1];
11917 if (nr_columns
< 2)
11919 error (_("Dwarf Error: bad DWP hash table, too few columns"
11920 " in section table [in module %s]"),
11923 if (nr_columns
> MAX_NR_V2_DWO_SECTIONS
)
11925 error (_("Dwarf Error: bad DWP hash table, too many columns"
11926 " in section table [in module %s]"),
11929 memset (ids
, 255, sizeof_ids
);
11930 memset (ids_seen
, 255, sizeof (ids_seen
));
11931 for (i
= 0; i
< nr_columns
; ++i
)
11933 int id
= read_4_bytes (dbfd
, ids_ptr
+ i
* sizeof (uint32_t));
11935 if (id
< DW_SECT_MIN
|| id
> DW_SECT_MAX
)
11937 error (_("Dwarf Error: bad DWP hash table, bad section id %d"
11938 " in section table [in module %s]"),
11939 id
, dwp_file
->name
);
11941 if (ids_seen
[id
] != -1)
11943 error (_("Dwarf Error: bad DWP hash table, duplicate section"
11944 " id %d in section table [in module %s]"),
11945 id
, dwp_file
->name
);
11950 /* Must have exactly one info or types section. */
11951 if (((ids_seen
[DW_SECT_INFO
] != -1)
11952 + (ids_seen
[DW_SECT_TYPES
] != -1))
11955 error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
11956 " DWO info/types section [in module %s]"),
11959 /* Must have an abbrev section. */
11960 if (ids_seen
[DW_SECT_ABBREV
] == -1)
11962 error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
11963 " section [in module %s]"),
11966 htab
->section_pool
.v2
.offsets
= ids_ptr
+ sizeof (uint32_t) * nr_columns
;
11967 htab
->section_pool
.v2
.sizes
=
11968 htab
->section_pool
.v2
.offsets
+ (sizeof (uint32_t)
11969 * nr_units
* nr_columns
);
11970 if ((htab
->section_pool
.v2
.sizes
+ (sizeof (uint32_t)
11971 * nr_units
* nr_columns
))
11974 error (_("Dwarf Error: DWP index section is corrupt (too small)"
11975 " [in module %s]"),
11979 else /* version == 5 */
11981 const gdb_byte
*ids_ptr
= htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
11982 int *ids
= htab
->section_pool
.v5
.section_ids
;
11983 size_t sizeof_ids
= sizeof (htab
->section_pool
.v5
.section_ids
);
11984 /* Reverse map for error checking. */
11985 int ids_seen
[DW_SECT_MAX_V5
+ 1];
11987 if (nr_columns
< 2)
11989 error (_("Dwarf Error: bad DWP hash table, too few columns"
11990 " in section table [in module %s]"),
11993 if (nr_columns
> MAX_NR_V5_DWO_SECTIONS
)
11995 error (_("Dwarf Error: bad DWP hash table, too many columns"
11996 " in section table [in module %s]"),
11999 memset (ids
, 255, sizeof_ids
);
12000 memset (ids_seen
, 255, sizeof (ids_seen
));
12001 for (int i
= 0; i
< nr_columns
; ++i
)
12003 int id
= read_4_bytes (dbfd
, ids_ptr
+ i
* sizeof (uint32_t));
12005 if (id
< DW_SECT_MIN
|| id
> DW_SECT_MAX_V5
)
12007 error (_("Dwarf Error: bad DWP hash table, bad section id %d"
12008 " in section table [in module %s]"),
12009 id
, dwp_file
->name
);
12011 if (ids_seen
[id
] != -1)
12013 error (_("Dwarf Error: bad DWP hash table, duplicate section"
12014 " id %d in section table [in module %s]"),
12015 id
, dwp_file
->name
);
12020 /* Must have seen an info section. */
12021 if (ids_seen
[DW_SECT_INFO_V5
] == -1)
12023 error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
12024 " DWO info/types section [in module %s]"),
12027 /* Must have an abbrev section. */
12028 if (ids_seen
[DW_SECT_ABBREV_V5
] == -1)
12030 error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
12031 " section [in module %s]"),
12034 htab
->section_pool
.v5
.offsets
= ids_ptr
+ sizeof (uint32_t) * nr_columns
;
12035 htab
->section_pool
.v5
.sizes
12036 = htab
->section_pool
.v5
.offsets
+ (sizeof (uint32_t)
12037 * nr_units
* nr_columns
);
12038 if ((htab
->section_pool
.v5
.sizes
+ (sizeof (uint32_t)
12039 * nr_units
* nr_columns
))
12042 error (_("Dwarf Error: DWP index section is corrupt (too small)"
12043 " [in module %s]"),
12051 /* Update SECTIONS with the data from SECTP.
12053 This function is like the other "locate" section routines, but in
12054 this context the sections to read comes from the DWP V1 hash table,
12055 not the full ELF section table.
12057 The result is non-zero for success, or zero if an error was found. */
12060 locate_v1_virtual_dwo_sections (asection
*sectp
,
12061 struct virtual_v1_dwo_sections
*sections
)
12063 const struct dwop_section_names
*names
= &dwop_section_names
;
12065 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
12067 /* There can be only one. */
12068 if (sections
->abbrev
.s
.section
!= NULL
)
12070 sections
->abbrev
.s
.section
= sectp
;
12071 sections
->abbrev
.size
= bfd_section_size (sectp
);
12073 else if (section_is_p (sectp
->name
, &names
->info_dwo
)
12074 || section_is_p (sectp
->name
, &names
->types_dwo
))
12076 /* There can be only one. */
12077 if (sections
->info_or_types
.s
.section
!= NULL
)
12079 sections
->info_or_types
.s
.section
= sectp
;
12080 sections
->info_or_types
.size
= bfd_section_size (sectp
);
12082 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
12084 /* There can be only one. */
12085 if (sections
->line
.s
.section
!= NULL
)
12087 sections
->line
.s
.section
= sectp
;
12088 sections
->line
.size
= bfd_section_size (sectp
);
12090 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
12092 /* There can be only one. */
12093 if (sections
->loc
.s
.section
!= NULL
)
12095 sections
->loc
.s
.section
= sectp
;
12096 sections
->loc
.size
= bfd_section_size (sectp
);
12098 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
12100 /* There can be only one. */
12101 if (sections
->macinfo
.s
.section
!= NULL
)
12103 sections
->macinfo
.s
.section
= sectp
;
12104 sections
->macinfo
.size
= bfd_section_size (sectp
);
12106 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
12108 /* There can be only one. */
12109 if (sections
->macro
.s
.section
!= NULL
)
12111 sections
->macro
.s
.section
= sectp
;
12112 sections
->macro
.size
= bfd_section_size (sectp
);
12114 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
12116 /* There can be only one. */
12117 if (sections
->str_offsets
.s
.section
!= NULL
)
12119 sections
->str_offsets
.s
.section
= sectp
;
12120 sections
->str_offsets
.size
= bfd_section_size (sectp
);
12124 /* No other kind of section is valid. */
12131 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12132 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12133 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12134 This is for DWP version 1 files. */
12136 static struct dwo_unit
*
12137 create_dwo_unit_in_dwp_v1 (dwarf2_per_objfile
*per_objfile
,
12138 struct dwp_file
*dwp_file
,
12139 uint32_t unit_index
,
12140 const char *comp_dir
,
12141 ULONGEST signature
, int is_debug_types
)
12143 const struct dwp_hash_table
*dwp_htab
=
12144 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12145 bfd
*dbfd
= dwp_file
->dbfd
.get ();
12146 const char *kind
= is_debug_types
? "TU" : "CU";
12147 struct dwo_file
*dwo_file
;
12148 struct dwo_unit
*dwo_unit
;
12149 struct virtual_v1_dwo_sections sections
;
12150 void **dwo_file_slot
;
12153 gdb_assert (dwp_file
->version
== 1);
12155 dwarf_read_debug_printf ("Reading %s %s/%s in DWP V1 file: %s",
12156 kind
, pulongest (unit_index
), hex_string (signature
),
12159 /* Fetch the sections of this DWO unit.
12160 Put a limit on the number of sections we look for so that bad data
12161 doesn't cause us to loop forever. */
12163 #define MAX_NR_V1_DWO_SECTIONS \
12164 (1 /* .debug_info or .debug_types */ \
12165 + 1 /* .debug_abbrev */ \
12166 + 1 /* .debug_line */ \
12167 + 1 /* .debug_loc */ \
12168 + 1 /* .debug_str_offsets */ \
12169 + 1 /* .debug_macro or .debug_macinfo */ \
12170 + 1 /* trailing zero */)
12172 memset (§ions
, 0, sizeof (sections
));
12174 for (i
= 0; i
< MAX_NR_V1_DWO_SECTIONS
; ++i
)
12177 uint32_t section_nr
=
12178 read_4_bytes (dbfd
,
12179 dwp_htab
->section_pool
.v1
.indices
12180 + (unit_index
+ i
) * sizeof (uint32_t));
12182 if (section_nr
== 0)
12184 if (section_nr
>= dwp_file
->num_sections
)
12186 error (_("Dwarf Error: bad DWP hash table, section number too large"
12187 " [in module %s]"),
12191 sectp
= dwp_file
->elf_sections
[section_nr
];
12192 if (! locate_v1_virtual_dwo_sections (sectp
, §ions
))
12194 error (_("Dwarf Error: bad DWP hash table, invalid section found"
12195 " [in module %s]"),
12201 || sections
.info_or_types
.empty ()
12202 || sections
.abbrev
.empty ())
12204 error (_("Dwarf Error: bad DWP hash table, missing DWO sections"
12205 " [in module %s]"),
12208 if (i
== MAX_NR_V1_DWO_SECTIONS
)
12210 error (_("Dwarf Error: bad DWP hash table, too many DWO sections"
12211 " [in module %s]"),
12215 /* It's easier for the rest of the code if we fake a struct dwo_file and
12216 have dwo_unit "live" in that. At least for now.
12218 The DWP file can be made up of a random collection of CUs and TUs.
12219 However, for each CU + set of TUs that came from the same original DWO
12220 file, we can combine them back into a virtual DWO file to save space
12221 (fewer struct dwo_file objects to allocate). Remember that for really
12222 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
12224 std::string virtual_dwo_name
=
12225 string_printf ("virtual-dwo/%d-%d-%d-%d",
12226 sections
.abbrev
.get_id (),
12227 sections
.line
.get_id (),
12228 sections
.loc
.get_id (),
12229 sections
.str_offsets
.get_id ());
12230 /* Can we use an existing virtual DWO file? */
12231 dwo_file_slot
= lookup_dwo_file_slot (per_objfile
, virtual_dwo_name
.c_str (),
12233 /* Create one if necessary. */
12234 if (*dwo_file_slot
== NULL
)
12236 dwarf_read_debug_printf ("Creating virtual DWO: %s",
12237 virtual_dwo_name
.c_str ());
12239 dwo_file
= new struct dwo_file
;
12240 dwo_file
->dwo_name
= per_objfile
->objfile
->intern (virtual_dwo_name
);
12241 dwo_file
->comp_dir
= comp_dir
;
12242 dwo_file
->sections
.abbrev
= sections
.abbrev
;
12243 dwo_file
->sections
.line
= sections
.line
;
12244 dwo_file
->sections
.loc
= sections
.loc
;
12245 dwo_file
->sections
.macinfo
= sections
.macinfo
;
12246 dwo_file
->sections
.macro
= sections
.macro
;
12247 dwo_file
->sections
.str_offsets
= sections
.str_offsets
;
12248 /* The "str" section is global to the entire DWP file. */
12249 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
12250 /* The info or types section is assigned below to dwo_unit,
12251 there's no need to record it in dwo_file.
12252 Also, we can't simply record type sections in dwo_file because
12253 we record a pointer into the vector in dwo_unit. As we collect more
12254 types we'll grow the vector and eventually have to reallocate space
12255 for it, invalidating all copies of pointers into the previous
12257 *dwo_file_slot
= dwo_file
;
12261 dwarf_read_debug_printf ("Using existing virtual DWO: %s",
12262 virtual_dwo_name
.c_str ());
12264 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
12267 dwo_unit
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, struct dwo_unit
);
12268 dwo_unit
->dwo_file
= dwo_file
;
12269 dwo_unit
->signature
= signature
;
12270 dwo_unit
->section
=
12271 XOBNEW (&per_objfile
->per_bfd
->obstack
, struct dwarf2_section_info
);
12272 *dwo_unit
->section
= sections
.info_or_types
;
12273 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12278 /* Subroutine of create_dwo_unit_in_dwp_v2 and create_dwo_unit_in_dwp_v5 to
12279 simplify them. Given a pointer to the containing section SECTION, and
12280 OFFSET,SIZE of the piece within that section used by a TU/CU, return a
12281 virtual section of just that piece. */
12283 static struct dwarf2_section_info
12284 create_dwp_v2_or_v5_section (dwarf2_per_objfile
*per_objfile
,
12285 struct dwarf2_section_info
*section
,
12286 bfd_size_type offset
, bfd_size_type size
)
12288 struct dwarf2_section_info result
;
12291 gdb_assert (section
!= NULL
);
12292 gdb_assert (!section
->is_virtual
);
12294 memset (&result
, 0, sizeof (result
));
12295 result
.s
.containing_section
= section
;
12296 result
.is_virtual
= true;
12301 sectp
= section
->get_bfd_section ();
12303 /* Flag an error if the piece denoted by OFFSET,SIZE is outside the
12304 bounds of the real section. This is a pretty-rare event, so just
12305 flag an error (easier) instead of a warning and trying to cope. */
12307 || offset
+ size
> bfd_section_size (sectp
))
12309 error (_("Dwarf Error: Bad DWP V2 or V5 section info, doesn't fit"
12310 " in section %s [in module %s]"),
12311 sectp
? bfd_section_name (sectp
) : "<unknown>",
12312 objfile_name (per_objfile
->objfile
));
12315 result
.virtual_offset
= offset
;
12316 result
.size
= size
;
12320 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12321 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12322 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12323 This is for DWP version 2 files. */
12325 static struct dwo_unit
*
12326 create_dwo_unit_in_dwp_v2 (dwarf2_per_objfile
*per_objfile
,
12327 struct dwp_file
*dwp_file
,
12328 uint32_t unit_index
,
12329 const char *comp_dir
,
12330 ULONGEST signature
, int is_debug_types
)
12332 const struct dwp_hash_table
*dwp_htab
=
12333 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12334 bfd
*dbfd
= dwp_file
->dbfd
.get ();
12335 const char *kind
= is_debug_types
? "TU" : "CU";
12336 struct dwo_file
*dwo_file
;
12337 struct dwo_unit
*dwo_unit
;
12338 struct virtual_v2_or_v5_dwo_sections sections
;
12339 void **dwo_file_slot
;
12342 gdb_assert (dwp_file
->version
== 2);
12344 dwarf_read_debug_printf ("Reading %s %s/%s in DWP V2 file: %s",
12345 kind
, pulongest (unit_index
), hex_string (signature
),
12348 /* Fetch the section offsets of this DWO unit. */
12350 memset (§ions
, 0, sizeof (sections
));
12352 for (i
= 0; i
< dwp_htab
->nr_columns
; ++i
)
12354 uint32_t offset
= read_4_bytes (dbfd
,
12355 dwp_htab
->section_pool
.v2
.offsets
12356 + (((unit_index
- 1) * dwp_htab
->nr_columns
12358 * sizeof (uint32_t)));
12359 uint32_t size
= read_4_bytes (dbfd
,
12360 dwp_htab
->section_pool
.v2
.sizes
12361 + (((unit_index
- 1) * dwp_htab
->nr_columns
12363 * sizeof (uint32_t)));
12365 switch (dwp_htab
->section_pool
.v2
.section_ids
[i
])
12368 case DW_SECT_TYPES
:
12369 sections
.info_or_types_offset
= offset
;
12370 sections
.info_or_types_size
= size
;
12372 case DW_SECT_ABBREV
:
12373 sections
.abbrev_offset
= offset
;
12374 sections
.abbrev_size
= size
;
12377 sections
.line_offset
= offset
;
12378 sections
.line_size
= size
;
12381 sections
.loc_offset
= offset
;
12382 sections
.loc_size
= size
;
12384 case DW_SECT_STR_OFFSETS
:
12385 sections
.str_offsets_offset
= offset
;
12386 sections
.str_offsets_size
= size
;
12388 case DW_SECT_MACINFO
:
12389 sections
.macinfo_offset
= offset
;
12390 sections
.macinfo_size
= size
;
12392 case DW_SECT_MACRO
:
12393 sections
.macro_offset
= offset
;
12394 sections
.macro_size
= size
;
12399 /* It's easier for the rest of the code if we fake a struct dwo_file and
12400 have dwo_unit "live" in that. At least for now.
12402 The DWP file can be made up of a random collection of CUs and TUs.
12403 However, for each CU + set of TUs that came from the same original DWO
12404 file, we can combine them back into a virtual DWO file to save space
12405 (fewer struct dwo_file objects to allocate). Remember that for really
12406 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
12408 std::string virtual_dwo_name
=
12409 string_printf ("virtual-dwo/%ld-%ld-%ld-%ld",
12410 (long) (sections
.abbrev_size
? sections
.abbrev_offset
: 0),
12411 (long) (sections
.line_size
? sections
.line_offset
: 0),
12412 (long) (sections
.loc_size
? sections
.loc_offset
: 0),
12413 (long) (sections
.str_offsets_size
12414 ? sections
.str_offsets_offset
: 0));
12415 /* Can we use an existing virtual DWO file? */
12416 dwo_file_slot
= lookup_dwo_file_slot (per_objfile
, virtual_dwo_name
.c_str (),
12418 /* Create one if necessary. */
12419 if (*dwo_file_slot
== NULL
)
12421 dwarf_read_debug_printf ("Creating virtual DWO: %s",
12422 virtual_dwo_name
.c_str ());
12424 dwo_file
= new struct dwo_file
;
12425 dwo_file
->dwo_name
= per_objfile
->objfile
->intern (virtual_dwo_name
);
12426 dwo_file
->comp_dir
= comp_dir
;
12427 dwo_file
->sections
.abbrev
=
12428 create_dwp_v2_or_v5_section (per_objfile
, &dwp_file
->sections
.abbrev
,
12429 sections
.abbrev_offset
,
12430 sections
.abbrev_size
);
12431 dwo_file
->sections
.line
=
12432 create_dwp_v2_or_v5_section (per_objfile
, &dwp_file
->sections
.line
,
12433 sections
.line_offset
,
12434 sections
.line_size
);
12435 dwo_file
->sections
.loc
=
12436 create_dwp_v2_or_v5_section (per_objfile
, &dwp_file
->sections
.loc
,
12437 sections
.loc_offset
, sections
.loc_size
);
12438 dwo_file
->sections
.macinfo
=
12439 create_dwp_v2_or_v5_section (per_objfile
, &dwp_file
->sections
.macinfo
,
12440 sections
.macinfo_offset
,
12441 sections
.macinfo_size
);
12442 dwo_file
->sections
.macro
=
12443 create_dwp_v2_or_v5_section (per_objfile
, &dwp_file
->sections
.macro
,
12444 sections
.macro_offset
,
12445 sections
.macro_size
);
12446 dwo_file
->sections
.str_offsets
=
12447 create_dwp_v2_or_v5_section (per_objfile
,
12448 &dwp_file
->sections
.str_offsets
,
12449 sections
.str_offsets_offset
,
12450 sections
.str_offsets_size
);
12451 /* The "str" section is global to the entire DWP file. */
12452 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
12453 /* The info or types section is assigned below to dwo_unit,
12454 there's no need to record it in dwo_file.
12455 Also, we can't simply record type sections in dwo_file because
12456 we record a pointer into the vector in dwo_unit. As we collect more
12457 types we'll grow the vector and eventually have to reallocate space
12458 for it, invalidating all copies of pointers into the previous
12460 *dwo_file_slot
= dwo_file
;
12464 dwarf_read_debug_printf ("Using existing virtual DWO: %s",
12465 virtual_dwo_name
.c_str ());
12467 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
12470 dwo_unit
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, struct dwo_unit
);
12471 dwo_unit
->dwo_file
= dwo_file
;
12472 dwo_unit
->signature
= signature
;
12473 dwo_unit
->section
=
12474 XOBNEW (&per_objfile
->per_bfd
->obstack
, struct dwarf2_section_info
);
12475 *dwo_unit
->section
= create_dwp_v2_or_v5_section
12478 ? &dwp_file
->sections
.types
12479 : &dwp_file
->sections
.info
,
12480 sections
.info_or_types_offset
,
12481 sections
.info_or_types_size
);
12482 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12487 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12488 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12489 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12490 This is for DWP version 5 files. */
12492 static struct dwo_unit
*
12493 create_dwo_unit_in_dwp_v5 (dwarf2_per_objfile
*per_objfile
,
12494 struct dwp_file
*dwp_file
,
12495 uint32_t unit_index
,
12496 const char *comp_dir
,
12497 ULONGEST signature
, int is_debug_types
)
12499 const struct dwp_hash_table
*dwp_htab
12500 = is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12501 bfd
*dbfd
= dwp_file
->dbfd
.get ();
12502 const char *kind
= is_debug_types
? "TU" : "CU";
12503 struct dwo_file
*dwo_file
;
12504 struct dwo_unit
*dwo_unit
;
12505 struct virtual_v2_or_v5_dwo_sections sections
{};
12506 void **dwo_file_slot
;
12508 gdb_assert (dwp_file
->version
== 5);
12510 dwarf_read_debug_printf ("Reading %s %s/%s in DWP V5 file: %s",
12511 kind
, pulongest (unit_index
), hex_string (signature
),
12514 /* Fetch the section offsets of this DWO unit. */
12516 /* memset (§ions, 0, sizeof (sections)); */
12518 for (int i
= 0; i
< dwp_htab
->nr_columns
; ++i
)
12520 uint32_t offset
= read_4_bytes (dbfd
,
12521 dwp_htab
->section_pool
.v5
.offsets
12522 + (((unit_index
- 1)
12523 * dwp_htab
->nr_columns
12525 * sizeof (uint32_t)));
12526 uint32_t size
= read_4_bytes (dbfd
,
12527 dwp_htab
->section_pool
.v5
.sizes
12528 + (((unit_index
- 1) * dwp_htab
->nr_columns
12530 * sizeof (uint32_t)));
12532 switch (dwp_htab
->section_pool
.v5
.section_ids
[i
])
12534 case DW_SECT_ABBREV_V5
:
12535 sections
.abbrev_offset
= offset
;
12536 sections
.abbrev_size
= size
;
12538 case DW_SECT_INFO_V5
:
12539 sections
.info_or_types_offset
= offset
;
12540 sections
.info_or_types_size
= size
;
12542 case DW_SECT_LINE_V5
:
12543 sections
.line_offset
= offset
;
12544 sections
.line_size
= size
;
12546 case DW_SECT_LOCLISTS_V5
:
12547 sections
.loclists_offset
= offset
;
12548 sections
.loclists_size
= size
;
12550 case DW_SECT_MACRO_V5
:
12551 sections
.macro_offset
= offset
;
12552 sections
.macro_size
= size
;
12554 case DW_SECT_RNGLISTS_V5
:
12555 sections
.rnglists_offset
= offset
;
12556 sections
.rnglists_size
= size
;
12558 case DW_SECT_STR_OFFSETS_V5
:
12559 sections
.str_offsets_offset
= offset
;
12560 sections
.str_offsets_size
= size
;
12562 case DW_SECT_RESERVED_V5
:
12568 /* It's easier for the rest of the code if we fake a struct dwo_file and
12569 have dwo_unit "live" in that. At least for now.
12571 The DWP file can be made up of a random collection of CUs and TUs.
12572 However, for each CU + set of TUs that came from the same original DWO
12573 file, we can combine them back into a virtual DWO file to save space
12574 (fewer struct dwo_file objects to allocate). Remember that for really
12575 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
12577 std::string virtual_dwo_name
=
12578 string_printf ("virtual-dwo/%ld-%ld-%ld-%ld-%ld-%ld",
12579 (long) (sections
.abbrev_size
? sections
.abbrev_offset
: 0),
12580 (long) (sections
.line_size
? sections
.line_offset
: 0),
12581 (long) (sections
.loclists_size
? sections
.loclists_offset
: 0),
12582 (long) (sections
.str_offsets_size
12583 ? sections
.str_offsets_offset
: 0),
12584 (long) (sections
.macro_size
? sections
.macro_offset
: 0),
12585 (long) (sections
.rnglists_size
? sections
.rnglists_offset
: 0));
12586 /* Can we use an existing virtual DWO file? */
12587 dwo_file_slot
= lookup_dwo_file_slot (per_objfile
,
12588 virtual_dwo_name
.c_str (),
12590 /* Create one if necessary. */
12591 if (*dwo_file_slot
== NULL
)
12593 dwarf_read_debug_printf ("Creating virtual DWO: %s",
12594 virtual_dwo_name
.c_str ());
12596 dwo_file
= new struct dwo_file
;
12597 dwo_file
->dwo_name
= per_objfile
->objfile
->intern (virtual_dwo_name
);
12598 dwo_file
->comp_dir
= comp_dir
;
12599 dwo_file
->sections
.abbrev
=
12600 create_dwp_v2_or_v5_section (per_objfile
,
12601 &dwp_file
->sections
.abbrev
,
12602 sections
.abbrev_offset
,
12603 sections
.abbrev_size
);
12604 dwo_file
->sections
.line
=
12605 create_dwp_v2_or_v5_section (per_objfile
,
12606 &dwp_file
->sections
.line
,
12607 sections
.line_offset
, sections
.line_size
);
12608 dwo_file
->sections
.macro
=
12609 create_dwp_v2_or_v5_section (per_objfile
,
12610 &dwp_file
->sections
.macro
,
12611 sections
.macro_offset
,
12612 sections
.macro_size
);
12613 dwo_file
->sections
.loclists
=
12614 create_dwp_v2_or_v5_section (per_objfile
,
12615 &dwp_file
->sections
.loclists
,
12616 sections
.loclists_offset
,
12617 sections
.loclists_size
);
12618 dwo_file
->sections
.rnglists
=
12619 create_dwp_v2_or_v5_section (per_objfile
,
12620 &dwp_file
->sections
.rnglists
,
12621 sections
.rnglists_offset
,
12622 sections
.rnglists_size
);
12623 dwo_file
->sections
.str_offsets
=
12624 create_dwp_v2_or_v5_section (per_objfile
,
12625 &dwp_file
->sections
.str_offsets
,
12626 sections
.str_offsets_offset
,
12627 sections
.str_offsets_size
);
12628 /* The "str" section is global to the entire DWP file. */
12629 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
12630 /* The info or types section is assigned below to dwo_unit,
12631 there's no need to record it in dwo_file.
12632 Also, we can't simply record type sections in dwo_file because
12633 we record a pointer into the vector in dwo_unit. As we collect more
12634 types we'll grow the vector and eventually have to reallocate space
12635 for it, invalidating all copies of pointers into the previous
12637 *dwo_file_slot
= dwo_file
;
12641 dwarf_read_debug_printf ("Using existing virtual DWO: %s",
12642 virtual_dwo_name
.c_str ());
12644 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
12647 dwo_unit
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, struct dwo_unit
);
12648 dwo_unit
->dwo_file
= dwo_file
;
12649 dwo_unit
->signature
= signature
;
12651 = XOBNEW (&per_objfile
->per_bfd
->obstack
, struct dwarf2_section_info
);
12652 *dwo_unit
->section
= create_dwp_v2_or_v5_section (per_objfile
,
12653 &dwp_file
->sections
.info
,
12654 sections
.info_or_types_offset
,
12655 sections
.info_or_types_size
);
12656 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12661 /* Lookup the DWO unit with SIGNATURE in DWP_FILE.
12662 Returns NULL if the signature isn't found. */
12664 static struct dwo_unit
*
12665 lookup_dwo_unit_in_dwp (dwarf2_per_objfile
*per_objfile
,
12666 struct dwp_file
*dwp_file
, const char *comp_dir
,
12667 ULONGEST signature
, int is_debug_types
)
12669 const struct dwp_hash_table
*dwp_htab
=
12670 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12671 bfd
*dbfd
= dwp_file
->dbfd
.get ();
12672 uint32_t mask
= dwp_htab
->nr_slots
- 1;
12673 uint32_t hash
= signature
& mask
;
12674 uint32_t hash2
= ((signature
>> 32) & mask
) | 1;
12677 struct dwo_unit find_dwo_cu
;
12679 memset (&find_dwo_cu
, 0, sizeof (find_dwo_cu
));
12680 find_dwo_cu
.signature
= signature
;
12681 slot
= htab_find_slot (is_debug_types
12682 ? dwp_file
->loaded_tus
.get ()
12683 : dwp_file
->loaded_cus
.get (),
12684 &find_dwo_cu
, INSERT
);
12687 return (struct dwo_unit
*) *slot
;
12689 /* Use a for loop so that we don't loop forever on bad debug info. */
12690 for (i
= 0; i
< dwp_htab
->nr_slots
; ++i
)
12692 ULONGEST signature_in_table
;
12694 signature_in_table
=
12695 read_8_bytes (dbfd
, dwp_htab
->hash_table
+ hash
* sizeof (uint64_t));
12696 if (signature_in_table
== signature
)
12698 uint32_t unit_index
=
12699 read_4_bytes (dbfd
,
12700 dwp_htab
->unit_table
+ hash
* sizeof (uint32_t));
12702 if (dwp_file
->version
== 1)
12704 *slot
= create_dwo_unit_in_dwp_v1 (per_objfile
, dwp_file
,
12705 unit_index
, comp_dir
,
12706 signature
, is_debug_types
);
12708 else if (dwp_file
->version
== 2)
12710 *slot
= create_dwo_unit_in_dwp_v2 (per_objfile
, dwp_file
,
12711 unit_index
, comp_dir
,
12712 signature
, is_debug_types
);
12714 else /* version == 5 */
12716 *slot
= create_dwo_unit_in_dwp_v5 (per_objfile
, dwp_file
,
12717 unit_index
, comp_dir
,
12718 signature
, is_debug_types
);
12720 return (struct dwo_unit
*) *slot
;
12722 if (signature_in_table
== 0)
12724 hash
= (hash
+ hash2
) & mask
;
12727 error (_("Dwarf Error: bad DWP hash table, lookup didn't terminate"
12728 " [in module %s]"),
12732 /* Subroutine of open_dwo_file,open_dwp_file to simplify them.
12733 Open the file specified by FILE_NAME and hand it off to BFD for
12734 preliminary analysis. Return a newly initialized bfd *, which
12735 includes a canonicalized copy of FILE_NAME.
12736 If IS_DWP is TRUE, we're opening a DWP file, otherwise a DWO file.
12737 SEARCH_CWD is true if the current directory is to be searched.
12738 It will be searched before debug-file-directory.
12739 If successful, the file is added to the bfd include table of the
12740 objfile's bfd (see gdb_bfd_record_inclusion).
12741 If unable to find/open the file, return NULL.
12742 NOTE: This function is derived from symfile_bfd_open. */
12744 static gdb_bfd_ref_ptr
12745 try_open_dwop_file (dwarf2_per_objfile
*per_objfile
,
12746 const char *file_name
, int is_dwp
, int search_cwd
)
12749 /* Blech. OPF_TRY_CWD_FIRST also disables searching the path list if
12750 FILE_NAME contains a '/'. So we can't use it. Instead prepend "."
12751 to debug_file_directory. */
12752 const char *search_path
;
12753 static const char dirname_separator_string
[] = { DIRNAME_SEPARATOR
, '\0' };
12755 gdb::unique_xmalloc_ptr
<char> search_path_holder
;
12758 if (*debug_file_directory
!= '\0')
12760 search_path_holder
.reset (concat (".", dirname_separator_string
,
12761 debug_file_directory
,
12763 search_path
= search_path_holder
.get ();
12769 search_path
= debug_file_directory
;
12771 openp_flags flags
= OPF_RETURN_REALPATH
;
12773 flags
|= OPF_SEARCH_IN_PATH
;
12775 gdb::unique_xmalloc_ptr
<char> absolute_name
;
12776 desc
= openp (search_path
, flags
, file_name
,
12777 O_RDONLY
| O_BINARY
, &absolute_name
);
12781 gdb_bfd_ref_ptr
sym_bfd (gdb_bfd_open (absolute_name
.get (),
12783 if (sym_bfd
== NULL
)
12785 bfd_set_cacheable (sym_bfd
.get (), 1);
12787 if (!bfd_check_format (sym_bfd
.get (), bfd_object
))
12790 /* Success. Record the bfd as having been included by the objfile's bfd.
12791 This is important because things like demangled_names_hash lives in the
12792 objfile's per_bfd space and may have references to things like symbol
12793 names that live in the DWO/DWP file's per_bfd space. PR 16426. */
12794 gdb_bfd_record_inclusion (per_objfile
->objfile
->obfd
, sym_bfd
.get ());
12799 /* Try to open DWO file FILE_NAME.
12800 COMP_DIR is the DW_AT_comp_dir attribute.
12801 The result is the bfd handle of the file.
12802 If there is a problem finding or opening the file, return NULL.
12803 Upon success, the canonicalized path of the file is stored in the bfd,
12804 same as symfile_bfd_open. */
12806 static gdb_bfd_ref_ptr
12807 open_dwo_file (dwarf2_per_objfile
*per_objfile
,
12808 const char *file_name
, const char *comp_dir
)
12810 if (IS_ABSOLUTE_PATH (file_name
))
12811 return try_open_dwop_file (per_objfile
, file_name
,
12812 0 /*is_dwp*/, 0 /*search_cwd*/);
12814 /* Before trying the search path, try DWO_NAME in COMP_DIR. */
12816 if (comp_dir
!= NULL
)
12818 gdb::unique_xmalloc_ptr
<char> path_to_try
12819 (concat (comp_dir
, SLASH_STRING
, file_name
, (char *) NULL
));
12821 /* NOTE: If comp_dir is a relative path, this will also try the
12822 search path, which seems useful. */
12823 gdb_bfd_ref_ptr
abfd (try_open_dwop_file (per_objfile
, path_to_try
.get (),
12825 1 /*search_cwd*/));
12830 /* That didn't work, try debug-file-directory, which, despite its name,
12831 is a list of paths. */
12833 if (*debug_file_directory
== '\0')
12836 return try_open_dwop_file (per_objfile
, file_name
,
12837 0 /*is_dwp*/, 1 /*search_cwd*/);
12840 /* This function is mapped across the sections and remembers the offset and
12841 size of each of the DWO debugging sections we are interested in. */
12844 dwarf2_locate_dwo_sections (bfd
*abfd
, asection
*sectp
,
12845 dwo_sections
*dwo_sections
)
12847 const struct dwop_section_names
*names
= &dwop_section_names
;
12849 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
12851 dwo_sections
->abbrev
.s
.section
= sectp
;
12852 dwo_sections
->abbrev
.size
= bfd_section_size (sectp
);
12854 else if (section_is_p (sectp
->name
, &names
->info_dwo
))
12856 dwo_sections
->info
.s
.section
= sectp
;
12857 dwo_sections
->info
.size
= bfd_section_size (sectp
);
12859 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
12861 dwo_sections
->line
.s
.section
= sectp
;
12862 dwo_sections
->line
.size
= bfd_section_size (sectp
);
12864 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
12866 dwo_sections
->loc
.s
.section
= sectp
;
12867 dwo_sections
->loc
.size
= bfd_section_size (sectp
);
12869 else if (section_is_p (sectp
->name
, &names
->loclists_dwo
))
12871 dwo_sections
->loclists
.s
.section
= sectp
;
12872 dwo_sections
->loclists
.size
= bfd_section_size (sectp
);
12874 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
12876 dwo_sections
->macinfo
.s
.section
= sectp
;
12877 dwo_sections
->macinfo
.size
= bfd_section_size (sectp
);
12879 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
12881 dwo_sections
->macro
.s
.section
= sectp
;
12882 dwo_sections
->macro
.size
= bfd_section_size (sectp
);
12884 else if (section_is_p (sectp
->name
, &names
->rnglists_dwo
))
12886 dwo_sections
->rnglists
.s
.section
= sectp
;
12887 dwo_sections
->rnglists
.size
= bfd_section_size (sectp
);
12889 else if (section_is_p (sectp
->name
, &names
->str_dwo
))
12891 dwo_sections
->str
.s
.section
= sectp
;
12892 dwo_sections
->str
.size
= bfd_section_size (sectp
);
12894 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
12896 dwo_sections
->str_offsets
.s
.section
= sectp
;
12897 dwo_sections
->str_offsets
.size
= bfd_section_size (sectp
);
12899 else if (section_is_p (sectp
->name
, &names
->types_dwo
))
12901 struct dwarf2_section_info type_section
;
12903 memset (&type_section
, 0, sizeof (type_section
));
12904 type_section
.s
.section
= sectp
;
12905 type_section
.size
= bfd_section_size (sectp
);
12906 dwo_sections
->types
.push_back (type_section
);
12910 /* Initialize the use of the DWO file specified by DWO_NAME and referenced
12911 by PER_CU. This is for the non-DWP case.
12912 The result is NULL if DWO_NAME can't be found. */
12914 static struct dwo_file
*
12915 open_and_init_dwo_file (dwarf2_cu
*cu
, const char *dwo_name
,
12916 const char *comp_dir
)
12918 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
12920 gdb_bfd_ref_ptr dbfd
= open_dwo_file (per_objfile
, dwo_name
, comp_dir
);
12923 dwarf_read_debug_printf ("DWO file not found: %s", dwo_name
);
12928 dwo_file_up
dwo_file (new struct dwo_file
);
12929 dwo_file
->dwo_name
= dwo_name
;
12930 dwo_file
->comp_dir
= comp_dir
;
12931 dwo_file
->dbfd
= std::move (dbfd
);
12933 for (asection
*sec
: gdb_bfd_sections (dwo_file
->dbfd
))
12934 dwarf2_locate_dwo_sections (dwo_file
->dbfd
.get (), sec
,
12935 &dwo_file
->sections
);
12937 create_cus_hash_table (per_objfile
, cu
, *dwo_file
, dwo_file
->sections
.info
,
12940 if (cu
->per_cu
->dwarf_version
< 5)
12942 create_debug_types_hash_table (per_objfile
, dwo_file
.get (),
12943 dwo_file
->sections
.types
, dwo_file
->tus
);
12947 create_debug_type_hash_table (per_objfile
, dwo_file
.get (),
12948 &dwo_file
->sections
.info
, dwo_file
->tus
,
12952 dwarf_read_debug_printf ("DWO file found: %s", dwo_name
);
12954 return dwo_file
.release ();
12957 /* This function is mapped across the sections and remembers the offset and
12958 size of each of the DWP debugging sections common to version 1 and 2 that
12959 we are interested in. */
12962 dwarf2_locate_common_dwp_sections (bfd
*abfd
, asection
*sectp
,
12963 dwp_file
*dwp_file
)
12965 const struct dwop_section_names
*names
= &dwop_section_names
;
12966 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
12968 /* Record the ELF section number for later lookup: this is what the
12969 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
12970 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
12971 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
12973 /* Look for specific sections that we need. */
12974 if (section_is_p (sectp
->name
, &names
->str_dwo
))
12976 dwp_file
->sections
.str
.s
.section
= sectp
;
12977 dwp_file
->sections
.str
.size
= bfd_section_size (sectp
);
12979 else if (section_is_p (sectp
->name
, &names
->cu_index
))
12981 dwp_file
->sections
.cu_index
.s
.section
= sectp
;
12982 dwp_file
->sections
.cu_index
.size
= bfd_section_size (sectp
);
12984 else if (section_is_p (sectp
->name
, &names
->tu_index
))
12986 dwp_file
->sections
.tu_index
.s
.section
= sectp
;
12987 dwp_file
->sections
.tu_index
.size
= bfd_section_size (sectp
);
12991 /* This function is mapped across the sections and remembers the offset and
12992 size of each of the DWP version 2 debugging sections that we are interested
12993 in. This is split into a separate function because we don't know if we
12994 have version 1 or 2 or 5 until we parse the cu_index/tu_index sections. */
12997 dwarf2_locate_v2_dwp_sections (bfd
*abfd
, asection
*sectp
, void *dwp_file_ptr
)
12999 struct dwp_file
*dwp_file
= (struct dwp_file
*) dwp_file_ptr
;
13000 const struct dwop_section_names
*names
= &dwop_section_names
;
13001 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
13003 /* Record the ELF section number for later lookup: this is what the
13004 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
13005 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
13006 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
13008 /* Look for specific sections that we need. */
13009 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
13011 dwp_file
->sections
.abbrev
.s
.section
= sectp
;
13012 dwp_file
->sections
.abbrev
.size
= bfd_section_size (sectp
);
13014 else if (section_is_p (sectp
->name
, &names
->info_dwo
))
13016 dwp_file
->sections
.info
.s
.section
= sectp
;
13017 dwp_file
->sections
.info
.size
= bfd_section_size (sectp
);
13019 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
13021 dwp_file
->sections
.line
.s
.section
= sectp
;
13022 dwp_file
->sections
.line
.size
= bfd_section_size (sectp
);
13024 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
13026 dwp_file
->sections
.loc
.s
.section
= sectp
;
13027 dwp_file
->sections
.loc
.size
= bfd_section_size (sectp
);
13029 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
13031 dwp_file
->sections
.macinfo
.s
.section
= sectp
;
13032 dwp_file
->sections
.macinfo
.size
= bfd_section_size (sectp
);
13034 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
13036 dwp_file
->sections
.macro
.s
.section
= sectp
;
13037 dwp_file
->sections
.macro
.size
= bfd_section_size (sectp
);
13039 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
13041 dwp_file
->sections
.str_offsets
.s
.section
= sectp
;
13042 dwp_file
->sections
.str_offsets
.size
= bfd_section_size (sectp
);
13044 else if (section_is_p (sectp
->name
, &names
->types_dwo
))
13046 dwp_file
->sections
.types
.s
.section
= sectp
;
13047 dwp_file
->sections
.types
.size
= bfd_section_size (sectp
);
13051 /* This function is mapped across the sections and remembers the offset and
13052 size of each of the DWP version 5 debugging sections that we are interested
13053 in. This is split into a separate function because we don't know if we
13054 have version 1 or 2 or 5 until we parse the cu_index/tu_index sections. */
13057 dwarf2_locate_v5_dwp_sections (bfd
*abfd
, asection
*sectp
, void *dwp_file_ptr
)
13059 struct dwp_file
*dwp_file
= (struct dwp_file
*) dwp_file_ptr
;
13060 const struct dwop_section_names
*names
= &dwop_section_names
;
13061 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
13063 /* Record the ELF section number for later lookup: this is what the
13064 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
13065 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
13066 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
13068 /* Look for specific sections that we need. */
13069 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
13071 dwp_file
->sections
.abbrev
.s
.section
= sectp
;
13072 dwp_file
->sections
.abbrev
.size
= bfd_section_size (sectp
);
13074 else if (section_is_p (sectp
->name
, &names
->info_dwo
))
13076 dwp_file
->sections
.info
.s
.section
= sectp
;
13077 dwp_file
->sections
.info
.size
= bfd_section_size (sectp
);
13079 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
13081 dwp_file
->sections
.line
.s
.section
= sectp
;
13082 dwp_file
->sections
.line
.size
= bfd_section_size (sectp
);
13084 else if (section_is_p (sectp
->name
, &names
->loclists_dwo
))
13086 dwp_file
->sections
.loclists
.s
.section
= sectp
;
13087 dwp_file
->sections
.loclists
.size
= bfd_section_size (sectp
);
13089 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
13091 dwp_file
->sections
.macro
.s
.section
= sectp
;
13092 dwp_file
->sections
.macro
.size
= bfd_section_size (sectp
);
13094 else if (section_is_p (sectp
->name
, &names
->rnglists_dwo
))
13096 dwp_file
->sections
.rnglists
.s
.section
= sectp
;
13097 dwp_file
->sections
.rnglists
.size
= bfd_section_size (sectp
);
13099 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
13101 dwp_file
->sections
.str_offsets
.s
.section
= sectp
;
13102 dwp_file
->sections
.str_offsets
.size
= bfd_section_size (sectp
);
13106 /* Hash function for dwp_file loaded CUs/TUs. */
13109 hash_dwp_loaded_cutus (const void *item
)
13111 const struct dwo_unit
*dwo_unit
= (const struct dwo_unit
*) item
;
13113 /* This drops the top 32 bits of the signature, but is ok for a hash. */
13114 return dwo_unit
->signature
;
13117 /* Equality function for dwp_file loaded CUs/TUs. */
13120 eq_dwp_loaded_cutus (const void *a
, const void *b
)
13122 const struct dwo_unit
*dua
= (const struct dwo_unit
*) a
;
13123 const struct dwo_unit
*dub
= (const struct dwo_unit
*) b
;
13125 return dua
->signature
== dub
->signature
;
13128 /* Allocate a hash table for dwp_file loaded CUs/TUs. */
13131 allocate_dwp_loaded_cutus_table ()
13133 return htab_up (htab_create_alloc (3,
13134 hash_dwp_loaded_cutus
,
13135 eq_dwp_loaded_cutus
,
13136 NULL
, xcalloc
, xfree
));
13139 /* Try to open DWP file FILE_NAME.
13140 The result is the bfd handle of the file.
13141 If there is a problem finding or opening the file, return NULL.
13142 Upon success, the canonicalized path of the file is stored in the bfd,
13143 same as symfile_bfd_open. */
13145 static gdb_bfd_ref_ptr
13146 open_dwp_file (dwarf2_per_objfile
*per_objfile
, const char *file_name
)
13148 gdb_bfd_ref_ptr
abfd (try_open_dwop_file (per_objfile
, file_name
,
13150 1 /*search_cwd*/));
13154 /* Work around upstream bug 15652.
13155 http://sourceware.org/bugzilla/show_bug.cgi?id=15652
13156 [Whether that's a "bug" is debatable, but it is getting in our way.]
13157 We have no real idea where the dwp file is, because gdb's realpath-ing
13158 of the executable's path may have discarded the needed info.
13159 [IWBN if the dwp file name was recorded in the executable, akin to
13160 .gnu_debuglink, but that doesn't exist yet.]
13161 Strip the directory from FILE_NAME and search again. */
13162 if (*debug_file_directory
!= '\0')
13164 /* Don't implicitly search the current directory here.
13165 If the user wants to search "." to handle this case,
13166 it must be added to debug-file-directory. */
13167 return try_open_dwop_file (per_objfile
, lbasename (file_name
),
13175 /* Initialize the use of the DWP file for the current objfile.
13176 By convention the name of the DWP file is ${objfile}.dwp.
13177 The result is NULL if it can't be found. */
13179 static std::unique_ptr
<struct dwp_file
>
13180 open_and_init_dwp_file (dwarf2_per_objfile
*per_objfile
)
13182 struct objfile
*objfile
= per_objfile
->objfile
;
13184 /* Try to find first .dwp for the binary file before any symbolic links
13187 /* If the objfile is a debug file, find the name of the real binary
13188 file and get the name of dwp file from there. */
13189 std::string dwp_name
;
13190 if (objfile
->separate_debug_objfile_backlink
!= NULL
)
13192 struct objfile
*backlink
= objfile
->separate_debug_objfile_backlink
;
13193 const char *backlink_basename
= lbasename (backlink
->original_name
);
13195 dwp_name
= ldirname (objfile
->original_name
) + SLASH_STRING
+ backlink_basename
;
13198 dwp_name
= objfile
->original_name
;
13200 dwp_name
+= ".dwp";
13202 gdb_bfd_ref_ptr
dbfd (open_dwp_file (per_objfile
, dwp_name
.c_str ()));
13204 && strcmp (objfile
->original_name
, objfile_name (objfile
)) != 0)
13206 /* Try to find .dwp for the binary file after gdb_realpath resolving. */
13207 dwp_name
= objfile_name (objfile
);
13208 dwp_name
+= ".dwp";
13209 dbfd
= open_dwp_file (per_objfile
, dwp_name
.c_str ());
13214 dwarf_read_debug_printf ("DWP file not found: %s", dwp_name
.c_str ());
13216 return std::unique_ptr
<dwp_file
> ();
13219 const char *name
= bfd_get_filename (dbfd
.get ());
13220 std::unique_ptr
<struct dwp_file
> dwp_file
13221 (new struct dwp_file (name
, std::move (dbfd
)));
13223 dwp_file
->num_sections
= elf_numsections (dwp_file
->dbfd
);
13224 dwp_file
->elf_sections
=
13225 OBSTACK_CALLOC (&per_objfile
->per_bfd
->obstack
,
13226 dwp_file
->num_sections
, asection
*);
13228 for (asection
*sec
: gdb_bfd_sections (dwp_file
->dbfd
))
13229 dwarf2_locate_common_dwp_sections (dwp_file
->dbfd
.get (), sec
,
13232 dwp_file
->cus
= create_dwp_hash_table (per_objfile
, dwp_file
.get (), 0);
13234 dwp_file
->tus
= create_dwp_hash_table (per_objfile
, dwp_file
.get (), 1);
13236 /* The DWP file version is stored in the hash table. Oh well. */
13237 if (dwp_file
->cus
&& dwp_file
->tus
13238 && dwp_file
->cus
->version
!= dwp_file
->tus
->version
)
13240 /* Technically speaking, we should try to limp along, but this is
13241 pretty bizarre. We use pulongest here because that's the established
13242 portability solution (e.g, we cannot use %u for uint32_t). */
13243 error (_("Dwarf Error: DWP file CU version %s doesn't match"
13244 " TU version %s [in DWP file %s]"),
13245 pulongest (dwp_file
->cus
->version
),
13246 pulongest (dwp_file
->tus
->version
), dwp_name
.c_str ());
13250 dwp_file
->version
= dwp_file
->cus
->version
;
13251 else if (dwp_file
->tus
)
13252 dwp_file
->version
= dwp_file
->tus
->version
;
13254 dwp_file
->version
= 2;
13256 for (asection
*sec
: gdb_bfd_sections (dwp_file
->dbfd
))
13258 if (dwp_file
->version
== 2)
13259 dwarf2_locate_v2_dwp_sections (dwp_file
->dbfd
.get (), sec
,
13262 dwarf2_locate_v5_dwp_sections (dwp_file
->dbfd
.get (), sec
,
13266 dwp_file
->loaded_cus
= allocate_dwp_loaded_cutus_table ();
13267 dwp_file
->loaded_tus
= allocate_dwp_loaded_cutus_table ();
13269 dwarf_read_debug_printf ("DWP file found: %s", dwp_file
->name
);
13270 dwarf_read_debug_printf (" %s CUs, %s TUs",
13271 pulongest (dwp_file
->cus
? dwp_file
->cus
->nr_units
: 0),
13272 pulongest (dwp_file
->tus
? dwp_file
->tus
->nr_units
: 0));
13277 /* Wrapper around open_and_init_dwp_file, only open it once. */
13279 static struct dwp_file
*
13280 get_dwp_file (dwarf2_per_objfile
*per_objfile
)
13282 if (!per_objfile
->per_bfd
->dwp_checked
)
13284 per_objfile
->per_bfd
->dwp_file
= open_and_init_dwp_file (per_objfile
);
13285 per_objfile
->per_bfd
->dwp_checked
= 1;
13287 return per_objfile
->per_bfd
->dwp_file
.get ();
13290 /* Subroutine of lookup_dwo_comp_unit, lookup_dwo_type_unit.
13291 Look up the CU/TU with signature SIGNATURE, either in DWO file DWO_NAME
13292 or in the DWP file for the objfile, referenced by THIS_UNIT.
13293 If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
13294 IS_DEBUG_TYPES is non-zero if reading a TU, otherwise read a CU.
13296 This is called, for example, when wanting to read a variable with a
13297 complex location. Therefore we don't want to do file i/o for every call.
13298 Therefore we don't want to look for a DWO file on every call.
13299 Therefore we first see if we've already seen SIGNATURE in a DWP file,
13300 then we check if we've already seen DWO_NAME, and only THEN do we check
13303 The result is a pointer to the dwo_unit object or NULL if we didn't find it
13304 (dwo_id mismatch or couldn't find the DWO/DWP file). */
13306 static struct dwo_unit
*
13307 lookup_dwo_cutu (dwarf2_cu
*cu
, const char *dwo_name
, const char *comp_dir
,
13308 ULONGEST signature
, int is_debug_types
)
13310 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
13311 struct objfile
*objfile
= per_objfile
->objfile
;
13312 const char *kind
= is_debug_types
? "TU" : "CU";
13313 void **dwo_file_slot
;
13314 struct dwo_file
*dwo_file
;
13315 struct dwp_file
*dwp_file
;
13317 /* First see if there's a DWP file.
13318 If we have a DWP file but didn't find the DWO inside it, don't
13319 look for the original DWO file. It makes gdb behave differently
13320 depending on whether one is debugging in the build tree. */
13322 dwp_file
= get_dwp_file (per_objfile
);
13323 if (dwp_file
!= NULL
)
13325 const struct dwp_hash_table
*dwp_htab
=
13326 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
13328 if (dwp_htab
!= NULL
)
13330 struct dwo_unit
*dwo_cutu
=
13331 lookup_dwo_unit_in_dwp (per_objfile
, dwp_file
, comp_dir
, signature
,
13334 if (dwo_cutu
!= NULL
)
13336 dwarf_read_debug_printf ("Virtual DWO %s %s found: @%s",
13337 kind
, hex_string (signature
),
13338 host_address_to_string (dwo_cutu
));
13346 /* No DWP file, look for the DWO file. */
13348 dwo_file_slot
= lookup_dwo_file_slot (per_objfile
, dwo_name
, comp_dir
);
13349 if (*dwo_file_slot
== NULL
)
13351 /* Read in the file and build a table of the CUs/TUs it contains. */
13352 *dwo_file_slot
= open_and_init_dwo_file (cu
, dwo_name
, comp_dir
);
13354 /* NOTE: This will be NULL if unable to open the file. */
13355 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
13357 if (dwo_file
!= NULL
)
13359 struct dwo_unit
*dwo_cutu
= NULL
;
13361 if (is_debug_types
&& dwo_file
->tus
)
13363 struct dwo_unit find_dwo_cutu
;
13365 memset (&find_dwo_cutu
, 0, sizeof (find_dwo_cutu
));
13366 find_dwo_cutu
.signature
= signature
;
13368 = (struct dwo_unit
*) htab_find (dwo_file
->tus
.get (),
13371 else if (!is_debug_types
&& dwo_file
->cus
)
13373 struct dwo_unit find_dwo_cutu
;
13375 memset (&find_dwo_cutu
, 0, sizeof (find_dwo_cutu
));
13376 find_dwo_cutu
.signature
= signature
;
13377 dwo_cutu
= (struct dwo_unit
*)htab_find (dwo_file
->cus
.get (),
13381 if (dwo_cutu
!= NULL
)
13383 dwarf_read_debug_printf ("DWO %s %s(%s) found: @%s",
13384 kind
, dwo_name
, hex_string (signature
),
13385 host_address_to_string (dwo_cutu
));
13392 /* We didn't find it. This could mean a dwo_id mismatch, or
13393 someone deleted the DWO/DWP file, or the search path isn't set up
13394 correctly to find the file. */
13396 dwarf_read_debug_printf ("DWO %s %s(%s) not found",
13397 kind
, dwo_name
, hex_string (signature
));
13399 /* This is a warning and not a complaint because it can be caused by
13400 pilot error (e.g., user accidentally deleting the DWO). */
13402 /* Print the name of the DWP file if we looked there, helps the user
13403 better diagnose the problem. */
13404 std::string dwp_text
;
13406 if (dwp_file
!= NULL
)
13407 dwp_text
= string_printf (" [in DWP file %s]",
13408 lbasename (dwp_file
->name
));
13410 warning (_("Could not find DWO %s %s(%s)%s referenced by %s at offset %s"
13411 " [in module %s]"),
13412 kind
, dwo_name
, hex_string (signature
), dwp_text
.c_str (), kind
,
13413 sect_offset_str (cu
->per_cu
->sect_off
), objfile_name (objfile
));
13418 /* Lookup the DWO CU DWO_NAME/SIGNATURE referenced from THIS_CU.
13419 See lookup_dwo_cutu_unit for details. */
13421 static struct dwo_unit
*
13422 lookup_dwo_comp_unit (dwarf2_cu
*cu
, const char *dwo_name
, const char *comp_dir
,
13423 ULONGEST signature
)
13425 gdb_assert (!cu
->per_cu
->is_debug_types
);
13427 return lookup_dwo_cutu (cu
, dwo_name
, comp_dir
, signature
, 0);
13430 /* Lookup the DWO TU DWO_NAME/SIGNATURE referenced from THIS_TU.
13431 See lookup_dwo_cutu_unit for details. */
13433 static struct dwo_unit
*
13434 lookup_dwo_type_unit (dwarf2_cu
*cu
, const char *dwo_name
, const char *comp_dir
)
13436 gdb_assert (cu
->per_cu
->is_debug_types
);
13438 signatured_type
*sig_type
= (signatured_type
*) cu
->per_cu
;
13440 return lookup_dwo_cutu (cu
, dwo_name
, comp_dir
, sig_type
->signature
, 1);
13443 /* Traversal function for queue_and_load_all_dwo_tus. */
13446 queue_and_load_dwo_tu (void **slot
, void *info
)
13448 struct dwo_unit
*dwo_unit
= (struct dwo_unit
*) *slot
;
13449 dwarf2_cu
*cu
= (dwarf2_cu
*) info
;
13450 ULONGEST signature
= dwo_unit
->signature
;
13451 signatured_type
*sig_type
= lookup_dwo_signatured_type (cu
, signature
);
13453 if (sig_type
!= NULL
)
13455 struct dwarf2_per_cu_data
*sig_cu
= &sig_type
->per_cu
;
13457 /* We pass NULL for DEPENDENT_CU because we don't yet know if there's
13458 a real dependency of PER_CU on SIG_TYPE. That is detected later
13459 while processing PER_CU. */
13460 if (maybe_queue_comp_unit (NULL
, sig_cu
, cu
->per_objfile
, cu
->language
))
13461 load_full_type_unit (sig_cu
, cu
->per_objfile
);
13462 cu
->per_cu
->imported_symtabs_push (sig_cu
);
13468 /* Queue all TUs contained in the DWO of CU to be read in.
13469 The DWO may have the only definition of the type, though it may not be
13470 referenced anywhere in PER_CU. Thus we have to load *all* its TUs.
13471 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
13474 queue_and_load_all_dwo_tus (dwarf2_cu
*cu
)
13476 struct dwo_unit
*dwo_unit
;
13477 struct dwo_file
*dwo_file
;
13479 gdb_assert (cu
!= nullptr);
13480 gdb_assert (!cu
->per_cu
->is_debug_types
);
13481 gdb_assert (get_dwp_file (cu
->per_objfile
) == nullptr);
13483 dwo_unit
= cu
->dwo_unit
;
13484 gdb_assert (dwo_unit
!= NULL
);
13486 dwo_file
= dwo_unit
->dwo_file
;
13487 if (dwo_file
->tus
!= NULL
)
13488 htab_traverse_noresize (dwo_file
->tus
.get (), queue_and_load_dwo_tu
, cu
);
13491 /* Read in various DIEs. */
13493 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
13494 Inherit only the children of the DW_AT_abstract_origin DIE not being
13495 already referenced by DW_AT_abstract_origin from the children of the
13499 inherit_abstract_dies (struct die_info
*die
, struct dwarf2_cu
*cu
)
13501 struct die_info
*child_die
;
13502 sect_offset
*offsetp
;
13503 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
13504 struct die_info
*origin_die
;
13505 /* Iterator of the ORIGIN_DIE children. */
13506 struct die_info
*origin_child_die
;
13507 struct attribute
*attr
;
13508 struct dwarf2_cu
*origin_cu
;
13509 struct pending
**origin_previous_list_in_scope
;
13511 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
13515 /* Note that following die references may follow to a die in a
13519 origin_die
= follow_die_ref (die
, attr
, &origin_cu
);
13521 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
13523 origin_previous_list_in_scope
= origin_cu
->list_in_scope
;
13524 origin_cu
->list_in_scope
= cu
->list_in_scope
;
13526 if (die
->tag
!= origin_die
->tag
13527 && !(die
->tag
== DW_TAG_inlined_subroutine
13528 && origin_die
->tag
== DW_TAG_subprogram
))
13529 complaint (_("DIE %s and its abstract origin %s have different tags"),
13530 sect_offset_str (die
->sect_off
),
13531 sect_offset_str (origin_die
->sect_off
));
13533 std::vector
<sect_offset
> offsets
;
13535 for (child_die
= die
->child
;
13536 child_die
&& child_die
->tag
;
13537 child_die
= child_die
->sibling
)
13539 struct die_info
*child_origin_die
;
13540 struct dwarf2_cu
*child_origin_cu
;
13542 /* We are trying to process concrete instance entries:
13543 DW_TAG_call_site DIEs indeed have a DW_AT_abstract_origin tag, but
13544 it's not relevant to our analysis here. i.e. detecting DIEs that are
13545 present in the abstract instance but not referenced in the concrete
13547 if (child_die
->tag
== DW_TAG_call_site
13548 || child_die
->tag
== DW_TAG_GNU_call_site
)
13551 /* For each CHILD_DIE, find the corresponding child of
13552 ORIGIN_DIE. If there is more than one layer of
13553 DW_AT_abstract_origin, follow them all; there shouldn't be,
13554 but GCC versions at least through 4.4 generate this (GCC PR
13556 child_origin_die
= child_die
;
13557 child_origin_cu
= cu
;
13560 attr
= dwarf2_attr (child_origin_die
, DW_AT_abstract_origin
,
13564 child_origin_die
= follow_die_ref (child_origin_die
, attr
,
13568 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
13569 counterpart may exist. */
13570 if (child_origin_die
!= child_die
)
13572 if (child_die
->tag
!= child_origin_die
->tag
13573 && !(child_die
->tag
== DW_TAG_inlined_subroutine
13574 && child_origin_die
->tag
== DW_TAG_subprogram
))
13575 complaint (_("Child DIE %s and its abstract origin %s have "
13577 sect_offset_str (child_die
->sect_off
),
13578 sect_offset_str (child_origin_die
->sect_off
));
13579 if (child_origin_die
->parent
!= origin_die
)
13580 complaint (_("Child DIE %s and its abstract origin %s have "
13581 "different parents"),
13582 sect_offset_str (child_die
->sect_off
),
13583 sect_offset_str (child_origin_die
->sect_off
));
13585 offsets
.push_back (child_origin_die
->sect_off
);
13588 std::sort (offsets
.begin (), offsets
.end ());
13589 sect_offset
*offsets_end
= offsets
.data () + offsets
.size ();
13590 for (offsetp
= offsets
.data () + 1; offsetp
< offsets_end
; offsetp
++)
13591 if (offsetp
[-1] == *offsetp
)
13592 complaint (_("Multiple children of DIE %s refer "
13593 "to DIE %s as their abstract origin"),
13594 sect_offset_str (die
->sect_off
), sect_offset_str (*offsetp
));
13596 offsetp
= offsets
.data ();
13597 origin_child_die
= origin_die
->child
;
13598 while (origin_child_die
&& origin_child_die
->tag
)
13600 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
13601 while (offsetp
< offsets_end
13602 && *offsetp
< origin_child_die
->sect_off
)
13604 if (offsetp
>= offsets_end
13605 || *offsetp
> origin_child_die
->sect_off
)
13607 /* Found that ORIGIN_CHILD_DIE is really not referenced.
13608 Check whether we're already processing ORIGIN_CHILD_DIE.
13609 This can happen with mutually referenced abstract_origins.
13611 if (!origin_child_die
->in_process
)
13612 process_die (origin_child_die
, origin_cu
);
13614 origin_child_die
= origin_child_die
->sibling
;
13616 origin_cu
->list_in_scope
= origin_previous_list_in_scope
;
13618 if (cu
!= origin_cu
)
13619 compute_delayed_physnames (origin_cu
);
13623 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13625 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
13626 struct gdbarch
*gdbarch
= objfile
->arch ();
13627 struct context_stack
*newobj
;
13630 struct die_info
*child_die
;
13631 struct attribute
*attr
, *call_line
, *call_file
;
13633 CORE_ADDR baseaddr
;
13634 struct block
*block
;
13635 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
13636 std::vector
<struct symbol
*> template_args
;
13637 struct template_symbol
*templ_func
= NULL
;
13641 /* If we do not have call site information, we can't show the
13642 caller of this inlined function. That's too confusing, so
13643 only use the scope for local variables. */
13644 call_line
= dwarf2_attr (die
, DW_AT_call_line
, cu
);
13645 call_file
= dwarf2_attr (die
, DW_AT_call_file
, cu
);
13646 if (call_line
== NULL
|| call_file
== NULL
)
13648 read_lexical_block_scope (die
, cu
);
13653 baseaddr
= objfile
->text_section_offset ();
13655 name
= dwarf2_name (die
, cu
);
13657 /* Ignore functions with missing or empty names. These are actually
13658 illegal according to the DWARF standard. */
13661 complaint (_("missing name for subprogram DIE at %s"),
13662 sect_offset_str (die
->sect_off
));
13666 /* Ignore functions with missing or invalid low and high pc attributes. */
13667 if (dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
)
13668 <= PC_BOUNDS_INVALID
)
13670 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
13671 if (attr
== nullptr || !attr
->as_boolean ())
13672 complaint (_("cannot get low and high bounds "
13673 "for subprogram DIE at %s"),
13674 sect_offset_str (die
->sect_off
));
13678 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
13679 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
13681 /* If we have any template arguments, then we must allocate a
13682 different sort of symbol. */
13683 for (child_die
= die
->child
; child_die
; child_die
= child_die
->sibling
)
13685 if (child_die
->tag
== DW_TAG_template_type_param
13686 || child_die
->tag
== DW_TAG_template_value_param
)
13688 templ_func
= new (&objfile
->objfile_obstack
) template_symbol
;
13689 templ_func
->subclass
= SYMBOL_TEMPLATE
;
13694 newobj
= cu
->get_builder ()->push_context (0, lowpc
);
13695 newobj
->name
= new_symbol (die
, read_type_die (die
, cu
), cu
,
13696 (struct symbol
*) templ_func
);
13698 if (dwarf2_flag_true_p (die
, DW_AT_main_subprogram
, cu
))
13699 set_objfile_main_name (objfile
, newobj
->name
->linkage_name (),
13702 /* If there is a location expression for DW_AT_frame_base, record
13704 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
13705 if (attr
!= nullptr)
13706 dwarf2_symbol_mark_computed (attr
, newobj
->name
, cu
, 1);
13708 /* If there is a location for the static link, record it. */
13709 newobj
->static_link
= NULL
;
13710 attr
= dwarf2_attr (die
, DW_AT_static_link
, cu
);
13711 if (attr
!= nullptr)
13713 newobj
->static_link
13714 = XOBNEW (&objfile
->objfile_obstack
, struct dynamic_prop
);
13715 attr_to_dynamic_prop (attr
, die
, cu
, newobj
->static_link
,
13719 cu
->list_in_scope
= cu
->get_builder ()->get_local_symbols ();
13721 if (die
->child
!= NULL
)
13723 child_die
= die
->child
;
13724 while (child_die
&& child_die
->tag
)
13726 if (child_die
->tag
== DW_TAG_template_type_param
13727 || child_die
->tag
== DW_TAG_template_value_param
)
13729 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
13732 template_args
.push_back (arg
);
13735 process_die (child_die
, cu
);
13736 child_die
= child_die
->sibling
;
13740 inherit_abstract_dies (die
, cu
);
13742 /* If we have a DW_AT_specification, we might need to import using
13743 directives from the context of the specification DIE. See the
13744 comment in determine_prefix. */
13745 if (cu
->language
== language_cplus
13746 && dwarf2_attr (die
, DW_AT_specification
, cu
))
13748 struct dwarf2_cu
*spec_cu
= cu
;
13749 struct die_info
*spec_die
= die_specification (die
, &spec_cu
);
13753 child_die
= spec_die
->child
;
13754 while (child_die
&& child_die
->tag
)
13756 if (child_die
->tag
== DW_TAG_imported_module
)
13757 process_die (child_die
, spec_cu
);
13758 child_die
= child_die
->sibling
;
13761 /* In some cases, GCC generates specification DIEs that
13762 themselves contain DW_AT_specification attributes. */
13763 spec_die
= die_specification (spec_die
, &spec_cu
);
13767 struct context_stack cstk
= cu
->get_builder ()->pop_context ();
13768 /* Make a block for the local symbols within. */
13769 block
= cu
->get_builder ()->finish_block (cstk
.name
, cstk
.old_blocks
,
13770 cstk
.static_link
, lowpc
, highpc
);
13772 /* For C++, set the block's scope. */
13773 if ((cu
->language
== language_cplus
13774 || cu
->language
== language_fortran
13775 || cu
->language
== language_d
13776 || cu
->language
== language_rust
)
13777 && cu
->processing_has_namespace_info
)
13778 block_set_scope (block
, determine_prefix (die
, cu
),
13779 &objfile
->objfile_obstack
);
13781 /* If we have address ranges, record them. */
13782 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
13784 gdbarch_make_symbol_special (gdbarch
, cstk
.name
, objfile
);
13786 /* Attach template arguments to function. */
13787 if (!template_args
.empty ())
13789 gdb_assert (templ_func
!= NULL
);
13791 templ_func
->n_template_arguments
= template_args
.size ();
13792 templ_func
->template_arguments
13793 = XOBNEWVEC (&objfile
->objfile_obstack
, struct symbol
*,
13794 templ_func
->n_template_arguments
);
13795 memcpy (templ_func
->template_arguments
,
13796 template_args
.data (),
13797 (templ_func
->n_template_arguments
* sizeof (struct symbol
*)));
13799 /* Make sure that the symtab is set on the new symbols. Even
13800 though they don't appear in this symtab directly, other parts
13801 of gdb assume that symbols do, and this is reasonably
13803 for (symbol
*sym
: template_args
)
13804 symbol_set_symtab (sym
, symbol_symtab (templ_func
));
13807 /* In C++, we can have functions nested inside functions (e.g., when
13808 a function declares a class that has methods). This means that
13809 when we finish processing a function scope, we may need to go
13810 back to building a containing block's symbol lists. */
13811 *cu
->get_builder ()->get_local_symbols () = cstk
.locals
;
13812 cu
->get_builder ()->set_local_using_directives (cstk
.local_using_directives
);
13814 /* If we've finished processing a top-level function, subsequent
13815 symbols go in the file symbol list. */
13816 if (cu
->get_builder ()->outermost_context_p ())
13817 cu
->list_in_scope
= cu
->get_builder ()->get_file_symbols ();
13820 /* Process all the DIES contained within a lexical block scope. Start
13821 a new scope, process the dies, and then close the scope. */
13824 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13826 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
13827 struct gdbarch
*gdbarch
= objfile
->arch ();
13828 CORE_ADDR lowpc
, highpc
;
13829 struct die_info
*child_die
;
13830 CORE_ADDR baseaddr
;
13832 baseaddr
= objfile
->text_section_offset ();
13834 /* Ignore blocks with missing or invalid low and high pc attributes. */
13835 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
13836 as multiple lexical blocks? Handling children in a sane way would
13837 be nasty. Might be easier to properly extend generic blocks to
13838 describe ranges. */
13839 switch (dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
13841 case PC_BOUNDS_NOT_PRESENT
:
13842 /* DW_TAG_lexical_block has no attributes, process its children as if
13843 there was no wrapping by that DW_TAG_lexical_block.
13844 GCC does no longer produces such DWARF since GCC r224161. */
13845 for (child_die
= die
->child
;
13846 child_die
!= NULL
&& child_die
->tag
;
13847 child_die
= child_die
->sibling
)
13849 /* We might already be processing this DIE. This can happen
13850 in an unusual circumstance -- where a subroutine A
13851 appears lexically in another subroutine B, but A actually
13852 inlines B. The recursion is broken here, rather than in
13853 inherit_abstract_dies, because it seems better to simply
13854 drop concrete children here. */
13855 if (!child_die
->in_process
)
13856 process_die (child_die
, cu
);
13859 case PC_BOUNDS_INVALID
:
13862 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
13863 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
13865 cu
->get_builder ()->push_context (0, lowpc
);
13866 if (die
->child
!= NULL
)
13868 child_die
= die
->child
;
13869 while (child_die
&& child_die
->tag
)
13871 process_die (child_die
, cu
);
13872 child_die
= child_die
->sibling
;
13875 inherit_abstract_dies (die
, cu
);
13876 struct context_stack cstk
= cu
->get_builder ()->pop_context ();
13878 if (*cu
->get_builder ()->get_local_symbols () != NULL
13879 || (*cu
->get_builder ()->get_local_using_directives ()) != NULL
)
13881 struct block
*block
13882 = cu
->get_builder ()->finish_block (0, cstk
.old_blocks
, NULL
,
13883 cstk
.start_addr
, highpc
);
13885 /* Note that recording ranges after traversing children, as we
13886 do here, means that recording a parent's ranges entails
13887 walking across all its children's ranges as they appear in
13888 the address map, which is quadratic behavior.
13890 It would be nicer to record the parent's ranges before
13891 traversing its children, simply overriding whatever you find
13892 there. But since we don't even decide whether to create a
13893 block until after we've traversed its children, that's hard
13895 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
13897 *cu
->get_builder ()->get_local_symbols () = cstk
.locals
;
13898 cu
->get_builder ()->set_local_using_directives (cstk
.local_using_directives
);
13901 /* Read in DW_TAG_call_site and insert it to CU->call_site_htab. */
13904 read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13906 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
13907 struct objfile
*objfile
= per_objfile
->objfile
;
13908 struct gdbarch
*gdbarch
= objfile
->arch ();
13909 CORE_ADDR pc
, baseaddr
;
13910 struct attribute
*attr
;
13911 struct call_site
*call_site
, call_site_local
;
13914 struct die_info
*child_die
;
13916 baseaddr
= objfile
->text_section_offset ();
13918 attr
= dwarf2_attr (die
, DW_AT_call_return_pc
, cu
);
13921 /* This was a pre-DWARF-5 GNU extension alias
13922 for DW_AT_call_return_pc. */
13923 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
13927 complaint (_("missing DW_AT_call_return_pc for DW_TAG_call_site "
13928 "DIE %s [in module %s]"),
13929 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
13932 pc
= attr
->as_address () + baseaddr
;
13933 pc
= gdbarch_adjust_dwarf2_addr (gdbarch
, pc
);
13935 if (cu
->call_site_htab
== NULL
)
13936 cu
->call_site_htab
= htab_create_alloc_ex (16, core_addr_hash
, core_addr_eq
,
13937 NULL
, &objfile
->objfile_obstack
,
13938 hashtab_obstack_allocate
, NULL
);
13939 call_site_local
.pc
= pc
;
13940 slot
= htab_find_slot (cu
->call_site_htab
, &call_site_local
, INSERT
);
13943 complaint (_("Duplicate PC %s for DW_TAG_call_site "
13944 "DIE %s [in module %s]"),
13945 paddress (gdbarch
, pc
), sect_offset_str (die
->sect_off
),
13946 objfile_name (objfile
));
13950 /* Count parameters at the caller. */
13953 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
13954 child_die
= child_die
->sibling
)
13956 if (child_die
->tag
!= DW_TAG_call_site_parameter
13957 && child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
13959 complaint (_("Tag %d is not DW_TAG_call_site_parameter in "
13960 "DW_TAG_call_site child DIE %s [in module %s]"),
13961 child_die
->tag
, sect_offset_str (child_die
->sect_off
),
13962 objfile_name (objfile
));
13970 = ((struct call_site
*)
13971 obstack_alloc (&objfile
->objfile_obstack
,
13972 sizeof (*call_site
)
13973 + (sizeof (*call_site
->parameter
) * (nparams
- 1))));
13975 memset (call_site
, 0, sizeof (*call_site
) - sizeof (*call_site
->parameter
));
13976 call_site
->pc
= pc
;
13978 if (dwarf2_flag_true_p (die
, DW_AT_call_tail_call
, cu
)
13979 || dwarf2_flag_true_p (die
, DW_AT_GNU_tail_call
, cu
))
13981 struct die_info
*func_die
;
13983 /* Skip also over DW_TAG_inlined_subroutine. */
13984 for (func_die
= die
->parent
;
13985 func_die
&& func_die
->tag
!= DW_TAG_subprogram
13986 && func_die
->tag
!= DW_TAG_subroutine_type
;
13987 func_die
= func_die
->parent
);
13989 /* DW_AT_call_all_calls is a superset
13990 of DW_AT_call_all_tail_calls. */
13992 && !dwarf2_flag_true_p (func_die
, DW_AT_call_all_calls
, cu
)
13993 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_call_sites
, cu
)
13994 && !dwarf2_flag_true_p (func_die
, DW_AT_call_all_tail_calls
, cu
)
13995 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_tail_call_sites
, cu
))
13997 /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
13998 not complete. But keep CALL_SITE for look ups via call_site_htab,
13999 both the initial caller containing the real return address PC and
14000 the final callee containing the current PC of a chain of tail
14001 calls do not need to have the tail call list complete. But any
14002 function candidate for a virtual tail call frame searched via
14003 TYPE_TAIL_CALL_LIST must have the tail call list complete to be
14004 determined unambiguously. */
14008 struct type
*func_type
= NULL
;
14011 func_type
= get_die_type (func_die
, cu
);
14012 if (func_type
!= NULL
)
14014 gdb_assert (func_type
->code () == TYPE_CODE_FUNC
);
14016 /* Enlist this call site to the function. */
14017 call_site
->tail_call_next
= TYPE_TAIL_CALL_LIST (func_type
);
14018 TYPE_TAIL_CALL_LIST (func_type
) = call_site
;
14021 complaint (_("Cannot find function owning DW_TAG_call_site "
14022 "DIE %s [in module %s]"),
14023 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
14027 attr
= dwarf2_attr (die
, DW_AT_call_target
, cu
);
14029 attr
= dwarf2_attr (die
, DW_AT_GNU_call_site_target
, cu
);
14031 attr
= dwarf2_attr (die
, DW_AT_call_origin
, cu
);
14034 /* This was a pre-DWARF-5 GNU extension alias for DW_AT_call_origin. */
14035 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
14037 SET_FIELD_DWARF_BLOCK (call_site
->target
, NULL
);
14038 if (!attr
|| (attr
->form_is_block () && attr
->as_block ()->size
== 0))
14039 /* Keep NULL DWARF_BLOCK. */;
14040 else if (attr
->form_is_block ())
14042 struct dwarf2_locexpr_baton
*dlbaton
;
14043 struct dwarf_block
*block
= attr
->as_block ();
14045 dlbaton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
14046 dlbaton
->data
= block
->data
;
14047 dlbaton
->size
= block
->size
;
14048 dlbaton
->per_objfile
= per_objfile
;
14049 dlbaton
->per_cu
= cu
->per_cu
;
14051 SET_FIELD_DWARF_BLOCK (call_site
->target
, dlbaton
);
14053 else if (attr
->form_is_ref ())
14055 struct dwarf2_cu
*target_cu
= cu
;
14056 struct die_info
*target_die
;
14058 target_die
= follow_die_ref (die
, attr
, &target_cu
);
14059 gdb_assert (target_cu
->per_objfile
->objfile
== objfile
);
14060 if (die_is_declaration (target_die
, target_cu
))
14062 const char *target_physname
;
14064 /* Prefer the mangled name; otherwise compute the demangled one. */
14065 target_physname
= dw2_linkage_name (target_die
, target_cu
);
14066 if (target_physname
== NULL
)
14067 target_physname
= dwarf2_physname (NULL
, target_die
, target_cu
);
14068 if (target_physname
== NULL
)
14069 complaint (_("DW_AT_call_target target DIE has invalid "
14070 "physname, for referencing DIE %s [in module %s]"),
14071 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
14073 SET_FIELD_PHYSNAME (call_site
->target
, target_physname
);
14079 /* DW_AT_entry_pc should be preferred. */
14080 if (dwarf2_get_pc_bounds (target_die
, &lowpc
, NULL
, target_cu
, NULL
)
14081 <= PC_BOUNDS_INVALID
)
14082 complaint (_("DW_AT_call_target target DIE has invalid "
14083 "low pc, for referencing DIE %s [in module %s]"),
14084 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
14087 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
14088 SET_FIELD_PHYSADDR (call_site
->target
, lowpc
);
14093 complaint (_("DW_TAG_call_site DW_AT_call_target is neither "
14094 "block nor reference, for DIE %s [in module %s]"),
14095 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
14097 call_site
->per_cu
= cu
->per_cu
;
14098 call_site
->per_objfile
= per_objfile
;
14100 for (child_die
= die
->child
;
14101 child_die
&& child_die
->tag
;
14102 child_die
= child_die
->sibling
)
14104 struct call_site_parameter
*parameter
;
14105 struct attribute
*loc
, *origin
;
14107 if (child_die
->tag
!= DW_TAG_call_site_parameter
14108 && child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
14110 /* Already printed the complaint above. */
14114 gdb_assert (call_site
->parameter_count
< nparams
);
14115 parameter
= &call_site
->parameter
[call_site
->parameter_count
];
14117 /* DW_AT_location specifies the register number or DW_AT_abstract_origin
14118 specifies DW_TAG_formal_parameter. Value of the data assumed for the
14119 register is contained in DW_AT_call_value. */
14121 loc
= dwarf2_attr (child_die
, DW_AT_location
, cu
);
14122 origin
= dwarf2_attr (child_die
, DW_AT_call_parameter
, cu
);
14123 if (origin
== NULL
)
14125 /* This was a pre-DWARF-5 GNU extension alias
14126 for DW_AT_call_parameter. */
14127 origin
= dwarf2_attr (child_die
, DW_AT_abstract_origin
, cu
);
14129 if (loc
== NULL
&& origin
!= NULL
&& origin
->form_is_ref ())
14131 parameter
->kind
= CALL_SITE_PARAMETER_PARAM_OFFSET
;
14133 sect_offset sect_off
= origin
->get_ref_die_offset ();
14134 if (!cu
->header
.offset_in_cu_p (sect_off
))
14136 /* As DW_OP_GNU_parameter_ref uses CU-relative offset this
14137 binding can be done only inside one CU. Such referenced DIE
14138 therefore cannot be even moved to DW_TAG_partial_unit. */
14139 complaint (_("DW_AT_call_parameter offset is not in CU for "
14140 "DW_TAG_call_site child DIE %s [in module %s]"),
14141 sect_offset_str (child_die
->sect_off
),
14142 objfile_name (objfile
));
14145 parameter
->u
.param_cu_off
14146 = (cu_offset
) (sect_off
- cu
->header
.sect_off
);
14148 else if (loc
== NULL
|| origin
!= NULL
|| !loc
->form_is_block ())
14150 complaint (_("No DW_FORM_block* DW_AT_location for "
14151 "DW_TAG_call_site child DIE %s [in module %s]"),
14152 sect_offset_str (child_die
->sect_off
), objfile_name (objfile
));
14157 struct dwarf_block
*block
= loc
->as_block ();
14159 parameter
->u
.dwarf_reg
= dwarf_block_to_dwarf_reg
14160 (block
->data
, &block
->data
[block
->size
]);
14161 if (parameter
->u
.dwarf_reg
!= -1)
14162 parameter
->kind
= CALL_SITE_PARAMETER_DWARF_REG
;
14163 else if (dwarf_block_to_sp_offset (gdbarch
, block
->data
,
14164 &block
->data
[block
->size
],
14165 ¶meter
->u
.fb_offset
))
14166 parameter
->kind
= CALL_SITE_PARAMETER_FB_OFFSET
;
14169 complaint (_("Only single DW_OP_reg or DW_OP_fbreg is supported "
14170 "for DW_FORM_block* DW_AT_location is supported for "
14171 "DW_TAG_call_site child DIE %s "
14173 sect_offset_str (child_die
->sect_off
),
14174 objfile_name (objfile
));
14179 attr
= dwarf2_attr (child_die
, DW_AT_call_value
, cu
);
14181 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_value
, cu
);
14182 if (attr
== NULL
|| !attr
->form_is_block ())
14184 complaint (_("No DW_FORM_block* DW_AT_call_value for "
14185 "DW_TAG_call_site child DIE %s [in module %s]"),
14186 sect_offset_str (child_die
->sect_off
),
14187 objfile_name (objfile
));
14191 struct dwarf_block
*block
= attr
->as_block ();
14192 parameter
->value
= block
->data
;
14193 parameter
->value_size
= block
->size
;
14195 /* Parameters are not pre-cleared by memset above. */
14196 parameter
->data_value
= NULL
;
14197 parameter
->data_value_size
= 0;
14198 call_site
->parameter_count
++;
14200 attr
= dwarf2_attr (child_die
, DW_AT_call_data_value
, cu
);
14202 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_data_value
, cu
);
14203 if (attr
!= nullptr)
14205 if (!attr
->form_is_block ())
14206 complaint (_("No DW_FORM_block* DW_AT_call_data_value for "
14207 "DW_TAG_call_site child DIE %s [in module %s]"),
14208 sect_offset_str (child_die
->sect_off
),
14209 objfile_name (objfile
));
14212 block
= attr
->as_block ();
14213 parameter
->data_value
= block
->data
;
14214 parameter
->data_value_size
= block
->size
;
14220 /* Helper function for read_variable. If DIE represents a virtual
14221 table, then return the type of the concrete object that is
14222 associated with the virtual table. Otherwise, return NULL. */
14224 static struct type
*
14225 rust_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14227 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
14231 /* Find the type DIE. */
14232 struct die_info
*type_die
= NULL
;
14233 struct dwarf2_cu
*type_cu
= cu
;
14235 if (attr
->form_is_ref ())
14236 type_die
= follow_die_ref (die
, attr
, &type_cu
);
14237 if (type_die
== NULL
)
14240 if (dwarf2_attr (type_die
, DW_AT_containing_type
, type_cu
) == NULL
)
14242 return die_containing_type (type_die
, type_cu
);
14245 /* Read a variable (DW_TAG_variable) DIE and create a new symbol. */
14248 read_variable (struct die_info
*die
, struct dwarf2_cu
*cu
)
14250 struct rust_vtable_symbol
*storage
= NULL
;
14252 if (cu
->language
== language_rust
)
14254 struct type
*containing_type
= rust_containing_type (die
, cu
);
14256 if (containing_type
!= NULL
)
14258 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
14260 storage
= new (&objfile
->objfile_obstack
) rust_vtable_symbol
;
14261 storage
->concrete_type
= containing_type
;
14262 storage
->subclass
= SYMBOL_RUST_VTABLE
;
14266 struct symbol
*res
= new_symbol (die
, NULL
, cu
, storage
);
14267 struct attribute
*abstract_origin
14268 = dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
14269 struct attribute
*loc
= dwarf2_attr (die
, DW_AT_location
, cu
);
14270 if (res
== NULL
&& loc
&& abstract_origin
)
14272 /* We have a variable without a name, but with a location and an abstract
14273 origin. This may be a concrete instance of an abstract variable
14274 referenced from an DW_OP_GNU_variable_value, so save it to find it back
14276 struct dwarf2_cu
*origin_cu
= cu
;
14277 struct die_info
*origin_die
14278 = follow_die_ref (die
, abstract_origin
, &origin_cu
);
14279 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
14280 per_objfile
->per_bfd
->abstract_to_concrete
14281 [origin_die
->sect_off
].push_back (die
->sect_off
);
14285 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET
14286 reading .debug_rnglists.
14287 Callback's type should be:
14288 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14289 Return true if the attributes are present and valid, otherwise,
14292 template <typename Callback
>
14294 dwarf2_rnglists_process (unsigned offset
, struct dwarf2_cu
*cu
,
14295 dwarf_tag tag
, Callback
&&callback
)
14297 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
14298 struct objfile
*objfile
= per_objfile
->objfile
;
14299 bfd
*obfd
= objfile
->obfd
;
14300 /* Base address selection entry. */
14301 gdb::optional
<CORE_ADDR
> base
;
14302 const gdb_byte
*buffer
;
14303 CORE_ADDR baseaddr
;
14304 bool overflow
= false;
14305 ULONGEST addr_index
;
14306 struct dwarf2_section_info
*rnglists_section
;
14308 base
= cu
->base_address
;
14309 rnglists_section
= cu_debug_rnglists_section (cu
, tag
);
14310 rnglists_section
->read (objfile
);
14312 if (offset
>= rnglists_section
->size
)
14314 complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
14318 buffer
= rnglists_section
->buffer
+ offset
;
14320 baseaddr
= objfile
->text_section_offset ();
14324 /* Initialize it due to a false compiler warning. */
14325 CORE_ADDR range_beginning
= 0, range_end
= 0;
14326 const gdb_byte
*buf_end
= (rnglists_section
->buffer
14327 + rnglists_section
->size
);
14328 unsigned int bytes_read
;
14330 if (buffer
== buf_end
)
14335 const auto rlet
= static_cast<enum dwarf_range_list_entry
>(*buffer
++);
14338 case DW_RLE_end_of_list
:
14340 case DW_RLE_base_address
:
14341 if (buffer
+ cu
->header
.addr_size
> buf_end
)
14346 base
= cu
->header
.read_address (obfd
, buffer
, &bytes_read
);
14347 buffer
+= bytes_read
;
14349 case DW_RLE_base_addressx
:
14350 addr_index
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14351 buffer
+= bytes_read
;
14352 base
= read_addr_index (cu
, addr_index
);
14354 case DW_RLE_start_length
:
14355 if (buffer
+ cu
->header
.addr_size
> buf_end
)
14360 range_beginning
= cu
->header
.read_address (obfd
, buffer
,
14362 buffer
+= bytes_read
;
14363 range_end
= (range_beginning
14364 + read_unsigned_leb128 (obfd
, buffer
, &bytes_read
));
14365 buffer
+= bytes_read
;
14366 if (buffer
> buf_end
)
14372 case DW_RLE_startx_length
:
14373 addr_index
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14374 buffer
+= bytes_read
;
14375 range_beginning
= read_addr_index (cu
, addr_index
);
14376 if (buffer
> buf_end
)
14381 range_end
= (range_beginning
14382 + read_unsigned_leb128 (obfd
, buffer
, &bytes_read
));
14383 buffer
+= bytes_read
;
14385 case DW_RLE_offset_pair
:
14386 range_beginning
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14387 buffer
+= bytes_read
;
14388 if (buffer
> buf_end
)
14393 range_end
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14394 buffer
+= bytes_read
;
14395 if (buffer
> buf_end
)
14401 case DW_RLE_start_end
:
14402 if (buffer
+ 2 * cu
->header
.addr_size
> buf_end
)
14407 range_beginning
= cu
->header
.read_address (obfd
, buffer
,
14409 buffer
+= bytes_read
;
14410 range_end
= cu
->header
.read_address (obfd
, buffer
, &bytes_read
);
14411 buffer
+= bytes_read
;
14413 case DW_RLE_startx_endx
:
14414 addr_index
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14415 buffer
+= bytes_read
;
14416 range_beginning
= read_addr_index (cu
, addr_index
);
14417 if (buffer
> buf_end
)
14422 addr_index
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14423 buffer
+= bytes_read
;
14424 range_end
= read_addr_index (cu
, addr_index
);
14427 complaint (_("Invalid .debug_rnglists data (no base address)"));
14430 if (rlet
== DW_RLE_end_of_list
|| overflow
)
14432 if (rlet
== DW_RLE_base_address
)
14435 if (range_beginning
> range_end
)
14437 /* Inverted range entries are invalid. */
14438 complaint (_("Invalid .debug_rnglists data (inverted range)"));
14442 /* Empty range entries have no effect. */
14443 if (range_beginning
== range_end
)
14446 /* Only DW_RLE_offset_pair needs the base address added. */
14447 if (rlet
== DW_RLE_offset_pair
)
14449 if (!base
.has_value ())
14451 /* We have no valid base address for the DW_RLE_offset_pair. */
14452 complaint (_("Invalid .debug_rnglists data (no base address for "
14453 "DW_RLE_offset_pair)"));
14457 range_beginning
+= *base
;
14458 range_end
+= *base
;
14461 /* A not-uncommon case of bad debug info.
14462 Don't pollute the addrmap with bad data. */
14463 if (range_beginning
+ baseaddr
== 0
14464 && !per_objfile
->per_bfd
->has_section_at_zero
)
14466 complaint (_(".debug_rnglists entry has start address of zero"
14467 " [in module %s]"), objfile_name (objfile
));
14471 callback (range_beginning
, range_end
);
14476 complaint (_("Offset %d is not terminated "
14477 "for DW_AT_ranges attribute"),
14485 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET reading .debug_ranges.
14486 Callback's type should be:
14487 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14488 Return 1 if the attributes are present and valid, otherwise, return 0. */
14490 template <typename Callback
>
14492 dwarf2_ranges_process (unsigned offset
, struct dwarf2_cu
*cu
, dwarf_tag tag
,
14493 Callback
&&callback
)
14495 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
14496 struct objfile
*objfile
= per_objfile
->objfile
;
14497 struct comp_unit_head
*cu_header
= &cu
->header
;
14498 bfd
*obfd
= objfile
->obfd
;
14499 unsigned int addr_size
= cu_header
->addr_size
;
14500 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
14501 /* Base address selection entry. */
14502 gdb::optional
<CORE_ADDR
> base
;
14503 unsigned int dummy
;
14504 const gdb_byte
*buffer
;
14505 CORE_ADDR baseaddr
;
14507 if (cu_header
->version
>= 5)
14508 return dwarf2_rnglists_process (offset
, cu
, tag
, callback
);
14510 base
= cu
->base_address
;
14512 per_objfile
->per_bfd
->ranges
.read (objfile
);
14513 if (offset
>= per_objfile
->per_bfd
->ranges
.size
)
14515 complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
14519 buffer
= per_objfile
->per_bfd
->ranges
.buffer
+ offset
;
14521 baseaddr
= objfile
->text_section_offset ();
14525 CORE_ADDR range_beginning
, range_end
;
14527 range_beginning
= cu
->header
.read_address (obfd
, buffer
, &dummy
);
14528 buffer
+= addr_size
;
14529 range_end
= cu
->header
.read_address (obfd
, buffer
, &dummy
);
14530 buffer
+= addr_size
;
14531 offset
+= 2 * addr_size
;
14533 /* An end of list marker is a pair of zero addresses. */
14534 if (range_beginning
== 0 && range_end
== 0)
14535 /* Found the end of list entry. */
14538 /* Each base address selection entry is a pair of 2 values.
14539 The first is the largest possible address, the second is
14540 the base address. Check for a base address here. */
14541 if ((range_beginning
& mask
) == mask
)
14543 /* If we found the largest possible address, then we already
14544 have the base address in range_end. */
14549 if (!base
.has_value ())
14551 /* We have no valid base address for the ranges
14553 complaint (_("Invalid .debug_ranges data (no base address)"));
14557 if (range_beginning
> range_end
)
14559 /* Inverted range entries are invalid. */
14560 complaint (_("Invalid .debug_ranges data (inverted range)"));
14564 /* Empty range entries have no effect. */
14565 if (range_beginning
== range_end
)
14568 range_beginning
+= *base
;
14569 range_end
+= *base
;
14571 /* A not-uncommon case of bad debug info.
14572 Don't pollute the addrmap with bad data. */
14573 if (range_beginning
+ baseaddr
== 0
14574 && !per_objfile
->per_bfd
->has_section_at_zero
)
14576 complaint (_(".debug_ranges entry has start address of zero"
14577 " [in module %s]"), objfile_name (objfile
));
14581 callback (range_beginning
, range_end
);
14587 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
14588 Return 1 if the attributes are present and valid, otherwise, return 0.
14589 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
14592 dwarf2_ranges_read (unsigned offset
, CORE_ADDR
*low_return
,
14593 CORE_ADDR
*high_return
, struct dwarf2_cu
*cu
,
14594 dwarf2_psymtab
*ranges_pst
, dwarf_tag tag
)
14596 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
14597 struct gdbarch
*gdbarch
= objfile
->arch ();
14598 const CORE_ADDR baseaddr
= objfile
->text_section_offset ();
14601 CORE_ADDR high
= 0;
14604 retval
= dwarf2_ranges_process (offset
, cu
, tag
,
14605 [&] (CORE_ADDR range_beginning
, CORE_ADDR range_end
)
14607 if (ranges_pst
!= NULL
)
14612 lowpc
= (gdbarch_adjust_dwarf2_addr (gdbarch
,
14613 range_beginning
+ baseaddr
)
14615 highpc
= (gdbarch_adjust_dwarf2_addr (gdbarch
,
14616 range_end
+ baseaddr
)
14618 addrmap_set_empty (objfile
->partial_symtabs
->psymtabs_addrmap
,
14619 lowpc
, highpc
- 1, ranges_pst
);
14622 /* FIXME: This is recording everything as a low-high
14623 segment of consecutive addresses. We should have a
14624 data structure for discontiguous block ranges
14628 low
= range_beginning
;
14634 if (range_beginning
< low
)
14635 low
= range_beginning
;
14636 if (range_end
> high
)
14644 /* If the first entry is an end-of-list marker, the range
14645 describes an empty scope, i.e. no instructions. */
14651 *high_return
= high
;
14655 /* Get low and high pc attributes from a die. See enum pc_bounds_kind
14656 definition for the return value. *LOWPC and *HIGHPC are set iff
14657 neither PC_BOUNDS_NOT_PRESENT nor PC_BOUNDS_INVALID are returned. */
14659 static enum pc_bounds_kind
14660 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
14661 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
,
14662 dwarf2_psymtab
*pst
)
14664 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
14665 struct attribute
*attr
;
14666 struct attribute
*attr_high
;
14668 CORE_ADDR high
= 0;
14669 enum pc_bounds_kind ret
;
14671 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
14674 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
14675 if (attr
!= nullptr)
14677 low
= attr
->as_address ();
14678 high
= attr_high
->as_address ();
14679 if (cu
->header
.version
>= 4 && attr_high
->form_is_constant ())
14683 /* Found high w/o low attribute. */
14684 return PC_BOUNDS_INVALID
;
14686 /* Found consecutive range of addresses. */
14687 ret
= PC_BOUNDS_HIGH_LOW
;
14691 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
14692 if (attr
!= nullptr && attr
->form_is_unsigned ())
14694 /* Offset in the .debug_ranges or .debug_rnglist section (depending
14695 on DWARF version). */
14696 ULONGEST ranges_offset
= attr
->as_unsigned ();
14698 /* See dwarf2_cu::gnu_ranges_base's doc for why we might want to add
14700 if (die
->tag
!= DW_TAG_compile_unit
)
14701 ranges_offset
+= cu
->gnu_ranges_base
;
14703 /* Value of the DW_AT_ranges attribute is the offset in the
14704 .debug_ranges section. */
14705 if (!dwarf2_ranges_read (ranges_offset
, &low
, &high
, cu
, pst
,
14707 return PC_BOUNDS_INVALID
;
14708 /* Found discontinuous range of addresses. */
14709 ret
= PC_BOUNDS_RANGES
;
14712 return PC_BOUNDS_NOT_PRESENT
;
14715 /* partial_die_info::read has also the strict LOW < HIGH requirement. */
14717 return PC_BOUNDS_INVALID
;
14719 /* When using the GNU linker, .gnu.linkonce. sections are used to
14720 eliminate duplicate copies of functions and vtables and such.
14721 The linker will arbitrarily choose one and discard the others.
14722 The AT_*_pc values for such functions refer to local labels in
14723 these sections. If the section from that file was discarded, the
14724 labels are not in the output, so the relocs get a value of 0.
14725 If this is a discarded function, mark the pc bounds as invalid,
14726 so that GDB will ignore it. */
14727 if (low
== 0 && !per_objfile
->per_bfd
->has_section_at_zero
)
14728 return PC_BOUNDS_INVALID
;
14736 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
14737 its low and high PC addresses. Do nothing if these addresses could not
14738 be determined. Otherwise, set LOWPC to the low address if it is smaller,
14739 and HIGHPC to the high address if greater than HIGHPC. */
14742 dwarf2_get_subprogram_pc_bounds (struct die_info
*die
,
14743 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
14744 struct dwarf2_cu
*cu
)
14746 CORE_ADDR low
, high
;
14747 struct die_info
*child
= die
->child
;
14749 if (dwarf2_get_pc_bounds (die
, &low
, &high
, cu
, NULL
) >= PC_BOUNDS_RANGES
)
14751 *lowpc
= std::min (*lowpc
, low
);
14752 *highpc
= std::max (*highpc
, high
);
14755 /* If the language does not allow nested subprograms (either inside
14756 subprograms or lexical blocks), we're done. */
14757 if (cu
->language
!= language_ada
)
14760 /* Check all the children of the given DIE. If it contains nested
14761 subprograms, then check their pc bounds. Likewise, we need to
14762 check lexical blocks as well, as they may also contain subprogram
14764 while (child
&& child
->tag
)
14766 if (child
->tag
== DW_TAG_subprogram
14767 || child
->tag
== DW_TAG_lexical_block
)
14768 dwarf2_get_subprogram_pc_bounds (child
, lowpc
, highpc
, cu
);
14769 child
= child
->sibling
;
14773 /* Get the low and high pc's represented by the scope DIE, and store
14774 them in *LOWPC and *HIGHPC. If the correct values can't be
14775 determined, set *LOWPC to -1 and *HIGHPC to 0. */
14778 get_scope_pc_bounds (struct die_info
*die
,
14779 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
14780 struct dwarf2_cu
*cu
)
14782 CORE_ADDR best_low
= (CORE_ADDR
) -1;
14783 CORE_ADDR best_high
= (CORE_ADDR
) 0;
14784 CORE_ADDR current_low
, current_high
;
14786 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
, NULL
)
14787 >= PC_BOUNDS_RANGES
)
14789 best_low
= current_low
;
14790 best_high
= current_high
;
14794 struct die_info
*child
= die
->child
;
14796 while (child
&& child
->tag
)
14798 switch (child
->tag
) {
14799 case DW_TAG_subprogram
:
14800 dwarf2_get_subprogram_pc_bounds (child
, &best_low
, &best_high
, cu
);
14802 case DW_TAG_namespace
:
14803 case DW_TAG_module
:
14804 /* FIXME: carlton/2004-01-16: Should we do this for
14805 DW_TAG_class_type/DW_TAG_structure_type, too? I think
14806 that current GCC's always emit the DIEs corresponding
14807 to definitions of methods of classes as children of a
14808 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
14809 the DIEs giving the declarations, which could be
14810 anywhere). But I don't see any reason why the
14811 standards says that they have to be there. */
14812 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
14814 if (current_low
!= ((CORE_ADDR
) -1))
14816 best_low
= std::min (best_low
, current_low
);
14817 best_high
= std::max (best_high
, current_high
);
14825 child
= child
->sibling
;
14830 *highpc
= best_high
;
14833 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
14837 dwarf2_record_block_ranges (struct die_info
*die
, struct block
*block
,
14838 CORE_ADDR baseaddr
, struct dwarf2_cu
*cu
)
14840 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
14841 struct gdbarch
*gdbarch
= objfile
->arch ();
14842 struct attribute
*attr
;
14843 struct attribute
*attr_high
;
14845 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
14848 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
14849 if (attr
!= nullptr)
14851 CORE_ADDR low
= attr
->as_address ();
14852 CORE_ADDR high
= attr_high
->as_address ();
14854 if (cu
->header
.version
>= 4 && attr_high
->form_is_constant ())
14857 low
= gdbarch_adjust_dwarf2_addr (gdbarch
, low
+ baseaddr
);
14858 high
= gdbarch_adjust_dwarf2_addr (gdbarch
, high
+ baseaddr
);
14859 cu
->get_builder ()->record_block_range (block
, low
, high
- 1);
14863 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
14864 if (attr
!= nullptr && attr
->form_is_unsigned ())
14866 /* Offset in the .debug_ranges or .debug_rnglist section (depending
14867 on DWARF version). */
14868 ULONGEST ranges_offset
= attr
->as_unsigned ();
14870 /* See dwarf2_cu::gnu_ranges_base's doc for why we might want to add
14872 if (die
->tag
!= DW_TAG_compile_unit
)
14873 ranges_offset
+= cu
->gnu_ranges_base
;
14875 std::vector
<blockrange
> blockvec
;
14876 dwarf2_ranges_process (ranges_offset
, cu
, die
->tag
,
14877 [&] (CORE_ADDR start
, CORE_ADDR end
)
14881 start
= gdbarch_adjust_dwarf2_addr (gdbarch
, start
);
14882 end
= gdbarch_adjust_dwarf2_addr (gdbarch
, end
);
14883 cu
->get_builder ()->record_block_range (block
, start
, end
- 1);
14884 blockvec
.emplace_back (start
, end
);
14887 BLOCK_RANGES(block
) = make_blockranges (objfile
, blockvec
);
14891 /* Check whether the producer field indicates either of GCC < 4.6, or the
14892 Intel C/C++ compiler, and cache the result in CU. */
14895 check_producer (struct dwarf2_cu
*cu
)
14899 if (cu
->producer
== NULL
)
14901 /* For unknown compilers expect their behavior is DWARF version
14904 GCC started to support .debug_types sections by -gdwarf-4 since
14905 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
14906 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
14907 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
14908 interpreted incorrectly by GDB now - GCC PR debug/48229. */
14910 else if (producer_is_gcc (cu
->producer
, &major
, &minor
))
14912 cu
->producer_is_gxx_lt_4_6
= major
< 4 || (major
== 4 && minor
< 6);
14913 cu
->producer_is_gcc_lt_4_3
= major
< 4 || (major
== 4 && minor
< 3);
14915 else if (producer_is_icc (cu
->producer
, &major
, &minor
))
14917 cu
->producer_is_icc
= true;
14918 cu
->producer_is_icc_lt_14
= major
< 14;
14920 else if (startswith (cu
->producer
, "CodeWarrior S12/L-ISA"))
14921 cu
->producer_is_codewarrior
= true;
14924 /* For other non-GCC compilers, expect their behavior is DWARF version
14928 cu
->checked_producer
= true;
14931 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
14932 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
14933 during 4.6.0 experimental. */
14936 producer_is_gxx_lt_4_6 (struct dwarf2_cu
*cu
)
14938 if (!cu
->checked_producer
)
14939 check_producer (cu
);
14941 return cu
->producer_is_gxx_lt_4_6
;
14945 /* Codewarrior (at least as of version 5.0.40) generates dwarf line information
14946 with incorrect is_stmt attributes. */
14949 producer_is_codewarrior (struct dwarf2_cu
*cu
)
14951 if (!cu
->checked_producer
)
14952 check_producer (cu
);
14954 return cu
->producer_is_codewarrior
;
14957 /* Return the accessibility of DIE, as given by DW_AT_accessibility.
14958 If that attribute is not available, return the appropriate
14961 static enum dwarf_access_attribute
14962 dwarf2_access_attribute (struct die_info
*die
, struct dwarf2_cu
*cu
)
14964 attribute
*attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
14965 if (attr
!= nullptr)
14967 LONGEST value
= attr
->constant_value (-1);
14968 if (value
== DW_ACCESS_public
14969 || value
== DW_ACCESS_protected
14970 || value
== DW_ACCESS_private
)
14971 return (dwarf_access_attribute
) value
;
14972 complaint (_("Unhandled DW_AT_accessibility value (%s)"),
14976 if (cu
->header
.version
< 3 || producer_is_gxx_lt_4_6 (cu
))
14978 /* The default DWARF 2 accessibility for members is public, the default
14979 accessibility for inheritance is private. */
14981 if (die
->tag
!= DW_TAG_inheritance
)
14982 return DW_ACCESS_public
;
14984 return DW_ACCESS_private
;
14988 /* DWARF 3+ defines the default accessibility a different way. The same
14989 rules apply now for DW_TAG_inheritance as for the members and it only
14990 depends on the container kind. */
14992 if (die
->parent
->tag
== DW_TAG_class_type
)
14993 return DW_ACCESS_private
;
14995 return DW_ACCESS_public
;
14999 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
15000 offset. If the attribute was not found return 0, otherwise return
15001 1. If it was found but could not properly be handled, set *OFFSET
15005 handle_data_member_location (struct die_info
*die
, struct dwarf2_cu
*cu
,
15008 struct attribute
*attr
;
15010 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
15015 /* Note that we do not check for a section offset first here.
15016 This is because DW_AT_data_member_location is new in DWARF 4,
15017 so if we see it, we can assume that a constant form is really
15018 a constant and not a section offset. */
15019 if (attr
->form_is_constant ())
15020 *offset
= attr
->constant_value (0);
15021 else if (attr
->form_is_section_offset ())
15022 dwarf2_complex_location_expr_complaint ();
15023 else if (attr
->form_is_block ())
15024 *offset
= decode_locdesc (attr
->as_block (), cu
);
15026 dwarf2_complex_location_expr_complaint ();
15034 /* Look for DW_AT_data_member_location and store the results in FIELD. */
15037 handle_data_member_location (struct die_info
*die
, struct dwarf2_cu
*cu
,
15038 struct field
*field
)
15040 struct attribute
*attr
;
15042 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
15045 if (attr
->form_is_constant ())
15047 LONGEST offset
= attr
->constant_value (0);
15048 SET_FIELD_BITPOS (*field
, offset
* bits_per_byte
);
15050 else if (attr
->form_is_section_offset ())
15051 dwarf2_complex_location_expr_complaint ();
15052 else if (attr
->form_is_block ())
15055 CORE_ADDR offset
= decode_locdesc (attr
->as_block (), cu
, &handled
);
15057 SET_FIELD_BITPOS (*field
, offset
* bits_per_byte
);
15060 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
15061 struct objfile
*objfile
= per_objfile
->objfile
;
15062 struct dwarf2_locexpr_baton
*dlbaton
15063 = XOBNEW (&objfile
->objfile_obstack
,
15064 struct dwarf2_locexpr_baton
);
15065 dlbaton
->data
= attr
->as_block ()->data
;
15066 dlbaton
->size
= attr
->as_block ()->size
;
15067 /* When using this baton, we want to compute the address
15068 of the field, not the value. This is why
15069 is_reference is set to false here. */
15070 dlbaton
->is_reference
= false;
15071 dlbaton
->per_objfile
= per_objfile
;
15072 dlbaton
->per_cu
= cu
->per_cu
;
15074 SET_FIELD_DWARF_BLOCK (*field
, dlbaton
);
15078 dwarf2_complex_location_expr_complaint ();
15082 /* Add an aggregate field to the field list. */
15085 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
15086 struct dwarf2_cu
*cu
)
15088 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
15089 struct gdbarch
*gdbarch
= objfile
->arch ();
15090 struct nextfield
*new_field
;
15091 struct attribute
*attr
;
15093 const char *fieldname
= "";
15095 if (die
->tag
== DW_TAG_inheritance
)
15097 fip
->baseclasses
.emplace_back ();
15098 new_field
= &fip
->baseclasses
.back ();
15102 fip
->fields
.emplace_back ();
15103 new_field
= &fip
->fields
.back ();
15106 new_field
->offset
= die
->sect_off
;
15108 new_field
->accessibility
= dwarf2_access_attribute (die
, cu
);
15109 if (new_field
->accessibility
!= DW_ACCESS_public
)
15110 fip
->non_public_fields
= true;
15112 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
15113 if (attr
!= nullptr)
15114 new_field
->virtuality
= attr
->as_virtuality ();
15116 new_field
->virtuality
= DW_VIRTUALITY_none
;
15118 fp
= &new_field
->field
;
15120 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
15122 /* Data member other than a C++ static data member. */
15124 /* Get type of field. */
15125 fp
->set_type (die_type (die
, cu
));
15127 SET_FIELD_BITPOS (*fp
, 0);
15129 /* Get bit size of field (zero if none). */
15130 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
15131 if (attr
!= nullptr)
15133 FIELD_BITSIZE (*fp
) = attr
->constant_value (0);
15137 FIELD_BITSIZE (*fp
) = 0;
15140 /* Get bit offset of field. */
15141 handle_data_member_location (die
, cu
, fp
);
15142 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
15143 if (attr
!= nullptr && attr
->form_is_constant ())
15145 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
)
15147 /* For big endian bits, the DW_AT_bit_offset gives the
15148 additional bit offset from the MSB of the containing
15149 anonymous object to the MSB of the field. We don't
15150 have to do anything special since we don't need to
15151 know the size of the anonymous object. */
15152 SET_FIELD_BITPOS (*fp
, (FIELD_BITPOS (*fp
)
15153 + attr
->constant_value (0)));
15157 /* For little endian bits, compute the bit offset to the
15158 MSB of the anonymous object, subtract off the number of
15159 bits from the MSB of the field to the MSB of the
15160 object, and then subtract off the number of bits of
15161 the field itself. The result is the bit offset of
15162 the LSB of the field. */
15163 int anonymous_size
;
15164 int bit_offset
= attr
->constant_value (0);
15166 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
15167 if (attr
!= nullptr && attr
->form_is_constant ())
15169 /* The size of the anonymous object containing
15170 the bit field is explicit, so use the
15171 indicated size (in bytes). */
15172 anonymous_size
= attr
->constant_value (0);
15176 /* The size of the anonymous object containing
15177 the bit field must be inferred from the type
15178 attribute of the data member containing the
15180 anonymous_size
= TYPE_LENGTH (fp
->type ());
15182 SET_FIELD_BITPOS (*fp
,
15183 (FIELD_BITPOS (*fp
)
15184 + anonymous_size
* bits_per_byte
15185 - bit_offset
- FIELD_BITSIZE (*fp
)));
15188 attr
= dwarf2_attr (die
, DW_AT_data_bit_offset
, cu
);
15190 SET_FIELD_BITPOS (*fp
, (FIELD_BITPOS (*fp
)
15191 + attr
->constant_value (0)));
15193 /* Get name of field. */
15194 fieldname
= dwarf2_name (die
, cu
);
15195 if (fieldname
== NULL
)
15198 /* The name is already allocated along with this objfile, so we don't
15199 need to duplicate it for the type. */
15200 fp
->name
= fieldname
;
15202 /* Change accessibility for artificial fields (e.g. virtual table
15203 pointer or virtual base class pointer) to private. */
15204 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
15206 FIELD_ARTIFICIAL (*fp
) = 1;
15207 new_field
->accessibility
= DW_ACCESS_private
;
15208 fip
->non_public_fields
= true;
15211 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
15213 /* C++ static member. */
15215 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
15216 is a declaration, but all versions of G++ as of this writing
15217 (so through at least 3.2.1) incorrectly generate
15218 DW_TAG_variable tags. */
15220 const char *physname
;
15222 /* Get name of field. */
15223 fieldname
= dwarf2_name (die
, cu
);
15224 if (fieldname
== NULL
)
15227 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
15229 /* Only create a symbol if this is an external value.
15230 new_symbol checks this and puts the value in the global symbol
15231 table, which we want. If it is not external, new_symbol
15232 will try to put the value in cu->list_in_scope which is wrong. */
15233 && dwarf2_flag_true_p (die
, DW_AT_external
, cu
))
15235 /* A static const member, not much different than an enum as far as
15236 we're concerned, except that we can support more types. */
15237 new_symbol (die
, NULL
, cu
);
15240 /* Get physical name. */
15241 physname
= dwarf2_physname (fieldname
, die
, cu
);
15243 /* The name is already allocated along with this objfile, so we don't
15244 need to duplicate it for the type. */
15245 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
15246 fp
->set_type (die_type (die
, cu
));
15247 FIELD_NAME (*fp
) = fieldname
;
15249 else if (die
->tag
== DW_TAG_inheritance
)
15251 /* C++ base class field. */
15252 handle_data_member_location (die
, cu
, fp
);
15253 FIELD_BITSIZE (*fp
) = 0;
15254 fp
->set_type (die_type (die
, cu
));
15255 FIELD_NAME (*fp
) = fp
->type ()->name ();
15258 gdb_assert_not_reached ("missing case in dwarf2_add_field");
15261 /* Can the type given by DIE define another type? */
15264 type_can_define_types (const struct die_info
*die
)
15268 case DW_TAG_typedef
:
15269 case DW_TAG_class_type
:
15270 case DW_TAG_structure_type
:
15271 case DW_TAG_union_type
:
15272 case DW_TAG_enumeration_type
:
15280 /* Add a type definition defined in the scope of the FIP's class. */
15283 dwarf2_add_type_defn (struct field_info
*fip
, struct die_info
*die
,
15284 struct dwarf2_cu
*cu
)
15286 struct decl_field fp
;
15287 memset (&fp
, 0, sizeof (fp
));
15289 gdb_assert (type_can_define_types (die
));
15291 /* Get name of field. NULL is okay here, meaning an anonymous type. */
15292 fp
.name
= dwarf2_name (die
, cu
);
15293 fp
.type
= read_type_die (die
, cu
);
15295 /* Save accessibility. */
15296 dwarf_access_attribute accessibility
= dwarf2_access_attribute (die
, cu
);
15297 switch (accessibility
)
15299 case DW_ACCESS_public
:
15300 /* The assumed value if neither private nor protected. */
15302 case DW_ACCESS_private
:
15305 case DW_ACCESS_protected
:
15306 fp
.is_protected
= 1;
15310 if (die
->tag
== DW_TAG_typedef
)
15311 fip
->typedef_field_list
.push_back (fp
);
15313 fip
->nested_types_list
.push_back (fp
);
15316 /* A convenience typedef that's used when finding the discriminant
15317 field for a variant part. */
15318 typedef std::unordered_map
<sect_offset
, int, gdb::hash_enum
<sect_offset
>>
15321 /* Compute the discriminant range for a given variant. OBSTACK is
15322 where the results will be stored. VARIANT is the variant to
15323 process. IS_UNSIGNED indicates whether the discriminant is signed
15326 static const gdb::array_view
<discriminant_range
>
15327 convert_variant_range (struct obstack
*obstack
, const variant_field
&variant
,
15330 std::vector
<discriminant_range
> ranges
;
15332 if (variant
.default_branch
)
15335 if (variant
.discr_list_data
== nullptr)
15337 discriminant_range r
15338 = {variant
.discriminant_value
, variant
.discriminant_value
};
15339 ranges
.push_back (r
);
15343 gdb::array_view
<const gdb_byte
> data (variant
.discr_list_data
->data
,
15344 variant
.discr_list_data
->size
);
15345 while (!data
.empty ())
15347 if (data
[0] != DW_DSC_range
&& data
[0] != DW_DSC_label
)
15349 complaint (_("invalid discriminant marker: %d"), data
[0]);
15352 bool is_range
= data
[0] == DW_DSC_range
;
15353 data
= data
.slice (1);
15355 ULONGEST low
, high
;
15356 unsigned int bytes_read
;
15360 complaint (_("DW_AT_discr_list missing low value"));
15364 low
= read_unsigned_leb128 (nullptr, data
.data (), &bytes_read
);
15366 low
= (ULONGEST
) read_signed_leb128 (nullptr, data
.data (),
15368 data
= data
.slice (bytes_read
);
15374 complaint (_("DW_AT_discr_list missing high value"));
15378 high
= read_unsigned_leb128 (nullptr, data
.data (),
15381 high
= (LONGEST
) read_signed_leb128 (nullptr, data
.data (),
15383 data
= data
.slice (bytes_read
);
15388 ranges
.push_back ({ low
, high
});
15392 discriminant_range
*result
= XOBNEWVEC (obstack
, discriminant_range
,
15394 std::copy (ranges
.begin (), ranges
.end (), result
);
15395 return gdb::array_view
<discriminant_range
> (result
, ranges
.size ());
15398 static const gdb::array_view
<variant_part
> create_variant_parts
15399 (struct obstack
*obstack
,
15400 const offset_map_type
&offset_map
,
15401 struct field_info
*fi
,
15402 const std::vector
<variant_part_builder
> &variant_parts
);
15404 /* Fill in a "struct variant" for a given variant field. RESULT is
15405 the variant to fill in. OBSTACK is where any needed allocations
15406 will be done. OFFSET_MAP holds the mapping from section offsets to
15407 fields for the type. FI describes the fields of the type we're
15408 processing. FIELD is the variant field we're converting. */
15411 create_one_variant (variant
&result
, struct obstack
*obstack
,
15412 const offset_map_type
&offset_map
,
15413 struct field_info
*fi
, const variant_field
&field
)
15415 result
.discriminants
= convert_variant_range (obstack
, field
, false);
15416 result
.first_field
= field
.first_field
+ fi
->baseclasses
.size ();
15417 result
.last_field
= field
.last_field
+ fi
->baseclasses
.size ();
15418 result
.parts
= create_variant_parts (obstack
, offset_map
, fi
,
15419 field
.variant_parts
);
15422 /* Fill in a "struct variant_part" for a given variant part. RESULT
15423 is the variant part to fill in. OBSTACK is where any needed
15424 allocations will be done. OFFSET_MAP holds the mapping from
15425 section offsets to fields for the type. FI describes the fields of
15426 the type we're processing. BUILDER is the variant part to be
15430 create_one_variant_part (variant_part
&result
,
15431 struct obstack
*obstack
,
15432 const offset_map_type
&offset_map
,
15433 struct field_info
*fi
,
15434 const variant_part_builder
&builder
)
15436 auto iter
= offset_map
.find (builder
.discriminant_offset
);
15437 if (iter
== offset_map
.end ())
15439 result
.discriminant_index
= -1;
15440 /* Doesn't matter. */
15441 result
.is_unsigned
= false;
15445 result
.discriminant_index
= iter
->second
;
15447 = fi
->fields
[result
.discriminant_index
].field
.type ()->is_unsigned ();
15450 size_t n
= builder
.variants
.size ();
15451 variant
*output
= new (obstack
) variant
[n
];
15452 for (size_t i
= 0; i
< n
; ++i
)
15453 create_one_variant (output
[i
], obstack
, offset_map
, fi
,
15454 builder
.variants
[i
]);
15456 result
.variants
= gdb::array_view
<variant
> (output
, n
);
15459 /* Create a vector of variant parts that can be attached to a type.
15460 OBSTACK is where any needed allocations will be done. OFFSET_MAP
15461 holds the mapping from section offsets to fields for the type. FI
15462 describes the fields of the type we're processing. VARIANT_PARTS
15463 is the vector to convert. */
15465 static const gdb::array_view
<variant_part
>
15466 create_variant_parts (struct obstack
*obstack
,
15467 const offset_map_type
&offset_map
,
15468 struct field_info
*fi
,
15469 const std::vector
<variant_part_builder
> &variant_parts
)
15471 if (variant_parts
.empty ())
15474 size_t n
= variant_parts
.size ();
15475 variant_part
*result
= new (obstack
) variant_part
[n
];
15476 for (size_t i
= 0; i
< n
; ++i
)
15477 create_one_variant_part (result
[i
], obstack
, offset_map
, fi
,
15480 return gdb::array_view
<variant_part
> (result
, n
);
15483 /* Compute the variant part vector for FIP, attaching it to TYPE when
15487 add_variant_property (struct field_info
*fip
, struct type
*type
,
15488 struct dwarf2_cu
*cu
)
15490 /* Map section offsets of fields to their field index. Note the
15491 field index here does not take the number of baseclasses into
15493 offset_map_type offset_map
;
15494 for (int i
= 0; i
< fip
->fields
.size (); ++i
)
15495 offset_map
[fip
->fields
[i
].offset
] = i
;
15497 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
15498 gdb::array_view
<variant_part
> parts
15499 = create_variant_parts (&objfile
->objfile_obstack
, offset_map
, fip
,
15500 fip
->variant_parts
);
15502 struct dynamic_prop prop
;
15503 prop
.set_variant_parts ((gdb::array_view
<variant_part
> *)
15504 obstack_copy (&objfile
->objfile_obstack
, &parts
,
15507 type
->add_dyn_prop (DYN_PROP_VARIANT_PARTS
, prop
);
15510 /* Create the vector of fields, and attach it to the type. */
15513 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
15514 struct dwarf2_cu
*cu
)
15516 int nfields
= fip
->nfields ();
15518 /* Record the field count, allocate space for the array of fields,
15519 and create blank accessibility bitfields if necessary. */
15520 type
->set_num_fields (nfields
);
15522 ((struct field
*) TYPE_ZALLOC (type
, sizeof (struct field
) * nfields
));
15524 if (fip
->non_public_fields
&& cu
->language
!= language_ada
)
15526 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15528 TYPE_FIELD_PRIVATE_BITS (type
) =
15529 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
15530 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
15532 TYPE_FIELD_PROTECTED_BITS (type
) =
15533 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
15534 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
15536 TYPE_FIELD_IGNORE_BITS (type
) =
15537 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
15538 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
15541 /* If the type has baseclasses, allocate and clear a bit vector for
15542 TYPE_FIELD_VIRTUAL_BITS. */
15543 if (!fip
->baseclasses
.empty () && cu
->language
!= language_ada
)
15545 int num_bytes
= B_BYTES (fip
->baseclasses
.size ());
15546 unsigned char *pointer
;
15548 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15549 pointer
= (unsigned char *) TYPE_ALLOC (type
, num_bytes
);
15550 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
15551 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->baseclasses
.size ());
15552 TYPE_N_BASECLASSES (type
) = fip
->baseclasses
.size ();
15555 if (!fip
->variant_parts
.empty ())
15556 add_variant_property (fip
, type
, cu
);
15558 /* Copy the saved-up fields into the field vector. */
15559 for (int i
= 0; i
< nfields
; ++i
)
15561 struct nextfield
&field
15562 = ((i
< fip
->baseclasses
.size ()) ? fip
->baseclasses
[i
]
15563 : fip
->fields
[i
- fip
->baseclasses
.size ()]);
15565 type
->field (i
) = field
.field
;
15566 switch (field
.accessibility
)
15568 case DW_ACCESS_private
:
15569 if (cu
->language
!= language_ada
)
15570 SET_TYPE_FIELD_PRIVATE (type
, i
);
15573 case DW_ACCESS_protected
:
15574 if (cu
->language
!= language_ada
)
15575 SET_TYPE_FIELD_PROTECTED (type
, i
);
15578 case DW_ACCESS_public
:
15582 /* Unknown accessibility. Complain and treat it as public. */
15584 complaint (_("unsupported accessibility %d"),
15585 field
.accessibility
);
15589 if (i
< fip
->baseclasses
.size ())
15591 switch (field
.virtuality
)
15593 case DW_VIRTUALITY_virtual
:
15594 case DW_VIRTUALITY_pure_virtual
:
15595 if (cu
->language
== language_ada
)
15596 error (_("unexpected virtuality in component of Ada type"));
15597 SET_TYPE_FIELD_VIRTUAL (type
, i
);
15604 /* Return true if this member function is a constructor, false
15608 dwarf2_is_constructor (struct die_info
*die
, struct dwarf2_cu
*cu
)
15610 const char *fieldname
;
15611 const char *type_name
;
15614 if (die
->parent
== NULL
)
15617 if (die
->parent
->tag
!= DW_TAG_structure_type
15618 && die
->parent
->tag
!= DW_TAG_union_type
15619 && die
->parent
->tag
!= DW_TAG_class_type
)
15622 fieldname
= dwarf2_name (die
, cu
);
15623 type_name
= dwarf2_name (die
->parent
, cu
);
15624 if (fieldname
== NULL
|| type_name
== NULL
)
15627 len
= strlen (fieldname
);
15628 return (strncmp (fieldname
, type_name
, len
) == 0
15629 && (type_name
[len
] == '\0' || type_name
[len
] == '<'));
15632 /* Add a member function to the proper fieldlist. */
15635 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
15636 struct type
*type
, struct dwarf2_cu
*cu
)
15638 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
15639 struct attribute
*attr
;
15641 struct fnfieldlist
*flp
= nullptr;
15642 struct fn_field
*fnp
;
15643 const char *fieldname
;
15644 struct type
*this_type
;
15646 if (cu
->language
== language_ada
)
15647 error (_("unexpected member function in Ada type"));
15649 /* Get name of member function. */
15650 fieldname
= dwarf2_name (die
, cu
);
15651 if (fieldname
== NULL
)
15654 /* Look up member function name in fieldlist. */
15655 for (i
= 0; i
< fip
->fnfieldlists
.size (); i
++)
15657 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
15659 flp
= &fip
->fnfieldlists
[i
];
15664 /* Create a new fnfieldlist if necessary. */
15665 if (flp
== nullptr)
15667 fip
->fnfieldlists
.emplace_back ();
15668 flp
= &fip
->fnfieldlists
.back ();
15669 flp
->name
= fieldname
;
15670 i
= fip
->fnfieldlists
.size () - 1;
15673 /* Create a new member function field and add it to the vector of
15675 flp
->fnfields
.emplace_back ();
15676 fnp
= &flp
->fnfields
.back ();
15678 /* Delay processing of the physname until later. */
15679 if (cu
->language
== language_cplus
)
15680 add_to_method_list (type
, i
, flp
->fnfields
.size () - 1, fieldname
,
15684 const char *physname
= dwarf2_physname (fieldname
, die
, cu
);
15685 fnp
->physname
= physname
? physname
: "";
15688 fnp
->type
= alloc_type (objfile
);
15689 this_type
= read_type_die (die
, cu
);
15690 if (this_type
&& this_type
->code () == TYPE_CODE_FUNC
)
15692 int nparams
= this_type
->num_fields ();
15694 /* TYPE is the domain of this method, and THIS_TYPE is the type
15695 of the method itself (TYPE_CODE_METHOD). */
15696 smash_to_method_type (fnp
->type
, type
,
15697 TYPE_TARGET_TYPE (this_type
),
15698 this_type
->fields (),
15699 this_type
->num_fields (),
15700 this_type
->has_varargs ());
15702 /* Handle static member functions.
15703 Dwarf2 has no clean way to discern C++ static and non-static
15704 member functions. G++ helps GDB by marking the first
15705 parameter for non-static member functions (which is the this
15706 pointer) as artificial. We obtain this information from
15707 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
15708 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (this_type
, 0) == 0)
15709 fnp
->voffset
= VOFFSET_STATIC
;
15712 complaint (_("member function type missing for '%s'"),
15713 dwarf2_full_name (fieldname
, die
, cu
));
15715 /* Get fcontext from DW_AT_containing_type if present. */
15716 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
15717 fnp
->fcontext
= die_containing_type (die
, cu
);
15719 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
15720 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
15722 /* Get accessibility. */
15723 dwarf_access_attribute accessibility
= dwarf2_access_attribute (die
, cu
);
15724 switch (accessibility
)
15726 case DW_ACCESS_private
:
15727 fnp
->is_private
= 1;
15729 case DW_ACCESS_protected
:
15730 fnp
->is_protected
= 1;
15734 /* Check for artificial methods. */
15735 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
15736 if (attr
&& attr
->as_boolean ())
15737 fnp
->is_artificial
= 1;
15739 /* Check for defaulted methods. */
15740 attr
= dwarf2_attr (die
, DW_AT_defaulted
, cu
);
15741 if (attr
!= nullptr)
15742 fnp
->defaulted
= attr
->defaulted ();
15744 /* Check for deleted methods. */
15745 attr
= dwarf2_attr (die
, DW_AT_deleted
, cu
);
15746 if (attr
!= nullptr && attr
->as_boolean ())
15747 fnp
->is_deleted
= 1;
15749 fnp
->is_constructor
= dwarf2_is_constructor (die
, cu
);
15751 /* Get index in virtual function table if it is a virtual member
15752 function. For older versions of GCC, this is an offset in the
15753 appropriate virtual table, as specified by DW_AT_containing_type.
15754 For everyone else, it is an expression to be evaluated relative
15755 to the object address. */
15757 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
15758 if (attr
!= nullptr)
15760 if (attr
->form_is_block () && attr
->as_block ()->size
> 0)
15762 struct dwarf_block
*block
= attr
->as_block ();
15764 if (block
->data
[0] == DW_OP_constu
)
15766 /* Old-style GCC. */
15767 fnp
->voffset
= decode_locdesc (block
, cu
) + 2;
15769 else if (block
->data
[0] == DW_OP_deref
15770 || (block
->size
> 1
15771 && block
->data
[0] == DW_OP_deref_size
15772 && block
->data
[1] == cu
->header
.addr_size
))
15774 fnp
->voffset
= decode_locdesc (block
, cu
);
15775 if ((fnp
->voffset
% cu
->header
.addr_size
) != 0)
15776 dwarf2_complex_location_expr_complaint ();
15778 fnp
->voffset
/= cu
->header
.addr_size
;
15782 dwarf2_complex_location_expr_complaint ();
15784 if (!fnp
->fcontext
)
15786 /* If there is no `this' field and no DW_AT_containing_type,
15787 we cannot actually find a base class context for the
15789 if (this_type
->num_fields () == 0
15790 || !TYPE_FIELD_ARTIFICIAL (this_type
, 0))
15792 complaint (_("cannot determine context for virtual member "
15793 "function \"%s\" (offset %s)"),
15794 fieldname
, sect_offset_str (die
->sect_off
));
15799 = TYPE_TARGET_TYPE (this_type
->field (0).type ());
15803 else if (attr
->form_is_section_offset ())
15805 dwarf2_complex_location_expr_complaint ();
15809 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
15815 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
15816 if (attr
!= nullptr && attr
->as_virtuality () != DW_VIRTUALITY_none
)
15818 /* GCC does this, as of 2008-08-25; PR debug/37237. */
15819 complaint (_("Member function \"%s\" (offset %s) is virtual "
15820 "but the vtable offset is not specified"),
15821 fieldname
, sect_offset_str (die
->sect_off
));
15822 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15823 TYPE_CPLUS_DYNAMIC (type
) = 1;
15828 /* Create the vector of member function fields, and attach it to the type. */
15831 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
15832 struct dwarf2_cu
*cu
)
15834 if (cu
->language
== language_ada
)
15835 error (_("unexpected member functions in Ada type"));
15837 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15838 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
15840 sizeof (struct fn_fieldlist
) * fip
->fnfieldlists
.size ());
15842 for (int i
= 0; i
< fip
->fnfieldlists
.size (); i
++)
15844 struct fnfieldlist
&nf
= fip
->fnfieldlists
[i
];
15845 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
15847 TYPE_FN_FIELDLIST_NAME (type
, i
) = nf
.name
;
15848 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = nf
.fnfields
.size ();
15849 fn_flp
->fn_fields
= (struct fn_field
*)
15850 TYPE_ALLOC (type
, sizeof (struct fn_field
) * nf
.fnfields
.size ());
15852 for (int k
= 0; k
< nf
.fnfields
.size (); ++k
)
15853 fn_flp
->fn_fields
[k
] = nf
.fnfields
[k
];
15856 TYPE_NFN_FIELDS (type
) = fip
->fnfieldlists
.size ();
15859 /* Returns non-zero if NAME is the name of a vtable member in CU's
15860 language, zero otherwise. */
15862 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
15864 static const char vptr
[] = "_vptr";
15866 /* Look for the C++ form of the vtable. */
15867 if (startswith (name
, vptr
) && is_cplus_marker (name
[sizeof (vptr
) - 1]))
15873 /* GCC outputs unnamed structures that are really pointers to member
15874 functions, with the ABI-specified layout. If TYPE describes
15875 such a structure, smash it into a member function type.
15877 GCC shouldn't do this; it should just output pointer to member DIEs.
15878 This is GCC PR debug/28767. */
15881 quirk_gcc_member_function_pointer (struct type
*type
, struct objfile
*objfile
)
15883 struct type
*pfn_type
, *self_type
, *new_type
;
15885 /* Check for a structure with no name and two children. */
15886 if (type
->code () != TYPE_CODE_STRUCT
|| type
->num_fields () != 2)
15889 /* Check for __pfn and __delta members. */
15890 if (TYPE_FIELD_NAME (type
, 0) == NULL
15891 || strcmp (TYPE_FIELD_NAME (type
, 0), "__pfn") != 0
15892 || TYPE_FIELD_NAME (type
, 1) == NULL
15893 || strcmp (TYPE_FIELD_NAME (type
, 1), "__delta") != 0)
15896 /* Find the type of the method. */
15897 pfn_type
= type
->field (0).type ();
15898 if (pfn_type
== NULL
15899 || pfn_type
->code () != TYPE_CODE_PTR
15900 || TYPE_TARGET_TYPE (pfn_type
)->code () != TYPE_CODE_FUNC
)
15903 /* Look for the "this" argument. */
15904 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
15905 if (pfn_type
->num_fields () == 0
15906 /* || pfn_type->field (0).type () == NULL */
15907 || pfn_type
->field (0).type ()->code () != TYPE_CODE_PTR
)
15910 self_type
= TYPE_TARGET_TYPE (pfn_type
->field (0).type ());
15911 new_type
= alloc_type (objfile
);
15912 smash_to_method_type (new_type
, self_type
, TYPE_TARGET_TYPE (pfn_type
),
15913 pfn_type
->fields (), pfn_type
->num_fields (),
15914 pfn_type
->has_varargs ());
15915 smash_to_methodptr_type (type
, new_type
);
15918 /* Helper for quirk_ada_thick_pointer. If TYPE is an array type that
15919 requires rewriting, then copy it and return the updated copy.
15920 Otherwise return nullptr. */
15922 static struct type
*
15923 rewrite_array_type (struct type
*type
)
15925 if (type
->code () != TYPE_CODE_ARRAY
)
15928 struct type
*index_type
= type
->index_type ();
15929 range_bounds
*current_bounds
= index_type
->bounds ();
15931 /* Handle multi-dimensional arrays. */
15932 struct type
*new_target
= rewrite_array_type (TYPE_TARGET_TYPE (type
));
15933 if (new_target
== nullptr)
15935 /* Maybe we don't need to rewrite this array. */
15936 if (current_bounds
->low
.kind () == PROP_CONST
15937 && current_bounds
->high
.kind () == PROP_CONST
)
15941 /* Either the target type was rewritten, or the bounds have to be
15942 updated. Either way we want to copy the type and update
15944 struct type
*copy
= copy_type (type
);
15945 int nfields
= copy
->num_fields ();
15947 = ((struct field
*) TYPE_ZALLOC (copy
,
15948 nfields
* sizeof (struct field
)));
15949 memcpy (new_fields
, copy
->fields (), nfields
* sizeof (struct field
));
15950 copy
->set_fields (new_fields
);
15951 if (new_target
!= nullptr)
15952 TYPE_TARGET_TYPE (copy
) = new_target
;
15954 struct type
*index_copy
= copy_type (index_type
);
15955 range_bounds
*bounds
15956 = (struct range_bounds
*) TYPE_ZALLOC (index_copy
,
15957 sizeof (range_bounds
));
15958 *bounds
= *current_bounds
;
15959 bounds
->low
.set_const_val (1);
15960 bounds
->high
.set_const_val (0);
15961 index_copy
->set_bounds (bounds
);
15962 copy
->set_index_type (index_copy
);
15967 /* While some versions of GCC will generate complicated DWARF for an
15968 array (see quirk_ada_thick_pointer), more recent versions were
15969 modified to emit an explicit thick pointer structure. However, in
15970 this case, the array still has DWARF expressions for its ranges,
15971 and these must be ignored. */
15974 quirk_ada_thick_pointer_struct (struct die_info
*die
, struct dwarf2_cu
*cu
,
15977 gdb_assert (cu
->language
== language_ada
);
15979 /* Check for a structure with two children. */
15980 if (type
->code () != TYPE_CODE_STRUCT
|| type
->num_fields () != 2)
15983 /* Check for P_ARRAY and P_BOUNDS members. */
15984 if (TYPE_FIELD_NAME (type
, 0) == NULL
15985 || strcmp (TYPE_FIELD_NAME (type
, 0), "P_ARRAY") != 0
15986 || TYPE_FIELD_NAME (type
, 1) == NULL
15987 || strcmp (TYPE_FIELD_NAME (type
, 1), "P_BOUNDS") != 0)
15990 /* Make sure we're looking at a pointer to an array. */
15991 if (type
->field (0).type ()->code () != TYPE_CODE_PTR
)
15994 /* The Ada code already knows how to handle these types, so all that
15995 we need to do is turn the bounds into static bounds. However, we
15996 don't want to rewrite existing array or index types in-place,
15997 because those may be referenced in other contexts where this
15998 rewriting is undesirable. */
15999 struct type
*new_ary_type
16000 = rewrite_array_type (TYPE_TARGET_TYPE (type
->field (0).type ()));
16001 if (new_ary_type
!= nullptr)
16002 type
->field (0).set_type (lookup_pointer_type (new_ary_type
));
16005 /* If the DIE has a DW_AT_alignment attribute, return its value, doing
16006 appropriate error checking and issuing complaints if there is a
16010 get_alignment (struct dwarf2_cu
*cu
, struct die_info
*die
)
16012 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_alignment
, cu
);
16014 if (attr
== nullptr)
16017 if (!attr
->form_is_constant ())
16019 complaint (_("DW_AT_alignment must have constant form"
16020 " - DIE at %s [in module %s]"),
16021 sect_offset_str (die
->sect_off
),
16022 objfile_name (cu
->per_objfile
->objfile
));
16026 LONGEST val
= attr
->constant_value (0);
16029 complaint (_("DW_AT_alignment value must not be negative"
16030 " - DIE at %s [in module %s]"),
16031 sect_offset_str (die
->sect_off
),
16032 objfile_name (cu
->per_objfile
->objfile
));
16035 ULONGEST align
= val
;
16039 complaint (_("DW_AT_alignment value must not be zero"
16040 " - DIE at %s [in module %s]"),
16041 sect_offset_str (die
->sect_off
),
16042 objfile_name (cu
->per_objfile
->objfile
));
16045 if ((align
& (align
- 1)) != 0)
16047 complaint (_("DW_AT_alignment value must be a power of 2"
16048 " - DIE at %s [in module %s]"),
16049 sect_offset_str (die
->sect_off
),
16050 objfile_name (cu
->per_objfile
->objfile
));
16057 /* If the DIE has a DW_AT_alignment attribute, use its value to set
16058 the alignment for TYPE. */
16061 maybe_set_alignment (struct dwarf2_cu
*cu
, struct die_info
*die
,
16064 if (!set_type_align (type
, get_alignment (cu
, die
)))
16065 complaint (_("DW_AT_alignment value too large"
16066 " - DIE at %s [in module %s]"),
16067 sect_offset_str (die
->sect_off
),
16068 objfile_name (cu
->per_objfile
->objfile
));
16071 /* Check if the given VALUE is a valid enum dwarf_calling_convention
16072 constant for a type, according to DWARF5 spec, Table 5.5. */
16075 is_valid_DW_AT_calling_convention_for_type (ULONGEST value
)
16080 case DW_CC_pass_by_reference
:
16081 case DW_CC_pass_by_value
:
16085 complaint (_("unrecognized DW_AT_calling_convention value "
16086 "(%s) for a type"), pulongest (value
));
16091 /* Check if the given VALUE is a valid enum dwarf_calling_convention
16092 constant for a subroutine, according to DWARF5 spec, Table 3.3, and
16093 also according to GNU-specific values (see include/dwarf2.h). */
16096 is_valid_DW_AT_calling_convention_for_subroutine (ULONGEST value
)
16101 case DW_CC_program
:
16105 case DW_CC_GNU_renesas_sh
:
16106 case DW_CC_GNU_borland_fastcall_i386
:
16107 case DW_CC_GDB_IBM_OpenCL
:
16111 complaint (_("unrecognized DW_AT_calling_convention value "
16112 "(%s) for a subroutine"), pulongest (value
));
16117 /* Called when we find the DIE that starts a structure or union scope
16118 (definition) to create a type for the structure or union. Fill in
16119 the type's name and general properties; the members will not be
16120 processed until process_structure_scope. A symbol table entry for
16121 the type will also not be done until process_structure_scope (assuming
16122 the type has a name).
16124 NOTE: we need to call these functions regardless of whether or not the
16125 DIE has a DW_AT_name attribute, since it might be an anonymous
16126 structure or union. This gets the type entered into our set of
16127 user defined types. */
16129 static struct type
*
16130 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16132 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
16134 struct attribute
*attr
;
16137 /* If the definition of this type lives in .debug_types, read that type.
16138 Don't follow DW_AT_specification though, that will take us back up
16139 the chain and we want to go down. */
16140 attr
= die
->attr (DW_AT_signature
);
16141 if (attr
!= nullptr)
16143 type
= get_DW_AT_signature_type (die
, attr
, cu
);
16145 /* The type's CU may not be the same as CU.
16146 Ensure TYPE is recorded with CU in die_type_hash. */
16147 return set_die_type (die
, type
, cu
);
16150 type
= alloc_type (objfile
);
16151 INIT_CPLUS_SPECIFIC (type
);
16153 name
= dwarf2_name (die
, cu
);
16156 if (cu
->language
== language_cplus
16157 || cu
->language
== language_d
16158 || cu
->language
== language_rust
)
16160 const char *full_name
= dwarf2_full_name (name
, die
, cu
);
16162 /* dwarf2_full_name might have already finished building the DIE's
16163 type. If so, there is no need to continue. */
16164 if (get_die_type (die
, cu
) != NULL
)
16165 return get_die_type (die
, cu
);
16167 type
->set_name (full_name
);
16171 /* The name is already allocated along with this objfile, so
16172 we don't need to duplicate it for the type. */
16173 type
->set_name (name
);
16177 if (die
->tag
== DW_TAG_structure_type
)
16179 type
->set_code (TYPE_CODE_STRUCT
);
16181 else if (die
->tag
== DW_TAG_union_type
)
16183 type
->set_code (TYPE_CODE_UNION
);
16187 type
->set_code (TYPE_CODE_STRUCT
);
16190 if (cu
->language
== language_cplus
&& die
->tag
== DW_TAG_class_type
)
16191 TYPE_DECLARED_CLASS (type
) = 1;
16193 /* Store the calling convention in the type if it's available in
16194 the die. Otherwise the calling convention remains set to
16195 the default value DW_CC_normal. */
16196 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
16197 if (attr
!= nullptr
16198 && is_valid_DW_AT_calling_convention_for_type (attr
->constant_value (0)))
16200 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
16201 TYPE_CPLUS_CALLING_CONVENTION (type
)
16202 = (enum dwarf_calling_convention
) (attr
->constant_value (0));
16205 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16206 if (attr
!= nullptr)
16208 if (attr
->form_is_constant ())
16209 TYPE_LENGTH (type
) = attr
->constant_value (0);
16212 struct dynamic_prop prop
;
16213 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
, cu
->addr_type ()))
16214 type
->add_dyn_prop (DYN_PROP_BYTE_SIZE
, prop
);
16215 TYPE_LENGTH (type
) = 0;
16220 TYPE_LENGTH (type
) = 0;
16223 maybe_set_alignment (cu
, die
, type
);
16225 if (producer_is_icc_lt_14 (cu
) && (TYPE_LENGTH (type
) == 0))
16227 /* ICC<14 does not output the required DW_AT_declaration on
16228 incomplete types, but gives them a size of zero. */
16229 type
->set_is_stub (true);
16232 type
->set_stub_is_supported (true);
16234 if (die_is_declaration (die
, cu
))
16235 type
->set_is_stub (true);
16236 else if (attr
== NULL
&& die
->child
== NULL
16237 && producer_is_realview (cu
->producer
))
16238 /* RealView does not output the required DW_AT_declaration
16239 on incomplete types. */
16240 type
->set_is_stub (true);
16242 /* We need to add the type field to the die immediately so we don't
16243 infinitely recurse when dealing with pointers to the structure
16244 type within the structure itself. */
16245 set_die_type (die
, type
, cu
);
16247 /* set_die_type should be already done. */
16248 set_descriptive_type (type
, die
, cu
);
16253 static void handle_struct_member_die
16254 (struct die_info
*child_die
,
16256 struct field_info
*fi
,
16257 std::vector
<struct symbol
*> *template_args
,
16258 struct dwarf2_cu
*cu
);
16260 /* A helper for handle_struct_member_die that handles
16261 DW_TAG_variant_part. */
16264 handle_variant_part (struct die_info
*die
, struct type
*type
,
16265 struct field_info
*fi
,
16266 std::vector
<struct symbol
*> *template_args
,
16267 struct dwarf2_cu
*cu
)
16269 variant_part_builder
*new_part
;
16270 if (fi
->current_variant_part
== nullptr)
16272 fi
->variant_parts
.emplace_back ();
16273 new_part
= &fi
->variant_parts
.back ();
16275 else if (!fi
->current_variant_part
->processing_variant
)
16277 complaint (_("nested DW_TAG_variant_part seen "
16278 "- DIE at %s [in module %s]"),
16279 sect_offset_str (die
->sect_off
),
16280 objfile_name (cu
->per_objfile
->objfile
));
16285 variant_field
¤t
= fi
->current_variant_part
->variants
.back ();
16286 current
.variant_parts
.emplace_back ();
16287 new_part
= ¤t
.variant_parts
.back ();
16290 /* When we recurse, we want callees to add to this new variant
16292 scoped_restore save_current_variant_part
16293 = make_scoped_restore (&fi
->current_variant_part
, new_part
);
16295 struct attribute
*discr
= dwarf2_attr (die
, DW_AT_discr
, cu
);
16298 /* It's a univariant form, an extension we support. */
16300 else if (discr
->form_is_ref ())
16302 struct dwarf2_cu
*target_cu
= cu
;
16303 struct die_info
*target_die
= follow_die_ref (die
, discr
, &target_cu
);
16305 new_part
->discriminant_offset
= target_die
->sect_off
;
16309 complaint (_("DW_AT_discr does not have DIE reference form"
16310 " - DIE at %s [in module %s]"),
16311 sect_offset_str (die
->sect_off
),
16312 objfile_name (cu
->per_objfile
->objfile
));
16315 for (die_info
*child_die
= die
->child
;
16317 child_die
= child_die
->sibling
)
16318 handle_struct_member_die (child_die
, type
, fi
, template_args
, cu
);
16321 /* A helper for handle_struct_member_die that handles
16325 handle_variant (struct die_info
*die
, struct type
*type
,
16326 struct field_info
*fi
,
16327 std::vector
<struct symbol
*> *template_args
,
16328 struct dwarf2_cu
*cu
)
16330 if (fi
->current_variant_part
== nullptr)
16332 complaint (_("saw DW_TAG_variant outside DW_TAG_variant_part "
16333 "- DIE at %s [in module %s]"),
16334 sect_offset_str (die
->sect_off
),
16335 objfile_name (cu
->per_objfile
->objfile
));
16338 if (fi
->current_variant_part
->processing_variant
)
16340 complaint (_("nested DW_TAG_variant seen "
16341 "- DIE at %s [in module %s]"),
16342 sect_offset_str (die
->sect_off
),
16343 objfile_name (cu
->per_objfile
->objfile
));
16347 scoped_restore save_processing_variant
16348 = make_scoped_restore (&fi
->current_variant_part
->processing_variant
,
16351 fi
->current_variant_part
->variants
.emplace_back ();
16352 variant_field
&variant
= fi
->current_variant_part
->variants
.back ();
16353 variant
.first_field
= fi
->fields
.size ();
16355 /* In a variant we want to get the discriminant and also add a
16356 field for our sole member child. */
16357 struct attribute
*discr
= dwarf2_attr (die
, DW_AT_discr_value
, cu
);
16358 if (discr
== nullptr || !discr
->form_is_constant ())
16360 discr
= dwarf2_attr (die
, DW_AT_discr_list
, cu
);
16361 if (discr
== nullptr || discr
->as_block ()->size
== 0)
16362 variant
.default_branch
= true;
16364 variant
.discr_list_data
= discr
->as_block ();
16367 variant
.discriminant_value
= discr
->constant_value (0);
16369 for (die_info
*variant_child
= die
->child
;
16370 variant_child
!= NULL
;
16371 variant_child
= variant_child
->sibling
)
16372 handle_struct_member_die (variant_child
, type
, fi
, template_args
, cu
);
16374 variant
.last_field
= fi
->fields
.size ();
16377 /* A helper for process_structure_scope that handles a single member
16381 handle_struct_member_die (struct die_info
*child_die
, struct type
*type
,
16382 struct field_info
*fi
,
16383 std::vector
<struct symbol
*> *template_args
,
16384 struct dwarf2_cu
*cu
)
16386 if (child_die
->tag
== DW_TAG_member
16387 || child_die
->tag
== DW_TAG_variable
)
16389 /* NOTE: carlton/2002-11-05: A C++ static data member
16390 should be a DW_TAG_member that is a declaration, but
16391 all versions of G++ as of this writing (so through at
16392 least 3.2.1) incorrectly generate DW_TAG_variable
16393 tags for them instead. */
16394 dwarf2_add_field (fi
, child_die
, cu
);
16396 else if (child_die
->tag
== DW_TAG_subprogram
)
16398 /* Rust doesn't have member functions in the C++ sense.
16399 However, it does emit ordinary functions as children
16400 of a struct DIE. */
16401 if (cu
->language
== language_rust
)
16402 read_func_scope (child_die
, cu
);
16405 /* C++ member function. */
16406 dwarf2_add_member_fn (fi
, child_die
, type
, cu
);
16409 else if (child_die
->tag
== DW_TAG_inheritance
)
16411 /* C++ base class field. */
16412 dwarf2_add_field (fi
, child_die
, cu
);
16414 else if (type_can_define_types (child_die
))
16415 dwarf2_add_type_defn (fi
, child_die
, cu
);
16416 else if (child_die
->tag
== DW_TAG_template_type_param
16417 || child_die
->tag
== DW_TAG_template_value_param
)
16419 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
16422 template_args
->push_back (arg
);
16424 else if (child_die
->tag
== DW_TAG_variant_part
)
16425 handle_variant_part (child_die
, type
, fi
, template_args
, cu
);
16426 else if (child_die
->tag
== DW_TAG_variant
)
16427 handle_variant (child_die
, type
, fi
, template_args
, cu
);
16430 /* Finish creating a structure or union type, including filling in
16431 its members and creating a symbol for it. */
16434 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
16436 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
16437 struct die_info
*child_die
;
16440 type
= get_die_type (die
, cu
);
16442 type
= read_structure_type (die
, cu
);
16444 bool has_template_parameters
= false;
16445 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
16447 struct field_info fi
;
16448 std::vector
<struct symbol
*> template_args
;
16450 child_die
= die
->child
;
16452 while (child_die
&& child_die
->tag
)
16454 handle_struct_member_die (child_die
, type
, &fi
, &template_args
, cu
);
16455 child_die
= child_die
->sibling
;
16458 /* Attach template arguments to type. */
16459 if (!template_args
.empty ())
16461 has_template_parameters
= true;
16462 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
16463 TYPE_N_TEMPLATE_ARGUMENTS (type
) = template_args
.size ();
16464 TYPE_TEMPLATE_ARGUMENTS (type
)
16465 = XOBNEWVEC (&objfile
->objfile_obstack
,
16467 TYPE_N_TEMPLATE_ARGUMENTS (type
));
16468 memcpy (TYPE_TEMPLATE_ARGUMENTS (type
),
16469 template_args
.data (),
16470 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
16471 * sizeof (struct symbol
*)));
16474 /* Attach fields and member functions to the type. */
16475 if (fi
.nfields () > 0)
16476 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
16477 if (!fi
.fnfieldlists
.empty ())
16479 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
16481 /* Get the type which refers to the base class (possibly this
16482 class itself) which contains the vtable pointer for the current
16483 class from the DW_AT_containing_type attribute. This use of
16484 DW_AT_containing_type is a GNU extension. */
16486 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
16488 struct type
*t
= die_containing_type (die
, cu
);
16490 set_type_vptr_basetype (type
, t
);
16495 /* Our own class provides vtbl ptr. */
16496 for (i
= t
->num_fields () - 1;
16497 i
>= TYPE_N_BASECLASSES (t
);
16500 const char *fieldname
= TYPE_FIELD_NAME (t
, i
);
16502 if (is_vtable_name (fieldname
, cu
))
16504 set_type_vptr_fieldno (type
, i
);
16509 /* Complain if virtual function table field not found. */
16510 if (i
< TYPE_N_BASECLASSES (t
))
16511 complaint (_("virtual function table pointer "
16512 "not found when defining class '%s'"),
16513 type
->name () ? type
->name () : "");
16517 set_type_vptr_fieldno (type
, TYPE_VPTR_FIELDNO (t
));
16520 else if (cu
->producer
16521 && startswith (cu
->producer
, "IBM(R) XL C/C++ Advanced Edition"))
16523 /* The IBM XLC compiler does not provide direct indication
16524 of the containing type, but the vtable pointer is
16525 always named __vfp. */
16529 for (i
= type
->num_fields () - 1;
16530 i
>= TYPE_N_BASECLASSES (type
);
16533 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
16535 set_type_vptr_fieldno (type
, i
);
16536 set_type_vptr_basetype (type
, type
);
16543 /* Copy fi.typedef_field_list linked list elements content into the
16544 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
16545 if (!fi
.typedef_field_list
.empty ())
16547 int count
= fi
.typedef_field_list
.size ();
16549 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
16550 TYPE_TYPEDEF_FIELD_ARRAY (type
)
16551 = ((struct decl_field
*)
16553 sizeof (TYPE_TYPEDEF_FIELD (type
, 0)) * count
));
16554 TYPE_TYPEDEF_FIELD_COUNT (type
) = count
;
16556 for (int i
= 0; i
< fi
.typedef_field_list
.size (); ++i
)
16557 TYPE_TYPEDEF_FIELD (type
, i
) = fi
.typedef_field_list
[i
];
16560 /* Copy fi.nested_types_list linked list elements content into the
16561 allocated array TYPE_NESTED_TYPES_ARRAY (type). */
16562 if (!fi
.nested_types_list
.empty () && cu
->language
!= language_ada
)
16564 int count
= fi
.nested_types_list
.size ();
16566 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
16567 TYPE_NESTED_TYPES_ARRAY (type
)
16568 = ((struct decl_field
*)
16569 TYPE_ALLOC (type
, sizeof (struct decl_field
) * count
));
16570 TYPE_NESTED_TYPES_COUNT (type
) = count
;
16572 for (int i
= 0; i
< fi
.nested_types_list
.size (); ++i
)
16573 TYPE_NESTED_TYPES_FIELD (type
, i
) = fi
.nested_types_list
[i
];
16577 quirk_gcc_member_function_pointer (type
, objfile
);
16578 if (cu
->language
== language_rust
&& die
->tag
== DW_TAG_union_type
)
16579 cu
->rust_unions
.push_back (type
);
16580 else if (cu
->language
== language_ada
)
16581 quirk_ada_thick_pointer_struct (die
, cu
, type
);
16583 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
16584 snapshots) has been known to create a die giving a declaration
16585 for a class that has, as a child, a die giving a definition for a
16586 nested class. So we have to process our children even if the
16587 current die is a declaration. Normally, of course, a declaration
16588 won't have any children at all. */
16590 child_die
= die
->child
;
16592 while (child_die
!= NULL
&& child_die
->tag
)
16594 if (child_die
->tag
== DW_TAG_member
16595 || child_die
->tag
== DW_TAG_variable
16596 || child_die
->tag
== DW_TAG_inheritance
16597 || child_die
->tag
== DW_TAG_template_value_param
16598 || child_die
->tag
== DW_TAG_template_type_param
)
16603 process_die (child_die
, cu
);
16605 child_die
= child_die
->sibling
;
16608 /* Do not consider external references. According to the DWARF standard,
16609 these DIEs are identified by the fact that they have no byte_size
16610 attribute, and a declaration attribute. */
16611 if (dwarf2_attr (die
, DW_AT_byte_size
, cu
) != NULL
16612 || !die_is_declaration (die
, cu
)
16613 || dwarf2_attr (die
, DW_AT_signature
, cu
) != NULL
)
16615 struct symbol
*sym
= new_symbol (die
, type
, cu
);
16617 if (has_template_parameters
)
16619 struct symtab
*symtab
;
16620 if (sym
!= nullptr)
16621 symtab
= symbol_symtab (sym
);
16622 else if (cu
->line_header
!= nullptr)
16624 /* Any related symtab will do. */
16626 = cu
->line_header
->file_names ()[0].symtab
;
16631 complaint (_("could not find suitable "
16632 "symtab for template parameter"
16633 " - DIE at %s [in module %s]"),
16634 sect_offset_str (die
->sect_off
),
16635 objfile_name (objfile
));
16638 if (symtab
!= nullptr)
16640 /* Make sure that the symtab is set on the new symbols.
16641 Even though they don't appear in this symtab directly,
16642 other parts of gdb assume that symbols do, and this is
16643 reasonably true. */
16644 for (int i
= 0; i
< TYPE_N_TEMPLATE_ARGUMENTS (type
); ++i
)
16645 symbol_set_symtab (TYPE_TEMPLATE_ARGUMENT (type
, i
), symtab
);
16651 /* Assuming DIE is an enumeration type, and TYPE is its associated
16652 type, update TYPE using some information only available in DIE's
16653 children. In particular, the fields are computed. */
16656 update_enumeration_type_from_children (struct die_info
*die
,
16658 struct dwarf2_cu
*cu
)
16660 struct die_info
*child_die
;
16661 int unsigned_enum
= 1;
16664 auto_obstack obstack
;
16665 std::vector
<struct field
> fields
;
16667 for (child_die
= die
->child
;
16668 child_die
!= NULL
&& child_die
->tag
;
16669 child_die
= child_die
->sibling
)
16671 struct attribute
*attr
;
16673 const gdb_byte
*bytes
;
16674 struct dwarf2_locexpr_baton
*baton
;
16677 if (child_die
->tag
!= DW_TAG_enumerator
)
16680 attr
= dwarf2_attr (child_die
, DW_AT_const_value
, cu
);
16684 name
= dwarf2_name (child_die
, cu
);
16686 name
= "<anonymous enumerator>";
16688 dwarf2_const_value_attr (attr
, type
, name
, &obstack
, cu
,
16689 &value
, &bytes
, &baton
);
16697 if (count_one_bits_ll (value
) >= 2)
16701 fields
.emplace_back ();
16702 struct field
&field
= fields
.back ();
16703 FIELD_NAME (field
) = dwarf2_physname (name
, child_die
, cu
);
16704 SET_FIELD_ENUMVAL (field
, value
);
16707 if (!fields
.empty ())
16709 type
->set_num_fields (fields
.size ());
16712 TYPE_ALLOC (type
, sizeof (struct field
) * fields
.size ()));
16713 memcpy (type
->fields (), fields
.data (),
16714 sizeof (struct field
) * fields
.size ());
16718 type
->set_is_unsigned (true);
16721 TYPE_FLAG_ENUM (type
) = 1;
16724 /* Given a DW_AT_enumeration_type die, set its type. We do not
16725 complete the type's fields yet, or create any symbols. */
16727 static struct type
*
16728 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16730 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
16732 struct attribute
*attr
;
16735 /* If the definition of this type lives in .debug_types, read that type.
16736 Don't follow DW_AT_specification though, that will take us back up
16737 the chain and we want to go down. */
16738 attr
= die
->attr (DW_AT_signature
);
16739 if (attr
!= nullptr)
16741 type
= get_DW_AT_signature_type (die
, attr
, cu
);
16743 /* The type's CU may not be the same as CU.
16744 Ensure TYPE is recorded with CU in die_type_hash. */
16745 return set_die_type (die
, type
, cu
);
16748 type
= alloc_type (objfile
);
16750 type
->set_code (TYPE_CODE_ENUM
);
16751 name
= dwarf2_full_name (NULL
, die
, cu
);
16753 type
->set_name (name
);
16755 attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
16758 struct type
*underlying_type
= die_type (die
, cu
);
16760 TYPE_TARGET_TYPE (type
) = underlying_type
;
16763 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16764 if (attr
!= nullptr)
16766 TYPE_LENGTH (type
) = attr
->constant_value (0);
16770 TYPE_LENGTH (type
) = 0;
16773 maybe_set_alignment (cu
, die
, type
);
16775 /* The enumeration DIE can be incomplete. In Ada, any type can be
16776 declared as private in the package spec, and then defined only
16777 inside the package body. Such types are known as Taft Amendment
16778 Types. When another package uses such a type, an incomplete DIE
16779 may be generated by the compiler. */
16780 if (die_is_declaration (die
, cu
))
16781 type
->set_is_stub (true);
16783 /* If this type has an underlying type that is not a stub, then we
16784 may use its attributes. We always use the "unsigned" attribute
16785 in this situation, because ordinarily we guess whether the type
16786 is unsigned -- but the guess can be wrong and the underlying type
16787 can tell us the reality. However, we defer to a local size
16788 attribute if one exists, because this lets the compiler override
16789 the underlying type if needed. */
16790 if (TYPE_TARGET_TYPE (type
) != NULL
&& !TYPE_TARGET_TYPE (type
)->is_stub ())
16792 struct type
*underlying_type
= TYPE_TARGET_TYPE (type
);
16793 underlying_type
= check_typedef (underlying_type
);
16795 type
->set_is_unsigned (underlying_type
->is_unsigned ());
16797 if (TYPE_LENGTH (type
) == 0)
16798 TYPE_LENGTH (type
) = TYPE_LENGTH (underlying_type
);
16800 if (TYPE_RAW_ALIGN (type
) == 0
16801 && TYPE_RAW_ALIGN (underlying_type
) != 0)
16802 set_type_align (type
, TYPE_RAW_ALIGN (underlying_type
));
16805 TYPE_DECLARED_CLASS (type
) = dwarf2_flag_true_p (die
, DW_AT_enum_class
, cu
);
16807 set_die_type (die
, type
, cu
);
16809 /* Finish the creation of this type by using the enum's children.
16810 Note that, as usual, this must come after set_die_type to avoid
16811 infinite recursion when trying to compute the names of the
16813 update_enumeration_type_from_children (die
, type
, cu
);
16818 /* Given a pointer to a die which begins an enumeration, process all
16819 the dies that define the members of the enumeration, and create the
16820 symbol for the enumeration type.
16822 NOTE: We reverse the order of the element list. */
16825 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
16827 struct type
*this_type
;
16829 this_type
= get_die_type (die
, cu
);
16830 if (this_type
== NULL
)
16831 this_type
= read_enumeration_type (die
, cu
);
16833 if (die
->child
!= NULL
)
16835 struct die_info
*child_die
;
16838 child_die
= die
->child
;
16839 while (child_die
&& child_die
->tag
)
16841 if (child_die
->tag
!= DW_TAG_enumerator
)
16843 process_die (child_die
, cu
);
16847 name
= dwarf2_name (child_die
, cu
);
16849 new_symbol (child_die
, this_type
, cu
);
16852 child_die
= child_die
->sibling
;
16856 /* If we are reading an enum from a .debug_types unit, and the enum
16857 is a declaration, and the enum is not the signatured type in the
16858 unit, then we do not want to add a symbol for it. Adding a
16859 symbol would in some cases obscure the true definition of the
16860 enum, giving users an incomplete type when the definition is
16861 actually available. Note that we do not want to do this for all
16862 enums which are just declarations, because C++0x allows forward
16863 enum declarations. */
16864 if (cu
->per_cu
->is_debug_types
16865 && die_is_declaration (die
, cu
))
16867 struct signatured_type
*sig_type
;
16869 sig_type
= (struct signatured_type
*) cu
->per_cu
;
16870 gdb_assert (to_underlying (sig_type
->type_offset_in_section
) != 0);
16871 if (sig_type
->type_offset_in_section
!= die
->sect_off
)
16875 new_symbol (die
, this_type
, cu
);
16878 /* Helper function for quirk_ada_thick_pointer that examines a bounds
16879 expression for an index type and finds the corresponding field
16880 offset in the hidden "P_BOUNDS" structure. Returns true on success
16881 and updates *FIELD, false if it fails to recognize an
16885 recognize_bound_expression (struct die_info
*die
, enum dwarf_attribute name
,
16886 int *bounds_offset
, struct field
*field
,
16887 struct dwarf2_cu
*cu
)
16889 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
16890 if (attr
== nullptr || !attr
->form_is_block ())
16893 const struct dwarf_block
*block
= attr
->as_block ();
16894 const gdb_byte
*start
= block
->data
;
16895 const gdb_byte
*end
= block
->data
+ block
->size
;
16897 /* The expression to recognize generally looks like:
16899 (DW_OP_push_object_address; DW_OP_plus_uconst: 8; DW_OP_deref;
16900 DW_OP_plus_uconst: 4; DW_OP_deref_size: 4)
16902 However, the second "plus_uconst" may be missing:
16904 (DW_OP_push_object_address; DW_OP_plus_uconst: 8; DW_OP_deref;
16905 DW_OP_deref_size: 4)
16907 This happens when the field is at the start of the structure.
16909 Also, the final deref may not be sized:
16911 (DW_OP_push_object_address; DW_OP_plus_uconst: 4; DW_OP_deref;
16914 This happens when the size of the index type happens to be the
16915 same as the architecture's word size. This can occur with or
16916 without the second plus_uconst. */
16918 if (end
- start
< 2)
16920 if (*start
++ != DW_OP_push_object_address
)
16922 if (*start
++ != DW_OP_plus_uconst
)
16925 uint64_t this_bound_off
;
16926 start
= gdb_read_uleb128 (start
, end
, &this_bound_off
);
16927 if (start
== nullptr || (int) this_bound_off
!= this_bound_off
)
16929 /* Update *BOUNDS_OFFSET if needed, or alternatively verify that it
16930 is consistent among all bounds. */
16931 if (*bounds_offset
== -1)
16932 *bounds_offset
= this_bound_off
;
16933 else if (*bounds_offset
!= this_bound_off
)
16936 if (start
== end
|| *start
++ != DW_OP_deref
)
16942 else if (*start
== DW_OP_deref_size
|| *start
== DW_OP_deref
)
16944 /* This means an offset of 0. */
16946 else if (*start
++ != DW_OP_plus_uconst
)
16950 /* The size is the parameter to DW_OP_plus_uconst. */
16952 start
= gdb_read_uleb128 (start
, end
, &val
);
16953 if (start
== nullptr)
16955 if ((int) val
!= val
)
16964 if (*start
== DW_OP_deref_size
)
16966 start
= gdb_read_uleb128 (start
+ 1, end
, &size
);
16967 if (start
== nullptr)
16970 else if (*start
== DW_OP_deref
)
16972 size
= cu
->header
.addr_size
;
16978 SET_FIELD_BITPOS (*field
, 8 * offset
);
16979 if (size
!= TYPE_LENGTH (field
->type ()))
16980 FIELD_BITSIZE (*field
) = 8 * size
;
16985 /* With -fgnat-encodings=minimal, gcc will emit some unusual DWARF for
16986 some kinds of Ada arrays:
16988 <1><11db>: Abbrev Number: 7 (DW_TAG_array_type)
16989 <11dc> DW_AT_name : (indirect string, offset: 0x1bb8): string
16990 <11e0> DW_AT_data_location: 2 byte block: 97 6
16991 (DW_OP_push_object_address; DW_OP_deref)
16992 <11e3> DW_AT_type : <0x1173>
16993 <11e7> DW_AT_sibling : <0x1201>
16994 <2><11eb>: Abbrev Number: 8 (DW_TAG_subrange_type)
16995 <11ec> DW_AT_type : <0x1206>
16996 <11f0> DW_AT_lower_bound : 6 byte block: 97 23 8 6 94 4
16997 (DW_OP_push_object_address; DW_OP_plus_uconst: 8; DW_OP_deref;
16998 DW_OP_deref_size: 4)
16999 <11f7> DW_AT_upper_bound : 8 byte block: 97 23 8 6 23 4 94 4
17000 (DW_OP_push_object_address; DW_OP_plus_uconst: 8; DW_OP_deref;
17001 DW_OP_plus_uconst: 4; DW_OP_deref_size: 4)
17003 This actually represents a "thick pointer", which is a structure
17004 with two elements: one that is a pointer to the array data, and one
17005 that is a pointer to another structure; this second structure holds
17008 This returns a new type on success, or nullptr if this didn't
17009 recognize the type. */
17011 static struct type
*
17012 quirk_ada_thick_pointer (struct die_info
*die
, struct dwarf2_cu
*cu
,
17015 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_data_location
, cu
);
17016 /* So far we've only seen this with block form. */
17017 if (attr
== nullptr || !attr
->form_is_block ())
17020 /* Note that this will fail if the structure layout is changed by
17021 the compiler. However, we have no good way to recognize some
17022 other layout, because we don't know what expression the compiler
17023 might choose to emit should this happen. */
17024 struct dwarf_block
*blk
= attr
->as_block ();
17026 || blk
->data
[0] != DW_OP_push_object_address
17027 || blk
->data
[1] != DW_OP_deref
)
17030 int bounds_offset
= -1;
17031 int max_align
= -1;
17032 std::vector
<struct field
> range_fields
;
17033 for (struct die_info
*child_die
= die
->child
;
17035 child_die
= child_die
->sibling
)
17037 if (child_die
->tag
== DW_TAG_subrange_type
)
17039 struct type
*underlying
= read_subrange_index_type (child_die
, cu
);
17041 int this_align
= type_align (underlying
);
17042 if (this_align
> max_align
)
17043 max_align
= this_align
;
17045 range_fields
.emplace_back ();
17046 range_fields
.emplace_back ();
17048 struct field
&lower
= range_fields
[range_fields
.size () - 2];
17049 struct field
&upper
= range_fields
[range_fields
.size () - 1];
17051 lower
.set_type (underlying
);
17052 FIELD_ARTIFICIAL (lower
) = 1;
17054 upper
.set_type (underlying
);
17055 FIELD_ARTIFICIAL (upper
) = 1;
17057 if (!recognize_bound_expression (child_die
, DW_AT_lower_bound
,
17058 &bounds_offset
, &lower
, cu
)
17059 || !recognize_bound_expression (child_die
, DW_AT_upper_bound
,
17060 &bounds_offset
, &upper
, cu
))
17065 /* This shouldn't really happen, but double-check that we found
17066 where the bounds are stored. */
17067 if (bounds_offset
== -1)
17070 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17071 for (int i
= 0; i
< range_fields
.size (); i
+= 2)
17075 /* Set the name of each field in the bounds. */
17076 xsnprintf (name
, sizeof (name
), "LB%d", i
/ 2);
17077 FIELD_NAME (range_fields
[i
]) = objfile
->intern (name
);
17078 xsnprintf (name
, sizeof (name
), "UB%d", i
/ 2);
17079 FIELD_NAME (range_fields
[i
+ 1]) = objfile
->intern (name
);
17082 struct type
*bounds
= alloc_type (objfile
);
17083 bounds
->set_code (TYPE_CODE_STRUCT
);
17085 bounds
->set_num_fields (range_fields
.size ());
17087 ((struct field
*) TYPE_ALLOC (bounds
, (bounds
->num_fields ()
17088 * sizeof (struct field
))));
17089 memcpy (bounds
->fields (), range_fields
.data (),
17090 bounds
->num_fields () * sizeof (struct field
));
17092 int last_fieldno
= range_fields
.size () - 1;
17093 int bounds_size
= (TYPE_FIELD_BITPOS (bounds
, last_fieldno
) / 8
17094 + TYPE_LENGTH (bounds
->field (last_fieldno
).type ()));
17095 TYPE_LENGTH (bounds
) = align_up (bounds_size
, max_align
);
17097 /* Rewrite the existing array type in place. Specifically, we
17098 remove any dynamic properties we might have read, and we replace
17099 the index types. */
17100 struct type
*iter
= type
;
17101 for (int i
= 0; i
< range_fields
.size (); i
+= 2)
17103 gdb_assert (iter
->code () == TYPE_CODE_ARRAY
);
17104 iter
->main_type
->dyn_prop_list
= nullptr;
17105 iter
->set_index_type
17106 (create_static_range_type (NULL
, bounds
->field (i
).type (), 1, 0));
17107 iter
= TYPE_TARGET_TYPE (iter
);
17110 struct type
*result
= alloc_type (objfile
);
17111 result
->set_code (TYPE_CODE_STRUCT
);
17113 result
->set_num_fields (2);
17115 ((struct field
*) TYPE_ZALLOC (result
, (result
->num_fields ()
17116 * sizeof (struct field
))));
17118 /* The names are chosen to coincide with what the compiler does with
17119 -fgnat-encodings=all, which the Ada code in gdb already
17121 TYPE_FIELD_NAME (result
, 0) = "P_ARRAY";
17122 result
->field (0).set_type (lookup_pointer_type (type
));
17124 TYPE_FIELD_NAME (result
, 1) = "P_BOUNDS";
17125 result
->field (1).set_type (lookup_pointer_type (bounds
));
17126 SET_FIELD_BITPOS (result
->field (1), 8 * bounds_offset
);
17128 result
->set_name (type
->name ());
17129 TYPE_LENGTH (result
) = (TYPE_LENGTH (result
->field (0).type ())
17130 + TYPE_LENGTH (result
->field (1).type ()));
17135 /* Extract all information from a DW_TAG_array_type DIE and put it in
17136 the DIE's type field. For now, this only handles one dimensional
17139 static struct type
*
17140 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17142 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17143 struct die_info
*child_die
;
17145 struct type
*element_type
, *range_type
, *index_type
;
17146 struct attribute
*attr
;
17148 struct dynamic_prop
*byte_stride_prop
= NULL
;
17149 unsigned int bit_stride
= 0;
17151 element_type
= die_type (die
, cu
);
17153 /* The die_type call above may have already set the type for this DIE. */
17154 type
= get_die_type (die
, cu
);
17158 attr
= dwarf2_attr (die
, DW_AT_byte_stride
, cu
);
17162 struct type
*prop_type
= cu
->addr_sized_int_type (false);
17165 = (struct dynamic_prop
*) alloca (sizeof (struct dynamic_prop
));
17166 stride_ok
= attr_to_dynamic_prop (attr
, die
, cu
, byte_stride_prop
,
17170 complaint (_("unable to read array DW_AT_byte_stride "
17171 " - DIE at %s [in module %s]"),
17172 sect_offset_str (die
->sect_off
),
17173 objfile_name (cu
->per_objfile
->objfile
));
17174 /* Ignore this attribute. We will likely not be able to print
17175 arrays of this type correctly, but there is little we can do
17176 to help if we cannot read the attribute's value. */
17177 byte_stride_prop
= NULL
;
17181 attr
= dwarf2_attr (die
, DW_AT_bit_stride
, cu
);
17183 bit_stride
= attr
->constant_value (0);
17185 /* Irix 6.2 native cc creates array types without children for
17186 arrays with unspecified length. */
17187 if (die
->child
== NULL
)
17189 index_type
= objfile_type (objfile
)->builtin_int
;
17190 range_type
= create_static_range_type (NULL
, index_type
, 0, -1);
17191 type
= create_array_type_with_stride (NULL
, element_type
, range_type
,
17192 byte_stride_prop
, bit_stride
);
17193 return set_die_type (die
, type
, cu
);
17196 std::vector
<struct type
*> range_types
;
17197 child_die
= die
->child
;
17198 while (child_die
&& child_die
->tag
)
17200 if (child_die
->tag
== DW_TAG_subrange_type
)
17202 struct type
*child_type
= read_type_die (child_die
, cu
);
17204 if (child_type
!= NULL
)
17206 /* The range type was succesfully read. Save it for the
17207 array type creation. */
17208 range_types
.push_back (child_type
);
17211 child_die
= child_die
->sibling
;
17214 /* Dwarf2 dimensions are output from left to right, create the
17215 necessary array types in backwards order. */
17217 type
= element_type
;
17219 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
17223 while (i
< range_types
.size ())
17225 type
= create_array_type_with_stride (NULL
, type
, range_types
[i
++],
17226 byte_stride_prop
, bit_stride
);
17228 byte_stride_prop
= nullptr;
17233 size_t ndim
= range_types
.size ();
17236 type
= create_array_type_with_stride (NULL
, type
, range_types
[ndim
],
17237 byte_stride_prop
, bit_stride
);
17239 byte_stride_prop
= nullptr;
17243 /* Understand Dwarf2 support for vector types (like they occur on
17244 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
17245 array type. This is not part of the Dwarf2/3 standard yet, but a
17246 custom vendor extension. The main difference between a regular
17247 array and the vector variant is that vectors are passed by value
17249 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
17250 if (attr
!= nullptr)
17251 make_vector_type (type
);
17253 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
17254 implementation may choose to implement triple vectors using this
17256 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17257 if (attr
!= nullptr && attr
->form_is_unsigned ())
17259 if (attr
->as_unsigned () >= TYPE_LENGTH (type
))
17260 TYPE_LENGTH (type
) = attr
->as_unsigned ();
17262 complaint (_("DW_AT_byte_size for array type smaller "
17263 "than the total size of elements"));
17266 name
= dwarf2_name (die
, cu
);
17268 type
->set_name (name
);
17270 maybe_set_alignment (cu
, die
, type
);
17272 struct type
*replacement_type
= nullptr;
17273 if (cu
->language
== language_ada
)
17275 replacement_type
= quirk_ada_thick_pointer (die
, cu
, type
);
17276 if (replacement_type
!= nullptr)
17277 type
= replacement_type
;
17280 /* Install the type in the die. */
17281 set_die_type (die
, type
, cu
, replacement_type
!= nullptr);
17283 /* set_die_type should be already done. */
17284 set_descriptive_type (type
, die
, cu
);
17289 static enum dwarf_array_dim_ordering
17290 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
17292 struct attribute
*attr
;
17294 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
17296 if (attr
!= nullptr)
17298 LONGEST val
= attr
->constant_value (-1);
17299 if (val
== DW_ORD_row_major
|| val
== DW_ORD_col_major
)
17300 return (enum dwarf_array_dim_ordering
) val
;
17303 /* GNU F77 is a special case, as at 08/2004 array type info is the
17304 opposite order to the dwarf2 specification, but data is still
17305 laid out as per normal fortran.
17307 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
17308 version checking. */
17310 if (cu
->language
== language_fortran
17311 && cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
17313 return DW_ORD_row_major
;
17316 switch (cu
->language_defn
->array_ordering ())
17318 case array_column_major
:
17319 return DW_ORD_col_major
;
17320 case array_row_major
:
17322 return DW_ORD_row_major
;
17326 /* Extract all information from a DW_TAG_set_type DIE and put it in
17327 the DIE's type field. */
17329 static struct type
*
17330 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17332 struct type
*domain_type
, *set_type
;
17333 struct attribute
*attr
;
17335 domain_type
= die_type (die
, cu
);
17337 /* The die_type call above may have already set the type for this DIE. */
17338 set_type
= get_die_type (die
, cu
);
17342 set_type
= create_set_type (NULL
, domain_type
);
17344 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17345 if (attr
!= nullptr && attr
->form_is_unsigned ())
17346 TYPE_LENGTH (set_type
) = attr
->as_unsigned ();
17348 maybe_set_alignment (cu
, die
, set_type
);
17350 return set_die_type (die
, set_type
, cu
);
17353 /* A helper for read_common_block that creates a locexpr baton.
17354 SYM is the symbol which we are marking as computed.
17355 COMMON_DIE is the DIE for the common block.
17356 COMMON_LOC is the location expression attribute for the common
17358 MEMBER_LOC is the location expression attribute for the particular
17359 member of the common block that we are processing.
17360 CU is the CU from which the above come. */
17363 mark_common_block_symbol_computed (struct symbol
*sym
,
17364 struct die_info
*common_die
,
17365 struct attribute
*common_loc
,
17366 struct attribute
*member_loc
,
17367 struct dwarf2_cu
*cu
)
17369 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
17370 struct objfile
*objfile
= per_objfile
->objfile
;
17371 struct dwarf2_locexpr_baton
*baton
;
17373 unsigned int cu_off
;
17374 enum bfd_endian byte_order
= gdbarch_byte_order (objfile
->arch ());
17375 LONGEST offset
= 0;
17377 gdb_assert (common_loc
&& member_loc
);
17378 gdb_assert (common_loc
->form_is_block ());
17379 gdb_assert (member_loc
->form_is_block ()
17380 || member_loc
->form_is_constant ());
17382 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
17383 baton
->per_objfile
= per_objfile
;
17384 baton
->per_cu
= cu
->per_cu
;
17385 gdb_assert (baton
->per_cu
);
17387 baton
->size
= 5 /* DW_OP_call4 */ + 1 /* DW_OP_plus */;
17389 if (member_loc
->form_is_constant ())
17391 offset
= member_loc
->constant_value (0);
17392 baton
->size
+= 1 /* DW_OP_addr */ + cu
->header
.addr_size
;
17395 baton
->size
+= member_loc
->as_block ()->size
;
17397 ptr
= (gdb_byte
*) obstack_alloc (&objfile
->objfile_obstack
, baton
->size
);
17400 *ptr
++ = DW_OP_call4
;
17401 cu_off
= common_die
->sect_off
- cu
->per_cu
->sect_off
;
17402 store_unsigned_integer (ptr
, 4, byte_order
, cu_off
);
17405 if (member_loc
->form_is_constant ())
17407 *ptr
++ = DW_OP_addr
;
17408 store_unsigned_integer (ptr
, cu
->header
.addr_size
, byte_order
, offset
);
17409 ptr
+= cu
->header
.addr_size
;
17413 /* We have to copy the data here, because DW_OP_call4 will only
17414 use a DW_AT_location attribute. */
17415 struct dwarf_block
*block
= member_loc
->as_block ();
17416 memcpy (ptr
, block
->data
, block
->size
);
17417 ptr
+= block
->size
;
17420 *ptr
++ = DW_OP_plus
;
17421 gdb_assert (ptr
- baton
->data
== baton
->size
);
17423 SYMBOL_LOCATION_BATON (sym
) = baton
;
17424 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
17427 /* Create appropriate locally-scoped variables for all the
17428 DW_TAG_common_block entries. Also create a struct common_block
17429 listing all such variables for `info common'. COMMON_BLOCK_DOMAIN
17430 is used to separate the common blocks name namespace from regular
17434 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
17436 struct attribute
*attr
;
17438 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
17439 if (attr
!= nullptr)
17441 /* Support the .debug_loc offsets. */
17442 if (attr
->form_is_block ())
17446 else if (attr
->form_is_section_offset ())
17448 dwarf2_complex_location_expr_complaint ();
17453 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
17454 "common block member");
17459 if (die
->child
!= NULL
)
17461 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17462 struct die_info
*child_die
;
17463 size_t n_entries
= 0, size
;
17464 struct common_block
*common_block
;
17465 struct symbol
*sym
;
17467 for (child_die
= die
->child
;
17468 child_die
&& child_die
->tag
;
17469 child_die
= child_die
->sibling
)
17472 size
= (sizeof (struct common_block
)
17473 + (n_entries
- 1) * sizeof (struct symbol
*));
17475 = (struct common_block
*) obstack_alloc (&objfile
->objfile_obstack
,
17477 memset (common_block
->contents
, 0, n_entries
* sizeof (struct symbol
*));
17478 common_block
->n_entries
= 0;
17480 for (child_die
= die
->child
;
17481 child_die
&& child_die
->tag
;
17482 child_die
= child_die
->sibling
)
17484 /* Create the symbol in the DW_TAG_common_block block in the current
17486 sym
= new_symbol (child_die
, NULL
, cu
);
17489 struct attribute
*member_loc
;
17491 common_block
->contents
[common_block
->n_entries
++] = sym
;
17493 member_loc
= dwarf2_attr (child_die
, DW_AT_data_member_location
,
17497 /* GDB has handled this for a long time, but it is
17498 not specified by DWARF. It seems to have been
17499 emitted by gfortran at least as recently as:
17500 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=23057. */
17501 complaint (_("Variable in common block has "
17502 "DW_AT_data_member_location "
17503 "- DIE at %s [in module %s]"),
17504 sect_offset_str (child_die
->sect_off
),
17505 objfile_name (objfile
));
17507 if (member_loc
->form_is_section_offset ())
17508 dwarf2_complex_location_expr_complaint ();
17509 else if (member_loc
->form_is_constant ()
17510 || member_loc
->form_is_block ())
17512 if (attr
!= nullptr)
17513 mark_common_block_symbol_computed (sym
, die
, attr
,
17517 dwarf2_complex_location_expr_complaint ();
17522 sym
= new_symbol (die
, objfile_type (objfile
)->builtin_void
, cu
);
17523 SYMBOL_VALUE_COMMON_BLOCK (sym
) = common_block
;
17527 /* Create a type for a C++ namespace. */
17529 static struct type
*
17530 read_namespace_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17532 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17533 const char *previous_prefix
, *name
;
17537 /* For extensions, reuse the type of the original namespace. */
17538 if (dwarf2_attr (die
, DW_AT_extension
, cu
) != NULL
)
17540 struct die_info
*ext_die
;
17541 struct dwarf2_cu
*ext_cu
= cu
;
17543 ext_die
= dwarf2_extension (die
, &ext_cu
);
17544 type
= read_type_die (ext_die
, ext_cu
);
17546 /* EXT_CU may not be the same as CU.
17547 Ensure TYPE is recorded with CU in die_type_hash. */
17548 return set_die_type (die
, type
, cu
);
17551 name
= namespace_name (die
, &is_anonymous
, cu
);
17553 /* Now build the name of the current namespace. */
17555 previous_prefix
= determine_prefix (die
, cu
);
17556 if (previous_prefix
[0] != '\0')
17557 name
= typename_concat (&objfile
->objfile_obstack
,
17558 previous_prefix
, name
, 0, cu
);
17560 /* Create the type. */
17561 type
= init_type (objfile
, TYPE_CODE_NAMESPACE
, 0, name
);
17563 return set_die_type (die
, type
, cu
);
17566 /* Read a namespace scope. */
17569 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
17571 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17574 /* Add a symbol associated to this if we haven't seen the namespace
17575 before. Also, add a using directive if it's an anonymous
17578 if (dwarf2_attr (die
, DW_AT_extension
, cu
) == NULL
)
17582 type
= read_type_die (die
, cu
);
17583 new_symbol (die
, type
, cu
);
17585 namespace_name (die
, &is_anonymous
, cu
);
17588 const char *previous_prefix
= determine_prefix (die
, cu
);
17590 std::vector
<const char *> excludes
;
17591 add_using_directive (using_directives (cu
),
17592 previous_prefix
, type
->name (), NULL
,
17593 NULL
, excludes
, 0, &objfile
->objfile_obstack
);
17597 if (die
->child
!= NULL
)
17599 struct die_info
*child_die
= die
->child
;
17601 while (child_die
&& child_die
->tag
)
17603 process_die (child_die
, cu
);
17604 child_die
= child_die
->sibling
;
17609 /* Read a Fortran module as type. This DIE can be only a declaration used for
17610 imported module. Still we need that type as local Fortran "use ... only"
17611 declaration imports depend on the created type in determine_prefix. */
17613 static struct type
*
17614 read_module_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17616 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17617 const char *module_name
;
17620 module_name
= dwarf2_name (die
, cu
);
17621 type
= init_type (objfile
, TYPE_CODE_MODULE
, 0, module_name
);
17623 return set_die_type (die
, type
, cu
);
17626 /* Read a Fortran module. */
17629 read_module (struct die_info
*die
, struct dwarf2_cu
*cu
)
17631 struct die_info
*child_die
= die
->child
;
17634 type
= read_type_die (die
, cu
);
17635 new_symbol (die
, type
, cu
);
17637 while (child_die
&& child_die
->tag
)
17639 process_die (child_die
, cu
);
17640 child_die
= child_die
->sibling
;
17644 /* Return the name of the namespace represented by DIE. Set
17645 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
17648 static const char *
17649 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
17651 struct die_info
*current_die
;
17652 const char *name
= NULL
;
17654 /* Loop through the extensions until we find a name. */
17656 for (current_die
= die
;
17657 current_die
!= NULL
;
17658 current_die
= dwarf2_extension (die
, &cu
))
17660 /* We don't use dwarf2_name here so that we can detect the absence
17661 of a name -> anonymous namespace. */
17662 name
= dwarf2_string_attr (die
, DW_AT_name
, cu
);
17668 /* Is it an anonymous namespace? */
17670 *is_anonymous
= (name
== NULL
);
17672 name
= CP_ANONYMOUS_NAMESPACE_STR
;
17677 /* Extract all information from a DW_TAG_pointer_type DIE and add to
17678 the user defined type vector. */
17680 static struct type
*
17681 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17683 struct gdbarch
*gdbarch
= cu
->per_objfile
->objfile
->arch ();
17684 struct comp_unit_head
*cu_header
= &cu
->header
;
17686 struct attribute
*attr_byte_size
;
17687 struct attribute
*attr_address_class
;
17688 int byte_size
, addr_class
;
17689 struct type
*target_type
;
17691 target_type
= die_type (die
, cu
);
17693 /* The die_type call above may have already set the type for this DIE. */
17694 type
= get_die_type (die
, cu
);
17698 type
= lookup_pointer_type (target_type
);
17700 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17701 if (attr_byte_size
)
17702 byte_size
= attr_byte_size
->constant_value (cu_header
->addr_size
);
17704 byte_size
= cu_header
->addr_size
;
17706 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
17707 if (attr_address_class
)
17708 addr_class
= attr_address_class
->constant_value (DW_ADDR_none
);
17710 addr_class
= DW_ADDR_none
;
17712 ULONGEST alignment
= get_alignment (cu
, die
);
17714 /* If the pointer size, alignment, or address class is different
17715 than the default, create a type variant marked as such and set
17716 the length accordingly. */
17717 if (TYPE_LENGTH (type
) != byte_size
17718 || (alignment
!= 0 && TYPE_RAW_ALIGN (type
) != 0
17719 && alignment
!= TYPE_RAW_ALIGN (type
))
17720 || addr_class
!= DW_ADDR_none
)
17722 if (gdbarch_address_class_type_flags_p (gdbarch
))
17724 type_instance_flags type_flags
17725 = gdbarch_address_class_type_flags (gdbarch
, byte_size
,
17727 gdb_assert ((type_flags
& ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
17729 type
= make_type_with_address_space (type
, type_flags
);
17731 else if (TYPE_LENGTH (type
) != byte_size
)
17733 complaint (_("invalid pointer size %d"), byte_size
);
17735 else if (TYPE_RAW_ALIGN (type
) != alignment
)
17737 complaint (_("Invalid DW_AT_alignment"
17738 " - DIE at %s [in module %s]"),
17739 sect_offset_str (die
->sect_off
),
17740 objfile_name (cu
->per_objfile
->objfile
));
17744 /* Should we also complain about unhandled address classes? */
17748 TYPE_LENGTH (type
) = byte_size
;
17749 set_type_align (type
, alignment
);
17750 return set_die_type (die
, type
, cu
);
17753 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
17754 the user defined type vector. */
17756 static struct type
*
17757 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17760 struct type
*to_type
;
17761 struct type
*domain
;
17763 to_type
= die_type (die
, cu
);
17764 domain
= die_containing_type (die
, cu
);
17766 /* The calls above may have already set the type for this DIE. */
17767 type
= get_die_type (die
, cu
);
17771 if (check_typedef (to_type
)->code () == TYPE_CODE_METHOD
)
17772 type
= lookup_methodptr_type (to_type
);
17773 else if (check_typedef (to_type
)->code () == TYPE_CODE_FUNC
)
17775 struct type
*new_type
= alloc_type (cu
->per_objfile
->objfile
);
17777 smash_to_method_type (new_type
, domain
, TYPE_TARGET_TYPE (to_type
),
17778 to_type
->fields (), to_type
->num_fields (),
17779 to_type
->has_varargs ());
17780 type
= lookup_methodptr_type (new_type
);
17783 type
= lookup_memberptr_type (to_type
, domain
);
17785 return set_die_type (die
, type
, cu
);
17788 /* Extract all information from a DW_TAG_{rvalue_,}reference_type DIE and add to
17789 the user defined type vector. */
17791 static struct type
*
17792 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
,
17793 enum type_code refcode
)
17795 struct comp_unit_head
*cu_header
= &cu
->header
;
17796 struct type
*type
, *target_type
;
17797 struct attribute
*attr
;
17799 gdb_assert (refcode
== TYPE_CODE_REF
|| refcode
== TYPE_CODE_RVALUE_REF
);
17801 target_type
= die_type (die
, cu
);
17803 /* The die_type call above may have already set the type for this DIE. */
17804 type
= get_die_type (die
, cu
);
17808 type
= lookup_reference_type (target_type
, refcode
);
17809 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17810 if (attr
!= nullptr)
17812 TYPE_LENGTH (type
) = attr
->constant_value (cu_header
->addr_size
);
17816 TYPE_LENGTH (type
) = cu_header
->addr_size
;
17818 maybe_set_alignment (cu
, die
, type
);
17819 return set_die_type (die
, type
, cu
);
17822 /* Add the given cv-qualifiers to the element type of the array. GCC
17823 outputs DWARF type qualifiers that apply to an array, not the
17824 element type. But GDB relies on the array element type to carry
17825 the cv-qualifiers. This mimics section 6.7.3 of the C99
17828 static struct type
*
17829 add_array_cv_type (struct die_info
*die
, struct dwarf2_cu
*cu
,
17830 struct type
*base_type
, int cnst
, int voltl
)
17832 struct type
*el_type
, *inner_array
;
17834 base_type
= copy_type (base_type
);
17835 inner_array
= base_type
;
17837 while (TYPE_TARGET_TYPE (inner_array
)->code () == TYPE_CODE_ARRAY
)
17839 TYPE_TARGET_TYPE (inner_array
) =
17840 copy_type (TYPE_TARGET_TYPE (inner_array
));
17841 inner_array
= TYPE_TARGET_TYPE (inner_array
);
17844 el_type
= TYPE_TARGET_TYPE (inner_array
);
17845 cnst
|= TYPE_CONST (el_type
);
17846 voltl
|= TYPE_VOLATILE (el_type
);
17847 TYPE_TARGET_TYPE (inner_array
) = make_cv_type (cnst
, voltl
, el_type
, NULL
);
17849 return set_die_type (die
, base_type
, cu
);
17852 static struct type
*
17853 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17855 struct type
*base_type
, *cv_type
;
17857 base_type
= die_type (die
, cu
);
17859 /* The die_type call above may have already set the type for this DIE. */
17860 cv_type
= get_die_type (die
, cu
);
17864 /* In case the const qualifier is applied to an array type, the element type
17865 is so qualified, not the array type (section 6.7.3 of C99). */
17866 if (base_type
->code () == TYPE_CODE_ARRAY
)
17867 return add_array_cv_type (die
, cu
, base_type
, 1, 0);
17869 cv_type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
17870 return set_die_type (die
, cv_type
, cu
);
17873 static struct type
*
17874 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17876 struct type
*base_type
, *cv_type
;
17878 base_type
= die_type (die
, cu
);
17880 /* The die_type call above may have already set the type for this DIE. */
17881 cv_type
= get_die_type (die
, cu
);
17885 /* In case the volatile qualifier is applied to an array type, the
17886 element type is so qualified, not the array type (section 6.7.3
17888 if (base_type
->code () == TYPE_CODE_ARRAY
)
17889 return add_array_cv_type (die
, cu
, base_type
, 0, 1);
17891 cv_type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
17892 return set_die_type (die
, cv_type
, cu
);
17895 /* Handle DW_TAG_restrict_type. */
17897 static struct type
*
17898 read_tag_restrict_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17900 struct type
*base_type
, *cv_type
;
17902 base_type
= die_type (die
, cu
);
17904 /* The die_type call above may have already set the type for this DIE. */
17905 cv_type
= get_die_type (die
, cu
);
17909 cv_type
= make_restrict_type (base_type
);
17910 return set_die_type (die
, cv_type
, cu
);
17913 /* Handle DW_TAG_atomic_type. */
17915 static struct type
*
17916 read_tag_atomic_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17918 struct type
*base_type
, *cv_type
;
17920 base_type
= die_type (die
, cu
);
17922 /* The die_type call above may have already set the type for this DIE. */
17923 cv_type
= get_die_type (die
, cu
);
17927 cv_type
= make_atomic_type (base_type
);
17928 return set_die_type (die
, cv_type
, cu
);
17931 /* Extract all information from a DW_TAG_string_type DIE and add to
17932 the user defined type vector. It isn't really a user defined type,
17933 but it behaves like one, with other DIE's using an AT_user_def_type
17934 attribute to reference it. */
17936 static struct type
*
17937 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17939 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17940 struct gdbarch
*gdbarch
= objfile
->arch ();
17941 struct type
*type
, *range_type
, *index_type
, *char_type
;
17942 struct attribute
*attr
;
17943 struct dynamic_prop prop
;
17944 bool length_is_constant
= true;
17947 /* There are a couple of places where bit sizes might be made use of
17948 when parsing a DW_TAG_string_type, however, no producer that we know
17949 of make use of these. Handling bit sizes that are a multiple of the
17950 byte size is easy enough, but what about other bit sizes? Lets deal
17951 with that problem when we have to. Warn about these attributes being
17952 unsupported, then parse the type and ignore them like we always
17954 if (dwarf2_attr (die
, DW_AT_bit_size
, cu
) != nullptr
17955 || dwarf2_attr (die
, DW_AT_string_length_bit_size
, cu
) != nullptr)
17957 static bool warning_printed
= false;
17958 if (!warning_printed
)
17960 warning (_("DW_AT_bit_size and DW_AT_string_length_bit_size not "
17961 "currently supported on DW_TAG_string_type."));
17962 warning_printed
= true;
17966 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
17967 if (attr
!= nullptr && !attr
->form_is_constant ())
17969 /* The string length describes the location at which the length of
17970 the string can be found. The size of the length field can be
17971 specified with one of the attributes below. */
17972 struct type
*prop_type
;
17973 struct attribute
*len
17974 = dwarf2_attr (die
, DW_AT_string_length_byte_size
, cu
);
17975 if (len
== nullptr)
17976 len
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17977 if (len
!= nullptr && len
->form_is_constant ())
17979 /* Pass 0 as the default as we know this attribute is constant
17980 and the default value will not be returned. */
17981 LONGEST sz
= len
->constant_value (0);
17982 prop_type
= cu
->per_objfile
->int_type (sz
, true);
17986 /* If the size is not specified then we assume it is the size of
17987 an address on this target. */
17988 prop_type
= cu
->addr_sized_int_type (true);
17991 /* Convert the attribute into a dynamic property. */
17992 if (!attr_to_dynamic_prop (attr
, die
, cu
, &prop
, prop_type
))
17995 length_is_constant
= false;
17997 else if (attr
!= nullptr)
17999 /* This DW_AT_string_length just contains the length with no
18000 indirection. There's no need to create a dynamic property in this
18001 case. Pass 0 for the default value as we know it will not be
18002 returned in this case. */
18003 length
= attr
->constant_value (0);
18005 else if ((attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
)) != nullptr)
18007 /* We don't currently support non-constant byte sizes for strings. */
18008 length
= attr
->constant_value (1);
18012 /* Use 1 as a fallback length if we have nothing else. */
18016 index_type
= objfile_type (objfile
)->builtin_int
;
18017 if (length_is_constant
)
18018 range_type
= create_static_range_type (NULL
, index_type
, 1, length
);
18021 struct dynamic_prop low_bound
;
18023 low_bound
.set_const_val (1);
18024 range_type
= create_range_type (NULL
, index_type
, &low_bound
, &prop
, 0);
18026 char_type
= language_string_char_type (cu
->language_defn
, gdbarch
);
18027 type
= create_string_type (NULL
, char_type
, range_type
);
18029 return set_die_type (die
, type
, cu
);
18032 /* Assuming that DIE corresponds to a function, returns nonzero
18033 if the function is prototyped. */
18036 prototyped_function_p (struct die_info
*die
, struct dwarf2_cu
*cu
)
18038 struct attribute
*attr
;
18040 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
18041 if (attr
&& attr
->as_boolean ())
18044 /* The DWARF standard implies that the DW_AT_prototyped attribute
18045 is only meaningful for C, but the concept also extends to other
18046 languages that allow unprototyped functions (Eg: Objective C).
18047 For all other languages, assume that functions are always
18049 if (cu
->language
!= language_c
18050 && cu
->language
!= language_objc
18051 && cu
->language
!= language_opencl
)
18054 /* RealView does not emit DW_AT_prototyped. We can not distinguish
18055 prototyped and unprototyped functions; default to prototyped,
18056 since that is more common in modern code (and RealView warns
18057 about unprototyped functions). */
18058 if (producer_is_realview (cu
->producer
))
18064 /* Handle DIES due to C code like:
18068 int (*funcp)(int a, long l);
18072 ('funcp' generates a DW_TAG_subroutine_type DIE). */
18074 static struct type
*
18075 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18077 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
18078 struct type
*type
; /* Type that this function returns. */
18079 struct type
*ftype
; /* Function that returns above type. */
18080 struct attribute
*attr
;
18082 type
= die_type (die
, cu
);
18084 /* The die_type call above may have already set the type for this DIE. */
18085 ftype
= get_die_type (die
, cu
);
18089 ftype
= lookup_function_type (type
);
18091 if (prototyped_function_p (die
, cu
))
18092 ftype
->set_is_prototyped (true);
18094 /* Store the calling convention in the type if it's available in
18095 the subroutine die. Otherwise set the calling convention to
18096 the default value DW_CC_normal. */
18097 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
18098 if (attr
!= nullptr
18099 && is_valid_DW_AT_calling_convention_for_subroutine (attr
->constant_value (0)))
18100 TYPE_CALLING_CONVENTION (ftype
)
18101 = (enum dwarf_calling_convention
) attr
->constant_value (0);
18102 else if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL"))
18103 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_GDB_IBM_OpenCL
;
18105 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_normal
;
18107 /* Record whether the function returns normally to its caller or not
18108 if the DWARF producer set that information. */
18109 attr
= dwarf2_attr (die
, DW_AT_noreturn
, cu
);
18110 if (attr
&& attr
->as_boolean ())
18111 TYPE_NO_RETURN (ftype
) = 1;
18113 /* We need to add the subroutine type to the die immediately so
18114 we don't infinitely recurse when dealing with parameters
18115 declared as the same subroutine type. */
18116 set_die_type (die
, ftype
, cu
);
18118 if (die
->child
!= NULL
)
18120 struct type
*void_type
= objfile_type (objfile
)->builtin_void
;
18121 struct die_info
*child_die
;
18122 int nparams
, iparams
;
18124 /* Count the number of parameters.
18125 FIXME: GDB currently ignores vararg functions, but knows about
18126 vararg member functions. */
18128 child_die
= die
->child
;
18129 while (child_die
&& child_die
->tag
)
18131 if (child_die
->tag
== DW_TAG_formal_parameter
)
18133 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
18134 ftype
->set_has_varargs (true);
18136 child_die
= child_die
->sibling
;
18139 /* Allocate storage for parameters and fill them in. */
18140 ftype
->set_num_fields (nparams
);
18142 ((struct field
*) TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
)));
18144 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
18145 even if we error out during the parameters reading below. */
18146 for (iparams
= 0; iparams
< nparams
; iparams
++)
18147 ftype
->field (iparams
).set_type (void_type
);
18150 child_die
= die
->child
;
18151 while (child_die
&& child_die
->tag
)
18153 if (child_die
->tag
== DW_TAG_formal_parameter
)
18155 struct type
*arg_type
;
18157 /* DWARF version 2 has no clean way to discern C++
18158 static and non-static member functions. G++ helps
18159 GDB by marking the first parameter for non-static
18160 member functions (which is the this pointer) as
18161 artificial. We pass this information to
18162 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
18164 DWARF version 3 added DW_AT_object_pointer, which GCC
18165 4.5 does not yet generate. */
18166 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
18167 if (attr
!= nullptr)
18168 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = attr
->as_boolean ();
18170 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
18171 arg_type
= die_type (child_die
, cu
);
18173 /* RealView does not mark THIS as const, which the testsuite
18174 expects. GCC marks THIS as const in method definitions,
18175 but not in the class specifications (GCC PR 43053). */
18176 if (cu
->language
== language_cplus
&& !TYPE_CONST (arg_type
)
18177 && TYPE_FIELD_ARTIFICIAL (ftype
, iparams
))
18180 struct dwarf2_cu
*arg_cu
= cu
;
18181 const char *name
= dwarf2_name (child_die
, cu
);
18183 attr
= dwarf2_attr (die
, DW_AT_object_pointer
, cu
);
18184 if (attr
!= nullptr)
18186 /* If the compiler emits this, use it. */
18187 if (follow_die_ref (die
, attr
, &arg_cu
) == child_die
)
18190 else if (name
&& strcmp (name
, "this") == 0)
18191 /* Function definitions will have the argument names. */
18193 else if (name
== NULL
&& iparams
== 0)
18194 /* Declarations may not have the names, so like
18195 elsewhere in GDB, assume an artificial first
18196 argument is "this". */
18200 arg_type
= make_cv_type (1, TYPE_VOLATILE (arg_type
),
18204 ftype
->field (iparams
).set_type (arg_type
);
18207 child_die
= child_die
->sibling
;
18214 static struct type
*
18215 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
18217 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
18218 const char *name
= NULL
;
18219 struct type
*this_type
, *target_type
;
18221 name
= dwarf2_full_name (NULL
, die
, cu
);
18222 this_type
= init_type (objfile
, TYPE_CODE_TYPEDEF
, 0, name
);
18223 this_type
->set_target_is_stub (true);
18224 set_die_type (die
, this_type
, cu
);
18225 target_type
= die_type (die
, cu
);
18226 if (target_type
!= this_type
)
18227 TYPE_TARGET_TYPE (this_type
) = target_type
;
18230 /* Self-referential typedefs are, it seems, not allowed by the DWARF
18231 spec and cause infinite loops in GDB. */
18232 complaint (_("Self-referential DW_TAG_typedef "
18233 "- DIE at %s [in module %s]"),
18234 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
18235 TYPE_TARGET_TYPE (this_type
) = NULL
;
18239 /* Gcc-7 and before supports -feliminate-dwarf2-dups, which generates
18240 anonymous typedefs, which is, strictly speaking, invalid DWARF.
18241 Handle these by just returning the target type, rather than
18242 constructing an anonymous typedef type and trying to handle this
18244 set_die_type (die
, target_type
, cu
);
18245 return target_type
;
18250 /* Helper for get_dwarf2_rational_constant that computes the value of
18251 a given gmp_mpz given an attribute. */
18254 get_mpz (struct dwarf2_cu
*cu
, gdb_mpz
*value
, struct attribute
*attr
)
18256 /* GCC will sometimes emit a 16-byte constant value as a DWARF
18257 location expression that pushes an implicit value. */
18258 if (attr
->form
== DW_FORM_exprloc
)
18260 dwarf_block
*blk
= attr
->as_block ();
18261 if (blk
->size
> 0 && blk
->data
[0] == DW_OP_implicit_value
)
18264 const gdb_byte
*ptr
= safe_read_uleb128 (blk
->data
+ 1,
18265 blk
->data
+ blk
->size
,
18267 if (ptr
- blk
->data
+ len
<= blk
->size
)
18269 mpz_import (value
->val
, len
,
18270 bfd_big_endian (cu
->per_objfile
->objfile
->obfd
) ? 1 : -1,
18276 /* On failure set it to 1. */
18277 *value
= gdb_mpz (1);
18279 else if (attr
->form_is_block ())
18281 dwarf_block
*blk
= attr
->as_block ();
18282 mpz_import (value
->val
, blk
->size
,
18283 bfd_big_endian (cu
->per_objfile
->objfile
->obfd
) ? 1 : -1,
18284 1, 0, 0, blk
->data
);
18287 *value
= gdb_mpz (attr
->constant_value (1));
18290 /* Assuming DIE is a rational DW_TAG_constant, read the DIE's
18291 numerator and denominator into NUMERATOR and DENOMINATOR (resp).
18293 If the numerator and/or numerator attribute is missing,
18294 a complaint is filed, and NUMERATOR and DENOMINATOR are left
18298 get_dwarf2_rational_constant (struct die_info
*die
, struct dwarf2_cu
*cu
,
18299 gdb_mpz
*numerator
, gdb_mpz
*denominator
)
18301 struct attribute
*num_attr
, *denom_attr
;
18303 num_attr
= dwarf2_attr (die
, DW_AT_GNU_numerator
, cu
);
18304 if (num_attr
== nullptr)
18305 complaint (_("DW_AT_GNU_numerator missing in %s DIE at %s"),
18306 dwarf_tag_name (die
->tag
), sect_offset_str (die
->sect_off
));
18308 denom_attr
= dwarf2_attr (die
, DW_AT_GNU_denominator
, cu
);
18309 if (denom_attr
== nullptr)
18310 complaint (_("DW_AT_GNU_denominator missing in %s DIE at %s"),
18311 dwarf_tag_name (die
->tag
), sect_offset_str (die
->sect_off
));
18313 if (num_attr
== nullptr || denom_attr
== nullptr)
18316 get_mpz (cu
, numerator
, num_attr
);
18317 get_mpz (cu
, denominator
, denom_attr
);
18320 /* Same as get_dwarf2_rational_constant, but extracting an unsigned
18321 rational constant, rather than a signed one.
18323 If the rational constant has a negative value, a complaint
18324 is filed, and NUMERATOR and DENOMINATOR are left untouched. */
18327 get_dwarf2_unsigned_rational_constant (struct die_info
*die
,
18328 struct dwarf2_cu
*cu
,
18329 gdb_mpz
*numerator
,
18330 gdb_mpz
*denominator
)
18335 get_dwarf2_rational_constant (die
, cu
, &num
, &denom
);
18336 if (mpz_sgn (num
.val
) == -1 && mpz_sgn (denom
.val
) == -1)
18338 mpz_neg (num
.val
, num
.val
);
18339 mpz_neg (denom
.val
, denom
.val
);
18341 else if (mpz_sgn (num
.val
) == -1)
18343 complaint (_("unexpected negative value for DW_AT_GNU_numerator"
18345 sect_offset_str (die
->sect_off
));
18348 else if (mpz_sgn (denom
.val
) == -1)
18350 complaint (_("unexpected negative value for DW_AT_GNU_denominator"
18352 sect_offset_str (die
->sect_off
));
18356 *numerator
= std::move (num
);
18357 *denominator
= std::move (denom
);
18360 /* Assuming DIE corresponds to a fixed point type, finish the creation
18361 of the corresponding TYPE by setting its type-specific data.
18362 CU is the DIE's CU. */
18365 finish_fixed_point_type (struct type
*type
, struct die_info
*die
,
18366 struct dwarf2_cu
*cu
)
18368 struct attribute
*attr
;
18370 gdb_assert (type
->code () == TYPE_CODE_FIXED_POINT
18371 && TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_FIXED_POINT
);
18373 attr
= dwarf2_attr (die
, DW_AT_binary_scale
, cu
);
18375 attr
= dwarf2_attr (die
, DW_AT_decimal_scale
, cu
);
18377 attr
= dwarf2_attr (die
, DW_AT_small
, cu
);
18379 /* Numerator and denominator of our fixed-point type's scaling factor.
18380 The default is a scaling factor of 1, which we use as a fallback
18381 when we are not able to decode it (problem with the debugging info,
18382 unsupported forms, bug in GDB, etc...). Using that as the default
18383 allows us to at least print the unscaled value, which might still
18384 be useful to a user. */
18385 gdb_mpz
scale_num (1);
18386 gdb_mpz
scale_denom (1);
18388 if (attr
== nullptr)
18390 /* Scaling factor not found. Assume a scaling factor of 1,
18391 and hope for the best. At least the user will be able to see
18392 the encoded value. */
18393 complaint (_("no scale found for fixed-point type (DIE at %s)"),
18394 sect_offset_str (die
->sect_off
));
18396 else if (attr
->name
== DW_AT_binary_scale
)
18398 LONGEST scale_exp
= attr
->constant_value (0);
18399 gdb_mpz
*num_or_denom
= scale_exp
> 0 ? &scale_num
: &scale_denom
;
18401 mpz_mul_2exp (num_or_denom
->val
, num_or_denom
->val
, std::abs (scale_exp
));
18403 else if (attr
->name
== DW_AT_decimal_scale
)
18405 LONGEST scale_exp
= attr
->constant_value (0);
18406 gdb_mpz
*num_or_denom
= scale_exp
> 0 ? &scale_num
: &scale_denom
;
18408 mpz_ui_pow_ui (num_or_denom
->val
, 10, std::abs (scale_exp
));
18410 else if (attr
->name
== DW_AT_small
)
18412 struct die_info
*scale_die
;
18413 struct dwarf2_cu
*scale_cu
= cu
;
18415 scale_die
= follow_die_ref (die
, attr
, &scale_cu
);
18416 if (scale_die
->tag
== DW_TAG_constant
)
18417 get_dwarf2_unsigned_rational_constant (scale_die
, scale_cu
,
18418 &scale_num
, &scale_denom
);
18420 complaint (_("%s DIE not supported as target of DW_AT_small attribute"
18422 dwarf_tag_name (die
->tag
), sect_offset_str (die
->sect_off
));
18426 complaint (_("unsupported scale attribute %s for fixed-point type"
18428 dwarf_attr_name (attr
->name
),
18429 sect_offset_str (die
->sect_off
));
18432 gdb_mpq
&scaling_factor
= type
->fixed_point_info ().scaling_factor
;
18433 mpz_set (mpq_numref (scaling_factor
.val
), scale_num
.val
);
18434 mpz_set (mpq_denref (scaling_factor
.val
), scale_denom
.val
);
18435 mpq_canonicalize (scaling_factor
.val
);
18438 /* Allocate a floating-point type of size BITS and name NAME. Pass NAME_HINT
18439 (which may be different from NAME) to the architecture back-end to allow
18440 it to guess the correct format if necessary. */
18442 static struct type
*
18443 dwarf2_init_float_type (struct objfile
*objfile
, int bits
, const char *name
,
18444 const char *name_hint
, enum bfd_endian byte_order
)
18446 struct gdbarch
*gdbarch
= objfile
->arch ();
18447 const struct floatformat
**format
;
18450 format
= gdbarch_floatformat_for_type (gdbarch
, name_hint
, bits
);
18452 type
= init_float_type (objfile
, bits
, name
, format
, byte_order
);
18454 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
, name
);
18459 /* Allocate an integer type of size BITS and name NAME. */
18461 static struct type
*
18462 dwarf2_init_integer_type (struct dwarf2_cu
*cu
, struct objfile
*objfile
,
18463 int bits
, int unsigned_p
, const char *name
)
18467 /* Versions of Intel's C Compiler generate an integer type called "void"
18468 instead of using DW_TAG_unspecified_type. This has been seen on
18469 at least versions 14, 17, and 18. */
18470 if (bits
== 0 && producer_is_icc (cu
) && name
!= nullptr
18471 && strcmp (name
, "void") == 0)
18472 type
= objfile_type (objfile
)->builtin_void
;
18474 type
= init_integer_type (objfile
, bits
, unsigned_p
, name
);
18479 /* Return true if DIE has a DW_AT_small attribute whose value is
18480 a constant rational, where both the numerator and denominator
18483 CU is the DIE's Compilation Unit. */
18486 has_zero_over_zero_small_attribute (struct die_info
*die
,
18487 struct dwarf2_cu
*cu
)
18489 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_small
, cu
);
18490 if (attr
== nullptr)
18493 struct dwarf2_cu
*scale_cu
= cu
;
18494 struct die_info
*scale_die
18495 = follow_die_ref (die
, attr
, &scale_cu
);
18497 if (scale_die
->tag
!= DW_TAG_constant
)
18500 gdb_mpz
num (1), denom (1);
18501 get_dwarf2_rational_constant (scale_die
, cu
, &num
, &denom
);
18502 return mpz_sgn (num
.val
) == 0 && mpz_sgn (denom
.val
) == 0;
18505 /* Initialise and return a floating point type of size BITS suitable for
18506 use as a component of a complex number. The NAME_HINT is passed through
18507 when initialising the floating point type and is the name of the complex
18510 As DWARF doesn't currently provide an explicit name for the components
18511 of a complex number, but it can be helpful to have these components
18512 named, we try to select a suitable name based on the size of the
18514 static struct type
*
18515 dwarf2_init_complex_target_type (struct dwarf2_cu
*cu
,
18516 struct objfile
*objfile
,
18517 int bits
, const char *name_hint
,
18518 enum bfd_endian byte_order
)
18520 gdbarch
*gdbarch
= objfile
->arch ();
18521 struct type
*tt
= nullptr;
18523 /* Try to find a suitable floating point builtin type of size BITS.
18524 We're going to use the name of this type as the name for the complex
18525 target type that we are about to create. */
18526 switch (cu
->language
)
18528 case language_fortran
:
18532 tt
= builtin_f_type (gdbarch
)->builtin_real
;
18535 tt
= builtin_f_type (gdbarch
)->builtin_real_s8
;
18537 case 96: /* The x86-32 ABI specifies 96-bit long double. */
18539 tt
= builtin_f_type (gdbarch
)->builtin_real_s16
;
18547 tt
= builtin_type (gdbarch
)->builtin_float
;
18550 tt
= builtin_type (gdbarch
)->builtin_double
;
18552 case 96: /* The x86-32 ABI specifies 96-bit long double. */
18554 tt
= builtin_type (gdbarch
)->builtin_long_double
;
18560 /* If the type we found doesn't match the size we were looking for, then
18561 pretend we didn't find a type at all, the complex target type we
18562 create will then be nameless. */
18563 if (tt
!= nullptr && TYPE_LENGTH (tt
) * TARGET_CHAR_BIT
!= bits
)
18566 const char *name
= (tt
== nullptr) ? nullptr : tt
->name ();
18567 return dwarf2_init_float_type (objfile
, bits
, name
, name_hint
, byte_order
);
18570 /* Find a representation of a given base type and install
18571 it in the TYPE field of the die. */
18573 static struct type
*
18574 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18576 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
18578 struct attribute
*attr
;
18579 int encoding
= 0, bits
= 0;
18583 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
18584 if (attr
!= nullptr && attr
->form_is_constant ())
18585 encoding
= attr
->constant_value (0);
18586 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
18587 if (attr
!= nullptr)
18588 bits
= attr
->constant_value (0) * TARGET_CHAR_BIT
;
18589 name
= dwarf2_name (die
, cu
);
18591 complaint (_("DW_AT_name missing from DW_TAG_base_type"));
18593 arch
= objfile
->arch ();
18594 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
18596 attr
= dwarf2_attr (die
, DW_AT_endianity
, cu
);
18597 if (attr
!= nullptr && attr
->form_is_constant ())
18599 int endianity
= attr
->constant_value (0);
18604 byte_order
= BFD_ENDIAN_BIG
;
18606 case DW_END_little
:
18607 byte_order
= BFD_ENDIAN_LITTLE
;
18610 complaint (_("DW_AT_endianity has unrecognized value %d"), endianity
);
18615 if ((encoding
== DW_ATE_signed_fixed
|| encoding
== DW_ATE_unsigned_fixed
)
18616 && cu
->language
== language_ada
18617 && has_zero_over_zero_small_attribute (die
, cu
))
18619 /* brobecker/2018-02-24: This is a fixed point type for which
18620 the scaling factor is represented as fraction whose value
18621 does not make sense (zero divided by zero), so we should
18622 normally never see these. However, there is a small category
18623 of fixed point types for which GNAT is unable to provide
18624 the scaling factor via the standard DWARF mechanisms, and
18625 for which the info is provided via the GNAT encodings instead.
18626 This is likely what this DIE is about.
18628 Ideally, GNAT should be declaring this type the same way
18629 it declares other fixed point types when using the legacy
18630 GNAT encoding, which is to use a simple signed or unsigned
18631 base type. A report to the GNAT team has been created to
18632 look into it. In the meantime, pretend this type is a simple
18633 signed or unsigned integral, rather than a fixed point type,
18634 to avoid any confusion later on as to how to process this type. */
18635 encoding
= (encoding
== DW_ATE_signed_fixed
18637 : DW_ATE_unsigned
);
18642 case DW_ATE_address
:
18643 /* Turn DW_ATE_address into a void * pointer. */
18644 type
= init_type (objfile
, TYPE_CODE_VOID
, TARGET_CHAR_BIT
, NULL
);
18645 type
= init_pointer_type (objfile
, bits
, name
, type
);
18647 case DW_ATE_boolean
:
18648 type
= init_boolean_type (objfile
, bits
, 1, name
);
18650 case DW_ATE_complex_float
:
18651 type
= dwarf2_init_complex_target_type (cu
, objfile
, bits
/ 2, name
,
18653 if (type
->code () == TYPE_CODE_ERROR
)
18655 if (name
== nullptr)
18657 struct obstack
*obstack
18658 = &cu
->per_objfile
->objfile
->objfile_obstack
;
18659 name
= obconcat (obstack
, "_Complex ", type
->name (),
18662 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
, name
);
18665 type
= init_complex_type (name
, type
);
18667 case DW_ATE_decimal_float
:
18668 type
= init_decfloat_type (objfile
, bits
, name
);
18671 type
= dwarf2_init_float_type (objfile
, bits
, name
, name
, byte_order
);
18673 case DW_ATE_signed
:
18674 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 0, name
);
18676 case DW_ATE_unsigned
:
18677 if (cu
->language
== language_fortran
18679 && startswith (name
, "character("))
18680 type
= init_character_type (objfile
, bits
, 1, name
);
18682 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 1, name
);
18684 case DW_ATE_signed_char
:
18685 if (cu
->language
== language_ada
|| cu
->language
== language_m2
18686 || cu
->language
== language_pascal
18687 || cu
->language
== language_fortran
)
18688 type
= init_character_type (objfile
, bits
, 0, name
);
18690 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 0, name
);
18692 case DW_ATE_unsigned_char
:
18693 if (cu
->language
== language_ada
|| cu
->language
== language_m2
18694 || cu
->language
== language_pascal
18695 || cu
->language
== language_fortran
18696 || cu
->language
== language_rust
)
18697 type
= init_character_type (objfile
, bits
, 1, name
);
18699 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 1, name
);
18704 type
= builtin_type (arch
)->builtin_char16
;
18705 else if (bits
== 32)
18706 type
= builtin_type (arch
)->builtin_char32
;
18709 complaint (_("unsupported DW_ATE_UTF bit size: '%d'"),
18711 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 1, name
);
18713 return set_die_type (die
, type
, cu
);
18716 case DW_ATE_signed_fixed
:
18717 type
= init_fixed_point_type (objfile
, bits
, 0, name
);
18718 finish_fixed_point_type (type
, die
, cu
);
18720 case DW_ATE_unsigned_fixed
:
18721 type
= init_fixed_point_type (objfile
, bits
, 1, name
);
18722 finish_fixed_point_type (type
, die
, cu
);
18726 complaint (_("unsupported DW_AT_encoding: '%s'"),
18727 dwarf_type_encoding_name (encoding
));
18728 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
, name
);
18732 if (name
&& strcmp (name
, "char") == 0)
18733 type
->set_has_no_signedness (true);
18735 maybe_set_alignment (cu
, die
, type
);
18737 type
->set_endianity_is_not_default (gdbarch_byte_order (arch
) != byte_order
);
18739 if (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_INT
)
18741 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
18742 if (attr
!= nullptr && attr
->as_unsigned () <= 8 * TYPE_LENGTH (type
))
18744 unsigned real_bit_size
= attr
->as_unsigned ();
18745 attr
= dwarf2_attr (die
, DW_AT_data_bit_offset
, cu
);
18746 /* Only use the attributes if they make sense together. */
18747 if (attr
== nullptr
18748 || (attr
->as_unsigned () + real_bit_size
18749 <= 8 * TYPE_LENGTH (type
)))
18751 TYPE_MAIN_TYPE (type
)->type_specific
.int_stuff
.bit_size
18753 if (attr
!= nullptr)
18754 TYPE_MAIN_TYPE (type
)->type_specific
.int_stuff
.bit_offset
18755 = attr
->as_unsigned ();
18760 return set_die_type (die
, type
, cu
);
18763 /* Parse dwarf attribute if it's a block, reference or constant and put the
18764 resulting value of the attribute into struct bound_prop.
18765 Returns 1 if ATTR could be resolved into PROP, 0 otherwise. */
18768 attr_to_dynamic_prop (const struct attribute
*attr
, struct die_info
*die
,
18769 struct dwarf2_cu
*cu
, struct dynamic_prop
*prop
,
18770 struct type
*default_type
)
18772 struct dwarf2_property_baton
*baton
;
18773 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
18774 struct objfile
*objfile
= per_objfile
->objfile
;
18775 struct obstack
*obstack
= &objfile
->objfile_obstack
;
18777 gdb_assert (default_type
!= NULL
);
18779 if (attr
== NULL
|| prop
== NULL
)
18782 if (attr
->form_is_block ())
18784 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
18785 baton
->property_type
= default_type
;
18786 baton
->locexpr
.per_cu
= cu
->per_cu
;
18787 baton
->locexpr
.per_objfile
= per_objfile
;
18789 struct dwarf_block
*block
= attr
->as_block ();
18790 baton
->locexpr
.size
= block
->size
;
18791 baton
->locexpr
.data
= block
->data
;
18792 switch (attr
->name
)
18794 case DW_AT_string_length
:
18795 baton
->locexpr
.is_reference
= true;
18798 baton
->locexpr
.is_reference
= false;
18802 prop
->set_locexpr (baton
);
18803 gdb_assert (prop
->baton () != NULL
);
18805 else if (attr
->form_is_ref ())
18807 struct dwarf2_cu
*target_cu
= cu
;
18808 struct die_info
*target_die
;
18809 struct attribute
*target_attr
;
18811 target_die
= follow_die_ref (die
, attr
, &target_cu
);
18812 target_attr
= dwarf2_attr (target_die
, DW_AT_location
, target_cu
);
18813 if (target_attr
== NULL
)
18814 target_attr
= dwarf2_attr (target_die
, DW_AT_data_member_location
,
18816 if (target_attr
== NULL
)
18819 switch (target_attr
->name
)
18821 case DW_AT_location
:
18822 if (target_attr
->form_is_section_offset ())
18824 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
18825 baton
->property_type
= die_type (target_die
, target_cu
);
18826 fill_in_loclist_baton (cu
, &baton
->loclist
, target_attr
);
18827 prop
->set_loclist (baton
);
18828 gdb_assert (prop
->baton () != NULL
);
18830 else if (target_attr
->form_is_block ())
18832 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
18833 baton
->property_type
= die_type (target_die
, target_cu
);
18834 baton
->locexpr
.per_cu
= cu
->per_cu
;
18835 baton
->locexpr
.per_objfile
= per_objfile
;
18836 struct dwarf_block
*block
= target_attr
->as_block ();
18837 baton
->locexpr
.size
= block
->size
;
18838 baton
->locexpr
.data
= block
->data
;
18839 baton
->locexpr
.is_reference
= true;
18840 prop
->set_locexpr (baton
);
18841 gdb_assert (prop
->baton () != NULL
);
18845 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
18846 "dynamic property");
18850 case DW_AT_data_member_location
:
18854 if (!handle_data_member_location (target_die
, target_cu
,
18858 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
18859 baton
->property_type
= read_type_die (target_die
->parent
,
18861 baton
->offset_info
.offset
= offset
;
18862 baton
->offset_info
.type
= die_type (target_die
, target_cu
);
18863 prop
->set_addr_offset (baton
);
18868 else if (attr
->form_is_constant ())
18869 prop
->set_const_val (attr
->constant_value (0));
18872 dwarf2_invalid_attrib_class_complaint (dwarf_form_name (attr
->form
),
18873 dwarf2_name (die
, cu
));
18883 dwarf2_per_objfile::int_type (int size_in_bytes
, bool unsigned_p
) const
18885 struct type
*int_type
;
18887 /* Helper macro to examine the various builtin types. */
18888 #define TRY_TYPE(F) \
18889 int_type = (unsigned_p \
18890 ? objfile_type (objfile)->builtin_unsigned_ ## F \
18891 : objfile_type (objfile)->builtin_ ## F); \
18892 if (int_type != NULL && TYPE_LENGTH (int_type) == size_in_bytes) \
18899 TRY_TYPE (long_long
);
18903 gdb_assert_not_reached ("unable to find suitable integer type");
18909 dwarf2_cu::addr_sized_int_type (bool unsigned_p
) const
18911 int addr_size
= this->per_cu
->addr_size ();
18912 return this->per_objfile
->int_type (addr_size
, unsigned_p
);
18915 /* Read the DW_AT_type attribute for a sub-range. If this attribute is not
18916 present (which is valid) then compute the default type based on the
18917 compilation units address size. */
18919 static struct type
*
18920 read_subrange_index_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18922 struct type
*index_type
= die_type (die
, cu
);
18924 /* Dwarf-2 specifications explicitly allows to create subrange types
18925 without specifying a base type.
18926 In that case, the base type must be set to the type of
18927 the lower bound, upper bound or count, in that order, if any of these
18928 three attributes references an object that has a type.
18929 If no base type is found, the Dwarf-2 specifications say that
18930 a signed integer type of size equal to the size of an address should
18932 For the following C code: `extern char gdb_int [];'
18933 GCC produces an empty range DIE.
18934 FIXME: muller/2010-05-28: Possible references to object for low bound,
18935 high bound or count are not yet handled by this code. */
18936 if (index_type
->code () == TYPE_CODE_VOID
)
18937 index_type
= cu
->addr_sized_int_type (false);
18942 /* Read the given DW_AT_subrange DIE. */
18944 static struct type
*
18945 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18947 struct type
*base_type
, *orig_base_type
;
18948 struct type
*range_type
;
18949 struct attribute
*attr
;
18950 struct dynamic_prop low
, high
;
18951 int low_default_is_valid
;
18952 int high_bound_is_count
= 0;
18954 ULONGEST negative_mask
;
18956 orig_base_type
= read_subrange_index_type (die
, cu
);
18958 /* If ORIG_BASE_TYPE is a typedef, it will not be TYPE_UNSIGNED,
18959 whereas the real type might be. So, we use ORIG_BASE_TYPE when
18960 creating the range type, but we use the result of check_typedef
18961 when examining properties of the type. */
18962 base_type
= check_typedef (orig_base_type
);
18964 /* The die_type call above may have already set the type for this DIE. */
18965 range_type
= get_die_type (die
, cu
);
18969 high
.set_const_val (0);
18971 /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
18972 omitting DW_AT_lower_bound. */
18973 switch (cu
->language
)
18976 case language_cplus
:
18977 low
.set_const_val (0);
18978 low_default_is_valid
= 1;
18980 case language_fortran
:
18981 low
.set_const_val (1);
18982 low_default_is_valid
= 1;
18985 case language_objc
:
18986 case language_rust
:
18987 low
.set_const_val (0);
18988 low_default_is_valid
= (cu
->header
.version
>= 4);
18992 case language_pascal
:
18993 low
.set_const_val (1);
18994 low_default_is_valid
= (cu
->header
.version
>= 4);
18997 low
.set_const_val (0);
18998 low_default_is_valid
= 0;
19002 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
19003 if (attr
!= nullptr)
19004 attr_to_dynamic_prop (attr
, die
, cu
, &low
, base_type
);
19005 else if (!low_default_is_valid
)
19006 complaint (_("Missing DW_AT_lower_bound "
19007 "- DIE at %s [in module %s]"),
19008 sect_offset_str (die
->sect_off
),
19009 objfile_name (cu
->per_objfile
->objfile
));
19011 struct attribute
*attr_ub
, *attr_count
;
19012 attr
= attr_ub
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
19013 if (!attr_to_dynamic_prop (attr
, die
, cu
, &high
, base_type
))
19015 attr
= attr_count
= dwarf2_attr (die
, DW_AT_count
, cu
);
19016 if (attr_to_dynamic_prop (attr
, die
, cu
, &high
, base_type
))
19018 /* If bounds are constant do the final calculation here. */
19019 if (low
.kind () == PROP_CONST
&& high
.kind () == PROP_CONST
)
19020 high
.set_const_val (low
.const_val () + high
.const_val () - 1);
19022 high_bound_is_count
= 1;
19026 if (attr_ub
!= NULL
)
19027 complaint (_("Unresolved DW_AT_upper_bound "
19028 "- DIE at %s [in module %s]"),
19029 sect_offset_str (die
->sect_off
),
19030 objfile_name (cu
->per_objfile
->objfile
));
19031 if (attr_count
!= NULL
)
19032 complaint (_("Unresolved DW_AT_count "
19033 "- DIE at %s [in module %s]"),
19034 sect_offset_str (die
->sect_off
),
19035 objfile_name (cu
->per_objfile
->objfile
));
19040 struct attribute
*bias_attr
= dwarf2_attr (die
, DW_AT_GNU_bias
, cu
);
19041 if (bias_attr
!= nullptr && bias_attr
->form_is_constant ())
19042 bias
= bias_attr
->constant_value (0);
19044 /* Normally, the DWARF producers are expected to use a signed
19045 constant form (Eg. DW_FORM_sdata) to express negative bounds.
19046 But this is unfortunately not always the case, as witnessed
19047 with GCC, for instance, where the ambiguous DW_FORM_dataN form
19048 is used instead. To work around that ambiguity, we treat
19049 the bounds as signed, and thus sign-extend their values, when
19050 the base type is signed. */
19052 -((ULONGEST
) 1 << (TYPE_LENGTH (base_type
) * TARGET_CHAR_BIT
- 1));
19053 if (low
.kind () == PROP_CONST
19054 && !base_type
->is_unsigned () && (low
.const_val () & negative_mask
))
19055 low
.set_const_val (low
.const_val () | negative_mask
);
19056 if (high
.kind () == PROP_CONST
19057 && !base_type
->is_unsigned () && (high
.const_val () & negative_mask
))
19058 high
.set_const_val (high
.const_val () | negative_mask
);
19060 /* Check for bit and byte strides. */
19061 struct dynamic_prop byte_stride_prop
;
19062 attribute
*attr_byte_stride
= dwarf2_attr (die
, DW_AT_byte_stride
, cu
);
19063 if (attr_byte_stride
!= nullptr)
19065 struct type
*prop_type
= cu
->addr_sized_int_type (false);
19066 attr_to_dynamic_prop (attr_byte_stride
, die
, cu
, &byte_stride_prop
,
19070 struct dynamic_prop bit_stride_prop
;
19071 attribute
*attr_bit_stride
= dwarf2_attr (die
, DW_AT_bit_stride
, cu
);
19072 if (attr_bit_stride
!= nullptr)
19074 /* It only makes sense to have either a bit or byte stride. */
19075 if (attr_byte_stride
!= nullptr)
19077 complaint (_("Found DW_AT_bit_stride and DW_AT_byte_stride "
19078 "- DIE at %s [in module %s]"),
19079 sect_offset_str (die
->sect_off
),
19080 objfile_name (cu
->per_objfile
->objfile
));
19081 attr_bit_stride
= nullptr;
19085 struct type
*prop_type
= cu
->addr_sized_int_type (false);
19086 attr_to_dynamic_prop (attr_bit_stride
, die
, cu
, &bit_stride_prop
,
19091 if (attr_byte_stride
!= nullptr
19092 || attr_bit_stride
!= nullptr)
19094 bool byte_stride_p
= (attr_byte_stride
!= nullptr);
19095 struct dynamic_prop
*stride
19096 = byte_stride_p
? &byte_stride_prop
: &bit_stride_prop
;
19099 = create_range_type_with_stride (NULL
, orig_base_type
, &low
,
19100 &high
, bias
, stride
, byte_stride_p
);
19103 range_type
= create_range_type (NULL
, orig_base_type
, &low
, &high
, bias
);
19105 if (high_bound_is_count
)
19106 range_type
->bounds ()->flag_upper_bound_is_count
= 1;
19108 /* Ada expects an empty array on no boundary attributes. */
19109 if (attr
== NULL
&& cu
->language
!= language_ada
)
19110 range_type
->bounds ()->high
.set_undefined ();
19112 name
= dwarf2_name (die
, cu
);
19114 range_type
->set_name (name
);
19116 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
19117 if (attr
!= nullptr)
19118 TYPE_LENGTH (range_type
) = attr
->constant_value (0);
19120 maybe_set_alignment (cu
, die
, range_type
);
19122 set_die_type (die
, range_type
, cu
);
19124 /* set_die_type should be already done. */
19125 set_descriptive_type (range_type
, die
, cu
);
19130 static struct type
*
19131 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
19135 type
= init_type (cu
->per_objfile
->objfile
, TYPE_CODE_VOID
, 0, NULL
);
19136 type
->set_name (dwarf2_name (die
, cu
));
19138 /* In Ada, an unspecified type is typically used when the description
19139 of the type is deferred to a different unit. When encountering
19140 such a type, we treat it as a stub, and try to resolve it later on,
19142 if (cu
->language
== language_ada
)
19143 type
->set_is_stub (true);
19145 return set_die_type (die
, type
, cu
);
19148 /* Read a single die and all its descendents. Set the die's sibling
19149 field to NULL; set other fields in the die correctly, and set all
19150 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
19151 location of the info_ptr after reading all of those dies. PARENT
19152 is the parent of the die in question. */
19154 static struct die_info
*
19155 read_die_and_children (const struct die_reader_specs
*reader
,
19156 const gdb_byte
*info_ptr
,
19157 const gdb_byte
**new_info_ptr
,
19158 struct die_info
*parent
)
19160 struct die_info
*die
;
19161 const gdb_byte
*cur_ptr
;
19163 cur_ptr
= read_full_die_1 (reader
, &die
, info_ptr
, 0);
19166 *new_info_ptr
= cur_ptr
;
19169 store_in_ref_table (die
, reader
->cu
);
19171 if (die
->has_children
)
19172 die
->child
= read_die_and_siblings_1 (reader
, cur_ptr
, new_info_ptr
, die
);
19176 *new_info_ptr
= cur_ptr
;
19179 die
->sibling
= NULL
;
19180 die
->parent
= parent
;
19184 /* Read a die, all of its descendents, and all of its siblings; set
19185 all of the fields of all of the dies correctly. Arguments are as
19186 in read_die_and_children. */
19188 static struct die_info
*
19189 read_die_and_siblings_1 (const struct die_reader_specs
*reader
,
19190 const gdb_byte
*info_ptr
,
19191 const gdb_byte
**new_info_ptr
,
19192 struct die_info
*parent
)
19194 struct die_info
*first_die
, *last_sibling
;
19195 const gdb_byte
*cur_ptr
;
19197 cur_ptr
= info_ptr
;
19198 first_die
= last_sibling
= NULL
;
19202 struct die_info
*die
19203 = read_die_and_children (reader
, cur_ptr
, &cur_ptr
, parent
);
19207 *new_info_ptr
= cur_ptr
;
19214 last_sibling
->sibling
= die
;
19216 last_sibling
= die
;
19220 /* Read a die, all of its descendents, and all of its siblings; set
19221 all of the fields of all of the dies correctly. Arguments are as
19222 in read_die_and_children.
19223 This the main entry point for reading a DIE and all its children. */
19225 static struct die_info
*
19226 read_die_and_siblings (const struct die_reader_specs
*reader
,
19227 const gdb_byte
*info_ptr
,
19228 const gdb_byte
**new_info_ptr
,
19229 struct die_info
*parent
)
19231 struct die_info
*die
= read_die_and_siblings_1 (reader
, info_ptr
,
19232 new_info_ptr
, parent
);
19234 if (dwarf_die_debug
)
19236 fprintf_unfiltered (gdb_stdlog
,
19237 "Read die from %s@0x%x of %s:\n",
19238 reader
->die_section
->get_name (),
19239 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
19240 bfd_get_filename (reader
->abfd
));
19241 dump_die (die
, dwarf_die_debug
);
19247 /* Read a die and all its attributes, leave space for NUM_EXTRA_ATTRS
19249 The caller is responsible for filling in the extra attributes
19250 and updating (*DIEP)->num_attrs.
19251 Set DIEP to point to a newly allocated die with its information,
19252 except for its child, sibling, and parent fields. */
19254 static const gdb_byte
*
19255 read_full_die_1 (const struct die_reader_specs
*reader
,
19256 struct die_info
**diep
, const gdb_byte
*info_ptr
,
19257 int num_extra_attrs
)
19259 unsigned int abbrev_number
, bytes_read
, i
;
19260 struct abbrev_info
*abbrev
;
19261 struct die_info
*die
;
19262 struct dwarf2_cu
*cu
= reader
->cu
;
19263 bfd
*abfd
= reader
->abfd
;
19265 sect_offset sect_off
= (sect_offset
) (info_ptr
- reader
->buffer
);
19266 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
19267 info_ptr
+= bytes_read
;
19268 if (!abbrev_number
)
19274 abbrev
= reader
->abbrev_table
->lookup_abbrev (abbrev_number
);
19276 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
19278 bfd_get_filename (abfd
));
19280 die
= dwarf_alloc_die (cu
, abbrev
->num_attrs
+ num_extra_attrs
);
19281 die
->sect_off
= sect_off
;
19282 die
->tag
= abbrev
->tag
;
19283 die
->abbrev
= abbrev_number
;
19284 die
->has_children
= abbrev
->has_children
;
19286 /* Make the result usable.
19287 The caller needs to update num_attrs after adding the extra
19289 die
->num_attrs
= abbrev
->num_attrs
;
19291 bool any_need_reprocess
= false;
19292 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
19294 info_ptr
= read_attribute (reader
, &die
->attrs
[i
], &abbrev
->attrs
[i
],
19296 if (die
->attrs
[i
].requires_reprocessing_p ())
19297 any_need_reprocess
= true;
19300 struct attribute
*attr
= die
->attr (DW_AT_str_offsets_base
);
19301 if (attr
!= nullptr && attr
->form_is_unsigned ())
19302 cu
->str_offsets_base
= attr
->as_unsigned ();
19304 attr
= die
->attr (DW_AT_loclists_base
);
19305 if (attr
!= nullptr)
19306 cu
->loclist_base
= attr
->as_unsigned ();
19308 auto maybe_addr_base
= die
->addr_base ();
19309 if (maybe_addr_base
.has_value ())
19310 cu
->addr_base
= *maybe_addr_base
;
19312 attr
= die
->attr (DW_AT_rnglists_base
);
19313 if (attr
!= nullptr)
19314 cu
->rnglists_base
= attr
->as_unsigned ();
19316 if (any_need_reprocess
)
19318 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
19320 if (die
->attrs
[i
].requires_reprocessing_p ())
19321 read_attribute_reprocess (reader
, &die
->attrs
[i
], die
->tag
);
19328 /* Read a die and all its attributes.
19329 Set DIEP to point to a newly allocated die with its information,
19330 except for its child, sibling, and parent fields. */
19332 static const gdb_byte
*
19333 read_full_die (const struct die_reader_specs
*reader
,
19334 struct die_info
**diep
, const gdb_byte
*info_ptr
)
19336 const gdb_byte
*result
;
19338 result
= read_full_die_1 (reader
, diep
, info_ptr
, 0);
19340 if (dwarf_die_debug
)
19342 fprintf_unfiltered (gdb_stdlog
,
19343 "Read die from %s@0x%x of %s:\n",
19344 reader
->die_section
->get_name (),
19345 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
19346 bfd_get_filename (reader
->abfd
));
19347 dump_die (*diep
, dwarf_die_debug
);
19354 /* Returns nonzero if TAG represents a type that we might generate a partial
19358 is_type_tag_for_partial (int tag
, enum language lang
)
19363 /* Some types that would be reasonable to generate partial symbols for,
19364 that we don't at present. Note that normally this does not
19365 matter, mainly because C compilers don't give names to these
19366 types, but instead emit DW_TAG_typedef. */
19367 case DW_TAG_file_type
:
19368 case DW_TAG_ptr_to_member_type
:
19369 case DW_TAG_set_type
:
19370 case DW_TAG_string_type
:
19371 case DW_TAG_subroutine_type
:
19374 /* GNAT may emit an array with a name, but no typedef, so we
19375 need to make a symbol in this case. */
19376 case DW_TAG_array_type
:
19377 return lang
== language_ada
;
19379 case DW_TAG_base_type
:
19380 case DW_TAG_class_type
:
19381 case DW_TAG_interface_type
:
19382 case DW_TAG_enumeration_type
:
19383 case DW_TAG_structure_type
:
19384 case DW_TAG_subrange_type
:
19385 case DW_TAG_typedef
:
19386 case DW_TAG_union_type
:
19393 /* Load all DIEs that are interesting for partial symbols into memory. */
19395 static struct partial_die_info
*
19396 load_partial_dies (const struct die_reader_specs
*reader
,
19397 const gdb_byte
*info_ptr
, int building_psymtab
)
19399 struct dwarf2_cu
*cu
= reader
->cu
;
19400 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
19401 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
19402 unsigned int bytes_read
;
19403 unsigned int load_all
= 0;
19404 int nesting_level
= 1;
19409 gdb_assert (cu
->per_cu
!= NULL
);
19410 if (cu
->per_cu
->load_all_dies
)
19414 = htab_create_alloc_ex (cu
->header
.length
/ 12,
19418 &cu
->comp_unit_obstack
,
19419 hashtab_obstack_allocate
,
19420 dummy_obstack_deallocate
);
19424 abbrev_info
*abbrev
= peek_die_abbrev (*reader
, info_ptr
, &bytes_read
);
19426 /* A NULL abbrev means the end of a series of children. */
19427 if (abbrev
== NULL
)
19429 if (--nesting_level
== 0)
19432 info_ptr
+= bytes_read
;
19433 last_die
= parent_die
;
19434 parent_die
= parent_die
->die_parent
;
19438 /* Check for template arguments. We never save these; if
19439 they're seen, we just mark the parent, and go on our way. */
19440 if (parent_die
!= NULL
19441 && cu
->language
== language_cplus
19442 && (abbrev
->tag
== DW_TAG_template_type_param
19443 || abbrev
->tag
== DW_TAG_template_value_param
))
19445 parent_die
->has_template_arguments
= 1;
19449 /* We don't need a partial DIE for the template argument. */
19450 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
19455 /* We only recurse into c++ subprograms looking for template arguments.
19456 Skip their other children. */
19458 && cu
->language
== language_cplus
19459 && parent_die
!= NULL
19460 && parent_die
->tag
== DW_TAG_subprogram
19461 && abbrev
->tag
!= DW_TAG_inlined_subroutine
)
19463 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
19467 /* Check whether this DIE is interesting enough to save. Normally
19468 we would not be interested in members here, but there may be
19469 later variables referencing them via DW_AT_specification (for
19470 static members). */
19472 && !is_type_tag_for_partial (abbrev
->tag
, cu
->language
)
19473 && abbrev
->tag
!= DW_TAG_constant
19474 && abbrev
->tag
!= DW_TAG_enumerator
19475 && abbrev
->tag
!= DW_TAG_subprogram
19476 && abbrev
->tag
!= DW_TAG_inlined_subroutine
19477 && abbrev
->tag
!= DW_TAG_lexical_block
19478 && abbrev
->tag
!= DW_TAG_variable
19479 && abbrev
->tag
!= DW_TAG_namespace
19480 && abbrev
->tag
!= DW_TAG_module
19481 && abbrev
->tag
!= DW_TAG_member
19482 && abbrev
->tag
!= DW_TAG_imported_unit
19483 && abbrev
->tag
!= DW_TAG_imported_declaration
)
19485 /* Otherwise we skip to the next sibling, if any. */
19486 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
19490 struct partial_die_info
pdi ((sect_offset
) (info_ptr
- reader
->buffer
),
19493 info_ptr
= pdi
.read (reader
, *abbrev
, info_ptr
+ bytes_read
);
19495 /* This two-pass algorithm for processing partial symbols has a
19496 high cost in cache pressure. Thus, handle some simple cases
19497 here which cover the majority of C partial symbols. DIEs
19498 which neither have specification tags in them, nor could have
19499 specification tags elsewhere pointing at them, can simply be
19500 processed and discarded.
19502 This segment is also optional; scan_partial_symbols and
19503 add_partial_symbol will handle these DIEs if we chain
19504 them in normally. When compilers which do not emit large
19505 quantities of duplicate debug information are more common,
19506 this code can probably be removed. */
19508 /* Any complete simple types at the top level (pretty much all
19509 of them, for a language without namespaces), can be processed
19511 if (parent_die
== NULL
19512 && pdi
.has_specification
== 0
19513 && pdi
.is_declaration
== 0
19514 && ((pdi
.tag
== DW_TAG_typedef
&& !pdi
.has_children
)
19515 || pdi
.tag
== DW_TAG_base_type
19516 || pdi
.tag
== DW_TAG_array_type
19517 || pdi
.tag
== DW_TAG_subrange_type
))
19519 if (building_psymtab
&& pdi
.raw_name
!= NULL
)
19520 add_partial_symbol (&pdi
, cu
);
19522 info_ptr
= locate_pdi_sibling (reader
, &pdi
, info_ptr
);
19526 /* The exception for DW_TAG_typedef with has_children above is
19527 a workaround of GCC PR debug/47510. In the case of this complaint
19528 type_name_or_error will error on such types later.
19530 GDB skipped children of DW_TAG_typedef by the shortcut above and then
19531 it could not find the child DIEs referenced later, this is checked
19532 above. In correct DWARF DW_TAG_typedef should have no children. */
19534 if (pdi
.tag
== DW_TAG_typedef
&& pdi
.has_children
)
19535 complaint (_("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
19536 "- DIE at %s [in module %s]"),
19537 sect_offset_str (pdi
.sect_off
), objfile_name (objfile
));
19539 /* If we're at the second level, and we're an enumerator, and
19540 our parent has no specification (meaning possibly lives in a
19541 namespace elsewhere), then we can add the partial symbol now
19542 instead of queueing it. */
19543 if (pdi
.tag
== DW_TAG_enumerator
19544 && parent_die
!= NULL
19545 && parent_die
->die_parent
== NULL
19546 && parent_die
->tag
== DW_TAG_enumeration_type
19547 && parent_die
->has_specification
== 0)
19549 if (pdi
.raw_name
== NULL
)
19550 complaint (_("malformed enumerator DIE ignored"));
19551 else if (building_psymtab
)
19552 add_partial_symbol (&pdi
, cu
);
19554 info_ptr
= locate_pdi_sibling (reader
, &pdi
, info_ptr
);
19558 struct partial_die_info
*part_die
19559 = new (&cu
->comp_unit_obstack
) partial_die_info (pdi
);
19561 /* We'll save this DIE so link it in. */
19562 part_die
->die_parent
= parent_die
;
19563 part_die
->die_sibling
= NULL
;
19564 part_die
->die_child
= NULL
;
19566 if (last_die
&& last_die
== parent_die
)
19567 last_die
->die_child
= part_die
;
19569 last_die
->die_sibling
= part_die
;
19571 last_die
= part_die
;
19573 if (first_die
== NULL
)
19574 first_die
= part_die
;
19576 /* Maybe add the DIE to the hash table. Not all DIEs that we
19577 find interesting need to be in the hash table, because we
19578 also have the parent/sibling/child chains; only those that we
19579 might refer to by offset later during partial symbol reading.
19581 For now this means things that might have be the target of a
19582 DW_AT_specification, DW_AT_abstract_origin, or
19583 DW_AT_extension. DW_AT_extension will refer only to
19584 namespaces; DW_AT_abstract_origin refers to functions (and
19585 many things under the function DIE, but we do not recurse
19586 into function DIEs during partial symbol reading) and
19587 possibly variables as well; DW_AT_specification refers to
19588 declarations. Declarations ought to have the DW_AT_declaration
19589 flag. It happens that GCC forgets to put it in sometimes, but
19590 only for functions, not for types.
19592 Adding more things than necessary to the hash table is harmless
19593 except for the performance cost. Adding too few will result in
19594 wasted time in find_partial_die, when we reread the compilation
19595 unit with load_all_dies set. */
19598 || abbrev
->tag
== DW_TAG_constant
19599 || abbrev
->tag
== DW_TAG_subprogram
19600 || abbrev
->tag
== DW_TAG_variable
19601 || abbrev
->tag
== DW_TAG_namespace
19602 || part_die
->is_declaration
)
19606 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
19607 to_underlying (part_die
->sect_off
),
19612 /* For some DIEs we want to follow their children (if any). For C
19613 we have no reason to follow the children of structures; for other
19614 languages we have to, so that we can get at method physnames
19615 to infer fully qualified class names, for DW_AT_specification,
19616 and for C++ template arguments. For C++, we also look one level
19617 inside functions to find template arguments (if the name of the
19618 function does not already contain the template arguments).
19620 For Ada and Fortran, we need to scan the children of subprograms
19621 and lexical blocks as well because these languages allow the
19622 definition of nested entities that could be interesting for the
19623 debugger, such as nested subprograms for instance. */
19624 if (last_die
->has_children
19626 || last_die
->tag
== DW_TAG_namespace
19627 || last_die
->tag
== DW_TAG_module
19628 || last_die
->tag
== DW_TAG_enumeration_type
19629 || (cu
->language
== language_cplus
19630 && last_die
->tag
== DW_TAG_subprogram
19631 && (last_die
->raw_name
== NULL
19632 || strchr (last_die
->raw_name
, '<') == NULL
))
19633 || (cu
->language
!= language_c
19634 && (last_die
->tag
== DW_TAG_class_type
19635 || last_die
->tag
== DW_TAG_interface_type
19636 || last_die
->tag
== DW_TAG_structure_type
19637 || last_die
->tag
== DW_TAG_union_type
))
19638 || ((cu
->language
== language_ada
19639 || cu
->language
== language_fortran
)
19640 && (last_die
->tag
== DW_TAG_subprogram
19641 || last_die
->tag
== DW_TAG_lexical_block
))))
19644 parent_die
= last_die
;
19648 /* Otherwise we skip to the next sibling, if any. */
19649 info_ptr
= locate_pdi_sibling (reader
, last_die
, info_ptr
);
19651 /* Back to the top, do it again. */
19655 partial_die_info::partial_die_info (sect_offset sect_off_
,
19656 struct abbrev_info
*abbrev
)
19657 : partial_die_info (sect_off_
, abbrev
->tag
, abbrev
->has_children
)
19661 /* See class definition. */
19664 partial_die_info::name (dwarf2_cu
*cu
)
19666 if (!canonical_name
&& raw_name
!= nullptr)
19668 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
19669 raw_name
= dwarf2_canonicalize_name (raw_name
, cu
, objfile
);
19670 canonical_name
= 1;
19676 /* Read a minimal amount of information into the minimal die structure.
19677 INFO_PTR should point just after the initial uleb128 of a DIE. */
19680 partial_die_info::read (const struct die_reader_specs
*reader
,
19681 const struct abbrev_info
&abbrev
, const gdb_byte
*info_ptr
)
19683 struct dwarf2_cu
*cu
= reader
->cu
;
19684 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
19686 int has_low_pc_attr
= 0;
19687 int has_high_pc_attr
= 0;
19688 int high_pc_relative
= 0;
19690 for (i
= 0; i
< abbrev
.num_attrs
; ++i
)
19693 info_ptr
= read_attribute (reader
, &attr
, &abbrev
.attrs
[i
], info_ptr
);
19694 /* String and address offsets that need to do the reprocessing have
19695 already been read at this point, so there is no need to wait until
19696 the loop terminates to do the reprocessing. */
19697 if (attr
.requires_reprocessing_p ())
19698 read_attribute_reprocess (reader
, &attr
, tag
);
19699 /* Store the data if it is of an attribute we want to keep in a
19700 partial symbol table. */
19706 case DW_TAG_compile_unit
:
19707 case DW_TAG_partial_unit
:
19708 case DW_TAG_type_unit
:
19709 /* Compilation units have a DW_AT_name that is a filename, not
19710 a source language identifier. */
19711 case DW_TAG_enumeration_type
:
19712 case DW_TAG_enumerator
:
19713 /* These tags always have simple identifiers already; no need
19714 to canonicalize them. */
19715 canonical_name
= 1;
19716 raw_name
= attr
.as_string ();
19719 canonical_name
= 0;
19720 raw_name
= attr
.as_string ();
19724 case DW_AT_linkage_name
:
19725 case DW_AT_MIPS_linkage_name
:
19726 /* Note that both forms of linkage name might appear. We
19727 assume they will be the same, and we only store the last
19729 linkage_name
= attr
.as_string ();
19732 has_low_pc_attr
= 1;
19733 lowpc
= attr
.as_address ();
19735 case DW_AT_high_pc
:
19736 has_high_pc_attr
= 1;
19737 highpc
= attr
.as_address ();
19738 if (cu
->header
.version
>= 4 && attr
.form_is_constant ())
19739 high_pc_relative
= 1;
19741 case DW_AT_location
:
19742 /* Support the .debug_loc offsets. */
19743 if (attr
.form_is_block ())
19745 d
.locdesc
= attr
.as_block ();
19747 else if (attr
.form_is_section_offset ())
19749 dwarf2_complex_location_expr_complaint ();
19753 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
19754 "partial symbol information");
19757 case DW_AT_external
:
19758 is_external
= attr
.as_boolean ();
19760 case DW_AT_declaration
:
19761 is_declaration
= attr
.as_boolean ();
19766 case DW_AT_abstract_origin
:
19767 case DW_AT_specification
:
19768 case DW_AT_extension
:
19769 has_specification
= 1;
19770 spec_offset
= attr
.get_ref_die_offset ();
19771 spec_is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
19772 || cu
->per_cu
->is_dwz
);
19774 case DW_AT_sibling
:
19775 /* Ignore absolute siblings, they might point outside of
19776 the current compile unit. */
19777 if (attr
.form
== DW_FORM_ref_addr
)
19778 complaint (_("ignoring absolute DW_AT_sibling"));
19781 const gdb_byte
*buffer
= reader
->buffer
;
19782 sect_offset off
= attr
.get_ref_die_offset ();
19783 const gdb_byte
*sibling_ptr
= buffer
+ to_underlying (off
);
19785 if (sibling_ptr
< info_ptr
)
19786 complaint (_("DW_AT_sibling points backwards"));
19787 else if (sibling_ptr
> reader
->buffer_end
)
19788 reader
->die_section
->overflow_complaint ();
19790 sibling
= sibling_ptr
;
19793 case DW_AT_byte_size
:
19796 case DW_AT_const_value
:
19797 has_const_value
= 1;
19799 case DW_AT_calling_convention
:
19800 /* DWARF doesn't provide a way to identify a program's source-level
19801 entry point. DW_AT_calling_convention attributes are only meant
19802 to describe functions' calling conventions.
19804 However, because it's a necessary piece of information in
19805 Fortran, and before DWARF 4 DW_CC_program was the only
19806 piece of debugging information whose definition refers to
19807 a 'main program' at all, several compilers marked Fortran
19808 main programs with DW_CC_program --- even when those
19809 functions use the standard calling conventions.
19811 Although DWARF now specifies a way to provide this
19812 information, we support this practice for backward
19814 if (attr
.constant_value (0) == DW_CC_program
19815 && cu
->language
== language_fortran
)
19816 main_subprogram
= 1;
19820 LONGEST value
= attr
.constant_value (-1);
19821 if (value
== DW_INL_inlined
19822 || value
== DW_INL_declared_inlined
)
19823 may_be_inlined
= 1;
19828 if (tag
== DW_TAG_imported_unit
)
19830 d
.sect_off
= attr
.get_ref_die_offset ();
19831 is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
19832 || cu
->per_cu
->is_dwz
);
19836 case DW_AT_main_subprogram
:
19837 main_subprogram
= attr
.as_boolean ();
19842 /* Offset in the .debug_ranges or .debug_rnglist section (depending
19843 on DWARF version). */
19844 ULONGEST ranges_offset
= attr
.as_unsigned ();
19846 /* See dwarf2_cu::gnu_ranges_base's doc for why we might want to add
19848 if (tag
!= DW_TAG_compile_unit
)
19849 ranges_offset
+= cu
->gnu_ranges_base
;
19851 if (dwarf2_ranges_read (ranges_offset
, &lowpc
, &highpc
, cu
,
19862 /* For Ada, if both the name and the linkage name appear, we prefer
19863 the latter. This lets "catch exception" work better, regardless
19864 of the order in which the name and linkage name were emitted.
19865 Really, though, this is just a workaround for the fact that gdb
19866 doesn't store both the name and the linkage name. */
19867 if (cu
->language
== language_ada
&& linkage_name
!= nullptr)
19868 raw_name
= linkage_name
;
19870 if (high_pc_relative
)
19873 if (has_low_pc_attr
&& has_high_pc_attr
)
19875 /* When using the GNU linker, .gnu.linkonce. sections are used to
19876 eliminate duplicate copies of functions and vtables and such.
19877 The linker will arbitrarily choose one and discard the others.
19878 The AT_*_pc values for such functions refer to local labels in
19879 these sections. If the section from that file was discarded, the
19880 labels are not in the output, so the relocs get a value of 0.
19881 If this is a discarded function, mark the pc bounds as invalid,
19882 so that GDB will ignore it. */
19883 if (lowpc
== 0 && !per_objfile
->per_bfd
->has_section_at_zero
)
19885 struct objfile
*objfile
= per_objfile
->objfile
;
19886 struct gdbarch
*gdbarch
= objfile
->arch ();
19888 complaint (_("DW_AT_low_pc %s is zero "
19889 "for DIE at %s [in module %s]"),
19890 paddress (gdbarch
, lowpc
),
19891 sect_offset_str (sect_off
),
19892 objfile_name (objfile
));
19894 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
19895 else if (lowpc
>= highpc
)
19897 struct objfile
*objfile
= per_objfile
->objfile
;
19898 struct gdbarch
*gdbarch
= objfile
->arch ();
19900 complaint (_("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
19901 "for DIE at %s [in module %s]"),
19902 paddress (gdbarch
, lowpc
),
19903 paddress (gdbarch
, highpc
),
19904 sect_offset_str (sect_off
),
19905 objfile_name (objfile
));
19914 /* Find a cached partial DIE at OFFSET in CU. */
19916 struct partial_die_info
*
19917 dwarf2_cu::find_partial_die (sect_offset sect_off
)
19919 struct partial_die_info
*lookup_die
= NULL
;
19920 struct partial_die_info
part_die (sect_off
);
19922 lookup_die
= ((struct partial_die_info
*)
19923 htab_find_with_hash (partial_dies
, &part_die
,
19924 to_underlying (sect_off
)));
19929 /* Find a partial DIE at OFFSET, which may or may not be in CU,
19930 except in the case of .debug_types DIEs which do not reference
19931 outside their CU (they do however referencing other types via
19932 DW_FORM_ref_sig8). */
19934 static const struct cu_partial_die_info
19935 find_partial_die (sect_offset sect_off
, int offset_in_dwz
, struct dwarf2_cu
*cu
)
19937 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
19938 struct objfile
*objfile
= per_objfile
->objfile
;
19939 struct partial_die_info
*pd
= NULL
;
19941 if (offset_in_dwz
== cu
->per_cu
->is_dwz
19942 && cu
->header
.offset_in_cu_p (sect_off
))
19944 pd
= cu
->find_partial_die (sect_off
);
19947 /* We missed recording what we needed.
19948 Load all dies and try again. */
19952 /* TUs don't reference other CUs/TUs (except via type signatures). */
19953 if (cu
->per_cu
->is_debug_types
)
19955 error (_("Dwarf Error: Type Unit at offset %s contains"
19956 " external reference to offset %s [in module %s].\n"),
19957 sect_offset_str (cu
->header
.sect_off
), sect_offset_str (sect_off
),
19958 bfd_get_filename (objfile
->obfd
));
19960 dwarf2_per_cu_data
*per_cu
19961 = dwarf2_find_containing_comp_unit (sect_off
, offset_in_dwz
,
19964 cu
= per_objfile
->get_cu (per_cu
);
19965 if (cu
== NULL
|| cu
->partial_dies
== NULL
)
19966 load_partial_comp_unit (per_cu
, per_objfile
, nullptr);
19968 cu
= per_objfile
->get_cu (per_cu
);
19971 pd
= cu
->find_partial_die (sect_off
);
19974 /* If we didn't find it, and not all dies have been loaded,
19975 load them all and try again. */
19977 if (pd
== NULL
&& cu
->per_cu
->load_all_dies
== 0)
19979 cu
->per_cu
->load_all_dies
= 1;
19981 /* This is nasty. When we reread the DIEs, somewhere up the call chain
19982 THIS_CU->cu may already be in use. So we can't just free it and
19983 replace its DIEs with the ones we read in. Instead, we leave those
19984 DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
19985 and clobber THIS_CU->cu->partial_dies with the hash table for the new
19987 load_partial_comp_unit (cu
->per_cu
, per_objfile
, cu
);
19989 pd
= cu
->find_partial_die (sect_off
);
19993 error (_("Dwarf Error: Cannot not find DIE at %s [from module %s]\n"),
19994 sect_offset_str (sect_off
), bfd_get_filename (objfile
->obfd
));
19998 /* See if we can figure out if the class lives in a namespace. We do
19999 this by looking for a member function; its demangled name will
20000 contain namespace info, if there is any. */
20003 guess_partial_die_structure_name (struct partial_die_info
*struct_pdi
,
20004 struct dwarf2_cu
*cu
)
20006 /* NOTE: carlton/2003-10-07: Getting the info this way changes
20007 what template types look like, because the demangler
20008 frequently doesn't give the same name as the debug info. We
20009 could fix this by only using the demangled name to get the
20010 prefix (but see comment in read_structure_type). */
20012 struct partial_die_info
*real_pdi
;
20013 struct partial_die_info
*child_pdi
;
20015 /* If this DIE (this DIE's specification, if any) has a parent, then
20016 we should not do this. We'll prepend the parent's fully qualified
20017 name when we create the partial symbol. */
20019 real_pdi
= struct_pdi
;
20020 while (real_pdi
->has_specification
)
20022 auto res
= find_partial_die (real_pdi
->spec_offset
,
20023 real_pdi
->spec_is_dwz
, cu
);
20024 real_pdi
= res
.pdi
;
20028 if (real_pdi
->die_parent
!= NULL
)
20031 for (child_pdi
= struct_pdi
->die_child
;
20033 child_pdi
= child_pdi
->die_sibling
)
20035 if (child_pdi
->tag
== DW_TAG_subprogram
20036 && child_pdi
->linkage_name
!= NULL
)
20038 gdb::unique_xmalloc_ptr
<char> actual_class_name
20039 (cu
->language_defn
->class_name_from_physname
20040 (child_pdi
->linkage_name
));
20041 if (actual_class_name
!= NULL
)
20043 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
20044 struct_pdi
->raw_name
= objfile
->intern (actual_class_name
.get ());
20045 struct_pdi
->canonical_name
= 1;
20052 /* Return true if a DIE with TAG may have the DW_AT_const_value
20056 can_have_DW_AT_const_value_p (enum dwarf_tag tag
)
20060 case DW_TAG_constant
:
20061 case DW_TAG_enumerator
:
20062 case DW_TAG_formal_parameter
:
20063 case DW_TAG_template_value_param
:
20064 case DW_TAG_variable
:
20072 partial_die_info::fixup (struct dwarf2_cu
*cu
)
20074 /* Once we've fixed up a die, there's no point in doing so again.
20075 This also avoids a memory leak if we were to call
20076 guess_partial_die_structure_name multiple times. */
20080 /* If we found a reference attribute and the DIE has no name, try
20081 to find a name in the referred to DIE. */
20083 if (raw_name
== NULL
&& has_specification
)
20085 struct partial_die_info
*spec_die
;
20087 auto res
= find_partial_die (spec_offset
, spec_is_dwz
, cu
);
20088 spec_die
= res
.pdi
;
20091 spec_die
->fixup (cu
);
20093 if (spec_die
->raw_name
)
20095 raw_name
= spec_die
->raw_name
;
20096 canonical_name
= spec_die
->canonical_name
;
20098 /* Copy DW_AT_external attribute if it is set. */
20099 if (spec_die
->is_external
)
20100 is_external
= spec_die
->is_external
;
20104 if (!has_const_value
&& has_specification
20105 && can_have_DW_AT_const_value_p (tag
))
20107 struct partial_die_info
*spec_die
;
20109 auto res
= find_partial_die (spec_offset
, spec_is_dwz
, cu
);
20110 spec_die
= res
.pdi
;
20113 spec_die
->fixup (cu
);
20115 if (spec_die
->has_const_value
)
20117 /* Copy DW_AT_const_value attribute if it is set. */
20118 has_const_value
= spec_die
->has_const_value
;
20122 /* Set default names for some unnamed DIEs. */
20124 if (raw_name
== NULL
&& tag
== DW_TAG_namespace
)
20126 raw_name
= CP_ANONYMOUS_NAMESPACE_STR
;
20127 canonical_name
= 1;
20130 /* If there is no parent die to provide a namespace, and there are
20131 children, see if we can determine the namespace from their linkage
20133 if (cu
->language
== language_cplus
20134 && !cu
->per_objfile
->per_bfd
->types
.empty ()
20135 && die_parent
== NULL
20137 && (tag
== DW_TAG_class_type
20138 || tag
== DW_TAG_structure_type
20139 || tag
== DW_TAG_union_type
))
20140 guess_partial_die_structure_name (this, cu
);
20142 /* GCC might emit a nameless struct or union that has a linkage
20143 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
20144 if (raw_name
== NULL
20145 && (tag
== DW_TAG_class_type
20146 || tag
== DW_TAG_interface_type
20147 || tag
== DW_TAG_structure_type
20148 || tag
== DW_TAG_union_type
)
20149 && linkage_name
!= NULL
)
20151 gdb::unique_xmalloc_ptr
<char> demangled
20152 (gdb_demangle (linkage_name
, DMGL_TYPES
));
20153 if (demangled
!= nullptr)
20157 /* Strip any leading namespaces/classes, keep only the base name.
20158 DW_AT_name for named DIEs does not contain the prefixes. */
20159 base
= strrchr (demangled
.get (), ':');
20160 if (base
&& base
> demangled
.get () && base
[-1] == ':')
20163 base
= demangled
.get ();
20165 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
20166 raw_name
= objfile
->intern (base
);
20167 canonical_name
= 1;
20174 /* Read the .debug_loclists or .debug_rnglists header (they are the same format)
20175 contents from the given SECTION in the HEADER.
20177 HEADER_OFFSET is the offset of the header in the section. */
20179 read_loclists_rnglists_header (struct loclists_rnglists_header
*header
,
20180 struct dwarf2_section_info
*section
,
20181 sect_offset header_offset
)
20183 unsigned int bytes_read
;
20184 bfd
*abfd
= section
->get_bfd_owner ();
20185 const gdb_byte
*info_ptr
= section
->buffer
+ to_underlying (header_offset
);
20187 header
->length
= read_initial_length (abfd
, info_ptr
, &bytes_read
);
20188 info_ptr
+= bytes_read
;
20190 header
->version
= read_2_bytes (abfd
, info_ptr
);
20193 header
->addr_size
= read_1_byte (abfd
, info_ptr
);
20196 header
->segment_collector_size
= read_1_byte (abfd
, info_ptr
);
20199 header
->offset_entry_count
= read_4_bytes (abfd
, info_ptr
);
20202 /* Return the DW_AT_loclists_base value for the CU. */
20204 lookup_loclist_base (struct dwarf2_cu
*cu
)
20206 /* For the .dwo unit, the loclist_base points to the first offset following
20207 the header. The header consists of the following entities-
20208 1. Unit Length (4 bytes for 32 bit DWARF format, and 12 bytes for the 64
20210 2. version (2 bytes)
20211 3. address size (1 byte)
20212 4. segment selector size (1 byte)
20213 5. offset entry count (4 bytes)
20214 These sizes are derived as per the DWARFv5 standard. */
20215 if (cu
->dwo_unit
!= nullptr)
20217 if (cu
->header
.initial_length_size
== 4)
20218 return LOCLIST_HEADER_SIZE32
;
20219 return LOCLIST_HEADER_SIZE64
;
20221 return cu
->loclist_base
;
20224 /* Given a DW_FORM_loclistx value LOCLIST_INDEX, fetch the offset from the
20225 array of offsets in the .debug_loclists section. */
20228 read_loclist_index (struct dwarf2_cu
*cu
, ULONGEST loclist_index
)
20230 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
20231 struct objfile
*objfile
= per_objfile
->objfile
;
20232 bfd
*abfd
= objfile
->obfd
;
20233 ULONGEST loclist_header_size
=
20234 (cu
->header
.initial_length_size
== 4 ? LOCLIST_HEADER_SIZE32
20235 : LOCLIST_HEADER_SIZE64
);
20236 ULONGEST loclist_base
= lookup_loclist_base (cu
);
20238 /* Offset in .debug_loclists of the offset for LOCLIST_INDEX. */
20239 ULONGEST start_offset
=
20240 loclist_base
+ loclist_index
* cu
->header
.offset_size
;
20242 /* Get loclists section. */
20243 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
20245 /* Read the loclists section content. */
20246 section
->read (objfile
);
20247 if (section
->buffer
== NULL
)
20248 error (_("DW_FORM_loclistx used without .debug_loclists "
20249 "section [in module %s]"), objfile_name (objfile
));
20251 /* DW_AT_loclists_base points after the .debug_loclists contribution header,
20252 so if loclist_base is smaller than the header size, we have a problem. */
20253 if (loclist_base
< loclist_header_size
)
20254 error (_("DW_AT_loclists_base is smaller than header size [in module %s]"),
20255 objfile_name (objfile
));
20257 /* Read the header of the loclists contribution. */
20258 struct loclists_rnglists_header header
;
20259 read_loclists_rnglists_header (&header
, section
,
20260 (sect_offset
) (loclist_base
- loclist_header_size
));
20262 /* Verify the loclist index is valid. */
20263 if (loclist_index
>= header
.offset_entry_count
)
20264 error (_("DW_FORM_loclistx pointing outside of "
20265 ".debug_loclists offset array [in module %s]"),
20266 objfile_name (objfile
));
20268 /* Validate that reading won't go beyond the end of the section. */
20269 if (start_offset
+ cu
->header
.offset_size
> section
->size
)
20270 error (_("Reading DW_FORM_loclistx index beyond end of"
20271 ".debug_loclists section [in module %s]"),
20272 objfile_name (objfile
));
20274 const gdb_byte
*info_ptr
= section
->buffer
+ start_offset
;
20276 if (cu
->header
.offset_size
== 4)
20277 return (sect_offset
) (bfd_get_32 (abfd
, info_ptr
) + loclist_base
);
20279 return (sect_offset
) (bfd_get_64 (abfd
, info_ptr
) + loclist_base
);
20282 /* Given a DW_FORM_rnglistx value RNGLIST_INDEX, fetch the offset from the
20283 array of offsets in the .debug_rnglists section. */
20286 read_rnglist_index (struct dwarf2_cu
*cu
, ULONGEST rnglist_index
,
20289 struct dwarf2_per_objfile
*dwarf2_per_objfile
= cu
->per_objfile
;
20290 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
20291 bfd
*abfd
= objfile
->obfd
;
20292 ULONGEST rnglist_header_size
=
20293 (cu
->header
.initial_length_size
== 4 ? RNGLIST_HEADER_SIZE32
20294 : RNGLIST_HEADER_SIZE64
);
20296 /* When reading a DW_FORM_rnglistx from a DWO, we read from the DWO's
20297 .debug_rnglists.dwo section. The rnglists base given in the skeleton
20299 ULONGEST rnglist_base
=
20300 (cu
->dwo_unit
!= nullptr) ? rnglist_header_size
: cu
->rnglists_base
;
20302 /* Offset in .debug_rnglists of the offset for RNGLIST_INDEX. */
20303 ULONGEST start_offset
=
20304 rnglist_base
+ rnglist_index
* cu
->header
.offset_size
;
20306 /* Get rnglists section. */
20307 struct dwarf2_section_info
*section
= cu_debug_rnglists_section (cu
, tag
);
20309 /* Read the rnglists section content. */
20310 section
->read (objfile
);
20311 if (section
->buffer
== nullptr)
20312 error (_("DW_FORM_rnglistx used without .debug_rnglists section "
20314 objfile_name (objfile
));
20316 /* DW_AT_rnglists_base points after the .debug_rnglists contribution header,
20317 so if rnglist_base is smaller than the header size, we have a problem. */
20318 if (rnglist_base
< rnglist_header_size
)
20319 error (_("DW_AT_rnglists_base is smaller than header size [in module %s]"),
20320 objfile_name (objfile
));
20322 /* Read the header of the rnglists contribution. */
20323 struct loclists_rnglists_header header
;
20324 read_loclists_rnglists_header (&header
, section
,
20325 (sect_offset
) (rnglist_base
- rnglist_header_size
));
20327 /* Verify the rnglist index is valid. */
20328 if (rnglist_index
>= header
.offset_entry_count
)
20329 error (_("DW_FORM_rnglistx index pointing outside of "
20330 ".debug_rnglists offset array [in module %s]"),
20331 objfile_name (objfile
));
20333 /* Validate that reading won't go beyond the end of the section. */
20334 if (start_offset
+ cu
->header
.offset_size
> section
->size
)
20335 error (_("Reading DW_FORM_rnglistx index beyond end of"
20336 ".debug_rnglists section [in module %s]"),
20337 objfile_name (objfile
));
20339 const gdb_byte
*info_ptr
= section
->buffer
+ start_offset
;
20341 if (cu
->header
.offset_size
== 4)
20342 return (sect_offset
) (read_4_bytes (abfd
, info_ptr
) + rnglist_base
);
20344 return (sect_offset
) (read_8_bytes (abfd
, info_ptr
) + rnglist_base
);
20347 /* Process the attributes that had to be skipped in the first round. These
20348 attributes are the ones that need str_offsets_base or addr_base attributes.
20349 They could not have been processed in the first round, because at the time
20350 the values of str_offsets_base or addr_base may not have been known. */
20352 read_attribute_reprocess (const struct die_reader_specs
*reader
,
20353 struct attribute
*attr
, dwarf_tag tag
)
20355 struct dwarf2_cu
*cu
= reader
->cu
;
20356 switch (attr
->form
)
20358 case DW_FORM_addrx
:
20359 case DW_FORM_GNU_addr_index
:
20360 attr
->set_address (read_addr_index (cu
,
20361 attr
->as_unsigned_reprocess ()));
20363 case DW_FORM_loclistx
:
20365 sect_offset loclists_sect_off
20366 = read_loclist_index (cu
, attr
->as_unsigned_reprocess ());
20368 attr
->set_unsigned (to_underlying (loclists_sect_off
));
20371 case DW_FORM_rnglistx
:
20373 sect_offset rnglists_sect_off
20374 = read_rnglist_index (cu
, attr
->as_unsigned_reprocess (), tag
);
20376 attr
->set_unsigned (to_underlying (rnglists_sect_off
));
20380 case DW_FORM_strx1
:
20381 case DW_FORM_strx2
:
20382 case DW_FORM_strx3
:
20383 case DW_FORM_strx4
:
20384 case DW_FORM_GNU_str_index
:
20386 unsigned int str_index
= attr
->as_unsigned_reprocess ();
20387 gdb_assert (!attr
->canonical_string_p ());
20388 if (reader
->dwo_file
!= NULL
)
20389 attr
->set_string_noncanonical (read_dwo_str_index (reader
,
20392 attr
->set_string_noncanonical (read_stub_str_index (cu
,
20397 gdb_assert_not_reached (_("Unexpected DWARF form."));
20401 /* Read an attribute value described by an attribute form. */
20403 static const gdb_byte
*
20404 read_attribute_value (const struct die_reader_specs
*reader
,
20405 struct attribute
*attr
, unsigned form
,
20406 LONGEST implicit_const
, const gdb_byte
*info_ptr
)
20408 struct dwarf2_cu
*cu
= reader
->cu
;
20409 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
20410 struct objfile
*objfile
= per_objfile
->objfile
;
20411 bfd
*abfd
= reader
->abfd
;
20412 struct comp_unit_head
*cu_header
= &cu
->header
;
20413 unsigned int bytes_read
;
20414 struct dwarf_block
*blk
;
20416 attr
->form
= (enum dwarf_form
) form
;
20419 case DW_FORM_ref_addr
:
20420 if (cu
->header
.version
== 2)
20421 attr
->set_unsigned (cu
->header
.read_address (abfd
, info_ptr
,
20424 attr
->set_unsigned (cu
->header
.read_offset (abfd
, info_ptr
,
20426 info_ptr
+= bytes_read
;
20428 case DW_FORM_GNU_ref_alt
:
20429 attr
->set_unsigned (cu
->header
.read_offset (abfd
, info_ptr
,
20431 info_ptr
+= bytes_read
;
20435 struct gdbarch
*gdbarch
= objfile
->arch ();
20436 CORE_ADDR addr
= cu
->header
.read_address (abfd
, info_ptr
, &bytes_read
);
20437 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, addr
);
20438 attr
->set_address (addr
);
20439 info_ptr
+= bytes_read
;
20442 case DW_FORM_block2
:
20443 blk
= dwarf_alloc_block (cu
);
20444 blk
->size
= read_2_bytes (abfd
, info_ptr
);
20446 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
20447 info_ptr
+= blk
->size
;
20448 attr
->set_block (blk
);
20450 case DW_FORM_block4
:
20451 blk
= dwarf_alloc_block (cu
);
20452 blk
->size
= read_4_bytes (abfd
, info_ptr
);
20454 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
20455 info_ptr
+= blk
->size
;
20456 attr
->set_block (blk
);
20458 case DW_FORM_data2
:
20459 attr
->set_unsigned (read_2_bytes (abfd
, info_ptr
));
20462 case DW_FORM_data4
:
20463 attr
->set_unsigned (read_4_bytes (abfd
, info_ptr
));
20466 case DW_FORM_data8
:
20467 attr
->set_unsigned (read_8_bytes (abfd
, info_ptr
));
20470 case DW_FORM_data16
:
20471 blk
= dwarf_alloc_block (cu
);
20473 blk
->data
= read_n_bytes (abfd
, info_ptr
, 16);
20475 attr
->set_block (blk
);
20477 case DW_FORM_sec_offset
:
20478 attr
->set_unsigned (cu
->header
.read_offset (abfd
, info_ptr
,
20480 info_ptr
+= bytes_read
;
20482 case DW_FORM_loclistx
:
20484 attr
->set_unsigned_reprocess (read_unsigned_leb128 (abfd
, info_ptr
,
20486 info_ptr
+= bytes_read
;
20489 case DW_FORM_string
:
20490 attr
->set_string_noncanonical (read_direct_string (abfd
, info_ptr
,
20492 info_ptr
+= bytes_read
;
20495 if (!cu
->per_cu
->is_dwz
)
20497 attr
->set_string_noncanonical
20498 (read_indirect_string (per_objfile
,
20499 abfd
, info_ptr
, cu_header
,
20501 info_ptr
+= bytes_read
;
20505 case DW_FORM_line_strp
:
20506 if (!cu
->per_cu
->is_dwz
)
20508 attr
->set_string_noncanonical
20509 (per_objfile
->read_line_string (info_ptr
, cu_header
,
20511 info_ptr
+= bytes_read
;
20515 case DW_FORM_GNU_strp_alt
:
20517 dwz_file
*dwz
= dwarf2_get_dwz_file (per_objfile
->per_bfd
);
20518 LONGEST str_offset
= cu_header
->read_offset (abfd
, info_ptr
,
20521 attr
->set_string_noncanonical
20522 (dwz
->read_string (objfile
, str_offset
));
20523 info_ptr
+= bytes_read
;
20526 case DW_FORM_exprloc
:
20527 case DW_FORM_block
:
20528 blk
= dwarf_alloc_block (cu
);
20529 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
20530 info_ptr
+= bytes_read
;
20531 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
20532 info_ptr
+= blk
->size
;
20533 attr
->set_block (blk
);
20535 case DW_FORM_block1
:
20536 blk
= dwarf_alloc_block (cu
);
20537 blk
->size
= read_1_byte (abfd
, info_ptr
);
20539 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
20540 info_ptr
+= blk
->size
;
20541 attr
->set_block (blk
);
20543 case DW_FORM_data1
:
20545 attr
->set_unsigned (read_1_byte (abfd
, info_ptr
));
20548 case DW_FORM_flag_present
:
20549 attr
->set_unsigned (1);
20551 case DW_FORM_sdata
:
20552 attr
->set_signed (read_signed_leb128 (abfd
, info_ptr
, &bytes_read
));
20553 info_ptr
+= bytes_read
;
20555 case DW_FORM_rnglistx
:
20557 attr
->set_unsigned_reprocess (read_unsigned_leb128 (abfd
, info_ptr
,
20559 info_ptr
+= bytes_read
;
20562 case DW_FORM_udata
:
20563 attr
->set_unsigned (read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
20564 info_ptr
+= bytes_read
;
20567 attr
->set_unsigned ((to_underlying (cu
->header
.sect_off
)
20568 + read_1_byte (abfd
, info_ptr
)));
20572 attr
->set_unsigned ((to_underlying (cu
->header
.sect_off
)
20573 + read_2_bytes (abfd
, info_ptr
)));
20577 attr
->set_unsigned ((to_underlying (cu
->header
.sect_off
)
20578 + read_4_bytes (abfd
, info_ptr
)));
20582 attr
->set_unsigned ((to_underlying (cu
->header
.sect_off
)
20583 + read_8_bytes (abfd
, info_ptr
)));
20586 case DW_FORM_ref_sig8
:
20587 attr
->set_signature (read_8_bytes (abfd
, info_ptr
));
20590 case DW_FORM_ref_udata
:
20591 attr
->set_unsigned ((to_underlying (cu
->header
.sect_off
)
20592 + read_unsigned_leb128 (abfd
, info_ptr
,
20594 info_ptr
+= bytes_read
;
20596 case DW_FORM_indirect
:
20597 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
20598 info_ptr
+= bytes_read
;
20599 if (form
== DW_FORM_implicit_const
)
20601 implicit_const
= read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
20602 info_ptr
+= bytes_read
;
20604 info_ptr
= read_attribute_value (reader
, attr
, form
, implicit_const
,
20607 case DW_FORM_implicit_const
:
20608 attr
->set_signed (implicit_const
);
20610 case DW_FORM_addrx
:
20611 case DW_FORM_GNU_addr_index
:
20612 attr
->set_unsigned_reprocess (read_unsigned_leb128 (abfd
, info_ptr
,
20614 info_ptr
+= bytes_read
;
20617 case DW_FORM_strx1
:
20618 case DW_FORM_strx2
:
20619 case DW_FORM_strx3
:
20620 case DW_FORM_strx4
:
20621 case DW_FORM_GNU_str_index
:
20623 ULONGEST str_index
;
20624 if (form
== DW_FORM_strx1
)
20626 str_index
= read_1_byte (abfd
, info_ptr
);
20629 else if (form
== DW_FORM_strx2
)
20631 str_index
= read_2_bytes (abfd
, info_ptr
);
20634 else if (form
== DW_FORM_strx3
)
20636 str_index
= read_3_bytes (abfd
, info_ptr
);
20639 else if (form
== DW_FORM_strx4
)
20641 str_index
= read_4_bytes (abfd
, info_ptr
);
20646 str_index
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
20647 info_ptr
+= bytes_read
;
20649 attr
->set_unsigned_reprocess (str_index
);
20653 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
20654 dwarf_form_name (form
),
20655 bfd_get_filename (abfd
));
20659 if (cu
->per_cu
->is_dwz
&& attr
->form_is_ref ())
20660 attr
->form
= DW_FORM_GNU_ref_alt
;
20662 /* We have seen instances where the compiler tried to emit a byte
20663 size attribute of -1 which ended up being encoded as an unsigned
20664 0xffffffff. Although 0xffffffff is technically a valid size value,
20665 an object of this size seems pretty unlikely so we can relatively
20666 safely treat these cases as if the size attribute was invalid and
20667 treat them as zero by default. */
20668 if (attr
->name
== DW_AT_byte_size
20669 && form
== DW_FORM_data4
20670 && attr
->as_unsigned () >= 0xffffffff)
20673 (_("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
20674 hex_string (attr
->as_unsigned ()));
20675 attr
->set_unsigned (0);
20681 /* Read an attribute described by an abbreviated attribute. */
20683 static const gdb_byte
*
20684 read_attribute (const struct die_reader_specs
*reader
,
20685 struct attribute
*attr
, struct attr_abbrev
*abbrev
,
20686 const gdb_byte
*info_ptr
)
20688 attr
->name
= abbrev
->name
;
20689 attr
->string_is_canonical
= 0;
20690 attr
->requires_reprocessing
= 0;
20691 return read_attribute_value (reader
, attr
, abbrev
->form
,
20692 abbrev
->implicit_const
, info_ptr
);
20695 /* Return pointer to string at .debug_str offset STR_OFFSET. */
20697 static const char *
20698 read_indirect_string_at_offset (dwarf2_per_objfile
*per_objfile
,
20699 LONGEST str_offset
)
20701 return per_objfile
->per_bfd
->str
.read_string (per_objfile
->objfile
,
20702 str_offset
, "DW_FORM_strp");
20705 /* Return pointer to string at .debug_str offset as read from BUF.
20706 BUF is assumed to be in a compilation unit described by CU_HEADER.
20707 Return *BYTES_READ_PTR count of bytes read from BUF. */
20709 static const char *
20710 read_indirect_string (dwarf2_per_objfile
*per_objfile
, bfd
*abfd
,
20711 const gdb_byte
*buf
,
20712 const struct comp_unit_head
*cu_header
,
20713 unsigned int *bytes_read_ptr
)
20715 LONGEST str_offset
= cu_header
->read_offset (abfd
, buf
, bytes_read_ptr
);
20717 return read_indirect_string_at_offset (per_objfile
, str_offset
);
20723 dwarf2_per_objfile::read_line_string (const gdb_byte
*buf
,
20724 const struct comp_unit_head
*cu_header
,
20725 unsigned int *bytes_read_ptr
)
20727 bfd
*abfd
= objfile
->obfd
;
20728 LONGEST str_offset
= cu_header
->read_offset (abfd
, buf
, bytes_read_ptr
);
20730 return per_bfd
->line_str
.read_string (objfile
, str_offset
, "DW_FORM_line_strp");
20733 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
20734 ADDR_BASE is the DW_AT_addr_base (DW_AT_GNU_addr_base) attribute or zero.
20735 ADDR_SIZE is the size of addresses from the CU header. */
20738 read_addr_index_1 (dwarf2_per_objfile
*per_objfile
, unsigned int addr_index
,
20739 gdb::optional
<ULONGEST
> addr_base
, int addr_size
)
20741 struct objfile
*objfile
= per_objfile
->objfile
;
20742 bfd
*abfd
= objfile
->obfd
;
20743 const gdb_byte
*info_ptr
;
20744 ULONGEST addr_base_or_zero
= addr_base
.has_value () ? *addr_base
: 0;
20746 per_objfile
->per_bfd
->addr
.read (objfile
);
20747 if (per_objfile
->per_bfd
->addr
.buffer
== NULL
)
20748 error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
20749 objfile_name (objfile
));
20750 if (addr_base_or_zero
+ addr_index
* addr_size
20751 >= per_objfile
->per_bfd
->addr
.size
)
20752 error (_("DW_FORM_addr_index pointing outside of "
20753 ".debug_addr section [in module %s]"),
20754 objfile_name (objfile
));
20755 info_ptr
= (per_objfile
->per_bfd
->addr
.buffer
+ addr_base_or_zero
20756 + addr_index
* addr_size
);
20757 if (addr_size
== 4)
20758 return bfd_get_32 (abfd
, info_ptr
);
20760 return bfd_get_64 (abfd
, info_ptr
);
20763 /* Given index ADDR_INDEX in .debug_addr, fetch the value. */
20766 read_addr_index (struct dwarf2_cu
*cu
, unsigned int addr_index
)
20768 return read_addr_index_1 (cu
->per_objfile
, addr_index
,
20769 cu
->addr_base
, cu
->header
.addr_size
);
20772 /* Given a pointer to an leb128 value, fetch the value from .debug_addr. */
20775 read_addr_index_from_leb128 (struct dwarf2_cu
*cu
, const gdb_byte
*info_ptr
,
20776 unsigned int *bytes_read
)
20778 bfd
*abfd
= cu
->per_objfile
->objfile
->obfd
;
20779 unsigned int addr_index
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
20781 return read_addr_index (cu
, addr_index
);
20787 dwarf2_read_addr_index (dwarf2_per_cu_data
*per_cu
,
20788 dwarf2_per_objfile
*per_objfile
,
20789 unsigned int addr_index
)
20791 struct dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
20792 gdb::optional
<ULONGEST
> addr_base
;
20795 /* We need addr_base and addr_size.
20796 If we don't have PER_CU->cu, we have to get it.
20797 Nasty, but the alternative is storing the needed info in PER_CU,
20798 which at this point doesn't seem justified: it's not clear how frequently
20799 it would get used and it would increase the size of every PER_CU.
20800 Entry points like dwarf2_per_cu_addr_size do a similar thing
20801 so we're not in uncharted territory here.
20802 Alas we need to be a bit more complicated as addr_base is contained
20805 We don't need to read the entire CU(/TU).
20806 We just need the header and top level die.
20808 IWBN to use the aging mechanism to let us lazily later discard the CU.
20809 For now we skip this optimization. */
20813 addr_base
= cu
->addr_base
;
20814 addr_size
= cu
->header
.addr_size
;
20818 cutu_reader
reader (per_cu
, per_objfile
, nullptr, nullptr, false);
20819 addr_base
= reader
.cu
->addr_base
;
20820 addr_size
= reader
.cu
->header
.addr_size
;
20823 return read_addr_index_1 (per_objfile
, addr_index
, addr_base
, addr_size
);
20826 /* Given a DW_FORM_GNU_str_index value STR_INDEX, fetch the string.
20827 STR_SECTION, STR_OFFSETS_SECTION can be from a Fission stub or a
20830 static const char *
20831 read_str_index (struct dwarf2_cu
*cu
,
20832 struct dwarf2_section_info
*str_section
,
20833 struct dwarf2_section_info
*str_offsets_section
,
20834 ULONGEST str_offsets_base
, ULONGEST str_index
)
20836 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
20837 struct objfile
*objfile
= per_objfile
->objfile
;
20838 const char *objf_name
= objfile_name (objfile
);
20839 bfd
*abfd
= objfile
->obfd
;
20840 const gdb_byte
*info_ptr
;
20841 ULONGEST str_offset
;
20842 static const char form_name
[] = "DW_FORM_GNU_str_index or DW_FORM_strx";
20844 str_section
->read (objfile
);
20845 str_offsets_section
->read (objfile
);
20846 if (str_section
->buffer
== NULL
)
20847 error (_("%s used without %s section"
20848 " in CU at offset %s [in module %s]"),
20849 form_name
, str_section
->get_name (),
20850 sect_offset_str (cu
->header
.sect_off
), objf_name
);
20851 if (str_offsets_section
->buffer
== NULL
)
20852 error (_("%s used without %s section"
20853 " in CU at offset %s [in module %s]"),
20854 form_name
, str_section
->get_name (),
20855 sect_offset_str (cu
->header
.sect_off
), objf_name
);
20856 info_ptr
= (str_offsets_section
->buffer
20858 + str_index
* cu
->header
.offset_size
);
20859 if (cu
->header
.offset_size
== 4)
20860 str_offset
= bfd_get_32 (abfd
, info_ptr
);
20862 str_offset
= bfd_get_64 (abfd
, info_ptr
);
20863 if (str_offset
>= str_section
->size
)
20864 error (_("Offset from %s pointing outside of"
20865 " .debug_str.dwo section in CU at offset %s [in module %s]"),
20866 form_name
, sect_offset_str (cu
->header
.sect_off
), objf_name
);
20867 return (const char *) (str_section
->buffer
+ str_offset
);
20870 /* Given a DW_FORM_GNU_str_index from a DWO file, fetch the string. */
20872 static const char *
20873 read_dwo_str_index (const struct die_reader_specs
*reader
, ULONGEST str_index
)
20875 ULONGEST str_offsets_base
= reader
->cu
->header
.version
>= 5
20876 ? reader
->cu
->header
.addr_size
: 0;
20877 return read_str_index (reader
->cu
,
20878 &reader
->dwo_file
->sections
.str
,
20879 &reader
->dwo_file
->sections
.str_offsets
,
20880 str_offsets_base
, str_index
);
20883 /* Given a DW_FORM_GNU_str_index from a Fission stub, fetch the string. */
20885 static const char *
20886 read_stub_str_index (struct dwarf2_cu
*cu
, ULONGEST str_index
)
20888 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
20889 const char *objf_name
= objfile_name (objfile
);
20890 static const char form_name
[] = "DW_FORM_GNU_str_index";
20891 static const char str_offsets_attr_name
[] = "DW_AT_str_offsets";
20893 if (!cu
->str_offsets_base
.has_value ())
20894 error (_("%s used in Fission stub without %s"
20895 " in CU at offset 0x%lx [in module %s]"),
20896 form_name
, str_offsets_attr_name
,
20897 (long) cu
->header
.offset_size
, objf_name
);
20899 return read_str_index (cu
,
20900 &cu
->per_objfile
->per_bfd
->str
,
20901 &cu
->per_objfile
->per_bfd
->str_offsets
,
20902 *cu
->str_offsets_base
, str_index
);
20905 /* Return the length of an LEB128 number in BUF. */
20908 leb128_size (const gdb_byte
*buf
)
20910 const gdb_byte
*begin
= buf
;
20916 if ((byte
& 128) == 0)
20917 return buf
- begin
;
20922 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
20931 cu
->language
= language_c
;
20934 case DW_LANG_C_plus_plus
:
20935 case DW_LANG_C_plus_plus_11
:
20936 case DW_LANG_C_plus_plus_14
:
20937 cu
->language
= language_cplus
;
20940 cu
->language
= language_d
;
20942 case DW_LANG_Fortran77
:
20943 case DW_LANG_Fortran90
:
20944 case DW_LANG_Fortran95
:
20945 case DW_LANG_Fortran03
:
20946 case DW_LANG_Fortran08
:
20947 cu
->language
= language_fortran
;
20950 cu
->language
= language_go
;
20952 case DW_LANG_Mips_Assembler
:
20953 cu
->language
= language_asm
;
20955 case DW_LANG_Ada83
:
20956 case DW_LANG_Ada95
:
20957 cu
->language
= language_ada
;
20959 case DW_LANG_Modula2
:
20960 cu
->language
= language_m2
;
20962 case DW_LANG_Pascal83
:
20963 cu
->language
= language_pascal
;
20966 cu
->language
= language_objc
;
20969 case DW_LANG_Rust_old
:
20970 cu
->language
= language_rust
;
20972 case DW_LANG_Cobol74
:
20973 case DW_LANG_Cobol85
:
20975 cu
->language
= language_minimal
;
20978 cu
->language_defn
= language_def (cu
->language
);
20981 /* Return the named attribute or NULL if not there. */
20983 static struct attribute
*
20984 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
20989 struct attribute
*spec
= NULL
;
20991 for (i
= 0; i
< die
->num_attrs
; ++i
)
20993 if (die
->attrs
[i
].name
== name
)
20994 return &die
->attrs
[i
];
20995 if (die
->attrs
[i
].name
== DW_AT_specification
20996 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
20997 spec
= &die
->attrs
[i
];
21003 die
= follow_die_ref (die
, spec
, &cu
);
21009 /* Return the string associated with a string-typed attribute, or NULL if it
21010 is either not found or is of an incorrect type. */
21012 static const char *
21013 dwarf2_string_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
21015 struct attribute
*attr
;
21016 const char *str
= NULL
;
21018 attr
= dwarf2_attr (die
, name
, cu
);
21022 str
= attr
->as_string ();
21023 if (str
== nullptr)
21024 complaint (_("string type expected for attribute %s for "
21025 "DIE at %s in module %s"),
21026 dwarf_attr_name (name
), sect_offset_str (die
->sect_off
),
21027 objfile_name (cu
->per_objfile
->objfile
));
21033 /* Return the dwo name or NULL if not present. If present, it is in either
21034 DW_AT_GNU_dwo_name or DW_AT_dwo_name attribute. */
21035 static const char *
21036 dwarf2_dwo_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
21038 const char *dwo_name
= dwarf2_string_attr (die
, DW_AT_GNU_dwo_name
, cu
);
21039 if (dwo_name
== nullptr)
21040 dwo_name
= dwarf2_string_attr (die
, DW_AT_dwo_name
, cu
);
21044 /* Return non-zero iff the attribute NAME is defined for the given DIE,
21045 and holds a non-zero value. This function should only be used for
21046 DW_FORM_flag or DW_FORM_flag_present attributes. */
21049 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
21051 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
21053 return attr
!= nullptr && attr
->as_boolean ();
21057 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
21059 /* A DIE is a declaration if it has a DW_AT_declaration attribute
21060 which value is non-zero. However, we have to be careful with
21061 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
21062 (via dwarf2_flag_true_p) follows this attribute. So we may
21063 end up accidently finding a declaration attribute that belongs
21064 to a different DIE referenced by the specification attribute,
21065 even though the given DIE does not have a declaration attribute. */
21066 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
21067 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
21070 /* Return the die giving the specification for DIE, if there is
21071 one. *SPEC_CU is the CU containing DIE on input, and the CU
21072 containing the return value on output. If there is no
21073 specification, but there is an abstract origin, that is
21076 static struct die_info
*
21077 die_specification (struct die_info
*die
, struct dwarf2_cu
**spec_cu
)
21079 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
,
21082 if (spec_attr
== NULL
)
21083 spec_attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, *spec_cu
);
21085 if (spec_attr
== NULL
)
21088 return follow_die_ref (die
, spec_attr
, spec_cu
);
21091 /* Stub for free_line_header to match void * callback types. */
21094 free_line_header_voidp (void *arg
)
21096 struct line_header
*lh
= (struct line_header
*) arg
;
21101 /* A convenience function to find the proper .debug_line section for a CU. */
21103 static struct dwarf2_section_info
*
21104 get_debug_line_section (struct dwarf2_cu
*cu
)
21106 struct dwarf2_section_info
*section
;
21107 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
21109 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
21111 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
21112 section
= &cu
->dwo_unit
->dwo_file
->sections
.line
;
21113 else if (cu
->per_cu
->is_dwz
)
21115 dwz_file
*dwz
= dwarf2_get_dwz_file (per_objfile
->per_bfd
);
21117 section
= &dwz
->line
;
21120 section
= &per_objfile
->per_bfd
->line
;
21125 /* Read the statement program header starting at OFFSET in
21126 .debug_line, or .debug_line.dwo. Return a pointer
21127 to a struct line_header, allocated using xmalloc.
21128 Returns NULL if there is a problem reading the header, e.g., if it
21129 has a version we don't understand.
21131 NOTE: the strings in the include directory and file name tables of
21132 the returned object point into the dwarf line section buffer,
21133 and must not be freed. */
21135 static line_header_up
21136 dwarf_decode_line_header (sect_offset sect_off
, struct dwarf2_cu
*cu
)
21138 struct dwarf2_section_info
*section
;
21139 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
21141 section
= get_debug_line_section (cu
);
21142 section
->read (per_objfile
->objfile
);
21143 if (section
->buffer
== NULL
)
21145 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
21146 complaint (_("missing .debug_line.dwo section"));
21148 complaint (_("missing .debug_line section"));
21152 return dwarf_decode_line_header (sect_off
, cu
->per_cu
->is_dwz
,
21153 per_objfile
, section
, &cu
->header
);
21156 /* Subroutine of dwarf_decode_lines to simplify it.
21157 Return the file name of the psymtab for the given file_entry.
21158 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
21159 If space for the result is malloc'd, *NAME_HOLDER will be set.
21160 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename. */
21162 static const char *
21163 psymtab_include_file_name (const struct line_header
*lh
, const file_entry
&fe
,
21164 const dwarf2_psymtab
*pst
,
21165 const char *comp_dir
,
21166 gdb::unique_xmalloc_ptr
<char> *name_holder
)
21168 const char *include_name
= fe
.name
;
21169 const char *include_name_to_compare
= include_name
;
21170 const char *pst_filename
;
21173 const char *dir_name
= fe
.include_dir (lh
);
21175 gdb::unique_xmalloc_ptr
<char> hold_compare
;
21176 if (!IS_ABSOLUTE_PATH (include_name
)
21177 && (dir_name
!= NULL
|| comp_dir
!= NULL
))
21179 /* Avoid creating a duplicate psymtab for PST.
21180 We do this by comparing INCLUDE_NAME and PST_FILENAME.
21181 Before we do the comparison, however, we need to account
21182 for DIR_NAME and COMP_DIR.
21183 First prepend dir_name (if non-NULL). If we still don't
21184 have an absolute path prepend comp_dir (if non-NULL).
21185 However, the directory we record in the include-file's
21186 psymtab does not contain COMP_DIR (to match the
21187 corresponding symtab(s)).
21192 bash$ gcc -g ./hello.c
21193 include_name = "hello.c"
21195 DW_AT_comp_dir = comp_dir = "/tmp"
21196 DW_AT_name = "./hello.c"
21200 if (dir_name
!= NULL
)
21202 name_holder
->reset (concat (dir_name
, SLASH_STRING
,
21203 include_name
, (char *) NULL
));
21204 include_name
= name_holder
->get ();
21205 include_name_to_compare
= include_name
;
21207 if (!IS_ABSOLUTE_PATH (include_name
) && comp_dir
!= NULL
)
21209 hold_compare
.reset (concat (comp_dir
, SLASH_STRING
,
21210 include_name
, (char *) NULL
));
21211 include_name_to_compare
= hold_compare
.get ();
21215 pst_filename
= pst
->filename
;
21216 gdb::unique_xmalloc_ptr
<char> copied_name
;
21217 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
21219 copied_name
.reset (concat (pst
->dirname
, SLASH_STRING
,
21220 pst_filename
, (char *) NULL
));
21221 pst_filename
= copied_name
.get ();
21224 file_is_pst
= FILENAME_CMP (include_name_to_compare
, pst_filename
) == 0;
21228 return include_name
;
21231 /* State machine to track the state of the line number program. */
21233 class lnp_state_machine
21236 /* Initialize a machine state for the start of a line number
21238 lnp_state_machine (struct dwarf2_cu
*cu
, gdbarch
*arch
, line_header
*lh
,
21239 bool record_lines_p
);
21241 file_entry
*current_file ()
21243 /* lh->file_names is 0-based, but the file name numbers in the
21244 statement program are 1-based. */
21245 return m_line_header
->file_name_at (m_file
);
21248 /* Record the line in the state machine. END_SEQUENCE is true if
21249 we're processing the end of a sequence. */
21250 void record_line (bool end_sequence
);
21252 /* Check ADDRESS is -1, or zero and less than UNRELOCATED_LOWPC, and if true
21253 nop-out rest of the lines in this sequence. */
21254 void check_line_address (struct dwarf2_cu
*cu
,
21255 const gdb_byte
*line_ptr
,
21256 CORE_ADDR unrelocated_lowpc
, CORE_ADDR address
);
21258 void handle_set_discriminator (unsigned int discriminator
)
21260 m_discriminator
= discriminator
;
21261 m_line_has_non_zero_discriminator
|= discriminator
!= 0;
21264 /* Handle DW_LNE_set_address. */
21265 void handle_set_address (CORE_ADDR baseaddr
, CORE_ADDR address
)
21268 address
+= baseaddr
;
21269 m_address
= gdbarch_adjust_dwarf2_line (m_gdbarch
, address
, false);
21272 /* Handle DW_LNS_advance_pc. */
21273 void handle_advance_pc (CORE_ADDR adjust
);
21275 /* Handle a special opcode. */
21276 void handle_special_opcode (unsigned char op_code
);
21278 /* Handle DW_LNS_advance_line. */
21279 void handle_advance_line (int line_delta
)
21281 advance_line (line_delta
);
21284 /* Handle DW_LNS_set_file. */
21285 void handle_set_file (file_name_index file
);
21287 /* Handle DW_LNS_negate_stmt. */
21288 void handle_negate_stmt ()
21290 m_is_stmt
= !m_is_stmt
;
21293 /* Handle DW_LNS_const_add_pc. */
21294 void handle_const_add_pc ();
21296 /* Handle DW_LNS_fixed_advance_pc. */
21297 void handle_fixed_advance_pc (CORE_ADDR addr_adj
)
21299 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
21303 /* Handle DW_LNS_copy. */
21304 void handle_copy ()
21306 record_line (false);
21307 m_discriminator
= 0;
21310 /* Handle DW_LNE_end_sequence. */
21311 void handle_end_sequence ()
21313 m_currently_recording_lines
= true;
21317 /* Advance the line by LINE_DELTA. */
21318 void advance_line (int line_delta
)
21320 m_line
+= line_delta
;
21322 if (line_delta
!= 0)
21323 m_line_has_non_zero_discriminator
= m_discriminator
!= 0;
21326 struct dwarf2_cu
*m_cu
;
21328 gdbarch
*m_gdbarch
;
21330 /* True if we're recording lines.
21331 Otherwise we're building partial symtabs and are just interested in
21332 finding include files mentioned by the line number program. */
21333 bool m_record_lines_p
;
21335 /* The line number header. */
21336 line_header
*m_line_header
;
21338 /* These are part of the standard DWARF line number state machine,
21339 and initialized according to the DWARF spec. */
21341 unsigned char m_op_index
= 0;
21342 /* The line table index of the current file. */
21343 file_name_index m_file
= 1;
21344 unsigned int m_line
= 1;
21346 /* These are initialized in the constructor. */
21348 CORE_ADDR m_address
;
21350 unsigned int m_discriminator
;
21352 /* Additional bits of state we need to track. */
21354 /* The last file that we called dwarf2_start_subfile for.
21355 This is only used for TLLs. */
21356 unsigned int m_last_file
= 0;
21357 /* The last file a line number was recorded for. */
21358 struct subfile
*m_last_subfile
= NULL
;
21360 /* The address of the last line entry. */
21361 CORE_ADDR m_last_address
;
21363 /* Set to true when a previous line at the same address (using
21364 m_last_address) had m_is_stmt true. This is reset to false when a
21365 line entry at a new address (m_address different to m_last_address) is
21367 bool m_stmt_at_address
= false;
21369 /* When true, record the lines we decode. */
21370 bool m_currently_recording_lines
= false;
21372 /* The last line number that was recorded, used to coalesce
21373 consecutive entries for the same line. This can happen, for
21374 example, when discriminators are present. PR 17276. */
21375 unsigned int m_last_line
= 0;
21376 bool m_line_has_non_zero_discriminator
= false;
21380 lnp_state_machine::handle_advance_pc (CORE_ADDR adjust
)
21382 CORE_ADDR addr_adj
= (((m_op_index
+ adjust
)
21383 / m_line_header
->maximum_ops_per_instruction
)
21384 * m_line_header
->minimum_instruction_length
);
21385 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
21386 m_op_index
= ((m_op_index
+ adjust
)
21387 % m_line_header
->maximum_ops_per_instruction
);
21391 lnp_state_machine::handle_special_opcode (unsigned char op_code
)
21393 unsigned char adj_opcode
= op_code
- m_line_header
->opcode_base
;
21394 unsigned char adj_opcode_d
= adj_opcode
/ m_line_header
->line_range
;
21395 unsigned char adj_opcode_r
= adj_opcode
% m_line_header
->line_range
;
21396 CORE_ADDR addr_adj
= (((m_op_index
+ adj_opcode_d
)
21397 / m_line_header
->maximum_ops_per_instruction
)
21398 * m_line_header
->minimum_instruction_length
);
21399 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
21400 m_op_index
= ((m_op_index
+ adj_opcode_d
)
21401 % m_line_header
->maximum_ops_per_instruction
);
21403 int line_delta
= m_line_header
->line_base
+ adj_opcode_r
;
21404 advance_line (line_delta
);
21405 record_line (false);
21406 m_discriminator
= 0;
21410 lnp_state_machine::handle_set_file (file_name_index file
)
21414 const file_entry
*fe
= current_file ();
21416 dwarf2_debug_line_missing_file_complaint ();
21417 else if (m_record_lines_p
)
21419 const char *dir
= fe
->include_dir (m_line_header
);
21421 m_last_subfile
= m_cu
->get_builder ()->get_current_subfile ();
21422 m_line_has_non_zero_discriminator
= m_discriminator
!= 0;
21423 dwarf2_start_subfile (m_cu
, fe
->name
, dir
);
21428 lnp_state_machine::handle_const_add_pc ()
21431 = (255 - m_line_header
->opcode_base
) / m_line_header
->line_range
;
21434 = (((m_op_index
+ adjust
)
21435 / m_line_header
->maximum_ops_per_instruction
)
21436 * m_line_header
->minimum_instruction_length
);
21438 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
21439 m_op_index
= ((m_op_index
+ adjust
)
21440 % m_line_header
->maximum_ops_per_instruction
);
21443 /* Return non-zero if we should add LINE to the line number table.
21444 LINE is the line to add, LAST_LINE is the last line that was added,
21445 LAST_SUBFILE is the subfile for LAST_LINE.
21446 LINE_HAS_NON_ZERO_DISCRIMINATOR is non-zero if LINE has ever
21447 had a non-zero discriminator.
21449 We have to be careful in the presence of discriminators.
21450 E.g., for this line:
21452 for (i = 0; i < 100000; i++);
21454 clang can emit four line number entries for that one line,
21455 each with a different discriminator.
21456 See gdb.dwarf2/dw2-single-line-discriminators.exp for an example.
21458 However, we want gdb to coalesce all four entries into one.
21459 Otherwise the user could stepi into the middle of the line and
21460 gdb would get confused about whether the pc really was in the
21461 middle of the line.
21463 Things are further complicated by the fact that two consecutive
21464 line number entries for the same line is a heuristic used by gcc
21465 to denote the end of the prologue. So we can't just discard duplicate
21466 entries, we have to be selective about it. The heuristic we use is
21467 that we only collapse consecutive entries for the same line if at least
21468 one of those entries has a non-zero discriminator. PR 17276.
21470 Note: Addresses in the line number state machine can never go backwards
21471 within one sequence, thus this coalescing is ok. */
21474 dwarf_record_line_p (struct dwarf2_cu
*cu
,
21475 unsigned int line
, unsigned int last_line
,
21476 int line_has_non_zero_discriminator
,
21477 struct subfile
*last_subfile
)
21479 if (cu
->get_builder ()->get_current_subfile () != last_subfile
)
21481 if (line
!= last_line
)
21483 /* Same line for the same file that we've seen already.
21484 As a last check, for pr 17276, only record the line if the line
21485 has never had a non-zero discriminator. */
21486 if (!line_has_non_zero_discriminator
)
21491 /* Use the CU's builder to record line number LINE beginning at
21492 address ADDRESS in the line table of subfile SUBFILE. */
21495 dwarf_record_line_1 (struct gdbarch
*gdbarch
, struct subfile
*subfile
,
21496 unsigned int line
, CORE_ADDR address
, bool is_stmt
,
21497 struct dwarf2_cu
*cu
)
21499 CORE_ADDR addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
21501 if (dwarf_line_debug
)
21503 fprintf_unfiltered (gdb_stdlog
,
21504 "Recording line %u, file %s, address %s\n",
21505 line
, lbasename (subfile
->name
),
21506 paddress (gdbarch
, address
));
21510 cu
->get_builder ()->record_line (subfile
, line
, addr
, is_stmt
);
21513 /* Subroutine of dwarf_decode_lines_1 to simplify it.
21514 Mark the end of a set of line number records.
21515 The arguments are the same as for dwarf_record_line_1.
21516 If SUBFILE is NULL the request is ignored. */
21519 dwarf_finish_line (struct gdbarch
*gdbarch
, struct subfile
*subfile
,
21520 CORE_ADDR address
, struct dwarf2_cu
*cu
)
21522 if (subfile
== NULL
)
21525 if (dwarf_line_debug
)
21527 fprintf_unfiltered (gdb_stdlog
,
21528 "Finishing current line, file %s, address %s\n",
21529 lbasename (subfile
->name
),
21530 paddress (gdbarch
, address
));
21533 dwarf_record_line_1 (gdbarch
, subfile
, 0, address
, true, cu
);
21537 lnp_state_machine::record_line (bool end_sequence
)
21539 if (dwarf_line_debug
)
21541 fprintf_unfiltered (gdb_stdlog
,
21542 "Processing actual line %u: file %u,"
21543 " address %s, is_stmt %u, discrim %u%s\n",
21545 paddress (m_gdbarch
, m_address
),
21546 m_is_stmt
, m_discriminator
,
21547 (end_sequence
? "\t(end sequence)" : ""));
21550 file_entry
*fe
= current_file ();
21553 dwarf2_debug_line_missing_file_complaint ();
21554 /* For now we ignore lines not starting on an instruction boundary.
21555 But not when processing end_sequence for compatibility with the
21556 previous version of the code. */
21557 else if (m_op_index
== 0 || end_sequence
)
21559 fe
->included_p
= 1;
21560 if (m_record_lines_p
)
21562 /* When we switch files we insert an end maker in the first file,
21563 switch to the second file and add a new line entry. The
21564 problem is that the end marker inserted in the first file will
21565 discard any previous line entries at the same address. If the
21566 line entries in the first file are marked as is-stmt, while
21567 the new line in the second file is non-stmt, then this means
21568 the end marker will discard is-stmt lines so we can have a
21569 non-stmt line. This means that there are less addresses at
21570 which the user can insert a breakpoint.
21572 To improve this we track the last address in m_last_address,
21573 and whether we have seen an is-stmt at this address. Then
21574 when switching files, if we have seen a stmt at the current
21575 address, and we are switching to create a non-stmt line, then
21576 discard the new line. */
21578 = m_last_subfile
!= m_cu
->get_builder ()->get_current_subfile ();
21579 bool ignore_this_line
21580 = ((file_changed
&& !end_sequence
&& m_last_address
== m_address
21581 && !m_is_stmt
&& m_stmt_at_address
)
21582 || (!end_sequence
&& m_line
== 0));
21584 if ((file_changed
&& !ignore_this_line
) || end_sequence
)
21586 dwarf_finish_line (m_gdbarch
, m_last_subfile
, m_address
,
21587 m_currently_recording_lines
? m_cu
: nullptr);
21590 if (!end_sequence
&& !ignore_this_line
)
21592 bool is_stmt
= producer_is_codewarrior (m_cu
) || m_is_stmt
;
21594 if (dwarf_record_line_p (m_cu
, m_line
, m_last_line
,
21595 m_line_has_non_zero_discriminator
,
21598 buildsym_compunit
*builder
= m_cu
->get_builder ();
21599 dwarf_record_line_1 (m_gdbarch
,
21600 builder
->get_current_subfile (),
21601 m_line
, m_address
, is_stmt
,
21602 m_currently_recording_lines
? m_cu
: nullptr);
21604 m_last_subfile
= m_cu
->get_builder ()->get_current_subfile ();
21605 m_last_line
= m_line
;
21610 /* Track whether we have seen any m_is_stmt true at m_address in case we
21611 have multiple line table entries all at m_address. */
21612 if (m_last_address
!= m_address
)
21614 m_stmt_at_address
= false;
21615 m_last_address
= m_address
;
21617 m_stmt_at_address
|= m_is_stmt
;
21620 lnp_state_machine::lnp_state_machine (struct dwarf2_cu
*cu
, gdbarch
*arch
,
21621 line_header
*lh
, bool record_lines_p
)
21625 m_record_lines_p
= record_lines_p
;
21626 m_line_header
= lh
;
21628 m_currently_recording_lines
= true;
21630 /* Call `gdbarch_adjust_dwarf2_line' on the initial 0 address as if there
21631 was a line entry for it so that the backend has a chance to adjust it
21632 and also record it in case it needs it. This is currently used by MIPS
21633 code, cf. `mips_adjust_dwarf2_line'. */
21634 m_address
= gdbarch_adjust_dwarf2_line (arch
, 0, 0);
21635 m_is_stmt
= lh
->default_is_stmt
;
21636 m_discriminator
= 0;
21638 m_last_address
= m_address
;
21639 m_stmt_at_address
= false;
21643 lnp_state_machine::check_line_address (struct dwarf2_cu
*cu
,
21644 const gdb_byte
*line_ptr
,
21645 CORE_ADDR unrelocated_lowpc
, CORE_ADDR address
)
21647 /* Linkers resolve a symbolic relocation referencing a GC'd function to 0 or
21648 -1. If ADDRESS is 0, ignoring the opcode will err if the text section is
21649 located at 0x0. In this case, additionally check that if
21650 ADDRESS < UNRELOCATED_LOWPC. */
21652 if ((address
== 0 && address
< unrelocated_lowpc
)
21653 || address
== (CORE_ADDR
) -1)
21655 /* This line table is for a function which has been
21656 GCd by the linker. Ignore it. PR gdb/12528 */
21658 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
21659 long line_offset
= line_ptr
- get_debug_line_section (cu
)->buffer
;
21661 complaint (_(".debug_line address at offset 0x%lx is 0 [in module %s]"),
21662 line_offset
, objfile_name (objfile
));
21663 m_currently_recording_lines
= false;
21664 /* Note: m_currently_recording_lines is left as false until we see
21665 DW_LNE_end_sequence. */
21669 /* Subroutine of dwarf_decode_lines to simplify it.
21670 Process the line number information in LH.
21671 If DECODE_FOR_PST_P is non-zero, all we do is process the line number
21672 program in order to set included_p for every referenced header. */
21675 dwarf_decode_lines_1 (struct line_header
*lh
, struct dwarf2_cu
*cu
,
21676 const int decode_for_pst_p
, CORE_ADDR lowpc
)
21678 const gdb_byte
*line_ptr
, *extended_end
;
21679 const gdb_byte
*line_end
;
21680 unsigned int bytes_read
, extended_len
;
21681 unsigned char op_code
, extended_op
;
21682 CORE_ADDR baseaddr
;
21683 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
21684 bfd
*abfd
= objfile
->obfd
;
21685 struct gdbarch
*gdbarch
= objfile
->arch ();
21686 /* True if we're recording line info (as opposed to building partial
21687 symtabs and just interested in finding include files mentioned by
21688 the line number program). */
21689 bool record_lines_p
= !decode_for_pst_p
;
21691 baseaddr
= objfile
->text_section_offset ();
21693 line_ptr
= lh
->statement_program_start
;
21694 line_end
= lh
->statement_program_end
;
21696 /* Read the statement sequences until there's nothing left. */
21697 while (line_ptr
< line_end
)
21699 /* The DWARF line number program state machine. Reset the state
21700 machine at the start of each sequence. */
21701 lnp_state_machine
state_machine (cu
, gdbarch
, lh
, record_lines_p
);
21702 bool end_sequence
= false;
21704 if (record_lines_p
)
21706 /* Start a subfile for the current file of the state
21708 const file_entry
*fe
= state_machine
.current_file ();
21711 dwarf2_start_subfile (cu
, fe
->name
, fe
->include_dir (lh
));
21714 /* Decode the table. */
21715 while (line_ptr
< line_end
&& !end_sequence
)
21717 op_code
= read_1_byte (abfd
, line_ptr
);
21720 if (op_code
>= lh
->opcode_base
)
21722 /* Special opcode. */
21723 state_machine
.handle_special_opcode (op_code
);
21725 else switch (op_code
)
21727 case DW_LNS_extended_op
:
21728 extended_len
= read_unsigned_leb128 (abfd
, line_ptr
,
21730 line_ptr
+= bytes_read
;
21731 extended_end
= line_ptr
+ extended_len
;
21732 extended_op
= read_1_byte (abfd
, line_ptr
);
21734 if (DW_LNE_lo_user
<= extended_op
21735 && extended_op
<= DW_LNE_hi_user
)
21737 /* Vendor extension, ignore. */
21738 line_ptr
= extended_end
;
21741 switch (extended_op
)
21743 case DW_LNE_end_sequence
:
21744 state_machine
.handle_end_sequence ();
21745 end_sequence
= true;
21747 case DW_LNE_set_address
:
21750 = cu
->header
.read_address (abfd
, line_ptr
, &bytes_read
);
21751 line_ptr
+= bytes_read
;
21753 state_machine
.check_line_address (cu
, line_ptr
,
21754 lowpc
- baseaddr
, address
);
21755 state_machine
.handle_set_address (baseaddr
, address
);
21758 case DW_LNE_define_file
:
21760 const char *cur_file
;
21761 unsigned int mod_time
, length
;
21764 cur_file
= read_direct_string (abfd
, line_ptr
,
21766 line_ptr
+= bytes_read
;
21767 dindex
= (dir_index
)
21768 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21769 line_ptr
+= bytes_read
;
21771 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21772 line_ptr
+= bytes_read
;
21774 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21775 line_ptr
+= bytes_read
;
21776 lh
->add_file_name (cur_file
, dindex
, mod_time
, length
);
21779 case DW_LNE_set_discriminator
:
21781 /* The discriminator is not interesting to the
21782 debugger; just ignore it. We still need to
21783 check its value though:
21784 if there are consecutive entries for the same
21785 (non-prologue) line we want to coalesce them.
21788 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21789 line_ptr
+= bytes_read
;
21791 state_machine
.handle_set_discriminator (discr
);
21795 complaint (_("mangled .debug_line section"));
21798 /* Make sure that we parsed the extended op correctly. If e.g.
21799 we expected a different address size than the producer used,
21800 we may have read the wrong number of bytes. */
21801 if (line_ptr
!= extended_end
)
21803 complaint (_("mangled .debug_line section"));
21808 state_machine
.handle_copy ();
21810 case DW_LNS_advance_pc
:
21813 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21814 line_ptr
+= bytes_read
;
21816 state_machine
.handle_advance_pc (adjust
);
21819 case DW_LNS_advance_line
:
21822 = read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
21823 line_ptr
+= bytes_read
;
21825 state_machine
.handle_advance_line (line_delta
);
21828 case DW_LNS_set_file
:
21830 file_name_index file
21831 = (file_name_index
) read_unsigned_leb128 (abfd
, line_ptr
,
21833 line_ptr
+= bytes_read
;
21835 state_machine
.handle_set_file (file
);
21838 case DW_LNS_set_column
:
21839 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21840 line_ptr
+= bytes_read
;
21842 case DW_LNS_negate_stmt
:
21843 state_machine
.handle_negate_stmt ();
21845 case DW_LNS_set_basic_block
:
21847 /* Add to the address register of the state machine the
21848 address increment value corresponding to special opcode
21849 255. I.e., this value is scaled by the minimum
21850 instruction length since special opcode 255 would have
21851 scaled the increment. */
21852 case DW_LNS_const_add_pc
:
21853 state_machine
.handle_const_add_pc ();
21855 case DW_LNS_fixed_advance_pc
:
21857 CORE_ADDR addr_adj
= read_2_bytes (abfd
, line_ptr
);
21860 state_machine
.handle_fixed_advance_pc (addr_adj
);
21865 /* Unknown standard opcode, ignore it. */
21868 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
21870 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21871 line_ptr
+= bytes_read
;
21878 dwarf2_debug_line_missing_end_sequence_complaint ();
21880 /* We got a DW_LNE_end_sequence (or we ran off the end of the buffer,
21881 in which case we still finish recording the last line). */
21882 state_machine
.record_line (true);
21886 /* Decode the Line Number Program (LNP) for the given line_header
21887 structure and CU. The actual information extracted and the type
21888 of structures created from the LNP depends on the value of PST.
21890 1. If PST is NULL, then this procedure uses the data from the program
21891 to create all necessary symbol tables, and their linetables.
21893 2. If PST is not NULL, this procedure reads the program to determine
21894 the list of files included by the unit represented by PST, and
21895 builds all the associated partial symbol tables.
21897 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
21898 It is used for relative paths in the line table.
21899 NOTE: When processing partial symtabs (pst != NULL),
21900 comp_dir == pst->dirname.
21902 NOTE: It is important that psymtabs have the same file name (via strcmp)
21903 as the corresponding symtab. Since COMP_DIR is not used in the name of the
21904 symtab we don't use it in the name of the psymtabs we create.
21905 E.g. expand_line_sal requires this when finding psymtabs to expand.
21906 A good testcase for this is mb-inline.exp.
21908 LOWPC is the lowest address in CU (or 0 if not known).
21910 Boolean DECODE_MAPPING specifies we need to fully decode .debug_line
21911 for its PC<->lines mapping information. Otherwise only the filename
21912 table is read in. */
21915 dwarf_decode_lines (struct line_header
*lh
, const char *comp_dir
,
21916 struct dwarf2_cu
*cu
, dwarf2_psymtab
*pst
,
21917 CORE_ADDR lowpc
, int decode_mapping
)
21919 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
21920 const int decode_for_pst_p
= (pst
!= NULL
);
21922 if (decode_mapping
)
21923 dwarf_decode_lines_1 (lh
, cu
, decode_for_pst_p
, lowpc
);
21925 if (decode_for_pst_p
)
21927 /* Now that we're done scanning the Line Header Program, we can
21928 create the psymtab of each included file. */
21929 for (auto &file_entry
: lh
->file_names ())
21930 if (file_entry
.included_p
== 1)
21932 gdb::unique_xmalloc_ptr
<char> name_holder
;
21933 const char *include_name
=
21934 psymtab_include_file_name (lh
, file_entry
, pst
,
21935 comp_dir
, &name_holder
);
21936 if (include_name
!= NULL
)
21937 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
21942 /* Make sure a symtab is created for every file, even files
21943 which contain only variables (i.e. no code with associated
21945 buildsym_compunit
*builder
= cu
->get_builder ();
21946 struct compunit_symtab
*cust
= builder
->get_compunit_symtab ();
21948 for (auto &fe
: lh
->file_names ())
21950 dwarf2_start_subfile (cu
, fe
.name
, fe
.include_dir (lh
));
21951 if (builder
->get_current_subfile ()->symtab
== NULL
)
21953 builder
->get_current_subfile ()->symtab
21954 = allocate_symtab (cust
,
21955 builder
->get_current_subfile ()->name
);
21957 fe
.symtab
= builder
->get_current_subfile ()->symtab
;
21962 /* Start a subfile for DWARF. FILENAME is the name of the file and
21963 DIRNAME the name of the source directory which contains FILENAME
21964 or NULL if not known.
21965 This routine tries to keep line numbers from identical absolute and
21966 relative file names in a common subfile.
21968 Using the `list' example from the GDB testsuite, which resides in
21969 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
21970 of /srcdir/list0.c yields the following debugging information for list0.c:
21972 DW_AT_name: /srcdir/list0.c
21973 DW_AT_comp_dir: /compdir
21974 files.files[0].name: list0.h
21975 files.files[0].dir: /srcdir
21976 files.files[1].name: list0.c
21977 files.files[1].dir: /srcdir
21979 The line number information for list0.c has to end up in a single
21980 subfile, so that `break /srcdir/list0.c:1' works as expected.
21981 start_subfile will ensure that this happens provided that we pass the
21982 concatenation of files.files[1].dir and files.files[1].name as the
21986 dwarf2_start_subfile (struct dwarf2_cu
*cu
, const char *filename
,
21987 const char *dirname
)
21989 gdb::unique_xmalloc_ptr
<char> copy
;
21991 /* In order not to lose the line information directory,
21992 we concatenate it to the filename when it makes sense.
21993 Note that the Dwarf3 standard says (speaking of filenames in line
21994 information): ``The directory index is ignored for file names
21995 that represent full path names''. Thus ignoring dirname in the
21996 `else' branch below isn't an issue. */
21998 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
22000 copy
.reset (concat (dirname
, SLASH_STRING
, filename
, (char *) NULL
));
22001 filename
= copy
.get ();
22004 cu
->get_builder ()->start_subfile (filename
);
22007 /* Start a symtab for DWARF. NAME, COMP_DIR, LOW_PC are passed to the
22008 buildsym_compunit constructor. */
22010 struct compunit_symtab
*
22011 dwarf2_cu::start_symtab (const char *name
, const char *comp_dir
,
22014 gdb_assert (m_builder
== nullptr);
22016 m_builder
.reset (new struct buildsym_compunit
22017 (this->per_objfile
->objfile
,
22018 name
, comp_dir
, language
, low_pc
));
22020 list_in_scope
= get_builder ()->get_file_symbols ();
22022 get_builder ()->record_debugformat ("DWARF 2");
22023 get_builder ()->record_producer (producer
);
22025 processing_has_namespace_info
= false;
22027 return get_builder ()->get_compunit_symtab ();
22031 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
22032 struct dwarf2_cu
*cu
)
22034 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22035 struct comp_unit_head
*cu_header
= &cu
->header
;
22037 /* NOTE drow/2003-01-30: There used to be a comment and some special
22038 code here to turn a symbol with DW_AT_external and a
22039 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
22040 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
22041 with some versions of binutils) where shared libraries could have
22042 relocations against symbols in their debug information - the
22043 minimal symbol would have the right address, but the debug info
22044 would not. It's no longer necessary, because we will explicitly
22045 apply relocations when we read in the debug information now. */
22047 /* A DW_AT_location attribute with no contents indicates that a
22048 variable has been optimized away. */
22049 if (attr
->form_is_block () && attr
->as_block ()->size
== 0)
22051 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
22055 /* Handle one degenerate form of location expression specially, to
22056 preserve GDB's previous behavior when section offsets are
22057 specified. If this is just a DW_OP_addr, DW_OP_addrx, or
22058 DW_OP_GNU_addr_index then mark this symbol as LOC_STATIC. */
22060 if (attr
->form_is_block ())
22062 struct dwarf_block
*block
= attr
->as_block ();
22064 if ((block
->data
[0] == DW_OP_addr
22065 && block
->size
== 1 + cu_header
->addr_size
)
22066 || ((block
->data
[0] == DW_OP_GNU_addr_index
22067 || block
->data
[0] == DW_OP_addrx
)
22069 == 1 + leb128_size (&block
->data
[1]))))
22071 unsigned int dummy
;
22073 if (block
->data
[0] == DW_OP_addr
)
22074 SET_SYMBOL_VALUE_ADDRESS
22075 (sym
, cu
->header
.read_address (objfile
->obfd
,
22079 SET_SYMBOL_VALUE_ADDRESS
22080 (sym
, read_addr_index_from_leb128 (cu
, block
->data
+ 1,
22082 SYMBOL_ACLASS_INDEX (sym
) = LOC_STATIC
;
22083 fixup_symbol_section (sym
, objfile
);
22084 SET_SYMBOL_VALUE_ADDRESS
22086 SYMBOL_VALUE_ADDRESS (sym
)
22087 + objfile
->section_offsets
[SYMBOL_SECTION (sym
)]);
22092 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
22093 expression evaluator, and use LOC_COMPUTED only when necessary
22094 (i.e. when the value of a register or memory location is
22095 referenced, or a thread-local block, etc.). Then again, it might
22096 not be worthwhile. I'm assuming that it isn't unless performance
22097 or memory numbers show me otherwise. */
22099 dwarf2_symbol_mark_computed (attr
, sym
, cu
, 0);
22101 if (SYMBOL_COMPUTED_OPS (sym
)->location_has_loclist
)
22102 cu
->has_loclist
= true;
22105 /* Given a pointer to a DWARF information entry, figure out if we need
22106 to make a symbol table entry for it, and if so, create a new entry
22107 and return a pointer to it.
22108 If TYPE is NULL, determine symbol type from the die, otherwise
22109 used the passed type.
22110 If SPACE is not NULL, use it to hold the new symbol. If it is
22111 NULL, allocate a new symbol on the objfile's obstack. */
22113 static struct symbol
*
22114 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
,
22115 struct symbol
*space
)
22117 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
22118 struct objfile
*objfile
= per_objfile
->objfile
;
22119 struct gdbarch
*gdbarch
= objfile
->arch ();
22120 struct symbol
*sym
= NULL
;
22122 struct attribute
*attr
= NULL
;
22123 struct attribute
*attr2
= NULL
;
22124 CORE_ADDR baseaddr
;
22125 struct pending
**list_to_add
= NULL
;
22127 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
22129 baseaddr
= objfile
->text_section_offset ();
22131 name
= dwarf2_name (die
, cu
);
22134 int suppress_add
= 0;
22139 sym
= new (&objfile
->objfile_obstack
) symbol
;
22140 OBJSTAT (objfile
, n_syms
++);
22142 /* Cache this symbol's name and the name's demangled form (if any). */
22143 sym
->set_language (cu
->language
, &objfile
->objfile_obstack
);
22144 /* Fortran does not have mangling standard and the mangling does differ
22145 between gfortran, iFort etc. */
22146 const char *physname
22147 = (cu
->language
== language_fortran
22148 ? dwarf2_full_name (name
, die
, cu
)
22149 : dwarf2_physname (name
, die
, cu
));
22150 const char *linkagename
= dw2_linkage_name (die
, cu
);
22152 if (linkagename
== nullptr || cu
->language
== language_ada
)
22153 sym
->set_linkage_name (physname
);
22156 sym
->set_demangled_name (physname
, &objfile
->objfile_obstack
);
22157 sym
->set_linkage_name (linkagename
);
22160 /* Default assumptions.
22161 Use the passed type or decode it from the die. */
22162 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
22163 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
22165 SYMBOL_TYPE (sym
) = type
;
22167 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
22168 attr
= dwarf2_attr (die
,
22169 inlined_func
? DW_AT_call_line
: DW_AT_decl_line
,
22171 if (attr
!= nullptr)
22172 SYMBOL_LINE (sym
) = attr
->constant_value (0);
22174 attr
= dwarf2_attr (die
,
22175 inlined_func
? DW_AT_call_file
: DW_AT_decl_file
,
22177 if (attr
!= nullptr && attr
->form_is_unsigned ())
22179 file_name_index file_index
22180 = (file_name_index
) attr
->as_unsigned ();
22181 struct file_entry
*fe
;
22183 if (cu
->line_header
!= NULL
)
22184 fe
= cu
->line_header
->file_name_at (file_index
);
22189 complaint (_("file index out of range"));
22191 symbol_set_symtab (sym
, fe
->symtab
);
22197 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
22198 if (attr
!= nullptr)
22202 addr
= attr
->as_address ();
22203 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, addr
+ baseaddr
);
22204 SET_SYMBOL_VALUE_ADDRESS (sym
, addr
);
22205 SYMBOL_ACLASS_INDEX (sym
) = LOC_LABEL
;
22208 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
22209 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_core_addr
;
22210 SYMBOL_DOMAIN (sym
) = LABEL_DOMAIN
;
22211 add_symbol_to_list (sym
, cu
->list_in_scope
);
22213 case DW_TAG_subprogram
:
22214 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
22216 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
22217 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
22218 if ((attr2
!= nullptr && attr2
->as_boolean ())
22219 || cu
->language
== language_ada
22220 || cu
->language
== language_fortran
)
22222 /* Subprograms marked external are stored as a global symbol.
22223 Ada and Fortran subprograms, whether marked external or
22224 not, are always stored as a global symbol, because we want
22225 to be able to access them globally. For instance, we want
22226 to be able to break on a nested subprogram without having
22227 to specify the context. */
22228 list_to_add
= cu
->get_builder ()->get_global_symbols ();
22232 list_to_add
= cu
->list_in_scope
;
22235 case DW_TAG_inlined_subroutine
:
22236 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
22238 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
22239 SYMBOL_INLINED (sym
) = 1;
22240 list_to_add
= cu
->list_in_scope
;
22242 case DW_TAG_template_value_param
:
22244 /* Fall through. */
22245 case DW_TAG_constant
:
22246 case DW_TAG_variable
:
22247 case DW_TAG_member
:
22248 /* Compilation with minimal debug info may result in
22249 variables with missing type entries. Change the
22250 misleading `void' type to something sensible. */
22251 if (SYMBOL_TYPE (sym
)->code () == TYPE_CODE_VOID
)
22252 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_int
;
22254 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
22255 /* In the case of DW_TAG_member, we should only be called for
22256 static const members. */
22257 if (die
->tag
== DW_TAG_member
)
22259 /* dwarf2_add_field uses die_is_declaration,
22260 so we do the same. */
22261 gdb_assert (die_is_declaration (die
, cu
));
22264 if (attr
!= nullptr)
22266 dwarf2_const_value (attr
, sym
, cu
);
22267 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
22270 if (attr2
!= nullptr && attr2
->as_boolean ())
22271 list_to_add
= cu
->get_builder ()->get_global_symbols ();
22273 list_to_add
= cu
->list_in_scope
;
22277 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
22278 if (attr
!= nullptr)
22280 var_decode_location (attr
, sym
, cu
);
22281 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
22283 /* Fortran explicitly imports any global symbols to the local
22284 scope by DW_TAG_common_block. */
22285 if (cu
->language
== language_fortran
&& die
->parent
22286 && die
->parent
->tag
== DW_TAG_common_block
)
22289 if (SYMBOL_CLASS (sym
) == LOC_STATIC
22290 && SYMBOL_VALUE_ADDRESS (sym
) == 0
22291 && !per_objfile
->per_bfd
->has_section_at_zero
)
22293 /* When a static variable is eliminated by the linker,
22294 the corresponding debug information is not stripped
22295 out, but the variable address is set to null;
22296 do not add such variables into symbol table. */
22298 else if (attr2
!= nullptr && attr2
->as_boolean ())
22300 if (SYMBOL_CLASS (sym
) == LOC_STATIC
22301 && (objfile
->flags
& OBJF_MAINLINE
) == 0
22302 && per_objfile
->per_bfd
->can_copy
)
22304 /* A global static variable might be subject to
22305 copy relocation. We first check for a local
22306 minsym, though, because maybe the symbol was
22307 marked hidden, in which case this would not
22309 bound_minimal_symbol found
22310 = (lookup_minimal_symbol_linkage
22311 (sym
->linkage_name (), objfile
));
22312 if (found
.minsym
!= nullptr)
22313 sym
->maybe_copied
= 1;
22316 /* A variable with DW_AT_external is never static,
22317 but it may be block-scoped. */
22319 = ((cu
->list_in_scope
22320 == cu
->get_builder ()->get_file_symbols ())
22321 ? cu
->get_builder ()->get_global_symbols ()
22322 : cu
->list_in_scope
);
22325 list_to_add
= cu
->list_in_scope
;
22329 /* We do not know the address of this symbol.
22330 If it is an external symbol and we have type information
22331 for it, enter the symbol as a LOC_UNRESOLVED symbol.
22332 The address of the variable will then be determined from
22333 the minimal symbol table whenever the variable is
22335 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
22337 /* Fortran explicitly imports any global symbols to the local
22338 scope by DW_TAG_common_block. */
22339 if (cu
->language
== language_fortran
&& die
->parent
22340 && die
->parent
->tag
== DW_TAG_common_block
)
22342 /* SYMBOL_CLASS doesn't matter here because
22343 read_common_block is going to reset it. */
22345 list_to_add
= cu
->list_in_scope
;
22347 else if (attr2
!= nullptr && attr2
->as_boolean ()
22348 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
22350 /* A variable with DW_AT_external is never static, but it
22351 may be block-scoped. */
22353 = ((cu
->list_in_scope
22354 == cu
->get_builder ()->get_file_symbols ())
22355 ? cu
->get_builder ()->get_global_symbols ()
22356 : cu
->list_in_scope
);
22358 SYMBOL_ACLASS_INDEX (sym
) = LOC_UNRESOLVED
;
22360 else if (!die_is_declaration (die
, cu
))
22362 /* Use the default LOC_OPTIMIZED_OUT class. */
22363 gdb_assert (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
);
22365 list_to_add
= cu
->list_in_scope
;
22369 case DW_TAG_formal_parameter
:
22371 /* If we are inside a function, mark this as an argument. If
22372 not, we might be looking at an argument to an inlined function
22373 when we do not have enough information to show inlined frames;
22374 pretend it's a local variable in that case so that the user can
22376 struct context_stack
*curr
22377 = cu
->get_builder ()->get_current_context_stack ();
22378 if (curr
!= nullptr && curr
->name
!= nullptr)
22379 SYMBOL_IS_ARGUMENT (sym
) = 1;
22380 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
22381 if (attr
!= nullptr)
22383 var_decode_location (attr
, sym
, cu
);
22385 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
22386 if (attr
!= nullptr)
22388 dwarf2_const_value (attr
, sym
, cu
);
22391 list_to_add
= cu
->list_in_scope
;
22394 case DW_TAG_unspecified_parameters
:
22395 /* From varargs functions; gdb doesn't seem to have any
22396 interest in this information, so just ignore it for now.
22399 case DW_TAG_template_type_param
:
22401 /* Fall through. */
22402 case DW_TAG_class_type
:
22403 case DW_TAG_interface_type
:
22404 case DW_TAG_structure_type
:
22405 case DW_TAG_union_type
:
22406 case DW_TAG_set_type
:
22407 case DW_TAG_enumeration_type
:
22408 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
22409 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
22412 /* NOTE: carlton/2003-11-10: C++ class symbols shouldn't
22413 really ever be static objects: otherwise, if you try
22414 to, say, break of a class's method and you're in a file
22415 which doesn't mention that class, it won't work unless
22416 the check for all static symbols in lookup_symbol_aux
22417 saves you. See the OtherFileClass tests in
22418 gdb.c++/namespace.exp. */
22422 buildsym_compunit
*builder
= cu
->get_builder ();
22424 = (cu
->list_in_scope
== builder
->get_file_symbols ()
22425 && cu
->language
== language_cplus
22426 ? builder
->get_global_symbols ()
22427 : cu
->list_in_scope
);
22429 /* The semantics of C++ state that "struct foo {
22430 ... }" also defines a typedef for "foo". */
22431 if (cu
->language
== language_cplus
22432 || cu
->language
== language_ada
22433 || cu
->language
== language_d
22434 || cu
->language
== language_rust
)
22436 /* The symbol's name is already allocated along
22437 with this objfile, so we don't need to
22438 duplicate it for the type. */
22439 if (SYMBOL_TYPE (sym
)->name () == 0)
22440 SYMBOL_TYPE (sym
)->set_name (sym
->search_name ());
22445 case DW_TAG_typedef
:
22446 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
22447 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
22448 list_to_add
= cu
->list_in_scope
;
22450 case DW_TAG_array_type
:
22451 case DW_TAG_base_type
:
22452 case DW_TAG_subrange_type
:
22453 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
22454 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
22455 list_to_add
= cu
->list_in_scope
;
22457 case DW_TAG_enumerator
:
22458 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
22459 if (attr
!= nullptr)
22461 dwarf2_const_value (attr
, sym
, cu
);
22464 /* NOTE: carlton/2003-11-10: See comment above in the
22465 DW_TAG_class_type, etc. block. */
22468 = (cu
->list_in_scope
== cu
->get_builder ()->get_file_symbols ()
22469 && cu
->language
== language_cplus
22470 ? cu
->get_builder ()->get_global_symbols ()
22471 : cu
->list_in_scope
);
22474 case DW_TAG_imported_declaration
:
22475 case DW_TAG_namespace
:
22476 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
22477 list_to_add
= cu
->get_builder ()->get_global_symbols ();
22479 case DW_TAG_module
:
22480 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
22481 SYMBOL_DOMAIN (sym
) = MODULE_DOMAIN
;
22482 list_to_add
= cu
->get_builder ()->get_global_symbols ();
22484 case DW_TAG_common_block
:
22485 SYMBOL_ACLASS_INDEX (sym
) = LOC_COMMON_BLOCK
;
22486 SYMBOL_DOMAIN (sym
) = COMMON_BLOCK_DOMAIN
;
22487 add_symbol_to_list (sym
, cu
->list_in_scope
);
22490 /* Not a tag we recognize. Hopefully we aren't processing
22491 trash data, but since we must specifically ignore things
22492 we don't recognize, there is nothing else we should do at
22494 complaint (_("unsupported tag: '%s'"),
22495 dwarf_tag_name (die
->tag
));
22501 sym
->hash_next
= objfile
->template_symbols
;
22502 objfile
->template_symbols
= sym
;
22503 list_to_add
= NULL
;
22506 if (list_to_add
!= NULL
)
22507 add_symbol_to_list (sym
, list_to_add
);
22509 /* For the benefit of old versions of GCC, check for anonymous
22510 namespaces based on the demangled name. */
22511 if (!cu
->processing_has_namespace_info
22512 && cu
->language
== language_cplus
)
22513 cp_scan_for_anonymous_namespaces (cu
->get_builder (), sym
, objfile
);
22518 /* Given an attr with a DW_FORM_dataN value in host byte order,
22519 zero-extend it as appropriate for the symbol's type. The DWARF
22520 standard (v4) is not entirely clear about the meaning of using
22521 DW_FORM_dataN for a constant with a signed type, where the type is
22522 wider than the data. The conclusion of a discussion on the DWARF
22523 list was that this is unspecified. We choose to always zero-extend
22524 because that is the interpretation long in use by GCC. */
22527 dwarf2_const_value_data (const struct attribute
*attr
, struct obstack
*obstack
,
22528 struct dwarf2_cu
*cu
, LONGEST
*value
, int bits
)
22530 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22531 enum bfd_endian byte_order
= bfd_big_endian (objfile
->obfd
) ?
22532 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
22533 LONGEST l
= attr
->constant_value (0);
22535 if (bits
< sizeof (*value
) * 8)
22537 l
&= ((LONGEST
) 1 << bits
) - 1;
22540 else if (bits
== sizeof (*value
) * 8)
22544 gdb_byte
*bytes
= (gdb_byte
*) obstack_alloc (obstack
, bits
/ 8);
22545 store_unsigned_integer (bytes
, bits
/ 8, byte_order
, l
);
22552 /* Read a constant value from an attribute. Either set *VALUE, or if
22553 the value does not fit in *VALUE, set *BYTES - either already
22554 allocated on the objfile obstack, or newly allocated on OBSTACK,
22555 or, set *BATON, if we translated the constant to a location
22559 dwarf2_const_value_attr (const struct attribute
*attr
, struct type
*type
,
22560 const char *name
, struct obstack
*obstack
,
22561 struct dwarf2_cu
*cu
,
22562 LONGEST
*value
, const gdb_byte
**bytes
,
22563 struct dwarf2_locexpr_baton
**baton
)
22565 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
22566 struct objfile
*objfile
= per_objfile
->objfile
;
22567 struct comp_unit_head
*cu_header
= &cu
->header
;
22568 struct dwarf_block
*blk
;
22569 enum bfd_endian byte_order
= (bfd_big_endian (objfile
->obfd
) ?
22570 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
22576 switch (attr
->form
)
22579 case DW_FORM_addrx
:
22580 case DW_FORM_GNU_addr_index
:
22584 if (TYPE_LENGTH (type
) != cu_header
->addr_size
)
22585 dwarf2_const_value_length_mismatch_complaint (name
,
22586 cu_header
->addr_size
,
22587 TYPE_LENGTH (type
));
22588 /* Symbols of this form are reasonably rare, so we just
22589 piggyback on the existing location code rather than writing
22590 a new implementation of symbol_computed_ops. */
22591 *baton
= XOBNEW (obstack
, struct dwarf2_locexpr_baton
);
22592 (*baton
)->per_objfile
= per_objfile
;
22593 (*baton
)->per_cu
= cu
->per_cu
;
22594 gdb_assert ((*baton
)->per_cu
);
22596 (*baton
)->size
= 2 + cu_header
->addr_size
;
22597 data
= (gdb_byte
*) obstack_alloc (obstack
, (*baton
)->size
);
22598 (*baton
)->data
= data
;
22600 data
[0] = DW_OP_addr
;
22601 store_unsigned_integer (&data
[1], cu_header
->addr_size
,
22602 byte_order
, attr
->as_address ());
22603 data
[cu_header
->addr_size
+ 1] = DW_OP_stack_value
;
22606 case DW_FORM_string
:
22609 case DW_FORM_GNU_str_index
:
22610 case DW_FORM_GNU_strp_alt
:
22611 /* The string is already allocated on the objfile obstack, point
22613 *bytes
= (const gdb_byte
*) attr
->as_string ();
22615 case DW_FORM_block1
:
22616 case DW_FORM_block2
:
22617 case DW_FORM_block4
:
22618 case DW_FORM_block
:
22619 case DW_FORM_exprloc
:
22620 case DW_FORM_data16
:
22621 blk
= attr
->as_block ();
22622 if (TYPE_LENGTH (type
) != blk
->size
)
22623 dwarf2_const_value_length_mismatch_complaint (name
, blk
->size
,
22624 TYPE_LENGTH (type
));
22625 *bytes
= blk
->data
;
22628 /* The DW_AT_const_value attributes are supposed to carry the
22629 symbol's value "represented as it would be on the target
22630 architecture." By the time we get here, it's already been
22631 converted to host endianness, so we just need to sign- or
22632 zero-extend it as appropriate. */
22633 case DW_FORM_data1
:
22634 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 8);
22636 case DW_FORM_data2
:
22637 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 16);
22639 case DW_FORM_data4
:
22640 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 32);
22642 case DW_FORM_data8
:
22643 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 64);
22646 case DW_FORM_sdata
:
22647 case DW_FORM_implicit_const
:
22648 *value
= attr
->as_signed ();
22651 case DW_FORM_udata
:
22652 *value
= attr
->as_unsigned ();
22656 complaint (_("unsupported const value attribute form: '%s'"),
22657 dwarf_form_name (attr
->form
));
22664 /* Copy constant value from an attribute to a symbol. */
22667 dwarf2_const_value (const struct attribute
*attr
, struct symbol
*sym
,
22668 struct dwarf2_cu
*cu
)
22670 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22672 const gdb_byte
*bytes
;
22673 struct dwarf2_locexpr_baton
*baton
;
22675 dwarf2_const_value_attr (attr
, SYMBOL_TYPE (sym
),
22676 sym
->print_name (),
22677 &objfile
->objfile_obstack
, cu
,
22678 &value
, &bytes
, &baton
);
22682 SYMBOL_LOCATION_BATON (sym
) = baton
;
22683 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
22685 else if (bytes
!= NULL
)
22687 SYMBOL_VALUE_BYTES (sym
) = bytes
;
22688 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST_BYTES
;
22692 SYMBOL_VALUE (sym
) = value
;
22693 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST
;
22697 /* Return the type of the die in question using its DW_AT_type attribute. */
22699 static struct type
*
22700 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
22702 struct attribute
*type_attr
;
22704 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
22707 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22708 /* A missing DW_AT_type represents a void type. */
22709 return objfile_type (objfile
)->builtin_void
;
22712 return lookup_die_type (die
, type_attr
, cu
);
22715 /* True iff CU's producer generates GNAT Ada auxiliary information
22716 that allows to find parallel types through that information instead
22717 of having to do expensive parallel lookups by type name. */
22720 need_gnat_info (struct dwarf2_cu
*cu
)
22722 /* Assume that the Ada compiler was GNAT, which always produces
22723 the auxiliary information. */
22724 return (cu
->language
== language_ada
);
22727 /* Return the auxiliary type of the die in question using its
22728 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
22729 attribute is not present. */
22731 static struct type
*
22732 die_descriptive_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
22734 struct attribute
*type_attr
;
22736 type_attr
= dwarf2_attr (die
, DW_AT_GNAT_descriptive_type
, cu
);
22740 return lookup_die_type (die
, type_attr
, cu
);
22743 /* If DIE has a descriptive_type attribute, then set the TYPE's
22744 descriptive type accordingly. */
22747 set_descriptive_type (struct type
*type
, struct die_info
*die
,
22748 struct dwarf2_cu
*cu
)
22750 struct type
*descriptive_type
= die_descriptive_type (die
, cu
);
22752 if (descriptive_type
)
22754 ALLOCATE_GNAT_AUX_TYPE (type
);
22755 TYPE_DESCRIPTIVE_TYPE (type
) = descriptive_type
;
22759 /* Return the containing type of the die in question using its
22760 DW_AT_containing_type attribute. */
22762 static struct type
*
22763 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
22765 struct attribute
*type_attr
;
22766 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22768 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
22770 error (_("Dwarf Error: Problem turning containing type into gdb type "
22771 "[in module %s]"), objfile_name (objfile
));
22773 return lookup_die_type (die
, type_attr
, cu
);
22776 /* Return an error marker type to use for the ill formed type in DIE/CU. */
22778 static struct type
*
22779 build_error_marker_type (struct dwarf2_cu
*cu
, struct die_info
*die
)
22781 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
22782 struct objfile
*objfile
= per_objfile
->objfile
;
22785 std::string message
22786 = string_printf (_("<unknown type in %s, CU %s, DIE %s>"),
22787 objfile_name (objfile
),
22788 sect_offset_str (cu
->header
.sect_off
),
22789 sect_offset_str (die
->sect_off
));
22790 saved
= obstack_strdup (&objfile
->objfile_obstack
, message
);
22792 return init_type (objfile
, TYPE_CODE_ERROR
, 0, saved
);
22795 /* Look up the type of DIE in CU using its type attribute ATTR.
22796 ATTR must be one of: DW_AT_type, DW_AT_GNAT_descriptive_type,
22797 DW_AT_containing_type.
22798 If there is no type substitute an error marker. */
22800 static struct type
*
22801 lookup_die_type (struct die_info
*die
, const struct attribute
*attr
,
22802 struct dwarf2_cu
*cu
)
22804 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
22805 struct objfile
*objfile
= per_objfile
->objfile
;
22806 struct type
*this_type
;
22808 gdb_assert (attr
->name
== DW_AT_type
22809 || attr
->name
== DW_AT_GNAT_descriptive_type
22810 || attr
->name
== DW_AT_containing_type
);
22812 /* First see if we have it cached. */
22814 if (attr
->form
== DW_FORM_GNU_ref_alt
)
22816 struct dwarf2_per_cu_data
*per_cu
;
22817 sect_offset sect_off
= attr
->get_ref_die_offset ();
22819 per_cu
= dwarf2_find_containing_comp_unit (sect_off
, 1, per_objfile
);
22820 this_type
= get_die_type_at_offset (sect_off
, per_cu
, per_objfile
);
22822 else if (attr
->form_is_ref ())
22824 sect_offset sect_off
= attr
->get_ref_die_offset ();
22826 this_type
= get_die_type_at_offset (sect_off
, cu
->per_cu
, per_objfile
);
22828 else if (attr
->form
== DW_FORM_ref_sig8
)
22830 ULONGEST signature
= attr
->as_signature ();
22832 return get_signatured_type (die
, signature
, cu
);
22836 complaint (_("Dwarf Error: Bad type attribute %s in DIE"
22837 " at %s [in module %s]"),
22838 dwarf_attr_name (attr
->name
), sect_offset_str (die
->sect_off
),
22839 objfile_name (objfile
));
22840 return build_error_marker_type (cu
, die
);
22843 /* If not cached we need to read it in. */
22845 if (this_type
== NULL
)
22847 struct die_info
*type_die
= NULL
;
22848 struct dwarf2_cu
*type_cu
= cu
;
22850 if (attr
->form_is_ref ())
22851 type_die
= follow_die_ref (die
, attr
, &type_cu
);
22852 if (type_die
== NULL
)
22853 return build_error_marker_type (cu
, die
);
22854 /* If we find the type now, it's probably because the type came
22855 from an inter-CU reference and the type's CU got expanded before
22857 this_type
= read_type_die (type_die
, type_cu
);
22860 /* If we still don't have a type use an error marker. */
22862 if (this_type
== NULL
)
22863 return build_error_marker_type (cu
, die
);
22868 /* Return the type in DIE, CU.
22869 Returns NULL for invalid types.
22871 This first does a lookup in die_type_hash,
22872 and only reads the die in if necessary.
22874 NOTE: This can be called when reading in partial or full symbols. */
22876 static struct type
*
22877 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
22879 struct type
*this_type
;
22881 this_type
= get_die_type (die
, cu
);
22885 return read_type_die_1 (die
, cu
);
22888 /* Read the type in DIE, CU.
22889 Returns NULL for invalid types. */
22891 static struct type
*
22892 read_type_die_1 (struct die_info
*die
, struct dwarf2_cu
*cu
)
22894 struct type
*this_type
= NULL
;
22898 case DW_TAG_class_type
:
22899 case DW_TAG_interface_type
:
22900 case DW_TAG_structure_type
:
22901 case DW_TAG_union_type
:
22902 this_type
= read_structure_type (die
, cu
);
22904 case DW_TAG_enumeration_type
:
22905 this_type
= read_enumeration_type (die
, cu
);
22907 case DW_TAG_subprogram
:
22908 case DW_TAG_subroutine_type
:
22909 case DW_TAG_inlined_subroutine
:
22910 this_type
= read_subroutine_type (die
, cu
);
22912 case DW_TAG_array_type
:
22913 this_type
= read_array_type (die
, cu
);
22915 case DW_TAG_set_type
:
22916 this_type
= read_set_type (die
, cu
);
22918 case DW_TAG_pointer_type
:
22919 this_type
= read_tag_pointer_type (die
, cu
);
22921 case DW_TAG_ptr_to_member_type
:
22922 this_type
= read_tag_ptr_to_member_type (die
, cu
);
22924 case DW_TAG_reference_type
:
22925 this_type
= read_tag_reference_type (die
, cu
, TYPE_CODE_REF
);
22927 case DW_TAG_rvalue_reference_type
:
22928 this_type
= read_tag_reference_type (die
, cu
, TYPE_CODE_RVALUE_REF
);
22930 case DW_TAG_const_type
:
22931 this_type
= read_tag_const_type (die
, cu
);
22933 case DW_TAG_volatile_type
:
22934 this_type
= read_tag_volatile_type (die
, cu
);
22936 case DW_TAG_restrict_type
:
22937 this_type
= read_tag_restrict_type (die
, cu
);
22939 case DW_TAG_string_type
:
22940 this_type
= read_tag_string_type (die
, cu
);
22942 case DW_TAG_typedef
:
22943 this_type
= read_typedef (die
, cu
);
22945 case DW_TAG_subrange_type
:
22946 this_type
= read_subrange_type (die
, cu
);
22948 case DW_TAG_base_type
:
22949 this_type
= read_base_type (die
, cu
);
22951 case DW_TAG_unspecified_type
:
22952 this_type
= read_unspecified_type (die
, cu
);
22954 case DW_TAG_namespace
:
22955 this_type
= read_namespace_type (die
, cu
);
22957 case DW_TAG_module
:
22958 this_type
= read_module_type (die
, cu
);
22960 case DW_TAG_atomic_type
:
22961 this_type
= read_tag_atomic_type (die
, cu
);
22964 complaint (_("unexpected tag in read_type_die: '%s'"),
22965 dwarf_tag_name (die
->tag
));
22972 /* See if we can figure out if the class lives in a namespace. We do
22973 this by looking for a member function; its demangled name will
22974 contain namespace info, if there is any.
22975 Return the computed name or NULL.
22976 Space for the result is allocated on the objfile's obstack.
22977 This is the full-die version of guess_partial_die_structure_name.
22978 In this case we know DIE has no useful parent. */
22980 static const char *
22981 guess_full_die_structure_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
22983 struct die_info
*spec_die
;
22984 struct dwarf2_cu
*spec_cu
;
22985 struct die_info
*child
;
22986 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22989 spec_die
= die_specification (die
, &spec_cu
);
22990 if (spec_die
!= NULL
)
22996 for (child
= die
->child
;
22998 child
= child
->sibling
)
23000 if (child
->tag
== DW_TAG_subprogram
)
23002 const char *linkage_name
= dw2_linkage_name (child
, cu
);
23004 if (linkage_name
!= NULL
)
23006 gdb::unique_xmalloc_ptr
<char> actual_name
23007 (cu
->language_defn
->class_name_from_physname (linkage_name
));
23008 const char *name
= NULL
;
23010 if (actual_name
!= NULL
)
23012 const char *die_name
= dwarf2_name (die
, cu
);
23014 if (die_name
!= NULL
23015 && strcmp (die_name
, actual_name
.get ()) != 0)
23017 /* Strip off the class name from the full name.
23018 We want the prefix. */
23019 int die_name_len
= strlen (die_name
);
23020 int actual_name_len
= strlen (actual_name
.get ());
23021 const char *ptr
= actual_name
.get ();
23023 /* Test for '::' as a sanity check. */
23024 if (actual_name_len
> die_name_len
+ 2
23025 && ptr
[actual_name_len
- die_name_len
- 1] == ':')
23026 name
= obstack_strndup (
23027 &objfile
->per_bfd
->storage_obstack
,
23028 ptr
, actual_name_len
- die_name_len
- 2);
23039 /* GCC might emit a nameless typedef that has a linkage name. Determine the
23040 prefix part in such case. See
23041 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
23043 static const char *
23044 anonymous_struct_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
23046 struct attribute
*attr
;
23049 if (die
->tag
!= DW_TAG_class_type
&& die
->tag
!= DW_TAG_interface_type
23050 && die
->tag
!= DW_TAG_structure_type
&& die
->tag
!= DW_TAG_union_type
)
23053 if (dwarf2_string_attr (die
, DW_AT_name
, cu
) != NULL
)
23056 attr
= dw2_linkage_name_attr (die
, cu
);
23057 const char *attr_name
= attr
->as_string ();
23058 if (attr
== NULL
|| attr_name
== NULL
)
23061 /* dwarf2_name had to be already called. */
23062 gdb_assert (attr
->canonical_string_p ());
23064 /* Strip the base name, keep any leading namespaces/classes. */
23065 base
= strrchr (attr_name
, ':');
23066 if (base
== NULL
|| base
== attr_name
|| base
[-1] != ':')
23069 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
23070 return obstack_strndup (&objfile
->per_bfd
->storage_obstack
,
23072 &base
[-1] - attr_name
);
23075 /* Return the name of the namespace/class that DIE is defined within,
23076 or "" if we can't tell. The caller should not xfree the result.
23078 For example, if we're within the method foo() in the following
23088 then determine_prefix on foo's die will return "N::C". */
23090 static const char *
23091 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
23093 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
23094 struct die_info
*parent
, *spec_die
;
23095 struct dwarf2_cu
*spec_cu
;
23096 struct type
*parent_type
;
23097 const char *retval
;
23099 if (cu
->language
!= language_cplus
23100 && cu
->language
!= language_fortran
&& cu
->language
!= language_d
23101 && cu
->language
!= language_rust
)
23104 retval
= anonymous_struct_prefix (die
, cu
);
23108 /* We have to be careful in the presence of DW_AT_specification.
23109 For example, with GCC 3.4, given the code
23113 // Definition of N::foo.
23117 then we'll have a tree of DIEs like this:
23119 1: DW_TAG_compile_unit
23120 2: DW_TAG_namespace // N
23121 3: DW_TAG_subprogram // declaration of N::foo
23122 4: DW_TAG_subprogram // definition of N::foo
23123 DW_AT_specification // refers to die #3
23125 Thus, when processing die #4, we have to pretend that we're in
23126 the context of its DW_AT_specification, namely the contex of die
23129 spec_die
= die_specification (die
, &spec_cu
);
23130 if (spec_die
== NULL
)
23131 parent
= die
->parent
;
23134 parent
= spec_die
->parent
;
23138 if (parent
== NULL
)
23140 else if (parent
->building_fullname
)
23143 const char *parent_name
;
23145 /* It has been seen on RealView 2.2 built binaries,
23146 DW_TAG_template_type_param types actually _defined_ as
23147 children of the parent class:
23150 template class <class Enum> Class{};
23151 Class<enum E> class_e;
23153 1: DW_TAG_class_type (Class)
23154 2: DW_TAG_enumeration_type (E)
23155 3: DW_TAG_enumerator (enum1:0)
23156 3: DW_TAG_enumerator (enum2:1)
23158 2: DW_TAG_template_type_param
23159 DW_AT_type DW_FORM_ref_udata (E)
23161 Besides being broken debug info, it can put GDB into an
23162 infinite loop. Consider:
23164 When we're building the full name for Class<E>, we'll start
23165 at Class, and go look over its template type parameters,
23166 finding E. We'll then try to build the full name of E, and
23167 reach here. We're now trying to build the full name of E,
23168 and look over the parent DIE for containing scope. In the
23169 broken case, if we followed the parent DIE of E, we'd again
23170 find Class, and once again go look at its template type
23171 arguments, etc., etc. Simply don't consider such parent die
23172 as source-level parent of this die (it can't be, the language
23173 doesn't allow it), and break the loop here. */
23174 name
= dwarf2_name (die
, cu
);
23175 parent_name
= dwarf2_name (parent
, cu
);
23176 complaint (_("template param type '%s' defined within parent '%s'"),
23177 name
? name
: "<unknown>",
23178 parent_name
? parent_name
: "<unknown>");
23182 switch (parent
->tag
)
23184 case DW_TAG_namespace
:
23185 parent_type
= read_type_die (parent
, cu
);
23186 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
23187 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
23188 Work around this problem here. */
23189 if (cu
->language
== language_cplus
23190 && strcmp (parent_type
->name (), "::") == 0)
23192 /* We give a name to even anonymous namespaces. */
23193 return parent_type
->name ();
23194 case DW_TAG_class_type
:
23195 case DW_TAG_interface_type
:
23196 case DW_TAG_structure_type
:
23197 case DW_TAG_union_type
:
23198 case DW_TAG_module
:
23199 parent_type
= read_type_die (parent
, cu
);
23200 if (parent_type
->name () != NULL
)
23201 return parent_type
->name ();
23203 /* An anonymous structure is only allowed non-static data
23204 members; no typedefs, no member functions, et cetera.
23205 So it does not need a prefix. */
23207 case DW_TAG_compile_unit
:
23208 case DW_TAG_partial_unit
:
23209 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
23210 if (cu
->language
== language_cplus
23211 && !per_objfile
->per_bfd
->types
.empty ()
23212 && die
->child
!= NULL
23213 && (die
->tag
== DW_TAG_class_type
23214 || die
->tag
== DW_TAG_structure_type
23215 || die
->tag
== DW_TAG_union_type
))
23217 const char *name
= guess_full_die_structure_name (die
, cu
);
23222 case DW_TAG_subprogram
:
23223 /* Nested subroutines in Fortran get a prefix with the name
23224 of the parent's subroutine. */
23225 if (cu
->language
== language_fortran
)
23227 if ((die
->tag
== DW_TAG_subprogram
)
23228 && (dwarf2_name (parent
, cu
) != NULL
))
23229 return dwarf2_name (parent
, cu
);
23231 return determine_prefix (parent
, cu
);
23232 case DW_TAG_enumeration_type
:
23233 parent_type
= read_type_die (parent
, cu
);
23234 if (TYPE_DECLARED_CLASS (parent_type
))
23236 if (parent_type
->name () != NULL
)
23237 return parent_type
->name ();
23240 /* Fall through. */
23242 return determine_prefix (parent
, cu
);
23246 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
23247 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
23248 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
23249 an obconcat, otherwise allocate storage for the result. The CU argument is
23250 used to determine the language and hence, the appropriate separator. */
23252 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
23255 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
23256 int physname
, struct dwarf2_cu
*cu
)
23258 const char *lead
= "";
23261 if (suffix
== NULL
|| suffix
[0] == '\0'
23262 || prefix
== NULL
|| prefix
[0] == '\0')
23264 else if (cu
->language
== language_d
)
23266 /* For D, the 'main' function could be defined in any module, but it
23267 should never be prefixed. */
23268 if (strcmp (suffix
, "D main") == 0)
23276 else if (cu
->language
== language_fortran
&& physname
)
23278 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
23279 DW_AT_MIPS_linkage_name is preferred and used instead. */
23287 if (prefix
== NULL
)
23289 if (suffix
== NULL
)
23296 xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1));
23298 strcpy (retval
, lead
);
23299 strcat (retval
, prefix
);
23300 strcat (retval
, sep
);
23301 strcat (retval
, suffix
);
23306 /* We have an obstack. */
23307 return obconcat (obs
, lead
, prefix
, sep
, suffix
, (char *) NULL
);
23311 /* Get name of a die, return NULL if not found. */
23313 static const char *
23314 dwarf2_canonicalize_name (const char *name
, struct dwarf2_cu
*cu
,
23315 struct objfile
*objfile
)
23317 if (name
&& cu
->language
== language_cplus
)
23319 gdb::unique_xmalloc_ptr
<char> canon_name
23320 = cp_canonicalize_string (name
);
23322 if (canon_name
!= nullptr)
23323 name
= objfile
->intern (canon_name
.get ());
23329 /* Get name of a die, return NULL if not found.
23330 Anonymous namespaces are converted to their magic string. */
23332 static const char *
23333 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
23335 struct attribute
*attr
;
23336 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
23338 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
23339 const char *attr_name
= attr
== nullptr ? nullptr : attr
->as_string ();
23340 if (attr_name
== nullptr
23341 && die
->tag
!= DW_TAG_namespace
23342 && die
->tag
!= DW_TAG_class_type
23343 && die
->tag
!= DW_TAG_interface_type
23344 && die
->tag
!= DW_TAG_structure_type
23345 && die
->tag
!= DW_TAG_union_type
)
23350 case DW_TAG_compile_unit
:
23351 case DW_TAG_partial_unit
:
23352 /* Compilation units have a DW_AT_name that is a filename, not
23353 a source language identifier. */
23354 case DW_TAG_enumeration_type
:
23355 case DW_TAG_enumerator
:
23356 /* These tags always have simple identifiers already; no need
23357 to canonicalize them. */
23360 case DW_TAG_namespace
:
23361 if (attr_name
!= nullptr)
23363 return CP_ANONYMOUS_NAMESPACE_STR
;
23365 case DW_TAG_class_type
:
23366 case DW_TAG_interface_type
:
23367 case DW_TAG_structure_type
:
23368 case DW_TAG_union_type
:
23369 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
23370 structures or unions. These were of the form "._%d" in GCC 4.1,
23371 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
23372 and GCC 4.4. We work around this problem by ignoring these. */
23373 if (attr_name
!= nullptr
23374 && (startswith (attr_name
, "._")
23375 || startswith (attr_name
, "<anonymous")))
23378 /* GCC might emit a nameless typedef that has a linkage name. See
23379 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
23380 if (!attr
|| attr_name
== NULL
)
23382 attr
= dw2_linkage_name_attr (die
, cu
);
23383 attr_name
= attr
== nullptr ? nullptr : attr
->as_string ();
23384 if (attr
== NULL
|| attr_name
== NULL
)
23387 /* Avoid demangling attr_name the second time on a second
23388 call for the same DIE. */
23389 if (!attr
->canonical_string_p ())
23391 gdb::unique_xmalloc_ptr
<char> demangled
23392 (gdb_demangle (attr_name
, DMGL_TYPES
));
23393 if (demangled
== nullptr)
23396 attr
->set_string_canonical (objfile
->intern (demangled
.get ()));
23397 attr_name
= attr
->as_string ();
23400 /* Strip any leading namespaces/classes, keep only the
23401 base name. DW_AT_name for named DIEs does not
23402 contain the prefixes. */
23403 const char *base
= strrchr (attr_name
, ':');
23404 if (base
&& base
> attr_name
&& base
[-1] == ':')
23415 if (!attr
->canonical_string_p ())
23416 attr
->set_string_canonical (dwarf2_canonicalize_name (attr_name
, cu
,
23418 return attr
->as_string ();
23421 /* Return the die that this die in an extension of, or NULL if there
23422 is none. *EXT_CU is the CU containing DIE on input, and the CU
23423 containing the return value on output. */
23425 static struct die_info
*
23426 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
**ext_cu
)
23428 struct attribute
*attr
;
23430 attr
= dwarf2_attr (die
, DW_AT_extension
, *ext_cu
);
23434 return follow_die_ref (die
, attr
, ext_cu
);
23438 dump_die_shallow (struct ui_file
*f
, int indent
, struct die_info
*die
)
23442 print_spaces (indent
, f
);
23443 fprintf_unfiltered (f
, "Die: %s (abbrev %d, offset %s)\n",
23444 dwarf_tag_name (die
->tag
), die
->abbrev
,
23445 sect_offset_str (die
->sect_off
));
23447 if (die
->parent
!= NULL
)
23449 print_spaces (indent
, f
);
23450 fprintf_unfiltered (f
, " parent at offset: %s\n",
23451 sect_offset_str (die
->parent
->sect_off
));
23454 print_spaces (indent
, f
);
23455 fprintf_unfiltered (f
, " has children: %s\n",
23456 dwarf_bool_name (die
->child
!= NULL
));
23458 print_spaces (indent
, f
);
23459 fprintf_unfiltered (f
, " attributes:\n");
23461 for (i
= 0; i
< die
->num_attrs
; ++i
)
23463 print_spaces (indent
, f
);
23464 fprintf_unfiltered (f
, " %s (%s) ",
23465 dwarf_attr_name (die
->attrs
[i
].name
),
23466 dwarf_form_name (die
->attrs
[i
].form
));
23468 switch (die
->attrs
[i
].form
)
23471 case DW_FORM_addrx
:
23472 case DW_FORM_GNU_addr_index
:
23473 fprintf_unfiltered (f
, "address: ");
23474 fputs_filtered (hex_string (die
->attrs
[i
].as_address ()), f
);
23476 case DW_FORM_block2
:
23477 case DW_FORM_block4
:
23478 case DW_FORM_block
:
23479 case DW_FORM_block1
:
23480 fprintf_unfiltered (f
, "block: size %s",
23481 pulongest (die
->attrs
[i
].as_block ()->size
));
23483 case DW_FORM_exprloc
:
23484 fprintf_unfiltered (f
, "expression: size %s",
23485 pulongest (die
->attrs
[i
].as_block ()->size
));
23487 case DW_FORM_data16
:
23488 fprintf_unfiltered (f
, "constant of 16 bytes");
23490 case DW_FORM_ref_addr
:
23491 fprintf_unfiltered (f
, "ref address: ");
23492 fputs_filtered (hex_string (die
->attrs
[i
].as_unsigned ()), f
);
23494 case DW_FORM_GNU_ref_alt
:
23495 fprintf_unfiltered (f
, "alt ref address: ");
23496 fputs_filtered (hex_string (die
->attrs
[i
].as_unsigned ()), f
);
23502 case DW_FORM_ref_udata
:
23503 fprintf_unfiltered (f
, "constant ref: 0x%lx (adjusted)",
23504 (long) (die
->attrs
[i
].as_unsigned ()));
23506 case DW_FORM_data1
:
23507 case DW_FORM_data2
:
23508 case DW_FORM_data4
:
23509 case DW_FORM_data8
:
23510 case DW_FORM_udata
:
23511 fprintf_unfiltered (f
, "constant: %s",
23512 pulongest (die
->attrs
[i
].as_unsigned ()));
23514 case DW_FORM_sec_offset
:
23515 fprintf_unfiltered (f
, "section offset: %s",
23516 pulongest (die
->attrs
[i
].as_unsigned ()));
23518 case DW_FORM_ref_sig8
:
23519 fprintf_unfiltered (f
, "signature: %s",
23520 hex_string (die
->attrs
[i
].as_signature ()));
23522 case DW_FORM_string
:
23524 case DW_FORM_line_strp
:
23526 case DW_FORM_GNU_str_index
:
23527 case DW_FORM_GNU_strp_alt
:
23528 fprintf_unfiltered (f
, "string: \"%s\" (%s canonicalized)",
23529 die
->attrs
[i
].as_string ()
23530 ? die
->attrs
[i
].as_string () : "",
23531 die
->attrs
[i
].canonical_string_p () ? "is" : "not");
23534 if (die
->attrs
[i
].as_boolean ())
23535 fprintf_unfiltered (f
, "flag: TRUE");
23537 fprintf_unfiltered (f
, "flag: FALSE");
23539 case DW_FORM_flag_present
:
23540 fprintf_unfiltered (f
, "flag: TRUE");
23542 case DW_FORM_indirect
:
23543 /* The reader will have reduced the indirect form to
23544 the "base form" so this form should not occur. */
23545 fprintf_unfiltered (f
,
23546 "unexpected attribute form: DW_FORM_indirect");
23548 case DW_FORM_sdata
:
23549 case DW_FORM_implicit_const
:
23550 fprintf_unfiltered (f
, "constant: %s",
23551 plongest (die
->attrs
[i
].as_signed ()));
23554 fprintf_unfiltered (f
, "unsupported attribute form: %d.",
23555 die
->attrs
[i
].form
);
23558 fprintf_unfiltered (f
, "\n");
23563 dump_die_for_error (struct die_info
*die
)
23565 dump_die_shallow (gdb_stderr
, 0, die
);
23569 dump_die_1 (struct ui_file
*f
, int level
, int max_level
, struct die_info
*die
)
23571 int indent
= level
* 4;
23573 gdb_assert (die
!= NULL
);
23575 if (level
>= max_level
)
23578 dump_die_shallow (f
, indent
, die
);
23580 if (die
->child
!= NULL
)
23582 print_spaces (indent
, f
);
23583 fprintf_unfiltered (f
, " Children:");
23584 if (level
+ 1 < max_level
)
23586 fprintf_unfiltered (f
, "\n");
23587 dump_die_1 (f
, level
+ 1, max_level
, die
->child
);
23591 fprintf_unfiltered (f
,
23592 " [not printed, max nesting level reached]\n");
23596 if (die
->sibling
!= NULL
&& level
> 0)
23598 dump_die_1 (f
, level
, max_level
, die
->sibling
);
23602 /* This is called from the pdie macro in gdbinit.in.
23603 It's not static so gcc will keep a copy callable from gdb. */
23606 dump_die (struct die_info
*die
, int max_level
)
23608 dump_die_1 (gdb_stdlog
, 0, max_level
, die
);
23612 store_in_ref_table (struct die_info
*die
, struct dwarf2_cu
*cu
)
23616 slot
= htab_find_slot_with_hash (cu
->die_hash
, die
,
23617 to_underlying (die
->sect_off
),
23623 /* Follow reference or signature attribute ATTR of SRC_DIE.
23624 On entry *REF_CU is the CU of SRC_DIE.
23625 On exit *REF_CU is the CU of the result. */
23627 static struct die_info
*
23628 follow_die_ref_or_sig (struct die_info
*src_die
, const struct attribute
*attr
,
23629 struct dwarf2_cu
**ref_cu
)
23631 struct die_info
*die
;
23633 if (attr
->form_is_ref ())
23634 die
= follow_die_ref (src_die
, attr
, ref_cu
);
23635 else if (attr
->form
== DW_FORM_ref_sig8
)
23636 die
= follow_die_sig (src_die
, attr
, ref_cu
);
23639 dump_die_for_error (src_die
);
23640 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
23641 objfile_name ((*ref_cu
)->per_objfile
->objfile
));
23647 /* Follow reference OFFSET.
23648 On entry *REF_CU is the CU of the source die referencing OFFSET.
23649 On exit *REF_CU is the CU of the result.
23650 Returns NULL if OFFSET is invalid. */
23652 static struct die_info
*
23653 follow_die_offset (sect_offset sect_off
, int offset_in_dwz
,
23654 struct dwarf2_cu
**ref_cu
)
23656 struct die_info temp_die
;
23657 struct dwarf2_cu
*target_cu
, *cu
= *ref_cu
;
23658 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
23660 gdb_assert (cu
->per_cu
!= NULL
);
23664 dwarf_read_debug_printf_v ("source CU offset: %s, target offset: %s, "
23665 "source CU contains target offset: %d",
23666 sect_offset_str (cu
->per_cu
->sect_off
),
23667 sect_offset_str (sect_off
),
23668 cu
->header
.offset_in_cu_p (sect_off
));
23670 if (cu
->per_cu
->is_debug_types
)
23672 /* .debug_types CUs cannot reference anything outside their CU.
23673 If they need to, they have to reference a signatured type via
23674 DW_FORM_ref_sig8. */
23675 if (!cu
->header
.offset_in_cu_p (sect_off
))
23678 else if (offset_in_dwz
!= cu
->per_cu
->is_dwz
23679 || !cu
->header
.offset_in_cu_p (sect_off
))
23681 struct dwarf2_per_cu_data
*per_cu
;
23683 per_cu
= dwarf2_find_containing_comp_unit (sect_off
, offset_in_dwz
,
23686 dwarf_read_debug_printf_v ("target CU offset: %s, "
23687 "target CU DIEs loaded: %d",
23688 sect_offset_str (per_cu
->sect_off
),
23689 per_objfile
->get_cu (per_cu
) != nullptr);
23691 /* If necessary, add it to the queue and load its DIEs. */
23692 if (maybe_queue_comp_unit (cu
, per_cu
, per_objfile
, cu
->language
))
23693 load_full_comp_unit (per_cu
, per_objfile
, per_objfile
->get_cu (per_cu
),
23694 false, cu
->language
);
23696 target_cu
= per_objfile
->get_cu (per_cu
);
23698 else if (cu
->dies
== NULL
)
23700 /* We're loading full DIEs during partial symbol reading. */
23701 gdb_assert (per_objfile
->per_bfd
->reading_partial_symbols
);
23702 load_full_comp_unit (cu
->per_cu
, per_objfile
, cu
, false,
23706 *ref_cu
= target_cu
;
23707 temp_die
.sect_off
= sect_off
;
23709 if (target_cu
!= cu
)
23710 target_cu
->ancestor
= cu
;
23712 return (struct die_info
*) htab_find_with_hash (target_cu
->die_hash
,
23714 to_underlying (sect_off
));
23717 /* Follow reference attribute ATTR of SRC_DIE.
23718 On entry *REF_CU is the CU of SRC_DIE.
23719 On exit *REF_CU is the CU of the result. */
23721 static struct die_info
*
23722 follow_die_ref (struct die_info
*src_die
, const struct attribute
*attr
,
23723 struct dwarf2_cu
**ref_cu
)
23725 sect_offset sect_off
= attr
->get_ref_die_offset ();
23726 struct dwarf2_cu
*cu
= *ref_cu
;
23727 struct die_info
*die
;
23729 die
= follow_die_offset (sect_off
,
23730 (attr
->form
== DW_FORM_GNU_ref_alt
23731 || cu
->per_cu
->is_dwz
),
23734 error (_("Dwarf Error: Cannot find DIE at %s referenced from DIE "
23735 "at %s [in module %s]"),
23736 sect_offset_str (sect_off
), sect_offset_str (src_die
->sect_off
),
23737 objfile_name (cu
->per_objfile
->objfile
));
23744 struct dwarf2_locexpr_baton
23745 dwarf2_fetch_die_loc_sect_off (sect_offset sect_off
,
23746 dwarf2_per_cu_data
*per_cu
,
23747 dwarf2_per_objfile
*per_objfile
,
23748 gdb::function_view
<CORE_ADDR ()> get_frame_pc
,
23749 bool resolve_abstract_p
)
23751 struct die_info
*die
;
23752 struct attribute
*attr
;
23753 struct dwarf2_locexpr_baton retval
;
23754 struct objfile
*objfile
= per_objfile
->objfile
;
23756 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
23758 cu
= load_cu (per_cu
, per_objfile
, false);
23762 /* We shouldn't get here for a dummy CU, but don't crash on the user.
23763 Instead just throw an error, not much else we can do. */
23764 error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23765 sect_offset_str (sect_off
), objfile_name (objfile
));
23768 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
23770 error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23771 sect_offset_str (sect_off
), objfile_name (objfile
));
23773 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
23774 if (!attr
&& resolve_abstract_p
23775 && (per_objfile
->per_bfd
->abstract_to_concrete
.find (die
->sect_off
)
23776 != per_objfile
->per_bfd
->abstract_to_concrete
.end ()))
23778 CORE_ADDR pc
= get_frame_pc ();
23779 CORE_ADDR baseaddr
= objfile
->text_section_offset ();
23780 struct gdbarch
*gdbarch
= objfile
->arch ();
23782 for (const auto &cand_off
23783 : per_objfile
->per_bfd
->abstract_to_concrete
[die
->sect_off
])
23785 struct dwarf2_cu
*cand_cu
= cu
;
23786 struct die_info
*cand
23787 = follow_die_offset (cand_off
, per_cu
->is_dwz
, &cand_cu
);
23790 || cand
->parent
->tag
!= DW_TAG_subprogram
)
23793 CORE_ADDR pc_low
, pc_high
;
23794 get_scope_pc_bounds (cand
->parent
, &pc_low
, &pc_high
, cu
);
23795 if (pc_low
== ((CORE_ADDR
) -1))
23797 pc_low
= gdbarch_adjust_dwarf2_addr (gdbarch
, pc_low
+ baseaddr
);
23798 pc_high
= gdbarch_adjust_dwarf2_addr (gdbarch
, pc_high
+ baseaddr
);
23799 if (!(pc_low
<= pc
&& pc
< pc_high
))
23803 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
23810 /* DWARF: "If there is no such attribute, then there is no effect.".
23811 DATA is ignored if SIZE is 0. */
23813 retval
.data
= NULL
;
23816 else if (attr
->form_is_section_offset ())
23818 struct dwarf2_loclist_baton loclist_baton
;
23819 CORE_ADDR pc
= get_frame_pc ();
23822 fill_in_loclist_baton (cu
, &loclist_baton
, attr
);
23824 retval
.data
= dwarf2_find_location_expression (&loclist_baton
,
23826 retval
.size
= size
;
23830 if (!attr
->form_is_block ())
23831 error (_("Dwarf Error: DIE at %s referenced in module %s "
23832 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
23833 sect_offset_str (sect_off
), objfile_name (objfile
));
23835 struct dwarf_block
*block
= attr
->as_block ();
23836 retval
.data
= block
->data
;
23837 retval
.size
= block
->size
;
23839 retval
.per_objfile
= per_objfile
;
23840 retval
.per_cu
= cu
->per_cu
;
23842 per_objfile
->age_comp_units ();
23849 struct dwarf2_locexpr_baton
23850 dwarf2_fetch_die_loc_cu_off (cu_offset offset_in_cu
,
23851 dwarf2_per_cu_data
*per_cu
,
23852 dwarf2_per_objfile
*per_objfile
,
23853 gdb::function_view
<CORE_ADDR ()> get_frame_pc
)
23855 sect_offset sect_off
= per_cu
->sect_off
+ to_underlying (offset_in_cu
);
23857 return dwarf2_fetch_die_loc_sect_off (sect_off
, per_cu
, per_objfile
,
23861 /* Write a constant of a given type as target-ordered bytes into
23864 static const gdb_byte
*
23865 write_constant_as_bytes (struct obstack
*obstack
,
23866 enum bfd_endian byte_order
,
23873 *len
= TYPE_LENGTH (type
);
23874 result
= (gdb_byte
*) obstack_alloc (obstack
, *len
);
23875 store_unsigned_integer (result
, *len
, byte_order
, value
);
23883 dwarf2_fetch_constant_bytes (sect_offset sect_off
,
23884 dwarf2_per_cu_data
*per_cu
,
23885 dwarf2_per_objfile
*per_objfile
,
23889 struct die_info
*die
;
23890 struct attribute
*attr
;
23891 const gdb_byte
*result
= NULL
;
23894 enum bfd_endian byte_order
;
23895 struct objfile
*objfile
= per_objfile
->objfile
;
23897 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
23899 cu
= load_cu (per_cu
, per_objfile
, false);
23903 /* We shouldn't get here for a dummy CU, but don't crash on the user.
23904 Instead just throw an error, not much else we can do. */
23905 error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23906 sect_offset_str (sect_off
), objfile_name (objfile
));
23909 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
23911 error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23912 sect_offset_str (sect_off
), objfile_name (objfile
));
23914 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
23918 byte_order
= (bfd_big_endian (objfile
->obfd
)
23919 ? BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
23921 switch (attr
->form
)
23924 case DW_FORM_addrx
:
23925 case DW_FORM_GNU_addr_index
:
23929 *len
= cu
->header
.addr_size
;
23930 tem
= (gdb_byte
*) obstack_alloc (obstack
, *len
);
23931 store_unsigned_integer (tem
, *len
, byte_order
, attr
->as_address ());
23935 case DW_FORM_string
:
23938 case DW_FORM_GNU_str_index
:
23939 case DW_FORM_GNU_strp_alt
:
23940 /* The string is already allocated on the objfile obstack, point
23943 const char *attr_name
= attr
->as_string ();
23944 result
= (const gdb_byte
*) attr_name
;
23945 *len
= strlen (attr_name
);
23948 case DW_FORM_block1
:
23949 case DW_FORM_block2
:
23950 case DW_FORM_block4
:
23951 case DW_FORM_block
:
23952 case DW_FORM_exprloc
:
23953 case DW_FORM_data16
:
23955 struct dwarf_block
*block
= attr
->as_block ();
23956 result
= block
->data
;
23957 *len
= block
->size
;
23961 /* The DW_AT_const_value attributes are supposed to carry the
23962 symbol's value "represented as it would be on the target
23963 architecture." By the time we get here, it's already been
23964 converted to host endianness, so we just need to sign- or
23965 zero-extend it as appropriate. */
23966 case DW_FORM_data1
:
23967 type
= die_type (die
, cu
);
23968 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 8);
23969 if (result
== NULL
)
23970 result
= write_constant_as_bytes (obstack
, byte_order
,
23973 case DW_FORM_data2
:
23974 type
= die_type (die
, cu
);
23975 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 16);
23976 if (result
== NULL
)
23977 result
= write_constant_as_bytes (obstack
, byte_order
,
23980 case DW_FORM_data4
:
23981 type
= die_type (die
, cu
);
23982 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 32);
23983 if (result
== NULL
)
23984 result
= write_constant_as_bytes (obstack
, byte_order
,
23987 case DW_FORM_data8
:
23988 type
= die_type (die
, cu
);
23989 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 64);
23990 if (result
== NULL
)
23991 result
= write_constant_as_bytes (obstack
, byte_order
,
23995 case DW_FORM_sdata
:
23996 case DW_FORM_implicit_const
:
23997 type
= die_type (die
, cu
);
23998 result
= write_constant_as_bytes (obstack
, byte_order
,
23999 type
, attr
->as_signed (), len
);
24002 case DW_FORM_udata
:
24003 type
= die_type (die
, cu
);
24004 result
= write_constant_as_bytes (obstack
, byte_order
,
24005 type
, attr
->as_unsigned (), len
);
24009 complaint (_("unsupported const value attribute form: '%s'"),
24010 dwarf_form_name (attr
->form
));
24020 dwarf2_fetch_die_type_sect_off (sect_offset sect_off
,
24021 dwarf2_per_cu_data
*per_cu
,
24022 dwarf2_per_objfile
*per_objfile
)
24024 struct die_info
*die
;
24026 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
24028 cu
= load_cu (per_cu
, per_objfile
, false);
24033 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
24037 return die_type (die
, cu
);
24043 dwarf2_get_die_type (cu_offset die_offset
,
24044 dwarf2_per_cu_data
*per_cu
,
24045 dwarf2_per_objfile
*per_objfile
)
24047 sect_offset die_offset_sect
= per_cu
->sect_off
+ to_underlying (die_offset
);
24048 return get_die_type_at_offset (die_offset_sect
, per_cu
, per_objfile
);
24051 /* Follow type unit SIG_TYPE referenced by SRC_DIE.
24052 On entry *REF_CU is the CU of SRC_DIE.
24053 On exit *REF_CU is the CU of the result.
24054 Returns NULL if the referenced DIE isn't found. */
24056 static struct die_info
*
24057 follow_die_sig_1 (struct die_info
*src_die
, struct signatured_type
*sig_type
,
24058 struct dwarf2_cu
**ref_cu
)
24060 struct die_info temp_die
;
24061 struct dwarf2_cu
*sig_cu
, *cu
= *ref_cu
;
24062 struct die_info
*die
;
24063 dwarf2_per_objfile
*per_objfile
= (*ref_cu
)->per_objfile
;
24066 /* While it might be nice to assert sig_type->type == NULL here,
24067 we can get here for DW_AT_imported_declaration where we need
24068 the DIE not the type. */
24070 /* If necessary, add it to the queue and load its DIEs. */
24072 if (maybe_queue_comp_unit (*ref_cu
, &sig_type
->per_cu
, per_objfile
,
24074 read_signatured_type (sig_type
, per_objfile
);
24076 sig_cu
= per_objfile
->get_cu (&sig_type
->per_cu
);
24077 gdb_assert (sig_cu
!= NULL
);
24078 gdb_assert (to_underlying (sig_type
->type_offset_in_section
) != 0);
24079 temp_die
.sect_off
= sig_type
->type_offset_in_section
;
24080 die
= (struct die_info
*) htab_find_with_hash (sig_cu
->die_hash
, &temp_die
,
24081 to_underlying (temp_die
.sect_off
));
24084 /* For .gdb_index version 7 keep track of included TUs.
24085 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
24086 if (per_objfile
->per_bfd
->index_table
!= NULL
24087 && per_objfile
->per_bfd
->index_table
->version
<= 7)
24089 (*ref_cu
)->per_cu
->imported_symtabs_push (sig_cu
->per_cu
);
24094 sig_cu
->ancestor
= cu
;
24102 /* Follow signatured type referenced by ATTR in SRC_DIE.
24103 On entry *REF_CU is the CU of SRC_DIE.
24104 On exit *REF_CU is the CU of the result.
24105 The result is the DIE of the type.
24106 If the referenced type cannot be found an error is thrown. */
24108 static struct die_info
*
24109 follow_die_sig (struct die_info
*src_die
, const struct attribute
*attr
,
24110 struct dwarf2_cu
**ref_cu
)
24112 ULONGEST signature
= attr
->as_signature ();
24113 struct signatured_type
*sig_type
;
24114 struct die_info
*die
;
24116 gdb_assert (attr
->form
== DW_FORM_ref_sig8
);
24118 sig_type
= lookup_signatured_type (*ref_cu
, signature
);
24119 /* sig_type will be NULL if the signatured type is missing from
24121 if (sig_type
== NULL
)
24123 error (_("Dwarf Error: Cannot find signatured DIE %s referenced"
24124 " from DIE at %s [in module %s]"),
24125 hex_string (signature
), sect_offset_str (src_die
->sect_off
),
24126 objfile_name ((*ref_cu
)->per_objfile
->objfile
));
24129 die
= follow_die_sig_1 (src_die
, sig_type
, ref_cu
);
24132 dump_die_for_error (src_die
);
24133 error (_("Dwarf Error: Problem reading signatured DIE %s referenced"
24134 " from DIE at %s [in module %s]"),
24135 hex_string (signature
), sect_offset_str (src_die
->sect_off
),
24136 objfile_name ((*ref_cu
)->per_objfile
->objfile
));
24142 /* Get the type specified by SIGNATURE referenced in DIE/CU,
24143 reading in and processing the type unit if necessary. */
24145 static struct type
*
24146 get_signatured_type (struct die_info
*die
, ULONGEST signature
,
24147 struct dwarf2_cu
*cu
)
24149 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
24150 struct signatured_type
*sig_type
;
24151 struct dwarf2_cu
*type_cu
;
24152 struct die_info
*type_die
;
24155 sig_type
= lookup_signatured_type (cu
, signature
);
24156 /* sig_type will be NULL if the signatured type is missing from
24158 if (sig_type
== NULL
)
24160 complaint (_("Dwarf Error: Cannot find signatured DIE %s referenced"
24161 " from DIE at %s [in module %s]"),
24162 hex_string (signature
), sect_offset_str (die
->sect_off
),
24163 objfile_name (per_objfile
->objfile
));
24164 return build_error_marker_type (cu
, die
);
24167 /* If we already know the type we're done. */
24168 type
= per_objfile
->get_type_for_signatured_type (sig_type
);
24169 if (type
!= nullptr)
24173 type_die
= follow_die_sig_1 (die
, sig_type
, &type_cu
);
24174 if (type_die
!= NULL
)
24176 /* N.B. We need to call get_die_type to ensure only one type for this DIE
24177 is created. This is important, for example, because for c++ classes
24178 we need TYPE_NAME set which is only done by new_symbol. Blech. */
24179 type
= read_type_die (type_die
, type_cu
);
24182 complaint (_("Dwarf Error: Cannot build signatured type %s"
24183 " referenced from DIE at %s [in module %s]"),
24184 hex_string (signature
), sect_offset_str (die
->sect_off
),
24185 objfile_name (per_objfile
->objfile
));
24186 type
= build_error_marker_type (cu
, die
);
24191 complaint (_("Dwarf Error: Problem reading signatured DIE %s referenced"
24192 " from DIE at %s [in module %s]"),
24193 hex_string (signature
), sect_offset_str (die
->sect_off
),
24194 objfile_name (per_objfile
->objfile
));
24195 type
= build_error_marker_type (cu
, die
);
24198 per_objfile
->set_type_for_signatured_type (sig_type
, type
);
24203 /* Get the type specified by the DW_AT_signature ATTR in DIE/CU,
24204 reading in and processing the type unit if necessary. */
24206 static struct type
*
24207 get_DW_AT_signature_type (struct die_info
*die
, const struct attribute
*attr
,
24208 struct dwarf2_cu
*cu
) /* ARI: editCase function */
24210 /* Yes, DW_AT_signature can use a non-ref_sig8 reference. */
24211 if (attr
->form_is_ref ())
24213 struct dwarf2_cu
*type_cu
= cu
;
24214 struct die_info
*type_die
= follow_die_ref (die
, attr
, &type_cu
);
24216 return read_type_die (type_die
, type_cu
);
24218 else if (attr
->form
== DW_FORM_ref_sig8
)
24220 return get_signatured_type (die
, attr
->as_signature (), cu
);
24224 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
24226 complaint (_("Dwarf Error: DW_AT_signature has bad form %s in DIE"
24227 " at %s [in module %s]"),
24228 dwarf_form_name (attr
->form
), sect_offset_str (die
->sect_off
),
24229 objfile_name (per_objfile
->objfile
));
24230 return build_error_marker_type (cu
, die
);
24234 /* Load the DIEs associated with type unit PER_CU into memory. */
24237 load_full_type_unit (dwarf2_per_cu_data
*per_cu
,
24238 dwarf2_per_objfile
*per_objfile
)
24240 struct signatured_type
*sig_type
;
24242 /* Caller is responsible for ensuring type_unit_groups don't get here. */
24243 gdb_assert (! per_cu
->type_unit_group_p ());
24245 /* We have the per_cu, but we need the signatured_type.
24246 Fortunately this is an easy translation. */
24247 gdb_assert (per_cu
->is_debug_types
);
24248 sig_type
= (struct signatured_type
*) per_cu
;
24250 gdb_assert (per_objfile
->get_cu (per_cu
) == nullptr);
24252 read_signatured_type (sig_type
, per_objfile
);
24254 gdb_assert (per_objfile
->get_cu (per_cu
) != nullptr);
24257 /* Read in a signatured type and build its CU and DIEs.
24258 If the type is a stub for the real type in a DWO file,
24259 read in the real type from the DWO file as well. */
24262 read_signatured_type (signatured_type
*sig_type
,
24263 dwarf2_per_objfile
*per_objfile
)
24265 struct dwarf2_per_cu_data
*per_cu
= &sig_type
->per_cu
;
24267 gdb_assert (per_cu
->is_debug_types
);
24268 gdb_assert (per_objfile
->get_cu (per_cu
) == nullptr);
24270 cutu_reader
reader (per_cu
, per_objfile
, nullptr, nullptr, false);
24272 if (!reader
.dummy_p
)
24274 struct dwarf2_cu
*cu
= reader
.cu
;
24275 const gdb_byte
*info_ptr
= reader
.info_ptr
;
24277 gdb_assert (cu
->die_hash
== NULL
);
24279 htab_create_alloc_ex (cu
->header
.length
/ 12,
24283 &cu
->comp_unit_obstack
,
24284 hashtab_obstack_allocate
,
24285 dummy_obstack_deallocate
);
24287 if (reader
.comp_unit_die
->has_children
)
24288 reader
.comp_unit_die
->child
24289 = read_die_and_siblings (&reader
, info_ptr
, &info_ptr
,
24290 reader
.comp_unit_die
);
24291 cu
->dies
= reader
.comp_unit_die
;
24292 /* comp_unit_die is not stored in die_hash, no need. */
24294 /* We try not to read any attributes in this function, because
24295 not all CUs needed for references have been loaded yet, and
24296 symbol table processing isn't initialized. But we have to
24297 set the CU language, or we won't be able to build types
24298 correctly. Similarly, if we do not read the producer, we can
24299 not apply producer-specific interpretation. */
24300 prepare_one_comp_unit (cu
, cu
->dies
, language_minimal
);
24305 sig_type
->per_cu
.tu_read
= 1;
24308 /* Decode simple location descriptions.
24309 Given a pointer to a dwarf block that defines a location, compute
24310 the location and return the value. If COMPUTED is non-null, it is
24311 set to true to indicate that decoding was successful, and false
24312 otherwise. If COMPUTED is null, then this function may emit a
24316 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
, bool *computed
)
24318 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
24320 size_t size
= blk
->size
;
24321 const gdb_byte
*data
= blk
->data
;
24322 CORE_ADDR stack
[64];
24324 unsigned int bytes_read
, unsnd
;
24327 if (computed
!= nullptr)
24333 stack
[++stacki
] = 0;
24372 stack
[++stacki
] = op
- DW_OP_lit0
;
24407 stack
[++stacki
] = op
- DW_OP_reg0
;
24410 if (computed
== nullptr)
24411 dwarf2_complex_location_expr_complaint ();
24418 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
24420 stack
[++stacki
] = unsnd
;
24423 if (computed
== nullptr)
24424 dwarf2_complex_location_expr_complaint ();
24431 stack
[++stacki
] = cu
->header
.read_address (objfile
->obfd
, &data
[i
],
24436 case DW_OP_const1u
:
24437 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
24441 case DW_OP_const1s
:
24442 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
24446 case DW_OP_const2u
:
24447 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
24451 case DW_OP_const2s
:
24452 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
24456 case DW_OP_const4u
:
24457 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
24461 case DW_OP_const4s
:
24462 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
24466 case DW_OP_const8u
:
24467 stack
[++stacki
] = read_8_bytes (objfile
->obfd
, &data
[i
]);
24472 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
24478 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
24483 stack
[stacki
+ 1] = stack
[stacki
];
24488 stack
[stacki
- 1] += stack
[stacki
];
24492 case DW_OP_plus_uconst
:
24493 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
),
24499 stack
[stacki
- 1] -= stack
[stacki
];
24504 /* If we're not the last op, then we definitely can't encode
24505 this using GDB's address_class enum. This is valid for partial
24506 global symbols, although the variable's address will be bogus
24510 if (computed
== nullptr)
24511 dwarf2_complex_location_expr_complaint ();
24517 case DW_OP_GNU_push_tls_address
:
24518 case DW_OP_form_tls_address
:
24519 /* The top of the stack has the offset from the beginning
24520 of the thread control block at which the variable is located. */
24521 /* Nothing should follow this operator, so the top of stack would
24523 /* This is valid for partial global symbols, but the variable's
24524 address will be bogus in the psymtab. Make it always at least
24525 non-zero to not look as a variable garbage collected by linker
24526 which have DW_OP_addr 0. */
24529 if (computed
== nullptr)
24530 dwarf2_complex_location_expr_complaint ();
24537 case DW_OP_GNU_uninit
:
24538 if (computed
!= nullptr)
24543 case DW_OP_GNU_addr_index
:
24544 case DW_OP_GNU_const_index
:
24545 stack
[++stacki
] = read_addr_index_from_leb128 (cu
, &data
[i
],
24551 if (computed
== nullptr)
24553 const char *name
= get_DW_OP_name (op
);
24556 complaint (_("unsupported stack op: '%s'"),
24559 complaint (_("unsupported stack op: '%02x'"),
24563 return (stack
[stacki
]);
24566 /* Enforce maximum stack depth of SIZE-1 to avoid writing
24567 outside of the allocated space. Also enforce minimum>0. */
24568 if (stacki
>= ARRAY_SIZE (stack
) - 1)
24570 if (computed
== nullptr)
24571 complaint (_("location description stack overflow"));
24577 if (computed
== nullptr)
24578 complaint (_("location description stack underflow"));
24583 if (computed
!= nullptr)
24585 return (stack
[stacki
]);
24588 /* memory allocation interface */
24590 static struct dwarf_block
*
24591 dwarf_alloc_block (struct dwarf2_cu
*cu
)
24593 return XOBNEW (&cu
->comp_unit_obstack
, struct dwarf_block
);
24596 static struct die_info
*
24597 dwarf_alloc_die (struct dwarf2_cu
*cu
, int num_attrs
)
24599 struct die_info
*die
;
24600 size_t size
= sizeof (struct die_info
);
24603 size
+= (num_attrs
- 1) * sizeof (struct attribute
);
24605 die
= (struct die_info
*) obstack_alloc (&cu
->comp_unit_obstack
, size
);
24606 memset (die
, 0, sizeof (struct die_info
));
24612 /* Macro support. */
24614 /* An overload of dwarf_decode_macros that finds the correct section
24615 and ensures it is read in before calling the other overload. */
24618 dwarf_decode_macros (struct dwarf2_cu
*cu
, unsigned int offset
,
24619 int section_is_gnu
)
24621 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
24622 struct objfile
*objfile
= per_objfile
->objfile
;
24623 const struct line_header
*lh
= cu
->line_header
;
24624 unsigned int offset_size
= cu
->header
.offset_size
;
24625 struct dwarf2_section_info
*section
;
24626 const char *section_name
;
24628 if (cu
->dwo_unit
!= nullptr)
24630 if (section_is_gnu
)
24632 section
= &cu
->dwo_unit
->dwo_file
->sections
.macro
;
24633 section_name
= ".debug_macro.dwo";
24637 section
= &cu
->dwo_unit
->dwo_file
->sections
.macinfo
;
24638 section_name
= ".debug_macinfo.dwo";
24643 if (section_is_gnu
)
24645 section
= &per_objfile
->per_bfd
->macro
;
24646 section_name
= ".debug_macro";
24650 section
= &per_objfile
->per_bfd
->macinfo
;
24651 section_name
= ".debug_macinfo";
24655 section
->read (objfile
);
24656 if (section
->buffer
== nullptr)
24658 complaint (_("missing %s section"), section_name
);
24662 buildsym_compunit
*builder
= cu
->get_builder ();
24664 struct dwarf2_section_info
*str_offsets_section
;
24665 struct dwarf2_section_info
*str_section
;
24666 ULONGEST str_offsets_base
;
24668 if (cu
->dwo_unit
!= nullptr)
24670 str_offsets_section
= &cu
->dwo_unit
->dwo_file
24671 ->sections
.str_offsets
;
24672 str_section
= &cu
->dwo_unit
->dwo_file
->sections
.str
;
24673 str_offsets_base
= cu
->header
.addr_size
;
24677 str_offsets_section
= &per_objfile
->per_bfd
->str_offsets
;
24678 str_section
= &per_objfile
->per_bfd
->str
;
24679 str_offsets_base
= *cu
->str_offsets_base
;
24682 dwarf_decode_macros (per_objfile
, builder
, section
, lh
,
24683 offset_size
, offset
, str_section
, str_offsets_section
,
24684 str_offsets_base
, section_is_gnu
);
24687 /* Return the .debug_loc section to use for CU.
24688 For DWO files use .debug_loc.dwo. */
24690 static struct dwarf2_section_info
*
24691 cu_debug_loc_section (struct dwarf2_cu
*cu
)
24693 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
24697 struct dwo_sections
*sections
= &cu
->dwo_unit
->dwo_file
->sections
;
24699 return cu
->header
.version
>= 5 ? §ions
->loclists
: §ions
->loc
;
24701 return (cu
->header
.version
>= 5 ? &per_objfile
->per_bfd
->loclists
24702 : &per_objfile
->per_bfd
->loc
);
24705 /* Return the .debug_rnglists section to use for CU. */
24706 static struct dwarf2_section_info
*
24707 cu_debug_rnglists_section (struct dwarf2_cu
*cu
, dwarf_tag tag
)
24709 if (cu
->header
.version
< 5)
24710 error (_(".debug_rnglists section cannot be used in DWARF %d"),
24711 cu
->header
.version
);
24712 struct dwarf2_per_objfile
*dwarf2_per_objfile
= cu
->per_objfile
;
24714 /* Make sure we read the .debug_rnglists section from the file that
24715 contains the DW_AT_ranges attribute we are reading. Normally that
24716 would be the .dwo file, if there is one. However for DW_TAG_compile_unit
24717 or DW_TAG_skeleton unit, we always want to read from objfile/linked
24719 if (cu
->dwo_unit
!= nullptr
24720 && tag
!= DW_TAG_compile_unit
24721 && tag
!= DW_TAG_skeleton_unit
)
24723 struct dwo_sections
*sections
= &cu
->dwo_unit
->dwo_file
->sections
;
24725 if (sections
->rnglists
.size
> 0)
24726 return §ions
->rnglists
;
24728 error (_(".debug_rnglists section is missing from .dwo file."));
24730 return &dwarf2_per_objfile
->per_bfd
->rnglists
;
24733 /* A helper function that fills in a dwarf2_loclist_baton. */
24736 fill_in_loclist_baton (struct dwarf2_cu
*cu
,
24737 struct dwarf2_loclist_baton
*baton
,
24738 const struct attribute
*attr
)
24740 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
24741 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
24743 section
->read (per_objfile
->objfile
);
24745 baton
->per_objfile
= per_objfile
;
24746 baton
->per_cu
= cu
->per_cu
;
24747 gdb_assert (baton
->per_cu
);
24748 /* We don't know how long the location list is, but make sure we
24749 don't run off the edge of the section. */
24750 baton
->size
= section
->size
- attr
->as_unsigned ();
24751 baton
->data
= section
->buffer
+ attr
->as_unsigned ();
24752 if (cu
->base_address
.has_value ())
24753 baton
->base_address
= *cu
->base_address
;
24755 baton
->base_address
= 0;
24756 baton
->from_dwo
= cu
->dwo_unit
!= NULL
;
24760 dwarf2_symbol_mark_computed (const struct attribute
*attr
, struct symbol
*sym
,
24761 struct dwarf2_cu
*cu
, int is_block
)
24763 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
24764 struct objfile
*objfile
= per_objfile
->objfile
;
24765 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
24767 if (attr
->form_is_section_offset ()
24768 /* .debug_loc{,.dwo} may not exist at all, or the offset may be outside
24769 the section. If so, fall through to the complaint in the
24771 && attr
->as_unsigned () < section
->get_size (objfile
))
24773 struct dwarf2_loclist_baton
*baton
;
24775 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_loclist_baton
);
24777 fill_in_loclist_baton (cu
, baton
, attr
);
24779 if (!cu
->base_address
.has_value ())
24780 complaint (_("Location list used without "
24781 "specifying the CU base address."));
24783 SYMBOL_ACLASS_INDEX (sym
) = (is_block
24784 ? dwarf2_loclist_block_index
24785 : dwarf2_loclist_index
);
24786 SYMBOL_LOCATION_BATON (sym
) = baton
;
24790 struct dwarf2_locexpr_baton
*baton
;
24792 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
24793 baton
->per_objfile
= per_objfile
;
24794 baton
->per_cu
= cu
->per_cu
;
24795 gdb_assert (baton
->per_cu
);
24797 if (attr
->form_is_block ())
24799 /* Note that we're just copying the block's data pointer
24800 here, not the actual data. We're still pointing into the
24801 info_buffer for SYM's objfile; right now we never release
24802 that buffer, but when we do clean up properly this may
24804 struct dwarf_block
*block
= attr
->as_block ();
24805 baton
->size
= block
->size
;
24806 baton
->data
= block
->data
;
24810 dwarf2_invalid_attrib_class_complaint ("location description",
24811 sym
->natural_name ());
24815 SYMBOL_ACLASS_INDEX (sym
) = (is_block
24816 ? dwarf2_locexpr_block_index
24817 : dwarf2_locexpr_index
);
24818 SYMBOL_LOCATION_BATON (sym
) = baton
;
24824 const comp_unit_head
*
24825 dwarf2_per_cu_data::get_header () const
24827 if (!m_header_read_in
)
24829 const gdb_byte
*info_ptr
24830 = this->section
->buffer
+ to_underlying (this->sect_off
);
24832 memset (&m_header
, 0, sizeof (m_header
));
24834 read_comp_unit_head (&m_header
, info_ptr
, this->section
,
24835 rcuh_kind::COMPILE
);
24844 dwarf2_per_cu_data::addr_size () const
24846 return this->get_header ()->addr_size
;
24852 dwarf2_per_cu_data::offset_size () const
24854 return this->get_header ()->offset_size
;
24860 dwarf2_per_cu_data::ref_addr_size () const
24862 const comp_unit_head
*header
= this->get_header ();
24864 if (header
->version
== 2)
24865 return header
->addr_size
;
24867 return header
->offset_size
;
24873 dwarf2_cu::addr_type () const
24875 struct objfile
*objfile
= this->per_objfile
->objfile
;
24876 struct type
*void_type
= objfile_type (objfile
)->builtin_void
;
24877 struct type
*addr_type
= lookup_pointer_type (void_type
);
24878 int addr_size
= this->per_cu
->addr_size ();
24880 if (TYPE_LENGTH (addr_type
) == addr_size
)
24883 addr_type
= addr_sized_int_type (addr_type
->is_unsigned ());
24887 /* A helper function for dwarf2_find_containing_comp_unit that returns
24888 the index of the result, and that searches a vector. It will
24889 return a result even if the offset in question does not actually
24890 occur in any CU. This is separate so that it can be unit
24894 dwarf2_find_containing_comp_unit
24895 (sect_offset sect_off
,
24896 unsigned int offset_in_dwz
,
24897 const std::vector
<dwarf2_per_cu_data
*> &all_comp_units
)
24902 high
= all_comp_units
.size () - 1;
24905 struct dwarf2_per_cu_data
*mid_cu
;
24906 int mid
= low
+ (high
- low
) / 2;
24908 mid_cu
= all_comp_units
[mid
];
24909 if (mid_cu
->is_dwz
> offset_in_dwz
24910 || (mid_cu
->is_dwz
== offset_in_dwz
24911 && mid_cu
->sect_off
+ mid_cu
->length
> sect_off
))
24916 gdb_assert (low
== high
);
24920 /* Locate the .debug_info compilation unit from CU's objfile which contains
24921 the DIE at OFFSET. Raises an error on failure. */
24923 static struct dwarf2_per_cu_data
*
24924 dwarf2_find_containing_comp_unit (sect_offset sect_off
,
24925 unsigned int offset_in_dwz
,
24926 dwarf2_per_objfile
*per_objfile
)
24928 int low
= dwarf2_find_containing_comp_unit
24929 (sect_off
, offset_in_dwz
, per_objfile
->per_bfd
->all_comp_units
);
24930 dwarf2_per_cu_data
*this_cu
= per_objfile
->per_bfd
->all_comp_units
[low
];
24932 if (this_cu
->is_dwz
!= offset_in_dwz
|| this_cu
->sect_off
> sect_off
)
24934 if (low
== 0 || this_cu
->is_dwz
!= offset_in_dwz
)
24935 error (_("Dwarf Error: could not find partial DIE containing "
24936 "offset %s [in module %s]"),
24937 sect_offset_str (sect_off
),
24938 bfd_get_filename (per_objfile
->objfile
->obfd
));
24940 gdb_assert (per_objfile
->per_bfd
->all_comp_units
[low
-1]->sect_off
24942 return per_objfile
->per_bfd
->all_comp_units
[low
-1];
24946 if (low
== per_objfile
->per_bfd
->all_comp_units
.size () - 1
24947 && sect_off
>= this_cu
->sect_off
+ this_cu
->length
)
24948 error (_("invalid dwarf2 offset %s"), sect_offset_str (sect_off
));
24949 gdb_assert (sect_off
< this_cu
->sect_off
+ this_cu
->length
);
24956 namespace selftests
{
24957 namespace find_containing_comp_unit
{
24962 struct dwarf2_per_cu_data one
{};
24963 struct dwarf2_per_cu_data two
{};
24964 struct dwarf2_per_cu_data three
{};
24965 struct dwarf2_per_cu_data four
{};
24968 two
.sect_off
= sect_offset (one
.length
);
24973 four
.sect_off
= sect_offset (three
.length
);
24977 std::vector
<dwarf2_per_cu_data
*> units
;
24978 units
.push_back (&one
);
24979 units
.push_back (&two
);
24980 units
.push_back (&three
);
24981 units
.push_back (&four
);
24985 result
= dwarf2_find_containing_comp_unit (sect_offset (0), 0, units
);
24986 SELF_CHECK (units
[result
] == &one
);
24987 result
= dwarf2_find_containing_comp_unit (sect_offset (3), 0, units
);
24988 SELF_CHECK (units
[result
] == &one
);
24989 result
= dwarf2_find_containing_comp_unit (sect_offset (5), 0, units
);
24990 SELF_CHECK (units
[result
] == &two
);
24992 result
= dwarf2_find_containing_comp_unit (sect_offset (0), 1, units
);
24993 SELF_CHECK (units
[result
] == &three
);
24994 result
= dwarf2_find_containing_comp_unit (sect_offset (3), 1, units
);
24995 SELF_CHECK (units
[result
] == &three
);
24996 result
= dwarf2_find_containing_comp_unit (sect_offset (5), 1, units
);
24997 SELF_CHECK (units
[result
] == &four
);
25003 #endif /* GDB_SELF_TEST */
25005 /* Initialize dwarf2_cu to read PER_CU, in the context of PER_OBJFILE. */
25007 dwarf2_cu::dwarf2_cu (dwarf2_per_cu_data
*per_cu
,
25008 dwarf2_per_objfile
*per_objfile
)
25010 per_objfile (per_objfile
),
25012 has_loclist (false),
25013 checked_producer (false),
25014 producer_is_gxx_lt_4_6 (false),
25015 producer_is_gcc_lt_4_3 (false),
25016 producer_is_icc (false),
25017 producer_is_icc_lt_14 (false),
25018 producer_is_codewarrior (false),
25019 processing_has_namespace_info (false)
25023 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
25026 prepare_one_comp_unit (struct dwarf2_cu
*cu
, struct die_info
*comp_unit_die
,
25027 enum language pretend_language
)
25029 struct attribute
*attr
;
25031 /* Set the language we're debugging. */
25032 attr
= dwarf2_attr (comp_unit_die
, DW_AT_language
, cu
);
25033 if (attr
!= nullptr)
25034 set_cu_language (attr
->constant_value (0), cu
);
25037 cu
->language
= pretend_language
;
25038 cu
->language_defn
= language_def (cu
->language
);
25041 cu
->producer
= dwarf2_string_attr (comp_unit_die
, DW_AT_producer
, cu
);
25047 dwarf2_per_objfile::get_cu (dwarf2_per_cu_data
*per_cu
)
25049 auto it
= m_dwarf2_cus
.find (per_cu
);
25050 if (it
== m_dwarf2_cus
.end ())
25059 dwarf2_per_objfile::set_cu (dwarf2_per_cu_data
*per_cu
, dwarf2_cu
*cu
)
25061 gdb_assert (this->get_cu (per_cu
) == nullptr);
25063 m_dwarf2_cus
[per_cu
] = cu
;
25069 dwarf2_per_objfile::age_comp_units ()
25071 dwarf_read_debug_printf_v ("running");
25073 /* Start by clearing all marks. */
25074 for (auto pair
: m_dwarf2_cus
)
25075 pair
.second
->mark
= false;
25077 /* Traverse all CUs, mark them and their dependencies if used recently
25079 for (auto pair
: m_dwarf2_cus
)
25081 dwarf2_cu
*cu
= pair
.second
;
25084 if (cu
->last_used
<= dwarf_max_cache_age
)
25088 /* Delete all CUs still not marked. */
25089 for (auto it
= m_dwarf2_cus
.begin (); it
!= m_dwarf2_cus
.end ();)
25091 dwarf2_cu
*cu
= it
->second
;
25095 dwarf_read_debug_printf_v ("deleting old CU %s",
25096 sect_offset_str (cu
->per_cu
->sect_off
));
25098 it
= m_dwarf2_cus
.erase (it
);
25108 dwarf2_per_objfile::remove_cu (dwarf2_per_cu_data
*per_cu
)
25110 auto it
= m_dwarf2_cus
.find (per_cu
);
25111 if (it
== m_dwarf2_cus
.end ())
25116 m_dwarf2_cus
.erase (it
);
25119 dwarf2_per_objfile::~dwarf2_per_objfile ()
25124 /* A set of CU "per_cu" pointer, DIE offset, and GDB type pointer.
25125 We store these in a hash table separate from the DIEs, and preserve them
25126 when the DIEs are flushed out of cache.
25128 The CU "per_cu" pointer is needed because offset alone is not enough to
25129 uniquely identify the type. A file may have multiple .debug_types sections,
25130 or the type may come from a DWO file. Furthermore, while it's more logical
25131 to use per_cu->section+offset, with Fission the section with the data is in
25132 the DWO file but we don't know that section at the point we need it.
25133 We have to use something in dwarf2_per_cu_data (or the pointer to it)
25134 because we can enter the lookup routine, get_die_type_at_offset, from
25135 outside this file, and thus won't necessarily have PER_CU->cu.
25136 Fortunately, PER_CU is stable for the life of the objfile. */
25138 struct dwarf2_per_cu_offset_and_type
25140 const struct dwarf2_per_cu_data
*per_cu
;
25141 sect_offset sect_off
;
25145 /* Hash function for a dwarf2_per_cu_offset_and_type. */
25148 per_cu_offset_and_type_hash (const void *item
)
25150 const struct dwarf2_per_cu_offset_and_type
*ofs
25151 = (const struct dwarf2_per_cu_offset_and_type
*) item
;
25153 return (uintptr_t) ofs
->per_cu
+ to_underlying (ofs
->sect_off
);
25156 /* Equality function for a dwarf2_per_cu_offset_and_type. */
25159 per_cu_offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
25161 const struct dwarf2_per_cu_offset_and_type
*ofs_lhs
25162 = (const struct dwarf2_per_cu_offset_and_type
*) item_lhs
;
25163 const struct dwarf2_per_cu_offset_and_type
*ofs_rhs
25164 = (const struct dwarf2_per_cu_offset_and_type
*) item_rhs
;
25166 return (ofs_lhs
->per_cu
== ofs_rhs
->per_cu
25167 && ofs_lhs
->sect_off
== ofs_rhs
->sect_off
);
25170 /* Set the type associated with DIE to TYPE. Save it in CU's hash
25171 table if necessary. For convenience, return TYPE.
25173 The DIEs reading must have careful ordering to:
25174 * Not cause infinite loops trying to read in DIEs as a prerequisite for
25175 reading current DIE.
25176 * Not trying to dereference contents of still incompletely read in types
25177 while reading in other DIEs.
25178 * Enable referencing still incompletely read in types just by a pointer to
25179 the type without accessing its fields.
25181 Therefore caller should follow these rules:
25182 * Try to fetch any prerequisite types we may need to build this DIE type
25183 before building the type and calling set_die_type.
25184 * After building type call set_die_type for current DIE as soon as
25185 possible before fetching more types to complete the current type.
25186 * Make the type as complete as possible before fetching more types. */
25188 static struct type
*
25189 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
,
25190 bool skip_data_location
)
25192 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
25193 struct dwarf2_per_cu_offset_and_type
**slot
, ofs
;
25194 struct objfile
*objfile
= per_objfile
->objfile
;
25195 struct attribute
*attr
;
25196 struct dynamic_prop prop
;
25198 /* For Ada types, make sure that the gnat-specific data is always
25199 initialized (if not already set). There are a few types where
25200 we should not be doing so, because the type-specific area is
25201 already used to hold some other piece of info (eg: TYPE_CODE_FLT
25202 where the type-specific area is used to store the floatformat).
25203 But this is not a problem, because the gnat-specific information
25204 is actually not needed for these types. */
25205 if (need_gnat_info (cu
)
25206 && type
->code () != TYPE_CODE_FUNC
25207 && type
->code () != TYPE_CODE_FLT
25208 && type
->code () != TYPE_CODE_METHODPTR
25209 && type
->code () != TYPE_CODE_MEMBERPTR
25210 && type
->code () != TYPE_CODE_METHOD
25211 && type
->code () != TYPE_CODE_FIXED_POINT
25212 && !HAVE_GNAT_AUX_INFO (type
))
25213 INIT_GNAT_SPECIFIC (type
);
25215 /* Read DW_AT_allocated and set in type. */
25216 attr
= dwarf2_attr (die
, DW_AT_allocated
, cu
);
25219 struct type
*prop_type
= cu
->addr_sized_int_type (false);
25220 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
, prop_type
))
25221 type
->add_dyn_prop (DYN_PROP_ALLOCATED
, prop
);
25224 /* Read DW_AT_associated and set in type. */
25225 attr
= dwarf2_attr (die
, DW_AT_associated
, cu
);
25228 struct type
*prop_type
= cu
->addr_sized_int_type (false);
25229 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
, prop_type
))
25230 type
->add_dyn_prop (DYN_PROP_ASSOCIATED
, prop
);
25233 /* Read DW_AT_data_location and set in type. */
25234 if (!skip_data_location
)
25236 attr
= dwarf2_attr (die
, DW_AT_data_location
, cu
);
25237 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
, cu
->addr_type ()))
25238 type
->add_dyn_prop (DYN_PROP_DATA_LOCATION
, prop
);
25241 if (per_objfile
->die_type_hash
== NULL
)
25242 per_objfile
->die_type_hash
25243 = htab_up (htab_create_alloc (127,
25244 per_cu_offset_and_type_hash
,
25245 per_cu_offset_and_type_eq
,
25246 NULL
, xcalloc
, xfree
));
25248 ofs
.per_cu
= cu
->per_cu
;
25249 ofs
.sect_off
= die
->sect_off
;
25251 slot
= (struct dwarf2_per_cu_offset_and_type
**)
25252 htab_find_slot (per_objfile
->die_type_hash
.get (), &ofs
, INSERT
);
25254 complaint (_("A problem internal to GDB: DIE %s has type already set"),
25255 sect_offset_str (die
->sect_off
));
25256 *slot
= XOBNEW (&objfile
->objfile_obstack
,
25257 struct dwarf2_per_cu_offset_and_type
);
25262 /* Look up the type for the die at SECT_OFF in PER_CU in die_type_hash,
25263 or return NULL if the die does not have a saved type. */
25265 static struct type
*
25266 get_die_type_at_offset (sect_offset sect_off
,
25267 dwarf2_per_cu_data
*per_cu
,
25268 dwarf2_per_objfile
*per_objfile
)
25270 struct dwarf2_per_cu_offset_and_type
*slot
, ofs
;
25272 if (per_objfile
->die_type_hash
== NULL
)
25275 ofs
.per_cu
= per_cu
;
25276 ofs
.sect_off
= sect_off
;
25277 slot
= ((struct dwarf2_per_cu_offset_and_type
*)
25278 htab_find (per_objfile
->die_type_hash
.get (), &ofs
));
25285 /* Look up the type for DIE in CU in die_type_hash,
25286 or return NULL if DIE does not have a saved type. */
25288 static struct type
*
25289 get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
25291 return get_die_type_at_offset (die
->sect_off
, cu
->per_cu
, cu
->per_objfile
);
25294 /* Add a dependence relationship from CU to REF_PER_CU. */
25297 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
25298 struct dwarf2_per_cu_data
*ref_per_cu
)
25302 if (cu
->dependencies
== NULL
)
25304 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
25305 NULL
, &cu
->comp_unit_obstack
,
25306 hashtab_obstack_allocate
,
25307 dummy_obstack_deallocate
);
25309 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
25311 *slot
= ref_per_cu
;
25314 /* Subroutine of dwarf2_mark to pass to htab_traverse.
25315 Set the mark field in every compilation unit in the
25316 cache that we must keep because we are keeping CU.
25318 DATA is the dwarf2_per_objfile object in which to look up CUs. */
25321 dwarf2_mark_helper (void **slot
, void *data
)
25323 dwarf2_per_cu_data
*per_cu
= (dwarf2_per_cu_data
*) *slot
;
25324 dwarf2_per_objfile
*per_objfile
= (dwarf2_per_objfile
*) data
;
25325 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
25327 /* cu->dependencies references may not yet have been ever read if QUIT aborts
25328 reading of the chain. As such dependencies remain valid it is not much
25329 useful to track and undo them during QUIT cleanups. */
25338 if (cu
->dependencies
!= nullptr)
25339 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, per_objfile
);
25344 /* Set the mark field in CU and in every other compilation unit in the
25345 cache that we must keep because we are keeping CU. */
25348 dwarf2_mark (struct dwarf2_cu
*cu
)
25355 if (cu
->dependencies
!= nullptr)
25356 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, cu
->per_objfile
);
25359 /* Trivial hash function for partial_die_info: the hash value of a DIE
25360 is its offset in .debug_info for this objfile. */
25363 partial_die_hash (const void *item
)
25365 const struct partial_die_info
*part_die
25366 = (const struct partial_die_info
*) item
;
25368 return to_underlying (part_die
->sect_off
);
25371 /* Trivial comparison function for partial_die_info structures: two DIEs
25372 are equal if they have the same offset. */
25375 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
25377 const struct partial_die_info
*part_die_lhs
25378 = (const struct partial_die_info
*) item_lhs
;
25379 const struct partial_die_info
*part_die_rhs
25380 = (const struct partial_die_info
*) item_rhs
;
25382 return part_die_lhs
->sect_off
== part_die_rhs
->sect_off
;
25385 struct cmd_list_element
*set_dwarf_cmdlist
;
25386 struct cmd_list_element
*show_dwarf_cmdlist
;
25389 show_check_physname (struct ui_file
*file
, int from_tty
,
25390 struct cmd_list_element
*c
, const char *value
)
25392 fprintf_filtered (file
,
25393 _("Whether to check \"physname\" is %s.\n"),
25397 void _initialize_dwarf2_read ();
25399 _initialize_dwarf2_read ()
25401 add_basic_prefix_cmd ("dwarf", class_maintenance
, _("\
25402 Set DWARF specific variables.\n\
25403 Configure DWARF variables such as the cache size."),
25404 &set_dwarf_cmdlist
, "maintenance set dwarf ",
25405 0/*allow-unknown*/, &maintenance_set_cmdlist
);
25407 add_show_prefix_cmd ("dwarf", class_maintenance
, _("\
25408 Show DWARF specific variables.\n\
25409 Show DWARF variables such as the cache size."),
25410 &show_dwarf_cmdlist
, "maintenance show dwarf ",
25411 0/*allow-unknown*/, &maintenance_show_cmdlist
);
25413 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
25414 &dwarf_max_cache_age
, _("\
25415 Set the upper bound on the age of cached DWARF compilation units."), _("\
25416 Show the upper bound on the age of cached DWARF compilation units."), _("\
25417 A higher limit means that cached compilation units will be stored\n\
25418 in memory longer, and more total memory will be used. Zero disables\n\
25419 caching, which can slow down startup."),
25421 show_dwarf_max_cache_age
,
25422 &set_dwarf_cmdlist
,
25423 &show_dwarf_cmdlist
);
25425 add_setshow_zuinteger_cmd ("dwarf-read", no_class
, &dwarf_read_debug
, _("\
25426 Set debugging of the DWARF reader."), _("\
25427 Show debugging of the DWARF reader."), _("\
25428 When enabled (non-zero), debugging messages are printed during DWARF\n\
25429 reading and symtab expansion. A value of 1 (one) provides basic\n\
25430 information. A value greater than 1 provides more verbose information."),
25433 &setdebuglist
, &showdebuglist
);
25435 add_setshow_zuinteger_cmd ("dwarf-die", no_class
, &dwarf_die_debug
, _("\
25436 Set debugging of the DWARF DIE reader."), _("\
25437 Show debugging of the DWARF DIE reader."), _("\
25438 When enabled (non-zero), DIEs are dumped after they are read in.\n\
25439 The value is the maximum depth to print."),
25442 &setdebuglist
, &showdebuglist
);
25444 add_setshow_zuinteger_cmd ("dwarf-line", no_class
, &dwarf_line_debug
, _("\
25445 Set debugging of the dwarf line reader."), _("\
25446 Show debugging of the dwarf line reader."), _("\
25447 When enabled (non-zero), line number entries are dumped as they are read in.\n\
25448 A value of 1 (one) provides basic information.\n\
25449 A value greater than 1 provides more verbose information."),
25452 &setdebuglist
, &showdebuglist
);
25454 add_setshow_boolean_cmd ("check-physname", no_class
, &check_physname
, _("\
25455 Set cross-checking of \"physname\" code against demangler."), _("\
25456 Show cross-checking of \"physname\" code against demangler."), _("\
25457 When enabled, GDB's internal \"physname\" code is checked against\n\
25459 NULL
, show_check_physname
,
25460 &setdebuglist
, &showdebuglist
);
25462 add_setshow_boolean_cmd ("use-deprecated-index-sections",
25463 no_class
, &use_deprecated_index_sections
, _("\
25464 Set whether to use deprecated gdb_index sections."), _("\
25465 Show whether to use deprecated gdb_index sections."), _("\
25466 When enabled, deprecated .gdb_index sections are used anyway.\n\
25467 Normally they are ignored either because of a missing feature or\n\
25468 performance issue.\n\
25469 Warning: This option must be enabled before gdb reads the file."),
25472 &setlist
, &showlist
);
25474 dwarf2_locexpr_index
= register_symbol_computed_impl (LOC_COMPUTED
,
25475 &dwarf2_locexpr_funcs
);
25476 dwarf2_loclist_index
= register_symbol_computed_impl (LOC_COMPUTED
,
25477 &dwarf2_loclist_funcs
);
25479 dwarf2_locexpr_block_index
= register_symbol_block_impl (LOC_BLOCK
,
25480 &dwarf2_block_frame_base_locexpr_funcs
);
25481 dwarf2_loclist_block_index
= register_symbol_block_impl (LOC_BLOCK
,
25482 &dwarf2_block_frame_base_loclist_funcs
);
25485 selftests::register_test ("dw2_expand_symtabs_matching",
25486 selftests::dw2_expand_symtabs_matching::run_test
);
25487 selftests::register_test ("dwarf2_find_containing_comp_unit",
25488 selftests::find_containing_comp_unit::run_test
);