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/sect-names.h"
44 #include "dwarf2/stringify.h"
45 #include "dwarf2/public.h"
54 #include "gdb-demangle.h"
55 #include "filenames.h" /* for DOSish file names */
57 #include "complaints.h"
58 #include "dwarf2/expr.h"
59 #include "dwarf2/loc.h"
60 #include "cp-support.h"
66 #include "typeprint.h"
71 #include "gdbcore.h" /* for gnutarget */
72 #include "gdb/gdb-index.h"
77 #include "namespace.h"
78 #include "gdbsupport/function-view.h"
79 #include "gdbsupport/gdb_optional.h"
80 #include "gdbsupport/underlying.h"
81 #include "gdbsupport/hash_enum.h"
82 #include "filename-seen-cache.h"
86 #include <unordered_map>
87 #include "gdbsupport/selftest.h"
88 #include "rust-lang.h"
89 #include "gdbsupport/pathstuff.h"
90 #include "count-one-bits.h"
92 /* When == 1, print basic high level tracing messages.
93 When > 1, be more verbose.
94 This is in contrast to the low level DIE reading of dwarf_die_debug. */
95 static unsigned int dwarf_read_debug
= 0;
97 /* Print a "dwarf-read" debug statement if dwarf_read_debug is >= 1. */
99 #define dwarf_read_debug_printf(fmt, ...) \
100 debug_prefixed_printf_cond (dwarf_read_debug >= 1, "dwarf-read", fmt, \
103 /* Print a "dwarf-read" debug statement if dwarf_read_debug is >= 2. */
105 #define dwarf_read_debug_printf_v(fmt, ...) \
106 debug_prefixed_printf_cond (dwarf_read_debug >= 2, "dwarf-read", fmt, \
109 /* When non-zero, dump DIEs after they are read in. */
110 static unsigned int dwarf_die_debug
= 0;
112 /* When non-zero, dump line number entries as they are read in. */
113 unsigned int dwarf_line_debug
= 0;
115 /* When true, cross-check physname against demangler. */
116 static bool check_physname
= false;
118 /* When true, do not reject deprecated .gdb_index sections. */
119 static bool use_deprecated_index_sections
= false;
121 /* This is used to store the data that is always per objfile. */
122 static const objfile_key
<dwarf2_per_objfile
> dwarf2_objfile_data_key
;
124 /* These are used to store the dwarf2_per_bfd objects.
126 objfiles having the same BFD, which doesn't require relocations, are going to
127 share a dwarf2_per_bfd object, which is held in the _bfd_data_key version.
129 Other objfiles are not going to share a dwarf2_per_bfd with any other
130 objfiles, so they'll have their own version kept in the _objfile_data_key
132 static const struct bfd_key
<dwarf2_per_bfd
> dwarf2_per_bfd_bfd_data_key
;
133 static const struct objfile_key
<dwarf2_per_bfd
> dwarf2_per_bfd_objfile_data_key
;
135 /* The "aclass" indices for various kinds of computed DWARF symbols. */
137 static int dwarf2_locexpr_index
;
138 static int dwarf2_loclist_index
;
139 static int dwarf2_locexpr_block_index
;
140 static int dwarf2_loclist_block_index
;
142 /* Size of .debug_loclists section header for 32-bit DWARF format. */
143 #define LOCLIST_HEADER_SIZE32 12
145 /* Size of .debug_loclists section header for 64-bit DWARF format. */
146 #define LOCLIST_HEADER_SIZE64 20
148 /* Size of .debug_rnglists section header for 32-bit DWARF format. */
149 #define RNGLIST_HEADER_SIZE32 12
151 /* Size of .debug_rnglists section header for 64-bit DWARF format. */
152 #define RNGLIST_HEADER_SIZE64 20
154 /* An index into a (C++) symbol name component in a symbol name as
155 recorded in the mapped_index's symbol table. For each C++ symbol
156 in the symbol table, we record one entry for the start of each
157 component in the symbol in a table of name components, and then
158 sort the table, in order to be able to binary search symbol names,
159 ignoring leading namespaces, both completion and regular look up.
160 For example, for symbol "A::B::C", we'll have an entry that points
161 to "A::B::C", another that points to "B::C", and another for "C".
162 Note that function symbols in GDB index have no parameter
163 information, just the function/method names. You can convert a
164 name_component to a "const char *" using the
165 'mapped_index::symbol_name_at(offset_type)' method. */
167 struct name_component
169 /* Offset in the symbol name where the component starts. Stored as
170 a (32-bit) offset instead of a pointer to save memory and improve
171 locality on 64-bit architectures. */
172 offset_type name_offset
;
174 /* The symbol's index in the symbol and constant pool tables of a
179 /* Base class containing bits shared by both .gdb_index and
180 .debug_name indexes. */
182 struct mapped_index_base
184 mapped_index_base () = default;
185 DISABLE_COPY_AND_ASSIGN (mapped_index_base
);
187 /* The name_component table (a sorted vector). See name_component's
188 description above. */
189 std::vector
<name_component
> name_components
;
191 /* How NAME_COMPONENTS is sorted. */
192 enum case_sensitivity name_components_casing
;
194 /* Return the number of names in the symbol table. */
195 virtual size_t symbol_name_count () const = 0;
197 /* Get the name of the symbol at IDX in the symbol table. */
198 virtual const char *symbol_name_at
199 (offset_type idx
, dwarf2_per_objfile
*per_objfile
) const = 0;
201 /* Return whether the name at IDX in the symbol table should be
203 virtual bool symbol_name_slot_invalid (offset_type idx
) const
208 /* Build the symbol name component sorted vector, if we haven't
210 void build_name_components (dwarf2_per_objfile
*per_objfile
);
212 /* Returns the lower (inclusive) and upper (exclusive) bounds of the
213 possible matches for LN_NO_PARAMS in the name component
215 std::pair
<std::vector
<name_component
>::const_iterator
,
216 std::vector
<name_component
>::const_iterator
>
217 find_name_components_bounds (const lookup_name_info
&ln_no_params
,
219 dwarf2_per_objfile
*per_objfile
) const;
221 /* Prevent deleting/destroying via a base class pointer. */
223 ~mapped_index_base() = default;
226 /* A description of the mapped index. The file format is described in
227 a comment by the code that writes the index. */
228 struct mapped_index final
: public mapped_index_base
230 /* A slot/bucket in the symbol table hash. */
231 struct symbol_table_slot
233 const offset_type name
;
234 const offset_type vec
;
237 /* Index data format version. */
240 /* The address table data. */
241 gdb::array_view
<const gdb_byte
> address_table
;
243 /* The symbol table, implemented as a hash table. */
244 gdb::array_view
<symbol_table_slot
> symbol_table
;
246 /* A pointer to the constant pool. */
247 const char *constant_pool
= nullptr;
249 bool symbol_name_slot_invalid (offset_type idx
) const override
251 const auto &bucket
= this->symbol_table
[idx
];
252 return bucket
.name
== 0 && bucket
.vec
== 0;
255 /* Convenience method to get at the name of the symbol at IDX in the
257 const char *symbol_name_at
258 (offset_type idx
, dwarf2_per_objfile
*per_objfile
) const override
259 { return this->constant_pool
+ MAYBE_SWAP (this->symbol_table
[idx
].name
); }
261 size_t symbol_name_count () const override
262 { return this->symbol_table
.size (); }
265 /* A description of the mapped .debug_names.
266 Uninitialized map has CU_COUNT 0. */
267 struct mapped_debug_names final
: public mapped_index_base
269 bfd_endian dwarf5_byte_order
;
270 bool dwarf5_is_dwarf64
;
271 bool augmentation_is_gdb
;
273 uint32_t cu_count
= 0;
274 uint32_t tu_count
, bucket_count
, name_count
;
275 const gdb_byte
*cu_table_reordered
, *tu_table_reordered
;
276 const uint32_t *bucket_table_reordered
, *hash_table_reordered
;
277 const gdb_byte
*name_table_string_offs_reordered
;
278 const gdb_byte
*name_table_entry_offs_reordered
;
279 const gdb_byte
*entry_pool
;
286 /* Attribute name DW_IDX_*. */
289 /* Attribute form DW_FORM_*. */
292 /* Value if FORM is DW_FORM_implicit_const. */
293 LONGEST implicit_const
;
295 std::vector
<attr
> attr_vec
;
298 std::unordered_map
<ULONGEST
, index_val
> abbrev_map
;
300 const char *namei_to_name
301 (uint32_t namei
, dwarf2_per_objfile
*per_objfile
) const;
303 /* Implementation of the mapped_index_base virtual interface, for
304 the name_components cache. */
306 const char *symbol_name_at
307 (offset_type idx
, dwarf2_per_objfile
*per_objfile
) const override
308 { return namei_to_name (idx
, per_objfile
); }
310 size_t symbol_name_count () const override
311 { return this->name_count
; }
314 /* See dwarf2read.h. */
317 get_dwarf2_per_objfile (struct objfile
*objfile
)
319 return dwarf2_objfile_data_key
.get (objfile
);
322 /* Default names of the debugging sections. */
324 /* Note that if the debugging section has been compressed, it might
325 have a name like .zdebug_info. */
327 const struct dwarf2_debug_sections dwarf2_elf_names
=
329 { ".debug_info", ".zdebug_info" },
330 { ".debug_abbrev", ".zdebug_abbrev" },
331 { ".debug_line", ".zdebug_line" },
332 { ".debug_loc", ".zdebug_loc" },
333 { ".debug_loclists", ".zdebug_loclists" },
334 { ".debug_macinfo", ".zdebug_macinfo" },
335 { ".debug_macro", ".zdebug_macro" },
336 { ".debug_str", ".zdebug_str" },
337 { ".debug_str_offsets", ".zdebug_str_offsets" },
338 { ".debug_line_str", ".zdebug_line_str" },
339 { ".debug_ranges", ".zdebug_ranges" },
340 { ".debug_rnglists", ".zdebug_rnglists" },
341 { ".debug_types", ".zdebug_types" },
342 { ".debug_addr", ".zdebug_addr" },
343 { ".debug_frame", ".zdebug_frame" },
344 { ".eh_frame", NULL
},
345 { ".gdb_index", ".zgdb_index" },
346 { ".debug_names", ".zdebug_names" },
347 { ".debug_aranges", ".zdebug_aranges" },
351 /* List of DWO/DWP sections. */
353 static const struct dwop_section_names
355 struct dwarf2_section_names abbrev_dwo
;
356 struct dwarf2_section_names info_dwo
;
357 struct dwarf2_section_names line_dwo
;
358 struct dwarf2_section_names loc_dwo
;
359 struct dwarf2_section_names loclists_dwo
;
360 struct dwarf2_section_names macinfo_dwo
;
361 struct dwarf2_section_names macro_dwo
;
362 struct dwarf2_section_names rnglists_dwo
;
363 struct dwarf2_section_names str_dwo
;
364 struct dwarf2_section_names str_offsets_dwo
;
365 struct dwarf2_section_names types_dwo
;
366 struct dwarf2_section_names cu_index
;
367 struct dwarf2_section_names tu_index
;
371 { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo" },
372 { ".debug_info.dwo", ".zdebug_info.dwo" },
373 { ".debug_line.dwo", ".zdebug_line.dwo" },
374 { ".debug_loc.dwo", ".zdebug_loc.dwo" },
375 { ".debug_loclists.dwo", ".zdebug_loclists.dwo" },
376 { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo" },
377 { ".debug_macro.dwo", ".zdebug_macro.dwo" },
378 { ".debug_rnglists.dwo", ".zdebug_rnglists.dwo" },
379 { ".debug_str.dwo", ".zdebug_str.dwo" },
380 { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo" },
381 { ".debug_types.dwo", ".zdebug_types.dwo" },
382 { ".debug_cu_index", ".zdebug_cu_index" },
383 { ".debug_tu_index", ".zdebug_tu_index" },
386 /* local data types */
388 /* The location list and range list sections (.debug_loclists & .debug_rnglists)
389 begin with a header, which contains the following information. */
390 struct loclists_rnglists_header
392 /* A 4-byte or 12-byte length containing the length of the
393 set of entries for this compilation unit, not including the
394 length field itself. */
397 /* A 2-byte version identifier. */
400 /* A 1-byte unsigned integer containing the size in bytes of an address on
401 the target system. */
402 unsigned char addr_size
;
404 /* A 1-byte unsigned integer containing the size in bytes of a segment selector
405 on the target system. */
406 unsigned char segment_collector_size
;
408 /* A 4-byte count of the number of offsets that follow the header. */
409 unsigned int offset_entry_count
;
412 /* Type used for delaying computation of method physnames.
413 See comments for compute_delayed_physnames. */
414 struct delayed_method_info
416 /* The type to which the method is attached, i.e., its parent class. */
419 /* The index of the method in the type's function fieldlists. */
422 /* The index of the method in the fieldlist. */
425 /* The name of the DIE. */
428 /* The DIE associated with this method. */
429 struct die_info
*die
;
432 /* Internal state when decoding a particular compilation unit. */
435 explicit dwarf2_cu (dwarf2_per_cu_data
*per_cu
,
436 dwarf2_per_objfile
*per_objfile
);
438 DISABLE_COPY_AND_ASSIGN (dwarf2_cu
);
440 /* TU version of handle_DW_AT_stmt_list for read_type_unit_scope.
441 Create the set of symtabs used by this TU, or if this TU is sharing
442 symtabs with another TU and the symtabs have already been created
443 then restore those symtabs in the line header.
444 We don't need the pc/line-number mapping for type units. */
445 void setup_type_unit_groups (struct die_info
*die
);
447 /* Start a symtab for DWARF. NAME, COMP_DIR, LOW_PC are passed to the
448 buildsym_compunit constructor. */
449 struct compunit_symtab
*start_symtab (const char *name
,
450 const char *comp_dir
,
453 /* Reset the builder. */
454 void reset_builder () { m_builder
.reset (); }
456 /* Return a type that is a generic pointer type, the size of which
457 matches the address size given in the compilation unit header for
459 struct type
*addr_type () const;
461 /* Find an integer type the same size as the address size given in
462 the compilation unit header for this CU. UNSIGNED_P controls if
463 the integer is unsigned or not. */
464 struct type
*addr_sized_int_type (bool unsigned_p
) const;
466 /* The header of the compilation unit. */
467 struct comp_unit_head header
{};
469 /* Base address of this compilation unit. */
470 gdb::optional
<CORE_ADDR
> base_address
;
472 /* The language we are debugging. */
473 enum language language
= language_unknown
;
474 const struct language_defn
*language_defn
= nullptr;
476 const char *producer
= nullptr;
479 /* The symtab builder for this CU. This is only non-NULL when full
480 symbols are being read. */
481 std::unique_ptr
<buildsym_compunit
> m_builder
;
484 /* The generic symbol table building routines have separate lists for
485 file scope symbols and all all other scopes (local scopes). So
486 we need to select the right one to pass to add_symbol_to_list().
487 We do it by keeping a pointer to the correct list in list_in_scope.
489 FIXME: The original dwarf code just treated the file scope as the
490 first local scope, and all other local scopes as nested local
491 scopes, and worked fine. Check to see if we really need to
492 distinguish these in buildsym.c. */
493 struct pending
**list_in_scope
= nullptr;
495 /* Hash table holding all the loaded partial DIEs
496 with partial_die->offset.SECT_OFF as hash. */
497 htab_t partial_dies
= nullptr;
499 /* Storage for things with the same lifetime as this read-in compilation
500 unit, including partial DIEs. */
501 auto_obstack comp_unit_obstack
;
503 /* Backlink to our per_cu entry. */
504 struct dwarf2_per_cu_data
*per_cu
;
506 /* The dwarf2_per_objfile that owns this. */
507 dwarf2_per_objfile
*per_objfile
;
509 /* How many compilation units ago was this CU last referenced? */
512 /* A hash table of DIE cu_offset for following references with
513 die_info->offset.sect_off as hash. */
514 htab_t die_hash
= nullptr;
516 /* Full DIEs if read in. */
517 struct die_info
*dies
= nullptr;
519 /* A set of pointers to dwarf2_per_cu_data objects for compilation
520 units referenced by this one. Only set during full symbol processing;
521 partial symbol tables do not have dependencies. */
522 htab_t dependencies
= nullptr;
524 /* Header data from the line table, during full symbol processing. */
525 struct line_header
*line_header
= nullptr;
526 /* Non-NULL if LINE_HEADER is owned by this DWARF_CU. Otherwise,
527 it's owned by dwarf2_per_bfd::line_header_hash. If non-NULL,
528 this is the DW_TAG_compile_unit die for this CU. We'll hold on
529 to the line header as long as this DIE is being processed. See
530 process_die_scope. */
531 die_info
*line_header_die_owner
= nullptr;
533 /* A list of methods which need to have physnames computed
534 after all type information has been read. */
535 std::vector
<delayed_method_info
> method_list
;
537 /* To be copied to symtab->call_site_htab. */
538 htab_t call_site_htab
= nullptr;
540 /* Non-NULL if this CU came from a DWO file.
541 There is an invariant here that is important to remember:
542 Except for attributes copied from the top level DIE in the "main"
543 (or "stub") file in preparation for reading the DWO file
544 (e.g., DW_AT_addr_base), we KISS: there is only *one* CU.
545 Either there isn't a DWO file (in which case this is NULL and the point
546 is moot), or there is and either we're not going to read it (in which
547 case this is NULL) or there is and we are reading it (in which case this
549 struct dwo_unit
*dwo_unit
= nullptr;
551 /* The DW_AT_addr_base (DW_AT_GNU_addr_base) attribute if present.
552 Note this value comes from the Fission stub CU/TU's DIE. */
553 gdb::optional
<ULONGEST
> addr_base
;
555 /* The DW_AT_GNU_ranges_base attribute, if present.
557 This is only relevant in the context of pre-DWARF 5 split units. In this
558 context, there is a .debug_ranges section in the linked executable,
559 containing all the ranges data for all the compilation units. Each
560 skeleton/stub unit has (if needed) a DW_AT_GNU_ranges_base attribute that
561 indicates the base of its contribution to that section. The DW_AT_ranges
562 attributes in the split-unit are of the form DW_FORM_sec_offset and point
563 into the .debug_ranges section of the linked file. However, they are not
564 "true" DW_FORM_sec_offset, because they are relative to the base of their
565 compilation unit's contribution, rather than relative to the beginning of
566 the section. The DW_AT_GNU_ranges_base value must be added to it to make
567 it relative to the beginning of the section.
569 Note that the value is zero when we are not in a pre-DWARF 5 split-unit
570 case, so this value can be added without needing to know whether we are in
573 N.B. If a DW_AT_ranges attribute is found on the DW_TAG_compile_unit in the
574 skeleton/stub, it must not have the base added, as it already points to the
575 right place. And since the DW_TAG_compile_unit DIE in the split-unit can't
576 have a DW_AT_ranges attribute, we can use the
578 die->tag != DW_AT_compile_unit
580 to determine whether the base should be added or not. */
581 ULONGEST gnu_ranges_base
= 0;
583 /* The DW_AT_rnglists_base attribute, if present.
585 This is used when processing attributes of form DW_FORM_rnglistx in
586 non-split units. Attributes of this form found in a split unit don't
587 use it, as split-unit files have their own non-shared .debug_rnglists.dwo
589 ULONGEST rnglists_base
= 0;
591 /* The DW_AT_loclists_base attribute if present. */
592 ULONGEST loclist_base
= 0;
594 /* When reading debug info generated by older versions of rustc, we
595 have to rewrite some union types to be struct types with a
596 variant part. This rewriting must be done after the CU is fully
597 read in, because otherwise at the point of rewriting some struct
598 type might not have been fully processed. So, we keep a list of
599 all such types here and process them after expansion. */
600 std::vector
<struct type
*> rust_unions
;
602 /* The DW_AT_str_offsets_base attribute if present. For DWARF 4 version DWO
603 files, the value is implicitly zero. For DWARF 5 version DWO files, the
604 value is often implicit and is the size of the header of
605 .debug_str_offsets section (8 or 4, depending on the address size). */
606 gdb::optional
<ULONGEST
> str_offsets_base
;
608 /* Mark used when releasing cached dies. */
611 /* This CU references .debug_loc. See the symtab->locations_valid field.
612 This test is imperfect as there may exist optimized debug code not using
613 any location list and still facing inlining issues if handled as
614 unoptimized code. For a future better test see GCC PR other/32998. */
615 bool has_loclist
: 1;
617 /* These cache the results for producer_is_* fields. CHECKED_PRODUCER is true
618 if all the producer_is_* fields are valid. This information is cached
619 because profiling CU expansion showed excessive time spent in
620 producer_is_gxx_lt_4_6. */
621 bool checked_producer
: 1;
622 bool producer_is_gxx_lt_4_6
: 1;
623 bool producer_is_gcc_lt_4_3
: 1;
624 bool producer_is_icc
: 1;
625 bool producer_is_icc_lt_14
: 1;
626 bool producer_is_codewarrior
: 1;
628 /* When true, the file that we're processing is known to have
629 debugging info for C++ namespaces. GCC 3.3.x did not produce
630 this information, but later versions do. */
632 bool processing_has_namespace_info
: 1;
634 struct partial_die_info
*find_partial_die (sect_offset sect_off
);
636 /* If this CU was inherited by another CU (via specification,
637 abstract_origin, etc), this is the ancestor CU. */
640 /* Get the buildsym_compunit for this CU. */
641 buildsym_compunit
*get_builder ()
643 /* If this CU has a builder associated with it, use that. */
644 if (m_builder
!= nullptr)
645 return m_builder
.get ();
647 /* Otherwise, search ancestors for a valid builder. */
648 if (ancestor
!= nullptr)
649 return ancestor
->get_builder ();
655 /* A struct that can be used as a hash key for tables based on DW_AT_stmt_list.
656 This includes type_unit_group and quick_file_names. */
658 struct stmt_list_hash
660 /* The DWO unit this table is from or NULL if there is none. */
661 struct dwo_unit
*dwo_unit
;
663 /* Offset in .debug_line or .debug_line.dwo. */
664 sect_offset line_sect_off
;
667 /* Each element of dwarf2_per_bfd->type_unit_groups is a pointer to
668 an object of this type. This contains elements of type unit groups
669 that can be shared across objfiles. The non-shareable parts are in
670 type_unit_group_unshareable. */
672 struct type_unit_group
674 /* dwarf2read.c's main "handle" on a TU symtab.
675 To simplify things we create an artificial CU that "includes" all the
676 type units using this stmt_list so that the rest of the code still has
677 a "per_cu" handle on the symtab. */
678 struct dwarf2_per_cu_data per_cu
;
680 /* The TUs that share this DW_AT_stmt_list entry.
681 This is added to while parsing type units to build partial symtabs,
682 and is deleted afterwards and not used again. */
683 std::vector
<signatured_type
*> *tus
;
685 /* The data used to construct the hash key. */
686 struct stmt_list_hash hash
;
689 /* These sections are what may appear in a (real or virtual) DWO file. */
693 struct dwarf2_section_info abbrev
;
694 struct dwarf2_section_info line
;
695 struct dwarf2_section_info loc
;
696 struct dwarf2_section_info loclists
;
697 struct dwarf2_section_info macinfo
;
698 struct dwarf2_section_info macro
;
699 struct dwarf2_section_info rnglists
;
700 struct dwarf2_section_info str
;
701 struct dwarf2_section_info str_offsets
;
702 /* In the case of a virtual DWO file, these two are unused. */
703 struct dwarf2_section_info info
;
704 std::vector
<dwarf2_section_info
> types
;
707 /* CUs/TUs in DWP/DWO files. */
711 /* Backlink to the containing struct dwo_file. */
712 struct dwo_file
*dwo_file
;
714 /* The "id" that distinguishes this CU/TU.
715 .debug_info calls this "dwo_id", .debug_types calls this "signature".
716 Since signatures came first, we stick with it for consistency. */
719 /* The section this CU/TU lives in, in the DWO file. */
720 struct dwarf2_section_info
*section
;
722 /* Same as dwarf2_per_cu_data:{sect_off,length} but in the DWO section. */
723 sect_offset sect_off
;
726 /* For types, offset in the type's DIE of the type defined by this TU. */
727 cu_offset type_offset_in_tu
;
730 /* include/dwarf2.h defines the DWP section codes.
731 It defines a max value but it doesn't define a min value, which we
732 use for error checking, so provide one. */
734 enum dwp_v2_section_ids
739 /* Data for one DWO file.
741 This includes virtual DWO files (a virtual DWO file is a DWO file as it
742 appears in a DWP file). DWP files don't really have DWO files per se -
743 comdat folding of types "loses" the DWO file they came from, and from
744 a high level view DWP files appear to contain a mass of random types.
745 However, to maintain consistency with the non-DWP case we pretend DWP
746 files contain virtual DWO files, and we assign each TU with one virtual
747 DWO file (generally based on the line and abbrev section offsets -
748 a heuristic that seems to work in practice). */
752 dwo_file () = default;
753 DISABLE_COPY_AND_ASSIGN (dwo_file
);
755 /* The DW_AT_GNU_dwo_name or DW_AT_dwo_name attribute.
756 For virtual DWO files the name is constructed from the section offsets
757 of abbrev,line,loc,str_offsets so that we combine virtual DWO files
758 from related CU+TUs. */
759 const char *dwo_name
= nullptr;
761 /* The DW_AT_comp_dir attribute. */
762 const char *comp_dir
= nullptr;
764 /* The bfd, when the file is open. Otherwise this is NULL.
765 This is unused(NULL) for virtual DWO files where we use dwp_file.dbfd. */
766 gdb_bfd_ref_ptr dbfd
;
768 /* The sections that make up this DWO file.
769 Remember that for virtual DWO files in DWP V2 or DWP V5, these are virtual
770 sections (for lack of a better name). */
771 struct dwo_sections sections
{};
773 /* The CUs in the file.
774 Each element is a struct dwo_unit. Multiple CUs per DWO are supported as
775 an extension to handle LLVM's Link Time Optimization output (where
776 multiple source files may be compiled into a single object/dwo pair). */
779 /* Table of TUs in the file.
780 Each element is a struct dwo_unit. */
784 /* These sections are what may appear in a DWP file. */
788 /* These are used by all DWP versions (1, 2 and 5). */
789 struct dwarf2_section_info str
;
790 struct dwarf2_section_info cu_index
;
791 struct dwarf2_section_info tu_index
;
793 /* These are only used by DWP version 2 and version 5 files.
794 In DWP version 1 the .debug_info.dwo, .debug_types.dwo, and other
795 sections are referenced by section number, and are not recorded here.
796 In DWP version 2 or 5 there is at most one copy of all these sections,
797 each section being (effectively) comprised of the concatenation of all of
798 the individual sections that exist in the version 1 format.
799 To keep the code simple we treat each of these concatenated pieces as a
800 section itself (a virtual section?). */
801 struct dwarf2_section_info abbrev
;
802 struct dwarf2_section_info info
;
803 struct dwarf2_section_info line
;
804 struct dwarf2_section_info loc
;
805 struct dwarf2_section_info loclists
;
806 struct dwarf2_section_info macinfo
;
807 struct dwarf2_section_info macro
;
808 struct dwarf2_section_info rnglists
;
809 struct dwarf2_section_info str_offsets
;
810 struct dwarf2_section_info types
;
813 /* These sections are what may appear in a virtual DWO file in DWP version 1.
814 A virtual DWO file is a DWO file as it appears in a DWP file. */
816 struct virtual_v1_dwo_sections
818 struct dwarf2_section_info abbrev
;
819 struct dwarf2_section_info line
;
820 struct dwarf2_section_info loc
;
821 struct dwarf2_section_info macinfo
;
822 struct dwarf2_section_info macro
;
823 struct dwarf2_section_info str_offsets
;
824 /* Each DWP hash table entry records one CU or one TU.
825 That is recorded here, and copied to dwo_unit.section. */
826 struct dwarf2_section_info info_or_types
;
829 /* Similar to virtual_v1_dwo_sections, but for DWP version 2 or 5.
830 In version 2, the sections of the DWO files are concatenated together
831 and stored in one section of that name. Thus each ELF section contains
832 several "virtual" sections. */
834 struct virtual_v2_or_v5_dwo_sections
836 bfd_size_type abbrev_offset
;
837 bfd_size_type abbrev_size
;
839 bfd_size_type line_offset
;
840 bfd_size_type line_size
;
842 bfd_size_type loc_offset
;
843 bfd_size_type loc_size
;
845 bfd_size_type loclists_offset
;
846 bfd_size_type loclists_size
;
848 bfd_size_type macinfo_offset
;
849 bfd_size_type macinfo_size
;
851 bfd_size_type macro_offset
;
852 bfd_size_type macro_size
;
854 bfd_size_type rnglists_offset
;
855 bfd_size_type rnglists_size
;
857 bfd_size_type str_offsets_offset
;
858 bfd_size_type str_offsets_size
;
860 /* Each DWP hash table entry records one CU or one TU.
861 That is recorded here, and copied to dwo_unit.section. */
862 bfd_size_type info_or_types_offset
;
863 bfd_size_type info_or_types_size
;
866 /* Contents of DWP hash tables. */
868 struct dwp_hash_table
870 uint32_t version
, nr_columns
;
871 uint32_t nr_units
, nr_slots
;
872 const gdb_byte
*hash_table
, *unit_table
;
877 const gdb_byte
*indices
;
881 /* This is indexed by column number and gives the id of the section
883 #define MAX_NR_V2_DWO_SECTIONS \
884 (1 /* .debug_info or .debug_types */ \
885 + 1 /* .debug_abbrev */ \
886 + 1 /* .debug_line */ \
887 + 1 /* .debug_loc */ \
888 + 1 /* .debug_str_offsets */ \
889 + 1 /* .debug_macro or .debug_macinfo */)
890 int section_ids
[MAX_NR_V2_DWO_SECTIONS
];
891 const gdb_byte
*offsets
;
892 const gdb_byte
*sizes
;
896 /* This is indexed by column number and gives the id of the section
898 #define MAX_NR_V5_DWO_SECTIONS \
899 (1 /* .debug_info */ \
900 + 1 /* .debug_abbrev */ \
901 + 1 /* .debug_line */ \
902 + 1 /* .debug_loclists */ \
903 + 1 /* .debug_str_offsets */ \
904 + 1 /* .debug_macro */ \
905 + 1 /* .debug_rnglists */)
906 int section_ids
[MAX_NR_V5_DWO_SECTIONS
];
907 const gdb_byte
*offsets
;
908 const gdb_byte
*sizes
;
913 /* Data for one DWP file. */
917 dwp_file (const char *name_
, gdb_bfd_ref_ptr
&&abfd
)
919 dbfd (std::move (abfd
))
923 /* Name of the file. */
926 /* File format version. */
930 gdb_bfd_ref_ptr dbfd
;
932 /* Section info for this file. */
933 struct dwp_sections sections
{};
935 /* Table of CUs in the file. */
936 const struct dwp_hash_table
*cus
= nullptr;
938 /* Table of TUs in the file. */
939 const struct dwp_hash_table
*tus
= nullptr;
941 /* Tables of loaded CUs/TUs. Each entry is a struct dwo_unit *. */
945 /* Table to map ELF section numbers to their sections.
946 This is only needed for the DWP V1 file format. */
947 unsigned int num_sections
= 0;
948 asection
**elf_sections
= nullptr;
951 /* Struct used to pass misc. parameters to read_die_and_children, et
952 al. which are used for both .debug_info and .debug_types dies.
953 All parameters here are unchanging for the life of the call. This
954 struct exists to abstract away the constant parameters of die reading. */
956 struct die_reader_specs
958 /* The bfd of die_section. */
961 /* The CU of the DIE we are parsing. */
962 struct dwarf2_cu
*cu
;
964 /* Non-NULL if reading a DWO file (including one packaged into a DWP). */
965 struct dwo_file
*dwo_file
;
967 /* The section the die comes from.
968 This is either .debug_info or .debug_types, or the .dwo variants. */
969 struct dwarf2_section_info
*die_section
;
971 /* die_section->buffer. */
972 const gdb_byte
*buffer
;
974 /* The end of the buffer. */
975 const gdb_byte
*buffer_end
;
977 /* The abbreviation table to use when reading the DIEs. */
978 struct abbrev_table
*abbrev_table
;
981 /* A subclass of die_reader_specs that holds storage and has complex
982 constructor and destructor behavior. */
984 class cutu_reader
: public die_reader_specs
988 cutu_reader (dwarf2_per_cu_data
*this_cu
,
989 dwarf2_per_objfile
*per_objfile
,
990 struct abbrev_table
*abbrev_table
,
991 dwarf2_cu
*existing_cu
,
994 explicit cutu_reader (struct dwarf2_per_cu_data
*this_cu
,
995 dwarf2_per_objfile
*per_objfile
,
996 struct dwarf2_cu
*parent_cu
= nullptr,
997 struct dwo_file
*dwo_file
= nullptr);
999 DISABLE_COPY_AND_ASSIGN (cutu_reader
);
1001 const gdb_byte
*info_ptr
= nullptr;
1002 struct die_info
*comp_unit_die
= nullptr;
1003 bool dummy_p
= false;
1005 /* Release the new CU, putting it on the chain. This cannot be done
1010 void init_tu_and_read_dwo_dies (dwarf2_per_cu_data
*this_cu
,
1011 dwarf2_per_objfile
*per_objfile
,
1012 dwarf2_cu
*existing_cu
);
1014 struct dwarf2_per_cu_data
*m_this_cu
;
1015 std::unique_ptr
<dwarf2_cu
> m_new_cu
;
1017 /* The ordinary abbreviation table. */
1018 abbrev_table_up m_abbrev_table_holder
;
1020 /* The DWO abbreviation table. */
1021 abbrev_table_up m_dwo_abbrev_table
;
1024 /* When we construct a partial symbol table entry we only
1025 need this much information. */
1026 struct partial_die_info
: public allocate_on_obstack
1028 partial_die_info (sect_offset sect_off
, const struct abbrev_info
*abbrev
);
1030 /* Disable assign but still keep copy ctor, which is needed
1031 load_partial_dies. */
1032 partial_die_info
& operator=(const partial_die_info
& rhs
) = delete;
1034 /* Adjust the partial die before generating a symbol for it. This
1035 function may set the is_external flag or change the DIE's
1037 void fixup (struct dwarf2_cu
*cu
);
1039 /* Read a minimal amount of information into the minimal die
1041 const gdb_byte
*read (const struct die_reader_specs
*reader
,
1042 const struct abbrev_info
&abbrev
,
1043 const gdb_byte
*info_ptr
);
1045 /* Compute the name of this partial DIE. This memoizes the
1046 result, so it is safe to call multiple times. */
1047 const char *name (dwarf2_cu
*cu
);
1049 /* Offset of this DIE. */
1050 const sect_offset sect_off
;
1052 /* DWARF-2 tag for this DIE. */
1053 const ENUM_BITFIELD(dwarf_tag
) tag
: 16;
1055 /* Assorted flags describing the data found in this DIE. */
1056 const unsigned int has_children
: 1;
1058 unsigned int is_external
: 1;
1059 unsigned int is_declaration
: 1;
1060 unsigned int has_type
: 1;
1061 unsigned int has_specification
: 1;
1062 unsigned int has_pc_info
: 1;
1063 unsigned int may_be_inlined
: 1;
1065 /* This DIE has been marked DW_AT_main_subprogram. */
1066 unsigned int main_subprogram
: 1;
1068 /* Flag set if the SCOPE field of this structure has been
1070 unsigned int scope_set
: 1;
1072 /* Flag set if the DIE has a byte_size attribute. */
1073 unsigned int has_byte_size
: 1;
1075 /* Flag set if the DIE has a DW_AT_const_value attribute. */
1076 unsigned int has_const_value
: 1;
1078 /* Flag set if any of the DIE's children are template arguments. */
1079 unsigned int has_template_arguments
: 1;
1081 /* Flag set if fixup has been called on this die. */
1082 unsigned int fixup_called
: 1;
1084 /* Flag set if DW_TAG_imported_unit uses DW_FORM_GNU_ref_alt. */
1085 unsigned int is_dwz
: 1;
1087 /* Flag set if spec_offset uses DW_FORM_GNU_ref_alt. */
1088 unsigned int spec_is_dwz
: 1;
1090 unsigned int canonical_name
: 1;
1092 /* The name of this DIE. Normally the value of DW_AT_name, but
1093 sometimes a default name for unnamed DIEs. */
1094 const char *raw_name
= nullptr;
1096 /* The linkage name, if present. */
1097 const char *linkage_name
= nullptr;
1099 /* The scope to prepend to our children. This is generally
1100 allocated on the comp_unit_obstack, so will disappear
1101 when this compilation unit leaves the cache. */
1102 const char *scope
= nullptr;
1104 /* Some data associated with the partial DIE. The tag determines
1105 which field is live. */
1108 /* The location description associated with this DIE, if any. */
1109 struct dwarf_block
*locdesc
;
1110 /* The offset of an import, for DW_TAG_imported_unit. */
1111 sect_offset sect_off
;
1114 /* If HAS_PC_INFO, the PC range associated with this DIE. */
1115 CORE_ADDR lowpc
= 0;
1116 CORE_ADDR highpc
= 0;
1118 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
1119 DW_AT_sibling, if any. */
1120 /* NOTE: This member isn't strictly necessary, partial_die_info::read
1121 could return DW_AT_sibling values to its caller load_partial_dies. */
1122 const gdb_byte
*sibling
= nullptr;
1124 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
1125 DW_AT_specification (or DW_AT_abstract_origin or
1126 DW_AT_extension). */
1127 sect_offset spec_offset
{};
1129 /* Pointers to this DIE's parent, first child, and next sibling,
1131 struct partial_die_info
*die_parent
= nullptr;
1132 struct partial_die_info
*die_child
= nullptr;
1133 struct partial_die_info
*die_sibling
= nullptr;
1135 friend struct partial_die_info
*
1136 dwarf2_cu::find_partial_die (sect_offset sect_off
);
1139 /* Only need to do look up in dwarf2_cu::find_partial_die. */
1140 partial_die_info (sect_offset sect_off
)
1141 : partial_die_info (sect_off
, DW_TAG_padding
, 0)
1145 partial_die_info (sect_offset sect_off_
, enum dwarf_tag tag_
,
1147 : sect_off (sect_off_
), tag (tag_
), has_children (has_children_
)
1152 has_specification
= 0;
1155 main_subprogram
= 0;
1158 has_const_value
= 0;
1159 has_template_arguments
= 0;
1167 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
1168 but this would require a corresponding change in unpack_field_as_long
1170 static int bits_per_byte
= 8;
1172 struct variant_part_builder
;
1174 /* When reading a variant, we track a bit more information about the
1175 field, and store it in an object of this type. */
1177 struct variant_field
1179 int first_field
= -1;
1180 int last_field
= -1;
1182 /* A variant can contain other variant parts. */
1183 std::vector
<variant_part_builder
> variant_parts
;
1185 /* If we see a DW_TAG_variant, then this will be set if this is the
1187 bool default_branch
= false;
1188 /* If we see a DW_AT_discr_value, then this will be the discriminant
1190 ULONGEST discriminant_value
= 0;
1191 /* If we see a DW_AT_discr_list, then this is a pointer to the list
1193 struct dwarf_block
*discr_list_data
= nullptr;
1196 /* This represents a DW_TAG_variant_part. */
1198 struct variant_part_builder
1200 /* The offset of the discriminant field. */
1201 sect_offset discriminant_offset
{};
1203 /* Variants that are direct children of this variant part. */
1204 std::vector
<variant_field
> variants
;
1206 /* True if we're currently reading a variant. */
1207 bool processing_variant
= false;
1212 int accessibility
= 0;
1214 /* Variant parts need to find the discriminant, which is a DIE
1215 reference. We track the section offset of each field to make
1218 struct field field
{};
1223 const char *name
= nullptr;
1224 std::vector
<struct fn_field
> fnfields
;
1227 /* The routines that read and process dies for a C struct or C++ class
1228 pass lists of data member fields and lists of member function fields
1229 in an instance of a field_info structure, as defined below. */
1232 /* List of data member and baseclasses fields. */
1233 std::vector
<struct nextfield
> fields
;
1234 std::vector
<struct nextfield
> baseclasses
;
1236 /* Set if the accessibility of one of the fields is not public. */
1237 bool non_public_fields
= false;
1239 /* Member function fieldlist array, contains name of possibly overloaded
1240 member function, number of overloaded member functions and a pointer
1241 to the head of the member function field chain. */
1242 std::vector
<struct fnfieldlist
> fnfieldlists
;
1244 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
1245 a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
1246 std::vector
<struct decl_field
> typedef_field_list
;
1248 /* Nested types defined by this class and the number of elements in this
1250 std::vector
<struct decl_field
> nested_types_list
;
1252 /* If non-null, this is the variant part we are currently
1254 variant_part_builder
*current_variant_part
= nullptr;
1255 /* This holds all the top-level variant parts attached to the type
1257 std::vector
<variant_part_builder
> variant_parts
;
1259 /* Return the total number of fields (including baseclasses). */
1260 int nfields () const
1262 return fields
.size () + baseclasses
.size ();
1266 /* Loaded secondary compilation units are kept in memory until they
1267 have not been referenced for the processing of this many
1268 compilation units. Set this to zero to disable caching. Cache
1269 sizes of up to at least twenty will improve startup time for
1270 typical inter-CU-reference binaries, at an obvious memory cost. */
1271 static int dwarf_max_cache_age
= 5;
1273 show_dwarf_max_cache_age (struct ui_file
*file
, int from_tty
,
1274 struct cmd_list_element
*c
, const char *value
)
1276 fprintf_filtered (file
, _("The upper bound on the age of cached "
1277 "DWARF compilation units is %s.\n"),
1281 /* local function prototypes */
1283 static void dwarf2_find_base_address (struct die_info
*die
,
1284 struct dwarf2_cu
*cu
);
1286 static dwarf2_psymtab
*create_partial_symtab
1287 (dwarf2_per_cu_data
*per_cu
, dwarf2_per_objfile
*per_objfile
,
1290 static void build_type_psymtabs_reader (const struct die_reader_specs
*reader
,
1291 const gdb_byte
*info_ptr
,
1292 struct die_info
*type_unit_die
);
1294 static void dwarf2_build_psymtabs_hard (dwarf2_per_objfile
*per_objfile
);
1296 static void scan_partial_symbols (struct partial_die_info
*,
1297 CORE_ADDR
*, CORE_ADDR
*,
1298 int, struct dwarf2_cu
*);
1300 static void add_partial_symbol (struct partial_die_info
*,
1301 struct dwarf2_cu
*);
1303 static void add_partial_namespace (struct partial_die_info
*pdi
,
1304 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1305 int set_addrmap
, struct dwarf2_cu
*cu
);
1307 static void add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
1308 CORE_ADDR
*highpc
, int set_addrmap
,
1309 struct dwarf2_cu
*cu
);
1311 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
1312 struct dwarf2_cu
*cu
);
1314 static void add_partial_subprogram (struct partial_die_info
*pdi
,
1315 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1316 int need_pc
, struct dwarf2_cu
*cu
);
1318 static unsigned int peek_abbrev_code (bfd
*, const gdb_byte
*);
1320 static struct partial_die_info
*load_partial_dies
1321 (const struct die_reader_specs
*, const gdb_byte
*, int);
1323 /* A pair of partial_die_info and compilation unit. */
1324 struct cu_partial_die_info
1326 /* The compilation unit of the partial_die_info. */
1327 struct dwarf2_cu
*cu
;
1328 /* A partial_die_info. */
1329 struct partial_die_info
*pdi
;
1331 cu_partial_die_info (struct dwarf2_cu
*cu
, struct partial_die_info
*pdi
)
1337 cu_partial_die_info () = delete;
1340 static const struct cu_partial_die_info
find_partial_die (sect_offset
, int,
1341 struct dwarf2_cu
*);
1343 static const gdb_byte
*read_attribute (const struct die_reader_specs
*,
1345 const struct attr_abbrev
*,
1348 static void read_attribute_reprocess (const struct die_reader_specs
*reader
,
1349 struct attribute
*attr
, dwarf_tag tag
);
1351 static CORE_ADDR
read_addr_index (struct dwarf2_cu
*cu
, unsigned int addr_index
);
1353 static sect_offset
read_abbrev_offset (dwarf2_per_objfile
*per_objfile
,
1354 dwarf2_section_info
*, sect_offset
);
1356 static const char *read_indirect_string
1357 (dwarf2_per_objfile
*per_objfile
, bfd
*, const gdb_byte
*,
1358 const struct comp_unit_head
*, unsigned int *);
1360 static const char *read_indirect_string_at_offset
1361 (dwarf2_per_objfile
*per_objfile
, LONGEST str_offset
);
1363 static CORE_ADDR
read_addr_index_from_leb128 (struct dwarf2_cu
*,
1367 static const char *read_dwo_str_index (const struct die_reader_specs
*reader
,
1368 ULONGEST str_index
);
1370 static const char *read_stub_str_index (struct dwarf2_cu
*cu
,
1371 ULONGEST str_index
);
1373 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
1375 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
1376 struct dwarf2_cu
*);
1378 static const char *dwarf2_string_attr (struct die_info
*die
, unsigned int name
,
1379 struct dwarf2_cu
*cu
);
1381 static const char *dwarf2_dwo_name (struct die_info
*die
, struct dwarf2_cu
*cu
);
1383 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
1384 struct dwarf2_cu
*cu
);
1386 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
1388 static struct die_info
*die_specification (struct die_info
*die
,
1389 struct dwarf2_cu
**);
1391 static line_header_up
dwarf_decode_line_header (sect_offset sect_off
,
1392 struct dwarf2_cu
*cu
);
1394 static void dwarf_decode_lines (struct line_header
*, const char *,
1395 struct dwarf2_cu
*, dwarf2_psymtab
*,
1396 CORE_ADDR
, int decode_mapping
);
1398 static void dwarf2_start_subfile (struct dwarf2_cu
*, const char *,
1401 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
1402 struct dwarf2_cu
*, struct symbol
* = NULL
);
1404 static void dwarf2_const_value (const struct attribute
*, struct symbol
*,
1405 struct dwarf2_cu
*);
1407 static void dwarf2_const_value_attr (const struct attribute
*attr
,
1410 struct obstack
*obstack
,
1411 struct dwarf2_cu
*cu
, LONGEST
*value
,
1412 const gdb_byte
**bytes
,
1413 struct dwarf2_locexpr_baton
**baton
);
1415 static struct type
*read_subrange_index_type (struct die_info
*die
,
1416 struct dwarf2_cu
*cu
);
1418 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
1420 static int need_gnat_info (struct dwarf2_cu
*);
1422 static struct type
*die_descriptive_type (struct die_info
*,
1423 struct dwarf2_cu
*);
1425 static void set_descriptive_type (struct type
*, struct die_info
*,
1426 struct dwarf2_cu
*);
1428 static struct type
*die_containing_type (struct die_info
*,
1429 struct dwarf2_cu
*);
1431 static struct type
*lookup_die_type (struct die_info
*, const struct attribute
*,
1432 struct dwarf2_cu
*);
1434 static struct type
*read_type_die (struct die_info
*, struct dwarf2_cu
*);
1436 static struct type
*read_type_die_1 (struct die_info
*, struct dwarf2_cu
*);
1438 static const char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
1440 static char *typename_concat (struct obstack
*obs
, const char *prefix
,
1441 const char *suffix
, int physname
,
1442 struct dwarf2_cu
*cu
);
1444 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
1446 static void read_type_unit_scope (struct die_info
*, struct dwarf2_cu
*);
1448 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
1450 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
1452 static void read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
);
1454 static void read_variable (struct die_info
*die
, struct dwarf2_cu
*cu
);
1456 /* Return the .debug_loclists section to use for cu. */
1457 static struct dwarf2_section_info
*cu_debug_loc_section (struct dwarf2_cu
*cu
);
1459 /* Return the .debug_rnglists section to use for cu. */
1460 static struct dwarf2_section_info
*cu_debug_rnglists_section
1461 (struct dwarf2_cu
*cu
, dwarf_tag tag
);
1463 /* How dwarf2_get_pc_bounds constructed its *LOWPC and *HIGHPC return
1464 values. Keep the items ordered with increasing constraints compliance. */
1467 /* No attribute DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges was found. */
1468 PC_BOUNDS_NOT_PRESENT
,
1470 /* Some of the attributes DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges
1471 were present but they do not form a valid range of PC addresses. */
1474 /* Discontiguous range was found - that is DW_AT_ranges was found. */
1477 /* Contiguous range was found - DW_AT_low_pc and DW_AT_high_pc were found. */
1481 static enum pc_bounds_kind
dwarf2_get_pc_bounds (struct die_info
*,
1482 CORE_ADDR
*, CORE_ADDR
*,
1486 static void get_scope_pc_bounds (struct die_info
*,
1487 CORE_ADDR
*, CORE_ADDR
*,
1488 struct dwarf2_cu
*);
1490 static void dwarf2_record_block_ranges (struct die_info
*, struct block
*,
1491 CORE_ADDR
, struct dwarf2_cu
*);
1493 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
1494 struct dwarf2_cu
*);
1496 static void dwarf2_attach_fields_to_type (struct field_info
*,
1497 struct type
*, struct dwarf2_cu
*);
1499 static void dwarf2_add_member_fn (struct field_info
*,
1500 struct die_info
*, struct type
*,
1501 struct dwarf2_cu
*);
1503 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
1505 struct dwarf2_cu
*);
1507 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
1509 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
1511 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
1513 static void read_module (struct die_info
*die
, struct dwarf2_cu
*cu
);
1515 static struct using_direct
**using_directives (struct dwarf2_cu
*cu
);
1517 static void read_import_statement (struct die_info
*die
, struct dwarf2_cu
*);
1519 static int read_namespace_alias (struct die_info
*die
, struct dwarf2_cu
*cu
);
1521 static struct type
*read_module_type (struct die_info
*die
,
1522 struct dwarf2_cu
*cu
);
1524 static const char *namespace_name (struct die_info
*die
,
1525 int *is_anonymous
, struct dwarf2_cu
*);
1527 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
1529 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*,
1532 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
1533 struct dwarf2_cu
*);
1535 static struct die_info
*read_die_and_siblings_1
1536 (const struct die_reader_specs
*, const gdb_byte
*, const gdb_byte
**,
1539 static struct die_info
*read_die_and_siblings (const struct die_reader_specs
*,
1540 const gdb_byte
*info_ptr
,
1541 const gdb_byte
**new_info_ptr
,
1542 struct die_info
*parent
);
1544 static const gdb_byte
*read_full_die_1 (const struct die_reader_specs
*,
1545 struct die_info
**, const gdb_byte
*,
1548 static const gdb_byte
*read_full_die (const struct die_reader_specs
*,
1549 struct die_info
**, const gdb_byte
*);
1551 static void process_die (struct die_info
*, struct dwarf2_cu
*);
1553 static const char *dwarf2_canonicalize_name (const char *, struct dwarf2_cu
*,
1556 static const char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
1558 static const char *dwarf2_full_name (const char *name
,
1559 struct die_info
*die
,
1560 struct dwarf2_cu
*cu
);
1562 static const char *dwarf2_physname (const char *name
, struct die_info
*die
,
1563 struct dwarf2_cu
*cu
);
1565 static struct die_info
*dwarf2_extension (struct die_info
*die
,
1566 struct dwarf2_cu
**);
1568 static void dump_die_shallow (struct ui_file
*, int indent
, struct die_info
*);
1570 static void dump_die_for_error (struct die_info
*);
1572 static void dump_die_1 (struct ui_file
*, int level
, int max_level
,
1575 /*static*/ void dump_die (struct die_info
*, int max_level
);
1577 static void store_in_ref_table (struct die_info
*,
1578 struct dwarf2_cu
*);
1580 static struct die_info
*follow_die_ref_or_sig (struct die_info
*,
1581 const struct attribute
*,
1582 struct dwarf2_cu
**);
1584 static struct die_info
*follow_die_ref (struct die_info
*,
1585 const struct attribute
*,
1586 struct dwarf2_cu
**);
1588 static struct die_info
*follow_die_sig (struct die_info
*,
1589 const struct attribute
*,
1590 struct dwarf2_cu
**);
1592 static struct type
*get_signatured_type (struct die_info
*, ULONGEST
,
1593 struct dwarf2_cu
*);
1595 static struct type
*get_DW_AT_signature_type (struct die_info
*,
1596 const struct attribute
*,
1597 struct dwarf2_cu
*);
1599 static void load_full_type_unit (dwarf2_per_cu_data
*per_cu
,
1600 dwarf2_per_objfile
*per_objfile
);
1602 static void read_signatured_type (signatured_type
*sig_type
,
1603 dwarf2_per_objfile
*per_objfile
);
1605 static int attr_to_dynamic_prop (const struct attribute
*attr
,
1606 struct die_info
*die
, struct dwarf2_cu
*cu
,
1607 struct dynamic_prop
*prop
, struct type
*type
);
1609 /* memory allocation interface */
1611 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1613 static struct die_info
*dwarf_alloc_die (struct dwarf2_cu
*, int);
1615 static void dwarf_decode_macros (struct dwarf2_cu
*, unsigned int, int);
1617 static void fill_in_loclist_baton (struct dwarf2_cu
*cu
,
1618 struct dwarf2_loclist_baton
*baton
,
1619 const struct attribute
*attr
);
1621 static void dwarf2_symbol_mark_computed (const struct attribute
*attr
,
1623 struct dwarf2_cu
*cu
,
1626 static const gdb_byte
*skip_one_die (const struct die_reader_specs
*reader
,
1627 const gdb_byte
*info_ptr
,
1628 const struct abbrev_info
*abbrev
);
1630 static hashval_t
partial_die_hash (const void *item
);
1632 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1634 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1635 (sect_offset sect_off
, unsigned int offset_in_dwz
,
1636 dwarf2_per_objfile
*per_objfile
);
1638 static void prepare_one_comp_unit (struct dwarf2_cu
*cu
,
1639 struct die_info
*comp_unit_die
,
1640 enum language pretend_language
);
1642 static struct type
*set_die_type (struct die_info
*, struct type
*,
1643 struct dwarf2_cu
*, bool = false);
1645 static void create_all_comp_units (dwarf2_per_objfile
*per_objfile
);
1647 static int create_all_type_units (dwarf2_per_objfile
*per_objfile
);
1649 static void load_full_comp_unit (dwarf2_per_cu_data
*per_cu
,
1650 dwarf2_per_objfile
*per_objfile
,
1651 dwarf2_cu
*existing_cu
,
1653 enum language pretend_language
);
1655 static void process_full_comp_unit (dwarf2_cu
*cu
,
1656 enum language pretend_language
);
1658 static void process_full_type_unit (dwarf2_cu
*cu
,
1659 enum language pretend_language
);
1661 static void dwarf2_add_dependence (struct dwarf2_cu
*,
1662 struct dwarf2_per_cu_data
*);
1664 static void dwarf2_mark (struct dwarf2_cu
*);
1666 static struct type
*get_die_type_at_offset (sect_offset
,
1667 dwarf2_per_cu_data
*per_cu
,
1668 dwarf2_per_objfile
*per_objfile
);
1670 static struct type
*get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
1672 static void queue_comp_unit (dwarf2_per_cu_data
*per_cu
,
1673 dwarf2_per_objfile
*per_objfile
,
1674 enum language pretend_language
);
1676 static void process_queue (dwarf2_per_objfile
*per_objfile
);
1678 /* Class, the destructor of which frees all allocated queue entries. This
1679 will only have work to do if an error was thrown while processing the
1680 dwarf. If no error was thrown then the queue entries should have all
1681 been processed, and freed, as we went along. */
1683 class dwarf2_queue_guard
1686 explicit dwarf2_queue_guard (dwarf2_per_objfile
*per_objfile
)
1687 : m_per_objfile (per_objfile
)
1689 gdb_assert (!m_per_objfile
->per_bfd
->queue
.has_value ());
1691 m_per_objfile
->per_bfd
->queue
.emplace ();
1694 /* Free any entries remaining on the queue. There should only be
1695 entries left if we hit an error while processing the dwarf. */
1696 ~dwarf2_queue_guard ()
1698 gdb_assert (m_per_objfile
->per_bfd
->queue
.has_value ());
1700 m_per_objfile
->per_bfd
->queue
.reset ();
1703 DISABLE_COPY_AND_ASSIGN (dwarf2_queue_guard
);
1706 dwarf2_per_objfile
*m_per_objfile
;
1709 dwarf2_queue_item::~dwarf2_queue_item ()
1711 /* Anything still marked queued is likely to be in an
1712 inconsistent state, so discard it. */
1715 per_objfile
->remove_cu (per_cu
);
1720 /* The return type of find_file_and_directory. Note, the enclosed
1721 string pointers are only valid while this object is valid. */
1723 struct file_and_directory
1725 /* The filename. This is never NULL. */
1728 /* The compilation directory. NULL if not known. If we needed to
1729 compute a new string, this points to COMP_DIR_STORAGE, otherwise,
1730 points directly to the DW_AT_comp_dir string attribute owned by
1731 the obstack that owns the DIE. */
1732 const char *comp_dir
;
1734 /* If we needed to build a new string for comp_dir, this is what
1735 owns the storage. */
1736 std::string comp_dir_storage
;
1739 static file_and_directory
find_file_and_directory (struct die_info
*die
,
1740 struct dwarf2_cu
*cu
);
1742 static htab_up
allocate_signatured_type_table ();
1744 static htab_up
allocate_dwo_unit_table ();
1746 static struct dwo_unit
*lookup_dwo_unit_in_dwp
1747 (dwarf2_per_objfile
*per_objfile
, struct dwp_file
*dwp_file
,
1748 const char *comp_dir
, ULONGEST signature
, int is_debug_types
);
1750 static struct dwp_file
*get_dwp_file (dwarf2_per_objfile
*per_objfile
);
1752 static struct dwo_unit
*lookup_dwo_comp_unit
1753 (dwarf2_cu
*cu
, const char *dwo_name
, const char *comp_dir
,
1754 ULONGEST signature
);
1756 static struct dwo_unit
*lookup_dwo_type_unit
1757 (dwarf2_cu
*cu
, const char *dwo_name
, const char *comp_dir
);
1759 static void queue_and_load_all_dwo_tus (dwarf2_cu
*cu
);
1761 /* A unique pointer to a dwo_file. */
1763 typedef std::unique_ptr
<struct dwo_file
> dwo_file_up
;
1765 static void process_cu_includes (dwarf2_per_objfile
*per_objfile
);
1767 static void check_producer (struct dwarf2_cu
*cu
);
1769 static void free_line_header_voidp (void *arg
);
1771 /* Various complaints about symbol reading that don't abort the process. */
1774 dwarf2_debug_line_missing_file_complaint (void)
1776 complaint (_(".debug_line section has line data without a file"));
1780 dwarf2_debug_line_missing_end_sequence_complaint (void)
1782 complaint (_(".debug_line section has line "
1783 "program sequence without an end"));
1787 dwarf2_complex_location_expr_complaint (void)
1789 complaint (_("location expression too complex"));
1793 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
1796 complaint (_("const value length mismatch for '%s', got %d, expected %d"),
1801 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
1803 complaint (_("invalid attribute class or form for '%s' in '%s'"),
1807 /* Hash function for line_header_hash. */
1810 line_header_hash (const struct line_header
*ofs
)
1812 return to_underlying (ofs
->sect_off
) ^ ofs
->offset_in_dwz
;
1815 /* Hash function for htab_create_alloc_ex for line_header_hash. */
1818 line_header_hash_voidp (const void *item
)
1820 const struct line_header
*ofs
= (const struct line_header
*) item
;
1822 return line_header_hash (ofs
);
1825 /* Equality function for line_header_hash. */
1828 line_header_eq_voidp (const void *item_lhs
, const void *item_rhs
)
1830 const struct line_header
*ofs_lhs
= (const struct line_header
*) item_lhs
;
1831 const struct line_header
*ofs_rhs
= (const struct line_header
*) item_rhs
;
1833 return (ofs_lhs
->sect_off
== ofs_rhs
->sect_off
1834 && ofs_lhs
->offset_in_dwz
== ofs_rhs
->offset_in_dwz
);
1839 /* See declaration. */
1841 dwarf2_per_bfd::dwarf2_per_bfd (bfd
*obfd
, const dwarf2_debug_sections
*names
,
1844 can_copy (can_copy_
)
1847 names
= &dwarf2_elf_names
;
1849 for (asection
*sec
= obfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
1850 locate_sections (obfd
, sec
, *names
);
1853 dwarf2_per_bfd::~dwarf2_per_bfd ()
1855 for (dwarf2_per_cu_data
*per_cu
: all_comp_units
)
1856 per_cu
->imported_symtabs_free ();
1858 for (signatured_type
*sig_type
: all_type_units
)
1859 sig_type
->per_cu
.imported_symtabs_free ();
1861 /* Everything else should be on this->obstack. */
1867 dwarf2_per_objfile::remove_all_cus ()
1869 gdb_assert (!this->per_bfd
->queue
.has_value ());
1871 for (auto pair
: m_dwarf2_cus
)
1874 m_dwarf2_cus
.clear ();
1877 /* A helper class that calls free_cached_comp_units on
1880 class free_cached_comp_units
1884 explicit free_cached_comp_units (dwarf2_per_objfile
*per_objfile
)
1885 : m_per_objfile (per_objfile
)
1889 ~free_cached_comp_units ()
1891 m_per_objfile
->remove_all_cus ();
1894 DISABLE_COPY_AND_ASSIGN (free_cached_comp_units
);
1898 dwarf2_per_objfile
*m_per_objfile
;
1904 dwarf2_per_objfile::symtab_set_p (const dwarf2_per_cu_data
*per_cu
) const
1906 gdb_assert (per_cu
->index
< this->m_symtabs
.size ());
1908 return this->m_symtabs
[per_cu
->index
] != nullptr;
1914 dwarf2_per_objfile::get_symtab (const dwarf2_per_cu_data
*per_cu
) const
1916 gdb_assert (per_cu
->index
< this->m_symtabs
.size ());
1918 return this->m_symtabs
[per_cu
->index
];
1924 dwarf2_per_objfile::set_symtab (const dwarf2_per_cu_data
*per_cu
,
1925 compunit_symtab
*symtab
)
1927 gdb_assert (per_cu
->index
< this->m_symtabs
.size ());
1928 gdb_assert (this->m_symtabs
[per_cu
->index
] == nullptr);
1930 this->m_symtabs
[per_cu
->index
] = symtab
;
1933 /* Try to locate the sections we need for DWARF 2 debugging
1934 information and return true if we have enough to do something.
1935 NAMES points to the dwarf2 section names, or is NULL if the standard
1936 ELF names are used. CAN_COPY is true for formats where symbol
1937 interposition is possible and so symbol values must follow copy
1938 relocation rules. */
1941 dwarf2_has_info (struct objfile
*objfile
,
1942 const struct dwarf2_debug_sections
*names
,
1945 if (objfile
->flags
& OBJF_READNEVER
)
1948 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
1950 if (per_objfile
== NULL
)
1952 dwarf2_per_bfd
*per_bfd
;
1954 /* We can share a "dwarf2_per_bfd" with other objfiles if the
1955 BFD doesn't require relocations.
1957 We don't share with objfiles for which -readnow was requested,
1958 because it would complicate things when loading the same BFD with
1959 -readnow and then without -readnow. */
1960 if (!gdb_bfd_requires_relocations (objfile
->obfd
)
1961 && (objfile
->flags
& OBJF_READNOW
) == 0)
1963 /* See if one has been created for this BFD yet. */
1964 per_bfd
= dwarf2_per_bfd_bfd_data_key
.get (objfile
->obfd
);
1966 if (per_bfd
== nullptr)
1968 /* No, create it now. */
1969 per_bfd
= new dwarf2_per_bfd (objfile
->obfd
, names
, can_copy
);
1970 dwarf2_per_bfd_bfd_data_key
.set (objfile
->obfd
, per_bfd
);
1975 /* No sharing possible, create one specifically for this objfile. */
1976 per_bfd
= new dwarf2_per_bfd (objfile
->obfd
, names
, can_copy
);
1977 dwarf2_per_bfd_objfile_data_key
.set (objfile
, per_bfd
);
1980 per_objfile
= dwarf2_objfile_data_key
.emplace (objfile
, objfile
, per_bfd
);
1983 return (!per_objfile
->per_bfd
->info
.is_virtual
1984 && per_objfile
->per_bfd
->info
.s
.section
!= NULL
1985 && !per_objfile
->per_bfd
->abbrev
.is_virtual
1986 && per_objfile
->per_bfd
->abbrev
.s
.section
!= NULL
);
1989 /* See declaration. */
1992 dwarf2_per_bfd::locate_sections (bfd
*abfd
, asection
*sectp
,
1993 const dwarf2_debug_sections
&names
)
1995 flagword aflag
= bfd_section_flags (sectp
);
1997 if ((aflag
& SEC_HAS_CONTENTS
) == 0)
2000 else if (elf_section_data (sectp
)->this_hdr
.sh_size
2001 > bfd_get_file_size (abfd
))
2003 bfd_size_type size
= elf_section_data (sectp
)->this_hdr
.sh_size
;
2004 warning (_("Discarding section %s which has a section size (%s"
2005 ") larger than the file size [in module %s]"),
2006 bfd_section_name (sectp
), phex_nz (size
, sizeof (size
)),
2007 bfd_get_filename (abfd
));
2009 else if (names
.info
.matches (sectp
->name
))
2011 this->info
.s
.section
= sectp
;
2012 this->info
.size
= bfd_section_size (sectp
);
2014 else if (names
.abbrev
.matches (sectp
->name
))
2016 this->abbrev
.s
.section
= sectp
;
2017 this->abbrev
.size
= bfd_section_size (sectp
);
2019 else if (names
.line
.matches (sectp
->name
))
2021 this->line
.s
.section
= sectp
;
2022 this->line
.size
= bfd_section_size (sectp
);
2024 else if (names
.loc
.matches (sectp
->name
))
2026 this->loc
.s
.section
= sectp
;
2027 this->loc
.size
= bfd_section_size (sectp
);
2029 else if (names
.loclists
.matches (sectp
->name
))
2031 this->loclists
.s
.section
= sectp
;
2032 this->loclists
.size
= bfd_section_size (sectp
);
2034 else if (names
.macinfo
.matches (sectp
->name
))
2036 this->macinfo
.s
.section
= sectp
;
2037 this->macinfo
.size
= bfd_section_size (sectp
);
2039 else if (names
.macro
.matches (sectp
->name
))
2041 this->macro
.s
.section
= sectp
;
2042 this->macro
.size
= bfd_section_size (sectp
);
2044 else if (names
.str
.matches (sectp
->name
))
2046 this->str
.s
.section
= sectp
;
2047 this->str
.size
= bfd_section_size (sectp
);
2049 else if (names
.str_offsets
.matches (sectp
->name
))
2051 this->str_offsets
.s
.section
= sectp
;
2052 this->str_offsets
.size
= bfd_section_size (sectp
);
2054 else if (names
.line_str
.matches (sectp
->name
))
2056 this->line_str
.s
.section
= sectp
;
2057 this->line_str
.size
= bfd_section_size (sectp
);
2059 else if (names
.addr
.matches (sectp
->name
))
2061 this->addr
.s
.section
= sectp
;
2062 this->addr
.size
= bfd_section_size (sectp
);
2064 else if (names
.frame
.matches (sectp
->name
))
2066 this->frame
.s
.section
= sectp
;
2067 this->frame
.size
= bfd_section_size (sectp
);
2069 else if (names
.eh_frame
.matches (sectp
->name
))
2071 this->eh_frame
.s
.section
= sectp
;
2072 this->eh_frame
.size
= bfd_section_size (sectp
);
2074 else if (names
.ranges
.matches (sectp
->name
))
2076 this->ranges
.s
.section
= sectp
;
2077 this->ranges
.size
= bfd_section_size (sectp
);
2079 else if (names
.rnglists
.matches (sectp
->name
))
2081 this->rnglists
.s
.section
= sectp
;
2082 this->rnglists
.size
= bfd_section_size (sectp
);
2084 else if (names
.types
.matches (sectp
->name
))
2086 struct dwarf2_section_info type_section
;
2088 memset (&type_section
, 0, sizeof (type_section
));
2089 type_section
.s
.section
= sectp
;
2090 type_section
.size
= bfd_section_size (sectp
);
2092 this->types
.push_back (type_section
);
2094 else if (names
.gdb_index
.matches (sectp
->name
))
2096 this->gdb_index
.s
.section
= sectp
;
2097 this->gdb_index
.size
= bfd_section_size (sectp
);
2099 else if (names
.debug_names
.matches (sectp
->name
))
2101 this->debug_names
.s
.section
= sectp
;
2102 this->debug_names
.size
= bfd_section_size (sectp
);
2104 else if (names
.debug_aranges
.matches (sectp
->name
))
2106 this->debug_aranges
.s
.section
= sectp
;
2107 this->debug_aranges
.size
= bfd_section_size (sectp
);
2110 if ((bfd_section_flags (sectp
) & (SEC_LOAD
| SEC_ALLOC
))
2111 && bfd_section_vma (sectp
) == 0)
2112 this->has_section_at_zero
= true;
2115 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
2119 dwarf2_get_section_info (struct objfile
*objfile
,
2120 enum dwarf2_section_enum sect
,
2121 asection
**sectp
, const gdb_byte
**bufp
,
2122 bfd_size_type
*sizep
)
2124 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
2125 struct dwarf2_section_info
*info
;
2127 /* We may see an objfile without any DWARF, in which case we just
2129 if (per_objfile
== NULL
)
2138 case DWARF2_DEBUG_FRAME
:
2139 info
= &per_objfile
->per_bfd
->frame
;
2141 case DWARF2_EH_FRAME
:
2142 info
= &per_objfile
->per_bfd
->eh_frame
;
2145 gdb_assert_not_reached ("unexpected section");
2148 info
->read (objfile
);
2150 *sectp
= info
->get_bfd_section ();
2151 *bufp
= info
->buffer
;
2152 *sizep
= info
->size
;
2156 /* DWARF quick_symbol_functions support. */
2158 /* TUs can share .debug_line entries, and there can be a lot more TUs than
2159 unique line tables, so we maintain a separate table of all .debug_line
2160 derived entries to support the sharing.
2161 All the quick functions need is the list of file names. We discard the
2162 line_header when we're done and don't need to record it here. */
2163 struct quick_file_names
2165 /* The data used to construct the hash key. */
2166 struct stmt_list_hash hash
;
2168 /* The number of entries in file_names, real_names. */
2169 unsigned int num_file_names
;
2171 /* The file names from the line table, after being run through
2173 const char **file_names
;
2175 /* The file names from the line table after being run through
2176 gdb_realpath. These are computed lazily. */
2177 const char **real_names
;
2180 /* When using the index (and thus not using psymtabs), each CU has an
2181 object of this type. This is used to hold information needed by
2182 the various "quick" methods. */
2183 struct dwarf2_per_cu_quick_data
2185 /* The file table. This can be NULL if there was no file table
2186 or it's currently not read in.
2187 NOTE: This points into dwarf2_per_objfile->per_bfd->quick_file_names_table. */
2188 struct quick_file_names
*file_names
;
2190 /* A temporary mark bit used when iterating over all CUs in
2191 expand_symtabs_matching. */
2192 unsigned int mark
: 1;
2194 /* True if we've tried to read the file table and found there isn't one.
2195 There will be no point in trying to read it again next time. */
2196 unsigned int no_file_data
: 1;
2199 /* A subclass of psymbol_functions that arranges to read the DWARF
2200 partial symbols when needed. */
2201 struct lazy_dwarf_reader
: public psymbol_functions
2203 using psymbol_functions::psymbol_functions
;
2205 bool can_lazily_read_symbols () override
2210 void read_partial_symbols (struct objfile
*objfile
) override
2212 if (dwarf2_has_info (objfile
, nullptr))
2213 dwarf2_build_psymtabs (objfile
, this);
2217 static quick_symbol_functions_up
2218 make_lazy_dwarf_reader ()
2220 return quick_symbol_functions_up (new lazy_dwarf_reader
);
2223 struct dwarf2_base_index_functions
: public quick_symbol_functions
2225 bool has_symbols (struct objfile
*objfile
) override
;
2227 struct symtab
*find_last_source_symtab (struct objfile
*objfile
) override
;
2229 void forget_cached_source_info (struct objfile
*objfile
) override
;
2231 enum language
lookup_global_symbol_language (struct objfile
*objfile
,
2234 bool *symbol_found_p
) override
2236 *symbol_found_p
= false;
2237 return language_unknown
;
2240 void print_stats (struct objfile
*objfile
, bool print_bcache
) override
;
2242 void expand_all_symtabs (struct objfile
*objfile
) override
;
2244 void expand_symtabs_with_fullname (struct objfile
*objfile
,
2245 const char *fullname
) override
;
2247 struct compunit_symtab
*find_pc_sect_compunit_symtab
2248 (struct objfile
*objfile
, struct bound_minimal_symbol msymbol
,
2249 CORE_ADDR pc
, struct obj_section
*section
, int warn_if_readin
) override
;
2251 struct compunit_symtab
*find_compunit_symtab_by_address
2252 (struct objfile
*objfile
, CORE_ADDR address
) override
2257 void map_symbol_filenames (struct objfile
*objfile
,
2258 gdb::function_view
<symbol_filename_ftype
> fun
,
2259 bool need_fullname
) override
;
2262 struct dwarf2_gdb_index
: public dwarf2_base_index_functions
2264 void dump (struct objfile
*objfile
) override
;
2266 void map_matching_symbols
2268 const lookup_name_info
&lookup_name
,
2271 gdb::function_view
<symbol_found_callback_ftype
> callback
,
2272 symbol_compare_ftype
*ordered_compare
) override
;
2274 bool expand_symtabs_matching
2275 (struct objfile
*objfile
,
2276 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
2277 const lookup_name_info
*lookup_name
,
2278 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
2279 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
2280 block_search_flags search_flags
,
2282 enum search_domain kind
) override
;
2285 struct dwarf2_debug_names_index
: public dwarf2_base_index_functions
2287 void dump (struct objfile
*objfile
) override
;
2289 void map_matching_symbols
2291 const lookup_name_info
&lookup_name
,
2294 gdb::function_view
<symbol_found_callback_ftype
> callback
,
2295 symbol_compare_ftype
*ordered_compare
) override
;
2297 bool expand_symtabs_matching
2298 (struct objfile
*objfile
,
2299 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
2300 const lookup_name_info
*lookup_name
,
2301 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
2302 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
2303 block_search_flags search_flags
,
2305 enum search_domain kind
) override
;
2308 static quick_symbol_functions_up
2309 make_dwarf_gdb_index ()
2311 return quick_symbol_functions_up (new dwarf2_gdb_index
);
2314 static quick_symbol_functions_up
2315 make_dwarf_debug_names ()
2317 return quick_symbol_functions_up (new dwarf2_debug_names_index
);
2320 /* Utility hash function for a stmt_list_hash. */
2323 hash_stmt_list_entry (const struct stmt_list_hash
*stmt_list_hash
)
2327 if (stmt_list_hash
->dwo_unit
!= NULL
)
2328 v
+= (uintptr_t) stmt_list_hash
->dwo_unit
->dwo_file
;
2329 v
+= to_underlying (stmt_list_hash
->line_sect_off
);
2333 /* Utility equality function for a stmt_list_hash. */
2336 eq_stmt_list_entry (const struct stmt_list_hash
*lhs
,
2337 const struct stmt_list_hash
*rhs
)
2339 if ((lhs
->dwo_unit
!= NULL
) != (rhs
->dwo_unit
!= NULL
))
2341 if (lhs
->dwo_unit
!= NULL
2342 && lhs
->dwo_unit
->dwo_file
!= rhs
->dwo_unit
->dwo_file
)
2345 return lhs
->line_sect_off
== rhs
->line_sect_off
;
2348 /* Hash function for a quick_file_names. */
2351 hash_file_name_entry (const void *e
)
2353 const struct quick_file_names
*file_data
2354 = (const struct quick_file_names
*) e
;
2356 return hash_stmt_list_entry (&file_data
->hash
);
2359 /* Equality function for a quick_file_names. */
2362 eq_file_name_entry (const void *a
, const void *b
)
2364 const struct quick_file_names
*ea
= (const struct quick_file_names
*) a
;
2365 const struct quick_file_names
*eb
= (const struct quick_file_names
*) b
;
2367 return eq_stmt_list_entry (&ea
->hash
, &eb
->hash
);
2370 /* Delete function for a quick_file_names. */
2373 delete_file_name_entry (void *e
)
2375 struct quick_file_names
*file_data
= (struct quick_file_names
*) e
;
2378 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
2380 xfree ((void*) file_data
->file_names
[i
]);
2381 if (file_data
->real_names
)
2382 xfree ((void*) file_data
->real_names
[i
]);
2385 /* The space for the struct itself lives on the obstack, so we don't
2389 /* Create a quick_file_names hash table. */
2392 create_quick_file_names_table (unsigned int nr_initial_entries
)
2394 return htab_up (htab_create_alloc (nr_initial_entries
,
2395 hash_file_name_entry
, eq_file_name_entry
,
2396 delete_file_name_entry
, xcalloc
, xfree
));
2399 /* Read in CU (dwarf2_cu object) for PER_CU in the context of PER_OBJFILE. This
2400 function is unrelated to symtabs, symtab would have to be created afterwards.
2401 You should call age_cached_comp_units after processing the CU. */
2404 load_cu (dwarf2_per_cu_data
*per_cu
, dwarf2_per_objfile
*per_objfile
,
2407 if (per_cu
->is_debug_types
)
2408 load_full_type_unit (per_cu
, per_objfile
);
2410 load_full_comp_unit (per_cu
, per_objfile
, per_objfile
->get_cu (per_cu
),
2411 skip_partial
, language_minimal
);
2413 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
2415 return nullptr; /* Dummy CU. */
2417 dwarf2_find_base_address (cu
->dies
, cu
);
2422 /* Read in the symbols for PER_CU in the context of PER_OBJFILE. */
2425 dw2_do_instantiate_symtab (dwarf2_per_cu_data
*per_cu
,
2426 dwarf2_per_objfile
*per_objfile
, bool skip_partial
)
2428 /* Skip type_unit_groups, reading the type units they contain
2429 is handled elsewhere. */
2430 if (per_cu
->type_unit_group_p ())
2434 /* The destructor of dwarf2_queue_guard frees any entries left on
2435 the queue. After this point we're guaranteed to leave this function
2436 with the dwarf queue empty. */
2437 dwarf2_queue_guard
q_guard (per_objfile
);
2439 if (!per_objfile
->symtab_set_p (per_cu
))
2441 queue_comp_unit (per_cu
, per_objfile
, language_minimal
);
2442 dwarf2_cu
*cu
= load_cu (per_cu
, per_objfile
, skip_partial
);
2444 /* If we just loaded a CU from a DWO, and we're working with an index
2445 that may badly handle TUs, load all the TUs in that DWO as well.
2446 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
2447 if (!per_cu
->is_debug_types
2449 && cu
->dwo_unit
!= NULL
2450 && per_objfile
->per_bfd
->index_table
!= NULL
2451 && per_objfile
->per_bfd
->index_table
->version
<= 7
2452 /* DWP files aren't supported yet. */
2453 && get_dwp_file (per_objfile
) == NULL
)
2454 queue_and_load_all_dwo_tus (cu
);
2457 process_queue (per_objfile
);
2460 /* Age the cache, releasing compilation units that have not
2461 been used recently. */
2462 per_objfile
->age_comp_units ();
2465 /* Ensure that the symbols for PER_CU have been read in. DWARF2_PER_OBJFILE is
2466 the per-objfile for which this symtab is instantiated.
2468 Returns the resulting symbol table. */
2470 static struct compunit_symtab
*
2471 dw2_instantiate_symtab (dwarf2_per_cu_data
*per_cu
,
2472 dwarf2_per_objfile
*per_objfile
,
2475 gdb_assert (per_objfile
->per_bfd
->using_index
);
2477 if (!per_objfile
->symtab_set_p (per_cu
))
2479 free_cached_comp_units
freer (per_objfile
);
2480 scoped_restore decrementer
= increment_reading_symtab ();
2481 dw2_do_instantiate_symtab (per_cu
, per_objfile
, skip_partial
);
2482 process_cu_includes (per_objfile
);
2485 return per_objfile
->get_symtab (per_cu
);
2488 /* See declaration. */
2490 dwarf2_per_cu_data
*
2491 dwarf2_per_bfd::get_cutu (int index
)
2493 if (index
>= this->all_comp_units
.size ())
2495 index
-= this->all_comp_units
.size ();
2496 gdb_assert (index
< this->all_type_units
.size ());
2497 return &this->all_type_units
[index
]->per_cu
;
2500 return this->all_comp_units
[index
];
2503 /* See declaration. */
2505 dwarf2_per_cu_data
*
2506 dwarf2_per_bfd::get_cu (int index
)
2508 gdb_assert (index
>= 0 && index
< this->all_comp_units
.size ());
2510 return this->all_comp_units
[index
];
2513 /* See declaration. */
2516 dwarf2_per_bfd::get_tu (int index
)
2518 gdb_assert (index
>= 0 && index
< this->all_type_units
.size ());
2520 return this->all_type_units
[index
];
2525 dwarf2_per_cu_data
*
2526 dwarf2_per_bfd::allocate_per_cu ()
2528 dwarf2_per_cu_data
*result
= OBSTACK_ZALLOC (&obstack
, dwarf2_per_cu_data
);
2529 result
->per_bfd
= this;
2530 result
->index
= m_num_psymtabs
++;
2537 dwarf2_per_bfd::allocate_signatured_type ()
2539 signatured_type
*result
= OBSTACK_ZALLOC (&obstack
, signatured_type
);
2540 result
->per_cu
.per_bfd
= this;
2541 result
->per_cu
.index
= m_num_psymtabs
++;
2545 /* Return a new dwarf2_per_cu_data allocated on the per-bfd
2546 obstack, and constructed with the specified field values. */
2548 static dwarf2_per_cu_data
*
2549 create_cu_from_index_list (dwarf2_per_bfd
*per_bfd
,
2550 struct dwarf2_section_info
*section
,
2552 sect_offset sect_off
, ULONGEST length
)
2554 dwarf2_per_cu_data
*the_cu
= per_bfd
->allocate_per_cu ();
2555 the_cu
->sect_off
= sect_off
;
2556 the_cu
->length
= length
;
2557 the_cu
->section
= section
;
2558 the_cu
->v
.quick
= OBSTACK_ZALLOC (&per_bfd
->obstack
,
2559 struct dwarf2_per_cu_quick_data
);
2560 the_cu
->is_dwz
= is_dwz
;
2564 /* A helper for create_cus_from_index that handles a given list of
2568 create_cus_from_index_list (dwarf2_per_bfd
*per_bfd
,
2569 const gdb_byte
*cu_list
, offset_type n_elements
,
2570 struct dwarf2_section_info
*section
,
2573 for (offset_type i
= 0; i
< n_elements
; i
+= 2)
2575 gdb_static_assert (sizeof (ULONGEST
) >= 8);
2577 sect_offset sect_off
2578 = (sect_offset
) extract_unsigned_integer (cu_list
, 8, BFD_ENDIAN_LITTLE
);
2579 ULONGEST length
= extract_unsigned_integer (cu_list
+ 8, 8, BFD_ENDIAN_LITTLE
);
2582 dwarf2_per_cu_data
*per_cu
2583 = create_cu_from_index_list (per_bfd
, section
, is_dwz
, sect_off
,
2585 per_bfd
->all_comp_units
.push_back (per_cu
);
2589 /* Read the CU list from the mapped index, and use it to create all
2590 the CU objects for PER_BFD. */
2593 create_cus_from_index (dwarf2_per_bfd
*per_bfd
,
2594 const gdb_byte
*cu_list
, offset_type cu_list_elements
,
2595 const gdb_byte
*dwz_list
, offset_type dwz_elements
)
2597 gdb_assert (per_bfd
->all_comp_units
.empty ());
2598 per_bfd
->all_comp_units
.reserve ((cu_list_elements
+ dwz_elements
) / 2);
2600 create_cus_from_index_list (per_bfd
, cu_list
, cu_list_elements
,
2603 if (dwz_elements
== 0)
2606 dwz_file
*dwz
= dwarf2_get_dwz_file (per_bfd
);
2607 create_cus_from_index_list (per_bfd
, dwz_list
, dwz_elements
,
2611 /* Create the signatured type hash table from the index. */
2614 create_signatured_type_table_from_index
2615 (dwarf2_per_bfd
*per_bfd
, struct dwarf2_section_info
*section
,
2616 const gdb_byte
*bytes
, offset_type elements
)
2618 gdb_assert (per_bfd
->all_type_units
.empty ());
2619 per_bfd
->all_type_units
.reserve (elements
/ 3);
2621 htab_up sig_types_hash
= allocate_signatured_type_table ();
2623 for (offset_type i
= 0; i
< elements
; i
+= 3)
2625 struct signatured_type
*sig_type
;
2628 cu_offset type_offset_in_tu
;
2630 gdb_static_assert (sizeof (ULONGEST
) >= 8);
2631 sect_offset sect_off
2632 = (sect_offset
) extract_unsigned_integer (bytes
, 8, BFD_ENDIAN_LITTLE
);
2634 = (cu_offset
) extract_unsigned_integer (bytes
+ 8, 8,
2636 signature
= extract_unsigned_integer (bytes
+ 16, 8, BFD_ENDIAN_LITTLE
);
2639 sig_type
= per_bfd
->allocate_signatured_type ();
2640 sig_type
->signature
= signature
;
2641 sig_type
->type_offset_in_tu
= type_offset_in_tu
;
2642 sig_type
->per_cu
.is_debug_types
= 1;
2643 sig_type
->per_cu
.section
= section
;
2644 sig_type
->per_cu
.sect_off
= sect_off
;
2645 sig_type
->per_cu
.v
.quick
2646 = OBSTACK_ZALLOC (&per_bfd
->obstack
,
2647 struct dwarf2_per_cu_quick_data
);
2649 slot
= htab_find_slot (sig_types_hash
.get (), sig_type
, INSERT
);
2652 per_bfd
->all_type_units
.push_back (sig_type
);
2655 per_bfd
->signatured_types
= std::move (sig_types_hash
);
2658 /* Create the signatured type hash table from .debug_names. */
2661 create_signatured_type_table_from_debug_names
2662 (dwarf2_per_objfile
*per_objfile
,
2663 const mapped_debug_names
&map
,
2664 struct dwarf2_section_info
*section
,
2665 struct dwarf2_section_info
*abbrev_section
)
2667 struct objfile
*objfile
= per_objfile
->objfile
;
2669 section
->read (objfile
);
2670 abbrev_section
->read (objfile
);
2672 gdb_assert (per_objfile
->per_bfd
->all_type_units
.empty ());
2673 per_objfile
->per_bfd
->all_type_units
.reserve (map
.tu_count
);
2675 htab_up sig_types_hash
= allocate_signatured_type_table ();
2677 for (uint32_t i
= 0; i
< map
.tu_count
; ++i
)
2679 struct signatured_type
*sig_type
;
2682 sect_offset sect_off
2683 = (sect_offset
) (extract_unsigned_integer
2684 (map
.tu_table_reordered
+ i
* map
.offset_size
,
2686 map
.dwarf5_byte_order
));
2688 comp_unit_head cu_header
;
2689 read_and_check_comp_unit_head (per_objfile
, &cu_header
, section
,
2691 section
->buffer
+ to_underlying (sect_off
),
2694 sig_type
= per_objfile
->per_bfd
->allocate_signatured_type ();
2695 sig_type
->signature
= cu_header
.signature
;
2696 sig_type
->type_offset_in_tu
= cu_header
.type_cu_offset_in_tu
;
2697 sig_type
->per_cu
.is_debug_types
= 1;
2698 sig_type
->per_cu
.section
= section
;
2699 sig_type
->per_cu
.sect_off
= sect_off
;
2700 sig_type
->per_cu
.v
.quick
2701 = OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
,
2702 struct dwarf2_per_cu_quick_data
);
2704 slot
= htab_find_slot (sig_types_hash
.get (), sig_type
, INSERT
);
2707 per_objfile
->per_bfd
->all_type_units
.push_back (sig_type
);
2710 per_objfile
->per_bfd
->signatured_types
= std::move (sig_types_hash
);
2713 /* Read the address map data from the mapped index, and use it to
2714 populate the psymtabs_addrmap. */
2717 create_addrmap_from_index (dwarf2_per_objfile
*per_objfile
,
2718 struct mapped_index
*index
)
2720 struct objfile
*objfile
= per_objfile
->objfile
;
2721 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
2722 struct gdbarch
*gdbarch
= objfile
->arch ();
2723 const gdb_byte
*iter
, *end
;
2724 struct addrmap
*mutable_map
;
2727 auto_obstack temp_obstack
;
2729 mutable_map
= addrmap_create_mutable (&temp_obstack
);
2731 iter
= index
->address_table
.data ();
2732 end
= iter
+ index
->address_table
.size ();
2734 baseaddr
= objfile
->text_section_offset ();
2738 ULONGEST hi
, lo
, cu_index
;
2739 lo
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
2741 hi
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
2743 cu_index
= extract_unsigned_integer (iter
, 4, BFD_ENDIAN_LITTLE
);
2748 complaint (_(".gdb_index address table has invalid range (%s - %s)"),
2749 hex_string (lo
), hex_string (hi
));
2753 if (cu_index
>= per_bfd
->all_comp_units
.size ())
2755 complaint (_(".gdb_index address table has invalid CU number %u"),
2756 (unsigned) cu_index
);
2760 lo
= gdbarch_adjust_dwarf2_addr (gdbarch
, lo
+ baseaddr
) - baseaddr
;
2761 hi
= gdbarch_adjust_dwarf2_addr (gdbarch
, hi
+ baseaddr
) - baseaddr
;
2762 addrmap_set_empty (mutable_map
, lo
, hi
- 1,
2763 per_bfd
->get_cu (cu_index
));
2766 per_bfd
->index_addrmap
= addrmap_create_fixed (mutable_map
,
2770 /* Read the address map data from DWARF-5 .debug_aranges, and use it to
2771 populate the psymtabs_addrmap. */
2774 create_addrmap_from_aranges (dwarf2_per_objfile
*per_objfile
,
2775 struct dwarf2_section_info
*section
)
2777 struct objfile
*objfile
= per_objfile
->objfile
;
2778 bfd
*abfd
= objfile
->obfd
;
2779 struct gdbarch
*gdbarch
= objfile
->arch ();
2780 const CORE_ADDR baseaddr
= objfile
->text_section_offset ();
2781 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
2783 auto_obstack temp_obstack
;
2784 addrmap
*mutable_map
= addrmap_create_mutable (&temp_obstack
);
2786 std::unordered_map
<sect_offset
,
2787 dwarf2_per_cu_data
*,
2788 gdb::hash_enum
<sect_offset
>>
2789 debug_info_offset_to_per_cu
;
2790 for (dwarf2_per_cu_data
*per_cu
: per_bfd
->all_comp_units
)
2792 const auto insertpair
2793 = debug_info_offset_to_per_cu
.emplace (per_cu
->sect_off
, per_cu
);
2794 if (!insertpair
.second
)
2796 warning (_("Section .debug_aranges in %s has duplicate "
2797 "debug_info_offset %s, ignoring .debug_aranges."),
2798 objfile_name (objfile
), sect_offset_str (per_cu
->sect_off
));
2803 section
->read (objfile
);
2805 const bfd_endian dwarf5_byte_order
= gdbarch_byte_order (gdbarch
);
2807 const gdb_byte
*addr
= section
->buffer
;
2809 while (addr
< section
->buffer
+ section
->size
)
2811 const gdb_byte
*const entry_addr
= addr
;
2812 unsigned int bytes_read
;
2814 const LONGEST entry_length
= read_initial_length (abfd
, addr
,
2818 const gdb_byte
*const entry_end
= addr
+ entry_length
;
2819 const bool dwarf5_is_dwarf64
= bytes_read
!= 4;
2820 const uint8_t offset_size
= dwarf5_is_dwarf64
? 8 : 4;
2821 if (addr
+ entry_length
> section
->buffer
+ section
->size
)
2823 warning (_("Section .debug_aranges in %s entry at offset %s "
2824 "length %s exceeds section length %s, "
2825 "ignoring .debug_aranges."),
2826 objfile_name (objfile
),
2827 plongest (entry_addr
- section
->buffer
),
2828 plongest (bytes_read
+ entry_length
),
2829 pulongest (section
->size
));
2833 /* The version number. */
2834 const uint16_t version
= read_2_bytes (abfd
, addr
);
2838 warning (_("Section .debug_aranges in %s entry at offset %s "
2839 "has unsupported version %d, ignoring .debug_aranges."),
2840 objfile_name (objfile
),
2841 plongest (entry_addr
- section
->buffer
), version
);
2845 const uint64_t debug_info_offset
2846 = extract_unsigned_integer (addr
, offset_size
, dwarf5_byte_order
);
2847 addr
+= offset_size
;
2848 const auto per_cu_it
2849 = debug_info_offset_to_per_cu
.find (sect_offset (debug_info_offset
));
2850 if (per_cu_it
== debug_info_offset_to_per_cu
.cend ())
2852 warning (_("Section .debug_aranges in %s entry at offset %s "
2853 "debug_info_offset %s does not exists, "
2854 "ignoring .debug_aranges."),
2855 objfile_name (objfile
),
2856 plongest (entry_addr
- section
->buffer
),
2857 pulongest (debug_info_offset
));
2860 dwarf2_per_cu_data
*const per_cu
= per_cu_it
->second
;
2862 const uint8_t address_size
= *addr
++;
2863 if (address_size
< 1 || address_size
> 8)
2865 warning (_("Section .debug_aranges in %s entry at offset %s "
2866 "address_size %u is invalid, ignoring .debug_aranges."),
2867 objfile_name (objfile
),
2868 plongest (entry_addr
- section
->buffer
), address_size
);
2872 const uint8_t segment_selector_size
= *addr
++;
2873 if (segment_selector_size
!= 0)
2875 warning (_("Section .debug_aranges in %s entry at offset %s "
2876 "segment_selector_size %u is not supported, "
2877 "ignoring .debug_aranges."),
2878 objfile_name (objfile
),
2879 plongest (entry_addr
- section
->buffer
),
2880 segment_selector_size
);
2884 /* Must pad to an alignment boundary that is twice the address
2885 size. It is undocumented by the DWARF standard but GCC does
2887 for (size_t padding
= ((-(addr
- section
->buffer
))
2888 & (2 * address_size
- 1));
2889 padding
> 0; padding
--)
2892 warning (_("Section .debug_aranges in %s entry at offset %s "
2893 "padding is not zero, ignoring .debug_aranges."),
2894 objfile_name (objfile
),
2895 plongest (entry_addr
- section
->buffer
));
2901 if (addr
+ 2 * address_size
> entry_end
)
2903 warning (_("Section .debug_aranges in %s entry at offset %s "
2904 "address list is not properly terminated, "
2905 "ignoring .debug_aranges."),
2906 objfile_name (objfile
),
2907 plongest (entry_addr
- section
->buffer
));
2910 ULONGEST start
= extract_unsigned_integer (addr
, address_size
,
2912 addr
+= address_size
;
2913 ULONGEST length
= extract_unsigned_integer (addr
, address_size
,
2915 addr
+= address_size
;
2916 if (start
== 0 && length
== 0)
2918 if (start
== 0 && !per_bfd
->has_section_at_zero
)
2920 /* Symbol was eliminated due to a COMDAT group. */
2923 ULONGEST end
= start
+ length
;
2924 start
= (gdbarch_adjust_dwarf2_addr (gdbarch
, start
+ baseaddr
)
2926 end
= (gdbarch_adjust_dwarf2_addr (gdbarch
, end
+ baseaddr
)
2928 addrmap_set_empty (mutable_map
, start
, end
- 1, per_cu
);
2932 per_bfd
->index_addrmap
= addrmap_create_fixed (mutable_map
,
2936 /* A helper function that reads the .gdb_index from BUFFER and fills
2937 in MAP. FILENAME is the name of the file containing the data;
2938 it is used for error reporting. DEPRECATED_OK is true if it is
2939 ok to use deprecated sections.
2941 CU_LIST, CU_LIST_ELEMENTS, TYPES_LIST, and TYPES_LIST_ELEMENTS are
2942 out parameters that are filled in with information about the CU and
2943 TU lists in the section.
2945 Returns true if all went well, false otherwise. */
2948 read_gdb_index_from_buffer (const char *filename
,
2950 gdb::array_view
<const gdb_byte
> buffer
,
2951 struct mapped_index
*map
,
2952 const gdb_byte
**cu_list
,
2953 offset_type
*cu_list_elements
,
2954 const gdb_byte
**types_list
,
2955 offset_type
*types_list_elements
)
2957 const gdb_byte
*addr
= &buffer
[0];
2959 /* Version check. */
2960 offset_type version
= MAYBE_SWAP (*(offset_type
*) addr
);
2961 /* Versions earlier than 3 emitted every copy of a psymbol. This
2962 causes the index to behave very poorly for certain requests. Version 3
2963 contained incomplete addrmap. So, it seems better to just ignore such
2967 static int warning_printed
= 0;
2968 if (!warning_printed
)
2970 warning (_("Skipping obsolete .gdb_index section in %s."),
2972 warning_printed
= 1;
2976 /* Index version 4 uses a different hash function than index version
2979 Versions earlier than 6 did not emit psymbols for inlined
2980 functions. Using these files will cause GDB not to be able to
2981 set breakpoints on inlined functions by name, so we ignore these
2982 indices unless the user has done
2983 "set use-deprecated-index-sections on". */
2984 if (version
< 6 && !deprecated_ok
)
2986 static int warning_printed
= 0;
2987 if (!warning_printed
)
2990 Skipping deprecated .gdb_index section in %s.\n\
2991 Do \"set use-deprecated-index-sections on\" before the file is read\n\
2992 to use the section anyway."),
2994 warning_printed
= 1;
2998 /* Version 7 indices generated by gold refer to the CU for a symbol instead
2999 of the TU (for symbols coming from TUs),
3000 http://sourceware.org/bugzilla/show_bug.cgi?id=15021.
3001 Plus gold-generated indices can have duplicate entries for global symbols,
3002 http://sourceware.org/bugzilla/show_bug.cgi?id=15646.
3003 These are just performance bugs, and we can't distinguish gdb-generated
3004 indices from gold-generated ones, so issue no warning here. */
3006 /* Indexes with higher version than the one supported by GDB may be no
3007 longer backward compatible. */
3011 map
->version
= version
;
3013 offset_type
*metadata
= (offset_type
*) (addr
+ sizeof (offset_type
));
3016 *cu_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
3017 *cu_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1]) - MAYBE_SWAP (metadata
[i
]))
3021 *types_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
3022 *types_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1])
3023 - MAYBE_SWAP (metadata
[i
]))
3027 const gdb_byte
*address_table
= addr
+ MAYBE_SWAP (metadata
[i
]);
3028 const gdb_byte
*address_table_end
= addr
+ MAYBE_SWAP (metadata
[i
+ 1]);
3030 = gdb::array_view
<const gdb_byte
> (address_table
, address_table_end
);
3033 const gdb_byte
*symbol_table
= addr
+ MAYBE_SWAP (metadata
[i
]);
3034 const gdb_byte
*symbol_table_end
= addr
+ MAYBE_SWAP (metadata
[i
+ 1]);
3036 = gdb::array_view
<mapped_index::symbol_table_slot
>
3037 ((mapped_index::symbol_table_slot
*) symbol_table
,
3038 (mapped_index::symbol_table_slot
*) symbol_table_end
);
3041 map
->constant_pool
= (char *) (addr
+ MAYBE_SWAP (metadata
[i
]));
3046 /* Callback types for dwarf2_read_gdb_index. */
3048 typedef gdb::function_view
3049 <gdb::array_view
<const gdb_byte
>(objfile
*, dwarf2_per_bfd
*)>
3050 get_gdb_index_contents_ftype
;
3051 typedef gdb::function_view
3052 <gdb::array_view
<const gdb_byte
>(objfile
*, dwz_file
*)>
3053 get_gdb_index_contents_dwz_ftype
;
3055 /* Read .gdb_index. If everything went ok, initialize the "quick"
3056 elements of all the CUs and return 1. Otherwise, return 0. */
3059 dwarf2_read_gdb_index
3060 (dwarf2_per_objfile
*per_objfile
,
3061 get_gdb_index_contents_ftype get_gdb_index_contents
,
3062 get_gdb_index_contents_dwz_ftype get_gdb_index_contents_dwz
)
3064 const gdb_byte
*cu_list
, *types_list
, *dwz_list
= NULL
;
3065 offset_type cu_list_elements
, types_list_elements
, dwz_list_elements
= 0;
3066 struct dwz_file
*dwz
;
3067 struct objfile
*objfile
= per_objfile
->objfile
;
3068 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
3070 gdb::array_view
<const gdb_byte
> main_index_contents
3071 = get_gdb_index_contents (objfile
, per_bfd
);
3073 if (main_index_contents
.empty ())
3076 std::unique_ptr
<struct mapped_index
> map (new struct mapped_index
);
3077 if (!read_gdb_index_from_buffer (objfile_name (objfile
),
3078 use_deprecated_index_sections
,
3079 main_index_contents
, map
.get (), &cu_list
,
3080 &cu_list_elements
, &types_list
,
3081 &types_list_elements
))
3084 /* Don't use the index if it's empty. */
3085 if (map
->symbol_table
.empty ())
3088 /* If there is a .dwz file, read it so we can get its CU list as
3090 dwz
= dwarf2_get_dwz_file (per_bfd
);
3093 struct mapped_index dwz_map
;
3094 const gdb_byte
*dwz_types_ignore
;
3095 offset_type dwz_types_elements_ignore
;
3097 gdb::array_view
<const gdb_byte
> dwz_index_content
3098 = get_gdb_index_contents_dwz (objfile
, dwz
);
3100 if (dwz_index_content
.empty ())
3103 if (!read_gdb_index_from_buffer (bfd_get_filename (dwz
->dwz_bfd
.get ()),
3104 1, dwz_index_content
, &dwz_map
,
3105 &dwz_list
, &dwz_list_elements
,
3107 &dwz_types_elements_ignore
))
3109 warning (_("could not read '.gdb_index' section from %s; skipping"),
3110 bfd_get_filename (dwz
->dwz_bfd
.get ()));
3115 create_cus_from_index (per_bfd
, cu_list
, cu_list_elements
, dwz_list
,
3118 if (types_list_elements
)
3120 /* We can only handle a single .debug_types when we have an
3122 if (per_bfd
->types
.size () != 1)
3125 dwarf2_section_info
*section
= &per_bfd
->types
[0];
3127 create_signatured_type_table_from_index (per_bfd
, section
, types_list
,
3128 types_list_elements
);
3131 create_addrmap_from_index (per_objfile
, map
.get ());
3133 per_bfd
->index_table
= std::move (map
);
3134 per_bfd
->using_index
= 1;
3135 per_bfd
->quick_file_names_table
=
3136 create_quick_file_names_table (per_bfd
->all_comp_units
.size ());
3141 /* die_reader_func for dw2_get_file_names. */
3144 dw2_get_file_names_reader (const struct die_reader_specs
*reader
,
3145 struct die_info
*comp_unit_die
)
3147 struct dwarf2_cu
*cu
= reader
->cu
;
3148 struct dwarf2_per_cu_data
*this_cu
= cu
->per_cu
;
3149 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
3150 struct dwarf2_per_cu_data
*lh_cu
;
3151 struct attribute
*attr
;
3153 struct quick_file_names
*qfn
;
3155 gdb_assert (! this_cu
->is_debug_types
);
3157 /* Our callers never want to match partial units -- instead they
3158 will match the enclosing full CU. */
3159 if (comp_unit_die
->tag
== DW_TAG_partial_unit
)
3161 this_cu
->v
.quick
->no_file_data
= 1;
3169 sect_offset line_offset
{};
3171 attr
= dwarf2_attr (comp_unit_die
, DW_AT_stmt_list
, cu
);
3172 if (attr
!= nullptr && attr
->form_is_unsigned ())
3174 struct quick_file_names find_entry
;
3176 line_offset
= (sect_offset
) attr
->as_unsigned ();
3178 /* We may have already read in this line header (TU line header sharing).
3179 If we have we're done. */
3180 find_entry
.hash
.dwo_unit
= cu
->dwo_unit
;
3181 find_entry
.hash
.line_sect_off
= line_offset
;
3182 slot
= htab_find_slot (per_objfile
->per_bfd
->quick_file_names_table
.get (),
3183 &find_entry
, INSERT
);
3186 lh_cu
->v
.quick
->file_names
= (struct quick_file_names
*) *slot
;
3190 lh
= dwarf_decode_line_header (line_offset
, cu
);
3194 lh_cu
->v
.quick
->no_file_data
= 1;
3198 qfn
= XOBNEW (&per_objfile
->per_bfd
->obstack
, struct quick_file_names
);
3199 qfn
->hash
.dwo_unit
= cu
->dwo_unit
;
3200 qfn
->hash
.line_sect_off
= line_offset
;
3201 gdb_assert (slot
!= NULL
);
3204 file_and_directory fnd
= find_file_and_directory (comp_unit_die
, cu
);
3207 if (strcmp (fnd
.name
, "<unknown>") != 0)
3210 qfn
->num_file_names
= offset
+ lh
->file_names_size ();
3212 XOBNEWVEC (&per_objfile
->per_bfd
->obstack
, const char *,
3213 qfn
->num_file_names
);
3215 qfn
->file_names
[0] = xstrdup (fnd
.name
);
3216 for (int i
= 0; i
< lh
->file_names_size (); ++i
)
3217 qfn
->file_names
[i
+ offset
] = lh
->file_full_name (i
+ 1,
3218 fnd
.comp_dir
).release ();
3219 qfn
->real_names
= NULL
;
3221 lh_cu
->v
.quick
->file_names
= qfn
;
3224 /* A helper for the "quick" functions which attempts to read the line
3225 table for THIS_CU. */
3227 static struct quick_file_names
*
3228 dw2_get_file_names (dwarf2_per_cu_data
*this_cu
,
3229 dwarf2_per_objfile
*per_objfile
)
3231 /* This should never be called for TUs. */
3232 gdb_assert (! this_cu
->is_debug_types
);
3233 /* Nor type unit groups. */
3234 gdb_assert (! this_cu
->type_unit_group_p ());
3236 if (this_cu
->v
.quick
->file_names
!= NULL
)
3237 return this_cu
->v
.quick
->file_names
;
3238 /* If we know there is no line data, no point in looking again. */
3239 if (this_cu
->v
.quick
->no_file_data
)
3242 cutu_reader
reader (this_cu
, per_objfile
);
3243 if (!reader
.dummy_p
)
3244 dw2_get_file_names_reader (&reader
, reader
.comp_unit_die
);
3246 if (this_cu
->v
.quick
->no_file_data
)
3248 return this_cu
->v
.quick
->file_names
;
3251 /* A helper for the "quick" functions which computes and caches the
3252 real path for a given file name from the line table. */
3255 dw2_get_real_path (dwarf2_per_objfile
*per_objfile
,
3256 struct quick_file_names
*qfn
, int index
)
3258 if (qfn
->real_names
== NULL
)
3259 qfn
->real_names
= OBSTACK_CALLOC (&per_objfile
->per_bfd
->obstack
,
3260 qfn
->num_file_names
, const char *);
3262 if (qfn
->real_names
[index
] == NULL
)
3263 qfn
->real_names
[index
] = gdb_realpath (qfn
->file_names
[index
]).release ();
3265 return qfn
->real_names
[index
];
3269 dwarf2_base_index_functions::find_last_source_symtab (struct objfile
*objfile
)
3271 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3272 dwarf2_per_cu_data
*dwarf_cu
= per_objfile
->per_bfd
->all_comp_units
.back ();
3273 compunit_symtab
*cust
= dw2_instantiate_symtab (dwarf_cu
, per_objfile
, false);
3278 return compunit_primary_filetab (cust
);
3281 /* Traversal function for dw2_forget_cached_source_info. */
3284 dw2_free_cached_file_names (void **slot
, void *info
)
3286 struct quick_file_names
*file_data
= (struct quick_file_names
*) *slot
;
3288 if (file_data
->real_names
)
3292 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
3294 xfree ((void*) file_data
->real_names
[i
]);
3295 file_data
->real_names
[i
] = NULL
;
3303 dwarf2_base_index_functions::forget_cached_source_info
3304 (struct objfile
*objfile
)
3306 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3308 htab_traverse_noresize (per_objfile
->per_bfd
->quick_file_names_table
.get (),
3309 dw2_free_cached_file_names
, NULL
);
3312 /* Struct used to manage iterating over all CUs looking for a symbol. */
3314 struct dw2_symtab_iterator
3316 /* The dwarf2_per_objfile owning the CUs we are iterating on. */
3317 dwarf2_per_objfile
*per_objfile
;
3318 /* If set, only look for symbols that match that block. Valid values are
3319 GLOBAL_BLOCK and STATIC_BLOCK. */
3320 gdb::optional
<block_enum
> block_index
;
3321 /* The kind of symbol we're looking for. */
3323 /* The list of CUs from the index entry of the symbol,
3324 or NULL if not found. */
3326 /* The next element in VEC to look at. */
3328 /* The number of elements in VEC, or zero if there is no match. */
3330 /* Have we seen a global version of the symbol?
3331 If so we can ignore all further global instances.
3332 This is to work around gold/15646, inefficient gold-generated
3337 /* Initialize the index symtab iterator ITER, offset_type NAMEI variant. */
3340 dw2_symtab_iter_init (struct dw2_symtab_iterator
*iter
,
3341 dwarf2_per_objfile
*per_objfile
,
3342 gdb::optional
<block_enum
> block_index
,
3343 domain_enum domain
, offset_type namei
)
3345 iter
->per_objfile
= per_objfile
;
3346 iter
->block_index
= block_index
;
3347 iter
->domain
= domain
;
3349 iter
->global_seen
= 0;
3353 mapped_index
*index
= per_objfile
->per_bfd
->index_table
.get ();
3354 /* index is NULL if OBJF_READNOW. */
3358 gdb_assert (!index
->symbol_name_slot_invalid (namei
));
3359 const auto &bucket
= index
->symbol_table
[namei
];
3361 iter
->vec
= (offset_type
*) (index
->constant_pool
3362 + MAYBE_SWAP (bucket
.vec
));
3363 iter
->length
= MAYBE_SWAP (*iter
->vec
);
3366 /* Return the next matching CU or NULL if there are no more. */
3368 static struct dwarf2_per_cu_data
*
3369 dw2_symtab_iter_next (struct dw2_symtab_iterator
*iter
)
3371 dwarf2_per_objfile
*per_objfile
= iter
->per_objfile
;
3373 for ( ; iter
->next
< iter
->length
; ++iter
->next
)
3375 offset_type cu_index_and_attrs
=
3376 MAYBE_SWAP (iter
->vec
[iter
->next
+ 1]);
3377 offset_type cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
3378 gdb_index_symbol_kind symbol_kind
=
3379 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
3380 /* Only check the symbol attributes if they're present.
3381 Indices prior to version 7 don't record them,
3382 and indices >= 7 may elide them for certain symbols
3383 (gold does this). */
3385 (per_objfile
->per_bfd
->index_table
->version
>= 7
3386 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_NONE
);
3388 /* Don't crash on bad data. */
3389 if (cu_index
>= (per_objfile
->per_bfd
->all_comp_units
.size ()
3390 + per_objfile
->per_bfd
->all_type_units
.size ()))
3392 complaint (_(".gdb_index entry has bad CU index"
3393 " [in module %s]"), objfile_name (per_objfile
->objfile
));
3397 dwarf2_per_cu_data
*per_cu
= per_objfile
->per_bfd
->get_cutu (cu_index
);
3399 /* Skip if already read in. */
3400 if (per_objfile
->symtab_set_p (per_cu
))
3403 /* Check static vs global. */
3406 bool is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs
);
3408 if (iter
->block_index
.has_value ())
3410 bool want_static
= *iter
->block_index
== STATIC_BLOCK
;
3412 if (is_static
!= want_static
)
3416 /* Work around gold/15646. */
3418 && symbol_kind
== GDB_INDEX_SYMBOL_KIND_TYPE
)
3420 if (iter
->global_seen
)
3423 iter
->global_seen
= 1;
3427 /* Only check the symbol's kind if it has one. */
3430 switch (iter
->domain
)
3433 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
3434 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
3435 /* Some types are also in VAR_DOMAIN. */
3436 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
3440 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
3444 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_OTHER
)
3448 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_OTHER
)
3464 dwarf2_base_index_functions::print_stats (struct objfile
*objfile
,
3470 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3471 int total
= (per_objfile
->per_bfd
->all_comp_units
.size ()
3472 + per_objfile
->per_bfd
->all_type_units
.size ());
3475 for (int i
= 0; i
< total
; ++i
)
3477 dwarf2_per_cu_data
*per_cu
= per_objfile
->per_bfd
->get_cutu (i
);
3479 if (!per_objfile
->symtab_set_p (per_cu
))
3482 printf_filtered (_(" Number of read CUs: %d\n"), total
- count
);
3483 printf_filtered (_(" Number of unread CUs: %d\n"), count
);
3486 /* This dumps minimal information about the index.
3487 It is called via "mt print objfiles".
3488 One use is to verify .gdb_index has been loaded by the
3489 gdb.dwarf2/gdb-index.exp testcase. */
3492 dwarf2_gdb_index::dump (struct objfile
*objfile
)
3494 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3496 gdb_assert (per_objfile
->per_bfd
->using_index
);
3497 printf_filtered (".gdb_index:");
3498 if (per_objfile
->per_bfd
->index_table
!= NULL
)
3500 printf_filtered (" version %d\n",
3501 per_objfile
->per_bfd
->index_table
->version
);
3504 printf_filtered (" faked for \"readnow\"\n");
3505 printf_filtered ("\n");
3509 dwarf2_base_index_functions::expand_all_symtabs (struct objfile
*objfile
)
3511 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3512 int total_units
= (per_objfile
->per_bfd
->all_comp_units
.size ()
3513 + per_objfile
->per_bfd
->all_type_units
.size ());
3515 for (int i
= 0; i
< total_units
; ++i
)
3517 dwarf2_per_cu_data
*per_cu
= per_objfile
->per_bfd
->get_cutu (i
);
3519 /* We don't want to directly expand a partial CU, because if we
3520 read it with the wrong language, then assertion failures can
3521 be triggered later on. See PR symtab/23010. So, tell
3522 dw2_instantiate_symtab to skip partial CUs -- any important
3523 partial CU will be read via DW_TAG_imported_unit anyway. */
3524 dw2_instantiate_symtab (per_cu
, per_objfile
, true);
3529 dwarf2_base_index_functions::expand_symtabs_with_fullname
3530 (struct objfile
*objfile
, const char *fullname
)
3532 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3534 /* We don't need to consider type units here.
3535 This is only called for examining code, e.g. expand_line_sal.
3536 There can be an order of magnitude (or more) more type units
3537 than comp units, and we avoid them if we can. */
3539 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
3541 /* We only need to look at symtabs not already expanded. */
3542 if (per_objfile
->symtab_set_p (per_cu
))
3545 quick_file_names
*file_data
= dw2_get_file_names (per_cu
, per_objfile
);
3546 if (file_data
== NULL
)
3549 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
3551 const char *this_fullname
= file_data
->file_names
[j
];
3553 if (filename_cmp (this_fullname
, fullname
) == 0)
3555 dw2_instantiate_symtab (per_cu
, per_objfile
, false);
3563 dw2_expand_symtabs_matching_symbol
3564 (mapped_index_base
&index
,
3565 const lookup_name_info
&lookup_name_in
,
3566 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
3567 gdb::function_view
<bool (offset_type
)> match_callback
,
3568 dwarf2_per_objfile
*per_objfile
);
3571 dw2_expand_symtabs_matching_one
3572 (dwarf2_per_cu_data
*per_cu
,
3573 dwarf2_per_objfile
*per_objfile
,
3574 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
3575 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
);
3578 dwarf2_gdb_index::map_matching_symbols
3579 (struct objfile
*objfile
,
3580 const lookup_name_info
&name
, domain_enum domain
,
3582 gdb::function_view
<symbol_found_callback_ftype
> callback
,
3583 symbol_compare_ftype
*ordered_compare
)
3586 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3588 const block_enum block_kind
= global
? GLOBAL_BLOCK
: STATIC_BLOCK
;
3590 if (per_objfile
->per_bfd
->index_table
!= nullptr)
3592 mapped_index
&index
= *per_objfile
->per_bfd
->index_table
;
3594 const char *match_name
= name
.ada ().lookup_name ().c_str ();
3595 auto matcher
= [&] (const char *symname
)
3597 if (ordered_compare
== nullptr)
3599 return ordered_compare (symname
, match_name
) == 0;
3602 dw2_expand_symtabs_matching_symbol (index
, name
, matcher
,
3603 [&] (offset_type namei
)
3605 struct dw2_symtab_iterator iter
;
3606 struct dwarf2_per_cu_data
*per_cu
;
3608 dw2_symtab_iter_init (&iter
, per_objfile
, block_kind
, domain
,
3610 while ((per_cu
= dw2_symtab_iter_next (&iter
)) != NULL
)
3611 dw2_expand_symtabs_matching_one (per_cu
, per_objfile
, nullptr,
3618 /* We have -readnow: no .gdb_index, but no partial symtabs either. So,
3619 proceed assuming all symtabs have been read in. */
3622 for (compunit_symtab
*cust
: objfile
->compunits ())
3624 const struct block
*block
;
3628 block
= BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust
), block_kind
);
3629 if (!iterate_over_symbols_terminated (block
, name
,
3635 /* Starting from a search name, return the string that finds the upper
3636 bound of all strings that start with SEARCH_NAME in a sorted name
3637 list. Returns the empty string to indicate that the upper bound is
3638 the end of the list. */
3641 make_sort_after_prefix_name (const char *search_name
)
3643 /* When looking to complete "func", we find the upper bound of all
3644 symbols that start with "func" by looking for where we'd insert
3645 the closest string that would follow "func" in lexicographical
3646 order. Usually, that's "func"-with-last-character-incremented,
3647 i.e. "fund". Mind non-ASCII characters, though. Usually those
3648 will be UTF-8 multi-byte sequences, but we can't be certain.
3649 Especially mind the 0xff character, which is a valid character in
3650 non-UTF-8 source character sets (e.g. Latin1 'ÿ'), and we can't
3651 rule out compilers allowing it in identifiers. Note that
3652 conveniently, strcmp/strcasecmp are specified to compare
3653 characters interpreted as unsigned char. So what we do is treat
3654 the whole string as a base 256 number composed of a sequence of
3655 base 256 "digits" and add 1 to it. I.e., adding 1 to 0xff wraps
3656 to 0, and carries 1 to the following more-significant position.
3657 If the very first character in SEARCH_NAME ends up incremented
3658 and carries/overflows, then the upper bound is the end of the
3659 list. The string after the empty string is also the empty
3662 Some examples of this operation:
3664 SEARCH_NAME => "+1" RESULT
3668 "\xff" "a" "\xff" => "\xff" "b"
3673 Then, with these symbols for example:
3679 completing "func" looks for symbols between "func" and
3680 "func"-with-last-character-incremented, i.e. "fund" (exclusive),
3681 which finds "func" and "func1", but not "fund".
3685 funcÿ (Latin1 'ÿ' [0xff])
3689 completing "funcÿ" looks for symbols between "funcÿ" and "fund"
3690 (exclusive), which finds "funcÿ" and "funcÿ1", but not "fund".
3694 ÿÿ (Latin1 'ÿ' [0xff])
3697 completing "ÿ" or "ÿÿ" looks for symbols between between "ÿÿ" and
3698 the end of the list.
3700 std::string after
= search_name
;
3701 while (!after
.empty () && (unsigned char) after
.back () == 0xff)
3703 if (!after
.empty ())
3704 after
.back () = (unsigned char) after
.back () + 1;
3708 /* See declaration. */
3710 std::pair
<std::vector
<name_component
>::const_iterator
,
3711 std::vector
<name_component
>::const_iterator
>
3712 mapped_index_base::find_name_components_bounds
3713 (const lookup_name_info
&lookup_name_without_params
, language lang
,
3714 dwarf2_per_objfile
*per_objfile
) const
3717 = this->name_components_casing
== case_sensitive_on
? strcmp
: strcasecmp
;
3719 const char *lang_name
3720 = lookup_name_without_params
.language_lookup_name (lang
);
3722 /* Comparison function object for lower_bound that matches against a
3723 given symbol name. */
3724 auto lookup_compare_lower
= [&] (const name_component
&elem
,
3727 const char *elem_qualified
= this->symbol_name_at (elem
.idx
, per_objfile
);
3728 const char *elem_name
= elem_qualified
+ elem
.name_offset
;
3729 return name_cmp (elem_name
, name
) < 0;
3732 /* Comparison function object for upper_bound that matches against a
3733 given symbol name. */
3734 auto lookup_compare_upper
= [&] (const char *name
,
3735 const name_component
&elem
)
3737 const char *elem_qualified
= this->symbol_name_at (elem
.idx
, per_objfile
);
3738 const char *elem_name
= elem_qualified
+ elem
.name_offset
;
3739 return name_cmp (name
, elem_name
) < 0;
3742 auto begin
= this->name_components
.begin ();
3743 auto end
= this->name_components
.end ();
3745 /* Find the lower bound. */
3748 if (lookup_name_without_params
.completion_mode () && lang_name
[0] == '\0')
3751 return std::lower_bound (begin
, end
, lang_name
, lookup_compare_lower
);
3754 /* Find the upper bound. */
3757 if (lookup_name_without_params
.completion_mode ())
3759 /* In completion mode, we want UPPER to point past all
3760 symbols names that have the same prefix. I.e., with
3761 these symbols, and completing "func":
3763 function << lower bound
3765 other_function << upper bound
3767 We find the upper bound by looking for the insertion
3768 point of "func"-with-last-character-incremented,
3770 std::string after
= make_sort_after_prefix_name (lang_name
);
3773 return std::lower_bound (lower
, end
, after
.c_str (),
3774 lookup_compare_lower
);
3777 return std::upper_bound (lower
, end
, lang_name
, lookup_compare_upper
);
3780 return {lower
, upper
};
3783 /* See declaration. */
3786 mapped_index_base::build_name_components (dwarf2_per_objfile
*per_objfile
)
3788 if (!this->name_components
.empty ())
3791 this->name_components_casing
= case_sensitivity
;
3793 = this->name_components_casing
== case_sensitive_on
? strcmp
: strcasecmp
;
3795 /* The code below only knows how to break apart components of C++
3796 symbol names (and other languages that use '::' as
3797 namespace/module separator) and Ada symbol names. */
3798 auto count
= this->symbol_name_count ();
3799 for (offset_type idx
= 0; idx
< count
; idx
++)
3801 if (this->symbol_name_slot_invalid (idx
))
3804 const char *name
= this->symbol_name_at (idx
, per_objfile
);
3806 /* Add each name component to the name component table. */
3807 unsigned int previous_len
= 0;
3809 if (strstr (name
, "::") != nullptr)
3811 for (unsigned int current_len
= cp_find_first_component (name
);
3812 name
[current_len
] != '\0';
3813 current_len
+= cp_find_first_component (name
+ current_len
))
3815 gdb_assert (name
[current_len
] == ':');
3816 this->name_components
.push_back ({previous_len
, idx
});
3817 /* Skip the '::'. */
3819 previous_len
= current_len
;
3824 /* Handle the Ada encoded (aka mangled) form here. */
3825 for (const char *iter
= strstr (name
, "__");
3827 iter
= strstr (iter
, "__"))
3829 this->name_components
.push_back ({previous_len
, idx
});
3831 previous_len
= iter
- name
;
3835 this->name_components
.push_back ({previous_len
, idx
});
3838 /* Sort name_components elements by name. */
3839 auto name_comp_compare
= [&] (const name_component
&left
,
3840 const name_component
&right
)
3842 const char *left_qualified
3843 = this->symbol_name_at (left
.idx
, per_objfile
);
3844 const char *right_qualified
3845 = this->symbol_name_at (right
.idx
, per_objfile
);
3847 const char *left_name
= left_qualified
+ left
.name_offset
;
3848 const char *right_name
= right_qualified
+ right
.name_offset
;
3850 return name_cmp (left_name
, right_name
) < 0;
3853 std::sort (this->name_components
.begin (),
3854 this->name_components
.end (),
3858 /* Helper for dw2_expand_symtabs_matching that works with a
3859 mapped_index_base instead of the containing objfile. This is split
3860 to a separate function in order to be able to unit test the
3861 name_components matching using a mock mapped_index_base. For each
3862 symbol name that matches, calls MATCH_CALLBACK, passing it the
3863 symbol's index in the mapped_index_base symbol table. */
3866 dw2_expand_symtabs_matching_symbol
3867 (mapped_index_base
&index
,
3868 const lookup_name_info
&lookup_name_in
,
3869 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
3870 gdb::function_view
<bool (offset_type
)> match_callback
,
3871 dwarf2_per_objfile
*per_objfile
)
3873 lookup_name_info lookup_name_without_params
3874 = lookup_name_in
.make_ignore_params ();
3876 /* Build the symbol name component sorted vector, if we haven't
3878 index
.build_name_components (per_objfile
);
3880 /* The same symbol may appear more than once in the range though.
3881 E.g., if we're looking for symbols that complete "w", and we have
3882 a symbol named "w1::w2", we'll find the two name components for
3883 that same symbol in the range. To be sure we only call the
3884 callback once per symbol, we first collect the symbol name
3885 indexes that matched in a temporary vector and ignore
3887 std::vector
<offset_type
> matches
;
3889 struct name_and_matcher
3891 symbol_name_matcher_ftype
*matcher
;
3894 bool operator== (const name_and_matcher
&other
) const
3896 return matcher
== other
.matcher
&& strcmp (name
, other
.name
) == 0;
3900 /* A vector holding all the different symbol name matchers, for all
3902 std::vector
<name_and_matcher
> matchers
;
3904 for (int i
= 0; i
< nr_languages
; i
++)
3906 enum language lang_e
= (enum language
) i
;
3908 const language_defn
*lang
= language_def (lang_e
);
3909 symbol_name_matcher_ftype
*name_matcher
3910 = lang
->get_symbol_name_matcher (lookup_name_without_params
);
3912 name_and_matcher key
{
3914 lookup_name_without_params
.language_lookup_name (lang_e
)
3917 /* Don't insert the same comparison routine more than once.
3918 Note that we do this linear walk. This is not a problem in
3919 practice because the number of supported languages is
3921 if (std::find (matchers
.begin (), matchers
.end (), key
)
3924 matchers
.push_back (std::move (key
));
3927 = index
.find_name_components_bounds (lookup_name_without_params
,
3928 lang_e
, per_objfile
);
3930 /* Now for each symbol name in range, check to see if we have a name
3931 match, and if so, call the MATCH_CALLBACK callback. */
3933 for (; bounds
.first
!= bounds
.second
; ++bounds
.first
)
3935 const char *qualified
3936 = index
.symbol_name_at (bounds
.first
->idx
, per_objfile
);
3938 if (!name_matcher (qualified
, lookup_name_without_params
, NULL
)
3939 || (symbol_matcher
!= NULL
&& !symbol_matcher (qualified
)))
3942 matches
.push_back (bounds
.first
->idx
);
3946 std::sort (matches
.begin (), matches
.end ());
3948 /* Finally call the callback, once per match. */
3951 for (offset_type idx
: matches
)
3955 if (!match_callback (idx
))
3964 /* Above we use a type wider than idx's for 'prev', since 0 and
3965 (offset_type)-1 are both possible values. */
3966 static_assert (sizeof (prev
) > sizeof (offset_type
), "");
3973 namespace selftests
{ namespace dw2_expand_symtabs_matching
{
3975 /* A mock .gdb_index/.debug_names-like name index table, enough to
3976 exercise dw2_expand_symtabs_matching_symbol, which works with the
3977 mapped_index_base interface. Builds an index from the symbol list
3978 passed as parameter to the constructor. */
3979 class mock_mapped_index
: public mapped_index_base
3982 mock_mapped_index (gdb::array_view
<const char *> symbols
)
3983 : m_symbol_table (symbols
)
3986 DISABLE_COPY_AND_ASSIGN (mock_mapped_index
);
3988 /* Return the number of names in the symbol table. */
3989 size_t symbol_name_count () const override
3991 return m_symbol_table
.size ();
3994 /* Get the name of the symbol at IDX in the symbol table. */
3995 const char *symbol_name_at
3996 (offset_type idx
, dwarf2_per_objfile
*per_objfile
) const override
3998 return m_symbol_table
[idx
];
4002 gdb::array_view
<const char *> m_symbol_table
;
4005 /* Convenience function that converts a NULL pointer to a "<null>"
4006 string, to pass to print routines. */
4009 string_or_null (const char *str
)
4011 return str
!= NULL
? str
: "<null>";
4014 /* Check if a lookup_name_info built from
4015 NAME/MATCH_TYPE/COMPLETION_MODE matches the symbols in the mock
4016 index. EXPECTED_LIST is the list of expected matches, in expected
4017 matching order. If no match expected, then an empty list is
4018 specified. Returns true on success. On failure prints a warning
4019 indicating the file:line that failed, and returns false. */
4022 check_match (const char *file
, int line
,
4023 mock_mapped_index
&mock_index
,
4024 const char *name
, symbol_name_match_type match_type
,
4025 bool completion_mode
,
4026 std::initializer_list
<const char *> expected_list
,
4027 dwarf2_per_objfile
*per_objfile
)
4029 lookup_name_info
lookup_name (name
, match_type
, completion_mode
);
4031 bool matched
= true;
4033 auto mismatch
= [&] (const char *expected_str
,
4036 warning (_("%s:%d: match_type=%s, looking-for=\"%s\", "
4037 "expected=\"%s\", got=\"%s\"\n"),
4039 (match_type
== symbol_name_match_type::FULL
4041 name
, string_or_null (expected_str
), string_or_null (got
));
4045 auto expected_it
= expected_list
.begin ();
4046 auto expected_end
= expected_list
.end ();
4048 dw2_expand_symtabs_matching_symbol (mock_index
, lookup_name
,
4050 [&] (offset_type idx
)
4052 const char *matched_name
= mock_index
.symbol_name_at (idx
, per_objfile
);
4053 const char *expected_str
4054 = expected_it
== expected_end
? NULL
: *expected_it
++;
4056 if (expected_str
== NULL
|| strcmp (expected_str
, matched_name
) != 0)
4057 mismatch (expected_str
, matched_name
);
4061 const char *expected_str
4062 = expected_it
== expected_end
? NULL
: *expected_it
++;
4063 if (expected_str
!= NULL
)
4064 mismatch (expected_str
, NULL
);
4069 /* The symbols added to the mock mapped_index for testing (in
4071 static const char *test_symbols
[] = {
4080 "ns2::tmpl<int>::foo2",
4081 "(anonymous namespace)::A::B::C",
4083 /* These are used to check that the increment-last-char in the
4084 matching algorithm for completion doesn't match "t1_fund" when
4085 completing "t1_func". */
4091 /* A UTF-8 name with multi-byte sequences to make sure that
4092 cp-name-parser understands this as a single identifier ("função"
4093 is "function" in PT). */
4096 /* \377 (0xff) is Latin1 'ÿ'. */
4099 /* \377 (0xff) is Latin1 'ÿ'. */
4103 /* A name with all sorts of complications. Starts with "z" to make
4104 it easier for the completion tests below. */
4105 #define Z_SYM_NAME \
4106 "z::std::tuple<(anonymous namespace)::ui*, std::bar<(anonymous namespace)::ui> >" \
4107 "::tuple<(anonymous namespace)::ui*, " \
4108 "std::default_delete<(anonymous namespace)::ui>, void>"
4113 /* Returns true if the mapped_index_base::find_name_component_bounds
4114 method finds EXPECTED_SYMS in INDEX when looking for SEARCH_NAME,
4115 in completion mode. */
4118 check_find_bounds_finds (mapped_index_base
&index
,
4119 const char *search_name
,
4120 gdb::array_view
<const char *> expected_syms
,
4121 dwarf2_per_objfile
*per_objfile
)
4123 lookup_name_info
lookup_name (search_name
,
4124 symbol_name_match_type::FULL
, true);
4126 auto bounds
= index
.find_name_components_bounds (lookup_name
,
4130 size_t distance
= std::distance (bounds
.first
, bounds
.second
);
4131 if (distance
!= expected_syms
.size ())
4134 for (size_t exp_elem
= 0; exp_elem
< distance
; exp_elem
++)
4136 auto nc_elem
= bounds
.first
+ exp_elem
;
4137 const char *qualified
= index
.symbol_name_at (nc_elem
->idx
, per_objfile
);
4138 if (strcmp (qualified
, expected_syms
[exp_elem
]) != 0)
4145 /* Test the lower-level mapped_index::find_name_component_bounds
4149 test_mapped_index_find_name_component_bounds ()
4151 mock_mapped_index
mock_index (test_symbols
);
4153 mock_index
.build_name_components (NULL
/* per_objfile */);
4155 /* Test the lower-level mapped_index::find_name_component_bounds
4156 method in completion mode. */
4158 static const char *expected_syms
[] = {
4163 SELF_CHECK (check_find_bounds_finds
4164 (mock_index
, "t1_func", expected_syms
,
4165 NULL
/* per_objfile */));
4168 /* Check that the increment-last-char in the name matching algorithm
4169 for completion doesn't get confused with Ansi1 'ÿ' / 0xff. */
4171 static const char *expected_syms1
[] = {
4175 SELF_CHECK (check_find_bounds_finds
4176 (mock_index
, "\377", expected_syms1
, NULL
/* per_objfile */));
4178 static const char *expected_syms2
[] = {
4181 SELF_CHECK (check_find_bounds_finds
4182 (mock_index
, "\377\377", expected_syms2
,
4183 NULL
/* per_objfile */));
4187 /* Test dw2_expand_symtabs_matching_symbol. */
4190 test_dw2_expand_symtabs_matching_symbol ()
4192 mock_mapped_index
mock_index (test_symbols
);
4194 /* We let all tests run until the end even if some fails, for debug
4196 bool any_mismatch
= false;
4198 /* Create the expected symbols list (an initializer_list). Needed
4199 because lists have commas, and we need to pass them to CHECK,
4200 which is a macro. */
4201 #define EXPECT(...) { __VA_ARGS__ }
4203 /* Wrapper for check_match that passes down the current
4204 __FILE__/__LINE__. */
4205 #define CHECK_MATCH(NAME, MATCH_TYPE, COMPLETION_MODE, EXPECTED_LIST) \
4206 any_mismatch |= !check_match (__FILE__, __LINE__, \
4208 NAME, MATCH_TYPE, COMPLETION_MODE, \
4209 EXPECTED_LIST, NULL)
4211 /* Identity checks. */
4212 for (const char *sym
: test_symbols
)
4214 /* Should be able to match all existing symbols. */
4215 CHECK_MATCH (sym
, symbol_name_match_type::FULL
, false,
4218 /* Should be able to match all existing symbols with
4220 std::string with_params
= std::string (sym
) + "(int)";
4221 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
4224 /* Should be able to match all existing symbols with
4225 parameters and qualifiers. */
4226 with_params
= std::string (sym
) + " ( int ) const";
4227 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
4230 /* This should really find sym, but cp-name-parser.y doesn't
4231 know about lvalue/rvalue qualifiers yet. */
4232 with_params
= std::string (sym
) + " ( int ) &&";
4233 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
4237 /* Check that the name matching algorithm for completion doesn't get
4238 confused with Latin1 'ÿ' / 0xff. */
4240 static const char str
[] = "\377";
4241 CHECK_MATCH (str
, symbol_name_match_type::FULL
, true,
4242 EXPECT ("\377", "\377\377123"));
4245 /* Check that the increment-last-char in the matching algorithm for
4246 completion doesn't match "t1_fund" when completing "t1_func". */
4248 static const char str
[] = "t1_func";
4249 CHECK_MATCH (str
, symbol_name_match_type::FULL
, true,
4250 EXPECT ("t1_func", "t1_func1"));
4253 /* Check that completion mode works at each prefix of the expected
4256 static const char str
[] = "function(int)";
4257 size_t len
= strlen (str
);
4260 for (size_t i
= 1; i
< len
; i
++)
4262 lookup
.assign (str
, i
);
4263 CHECK_MATCH (lookup
.c_str (), symbol_name_match_type::FULL
, true,
4264 EXPECT ("function"));
4268 /* While "w" is a prefix of both components, the match function
4269 should still only be called once. */
4271 CHECK_MATCH ("w", symbol_name_match_type::FULL
, true,
4273 CHECK_MATCH ("w", symbol_name_match_type::WILD
, true,
4277 /* Same, with a "complicated" symbol. */
4279 static const char str
[] = Z_SYM_NAME
;
4280 size_t len
= strlen (str
);
4283 for (size_t i
= 1; i
< len
; i
++)
4285 lookup
.assign (str
, i
);
4286 CHECK_MATCH (lookup
.c_str (), symbol_name_match_type::FULL
, true,
4287 EXPECT (Z_SYM_NAME
));
4291 /* In FULL mode, an incomplete symbol doesn't match. */
4293 CHECK_MATCH ("std::zfunction(int", symbol_name_match_type::FULL
, false,
4297 /* A complete symbol with parameters matches any overload, since the
4298 index has no overload info. */
4300 CHECK_MATCH ("std::zfunction(int)", symbol_name_match_type::FULL
, true,
4301 EXPECT ("std::zfunction", "std::zfunction2"));
4302 CHECK_MATCH ("zfunction(int)", symbol_name_match_type::WILD
, true,
4303 EXPECT ("std::zfunction", "std::zfunction2"));
4304 CHECK_MATCH ("zfunc", symbol_name_match_type::WILD
, true,
4305 EXPECT ("std::zfunction", "std::zfunction2"));
4308 /* Check that whitespace is ignored appropriately. A symbol with a
4309 template argument list. */
4311 static const char expected
[] = "ns::foo<int>";
4312 CHECK_MATCH ("ns :: foo < int > ", symbol_name_match_type::FULL
, false,
4314 CHECK_MATCH ("foo < int > ", symbol_name_match_type::WILD
, false,
4318 /* Check that whitespace is ignored appropriately. A symbol with a
4319 template argument list that includes a pointer. */
4321 static const char expected
[] = "ns::foo<char*>";
4322 /* Try both completion and non-completion modes. */
4323 static const bool completion_mode
[2] = {false, true};
4324 for (size_t i
= 0; i
< 2; i
++)
4326 CHECK_MATCH ("ns :: foo < char * >", symbol_name_match_type::FULL
,
4327 completion_mode
[i
], EXPECT (expected
));
4328 CHECK_MATCH ("foo < char * >", symbol_name_match_type::WILD
,
4329 completion_mode
[i
], EXPECT (expected
));
4331 CHECK_MATCH ("ns :: foo < char * > (int)", symbol_name_match_type::FULL
,
4332 completion_mode
[i
], EXPECT (expected
));
4333 CHECK_MATCH ("foo < char * > (int)", symbol_name_match_type::WILD
,
4334 completion_mode
[i
], EXPECT (expected
));
4339 /* Check method qualifiers are ignored. */
4340 static const char expected
[] = "ns::foo<char*>";
4341 CHECK_MATCH ("ns :: foo < char * > ( int ) const",
4342 symbol_name_match_type::FULL
, true, EXPECT (expected
));
4343 CHECK_MATCH ("ns :: foo < char * > ( int ) &&",
4344 symbol_name_match_type::FULL
, true, EXPECT (expected
));
4345 CHECK_MATCH ("foo < char * > ( int ) const",
4346 symbol_name_match_type::WILD
, true, EXPECT (expected
));
4347 CHECK_MATCH ("foo < char * > ( int ) &&",
4348 symbol_name_match_type::WILD
, true, EXPECT (expected
));
4351 /* Test lookup names that don't match anything. */
4353 CHECK_MATCH ("bar2", symbol_name_match_type::WILD
, false,
4356 CHECK_MATCH ("doesntexist", symbol_name_match_type::FULL
, false,
4360 /* Some wild matching tests, exercising "(anonymous namespace)",
4361 which should not be confused with a parameter list. */
4363 static const char *syms
[] = {
4367 "A :: B :: C ( int )",
4372 for (const char *s
: syms
)
4374 CHECK_MATCH (s
, symbol_name_match_type::WILD
, false,
4375 EXPECT ("(anonymous namespace)::A::B::C"));
4380 static const char expected
[] = "ns2::tmpl<int>::foo2";
4381 CHECK_MATCH ("tmp", symbol_name_match_type::WILD
, true,
4383 CHECK_MATCH ("tmpl<", symbol_name_match_type::WILD
, true,
4387 SELF_CHECK (!any_mismatch
);
4396 test_mapped_index_find_name_component_bounds ();
4397 test_dw2_expand_symtabs_matching_symbol ();
4400 }} // namespace selftests::dw2_expand_symtabs_matching
4402 #endif /* GDB_SELF_TEST */
4404 /* If FILE_MATCHER is NULL or if PER_CU has
4405 dwarf2_per_cu_quick_data::MARK set (see
4406 dw_expand_symtabs_matching_file_matcher), expand the CU and call
4407 EXPANSION_NOTIFY on it. */
4410 dw2_expand_symtabs_matching_one
4411 (dwarf2_per_cu_data
*per_cu
,
4412 dwarf2_per_objfile
*per_objfile
,
4413 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
4414 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
)
4416 if (file_matcher
== NULL
|| per_cu
->v
.quick
->mark
)
4418 bool symtab_was_null
= !per_objfile
->symtab_set_p (per_cu
);
4420 compunit_symtab
*symtab
4421 = dw2_instantiate_symtab (per_cu
, per_objfile
, false);
4422 gdb_assert (symtab
!= nullptr);
4424 if (expansion_notify
!= NULL
&& symtab_was_null
)
4425 return expansion_notify (symtab
);
4430 /* Helper for dw2_expand_matching symtabs. Called on each symbol
4431 matched, to expand corresponding CUs that were marked. IDX is the
4432 index of the symbol name that matched. */
4435 dw2_expand_marked_cus
4436 (dwarf2_per_objfile
*per_objfile
, offset_type idx
,
4437 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
4438 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
4439 block_search_flags search_flags
,
4442 offset_type
*vec
, vec_len
, vec_idx
;
4443 bool global_seen
= false;
4444 mapped_index
&index
= *per_objfile
->per_bfd
->index_table
;
4446 vec
= (offset_type
*) (index
.constant_pool
4447 + MAYBE_SWAP (index
.symbol_table
[idx
].vec
));
4448 vec_len
= MAYBE_SWAP (vec
[0]);
4449 for (vec_idx
= 0; vec_idx
< vec_len
; ++vec_idx
)
4451 offset_type cu_index_and_attrs
= MAYBE_SWAP (vec
[vec_idx
+ 1]);
4452 /* This value is only valid for index versions >= 7. */
4453 int is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs
);
4454 gdb_index_symbol_kind symbol_kind
=
4455 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
4456 int cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
4457 /* Only check the symbol attributes if they're present.
4458 Indices prior to version 7 don't record them,
4459 and indices >= 7 may elide them for certain symbols
4460 (gold does this). */
4463 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_NONE
);
4465 /* Work around gold/15646. */
4468 && symbol_kind
== GDB_INDEX_SYMBOL_KIND_TYPE
)
4476 /* Only check the symbol's kind if it has one. */
4481 if ((search_flags
& SEARCH_STATIC_BLOCK
) == 0)
4486 if ((search_flags
& SEARCH_GLOBAL_BLOCK
) == 0)
4492 case VARIABLES_DOMAIN
:
4493 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
)
4496 case FUNCTIONS_DOMAIN
:
4497 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
)
4501 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
4504 case MODULES_DOMAIN
:
4505 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_OTHER
)
4513 /* Don't crash on bad data. */
4514 if (cu_index
>= (per_objfile
->per_bfd
->all_comp_units
.size ()
4515 + per_objfile
->per_bfd
->all_type_units
.size ()))
4517 complaint (_(".gdb_index entry has bad CU index"
4518 " [in module %s]"), objfile_name (per_objfile
->objfile
));
4522 dwarf2_per_cu_data
*per_cu
= per_objfile
->per_bfd
->get_cutu (cu_index
);
4523 if (!dw2_expand_symtabs_matching_one (per_cu
, per_objfile
, file_matcher
,
4531 /* If FILE_MATCHER is non-NULL, set all the
4532 dwarf2_per_cu_quick_data::MARK of the current DWARF2_PER_OBJFILE
4533 that match FILE_MATCHER. */
4536 dw_expand_symtabs_matching_file_matcher
4537 (dwarf2_per_objfile
*per_objfile
,
4538 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
)
4540 if (file_matcher
== NULL
)
4543 htab_up
visited_found (htab_create_alloc (10, htab_hash_pointer
,
4545 NULL
, xcalloc
, xfree
));
4546 htab_up
visited_not_found (htab_create_alloc (10, htab_hash_pointer
,
4548 NULL
, xcalloc
, xfree
));
4550 /* The rule is CUs specify all the files, including those used by
4551 any TU, so there's no need to scan TUs here. */
4553 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
4557 per_cu
->v
.quick
->mark
= 0;
4559 /* We only need to look at symtabs not already expanded. */
4560 if (per_objfile
->symtab_set_p (per_cu
))
4563 quick_file_names
*file_data
= dw2_get_file_names (per_cu
, per_objfile
);
4564 if (file_data
== NULL
)
4567 if (htab_find (visited_not_found
.get (), file_data
) != NULL
)
4569 else if (htab_find (visited_found
.get (), file_data
) != NULL
)
4571 per_cu
->v
.quick
->mark
= 1;
4575 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
4577 const char *this_real_name
;
4579 if (file_matcher (file_data
->file_names
[j
], false))
4581 per_cu
->v
.quick
->mark
= 1;
4585 /* Before we invoke realpath, which can get expensive when many
4586 files are involved, do a quick comparison of the basenames. */
4587 if (!basenames_may_differ
4588 && !file_matcher (lbasename (file_data
->file_names
[j
]),
4592 this_real_name
= dw2_get_real_path (per_objfile
, file_data
, j
);
4593 if (file_matcher (this_real_name
, false))
4595 per_cu
->v
.quick
->mark
= 1;
4600 void **slot
= htab_find_slot (per_cu
->v
.quick
->mark
4601 ? visited_found
.get ()
4602 : visited_not_found
.get (),
4609 dwarf2_gdb_index::expand_symtabs_matching
4610 (struct objfile
*objfile
,
4611 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
4612 const lookup_name_info
*lookup_name
,
4613 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
4614 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
4615 block_search_flags search_flags
,
4617 enum search_domain kind
)
4619 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
4621 /* index_table is NULL if OBJF_READNOW. */
4622 if (!per_objfile
->per_bfd
->index_table
)
4625 dw_expand_symtabs_matching_file_matcher (per_objfile
, file_matcher
);
4627 if (symbol_matcher
== NULL
&& lookup_name
== NULL
)
4629 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
4633 if (!dw2_expand_symtabs_matching_one (per_cu
, per_objfile
,
4641 mapped_index
&index
= *per_objfile
->per_bfd
->index_table
;
4644 = dw2_expand_symtabs_matching_symbol (index
, *lookup_name
,
4646 [&] (offset_type idx
)
4648 if (!dw2_expand_marked_cus (per_objfile
, idx
, file_matcher
,
4649 expansion_notify
, search_flags
, kind
))
4657 /* A helper for dw2_find_pc_sect_compunit_symtab which finds the most specific
4660 static struct compunit_symtab
*
4661 recursively_find_pc_sect_compunit_symtab (struct compunit_symtab
*cust
,
4666 if (COMPUNIT_BLOCKVECTOR (cust
) != NULL
4667 && blockvector_contains_pc (COMPUNIT_BLOCKVECTOR (cust
), pc
))
4670 if (cust
->includes
== NULL
)
4673 for (i
= 0; cust
->includes
[i
]; ++i
)
4675 struct compunit_symtab
*s
= cust
->includes
[i
];
4677 s
= recursively_find_pc_sect_compunit_symtab (s
, pc
);
4685 struct compunit_symtab
*
4686 dwarf2_base_index_functions::find_pc_sect_compunit_symtab
4687 (struct objfile
*objfile
,
4688 struct bound_minimal_symbol msymbol
,
4690 struct obj_section
*section
,
4693 struct dwarf2_per_cu_data
*data
;
4694 struct compunit_symtab
*result
;
4696 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
4697 if (per_objfile
->per_bfd
->index_addrmap
== nullptr)
4700 CORE_ADDR baseaddr
= objfile
->text_section_offset ();
4701 data
= ((struct dwarf2_per_cu_data
*)
4702 addrmap_find (per_objfile
->per_bfd
->index_addrmap
,
4707 if (warn_if_readin
&& per_objfile
->symtab_set_p (data
))
4708 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
4709 paddress (objfile
->arch (), pc
));
4711 result
= recursively_find_pc_sect_compunit_symtab
4712 (dw2_instantiate_symtab (data
, per_objfile
, false), pc
);
4714 gdb_assert (result
!= NULL
);
4719 dwarf2_base_index_functions::map_symbol_filenames
4720 (struct objfile
*objfile
,
4721 gdb::function_view
<symbol_filename_ftype
> fun
,
4724 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
4726 if (!per_objfile
->per_bfd
->filenames_cache
)
4728 per_objfile
->per_bfd
->filenames_cache
.emplace ();
4730 htab_up
visited (htab_create_alloc (10,
4731 htab_hash_pointer
, htab_eq_pointer
,
4732 NULL
, xcalloc
, xfree
));
4734 /* The rule is CUs specify all the files, including those used
4735 by any TU, so there's no need to scan TUs here. We can
4736 ignore file names coming from already-expanded CUs. */
4738 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
4740 if (per_objfile
->symtab_set_p (per_cu
))
4742 void **slot
= htab_find_slot (visited
.get (),
4743 per_cu
->v
.quick
->file_names
,
4746 *slot
= per_cu
->v
.quick
->file_names
;
4750 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
4752 /* We only need to look at symtabs not already expanded. */
4753 if (per_objfile
->symtab_set_p (per_cu
))
4756 quick_file_names
*file_data
4757 = dw2_get_file_names (per_cu
, per_objfile
);
4758 if (file_data
== NULL
)
4761 void **slot
= htab_find_slot (visited
.get (), file_data
, INSERT
);
4764 /* Already visited. */
4769 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
4771 const char *filename
= file_data
->file_names
[j
];
4772 per_objfile
->per_bfd
->filenames_cache
->seen (filename
);
4777 per_objfile
->per_bfd
->filenames_cache
->traverse ([&] (const char *filename
)
4779 gdb::unique_xmalloc_ptr
<char> this_real_name
;
4782 this_real_name
= gdb_realpath (filename
);
4783 fun (filename
, this_real_name
.get ());
4788 dwarf2_base_index_functions::has_symbols (struct objfile
*objfile
)
4793 /* DWARF-5 debug_names reader. */
4795 /* DWARF-5 augmentation string for GDB's DW_IDX_GNU_* extension. */
4796 static const gdb_byte dwarf5_augmentation
[] = { 'G', 'D', 'B', 0 };
4798 /* A helper function that reads the .debug_names section in SECTION
4799 and fills in MAP. FILENAME is the name of the file containing the
4800 section; it is used for error reporting.
4802 Returns true if all went well, false otherwise. */
4805 read_debug_names_from_section (struct objfile
*objfile
,
4806 const char *filename
,
4807 struct dwarf2_section_info
*section
,
4808 mapped_debug_names
&map
)
4810 if (section
->empty ())
4813 /* Older elfutils strip versions could keep the section in the main
4814 executable while splitting it for the separate debug info file. */
4815 if ((section
->get_flags () & SEC_HAS_CONTENTS
) == 0)
4818 section
->read (objfile
);
4820 map
.dwarf5_byte_order
= gdbarch_byte_order (objfile
->arch ());
4822 const gdb_byte
*addr
= section
->buffer
;
4824 bfd
*const abfd
= section
->get_bfd_owner ();
4826 unsigned int bytes_read
;
4827 LONGEST length
= read_initial_length (abfd
, addr
, &bytes_read
);
4830 map
.dwarf5_is_dwarf64
= bytes_read
!= 4;
4831 map
.offset_size
= map
.dwarf5_is_dwarf64
? 8 : 4;
4832 if (bytes_read
+ length
!= section
->size
)
4834 /* There may be multiple per-CU indices. */
4835 warning (_("Section .debug_names in %s length %s does not match "
4836 "section length %s, ignoring .debug_names."),
4837 filename
, plongest (bytes_read
+ length
),
4838 pulongest (section
->size
));
4842 /* The version number. */
4843 uint16_t version
= read_2_bytes (abfd
, addr
);
4847 warning (_("Section .debug_names in %s has unsupported version %d, "
4848 "ignoring .debug_names."),
4854 uint16_t padding
= read_2_bytes (abfd
, addr
);
4858 warning (_("Section .debug_names in %s has unsupported padding %d, "
4859 "ignoring .debug_names."),
4864 /* comp_unit_count - The number of CUs in the CU list. */
4865 map
.cu_count
= read_4_bytes (abfd
, addr
);
4868 /* local_type_unit_count - The number of TUs in the local TU
4870 map
.tu_count
= read_4_bytes (abfd
, addr
);
4873 /* foreign_type_unit_count - The number of TUs in the foreign TU
4875 uint32_t foreign_tu_count
= read_4_bytes (abfd
, addr
);
4877 if (foreign_tu_count
!= 0)
4879 warning (_("Section .debug_names in %s has unsupported %lu foreign TUs, "
4880 "ignoring .debug_names."),
4881 filename
, static_cast<unsigned long> (foreign_tu_count
));
4885 /* bucket_count - The number of hash buckets in the hash lookup
4887 map
.bucket_count
= read_4_bytes (abfd
, addr
);
4890 /* name_count - The number of unique names in the index. */
4891 map
.name_count
= read_4_bytes (abfd
, addr
);
4894 /* abbrev_table_size - The size in bytes of the abbreviations
4896 uint32_t abbrev_table_size
= read_4_bytes (abfd
, addr
);
4899 /* augmentation_string_size - The size in bytes of the augmentation
4900 string. This value is rounded up to a multiple of 4. */
4901 uint32_t augmentation_string_size
= read_4_bytes (abfd
, addr
);
4903 map
.augmentation_is_gdb
= ((augmentation_string_size
4904 == sizeof (dwarf5_augmentation
))
4905 && memcmp (addr
, dwarf5_augmentation
,
4906 sizeof (dwarf5_augmentation
)) == 0);
4907 augmentation_string_size
+= (-augmentation_string_size
) & 3;
4908 addr
+= augmentation_string_size
;
4911 map
.cu_table_reordered
= addr
;
4912 addr
+= map
.cu_count
* map
.offset_size
;
4914 /* List of Local TUs */
4915 map
.tu_table_reordered
= addr
;
4916 addr
+= map
.tu_count
* map
.offset_size
;
4918 /* Hash Lookup Table */
4919 map
.bucket_table_reordered
= reinterpret_cast<const uint32_t *> (addr
);
4920 addr
+= map
.bucket_count
* 4;
4921 map
.hash_table_reordered
= reinterpret_cast<const uint32_t *> (addr
);
4922 addr
+= map
.name_count
* 4;
4925 map
.name_table_string_offs_reordered
= addr
;
4926 addr
+= map
.name_count
* map
.offset_size
;
4927 map
.name_table_entry_offs_reordered
= addr
;
4928 addr
+= map
.name_count
* map
.offset_size
;
4930 const gdb_byte
*abbrev_table_start
= addr
;
4933 const ULONGEST index_num
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
4938 const auto insertpair
4939 = map
.abbrev_map
.emplace (index_num
, mapped_debug_names::index_val ());
4940 if (!insertpair
.second
)
4942 warning (_("Section .debug_names in %s has duplicate index %s, "
4943 "ignoring .debug_names."),
4944 filename
, pulongest (index_num
));
4947 mapped_debug_names::index_val
&indexval
= insertpair
.first
->second
;
4948 indexval
.dwarf_tag
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
4953 mapped_debug_names::index_val::attr attr
;
4954 attr
.dw_idx
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
4956 attr
.form
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
4958 if (attr
.form
== DW_FORM_implicit_const
)
4960 attr
.implicit_const
= read_signed_leb128 (abfd
, addr
,
4964 if (attr
.dw_idx
== 0 && attr
.form
== 0)
4966 indexval
.attr_vec
.push_back (std::move (attr
));
4969 if (addr
!= abbrev_table_start
+ abbrev_table_size
)
4971 warning (_("Section .debug_names in %s has abbreviation_table "
4972 "of size %s vs. written as %u, ignoring .debug_names."),
4973 filename
, plongest (addr
- abbrev_table_start
),
4977 map
.entry_pool
= addr
;
4982 /* A helper for create_cus_from_debug_names that handles the MAP's CU
4986 create_cus_from_debug_names_list (dwarf2_per_bfd
*per_bfd
,
4987 const mapped_debug_names
&map
,
4988 dwarf2_section_info
§ion
,
4991 if (!map
.augmentation_is_gdb
)
4993 for (uint32_t i
= 0; i
< map
.cu_count
; ++i
)
4995 sect_offset sect_off
4996 = (sect_offset
) (extract_unsigned_integer
4997 (map
.cu_table_reordered
+ i
* map
.offset_size
,
4999 map
.dwarf5_byte_order
));
5000 /* We don't know the length of the CU, because the CU list in a
5001 .debug_names index can be incomplete, so we can't use the start
5002 of the next CU as end of this CU. We create the CUs here with
5003 length 0, and in cutu_reader::cutu_reader we'll fill in the
5005 dwarf2_per_cu_data
*per_cu
5006 = create_cu_from_index_list (per_bfd
, §ion
, is_dwz
,
5008 per_bfd
->all_comp_units
.push_back (per_cu
);
5013 sect_offset sect_off_prev
;
5014 for (uint32_t i
= 0; i
<= map
.cu_count
; ++i
)
5016 sect_offset sect_off_next
;
5017 if (i
< map
.cu_count
)
5020 = (sect_offset
) (extract_unsigned_integer
5021 (map
.cu_table_reordered
+ i
* map
.offset_size
,
5023 map
.dwarf5_byte_order
));
5026 sect_off_next
= (sect_offset
) section
.size
;
5029 const ULONGEST length
= sect_off_next
- sect_off_prev
;
5030 dwarf2_per_cu_data
*per_cu
5031 = create_cu_from_index_list (per_bfd
, §ion
, is_dwz
,
5032 sect_off_prev
, length
);
5033 per_bfd
->all_comp_units
.push_back (per_cu
);
5035 sect_off_prev
= sect_off_next
;
5039 /* Read the CU list from the mapped index, and use it to create all
5040 the CU objects for this dwarf2_per_objfile. */
5043 create_cus_from_debug_names (dwarf2_per_bfd
*per_bfd
,
5044 const mapped_debug_names
&map
,
5045 const mapped_debug_names
&dwz_map
)
5047 gdb_assert (per_bfd
->all_comp_units
.empty ());
5048 per_bfd
->all_comp_units
.reserve (map
.cu_count
+ dwz_map
.cu_count
);
5050 create_cus_from_debug_names_list (per_bfd
, map
, per_bfd
->info
,
5051 false /* is_dwz */);
5053 if (dwz_map
.cu_count
== 0)
5056 dwz_file
*dwz
= dwarf2_get_dwz_file (per_bfd
);
5057 create_cus_from_debug_names_list (per_bfd
, dwz_map
, dwz
->info
,
5061 /* Read .debug_names. If everything went ok, initialize the "quick"
5062 elements of all the CUs and return true. Otherwise, return false. */
5065 dwarf2_read_debug_names (dwarf2_per_objfile
*per_objfile
)
5067 std::unique_ptr
<mapped_debug_names
> map (new mapped_debug_names
);
5068 mapped_debug_names dwz_map
;
5069 struct objfile
*objfile
= per_objfile
->objfile
;
5070 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
5072 if (!read_debug_names_from_section (objfile
, objfile_name (objfile
),
5073 &per_bfd
->debug_names
, *map
))
5076 /* Don't use the index if it's empty. */
5077 if (map
->name_count
== 0)
5080 /* If there is a .dwz file, read it so we can get its CU list as
5082 dwz_file
*dwz
= dwarf2_get_dwz_file (per_bfd
);
5085 if (!read_debug_names_from_section (objfile
,
5086 bfd_get_filename (dwz
->dwz_bfd
.get ()),
5087 &dwz
->debug_names
, dwz_map
))
5089 warning (_("could not read '.debug_names' section from %s; skipping"),
5090 bfd_get_filename (dwz
->dwz_bfd
.get ()));
5095 create_cus_from_debug_names (per_bfd
, *map
, dwz_map
);
5097 if (map
->tu_count
!= 0)
5099 /* We can only handle a single .debug_types when we have an
5101 if (per_bfd
->types
.size () != 1)
5104 dwarf2_section_info
*section
= &per_bfd
->types
[0];
5106 create_signatured_type_table_from_debug_names
5107 (per_objfile
, *map
, section
, &per_bfd
->abbrev
);
5110 create_addrmap_from_aranges (per_objfile
, &per_bfd
->debug_aranges
);
5112 per_bfd
->debug_names_table
= std::move (map
);
5113 per_bfd
->using_index
= 1;
5114 per_bfd
->quick_file_names_table
=
5115 create_quick_file_names_table (per_bfd
->all_comp_units
.size ());
5120 /* Type used to manage iterating over all CUs looking for a symbol for
5123 class dw2_debug_names_iterator
5126 dw2_debug_names_iterator (const mapped_debug_names
&map
,
5127 block_search_flags block_index
,
5129 const char *name
, dwarf2_per_objfile
*per_objfile
)
5130 : m_map (map
), m_block_index (block_index
), m_domain (domain
),
5131 m_addr (find_vec_in_debug_names (map
, name
, per_objfile
)),
5132 m_per_objfile (per_objfile
)
5135 dw2_debug_names_iterator (const mapped_debug_names
&map
,
5136 search_domain search
, uint32_t namei
,
5137 dwarf2_per_objfile
*per_objfile
,
5138 domain_enum domain
= UNDEF_DOMAIN
)
5142 m_addr (find_vec_in_debug_names (map
, namei
, per_objfile
)),
5143 m_per_objfile (per_objfile
)
5146 dw2_debug_names_iterator (const mapped_debug_names
&map
,
5147 block_search_flags block_index
, domain_enum domain
,
5148 uint32_t namei
, dwarf2_per_objfile
*per_objfile
)
5149 : m_map (map
), m_block_index (block_index
), m_domain (domain
),
5150 m_addr (find_vec_in_debug_names (map
, namei
, per_objfile
)),
5151 m_per_objfile (per_objfile
)
5154 /* Return the next matching CU or NULL if there are no more. */
5155 dwarf2_per_cu_data
*next ();
5158 static const gdb_byte
*find_vec_in_debug_names (const mapped_debug_names
&map
,
5160 dwarf2_per_objfile
*per_objfile
);
5161 static const gdb_byte
*find_vec_in_debug_names (const mapped_debug_names
&map
,
5163 dwarf2_per_objfile
*per_objfile
);
5165 /* The internalized form of .debug_names. */
5166 const mapped_debug_names
&m_map
;
5168 /* Restrict the search to these blocks. */
5169 block_search_flags m_block_index
= (SEARCH_GLOBAL_BLOCK
5170 | SEARCH_STATIC_BLOCK
);
5172 /* The kind of symbol we're looking for. */
5173 const domain_enum m_domain
= UNDEF_DOMAIN
;
5174 const search_domain m_search
= ALL_DOMAIN
;
5176 /* The list of CUs from the index entry of the symbol, or NULL if
5178 const gdb_byte
*m_addr
;
5180 dwarf2_per_objfile
*m_per_objfile
;
5184 mapped_debug_names::namei_to_name
5185 (uint32_t namei
, dwarf2_per_objfile
*per_objfile
) const
5187 const ULONGEST namei_string_offs
5188 = extract_unsigned_integer ((name_table_string_offs_reordered
5189 + namei
* offset_size
),
5192 return read_indirect_string_at_offset (per_objfile
, namei_string_offs
);
5195 /* Find a slot in .debug_names for the object named NAME. If NAME is
5196 found, return pointer to its pool data. If NAME cannot be found,
5200 dw2_debug_names_iterator::find_vec_in_debug_names
5201 (const mapped_debug_names
&map
, const char *name
,
5202 dwarf2_per_objfile
*per_objfile
)
5204 int (*cmp
) (const char *, const char *);
5206 gdb::unique_xmalloc_ptr
<char> without_params
;
5207 if (current_language
->la_language
== language_cplus
5208 || current_language
->la_language
== language_fortran
5209 || current_language
->la_language
== language_d
)
5211 /* NAME is already canonical. Drop any qualifiers as
5212 .debug_names does not contain any. */
5214 if (strchr (name
, '(') != NULL
)
5216 without_params
= cp_remove_params (name
);
5217 if (without_params
!= NULL
)
5218 name
= without_params
.get ();
5222 cmp
= (case_sensitivity
== case_sensitive_on
? strcmp
: strcasecmp
);
5224 const uint32_t full_hash
= dwarf5_djb_hash (name
);
5226 = extract_unsigned_integer (reinterpret_cast<const gdb_byte
*>
5227 (map
.bucket_table_reordered
5228 + (full_hash
% map
.bucket_count
)), 4,
5229 map
.dwarf5_byte_order
);
5233 if (namei
>= map
.name_count
)
5235 complaint (_("Wrong .debug_names with name index %u but name_count=%u "
5237 namei
, map
.name_count
,
5238 objfile_name (per_objfile
->objfile
));
5244 const uint32_t namei_full_hash
5245 = extract_unsigned_integer (reinterpret_cast<const gdb_byte
*>
5246 (map
.hash_table_reordered
+ namei
), 4,
5247 map
.dwarf5_byte_order
);
5248 if (full_hash
% map
.bucket_count
!= namei_full_hash
% map
.bucket_count
)
5251 if (full_hash
== namei_full_hash
)
5253 const char *const namei_string
= map
.namei_to_name (namei
, per_objfile
);
5255 #if 0 /* An expensive sanity check. */
5256 if (namei_full_hash
!= dwarf5_djb_hash (namei_string
))
5258 complaint (_("Wrong .debug_names hash for string at index %u "
5260 namei
, objfile_name (dwarf2_per_objfile
->objfile
));
5265 if (cmp (namei_string
, name
) == 0)
5267 const ULONGEST namei_entry_offs
5268 = extract_unsigned_integer ((map
.name_table_entry_offs_reordered
5269 + namei
* map
.offset_size
),
5270 map
.offset_size
, map
.dwarf5_byte_order
);
5271 return map
.entry_pool
+ namei_entry_offs
;
5276 if (namei
>= map
.name_count
)
5282 dw2_debug_names_iterator::find_vec_in_debug_names
5283 (const mapped_debug_names
&map
, uint32_t namei
, dwarf2_per_objfile
*per_objfile
)
5285 if (namei
>= map
.name_count
)
5287 complaint (_("Wrong .debug_names with name index %u but name_count=%u "
5289 namei
, map
.name_count
,
5290 objfile_name (per_objfile
->objfile
));
5294 const ULONGEST namei_entry_offs
5295 = extract_unsigned_integer ((map
.name_table_entry_offs_reordered
5296 + namei
* map
.offset_size
),
5297 map
.offset_size
, map
.dwarf5_byte_order
);
5298 return map
.entry_pool
+ namei_entry_offs
;
5301 /* See dw2_debug_names_iterator. */
5303 dwarf2_per_cu_data
*
5304 dw2_debug_names_iterator::next ()
5309 dwarf2_per_bfd
*per_bfd
= m_per_objfile
->per_bfd
;
5310 struct objfile
*objfile
= m_per_objfile
->objfile
;
5311 bfd
*const abfd
= objfile
->obfd
;
5315 unsigned int bytes_read
;
5316 const ULONGEST abbrev
= read_unsigned_leb128 (abfd
, m_addr
, &bytes_read
);
5317 m_addr
+= bytes_read
;
5321 const auto indexval_it
= m_map
.abbrev_map
.find (abbrev
);
5322 if (indexval_it
== m_map
.abbrev_map
.cend ())
5324 complaint (_("Wrong .debug_names undefined abbrev code %s "
5326 pulongest (abbrev
), objfile_name (objfile
));
5329 const mapped_debug_names::index_val
&indexval
= indexval_it
->second
;
5330 enum class symbol_linkage
{
5334 } symbol_linkage_
= symbol_linkage::unknown
;
5335 dwarf2_per_cu_data
*per_cu
= NULL
;
5336 for (const mapped_debug_names::index_val::attr
&attr
: indexval
.attr_vec
)
5341 case DW_FORM_implicit_const
:
5342 ull
= attr
.implicit_const
;
5344 case DW_FORM_flag_present
:
5348 ull
= read_unsigned_leb128 (abfd
, m_addr
, &bytes_read
);
5349 m_addr
+= bytes_read
;
5352 ull
= read_4_bytes (abfd
, m_addr
);
5356 ull
= read_8_bytes (abfd
, m_addr
);
5359 case DW_FORM_ref_sig8
:
5360 ull
= read_8_bytes (abfd
, m_addr
);
5364 complaint (_("Unsupported .debug_names form %s [in module %s]"),
5365 dwarf_form_name (attr
.form
),
5366 objfile_name (objfile
));
5369 switch (attr
.dw_idx
)
5371 case DW_IDX_compile_unit
:
5372 /* Don't crash on bad data. */
5373 if (ull
>= per_bfd
->all_comp_units
.size ())
5375 complaint (_(".debug_names entry has bad CU index %s"
5378 objfile_name (objfile
));
5381 per_cu
= per_bfd
->get_cutu (ull
);
5383 case DW_IDX_type_unit
:
5384 /* Don't crash on bad data. */
5385 if (ull
>= per_bfd
->all_type_units
.size ())
5387 complaint (_(".debug_names entry has bad TU index %s"
5390 objfile_name (objfile
));
5393 per_cu
= &per_bfd
->get_tu (ull
)->per_cu
;
5395 case DW_IDX_die_offset
:
5396 /* In a per-CU index (as opposed to a per-module index), index
5397 entries without CU attribute implicitly refer to the single CU. */
5399 per_cu
= per_bfd
->get_cu (0);
5401 case DW_IDX_GNU_internal
:
5402 if (!m_map
.augmentation_is_gdb
)
5404 symbol_linkage_
= symbol_linkage::static_
;
5406 case DW_IDX_GNU_external
:
5407 if (!m_map
.augmentation_is_gdb
)
5409 symbol_linkage_
= symbol_linkage::extern_
;
5414 /* Skip if already read in. */
5415 if (m_per_objfile
->symtab_set_p (per_cu
))
5418 /* Check static vs global. */
5419 if (symbol_linkage_
!= symbol_linkage::unknown
)
5421 if (symbol_linkage_
== symbol_linkage::static_
)
5423 if ((m_block_index
& SEARCH_STATIC_BLOCK
) == 0)
5428 if ((m_block_index
& SEARCH_GLOBAL_BLOCK
) == 0)
5433 /* Match dw2_symtab_iter_next, symbol_kind
5434 and debug_names::psymbol_tag. */
5438 switch (indexval
.dwarf_tag
)
5440 case DW_TAG_variable
:
5441 case DW_TAG_subprogram
:
5442 /* Some types are also in VAR_DOMAIN. */
5443 case DW_TAG_typedef
:
5444 case DW_TAG_structure_type
:
5451 switch (indexval
.dwarf_tag
)
5453 case DW_TAG_typedef
:
5454 case DW_TAG_structure_type
:
5461 switch (indexval
.dwarf_tag
)
5464 case DW_TAG_variable
:
5471 switch (indexval
.dwarf_tag
)
5483 /* Match dw2_expand_symtabs_matching, symbol_kind and
5484 debug_names::psymbol_tag. */
5487 case VARIABLES_DOMAIN
:
5488 switch (indexval
.dwarf_tag
)
5490 case DW_TAG_variable
:
5496 case FUNCTIONS_DOMAIN
:
5497 switch (indexval
.dwarf_tag
)
5499 case DW_TAG_subprogram
:
5506 switch (indexval
.dwarf_tag
)
5508 case DW_TAG_typedef
:
5509 case DW_TAG_structure_type
:
5515 case MODULES_DOMAIN
:
5516 switch (indexval
.dwarf_tag
)
5530 /* This dumps minimal information about .debug_names. It is called
5531 via "mt print objfiles". The gdb.dwarf2/gdb-index.exp testcase
5532 uses this to verify that .debug_names has been loaded. */
5535 dwarf2_debug_names_index::dump (struct objfile
*objfile
)
5537 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
5539 gdb_assert (per_objfile
->per_bfd
->using_index
);
5540 printf_filtered (".debug_names:");
5541 if (per_objfile
->per_bfd
->debug_names_table
)
5542 printf_filtered (" exists\n");
5544 printf_filtered (" faked for \"readnow\"\n");
5545 printf_filtered ("\n");
5549 dwarf2_debug_names_index::map_matching_symbols
5550 (struct objfile
*objfile
,
5551 const lookup_name_info
&name
, domain_enum domain
,
5553 gdb::function_view
<symbol_found_callback_ftype
> callback
,
5554 symbol_compare_ftype
*ordered_compare
)
5556 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
5558 /* debug_names_table is NULL if OBJF_READNOW. */
5559 if (!per_objfile
->per_bfd
->debug_names_table
)
5562 mapped_debug_names
&map
= *per_objfile
->per_bfd
->debug_names_table
;
5563 const block_enum block_kind
= global
? GLOBAL_BLOCK
: STATIC_BLOCK
;
5564 const block_search_flags block_flags
5565 = global
? SEARCH_GLOBAL_BLOCK
: SEARCH_STATIC_BLOCK
;
5567 const char *match_name
= name
.ada ().lookup_name ().c_str ();
5568 auto matcher
= [&] (const char *symname
)
5570 if (ordered_compare
== nullptr)
5572 return ordered_compare (symname
, match_name
) == 0;
5575 dw2_expand_symtabs_matching_symbol (map
, name
, matcher
,
5576 [&] (offset_type namei
)
5578 /* The name was matched, now expand corresponding CUs that were
5580 dw2_debug_names_iterator
iter (map
, block_flags
, domain
, namei
,
5583 struct dwarf2_per_cu_data
*per_cu
;
5584 while ((per_cu
= iter
.next ()) != NULL
)
5585 dw2_expand_symtabs_matching_one (per_cu
, per_objfile
, nullptr,
5590 /* It's a shame we couldn't do this inside the
5591 dw2_expand_symtabs_matching_symbol callback, but that skips CUs
5592 that have already been expanded. Instead, this loop matches what
5593 the psymtab code does. */
5594 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
5596 compunit_symtab
*symtab
= per_objfile
->get_symtab (per_cu
);
5597 if (symtab
!= nullptr)
5599 const struct block
*block
5600 = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (symtab
), block_kind
);
5601 if (!iterate_over_symbols_terminated (block
, name
,
5609 dwarf2_debug_names_index::expand_symtabs_matching
5610 (struct objfile
*objfile
,
5611 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
5612 const lookup_name_info
*lookup_name
,
5613 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
5614 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
5615 block_search_flags search_flags
,
5617 enum search_domain kind
)
5619 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
5621 /* debug_names_table is NULL if OBJF_READNOW. */
5622 if (!per_objfile
->per_bfd
->debug_names_table
)
5625 dw_expand_symtabs_matching_file_matcher (per_objfile
, file_matcher
);
5627 if (symbol_matcher
== NULL
&& lookup_name
== NULL
)
5629 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
5633 if (!dw2_expand_symtabs_matching_one (per_cu
, per_objfile
,
5641 mapped_debug_names
&map
= *per_objfile
->per_bfd
->debug_names_table
;
5644 = dw2_expand_symtabs_matching_symbol (map
, *lookup_name
,
5646 [&] (offset_type namei
)
5648 /* The name was matched, now expand corresponding CUs that were
5650 dw2_debug_names_iterator
iter (map
, kind
, namei
, per_objfile
, domain
);
5652 struct dwarf2_per_cu_data
*per_cu
;
5653 while ((per_cu
= iter
.next ()) != NULL
)
5654 if (!dw2_expand_symtabs_matching_one (per_cu
, per_objfile
,
5664 /* Get the content of the .gdb_index section of OBJ. SECTION_OWNER should point
5665 to either a dwarf2_per_bfd or dwz_file object. */
5667 template <typename T
>
5668 static gdb::array_view
<const gdb_byte
>
5669 get_gdb_index_contents_from_section (objfile
*obj
, T
*section_owner
)
5671 dwarf2_section_info
*section
= §ion_owner
->gdb_index
;
5673 if (section
->empty ())
5676 /* Older elfutils strip versions could keep the section in the main
5677 executable while splitting it for the separate debug info file. */
5678 if ((section
->get_flags () & SEC_HAS_CONTENTS
) == 0)
5681 section
->read (obj
);
5683 /* dwarf2_section_info::size is a bfd_size_type, while
5684 gdb::array_view works with size_t. On 32-bit hosts, with
5685 --enable-64-bit-bfd, bfd_size_type is a 64-bit type, while size_t
5686 is 32-bit. So we need an explicit narrowing conversion here.
5687 This is fine, because it's impossible to allocate or mmap an
5688 array/buffer larger than what size_t can represent. */
5689 return gdb::make_array_view (section
->buffer
, section
->size
);
5692 /* Lookup the index cache for the contents of the index associated to
5695 static gdb::array_view
<const gdb_byte
>
5696 get_gdb_index_contents_from_cache (objfile
*obj
, dwarf2_per_bfd
*dwarf2_per_bfd
)
5698 const bfd_build_id
*build_id
= build_id_bfd_get (obj
->obfd
);
5699 if (build_id
== nullptr)
5702 return global_index_cache
.lookup_gdb_index (build_id
,
5703 &dwarf2_per_bfd
->index_cache_res
);
5706 /* Same as the above, but for DWZ. */
5708 static gdb::array_view
<const gdb_byte
>
5709 get_gdb_index_contents_from_cache_dwz (objfile
*obj
, dwz_file
*dwz
)
5711 const bfd_build_id
*build_id
= build_id_bfd_get (dwz
->dwz_bfd
.get ());
5712 if (build_id
== nullptr)
5715 return global_index_cache
.lookup_gdb_index (build_id
, &dwz
->index_cache_res
);
5718 /* See dwarf2/public.h. */
5721 dwarf2_initialize_objfile (struct objfile
*objfile
)
5723 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
5724 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
5726 dwarf_read_debug_printf ("called");
5728 /* If we're about to read full symbols, don't bother with the
5729 indices. In this case we also don't care if some other debug
5730 format is making psymtabs, because they are all about to be
5732 if ((objfile
->flags
& OBJF_READNOW
))
5734 dwarf_read_debug_printf ("readnow requested");
5736 /* When using READNOW, the using_index flag (set below) indicates that
5737 PER_BFD was already initialized, when we loaded some other objfile. */
5738 if (per_bfd
->using_index
)
5740 dwarf_read_debug_printf ("using_index already set");
5741 per_objfile
->resize_symtabs ();
5742 objfile
->qf
.push_front (make_dwarf_gdb_index ());
5746 per_bfd
->using_index
= 1;
5747 create_all_comp_units (per_objfile
);
5748 create_all_type_units (per_objfile
);
5749 per_bfd
->quick_file_names_table
5750 = create_quick_file_names_table (per_bfd
->all_comp_units
.size ());
5751 per_objfile
->resize_symtabs ();
5753 for (int i
= 0; i
< (per_bfd
->all_comp_units
.size ()
5754 + per_bfd
->all_type_units
.size ()); ++i
)
5756 dwarf2_per_cu_data
*per_cu
= per_bfd
->get_cutu (i
);
5758 per_cu
->v
.quick
= OBSTACK_ZALLOC (&per_bfd
->obstack
,
5759 struct dwarf2_per_cu_quick_data
);
5762 /* Arrange for gdb to see the "quick" functions. However, these
5763 functions will be no-ops because we will have expanded all
5765 objfile
->qf
.push_front (make_dwarf_gdb_index ());
5769 /* Was a debug names index already read when we processed an objfile sharing
5771 if (per_bfd
->debug_names_table
!= nullptr)
5773 dwarf_read_debug_printf ("re-using shared debug names table");
5774 per_objfile
->resize_symtabs ();
5775 objfile
->qf
.push_front (make_dwarf_debug_names ());
5779 /* Was a GDB index already read when we processed an objfile sharing
5781 if (per_bfd
->index_table
!= nullptr)
5783 dwarf_read_debug_printf ("re-using shared index table");
5784 per_objfile
->resize_symtabs ();
5785 objfile
->qf
.push_front (make_dwarf_gdb_index ());
5789 /* There might already be partial symtabs built for this BFD. This happens
5790 when loading the same binary twice with the index-cache enabled. If so,
5791 don't try to read an index. The objfile / per_objfile initialization will
5792 be completed in dwarf2_build_psymtabs, in the standard partial symtabs
5794 if (per_bfd
->partial_symtabs
!= nullptr)
5796 dwarf_read_debug_printf ("re-using shared partial symtabs");
5797 objfile
->qf
.push_front (make_lazy_dwarf_reader ());
5801 if (dwarf2_read_debug_names (per_objfile
))
5803 dwarf_read_debug_printf ("found debug names");
5804 per_objfile
->resize_symtabs ();
5805 objfile
->qf
.push_front (make_dwarf_debug_names ());
5809 if (dwarf2_read_gdb_index (per_objfile
,
5810 get_gdb_index_contents_from_section
<struct dwarf2_per_bfd
>,
5811 get_gdb_index_contents_from_section
<dwz_file
>))
5813 dwarf_read_debug_printf ("found gdb index from file");
5814 per_objfile
->resize_symtabs ();
5815 objfile
->qf
.push_front (make_dwarf_gdb_index ());
5819 /* ... otherwise, try to find the index in the index cache. */
5820 if (dwarf2_read_gdb_index (per_objfile
,
5821 get_gdb_index_contents_from_cache
,
5822 get_gdb_index_contents_from_cache_dwz
))
5824 dwarf_read_debug_printf ("found gdb index from cache");
5825 global_index_cache
.hit ();
5826 per_objfile
->resize_symtabs ();
5827 objfile
->qf
.push_front (make_dwarf_gdb_index ());
5831 global_index_cache
.miss ();
5832 objfile
->qf
.push_front (make_lazy_dwarf_reader ());
5837 /* Build a partial symbol table. */
5840 dwarf2_build_psymtabs (struct objfile
*objfile
, psymbol_functions
*psf
)
5842 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
5843 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
5845 if (per_bfd
->partial_symtabs
!= nullptr)
5847 /* Partial symbols were already read, so now we can simply
5851 psf
= new psymbol_functions (per_bfd
->partial_symtabs
);
5852 objfile
->qf
.emplace_front (psf
);
5855 psf
->set_partial_symtabs (per_bfd
->partial_symtabs
);
5856 per_objfile
->resize_symtabs ();
5862 psf
= new psymbol_functions
;
5863 objfile
->qf
.emplace_front (psf
);
5865 const std::shared_ptr
<psymtab_storage
> &partial_symtabs
5866 = psf
->get_partial_symtabs ();
5868 /* Set the local reference to partial symtabs, so that we don't try
5869 to read them again if reading another objfile with the same BFD.
5870 If we can't in fact share, this won't make a difference anyway as
5871 the dwarf2_per_bfd object won't be shared. */
5872 per_bfd
->partial_symtabs
= partial_symtabs
;
5876 /* This isn't really ideal: all the data we allocate on the
5877 objfile's obstack is still uselessly kept around. However,
5878 freeing it seems unsafe. */
5879 psymtab_discarder
psymtabs (partial_symtabs
.get ());
5880 dwarf2_build_psymtabs_hard (per_objfile
);
5883 per_objfile
->resize_symtabs ();
5885 /* (maybe) store an index in the cache. */
5886 global_index_cache
.store (per_objfile
);
5888 catch (const gdb_exception_error
&except
)
5890 exception_print (gdb_stderr
, except
);
5894 /* Find the base address of the compilation unit for range lists and
5895 location lists. It will normally be specified by DW_AT_low_pc.
5896 In DWARF-3 draft 4, the base address could be overridden by
5897 DW_AT_entry_pc. It's been removed, but GCC still uses this for
5898 compilation units with discontinuous ranges. */
5901 dwarf2_find_base_address (struct die_info
*die
, struct dwarf2_cu
*cu
)
5903 struct attribute
*attr
;
5905 cu
->base_address
.reset ();
5907 attr
= dwarf2_attr (die
, DW_AT_entry_pc
, cu
);
5908 if (attr
!= nullptr)
5909 cu
->base_address
= attr
->as_address ();
5912 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
5913 if (attr
!= nullptr)
5914 cu
->base_address
= attr
->as_address ();
5918 /* Helper function that returns the proper abbrev section for
5921 static struct dwarf2_section_info
*
5922 get_abbrev_section_for_cu (struct dwarf2_per_cu_data
*this_cu
)
5924 struct dwarf2_section_info
*abbrev
;
5925 dwarf2_per_bfd
*per_bfd
= this_cu
->per_bfd
;
5927 if (this_cu
->is_dwz
)
5928 abbrev
= &dwarf2_get_dwz_file (per_bfd
, true)->abbrev
;
5930 abbrev
= &per_bfd
->abbrev
;
5935 /* Fetch the abbreviation table offset from a comp or type unit header. */
5938 read_abbrev_offset (dwarf2_per_objfile
*per_objfile
,
5939 struct dwarf2_section_info
*section
,
5940 sect_offset sect_off
)
5942 bfd
*abfd
= section
->get_bfd_owner ();
5943 const gdb_byte
*info_ptr
;
5944 unsigned int initial_length_size
, offset_size
;
5947 section
->read (per_objfile
->objfile
);
5948 info_ptr
= section
->buffer
+ to_underlying (sect_off
);
5949 read_initial_length (abfd
, info_ptr
, &initial_length_size
);
5950 offset_size
= initial_length_size
== 4 ? 4 : 8;
5951 info_ptr
+= initial_length_size
;
5953 version
= read_2_bytes (abfd
, info_ptr
);
5957 /* Skip unit type and address size. */
5961 return (sect_offset
) read_offset (abfd
, info_ptr
, offset_size
);
5964 /* A partial symtab that is used only for include files. */
5965 struct dwarf2_include_psymtab
: public partial_symtab
5967 dwarf2_include_psymtab (const char *filename
,
5968 psymtab_storage
*partial_symtabs
,
5969 objfile_per_bfd_storage
*objfile_per_bfd
)
5970 : partial_symtab (filename
, partial_symtabs
, objfile_per_bfd
)
5974 void read_symtab (struct objfile
*objfile
) override
5976 /* It's an include file, no symbols to read for it.
5977 Everything is in the includer symtab. */
5979 /* The expansion of a dwarf2_include_psymtab is just a trigger for
5980 expansion of the includer psymtab. We use the dependencies[0] field to
5981 model the includer. But if we go the regular route of calling
5982 expand_psymtab here, and having expand_psymtab call expand_dependencies
5983 to expand the includer, we'll only use expand_psymtab on the includer
5984 (making it a non-toplevel psymtab), while if we expand the includer via
5985 another path, we'll use read_symtab (making it a toplevel psymtab).
5986 So, don't pretend a dwarf2_include_psymtab is an actual toplevel
5987 psymtab, and trigger read_symtab on the includer here directly. */
5988 includer ()->read_symtab (objfile
);
5991 void expand_psymtab (struct objfile
*objfile
) override
5993 /* This is not called by read_symtab, and should not be called by any
5994 expand_dependencies. */
5998 bool readin_p (struct objfile
*objfile
) const override
6000 return includer ()->readin_p (objfile
);
6003 compunit_symtab
*get_compunit_symtab (struct objfile
*objfile
) const override
6009 partial_symtab
*includer () const
6011 /* An include psymtab has exactly one dependency: the psymtab that
6013 gdb_assert (this->number_of_dependencies
== 1);
6014 return this->dependencies
[0];
6018 /* Allocate a new partial symtab for file named NAME and mark this new
6019 partial symtab as being an include of PST. */
6022 dwarf2_create_include_psymtab (dwarf2_per_bfd
*per_bfd
,
6024 dwarf2_psymtab
*pst
,
6025 psymtab_storage
*partial_symtabs
,
6026 objfile_per_bfd_storage
*objfile_per_bfd
)
6028 dwarf2_include_psymtab
*subpst
6029 = new dwarf2_include_psymtab (name
, partial_symtabs
, objfile_per_bfd
);
6031 if (!IS_ABSOLUTE_PATH (subpst
->filename
))
6032 subpst
->dirname
= pst
->dirname
;
6034 subpst
->dependencies
= per_bfd
->partial_symtabs
->allocate_dependencies (1);
6035 subpst
->dependencies
[0] = pst
;
6036 subpst
->number_of_dependencies
= 1;
6039 /* Read the Line Number Program data and extract the list of files
6040 included by the source file represented by PST. Build an include
6041 partial symtab for each of these included files. */
6044 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
6045 struct die_info
*die
,
6046 dwarf2_psymtab
*pst
)
6049 struct attribute
*attr
;
6051 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
6052 if (attr
!= nullptr && attr
->form_is_unsigned ())
6053 lh
= dwarf_decode_line_header ((sect_offset
) attr
->as_unsigned (), cu
);
6055 return; /* No linetable, so no includes. */
6057 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). Also note
6058 that we pass in the raw text_low here; that is ok because we're
6059 only decoding the line table to make include partial symtabs, and
6060 so the addresses aren't really used. */
6061 dwarf_decode_lines (lh
.get (), pst
->dirname
, cu
, pst
,
6062 pst
->raw_text_low (), 1);
6066 hash_signatured_type (const void *item
)
6068 const struct signatured_type
*sig_type
6069 = (const struct signatured_type
*) item
;
6071 /* This drops the top 32 bits of the signature, but is ok for a hash. */
6072 return sig_type
->signature
;
6076 eq_signatured_type (const void *item_lhs
, const void *item_rhs
)
6078 const struct signatured_type
*lhs
= (const struct signatured_type
*) item_lhs
;
6079 const struct signatured_type
*rhs
= (const struct signatured_type
*) item_rhs
;
6081 return lhs
->signature
== rhs
->signature
;
6084 /* Allocate a hash table for signatured types. */
6087 allocate_signatured_type_table ()
6089 return htab_up (htab_create_alloc (41,
6090 hash_signatured_type
,
6092 NULL
, xcalloc
, xfree
));
6095 /* A helper function to add a signatured type CU to a table. */
6098 add_signatured_type_cu_to_table (void **slot
, void *datum
)
6100 struct signatured_type
*sigt
= (struct signatured_type
*) *slot
;
6101 std::vector
<signatured_type
*> *all_type_units
6102 = (std::vector
<signatured_type
*> *) datum
;
6104 all_type_units
->push_back (sigt
);
6109 /* A helper for create_debug_types_hash_table. Read types from SECTION
6110 and fill them into TYPES_HTAB. It will process only type units,
6111 therefore DW_UT_type. */
6114 create_debug_type_hash_table (dwarf2_per_objfile
*per_objfile
,
6115 struct dwo_file
*dwo_file
,
6116 dwarf2_section_info
*section
, htab_up
&types_htab
,
6117 rcuh_kind section_kind
)
6119 struct objfile
*objfile
= per_objfile
->objfile
;
6120 struct dwarf2_section_info
*abbrev_section
;
6122 const gdb_byte
*info_ptr
, *end_ptr
;
6124 abbrev_section
= (dwo_file
!= NULL
6125 ? &dwo_file
->sections
.abbrev
6126 : &per_objfile
->per_bfd
->abbrev
);
6128 dwarf_read_debug_printf ("Reading %s for %s",
6129 section
->get_name (),
6130 abbrev_section
->get_file_name ());
6132 section
->read (objfile
);
6133 info_ptr
= section
->buffer
;
6135 if (info_ptr
== NULL
)
6138 /* We can't set abfd until now because the section may be empty or
6139 not present, in which case the bfd is unknown. */
6140 abfd
= section
->get_bfd_owner ();
6142 /* We don't use cutu_reader here because we don't need to read
6143 any dies: the signature is in the header. */
6145 end_ptr
= info_ptr
+ section
->size
;
6146 while (info_ptr
< end_ptr
)
6148 struct signatured_type
*sig_type
;
6149 struct dwo_unit
*dwo_tu
;
6151 const gdb_byte
*ptr
= info_ptr
;
6152 struct comp_unit_head header
;
6153 unsigned int length
;
6155 sect_offset sect_off
= (sect_offset
) (ptr
- section
->buffer
);
6157 /* Initialize it due to a false compiler warning. */
6158 header
.signature
= -1;
6159 header
.type_cu_offset_in_tu
= (cu_offset
) -1;
6161 /* We need to read the type's signature in order to build the hash
6162 table, but we don't need anything else just yet. */
6164 ptr
= read_and_check_comp_unit_head (per_objfile
, &header
, section
,
6165 abbrev_section
, ptr
, section_kind
);
6167 length
= header
.get_length ();
6169 /* Skip dummy type units. */
6170 if (ptr
>= info_ptr
+ length
6171 || peek_abbrev_code (abfd
, ptr
) == 0
6172 || (header
.unit_type
!= DW_UT_type
6173 && header
.unit_type
!= DW_UT_split_type
))
6179 if (types_htab
== NULL
)
6182 types_htab
= allocate_dwo_unit_table ();
6184 types_htab
= allocate_signatured_type_table ();
6190 dwo_tu
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, dwo_unit
);
6191 dwo_tu
->dwo_file
= dwo_file
;
6192 dwo_tu
->signature
= header
.signature
;
6193 dwo_tu
->type_offset_in_tu
= header
.type_cu_offset_in_tu
;
6194 dwo_tu
->section
= section
;
6195 dwo_tu
->sect_off
= sect_off
;
6196 dwo_tu
->length
= length
;
6200 /* N.B.: type_offset is not usable if this type uses a DWO file.
6201 The real type_offset is in the DWO file. */
6203 sig_type
= per_objfile
->per_bfd
->allocate_signatured_type ();
6204 sig_type
->signature
= header
.signature
;
6205 sig_type
->type_offset_in_tu
= header
.type_cu_offset_in_tu
;
6206 sig_type
->per_cu
.is_debug_types
= 1;
6207 sig_type
->per_cu
.section
= section
;
6208 sig_type
->per_cu
.sect_off
= sect_off
;
6209 sig_type
->per_cu
.length
= length
;
6212 slot
= htab_find_slot (types_htab
.get (),
6213 dwo_file
? (void*) dwo_tu
: (void *) sig_type
,
6215 gdb_assert (slot
!= NULL
);
6218 sect_offset dup_sect_off
;
6222 const struct dwo_unit
*dup_tu
6223 = (const struct dwo_unit
*) *slot
;
6225 dup_sect_off
= dup_tu
->sect_off
;
6229 const struct signatured_type
*dup_tu
6230 = (const struct signatured_type
*) *slot
;
6232 dup_sect_off
= dup_tu
->per_cu
.sect_off
;
6235 complaint (_("debug type entry at offset %s is duplicate to"
6236 " the entry at offset %s, signature %s"),
6237 sect_offset_str (sect_off
), sect_offset_str (dup_sect_off
),
6238 hex_string (header
.signature
));
6240 *slot
= dwo_file
? (void *) dwo_tu
: (void *) sig_type
;
6242 dwarf_read_debug_printf_v (" offset %s, signature %s",
6243 sect_offset_str (sect_off
),
6244 hex_string (header
.signature
));
6250 /* Create the hash table of all entries in the .debug_types
6251 (or .debug_types.dwo) section(s).
6252 If reading a DWO file, then DWO_FILE is a pointer to the DWO file object,
6253 otherwise it is NULL.
6255 The result is a pointer to the hash table or NULL if there are no types.
6257 Note: This function processes DWO files only, not DWP files. */
6260 create_debug_types_hash_table (dwarf2_per_objfile
*per_objfile
,
6261 struct dwo_file
*dwo_file
,
6262 gdb::array_view
<dwarf2_section_info
> type_sections
,
6263 htab_up
&types_htab
)
6265 for (dwarf2_section_info
§ion
: type_sections
)
6266 create_debug_type_hash_table (per_objfile
, dwo_file
, §ion
, types_htab
,
6270 /* Create the hash table of all entries in the .debug_types section,
6271 and initialize all_type_units.
6272 The result is zero if there is an error (e.g. missing .debug_types section),
6273 otherwise non-zero. */
6276 create_all_type_units (dwarf2_per_objfile
*per_objfile
)
6280 create_debug_type_hash_table (per_objfile
, NULL
, &per_objfile
->per_bfd
->info
,
6281 types_htab
, rcuh_kind::COMPILE
);
6282 create_debug_types_hash_table (per_objfile
, NULL
, per_objfile
->per_bfd
->types
,
6284 if (types_htab
== NULL
)
6286 per_objfile
->per_bfd
->signatured_types
= NULL
;
6290 per_objfile
->per_bfd
->signatured_types
= std::move (types_htab
);
6292 gdb_assert (per_objfile
->per_bfd
->all_type_units
.empty ());
6293 per_objfile
->per_bfd
->all_type_units
.reserve
6294 (htab_elements (per_objfile
->per_bfd
->signatured_types
.get ()));
6296 htab_traverse_noresize (per_objfile
->per_bfd
->signatured_types
.get (),
6297 add_signatured_type_cu_to_table
,
6298 &per_objfile
->per_bfd
->all_type_units
);
6303 /* Add an entry for signature SIG to dwarf2_per_objfile->per_bfd->signatured_types.
6304 If SLOT is non-NULL, it is the entry to use in the hash table.
6305 Otherwise we find one. */
6307 static struct signatured_type
*
6308 add_type_unit (dwarf2_per_objfile
*per_objfile
, ULONGEST sig
, void **slot
)
6310 if (per_objfile
->per_bfd
->all_type_units
.size ()
6311 == per_objfile
->per_bfd
->all_type_units
.capacity ())
6312 ++per_objfile
->per_bfd
->tu_stats
.nr_all_type_units_reallocs
;
6314 signatured_type
*sig_type
= per_objfile
->per_bfd
->allocate_signatured_type ();
6316 per_objfile
->resize_symtabs ();
6318 per_objfile
->per_bfd
->all_type_units
.push_back (sig_type
);
6319 sig_type
->signature
= sig
;
6320 sig_type
->per_cu
.is_debug_types
= 1;
6321 if (per_objfile
->per_bfd
->using_index
)
6323 sig_type
->per_cu
.v
.quick
=
6324 OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
,
6325 struct dwarf2_per_cu_quick_data
);
6330 slot
= htab_find_slot (per_objfile
->per_bfd
->signatured_types
.get (),
6333 gdb_assert (*slot
== NULL
);
6335 /* The rest of sig_type must be filled in by the caller. */
6339 /* Subroutine of lookup_dwo_signatured_type and lookup_dwp_signatured_type.
6340 Fill in SIG_ENTRY with DWO_ENTRY. */
6343 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile
*per_objfile
,
6344 struct signatured_type
*sig_entry
,
6345 struct dwo_unit
*dwo_entry
)
6347 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
6349 /* Make sure we're not clobbering something we don't expect to. */
6350 gdb_assert (! sig_entry
->per_cu
.queued
);
6351 gdb_assert (per_objfile
->get_cu (&sig_entry
->per_cu
) == NULL
);
6352 if (per_bfd
->using_index
)
6354 gdb_assert (sig_entry
->per_cu
.v
.quick
!= NULL
);
6355 gdb_assert (!per_objfile
->symtab_set_p (&sig_entry
->per_cu
));
6358 gdb_assert (sig_entry
->per_cu
.v
.psymtab
== NULL
);
6359 gdb_assert (sig_entry
->signature
== dwo_entry
->signature
);
6360 gdb_assert (to_underlying (sig_entry
->type_offset_in_section
) == 0);
6361 gdb_assert (sig_entry
->type_unit_group
== NULL
);
6362 gdb_assert (sig_entry
->dwo_unit
== NULL
);
6364 sig_entry
->per_cu
.section
= dwo_entry
->section
;
6365 sig_entry
->per_cu
.sect_off
= dwo_entry
->sect_off
;
6366 sig_entry
->per_cu
.length
= dwo_entry
->length
;
6367 sig_entry
->per_cu
.reading_dwo_directly
= 1;
6368 sig_entry
->per_cu
.per_bfd
= per_bfd
;
6369 sig_entry
->type_offset_in_tu
= dwo_entry
->type_offset_in_tu
;
6370 sig_entry
->dwo_unit
= dwo_entry
;
6373 /* Subroutine of lookup_signatured_type.
6374 If we haven't read the TU yet, create the signatured_type data structure
6375 for a TU to be read in directly from a DWO file, bypassing the stub.
6376 This is the "Stay in DWO Optimization": When there is no DWP file and we're
6377 using .gdb_index, then when reading a CU we want to stay in the DWO file
6378 containing that CU. Otherwise we could end up reading several other DWO
6379 files (due to comdat folding) to process the transitive closure of all the
6380 mentioned TUs, and that can be slow. The current DWO file will have every
6381 type signature that it needs.
6382 We only do this for .gdb_index because in the psymtab case we already have
6383 to read all the DWOs to build the type unit groups. */
6385 static struct signatured_type
*
6386 lookup_dwo_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
6388 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
6389 struct dwo_file
*dwo_file
;
6390 struct dwo_unit find_dwo_entry
, *dwo_entry
;
6391 struct signatured_type find_sig_entry
, *sig_entry
;
6394 gdb_assert (cu
->dwo_unit
&& per_objfile
->per_bfd
->using_index
);
6396 /* If TU skeletons have been removed then we may not have read in any
6398 if (per_objfile
->per_bfd
->signatured_types
== NULL
)
6399 per_objfile
->per_bfd
->signatured_types
= allocate_signatured_type_table ();
6401 /* We only ever need to read in one copy of a signatured type.
6402 Use the global signatured_types array to do our own comdat-folding
6403 of types. If this is the first time we're reading this TU, and
6404 the TU has an entry in .gdb_index, replace the recorded data from
6405 .gdb_index with this TU. */
6407 find_sig_entry
.signature
= sig
;
6408 slot
= htab_find_slot (per_objfile
->per_bfd
->signatured_types
.get (),
6409 &find_sig_entry
, INSERT
);
6410 sig_entry
= (struct signatured_type
*) *slot
;
6412 /* We can get here with the TU already read, *or* in the process of being
6413 read. Don't reassign the global entry to point to this DWO if that's
6414 the case. Also note that if the TU is already being read, it may not
6415 have come from a DWO, the program may be a mix of Fission-compiled
6416 code and non-Fission-compiled code. */
6418 /* Have we already tried to read this TU?
6419 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
6420 needn't exist in the global table yet). */
6421 if (sig_entry
!= NULL
&& sig_entry
->per_cu
.tu_read
)
6424 /* Note: cu->dwo_unit is the dwo_unit that references this TU, not the
6425 dwo_unit of the TU itself. */
6426 dwo_file
= cu
->dwo_unit
->dwo_file
;
6428 /* Ok, this is the first time we're reading this TU. */
6429 if (dwo_file
->tus
== NULL
)
6431 find_dwo_entry
.signature
= sig
;
6432 dwo_entry
= (struct dwo_unit
*) htab_find (dwo_file
->tus
.get (),
6434 if (dwo_entry
== NULL
)
6437 /* If the global table doesn't have an entry for this TU, add one. */
6438 if (sig_entry
== NULL
)
6439 sig_entry
= add_type_unit (per_objfile
, sig
, slot
);
6441 fill_in_sig_entry_from_dwo_entry (per_objfile
, sig_entry
, dwo_entry
);
6442 sig_entry
->per_cu
.tu_read
= 1;
6446 /* Subroutine of lookup_signatured_type.
6447 Look up the type for signature SIG, and if we can't find SIG in .gdb_index
6448 then try the DWP file. If the TU stub (skeleton) has been removed then
6449 it won't be in .gdb_index. */
6451 static struct signatured_type
*
6452 lookup_dwp_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
6454 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
6455 struct dwp_file
*dwp_file
= get_dwp_file (per_objfile
);
6456 struct dwo_unit
*dwo_entry
;
6457 struct signatured_type find_sig_entry
, *sig_entry
;
6460 gdb_assert (cu
->dwo_unit
&& per_objfile
->per_bfd
->using_index
);
6461 gdb_assert (dwp_file
!= NULL
);
6463 /* If TU skeletons have been removed then we may not have read in any
6465 if (per_objfile
->per_bfd
->signatured_types
== NULL
)
6466 per_objfile
->per_bfd
->signatured_types
= allocate_signatured_type_table ();
6468 find_sig_entry
.signature
= sig
;
6469 slot
= htab_find_slot (per_objfile
->per_bfd
->signatured_types
.get (),
6470 &find_sig_entry
, INSERT
);
6471 sig_entry
= (struct signatured_type
*) *slot
;
6473 /* Have we already tried to read this TU?
6474 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
6475 needn't exist in the global table yet). */
6476 if (sig_entry
!= NULL
)
6479 if (dwp_file
->tus
== NULL
)
6481 dwo_entry
= lookup_dwo_unit_in_dwp (per_objfile
, dwp_file
, NULL
, sig
,
6482 1 /* is_debug_types */);
6483 if (dwo_entry
== NULL
)
6486 sig_entry
= add_type_unit (per_objfile
, sig
, slot
);
6487 fill_in_sig_entry_from_dwo_entry (per_objfile
, sig_entry
, dwo_entry
);
6492 /* Lookup a signature based type for DW_FORM_ref_sig8.
6493 Returns NULL if signature SIG is not present in the table.
6494 It is up to the caller to complain about this. */
6496 static struct signatured_type
*
6497 lookup_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
6499 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
6501 if (cu
->dwo_unit
&& per_objfile
->per_bfd
->using_index
)
6503 /* We're in a DWO/DWP file, and we're using .gdb_index.
6504 These cases require special processing. */
6505 if (get_dwp_file (per_objfile
) == NULL
)
6506 return lookup_dwo_signatured_type (cu
, sig
);
6508 return lookup_dwp_signatured_type (cu
, sig
);
6512 struct signatured_type find_entry
, *entry
;
6514 if (per_objfile
->per_bfd
->signatured_types
== NULL
)
6516 find_entry
.signature
= sig
;
6517 entry
= ((struct signatured_type
*)
6518 htab_find (per_objfile
->per_bfd
->signatured_types
.get (),
6524 /* Low level DIE reading support. */
6526 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
6529 init_cu_die_reader (struct die_reader_specs
*reader
,
6530 struct dwarf2_cu
*cu
,
6531 struct dwarf2_section_info
*section
,
6532 struct dwo_file
*dwo_file
,
6533 struct abbrev_table
*abbrev_table
)
6535 gdb_assert (section
->readin
&& section
->buffer
!= NULL
);
6536 reader
->abfd
= section
->get_bfd_owner ();
6538 reader
->dwo_file
= dwo_file
;
6539 reader
->die_section
= section
;
6540 reader
->buffer
= section
->buffer
;
6541 reader
->buffer_end
= section
->buffer
+ section
->size
;
6542 reader
->abbrev_table
= abbrev_table
;
6545 /* Subroutine of cutu_reader to simplify it.
6546 Read in the rest of a CU/TU top level DIE from DWO_UNIT.
6547 There's just a lot of work to do, and cutu_reader is big enough
6550 STUB_COMP_UNIT_DIE is for the stub DIE, we copy over certain attributes
6551 from it to the DIE in the DWO. If NULL we are skipping the stub.
6552 STUB_COMP_DIR is similar to STUB_COMP_UNIT_DIE: When reading a TU directly
6553 from the DWO file, bypassing the stub, it contains the DW_AT_comp_dir
6554 attribute of the referencing CU. At most one of STUB_COMP_UNIT_DIE and
6555 STUB_COMP_DIR may be non-NULL.
6556 *RESULT_READER,*RESULT_INFO_PTR,*RESULT_COMP_UNIT_DIE
6557 are filled in with the info of the DIE from the DWO file.
6558 *RESULT_DWO_ABBREV_TABLE will be filled in with the abbrev table allocated
6559 from the dwo. Since *RESULT_READER references this abbrev table, it must be
6560 kept around for at least as long as *RESULT_READER.
6562 The result is non-zero if a valid (non-dummy) DIE was found. */
6565 read_cutu_die_from_dwo (dwarf2_cu
*cu
,
6566 struct dwo_unit
*dwo_unit
,
6567 struct die_info
*stub_comp_unit_die
,
6568 const char *stub_comp_dir
,
6569 struct die_reader_specs
*result_reader
,
6570 const gdb_byte
**result_info_ptr
,
6571 struct die_info
**result_comp_unit_die
,
6572 abbrev_table_up
*result_dwo_abbrev_table
)
6574 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
6575 dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
6576 struct objfile
*objfile
= per_objfile
->objfile
;
6578 const gdb_byte
*begin_info_ptr
, *info_ptr
;
6579 struct attribute
*comp_dir
, *stmt_list
, *low_pc
, *high_pc
, *ranges
;
6580 int i
,num_extra_attrs
;
6581 struct dwarf2_section_info
*dwo_abbrev_section
;
6582 struct die_info
*comp_unit_die
;
6584 /* At most one of these may be provided. */
6585 gdb_assert ((stub_comp_unit_die
!= NULL
) + (stub_comp_dir
!= NULL
) <= 1);
6587 /* These attributes aren't processed until later:
6588 DW_AT_stmt_list, DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges.
6589 DW_AT_comp_dir is used now, to find the DWO file, but it is also
6590 referenced later. However, these attributes are found in the stub
6591 which we won't have later. In order to not impose this complication
6592 on the rest of the code, we read them here and copy them to the
6601 if (stub_comp_unit_die
!= NULL
)
6603 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
6605 if (!per_cu
->is_debug_types
)
6606 stmt_list
= dwarf2_attr (stub_comp_unit_die
, DW_AT_stmt_list
, cu
);
6607 low_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_low_pc
, cu
);
6608 high_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_high_pc
, cu
);
6609 ranges
= dwarf2_attr (stub_comp_unit_die
, DW_AT_ranges
, cu
);
6610 comp_dir
= dwarf2_attr (stub_comp_unit_die
, DW_AT_comp_dir
, cu
);
6612 cu
->addr_base
= stub_comp_unit_die
->addr_base ();
6614 /* There should be a DW_AT_GNU_ranges_base attribute here (if needed).
6615 We need the value before we can process DW_AT_ranges values from the
6617 cu
->gnu_ranges_base
= stub_comp_unit_die
->gnu_ranges_base ();
6619 /* For DWARF5: record the DW_AT_rnglists_base value from the skeleton. If
6620 there are attributes of form DW_FORM_rnglistx in the skeleton, they'll
6621 need the rnglists base. Attributes of form DW_FORM_rnglistx in the
6622 split unit don't use it, as the DWO has its own .debug_rnglists.dwo
6624 cu
->rnglists_base
= stub_comp_unit_die
->rnglists_base ();
6626 else if (stub_comp_dir
!= NULL
)
6628 /* Reconstruct the comp_dir attribute to simplify the code below. */
6629 comp_dir
= OBSTACK_ZALLOC (&cu
->comp_unit_obstack
, struct attribute
);
6630 comp_dir
->name
= DW_AT_comp_dir
;
6631 comp_dir
->form
= DW_FORM_string
;
6632 comp_dir
->set_string_noncanonical (stub_comp_dir
);
6635 /* Set up for reading the DWO CU/TU. */
6636 cu
->dwo_unit
= dwo_unit
;
6637 dwarf2_section_info
*section
= dwo_unit
->section
;
6638 section
->read (objfile
);
6639 abfd
= section
->get_bfd_owner ();
6640 begin_info_ptr
= info_ptr
= (section
->buffer
6641 + to_underlying (dwo_unit
->sect_off
));
6642 dwo_abbrev_section
= &dwo_unit
->dwo_file
->sections
.abbrev
;
6644 if (per_cu
->is_debug_types
)
6646 signatured_type
*sig_type
= (struct signatured_type
*) per_cu
;
6648 info_ptr
= read_and_check_comp_unit_head (per_objfile
, &cu
->header
,
6649 section
, dwo_abbrev_section
,
6650 info_ptr
, rcuh_kind::TYPE
);
6651 /* This is not an assert because it can be caused by bad debug info. */
6652 if (sig_type
->signature
!= cu
->header
.signature
)
6654 error (_("Dwarf Error: signature mismatch %s vs %s while reading"
6655 " TU at offset %s [in module %s]"),
6656 hex_string (sig_type
->signature
),
6657 hex_string (cu
->header
.signature
),
6658 sect_offset_str (dwo_unit
->sect_off
),
6659 bfd_get_filename (abfd
));
6661 gdb_assert (dwo_unit
->sect_off
== cu
->header
.sect_off
);
6662 /* For DWOs coming from DWP files, we don't know the CU length
6663 nor the type's offset in the TU until now. */
6664 dwo_unit
->length
= cu
->header
.get_length ();
6665 dwo_unit
->type_offset_in_tu
= cu
->header
.type_cu_offset_in_tu
;
6667 /* Establish the type offset that can be used to lookup the type.
6668 For DWO files, we don't know it until now. */
6669 sig_type
->type_offset_in_section
6670 = dwo_unit
->sect_off
+ to_underlying (dwo_unit
->type_offset_in_tu
);
6674 info_ptr
= read_and_check_comp_unit_head (per_objfile
, &cu
->header
,
6675 section
, dwo_abbrev_section
,
6676 info_ptr
, rcuh_kind::COMPILE
);
6677 gdb_assert (dwo_unit
->sect_off
== cu
->header
.sect_off
);
6678 /* For DWOs coming from DWP files, we don't know the CU length
6680 dwo_unit
->length
= cu
->header
.get_length ();
6683 dwo_abbrev_section
->read (objfile
);
6684 *result_dwo_abbrev_table
6685 = abbrev_table::read (dwo_abbrev_section
, cu
->header
.abbrev_sect_off
);
6686 init_cu_die_reader (result_reader
, cu
, section
, dwo_unit
->dwo_file
,
6687 result_dwo_abbrev_table
->get ());
6689 /* Read in the die, but leave space to copy over the attributes
6690 from the stub. This has the benefit of simplifying the rest of
6691 the code - all the work to maintain the illusion of a single
6692 DW_TAG_{compile,type}_unit DIE is done here. */
6693 num_extra_attrs
= ((stmt_list
!= NULL
)
6697 + (comp_dir
!= NULL
));
6698 info_ptr
= read_full_die_1 (result_reader
, result_comp_unit_die
, info_ptr
,
6701 /* Copy over the attributes from the stub to the DIE we just read in. */
6702 comp_unit_die
= *result_comp_unit_die
;
6703 i
= comp_unit_die
->num_attrs
;
6704 if (stmt_list
!= NULL
)
6705 comp_unit_die
->attrs
[i
++] = *stmt_list
;
6707 comp_unit_die
->attrs
[i
++] = *low_pc
;
6708 if (high_pc
!= NULL
)
6709 comp_unit_die
->attrs
[i
++] = *high_pc
;
6711 comp_unit_die
->attrs
[i
++] = *ranges
;
6712 if (comp_dir
!= NULL
)
6713 comp_unit_die
->attrs
[i
++] = *comp_dir
;
6714 comp_unit_die
->num_attrs
+= num_extra_attrs
;
6716 if (dwarf_die_debug
)
6718 fprintf_unfiltered (gdb_stdlog
,
6719 "Read die from %s@0x%x of %s:\n",
6720 section
->get_name (),
6721 (unsigned) (begin_info_ptr
- section
->buffer
),
6722 bfd_get_filename (abfd
));
6723 dump_die (comp_unit_die
, dwarf_die_debug
);
6726 /* Skip dummy compilation units. */
6727 if (info_ptr
>= begin_info_ptr
+ dwo_unit
->length
6728 || peek_abbrev_code (abfd
, info_ptr
) == 0)
6731 *result_info_ptr
= info_ptr
;
6735 /* Return the signature of the compile unit, if found. In DWARF 4 and before,
6736 the signature is in the DW_AT_GNU_dwo_id attribute. In DWARF 5 and later, the
6737 signature is part of the header. */
6738 static gdb::optional
<ULONGEST
>
6739 lookup_dwo_id (struct dwarf2_cu
*cu
, struct die_info
* comp_unit_die
)
6741 if (cu
->header
.version
>= 5)
6742 return cu
->header
.signature
;
6743 struct attribute
*attr
;
6744 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_id
, cu
);
6745 if (attr
== nullptr || !attr
->form_is_unsigned ())
6746 return gdb::optional
<ULONGEST
> ();
6747 return attr
->as_unsigned ();
6750 /* Subroutine of cutu_reader to simplify it.
6751 Look up the DWO unit specified by COMP_UNIT_DIE of THIS_CU.
6752 Returns NULL if the specified DWO unit cannot be found. */
6754 static struct dwo_unit
*
6755 lookup_dwo_unit (dwarf2_cu
*cu
, die_info
*comp_unit_die
, const char *dwo_name
)
6757 dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
6758 struct dwo_unit
*dwo_unit
;
6759 const char *comp_dir
;
6761 gdb_assert (cu
!= NULL
);
6763 /* Yeah, we look dwo_name up again, but it simplifies the code. */
6764 dwo_name
= dwarf2_dwo_name (comp_unit_die
, cu
);
6765 comp_dir
= dwarf2_string_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
6767 if (per_cu
->is_debug_types
)
6768 dwo_unit
= lookup_dwo_type_unit (cu
, dwo_name
, comp_dir
);
6771 gdb::optional
<ULONGEST
> signature
= lookup_dwo_id (cu
, comp_unit_die
);
6773 if (!signature
.has_value ())
6774 error (_("Dwarf Error: missing dwo_id for dwo_name %s"
6776 dwo_name
, bfd_get_filename (per_cu
->per_bfd
->obfd
));
6778 dwo_unit
= lookup_dwo_comp_unit (cu
, dwo_name
, comp_dir
, *signature
);
6784 /* Subroutine of cutu_reader to simplify it.
6785 See it for a description of the parameters.
6786 Read a TU directly from a DWO file, bypassing the stub. */
6789 cutu_reader::init_tu_and_read_dwo_dies (dwarf2_per_cu_data
*this_cu
,
6790 dwarf2_per_objfile
*per_objfile
,
6791 dwarf2_cu
*existing_cu
)
6793 struct signatured_type
*sig_type
;
6795 /* Verify we can do the following downcast, and that we have the
6797 gdb_assert (this_cu
->is_debug_types
&& this_cu
->reading_dwo_directly
);
6798 sig_type
= (struct signatured_type
*) this_cu
;
6799 gdb_assert (sig_type
->dwo_unit
!= NULL
);
6803 if (existing_cu
!= nullptr)
6806 gdb_assert (cu
->dwo_unit
== sig_type
->dwo_unit
);
6807 /* There's no need to do the rereading_dwo_cu handling that
6808 cutu_reader does since we don't read the stub. */
6812 /* If an existing_cu is provided, a dwarf2_cu must not exist for this_cu
6813 in per_objfile yet. */
6814 gdb_assert (per_objfile
->get_cu (this_cu
) == nullptr);
6815 m_new_cu
.reset (new dwarf2_cu (this_cu
, per_objfile
));
6816 cu
= m_new_cu
.get ();
6819 /* A future optimization, if needed, would be to use an existing
6820 abbrev table. When reading DWOs with skeletonless TUs, all the TUs
6821 could share abbrev tables. */
6823 if (read_cutu_die_from_dwo (cu
, sig_type
->dwo_unit
,
6824 NULL
/* stub_comp_unit_die */,
6825 sig_type
->dwo_unit
->dwo_file
->comp_dir
,
6828 &m_dwo_abbrev_table
) == 0)
6835 /* Initialize a CU (or TU) and read its DIEs.
6836 If the CU defers to a DWO file, read the DWO file as well.
6838 ABBREV_TABLE, if non-NULL, is the abbreviation table to use.
6839 Otherwise the table specified in the comp unit header is read in and used.
6840 This is an optimization for when we already have the abbrev table.
6842 If EXISTING_CU is non-NULL, then use it. Otherwise, a new CU is
6845 cutu_reader::cutu_reader (dwarf2_per_cu_data
*this_cu
,
6846 dwarf2_per_objfile
*per_objfile
,
6847 struct abbrev_table
*abbrev_table
,
6848 dwarf2_cu
*existing_cu
,
6850 : die_reader_specs
{},
6853 struct objfile
*objfile
= per_objfile
->objfile
;
6854 struct dwarf2_section_info
*section
= this_cu
->section
;
6855 bfd
*abfd
= section
->get_bfd_owner ();
6856 const gdb_byte
*begin_info_ptr
;
6857 struct signatured_type
*sig_type
= NULL
;
6858 struct dwarf2_section_info
*abbrev_section
;
6859 /* Non-zero if CU currently points to a DWO file and we need to
6860 reread it. When this happens we need to reread the skeleton die
6861 before we can reread the DWO file (this only applies to CUs, not TUs). */
6862 int rereading_dwo_cu
= 0;
6864 if (dwarf_die_debug
)
6865 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset %s\n",
6866 this_cu
->is_debug_types
? "type" : "comp",
6867 sect_offset_str (this_cu
->sect_off
));
6869 /* If we're reading a TU directly from a DWO file, including a virtual DWO
6870 file (instead of going through the stub), short-circuit all of this. */
6871 if (this_cu
->reading_dwo_directly
)
6873 /* Narrow down the scope of possibilities to have to understand. */
6874 gdb_assert (this_cu
->is_debug_types
);
6875 gdb_assert (abbrev_table
== NULL
);
6876 init_tu_and_read_dwo_dies (this_cu
, per_objfile
, existing_cu
);
6880 /* This is cheap if the section is already read in. */
6881 section
->read (objfile
);
6883 begin_info_ptr
= info_ptr
= section
->buffer
+ to_underlying (this_cu
->sect_off
);
6885 abbrev_section
= get_abbrev_section_for_cu (this_cu
);
6889 if (existing_cu
!= nullptr)
6892 /* If this CU is from a DWO file we need to start over, we need to
6893 refetch the attributes from the skeleton CU.
6894 This could be optimized by retrieving those attributes from when we
6895 were here the first time: the previous comp_unit_die was stored in
6896 comp_unit_obstack. But there's no data yet that we need this
6898 if (cu
->dwo_unit
!= NULL
)
6899 rereading_dwo_cu
= 1;
6903 /* If an existing_cu is provided, a dwarf2_cu must not exist for this_cu
6904 in per_objfile yet. */
6905 gdb_assert (per_objfile
->get_cu (this_cu
) == nullptr);
6906 m_new_cu
.reset (new dwarf2_cu (this_cu
, per_objfile
));
6907 cu
= m_new_cu
.get ();
6910 /* Get the header. */
6911 if (to_underlying (cu
->header
.first_die_cu_offset
) != 0 && !rereading_dwo_cu
)
6913 /* We already have the header, there's no need to read it in again. */
6914 info_ptr
+= to_underlying (cu
->header
.first_die_cu_offset
);
6918 if (this_cu
->is_debug_types
)
6920 info_ptr
= read_and_check_comp_unit_head (per_objfile
, &cu
->header
,
6921 section
, abbrev_section
,
6922 info_ptr
, rcuh_kind::TYPE
);
6924 /* Since per_cu is the first member of struct signatured_type,
6925 we can go from a pointer to one to a pointer to the other. */
6926 sig_type
= (struct signatured_type
*) this_cu
;
6927 gdb_assert (sig_type
->signature
== cu
->header
.signature
);
6928 gdb_assert (sig_type
->type_offset_in_tu
6929 == cu
->header
.type_cu_offset_in_tu
);
6930 gdb_assert (this_cu
->sect_off
== cu
->header
.sect_off
);
6932 /* LENGTH has not been set yet for type units if we're
6933 using .gdb_index. */
6934 this_cu
->length
= cu
->header
.get_length ();
6936 /* Establish the type offset that can be used to lookup the type. */
6937 sig_type
->type_offset_in_section
=
6938 this_cu
->sect_off
+ to_underlying (sig_type
->type_offset_in_tu
);
6940 this_cu
->dwarf_version
= cu
->header
.version
;
6944 info_ptr
= read_and_check_comp_unit_head (per_objfile
, &cu
->header
,
6945 section
, abbrev_section
,
6947 rcuh_kind::COMPILE
);
6949 gdb_assert (this_cu
->sect_off
== cu
->header
.sect_off
);
6950 if (this_cu
->length
== 0)
6951 this_cu
->length
= cu
->header
.get_length ();
6953 gdb_assert (this_cu
->length
== cu
->header
.get_length ());
6954 this_cu
->dwarf_version
= cu
->header
.version
;
6958 /* Skip dummy compilation units. */
6959 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
6960 || peek_abbrev_code (abfd
, info_ptr
) == 0)
6966 /* If we don't have them yet, read the abbrevs for this compilation unit.
6967 And if we need to read them now, make sure they're freed when we're
6969 if (abbrev_table
!= NULL
)
6970 gdb_assert (cu
->header
.abbrev_sect_off
== abbrev_table
->sect_off
);
6973 abbrev_section
->read (objfile
);
6974 m_abbrev_table_holder
6975 = abbrev_table::read (abbrev_section
, cu
->header
.abbrev_sect_off
);
6976 abbrev_table
= m_abbrev_table_holder
.get ();
6979 /* Read the top level CU/TU die. */
6980 init_cu_die_reader (this, cu
, section
, NULL
, abbrev_table
);
6981 info_ptr
= read_full_die (this, &comp_unit_die
, info_ptr
);
6983 if (skip_partial
&& comp_unit_die
->tag
== DW_TAG_partial_unit
)
6989 /* If we are in a DWO stub, process it and then read in the "real" CU/TU
6990 from the DWO file. read_cutu_die_from_dwo will allocate the abbreviation
6991 table from the DWO file and pass the ownership over to us. It will be
6992 referenced from READER, so we must make sure to free it after we're done
6995 Note that if USE_EXISTING_OK != 0, and THIS_CU->cu already contains a
6996 DWO CU, that this test will fail (the attribute will not be present). */
6997 const char *dwo_name
= dwarf2_dwo_name (comp_unit_die
, cu
);
6998 if (dwo_name
!= nullptr)
7000 struct dwo_unit
*dwo_unit
;
7001 struct die_info
*dwo_comp_unit_die
;
7003 if (comp_unit_die
->has_children
)
7005 complaint (_("compilation unit with DW_AT_GNU_dwo_name"
7006 " has children (offset %s) [in module %s]"),
7007 sect_offset_str (this_cu
->sect_off
),
7008 bfd_get_filename (abfd
));
7010 dwo_unit
= lookup_dwo_unit (cu
, comp_unit_die
, dwo_name
);
7011 if (dwo_unit
!= NULL
)
7013 if (read_cutu_die_from_dwo (cu
, dwo_unit
,
7014 comp_unit_die
, NULL
,
7017 &m_dwo_abbrev_table
) == 0)
7023 comp_unit_die
= dwo_comp_unit_die
;
7027 /* Yikes, we couldn't find the rest of the DIE, we only have
7028 the stub. A complaint has already been logged. There's
7029 not much more we can do except pass on the stub DIE to
7030 die_reader_func. We don't want to throw an error on bad
7037 cutu_reader::keep ()
7039 /* Done, clean up. */
7040 gdb_assert (!dummy_p
);
7041 if (m_new_cu
!= NULL
)
7043 /* Save this dwarf2_cu in the per_objfile. The per_objfile owns it
7045 dwarf2_per_objfile
*per_objfile
= m_new_cu
->per_objfile
;
7046 per_objfile
->set_cu (m_this_cu
, m_new_cu
.release ());
7050 /* Read CU/TU THIS_CU but do not follow DW_AT_GNU_dwo_name (DW_AT_dwo_name)
7051 if present. DWO_FILE, if non-NULL, is the DWO file to read (the caller is
7052 assumed to have already done the lookup to find the DWO file).
7054 The caller is required to fill in THIS_CU->section, THIS_CU->offset, and
7055 THIS_CU->is_debug_types, but nothing else.
7057 We fill in THIS_CU->length.
7059 THIS_CU->cu is always freed when done.
7060 This is done in order to not leave THIS_CU->cu in a state where we have
7061 to care whether it refers to the "main" CU or the DWO CU.
7063 When parent_cu is passed, it is used to provide a default value for
7064 str_offsets_base and addr_base from the parent. */
7066 cutu_reader::cutu_reader (dwarf2_per_cu_data
*this_cu
,
7067 dwarf2_per_objfile
*per_objfile
,
7068 struct dwarf2_cu
*parent_cu
,
7069 struct dwo_file
*dwo_file
)
7070 : die_reader_specs
{},
7073 struct objfile
*objfile
= per_objfile
->objfile
;
7074 struct dwarf2_section_info
*section
= this_cu
->section
;
7075 bfd
*abfd
= section
->get_bfd_owner ();
7076 struct dwarf2_section_info
*abbrev_section
;
7077 const gdb_byte
*begin_info_ptr
, *info_ptr
;
7079 if (dwarf_die_debug
)
7080 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset %s\n",
7081 this_cu
->is_debug_types
? "type" : "comp",
7082 sect_offset_str (this_cu
->sect_off
));
7084 gdb_assert (per_objfile
->get_cu (this_cu
) == nullptr);
7086 abbrev_section
= (dwo_file
!= NULL
7087 ? &dwo_file
->sections
.abbrev
7088 : get_abbrev_section_for_cu (this_cu
));
7090 /* This is cheap if the section is already read in. */
7091 section
->read (objfile
);
7093 m_new_cu
.reset (new dwarf2_cu (this_cu
, per_objfile
));
7095 begin_info_ptr
= info_ptr
= section
->buffer
+ to_underlying (this_cu
->sect_off
);
7096 info_ptr
= read_and_check_comp_unit_head (per_objfile
, &m_new_cu
->header
,
7097 section
, abbrev_section
, info_ptr
,
7098 (this_cu
->is_debug_types
7100 : rcuh_kind::COMPILE
));
7102 if (parent_cu
!= nullptr)
7104 m_new_cu
->str_offsets_base
= parent_cu
->str_offsets_base
;
7105 m_new_cu
->addr_base
= parent_cu
->addr_base
;
7107 this_cu
->length
= m_new_cu
->header
.get_length ();
7109 /* Skip dummy compilation units. */
7110 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
7111 || peek_abbrev_code (abfd
, info_ptr
) == 0)
7117 abbrev_section
->read (objfile
);
7118 m_abbrev_table_holder
7119 = abbrev_table::read (abbrev_section
, m_new_cu
->header
.abbrev_sect_off
);
7121 init_cu_die_reader (this, m_new_cu
.get (), section
, dwo_file
,
7122 m_abbrev_table_holder
.get ());
7123 info_ptr
= read_full_die (this, &comp_unit_die
, info_ptr
);
7127 /* Type Unit Groups.
7129 Type Unit Groups are a way to collapse the set of all TUs (type units) into
7130 a more manageable set. The grouping is done by DW_AT_stmt_list entry
7131 so that all types coming from the same compilation (.o file) are grouped
7132 together. A future step could be to put the types in the same symtab as
7133 the CU the types ultimately came from. */
7136 hash_type_unit_group (const void *item
)
7138 const struct type_unit_group
*tu_group
7139 = (const struct type_unit_group
*) item
;
7141 return hash_stmt_list_entry (&tu_group
->hash
);
7145 eq_type_unit_group (const void *item_lhs
, const void *item_rhs
)
7147 const struct type_unit_group
*lhs
= (const struct type_unit_group
*) item_lhs
;
7148 const struct type_unit_group
*rhs
= (const struct type_unit_group
*) item_rhs
;
7150 return eq_stmt_list_entry (&lhs
->hash
, &rhs
->hash
);
7153 /* Allocate a hash table for type unit groups. */
7156 allocate_type_unit_groups_table ()
7158 return htab_up (htab_create_alloc (3,
7159 hash_type_unit_group
,
7161 NULL
, xcalloc
, xfree
));
7164 /* Type units that don't have DW_AT_stmt_list are grouped into their own
7165 partial symtabs. We combine several TUs per psymtab to not let the size
7166 of any one psymtab grow too big. */
7167 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB (1 << 31)
7168 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE 10
7170 /* Helper routine for get_type_unit_group.
7171 Create the type_unit_group object used to hold one or more TUs. */
7173 static struct type_unit_group
*
7174 create_type_unit_group (struct dwarf2_cu
*cu
, sect_offset line_offset_struct
)
7176 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
7177 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
7178 struct dwarf2_per_cu_data
*per_cu
;
7179 struct type_unit_group
*tu_group
;
7181 tu_group
= OBSTACK_ZALLOC (&per_bfd
->obstack
, type_unit_group
);
7182 per_cu
= &tu_group
->per_cu
;
7183 per_cu
->per_bfd
= per_bfd
;
7185 if (per_bfd
->using_index
)
7187 per_cu
->v
.quick
= OBSTACK_ZALLOC (&per_bfd
->obstack
,
7188 struct dwarf2_per_cu_quick_data
);
7192 unsigned int line_offset
= to_underlying (line_offset_struct
);
7193 dwarf2_psymtab
*pst
;
7196 /* Give the symtab a useful name for debug purposes. */
7197 if ((line_offset
& NO_STMT_LIST_TYPE_UNIT_PSYMTAB
) != 0)
7198 name
= string_printf ("<type_units_%d>",
7199 (line_offset
& ~NO_STMT_LIST_TYPE_UNIT_PSYMTAB
));
7201 name
= string_printf ("<type_units_at_0x%x>", line_offset
);
7203 pst
= create_partial_symtab (per_cu
, per_objfile
, name
.c_str ());
7204 pst
->anonymous
= true;
7207 tu_group
->hash
.dwo_unit
= cu
->dwo_unit
;
7208 tu_group
->hash
.line_sect_off
= line_offset_struct
;
7213 /* Look up the type_unit_group for type unit CU, and create it if necessary.
7214 STMT_LIST is a DW_AT_stmt_list attribute. */
7216 static struct type_unit_group
*
7217 get_type_unit_group (struct dwarf2_cu
*cu
, const struct attribute
*stmt_list
)
7219 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
7220 struct tu_stats
*tu_stats
= &per_objfile
->per_bfd
->tu_stats
;
7221 struct type_unit_group
*tu_group
;
7223 unsigned int line_offset
;
7224 struct type_unit_group type_unit_group_for_lookup
;
7226 if (per_objfile
->per_bfd
->type_unit_groups
== NULL
)
7227 per_objfile
->per_bfd
->type_unit_groups
= allocate_type_unit_groups_table ();
7229 /* Do we need to create a new group, or can we use an existing one? */
7231 if (stmt_list
!= nullptr && stmt_list
->form_is_unsigned ())
7233 line_offset
= stmt_list
->as_unsigned ();
7234 ++tu_stats
->nr_symtab_sharers
;
7238 /* Ugh, no stmt_list. Rare, but we have to handle it.
7239 We can do various things here like create one group per TU or
7240 spread them over multiple groups to split up the expansion work.
7241 To avoid worst case scenarios (too many groups or too large groups)
7242 we, umm, group them in bunches. */
7243 line_offset
= (NO_STMT_LIST_TYPE_UNIT_PSYMTAB
7244 | (tu_stats
->nr_stmt_less_type_units
7245 / NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE
));
7246 ++tu_stats
->nr_stmt_less_type_units
;
7249 type_unit_group_for_lookup
.hash
.dwo_unit
= cu
->dwo_unit
;
7250 type_unit_group_for_lookup
.hash
.line_sect_off
= (sect_offset
) line_offset
;
7251 slot
= htab_find_slot (per_objfile
->per_bfd
->type_unit_groups
.get (),
7252 &type_unit_group_for_lookup
, INSERT
);
7255 tu_group
= (struct type_unit_group
*) *slot
;
7256 gdb_assert (tu_group
!= NULL
);
7260 sect_offset line_offset_struct
= (sect_offset
) line_offset
;
7261 tu_group
= create_type_unit_group (cu
, line_offset_struct
);
7263 ++tu_stats
->nr_symtabs
;
7269 /* Partial symbol tables. */
7271 /* Create a psymtab named NAME and assign it to PER_CU.
7273 The caller must fill in the following details:
7274 dirname, textlow, texthigh. */
7276 static dwarf2_psymtab
*
7277 create_partial_symtab (dwarf2_per_cu_data
*per_cu
,
7278 dwarf2_per_objfile
*per_objfile
,
7282 = new dwarf2_psymtab (name
, per_objfile
->per_bfd
->partial_symtabs
.get (),
7283 per_objfile
->objfile
->per_bfd
, per_cu
);
7285 pst
->psymtabs_addrmap_supported
= true;
7287 /* This is the glue that links PST into GDB's symbol API. */
7288 per_cu
->v
.psymtab
= pst
;
7293 /* DIE reader function for process_psymtab_comp_unit. */
7296 process_psymtab_comp_unit_reader (const struct die_reader_specs
*reader
,
7297 const gdb_byte
*info_ptr
,
7298 struct die_info
*comp_unit_die
,
7299 enum language pretend_language
)
7301 struct dwarf2_cu
*cu
= reader
->cu
;
7302 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
7303 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
7304 struct objfile
*objfile
= per_objfile
->objfile
;
7305 struct gdbarch
*gdbarch
= objfile
->arch ();
7306 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
7308 CORE_ADDR best_lowpc
= 0, best_highpc
= 0;
7309 dwarf2_psymtab
*pst
;
7310 enum pc_bounds_kind cu_bounds_kind
;
7311 const char *filename
;
7313 gdb_assert (! per_cu
->is_debug_types
);
7315 prepare_one_comp_unit (cu
, comp_unit_die
, pretend_language
);
7317 /* Allocate a new partial symbol table structure. */
7318 gdb::unique_xmalloc_ptr
<char> debug_filename
;
7319 static const char artificial
[] = "<artificial>";
7320 filename
= dwarf2_string_attr (comp_unit_die
, DW_AT_name
, cu
);
7321 if (filename
== NULL
)
7323 else if (strcmp (filename
, artificial
) == 0)
7325 debug_filename
.reset (concat (artificial
, "@",
7326 sect_offset_str (per_cu
->sect_off
),
7328 filename
= debug_filename
.get ();
7331 pst
= create_partial_symtab (per_cu
, per_objfile
, filename
);
7333 /* This must be done before calling dwarf2_build_include_psymtabs. */
7334 pst
->dirname
= dwarf2_string_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
7336 baseaddr
= objfile
->text_section_offset ();
7338 dwarf2_find_base_address (comp_unit_die
, cu
);
7340 /* Possibly set the default values of LOWPC and HIGHPC from
7342 cu_bounds_kind
= dwarf2_get_pc_bounds (comp_unit_die
, &best_lowpc
,
7343 &best_highpc
, cu
, pst
);
7344 if (cu_bounds_kind
== PC_BOUNDS_HIGH_LOW
&& best_lowpc
< best_highpc
)
7347 = (gdbarch_adjust_dwarf2_addr (gdbarch
, best_lowpc
+ baseaddr
)
7350 = (gdbarch_adjust_dwarf2_addr (gdbarch
, best_highpc
+ baseaddr
)
7352 /* Store the contiguous range if it is not empty; it can be
7353 empty for CUs with no code. */
7354 addrmap_set_empty (per_bfd
->partial_symtabs
->psymtabs_addrmap
,
7358 /* Check if comp unit has_children.
7359 If so, read the rest of the partial symbols from this comp unit.
7360 If not, there's no more debug_info for this comp unit. */
7361 if (comp_unit_die
->has_children
)
7363 struct partial_die_info
*first_die
;
7364 CORE_ADDR lowpc
, highpc
;
7366 lowpc
= ((CORE_ADDR
) -1);
7367 highpc
= ((CORE_ADDR
) 0);
7369 first_die
= load_partial_dies (reader
, info_ptr
, 1);
7371 scan_partial_symbols (first_die
, &lowpc
, &highpc
,
7372 cu_bounds_kind
<= PC_BOUNDS_INVALID
, cu
);
7374 /* If we didn't find a lowpc, set it to highpc to avoid
7375 complaints from `maint check'. */
7376 if (lowpc
== ((CORE_ADDR
) -1))
7379 /* If the compilation unit didn't have an explicit address range,
7380 then use the information extracted from its child dies. */
7381 if (cu_bounds_kind
<= PC_BOUNDS_INVALID
)
7384 best_highpc
= highpc
;
7387 pst
->set_text_low (gdbarch_adjust_dwarf2_addr (gdbarch
,
7388 best_lowpc
+ baseaddr
)
7390 pst
->set_text_high (gdbarch_adjust_dwarf2_addr (gdbarch
,
7391 best_highpc
+ baseaddr
)
7396 if (!cu
->per_cu
->imported_symtabs_empty ())
7399 int len
= cu
->per_cu
->imported_symtabs_size ();
7401 /* Fill in 'dependencies' here; we fill in 'users' in a
7403 pst
->number_of_dependencies
= len
;
7405 = per_bfd
->partial_symtabs
->allocate_dependencies (len
);
7406 for (i
= 0; i
< len
; ++i
)
7408 pst
->dependencies
[i
]
7409 = cu
->per_cu
->imported_symtabs
->at (i
)->v
.psymtab
;
7412 cu
->per_cu
->imported_symtabs_free ();
7415 /* Get the list of files included in the current compilation unit,
7416 and build a psymtab for each of them. */
7417 dwarf2_build_include_psymtabs (cu
, comp_unit_die
, pst
);
7419 dwarf_read_debug_printf ("Psymtab for %s unit @%s: %s - %s"
7420 ", %d global, %d static syms",
7421 per_cu
->is_debug_types
? "type" : "comp",
7422 sect_offset_str (per_cu
->sect_off
),
7423 paddress (gdbarch
, pst
->text_low (objfile
)),
7424 paddress (gdbarch
, pst
->text_high (objfile
)),
7425 (int) pst
->global_psymbols
.size (),
7426 (int) pst
->static_psymbols
.size ());
7429 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
7430 Process compilation unit THIS_CU for a psymtab. */
7433 process_psymtab_comp_unit (dwarf2_per_cu_data
*this_cu
,
7434 dwarf2_per_objfile
*per_objfile
,
7435 bool want_partial_unit
,
7436 enum language pretend_language
)
7438 /* If this compilation unit was already read in, free the
7439 cached copy in order to read it in again. This is
7440 necessary because we skipped some symbols when we first
7441 read in the compilation unit (see load_partial_dies).
7442 This problem could be avoided, but the benefit is unclear. */
7443 per_objfile
->remove_cu (this_cu
);
7445 cutu_reader
reader (this_cu
, per_objfile
, nullptr, nullptr, false);
7447 switch (reader
.comp_unit_die
->tag
)
7449 case DW_TAG_compile_unit
:
7450 this_cu
->unit_type
= DW_UT_compile
;
7452 case DW_TAG_partial_unit
:
7453 this_cu
->unit_type
= DW_UT_partial
;
7455 case DW_TAG_type_unit
:
7456 this_cu
->unit_type
= DW_UT_type
;
7459 error (_("Dwarf Error: unexpected tag '%s' at offset %s [in module %s]"),
7460 dwarf_tag_name (reader
.comp_unit_die
->tag
),
7461 sect_offset_str (reader
.cu
->per_cu
->sect_off
),
7462 objfile_name (per_objfile
->objfile
));
7469 else if (this_cu
->is_debug_types
)
7470 build_type_psymtabs_reader (&reader
, reader
.info_ptr
,
7471 reader
.comp_unit_die
);
7472 else if (want_partial_unit
7473 || reader
.comp_unit_die
->tag
!= DW_TAG_partial_unit
)
7474 process_psymtab_comp_unit_reader (&reader
, reader
.info_ptr
,
7475 reader
.comp_unit_die
,
7478 this_cu
->lang
= reader
.cu
->language
;
7480 /* Age out any secondary CUs. */
7481 per_objfile
->age_comp_units ();
7484 /* Reader function for build_type_psymtabs. */
7487 build_type_psymtabs_reader (const struct die_reader_specs
*reader
,
7488 const gdb_byte
*info_ptr
,
7489 struct die_info
*type_unit_die
)
7491 dwarf2_per_objfile
*per_objfile
= reader
->cu
->per_objfile
;
7492 struct dwarf2_cu
*cu
= reader
->cu
;
7493 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
7494 struct signatured_type
*sig_type
;
7495 struct type_unit_group
*tu_group
;
7496 struct attribute
*attr
;
7497 struct partial_die_info
*first_die
;
7498 CORE_ADDR lowpc
, highpc
;
7499 dwarf2_psymtab
*pst
;
7501 gdb_assert (per_cu
->is_debug_types
);
7502 sig_type
= (struct signatured_type
*) per_cu
;
7504 if (! type_unit_die
->has_children
)
7507 attr
= type_unit_die
->attr (DW_AT_stmt_list
);
7508 tu_group
= get_type_unit_group (cu
, attr
);
7510 if (tu_group
->tus
== nullptr)
7511 tu_group
->tus
= new std::vector
<signatured_type
*>;
7512 tu_group
->tus
->push_back (sig_type
);
7514 prepare_one_comp_unit (cu
, type_unit_die
, language_minimal
);
7515 pst
= create_partial_symtab (per_cu
, per_objfile
, "");
7516 pst
->anonymous
= true;
7518 first_die
= load_partial_dies (reader
, info_ptr
, 1);
7520 lowpc
= (CORE_ADDR
) -1;
7521 highpc
= (CORE_ADDR
) 0;
7522 scan_partial_symbols (first_die
, &lowpc
, &highpc
, 0, cu
);
7527 /* Struct used to sort TUs by their abbreviation table offset. */
7529 struct tu_abbrev_offset
7531 tu_abbrev_offset (signatured_type
*sig_type_
, sect_offset abbrev_offset_
)
7532 : sig_type (sig_type_
), abbrev_offset (abbrev_offset_
)
7535 signatured_type
*sig_type
;
7536 sect_offset abbrev_offset
;
7539 /* Helper routine for build_type_psymtabs_1, passed to std::sort. */
7542 sort_tu_by_abbrev_offset (const struct tu_abbrev_offset
&a
,
7543 const struct tu_abbrev_offset
&b
)
7545 return a
.abbrev_offset
< b
.abbrev_offset
;
7548 /* Efficiently read all the type units.
7549 This does the bulk of the work for build_type_psymtabs.
7551 The efficiency is because we sort TUs by the abbrev table they use and
7552 only read each abbrev table once. In one program there are 200K TUs
7553 sharing 8K abbrev tables.
7555 The main purpose of this function is to support building the
7556 dwarf2_per_objfile->per_bfd->type_unit_groups table.
7557 TUs typically share the DW_AT_stmt_list of the CU they came from, so we
7558 can collapse the search space by grouping them by stmt_list.
7559 The savings can be significant, in the same program from above the 200K TUs
7560 share 8K stmt_list tables.
7562 FUNC is expected to call get_type_unit_group, which will create the
7563 struct type_unit_group if necessary and add it to
7564 dwarf2_per_objfile->per_bfd->type_unit_groups. */
7567 build_type_psymtabs_1 (dwarf2_per_objfile
*per_objfile
)
7569 struct tu_stats
*tu_stats
= &per_objfile
->per_bfd
->tu_stats
;
7570 abbrev_table_up abbrev_table
;
7571 sect_offset abbrev_offset
;
7573 /* It's up to the caller to not call us multiple times. */
7574 gdb_assert (per_objfile
->per_bfd
->type_unit_groups
== NULL
);
7576 if (per_objfile
->per_bfd
->all_type_units
.empty ())
7579 /* TUs typically share abbrev tables, and there can be way more TUs than
7580 abbrev tables. Sort by abbrev table to reduce the number of times we
7581 read each abbrev table in.
7582 Alternatives are to punt or to maintain a cache of abbrev tables.
7583 This is simpler and efficient enough for now.
7585 Later we group TUs by their DW_AT_stmt_list value (as this defines the
7586 symtab to use). Typically TUs with the same abbrev offset have the same
7587 stmt_list value too so in practice this should work well.
7589 The basic algorithm here is:
7591 sort TUs by abbrev table
7592 for each TU with same abbrev table:
7593 read abbrev table if first user
7594 read TU top level DIE
7595 [IWBN if DWO skeletons had DW_AT_stmt_list]
7598 dwarf_read_debug_printf ("Building type unit groups ...");
7600 /* Sort in a separate table to maintain the order of all_type_units
7601 for .gdb_index: TU indices directly index all_type_units. */
7602 std::vector
<tu_abbrev_offset
> sorted_by_abbrev
;
7603 sorted_by_abbrev
.reserve (per_objfile
->per_bfd
->all_type_units
.size ());
7605 for (signatured_type
*sig_type
: per_objfile
->per_bfd
->all_type_units
)
7606 sorted_by_abbrev
.emplace_back
7607 (sig_type
, read_abbrev_offset (per_objfile
, sig_type
->per_cu
.section
,
7608 sig_type
->per_cu
.sect_off
));
7610 std::sort (sorted_by_abbrev
.begin (), sorted_by_abbrev
.end (),
7611 sort_tu_by_abbrev_offset
);
7613 abbrev_offset
= (sect_offset
) ~(unsigned) 0;
7615 for (const tu_abbrev_offset
&tu
: sorted_by_abbrev
)
7617 /* Switch to the next abbrev table if necessary. */
7618 if (abbrev_table
== NULL
7619 || tu
.abbrev_offset
!= abbrev_offset
)
7621 abbrev_offset
= tu
.abbrev_offset
;
7622 per_objfile
->per_bfd
->abbrev
.read (per_objfile
->objfile
);
7624 abbrev_table::read (&per_objfile
->per_bfd
->abbrev
, abbrev_offset
);
7625 ++tu_stats
->nr_uniq_abbrev_tables
;
7628 cutu_reader
reader (&tu
.sig_type
->per_cu
, per_objfile
,
7629 abbrev_table
.get (), nullptr, false);
7630 if (!reader
.dummy_p
)
7631 build_type_psymtabs_reader (&reader
, reader
.info_ptr
,
7632 reader
.comp_unit_die
);
7636 /* Print collected type unit statistics. */
7639 print_tu_stats (dwarf2_per_objfile
*per_objfile
)
7641 struct tu_stats
*tu_stats
= &per_objfile
->per_bfd
->tu_stats
;
7643 dwarf_read_debug_printf ("Type unit statistics:");
7644 dwarf_read_debug_printf (" %zu TUs",
7645 per_objfile
->per_bfd
->all_type_units
.size ());
7646 dwarf_read_debug_printf (" %d uniq abbrev tables",
7647 tu_stats
->nr_uniq_abbrev_tables
);
7648 dwarf_read_debug_printf (" %d symtabs from stmt_list entries",
7649 tu_stats
->nr_symtabs
);
7650 dwarf_read_debug_printf (" %d symtab sharers",
7651 tu_stats
->nr_symtab_sharers
);
7652 dwarf_read_debug_printf (" %d type units without a stmt_list",
7653 tu_stats
->nr_stmt_less_type_units
);
7654 dwarf_read_debug_printf (" %d all_type_units reallocs",
7655 tu_stats
->nr_all_type_units_reallocs
);
7658 /* Traversal function for build_type_psymtabs. */
7661 build_type_psymtab_dependencies (void **slot
, void *info
)
7663 dwarf2_per_objfile
*per_objfile
= (dwarf2_per_objfile
*) info
;
7664 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
7665 struct type_unit_group
*tu_group
= (struct type_unit_group
*) *slot
;
7666 struct dwarf2_per_cu_data
*per_cu
= &tu_group
->per_cu
;
7667 dwarf2_psymtab
*pst
= per_cu
->v
.psymtab
;
7668 int len
= (tu_group
->tus
== nullptr) ? 0 : tu_group
->tus
->size ();
7671 gdb_assert (len
> 0);
7672 gdb_assert (per_cu
->type_unit_group_p ());
7674 pst
->number_of_dependencies
= len
;
7675 pst
->dependencies
= per_bfd
->partial_symtabs
->allocate_dependencies (len
);
7676 for (i
= 0; i
< len
; ++i
)
7678 struct signatured_type
*iter
= tu_group
->tus
->at (i
);
7679 gdb_assert (iter
->per_cu
.is_debug_types
);
7680 pst
->dependencies
[i
] = iter
->per_cu
.v
.psymtab
;
7681 iter
->type_unit_group
= tu_group
;
7684 delete tu_group
->tus
;
7685 tu_group
->tus
= nullptr;
7690 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
7691 Build partial symbol tables for the .debug_types comp-units. */
7694 build_type_psymtabs (dwarf2_per_objfile
*per_objfile
)
7696 if (! create_all_type_units (per_objfile
))
7699 build_type_psymtabs_1 (per_objfile
);
7702 /* Traversal function for process_skeletonless_type_unit.
7703 Read a TU in a DWO file and build partial symbols for it. */
7706 process_skeletonless_type_unit (void **slot
, void *info
)
7708 struct dwo_unit
*dwo_unit
= (struct dwo_unit
*) *slot
;
7709 dwarf2_per_objfile
*per_objfile
= (dwarf2_per_objfile
*) info
;
7710 struct signatured_type find_entry
, *entry
;
7712 /* If this TU doesn't exist in the global table, add it and read it in. */
7714 if (per_objfile
->per_bfd
->signatured_types
== NULL
)
7715 per_objfile
->per_bfd
->signatured_types
= allocate_signatured_type_table ();
7717 find_entry
.signature
= dwo_unit
->signature
;
7718 slot
= htab_find_slot (per_objfile
->per_bfd
->signatured_types
.get (),
7719 &find_entry
, INSERT
);
7720 /* If we've already seen this type there's nothing to do. What's happening
7721 is we're doing our own version of comdat-folding here. */
7725 /* This does the job that create_all_type_units would have done for
7727 entry
= add_type_unit (per_objfile
, dwo_unit
->signature
, slot
);
7728 fill_in_sig_entry_from_dwo_entry (per_objfile
, entry
, dwo_unit
);
7731 /* This does the job that build_type_psymtabs_1 would have done. */
7732 cutu_reader
reader (&entry
->per_cu
, per_objfile
, nullptr, nullptr, false);
7733 if (!reader
.dummy_p
)
7734 build_type_psymtabs_reader (&reader
, reader
.info_ptr
,
7735 reader
.comp_unit_die
);
7740 /* Traversal function for process_skeletonless_type_units. */
7743 process_dwo_file_for_skeletonless_type_units (void **slot
, void *info
)
7745 struct dwo_file
*dwo_file
= (struct dwo_file
*) *slot
;
7747 if (dwo_file
->tus
!= NULL
)
7748 htab_traverse_noresize (dwo_file
->tus
.get (),
7749 process_skeletonless_type_unit
, info
);
7754 /* Scan all TUs of DWO files, verifying we've processed them.
7755 This is needed in case a TU was emitted without its skeleton.
7756 Note: This can't be done until we know what all the DWO files are. */
7759 process_skeletonless_type_units (dwarf2_per_objfile
*per_objfile
)
7761 /* Skeletonless TUs in DWP files without .gdb_index is not supported yet. */
7762 if (get_dwp_file (per_objfile
) == NULL
7763 && per_objfile
->per_bfd
->dwo_files
!= NULL
)
7765 htab_traverse_noresize (per_objfile
->per_bfd
->dwo_files
.get (),
7766 process_dwo_file_for_skeletonless_type_units
,
7771 /* Compute the 'user' field for each psymtab in DWARF2_PER_OBJFILE. */
7774 set_partial_user (dwarf2_per_objfile
*per_objfile
)
7776 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
7778 dwarf2_psymtab
*pst
= per_cu
->v
.psymtab
;
7783 for (int j
= 0; j
< pst
->number_of_dependencies
; ++j
)
7785 /* Set the 'user' field only if it is not already set. */
7786 if (pst
->dependencies
[j
]->user
== NULL
)
7787 pst
->dependencies
[j
]->user
= pst
;
7792 /* Build the partial symbol table by doing a quick pass through the
7793 .debug_info and .debug_abbrev sections. */
7796 dwarf2_build_psymtabs_hard (dwarf2_per_objfile
*per_objfile
)
7798 struct objfile
*objfile
= per_objfile
->objfile
;
7799 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
7801 dwarf_read_debug_printf ("Building psymtabs of objfile %s ...",
7802 objfile_name (objfile
));
7804 scoped_restore restore_reading_psyms
7805 = make_scoped_restore (&per_bfd
->reading_partial_symbols
, true);
7807 per_bfd
->info
.read (objfile
);
7809 /* Any cached compilation units will be linked by the per-objfile
7810 read_in_chain. Make sure to free them when we're done. */
7811 free_cached_comp_units
freer (per_objfile
);
7813 build_type_psymtabs (per_objfile
);
7815 create_all_comp_units (per_objfile
);
7817 /* Create a temporary address map on a temporary obstack. We later
7818 copy this to the final obstack. */
7819 auto_obstack temp_obstack
;
7821 scoped_restore save_psymtabs_addrmap
7822 = make_scoped_restore (&per_bfd
->partial_symtabs
->psymtabs_addrmap
,
7823 addrmap_create_mutable (&temp_obstack
));
7825 for (dwarf2_per_cu_data
*per_cu
: per_bfd
->all_comp_units
)
7827 if (per_cu
->v
.psymtab
!= NULL
)
7828 /* In case a forward DW_TAG_imported_unit has read the CU already. */
7830 process_psymtab_comp_unit (per_cu
, per_objfile
, false,
7834 /* This has to wait until we read the CUs, we need the list of DWOs. */
7835 process_skeletonless_type_units (per_objfile
);
7837 /* Now that all TUs have been processed we can fill in the dependencies. */
7838 if (per_bfd
->type_unit_groups
!= NULL
)
7840 htab_traverse_noresize (per_bfd
->type_unit_groups
.get (),
7841 build_type_psymtab_dependencies
, per_objfile
);
7844 if (dwarf_read_debug
> 0)
7845 print_tu_stats (per_objfile
);
7847 set_partial_user (per_objfile
);
7849 per_bfd
->partial_symtabs
->psymtabs_addrmap
7850 = addrmap_create_fixed (per_bfd
->partial_symtabs
->psymtabs_addrmap
,
7851 per_bfd
->partial_symtabs
->obstack ());
7852 /* At this point we want to keep the address map. */
7853 save_psymtabs_addrmap
.release ();
7855 dwarf_read_debug_printf ("Done building psymtabs of %s",
7856 objfile_name (objfile
));
7859 /* Load the partial DIEs for a secondary CU into memory.
7860 This is also used when rereading a primary CU with load_all_dies. */
7863 load_partial_comp_unit (dwarf2_per_cu_data
*this_cu
,
7864 dwarf2_per_objfile
*per_objfile
,
7865 dwarf2_cu
*existing_cu
)
7867 cutu_reader
reader (this_cu
, per_objfile
, nullptr, existing_cu
, false);
7869 if (!reader
.dummy_p
)
7871 prepare_one_comp_unit (reader
.cu
, reader
.comp_unit_die
,
7874 /* Check if comp unit has_children.
7875 If so, read the rest of the partial symbols from this comp unit.
7876 If not, there's no more debug_info for this comp unit. */
7877 if (reader
.comp_unit_die
->has_children
)
7878 load_partial_dies (&reader
, reader
.info_ptr
, 0);
7885 read_comp_units_from_section (dwarf2_per_objfile
*per_objfile
,
7886 struct dwarf2_section_info
*section
,
7887 struct dwarf2_section_info
*abbrev_section
,
7888 unsigned int is_dwz
)
7890 const gdb_byte
*info_ptr
;
7891 struct objfile
*objfile
= per_objfile
->objfile
;
7893 dwarf_read_debug_printf ("Reading %s for %s",
7894 section
->get_name (),
7895 section
->get_file_name ());
7897 section
->read (objfile
);
7899 info_ptr
= section
->buffer
;
7901 while (info_ptr
< section
->buffer
+ section
->size
)
7903 struct dwarf2_per_cu_data
*this_cu
;
7905 sect_offset sect_off
= (sect_offset
) (info_ptr
- section
->buffer
);
7907 comp_unit_head cu_header
;
7908 read_and_check_comp_unit_head (per_objfile
, &cu_header
, section
,
7909 abbrev_section
, info_ptr
,
7910 rcuh_kind::COMPILE
);
7912 /* Save the compilation unit for later lookup. */
7913 if (cu_header
.unit_type
!= DW_UT_type
)
7914 this_cu
= per_objfile
->per_bfd
->allocate_per_cu ();
7917 auto sig_type
= per_objfile
->per_bfd
->allocate_signatured_type ();
7918 sig_type
->signature
= cu_header
.signature
;
7919 sig_type
->type_offset_in_tu
= cu_header
.type_cu_offset_in_tu
;
7920 this_cu
= &sig_type
->per_cu
;
7922 this_cu
->is_debug_types
= (cu_header
.unit_type
== DW_UT_type
);
7923 this_cu
->sect_off
= sect_off
;
7924 this_cu
->length
= cu_header
.length
+ cu_header
.initial_length_size
;
7925 this_cu
->is_dwz
= is_dwz
;
7926 this_cu
->section
= section
;
7928 per_objfile
->per_bfd
->all_comp_units
.push_back (this_cu
);
7930 info_ptr
= info_ptr
+ this_cu
->length
;
7934 /* Create a list of all compilation units in OBJFILE.
7935 This is only done for -readnow and building partial symtabs. */
7938 create_all_comp_units (dwarf2_per_objfile
*per_objfile
)
7940 gdb_assert (per_objfile
->per_bfd
->all_comp_units
.empty ());
7941 read_comp_units_from_section (per_objfile
, &per_objfile
->per_bfd
->info
,
7942 &per_objfile
->per_bfd
->abbrev
, 0);
7944 dwz_file
*dwz
= dwarf2_get_dwz_file (per_objfile
->per_bfd
);
7946 read_comp_units_from_section (per_objfile
, &dwz
->info
, &dwz
->abbrev
, 1);
7949 /* Process all loaded DIEs for compilation unit CU, starting at
7950 FIRST_DIE. The caller should pass SET_ADDRMAP == 1 if the compilation
7951 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
7952 DW_AT_ranges). See the comments of add_partial_subprogram on how
7953 SET_ADDRMAP is used and how *LOWPC and *HIGHPC are updated. */
7956 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
7957 CORE_ADDR
*highpc
, int set_addrmap
,
7958 struct dwarf2_cu
*cu
)
7960 struct partial_die_info
*pdi
;
7962 /* Now, march along the PDI's, descending into ones which have
7963 interesting children but skipping the children of the other ones,
7964 until we reach the end of the compilation unit. */
7972 /* Anonymous namespaces or modules have no name but have interesting
7973 children, so we need to look at them. Ditto for anonymous
7976 if (pdi
->raw_name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
7977 || pdi
->tag
== DW_TAG_module
|| pdi
->tag
== DW_TAG_enumeration_type
7978 || pdi
->tag
== DW_TAG_imported_unit
7979 || pdi
->tag
== DW_TAG_inlined_subroutine
)
7983 case DW_TAG_subprogram
:
7984 case DW_TAG_inlined_subroutine
:
7985 add_partial_subprogram (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
7986 if (cu
->language
== language_cplus
)
7987 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
,
7990 case DW_TAG_constant
:
7991 case DW_TAG_variable
:
7992 case DW_TAG_typedef
:
7993 case DW_TAG_union_type
:
7994 if (!pdi
->is_declaration
7995 || (pdi
->tag
== DW_TAG_variable
&& pdi
->is_external
))
7997 add_partial_symbol (pdi
, cu
);
8000 case DW_TAG_class_type
:
8001 case DW_TAG_interface_type
:
8002 case DW_TAG_structure_type
:
8003 if (!pdi
->is_declaration
)
8005 add_partial_symbol (pdi
, cu
);
8007 if ((cu
->language
== language_rust
8008 || cu
->language
== language_cplus
) && pdi
->has_children
)
8009 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
,
8012 case DW_TAG_enumeration_type
:
8013 if (!pdi
->is_declaration
)
8014 add_partial_enumeration (pdi
, cu
);
8016 case DW_TAG_base_type
:
8017 case DW_TAG_subrange_type
:
8018 /* File scope base type definitions are added to the partial
8020 add_partial_symbol (pdi
, cu
);
8022 case DW_TAG_namespace
:
8023 add_partial_namespace (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
8026 if (!pdi
->is_declaration
)
8027 add_partial_module (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
8029 case DW_TAG_imported_unit
:
8031 struct dwarf2_per_cu_data
*per_cu
;
8033 /* For now we don't handle imported units in type units. */
8034 if (cu
->per_cu
->is_debug_types
)
8036 error (_("Dwarf Error: DW_TAG_imported_unit is not"
8037 " supported in type units [in module %s]"),
8038 objfile_name (cu
->per_objfile
->objfile
));
8041 per_cu
= dwarf2_find_containing_comp_unit
8042 (pdi
->d
.sect_off
, pdi
->is_dwz
, cu
->per_objfile
);
8044 /* Go read the partial unit, if needed. */
8045 if (per_cu
->v
.psymtab
== NULL
)
8046 process_psymtab_comp_unit (per_cu
, cu
->per_objfile
, true,
8049 cu
->per_cu
->imported_symtabs_push (per_cu
);
8052 case DW_TAG_imported_declaration
:
8053 add_partial_symbol (pdi
, cu
);
8060 /* If the die has a sibling, skip to the sibling. */
8062 pdi
= pdi
->die_sibling
;
8066 /* Functions used to compute the fully scoped name of a partial DIE.
8068 Normally, this is simple. For C++, the parent DIE's fully scoped
8069 name is concatenated with "::" and the partial DIE's name.
8070 Enumerators are an exception; they use the scope of their parent
8071 enumeration type, i.e. the name of the enumeration type is not
8072 prepended to the enumerator.
8074 There are two complexities. One is DW_AT_specification; in this
8075 case "parent" means the parent of the target of the specification,
8076 instead of the direct parent of the DIE. The other is compilers
8077 which do not emit DW_TAG_namespace; in this case we try to guess
8078 the fully qualified name of structure types from their members'
8079 linkage names. This must be done using the DIE's children rather
8080 than the children of any DW_AT_specification target. We only need
8081 to do this for structures at the top level, i.e. if the target of
8082 any DW_AT_specification (if any; otherwise the DIE itself) does not
8085 /* Compute the scope prefix associated with PDI's parent, in
8086 compilation unit CU. The result will be allocated on CU's
8087 comp_unit_obstack, or a copy of the already allocated PDI->NAME
8088 field. NULL is returned if no prefix is necessary. */
8090 partial_die_parent_scope (struct partial_die_info
*pdi
,
8091 struct dwarf2_cu
*cu
)
8093 const char *grandparent_scope
;
8094 struct partial_die_info
*parent
, *real_pdi
;
8096 /* We need to look at our parent DIE; if we have a DW_AT_specification,
8097 then this means the parent of the specification DIE. */
8100 while (real_pdi
->has_specification
)
8102 auto res
= find_partial_die (real_pdi
->spec_offset
,
8103 real_pdi
->spec_is_dwz
, cu
);
8108 parent
= real_pdi
->die_parent
;
8112 if (parent
->scope_set
)
8113 return parent
->scope
;
8117 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
8119 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
8120 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
8121 Work around this problem here. */
8122 if (cu
->language
== language_cplus
8123 && parent
->tag
== DW_TAG_namespace
8124 && strcmp (parent
->name (cu
), "::") == 0
8125 && grandparent_scope
== NULL
)
8127 parent
->scope
= NULL
;
8128 parent
->scope_set
= 1;
8132 /* Nested subroutines in Fortran get a prefix. */
8133 if (pdi
->tag
== DW_TAG_enumerator
)
8134 /* Enumerators should not get the name of the enumeration as a prefix. */
8135 parent
->scope
= grandparent_scope
;
8136 else if (parent
->tag
== DW_TAG_namespace
8137 || parent
->tag
== DW_TAG_module
8138 || parent
->tag
== DW_TAG_structure_type
8139 || parent
->tag
== DW_TAG_class_type
8140 || parent
->tag
== DW_TAG_interface_type
8141 || parent
->tag
== DW_TAG_union_type
8142 || parent
->tag
== DW_TAG_enumeration_type
8143 || (cu
->language
== language_fortran
8144 && parent
->tag
== DW_TAG_subprogram
8145 && pdi
->tag
== DW_TAG_subprogram
))
8147 if (grandparent_scope
== NULL
)
8148 parent
->scope
= parent
->name (cu
);
8150 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
,
8152 parent
->name (cu
), 0, cu
);
8156 /* FIXME drow/2004-04-01: What should we be doing with
8157 function-local names? For partial symbols, we should probably be
8159 complaint (_("unhandled containing DIE tag %s for DIE at %s"),
8160 dwarf_tag_name (parent
->tag
),
8161 sect_offset_str (pdi
->sect_off
));
8162 parent
->scope
= grandparent_scope
;
8165 parent
->scope_set
= 1;
8166 return parent
->scope
;
8169 /* Return the fully scoped name associated with PDI, from compilation unit
8170 CU. The result will be allocated with malloc. */
8172 static gdb::unique_xmalloc_ptr
<char>
8173 partial_die_full_name (struct partial_die_info
*pdi
,
8174 struct dwarf2_cu
*cu
)
8176 const char *parent_scope
;
8178 /* If this is a template instantiation, we can not work out the
8179 template arguments from partial DIEs. So, unfortunately, we have
8180 to go through the full DIEs. At least any work we do building
8181 types here will be reused if full symbols are loaded later. */
8182 if (pdi
->has_template_arguments
)
8186 if (pdi
->name (cu
) != NULL
&& strchr (pdi
->name (cu
), '<') == NULL
)
8188 struct die_info
*die
;
8189 struct attribute attr
;
8190 struct dwarf2_cu
*ref_cu
= cu
;
8192 /* DW_FORM_ref_addr is using section offset. */
8193 attr
.name
= (enum dwarf_attribute
) 0;
8194 attr
.form
= DW_FORM_ref_addr
;
8195 attr
.u
.unsnd
= to_underlying (pdi
->sect_off
);
8196 die
= follow_die_ref (NULL
, &attr
, &ref_cu
);
8198 return make_unique_xstrdup (dwarf2_full_name (NULL
, die
, ref_cu
));
8202 parent_scope
= partial_die_parent_scope (pdi
, cu
);
8203 if (parent_scope
== NULL
)
8206 return gdb::unique_xmalloc_ptr
<char> (typename_concat (NULL
, parent_scope
,
8212 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
8214 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
8215 struct objfile
*objfile
= per_objfile
->objfile
;
8216 struct gdbarch
*gdbarch
= objfile
->arch ();
8218 const char *actual_name
= NULL
;
8221 baseaddr
= objfile
->text_section_offset ();
8223 gdb::unique_xmalloc_ptr
<char> built_actual_name
8224 = partial_die_full_name (pdi
, cu
);
8225 if (built_actual_name
!= NULL
)
8226 actual_name
= built_actual_name
.get ();
8228 if (actual_name
== NULL
)
8229 actual_name
= pdi
->name (cu
);
8231 partial_symbol psymbol
;
8232 memset (&psymbol
, 0, sizeof (psymbol
));
8233 psymbol
.ginfo
.set_language (cu
->language
, &objfile
->objfile_obstack
);
8234 psymbol
.ginfo
.set_section_index (-1);
8236 /* The code below indicates that the psymbol should be installed by
8238 gdb::optional
<psymbol_placement
> where
;
8242 case DW_TAG_inlined_subroutine
:
8243 case DW_TAG_subprogram
:
8244 addr
= (gdbarch_adjust_dwarf2_addr (gdbarch
, pdi
->lowpc
+ baseaddr
)
8246 if (pdi
->is_external
8247 || cu
->language
== language_ada
8248 || (cu
->language
== language_fortran
8249 && pdi
->die_parent
!= NULL
8250 && pdi
->die_parent
->tag
== DW_TAG_subprogram
))
8252 /* Normally, only "external" DIEs are part of the global scope.
8253 But in Ada and Fortran, we want to be able to access nested
8254 procedures globally. So all Ada and Fortran subprograms are
8255 stored in the global scope. */
8256 where
= psymbol_placement::GLOBAL
;
8259 where
= psymbol_placement::STATIC
;
8261 psymbol
.domain
= VAR_DOMAIN
;
8262 psymbol
.aclass
= LOC_BLOCK
;
8263 psymbol
.ginfo
.set_section_index (SECT_OFF_TEXT (objfile
));
8264 psymbol
.ginfo
.value
.address
= addr
;
8266 if (pdi
->main_subprogram
&& actual_name
!= NULL
)
8267 set_objfile_main_name (objfile
, actual_name
, cu
->language
);
8269 case DW_TAG_constant
:
8270 psymbol
.domain
= VAR_DOMAIN
;
8271 psymbol
.aclass
= LOC_STATIC
;
8272 where
= (pdi
->is_external
8273 ? psymbol_placement::GLOBAL
8274 : psymbol_placement::STATIC
);
8276 case DW_TAG_variable
:
8278 addr
= decode_locdesc (pdi
->d
.locdesc
, cu
);
8282 && !per_objfile
->per_bfd
->has_section_at_zero
)
8284 /* A global or static variable may also have been stripped
8285 out by the linker if unused, in which case its address
8286 will be nullified; do not add such variables into partial
8287 symbol table then. */
8289 else if (pdi
->is_external
)
8292 Don't enter into the minimal symbol tables as there is
8293 a minimal symbol table entry from the ELF symbols already.
8294 Enter into partial symbol table if it has a location
8295 descriptor or a type.
8296 If the location descriptor is missing, new_symbol will create
8297 a LOC_UNRESOLVED symbol, the address of the variable will then
8298 be determined from the minimal symbol table whenever the variable
8300 The address for the partial symbol table entry is not
8301 used by GDB, but it comes in handy for debugging partial symbol
8304 if (pdi
->d
.locdesc
|| pdi
->has_type
)
8306 psymbol
.domain
= VAR_DOMAIN
;
8307 psymbol
.aclass
= LOC_STATIC
;
8308 psymbol
.ginfo
.set_section_index (SECT_OFF_TEXT (objfile
));
8309 psymbol
.ginfo
.value
.address
= addr
;
8310 where
= psymbol_placement::GLOBAL
;
8315 int has_loc
= pdi
->d
.locdesc
!= NULL
;
8317 /* Static Variable. Skip symbols whose value we cannot know (those
8318 without location descriptors or constant values). */
8319 if (!has_loc
&& !pdi
->has_const_value
)
8322 psymbol
.domain
= VAR_DOMAIN
;
8323 psymbol
.aclass
= LOC_STATIC
;
8324 psymbol
.ginfo
.set_section_index (SECT_OFF_TEXT (objfile
));
8326 psymbol
.ginfo
.value
.address
= addr
;
8327 where
= psymbol_placement::STATIC
;
8330 case DW_TAG_array_type
:
8331 case DW_TAG_typedef
:
8332 case DW_TAG_base_type
:
8333 case DW_TAG_subrange_type
:
8334 psymbol
.domain
= VAR_DOMAIN
;
8335 psymbol
.aclass
= LOC_TYPEDEF
;
8336 where
= psymbol_placement::STATIC
;
8338 case DW_TAG_imported_declaration
:
8339 case DW_TAG_namespace
:
8340 psymbol
.domain
= VAR_DOMAIN
;
8341 psymbol
.aclass
= LOC_TYPEDEF
;
8342 where
= psymbol_placement::GLOBAL
;
8345 /* With Fortran 77 there might be a "BLOCK DATA" module
8346 available without any name. If so, we skip the module as it
8347 doesn't bring any value. */
8348 if (actual_name
!= nullptr)
8350 psymbol
.domain
= MODULE_DOMAIN
;
8351 psymbol
.aclass
= LOC_TYPEDEF
;
8352 where
= psymbol_placement::GLOBAL
;
8355 case DW_TAG_class_type
:
8356 case DW_TAG_interface_type
:
8357 case DW_TAG_structure_type
:
8358 case DW_TAG_union_type
:
8359 case DW_TAG_enumeration_type
:
8360 /* Skip external references. The DWARF standard says in the section
8361 about "Structure, Union, and Class Type Entries": "An incomplete
8362 structure, union or class type is represented by a structure,
8363 union or class entry that does not have a byte size attribute
8364 and that has a DW_AT_declaration attribute." */
8365 if (!pdi
->has_byte_size
&& pdi
->is_declaration
)
8368 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
8369 static vs. global. */
8370 psymbol
.domain
= STRUCT_DOMAIN
;
8371 psymbol
.aclass
= LOC_TYPEDEF
;
8372 where
= (cu
->language
== language_cplus
8373 ? psymbol_placement::GLOBAL
8374 : psymbol_placement::STATIC
);
8376 case DW_TAG_enumerator
:
8377 psymbol
.domain
= VAR_DOMAIN
;
8378 psymbol
.aclass
= LOC_CONST
;
8379 where
= (cu
->language
== language_cplus
8380 ? psymbol_placement::GLOBAL
8381 : psymbol_placement::STATIC
);
8387 if (where
.has_value ())
8389 if (built_actual_name
!= nullptr)
8390 actual_name
= objfile
->intern (actual_name
);
8391 if (pdi
->linkage_name
== nullptr || cu
->language
== language_ada
)
8392 psymbol
.ginfo
.set_linkage_name (actual_name
);
8395 psymbol
.ginfo
.set_demangled_name (actual_name
,
8396 &objfile
->objfile_obstack
);
8397 psymbol
.ginfo
.set_linkage_name (pdi
->linkage_name
);
8399 cu
->per_cu
->v
.psymtab
->add_psymbol
8400 (psymbol
, *where
, per_objfile
->per_bfd
->partial_symtabs
.get (),
8405 /* Read a partial die corresponding to a namespace; also, add a symbol
8406 corresponding to that namespace to the symbol table. NAMESPACE is
8407 the name of the enclosing namespace. */
8410 add_partial_namespace (struct partial_die_info
*pdi
,
8411 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
8412 int set_addrmap
, struct dwarf2_cu
*cu
)
8414 /* Add a symbol for the namespace. */
8416 add_partial_symbol (pdi
, cu
);
8418 /* Now scan partial symbols in that namespace. */
8420 if (pdi
->has_children
)
8421 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, set_addrmap
, cu
);
8424 /* Read a partial die corresponding to a Fortran module. */
8427 add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
8428 CORE_ADDR
*highpc
, int set_addrmap
, struct dwarf2_cu
*cu
)
8430 /* Add a symbol for the namespace. */
8432 add_partial_symbol (pdi
, cu
);
8434 /* Now scan partial symbols in that module. */
8436 if (pdi
->has_children
)
8437 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, set_addrmap
, cu
);
8440 /* Read a partial die corresponding to a subprogram or an inlined
8441 subprogram and create a partial symbol for that subprogram.
8442 When the CU language allows it, this routine also defines a partial
8443 symbol for each nested subprogram that this subprogram contains.
8444 If SET_ADDRMAP is true, record the covered ranges in the addrmap.
8445 Set *LOWPC and *HIGHPC to the lowest and highest PC values found in PDI.
8447 PDI may also be a lexical block, in which case we simply search
8448 recursively for subprograms defined inside that lexical block.
8449 Again, this is only performed when the CU language allows this
8450 type of definitions. */
8453 add_partial_subprogram (struct partial_die_info
*pdi
,
8454 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
8455 int set_addrmap
, struct dwarf2_cu
*cu
)
8457 if (pdi
->tag
== DW_TAG_subprogram
|| pdi
->tag
== DW_TAG_inlined_subroutine
)
8459 if (pdi
->has_pc_info
)
8461 if (pdi
->lowpc
< *lowpc
)
8462 *lowpc
= pdi
->lowpc
;
8463 if (pdi
->highpc
> *highpc
)
8464 *highpc
= pdi
->highpc
;
8467 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
8468 dwarf2_per_bfd
*per_bfd
= cu
->per_objfile
->per_bfd
;
8469 struct gdbarch
*gdbarch
= objfile
->arch ();
8471 CORE_ADDR this_highpc
;
8472 CORE_ADDR this_lowpc
;
8474 baseaddr
= objfile
->text_section_offset ();
8476 = (gdbarch_adjust_dwarf2_addr (gdbarch
,
8477 pdi
->lowpc
+ baseaddr
)
8480 = (gdbarch_adjust_dwarf2_addr (gdbarch
,
8481 pdi
->highpc
+ baseaddr
)
8483 addrmap_set_empty (per_bfd
->partial_symtabs
->psymtabs_addrmap
,
8484 this_lowpc
, this_highpc
- 1,
8485 cu
->per_cu
->v
.psymtab
);
8489 if (pdi
->has_pc_info
|| (!pdi
->is_external
&& pdi
->may_be_inlined
))
8491 if (!pdi
->is_declaration
)
8492 /* Ignore subprogram DIEs that do not have a name, they are
8493 illegal. Do not emit a complaint at this point, we will
8494 do so when we convert this psymtab into a symtab. */
8496 add_partial_symbol (pdi
, cu
);
8500 if (! pdi
->has_children
)
8503 if (cu
->language
== language_ada
|| cu
->language
== language_fortran
)
8505 pdi
= pdi
->die_child
;
8509 if (pdi
->tag
== DW_TAG_subprogram
8510 || pdi
->tag
== DW_TAG_inlined_subroutine
8511 || pdi
->tag
== DW_TAG_lexical_block
)
8512 add_partial_subprogram (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
8513 pdi
= pdi
->die_sibling
;
8518 /* Read a partial die corresponding to an enumeration type. */
8521 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
8522 struct dwarf2_cu
*cu
)
8524 struct partial_die_info
*pdi
;
8526 if (enum_pdi
->name (cu
) != NULL
)
8527 add_partial_symbol (enum_pdi
, cu
);
8529 pdi
= enum_pdi
->die_child
;
8532 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->raw_name
== NULL
)
8533 complaint (_("malformed enumerator DIE ignored"));
8535 add_partial_symbol (pdi
, cu
);
8536 pdi
= pdi
->die_sibling
;
8540 /* Return the initial uleb128 in the die at INFO_PTR. */
8543 peek_abbrev_code (bfd
*abfd
, const gdb_byte
*info_ptr
)
8545 unsigned int bytes_read
;
8547 return read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
8550 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit
8551 READER::CU. Use READER::ABBREV_TABLE to lookup any abbreviation.
8553 Return the corresponding abbrev, or NULL if the number is zero (indicating
8554 an empty DIE). In either case *BYTES_READ will be set to the length of
8555 the initial number. */
8557 static const struct abbrev_info
*
8558 peek_die_abbrev (const die_reader_specs
&reader
,
8559 const gdb_byte
*info_ptr
, unsigned int *bytes_read
)
8561 dwarf2_cu
*cu
= reader
.cu
;
8562 bfd
*abfd
= reader
.abfd
;
8563 unsigned int abbrev_number
8564 = read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
8566 if (abbrev_number
== 0)
8569 const abbrev_info
*abbrev
8570 = reader
.abbrev_table
->lookup_abbrev (abbrev_number
);
8573 error (_("Dwarf Error: Could not find abbrev number %d in %s"
8574 " at offset %s [in module %s]"),
8575 abbrev_number
, cu
->per_cu
->is_debug_types
? "TU" : "CU",
8576 sect_offset_str (cu
->header
.sect_off
), bfd_get_filename (abfd
));
8582 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
8583 Returns a pointer to the end of a series of DIEs, terminated by an empty
8584 DIE. Any children of the skipped DIEs will also be skipped. */
8586 static const gdb_byte
*
8587 skip_children (const struct die_reader_specs
*reader
, const gdb_byte
*info_ptr
)
8591 unsigned int bytes_read
;
8592 const abbrev_info
*abbrev
= peek_die_abbrev (*reader
, info_ptr
,
8596 return info_ptr
+ bytes_read
;
8598 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
8602 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
8603 INFO_PTR should point just after the initial uleb128 of a DIE, and the
8604 abbrev corresponding to that skipped uleb128 should be passed in
8605 ABBREV. Returns a pointer to this DIE's sibling, skipping any
8608 static const gdb_byte
*
8609 skip_one_die (const struct die_reader_specs
*reader
, const gdb_byte
*info_ptr
,
8610 const struct abbrev_info
*abbrev
)
8612 unsigned int bytes_read
;
8613 struct attribute attr
;
8614 bfd
*abfd
= reader
->abfd
;
8615 struct dwarf2_cu
*cu
= reader
->cu
;
8616 const gdb_byte
*buffer
= reader
->buffer
;
8617 const gdb_byte
*buffer_end
= reader
->buffer_end
;
8618 unsigned int form
, i
;
8620 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
8622 /* The only abbrev we care about is DW_AT_sibling. */
8623 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
8625 read_attribute (reader
, &attr
, &abbrev
->attrs
[i
], info_ptr
);
8626 if (attr
.form
== DW_FORM_ref_addr
)
8627 complaint (_("ignoring absolute DW_AT_sibling"));
8630 sect_offset off
= attr
.get_ref_die_offset ();
8631 const gdb_byte
*sibling_ptr
= buffer
+ to_underlying (off
);
8633 if (sibling_ptr
< info_ptr
)
8634 complaint (_("DW_AT_sibling points backwards"));
8635 else if (sibling_ptr
> reader
->buffer_end
)
8636 reader
->die_section
->overflow_complaint ();
8642 /* If it isn't DW_AT_sibling, skip this attribute. */
8643 form
= abbrev
->attrs
[i
].form
;
8647 case DW_FORM_ref_addr
:
8648 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
8649 and later it is offset sized. */
8650 if (cu
->header
.version
== 2)
8651 info_ptr
+= cu
->header
.addr_size
;
8653 info_ptr
+= cu
->header
.offset_size
;
8655 case DW_FORM_GNU_ref_alt
:
8656 info_ptr
+= cu
->header
.offset_size
;
8659 info_ptr
+= cu
->header
.addr_size
;
8667 case DW_FORM_flag_present
:
8668 case DW_FORM_implicit_const
:
8685 case DW_FORM_ref_sig8
:
8688 case DW_FORM_data16
:
8691 case DW_FORM_string
:
8692 read_direct_string (abfd
, info_ptr
, &bytes_read
);
8693 info_ptr
+= bytes_read
;
8695 case DW_FORM_sec_offset
:
8697 case DW_FORM_GNU_strp_alt
:
8698 info_ptr
+= cu
->header
.offset_size
;
8700 case DW_FORM_exprloc
:
8702 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
8703 info_ptr
+= bytes_read
;
8705 case DW_FORM_block1
:
8706 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
8708 case DW_FORM_block2
:
8709 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
8711 case DW_FORM_block4
:
8712 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
8718 case DW_FORM_ref_udata
:
8719 case DW_FORM_GNU_addr_index
:
8720 case DW_FORM_GNU_str_index
:
8721 case DW_FORM_rnglistx
:
8722 case DW_FORM_loclistx
:
8723 info_ptr
= safe_skip_leb128 (info_ptr
, buffer_end
);
8725 case DW_FORM_indirect
:
8726 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
8727 info_ptr
+= bytes_read
;
8728 /* We need to continue parsing from here, so just go back to
8730 goto skip_attribute
;
8733 error (_("Dwarf Error: Cannot handle %s "
8734 "in DWARF reader [in module %s]"),
8735 dwarf_form_name (form
),
8736 bfd_get_filename (abfd
));
8740 if (abbrev
->has_children
)
8741 return skip_children (reader
, info_ptr
);
8746 /* Locate ORIG_PDI's sibling.
8747 INFO_PTR should point to the start of the next DIE after ORIG_PDI. */
8749 static const gdb_byte
*
8750 locate_pdi_sibling (const struct die_reader_specs
*reader
,
8751 struct partial_die_info
*orig_pdi
,
8752 const gdb_byte
*info_ptr
)
8754 /* Do we know the sibling already? */
8756 if (orig_pdi
->sibling
)
8757 return orig_pdi
->sibling
;
8759 /* Are there any children to deal with? */
8761 if (!orig_pdi
->has_children
)
8764 /* Skip the children the long way. */
8766 return skip_children (reader
, info_ptr
);
8769 /* Expand this partial symbol table into a full symbol table. SELF is
8773 dwarf2_psymtab::read_symtab (struct objfile
*objfile
)
8775 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
8777 gdb_assert (!per_objfile
->symtab_set_p (per_cu_data
));
8779 /* If this psymtab is constructed from a debug-only objfile, the
8780 has_section_at_zero flag will not necessarily be correct. We
8781 can get the correct value for this flag by looking at the data
8782 associated with the (presumably stripped) associated objfile. */
8783 if (objfile
->separate_debug_objfile_backlink
)
8785 dwarf2_per_objfile
*per_objfile_backlink
8786 = get_dwarf2_per_objfile (objfile
->separate_debug_objfile_backlink
);
8788 per_objfile
->per_bfd
->has_section_at_zero
8789 = per_objfile_backlink
->per_bfd
->has_section_at_zero
;
8792 expand_psymtab (objfile
);
8794 process_cu_includes (per_objfile
);
8797 /* Reading in full CUs. */
8799 /* Add PER_CU to the queue. */
8802 queue_comp_unit (dwarf2_per_cu_data
*per_cu
,
8803 dwarf2_per_objfile
*per_objfile
,
8804 enum language pretend_language
)
8808 gdb_assert (per_objfile
->per_bfd
->queue
.has_value ());
8809 per_cu
->per_bfd
->queue
->emplace (per_cu
, per_objfile
, pretend_language
);
8812 /* If PER_CU is not yet expanded of queued for expansion, add it to the queue.
8814 If DEPENDENT_CU is non-NULL, it has a reference to PER_CU so add a
8817 Return true if maybe_queue_comp_unit requires the caller to load the CU's
8818 DIEs, false otherwise.
8820 Explanation: there is an invariant that if a CU is queued for expansion
8821 (present in `dwarf2_per_bfd::queue`), then its DIEs are loaded
8822 (a dwarf2_cu object exists for this CU, and `dwarf2_per_objfile::get_cu`
8823 returns non-nullptr). If the CU gets enqueued by this function but its DIEs
8824 are not yet loaded, the the caller must load the CU's DIEs to ensure the
8825 invariant is respected.
8827 The caller is therefore not required to load the CU's DIEs (we return false)
8830 - the CU is already expanded, and therefore does not get enqueued
8831 - the CU gets enqueued for expansion, but its DIEs are already loaded
8833 Note that the caller should not use this function's return value as an
8834 indicator of whether the CU's DIEs are loaded right now, it should check
8835 that by calling `dwarf2_per_objfile::get_cu` instead. */
8838 maybe_queue_comp_unit (struct dwarf2_cu
*dependent_cu
,
8839 dwarf2_per_cu_data
*per_cu
,
8840 dwarf2_per_objfile
*per_objfile
,
8841 enum language pretend_language
)
8843 /* We may arrive here during partial symbol reading, if we need full
8844 DIEs to process an unusual case (e.g. template arguments). Do
8845 not queue PER_CU, just tell our caller to load its DIEs. */
8846 if (per_cu
->per_bfd
->reading_partial_symbols
)
8848 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
8850 if (cu
== NULL
|| cu
->dies
== NULL
)
8855 /* Mark the dependence relation so that we don't flush PER_CU
8857 if (dependent_cu
!= NULL
)
8858 dwarf2_add_dependence (dependent_cu
, per_cu
);
8860 /* If it's already on the queue, we have nothing to do. */
8863 /* Verify the invariant that if a CU is queued for expansion, its DIEs are
8865 gdb_assert (per_objfile
->get_cu (per_cu
) != nullptr);
8867 /* If the CU is queued for expansion, it should not already be
8869 gdb_assert (!per_objfile
->symtab_set_p (per_cu
));
8871 /* The DIEs are already loaded, the caller doesn't need to do it. */
8875 bool queued
= false;
8876 if (!per_objfile
->symtab_set_p (per_cu
))
8878 /* Add it to the queue. */
8879 queue_comp_unit (per_cu
, per_objfile
, pretend_language
);
8883 /* If the compilation unit is already loaded, just mark it as
8885 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
8889 /* Ask the caller to load the CU's DIEs if the CU got enqueued for expansion
8890 and the DIEs are not already loaded. */
8891 return queued
&& cu
== nullptr;
8894 /* Process the queue. */
8897 process_queue (dwarf2_per_objfile
*per_objfile
)
8899 dwarf_read_debug_printf ("Expanding one or more symtabs of objfile %s ...",
8900 objfile_name (per_objfile
->objfile
));
8902 /* The queue starts out with one item, but following a DIE reference
8903 may load a new CU, adding it to the end of the queue. */
8904 while (!per_objfile
->per_bfd
->queue
->empty ())
8906 dwarf2_queue_item
&item
= per_objfile
->per_bfd
->queue
->front ();
8907 dwarf2_per_cu_data
*per_cu
= item
.per_cu
;
8909 if (!per_objfile
->symtab_set_p (per_cu
))
8911 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
8913 /* Skip dummy CUs. */
8916 unsigned int debug_print_threshold
;
8919 if (per_cu
->is_debug_types
)
8921 struct signatured_type
*sig_type
=
8922 (struct signatured_type
*) per_cu
;
8924 sprintf (buf
, "TU %s at offset %s",
8925 hex_string (sig_type
->signature
),
8926 sect_offset_str (per_cu
->sect_off
));
8927 /* There can be 100s of TUs.
8928 Only print them in verbose mode. */
8929 debug_print_threshold
= 2;
8933 sprintf (buf
, "CU at offset %s",
8934 sect_offset_str (per_cu
->sect_off
));
8935 debug_print_threshold
= 1;
8938 if (dwarf_read_debug
>= debug_print_threshold
)
8939 dwarf_read_debug_printf ("Expanding symtab of %s", buf
);
8941 if (per_cu
->is_debug_types
)
8942 process_full_type_unit (cu
, item
.pretend_language
);
8944 process_full_comp_unit (cu
, item
.pretend_language
);
8946 if (dwarf_read_debug
>= debug_print_threshold
)
8947 dwarf_read_debug_printf ("Done expanding %s", buf
);
8952 per_objfile
->per_bfd
->queue
->pop ();
8955 dwarf_read_debug_printf ("Done expanding symtabs of %s.",
8956 objfile_name (per_objfile
->objfile
));
8959 /* Read in full symbols for PST, and anything it depends on. */
8962 dwarf2_psymtab::expand_psymtab (struct objfile
*objfile
)
8964 gdb_assert (!readin_p (objfile
));
8966 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
8967 free_cached_comp_units
freer (per_objfile
);
8968 expand_dependencies (objfile
);
8970 dw2_do_instantiate_symtab (per_cu_data
, per_objfile
, false);
8971 gdb_assert (get_compunit_symtab (objfile
) != nullptr);
8974 /* See psympriv.h. */
8977 dwarf2_psymtab::readin_p (struct objfile
*objfile
) const
8979 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
8980 return per_objfile
->symtab_set_p (per_cu_data
);
8983 /* See psympriv.h. */
8986 dwarf2_psymtab::get_compunit_symtab (struct objfile
*objfile
) const
8988 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
8989 return per_objfile
->get_symtab (per_cu_data
);
8992 /* Trivial hash function for die_info: the hash value of a DIE
8993 is its offset in .debug_info for this objfile. */
8996 die_hash (const void *item
)
8998 const struct die_info
*die
= (const struct die_info
*) item
;
9000 return to_underlying (die
->sect_off
);
9003 /* Trivial comparison function for die_info structures: two DIEs
9004 are equal if they have the same offset. */
9007 die_eq (const void *item_lhs
, const void *item_rhs
)
9009 const struct die_info
*die_lhs
= (const struct die_info
*) item_lhs
;
9010 const struct die_info
*die_rhs
= (const struct die_info
*) item_rhs
;
9012 return die_lhs
->sect_off
== die_rhs
->sect_off
;
9015 /* Load the DIEs associated with PER_CU into memory.
9017 In some cases, the caller, while reading partial symbols, will need to load
9018 the full symbols for the CU for some reason. It will already have a
9019 dwarf2_cu object for THIS_CU and pass it as EXISTING_CU, so it can be re-used
9020 rather than creating a new one. */
9023 load_full_comp_unit (dwarf2_per_cu_data
*this_cu
,
9024 dwarf2_per_objfile
*per_objfile
,
9025 dwarf2_cu
*existing_cu
,
9027 enum language pretend_language
)
9029 gdb_assert (! this_cu
->is_debug_types
);
9031 cutu_reader
reader (this_cu
, per_objfile
, NULL
, existing_cu
, skip_partial
);
9035 struct dwarf2_cu
*cu
= reader
.cu
;
9036 const gdb_byte
*info_ptr
= reader
.info_ptr
;
9038 gdb_assert (cu
->die_hash
== NULL
);
9040 htab_create_alloc_ex (cu
->header
.length
/ 12,
9044 &cu
->comp_unit_obstack
,
9045 hashtab_obstack_allocate
,
9046 dummy_obstack_deallocate
);
9048 if (reader
.comp_unit_die
->has_children
)
9049 reader
.comp_unit_die
->child
9050 = read_die_and_siblings (&reader
, reader
.info_ptr
,
9051 &info_ptr
, reader
.comp_unit_die
);
9052 cu
->dies
= reader
.comp_unit_die
;
9053 /* comp_unit_die is not stored in die_hash, no need. */
9055 /* We try not to read any attributes in this function, because not
9056 all CUs needed for references have been loaded yet, and symbol
9057 table processing isn't initialized. But we have to set the CU language,
9058 or we won't be able to build types correctly.
9059 Similarly, if we do not read the producer, we can not apply
9060 producer-specific interpretation. */
9061 prepare_one_comp_unit (cu
, cu
->dies
, pretend_language
);
9066 /* Add a DIE to the delayed physname list. */
9069 add_to_method_list (struct type
*type
, int fnfield_index
, int index
,
9070 const char *name
, struct die_info
*die
,
9071 struct dwarf2_cu
*cu
)
9073 struct delayed_method_info mi
;
9075 mi
.fnfield_index
= fnfield_index
;
9079 cu
->method_list
.push_back (mi
);
9082 /* Check whether [PHYSNAME, PHYSNAME+LEN) ends with a modifier like
9083 "const" / "volatile". If so, decrements LEN by the length of the
9084 modifier and return true. Otherwise return false. */
9088 check_modifier (const char *physname
, size_t &len
, const char (&mod
)[N
])
9090 size_t mod_len
= sizeof (mod
) - 1;
9091 if (len
> mod_len
&& startswith (physname
+ (len
- mod_len
), mod
))
9099 /* Compute the physnames of any methods on the CU's method list.
9101 The computation of method physnames is delayed in order to avoid the
9102 (bad) condition that one of the method's formal parameters is of an as yet
9106 compute_delayed_physnames (struct dwarf2_cu
*cu
)
9108 /* Only C++ delays computing physnames. */
9109 if (cu
->method_list
.empty ())
9111 gdb_assert (cu
->language
== language_cplus
);
9113 for (const delayed_method_info
&mi
: cu
->method_list
)
9115 const char *physname
;
9116 struct fn_fieldlist
*fn_flp
9117 = &TYPE_FN_FIELDLIST (mi
.type
, mi
.fnfield_index
);
9118 physname
= dwarf2_physname (mi
.name
, mi
.die
, cu
);
9119 TYPE_FN_FIELD_PHYSNAME (fn_flp
->fn_fields
, mi
.index
)
9120 = physname
? physname
: "";
9122 /* Since there's no tag to indicate whether a method is a
9123 const/volatile overload, extract that information out of the
9125 if (physname
!= NULL
)
9127 size_t len
= strlen (physname
);
9131 if (physname
[len
] == ')') /* shortcut */
9133 else if (check_modifier (physname
, len
, " const"))
9134 TYPE_FN_FIELD_CONST (fn_flp
->fn_fields
, mi
.index
) = 1;
9135 else if (check_modifier (physname
, len
, " volatile"))
9136 TYPE_FN_FIELD_VOLATILE (fn_flp
->fn_fields
, mi
.index
) = 1;
9143 /* The list is no longer needed. */
9144 cu
->method_list
.clear ();
9147 /* Go objects should be embedded in a DW_TAG_module DIE,
9148 and it's not clear if/how imported objects will appear.
9149 To keep Go support simple until that's worked out,
9150 go back through what we've read and create something usable.
9151 We could do this while processing each DIE, and feels kinda cleaner,
9152 but that way is more invasive.
9153 This is to, for example, allow the user to type "p var" or "b main"
9154 without having to specify the package name, and allow lookups
9155 of module.object to work in contexts that use the expression
9159 fixup_go_packaging (struct dwarf2_cu
*cu
)
9161 gdb::unique_xmalloc_ptr
<char> package_name
;
9162 struct pending
*list
;
9165 for (list
= *cu
->get_builder ()->get_global_symbols ();
9169 for (i
= 0; i
< list
->nsyms
; ++i
)
9171 struct symbol
*sym
= list
->symbol
[i
];
9173 if (sym
->language () == language_go
9174 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
9176 gdb::unique_xmalloc_ptr
<char> this_package_name
9177 (go_symbol_package_name (sym
));
9179 if (this_package_name
== NULL
)
9181 if (package_name
== NULL
)
9182 package_name
= std::move (this_package_name
);
9185 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
9186 if (strcmp (package_name
.get (), this_package_name
.get ()) != 0)
9187 complaint (_("Symtab %s has objects from two different Go packages: %s and %s"),
9188 (symbol_symtab (sym
) != NULL
9189 ? symtab_to_filename_for_display
9190 (symbol_symtab (sym
))
9191 : objfile_name (objfile
)),
9192 this_package_name
.get (), package_name
.get ());
9198 if (package_name
!= NULL
)
9200 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
9201 const char *saved_package_name
= objfile
->intern (package_name
.get ());
9202 struct type
*type
= init_type (objfile
, TYPE_CODE_MODULE
, 0,
9203 saved_package_name
);
9206 sym
= new (&objfile
->objfile_obstack
) symbol
;
9207 sym
->set_language (language_go
, &objfile
->objfile_obstack
);
9208 sym
->compute_and_set_names (saved_package_name
, false, objfile
->per_bfd
);
9209 /* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
9210 e.g., "main" finds the "main" module and not C's main(). */
9211 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
9212 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
9213 SYMBOL_TYPE (sym
) = type
;
9215 add_symbol_to_list (sym
, cu
->get_builder ()->get_global_symbols ());
9219 /* Allocate a fully-qualified name consisting of the two parts on the
9223 rust_fully_qualify (struct obstack
*obstack
, const char *p1
, const char *p2
)
9225 return obconcat (obstack
, p1
, "::", p2
, (char *) NULL
);
9228 /* A helper that allocates a variant part to attach to a Rust enum
9229 type. OBSTACK is where the results should be allocated. TYPE is
9230 the type we're processing. DISCRIMINANT_INDEX is the index of the
9231 discriminant. It must be the index of one of the fields of TYPE,
9232 or -1 to mean there is no discriminant (univariant enum).
9233 DEFAULT_INDEX is the index of the default field; or -1 if there is
9234 no default. RANGES is indexed by "effective" field number (the
9235 field index, but omitting the discriminant and default fields) and
9236 must hold the discriminant values used by the variants. Note that
9237 RANGES must have a lifetime at least as long as OBSTACK -- either
9238 already allocated on it, or static. */
9241 alloc_rust_variant (struct obstack
*obstack
, struct type
*type
,
9242 int discriminant_index
, int default_index
,
9243 gdb::array_view
<discriminant_range
> ranges
)
9245 /* When DISCRIMINANT_INDEX == -1, we have a univariant enum. */
9246 gdb_assert (discriminant_index
== -1
9247 || (discriminant_index
>= 0
9248 && discriminant_index
< type
->num_fields ()));
9249 gdb_assert (default_index
== -1
9250 || (default_index
>= 0 && default_index
< type
->num_fields ()));
9252 /* We have one variant for each non-discriminant field. */
9253 int n_variants
= type
->num_fields ();
9254 if (discriminant_index
!= -1)
9257 variant
*variants
= new (obstack
) variant
[n_variants
];
9260 for (int i
= 0; i
< type
->num_fields (); ++i
)
9262 if (i
== discriminant_index
)
9265 variants
[var_idx
].first_field
= i
;
9266 variants
[var_idx
].last_field
= i
+ 1;
9268 /* The default field does not need a range, but other fields do.
9269 We skipped the discriminant above. */
9270 if (i
!= default_index
)
9272 variants
[var_idx
].discriminants
= ranges
.slice (range_idx
, 1);
9279 gdb_assert (range_idx
== ranges
.size ());
9280 gdb_assert (var_idx
== n_variants
);
9282 variant_part
*part
= new (obstack
) variant_part
;
9283 part
->discriminant_index
= discriminant_index
;
9284 /* If there is no discriminant, then whether it is signed is of no
9287 = (discriminant_index
== -1
9289 : type
->field (discriminant_index
).type ()->is_unsigned ());
9290 part
->variants
= gdb::array_view
<variant
> (variants
, n_variants
);
9292 void *storage
= obstack_alloc (obstack
, sizeof (gdb::array_view
<variant_part
>));
9293 gdb::array_view
<variant_part
> *prop_value
9294 = new (storage
) gdb::array_view
<variant_part
> (part
, 1);
9296 struct dynamic_prop prop
;
9297 prop
.set_variant_parts (prop_value
);
9299 type
->add_dyn_prop (DYN_PROP_VARIANT_PARTS
, prop
);
9302 /* Some versions of rustc emitted enums in an unusual way.
9304 Ordinary enums were emitted as unions. The first element of each
9305 structure in the union was named "RUST$ENUM$DISR". This element
9306 held the discriminant.
9308 These versions of Rust also implemented the "non-zero"
9309 optimization. When the enum had two values, and one is empty and
9310 the other holds a pointer that cannot be zero, the pointer is used
9311 as the discriminant, with a zero value meaning the empty variant.
9312 Here, the union's first member is of the form
9313 RUST$ENCODED$ENUM$<fieldno>$<fieldno>$...$<variantname>
9314 where the fieldnos are the indices of the fields that should be
9315 traversed in order to find the field (which may be several fields deep)
9316 and the variantname is the name of the variant of the case when the
9319 This function recognizes whether TYPE is of one of these forms,
9320 and, if so, smashes it to be a variant type. */
9323 quirk_rust_enum (struct type
*type
, struct objfile
*objfile
)
9325 gdb_assert (type
->code () == TYPE_CODE_UNION
);
9327 /* We don't need to deal with empty enums. */
9328 if (type
->num_fields () == 0)
9331 #define RUST_ENUM_PREFIX "RUST$ENCODED$ENUM$"
9332 if (type
->num_fields () == 1
9333 && startswith (TYPE_FIELD_NAME (type
, 0), RUST_ENUM_PREFIX
))
9335 const char *name
= TYPE_FIELD_NAME (type
, 0) + strlen (RUST_ENUM_PREFIX
);
9337 /* Decode the field name to find the offset of the
9339 ULONGEST bit_offset
= 0;
9340 struct type
*field_type
= type
->field (0).type ();
9341 while (name
[0] >= '0' && name
[0] <= '9')
9344 unsigned long index
= strtoul (name
, &tail
, 10);
9347 || index
>= field_type
->num_fields ()
9348 || (TYPE_FIELD_LOC_KIND (field_type
, index
)
9349 != FIELD_LOC_KIND_BITPOS
))
9351 complaint (_("Could not parse Rust enum encoding string \"%s\""
9353 TYPE_FIELD_NAME (type
, 0),
9354 objfile_name (objfile
));
9359 bit_offset
+= TYPE_FIELD_BITPOS (field_type
, index
);
9360 field_type
= field_type
->field (index
).type ();
9363 /* Smash this type to be a structure type. We have to do this
9364 because the type has already been recorded. */
9365 type
->set_code (TYPE_CODE_STRUCT
);
9366 type
->set_num_fields (3);
9367 /* Save the field we care about. */
9368 struct field saved_field
= type
->field (0);
9370 ((struct field
*) TYPE_ZALLOC (type
, 3 * sizeof (struct field
)));
9372 /* Put the discriminant at index 0. */
9373 type
->field (0).set_type (field_type
);
9374 TYPE_FIELD_ARTIFICIAL (type
, 0) = 1;
9375 TYPE_FIELD_NAME (type
, 0) = "<<discriminant>>";
9376 SET_FIELD_BITPOS (type
->field (0), bit_offset
);
9378 /* The order of fields doesn't really matter, so put the real
9379 field at index 1 and the data-less field at index 2. */
9380 type
->field (1) = saved_field
;
9381 TYPE_FIELD_NAME (type
, 1)
9382 = rust_last_path_segment (type
->field (1).type ()->name ());
9383 type
->field (1).type ()->set_name
9384 (rust_fully_qualify (&objfile
->objfile_obstack
, type
->name (),
9385 TYPE_FIELD_NAME (type
, 1)));
9387 const char *dataless_name
9388 = rust_fully_qualify (&objfile
->objfile_obstack
, type
->name (),
9390 struct type
*dataless_type
= init_type (objfile
, TYPE_CODE_VOID
, 0,
9392 type
->field (2).set_type (dataless_type
);
9393 /* NAME points into the original discriminant name, which
9394 already has the correct lifetime. */
9395 TYPE_FIELD_NAME (type
, 2) = name
;
9396 SET_FIELD_BITPOS (type
->field (2), 0);
9398 /* Indicate that this is a variant type. */
9399 static discriminant_range ranges
[1] = { { 0, 0 } };
9400 alloc_rust_variant (&objfile
->objfile_obstack
, type
, 0, 1, ranges
);
9402 /* A union with a single anonymous field is probably an old-style
9404 else if (type
->num_fields () == 1 && streq (TYPE_FIELD_NAME (type
, 0), ""))
9406 /* Smash this type to be a structure type. We have to do this
9407 because the type has already been recorded. */
9408 type
->set_code (TYPE_CODE_STRUCT
);
9410 struct type
*field_type
= type
->field (0).type ();
9411 const char *variant_name
9412 = rust_last_path_segment (field_type
->name ());
9413 TYPE_FIELD_NAME (type
, 0) = variant_name
;
9414 field_type
->set_name
9415 (rust_fully_qualify (&objfile
->objfile_obstack
,
9416 type
->name (), variant_name
));
9418 alloc_rust_variant (&objfile
->objfile_obstack
, type
, -1, 0, {});
9422 struct type
*disr_type
= nullptr;
9423 for (int i
= 0; i
< type
->num_fields (); ++i
)
9425 disr_type
= type
->field (i
).type ();
9427 if (disr_type
->code () != TYPE_CODE_STRUCT
)
9429 /* All fields of a true enum will be structs. */
9432 else if (disr_type
->num_fields () == 0)
9434 /* Could be data-less variant, so keep going. */
9435 disr_type
= nullptr;
9437 else if (strcmp (TYPE_FIELD_NAME (disr_type
, 0),
9438 "RUST$ENUM$DISR") != 0)
9440 /* Not a Rust enum. */
9450 /* If we got here without a discriminant, then it's probably
9452 if (disr_type
== nullptr)
9455 /* Smash this type to be a structure type. We have to do this
9456 because the type has already been recorded. */
9457 type
->set_code (TYPE_CODE_STRUCT
);
9459 /* Make space for the discriminant field. */
9460 struct field
*disr_field
= &disr_type
->field (0);
9462 = (struct field
*) TYPE_ZALLOC (type
, ((type
->num_fields () + 1)
9463 * sizeof (struct field
)));
9464 memcpy (new_fields
+ 1, type
->fields (),
9465 type
->num_fields () * sizeof (struct field
));
9466 type
->set_fields (new_fields
);
9467 type
->set_num_fields (type
->num_fields () + 1);
9469 /* Install the discriminant at index 0 in the union. */
9470 type
->field (0) = *disr_field
;
9471 TYPE_FIELD_ARTIFICIAL (type
, 0) = 1;
9472 TYPE_FIELD_NAME (type
, 0) = "<<discriminant>>";
9474 /* We need a way to find the correct discriminant given a
9475 variant name. For convenience we build a map here. */
9476 struct type
*enum_type
= disr_field
->type ();
9477 std::unordered_map
<std::string
, ULONGEST
> discriminant_map
;
9478 for (int i
= 0; i
< enum_type
->num_fields (); ++i
)
9480 if (TYPE_FIELD_LOC_KIND (enum_type
, i
) == FIELD_LOC_KIND_ENUMVAL
)
9483 = rust_last_path_segment (TYPE_FIELD_NAME (enum_type
, i
));
9484 discriminant_map
[name
] = TYPE_FIELD_ENUMVAL (enum_type
, i
);
9488 int n_fields
= type
->num_fields ();
9489 /* We don't need a range entry for the discriminant, but we do
9490 need one for every other field, as there is no default
9492 discriminant_range
*ranges
= XOBNEWVEC (&objfile
->objfile_obstack
,
9495 /* Skip the discriminant here. */
9496 for (int i
= 1; i
< n_fields
; ++i
)
9498 /* Find the final word in the name of this variant's type.
9499 That name can be used to look up the correct
9501 const char *variant_name
9502 = rust_last_path_segment (type
->field (i
).type ()->name ());
9504 auto iter
= discriminant_map
.find (variant_name
);
9505 if (iter
!= discriminant_map
.end ())
9507 ranges
[i
- 1].low
= iter
->second
;
9508 ranges
[i
- 1].high
= iter
->second
;
9511 /* In Rust, each element should have the size of the
9513 TYPE_LENGTH (type
->field (i
).type ()) = TYPE_LENGTH (type
);
9515 /* Remove the discriminant field, if it exists. */
9516 struct type
*sub_type
= type
->field (i
).type ();
9517 if (sub_type
->num_fields () > 0)
9519 sub_type
->set_num_fields (sub_type
->num_fields () - 1);
9520 sub_type
->set_fields (sub_type
->fields () + 1);
9522 TYPE_FIELD_NAME (type
, i
) = variant_name
;
9524 (rust_fully_qualify (&objfile
->objfile_obstack
,
9525 type
->name (), variant_name
));
9528 /* Indicate that this is a variant type. */
9529 alloc_rust_variant (&objfile
->objfile_obstack
, type
, 0, -1,
9530 gdb::array_view
<discriminant_range
> (ranges
,
9535 /* Rewrite some Rust unions to be structures with variants parts. */
9538 rust_union_quirks (struct dwarf2_cu
*cu
)
9540 gdb_assert (cu
->language
== language_rust
);
9541 for (type
*type_
: cu
->rust_unions
)
9542 quirk_rust_enum (type_
, cu
->per_objfile
->objfile
);
9543 /* We don't need this any more. */
9544 cu
->rust_unions
.clear ();
9549 type_unit_group_unshareable
*
9550 dwarf2_per_objfile::get_type_unit_group_unshareable (type_unit_group
*tu_group
)
9552 auto iter
= this->m_type_units
.find (tu_group
);
9553 if (iter
!= this->m_type_units
.end ())
9554 return iter
->second
.get ();
9556 type_unit_group_unshareable_up
uniq (new type_unit_group_unshareable
);
9557 type_unit_group_unshareable
*result
= uniq
.get ();
9558 this->m_type_units
[tu_group
] = std::move (uniq
);
9563 dwarf2_per_objfile::get_type_for_signatured_type
9564 (signatured_type
*sig_type
) const
9566 auto iter
= this->m_type_map
.find (sig_type
);
9567 if (iter
== this->m_type_map
.end ())
9570 return iter
->second
;
9573 void dwarf2_per_objfile::set_type_for_signatured_type
9574 (signatured_type
*sig_type
, struct type
*type
)
9576 gdb_assert (this->m_type_map
.find (sig_type
) == this->m_type_map
.end ());
9578 this->m_type_map
[sig_type
] = type
;
9581 /* A helper function for computing the list of all symbol tables
9582 included by PER_CU. */
9585 recursively_compute_inclusions (std::vector
<compunit_symtab
*> *result
,
9586 htab_t all_children
, htab_t all_type_symtabs
,
9587 dwarf2_per_cu_data
*per_cu
,
9588 dwarf2_per_objfile
*per_objfile
,
9589 struct compunit_symtab
*immediate_parent
)
9591 void **slot
= htab_find_slot (all_children
, per_cu
, INSERT
);
9594 /* This inclusion and its children have been processed. */
9600 /* Only add a CU if it has a symbol table. */
9601 compunit_symtab
*cust
= per_objfile
->get_symtab (per_cu
);
9604 /* If this is a type unit only add its symbol table if we haven't
9605 seen it yet (type unit per_cu's can share symtabs). */
9606 if (per_cu
->is_debug_types
)
9608 slot
= htab_find_slot (all_type_symtabs
, cust
, INSERT
);
9612 result
->push_back (cust
);
9613 if (cust
->user
== NULL
)
9614 cust
->user
= immediate_parent
;
9619 result
->push_back (cust
);
9620 if (cust
->user
== NULL
)
9621 cust
->user
= immediate_parent
;
9625 if (!per_cu
->imported_symtabs_empty ())
9626 for (dwarf2_per_cu_data
*ptr
: *per_cu
->imported_symtabs
)
9628 recursively_compute_inclusions (result
, all_children
,
9629 all_type_symtabs
, ptr
, per_objfile
,
9634 /* Compute the compunit_symtab 'includes' fields for the compunit_symtab of
9638 compute_compunit_symtab_includes (dwarf2_per_cu_data
*per_cu
,
9639 dwarf2_per_objfile
*per_objfile
)
9641 gdb_assert (! per_cu
->is_debug_types
);
9643 if (!per_cu
->imported_symtabs_empty ())
9646 std::vector
<compunit_symtab
*> result_symtabs
;
9647 compunit_symtab
*cust
= per_objfile
->get_symtab (per_cu
);
9649 /* If we don't have a symtab, we can just skip this case. */
9653 htab_up
all_children (htab_create_alloc (1, htab_hash_pointer
,
9655 NULL
, xcalloc
, xfree
));
9656 htab_up
all_type_symtabs (htab_create_alloc (1, htab_hash_pointer
,
9658 NULL
, xcalloc
, xfree
));
9660 for (dwarf2_per_cu_data
*ptr
: *per_cu
->imported_symtabs
)
9662 recursively_compute_inclusions (&result_symtabs
, all_children
.get (),
9663 all_type_symtabs
.get (), ptr
,
9667 /* Now we have a transitive closure of all the included symtabs. */
9668 len
= result_symtabs
.size ();
9670 = XOBNEWVEC (&per_objfile
->objfile
->objfile_obstack
,
9671 struct compunit_symtab
*, len
+ 1);
9672 memcpy (cust
->includes
, result_symtabs
.data (),
9673 len
* sizeof (compunit_symtab
*));
9674 cust
->includes
[len
] = NULL
;
9678 /* Compute the 'includes' field for the symtabs of all the CUs we just
9682 process_cu_includes (dwarf2_per_objfile
*per_objfile
)
9684 for (dwarf2_per_cu_data
*iter
: per_objfile
->per_bfd
->just_read_cus
)
9686 if (! iter
->is_debug_types
)
9687 compute_compunit_symtab_includes (iter
, per_objfile
);
9690 per_objfile
->per_bfd
->just_read_cus
.clear ();
9693 /* Generate full symbol information for CU, whose DIEs have
9694 already been loaded into memory. */
9697 process_full_comp_unit (dwarf2_cu
*cu
, enum language pretend_language
)
9699 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
9700 struct objfile
*objfile
= per_objfile
->objfile
;
9701 struct gdbarch
*gdbarch
= objfile
->arch ();
9702 CORE_ADDR lowpc
, highpc
;
9703 struct compunit_symtab
*cust
;
9705 struct block
*static_block
;
9708 baseaddr
= objfile
->text_section_offset ();
9710 /* Clear the list here in case something was left over. */
9711 cu
->method_list
.clear ();
9713 cu
->language
= pretend_language
;
9714 cu
->language_defn
= language_def (cu
->language
);
9716 dwarf2_find_base_address (cu
->dies
, cu
);
9718 /* Before we start reading the top-level DIE, ensure it has a valid tag
9720 switch (cu
->dies
->tag
)
9722 case DW_TAG_compile_unit
:
9723 case DW_TAG_partial_unit
:
9724 case DW_TAG_type_unit
:
9727 error (_("Dwarf Error: unexpected tag '%s' at offset %s [in module %s]"),
9728 dwarf_tag_name (cu
->dies
->tag
),
9729 sect_offset_str (cu
->per_cu
->sect_off
),
9730 objfile_name (per_objfile
->objfile
));
9733 /* Do line number decoding in read_file_scope () */
9734 process_die (cu
->dies
, cu
);
9736 /* For now fudge the Go package. */
9737 if (cu
->language
== language_go
)
9738 fixup_go_packaging (cu
);
9740 /* Now that we have processed all the DIEs in the CU, all the types
9741 should be complete, and it should now be safe to compute all of the
9743 compute_delayed_physnames (cu
);
9745 if (cu
->language
== language_rust
)
9746 rust_union_quirks (cu
);
9748 /* Some compilers don't define a DW_AT_high_pc attribute for the
9749 compilation unit. If the DW_AT_high_pc is missing, synthesize
9750 it, by scanning the DIE's below the compilation unit. */
9751 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
9753 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
9754 static_block
= cu
->get_builder ()->end_symtab_get_static_block (addr
, 0, 1);
9756 /* If the comp unit has DW_AT_ranges, it may have discontiguous ranges.
9757 Also, DW_AT_ranges may record ranges not belonging to any child DIEs
9758 (such as virtual method tables). Record the ranges in STATIC_BLOCK's
9759 addrmap to help ensure it has an accurate map of pc values belonging to
9761 dwarf2_record_block_ranges (cu
->dies
, static_block
, baseaddr
, cu
);
9763 cust
= cu
->get_builder ()->end_symtab_from_static_block (static_block
,
9764 SECT_OFF_TEXT (objfile
),
9769 int gcc_4_minor
= producer_is_gcc_ge_4 (cu
->producer
);
9771 /* Set symtab language to language from DW_AT_language. If the
9772 compilation is from a C file generated by language preprocessors, do
9773 not set the language if it was already deduced by start_subfile. */
9774 if (!(cu
->language
== language_c
9775 && COMPUNIT_FILETABS (cust
)->language
!= language_unknown
))
9776 COMPUNIT_FILETABS (cust
)->language
= cu
->language
;
9778 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
9779 produce DW_AT_location with location lists but it can be possibly
9780 invalid without -fvar-tracking. Still up to GCC-4.4.x incl. 4.4.0
9781 there were bugs in prologue debug info, fixed later in GCC-4.5
9782 by "unwind info for epilogues" patch (which is not directly related).
9784 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
9785 needed, it would be wrong due to missing DW_AT_producer there.
9787 Still one can confuse GDB by using non-standard GCC compilation
9788 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
9790 if (cu
->has_loclist
&& gcc_4_minor
>= 5)
9791 cust
->locations_valid
= 1;
9793 if (gcc_4_minor
>= 5)
9794 cust
->epilogue_unwind_valid
= 1;
9796 cust
->call_site_htab
= cu
->call_site_htab
;
9799 per_objfile
->set_symtab (cu
->per_cu
, cust
);
9801 /* Push it for inclusion processing later. */
9802 per_objfile
->per_bfd
->just_read_cus
.push_back (cu
->per_cu
);
9804 /* Not needed any more. */
9805 cu
->reset_builder ();
9808 /* Generate full symbol information for type unit CU, whose DIEs have
9809 already been loaded into memory. */
9812 process_full_type_unit (dwarf2_cu
*cu
,
9813 enum language pretend_language
)
9815 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
9816 struct objfile
*objfile
= per_objfile
->objfile
;
9817 struct compunit_symtab
*cust
;
9818 struct signatured_type
*sig_type
;
9820 gdb_assert (cu
->per_cu
->is_debug_types
);
9821 sig_type
= (struct signatured_type
*) cu
->per_cu
;
9823 /* Clear the list here in case something was left over. */
9824 cu
->method_list
.clear ();
9826 cu
->language
= pretend_language
;
9827 cu
->language_defn
= language_def (cu
->language
);
9829 /* The symbol tables are set up in read_type_unit_scope. */
9830 process_die (cu
->dies
, cu
);
9832 /* For now fudge the Go package. */
9833 if (cu
->language
== language_go
)
9834 fixup_go_packaging (cu
);
9836 /* Now that we have processed all the DIEs in the CU, all the types
9837 should be complete, and it should now be safe to compute all of the
9839 compute_delayed_physnames (cu
);
9841 if (cu
->language
== language_rust
)
9842 rust_union_quirks (cu
);
9844 /* TUs share symbol tables.
9845 If this is the first TU to use this symtab, complete the construction
9846 of it with end_expandable_symtab. Otherwise, complete the addition of
9847 this TU's symbols to the existing symtab. */
9848 type_unit_group_unshareable
*tug_unshare
=
9849 per_objfile
->get_type_unit_group_unshareable (sig_type
->type_unit_group
);
9850 if (tug_unshare
->compunit_symtab
== NULL
)
9852 buildsym_compunit
*builder
= cu
->get_builder ();
9853 cust
= builder
->end_expandable_symtab (0, SECT_OFF_TEXT (objfile
));
9854 tug_unshare
->compunit_symtab
= cust
;
9858 /* Set symtab language to language from DW_AT_language. If the
9859 compilation is from a C file generated by language preprocessors,
9860 do not set the language if it was already deduced by
9862 if (!(cu
->language
== language_c
9863 && COMPUNIT_FILETABS (cust
)->language
!= language_c
))
9864 COMPUNIT_FILETABS (cust
)->language
= cu
->language
;
9869 cu
->get_builder ()->augment_type_symtab ();
9870 cust
= tug_unshare
->compunit_symtab
;
9873 per_objfile
->set_symtab (cu
->per_cu
, cust
);
9875 /* Not needed any more. */
9876 cu
->reset_builder ();
9879 /* Process an imported unit DIE. */
9882 process_imported_unit_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
9884 struct attribute
*attr
;
9886 /* For now we don't handle imported units in type units. */
9887 if (cu
->per_cu
->is_debug_types
)
9889 error (_("Dwarf Error: DW_TAG_imported_unit is not"
9890 " supported in type units [in module %s]"),
9891 objfile_name (cu
->per_objfile
->objfile
));
9894 attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
9897 sect_offset sect_off
= attr
->get_ref_die_offset ();
9898 bool is_dwz
= (attr
->form
== DW_FORM_GNU_ref_alt
|| cu
->per_cu
->is_dwz
);
9899 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
9900 dwarf2_per_cu_data
*per_cu
9901 = dwarf2_find_containing_comp_unit (sect_off
, is_dwz
, per_objfile
);
9903 /* We're importing a C++ compilation unit with tag DW_TAG_compile_unit
9904 into another compilation unit, at root level. Regard this as a hint,
9906 if (die
->parent
&& die
->parent
->parent
== NULL
9907 && per_cu
->unit_type
== DW_UT_compile
9908 && per_cu
->lang
== language_cplus
)
9911 /* If necessary, add it to the queue and load its DIEs. */
9912 if (maybe_queue_comp_unit (cu
, per_cu
, per_objfile
, cu
->language
))
9913 load_full_comp_unit (per_cu
, per_objfile
, per_objfile
->get_cu (per_cu
),
9914 false, cu
->language
);
9916 cu
->per_cu
->imported_symtabs_push (per_cu
);
9920 /* RAII object that represents a process_die scope: i.e.,
9921 starts/finishes processing a DIE. */
9922 class process_die_scope
9925 process_die_scope (die_info
*die
, dwarf2_cu
*cu
)
9926 : m_die (die
), m_cu (cu
)
9928 /* We should only be processing DIEs not already in process. */
9929 gdb_assert (!m_die
->in_process
);
9930 m_die
->in_process
= true;
9933 ~process_die_scope ()
9935 m_die
->in_process
= false;
9937 /* If we're done processing the DIE for the CU that owns the line
9938 header, we don't need the line header anymore. */
9939 if (m_cu
->line_header_die_owner
== m_die
)
9941 delete m_cu
->line_header
;
9942 m_cu
->line_header
= NULL
;
9943 m_cu
->line_header_die_owner
= NULL
;
9952 /* Process a die and its children. */
9955 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
9957 process_die_scope
scope (die
, cu
);
9961 case DW_TAG_padding
:
9963 case DW_TAG_compile_unit
:
9964 case DW_TAG_partial_unit
:
9965 read_file_scope (die
, cu
);
9967 case DW_TAG_type_unit
:
9968 read_type_unit_scope (die
, cu
);
9970 case DW_TAG_subprogram
:
9971 /* Nested subprograms in Fortran get a prefix. */
9972 if (cu
->language
== language_fortran
9973 && die
->parent
!= NULL
9974 && die
->parent
->tag
== DW_TAG_subprogram
)
9975 cu
->processing_has_namespace_info
= true;
9977 case DW_TAG_inlined_subroutine
:
9978 read_func_scope (die
, cu
);
9980 case DW_TAG_lexical_block
:
9981 case DW_TAG_try_block
:
9982 case DW_TAG_catch_block
:
9983 read_lexical_block_scope (die
, cu
);
9985 case DW_TAG_call_site
:
9986 case DW_TAG_GNU_call_site
:
9987 read_call_site_scope (die
, cu
);
9989 case DW_TAG_class_type
:
9990 case DW_TAG_interface_type
:
9991 case DW_TAG_structure_type
:
9992 case DW_TAG_union_type
:
9993 process_structure_scope (die
, cu
);
9995 case DW_TAG_enumeration_type
:
9996 process_enumeration_scope (die
, cu
);
9999 /* These dies have a type, but processing them does not create
10000 a symbol or recurse to process the children. Therefore we can
10001 read them on-demand through read_type_die. */
10002 case DW_TAG_subroutine_type
:
10003 case DW_TAG_set_type
:
10004 case DW_TAG_pointer_type
:
10005 case DW_TAG_ptr_to_member_type
:
10006 case DW_TAG_reference_type
:
10007 case DW_TAG_rvalue_reference_type
:
10008 case DW_TAG_string_type
:
10011 case DW_TAG_array_type
:
10012 /* We only need to handle this case for Ada -- in other
10013 languages, it's normal for the compiler to emit a typedef
10015 if (cu
->language
!= language_ada
)
10018 case DW_TAG_base_type
:
10019 case DW_TAG_subrange_type
:
10020 case DW_TAG_typedef
:
10021 /* Add a typedef symbol for the type definition, if it has a
10023 new_symbol (die
, read_type_die (die
, cu
), cu
);
10025 case DW_TAG_common_block
:
10026 read_common_block (die
, cu
);
10028 case DW_TAG_common_inclusion
:
10030 case DW_TAG_namespace
:
10031 cu
->processing_has_namespace_info
= true;
10032 read_namespace (die
, cu
);
10034 case DW_TAG_module
:
10035 cu
->processing_has_namespace_info
= true;
10036 read_module (die
, cu
);
10038 case DW_TAG_imported_declaration
:
10039 cu
->processing_has_namespace_info
= true;
10040 if (read_namespace_alias (die
, cu
))
10042 /* The declaration is not a global namespace alias. */
10043 /* Fall through. */
10044 case DW_TAG_imported_module
:
10045 cu
->processing_has_namespace_info
= true;
10046 if (die
->child
!= NULL
&& (die
->tag
== DW_TAG_imported_declaration
10047 || cu
->language
!= language_fortran
))
10048 complaint (_("Tag '%s' has unexpected children"),
10049 dwarf_tag_name (die
->tag
));
10050 read_import_statement (die
, cu
);
10053 case DW_TAG_imported_unit
:
10054 process_imported_unit_die (die
, cu
);
10057 case DW_TAG_variable
:
10058 read_variable (die
, cu
);
10062 new_symbol (die
, NULL
, cu
);
10067 /* DWARF name computation. */
10069 /* A helper function for dwarf2_compute_name which determines whether DIE
10070 needs to have the name of the scope prepended to the name listed in the
10074 die_needs_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
10076 struct attribute
*attr
;
10080 case DW_TAG_namespace
:
10081 case DW_TAG_typedef
:
10082 case DW_TAG_class_type
:
10083 case DW_TAG_interface_type
:
10084 case DW_TAG_structure_type
:
10085 case DW_TAG_union_type
:
10086 case DW_TAG_enumeration_type
:
10087 case DW_TAG_enumerator
:
10088 case DW_TAG_subprogram
:
10089 case DW_TAG_inlined_subroutine
:
10090 case DW_TAG_member
:
10091 case DW_TAG_imported_declaration
:
10094 case DW_TAG_variable
:
10095 case DW_TAG_constant
:
10096 /* We only need to prefix "globally" visible variables. These include
10097 any variable marked with DW_AT_external or any variable that
10098 lives in a namespace. [Variables in anonymous namespaces
10099 require prefixing, but they are not DW_AT_external.] */
10101 if (dwarf2_attr (die
, DW_AT_specification
, cu
))
10103 struct dwarf2_cu
*spec_cu
= cu
;
10105 return die_needs_namespace (die_specification (die
, &spec_cu
),
10109 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
10110 if (attr
== NULL
&& die
->parent
->tag
!= DW_TAG_namespace
10111 && die
->parent
->tag
!= DW_TAG_module
)
10113 /* A variable in a lexical block of some kind does not need a
10114 namespace, even though in C++ such variables may be external
10115 and have a mangled name. */
10116 if (die
->parent
->tag
== DW_TAG_lexical_block
10117 || die
->parent
->tag
== DW_TAG_try_block
10118 || die
->parent
->tag
== DW_TAG_catch_block
10119 || die
->parent
->tag
== DW_TAG_subprogram
)
10128 /* Return the DIE's linkage name attribute, either DW_AT_linkage_name
10129 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
10130 defined for the given DIE. */
10132 static struct attribute
*
10133 dw2_linkage_name_attr (struct die_info
*die
, struct dwarf2_cu
*cu
)
10135 struct attribute
*attr
;
10137 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
10139 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
10144 /* Return the DIE's linkage name as a string, either DW_AT_linkage_name
10145 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
10146 defined for the given DIE. */
10148 static const char *
10149 dw2_linkage_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
10151 const char *linkage_name
;
10153 linkage_name
= dwarf2_string_attr (die
, DW_AT_linkage_name
, cu
);
10154 if (linkage_name
== NULL
)
10155 linkage_name
= dwarf2_string_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
10157 /* rustc emits invalid values for DW_AT_linkage_name. Ignore these.
10158 See https://github.com/rust-lang/rust/issues/32925. */
10159 if (cu
->language
== language_rust
&& linkage_name
!= NULL
10160 && strchr (linkage_name
, '{') != NULL
)
10161 linkage_name
= NULL
;
10163 return linkage_name
;
10166 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
10167 compute the physname for the object, which include a method's:
10168 - formal parameters (C++),
10169 - receiver type (Go),
10171 The term "physname" is a bit confusing.
10172 For C++, for example, it is the demangled name.
10173 For Go, for example, it's the mangled name.
10175 For Ada, return the DIE's linkage name rather than the fully qualified
10176 name. PHYSNAME is ignored..
10178 The result is allocated on the objfile->per_bfd's obstack and
10181 static const char *
10182 dwarf2_compute_name (const char *name
,
10183 struct die_info
*die
, struct dwarf2_cu
*cu
,
10186 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
10189 name
= dwarf2_name (die
, cu
);
10191 /* For Fortran GDB prefers DW_AT_*linkage_name for the physname if present
10192 but otherwise compute it by typename_concat inside GDB.
10193 FIXME: Actually this is not really true, or at least not always true.
10194 It's all very confusing. compute_and_set_names doesn't try to demangle
10195 Fortran names because there is no mangling standard. So new_symbol
10196 will set the demangled name to the result of dwarf2_full_name, and it is
10197 the demangled name that GDB uses if it exists. */
10198 if (cu
->language
== language_ada
10199 || (cu
->language
== language_fortran
&& physname
))
10201 /* For Ada unit, we prefer the linkage name over the name, as
10202 the former contains the exported name, which the user expects
10203 to be able to reference. Ideally, we want the user to be able
10204 to reference this entity using either natural or linkage name,
10205 but we haven't started looking at this enhancement yet. */
10206 const char *linkage_name
= dw2_linkage_name (die
, cu
);
10208 if (linkage_name
!= NULL
)
10209 return linkage_name
;
10212 /* These are the only languages we know how to qualify names in. */
10214 && (cu
->language
== language_cplus
10215 || cu
->language
== language_fortran
|| cu
->language
== language_d
10216 || cu
->language
== language_rust
))
10218 if (die_needs_namespace (die
, cu
))
10220 const char *prefix
;
10221 const char *canonical_name
= NULL
;
10225 prefix
= determine_prefix (die
, cu
);
10226 if (*prefix
!= '\0')
10228 gdb::unique_xmalloc_ptr
<char> prefixed_name
10229 (typename_concat (NULL
, prefix
, name
, physname
, cu
));
10231 buf
.puts (prefixed_name
.get ());
10236 /* Template parameters may be specified in the DIE's DW_AT_name, or
10237 as children with DW_TAG_template_type_param or
10238 DW_TAG_value_type_param. If the latter, add them to the name
10239 here. If the name already has template parameters, then
10240 skip this step; some versions of GCC emit both, and
10241 it is more efficient to use the pre-computed name.
10243 Something to keep in mind about this process: it is very
10244 unlikely, or in some cases downright impossible, to produce
10245 something that will match the mangled name of a function.
10246 If the definition of the function has the same debug info,
10247 we should be able to match up with it anyway. But fallbacks
10248 using the minimal symbol, for instance to find a method
10249 implemented in a stripped copy of libstdc++, will not work.
10250 If we do not have debug info for the definition, we will have to
10251 match them up some other way.
10253 When we do name matching there is a related problem with function
10254 templates; two instantiated function templates are allowed to
10255 differ only by their return types, which we do not add here. */
10257 if (cu
->language
== language_cplus
&& strchr (name
, '<') == NULL
)
10259 struct attribute
*attr
;
10260 struct die_info
*child
;
10262 const language_defn
*cplus_lang
= language_def (cu
->language
);
10264 die
->building_fullname
= 1;
10266 for (child
= die
->child
; child
!= NULL
; child
= child
->sibling
)
10270 const gdb_byte
*bytes
;
10271 struct dwarf2_locexpr_baton
*baton
;
10274 if (child
->tag
!= DW_TAG_template_type_param
10275 && child
->tag
!= DW_TAG_template_value_param
)
10286 attr
= dwarf2_attr (child
, DW_AT_type
, cu
);
10289 complaint (_("template parameter missing DW_AT_type"));
10290 buf
.puts ("UNKNOWN_TYPE");
10293 type
= die_type (child
, cu
);
10295 if (child
->tag
== DW_TAG_template_type_param
)
10297 cplus_lang
->print_type (type
, "", &buf
, -1, 0,
10298 &type_print_raw_options
);
10302 attr
= dwarf2_attr (child
, DW_AT_const_value
, cu
);
10305 complaint (_("template parameter missing "
10306 "DW_AT_const_value"));
10307 buf
.puts ("UNKNOWN_VALUE");
10311 dwarf2_const_value_attr (attr
, type
, name
,
10312 &cu
->comp_unit_obstack
, cu
,
10313 &value
, &bytes
, &baton
);
10315 if (type
->has_no_signedness ())
10316 /* GDB prints characters as NUMBER 'CHAR'. If that's
10317 changed, this can use value_print instead. */
10318 cplus_lang
->printchar (value
, type
, &buf
);
10321 struct value_print_options opts
;
10324 v
= dwarf2_evaluate_loc_desc (type
, NULL
,
10328 baton
->per_objfile
);
10329 else if (bytes
!= NULL
)
10331 v
= allocate_value (type
);
10332 memcpy (value_contents_writeable (v
), bytes
,
10333 TYPE_LENGTH (type
));
10336 v
= value_from_longest (type
, value
);
10338 /* Specify decimal so that we do not depend on
10340 get_formatted_print_options (&opts
, 'd');
10342 value_print (v
, &buf
, &opts
);
10347 die
->building_fullname
= 0;
10351 /* Close the argument list, with a space if necessary
10352 (nested templates). */
10353 if (!buf
.empty () && buf
.string ().back () == '>')
10360 /* For C++ methods, append formal parameter type
10361 information, if PHYSNAME. */
10363 if (physname
&& die
->tag
== DW_TAG_subprogram
10364 && cu
->language
== language_cplus
)
10366 struct type
*type
= read_type_die (die
, cu
);
10368 c_type_print_args (type
, &buf
, 1, cu
->language
,
10369 &type_print_raw_options
);
10371 if (cu
->language
== language_cplus
)
10373 /* Assume that an artificial first parameter is
10374 "this", but do not crash if it is not. RealView
10375 marks unnamed (and thus unused) parameters as
10376 artificial; there is no way to differentiate
10378 if (type
->num_fields () > 0
10379 && TYPE_FIELD_ARTIFICIAL (type
, 0)
10380 && type
->field (0).type ()->code () == TYPE_CODE_PTR
10381 && TYPE_CONST (TYPE_TARGET_TYPE (type
->field (0).type ())))
10382 buf
.puts (" const");
10386 const std::string
&intermediate_name
= buf
.string ();
10388 if (cu
->language
== language_cplus
)
10390 = dwarf2_canonicalize_name (intermediate_name
.c_str (), cu
,
10393 /* If we only computed INTERMEDIATE_NAME, or if
10394 INTERMEDIATE_NAME is already canonical, then we need to
10396 if (canonical_name
== NULL
|| canonical_name
== intermediate_name
.c_str ())
10397 name
= objfile
->intern (intermediate_name
);
10399 name
= canonical_name
;
10406 /* Return the fully qualified name of DIE, based on its DW_AT_name.
10407 If scope qualifiers are appropriate they will be added. The result
10408 will be allocated on the storage_obstack, or NULL if the DIE does
10409 not have a name. NAME may either be from a previous call to
10410 dwarf2_name or NULL.
10412 The output string will be canonicalized (if C++). */
10414 static const char *
10415 dwarf2_full_name (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
10417 return dwarf2_compute_name (name
, die
, cu
, 0);
10420 /* Construct a physname for the given DIE in CU. NAME may either be
10421 from a previous call to dwarf2_name or NULL. The result will be
10422 allocated on the objfile_objstack or NULL if the DIE does not have a
10425 The output string will be canonicalized (if C++). */
10427 static const char *
10428 dwarf2_physname (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
10430 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
10431 const char *retval
, *mangled
= NULL
, *canon
= NULL
;
10434 /* In this case dwarf2_compute_name is just a shortcut not building anything
10436 if (!die_needs_namespace (die
, cu
))
10437 return dwarf2_compute_name (name
, die
, cu
, 1);
10439 if (cu
->language
!= language_rust
)
10440 mangled
= dw2_linkage_name (die
, cu
);
10442 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
10444 gdb::unique_xmalloc_ptr
<char> demangled
;
10445 if (mangled
!= NULL
)
10448 if (language_def (cu
->language
)->store_sym_names_in_linkage_form_p ())
10450 /* Do nothing (do not demangle the symbol name). */
10454 /* Use DMGL_RET_DROP for C++ template functions to suppress
10455 their return type. It is easier for GDB users to search
10456 for such functions as `name(params)' than `long name(params)'.
10457 In such case the minimal symbol names do not match the full
10458 symbol names but for template functions there is never a need
10459 to look up their definition from their declaration so
10460 the only disadvantage remains the minimal symbol variant
10461 `long name(params)' does not have the proper inferior type. */
10462 demangled
.reset (gdb_demangle (mangled
,
10463 (DMGL_PARAMS
| DMGL_ANSI
10464 | DMGL_RET_DROP
)));
10467 canon
= demangled
.get ();
10475 if (canon
== NULL
|| check_physname
)
10477 const char *physname
= dwarf2_compute_name (name
, die
, cu
, 1);
10479 if (canon
!= NULL
&& strcmp (physname
, canon
) != 0)
10481 /* It may not mean a bug in GDB. The compiler could also
10482 compute DW_AT_linkage_name incorrectly. But in such case
10483 GDB would need to be bug-to-bug compatible. */
10485 complaint (_("Computed physname <%s> does not match demangled <%s> "
10486 "(from linkage <%s>) - DIE at %s [in module %s]"),
10487 physname
, canon
, mangled
, sect_offset_str (die
->sect_off
),
10488 objfile_name (objfile
));
10490 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
10491 is available here - over computed PHYSNAME. It is safer
10492 against both buggy GDB and buggy compilers. */
10506 retval
= objfile
->intern (retval
);
10511 /* Inspect DIE in CU for a namespace alias. If one exists, record
10512 a new symbol for it.
10514 Returns 1 if a namespace alias was recorded, 0 otherwise. */
10517 read_namespace_alias (struct die_info
*die
, struct dwarf2_cu
*cu
)
10519 struct attribute
*attr
;
10521 /* If the die does not have a name, this is not a namespace
10523 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
10527 struct die_info
*d
= die
;
10528 struct dwarf2_cu
*imported_cu
= cu
;
10530 /* If the compiler has nested DW_AT_imported_declaration DIEs,
10531 keep inspecting DIEs until we hit the underlying import. */
10532 #define MAX_NESTED_IMPORTED_DECLARATIONS 100
10533 for (num
= 0; num
< MAX_NESTED_IMPORTED_DECLARATIONS
; ++num
)
10535 attr
= dwarf2_attr (d
, DW_AT_import
, cu
);
10539 d
= follow_die_ref (d
, attr
, &imported_cu
);
10540 if (d
->tag
!= DW_TAG_imported_declaration
)
10544 if (num
== MAX_NESTED_IMPORTED_DECLARATIONS
)
10546 complaint (_("DIE at %s has too many recursively imported "
10547 "declarations"), sect_offset_str (d
->sect_off
));
10554 sect_offset sect_off
= attr
->get_ref_die_offset ();
10556 type
= get_die_type_at_offset (sect_off
, cu
->per_cu
, cu
->per_objfile
);
10557 if (type
!= NULL
&& type
->code () == TYPE_CODE_NAMESPACE
)
10559 /* This declaration is a global namespace alias. Add
10560 a symbol for it whose type is the aliased namespace. */
10561 new_symbol (die
, type
, cu
);
10570 /* Return the using directives repository (global or local?) to use in the
10571 current context for CU.
10573 For Ada, imported declarations can materialize renamings, which *may* be
10574 global. However it is impossible (for now?) in DWARF to distinguish
10575 "external" imported declarations and "static" ones. As all imported
10576 declarations seem to be static in all other languages, make them all CU-wide
10577 global only in Ada. */
10579 static struct using_direct
**
10580 using_directives (struct dwarf2_cu
*cu
)
10582 if (cu
->language
== language_ada
10583 && cu
->get_builder ()->outermost_context_p ())
10584 return cu
->get_builder ()->get_global_using_directives ();
10586 return cu
->get_builder ()->get_local_using_directives ();
10589 /* Read the import statement specified by the given die and record it. */
10592 read_import_statement (struct die_info
*die
, struct dwarf2_cu
*cu
)
10594 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
10595 struct attribute
*import_attr
;
10596 struct die_info
*imported_die
, *child_die
;
10597 struct dwarf2_cu
*imported_cu
;
10598 const char *imported_name
;
10599 const char *imported_name_prefix
;
10600 const char *canonical_name
;
10601 const char *import_alias
;
10602 const char *imported_declaration
= NULL
;
10603 const char *import_prefix
;
10604 std::vector
<const char *> excludes
;
10606 import_attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
10607 if (import_attr
== NULL
)
10609 complaint (_("Tag '%s' has no DW_AT_import"),
10610 dwarf_tag_name (die
->tag
));
10615 imported_die
= follow_die_ref_or_sig (die
, import_attr
, &imported_cu
);
10616 imported_name
= dwarf2_name (imported_die
, imported_cu
);
10617 if (imported_name
== NULL
)
10619 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
10621 The import in the following code:
10635 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
10636 <52> DW_AT_decl_file : 1
10637 <53> DW_AT_decl_line : 6
10638 <54> DW_AT_import : <0x75>
10639 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
10640 <59> DW_AT_name : B
10641 <5b> DW_AT_decl_file : 1
10642 <5c> DW_AT_decl_line : 2
10643 <5d> DW_AT_type : <0x6e>
10645 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
10646 <76> DW_AT_byte_size : 4
10647 <77> DW_AT_encoding : 5 (signed)
10649 imports the wrong die ( 0x75 instead of 0x58 ).
10650 This case will be ignored until the gcc bug is fixed. */
10654 /* Figure out the local name after import. */
10655 import_alias
= dwarf2_name (die
, cu
);
10657 /* Figure out where the statement is being imported to. */
10658 import_prefix
= determine_prefix (die
, cu
);
10660 /* Figure out what the scope of the imported die is and prepend it
10661 to the name of the imported die. */
10662 imported_name_prefix
= determine_prefix (imported_die
, imported_cu
);
10664 if (imported_die
->tag
!= DW_TAG_namespace
10665 && imported_die
->tag
!= DW_TAG_module
)
10667 imported_declaration
= imported_name
;
10668 canonical_name
= imported_name_prefix
;
10670 else if (strlen (imported_name_prefix
) > 0)
10671 canonical_name
= obconcat (&objfile
->objfile_obstack
,
10672 imported_name_prefix
,
10673 (cu
->language
== language_d
? "." : "::"),
10674 imported_name
, (char *) NULL
);
10676 canonical_name
= imported_name
;
10678 if (die
->tag
== DW_TAG_imported_module
&& cu
->language
== language_fortran
)
10679 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
10680 child_die
= child_die
->sibling
)
10682 /* DWARF-4: A Fortran use statement with a “rename list” may be
10683 represented by an imported module entry with an import attribute
10684 referring to the module and owned entries corresponding to those
10685 entities that are renamed as part of being imported. */
10687 if (child_die
->tag
!= DW_TAG_imported_declaration
)
10689 complaint (_("child DW_TAG_imported_declaration expected "
10690 "- DIE at %s [in module %s]"),
10691 sect_offset_str (child_die
->sect_off
),
10692 objfile_name (objfile
));
10696 import_attr
= dwarf2_attr (child_die
, DW_AT_import
, cu
);
10697 if (import_attr
== NULL
)
10699 complaint (_("Tag '%s' has no DW_AT_import"),
10700 dwarf_tag_name (child_die
->tag
));
10705 imported_die
= follow_die_ref_or_sig (child_die
, import_attr
,
10707 imported_name
= dwarf2_name (imported_die
, imported_cu
);
10708 if (imported_name
== NULL
)
10710 complaint (_("child DW_TAG_imported_declaration has unknown "
10711 "imported name - DIE at %s [in module %s]"),
10712 sect_offset_str (child_die
->sect_off
),
10713 objfile_name (objfile
));
10717 excludes
.push_back (imported_name
);
10719 process_die (child_die
, cu
);
10722 add_using_directive (using_directives (cu
),
10726 imported_declaration
,
10729 &objfile
->objfile_obstack
);
10732 /* ICC<14 does not output the required DW_AT_declaration on incomplete
10733 types, but gives them a size of zero. Starting with version 14,
10734 ICC is compatible with GCC. */
10737 producer_is_icc_lt_14 (struct dwarf2_cu
*cu
)
10739 if (!cu
->checked_producer
)
10740 check_producer (cu
);
10742 return cu
->producer_is_icc_lt_14
;
10745 /* ICC generates a DW_AT_type for C void functions. This was observed on
10746 ICC 14.0.5.212, and appears to be against the DWARF spec (V5 3.3.2)
10747 which says that void functions should not have a DW_AT_type. */
10750 producer_is_icc (struct dwarf2_cu
*cu
)
10752 if (!cu
->checked_producer
)
10753 check_producer (cu
);
10755 return cu
->producer_is_icc
;
10758 /* Check for possibly missing DW_AT_comp_dir with relative .debug_line
10759 directory paths. GCC SVN r127613 (new option -fdebug-prefix-map) fixed
10760 this, it was first present in GCC release 4.3.0. */
10763 producer_is_gcc_lt_4_3 (struct dwarf2_cu
*cu
)
10765 if (!cu
->checked_producer
)
10766 check_producer (cu
);
10768 return cu
->producer_is_gcc_lt_4_3
;
10771 static file_and_directory
10772 find_file_and_directory (struct die_info
*die
, struct dwarf2_cu
*cu
)
10774 file_and_directory res
;
10776 /* Find the filename. Do not use dwarf2_name here, since the filename
10777 is not a source language identifier. */
10778 res
.name
= dwarf2_string_attr (die
, DW_AT_name
, cu
);
10779 res
.comp_dir
= dwarf2_string_attr (die
, DW_AT_comp_dir
, cu
);
10781 if (res
.comp_dir
== NULL
10782 && producer_is_gcc_lt_4_3 (cu
) && res
.name
!= NULL
10783 && IS_ABSOLUTE_PATH (res
.name
))
10785 res
.comp_dir_storage
= ldirname (res
.name
);
10786 if (!res
.comp_dir_storage
.empty ())
10787 res
.comp_dir
= res
.comp_dir_storage
.c_str ();
10789 if (res
.comp_dir
!= NULL
)
10791 /* Irix 6.2 native cc prepends <machine>.: to the compilation
10792 directory, get rid of it. */
10793 const char *cp
= strchr (res
.comp_dir
, ':');
10795 if (cp
&& cp
!= res
.comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
10796 res
.comp_dir
= cp
+ 1;
10799 if (res
.name
== NULL
)
10800 res
.name
= "<unknown>";
10805 /* Handle DW_AT_stmt_list for a compilation unit.
10806 DIE is the DW_TAG_compile_unit die for CU.
10807 COMP_DIR is the compilation directory. LOWPC is passed to
10808 dwarf_decode_lines. See dwarf_decode_lines comments about it. */
10811 handle_DW_AT_stmt_list (struct die_info
*die
, struct dwarf2_cu
*cu
,
10812 const char *comp_dir
, CORE_ADDR lowpc
) /* ARI: editCase function */
10814 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
10815 struct attribute
*attr
;
10816 struct line_header line_header_local
;
10817 hashval_t line_header_local_hash
;
10819 int decode_mapping
;
10821 gdb_assert (! cu
->per_cu
->is_debug_types
);
10823 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
10824 if (attr
== NULL
|| !attr
->form_is_unsigned ())
10827 sect_offset line_offset
= (sect_offset
) attr
->as_unsigned ();
10829 /* The line header hash table is only created if needed (it exists to
10830 prevent redundant reading of the line table for partial_units).
10831 If we're given a partial_unit, we'll need it. If we're given a
10832 compile_unit, then use the line header hash table if it's already
10833 created, but don't create one just yet. */
10835 if (per_objfile
->line_header_hash
== NULL
10836 && die
->tag
== DW_TAG_partial_unit
)
10838 per_objfile
->line_header_hash
10839 .reset (htab_create_alloc (127, line_header_hash_voidp
,
10840 line_header_eq_voidp
,
10841 free_line_header_voidp
,
10845 line_header_local
.sect_off
= line_offset
;
10846 line_header_local
.offset_in_dwz
= cu
->per_cu
->is_dwz
;
10847 line_header_local_hash
= line_header_hash (&line_header_local
);
10848 if (per_objfile
->line_header_hash
!= NULL
)
10850 slot
= htab_find_slot_with_hash (per_objfile
->line_header_hash
.get (),
10851 &line_header_local
,
10852 line_header_local_hash
, NO_INSERT
);
10854 /* For DW_TAG_compile_unit we need info like symtab::linetable which
10855 is not present in *SLOT (since if there is something in *SLOT then
10856 it will be for a partial_unit). */
10857 if (die
->tag
== DW_TAG_partial_unit
&& slot
!= NULL
)
10859 gdb_assert (*slot
!= NULL
);
10860 cu
->line_header
= (struct line_header
*) *slot
;
10865 /* dwarf_decode_line_header does not yet provide sufficient information.
10866 We always have to call also dwarf_decode_lines for it. */
10867 line_header_up lh
= dwarf_decode_line_header (line_offset
, cu
);
10871 cu
->line_header
= lh
.release ();
10872 cu
->line_header_die_owner
= die
;
10874 if (per_objfile
->line_header_hash
== NULL
)
10878 slot
= htab_find_slot_with_hash (per_objfile
->line_header_hash
.get (),
10879 &line_header_local
,
10880 line_header_local_hash
, INSERT
);
10881 gdb_assert (slot
!= NULL
);
10883 if (slot
!= NULL
&& *slot
== NULL
)
10885 /* This newly decoded line number information unit will be owned
10886 by line_header_hash hash table. */
10887 *slot
= cu
->line_header
;
10888 cu
->line_header_die_owner
= NULL
;
10892 /* We cannot free any current entry in (*slot) as that struct line_header
10893 may be already used by multiple CUs. Create only temporary decoded
10894 line_header for this CU - it may happen at most once for each line
10895 number information unit. And if we're not using line_header_hash
10896 then this is what we want as well. */
10897 gdb_assert (die
->tag
!= DW_TAG_partial_unit
);
10899 decode_mapping
= (die
->tag
!= DW_TAG_partial_unit
);
10900 dwarf_decode_lines (cu
->line_header
, comp_dir
, cu
, NULL
, lowpc
,
10905 /* Process DW_TAG_compile_unit or DW_TAG_partial_unit. */
10908 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
10910 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
10911 struct objfile
*objfile
= per_objfile
->objfile
;
10912 struct gdbarch
*gdbarch
= objfile
->arch ();
10913 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
10914 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
10915 struct attribute
*attr
;
10916 struct die_info
*child_die
;
10917 CORE_ADDR baseaddr
;
10919 prepare_one_comp_unit (cu
, die
, cu
->language
);
10920 baseaddr
= objfile
->text_section_offset ();
10922 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
10924 /* If we didn't find a lowpc, set it to highpc to avoid complaints
10925 from finish_block. */
10926 if (lowpc
== ((CORE_ADDR
) -1))
10928 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
10930 file_and_directory fnd
= find_file_and_directory (die
, cu
);
10932 /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
10933 standardised yet. As a workaround for the language detection we fall
10934 back to the DW_AT_producer string. */
10935 if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL") != NULL
)
10936 cu
->language
= language_opencl
;
10938 /* Similar hack for Go. */
10939 if (cu
->producer
&& strstr (cu
->producer
, "GNU Go ") != NULL
)
10940 set_cu_language (DW_LANG_Go
, cu
);
10942 cu
->start_symtab (fnd
.name
, fnd
.comp_dir
, lowpc
);
10944 /* Decode line number information if present. We do this before
10945 processing child DIEs, so that the line header table is available
10946 for DW_AT_decl_file. */
10947 handle_DW_AT_stmt_list (die
, cu
, fnd
.comp_dir
, lowpc
);
10949 /* Process all dies in compilation unit. */
10950 if (die
->child
!= NULL
)
10952 child_die
= die
->child
;
10953 while (child_die
&& child_die
->tag
)
10955 process_die (child_die
, cu
);
10956 child_die
= child_die
->sibling
;
10960 /* Decode macro information, if present. Dwarf 2 macro information
10961 refers to information in the line number info statement program
10962 header, so we can only read it if we've read the header
10964 attr
= dwarf2_attr (die
, DW_AT_macros
, cu
);
10966 attr
= dwarf2_attr (die
, DW_AT_GNU_macros
, cu
);
10967 if (attr
!= nullptr && attr
->form_is_unsigned () && cu
->line_header
)
10969 if (dwarf2_attr (die
, DW_AT_macro_info
, cu
))
10970 complaint (_("CU refers to both DW_AT_macros and DW_AT_macro_info"));
10972 dwarf_decode_macros (cu
, attr
->as_unsigned (), 1);
10976 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
10977 if (attr
!= nullptr && attr
->form_is_unsigned () && cu
->line_header
)
10979 unsigned int macro_offset
= attr
->as_unsigned ();
10981 dwarf_decode_macros (cu
, macro_offset
, 0);
10987 dwarf2_cu::setup_type_unit_groups (struct die_info
*die
)
10989 struct type_unit_group
*tu_group
;
10991 struct attribute
*attr
;
10993 struct signatured_type
*sig_type
;
10995 gdb_assert (per_cu
->is_debug_types
);
10996 sig_type
= (struct signatured_type
*) per_cu
;
10998 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, this);
11000 /* If we're using .gdb_index (includes -readnow) then
11001 per_cu->type_unit_group may not have been set up yet. */
11002 if (sig_type
->type_unit_group
== NULL
)
11003 sig_type
->type_unit_group
= get_type_unit_group (this, attr
);
11004 tu_group
= sig_type
->type_unit_group
;
11006 /* If we've already processed this stmt_list there's no real need to
11007 do it again, we could fake it and just recreate the part we need
11008 (file name,index -> symtab mapping). If data shows this optimization
11009 is useful we can do it then. */
11010 type_unit_group_unshareable
*tug_unshare
11011 = per_objfile
->get_type_unit_group_unshareable (tu_group
);
11012 first_time
= tug_unshare
->compunit_symtab
== NULL
;
11014 /* We have to handle the case of both a missing DW_AT_stmt_list or bad
11017 if (attr
!= NULL
&& attr
->form_is_unsigned ())
11019 sect_offset line_offset
= (sect_offset
) attr
->as_unsigned ();
11020 lh
= dwarf_decode_line_header (line_offset
, this);
11025 start_symtab ("", NULL
, 0);
11028 gdb_assert (tug_unshare
->symtabs
== NULL
);
11029 gdb_assert (m_builder
== nullptr);
11030 struct compunit_symtab
*cust
= tug_unshare
->compunit_symtab
;
11031 m_builder
.reset (new struct buildsym_compunit
11032 (COMPUNIT_OBJFILE (cust
), "",
11033 COMPUNIT_DIRNAME (cust
),
11034 compunit_language (cust
),
11036 list_in_scope
= get_builder ()->get_file_symbols ();
11041 line_header
= lh
.release ();
11042 line_header_die_owner
= die
;
11046 struct compunit_symtab
*cust
= start_symtab ("", NULL
, 0);
11048 /* Note: We don't assign tu_group->compunit_symtab yet because we're
11049 still initializing it, and our caller (a few levels up)
11050 process_full_type_unit still needs to know if this is the first
11053 tug_unshare
->symtabs
11054 = XOBNEWVEC (&COMPUNIT_OBJFILE (cust
)->objfile_obstack
,
11055 struct symtab
*, line_header
->file_names_size ());
11057 auto &file_names
= line_header
->file_names ();
11058 for (i
= 0; i
< file_names
.size (); ++i
)
11060 file_entry
&fe
= file_names
[i
];
11061 dwarf2_start_subfile (this, fe
.name
,
11062 fe
.include_dir (line_header
));
11063 buildsym_compunit
*b
= get_builder ();
11064 if (b
->get_current_subfile ()->symtab
== NULL
)
11066 /* NOTE: start_subfile will recognize when it's been
11067 passed a file it has already seen. So we can't
11068 assume there's a simple mapping from
11069 cu->line_header->file_names to subfiles, plus
11070 cu->line_header->file_names may contain dups. */
11071 b
->get_current_subfile ()->symtab
11072 = allocate_symtab (cust
, b
->get_current_subfile ()->name
);
11075 fe
.symtab
= b
->get_current_subfile ()->symtab
;
11076 tug_unshare
->symtabs
[i
] = fe
.symtab
;
11081 gdb_assert (m_builder
== nullptr);
11082 struct compunit_symtab
*cust
= tug_unshare
->compunit_symtab
;
11083 m_builder
.reset (new struct buildsym_compunit
11084 (COMPUNIT_OBJFILE (cust
), "",
11085 COMPUNIT_DIRNAME (cust
),
11086 compunit_language (cust
),
11088 list_in_scope
= get_builder ()->get_file_symbols ();
11090 auto &file_names
= line_header
->file_names ();
11091 for (i
= 0; i
< file_names
.size (); ++i
)
11093 file_entry
&fe
= file_names
[i
];
11094 fe
.symtab
= tug_unshare
->symtabs
[i
];
11098 /* The main symtab is allocated last. Type units don't have DW_AT_name
11099 so they don't have a "real" (so to speak) symtab anyway.
11100 There is later code that will assign the main symtab to all symbols
11101 that don't have one. We need to handle the case of a symbol with a
11102 missing symtab (DW_AT_decl_file) anyway. */
11105 /* Process DW_TAG_type_unit.
11106 For TUs we want to skip the first top level sibling if it's not the
11107 actual type being defined by this TU. In this case the first top
11108 level sibling is there to provide context only. */
11111 read_type_unit_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
11113 struct die_info
*child_die
;
11115 prepare_one_comp_unit (cu
, die
, language_minimal
);
11117 /* Initialize (or reinitialize) the machinery for building symtabs.
11118 We do this before processing child DIEs, so that the line header table
11119 is available for DW_AT_decl_file. */
11120 cu
->setup_type_unit_groups (die
);
11122 if (die
->child
!= NULL
)
11124 child_die
= die
->child
;
11125 while (child_die
&& child_die
->tag
)
11127 process_die (child_die
, cu
);
11128 child_die
= child_die
->sibling
;
11135 http://gcc.gnu.org/wiki/DebugFission
11136 http://gcc.gnu.org/wiki/DebugFissionDWP
11138 To simplify handling of both DWO files ("object" files with the DWARF info)
11139 and DWP files (a file with the DWOs packaged up into one file), we treat
11140 DWP files as having a collection of virtual DWO files. */
11143 hash_dwo_file (const void *item
)
11145 const struct dwo_file
*dwo_file
= (const struct dwo_file
*) item
;
11148 hash
= htab_hash_string (dwo_file
->dwo_name
);
11149 if (dwo_file
->comp_dir
!= NULL
)
11150 hash
+= htab_hash_string (dwo_file
->comp_dir
);
11155 eq_dwo_file (const void *item_lhs
, const void *item_rhs
)
11157 const struct dwo_file
*lhs
= (const struct dwo_file
*) item_lhs
;
11158 const struct dwo_file
*rhs
= (const struct dwo_file
*) item_rhs
;
11160 if (strcmp (lhs
->dwo_name
, rhs
->dwo_name
) != 0)
11162 if (lhs
->comp_dir
== NULL
|| rhs
->comp_dir
== NULL
)
11163 return lhs
->comp_dir
== rhs
->comp_dir
;
11164 return strcmp (lhs
->comp_dir
, rhs
->comp_dir
) == 0;
11167 /* Allocate a hash table for DWO files. */
11170 allocate_dwo_file_hash_table ()
11172 auto delete_dwo_file
= [] (void *item
)
11174 struct dwo_file
*dwo_file
= (struct dwo_file
*) item
;
11179 return htab_up (htab_create_alloc (41,
11186 /* Lookup DWO file DWO_NAME. */
11189 lookup_dwo_file_slot (dwarf2_per_objfile
*per_objfile
,
11190 const char *dwo_name
,
11191 const char *comp_dir
)
11193 struct dwo_file find_entry
;
11196 if (per_objfile
->per_bfd
->dwo_files
== NULL
)
11197 per_objfile
->per_bfd
->dwo_files
= allocate_dwo_file_hash_table ();
11199 find_entry
.dwo_name
= dwo_name
;
11200 find_entry
.comp_dir
= comp_dir
;
11201 slot
= htab_find_slot (per_objfile
->per_bfd
->dwo_files
.get (), &find_entry
,
11208 hash_dwo_unit (const void *item
)
11210 const struct dwo_unit
*dwo_unit
= (const struct dwo_unit
*) item
;
11212 /* This drops the top 32 bits of the id, but is ok for a hash. */
11213 return dwo_unit
->signature
;
11217 eq_dwo_unit (const void *item_lhs
, const void *item_rhs
)
11219 const struct dwo_unit
*lhs
= (const struct dwo_unit
*) item_lhs
;
11220 const struct dwo_unit
*rhs
= (const struct dwo_unit
*) item_rhs
;
11222 /* The signature is assumed to be unique within the DWO file.
11223 So while object file CU dwo_id's always have the value zero,
11224 that's OK, assuming each object file DWO file has only one CU,
11225 and that's the rule for now. */
11226 return lhs
->signature
== rhs
->signature
;
11229 /* Allocate a hash table for DWO CUs,TUs.
11230 There is one of these tables for each of CUs,TUs for each DWO file. */
11233 allocate_dwo_unit_table ()
11235 /* Start out with a pretty small number.
11236 Generally DWO files contain only one CU and maybe some TUs. */
11237 return htab_up (htab_create_alloc (3,
11240 NULL
, xcalloc
, xfree
));
11243 /* die_reader_func for create_dwo_cu. */
11246 create_dwo_cu_reader (const struct die_reader_specs
*reader
,
11247 const gdb_byte
*info_ptr
,
11248 struct die_info
*comp_unit_die
,
11249 struct dwo_file
*dwo_file
,
11250 struct dwo_unit
*dwo_unit
)
11252 struct dwarf2_cu
*cu
= reader
->cu
;
11253 sect_offset sect_off
= cu
->per_cu
->sect_off
;
11254 struct dwarf2_section_info
*section
= cu
->per_cu
->section
;
11256 gdb::optional
<ULONGEST
> signature
= lookup_dwo_id (cu
, comp_unit_die
);
11257 if (!signature
.has_value ())
11259 complaint (_("Dwarf Error: debug entry at offset %s is missing"
11260 " its dwo_id [in module %s]"),
11261 sect_offset_str (sect_off
), dwo_file
->dwo_name
);
11265 dwo_unit
->dwo_file
= dwo_file
;
11266 dwo_unit
->signature
= *signature
;
11267 dwo_unit
->section
= section
;
11268 dwo_unit
->sect_off
= sect_off
;
11269 dwo_unit
->length
= cu
->per_cu
->length
;
11271 dwarf_read_debug_printf (" offset %s, dwo_id %s",
11272 sect_offset_str (sect_off
),
11273 hex_string (dwo_unit
->signature
));
11276 /* Create the dwo_units for the CUs in a DWO_FILE.
11277 Note: This function processes DWO files only, not DWP files. */
11280 create_cus_hash_table (dwarf2_per_objfile
*per_objfile
,
11281 dwarf2_cu
*cu
, struct dwo_file
&dwo_file
,
11282 dwarf2_section_info
§ion
, htab_up
&cus_htab
)
11284 struct objfile
*objfile
= per_objfile
->objfile
;
11285 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
11286 const gdb_byte
*info_ptr
, *end_ptr
;
11288 section
.read (objfile
);
11289 info_ptr
= section
.buffer
;
11291 if (info_ptr
== NULL
)
11294 dwarf_read_debug_printf ("Reading %s for %s:",
11295 section
.get_name (),
11296 section
.get_file_name ());
11298 end_ptr
= info_ptr
+ section
.size
;
11299 while (info_ptr
< end_ptr
)
11301 struct dwarf2_per_cu_data per_cu
;
11302 struct dwo_unit read_unit
{};
11303 struct dwo_unit
*dwo_unit
;
11305 sect_offset sect_off
= (sect_offset
) (info_ptr
- section
.buffer
);
11307 memset (&per_cu
, 0, sizeof (per_cu
));
11308 per_cu
.per_bfd
= per_bfd
;
11309 per_cu
.is_debug_types
= 0;
11310 per_cu
.sect_off
= sect_offset (info_ptr
- section
.buffer
);
11311 per_cu
.section
= §ion
;
11313 cutu_reader
reader (&per_cu
, per_objfile
, cu
, &dwo_file
);
11314 if (!reader
.dummy_p
)
11315 create_dwo_cu_reader (&reader
, reader
.info_ptr
, reader
.comp_unit_die
,
11316 &dwo_file
, &read_unit
);
11317 info_ptr
+= per_cu
.length
;
11319 // If the unit could not be parsed, skip it.
11320 if (read_unit
.dwo_file
== NULL
)
11323 if (cus_htab
== NULL
)
11324 cus_htab
= allocate_dwo_unit_table ();
11326 dwo_unit
= OBSTACK_ZALLOC (&per_bfd
->obstack
,
11328 *dwo_unit
= read_unit
;
11329 slot
= htab_find_slot (cus_htab
.get (), dwo_unit
, INSERT
);
11330 gdb_assert (slot
!= NULL
);
11333 const struct dwo_unit
*dup_cu
= (const struct dwo_unit
*)*slot
;
11334 sect_offset dup_sect_off
= dup_cu
->sect_off
;
11336 complaint (_("debug cu entry at offset %s is duplicate to"
11337 " the entry at offset %s, signature %s"),
11338 sect_offset_str (sect_off
), sect_offset_str (dup_sect_off
),
11339 hex_string (dwo_unit
->signature
));
11341 *slot
= (void *)dwo_unit
;
11345 /* DWP file .debug_{cu,tu}_index section format:
11346 [ref: http://gcc.gnu.org/wiki/DebugFissionDWP]
11347 [ref: http://dwarfstd.org/doc/DWARF5.pdf, sect 7.3.5 "DWARF Package Files"]
11349 DWP Versions 1 & 2 are older, pre-standard format versions. The first
11350 officially standard DWP format was published with DWARF v5 and is called
11351 Version 5. There are no versions 3 or 4.
11355 Both index sections have the same format, and serve to map a 64-bit
11356 signature to a set of section numbers. Each section begins with a header,
11357 followed by a hash table of 64-bit signatures, a parallel table of 32-bit
11358 indexes, and a pool of 32-bit section numbers. The index sections will be
11359 aligned at 8-byte boundaries in the file.
11361 The index section header consists of:
11363 V, 32 bit version number
11365 N, 32 bit number of compilation units or type units in the index
11366 M, 32 bit number of slots in the hash table
11368 Numbers are recorded using the byte order of the application binary.
11370 The hash table begins at offset 16 in the section, and consists of an array
11371 of M 64-bit slots. Each slot contains a 64-bit signature (using the byte
11372 order of the application binary). Unused slots in the hash table are 0.
11373 (We rely on the extreme unlikeliness of a signature being exactly 0.)
11375 The parallel table begins immediately after the hash table
11376 (at offset 16 + 8 * M from the beginning of the section), and consists of an
11377 array of 32-bit indexes (using the byte order of the application binary),
11378 corresponding 1-1 with slots in the hash table. Each entry in the parallel
11379 table contains a 32-bit index into the pool of section numbers. For unused
11380 hash table slots, the corresponding entry in the parallel table will be 0.
11382 The pool of section numbers begins immediately following the hash table
11383 (at offset 16 + 12 * M from the beginning of the section). The pool of
11384 section numbers consists of an array of 32-bit words (using the byte order
11385 of the application binary). Each item in the array is indexed starting
11386 from 0. The hash table entry provides the index of the first section
11387 number in the set. Additional section numbers in the set follow, and the
11388 set is terminated by a 0 entry (section number 0 is not used in ELF).
11390 In each set of section numbers, the .debug_info.dwo or .debug_types.dwo
11391 section must be the first entry in the set, and the .debug_abbrev.dwo must
11392 be the second entry. Other members of the set may follow in any order.
11396 DWP Versions 2 and 5:
11398 DWP Versions 2 and 5 combine all the .debug_info, etc. sections into one,
11399 and the entries in the index tables are now offsets into these sections.
11400 CU offsets begin at 0. TU offsets begin at the size of the .debug_info
11403 Index Section Contents:
11405 Hash Table of Signatures dwp_hash_table.hash_table
11406 Parallel Table of Indices dwp_hash_table.unit_table
11407 Table of Section Offsets dwp_hash_table.{v2|v5}.{section_ids,offsets}
11408 Table of Section Sizes dwp_hash_table.{v2|v5}.sizes
11410 The index section header consists of:
11412 V, 32 bit version number
11413 L, 32 bit number of columns in the table of section offsets
11414 N, 32 bit number of compilation units or type units in the index
11415 M, 32 bit number of slots in the hash table
11417 Numbers are recorded using the byte order of the application binary.
11419 The hash table has the same format as version 1.
11420 The parallel table of indices has the same format as version 1,
11421 except that the entries are origin-1 indices into the table of sections
11422 offsets and the table of section sizes.
11424 The table of offsets begins immediately following the parallel table
11425 (at offset 16 + 12 * M from the beginning of the section). The table is
11426 a two-dimensional array of 32-bit words (using the byte order of the
11427 application binary), with L columns and N+1 rows, in row-major order.
11428 Each row in the array is indexed starting from 0. The first row provides
11429 a key to the remaining rows: each column in this row provides an identifier
11430 for a debug section, and the offsets in the same column of subsequent rows
11431 refer to that section. The section identifiers for Version 2 are:
11433 DW_SECT_INFO 1 .debug_info.dwo
11434 DW_SECT_TYPES 2 .debug_types.dwo
11435 DW_SECT_ABBREV 3 .debug_abbrev.dwo
11436 DW_SECT_LINE 4 .debug_line.dwo
11437 DW_SECT_LOC 5 .debug_loc.dwo
11438 DW_SECT_STR_OFFSETS 6 .debug_str_offsets.dwo
11439 DW_SECT_MACINFO 7 .debug_macinfo.dwo
11440 DW_SECT_MACRO 8 .debug_macro.dwo
11442 The section identifiers for Version 5 are:
11444 DW_SECT_INFO_V5 1 .debug_info.dwo
11445 DW_SECT_RESERVED_V5 2 --
11446 DW_SECT_ABBREV_V5 3 .debug_abbrev.dwo
11447 DW_SECT_LINE_V5 4 .debug_line.dwo
11448 DW_SECT_LOCLISTS_V5 5 .debug_loclists.dwo
11449 DW_SECT_STR_OFFSETS_V5 6 .debug_str_offsets.dwo
11450 DW_SECT_MACRO_V5 7 .debug_macro.dwo
11451 DW_SECT_RNGLISTS_V5 8 .debug_rnglists.dwo
11453 The offsets provided by the CU and TU index sections are the base offsets
11454 for the contributions made by each CU or TU to the corresponding section
11455 in the package file. Each CU and TU header contains an abbrev_offset
11456 field, used to find the abbreviations table for that CU or TU within the
11457 contribution to the .debug_abbrev.dwo section for that CU or TU, and should
11458 be interpreted as relative to the base offset given in the index section.
11459 Likewise, offsets into .debug_line.dwo from DW_AT_stmt_list attributes
11460 should be interpreted as relative to the base offset for .debug_line.dwo,
11461 and offsets into other debug sections obtained from DWARF attributes should
11462 also be interpreted as relative to the corresponding base offset.
11464 The table of sizes begins immediately following the table of offsets.
11465 Like the table of offsets, it is a two-dimensional array of 32-bit words,
11466 with L columns and N rows, in row-major order. Each row in the array is
11467 indexed starting from 1 (row 0 is shared by the two tables).
11471 Hash table lookup is handled the same in version 1 and 2:
11473 We assume that N and M will not exceed 2^32 - 1.
11474 The size of the hash table, M, must be 2^k such that 2^k > 3*N/2.
11476 Given a 64-bit compilation unit signature or a type signature S, an entry
11477 in the hash table is located as follows:
11479 1) Calculate a primary hash H = S & MASK(k), where MASK(k) is a mask with
11480 the low-order k bits all set to 1.
11482 2) Calculate a secondary hash H' = (((S >> 32) & MASK(k)) | 1).
11484 3) If the hash table entry at index H matches the signature, use that
11485 entry. If the hash table entry at index H is unused (all zeroes),
11486 terminate the search: the signature is not present in the table.
11488 4) Let H = (H + H') modulo M. Repeat at Step 3.
11490 Because M > N and H' and M are relatively prime, the search is guaranteed
11491 to stop at an unused slot or find the match. */
11493 /* Create a hash table to map DWO IDs to their CU/TU entry in
11494 .debug_{info,types}.dwo in DWP_FILE.
11495 Returns NULL if there isn't one.
11496 Note: This function processes DWP files only, not DWO files. */
11498 static struct dwp_hash_table
*
11499 create_dwp_hash_table (dwarf2_per_objfile
*per_objfile
,
11500 struct dwp_file
*dwp_file
, int is_debug_types
)
11502 struct objfile
*objfile
= per_objfile
->objfile
;
11503 bfd
*dbfd
= dwp_file
->dbfd
.get ();
11504 const gdb_byte
*index_ptr
, *index_end
;
11505 struct dwarf2_section_info
*index
;
11506 uint32_t version
, nr_columns
, nr_units
, nr_slots
;
11507 struct dwp_hash_table
*htab
;
11509 if (is_debug_types
)
11510 index
= &dwp_file
->sections
.tu_index
;
11512 index
= &dwp_file
->sections
.cu_index
;
11514 if (index
->empty ())
11516 index
->read (objfile
);
11518 index_ptr
= index
->buffer
;
11519 index_end
= index_ptr
+ index
->size
;
11521 /* For Version 5, the version is really 2 bytes of data & 2 bytes of padding.
11522 For now it's safe to just read 4 bytes (particularly as it's difficult to
11523 tell if you're dealing with Version 5 before you've read the version). */
11524 version
= read_4_bytes (dbfd
, index_ptr
);
11526 if (version
== 2 || version
== 5)
11527 nr_columns
= read_4_bytes (dbfd
, index_ptr
);
11531 nr_units
= read_4_bytes (dbfd
, index_ptr
);
11533 nr_slots
= read_4_bytes (dbfd
, index_ptr
);
11536 if (version
!= 1 && version
!= 2 && version
!= 5)
11538 error (_("Dwarf Error: unsupported DWP file version (%s)"
11539 " [in module %s]"),
11540 pulongest (version
), dwp_file
->name
);
11542 if (nr_slots
!= (nr_slots
& -nr_slots
))
11544 error (_("Dwarf Error: number of slots in DWP hash table (%s)"
11545 " is not power of 2 [in module %s]"),
11546 pulongest (nr_slots
), dwp_file
->name
);
11549 htab
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, struct dwp_hash_table
);
11550 htab
->version
= version
;
11551 htab
->nr_columns
= nr_columns
;
11552 htab
->nr_units
= nr_units
;
11553 htab
->nr_slots
= nr_slots
;
11554 htab
->hash_table
= index_ptr
;
11555 htab
->unit_table
= htab
->hash_table
+ sizeof (uint64_t) * nr_slots
;
11557 /* Exit early if the table is empty. */
11558 if (nr_slots
== 0 || nr_units
== 0
11559 || (version
== 2 && nr_columns
== 0)
11560 || (version
== 5 && nr_columns
== 0))
11562 /* All must be zero. */
11563 if (nr_slots
!= 0 || nr_units
!= 0
11564 || (version
== 2 && nr_columns
!= 0)
11565 || (version
== 5 && nr_columns
!= 0))
11567 complaint (_("Empty DWP but nr_slots,nr_units,nr_columns not"
11568 " all zero [in modules %s]"),
11576 htab
->section_pool
.v1
.indices
=
11577 htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
11578 /* It's harder to decide whether the section is too small in v1.
11579 V1 is deprecated anyway so we punt. */
11581 else if (version
== 2)
11583 const gdb_byte
*ids_ptr
= htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
11584 int *ids
= htab
->section_pool
.v2
.section_ids
;
11585 size_t sizeof_ids
= sizeof (htab
->section_pool
.v2
.section_ids
);
11586 /* Reverse map for error checking. */
11587 int ids_seen
[DW_SECT_MAX
+ 1];
11590 if (nr_columns
< 2)
11592 error (_("Dwarf Error: bad DWP hash table, too few columns"
11593 " in section table [in module %s]"),
11596 if (nr_columns
> MAX_NR_V2_DWO_SECTIONS
)
11598 error (_("Dwarf Error: bad DWP hash table, too many columns"
11599 " in section table [in module %s]"),
11602 memset (ids
, 255, sizeof_ids
);
11603 memset (ids_seen
, 255, sizeof (ids_seen
));
11604 for (i
= 0; i
< nr_columns
; ++i
)
11606 int id
= read_4_bytes (dbfd
, ids_ptr
+ i
* sizeof (uint32_t));
11608 if (id
< DW_SECT_MIN
|| id
> DW_SECT_MAX
)
11610 error (_("Dwarf Error: bad DWP hash table, bad section id %d"
11611 " in section table [in module %s]"),
11612 id
, dwp_file
->name
);
11614 if (ids_seen
[id
] != -1)
11616 error (_("Dwarf Error: bad DWP hash table, duplicate section"
11617 " id %d in section table [in module %s]"),
11618 id
, dwp_file
->name
);
11623 /* Must have exactly one info or types section. */
11624 if (((ids_seen
[DW_SECT_INFO
] != -1)
11625 + (ids_seen
[DW_SECT_TYPES
] != -1))
11628 error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
11629 " DWO info/types section [in module %s]"),
11632 /* Must have an abbrev section. */
11633 if (ids_seen
[DW_SECT_ABBREV
] == -1)
11635 error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
11636 " section [in module %s]"),
11639 htab
->section_pool
.v2
.offsets
= ids_ptr
+ sizeof (uint32_t) * nr_columns
;
11640 htab
->section_pool
.v2
.sizes
=
11641 htab
->section_pool
.v2
.offsets
+ (sizeof (uint32_t)
11642 * nr_units
* nr_columns
);
11643 if ((htab
->section_pool
.v2
.sizes
+ (sizeof (uint32_t)
11644 * nr_units
* nr_columns
))
11647 error (_("Dwarf Error: DWP index section is corrupt (too small)"
11648 " [in module %s]"),
11652 else /* version == 5 */
11654 const gdb_byte
*ids_ptr
= htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
11655 int *ids
= htab
->section_pool
.v5
.section_ids
;
11656 size_t sizeof_ids
= sizeof (htab
->section_pool
.v5
.section_ids
);
11657 /* Reverse map for error checking. */
11658 int ids_seen
[DW_SECT_MAX_V5
+ 1];
11660 if (nr_columns
< 2)
11662 error (_("Dwarf Error: bad DWP hash table, too few columns"
11663 " in section table [in module %s]"),
11666 if (nr_columns
> MAX_NR_V5_DWO_SECTIONS
)
11668 error (_("Dwarf Error: bad DWP hash table, too many columns"
11669 " in section table [in module %s]"),
11672 memset (ids
, 255, sizeof_ids
);
11673 memset (ids_seen
, 255, sizeof (ids_seen
));
11674 for (int i
= 0; i
< nr_columns
; ++i
)
11676 int id
= read_4_bytes (dbfd
, ids_ptr
+ i
* sizeof (uint32_t));
11678 if (id
< DW_SECT_MIN
|| id
> DW_SECT_MAX_V5
)
11680 error (_("Dwarf Error: bad DWP hash table, bad section id %d"
11681 " in section table [in module %s]"),
11682 id
, dwp_file
->name
);
11684 if (ids_seen
[id
] != -1)
11686 error (_("Dwarf Error: bad DWP hash table, duplicate section"
11687 " id %d in section table [in module %s]"),
11688 id
, dwp_file
->name
);
11693 /* Must have seen an info section. */
11694 if (ids_seen
[DW_SECT_INFO_V5
] == -1)
11696 error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
11697 " DWO info/types section [in module %s]"),
11700 /* Must have an abbrev section. */
11701 if (ids_seen
[DW_SECT_ABBREV_V5
] == -1)
11703 error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
11704 " section [in module %s]"),
11707 htab
->section_pool
.v5
.offsets
= ids_ptr
+ sizeof (uint32_t) * nr_columns
;
11708 htab
->section_pool
.v5
.sizes
11709 = htab
->section_pool
.v5
.offsets
+ (sizeof (uint32_t)
11710 * nr_units
* nr_columns
);
11711 if ((htab
->section_pool
.v5
.sizes
+ (sizeof (uint32_t)
11712 * nr_units
* nr_columns
))
11715 error (_("Dwarf Error: DWP index section is corrupt (too small)"
11716 " [in module %s]"),
11724 /* Update SECTIONS with the data from SECTP.
11726 This function is like the other "locate" section routines, but in
11727 this context the sections to read comes from the DWP V1 hash table,
11728 not the full ELF section table.
11730 The result is non-zero for success, or zero if an error was found. */
11733 locate_v1_virtual_dwo_sections (asection
*sectp
,
11734 struct virtual_v1_dwo_sections
*sections
)
11736 const struct dwop_section_names
*names
= &dwop_section_names
;
11738 if (names
->abbrev_dwo
.matches (sectp
->name
))
11740 /* There can be only one. */
11741 if (sections
->abbrev
.s
.section
!= NULL
)
11743 sections
->abbrev
.s
.section
= sectp
;
11744 sections
->abbrev
.size
= bfd_section_size (sectp
);
11746 else if (names
->info_dwo
.matches (sectp
->name
)
11747 || names
->types_dwo
.matches (sectp
->name
))
11749 /* There can be only one. */
11750 if (sections
->info_or_types
.s
.section
!= NULL
)
11752 sections
->info_or_types
.s
.section
= sectp
;
11753 sections
->info_or_types
.size
= bfd_section_size (sectp
);
11755 else if (names
->line_dwo
.matches (sectp
->name
))
11757 /* There can be only one. */
11758 if (sections
->line
.s
.section
!= NULL
)
11760 sections
->line
.s
.section
= sectp
;
11761 sections
->line
.size
= bfd_section_size (sectp
);
11763 else if (names
->loc_dwo
.matches (sectp
->name
))
11765 /* There can be only one. */
11766 if (sections
->loc
.s
.section
!= NULL
)
11768 sections
->loc
.s
.section
= sectp
;
11769 sections
->loc
.size
= bfd_section_size (sectp
);
11771 else if (names
->macinfo_dwo
.matches (sectp
->name
))
11773 /* There can be only one. */
11774 if (sections
->macinfo
.s
.section
!= NULL
)
11776 sections
->macinfo
.s
.section
= sectp
;
11777 sections
->macinfo
.size
= bfd_section_size (sectp
);
11779 else if (names
->macro_dwo
.matches (sectp
->name
))
11781 /* There can be only one. */
11782 if (sections
->macro
.s
.section
!= NULL
)
11784 sections
->macro
.s
.section
= sectp
;
11785 sections
->macro
.size
= bfd_section_size (sectp
);
11787 else if (names
->str_offsets_dwo
.matches (sectp
->name
))
11789 /* There can be only one. */
11790 if (sections
->str_offsets
.s
.section
!= NULL
)
11792 sections
->str_offsets
.s
.section
= sectp
;
11793 sections
->str_offsets
.size
= bfd_section_size (sectp
);
11797 /* No other kind of section is valid. */
11804 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
11805 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
11806 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
11807 This is for DWP version 1 files. */
11809 static struct dwo_unit
*
11810 create_dwo_unit_in_dwp_v1 (dwarf2_per_objfile
*per_objfile
,
11811 struct dwp_file
*dwp_file
,
11812 uint32_t unit_index
,
11813 const char *comp_dir
,
11814 ULONGEST signature
, int is_debug_types
)
11816 const struct dwp_hash_table
*dwp_htab
=
11817 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
11818 bfd
*dbfd
= dwp_file
->dbfd
.get ();
11819 const char *kind
= is_debug_types
? "TU" : "CU";
11820 struct dwo_file
*dwo_file
;
11821 struct dwo_unit
*dwo_unit
;
11822 struct virtual_v1_dwo_sections sections
;
11823 void **dwo_file_slot
;
11826 gdb_assert (dwp_file
->version
== 1);
11828 dwarf_read_debug_printf ("Reading %s %s/%s in DWP V1 file: %s",
11829 kind
, pulongest (unit_index
), hex_string (signature
),
11832 /* Fetch the sections of this DWO unit.
11833 Put a limit on the number of sections we look for so that bad data
11834 doesn't cause us to loop forever. */
11836 #define MAX_NR_V1_DWO_SECTIONS \
11837 (1 /* .debug_info or .debug_types */ \
11838 + 1 /* .debug_abbrev */ \
11839 + 1 /* .debug_line */ \
11840 + 1 /* .debug_loc */ \
11841 + 1 /* .debug_str_offsets */ \
11842 + 1 /* .debug_macro or .debug_macinfo */ \
11843 + 1 /* trailing zero */)
11845 memset (§ions
, 0, sizeof (sections
));
11847 for (i
= 0; i
< MAX_NR_V1_DWO_SECTIONS
; ++i
)
11850 uint32_t section_nr
=
11851 read_4_bytes (dbfd
,
11852 dwp_htab
->section_pool
.v1
.indices
11853 + (unit_index
+ i
) * sizeof (uint32_t));
11855 if (section_nr
== 0)
11857 if (section_nr
>= dwp_file
->num_sections
)
11859 error (_("Dwarf Error: bad DWP hash table, section number too large"
11860 " [in module %s]"),
11864 sectp
= dwp_file
->elf_sections
[section_nr
];
11865 if (! locate_v1_virtual_dwo_sections (sectp
, §ions
))
11867 error (_("Dwarf Error: bad DWP hash table, invalid section found"
11868 " [in module %s]"),
11874 || sections
.info_or_types
.empty ()
11875 || sections
.abbrev
.empty ())
11877 error (_("Dwarf Error: bad DWP hash table, missing DWO sections"
11878 " [in module %s]"),
11881 if (i
== MAX_NR_V1_DWO_SECTIONS
)
11883 error (_("Dwarf Error: bad DWP hash table, too many DWO sections"
11884 " [in module %s]"),
11888 /* It's easier for the rest of the code if we fake a struct dwo_file and
11889 have dwo_unit "live" in that. At least for now.
11891 The DWP file can be made up of a random collection of CUs and TUs.
11892 However, for each CU + set of TUs that came from the same original DWO
11893 file, we can combine them back into a virtual DWO file to save space
11894 (fewer struct dwo_file objects to allocate). Remember that for really
11895 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
11897 std::string virtual_dwo_name
=
11898 string_printf ("virtual-dwo/%d-%d-%d-%d",
11899 sections
.abbrev
.get_id (),
11900 sections
.line
.get_id (),
11901 sections
.loc
.get_id (),
11902 sections
.str_offsets
.get_id ());
11903 /* Can we use an existing virtual DWO file? */
11904 dwo_file_slot
= lookup_dwo_file_slot (per_objfile
, virtual_dwo_name
.c_str (),
11906 /* Create one if necessary. */
11907 if (*dwo_file_slot
== NULL
)
11909 dwarf_read_debug_printf ("Creating virtual DWO: %s",
11910 virtual_dwo_name
.c_str ());
11912 dwo_file
= new struct dwo_file
;
11913 dwo_file
->dwo_name
= per_objfile
->objfile
->intern (virtual_dwo_name
);
11914 dwo_file
->comp_dir
= comp_dir
;
11915 dwo_file
->sections
.abbrev
= sections
.abbrev
;
11916 dwo_file
->sections
.line
= sections
.line
;
11917 dwo_file
->sections
.loc
= sections
.loc
;
11918 dwo_file
->sections
.macinfo
= sections
.macinfo
;
11919 dwo_file
->sections
.macro
= sections
.macro
;
11920 dwo_file
->sections
.str_offsets
= sections
.str_offsets
;
11921 /* The "str" section is global to the entire DWP file. */
11922 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
11923 /* The info or types section is assigned below to dwo_unit,
11924 there's no need to record it in dwo_file.
11925 Also, we can't simply record type sections in dwo_file because
11926 we record a pointer into the vector in dwo_unit. As we collect more
11927 types we'll grow the vector and eventually have to reallocate space
11928 for it, invalidating all copies of pointers into the previous
11930 *dwo_file_slot
= dwo_file
;
11934 dwarf_read_debug_printf ("Using existing virtual DWO: %s",
11935 virtual_dwo_name
.c_str ());
11937 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
11940 dwo_unit
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, struct dwo_unit
);
11941 dwo_unit
->dwo_file
= dwo_file
;
11942 dwo_unit
->signature
= signature
;
11943 dwo_unit
->section
=
11944 XOBNEW (&per_objfile
->per_bfd
->obstack
, struct dwarf2_section_info
);
11945 *dwo_unit
->section
= sections
.info_or_types
;
11946 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
11951 /* Subroutine of create_dwo_unit_in_dwp_v2 and create_dwo_unit_in_dwp_v5 to
11952 simplify them. Given a pointer to the containing section SECTION, and
11953 OFFSET,SIZE of the piece within that section used by a TU/CU, return a
11954 virtual section of just that piece. */
11956 static struct dwarf2_section_info
11957 create_dwp_v2_or_v5_section (dwarf2_per_objfile
*per_objfile
,
11958 struct dwarf2_section_info
*section
,
11959 bfd_size_type offset
, bfd_size_type size
)
11961 struct dwarf2_section_info result
;
11964 gdb_assert (section
!= NULL
);
11965 gdb_assert (!section
->is_virtual
);
11967 memset (&result
, 0, sizeof (result
));
11968 result
.s
.containing_section
= section
;
11969 result
.is_virtual
= true;
11974 sectp
= section
->get_bfd_section ();
11976 /* Flag an error if the piece denoted by OFFSET,SIZE is outside the
11977 bounds of the real section. This is a pretty-rare event, so just
11978 flag an error (easier) instead of a warning and trying to cope. */
11980 || offset
+ size
> bfd_section_size (sectp
))
11982 error (_("Dwarf Error: Bad DWP V2 or V5 section info, doesn't fit"
11983 " in section %s [in module %s]"),
11984 sectp
? bfd_section_name (sectp
) : "<unknown>",
11985 objfile_name (per_objfile
->objfile
));
11988 result
.virtual_offset
= offset
;
11989 result
.size
= size
;
11993 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
11994 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
11995 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
11996 This is for DWP version 2 files. */
11998 static struct dwo_unit
*
11999 create_dwo_unit_in_dwp_v2 (dwarf2_per_objfile
*per_objfile
,
12000 struct dwp_file
*dwp_file
,
12001 uint32_t unit_index
,
12002 const char *comp_dir
,
12003 ULONGEST signature
, int is_debug_types
)
12005 const struct dwp_hash_table
*dwp_htab
=
12006 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12007 bfd
*dbfd
= dwp_file
->dbfd
.get ();
12008 const char *kind
= is_debug_types
? "TU" : "CU";
12009 struct dwo_file
*dwo_file
;
12010 struct dwo_unit
*dwo_unit
;
12011 struct virtual_v2_or_v5_dwo_sections sections
;
12012 void **dwo_file_slot
;
12015 gdb_assert (dwp_file
->version
== 2);
12017 dwarf_read_debug_printf ("Reading %s %s/%s in DWP V2 file: %s",
12018 kind
, pulongest (unit_index
), hex_string (signature
),
12021 /* Fetch the section offsets of this DWO unit. */
12023 memset (§ions
, 0, sizeof (sections
));
12025 for (i
= 0; i
< dwp_htab
->nr_columns
; ++i
)
12027 uint32_t offset
= read_4_bytes (dbfd
,
12028 dwp_htab
->section_pool
.v2
.offsets
12029 + (((unit_index
- 1) * dwp_htab
->nr_columns
12031 * sizeof (uint32_t)));
12032 uint32_t size
= read_4_bytes (dbfd
,
12033 dwp_htab
->section_pool
.v2
.sizes
12034 + (((unit_index
- 1) * dwp_htab
->nr_columns
12036 * sizeof (uint32_t)));
12038 switch (dwp_htab
->section_pool
.v2
.section_ids
[i
])
12041 case DW_SECT_TYPES
:
12042 sections
.info_or_types_offset
= offset
;
12043 sections
.info_or_types_size
= size
;
12045 case DW_SECT_ABBREV
:
12046 sections
.abbrev_offset
= offset
;
12047 sections
.abbrev_size
= size
;
12050 sections
.line_offset
= offset
;
12051 sections
.line_size
= size
;
12054 sections
.loc_offset
= offset
;
12055 sections
.loc_size
= size
;
12057 case DW_SECT_STR_OFFSETS
:
12058 sections
.str_offsets_offset
= offset
;
12059 sections
.str_offsets_size
= size
;
12061 case DW_SECT_MACINFO
:
12062 sections
.macinfo_offset
= offset
;
12063 sections
.macinfo_size
= size
;
12065 case DW_SECT_MACRO
:
12066 sections
.macro_offset
= offset
;
12067 sections
.macro_size
= size
;
12072 /* It's easier for the rest of the code if we fake a struct dwo_file and
12073 have dwo_unit "live" in that. At least for now.
12075 The DWP file can be made up of a random collection of CUs and TUs.
12076 However, for each CU + set of TUs that came from the same original DWO
12077 file, we can combine them back into a virtual DWO file to save space
12078 (fewer struct dwo_file objects to allocate). Remember that for really
12079 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
12081 std::string virtual_dwo_name
=
12082 string_printf ("virtual-dwo/%ld-%ld-%ld-%ld",
12083 (long) (sections
.abbrev_size
? sections
.abbrev_offset
: 0),
12084 (long) (sections
.line_size
? sections
.line_offset
: 0),
12085 (long) (sections
.loc_size
? sections
.loc_offset
: 0),
12086 (long) (sections
.str_offsets_size
12087 ? sections
.str_offsets_offset
: 0));
12088 /* Can we use an existing virtual DWO file? */
12089 dwo_file_slot
= lookup_dwo_file_slot (per_objfile
, virtual_dwo_name
.c_str (),
12091 /* Create one if necessary. */
12092 if (*dwo_file_slot
== NULL
)
12094 dwarf_read_debug_printf ("Creating virtual DWO: %s",
12095 virtual_dwo_name
.c_str ());
12097 dwo_file
= new struct dwo_file
;
12098 dwo_file
->dwo_name
= per_objfile
->objfile
->intern (virtual_dwo_name
);
12099 dwo_file
->comp_dir
= comp_dir
;
12100 dwo_file
->sections
.abbrev
=
12101 create_dwp_v2_or_v5_section (per_objfile
, &dwp_file
->sections
.abbrev
,
12102 sections
.abbrev_offset
,
12103 sections
.abbrev_size
);
12104 dwo_file
->sections
.line
=
12105 create_dwp_v2_or_v5_section (per_objfile
, &dwp_file
->sections
.line
,
12106 sections
.line_offset
,
12107 sections
.line_size
);
12108 dwo_file
->sections
.loc
=
12109 create_dwp_v2_or_v5_section (per_objfile
, &dwp_file
->sections
.loc
,
12110 sections
.loc_offset
, sections
.loc_size
);
12111 dwo_file
->sections
.macinfo
=
12112 create_dwp_v2_or_v5_section (per_objfile
, &dwp_file
->sections
.macinfo
,
12113 sections
.macinfo_offset
,
12114 sections
.macinfo_size
);
12115 dwo_file
->sections
.macro
=
12116 create_dwp_v2_or_v5_section (per_objfile
, &dwp_file
->sections
.macro
,
12117 sections
.macro_offset
,
12118 sections
.macro_size
);
12119 dwo_file
->sections
.str_offsets
=
12120 create_dwp_v2_or_v5_section (per_objfile
,
12121 &dwp_file
->sections
.str_offsets
,
12122 sections
.str_offsets_offset
,
12123 sections
.str_offsets_size
);
12124 /* The "str" section is global to the entire DWP file. */
12125 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
12126 /* The info or types section is assigned below to dwo_unit,
12127 there's no need to record it in dwo_file.
12128 Also, we can't simply record type sections in dwo_file because
12129 we record a pointer into the vector in dwo_unit. As we collect more
12130 types we'll grow the vector and eventually have to reallocate space
12131 for it, invalidating all copies of pointers into the previous
12133 *dwo_file_slot
= dwo_file
;
12137 dwarf_read_debug_printf ("Using existing virtual DWO: %s",
12138 virtual_dwo_name
.c_str ());
12140 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
12143 dwo_unit
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, struct dwo_unit
);
12144 dwo_unit
->dwo_file
= dwo_file
;
12145 dwo_unit
->signature
= signature
;
12146 dwo_unit
->section
=
12147 XOBNEW (&per_objfile
->per_bfd
->obstack
, struct dwarf2_section_info
);
12148 *dwo_unit
->section
= create_dwp_v2_or_v5_section
12151 ? &dwp_file
->sections
.types
12152 : &dwp_file
->sections
.info
,
12153 sections
.info_or_types_offset
,
12154 sections
.info_or_types_size
);
12155 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12160 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12161 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12162 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12163 This is for DWP version 5 files. */
12165 static struct dwo_unit
*
12166 create_dwo_unit_in_dwp_v5 (dwarf2_per_objfile
*per_objfile
,
12167 struct dwp_file
*dwp_file
,
12168 uint32_t unit_index
,
12169 const char *comp_dir
,
12170 ULONGEST signature
, int is_debug_types
)
12172 const struct dwp_hash_table
*dwp_htab
12173 = is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12174 bfd
*dbfd
= dwp_file
->dbfd
.get ();
12175 const char *kind
= is_debug_types
? "TU" : "CU";
12176 struct dwo_file
*dwo_file
;
12177 struct dwo_unit
*dwo_unit
;
12178 struct virtual_v2_or_v5_dwo_sections sections
{};
12179 void **dwo_file_slot
;
12181 gdb_assert (dwp_file
->version
== 5);
12183 dwarf_read_debug_printf ("Reading %s %s/%s in DWP V5 file: %s",
12184 kind
, pulongest (unit_index
), hex_string (signature
),
12187 /* Fetch the section offsets of this DWO unit. */
12189 /* memset (§ions, 0, sizeof (sections)); */
12191 for (int i
= 0; i
< dwp_htab
->nr_columns
; ++i
)
12193 uint32_t offset
= read_4_bytes (dbfd
,
12194 dwp_htab
->section_pool
.v5
.offsets
12195 + (((unit_index
- 1)
12196 * dwp_htab
->nr_columns
12198 * sizeof (uint32_t)));
12199 uint32_t size
= read_4_bytes (dbfd
,
12200 dwp_htab
->section_pool
.v5
.sizes
12201 + (((unit_index
- 1) * dwp_htab
->nr_columns
12203 * sizeof (uint32_t)));
12205 switch (dwp_htab
->section_pool
.v5
.section_ids
[i
])
12207 case DW_SECT_ABBREV_V5
:
12208 sections
.abbrev_offset
= offset
;
12209 sections
.abbrev_size
= size
;
12211 case DW_SECT_INFO_V5
:
12212 sections
.info_or_types_offset
= offset
;
12213 sections
.info_or_types_size
= size
;
12215 case DW_SECT_LINE_V5
:
12216 sections
.line_offset
= offset
;
12217 sections
.line_size
= size
;
12219 case DW_SECT_LOCLISTS_V5
:
12220 sections
.loclists_offset
= offset
;
12221 sections
.loclists_size
= size
;
12223 case DW_SECT_MACRO_V5
:
12224 sections
.macro_offset
= offset
;
12225 sections
.macro_size
= size
;
12227 case DW_SECT_RNGLISTS_V5
:
12228 sections
.rnglists_offset
= offset
;
12229 sections
.rnglists_size
= size
;
12231 case DW_SECT_STR_OFFSETS_V5
:
12232 sections
.str_offsets_offset
= offset
;
12233 sections
.str_offsets_size
= size
;
12235 case DW_SECT_RESERVED_V5
:
12241 /* It's easier for the rest of the code if we fake a struct dwo_file and
12242 have dwo_unit "live" in that. At least for now.
12244 The DWP file can be made up of a random collection of CUs and TUs.
12245 However, for each CU + set of TUs that came from the same original DWO
12246 file, we can combine them back into a virtual DWO file to save space
12247 (fewer struct dwo_file objects to allocate). Remember that for really
12248 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
12250 std::string virtual_dwo_name
=
12251 string_printf ("virtual-dwo/%ld-%ld-%ld-%ld-%ld-%ld",
12252 (long) (sections
.abbrev_size
? sections
.abbrev_offset
: 0),
12253 (long) (sections
.line_size
? sections
.line_offset
: 0),
12254 (long) (sections
.loclists_size
? sections
.loclists_offset
: 0),
12255 (long) (sections
.str_offsets_size
12256 ? sections
.str_offsets_offset
: 0),
12257 (long) (sections
.macro_size
? sections
.macro_offset
: 0),
12258 (long) (sections
.rnglists_size
? sections
.rnglists_offset
: 0));
12259 /* Can we use an existing virtual DWO file? */
12260 dwo_file_slot
= lookup_dwo_file_slot (per_objfile
,
12261 virtual_dwo_name
.c_str (),
12263 /* Create one if necessary. */
12264 if (*dwo_file_slot
== NULL
)
12266 dwarf_read_debug_printf ("Creating virtual DWO: %s",
12267 virtual_dwo_name
.c_str ());
12269 dwo_file
= new struct dwo_file
;
12270 dwo_file
->dwo_name
= per_objfile
->objfile
->intern (virtual_dwo_name
);
12271 dwo_file
->comp_dir
= comp_dir
;
12272 dwo_file
->sections
.abbrev
=
12273 create_dwp_v2_or_v5_section (per_objfile
,
12274 &dwp_file
->sections
.abbrev
,
12275 sections
.abbrev_offset
,
12276 sections
.abbrev_size
);
12277 dwo_file
->sections
.line
=
12278 create_dwp_v2_or_v5_section (per_objfile
,
12279 &dwp_file
->sections
.line
,
12280 sections
.line_offset
, sections
.line_size
);
12281 dwo_file
->sections
.macro
=
12282 create_dwp_v2_or_v5_section (per_objfile
,
12283 &dwp_file
->sections
.macro
,
12284 sections
.macro_offset
,
12285 sections
.macro_size
);
12286 dwo_file
->sections
.loclists
=
12287 create_dwp_v2_or_v5_section (per_objfile
,
12288 &dwp_file
->sections
.loclists
,
12289 sections
.loclists_offset
,
12290 sections
.loclists_size
);
12291 dwo_file
->sections
.rnglists
=
12292 create_dwp_v2_or_v5_section (per_objfile
,
12293 &dwp_file
->sections
.rnglists
,
12294 sections
.rnglists_offset
,
12295 sections
.rnglists_size
);
12296 dwo_file
->sections
.str_offsets
=
12297 create_dwp_v2_or_v5_section (per_objfile
,
12298 &dwp_file
->sections
.str_offsets
,
12299 sections
.str_offsets_offset
,
12300 sections
.str_offsets_size
);
12301 /* The "str" section is global to the entire DWP file. */
12302 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
12303 /* The info or types section is assigned below to dwo_unit,
12304 there's no need to record it in dwo_file.
12305 Also, we can't simply record type sections in dwo_file because
12306 we record a pointer into the vector in dwo_unit. As we collect more
12307 types we'll grow the vector and eventually have to reallocate space
12308 for it, invalidating all copies of pointers into the previous
12310 *dwo_file_slot
= dwo_file
;
12314 dwarf_read_debug_printf ("Using existing virtual DWO: %s",
12315 virtual_dwo_name
.c_str ());
12317 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
12320 dwo_unit
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, struct dwo_unit
);
12321 dwo_unit
->dwo_file
= dwo_file
;
12322 dwo_unit
->signature
= signature
;
12324 = XOBNEW (&per_objfile
->per_bfd
->obstack
, struct dwarf2_section_info
);
12325 *dwo_unit
->section
= create_dwp_v2_or_v5_section (per_objfile
,
12326 &dwp_file
->sections
.info
,
12327 sections
.info_or_types_offset
,
12328 sections
.info_or_types_size
);
12329 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12334 /* Lookup the DWO unit with SIGNATURE in DWP_FILE.
12335 Returns NULL if the signature isn't found. */
12337 static struct dwo_unit
*
12338 lookup_dwo_unit_in_dwp (dwarf2_per_objfile
*per_objfile
,
12339 struct dwp_file
*dwp_file
, const char *comp_dir
,
12340 ULONGEST signature
, int is_debug_types
)
12342 const struct dwp_hash_table
*dwp_htab
=
12343 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12344 bfd
*dbfd
= dwp_file
->dbfd
.get ();
12345 uint32_t mask
= dwp_htab
->nr_slots
- 1;
12346 uint32_t hash
= signature
& mask
;
12347 uint32_t hash2
= ((signature
>> 32) & mask
) | 1;
12350 struct dwo_unit find_dwo_cu
;
12352 memset (&find_dwo_cu
, 0, sizeof (find_dwo_cu
));
12353 find_dwo_cu
.signature
= signature
;
12354 slot
= htab_find_slot (is_debug_types
12355 ? dwp_file
->loaded_tus
.get ()
12356 : dwp_file
->loaded_cus
.get (),
12357 &find_dwo_cu
, INSERT
);
12360 return (struct dwo_unit
*) *slot
;
12362 /* Use a for loop so that we don't loop forever on bad debug info. */
12363 for (i
= 0; i
< dwp_htab
->nr_slots
; ++i
)
12365 ULONGEST signature_in_table
;
12367 signature_in_table
=
12368 read_8_bytes (dbfd
, dwp_htab
->hash_table
+ hash
* sizeof (uint64_t));
12369 if (signature_in_table
== signature
)
12371 uint32_t unit_index
=
12372 read_4_bytes (dbfd
,
12373 dwp_htab
->unit_table
+ hash
* sizeof (uint32_t));
12375 if (dwp_file
->version
== 1)
12377 *slot
= create_dwo_unit_in_dwp_v1 (per_objfile
, dwp_file
,
12378 unit_index
, comp_dir
,
12379 signature
, is_debug_types
);
12381 else if (dwp_file
->version
== 2)
12383 *slot
= create_dwo_unit_in_dwp_v2 (per_objfile
, dwp_file
,
12384 unit_index
, comp_dir
,
12385 signature
, is_debug_types
);
12387 else /* version == 5 */
12389 *slot
= create_dwo_unit_in_dwp_v5 (per_objfile
, dwp_file
,
12390 unit_index
, comp_dir
,
12391 signature
, is_debug_types
);
12393 return (struct dwo_unit
*) *slot
;
12395 if (signature_in_table
== 0)
12397 hash
= (hash
+ hash2
) & mask
;
12400 error (_("Dwarf Error: bad DWP hash table, lookup didn't terminate"
12401 " [in module %s]"),
12405 /* Subroutine of open_dwo_file,open_dwp_file to simplify them.
12406 Open the file specified by FILE_NAME and hand it off to BFD for
12407 preliminary analysis. Return a newly initialized bfd *, which
12408 includes a canonicalized copy of FILE_NAME.
12409 If IS_DWP is TRUE, we're opening a DWP file, otherwise a DWO file.
12410 SEARCH_CWD is true if the current directory is to be searched.
12411 It will be searched before debug-file-directory.
12412 If successful, the file is added to the bfd include table of the
12413 objfile's bfd (see gdb_bfd_record_inclusion).
12414 If unable to find/open the file, return NULL.
12415 NOTE: This function is derived from symfile_bfd_open. */
12417 static gdb_bfd_ref_ptr
12418 try_open_dwop_file (dwarf2_per_objfile
*per_objfile
,
12419 const char *file_name
, int is_dwp
, int search_cwd
)
12422 /* Blech. OPF_TRY_CWD_FIRST also disables searching the path list if
12423 FILE_NAME contains a '/'. So we can't use it. Instead prepend "."
12424 to debug_file_directory. */
12425 const char *search_path
;
12426 static const char dirname_separator_string
[] = { DIRNAME_SEPARATOR
, '\0' };
12428 gdb::unique_xmalloc_ptr
<char> search_path_holder
;
12431 if (*debug_file_directory
!= '\0')
12433 search_path_holder
.reset (concat (".", dirname_separator_string
,
12434 debug_file_directory
,
12436 search_path
= search_path_holder
.get ();
12442 search_path
= debug_file_directory
;
12444 /* Add the path for the executable binary to the list of search paths. */
12445 std::string objfile_dir
= ldirname (objfile_name (per_objfile
->objfile
));
12446 search_path_holder
.reset (concat (objfile_dir
.c_str (),
12447 dirname_separator_string
,
12448 search_path
, nullptr));
12449 search_path
= search_path_holder
.get ();
12451 openp_flags flags
= OPF_RETURN_REALPATH
;
12453 flags
|= OPF_SEARCH_IN_PATH
;
12455 gdb::unique_xmalloc_ptr
<char> absolute_name
;
12456 desc
= openp (search_path
, flags
, file_name
,
12457 O_RDONLY
| O_BINARY
, &absolute_name
);
12461 gdb_bfd_ref_ptr
sym_bfd (gdb_bfd_open (absolute_name
.get (),
12463 if (sym_bfd
== NULL
)
12465 bfd_set_cacheable (sym_bfd
.get (), 1);
12467 if (!bfd_check_format (sym_bfd
.get (), bfd_object
))
12470 /* Success. Record the bfd as having been included by the objfile's bfd.
12471 This is important because things like demangled_names_hash lives in the
12472 objfile's per_bfd space and may have references to things like symbol
12473 names that live in the DWO/DWP file's per_bfd space. PR 16426. */
12474 gdb_bfd_record_inclusion (per_objfile
->objfile
->obfd
, sym_bfd
.get ());
12479 /* Try to open DWO file FILE_NAME.
12480 COMP_DIR is the DW_AT_comp_dir attribute.
12481 The result is the bfd handle of the file.
12482 If there is a problem finding or opening the file, return NULL.
12483 Upon success, the canonicalized path of the file is stored in the bfd,
12484 same as symfile_bfd_open. */
12486 static gdb_bfd_ref_ptr
12487 open_dwo_file (dwarf2_per_objfile
*per_objfile
,
12488 const char *file_name
, const char *comp_dir
)
12490 if (IS_ABSOLUTE_PATH (file_name
))
12491 return try_open_dwop_file (per_objfile
, file_name
,
12492 0 /*is_dwp*/, 0 /*search_cwd*/);
12494 /* Before trying the search path, try DWO_NAME in COMP_DIR. */
12496 if (comp_dir
!= NULL
)
12498 gdb::unique_xmalloc_ptr
<char> path_to_try
12499 (concat (comp_dir
, SLASH_STRING
, file_name
, (char *) NULL
));
12501 /* NOTE: If comp_dir is a relative path, this will also try the
12502 search path, which seems useful. */
12503 gdb_bfd_ref_ptr
abfd (try_open_dwop_file (per_objfile
, path_to_try
.get (),
12505 1 /*search_cwd*/));
12510 /* That didn't work, try debug-file-directory, which, despite its name,
12511 is a list of paths. */
12513 if (*debug_file_directory
== '\0')
12516 return try_open_dwop_file (per_objfile
, file_name
,
12517 0 /*is_dwp*/, 1 /*search_cwd*/);
12520 /* This function is mapped across the sections and remembers the offset and
12521 size of each of the DWO debugging sections we are interested in. */
12524 dwarf2_locate_dwo_sections (bfd
*abfd
, asection
*sectp
,
12525 dwo_sections
*dwo_sections
)
12527 const struct dwop_section_names
*names
= &dwop_section_names
;
12529 if (names
->abbrev_dwo
.matches (sectp
->name
))
12531 dwo_sections
->abbrev
.s
.section
= sectp
;
12532 dwo_sections
->abbrev
.size
= bfd_section_size (sectp
);
12534 else if (names
->info_dwo
.matches (sectp
->name
))
12536 dwo_sections
->info
.s
.section
= sectp
;
12537 dwo_sections
->info
.size
= bfd_section_size (sectp
);
12539 else if (names
->line_dwo
.matches (sectp
->name
))
12541 dwo_sections
->line
.s
.section
= sectp
;
12542 dwo_sections
->line
.size
= bfd_section_size (sectp
);
12544 else if (names
->loc_dwo
.matches (sectp
->name
))
12546 dwo_sections
->loc
.s
.section
= sectp
;
12547 dwo_sections
->loc
.size
= bfd_section_size (sectp
);
12549 else if (names
->loclists_dwo
.matches (sectp
->name
))
12551 dwo_sections
->loclists
.s
.section
= sectp
;
12552 dwo_sections
->loclists
.size
= bfd_section_size (sectp
);
12554 else if (names
->macinfo_dwo
.matches (sectp
->name
))
12556 dwo_sections
->macinfo
.s
.section
= sectp
;
12557 dwo_sections
->macinfo
.size
= bfd_section_size (sectp
);
12559 else if (names
->macro_dwo
.matches (sectp
->name
))
12561 dwo_sections
->macro
.s
.section
= sectp
;
12562 dwo_sections
->macro
.size
= bfd_section_size (sectp
);
12564 else if (names
->rnglists_dwo
.matches (sectp
->name
))
12566 dwo_sections
->rnglists
.s
.section
= sectp
;
12567 dwo_sections
->rnglists
.size
= bfd_section_size (sectp
);
12569 else if (names
->str_dwo
.matches (sectp
->name
))
12571 dwo_sections
->str
.s
.section
= sectp
;
12572 dwo_sections
->str
.size
= bfd_section_size (sectp
);
12574 else if (names
->str_offsets_dwo
.matches (sectp
->name
))
12576 dwo_sections
->str_offsets
.s
.section
= sectp
;
12577 dwo_sections
->str_offsets
.size
= bfd_section_size (sectp
);
12579 else if (names
->types_dwo
.matches (sectp
->name
))
12581 struct dwarf2_section_info type_section
;
12583 memset (&type_section
, 0, sizeof (type_section
));
12584 type_section
.s
.section
= sectp
;
12585 type_section
.size
= bfd_section_size (sectp
);
12586 dwo_sections
->types
.push_back (type_section
);
12590 /* Initialize the use of the DWO file specified by DWO_NAME and referenced
12591 by PER_CU. This is for the non-DWP case.
12592 The result is NULL if DWO_NAME can't be found. */
12594 static struct dwo_file
*
12595 open_and_init_dwo_file (dwarf2_cu
*cu
, const char *dwo_name
,
12596 const char *comp_dir
)
12598 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
12600 gdb_bfd_ref_ptr dbfd
= open_dwo_file (per_objfile
, dwo_name
, comp_dir
);
12603 dwarf_read_debug_printf ("DWO file not found: %s", dwo_name
);
12608 dwo_file_up
dwo_file (new struct dwo_file
);
12609 dwo_file
->dwo_name
= dwo_name
;
12610 dwo_file
->comp_dir
= comp_dir
;
12611 dwo_file
->dbfd
= std::move (dbfd
);
12613 for (asection
*sec
: gdb_bfd_sections (dwo_file
->dbfd
))
12614 dwarf2_locate_dwo_sections (dwo_file
->dbfd
.get (), sec
,
12615 &dwo_file
->sections
);
12617 create_cus_hash_table (per_objfile
, cu
, *dwo_file
, dwo_file
->sections
.info
,
12620 if (cu
->per_cu
->dwarf_version
< 5)
12622 create_debug_types_hash_table (per_objfile
, dwo_file
.get (),
12623 dwo_file
->sections
.types
, dwo_file
->tus
);
12627 create_debug_type_hash_table (per_objfile
, dwo_file
.get (),
12628 &dwo_file
->sections
.info
, dwo_file
->tus
,
12629 rcuh_kind::COMPILE
);
12632 dwarf_read_debug_printf ("DWO file found: %s", dwo_name
);
12634 return dwo_file
.release ();
12637 /* This function is mapped across the sections and remembers the offset and
12638 size of each of the DWP debugging sections common to version 1 and 2 that
12639 we are interested in. */
12642 dwarf2_locate_common_dwp_sections (bfd
*abfd
, asection
*sectp
,
12643 dwp_file
*dwp_file
)
12645 const struct dwop_section_names
*names
= &dwop_section_names
;
12646 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
12648 /* Record the ELF section number for later lookup: this is what the
12649 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
12650 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
12651 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
12653 /* Look for specific sections that we need. */
12654 if (names
->str_dwo
.matches (sectp
->name
))
12656 dwp_file
->sections
.str
.s
.section
= sectp
;
12657 dwp_file
->sections
.str
.size
= bfd_section_size (sectp
);
12659 else if (names
->cu_index
.matches (sectp
->name
))
12661 dwp_file
->sections
.cu_index
.s
.section
= sectp
;
12662 dwp_file
->sections
.cu_index
.size
= bfd_section_size (sectp
);
12664 else if (names
->tu_index
.matches (sectp
->name
))
12666 dwp_file
->sections
.tu_index
.s
.section
= sectp
;
12667 dwp_file
->sections
.tu_index
.size
= bfd_section_size (sectp
);
12671 /* This function is mapped across the sections and remembers the offset and
12672 size of each of the DWP version 2 debugging sections that we are interested
12673 in. This is split into a separate function because we don't know if we
12674 have version 1 or 2 or 5 until we parse the cu_index/tu_index sections. */
12677 dwarf2_locate_v2_dwp_sections (bfd
*abfd
, asection
*sectp
, void *dwp_file_ptr
)
12679 struct dwp_file
*dwp_file
= (struct dwp_file
*) dwp_file_ptr
;
12680 const struct dwop_section_names
*names
= &dwop_section_names
;
12681 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
12683 /* Record the ELF section number for later lookup: this is what the
12684 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
12685 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
12686 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
12688 /* Look for specific sections that we need. */
12689 if (names
->abbrev_dwo
.matches (sectp
->name
))
12691 dwp_file
->sections
.abbrev
.s
.section
= sectp
;
12692 dwp_file
->sections
.abbrev
.size
= bfd_section_size (sectp
);
12694 else if (names
->info_dwo
.matches (sectp
->name
))
12696 dwp_file
->sections
.info
.s
.section
= sectp
;
12697 dwp_file
->sections
.info
.size
= bfd_section_size (sectp
);
12699 else if (names
->line_dwo
.matches (sectp
->name
))
12701 dwp_file
->sections
.line
.s
.section
= sectp
;
12702 dwp_file
->sections
.line
.size
= bfd_section_size (sectp
);
12704 else if (names
->loc_dwo
.matches (sectp
->name
))
12706 dwp_file
->sections
.loc
.s
.section
= sectp
;
12707 dwp_file
->sections
.loc
.size
= bfd_section_size (sectp
);
12709 else if (names
->macinfo_dwo
.matches (sectp
->name
))
12711 dwp_file
->sections
.macinfo
.s
.section
= sectp
;
12712 dwp_file
->sections
.macinfo
.size
= bfd_section_size (sectp
);
12714 else if (names
->macro_dwo
.matches (sectp
->name
))
12716 dwp_file
->sections
.macro
.s
.section
= sectp
;
12717 dwp_file
->sections
.macro
.size
= bfd_section_size (sectp
);
12719 else if (names
->str_offsets_dwo
.matches (sectp
->name
))
12721 dwp_file
->sections
.str_offsets
.s
.section
= sectp
;
12722 dwp_file
->sections
.str_offsets
.size
= bfd_section_size (sectp
);
12724 else if (names
->types_dwo
.matches (sectp
->name
))
12726 dwp_file
->sections
.types
.s
.section
= sectp
;
12727 dwp_file
->sections
.types
.size
= bfd_section_size (sectp
);
12731 /* This function is mapped across the sections and remembers the offset and
12732 size of each of the DWP version 5 debugging sections that we are interested
12733 in. This is split into a separate function because we don't know if we
12734 have version 1 or 2 or 5 until we parse the cu_index/tu_index sections. */
12737 dwarf2_locate_v5_dwp_sections (bfd
*abfd
, asection
*sectp
, void *dwp_file_ptr
)
12739 struct dwp_file
*dwp_file
= (struct dwp_file
*) dwp_file_ptr
;
12740 const struct dwop_section_names
*names
= &dwop_section_names
;
12741 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
12743 /* Record the ELF section number for later lookup: this is what the
12744 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
12745 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
12746 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
12748 /* Look for specific sections that we need. */
12749 if (names
->abbrev_dwo
.matches (sectp
->name
))
12751 dwp_file
->sections
.abbrev
.s
.section
= sectp
;
12752 dwp_file
->sections
.abbrev
.size
= bfd_section_size (sectp
);
12754 else if (names
->info_dwo
.matches (sectp
->name
))
12756 dwp_file
->sections
.info
.s
.section
= sectp
;
12757 dwp_file
->sections
.info
.size
= bfd_section_size (sectp
);
12759 else if (names
->line_dwo
.matches (sectp
->name
))
12761 dwp_file
->sections
.line
.s
.section
= sectp
;
12762 dwp_file
->sections
.line
.size
= bfd_section_size (sectp
);
12764 else if (names
->loclists_dwo
.matches (sectp
->name
))
12766 dwp_file
->sections
.loclists
.s
.section
= sectp
;
12767 dwp_file
->sections
.loclists
.size
= bfd_section_size (sectp
);
12769 else if (names
->macro_dwo
.matches (sectp
->name
))
12771 dwp_file
->sections
.macro
.s
.section
= sectp
;
12772 dwp_file
->sections
.macro
.size
= bfd_section_size (sectp
);
12774 else if (names
->rnglists_dwo
.matches (sectp
->name
))
12776 dwp_file
->sections
.rnglists
.s
.section
= sectp
;
12777 dwp_file
->sections
.rnglists
.size
= bfd_section_size (sectp
);
12779 else if (names
->str_offsets_dwo
.matches (sectp
->name
))
12781 dwp_file
->sections
.str_offsets
.s
.section
= sectp
;
12782 dwp_file
->sections
.str_offsets
.size
= bfd_section_size (sectp
);
12786 /* Hash function for dwp_file loaded CUs/TUs. */
12789 hash_dwp_loaded_cutus (const void *item
)
12791 const struct dwo_unit
*dwo_unit
= (const struct dwo_unit
*) item
;
12793 /* This drops the top 32 bits of the signature, but is ok for a hash. */
12794 return dwo_unit
->signature
;
12797 /* Equality function for dwp_file loaded CUs/TUs. */
12800 eq_dwp_loaded_cutus (const void *a
, const void *b
)
12802 const struct dwo_unit
*dua
= (const struct dwo_unit
*) a
;
12803 const struct dwo_unit
*dub
= (const struct dwo_unit
*) b
;
12805 return dua
->signature
== dub
->signature
;
12808 /* Allocate a hash table for dwp_file loaded CUs/TUs. */
12811 allocate_dwp_loaded_cutus_table ()
12813 return htab_up (htab_create_alloc (3,
12814 hash_dwp_loaded_cutus
,
12815 eq_dwp_loaded_cutus
,
12816 NULL
, xcalloc
, xfree
));
12819 /* Try to open DWP file FILE_NAME.
12820 The result is the bfd handle of the file.
12821 If there is a problem finding or opening the file, return NULL.
12822 Upon success, the canonicalized path of the file is stored in the bfd,
12823 same as symfile_bfd_open. */
12825 static gdb_bfd_ref_ptr
12826 open_dwp_file (dwarf2_per_objfile
*per_objfile
, const char *file_name
)
12828 gdb_bfd_ref_ptr
abfd (try_open_dwop_file (per_objfile
, file_name
,
12830 1 /*search_cwd*/));
12834 /* Work around upstream bug 15652.
12835 http://sourceware.org/bugzilla/show_bug.cgi?id=15652
12836 [Whether that's a "bug" is debatable, but it is getting in our way.]
12837 We have no real idea where the dwp file is, because gdb's realpath-ing
12838 of the executable's path may have discarded the needed info.
12839 [IWBN if the dwp file name was recorded in the executable, akin to
12840 .gnu_debuglink, but that doesn't exist yet.]
12841 Strip the directory from FILE_NAME and search again. */
12842 if (*debug_file_directory
!= '\0')
12844 /* Don't implicitly search the current directory here.
12845 If the user wants to search "." to handle this case,
12846 it must be added to debug-file-directory. */
12847 return try_open_dwop_file (per_objfile
, lbasename (file_name
),
12855 /* Initialize the use of the DWP file for the current objfile.
12856 By convention the name of the DWP file is ${objfile}.dwp.
12857 The result is NULL if it can't be found. */
12859 static std::unique_ptr
<struct dwp_file
>
12860 open_and_init_dwp_file (dwarf2_per_objfile
*per_objfile
)
12862 struct objfile
*objfile
= per_objfile
->objfile
;
12864 /* Try to find first .dwp for the binary file before any symbolic links
12867 /* If the objfile is a debug file, find the name of the real binary
12868 file and get the name of dwp file from there. */
12869 std::string dwp_name
;
12870 if (objfile
->separate_debug_objfile_backlink
!= NULL
)
12872 struct objfile
*backlink
= objfile
->separate_debug_objfile_backlink
;
12873 const char *backlink_basename
= lbasename (backlink
->original_name
);
12875 dwp_name
= ldirname (objfile
->original_name
) + SLASH_STRING
+ backlink_basename
;
12878 dwp_name
= objfile
->original_name
;
12880 dwp_name
+= ".dwp";
12882 gdb_bfd_ref_ptr
dbfd (open_dwp_file (per_objfile
, dwp_name
.c_str ()));
12884 && strcmp (objfile
->original_name
, objfile_name (objfile
)) != 0)
12886 /* Try to find .dwp for the binary file after gdb_realpath resolving. */
12887 dwp_name
= objfile_name (objfile
);
12888 dwp_name
+= ".dwp";
12889 dbfd
= open_dwp_file (per_objfile
, dwp_name
.c_str ());
12894 dwarf_read_debug_printf ("DWP file not found: %s", dwp_name
.c_str ());
12896 return std::unique_ptr
<dwp_file
> ();
12899 const char *name
= bfd_get_filename (dbfd
.get ());
12900 std::unique_ptr
<struct dwp_file
> dwp_file
12901 (new struct dwp_file (name
, std::move (dbfd
)));
12903 dwp_file
->num_sections
= elf_numsections (dwp_file
->dbfd
);
12904 dwp_file
->elf_sections
=
12905 OBSTACK_CALLOC (&per_objfile
->per_bfd
->obstack
,
12906 dwp_file
->num_sections
, asection
*);
12908 for (asection
*sec
: gdb_bfd_sections (dwp_file
->dbfd
))
12909 dwarf2_locate_common_dwp_sections (dwp_file
->dbfd
.get (), sec
,
12912 dwp_file
->cus
= create_dwp_hash_table (per_objfile
, dwp_file
.get (), 0);
12914 dwp_file
->tus
= create_dwp_hash_table (per_objfile
, dwp_file
.get (), 1);
12916 /* The DWP file version is stored in the hash table. Oh well. */
12917 if (dwp_file
->cus
&& dwp_file
->tus
12918 && dwp_file
->cus
->version
!= dwp_file
->tus
->version
)
12920 /* Technically speaking, we should try to limp along, but this is
12921 pretty bizarre. We use pulongest here because that's the established
12922 portability solution (e.g, we cannot use %u for uint32_t). */
12923 error (_("Dwarf Error: DWP file CU version %s doesn't match"
12924 " TU version %s [in DWP file %s]"),
12925 pulongest (dwp_file
->cus
->version
),
12926 pulongest (dwp_file
->tus
->version
), dwp_name
.c_str ());
12930 dwp_file
->version
= dwp_file
->cus
->version
;
12931 else if (dwp_file
->tus
)
12932 dwp_file
->version
= dwp_file
->tus
->version
;
12934 dwp_file
->version
= 2;
12936 for (asection
*sec
: gdb_bfd_sections (dwp_file
->dbfd
))
12938 if (dwp_file
->version
== 2)
12939 dwarf2_locate_v2_dwp_sections (dwp_file
->dbfd
.get (), sec
,
12942 dwarf2_locate_v5_dwp_sections (dwp_file
->dbfd
.get (), sec
,
12946 dwp_file
->loaded_cus
= allocate_dwp_loaded_cutus_table ();
12947 dwp_file
->loaded_tus
= allocate_dwp_loaded_cutus_table ();
12949 dwarf_read_debug_printf ("DWP file found: %s", dwp_file
->name
);
12950 dwarf_read_debug_printf (" %s CUs, %s TUs",
12951 pulongest (dwp_file
->cus
? dwp_file
->cus
->nr_units
: 0),
12952 pulongest (dwp_file
->tus
? dwp_file
->tus
->nr_units
: 0));
12957 /* Wrapper around open_and_init_dwp_file, only open it once. */
12959 static struct dwp_file
*
12960 get_dwp_file (dwarf2_per_objfile
*per_objfile
)
12962 if (!per_objfile
->per_bfd
->dwp_checked
)
12964 per_objfile
->per_bfd
->dwp_file
= open_and_init_dwp_file (per_objfile
);
12965 per_objfile
->per_bfd
->dwp_checked
= 1;
12967 return per_objfile
->per_bfd
->dwp_file
.get ();
12970 /* Subroutine of lookup_dwo_comp_unit, lookup_dwo_type_unit.
12971 Look up the CU/TU with signature SIGNATURE, either in DWO file DWO_NAME
12972 or in the DWP file for the objfile, referenced by THIS_UNIT.
12973 If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
12974 IS_DEBUG_TYPES is non-zero if reading a TU, otherwise read a CU.
12976 This is called, for example, when wanting to read a variable with a
12977 complex location. Therefore we don't want to do file i/o for every call.
12978 Therefore we don't want to look for a DWO file on every call.
12979 Therefore we first see if we've already seen SIGNATURE in a DWP file,
12980 then we check if we've already seen DWO_NAME, and only THEN do we check
12983 The result is a pointer to the dwo_unit object or NULL if we didn't find it
12984 (dwo_id mismatch or couldn't find the DWO/DWP file). */
12986 static struct dwo_unit
*
12987 lookup_dwo_cutu (dwarf2_cu
*cu
, const char *dwo_name
, const char *comp_dir
,
12988 ULONGEST signature
, int is_debug_types
)
12990 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
12991 struct objfile
*objfile
= per_objfile
->objfile
;
12992 const char *kind
= is_debug_types
? "TU" : "CU";
12993 void **dwo_file_slot
;
12994 struct dwo_file
*dwo_file
;
12995 struct dwp_file
*dwp_file
;
12997 /* First see if there's a DWP file.
12998 If we have a DWP file but didn't find the DWO inside it, don't
12999 look for the original DWO file. It makes gdb behave differently
13000 depending on whether one is debugging in the build tree. */
13002 dwp_file
= get_dwp_file (per_objfile
);
13003 if (dwp_file
!= NULL
)
13005 const struct dwp_hash_table
*dwp_htab
=
13006 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
13008 if (dwp_htab
!= NULL
)
13010 struct dwo_unit
*dwo_cutu
=
13011 lookup_dwo_unit_in_dwp (per_objfile
, dwp_file
, comp_dir
, signature
,
13014 if (dwo_cutu
!= NULL
)
13016 dwarf_read_debug_printf ("Virtual DWO %s %s found: @%s",
13017 kind
, hex_string (signature
),
13018 host_address_to_string (dwo_cutu
));
13026 /* No DWP file, look for the DWO file. */
13028 dwo_file_slot
= lookup_dwo_file_slot (per_objfile
, dwo_name
, comp_dir
);
13029 if (*dwo_file_slot
== NULL
)
13031 /* Read in the file and build a table of the CUs/TUs it contains. */
13032 *dwo_file_slot
= open_and_init_dwo_file (cu
, dwo_name
, comp_dir
);
13034 /* NOTE: This will be NULL if unable to open the file. */
13035 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
13037 if (dwo_file
!= NULL
)
13039 struct dwo_unit
*dwo_cutu
= NULL
;
13041 if (is_debug_types
&& dwo_file
->tus
)
13043 struct dwo_unit find_dwo_cutu
;
13045 memset (&find_dwo_cutu
, 0, sizeof (find_dwo_cutu
));
13046 find_dwo_cutu
.signature
= signature
;
13048 = (struct dwo_unit
*) htab_find (dwo_file
->tus
.get (),
13051 else if (!is_debug_types
&& dwo_file
->cus
)
13053 struct dwo_unit find_dwo_cutu
;
13055 memset (&find_dwo_cutu
, 0, sizeof (find_dwo_cutu
));
13056 find_dwo_cutu
.signature
= signature
;
13057 dwo_cutu
= (struct dwo_unit
*)htab_find (dwo_file
->cus
.get (),
13061 if (dwo_cutu
!= NULL
)
13063 dwarf_read_debug_printf ("DWO %s %s(%s) found: @%s",
13064 kind
, dwo_name
, hex_string (signature
),
13065 host_address_to_string (dwo_cutu
));
13072 /* We didn't find it. This could mean a dwo_id mismatch, or
13073 someone deleted the DWO/DWP file, or the search path isn't set up
13074 correctly to find the file. */
13076 dwarf_read_debug_printf ("DWO %s %s(%s) not found",
13077 kind
, dwo_name
, hex_string (signature
));
13079 /* This is a warning and not a complaint because it can be caused by
13080 pilot error (e.g., user accidentally deleting the DWO). */
13082 /* Print the name of the DWP file if we looked there, helps the user
13083 better diagnose the problem. */
13084 std::string dwp_text
;
13086 if (dwp_file
!= NULL
)
13087 dwp_text
= string_printf (" [in DWP file %s]",
13088 lbasename (dwp_file
->name
));
13090 warning (_("Could not find DWO %s %s(%s)%s referenced by %s at offset %s"
13091 " [in module %s]"),
13092 kind
, dwo_name
, hex_string (signature
), dwp_text
.c_str (), kind
,
13093 sect_offset_str (cu
->per_cu
->sect_off
), objfile_name (objfile
));
13098 /* Lookup the DWO CU DWO_NAME/SIGNATURE referenced from THIS_CU.
13099 See lookup_dwo_cutu_unit for details. */
13101 static struct dwo_unit
*
13102 lookup_dwo_comp_unit (dwarf2_cu
*cu
, const char *dwo_name
, const char *comp_dir
,
13103 ULONGEST signature
)
13105 gdb_assert (!cu
->per_cu
->is_debug_types
);
13107 return lookup_dwo_cutu (cu
, dwo_name
, comp_dir
, signature
, 0);
13110 /* Lookup the DWO TU DWO_NAME/SIGNATURE referenced from THIS_TU.
13111 See lookup_dwo_cutu_unit for details. */
13113 static struct dwo_unit
*
13114 lookup_dwo_type_unit (dwarf2_cu
*cu
, const char *dwo_name
, const char *comp_dir
)
13116 gdb_assert (cu
->per_cu
->is_debug_types
);
13118 signatured_type
*sig_type
= (signatured_type
*) cu
->per_cu
;
13120 return lookup_dwo_cutu (cu
, dwo_name
, comp_dir
, sig_type
->signature
, 1);
13123 /* Traversal function for queue_and_load_all_dwo_tus. */
13126 queue_and_load_dwo_tu (void **slot
, void *info
)
13128 struct dwo_unit
*dwo_unit
= (struct dwo_unit
*) *slot
;
13129 dwarf2_cu
*cu
= (dwarf2_cu
*) info
;
13130 ULONGEST signature
= dwo_unit
->signature
;
13131 signatured_type
*sig_type
= lookup_dwo_signatured_type (cu
, signature
);
13133 if (sig_type
!= NULL
)
13135 struct dwarf2_per_cu_data
*sig_cu
= &sig_type
->per_cu
;
13137 /* We pass NULL for DEPENDENT_CU because we don't yet know if there's
13138 a real dependency of PER_CU on SIG_TYPE. That is detected later
13139 while processing PER_CU. */
13140 if (maybe_queue_comp_unit (NULL
, sig_cu
, cu
->per_objfile
, cu
->language
))
13141 load_full_type_unit (sig_cu
, cu
->per_objfile
);
13142 cu
->per_cu
->imported_symtabs_push (sig_cu
);
13148 /* Queue all TUs contained in the DWO of CU to be read in.
13149 The DWO may have the only definition of the type, though it may not be
13150 referenced anywhere in PER_CU. Thus we have to load *all* its TUs.
13151 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
13154 queue_and_load_all_dwo_tus (dwarf2_cu
*cu
)
13156 struct dwo_unit
*dwo_unit
;
13157 struct dwo_file
*dwo_file
;
13159 gdb_assert (cu
!= nullptr);
13160 gdb_assert (!cu
->per_cu
->is_debug_types
);
13161 gdb_assert (get_dwp_file (cu
->per_objfile
) == nullptr);
13163 dwo_unit
= cu
->dwo_unit
;
13164 gdb_assert (dwo_unit
!= NULL
);
13166 dwo_file
= dwo_unit
->dwo_file
;
13167 if (dwo_file
->tus
!= NULL
)
13168 htab_traverse_noresize (dwo_file
->tus
.get (), queue_and_load_dwo_tu
, cu
);
13171 /* Read in various DIEs. */
13173 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
13174 Inherit only the children of the DW_AT_abstract_origin DIE not being
13175 already referenced by DW_AT_abstract_origin from the children of the
13179 inherit_abstract_dies (struct die_info
*die
, struct dwarf2_cu
*cu
)
13181 struct die_info
*child_die
;
13182 sect_offset
*offsetp
;
13183 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
13184 struct die_info
*origin_die
;
13185 /* Iterator of the ORIGIN_DIE children. */
13186 struct die_info
*origin_child_die
;
13187 struct attribute
*attr
;
13188 struct dwarf2_cu
*origin_cu
;
13189 struct pending
**origin_previous_list_in_scope
;
13191 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
13195 /* Note that following die references may follow to a die in a
13199 origin_die
= follow_die_ref (die
, attr
, &origin_cu
);
13201 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
13203 origin_previous_list_in_scope
= origin_cu
->list_in_scope
;
13204 origin_cu
->list_in_scope
= cu
->list_in_scope
;
13206 if (die
->tag
!= origin_die
->tag
13207 && !(die
->tag
== DW_TAG_inlined_subroutine
13208 && origin_die
->tag
== DW_TAG_subprogram
))
13209 complaint (_("DIE %s and its abstract origin %s have different tags"),
13210 sect_offset_str (die
->sect_off
),
13211 sect_offset_str (origin_die
->sect_off
));
13213 /* Find if the concrete and abstract trees are structurally the
13214 same. This is a shallow traversal and it is not bullet-proof;
13215 the compiler can trick the debugger into believing that the trees
13216 are isomorphic, whereas they actually are not. However, the
13217 likelyhood of this happening is pretty low, and a full-fledged
13218 check would be an overkill. */
13219 bool are_isomorphic
= true;
13220 die_info
*concrete_child
= die
->child
;
13221 die_info
*abstract_child
= origin_die
->child
;
13222 while (concrete_child
!= nullptr || abstract_child
!= nullptr)
13224 if (concrete_child
== nullptr
13225 || abstract_child
== nullptr
13226 || concrete_child
->tag
!= abstract_child
->tag
)
13228 are_isomorphic
= false;
13232 concrete_child
= concrete_child
->sibling
;
13233 abstract_child
= abstract_child
->sibling
;
13236 /* Walk the origin's children in parallel to the concrete children.
13237 This helps match an origin child in case the debug info misses
13238 DW_AT_abstract_origin attributes. Keep in mind that the abstract
13239 origin tree may not have the same tree structure as the concrete
13241 die_info
*corresponding_abstract_child
13242 = are_isomorphic
? origin_die
->child
: nullptr;
13244 std::vector
<sect_offset
> offsets
;
13246 for (child_die
= die
->child
;
13247 child_die
&& child_die
->tag
;
13248 child_die
= child_die
->sibling
)
13250 struct die_info
*child_origin_die
;
13251 struct dwarf2_cu
*child_origin_cu
;
13253 /* We are trying to process concrete instance entries:
13254 DW_TAG_call_site DIEs indeed have a DW_AT_abstract_origin tag, but
13255 it's not relevant to our analysis here. i.e. detecting DIEs that are
13256 present in the abstract instance but not referenced in the concrete
13258 if (child_die
->tag
== DW_TAG_call_site
13259 || child_die
->tag
== DW_TAG_GNU_call_site
)
13261 if (are_isomorphic
)
13262 corresponding_abstract_child
13263 = corresponding_abstract_child
->sibling
;
13267 /* For each CHILD_DIE, find the corresponding child of
13268 ORIGIN_DIE. If there is more than one layer of
13269 DW_AT_abstract_origin, follow them all; there shouldn't be,
13270 but GCC versions at least through 4.4 generate this (GCC PR
13272 child_origin_die
= child_die
;
13273 child_origin_cu
= cu
;
13276 attr
= dwarf2_attr (child_origin_die
, DW_AT_abstract_origin
,
13280 child_origin_die
= follow_die_ref (child_origin_die
, attr
,
13284 /* If missing DW_AT_abstract_origin, try the corresponding child
13285 of the origin. Clang emits such lexical scopes. */
13286 if (child_origin_die
== child_die
13287 && dwarf2_attr (child_die
, DW_AT_abstract_origin
, cu
) == nullptr
13289 && child_die
->tag
== DW_TAG_lexical_block
)
13290 child_origin_die
= corresponding_abstract_child
;
13292 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
13293 counterpart may exist. */
13294 if (child_origin_die
!= child_die
)
13296 if (child_die
->tag
!= child_origin_die
->tag
13297 && !(child_die
->tag
== DW_TAG_inlined_subroutine
13298 && child_origin_die
->tag
== DW_TAG_subprogram
))
13299 complaint (_("Child DIE %s and its abstract origin %s have "
13301 sect_offset_str (child_die
->sect_off
),
13302 sect_offset_str (child_origin_die
->sect_off
));
13303 if (child_origin_die
->parent
!= origin_die
)
13304 complaint (_("Child DIE %s and its abstract origin %s have "
13305 "different parents"),
13306 sect_offset_str (child_die
->sect_off
),
13307 sect_offset_str (child_origin_die
->sect_off
));
13309 offsets
.push_back (child_origin_die
->sect_off
);
13312 if (are_isomorphic
)
13313 corresponding_abstract_child
= corresponding_abstract_child
->sibling
;
13315 std::sort (offsets
.begin (), offsets
.end ());
13316 sect_offset
*offsets_end
= offsets
.data () + offsets
.size ();
13317 for (offsetp
= offsets
.data () + 1; offsetp
< offsets_end
; offsetp
++)
13318 if (offsetp
[-1] == *offsetp
)
13319 complaint (_("Multiple children of DIE %s refer "
13320 "to DIE %s as their abstract origin"),
13321 sect_offset_str (die
->sect_off
), sect_offset_str (*offsetp
));
13323 offsetp
= offsets
.data ();
13324 origin_child_die
= origin_die
->child
;
13325 while (origin_child_die
&& origin_child_die
->tag
)
13327 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
13328 while (offsetp
< offsets_end
13329 && *offsetp
< origin_child_die
->sect_off
)
13331 if (offsetp
>= offsets_end
13332 || *offsetp
> origin_child_die
->sect_off
)
13334 /* Found that ORIGIN_CHILD_DIE is really not referenced.
13335 Check whether we're already processing ORIGIN_CHILD_DIE.
13336 This can happen with mutually referenced abstract_origins.
13338 if (!origin_child_die
->in_process
)
13339 process_die (origin_child_die
, origin_cu
);
13341 origin_child_die
= origin_child_die
->sibling
;
13343 origin_cu
->list_in_scope
= origin_previous_list_in_scope
;
13345 if (cu
!= origin_cu
)
13346 compute_delayed_physnames (origin_cu
);
13350 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13352 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
13353 struct gdbarch
*gdbarch
= objfile
->arch ();
13354 struct context_stack
*newobj
;
13357 struct die_info
*child_die
;
13358 struct attribute
*attr
, *call_line
, *call_file
;
13360 CORE_ADDR baseaddr
;
13361 struct block
*block
;
13362 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
13363 std::vector
<struct symbol
*> template_args
;
13364 struct template_symbol
*templ_func
= NULL
;
13368 /* If we do not have call site information, we can't show the
13369 caller of this inlined function. That's too confusing, so
13370 only use the scope for local variables. */
13371 call_line
= dwarf2_attr (die
, DW_AT_call_line
, cu
);
13372 call_file
= dwarf2_attr (die
, DW_AT_call_file
, cu
);
13373 if (call_line
== NULL
|| call_file
== NULL
)
13375 read_lexical_block_scope (die
, cu
);
13380 baseaddr
= objfile
->text_section_offset ();
13382 name
= dwarf2_name (die
, cu
);
13384 /* Ignore functions with missing or empty names. These are actually
13385 illegal according to the DWARF standard. */
13388 complaint (_("missing name for subprogram DIE at %s"),
13389 sect_offset_str (die
->sect_off
));
13393 /* Ignore functions with missing or invalid low and high pc attributes. */
13394 if (dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
)
13395 <= PC_BOUNDS_INVALID
)
13397 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
13398 if (attr
== nullptr || !attr
->as_boolean ())
13399 complaint (_("cannot get low and high bounds "
13400 "for subprogram DIE at %s"),
13401 sect_offset_str (die
->sect_off
));
13405 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
13406 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
13408 /* If we have any template arguments, then we must allocate a
13409 different sort of symbol. */
13410 for (child_die
= die
->child
; child_die
; child_die
= child_die
->sibling
)
13412 if (child_die
->tag
== DW_TAG_template_type_param
13413 || child_die
->tag
== DW_TAG_template_value_param
)
13415 templ_func
= new (&objfile
->objfile_obstack
) template_symbol
;
13416 templ_func
->subclass
= SYMBOL_TEMPLATE
;
13421 gdb_assert (cu
->get_builder () != nullptr);
13422 newobj
= cu
->get_builder ()->push_context (0, lowpc
);
13423 newobj
->name
= new_symbol (die
, read_type_die (die
, cu
), cu
,
13424 (struct symbol
*) templ_func
);
13426 if (dwarf2_flag_true_p (die
, DW_AT_main_subprogram
, cu
))
13427 set_objfile_main_name (objfile
, newobj
->name
->linkage_name (),
13430 /* If there is a location expression for DW_AT_frame_base, record
13432 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
13433 if (attr
!= nullptr)
13434 dwarf2_symbol_mark_computed (attr
, newobj
->name
, cu
, 1);
13436 /* If there is a location for the static link, record it. */
13437 newobj
->static_link
= NULL
;
13438 attr
= dwarf2_attr (die
, DW_AT_static_link
, cu
);
13439 if (attr
!= nullptr)
13441 newobj
->static_link
13442 = XOBNEW (&objfile
->objfile_obstack
, struct dynamic_prop
);
13443 attr_to_dynamic_prop (attr
, die
, cu
, newobj
->static_link
,
13447 cu
->list_in_scope
= cu
->get_builder ()->get_local_symbols ();
13449 if (die
->child
!= NULL
)
13451 child_die
= die
->child
;
13452 while (child_die
&& child_die
->tag
)
13454 if (child_die
->tag
== DW_TAG_template_type_param
13455 || child_die
->tag
== DW_TAG_template_value_param
)
13457 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
13460 template_args
.push_back (arg
);
13463 process_die (child_die
, cu
);
13464 child_die
= child_die
->sibling
;
13468 inherit_abstract_dies (die
, cu
);
13470 /* If we have a DW_AT_specification, we might need to import using
13471 directives from the context of the specification DIE. See the
13472 comment in determine_prefix. */
13473 if (cu
->language
== language_cplus
13474 && dwarf2_attr (die
, DW_AT_specification
, cu
))
13476 struct dwarf2_cu
*spec_cu
= cu
;
13477 struct die_info
*spec_die
= die_specification (die
, &spec_cu
);
13481 child_die
= spec_die
->child
;
13482 while (child_die
&& child_die
->tag
)
13484 if (child_die
->tag
== DW_TAG_imported_module
)
13485 process_die (child_die
, spec_cu
);
13486 child_die
= child_die
->sibling
;
13489 /* In some cases, GCC generates specification DIEs that
13490 themselves contain DW_AT_specification attributes. */
13491 spec_die
= die_specification (spec_die
, &spec_cu
);
13495 struct context_stack cstk
= cu
->get_builder ()->pop_context ();
13496 /* Make a block for the local symbols within. */
13497 block
= cu
->get_builder ()->finish_block (cstk
.name
, cstk
.old_blocks
,
13498 cstk
.static_link
, lowpc
, highpc
);
13500 /* For C++, set the block's scope. */
13501 if ((cu
->language
== language_cplus
13502 || cu
->language
== language_fortran
13503 || cu
->language
== language_d
13504 || cu
->language
== language_rust
)
13505 && cu
->processing_has_namespace_info
)
13506 block_set_scope (block
, determine_prefix (die
, cu
),
13507 &objfile
->objfile_obstack
);
13509 /* If we have address ranges, record them. */
13510 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
13512 gdbarch_make_symbol_special (gdbarch
, cstk
.name
, objfile
);
13514 /* Attach template arguments to function. */
13515 if (!template_args
.empty ())
13517 gdb_assert (templ_func
!= NULL
);
13519 templ_func
->n_template_arguments
= template_args
.size ();
13520 templ_func
->template_arguments
13521 = XOBNEWVEC (&objfile
->objfile_obstack
, struct symbol
*,
13522 templ_func
->n_template_arguments
);
13523 memcpy (templ_func
->template_arguments
,
13524 template_args
.data (),
13525 (templ_func
->n_template_arguments
* sizeof (struct symbol
*)));
13527 /* Make sure that the symtab is set on the new symbols. Even
13528 though they don't appear in this symtab directly, other parts
13529 of gdb assume that symbols do, and this is reasonably
13531 for (symbol
*sym
: template_args
)
13532 symbol_set_symtab (sym
, symbol_symtab (templ_func
));
13535 /* In C++, we can have functions nested inside functions (e.g., when
13536 a function declares a class that has methods). This means that
13537 when we finish processing a function scope, we may need to go
13538 back to building a containing block's symbol lists. */
13539 *cu
->get_builder ()->get_local_symbols () = cstk
.locals
;
13540 cu
->get_builder ()->set_local_using_directives (cstk
.local_using_directives
);
13542 /* If we've finished processing a top-level function, subsequent
13543 symbols go in the file symbol list. */
13544 if (cu
->get_builder ()->outermost_context_p ())
13545 cu
->list_in_scope
= cu
->get_builder ()->get_file_symbols ();
13548 /* Process all the DIES contained within a lexical block scope. Start
13549 a new scope, process the dies, and then close the scope. */
13552 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13554 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
13555 struct gdbarch
*gdbarch
= objfile
->arch ();
13556 CORE_ADDR lowpc
, highpc
;
13557 struct die_info
*child_die
;
13558 CORE_ADDR baseaddr
;
13560 baseaddr
= objfile
->text_section_offset ();
13562 /* Ignore blocks with missing or invalid low and high pc attributes. */
13563 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
13564 as multiple lexical blocks? Handling children in a sane way would
13565 be nasty. Might be easier to properly extend generic blocks to
13566 describe ranges. */
13567 switch (dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
13569 case PC_BOUNDS_NOT_PRESENT
:
13570 /* DW_TAG_lexical_block has no attributes, process its children as if
13571 there was no wrapping by that DW_TAG_lexical_block.
13572 GCC does no longer produces such DWARF since GCC r224161. */
13573 for (child_die
= die
->child
;
13574 child_die
!= NULL
&& child_die
->tag
;
13575 child_die
= child_die
->sibling
)
13577 /* We might already be processing this DIE. This can happen
13578 in an unusual circumstance -- where a subroutine A
13579 appears lexically in another subroutine B, but A actually
13580 inlines B. The recursion is broken here, rather than in
13581 inherit_abstract_dies, because it seems better to simply
13582 drop concrete children here. */
13583 if (!child_die
->in_process
)
13584 process_die (child_die
, cu
);
13587 case PC_BOUNDS_INVALID
:
13590 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
13591 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
13593 cu
->get_builder ()->push_context (0, lowpc
);
13594 if (die
->child
!= NULL
)
13596 child_die
= die
->child
;
13597 while (child_die
&& child_die
->tag
)
13599 process_die (child_die
, cu
);
13600 child_die
= child_die
->sibling
;
13603 inherit_abstract_dies (die
, cu
);
13604 struct context_stack cstk
= cu
->get_builder ()->pop_context ();
13606 if (*cu
->get_builder ()->get_local_symbols () != NULL
13607 || (*cu
->get_builder ()->get_local_using_directives ()) != NULL
)
13609 struct block
*block
13610 = cu
->get_builder ()->finish_block (0, cstk
.old_blocks
, NULL
,
13611 cstk
.start_addr
, highpc
);
13613 /* Note that recording ranges after traversing children, as we
13614 do here, means that recording a parent's ranges entails
13615 walking across all its children's ranges as they appear in
13616 the address map, which is quadratic behavior.
13618 It would be nicer to record the parent's ranges before
13619 traversing its children, simply overriding whatever you find
13620 there. But since we don't even decide whether to create a
13621 block until after we've traversed its children, that's hard
13623 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
13625 *cu
->get_builder ()->get_local_symbols () = cstk
.locals
;
13626 cu
->get_builder ()->set_local_using_directives (cstk
.local_using_directives
);
13629 /* Read in DW_TAG_call_site and insert it to CU->call_site_htab. */
13632 read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13634 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
13635 struct objfile
*objfile
= per_objfile
->objfile
;
13636 struct gdbarch
*gdbarch
= objfile
->arch ();
13637 CORE_ADDR pc
, baseaddr
;
13638 struct attribute
*attr
;
13639 struct call_site
*call_site
, call_site_local
;
13642 struct die_info
*child_die
;
13644 baseaddr
= objfile
->text_section_offset ();
13646 attr
= dwarf2_attr (die
, DW_AT_call_return_pc
, cu
);
13649 /* This was a pre-DWARF-5 GNU extension alias
13650 for DW_AT_call_return_pc. */
13651 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
13655 complaint (_("missing DW_AT_call_return_pc for DW_TAG_call_site "
13656 "DIE %s [in module %s]"),
13657 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
13660 pc
= attr
->as_address () + baseaddr
;
13661 pc
= gdbarch_adjust_dwarf2_addr (gdbarch
, pc
);
13663 if (cu
->call_site_htab
== NULL
)
13664 cu
->call_site_htab
= htab_create_alloc_ex (16, core_addr_hash
, core_addr_eq
,
13665 NULL
, &objfile
->objfile_obstack
,
13666 hashtab_obstack_allocate
, NULL
);
13667 call_site_local
.pc
= pc
;
13668 slot
= htab_find_slot (cu
->call_site_htab
, &call_site_local
, INSERT
);
13671 complaint (_("Duplicate PC %s for DW_TAG_call_site "
13672 "DIE %s [in module %s]"),
13673 paddress (gdbarch
, pc
), sect_offset_str (die
->sect_off
),
13674 objfile_name (objfile
));
13678 /* Count parameters at the caller. */
13681 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
13682 child_die
= child_die
->sibling
)
13684 if (child_die
->tag
!= DW_TAG_call_site_parameter
13685 && child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
13687 complaint (_("Tag %d is not DW_TAG_call_site_parameter in "
13688 "DW_TAG_call_site child DIE %s [in module %s]"),
13689 child_die
->tag
, sect_offset_str (child_die
->sect_off
),
13690 objfile_name (objfile
));
13698 = ((struct call_site
*)
13699 obstack_alloc (&objfile
->objfile_obstack
,
13700 sizeof (*call_site
)
13701 + (sizeof (*call_site
->parameter
) * (nparams
- 1))));
13703 memset (call_site
, 0, sizeof (*call_site
) - sizeof (*call_site
->parameter
));
13704 call_site
->pc
= pc
;
13706 if (dwarf2_flag_true_p (die
, DW_AT_call_tail_call
, cu
)
13707 || dwarf2_flag_true_p (die
, DW_AT_GNU_tail_call
, cu
))
13709 struct die_info
*func_die
;
13711 /* Skip also over DW_TAG_inlined_subroutine. */
13712 for (func_die
= die
->parent
;
13713 func_die
&& func_die
->tag
!= DW_TAG_subprogram
13714 && func_die
->tag
!= DW_TAG_subroutine_type
;
13715 func_die
= func_die
->parent
);
13717 /* DW_AT_call_all_calls is a superset
13718 of DW_AT_call_all_tail_calls. */
13720 && !dwarf2_flag_true_p (func_die
, DW_AT_call_all_calls
, cu
)
13721 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_call_sites
, cu
)
13722 && !dwarf2_flag_true_p (func_die
, DW_AT_call_all_tail_calls
, cu
)
13723 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_tail_call_sites
, cu
))
13725 /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
13726 not complete. But keep CALL_SITE for look ups via call_site_htab,
13727 both the initial caller containing the real return address PC and
13728 the final callee containing the current PC of a chain of tail
13729 calls do not need to have the tail call list complete. But any
13730 function candidate for a virtual tail call frame searched via
13731 TYPE_TAIL_CALL_LIST must have the tail call list complete to be
13732 determined unambiguously. */
13736 struct type
*func_type
= NULL
;
13739 func_type
= get_die_type (func_die
, cu
);
13740 if (func_type
!= NULL
)
13742 gdb_assert (func_type
->code () == TYPE_CODE_FUNC
);
13744 /* Enlist this call site to the function. */
13745 call_site
->tail_call_next
= TYPE_TAIL_CALL_LIST (func_type
);
13746 TYPE_TAIL_CALL_LIST (func_type
) = call_site
;
13749 complaint (_("Cannot find function owning DW_TAG_call_site "
13750 "DIE %s [in module %s]"),
13751 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
13755 attr
= dwarf2_attr (die
, DW_AT_call_target
, cu
);
13757 attr
= dwarf2_attr (die
, DW_AT_GNU_call_site_target
, cu
);
13759 attr
= dwarf2_attr (die
, DW_AT_call_origin
, cu
);
13762 /* This was a pre-DWARF-5 GNU extension alias for DW_AT_call_origin. */
13763 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
13765 SET_FIELD_DWARF_BLOCK (call_site
->target
, NULL
);
13766 if (!attr
|| (attr
->form_is_block () && attr
->as_block ()->size
== 0))
13767 /* Keep NULL DWARF_BLOCK. */;
13768 else if (attr
->form_is_block ())
13770 struct dwarf2_locexpr_baton
*dlbaton
;
13771 struct dwarf_block
*block
= attr
->as_block ();
13773 dlbaton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
13774 dlbaton
->data
= block
->data
;
13775 dlbaton
->size
= block
->size
;
13776 dlbaton
->per_objfile
= per_objfile
;
13777 dlbaton
->per_cu
= cu
->per_cu
;
13779 SET_FIELD_DWARF_BLOCK (call_site
->target
, dlbaton
);
13781 else if (attr
->form_is_ref ())
13783 struct dwarf2_cu
*target_cu
= cu
;
13784 struct die_info
*target_die
;
13786 target_die
= follow_die_ref (die
, attr
, &target_cu
);
13787 gdb_assert (target_cu
->per_objfile
->objfile
== objfile
);
13788 if (die_is_declaration (target_die
, target_cu
))
13790 const char *target_physname
;
13792 /* Prefer the mangled name; otherwise compute the demangled one. */
13793 target_physname
= dw2_linkage_name (target_die
, target_cu
);
13794 if (target_physname
== NULL
)
13795 target_physname
= dwarf2_physname (NULL
, target_die
, target_cu
);
13796 if (target_physname
== NULL
)
13797 complaint (_("DW_AT_call_target target DIE has invalid "
13798 "physname, for referencing DIE %s [in module %s]"),
13799 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
13801 SET_FIELD_PHYSNAME (call_site
->target
, target_physname
);
13807 /* DW_AT_entry_pc should be preferred. */
13808 if (dwarf2_get_pc_bounds (target_die
, &lowpc
, NULL
, target_cu
, NULL
)
13809 <= PC_BOUNDS_INVALID
)
13810 complaint (_("DW_AT_call_target target DIE has invalid "
13811 "low pc, for referencing DIE %s [in module %s]"),
13812 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
13815 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
13816 SET_FIELD_PHYSADDR (call_site
->target
, lowpc
);
13821 complaint (_("DW_TAG_call_site DW_AT_call_target is neither "
13822 "block nor reference, for DIE %s [in module %s]"),
13823 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
13825 call_site
->per_cu
= cu
->per_cu
;
13826 call_site
->per_objfile
= per_objfile
;
13828 for (child_die
= die
->child
;
13829 child_die
&& child_die
->tag
;
13830 child_die
= child_die
->sibling
)
13832 struct call_site_parameter
*parameter
;
13833 struct attribute
*loc
, *origin
;
13835 if (child_die
->tag
!= DW_TAG_call_site_parameter
13836 && child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
13838 /* Already printed the complaint above. */
13842 gdb_assert (call_site
->parameter_count
< nparams
);
13843 parameter
= &call_site
->parameter
[call_site
->parameter_count
];
13845 /* DW_AT_location specifies the register number or DW_AT_abstract_origin
13846 specifies DW_TAG_formal_parameter. Value of the data assumed for the
13847 register is contained in DW_AT_call_value. */
13849 loc
= dwarf2_attr (child_die
, DW_AT_location
, cu
);
13850 origin
= dwarf2_attr (child_die
, DW_AT_call_parameter
, cu
);
13851 if (origin
== NULL
)
13853 /* This was a pre-DWARF-5 GNU extension alias
13854 for DW_AT_call_parameter. */
13855 origin
= dwarf2_attr (child_die
, DW_AT_abstract_origin
, cu
);
13857 if (loc
== NULL
&& origin
!= NULL
&& origin
->form_is_ref ())
13859 parameter
->kind
= CALL_SITE_PARAMETER_PARAM_OFFSET
;
13861 sect_offset sect_off
= origin
->get_ref_die_offset ();
13862 if (!cu
->header
.offset_in_cu_p (sect_off
))
13864 /* As DW_OP_GNU_parameter_ref uses CU-relative offset this
13865 binding can be done only inside one CU. Such referenced DIE
13866 therefore cannot be even moved to DW_TAG_partial_unit. */
13867 complaint (_("DW_AT_call_parameter offset is not in CU for "
13868 "DW_TAG_call_site child DIE %s [in module %s]"),
13869 sect_offset_str (child_die
->sect_off
),
13870 objfile_name (objfile
));
13873 parameter
->u
.param_cu_off
13874 = (cu_offset
) (sect_off
- cu
->header
.sect_off
);
13876 else if (loc
== NULL
|| origin
!= NULL
|| !loc
->form_is_block ())
13878 complaint (_("No DW_FORM_block* DW_AT_location for "
13879 "DW_TAG_call_site child DIE %s [in module %s]"),
13880 sect_offset_str (child_die
->sect_off
), objfile_name (objfile
));
13885 struct dwarf_block
*block
= loc
->as_block ();
13887 parameter
->u
.dwarf_reg
= dwarf_block_to_dwarf_reg
13888 (block
->data
, &block
->data
[block
->size
]);
13889 if (parameter
->u
.dwarf_reg
!= -1)
13890 parameter
->kind
= CALL_SITE_PARAMETER_DWARF_REG
;
13891 else if (dwarf_block_to_sp_offset (gdbarch
, block
->data
,
13892 &block
->data
[block
->size
],
13893 ¶meter
->u
.fb_offset
))
13894 parameter
->kind
= CALL_SITE_PARAMETER_FB_OFFSET
;
13897 complaint (_("Only single DW_OP_reg or DW_OP_fbreg is supported "
13898 "for DW_FORM_block* DW_AT_location is supported for "
13899 "DW_TAG_call_site child DIE %s "
13901 sect_offset_str (child_die
->sect_off
),
13902 objfile_name (objfile
));
13907 attr
= dwarf2_attr (child_die
, DW_AT_call_value
, cu
);
13909 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_value
, cu
);
13910 if (attr
== NULL
|| !attr
->form_is_block ())
13912 complaint (_("No DW_FORM_block* DW_AT_call_value for "
13913 "DW_TAG_call_site child DIE %s [in module %s]"),
13914 sect_offset_str (child_die
->sect_off
),
13915 objfile_name (objfile
));
13919 struct dwarf_block
*block
= attr
->as_block ();
13920 parameter
->value
= block
->data
;
13921 parameter
->value_size
= block
->size
;
13923 /* Parameters are not pre-cleared by memset above. */
13924 parameter
->data_value
= NULL
;
13925 parameter
->data_value_size
= 0;
13926 call_site
->parameter_count
++;
13928 attr
= dwarf2_attr (child_die
, DW_AT_call_data_value
, cu
);
13930 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_data_value
, cu
);
13931 if (attr
!= nullptr)
13933 if (!attr
->form_is_block ())
13934 complaint (_("No DW_FORM_block* DW_AT_call_data_value for "
13935 "DW_TAG_call_site child DIE %s [in module %s]"),
13936 sect_offset_str (child_die
->sect_off
),
13937 objfile_name (objfile
));
13940 block
= attr
->as_block ();
13941 parameter
->data_value
= block
->data
;
13942 parameter
->data_value_size
= block
->size
;
13948 /* Helper function for read_variable. If DIE represents a virtual
13949 table, then return the type of the concrete object that is
13950 associated with the virtual table. Otherwise, return NULL. */
13952 static struct type
*
13953 rust_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
13955 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
13959 /* Find the type DIE. */
13960 struct die_info
*type_die
= NULL
;
13961 struct dwarf2_cu
*type_cu
= cu
;
13963 if (attr
->form_is_ref ())
13964 type_die
= follow_die_ref (die
, attr
, &type_cu
);
13965 if (type_die
== NULL
)
13968 if (dwarf2_attr (type_die
, DW_AT_containing_type
, type_cu
) == NULL
)
13970 return die_containing_type (type_die
, type_cu
);
13973 /* Read a variable (DW_TAG_variable) DIE and create a new symbol. */
13976 read_variable (struct die_info
*die
, struct dwarf2_cu
*cu
)
13978 struct rust_vtable_symbol
*storage
= NULL
;
13980 if (cu
->language
== language_rust
)
13982 struct type
*containing_type
= rust_containing_type (die
, cu
);
13984 if (containing_type
!= NULL
)
13986 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
13988 storage
= new (&objfile
->objfile_obstack
) rust_vtable_symbol
;
13989 storage
->concrete_type
= containing_type
;
13990 storage
->subclass
= SYMBOL_RUST_VTABLE
;
13994 struct symbol
*res
= new_symbol (die
, NULL
, cu
, storage
);
13995 struct attribute
*abstract_origin
13996 = dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
13997 struct attribute
*loc
= dwarf2_attr (die
, DW_AT_location
, cu
);
13998 if (res
== NULL
&& loc
&& abstract_origin
)
14000 /* We have a variable without a name, but with a location and an abstract
14001 origin. This may be a concrete instance of an abstract variable
14002 referenced from an DW_OP_GNU_variable_value, so save it to find it back
14004 struct dwarf2_cu
*origin_cu
= cu
;
14005 struct die_info
*origin_die
14006 = follow_die_ref (die
, abstract_origin
, &origin_cu
);
14007 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
14008 per_objfile
->per_bfd
->abstract_to_concrete
14009 [origin_die
->sect_off
].push_back (die
->sect_off
);
14013 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET
14014 reading .debug_rnglists.
14015 Callback's type should be:
14016 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14017 Return true if the attributes are present and valid, otherwise,
14020 template <typename Callback
>
14022 dwarf2_rnglists_process (unsigned offset
, struct dwarf2_cu
*cu
,
14023 dwarf_tag tag
, Callback
&&callback
)
14025 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
14026 struct objfile
*objfile
= per_objfile
->objfile
;
14027 bfd
*obfd
= objfile
->obfd
;
14028 /* Base address selection entry. */
14029 gdb::optional
<CORE_ADDR
> base
;
14030 const gdb_byte
*buffer
;
14031 CORE_ADDR baseaddr
;
14032 bool overflow
= false;
14033 ULONGEST addr_index
;
14034 struct dwarf2_section_info
*rnglists_section
;
14036 base
= cu
->base_address
;
14037 rnglists_section
= cu_debug_rnglists_section (cu
, tag
);
14038 rnglists_section
->read (objfile
);
14040 if (offset
>= rnglists_section
->size
)
14042 complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
14046 buffer
= rnglists_section
->buffer
+ offset
;
14048 baseaddr
= objfile
->text_section_offset ();
14052 /* Initialize it due to a false compiler warning. */
14053 CORE_ADDR range_beginning
= 0, range_end
= 0;
14054 const gdb_byte
*buf_end
= (rnglists_section
->buffer
14055 + rnglists_section
->size
);
14056 unsigned int bytes_read
;
14058 if (buffer
== buf_end
)
14063 const auto rlet
= static_cast<enum dwarf_range_list_entry
>(*buffer
++);
14066 case DW_RLE_end_of_list
:
14068 case DW_RLE_base_address
:
14069 if (buffer
+ cu
->header
.addr_size
> buf_end
)
14074 base
= cu
->header
.read_address (obfd
, buffer
, &bytes_read
);
14075 buffer
+= bytes_read
;
14077 case DW_RLE_base_addressx
:
14078 addr_index
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14079 buffer
+= bytes_read
;
14080 base
= read_addr_index (cu
, addr_index
);
14082 case DW_RLE_start_length
:
14083 if (buffer
+ cu
->header
.addr_size
> buf_end
)
14088 range_beginning
= cu
->header
.read_address (obfd
, buffer
,
14090 buffer
+= bytes_read
;
14091 range_end
= (range_beginning
14092 + read_unsigned_leb128 (obfd
, buffer
, &bytes_read
));
14093 buffer
+= bytes_read
;
14094 if (buffer
> buf_end
)
14100 case DW_RLE_startx_length
:
14101 addr_index
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14102 buffer
+= bytes_read
;
14103 range_beginning
= read_addr_index (cu
, addr_index
);
14104 if (buffer
> buf_end
)
14109 range_end
= (range_beginning
14110 + read_unsigned_leb128 (obfd
, buffer
, &bytes_read
));
14111 buffer
+= bytes_read
;
14113 case DW_RLE_offset_pair
:
14114 range_beginning
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14115 buffer
+= bytes_read
;
14116 if (buffer
> buf_end
)
14121 range_end
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14122 buffer
+= bytes_read
;
14123 if (buffer
> buf_end
)
14129 case DW_RLE_start_end
:
14130 if (buffer
+ 2 * cu
->header
.addr_size
> buf_end
)
14135 range_beginning
= cu
->header
.read_address (obfd
, buffer
,
14137 buffer
+= bytes_read
;
14138 range_end
= cu
->header
.read_address (obfd
, buffer
, &bytes_read
);
14139 buffer
+= bytes_read
;
14141 case DW_RLE_startx_endx
:
14142 addr_index
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14143 buffer
+= bytes_read
;
14144 range_beginning
= read_addr_index (cu
, addr_index
);
14145 if (buffer
> buf_end
)
14150 addr_index
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14151 buffer
+= bytes_read
;
14152 range_end
= read_addr_index (cu
, addr_index
);
14155 complaint (_("Invalid .debug_rnglists data (no base address)"));
14158 if (rlet
== DW_RLE_end_of_list
|| overflow
)
14160 if (rlet
== DW_RLE_base_address
)
14163 if (range_beginning
> range_end
)
14165 /* Inverted range entries are invalid. */
14166 complaint (_("Invalid .debug_rnglists data (inverted range)"));
14170 /* Empty range entries have no effect. */
14171 if (range_beginning
== range_end
)
14174 /* Only DW_RLE_offset_pair needs the base address added. */
14175 if (rlet
== DW_RLE_offset_pair
)
14177 if (!base
.has_value ())
14179 /* We have no valid base address for the DW_RLE_offset_pair. */
14180 complaint (_("Invalid .debug_rnglists data (no base address for "
14181 "DW_RLE_offset_pair)"));
14185 range_beginning
+= *base
;
14186 range_end
+= *base
;
14189 /* A not-uncommon case of bad debug info.
14190 Don't pollute the addrmap with bad data. */
14191 if (range_beginning
+ baseaddr
== 0
14192 && !per_objfile
->per_bfd
->has_section_at_zero
)
14194 complaint (_(".debug_rnglists entry has start address of zero"
14195 " [in module %s]"), objfile_name (objfile
));
14199 callback (range_beginning
, range_end
);
14204 complaint (_("Offset %d is not terminated "
14205 "for DW_AT_ranges attribute"),
14213 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET reading .debug_ranges.
14214 Callback's type should be:
14215 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14216 Return 1 if the attributes are present and valid, otherwise, return 0. */
14218 template <typename Callback
>
14220 dwarf2_ranges_process (unsigned offset
, struct dwarf2_cu
*cu
, dwarf_tag tag
,
14221 Callback
&&callback
)
14223 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
14224 struct objfile
*objfile
= per_objfile
->objfile
;
14225 struct comp_unit_head
*cu_header
= &cu
->header
;
14226 bfd
*obfd
= objfile
->obfd
;
14227 unsigned int addr_size
= cu_header
->addr_size
;
14228 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
14229 /* Base address selection entry. */
14230 gdb::optional
<CORE_ADDR
> base
;
14231 unsigned int dummy
;
14232 const gdb_byte
*buffer
;
14233 CORE_ADDR baseaddr
;
14235 if (cu_header
->version
>= 5)
14236 return dwarf2_rnglists_process (offset
, cu
, tag
, callback
);
14238 base
= cu
->base_address
;
14240 per_objfile
->per_bfd
->ranges
.read (objfile
);
14241 if (offset
>= per_objfile
->per_bfd
->ranges
.size
)
14243 complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
14247 buffer
= per_objfile
->per_bfd
->ranges
.buffer
+ offset
;
14249 baseaddr
= objfile
->text_section_offset ();
14253 CORE_ADDR range_beginning
, range_end
;
14255 range_beginning
= cu
->header
.read_address (obfd
, buffer
, &dummy
);
14256 buffer
+= addr_size
;
14257 range_end
= cu
->header
.read_address (obfd
, buffer
, &dummy
);
14258 buffer
+= addr_size
;
14259 offset
+= 2 * addr_size
;
14261 /* An end of list marker is a pair of zero addresses. */
14262 if (range_beginning
== 0 && range_end
== 0)
14263 /* Found the end of list entry. */
14266 /* Each base address selection entry is a pair of 2 values.
14267 The first is the largest possible address, the second is
14268 the base address. Check for a base address here. */
14269 if ((range_beginning
& mask
) == mask
)
14271 /* If we found the largest possible address, then we already
14272 have the base address in range_end. */
14277 if (!base
.has_value ())
14279 /* We have no valid base address for the ranges
14281 complaint (_("Invalid .debug_ranges data (no base address)"));
14285 if (range_beginning
> range_end
)
14287 /* Inverted range entries are invalid. */
14288 complaint (_("Invalid .debug_ranges data (inverted range)"));
14292 /* Empty range entries have no effect. */
14293 if (range_beginning
== range_end
)
14296 range_beginning
+= *base
;
14297 range_end
+= *base
;
14299 /* A not-uncommon case of bad debug info.
14300 Don't pollute the addrmap with bad data. */
14301 if (range_beginning
+ baseaddr
== 0
14302 && !per_objfile
->per_bfd
->has_section_at_zero
)
14304 complaint (_(".debug_ranges entry has start address of zero"
14305 " [in module %s]"), objfile_name (objfile
));
14309 callback (range_beginning
, range_end
);
14315 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
14316 Return 1 if the attributes are present and valid, otherwise, return 0.
14317 If RANGES_PST is not NULL we should set up the `psymtabs_addrmap'. */
14320 dwarf2_ranges_read (unsigned offset
, CORE_ADDR
*low_return
,
14321 CORE_ADDR
*high_return
, struct dwarf2_cu
*cu
,
14322 dwarf2_psymtab
*ranges_pst
, dwarf_tag tag
)
14324 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
14325 dwarf2_per_bfd
*per_bfd
= cu
->per_objfile
->per_bfd
;
14326 struct gdbarch
*gdbarch
= objfile
->arch ();
14327 const CORE_ADDR baseaddr
= objfile
->text_section_offset ();
14330 CORE_ADDR high
= 0;
14333 retval
= dwarf2_ranges_process (offset
, cu
, tag
,
14334 [&] (CORE_ADDR range_beginning
, CORE_ADDR range_end
)
14336 if (ranges_pst
!= NULL
)
14341 lowpc
= (gdbarch_adjust_dwarf2_addr (gdbarch
,
14342 range_beginning
+ baseaddr
)
14344 highpc
= (gdbarch_adjust_dwarf2_addr (gdbarch
,
14345 range_end
+ baseaddr
)
14347 addrmap_set_empty (per_bfd
->partial_symtabs
->psymtabs_addrmap
,
14348 lowpc
, highpc
- 1, ranges_pst
);
14351 /* FIXME: This is recording everything as a low-high
14352 segment of consecutive addresses. We should have a
14353 data structure for discontiguous block ranges
14357 low
= range_beginning
;
14363 if (range_beginning
< low
)
14364 low
= range_beginning
;
14365 if (range_end
> high
)
14373 /* If the first entry is an end-of-list marker, the range
14374 describes an empty scope, i.e. no instructions. */
14380 *high_return
= high
;
14384 /* Get low and high pc attributes from a die. See enum pc_bounds_kind
14385 definition for the return value. *LOWPC and *HIGHPC are set iff
14386 neither PC_BOUNDS_NOT_PRESENT nor PC_BOUNDS_INVALID are returned. */
14388 static enum pc_bounds_kind
14389 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
14390 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
,
14391 dwarf2_psymtab
*pst
)
14393 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
14394 struct attribute
*attr
;
14395 struct attribute
*attr_high
;
14397 CORE_ADDR high
= 0;
14398 enum pc_bounds_kind ret
;
14400 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
14403 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
14404 if (attr
!= nullptr)
14406 low
= attr
->as_address ();
14407 high
= attr_high
->as_address ();
14408 if (cu
->header
.version
>= 4 && attr_high
->form_is_constant ())
14412 /* Found high w/o low attribute. */
14413 return PC_BOUNDS_INVALID
;
14415 /* Found consecutive range of addresses. */
14416 ret
= PC_BOUNDS_HIGH_LOW
;
14420 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
14421 if (attr
!= nullptr && attr
->form_is_unsigned ())
14423 /* Offset in the .debug_ranges or .debug_rnglist section (depending
14424 on DWARF version). */
14425 ULONGEST ranges_offset
= attr
->as_unsigned ();
14427 /* See dwarf2_cu::gnu_ranges_base's doc for why we might want to add
14429 if (die
->tag
!= DW_TAG_compile_unit
)
14430 ranges_offset
+= cu
->gnu_ranges_base
;
14432 /* Value of the DW_AT_ranges attribute is the offset in the
14433 .debug_ranges section. */
14434 if (!dwarf2_ranges_read (ranges_offset
, &low
, &high
, cu
, pst
,
14436 return PC_BOUNDS_INVALID
;
14437 /* Found discontinuous range of addresses. */
14438 ret
= PC_BOUNDS_RANGES
;
14441 return PC_BOUNDS_NOT_PRESENT
;
14444 /* partial_die_info::read has also the strict LOW < HIGH requirement. */
14446 return PC_BOUNDS_INVALID
;
14448 /* When using the GNU linker, .gnu.linkonce. sections are used to
14449 eliminate duplicate copies of functions and vtables and such.
14450 The linker will arbitrarily choose one and discard the others.
14451 The AT_*_pc values for such functions refer to local labels in
14452 these sections. If the section from that file was discarded, the
14453 labels are not in the output, so the relocs get a value of 0.
14454 If this is a discarded function, mark the pc bounds as invalid,
14455 so that GDB will ignore it. */
14456 if (low
== 0 && !per_objfile
->per_bfd
->has_section_at_zero
)
14457 return PC_BOUNDS_INVALID
;
14465 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
14466 its low and high PC addresses. Do nothing if these addresses could not
14467 be determined. Otherwise, set LOWPC to the low address if it is smaller,
14468 and HIGHPC to the high address if greater than HIGHPC. */
14471 dwarf2_get_subprogram_pc_bounds (struct die_info
*die
,
14472 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
14473 struct dwarf2_cu
*cu
)
14475 CORE_ADDR low
, high
;
14476 struct die_info
*child
= die
->child
;
14478 if (dwarf2_get_pc_bounds (die
, &low
, &high
, cu
, NULL
) >= PC_BOUNDS_RANGES
)
14480 *lowpc
= std::min (*lowpc
, low
);
14481 *highpc
= std::max (*highpc
, high
);
14484 /* If the language does not allow nested subprograms (either inside
14485 subprograms or lexical blocks), we're done. */
14486 if (cu
->language
!= language_ada
)
14489 /* Check all the children of the given DIE. If it contains nested
14490 subprograms, then check their pc bounds. Likewise, we need to
14491 check lexical blocks as well, as they may also contain subprogram
14493 while (child
&& child
->tag
)
14495 if (child
->tag
== DW_TAG_subprogram
14496 || child
->tag
== DW_TAG_lexical_block
)
14497 dwarf2_get_subprogram_pc_bounds (child
, lowpc
, highpc
, cu
);
14498 child
= child
->sibling
;
14502 /* Get the low and high pc's represented by the scope DIE, and store
14503 them in *LOWPC and *HIGHPC. If the correct values can't be
14504 determined, set *LOWPC to -1 and *HIGHPC to 0. */
14507 get_scope_pc_bounds (struct die_info
*die
,
14508 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
14509 struct dwarf2_cu
*cu
)
14511 CORE_ADDR best_low
= (CORE_ADDR
) -1;
14512 CORE_ADDR best_high
= (CORE_ADDR
) 0;
14513 CORE_ADDR current_low
, current_high
;
14515 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
, NULL
)
14516 >= PC_BOUNDS_RANGES
)
14518 best_low
= current_low
;
14519 best_high
= current_high
;
14523 struct die_info
*child
= die
->child
;
14525 while (child
&& child
->tag
)
14527 switch (child
->tag
) {
14528 case DW_TAG_subprogram
:
14529 dwarf2_get_subprogram_pc_bounds (child
, &best_low
, &best_high
, cu
);
14531 case DW_TAG_namespace
:
14532 case DW_TAG_module
:
14533 /* FIXME: carlton/2004-01-16: Should we do this for
14534 DW_TAG_class_type/DW_TAG_structure_type, too? I think
14535 that current GCC's always emit the DIEs corresponding
14536 to definitions of methods of classes as children of a
14537 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
14538 the DIEs giving the declarations, which could be
14539 anywhere). But I don't see any reason why the
14540 standards says that they have to be there. */
14541 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
14543 if (current_low
!= ((CORE_ADDR
) -1))
14545 best_low
= std::min (best_low
, current_low
);
14546 best_high
= std::max (best_high
, current_high
);
14554 child
= child
->sibling
;
14559 *highpc
= best_high
;
14562 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
14566 dwarf2_record_block_ranges (struct die_info
*die
, struct block
*block
,
14567 CORE_ADDR baseaddr
, struct dwarf2_cu
*cu
)
14569 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
14570 struct gdbarch
*gdbarch
= objfile
->arch ();
14571 struct attribute
*attr
;
14572 struct attribute
*attr_high
;
14574 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
14577 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
14578 if (attr
!= nullptr)
14580 CORE_ADDR low
= attr
->as_address ();
14581 CORE_ADDR high
= attr_high
->as_address ();
14583 if (cu
->header
.version
>= 4 && attr_high
->form_is_constant ())
14586 low
= gdbarch_adjust_dwarf2_addr (gdbarch
, low
+ baseaddr
);
14587 high
= gdbarch_adjust_dwarf2_addr (gdbarch
, high
+ baseaddr
);
14588 cu
->get_builder ()->record_block_range (block
, low
, high
- 1);
14592 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
14593 if (attr
!= nullptr && attr
->form_is_unsigned ())
14595 /* Offset in the .debug_ranges or .debug_rnglist section (depending
14596 on DWARF version). */
14597 ULONGEST ranges_offset
= attr
->as_unsigned ();
14599 /* See dwarf2_cu::gnu_ranges_base's doc for why we might want to add
14601 if (die
->tag
!= DW_TAG_compile_unit
)
14602 ranges_offset
+= cu
->gnu_ranges_base
;
14604 std::vector
<blockrange
> blockvec
;
14605 dwarf2_ranges_process (ranges_offset
, cu
, die
->tag
,
14606 [&] (CORE_ADDR start
, CORE_ADDR end
)
14610 start
= gdbarch_adjust_dwarf2_addr (gdbarch
, start
);
14611 end
= gdbarch_adjust_dwarf2_addr (gdbarch
, end
);
14612 cu
->get_builder ()->record_block_range (block
, start
, end
- 1);
14613 blockvec
.emplace_back (start
, end
);
14616 BLOCK_RANGES(block
) = make_blockranges (objfile
, blockvec
);
14620 /* Check whether the producer field indicates either of GCC < 4.6, or the
14621 Intel C/C++ compiler, and cache the result in CU. */
14624 check_producer (struct dwarf2_cu
*cu
)
14628 if (cu
->producer
== NULL
)
14630 /* For unknown compilers expect their behavior is DWARF version
14633 GCC started to support .debug_types sections by -gdwarf-4 since
14634 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
14635 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
14636 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
14637 interpreted incorrectly by GDB now - GCC PR debug/48229. */
14639 else if (producer_is_gcc (cu
->producer
, &major
, &minor
))
14641 cu
->producer_is_gxx_lt_4_6
= major
< 4 || (major
== 4 && minor
< 6);
14642 cu
->producer_is_gcc_lt_4_3
= major
< 4 || (major
== 4 && minor
< 3);
14644 else if (producer_is_icc (cu
->producer
, &major
, &minor
))
14646 cu
->producer_is_icc
= true;
14647 cu
->producer_is_icc_lt_14
= major
< 14;
14649 else if (startswith (cu
->producer
, "CodeWarrior S12/L-ISA"))
14650 cu
->producer_is_codewarrior
= true;
14653 /* For other non-GCC compilers, expect their behavior is DWARF version
14657 cu
->checked_producer
= true;
14660 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
14661 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
14662 during 4.6.0 experimental. */
14665 producer_is_gxx_lt_4_6 (struct dwarf2_cu
*cu
)
14667 if (!cu
->checked_producer
)
14668 check_producer (cu
);
14670 return cu
->producer_is_gxx_lt_4_6
;
14674 /* Codewarrior (at least as of version 5.0.40) generates dwarf line information
14675 with incorrect is_stmt attributes. */
14678 producer_is_codewarrior (struct dwarf2_cu
*cu
)
14680 if (!cu
->checked_producer
)
14681 check_producer (cu
);
14683 return cu
->producer_is_codewarrior
;
14686 /* Return the accessibility of DIE, as given by DW_AT_accessibility.
14687 If that attribute is not available, return the appropriate
14690 static enum dwarf_access_attribute
14691 dwarf2_access_attribute (struct die_info
*die
, struct dwarf2_cu
*cu
)
14693 attribute
*attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
14694 if (attr
!= nullptr)
14696 LONGEST value
= attr
->constant_value (-1);
14697 if (value
== DW_ACCESS_public
14698 || value
== DW_ACCESS_protected
14699 || value
== DW_ACCESS_private
)
14700 return (dwarf_access_attribute
) value
;
14701 complaint (_("Unhandled DW_AT_accessibility value (%s)"),
14705 if (cu
->header
.version
< 3 || producer_is_gxx_lt_4_6 (cu
))
14707 /* The default DWARF 2 accessibility for members is public, the default
14708 accessibility for inheritance is private. */
14710 if (die
->tag
!= DW_TAG_inheritance
)
14711 return DW_ACCESS_public
;
14713 return DW_ACCESS_private
;
14717 /* DWARF 3+ defines the default accessibility a different way. The same
14718 rules apply now for DW_TAG_inheritance as for the members and it only
14719 depends on the container kind. */
14721 if (die
->parent
->tag
== DW_TAG_class_type
)
14722 return DW_ACCESS_private
;
14724 return DW_ACCESS_public
;
14728 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
14729 offset. If the attribute was not found return 0, otherwise return
14730 1. If it was found but could not properly be handled, set *OFFSET
14734 handle_data_member_location (struct die_info
*die
, struct dwarf2_cu
*cu
,
14737 struct attribute
*attr
;
14739 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
14744 /* Note that we do not check for a section offset first here.
14745 This is because DW_AT_data_member_location is new in DWARF 4,
14746 so if we see it, we can assume that a constant form is really
14747 a constant and not a section offset. */
14748 if (attr
->form_is_constant ())
14749 *offset
= attr
->constant_value (0);
14750 else if (attr
->form_is_section_offset ())
14751 dwarf2_complex_location_expr_complaint ();
14752 else if (attr
->form_is_block ())
14753 *offset
= decode_locdesc (attr
->as_block (), cu
);
14755 dwarf2_complex_location_expr_complaint ();
14763 /* Look for DW_AT_data_member_location and store the results in FIELD. */
14766 handle_data_member_location (struct die_info
*die
, struct dwarf2_cu
*cu
,
14767 struct field
*field
)
14769 struct attribute
*attr
;
14771 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
14774 if (attr
->form_is_constant ())
14776 LONGEST offset
= attr
->constant_value (0);
14777 SET_FIELD_BITPOS (*field
, offset
* bits_per_byte
);
14779 else if (attr
->form_is_section_offset ())
14780 dwarf2_complex_location_expr_complaint ();
14781 else if (attr
->form_is_block ())
14784 CORE_ADDR offset
= decode_locdesc (attr
->as_block (), cu
, &handled
);
14786 SET_FIELD_BITPOS (*field
, offset
* bits_per_byte
);
14789 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
14790 struct objfile
*objfile
= per_objfile
->objfile
;
14791 struct dwarf2_locexpr_baton
*dlbaton
14792 = XOBNEW (&objfile
->objfile_obstack
,
14793 struct dwarf2_locexpr_baton
);
14794 dlbaton
->data
= attr
->as_block ()->data
;
14795 dlbaton
->size
= attr
->as_block ()->size
;
14796 /* When using this baton, we want to compute the address
14797 of the field, not the value. This is why
14798 is_reference is set to false here. */
14799 dlbaton
->is_reference
= false;
14800 dlbaton
->per_objfile
= per_objfile
;
14801 dlbaton
->per_cu
= cu
->per_cu
;
14803 SET_FIELD_DWARF_BLOCK (*field
, dlbaton
);
14807 dwarf2_complex_location_expr_complaint ();
14811 /* Add an aggregate field to the field list. */
14814 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
14815 struct dwarf2_cu
*cu
)
14817 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
14818 struct gdbarch
*gdbarch
= objfile
->arch ();
14819 struct nextfield
*new_field
;
14820 struct attribute
*attr
;
14822 const char *fieldname
= "";
14824 if (die
->tag
== DW_TAG_inheritance
)
14826 fip
->baseclasses
.emplace_back ();
14827 new_field
= &fip
->baseclasses
.back ();
14831 fip
->fields
.emplace_back ();
14832 new_field
= &fip
->fields
.back ();
14835 new_field
->offset
= die
->sect_off
;
14837 new_field
->accessibility
= dwarf2_access_attribute (die
, cu
);
14838 if (new_field
->accessibility
!= DW_ACCESS_public
)
14839 fip
->non_public_fields
= true;
14841 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
14842 if (attr
!= nullptr)
14843 new_field
->virtuality
= attr
->as_virtuality ();
14845 new_field
->virtuality
= DW_VIRTUALITY_none
;
14847 fp
= &new_field
->field
;
14849 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
14851 /* Data member other than a C++ static data member. */
14853 /* Get type of field. */
14854 fp
->set_type (die_type (die
, cu
));
14856 SET_FIELD_BITPOS (*fp
, 0);
14858 /* Get bit size of field (zero if none). */
14859 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
14860 if (attr
!= nullptr)
14862 FIELD_BITSIZE (*fp
) = attr
->constant_value (0);
14866 FIELD_BITSIZE (*fp
) = 0;
14869 /* Get bit offset of field. */
14870 handle_data_member_location (die
, cu
, fp
);
14871 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
14872 if (attr
!= nullptr && attr
->form_is_constant ())
14874 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
)
14876 /* For big endian bits, the DW_AT_bit_offset gives the
14877 additional bit offset from the MSB of the containing
14878 anonymous object to the MSB of the field. We don't
14879 have to do anything special since we don't need to
14880 know the size of the anonymous object. */
14881 SET_FIELD_BITPOS (*fp
, (FIELD_BITPOS (*fp
)
14882 + attr
->constant_value (0)));
14886 /* For little endian bits, compute the bit offset to the
14887 MSB of the anonymous object, subtract off the number of
14888 bits from the MSB of the field to the MSB of the
14889 object, and then subtract off the number of bits of
14890 the field itself. The result is the bit offset of
14891 the LSB of the field. */
14892 int anonymous_size
;
14893 int bit_offset
= attr
->constant_value (0);
14895 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
14896 if (attr
!= nullptr && attr
->form_is_constant ())
14898 /* The size of the anonymous object containing
14899 the bit field is explicit, so use the
14900 indicated size (in bytes). */
14901 anonymous_size
= attr
->constant_value (0);
14905 /* The size of the anonymous object containing
14906 the bit field must be inferred from the type
14907 attribute of the data member containing the
14909 anonymous_size
= TYPE_LENGTH (fp
->type ());
14911 SET_FIELD_BITPOS (*fp
,
14912 (FIELD_BITPOS (*fp
)
14913 + anonymous_size
* bits_per_byte
14914 - bit_offset
- FIELD_BITSIZE (*fp
)));
14917 attr
= dwarf2_attr (die
, DW_AT_data_bit_offset
, cu
);
14919 SET_FIELD_BITPOS (*fp
, (FIELD_BITPOS (*fp
)
14920 + attr
->constant_value (0)));
14922 /* Get name of field. */
14923 fieldname
= dwarf2_name (die
, cu
);
14924 if (fieldname
== NULL
)
14927 /* The name is already allocated along with this objfile, so we don't
14928 need to duplicate it for the type. */
14929 fp
->name
= fieldname
;
14931 /* Change accessibility for artificial fields (e.g. virtual table
14932 pointer or virtual base class pointer) to private. */
14933 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
14935 FIELD_ARTIFICIAL (*fp
) = 1;
14936 new_field
->accessibility
= DW_ACCESS_private
;
14937 fip
->non_public_fields
= true;
14940 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
14942 /* C++ static member. */
14944 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
14945 is a declaration, but all versions of G++ as of this writing
14946 (so through at least 3.2.1) incorrectly generate
14947 DW_TAG_variable tags. */
14949 const char *physname
;
14951 /* Get name of field. */
14952 fieldname
= dwarf2_name (die
, cu
);
14953 if (fieldname
== NULL
)
14956 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
14958 /* Only create a symbol if this is an external value.
14959 new_symbol checks this and puts the value in the global symbol
14960 table, which we want. If it is not external, new_symbol
14961 will try to put the value in cu->list_in_scope which is wrong. */
14962 && dwarf2_flag_true_p (die
, DW_AT_external
, cu
))
14964 /* A static const member, not much different than an enum as far as
14965 we're concerned, except that we can support more types. */
14966 new_symbol (die
, NULL
, cu
);
14969 /* Get physical name. */
14970 physname
= dwarf2_physname (fieldname
, die
, cu
);
14972 /* The name is already allocated along with this objfile, so we don't
14973 need to duplicate it for the type. */
14974 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
14975 fp
->set_type (die_type (die
, cu
));
14976 FIELD_NAME (*fp
) = fieldname
;
14978 else if (die
->tag
== DW_TAG_inheritance
)
14980 /* C++ base class field. */
14981 handle_data_member_location (die
, cu
, fp
);
14982 FIELD_BITSIZE (*fp
) = 0;
14983 fp
->set_type (die_type (die
, cu
));
14984 FIELD_NAME (*fp
) = fp
->type ()->name ();
14987 gdb_assert_not_reached ("missing case in dwarf2_add_field");
14990 /* Can the type given by DIE define another type? */
14993 type_can_define_types (const struct die_info
*die
)
14997 case DW_TAG_typedef
:
14998 case DW_TAG_class_type
:
14999 case DW_TAG_structure_type
:
15000 case DW_TAG_union_type
:
15001 case DW_TAG_enumeration_type
:
15009 /* Add a type definition defined in the scope of the FIP's class. */
15012 dwarf2_add_type_defn (struct field_info
*fip
, struct die_info
*die
,
15013 struct dwarf2_cu
*cu
)
15015 struct decl_field fp
;
15016 memset (&fp
, 0, sizeof (fp
));
15018 gdb_assert (type_can_define_types (die
));
15020 /* Get name of field. NULL is okay here, meaning an anonymous type. */
15021 fp
.name
= dwarf2_name (die
, cu
);
15022 fp
.type
= read_type_die (die
, cu
);
15024 /* Save accessibility. */
15025 dwarf_access_attribute accessibility
= dwarf2_access_attribute (die
, cu
);
15026 switch (accessibility
)
15028 case DW_ACCESS_public
:
15029 /* The assumed value if neither private nor protected. */
15031 case DW_ACCESS_private
:
15034 case DW_ACCESS_protected
:
15035 fp
.is_protected
= 1;
15039 if (die
->tag
== DW_TAG_typedef
)
15040 fip
->typedef_field_list
.push_back (fp
);
15042 fip
->nested_types_list
.push_back (fp
);
15045 /* A convenience typedef that's used when finding the discriminant
15046 field for a variant part. */
15047 typedef std::unordered_map
<sect_offset
, int, gdb::hash_enum
<sect_offset
>>
15050 /* Compute the discriminant range for a given variant. OBSTACK is
15051 where the results will be stored. VARIANT is the variant to
15052 process. IS_UNSIGNED indicates whether the discriminant is signed
15055 static const gdb::array_view
<discriminant_range
>
15056 convert_variant_range (struct obstack
*obstack
, const variant_field
&variant
,
15059 std::vector
<discriminant_range
> ranges
;
15061 if (variant
.default_branch
)
15064 if (variant
.discr_list_data
== nullptr)
15066 discriminant_range r
15067 = {variant
.discriminant_value
, variant
.discriminant_value
};
15068 ranges
.push_back (r
);
15072 gdb::array_view
<const gdb_byte
> data (variant
.discr_list_data
->data
,
15073 variant
.discr_list_data
->size
);
15074 while (!data
.empty ())
15076 if (data
[0] != DW_DSC_range
&& data
[0] != DW_DSC_label
)
15078 complaint (_("invalid discriminant marker: %d"), data
[0]);
15081 bool is_range
= data
[0] == DW_DSC_range
;
15082 data
= data
.slice (1);
15084 ULONGEST low
, high
;
15085 unsigned int bytes_read
;
15089 complaint (_("DW_AT_discr_list missing low value"));
15093 low
= read_unsigned_leb128 (nullptr, data
.data (), &bytes_read
);
15095 low
= (ULONGEST
) read_signed_leb128 (nullptr, data
.data (),
15097 data
= data
.slice (bytes_read
);
15103 complaint (_("DW_AT_discr_list missing high value"));
15107 high
= read_unsigned_leb128 (nullptr, data
.data (),
15110 high
= (LONGEST
) read_signed_leb128 (nullptr, data
.data (),
15112 data
= data
.slice (bytes_read
);
15117 ranges
.push_back ({ low
, high
});
15121 discriminant_range
*result
= XOBNEWVEC (obstack
, discriminant_range
,
15123 std::copy (ranges
.begin (), ranges
.end (), result
);
15124 return gdb::array_view
<discriminant_range
> (result
, ranges
.size ());
15127 static const gdb::array_view
<variant_part
> create_variant_parts
15128 (struct obstack
*obstack
,
15129 const offset_map_type
&offset_map
,
15130 struct field_info
*fi
,
15131 const std::vector
<variant_part_builder
> &variant_parts
);
15133 /* Fill in a "struct variant" for a given variant field. RESULT is
15134 the variant to fill in. OBSTACK is where any needed allocations
15135 will be done. OFFSET_MAP holds the mapping from section offsets to
15136 fields for the type. FI describes the fields of the type we're
15137 processing. FIELD is the variant field we're converting. */
15140 create_one_variant (variant
&result
, struct obstack
*obstack
,
15141 const offset_map_type
&offset_map
,
15142 struct field_info
*fi
, const variant_field
&field
)
15144 result
.discriminants
= convert_variant_range (obstack
, field
, false);
15145 result
.first_field
= field
.first_field
+ fi
->baseclasses
.size ();
15146 result
.last_field
= field
.last_field
+ fi
->baseclasses
.size ();
15147 result
.parts
= create_variant_parts (obstack
, offset_map
, fi
,
15148 field
.variant_parts
);
15151 /* Fill in a "struct variant_part" for a given variant part. RESULT
15152 is the variant part to fill in. OBSTACK is where any needed
15153 allocations will be done. OFFSET_MAP holds the mapping from
15154 section offsets to fields for the type. FI describes the fields of
15155 the type we're processing. BUILDER is the variant part to be
15159 create_one_variant_part (variant_part
&result
,
15160 struct obstack
*obstack
,
15161 const offset_map_type
&offset_map
,
15162 struct field_info
*fi
,
15163 const variant_part_builder
&builder
)
15165 auto iter
= offset_map
.find (builder
.discriminant_offset
);
15166 if (iter
== offset_map
.end ())
15168 result
.discriminant_index
= -1;
15169 /* Doesn't matter. */
15170 result
.is_unsigned
= false;
15174 result
.discriminant_index
= iter
->second
;
15176 = fi
->fields
[result
.discriminant_index
].field
.type ()->is_unsigned ();
15179 size_t n
= builder
.variants
.size ();
15180 variant
*output
= new (obstack
) variant
[n
];
15181 for (size_t i
= 0; i
< n
; ++i
)
15182 create_one_variant (output
[i
], obstack
, offset_map
, fi
,
15183 builder
.variants
[i
]);
15185 result
.variants
= gdb::array_view
<variant
> (output
, n
);
15188 /* Create a vector of variant parts that can be attached to a type.
15189 OBSTACK is where any needed allocations will be done. OFFSET_MAP
15190 holds the mapping from section offsets to fields for the type. FI
15191 describes the fields of the type we're processing. VARIANT_PARTS
15192 is the vector to convert. */
15194 static const gdb::array_view
<variant_part
>
15195 create_variant_parts (struct obstack
*obstack
,
15196 const offset_map_type
&offset_map
,
15197 struct field_info
*fi
,
15198 const std::vector
<variant_part_builder
> &variant_parts
)
15200 if (variant_parts
.empty ())
15203 size_t n
= variant_parts
.size ();
15204 variant_part
*result
= new (obstack
) variant_part
[n
];
15205 for (size_t i
= 0; i
< n
; ++i
)
15206 create_one_variant_part (result
[i
], obstack
, offset_map
, fi
,
15209 return gdb::array_view
<variant_part
> (result
, n
);
15212 /* Compute the variant part vector for FIP, attaching it to TYPE when
15216 add_variant_property (struct field_info
*fip
, struct type
*type
,
15217 struct dwarf2_cu
*cu
)
15219 /* Map section offsets of fields to their field index. Note the
15220 field index here does not take the number of baseclasses into
15222 offset_map_type offset_map
;
15223 for (int i
= 0; i
< fip
->fields
.size (); ++i
)
15224 offset_map
[fip
->fields
[i
].offset
] = i
;
15226 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
15227 gdb::array_view
<variant_part
> parts
15228 = create_variant_parts (&objfile
->objfile_obstack
, offset_map
, fip
,
15229 fip
->variant_parts
);
15231 struct dynamic_prop prop
;
15232 prop
.set_variant_parts ((gdb::array_view
<variant_part
> *)
15233 obstack_copy (&objfile
->objfile_obstack
, &parts
,
15236 type
->add_dyn_prop (DYN_PROP_VARIANT_PARTS
, prop
);
15239 /* Create the vector of fields, and attach it to the type. */
15242 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
15243 struct dwarf2_cu
*cu
)
15245 int nfields
= fip
->nfields ();
15247 /* Record the field count, allocate space for the array of fields,
15248 and create blank accessibility bitfields if necessary. */
15249 type
->set_num_fields (nfields
);
15251 ((struct field
*) TYPE_ZALLOC (type
, sizeof (struct field
) * nfields
));
15253 if (fip
->non_public_fields
&& cu
->language
!= language_ada
)
15255 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15257 TYPE_FIELD_PRIVATE_BITS (type
) =
15258 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
15259 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
15261 TYPE_FIELD_PROTECTED_BITS (type
) =
15262 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
15263 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
15265 TYPE_FIELD_IGNORE_BITS (type
) =
15266 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
15267 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
15270 /* If the type has baseclasses, allocate and clear a bit vector for
15271 TYPE_FIELD_VIRTUAL_BITS. */
15272 if (!fip
->baseclasses
.empty () && cu
->language
!= language_ada
)
15274 int num_bytes
= B_BYTES (fip
->baseclasses
.size ());
15275 unsigned char *pointer
;
15277 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15278 pointer
= (unsigned char *) TYPE_ALLOC (type
, num_bytes
);
15279 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
15280 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->baseclasses
.size ());
15281 TYPE_N_BASECLASSES (type
) = fip
->baseclasses
.size ();
15284 if (!fip
->variant_parts
.empty ())
15285 add_variant_property (fip
, type
, cu
);
15287 /* Copy the saved-up fields into the field vector. */
15288 for (int i
= 0; i
< nfields
; ++i
)
15290 struct nextfield
&field
15291 = ((i
< fip
->baseclasses
.size ()) ? fip
->baseclasses
[i
]
15292 : fip
->fields
[i
- fip
->baseclasses
.size ()]);
15294 type
->field (i
) = field
.field
;
15295 switch (field
.accessibility
)
15297 case DW_ACCESS_private
:
15298 if (cu
->language
!= language_ada
)
15299 SET_TYPE_FIELD_PRIVATE (type
, i
);
15302 case DW_ACCESS_protected
:
15303 if (cu
->language
!= language_ada
)
15304 SET_TYPE_FIELD_PROTECTED (type
, i
);
15307 case DW_ACCESS_public
:
15311 /* Unknown accessibility. Complain and treat it as public. */
15313 complaint (_("unsupported accessibility %d"),
15314 field
.accessibility
);
15318 if (i
< fip
->baseclasses
.size ())
15320 switch (field
.virtuality
)
15322 case DW_VIRTUALITY_virtual
:
15323 case DW_VIRTUALITY_pure_virtual
:
15324 if (cu
->language
== language_ada
)
15325 error (_("unexpected virtuality in component of Ada type"));
15326 SET_TYPE_FIELD_VIRTUAL (type
, i
);
15333 /* Return true if this member function is a constructor, false
15337 dwarf2_is_constructor (struct die_info
*die
, struct dwarf2_cu
*cu
)
15339 const char *fieldname
;
15340 const char *type_name
;
15343 if (die
->parent
== NULL
)
15346 if (die
->parent
->tag
!= DW_TAG_structure_type
15347 && die
->parent
->tag
!= DW_TAG_union_type
15348 && die
->parent
->tag
!= DW_TAG_class_type
)
15351 fieldname
= dwarf2_name (die
, cu
);
15352 type_name
= dwarf2_name (die
->parent
, cu
);
15353 if (fieldname
== NULL
|| type_name
== NULL
)
15356 len
= strlen (fieldname
);
15357 return (strncmp (fieldname
, type_name
, len
) == 0
15358 && (type_name
[len
] == '\0' || type_name
[len
] == '<'));
15361 /* Add a member function to the proper fieldlist. */
15364 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
15365 struct type
*type
, struct dwarf2_cu
*cu
)
15367 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
15368 struct attribute
*attr
;
15370 struct fnfieldlist
*flp
= nullptr;
15371 struct fn_field
*fnp
;
15372 const char *fieldname
;
15373 struct type
*this_type
;
15375 if (cu
->language
== language_ada
)
15376 error (_("unexpected member function in Ada type"));
15378 /* Get name of member function. */
15379 fieldname
= dwarf2_name (die
, cu
);
15380 if (fieldname
== NULL
)
15383 /* Look up member function name in fieldlist. */
15384 for (i
= 0; i
< fip
->fnfieldlists
.size (); i
++)
15386 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
15388 flp
= &fip
->fnfieldlists
[i
];
15393 /* Create a new fnfieldlist if necessary. */
15394 if (flp
== nullptr)
15396 fip
->fnfieldlists
.emplace_back ();
15397 flp
= &fip
->fnfieldlists
.back ();
15398 flp
->name
= fieldname
;
15399 i
= fip
->fnfieldlists
.size () - 1;
15402 /* Create a new member function field and add it to the vector of
15404 flp
->fnfields
.emplace_back ();
15405 fnp
= &flp
->fnfields
.back ();
15407 /* Delay processing of the physname until later. */
15408 if (cu
->language
== language_cplus
)
15409 add_to_method_list (type
, i
, flp
->fnfields
.size () - 1, fieldname
,
15413 const char *physname
= dwarf2_physname (fieldname
, die
, cu
);
15414 fnp
->physname
= physname
? physname
: "";
15417 fnp
->type
= alloc_type (objfile
);
15418 this_type
= read_type_die (die
, cu
);
15419 if (this_type
&& this_type
->code () == TYPE_CODE_FUNC
)
15421 int nparams
= this_type
->num_fields ();
15423 /* TYPE is the domain of this method, and THIS_TYPE is the type
15424 of the method itself (TYPE_CODE_METHOD). */
15425 smash_to_method_type (fnp
->type
, type
,
15426 TYPE_TARGET_TYPE (this_type
),
15427 this_type
->fields (),
15428 this_type
->num_fields (),
15429 this_type
->has_varargs ());
15431 /* Handle static member functions.
15432 Dwarf2 has no clean way to discern C++ static and non-static
15433 member functions. G++ helps GDB by marking the first
15434 parameter for non-static member functions (which is the this
15435 pointer) as artificial. We obtain this information from
15436 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
15437 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (this_type
, 0) == 0)
15438 fnp
->voffset
= VOFFSET_STATIC
;
15441 complaint (_("member function type missing for '%s'"),
15442 dwarf2_full_name (fieldname
, die
, cu
));
15444 /* Get fcontext from DW_AT_containing_type if present. */
15445 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
15446 fnp
->fcontext
= die_containing_type (die
, cu
);
15448 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
15449 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
15451 /* Get accessibility. */
15452 dwarf_access_attribute accessibility
= dwarf2_access_attribute (die
, cu
);
15453 switch (accessibility
)
15455 case DW_ACCESS_private
:
15456 fnp
->is_private
= 1;
15458 case DW_ACCESS_protected
:
15459 fnp
->is_protected
= 1;
15463 /* Check for artificial methods. */
15464 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
15465 if (attr
&& attr
->as_boolean ())
15466 fnp
->is_artificial
= 1;
15468 /* Check for defaulted methods. */
15469 attr
= dwarf2_attr (die
, DW_AT_defaulted
, cu
);
15470 if (attr
!= nullptr)
15471 fnp
->defaulted
= attr
->defaulted ();
15473 /* Check for deleted methods. */
15474 attr
= dwarf2_attr (die
, DW_AT_deleted
, cu
);
15475 if (attr
!= nullptr && attr
->as_boolean ())
15476 fnp
->is_deleted
= 1;
15478 fnp
->is_constructor
= dwarf2_is_constructor (die
, cu
);
15480 /* Get index in virtual function table if it is a virtual member
15481 function. For older versions of GCC, this is an offset in the
15482 appropriate virtual table, as specified by DW_AT_containing_type.
15483 For everyone else, it is an expression to be evaluated relative
15484 to the object address. */
15486 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
15487 if (attr
!= nullptr)
15489 if (attr
->form_is_block () && attr
->as_block ()->size
> 0)
15491 struct dwarf_block
*block
= attr
->as_block ();
15493 if (block
->data
[0] == DW_OP_constu
)
15495 /* Old-style GCC. */
15496 fnp
->voffset
= decode_locdesc (block
, cu
) + 2;
15498 else if (block
->data
[0] == DW_OP_deref
15499 || (block
->size
> 1
15500 && block
->data
[0] == DW_OP_deref_size
15501 && block
->data
[1] == cu
->header
.addr_size
))
15503 fnp
->voffset
= decode_locdesc (block
, cu
);
15504 if ((fnp
->voffset
% cu
->header
.addr_size
) != 0)
15505 dwarf2_complex_location_expr_complaint ();
15507 fnp
->voffset
/= cu
->header
.addr_size
;
15511 dwarf2_complex_location_expr_complaint ();
15513 if (!fnp
->fcontext
)
15515 /* If there is no `this' field and no DW_AT_containing_type,
15516 we cannot actually find a base class context for the
15518 if (this_type
->num_fields () == 0
15519 || !TYPE_FIELD_ARTIFICIAL (this_type
, 0))
15521 complaint (_("cannot determine context for virtual member "
15522 "function \"%s\" (offset %s)"),
15523 fieldname
, sect_offset_str (die
->sect_off
));
15528 = TYPE_TARGET_TYPE (this_type
->field (0).type ());
15532 else if (attr
->form_is_section_offset ())
15534 dwarf2_complex_location_expr_complaint ();
15538 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
15544 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
15545 if (attr
!= nullptr && attr
->as_virtuality () != DW_VIRTUALITY_none
)
15547 /* GCC does this, as of 2008-08-25; PR debug/37237. */
15548 complaint (_("Member function \"%s\" (offset %s) is virtual "
15549 "but the vtable offset is not specified"),
15550 fieldname
, sect_offset_str (die
->sect_off
));
15551 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15552 TYPE_CPLUS_DYNAMIC (type
) = 1;
15557 /* Create the vector of member function fields, and attach it to the type. */
15560 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
15561 struct dwarf2_cu
*cu
)
15563 if (cu
->language
== language_ada
)
15564 error (_("unexpected member functions in Ada type"));
15566 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15567 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
15569 sizeof (struct fn_fieldlist
) * fip
->fnfieldlists
.size ());
15571 for (int i
= 0; i
< fip
->fnfieldlists
.size (); i
++)
15573 struct fnfieldlist
&nf
= fip
->fnfieldlists
[i
];
15574 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
15576 TYPE_FN_FIELDLIST_NAME (type
, i
) = nf
.name
;
15577 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = nf
.fnfields
.size ();
15578 fn_flp
->fn_fields
= (struct fn_field
*)
15579 TYPE_ALLOC (type
, sizeof (struct fn_field
) * nf
.fnfields
.size ());
15581 for (int k
= 0; k
< nf
.fnfields
.size (); ++k
)
15582 fn_flp
->fn_fields
[k
] = nf
.fnfields
[k
];
15585 TYPE_NFN_FIELDS (type
) = fip
->fnfieldlists
.size ();
15588 /* Returns non-zero if NAME is the name of a vtable member in CU's
15589 language, zero otherwise. */
15591 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
15593 static const char vptr
[] = "_vptr";
15595 /* Look for the C++ form of the vtable. */
15596 if (startswith (name
, vptr
) && is_cplus_marker (name
[sizeof (vptr
) - 1]))
15602 /* GCC outputs unnamed structures that are really pointers to member
15603 functions, with the ABI-specified layout. If TYPE describes
15604 such a structure, smash it into a member function type.
15606 GCC shouldn't do this; it should just output pointer to member DIEs.
15607 This is GCC PR debug/28767. */
15610 quirk_gcc_member_function_pointer (struct type
*type
, struct objfile
*objfile
)
15612 struct type
*pfn_type
, *self_type
, *new_type
;
15614 /* Check for a structure with no name and two children. */
15615 if (type
->code () != TYPE_CODE_STRUCT
|| type
->num_fields () != 2)
15618 /* Check for __pfn and __delta members. */
15619 if (TYPE_FIELD_NAME (type
, 0) == NULL
15620 || strcmp (TYPE_FIELD_NAME (type
, 0), "__pfn") != 0
15621 || TYPE_FIELD_NAME (type
, 1) == NULL
15622 || strcmp (TYPE_FIELD_NAME (type
, 1), "__delta") != 0)
15625 /* Find the type of the method. */
15626 pfn_type
= type
->field (0).type ();
15627 if (pfn_type
== NULL
15628 || pfn_type
->code () != TYPE_CODE_PTR
15629 || TYPE_TARGET_TYPE (pfn_type
)->code () != TYPE_CODE_FUNC
)
15632 /* Look for the "this" argument. */
15633 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
15634 if (pfn_type
->num_fields () == 0
15635 /* || pfn_type->field (0).type () == NULL */
15636 || pfn_type
->field (0).type ()->code () != TYPE_CODE_PTR
)
15639 self_type
= TYPE_TARGET_TYPE (pfn_type
->field (0).type ());
15640 new_type
= alloc_type (objfile
);
15641 smash_to_method_type (new_type
, self_type
, TYPE_TARGET_TYPE (pfn_type
),
15642 pfn_type
->fields (), pfn_type
->num_fields (),
15643 pfn_type
->has_varargs ());
15644 smash_to_methodptr_type (type
, new_type
);
15647 /* Helper for quirk_ada_thick_pointer. If TYPE is an array type that
15648 requires rewriting, then copy it and return the updated copy.
15649 Otherwise return nullptr. */
15651 static struct type
*
15652 rewrite_array_type (struct type
*type
)
15654 if (type
->code () != TYPE_CODE_ARRAY
)
15657 struct type
*index_type
= type
->index_type ();
15658 range_bounds
*current_bounds
= index_type
->bounds ();
15660 /* Handle multi-dimensional arrays. */
15661 struct type
*new_target
= rewrite_array_type (TYPE_TARGET_TYPE (type
));
15662 if (new_target
== nullptr)
15664 /* Maybe we don't need to rewrite this array. */
15665 if (current_bounds
->low
.kind () == PROP_CONST
15666 && current_bounds
->high
.kind () == PROP_CONST
)
15670 /* Either the target type was rewritten, or the bounds have to be
15671 updated. Either way we want to copy the type and update
15673 struct type
*copy
= copy_type (type
);
15674 int nfields
= copy
->num_fields ();
15676 = ((struct field
*) TYPE_ZALLOC (copy
,
15677 nfields
* sizeof (struct field
)));
15678 memcpy (new_fields
, copy
->fields (), nfields
* sizeof (struct field
));
15679 copy
->set_fields (new_fields
);
15680 if (new_target
!= nullptr)
15681 TYPE_TARGET_TYPE (copy
) = new_target
;
15683 struct type
*index_copy
= copy_type (index_type
);
15684 range_bounds
*bounds
15685 = (struct range_bounds
*) TYPE_ZALLOC (index_copy
,
15686 sizeof (range_bounds
));
15687 *bounds
= *current_bounds
;
15688 bounds
->low
.set_const_val (1);
15689 bounds
->high
.set_const_val (0);
15690 index_copy
->set_bounds (bounds
);
15691 copy
->set_index_type (index_copy
);
15696 /* While some versions of GCC will generate complicated DWARF for an
15697 array (see quirk_ada_thick_pointer), more recent versions were
15698 modified to emit an explicit thick pointer structure. However, in
15699 this case, the array still has DWARF expressions for its ranges,
15700 and these must be ignored. */
15703 quirk_ada_thick_pointer_struct (struct die_info
*die
, struct dwarf2_cu
*cu
,
15706 gdb_assert (cu
->language
== language_ada
);
15708 /* Check for a structure with two children. */
15709 if (type
->code () != TYPE_CODE_STRUCT
|| type
->num_fields () != 2)
15712 /* Check for P_ARRAY and P_BOUNDS members. */
15713 if (TYPE_FIELD_NAME (type
, 0) == NULL
15714 || strcmp (TYPE_FIELD_NAME (type
, 0), "P_ARRAY") != 0
15715 || TYPE_FIELD_NAME (type
, 1) == NULL
15716 || strcmp (TYPE_FIELD_NAME (type
, 1), "P_BOUNDS") != 0)
15719 /* Make sure we're looking at a pointer to an array. */
15720 if (type
->field (0).type ()->code () != TYPE_CODE_PTR
)
15723 /* The Ada code already knows how to handle these types, so all that
15724 we need to do is turn the bounds into static bounds. However, we
15725 don't want to rewrite existing array or index types in-place,
15726 because those may be referenced in other contexts where this
15727 rewriting is undesirable. */
15728 struct type
*new_ary_type
15729 = rewrite_array_type (TYPE_TARGET_TYPE (type
->field (0).type ()));
15730 if (new_ary_type
!= nullptr)
15731 type
->field (0).set_type (lookup_pointer_type (new_ary_type
));
15734 /* If the DIE has a DW_AT_alignment attribute, return its value, doing
15735 appropriate error checking and issuing complaints if there is a
15739 get_alignment (struct dwarf2_cu
*cu
, struct die_info
*die
)
15741 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_alignment
, cu
);
15743 if (attr
== nullptr)
15746 if (!attr
->form_is_constant ())
15748 complaint (_("DW_AT_alignment must have constant form"
15749 " - DIE at %s [in module %s]"),
15750 sect_offset_str (die
->sect_off
),
15751 objfile_name (cu
->per_objfile
->objfile
));
15755 LONGEST val
= attr
->constant_value (0);
15758 complaint (_("DW_AT_alignment value must not be negative"
15759 " - DIE at %s [in module %s]"),
15760 sect_offset_str (die
->sect_off
),
15761 objfile_name (cu
->per_objfile
->objfile
));
15764 ULONGEST align
= val
;
15768 complaint (_("DW_AT_alignment value must not be zero"
15769 " - DIE at %s [in module %s]"),
15770 sect_offset_str (die
->sect_off
),
15771 objfile_name (cu
->per_objfile
->objfile
));
15774 if ((align
& (align
- 1)) != 0)
15776 complaint (_("DW_AT_alignment value must be a power of 2"
15777 " - DIE at %s [in module %s]"),
15778 sect_offset_str (die
->sect_off
),
15779 objfile_name (cu
->per_objfile
->objfile
));
15786 /* If the DIE has a DW_AT_alignment attribute, use its value to set
15787 the alignment for TYPE. */
15790 maybe_set_alignment (struct dwarf2_cu
*cu
, struct die_info
*die
,
15793 if (!set_type_align (type
, get_alignment (cu
, die
)))
15794 complaint (_("DW_AT_alignment value too large"
15795 " - DIE at %s [in module %s]"),
15796 sect_offset_str (die
->sect_off
),
15797 objfile_name (cu
->per_objfile
->objfile
));
15800 /* Check if the given VALUE is a valid enum dwarf_calling_convention
15801 constant for a type, according to DWARF5 spec, Table 5.5. */
15804 is_valid_DW_AT_calling_convention_for_type (ULONGEST value
)
15809 case DW_CC_pass_by_reference
:
15810 case DW_CC_pass_by_value
:
15814 complaint (_("unrecognized DW_AT_calling_convention value "
15815 "(%s) for a type"), pulongest (value
));
15820 /* Check if the given VALUE is a valid enum dwarf_calling_convention
15821 constant for a subroutine, according to DWARF5 spec, Table 3.3, and
15822 also according to GNU-specific values (see include/dwarf2.h). */
15825 is_valid_DW_AT_calling_convention_for_subroutine (ULONGEST value
)
15830 case DW_CC_program
:
15834 case DW_CC_GNU_renesas_sh
:
15835 case DW_CC_GNU_borland_fastcall_i386
:
15836 case DW_CC_GDB_IBM_OpenCL
:
15840 complaint (_("unrecognized DW_AT_calling_convention value "
15841 "(%s) for a subroutine"), pulongest (value
));
15846 /* Called when we find the DIE that starts a structure or union scope
15847 (definition) to create a type for the structure or union. Fill in
15848 the type's name and general properties; the members will not be
15849 processed until process_structure_scope. A symbol table entry for
15850 the type will also not be done until process_structure_scope (assuming
15851 the type has a name).
15853 NOTE: we need to call these functions regardless of whether or not the
15854 DIE has a DW_AT_name attribute, since it might be an anonymous
15855 structure or union. This gets the type entered into our set of
15856 user defined types. */
15858 static struct type
*
15859 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
15861 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
15863 struct attribute
*attr
;
15866 /* If the definition of this type lives in .debug_types, read that type.
15867 Don't follow DW_AT_specification though, that will take us back up
15868 the chain and we want to go down. */
15869 attr
= die
->attr (DW_AT_signature
);
15870 if (attr
!= nullptr)
15872 type
= get_DW_AT_signature_type (die
, attr
, cu
);
15874 /* The type's CU may not be the same as CU.
15875 Ensure TYPE is recorded with CU in die_type_hash. */
15876 return set_die_type (die
, type
, cu
);
15879 type
= alloc_type (objfile
);
15880 INIT_CPLUS_SPECIFIC (type
);
15882 name
= dwarf2_name (die
, cu
);
15885 if (cu
->language
== language_cplus
15886 || cu
->language
== language_d
15887 || cu
->language
== language_rust
)
15889 const char *full_name
= dwarf2_full_name (name
, die
, cu
);
15891 /* dwarf2_full_name might have already finished building the DIE's
15892 type. If so, there is no need to continue. */
15893 if (get_die_type (die
, cu
) != NULL
)
15894 return get_die_type (die
, cu
);
15896 type
->set_name (full_name
);
15900 /* The name is already allocated along with this objfile, so
15901 we don't need to duplicate it for the type. */
15902 type
->set_name (name
);
15906 if (die
->tag
== DW_TAG_structure_type
)
15908 type
->set_code (TYPE_CODE_STRUCT
);
15910 else if (die
->tag
== DW_TAG_union_type
)
15912 type
->set_code (TYPE_CODE_UNION
);
15916 type
->set_code (TYPE_CODE_STRUCT
);
15919 if (cu
->language
== language_cplus
&& die
->tag
== DW_TAG_class_type
)
15920 type
->set_is_declared_class (true);
15922 /* Store the calling convention in the type if it's available in
15923 the die. Otherwise the calling convention remains set to
15924 the default value DW_CC_normal. */
15925 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
15926 if (attr
!= nullptr
15927 && is_valid_DW_AT_calling_convention_for_type (attr
->constant_value (0)))
15929 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15930 TYPE_CPLUS_CALLING_CONVENTION (type
)
15931 = (enum dwarf_calling_convention
) (attr
->constant_value (0));
15934 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
15935 if (attr
!= nullptr)
15937 if (attr
->form_is_constant ())
15938 TYPE_LENGTH (type
) = attr
->constant_value (0);
15941 struct dynamic_prop prop
;
15942 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
, cu
->addr_type ()))
15943 type
->add_dyn_prop (DYN_PROP_BYTE_SIZE
, prop
);
15944 TYPE_LENGTH (type
) = 0;
15949 TYPE_LENGTH (type
) = 0;
15952 maybe_set_alignment (cu
, die
, type
);
15954 if (producer_is_icc_lt_14 (cu
) && (TYPE_LENGTH (type
) == 0))
15956 /* ICC<14 does not output the required DW_AT_declaration on
15957 incomplete types, but gives them a size of zero. */
15958 type
->set_is_stub (true);
15961 type
->set_stub_is_supported (true);
15963 if (die_is_declaration (die
, cu
))
15964 type
->set_is_stub (true);
15965 else if (attr
== NULL
&& die
->child
== NULL
15966 && producer_is_realview (cu
->producer
))
15967 /* RealView does not output the required DW_AT_declaration
15968 on incomplete types. */
15969 type
->set_is_stub (true);
15971 /* We need to add the type field to the die immediately so we don't
15972 infinitely recurse when dealing with pointers to the structure
15973 type within the structure itself. */
15974 set_die_type (die
, type
, cu
);
15976 /* set_die_type should be already done. */
15977 set_descriptive_type (type
, die
, cu
);
15982 static void handle_struct_member_die
15983 (struct die_info
*child_die
,
15985 struct field_info
*fi
,
15986 std::vector
<struct symbol
*> *template_args
,
15987 struct dwarf2_cu
*cu
);
15989 /* A helper for handle_struct_member_die that handles
15990 DW_TAG_variant_part. */
15993 handle_variant_part (struct die_info
*die
, struct type
*type
,
15994 struct field_info
*fi
,
15995 std::vector
<struct symbol
*> *template_args
,
15996 struct dwarf2_cu
*cu
)
15998 variant_part_builder
*new_part
;
15999 if (fi
->current_variant_part
== nullptr)
16001 fi
->variant_parts
.emplace_back ();
16002 new_part
= &fi
->variant_parts
.back ();
16004 else if (!fi
->current_variant_part
->processing_variant
)
16006 complaint (_("nested DW_TAG_variant_part seen "
16007 "- DIE at %s [in module %s]"),
16008 sect_offset_str (die
->sect_off
),
16009 objfile_name (cu
->per_objfile
->objfile
));
16014 variant_field
¤t
= fi
->current_variant_part
->variants
.back ();
16015 current
.variant_parts
.emplace_back ();
16016 new_part
= ¤t
.variant_parts
.back ();
16019 /* When we recurse, we want callees to add to this new variant
16021 scoped_restore save_current_variant_part
16022 = make_scoped_restore (&fi
->current_variant_part
, new_part
);
16024 struct attribute
*discr
= dwarf2_attr (die
, DW_AT_discr
, cu
);
16027 /* It's a univariant form, an extension we support. */
16029 else if (discr
->form_is_ref ())
16031 struct dwarf2_cu
*target_cu
= cu
;
16032 struct die_info
*target_die
= follow_die_ref (die
, discr
, &target_cu
);
16034 new_part
->discriminant_offset
= target_die
->sect_off
;
16038 complaint (_("DW_AT_discr does not have DIE reference form"
16039 " - DIE at %s [in module %s]"),
16040 sect_offset_str (die
->sect_off
),
16041 objfile_name (cu
->per_objfile
->objfile
));
16044 for (die_info
*child_die
= die
->child
;
16046 child_die
= child_die
->sibling
)
16047 handle_struct_member_die (child_die
, type
, fi
, template_args
, cu
);
16050 /* A helper for handle_struct_member_die that handles
16054 handle_variant (struct die_info
*die
, struct type
*type
,
16055 struct field_info
*fi
,
16056 std::vector
<struct symbol
*> *template_args
,
16057 struct dwarf2_cu
*cu
)
16059 if (fi
->current_variant_part
== nullptr)
16061 complaint (_("saw DW_TAG_variant outside DW_TAG_variant_part "
16062 "- DIE at %s [in module %s]"),
16063 sect_offset_str (die
->sect_off
),
16064 objfile_name (cu
->per_objfile
->objfile
));
16067 if (fi
->current_variant_part
->processing_variant
)
16069 complaint (_("nested DW_TAG_variant seen "
16070 "- DIE at %s [in module %s]"),
16071 sect_offset_str (die
->sect_off
),
16072 objfile_name (cu
->per_objfile
->objfile
));
16076 scoped_restore save_processing_variant
16077 = make_scoped_restore (&fi
->current_variant_part
->processing_variant
,
16080 fi
->current_variant_part
->variants
.emplace_back ();
16081 variant_field
&variant
= fi
->current_variant_part
->variants
.back ();
16082 variant
.first_field
= fi
->fields
.size ();
16084 /* In a variant we want to get the discriminant and also add a
16085 field for our sole member child. */
16086 struct attribute
*discr
= dwarf2_attr (die
, DW_AT_discr_value
, cu
);
16087 if (discr
== nullptr || !discr
->form_is_constant ())
16089 discr
= dwarf2_attr (die
, DW_AT_discr_list
, cu
);
16090 if (discr
== nullptr || discr
->as_block ()->size
== 0)
16091 variant
.default_branch
= true;
16093 variant
.discr_list_data
= discr
->as_block ();
16096 variant
.discriminant_value
= discr
->constant_value (0);
16098 for (die_info
*variant_child
= die
->child
;
16099 variant_child
!= NULL
;
16100 variant_child
= variant_child
->sibling
)
16101 handle_struct_member_die (variant_child
, type
, fi
, template_args
, cu
);
16103 variant
.last_field
= fi
->fields
.size ();
16106 /* A helper for process_structure_scope that handles a single member
16110 handle_struct_member_die (struct die_info
*child_die
, struct type
*type
,
16111 struct field_info
*fi
,
16112 std::vector
<struct symbol
*> *template_args
,
16113 struct dwarf2_cu
*cu
)
16115 if (child_die
->tag
== DW_TAG_member
16116 || child_die
->tag
== DW_TAG_variable
)
16118 /* NOTE: carlton/2002-11-05: A C++ static data member
16119 should be a DW_TAG_member that is a declaration, but
16120 all versions of G++ as of this writing (so through at
16121 least 3.2.1) incorrectly generate DW_TAG_variable
16122 tags for them instead. */
16123 dwarf2_add_field (fi
, child_die
, cu
);
16125 else if (child_die
->tag
== DW_TAG_subprogram
)
16127 /* Rust doesn't have member functions in the C++ sense.
16128 However, it does emit ordinary functions as children
16129 of a struct DIE. */
16130 if (cu
->language
== language_rust
)
16131 read_func_scope (child_die
, cu
);
16134 /* C++ member function. */
16135 dwarf2_add_member_fn (fi
, child_die
, type
, cu
);
16138 else if (child_die
->tag
== DW_TAG_inheritance
)
16140 /* C++ base class field. */
16141 dwarf2_add_field (fi
, child_die
, cu
);
16143 else if (type_can_define_types (child_die
))
16144 dwarf2_add_type_defn (fi
, child_die
, cu
);
16145 else if (child_die
->tag
== DW_TAG_template_type_param
16146 || child_die
->tag
== DW_TAG_template_value_param
)
16148 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
16151 template_args
->push_back (arg
);
16153 else if (child_die
->tag
== DW_TAG_variant_part
)
16154 handle_variant_part (child_die
, type
, fi
, template_args
, cu
);
16155 else if (child_die
->tag
== DW_TAG_variant
)
16156 handle_variant (child_die
, type
, fi
, template_args
, cu
);
16159 /* Finish creating a structure or union type, including filling in
16160 its members and creating a symbol for it. */
16163 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
16165 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
16166 struct die_info
*child_die
;
16169 type
= get_die_type (die
, cu
);
16171 type
= read_structure_type (die
, cu
);
16173 bool has_template_parameters
= false;
16174 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
16176 struct field_info fi
;
16177 std::vector
<struct symbol
*> template_args
;
16179 child_die
= die
->child
;
16181 while (child_die
&& child_die
->tag
)
16183 handle_struct_member_die (child_die
, type
, &fi
, &template_args
, cu
);
16184 child_die
= child_die
->sibling
;
16187 /* Attach template arguments to type. */
16188 if (!template_args
.empty ())
16190 has_template_parameters
= true;
16191 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
16192 TYPE_N_TEMPLATE_ARGUMENTS (type
) = template_args
.size ();
16193 TYPE_TEMPLATE_ARGUMENTS (type
)
16194 = XOBNEWVEC (&objfile
->objfile_obstack
,
16196 TYPE_N_TEMPLATE_ARGUMENTS (type
));
16197 memcpy (TYPE_TEMPLATE_ARGUMENTS (type
),
16198 template_args
.data (),
16199 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
16200 * sizeof (struct symbol
*)));
16203 /* Attach fields and member functions to the type. */
16204 if (fi
.nfields () > 0)
16205 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
16206 if (!fi
.fnfieldlists
.empty ())
16208 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
16210 /* Get the type which refers to the base class (possibly this
16211 class itself) which contains the vtable pointer for the current
16212 class from the DW_AT_containing_type attribute. This use of
16213 DW_AT_containing_type is a GNU extension. */
16215 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
16217 struct type
*t
= die_containing_type (die
, cu
);
16219 set_type_vptr_basetype (type
, t
);
16224 /* Our own class provides vtbl ptr. */
16225 for (i
= t
->num_fields () - 1;
16226 i
>= TYPE_N_BASECLASSES (t
);
16229 const char *fieldname
= TYPE_FIELD_NAME (t
, i
);
16231 if (is_vtable_name (fieldname
, cu
))
16233 set_type_vptr_fieldno (type
, i
);
16238 /* Complain if virtual function table field not found. */
16239 if (i
< TYPE_N_BASECLASSES (t
))
16240 complaint (_("virtual function table pointer "
16241 "not found when defining class '%s'"),
16242 type
->name () ? type
->name () : "");
16246 set_type_vptr_fieldno (type
, TYPE_VPTR_FIELDNO (t
));
16249 else if (cu
->producer
16250 && startswith (cu
->producer
, "IBM(R) XL C/C++ Advanced Edition"))
16252 /* The IBM XLC compiler does not provide direct indication
16253 of the containing type, but the vtable pointer is
16254 always named __vfp. */
16258 for (i
= type
->num_fields () - 1;
16259 i
>= TYPE_N_BASECLASSES (type
);
16262 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
16264 set_type_vptr_fieldno (type
, i
);
16265 set_type_vptr_basetype (type
, type
);
16272 /* Copy fi.typedef_field_list linked list elements content into the
16273 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
16274 if (!fi
.typedef_field_list
.empty ())
16276 int count
= fi
.typedef_field_list
.size ();
16278 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
16279 TYPE_TYPEDEF_FIELD_ARRAY (type
)
16280 = ((struct decl_field
*)
16282 sizeof (TYPE_TYPEDEF_FIELD (type
, 0)) * count
));
16283 TYPE_TYPEDEF_FIELD_COUNT (type
) = count
;
16285 for (int i
= 0; i
< fi
.typedef_field_list
.size (); ++i
)
16286 TYPE_TYPEDEF_FIELD (type
, i
) = fi
.typedef_field_list
[i
];
16289 /* Copy fi.nested_types_list linked list elements content into the
16290 allocated array TYPE_NESTED_TYPES_ARRAY (type). */
16291 if (!fi
.nested_types_list
.empty () && cu
->language
!= language_ada
)
16293 int count
= fi
.nested_types_list
.size ();
16295 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
16296 TYPE_NESTED_TYPES_ARRAY (type
)
16297 = ((struct decl_field
*)
16298 TYPE_ALLOC (type
, sizeof (struct decl_field
) * count
));
16299 TYPE_NESTED_TYPES_COUNT (type
) = count
;
16301 for (int i
= 0; i
< fi
.nested_types_list
.size (); ++i
)
16302 TYPE_NESTED_TYPES_FIELD (type
, i
) = fi
.nested_types_list
[i
];
16306 quirk_gcc_member_function_pointer (type
, objfile
);
16307 if (cu
->language
== language_rust
&& die
->tag
== DW_TAG_union_type
)
16308 cu
->rust_unions
.push_back (type
);
16309 else if (cu
->language
== language_ada
)
16310 quirk_ada_thick_pointer_struct (die
, cu
, type
);
16312 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
16313 snapshots) has been known to create a die giving a declaration
16314 for a class that has, as a child, a die giving a definition for a
16315 nested class. So we have to process our children even if the
16316 current die is a declaration. Normally, of course, a declaration
16317 won't have any children at all. */
16319 child_die
= die
->child
;
16321 while (child_die
!= NULL
&& child_die
->tag
)
16323 if (child_die
->tag
== DW_TAG_member
16324 || child_die
->tag
== DW_TAG_variable
16325 || child_die
->tag
== DW_TAG_inheritance
16326 || child_die
->tag
== DW_TAG_template_value_param
16327 || child_die
->tag
== DW_TAG_template_type_param
)
16332 process_die (child_die
, cu
);
16334 child_die
= child_die
->sibling
;
16337 /* Do not consider external references. According to the DWARF standard,
16338 these DIEs are identified by the fact that they have no byte_size
16339 attribute, and a declaration attribute. */
16340 if (dwarf2_attr (die
, DW_AT_byte_size
, cu
) != NULL
16341 || !die_is_declaration (die
, cu
)
16342 || dwarf2_attr (die
, DW_AT_signature
, cu
) != NULL
)
16344 struct symbol
*sym
= new_symbol (die
, type
, cu
);
16346 if (has_template_parameters
)
16348 struct symtab
*symtab
;
16349 if (sym
!= nullptr)
16350 symtab
= symbol_symtab (sym
);
16351 else if (cu
->line_header
!= nullptr)
16353 /* Any related symtab will do. */
16355 = cu
->line_header
->file_names ()[0].symtab
;
16360 complaint (_("could not find suitable "
16361 "symtab for template parameter"
16362 " - DIE at %s [in module %s]"),
16363 sect_offset_str (die
->sect_off
),
16364 objfile_name (objfile
));
16367 if (symtab
!= nullptr)
16369 /* Make sure that the symtab is set on the new symbols.
16370 Even though they don't appear in this symtab directly,
16371 other parts of gdb assume that symbols do, and this is
16372 reasonably true. */
16373 for (int i
= 0; i
< TYPE_N_TEMPLATE_ARGUMENTS (type
); ++i
)
16374 symbol_set_symtab (TYPE_TEMPLATE_ARGUMENT (type
, i
), symtab
);
16380 /* Assuming DIE is an enumeration type, and TYPE is its associated
16381 type, update TYPE using some information only available in DIE's
16382 children. In particular, the fields are computed. */
16385 update_enumeration_type_from_children (struct die_info
*die
,
16387 struct dwarf2_cu
*cu
)
16389 struct die_info
*child_die
;
16390 int unsigned_enum
= 1;
16393 auto_obstack obstack
;
16394 std::vector
<struct field
> fields
;
16396 for (child_die
= die
->child
;
16397 child_die
!= NULL
&& child_die
->tag
;
16398 child_die
= child_die
->sibling
)
16400 struct attribute
*attr
;
16402 const gdb_byte
*bytes
;
16403 struct dwarf2_locexpr_baton
*baton
;
16406 if (child_die
->tag
!= DW_TAG_enumerator
)
16409 attr
= dwarf2_attr (child_die
, DW_AT_const_value
, cu
);
16413 name
= dwarf2_name (child_die
, cu
);
16415 name
= "<anonymous enumerator>";
16417 dwarf2_const_value_attr (attr
, type
, name
, &obstack
, cu
,
16418 &value
, &bytes
, &baton
);
16426 if (count_one_bits_ll (value
) >= 2)
16430 fields
.emplace_back ();
16431 struct field
&field
= fields
.back ();
16432 FIELD_NAME (field
) = dwarf2_physname (name
, child_die
, cu
);
16433 SET_FIELD_ENUMVAL (field
, value
);
16436 if (!fields
.empty ())
16438 type
->set_num_fields (fields
.size ());
16441 TYPE_ALLOC (type
, sizeof (struct field
) * fields
.size ()));
16442 memcpy (type
->fields (), fields
.data (),
16443 sizeof (struct field
) * fields
.size ());
16447 type
->set_is_unsigned (true);
16450 type
->set_is_flag_enum (true);
16453 /* Given a DW_AT_enumeration_type die, set its type. We do not
16454 complete the type's fields yet, or create any symbols. */
16456 static struct type
*
16457 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16459 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
16461 struct attribute
*attr
;
16464 /* If the definition of this type lives in .debug_types, read that type.
16465 Don't follow DW_AT_specification though, that will take us back up
16466 the chain and we want to go down. */
16467 attr
= die
->attr (DW_AT_signature
);
16468 if (attr
!= nullptr)
16470 type
= get_DW_AT_signature_type (die
, attr
, cu
);
16472 /* The type's CU may not be the same as CU.
16473 Ensure TYPE is recorded with CU in die_type_hash. */
16474 return set_die_type (die
, type
, cu
);
16477 type
= alloc_type (objfile
);
16479 type
->set_code (TYPE_CODE_ENUM
);
16480 name
= dwarf2_full_name (NULL
, die
, cu
);
16482 type
->set_name (name
);
16484 attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
16487 struct type
*underlying_type
= die_type (die
, cu
);
16489 TYPE_TARGET_TYPE (type
) = underlying_type
;
16492 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16493 if (attr
!= nullptr)
16495 TYPE_LENGTH (type
) = attr
->constant_value (0);
16499 TYPE_LENGTH (type
) = 0;
16502 maybe_set_alignment (cu
, die
, type
);
16504 /* The enumeration DIE can be incomplete. In Ada, any type can be
16505 declared as private in the package spec, and then defined only
16506 inside the package body. Such types are known as Taft Amendment
16507 Types. When another package uses such a type, an incomplete DIE
16508 may be generated by the compiler. */
16509 if (die_is_declaration (die
, cu
))
16510 type
->set_is_stub (true);
16512 /* If this type has an underlying type that is not a stub, then we
16513 may use its attributes. We always use the "unsigned" attribute
16514 in this situation, because ordinarily we guess whether the type
16515 is unsigned -- but the guess can be wrong and the underlying type
16516 can tell us the reality. However, we defer to a local size
16517 attribute if one exists, because this lets the compiler override
16518 the underlying type if needed. */
16519 if (TYPE_TARGET_TYPE (type
) != NULL
&& !TYPE_TARGET_TYPE (type
)->is_stub ())
16521 struct type
*underlying_type
= TYPE_TARGET_TYPE (type
);
16522 underlying_type
= check_typedef (underlying_type
);
16524 type
->set_is_unsigned (underlying_type
->is_unsigned ());
16526 if (TYPE_LENGTH (type
) == 0)
16527 TYPE_LENGTH (type
) = TYPE_LENGTH (underlying_type
);
16529 if (TYPE_RAW_ALIGN (type
) == 0
16530 && TYPE_RAW_ALIGN (underlying_type
) != 0)
16531 set_type_align (type
, TYPE_RAW_ALIGN (underlying_type
));
16534 type
->set_is_declared_class (dwarf2_flag_true_p (die
, DW_AT_enum_class
, cu
));
16536 set_die_type (die
, type
, cu
);
16538 /* Finish the creation of this type by using the enum's children.
16539 Note that, as usual, this must come after set_die_type to avoid
16540 infinite recursion when trying to compute the names of the
16542 update_enumeration_type_from_children (die
, type
, cu
);
16547 /* Given a pointer to a die which begins an enumeration, process all
16548 the dies that define the members of the enumeration, and create the
16549 symbol for the enumeration type.
16551 NOTE: We reverse the order of the element list. */
16554 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
16556 struct type
*this_type
;
16558 this_type
= get_die_type (die
, cu
);
16559 if (this_type
== NULL
)
16560 this_type
= read_enumeration_type (die
, cu
);
16562 if (die
->child
!= NULL
)
16564 struct die_info
*child_die
;
16567 child_die
= die
->child
;
16568 while (child_die
&& child_die
->tag
)
16570 if (child_die
->tag
!= DW_TAG_enumerator
)
16572 process_die (child_die
, cu
);
16576 name
= dwarf2_name (child_die
, cu
);
16578 new_symbol (child_die
, this_type
, cu
);
16581 child_die
= child_die
->sibling
;
16585 /* If we are reading an enum from a .debug_types unit, and the enum
16586 is a declaration, and the enum is not the signatured type in the
16587 unit, then we do not want to add a symbol for it. Adding a
16588 symbol would in some cases obscure the true definition of the
16589 enum, giving users an incomplete type when the definition is
16590 actually available. Note that we do not want to do this for all
16591 enums which are just declarations, because C++0x allows forward
16592 enum declarations. */
16593 if (cu
->per_cu
->is_debug_types
16594 && die_is_declaration (die
, cu
))
16596 struct signatured_type
*sig_type
;
16598 sig_type
= (struct signatured_type
*) cu
->per_cu
;
16599 gdb_assert (to_underlying (sig_type
->type_offset_in_section
) != 0);
16600 if (sig_type
->type_offset_in_section
!= die
->sect_off
)
16604 new_symbol (die
, this_type
, cu
);
16607 /* Helper function for quirk_ada_thick_pointer that examines a bounds
16608 expression for an index type and finds the corresponding field
16609 offset in the hidden "P_BOUNDS" structure. Returns true on success
16610 and updates *FIELD, false if it fails to recognize an
16614 recognize_bound_expression (struct die_info
*die
, enum dwarf_attribute name
,
16615 int *bounds_offset
, struct field
*field
,
16616 struct dwarf2_cu
*cu
)
16618 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
16619 if (attr
== nullptr || !attr
->form_is_block ())
16622 const struct dwarf_block
*block
= attr
->as_block ();
16623 const gdb_byte
*start
= block
->data
;
16624 const gdb_byte
*end
= block
->data
+ block
->size
;
16626 /* The expression to recognize generally looks like:
16628 (DW_OP_push_object_address; DW_OP_plus_uconst: 8; DW_OP_deref;
16629 DW_OP_plus_uconst: 4; DW_OP_deref_size: 4)
16631 However, the second "plus_uconst" may be missing:
16633 (DW_OP_push_object_address; DW_OP_plus_uconst: 8; DW_OP_deref;
16634 DW_OP_deref_size: 4)
16636 This happens when the field is at the start of the structure.
16638 Also, the final deref may not be sized:
16640 (DW_OP_push_object_address; DW_OP_plus_uconst: 4; DW_OP_deref;
16643 This happens when the size of the index type happens to be the
16644 same as the architecture's word size. This can occur with or
16645 without the second plus_uconst. */
16647 if (end
- start
< 2)
16649 if (*start
++ != DW_OP_push_object_address
)
16651 if (*start
++ != DW_OP_plus_uconst
)
16654 uint64_t this_bound_off
;
16655 start
= gdb_read_uleb128 (start
, end
, &this_bound_off
);
16656 if (start
== nullptr || (int) this_bound_off
!= this_bound_off
)
16658 /* Update *BOUNDS_OFFSET if needed, or alternatively verify that it
16659 is consistent among all bounds. */
16660 if (*bounds_offset
== -1)
16661 *bounds_offset
= this_bound_off
;
16662 else if (*bounds_offset
!= this_bound_off
)
16665 if (start
== end
|| *start
++ != DW_OP_deref
)
16671 else if (*start
== DW_OP_deref_size
|| *start
== DW_OP_deref
)
16673 /* This means an offset of 0. */
16675 else if (*start
++ != DW_OP_plus_uconst
)
16679 /* The size is the parameter to DW_OP_plus_uconst. */
16681 start
= gdb_read_uleb128 (start
, end
, &val
);
16682 if (start
== nullptr)
16684 if ((int) val
!= val
)
16693 if (*start
== DW_OP_deref_size
)
16695 start
= gdb_read_uleb128 (start
+ 1, end
, &size
);
16696 if (start
== nullptr)
16699 else if (*start
== DW_OP_deref
)
16701 size
= cu
->header
.addr_size
;
16707 SET_FIELD_BITPOS (*field
, 8 * offset
);
16708 if (size
!= TYPE_LENGTH (field
->type ()))
16709 FIELD_BITSIZE (*field
) = 8 * size
;
16714 /* With -fgnat-encodings=minimal, gcc will emit some unusual DWARF for
16715 some kinds of Ada arrays:
16717 <1><11db>: Abbrev Number: 7 (DW_TAG_array_type)
16718 <11dc> DW_AT_name : (indirect string, offset: 0x1bb8): string
16719 <11e0> DW_AT_data_location: 2 byte block: 97 6
16720 (DW_OP_push_object_address; DW_OP_deref)
16721 <11e3> DW_AT_type : <0x1173>
16722 <11e7> DW_AT_sibling : <0x1201>
16723 <2><11eb>: Abbrev Number: 8 (DW_TAG_subrange_type)
16724 <11ec> DW_AT_type : <0x1206>
16725 <11f0> DW_AT_lower_bound : 6 byte block: 97 23 8 6 94 4
16726 (DW_OP_push_object_address; DW_OP_plus_uconst: 8; DW_OP_deref;
16727 DW_OP_deref_size: 4)
16728 <11f7> DW_AT_upper_bound : 8 byte block: 97 23 8 6 23 4 94 4
16729 (DW_OP_push_object_address; DW_OP_plus_uconst: 8; DW_OP_deref;
16730 DW_OP_plus_uconst: 4; DW_OP_deref_size: 4)
16732 This actually represents a "thick pointer", which is a structure
16733 with two elements: one that is a pointer to the array data, and one
16734 that is a pointer to another structure; this second structure holds
16737 This returns a new type on success, or nullptr if this didn't
16738 recognize the type. */
16740 static struct type
*
16741 quirk_ada_thick_pointer (struct die_info
*die
, struct dwarf2_cu
*cu
,
16744 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_data_location
, cu
);
16745 /* So far we've only seen this with block form. */
16746 if (attr
== nullptr || !attr
->form_is_block ())
16749 /* Note that this will fail if the structure layout is changed by
16750 the compiler. However, we have no good way to recognize some
16751 other layout, because we don't know what expression the compiler
16752 might choose to emit should this happen. */
16753 struct dwarf_block
*blk
= attr
->as_block ();
16755 || blk
->data
[0] != DW_OP_push_object_address
16756 || blk
->data
[1] != DW_OP_deref
)
16759 int bounds_offset
= -1;
16760 int max_align
= -1;
16761 std::vector
<struct field
> range_fields
;
16762 for (struct die_info
*child_die
= die
->child
;
16764 child_die
= child_die
->sibling
)
16766 if (child_die
->tag
== DW_TAG_subrange_type
)
16768 struct type
*underlying
= read_subrange_index_type (child_die
, cu
);
16770 int this_align
= type_align (underlying
);
16771 if (this_align
> max_align
)
16772 max_align
= this_align
;
16774 range_fields
.emplace_back ();
16775 range_fields
.emplace_back ();
16777 struct field
&lower
= range_fields
[range_fields
.size () - 2];
16778 struct field
&upper
= range_fields
[range_fields
.size () - 1];
16780 lower
.set_type (underlying
);
16781 FIELD_ARTIFICIAL (lower
) = 1;
16783 upper
.set_type (underlying
);
16784 FIELD_ARTIFICIAL (upper
) = 1;
16786 if (!recognize_bound_expression (child_die
, DW_AT_lower_bound
,
16787 &bounds_offset
, &lower
, cu
)
16788 || !recognize_bound_expression (child_die
, DW_AT_upper_bound
,
16789 &bounds_offset
, &upper
, cu
))
16794 /* This shouldn't really happen, but double-check that we found
16795 where the bounds are stored. */
16796 if (bounds_offset
== -1)
16799 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
16800 for (int i
= 0; i
< range_fields
.size (); i
+= 2)
16804 /* Set the name of each field in the bounds. */
16805 xsnprintf (name
, sizeof (name
), "LB%d", i
/ 2);
16806 FIELD_NAME (range_fields
[i
]) = objfile
->intern (name
);
16807 xsnprintf (name
, sizeof (name
), "UB%d", i
/ 2);
16808 FIELD_NAME (range_fields
[i
+ 1]) = objfile
->intern (name
);
16811 struct type
*bounds
= alloc_type (objfile
);
16812 bounds
->set_code (TYPE_CODE_STRUCT
);
16814 bounds
->set_num_fields (range_fields
.size ());
16816 ((struct field
*) TYPE_ALLOC (bounds
, (bounds
->num_fields ()
16817 * sizeof (struct field
))));
16818 memcpy (bounds
->fields (), range_fields
.data (),
16819 bounds
->num_fields () * sizeof (struct field
));
16821 int last_fieldno
= range_fields
.size () - 1;
16822 int bounds_size
= (TYPE_FIELD_BITPOS (bounds
, last_fieldno
) / 8
16823 + TYPE_LENGTH (bounds
->field (last_fieldno
).type ()));
16824 TYPE_LENGTH (bounds
) = align_up (bounds_size
, max_align
);
16826 /* Rewrite the existing array type in place. Specifically, we
16827 remove any dynamic properties we might have read, and we replace
16828 the index types. */
16829 struct type
*iter
= type
;
16830 for (int i
= 0; i
< range_fields
.size (); i
+= 2)
16832 gdb_assert (iter
->code () == TYPE_CODE_ARRAY
);
16833 iter
->main_type
->dyn_prop_list
= nullptr;
16834 iter
->set_index_type
16835 (create_static_range_type (NULL
, bounds
->field (i
).type (), 1, 0));
16836 iter
= TYPE_TARGET_TYPE (iter
);
16839 struct type
*result
= alloc_type (objfile
);
16840 result
->set_code (TYPE_CODE_STRUCT
);
16842 result
->set_num_fields (2);
16844 ((struct field
*) TYPE_ZALLOC (result
, (result
->num_fields ()
16845 * sizeof (struct field
))));
16847 /* The names are chosen to coincide with what the compiler does with
16848 -fgnat-encodings=all, which the Ada code in gdb already
16850 TYPE_FIELD_NAME (result
, 0) = "P_ARRAY";
16851 result
->field (0).set_type (lookup_pointer_type (type
));
16853 TYPE_FIELD_NAME (result
, 1) = "P_BOUNDS";
16854 result
->field (1).set_type (lookup_pointer_type (bounds
));
16855 SET_FIELD_BITPOS (result
->field (1), 8 * bounds_offset
);
16857 result
->set_name (type
->name ());
16858 TYPE_LENGTH (result
) = (TYPE_LENGTH (result
->field (0).type ())
16859 + TYPE_LENGTH (result
->field (1).type ()));
16864 /* Extract all information from a DW_TAG_array_type DIE and put it in
16865 the DIE's type field. For now, this only handles one dimensional
16868 static struct type
*
16869 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16871 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
16872 struct die_info
*child_die
;
16874 struct type
*element_type
, *range_type
, *index_type
;
16875 struct attribute
*attr
;
16877 struct dynamic_prop
*byte_stride_prop
= NULL
;
16878 unsigned int bit_stride
= 0;
16880 element_type
= die_type (die
, cu
);
16882 /* The die_type call above may have already set the type for this DIE. */
16883 type
= get_die_type (die
, cu
);
16887 attr
= dwarf2_attr (die
, DW_AT_byte_stride
, cu
);
16891 struct type
*prop_type
= cu
->addr_sized_int_type (false);
16894 = (struct dynamic_prop
*) alloca (sizeof (struct dynamic_prop
));
16895 stride_ok
= attr_to_dynamic_prop (attr
, die
, cu
, byte_stride_prop
,
16899 complaint (_("unable to read array DW_AT_byte_stride "
16900 " - DIE at %s [in module %s]"),
16901 sect_offset_str (die
->sect_off
),
16902 objfile_name (cu
->per_objfile
->objfile
));
16903 /* Ignore this attribute. We will likely not be able to print
16904 arrays of this type correctly, but there is little we can do
16905 to help if we cannot read the attribute's value. */
16906 byte_stride_prop
= NULL
;
16910 attr
= dwarf2_attr (die
, DW_AT_bit_stride
, cu
);
16912 bit_stride
= attr
->constant_value (0);
16914 /* Irix 6.2 native cc creates array types without children for
16915 arrays with unspecified length. */
16916 if (die
->child
== NULL
)
16918 index_type
= objfile_type (objfile
)->builtin_int
;
16919 range_type
= create_static_range_type (NULL
, index_type
, 0, -1);
16920 type
= create_array_type_with_stride (NULL
, element_type
, range_type
,
16921 byte_stride_prop
, bit_stride
);
16922 return set_die_type (die
, type
, cu
);
16925 std::vector
<struct type
*> range_types
;
16926 child_die
= die
->child
;
16927 while (child_die
&& child_die
->tag
)
16929 if (child_die
->tag
== DW_TAG_subrange_type
)
16931 struct type
*child_type
= read_type_die (child_die
, cu
);
16933 if (child_type
!= NULL
)
16935 /* The range type was succesfully read. Save it for the
16936 array type creation. */
16937 range_types
.push_back (child_type
);
16940 child_die
= child_die
->sibling
;
16943 if (range_types
.empty ())
16945 complaint (_("unable to find array range - DIE at %s [in module %s]"),
16946 sect_offset_str (die
->sect_off
),
16947 objfile_name (cu
->per_objfile
->objfile
));
16951 /* Dwarf2 dimensions are output from left to right, create the
16952 necessary array types in backwards order. */
16954 type
= element_type
;
16956 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
16960 while (i
< range_types
.size ())
16962 type
= create_array_type_with_stride (NULL
, type
, range_types
[i
++],
16963 byte_stride_prop
, bit_stride
);
16965 byte_stride_prop
= nullptr;
16970 size_t ndim
= range_types
.size ();
16973 type
= create_array_type_with_stride (NULL
, type
, range_types
[ndim
],
16974 byte_stride_prop
, bit_stride
);
16976 byte_stride_prop
= nullptr;
16980 gdb_assert (type
!= element_type
);
16982 /* Understand Dwarf2 support for vector types (like they occur on
16983 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
16984 array type. This is not part of the Dwarf2/3 standard yet, but a
16985 custom vendor extension. The main difference between a regular
16986 array and the vector variant is that vectors are passed by value
16988 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
16989 if (attr
!= nullptr)
16990 make_vector_type (type
);
16992 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
16993 implementation may choose to implement triple vectors using this
16995 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16996 if (attr
!= nullptr && attr
->form_is_unsigned ())
16998 if (attr
->as_unsigned () >= TYPE_LENGTH (type
))
16999 TYPE_LENGTH (type
) = attr
->as_unsigned ();
17001 complaint (_("DW_AT_byte_size for array type smaller "
17002 "than the total size of elements"));
17005 name
= dwarf2_name (die
, cu
);
17007 type
->set_name (name
);
17009 maybe_set_alignment (cu
, die
, type
);
17011 struct type
*replacement_type
= nullptr;
17012 if (cu
->language
== language_ada
)
17014 replacement_type
= quirk_ada_thick_pointer (die
, cu
, type
);
17015 if (replacement_type
!= nullptr)
17016 type
= replacement_type
;
17019 /* Install the type in the die. */
17020 set_die_type (die
, type
, cu
, replacement_type
!= nullptr);
17022 /* set_die_type should be already done. */
17023 set_descriptive_type (type
, die
, cu
);
17028 static enum dwarf_array_dim_ordering
17029 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
17031 struct attribute
*attr
;
17033 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
17035 if (attr
!= nullptr)
17037 LONGEST val
= attr
->constant_value (-1);
17038 if (val
== DW_ORD_row_major
|| val
== DW_ORD_col_major
)
17039 return (enum dwarf_array_dim_ordering
) val
;
17042 /* GNU F77 is a special case, as at 08/2004 array type info is the
17043 opposite order to the dwarf2 specification, but data is still
17044 laid out as per normal fortran.
17046 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
17047 version checking. */
17049 if (cu
->language
== language_fortran
17050 && cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
17052 return DW_ORD_row_major
;
17055 switch (cu
->language_defn
->array_ordering ())
17057 case array_column_major
:
17058 return DW_ORD_col_major
;
17059 case array_row_major
:
17061 return DW_ORD_row_major
;
17065 /* Extract all information from a DW_TAG_set_type DIE and put it in
17066 the DIE's type field. */
17068 static struct type
*
17069 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17071 struct type
*domain_type
, *set_type
;
17072 struct attribute
*attr
;
17074 domain_type
= die_type (die
, cu
);
17076 /* The die_type call above may have already set the type for this DIE. */
17077 set_type
= get_die_type (die
, cu
);
17081 set_type
= create_set_type (NULL
, domain_type
);
17083 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17084 if (attr
!= nullptr && attr
->form_is_unsigned ())
17085 TYPE_LENGTH (set_type
) = attr
->as_unsigned ();
17087 maybe_set_alignment (cu
, die
, set_type
);
17089 return set_die_type (die
, set_type
, cu
);
17092 /* A helper for read_common_block that creates a locexpr baton.
17093 SYM is the symbol which we are marking as computed.
17094 COMMON_DIE is the DIE for the common block.
17095 COMMON_LOC is the location expression attribute for the common
17097 MEMBER_LOC is the location expression attribute for the particular
17098 member of the common block that we are processing.
17099 CU is the CU from which the above come. */
17102 mark_common_block_symbol_computed (struct symbol
*sym
,
17103 struct die_info
*common_die
,
17104 struct attribute
*common_loc
,
17105 struct attribute
*member_loc
,
17106 struct dwarf2_cu
*cu
)
17108 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
17109 struct objfile
*objfile
= per_objfile
->objfile
;
17110 struct dwarf2_locexpr_baton
*baton
;
17112 unsigned int cu_off
;
17113 enum bfd_endian byte_order
= gdbarch_byte_order (objfile
->arch ());
17114 LONGEST offset
= 0;
17116 gdb_assert (common_loc
&& member_loc
);
17117 gdb_assert (common_loc
->form_is_block ());
17118 gdb_assert (member_loc
->form_is_block ()
17119 || member_loc
->form_is_constant ());
17121 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
17122 baton
->per_objfile
= per_objfile
;
17123 baton
->per_cu
= cu
->per_cu
;
17124 gdb_assert (baton
->per_cu
);
17126 baton
->size
= 5 /* DW_OP_call4 */ + 1 /* DW_OP_plus */;
17128 if (member_loc
->form_is_constant ())
17130 offset
= member_loc
->constant_value (0);
17131 baton
->size
+= 1 /* DW_OP_addr */ + cu
->header
.addr_size
;
17134 baton
->size
+= member_loc
->as_block ()->size
;
17136 ptr
= (gdb_byte
*) obstack_alloc (&objfile
->objfile_obstack
, baton
->size
);
17139 *ptr
++ = DW_OP_call4
;
17140 cu_off
= common_die
->sect_off
- cu
->per_cu
->sect_off
;
17141 store_unsigned_integer (ptr
, 4, byte_order
, cu_off
);
17144 if (member_loc
->form_is_constant ())
17146 *ptr
++ = DW_OP_addr
;
17147 store_unsigned_integer (ptr
, cu
->header
.addr_size
, byte_order
, offset
);
17148 ptr
+= cu
->header
.addr_size
;
17152 /* We have to copy the data here, because DW_OP_call4 will only
17153 use a DW_AT_location attribute. */
17154 struct dwarf_block
*block
= member_loc
->as_block ();
17155 memcpy (ptr
, block
->data
, block
->size
);
17156 ptr
+= block
->size
;
17159 *ptr
++ = DW_OP_plus
;
17160 gdb_assert (ptr
- baton
->data
== baton
->size
);
17162 SYMBOL_LOCATION_BATON (sym
) = baton
;
17163 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
17166 /* Create appropriate locally-scoped variables for all the
17167 DW_TAG_common_block entries. Also create a struct common_block
17168 listing all such variables for `info common'. COMMON_BLOCK_DOMAIN
17169 is used to separate the common blocks name namespace from regular
17173 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
17175 struct attribute
*attr
;
17177 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
17178 if (attr
!= nullptr)
17180 /* Support the .debug_loc offsets. */
17181 if (attr
->form_is_block ())
17185 else if (attr
->form_is_section_offset ())
17187 dwarf2_complex_location_expr_complaint ();
17192 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
17193 "common block member");
17198 if (die
->child
!= NULL
)
17200 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17201 struct die_info
*child_die
;
17202 size_t n_entries
= 0, size
;
17203 struct common_block
*common_block
;
17204 struct symbol
*sym
;
17206 for (child_die
= die
->child
;
17207 child_die
&& child_die
->tag
;
17208 child_die
= child_die
->sibling
)
17211 size
= (sizeof (struct common_block
)
17212 + (n_entries
- 1) * sizeof (struct symbol
*));
17214 = (struct common_block
*) obstack_alloc (&objfile
->objfile_obstack
,
17216 memset (common_block
->contents
, 0, n_entries
* sizeof (struct symbol
*));
17217 common_block
->n_entries
= 0;
17219 for (child_die
= die
->child
;
17220 child_die
&& child_die
->tag
;
17221 child_die
= child_die
->sibling
)
17223 /* Create the symbol in the DW_TAG_common_block block in the current
17225 sym
= new_symbol (child_die
, NULL
, cu
);
17228 struct attribute
*member_loc
;
17230 common_block
->contents
[common_block
->n_entries
++] = sym
;
17232 member_loc
= dwarf2_attr (child_die
, DW_AT_data_member_location
,
17236 /* GDB has handled this for a long time, but it is
17237 not specified by DWARF. It seems to have been
17238 emitted by gfortran at least as recently as:
17239 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=23057. */
17240 complaint (_("Variable in common block has "
17241 "DW_AT_data_member_location "
17242 "- DIE at %s [in module %s]"),
17243 sect_offset_str (child_die
->sect_off
),
17244 objfile_name (objfile
));
17246 if (member_loc
->form_is_section_offset ())
17247 dwarf2_complex_location_expr_complaint ();
17248 else if (member_loc
->form_is_constant ()
17249 || member_loc
->form_is_block ())
17251 if (attr
!= nullptr)
17252 mark_common_block_symbol_computed (sym
, die
, attr
,
17256 dwarf2_complex_location_expr_complaint ();
17261 sym
= new_symbol (die
, objfile_type (objfile
)->builtin_void
, cu
);
17262 SYMBOL_VALUE_COMMON_BLOCK (sym
) = common_block
;
17266 /* Create a type for a C++ namespace. */
17268 static struct type
*
17269 read_namespace_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17271 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17272 const char *previous_prefix
, *name
;
17276 /* For extensions, reuse the type of the original namespace. */
17277 if (dwarf2_attr (die
, DW_AT_extension
, cu
) != NULL
)
17279 struct die_info
*ext_die
;
17280 struct dwarf2_cu
*ext_cu
= cu
;
17282 ext_die
= dwarf2_extension (die
, &ext_cu
);
17283 type
= read_type_die (ext_die
, ext_cu
);
17285 /* EXT_CU may not be the same as CU.
17286 Ensure TYPE is recorded with CU in die_type_hash. */
17287 return set_die_type (die
, type
, cu
);
17290 name
= namespace_name (die
, &is_anonymous
, cu
);
17292 /* Now build the name of the current namespace. */
17294 previous_prefix
= determine_prefix (die
, cu
);
17295 if (previous_prefix
[0] != '\0')
17296 name
= typename_concat (&objfile
->objfile_obstack
,
17297 previous_prefix
, name
, 0, cu
);
17299 /* Create the type. */
17300 type
= init_type (objfile
, TYPE_CODE_NAMESPACE
, 0, name
);
17302 return set_die_type (die
, type
, cu
);
17305 /* Read a namespace scope. */
17308 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
17310 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17313 /* Add a symbol associated to this if we haven't seen the namespace
17314 before. Also, add a using directive if it's an anonymous
17317 if (dwarf2_attr (die
, DW_AT_extension
, cu
) == NULL
)
17321 type
= read_type_die (die
, cu
);
17322 new_symbol (die
, type
, cu
);
17324 namespace_name (die
, &is_anonymous
, cu
);
17327 const char *previous_prefix
= determine_prefix (die
, cu
);
17329 std::vector
<const char *> excludes
;
17330 add_using_directive (using_directives (cu
),
17331 previous_prefix
, type
->name (), NULL
,
17332 NULL
, excludes
, 0, &objfile
->objfile_obstack
);
17336 if (die
->child
!= NULL
)
17338 struct die_info
*child_die
= die
->child
;
17340 while (child_die
&& child_die
->tag
)
17342 process_die (child_die
, cu
);
17343 child_die
= child_die
->sibling
;
17348 /* Read a Fortran module as type. This DIE can be only a declaration used for
17349 imported module. Still we need that type as local Fortran "use ... only"
17350 declaration imports depend on the created type in determine_prefix. */
17352 static struct type
*
17353 read_module_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17355 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17356 const char *module_name
;
17359 module_name
= dwarf2_name (die
, cu
);
17360 type
= init_type (objfile
, TYPE_CODE_MODULE
, 0, module_name
);
17362 return set_die_type (die
, type
, cu
);
17365 /* Read a Fortran module. */
17368 read_module (struct die_info
*die
, struct dwarf2_cu
*cu
)
17370 struct die_info
*child_die
= die
->child
;
17373 type
= read_type_die (die
, cu
);
17374 new_symbol (die
, type
, cu
);
17376 while (child_die
&& child_die
->tag
)
17378 process_die (child_die
, cu
);
17379 child_die
= child_die
->sibling
;
17383 /* Return the name of the namespace represented by DIE. Set
17384 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
17387 static const char *
17388 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
17390 struct die_info
*current_die
;
17391 const char *name
= NULL
;
17393 /* Loop through the extensions until we find a name. */
17395 for (current_die
= die
;
17396 current_die
!= NULL
;
17397 current_die
= dwarf2_extension (die
, &cu
))
17399 /* We don't use dwarf2_name here so that we can detect the absence
17400 of a name -> anonymous namespace. */
17401 name
= dwarf2_string_attr (die
, DW_AT_name
, cu
);
17407 /* Is it an anonymous namespace? */
17409 *is_anonymous
= (name
== NULL
);
17411 name
= CP_ANONYMOUS_NAMESPACE_STR
;
17416 /* Extract all information from a DW_TAG_pointer_type DIE and add to
17417 the user defined type vector. */
17419 static struct type
*
17420 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17422 struct gdbarch
*gdbarch
= cu
->per_objfile
->objfile
->arch ();
17423 struct comp_unit_head
*cu_header
= &cu
->header
;
17425 struct attribute
*attr_byte_size
;
17426 struct attribute
*attr_address_class
;
17427 int byte_size
, addr_class
;
17428 struct type
*target_type
;
17430 target_type
= die_type (die
, cu
);
17432 /* The die_type call above may have already set the type for this DIE. */
17433 type
= get_die_type (die
, cu
);
17437 type
= lookup_pointer_type (target_type
);
17439 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17440 if (attr_byte_size
)
17441 byte_size
= attr_byte_size
->constant_value (cu_header
->addr_size
);
17443 byte_size
= cu_header
->addr_size
;
17445 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
17446 if (attr_address_class
)
17447 addr_class
= attr_address_class
->constant_value (DW_ADDR_none
);
17449 addr_class
= DW_ADDR_none
;
17451 ULONGEST alignment
= get_alignment (cu
, die
);
17453 /* If the pointer size, alignment, or address class is different
17454 than the default, create a type variant marked as such and set
17455 the length accordingly. */
17456 if (TYPE_LENGTH (type
) != byte_size
17457 || (alignment
!= 0 && TYPE_RAW_ALIGN (type
) != 0
17458 && alignment
!= TYPE_RAW_ALIGN (type
))
17459 || addr_class
!= DW_ADDR_none
)
17461 if (gdbarch_address_class_type_flags_p (gdbarch
))
17463 type_instance_flags type_flags
17464 = gdbarch_address_class_type_flags (gdbarch
, byte_size
,
17466 gdb_assert ((type_flags
& ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
17468 type
= make_type_with_address_space (type
, type_flags
);
17470 else if (TYPE_LENGTH (type
) != byte_size
)
17472 complaint (_("invalid pointer size %d"), byte_size
);
17474 else if (TYPE_RAW_ALIGN (type
) != alignment
)
17476 complaint (_("Invalid DW_AT_alignment"
17477 " - DIE at %s [in module %s]"),
17478 sect_offset_str (die
->sect_off
),
17479 objfile_name (cu
->per_objfile
->objfile
));
17483 /* Should we also complain about unhandled address classes? */
17487 TYPE_LENGTH (type
) = byte_size
;
17488 set_type_align (type
, alignment
);
17489 return set_die_type (die
, type
, cu
);
17492 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
17493 the user defined type vector. */
17495 static struct type
*
17496 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17499 struct type
*to_type
;
17500 struct type
*domain
;
17502 to_type
= die_type (die
, cu
);
17503 domain
= die_containing_type (die
, cu
);
17505 /* The calls above may have already set the type for this DIE. */
17506 type
= get_die_type (die
, cu
);
17510 if (check_typedef (to_type
)->code () == TYPE_CODE_METHOD
)
17511 type
= lookup_methodptr_type (to_type
);
17512 else if (check_typedef (to_type
)->code () == TYPE_CODE_FUNC
)
17514 struct type
*new_type
= alloc_type (cu
->per_objfile
->objfile
);
17516 smash_to_method_type (new_type
, domain
, TYPE_TARGET_TYPE (to_type
),
17517 to_type
->fields (), to_type
->num_fields (),
17518 to_type
->has_varargs ());
17519 type
= lookup_methodptr_type (new_type
);
17522 type
= lookup_memberptr_type (to_type
, domain
);
17524 return set_die_type (die
, type
, cu
);
17527 /* Extract all information from a DW_TAG_{rvalue_,}reference_type DIE and add to
17528 the user defined type vector. */
17530 static struct type
*
17531 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
,
17532 enum type_code refcode
)
17534 struct comp_unit_head
*cu_header
= &cu
->header
;
17535 struct type
*type
, *target_type
;
17536 struct attribute
*attr
;
17538 gdb_assert (refcode
== TYPE_CODE_REF
|| refcode
== TYPE_CODE_RVALUE_REF
);
17540 target_type
= die_type (die
, cu
);
17542 /* The die_type call above may have already set the type for this DIE. */
17543 type
= get_die_type (die
, cu
);
17547 type
= lookup_reference_type (target_type
, refcode
);
17548 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17549 if (attr
!= nullptr)
17551 TYPE_LENGTH (type
) = attr
->constant_value (cu_header
->addr_size
);
17555 TYPE_LENGTH (type
) = cu_header
->addr_size
;
17557 maybe_set_alignment (cu
, die
, type
);
17558 return set_die_type (die
, type
, cu
);
17561 /* Add the given cv-qualifiers to the element type of the array. GCC
17562 outputs DWARF type qualifiers that apply to an array, not the
17563 element type. But GDB relies on the array element type to carry
17564 the cv-qualifiers. This mimics section 6.7.3 of the C99
17567 static struct type
*
17568 add_array_cv_type (struct die_info
*die
, struct dwarf2_cu
*cu
,
17569 struct type
*base_type
, int cnst
, int voltl
)
17571 struct type
*el_type
, *inner_array
;
17573 base_type
= copy_type (base_type
);
17574 inner_array
= base_type
;
17576 while (TYPE_TARGET_TYPE (inner_array
)->code () == TYPE_CODE_ARRAY
)
17578 TYPE_TARGET_TYPE (inner_array
) =
17579 copy_type (TYPE_TARGET_TYPE (inner_array
));
17580 inner_array
= TYPE_TARGET_TYPE (inner_array
);
17583 el_type
= TYPE_TARGET_TYPE (inner_array
);
17584 cnst
|= TYPE_CONST (el_type
);
17585 voltl
|= TYPE_VOLATILE (el_type
);
17586 TYPE_TARGET_TYPE (inner_array
) = make_cv_type (cnst
, voltl
, el_type
, NULL
);
17588 return set_die_type (die
, base_type
, cu
);
17591 static struct type
*
17592 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17594 struct type
*base_type
, *cv_type
;
17596 base_type
= die_type (die
, cu
);
17598 /* The die_type call above may have already set the type for this DIE. */
17599 cv_type
= get_die_type (die
, cu
);
17603 /* In case the const qualifier is applied to an array type, the element type
17604 is so qualified, not the array type (section 6.7.3 of C99). */
17605 if (base_type
->code () == TYPE_CODE_ARRAY
)
17606 return add_array_cv_type (die
, cu
, base_type
, 1, 0);
17608 cv_type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
17609 return set_die_type (die
, cv_type
, cu
);
17612 static struct type
*
17613 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17615 struct type
*base_type
, *cv_type
;
17617 base_type
= die_type (die
, cu
);
17619 /* The die_type call above may have already set the type for this DIE. */
17620 cv_type
= get_die_type (die
, cu
);
17624 /* In case the volatile qualifier is applied to an array type, the
17625 element type is so qualified, not the array type (section 6.7.3
17627 if (base_type
->code () == TYPE_CODE_ARRAY
)
17628 return add_array_cv_type (die
, cu
, base_type
, 0, 1);
17630 cv_type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
17631 return set_die_type (die
, cv_type
, cu
);
17634 /* Handle DW_TAG_restrict_type. */
17636 static struct type
*
17637 read_tag_restrict_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17639 struct type
*base_type
, *cv_type
;
17641 base_type
= die_type (die
, cu
);
17643 /* The die_type call above may have already set the type for this DIE. */
17644 cv_type
= get_die_type (die
, cu
);
17648 cv_type
= make_restrict_type (base_type
);
17649 return set_die_type (die
, cv_type
, cu
);
17652 /* Handle DW_TAG_atomic_type. */
17654 static struct type
*
17655 read_tag_atomic_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17657 struct type
*base_type
, *cv_type
;
17659 base_type
= die_type (die
, cu
);
17661 /* The die_type call above may have already set the type for this DIE. */
17662 cv_type
= get_die_type (die
, cu
);
17666 cv_type
= make_atomic_type (base_type
);
17667 return set_die_type (die
, cv_type
, cu
);
17670 /* Extract all information from a DW_TAG_string_type DIE and add to
17671 the user defined type vector. It isn't really a user defined type,
17672 but it behaves like one, with other DIE's using an AT_user_def_type
17673 attribute to reference it. */
17675 static struct type
*
17676 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17678 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17679 struct gdbarch
*gdbarch
= objfile
->arch ();
17680 struct type
*type
, *range_type
, *index_type
, *char_type
;
17681 struct attribute
*attr
;
17682 struct dynamic_prop prop
;
17683 bool length_is_constant
= true;
17686 /* There are a couple of places where bit sizes might be made use of
17687 when parsing a DW_TAG_string_type, however, no producer that we know
17688 of make use of these. Handling bit sizes that are a multiple of the
17689 byte size is easy enough, but what about other bit sizes? Lets deal
17690 with that problem when we have to. Warn about these attributes being
17691 unsupported, then parse the type and ignore them like we always
17693 if (dwarf2_attr (die
, DW_AT_bit_size
, cu
) != nullptr
17694 || dwarf2_attr (die
, DW_AT_string_length_bit_size
, cu
) != nullptr)
17696 static bool warning_printed
= false;
17697 if (!warning_printed
)
17699 warning (_("DW_AT_bit_size and DW_AT_string_length_bit_size not "
17700 "currently supported on DW_TAG_string_type."));
17701 warning_printed
= true;
17705 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
17706 if (attr
!= nullptr && !attr
->form_is_constant ())
17708 /* The string length describes the location at which the length of
17709 the string can be found. The size of the length field can be
17710 specified with one of the attributes below. */
17711 struct type
*prop_type
;
17712 struct attribute
*len
17713 = dwarf2_attr (die
, DW_AT_string_length_byte_size
, cu
);
17714 if (len
== nullptr)
17715 len
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17716 if (len
!= nullptr && len
->form_is_constant ())
17718 /* Pass 0 as the default as we know this attribute is constant
17719 and the default value will not be returned. */
17720 LONGEST sz
= len
->constant_value (0);
17721 prop_type
= cu
->per_objfile
->int_type (sz
, true);
17725 /* If the size is not specified then we assume it is the size of
17726 an address on this target. */
17727 prop_type
= cu
->addr_sized_int_type (true);
17730 /* Convert the attribute into a dynamic property. */
17731 if (!attr_to_dynamic_prop (attr
, die
, cu
, &prop
, prop_type
))
17734 length_is_constant
= false;
17736 else if (attr
!= nullptr)
17738 /* This DW_AT_string_length just contains the length with no
17739 indirection. There's no need to create a dynamic property in this
17740 case. Pass 0 for the default value as we know it will not be
17741 returned in this case. */
17742 length
= attr
->constant_value (0);
17744 else if ((attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
)) != nullptr)
17746 /* We don't currently support non-constant byte sizes for strings. */
17747 length
= attr
->constant_value (1);
17751 /* Use 1 as a fallback length if we have nothing else. */
17755 index_type
= objfile_type (objfile
)->builtin_int
;
17756 if (length_is_constant
)
17757 range_type
= create_static_range_type (NULL
, index_type
, 1, length
);
17760 struct dynamic_prop low_bound
;
17762 low_bound
.set_const_val (1);
17763 range_type
= create_range_type (NULL
, index_type
, &low_bound
, &prop
, 0);
17765 char_type
= language_string_char_type (cu
->language_defn
, gdbarch
);
17766 type
= create_string_type (NULL
, char_type
, range_type
);
17768 return set_die_type (die
, type
, cu
);
17771 /* Assuming that DIE corresponds to a function, returns nonzero
17772 if the function is prototyped. */
17775 prototyped_function_p (struct die_info
*die
, struct dwarf2_cu
*cu
)
17777 struct attribute
*attr
;
17779 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
17780 if (attr
&& attr
->as_boolean ())
17783 /* The DWARF standard implies that the DW_AT_prototyped attribute
17784 is only meaningful for C, but the concept also extends to other
17785 languages that allow unprototyped functions (Eg: Objective C).
17786 For all other languages, assume that functions are always
17788 if (cu
->language
!= language_c
17789 && cu
->language
!= language_objc
17790 && cu
->language
!= language_opencl
)
17793 /* RealView does not emit DW_AT_prototyped. We can not distinguish
17794 prototyped and unprototyped functions; default to prototyped,
17795 since that is more common in modern code (and RealView warns
17796 about unprototyped functions). */
17797 if (producer_is_realview (cu
->producer
))
17803 /* Handle DIES due to C code like:
17807 int (*funcp)(int a, long l);
17811 ('funcp' generates a DW_TAG_subroutine_type DIE). */
17813 static struct type
*
17814 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17816 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17817 struct type
*type
; /* Type that this function returns. */
17818 struct type
*ftype
; /* Function that returns above type. */
17819 struct attribute
*attr
;
17821 type
= die_type (die
, cu
);
17823 /* The die_type call above may have already set the type for this DIE. */
17824 ftype
= get_die_type (die
, cu
);
17828 ftype
= lookup_function_type (type
);
17830 if (prototyped_function_p (die
, cu
))
17831 ftype
->set_is_prototyped (true);
17833 /* Store the calling convention in the type if it's available in
17834 the subroutine die. Otherwise set the calling convention to
17835 the default value DW_CC_normal. */
17836 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
17837 if (attr
!= nullptr
17838 && is_valid_DW_AT_calling_convention_for_subroutine (attr
->constant_value (0)))
17839 TYPE_CALLING_CONVENTION (ftype
)
17840 = (enum dwarf_calling_convention
) attr
->constant_value (0);
17841 else if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL"))
17842 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_GDB_IBM_OpenCL
;
17844 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_normal
;
17846 /* Record whether the function returns normally to its caller or not
17847 if the DWARF producer set that information. */
17848 attr
= dwarf2_attr (die
, DW_AT_noreturn
, cu
);
17849 if (attr
&& attr
->as_boolean ())
17850 TYPE_NO_RETURN (ftype
) = 1;
17852 /* We need to add the subroutine type to the die immediately so
17853 we don't infinitely recurse when dealing with parameters
17854 declared as the same subroutine type. */
17855 set_die_type (die
, ftype
, cu
);
17857 if (die
->child
!= NULL
)
17859 struct type
*void_type
= objfile_type (objfile
)->builtin_void
;
17860 struct die_info
*child_die
;
17861 int nparams
, iparams
;
17863 /* Count the number of parameters.
17864 FIXME: GDB currently ignores vararg functions, but knows about
17865 vararg member functions. */
17867 child_die
= die
->child
;
17868 while (child_die
&& child_die
->tag
)
17870 if (child_die
->tag
== DW_TAG_formal_parameter
)
17872 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
17873 ftype
->set_has_varargs (true);
17875 child_die
= child_die
->sibling
;
17878 /* Allocate storage for parameters and fill them in. */
17879 ftype
->set_num_fields (nparams
);
17881 ((struct field
*) TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
)));
17883 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
17884 even if we error out during the parameters reading below. */
17885 for (iparams
= 0; iparams
< nparams
; iparams
++)
17886 ftype
->field (iparams
).set_type (void_type
);
17889 child_die
= die
->child
;
17890 while (child_die
&& child_die
->tag
)
17892 if (child_die
->tag
== DW_TAG_formal_parameter
)
17894 struct type
*arg_type
;
17896 /* DWARF version 2 has no clean way to discern C++
17897 static and non-static member functions. G++ helps
17898 GDB by marking the first parameter for non-static
17899 member functions (which is the this pointer) as
17900 artificial. We pass this information to
17901 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
17903 DWARF version 3 added DW_AT_object_pointer, which GCC
17904 4.5 does not yet generate. */
17905 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
17906 if (attr
!= nullptr)
17907 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = attr
->as_boolean ();
17909 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
17910 arg_type
= die_type (child_die
, cu
);
17912 /* RealView does not mark THIS as const, which the testsuite
17913 expects. GCC marks THIS as const in method definitions,
17914 but not in the class specifications (GCC PR 43053). */
17915 if (cu
->language
== language_cplus
&& !TYPE_CONST (arg_type
)
17916 && TYPE_FIELD_ARTIFICIAL (ftype
, iparams
))
17919 struct dwarf2_cu
*arg_cu
= cu
;
17920 const char *name
= dwarf2_name (child_die
, cu
);
17922 attr
= dwarf2_attr (die
, DW_AT_object_pointer
, cu
);
17923 if (attr
!= nullptr)
17925 /* If the compiler emits this, use it. */
17926 if (follow_die_ref (die
, attr
, &arg_cu
) == child_die
)
17929 else if (name
&& strcmp (name
, "this") == 0)
17930 /* Function definitions will have the argument names. */
17932 else if (name
== NULL
&& iparams
== 0)
17933 /* Declarations may not have the names, so like
17934 elsewhere in GDB, assume an artificial first
17935 argument is "this". */
17939 arg_type
= make_cv_type (1, TYPE_VOLATILE (arg_type
),
17943 ftype
->field (iparams
).set_type (arg_type
);
17946 child_die
= child_die
->sibling
;
17953 static struct type
*
17954 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
17956 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17957 const char *name
= NULL
;
17958 struct type
*this_type
, *target_type
;
17960 name
= dwarf2_full_name (NULL
, die
, cu
);
17961 this_type
= init_type (objfile
, TYPE_CODE_TYPEDEF
, 0, name
);
17962 this_type
->set_target_is_stub (true);
17963 set_die_type (die
, this_type
, cu
);
17964 target_type
= die_type (die
, cu
);
17965 if (target_type
!= this_type
)
17966 TYPE_TARGET_TYPE (this_type
) = target_type
;
17969 /* Self-referential typedefs are, it seems, not allowed by the DWARF
17970 spec and cause infinite loops in GDB. */
17971 complaint (_("Self-referential DW_TAG_typedef "
17972 "- DIE at %s [in module %s]"),
17973 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
17974 TYPE_TARGET_TYPE (this_type
) = NULL
;
17978 /* Gcc-7 and before supports -feliminate-dwarf2-dups, which generates
17979 anonymous typedefs, which is, strictly speaking, invalid DWARF.
17980 Handle these by just returning the target type, rather than
17981 constructing an anonymous typedef type and trying to handle this
17983 set_die_type (die
, target_type
, cu
);
17984 return target_type
;
17989 /* Helper for get_dwarf2_rational_constant that computes the value of
17990 a given gmp_mpz given an attribute. */
17993 get_mpz (struct dwarf2_cu
*cu
, gdb_mpz
*value
, struct attribute
*attr
)
17995 /* GCC will sometimes emit a 16-byte constant value as a DWARF
17996 location expression that pushes an implicit value. */
17997 if (attr
->form
== DW_FORM_exprloc
)
17999 dwarf_block
*blk
= attr
->as_block ();
18000 if (blk
->size
> 0 && blk
->data
[0] == DW_OP_implicit_value
)
18003 const gdb_byte
*ptr
= safe_read_uleb128 (blk
->data
+ 1,
18004 blk
->data
+ blk
->size
,
18006 if (ptr
- blk
->data
+ len
<= blk
->size
)
18008 mpz_import (value
->val
, len
,
18009 bfd_big_endian (cu
->per_objfile
->objfile
->obfd
) ? 1 : -1,
18015 /* On failure set it to 1. */
18016 *value
= gdb_mpz (1);
18018 else if (attr
->form_is_block ())
18020 dwarf_block
*blk
= attr
->as_block ();
18021 mpz_import (value
->val
, blk
->size
,
18022 bfd_big_endian (cu
->per_objfile
->objfile
->obfd
) ? 1 : -1,
18023 1, 0, 0, blk
->data
);
18026 *value
= gdb_mpz (attr
->constant_value (1));
18029 /* Assuming DIE is a rational DW_TAG_constant, read the DIE's
18030 numerator and denominator into NUMERATOR and DENOMINATOR (resp).
18032 If the numerator and/or numerator attribute is missing,
18033 a complaint is filed, and NUMERATOR and DENOMINATOR are left
18037 get_dwarf2_rational_constant (struct die_info
*die
, struct dwarf2_cu
*cu
,
18038 gdb_mpz
*numerator
, gdb_mpz
*denominator
)
18040 struct attribute
*num_attr
, *denom_attr
;
18042 num_attr
= dwarf2_attr (die
, DW_AT_GNU_numerator
, cu
);
18043 if (num_attr
== nullptr)
18044 complaint (_("DW_AT_GNU_numerator missing in %s DIE at %s"),
18045 dwarf_tag_name (die
->tag
), sect_offset_str (die
->sect_off
));
18047 denom_attr
= dwarf2_attr (die
, DW_AT_GNU_denominator
, cu
);
18048 if (denom_attr
== nullptr)
18049 complaint (_("DW_AT_GNU_denominator missing in %s DIE at %s"),
18050 dwarf_tag_name (die
->tag
), sect_offset_str (die
->sect_off
));
18052 if (num_attr
== nullptr || denom_attr
== nullptr)
18055 get_mpz (cu
, numerator
, num_attr
);
18056 get_mpz (cu
, denominator
, denom_attr
);
18059 /* Same as get_dwarf2_rational_constant, but extracting an unsigned
18060 rational constant, rather than a signed one.
18062 If the rational constant has a negative value, a complaint
18063 is filed, and NUMERATOR and DENOMINATOR are left untouched. */
18066 get_dwarf2_unsigned_rational_constant (struct die_info
*die
,
18067 struct dwarf2_cu
*cu
,
18068 gdb_mpz
*numerator
,
18069 gdb_mpz
*denominator
)
18074 get_dwarf2_rational_constant (die
, cu
, &num
, &denom
);
18075 if (mpz_sgn (num
.val
) == -1 && mpz_sgn (denom
.val
) == -1)
18077 mpz_neg (num
.val
, num
.val
);
18078 mpz_neg (denom
.val
, denom
.val
);
18080 else if (mpz_sgn (num
.val
) == -1)
18082 complaint (_("unexpected negative value for DW_AT_GNU_numerator"
18084 sect_offset_str (die
->sect_off
));
18087 else if (mpz_sgn (denom
.val
) == -1)
18089 complaint (_("unexpected negative value for DW_AT_GNU_denominator"
18091 sect_offset_str (die
->sect_off
));
18095 *numerator
= std::move (num
);
18096 *denominator
= std::move (denom
);
18099 /* Assuming that ENCODING is a string whose contents starting at the
18100 K'th character is "_nn" where "nn" is a decimal number, scan that
18101 number and set RESULT to the value. K is updated to point to the
18102 character immediately following the number.
18104 If the string does not conform to the format described above, false
18105 is returned, and K may or may not be changed. */
18108 ada_get_gnat_encoded_number (const char *encoding
, int &k
, gdb_mpz
*result
)
18110 /* The next character should be an underscore ('_') followed
18112 if (encoding
[k
] != '_' || !isdigit (encoding
[k
+ 1]))
18115 /* Skip the underscore. */
18119 /* Determine the number of digits for our number. */
18120 while (isdigit (encoding
[k
]))
18125 std::string
copy (&encoding
[start
], k
- start
);
18126 if (mpz_set_str (result
->val
, copy
.c_str (), 10) == -1)
18132 /* Scan two numbers from ENCODING at OFFSET, assuming the string is of
18133 the form _NN_DD, where NN and DD are decimal numbers. Set NUM and
18134 DENOM, update OFFSET, and return true on success. Return false on
18138 ada_get_gnat_encoded_ratio (const char *encoding
, int &offset
,
18139 gdb_mpz
*num
, gdb_mpz
*denom
)
18141 if (!ada_get_gnat_encoded_number (encoding
, offset
, num
))
18143 return ada_get_gnat_encoded_number (encoding
, offset
, denom
);
18146 /* Assuming DIE corresponds to a fixed point type, finish the creation
18147 of the corresponding TYPE by setting its type-specific data. CU is
18148 the DIE's CU. SUFFIX is the "XF" type name suffix coming from GNAT
18149 encodings. It is nullptr if the GNAT encoding should be
18153 finish_fixed_point_type (struct type
*type
, const char *suffix
,
18154 struct die_info
*die
, struct dwarf2_cu
*cu
)
18156 gdb_assert (type
->code () == TYPE_CODE_FIXED_POINT
18157 && TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_FIXED_POINT
);
18159 /* If GNAT encodings are preferred, don't examine the
18161 struct attribute
*attr
= nullptr;
18162 if (suffix
== nullptr)
18164 attr
= dwarf2_attr (die
, DW_AT_binary_scale
, cu
);
18165 if (attr
== nullptr)
18166 attr
= dwarf2_attr (die
, DW_AT_decimal_scale
, cu
);
18167 if (attr
== nullptr)
18168 attr
= dwarf2_attr (die
, DW_AT_small
, cu
);
18171 /* Numerator and denominator of our fixed-point type's scaling factor.
18172 The default is a scaling factor of 1, which we use as a fallback
18173 when we are not able to decode it (problem with the debugging info,
18174 unsupported forms, bug in GDB, etc...). Using that as the default
18175 allows us to at least print the unscaled value, which might still
18176 be useful to a user. */
18177 gdb_mpz
scale_num (1);
18178 gdb_mpz
scale_denom (1);
18180 if (attr
== nullptr)
18183 if (suffix
!= nullptr
18184 && ada_get_gnat_encoded_ratio (suffix
, offset
, &scale_num
,
18186 /* The number might be encoded as _nn_dd_nn_dd, where the
18187 second ratio is the 'small value. In this situation, we
18188 want the second value. */
18189 && (suffix
[offset
] != '_'
18190 || ada_get_gnat_encoded_ratio (suffix
, offset
, &scale_num
,
18197 /* Scaling factor not found. Assume a scaling factor of 1,
18198 and hope for the best. At least the user will be able to
18199 see the encoded value. */
18202 complaint (_("no scale found for fixed-point type (DIE at %s)"),
18203 sect_offset_str (die
->sect_off
));
18206 else if (attr
->name
== DW_AT_binary_scale
)
18208 LONGEST scale_exp
= attr
->constant_value (0);
18209 gdb_mpz
*num_or_denom
= scale_exp
> 0 ? &scale_num
: &scale_denom
;
18211 mpz_mul_2exp (num_or_denom
->val
, num_or_denom
->val
, std::abs (scale_exp
));
18213 else if (attr
->name
== DW_AT_decimal_scale
)
18215 LONGEST scale_exp
= attr
->constant_value (0);
18216 gdb_mpz
*num_or_denom
= scale_exp
> 0 ? &scale_num
: &scale_denom
;
18218 mpz_ui_pow_ui (num_or_denom
->val
, 10, std::abs (scale_exp
));
18220 else if (attr
->name
== DW_AT_small
)
18222 struct die_info
*scale_die
;
18223 struct dwarf2_cu
*scale_cu
= cu
;
18225 scale_die
= follow_die_ref (die
, attr
, &scale_cu
);
18226 if (scale_die
->tag
== DW_TAG_constant
)
18227 get_dwarf2_unsigned_rational_constant (scale_die
, scale_cu
,
18228 &scale_num
, &scale_denom
);
18230 complaint (_("%s DIE not supported as target of DW_AT_small attribute"
18232 dwarf_tag_name (die
->tag
), sect_offset_str (die
->sect_off
));
18236 complaint (_("unsupported scale attribute %s for fixed-point type"
18238 dwarf_attr_name (attr
->name
),
18239 sect_offset_str (die
->sect_off
));
18242 gdb_mpq
&scaling_factor
= type
->fixed_point_info ().scaling_factor
;
18243 mpz_set (mpq_numref (scaling_factor
.val
), scale_num
.val
);
18244 mpz_set (mpq_denref (scaling_factor
.val
), scale_denom
.val
);
18245 mpq_canonicalize (scaling_factor
.val
);
18248 /* The gnat-encoding suffix for fixed point. */
18250 #define GNAT_FIXED_POINT_SUFFIX "___XF_"
18252 /* If NAME encodes an Ada fixed-point type, return a pointer to the
18253 "XF" suffix of the name. The text after this is what encodes the
18254 'small and 'delta information. Otherwise, return nullptr. */
18256 static const char *
18257 gnat_encoded_fixed_point_type_info (const char *name
)
18259 return strstr (name
, GNAT_FIXED_POINT_SUFFIX
);
18262 /* Allocate a floating-point type of size BITS and name NAME. Pass NAME_HINT
18263 (which may be different from NAME) to the architecture back-end to allow
18264 it to guess the correct format if necessary. */
18266 static struct type
*
18267 dwarf2_init_float_type (struct objfile
*objfile
, int bits
, const char *name
,
18268 const char *name_hint
, enum bfd_endian byte_order
)
18270 struct gdbarch
*gdbarch
= objfile
->arch ();
18271 const struct floatformat
**format
;
18274 format
= gdbarch_floatformat_for_type (gdbarch
, name_hint
, bits
);
18276 type
= init_float_type (objfile
, bits
, name
, format
, byte_order
);
18278 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
, name
);
18283 /* Allocate an integer type of size BITS and name NAME. */
18285 static struct type
*
18286 dwarf2_init_integer_type (struct dwarf2_cu
*cu
, struct objfile
*objfile
,
18287 int bits
, int unsigned_p
, const char *name
)
18291 /* Versions of Intel's C Compiler generate an integer type called "void"
18292 instead of using DW_TAG_unspecified_type. This has been seen on
18293 at least versions 14, 17, and 18. */
18294 if (bits
== 0 && producer_is_icc (cu
) && name
!= nullptr
18295 && strcmp (name
, "void") == 0)
18296 type
= objfile_type (objfile
)->builtin_void
;
18298 type
= init_integer_type (objfile
, bits
, unsigned_p
, name
);
18303 /* Return true if DIE has a DW_AT_small attribute whose value is
18304 a constant rational, where both the numerator and denominator
18307 CU is the DIE's Compilation Unit. */
18310 has_zero_over_zero_small_attribute (struct die_info
*die
,
18311 struct dwarf2_cu
*cu
)
18313 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_small
, cu
);
18314 if (attr
== nullptr)
18317 struct dwarf2_cu
*scale_cu
= cu
;
18318 struct die_info
*scale_die
18319 = follow_die_ref (die
, attr
, &scale_cu
);
18321 if (scale_die
->tag
!= DW_TAG_constant
)
18324 gdb_mpz
num (1), denom (1);
18325 get_dwarf2_rational_constant (scale_die
, cu
, &num
, &denom
);
18326 return mpz_sgn (num
.val
) == 0 && mpz_sgn (denom
.val
) == 0;
18329 /* Initialise and return a floating point type of size BITS suitable for
18330 use as a component of a complex number. The NAME_HINT is passed through
18331 when initialising the floating point type and is the name of the complex
18334 As DWARF doesn't currently provide an explicit name for the components
18335 of a complex number, but it can be helpful to have these components
18336 named, we try to select a suitable name based on the size of the
18338 static struct type
*
18339 dwarf2_init_complex_target_type (struct dwarf2_cu
*cu
,
18340 struct objfile
*objfile
,
18341 int bits
, const char *name_hint
,
18342 enum bfd_endian byte_order
)
18344 gdbarch
*gdbarch
= objfile
->arch ();
18345 struct type
*tt
= nullptr;
18347 /* Try to find a suitable floating point builtin type of size BITS.
18348 We're going to use the name of this type as the name for the complex
18349 target type that we are about to create. */
18350 switch (cu
->language
)
18352 case language_fortran
:
18356 tt
= builtin_f_type (gdbarch
)->builtin_real
;
18359 tt
= builtin_f_type (gdbarch
)->builtin_real_s8
;
18361 case 96: /* The x86-32 ABI specifies 96-bit long double. */
18363 tt
= builtin_f_type (gdbarch
)->builtin_real_s16
;
18371 tt
= builtin_type (gdbarch
)->builtin_float
;
18374 tt
= builtin_type (gdbarch
)->builtin_double
;
18376 case 96: /* The x86-32 ABI specifies 96-bit long double. */
18378 tt
= builtin_type (gdbarch
)->builtin_long_double
;
18384 /* If the type we found doesn't match the size we were looking for, then
18385 pretend we didn't find a type at all, the complex target type we
18386 create will then be nameless. */
18387 if (tt
!= nullptr && TYPE_LENGTH (tt
) * TARGET_CHAR_BIT
!= bits
)
18390 const char *name
= (tt
== nullptr) ? nullptr : tt
->name ();
18391 return dwarf2_init_float_type (objfile
, bits
, name
, name_hint
, byte_order
);
18394 /* Find a representation of a given base type and install
18395 it in the TYPE field of the die. */
18397 static struct type
*
18398 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18400 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
18402 struct attribute
*attr
;
18403 int encoding
= 0, bits
= 0;
18407 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
18408 if (attr
!= nullptr && attr
->form_is_constant ())
18409 encoding
= attr
->constant_value (0);
18410 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
18411 if (attr
!= nullptr)
18412 bits
= attr
->constant_value (0) * TARGET_CHAR_BIT
;
18413 name
= dwarf2_name (die
, cu
);
18415 complaint (_("DW_AT_name missing from DW_TAG_base_type"));
18417 arch
= objfile
->arch ();
18418 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
18420 attr
= dwarf2_attr (die
, DW_AT_endianity
, cu
);
18421 if (attr
!= nullptr && attr
->form_is_constant ())
18423 int endianity
= attr
->constant_value (0);
18428 byte_order
= BFD_ENDIAN_BIG
;
18430 case DW_END_little
:
18431 byte_order
= BFD_ENDIAN_LITTLE
;
18434 complaint (_("DW_AT_endianity has unrecognized value %d"), endianity
);
18439 if ((encoding
== DW_ATE_signed_fixed
|| encoding
== DW_ATE_unsigned_fixed
)
18440 && cu
->language
== language_ada
18441 && has_zero_over_zero_small_attribute (die
, cu
))
18443 /* brobecker/2018-02-24: This is a fixed point type for which
18444 the scaling factor is represented as fraction whose value
18445 does not make sense (zero divided by zero), so we should
18446 normally never see these. However, there is a small category
18447 of fixed point types for which GNAT is unable to provide
18448 the scaling factor via the standard DWARF mechanisms, and
18449 for which the info is provided via the GNAT encodings instead.
18450 This is likely what this DIE is about. */
18451 encoding
= (encoding
== DW_ATE_signed_fixed
18453 : DW_ATE_unsigned
);
18456 /* With GNAT encodings, fixed-point information will be encoded in
18457 the type name. Note that this can also occur with the above
18458 zero-over-zero case, which is why this is a separate "if" rather
18459 than an "else if". */
18460 const char *gnat_encoding_suffix
= nullptr;
18461 if ((encoding
== DW_ATE_signed
|| encoding
== DW_ATE_unsigned
)
18462 && cu
->language
== language_ada
18463 && name
!= nullptr)
18465 gnat_encoding_suffix
= gnat_encoded_fixed_point_type_info (name
);
18466 if (gnat_encoding_suffix
!= nullptr)
18468 gdb_assert (startswith (gnat_encoding_suffix
,
18469 GNAT_FIXED_POINT_SUFFIX
));
18470 name
= obstack_strndup (&cu
->per_objfile
->objfile
->objfile_obstack
,
18471 name
, gnat_encoding_suffix
- name
);
18472 /* Use -1 here so that SUFFIX points at the "_" after the
18474 gnat_encoding_suffix
+= strlen (GNAT_FIXED_POINT_SUFFIX
) - 1;
18476 encoding
= (encoding
== DW_ATE_signed
18477 ? DW_ATE_signed_fixed
18478 : DW_ATE_unsigned_fixed
);
18484 case DW_ATE_address
:
18485 /* Turn DW_ATE_address into a void * pointer. */
18486 type
= init_type (objfile
, TYPE_CODE_VOID
, TARGET_CHAR_BIT
, NULL
);
18487 type
= init_pointer_type (objfile
, bits
, name
, type
);
18489 case DW_ATE_boolean
:
18490 type
= init_boolean_type (objfile
, bits
, 1, name
);
18492 case DW_ATE_complex_float
:
18493 type
= dwarf2_init_complex_target_type (cu
, objfile
, bits
/ 2, name
,
18495 if (type
->code () == TYPE_CODE_ERROR
)
18497 if (name
== nullptr)
18499 struct obstack
*obstack
18500 = &cu
->per_objfile
->objfile
->objfile_obstack
;
18501 name
= obconcat (obstack
, "_Complex ", type
->name (),
18504 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
, name
);
18507 type
= init_complex_type (name
, type
);
18509 case DW_ATE_decimal_float
:
18510 type
= init_decfloat_type (objfile
, bits
, name
);
18513 type
= dwarf2_init_float_type (objfile
, bits
, name
, name
, byte_order
);
18515 case DW_ATE_signed
:
18516 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 0, name
);
18518 case DW_ATE_unsigned
:
18519 if (cu
->language
== language_fortran
18521 && startswith (name
, "character("))
18522 type
= init_character_type (objfile
, bits
, 1, name
);
18524 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 1, name
);
18526 case DW_ATE_signed_char
:
18527 if (cu
->language
== language_ada
|| cu
->language
== language_m2
18528 || cu
->language
== language_pascal
18529 || cu
->language
== language_fortran
)
18530 type
= init_character_type (objfile
, bits
, 0, name
);
18532 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 0, name
);
18534 case DW_ATE_unsigned_char
:
18535 if (cu
->language
== language_ada
|| cu
->language
== language_m2
18536 || cu
->language
== language_pascal
18537 || cu
->language
== language_fortran
18538 || cu
->language
== language_rust
)
18539 type
= init_character_type (objfile
, bits
, 1, name
);
18541 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 1, name
);
18546 type
= builtin_type (arch
)->builtin_char16
;
18547 else if (bits
== 32)
18548 type
= builtin_type (arch
)->builtin_char32
;
18551 complaint (_("unsupported DW_ATE_UTF bit size: '%d'"),
18553 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 1, name
);
18555 return set_die_type (die
, type
, cu
);
18558 case DW_ATE_signed_fixed
:
18559 type
= init_fixed_point_type (objfile
, bits
, 0, name
);
18560 finish_fixed_point_type (type
, gnat_encoding_suffix
, die
, cu
);
18562 case DW_ATE_unsigned_fixed
:
18563 type
= init_fixed_point_type (objfile
, bits
, 1, name
);
18564 finish_fixed_point_type (type
, gnat_encoding_suffix
, die
, cu
);
18568 complaint (_("unsupported DW_AT_encoding: '%s'"),
18569 dwarf_type_encoding_name (encoding
));
18570 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
, name
);
18574 if (name
&& strcmp (name
, "char") == 0)
18575 type
->set_has_no_signedness (true);
18577 maybe_set_alignment (cu
, die
, type
);
18579 type
->set_endianity_is_not_default (gdbarch_byte_order (arch
) != byte_order
);
18581 if (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_INT
)
18583 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
18584 if (attr
!= nullptr && attr
->as_unsigned () <= 8 * TYPE_LENGTH (type
))
18586 unsigned real_bit_size
= attr
->as_unsigned ();
18587 attr
= dwarf2_attr (die
, DW_AT_data_bit_offset
, cu
);
18588 /* Only use the attributes if they make sense together. */
18589 if (attr
== nullptr
18590 || (attr
->as_unsigned () + real_bit_size
18591 <= 8 * TYPE_LENGTH (type
)))
18593 TYPE_MAIN_TYPE (type
)->type_specific
.int_stuff
.bit_size
18595 if (attr
!= nullptr)
18596 TYPE_MAIN_TYPE (type
)->type_specific
.int_stuff
.bit_offset
18597 = attr
->as_unsigned ();
18602 return set_die_type (die
, type
, cu
);
18605 /* Parse dwarf attribute if it's a block, reference or constant and put the
18606 resulting value of the attribute into struct bound_prop.
18607 Returns 1 if ATTR could be resolved into PROP, 0 otherwise. */
18610 attr_to_dynamic_prop (const struct attribute
*attr
, struct die_info
*die
,
18611 struct dwarf2_cu
*cu
, struct dynamic_prop
*prop
,
18612 struct type
*default_type
)
18614 struct dwarf2_property_baton
*baton
;
18615 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
18616 struct objfile
*objfile
= per_objfile
->objfile
;
18617 struct obstack
*obstack
= &objfile
->objfile_obstack
;
18619 gdb_assert (default_type
!= NULL
);
18621 if (attr
== NULL
|| prop
== NULL
)
18624 if (attr
->form_is_block ())
18626 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
18627 baton
->property_type
= default_type
;
18628 baton
->locexpr
.per_cu
= cu
->per_cu
;
18629 baton
->locexpr
.per_objfile
= per_objfile
;
18631 struct dwarf_block
*block
= attr
->as_block ();
18632 baton
->locexpr
.size
= block
->size
;
18633 baton
->locexpr
.data
= block
->data
;
18634 switch (attr
->name
)
18636 case DW_AT_string_length
:
18637 baton
->locexpr
.is_reference
= true;
18640 baton
->locexpr
.is_reference
= false;
18644 prop
->set_locexpr (baton
);
18645 gdb_assert (prop
->baton () != NULL
);
18647 else if (attr
->form_is_ref ())
18649 struct dwarf2_cu
*target_cu
= cu
;
18650 struct die_info
*target_die
;
18651 struct attribute
*target_attr
;
18653 target_die
= follow_die_ref (die
, attr
, &target_cu
);
18654 target_attr
= dwarf2_attr (target_die
, DW_AT_location
, target_cu
);
18655 if (target_attr
== NULL
)
18656 target_attr
= dwarf2_attr (target_die
, DW_AT_data_member_location
,
18658 if (target_attr
== NULL
)
18661 switch (target_attr
->name
)
18663 case DW_AT_location
:
18664 if (target_attr
->form_is_section_offset ())
18666 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
18667 baton
->property_type
= die_type (target_die
, target_cu
);
18668 fill_in_loclist_baton (cu
, &baton
->loclist
, target_attr
);
18669 prop
->set_loclist (baton
);
18670 gdb_assert (prop
->baton () != NULL
);
18672 else if (target_attr
->form_is_block ())
18674 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
18675 baton
->property_type
= die_type (target_die
, target_cu
);
18676 baton
->locexpr
.per_cu
= cu
->per_cu
;
18677 baton
->locexpr
.per_objfile
= per_objfile
;
18678 struct dwarf_block
*block
= target_attr
->as_block ();
18679 baton
->locexpr
.size
= block
->size
;
18680 baton
->locexpr
.data
= block
->data
;
18681 baton
->locexpr
.is_reference
= true;
18682 prop
->set_locexpr (baton
);
18683 gdb_assert (prop
->baton () != NULL
);
18687 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
18688 "dynamic property");
18692 case DW_AT_data_member_location
:
18696 if (!handle_data_member_location (target_die
, target_cu
,
18700 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
18701 baton
->property_type
= read_type_die (target_die
->parent
,
18703 baton
->offset_info
.offset
= offset
;
18704 baton
->offset_info
.type
= die_type (target_die
, target_cu
);
18705 prop
->set_addr_offset (baton
);
18710 else if (attr
->form_is_constant ())
18711 prop
->set_const_val (attr
->constant_value (0));
18714 dwarf2_invalid_attrib_class_complaint (dwarf_form_name (attr
->form
),
18715 dwarf2_name (die
, cu
));
18725 dwarf2_per_objfile::int_type (int size_in_bytes
, bool unsigned_p
) const
18727 struct type
*int_type
;
18729 /* Helper macro to examine the various builtin types. */
18730 #define TRY_TYPE(F) \
18731 int_type = (unsigned_p \
18732 ? objfile_type (objfile)->builtin_unsigned_ ## F \
18733 : objfile_type (objfile)->builtin_ ## F); \
18734 if (int_type != NULL && TYPE_LENGTH (int_type) == size_in_bytes) \
18741 TRY_TYPE (long_long
);
18745 gdb_assert_not_reached ("unable to find suitable integer type");
18751 dwarf2_cu::addr_sized_int_type (bool unsigned_p
) const
18753 int addr_size
= this->per_cu
->addr_size ();
18754 return this->per_objfile
->int_type (addr_size
, unsigned_p
);
18757 /* Read the DW_AT_type attribute for a sub-range. If this attribute is not
18758 present (which is valid) then compute the default type based on the
18759 compilation units address size. */
18761 static struct type
*
18762 read_subrange_index_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18764 struct type
*index_type
= die_type (die
, cu
);
18766 /* Dwarf-2 specifications explicitly allows to create subrange types
18767 without specifying a base type.
18768 In that case, the base type must be set to the type of
18769 the lower bound, upper bound or count, in that order, if any of these
18770 three attributes references an object that has a type.
18771 If no base type is found, the Dwarf-2 specifications say that
18772 a signed integer type of size equal to the size of an address should
18774 For the following C code: `extern char gdb_int [];'
18775 GCC produces an empty range DIE.
18776 FIXME: muller/2010-05-28: Possible references to object for low bound,
18777 high bound or count are not yet handled by this code. */
18778 if (index_type
->code () == TYPE_CODE_VOID
)
18779 index_type
= cu
->addr_sized_int_type (false);
18784 /* Read the given DW_AT_subrange DIE. */
18786 static struct type
*
18787 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18789 struct type
*base_type
, *orig_base_type
;
18790 struct type
*range_type
;
18791 struct attribute
*attr
;
18792 struct dynamic_prop low
, high
;
18793 int low_default_is_valid
;
18794 int high_bound_is_count
= 0;
18796 ULONGEST negative_mask
;
18798 orig_base_type
= read_subrange_index_type (die
, cu
);
18800 /* If ORIG_BASE_TYPE is a typedef, it will not be TYPE_UNSIGNED,
18801 whereas the real type might be. So, we use ORIG_BASE_TYPE when
18802 creating the range type, but we use the result of check_typedef
18803 when examining properties of the type. */
18804 base_type
= check_typedef (orig_base_type
);
18806 /* The die_type call above may have already set the type for this DIE. */
18807 range_type
= get_die_type (die
, cu
);
18811 high
.set_const_val (0);
18813 /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
18814 omitting DW_AT_lower_bound. */
18815 switch (cu
->language
)
18818 case language_cplus
:
18819 low
.set_const_val (0);
18820 low_default_is_valid
= 1;
18822 case language_fortran
:
18823 low
.set_const_val (1);
18824 low_default_is_valid
= 1;
18827 case language_objc
:
18828 case language_rust
:
18829 low
.set_const_val (0);
18830 low_default_is_valid
= (cu
->header
.version
>= 4);
18834 case language_pascal
:
18835 low
.set_const_val (1);
18836 low_default_is_valid
= (cu
->header
.version
>= 4);
18839 low
.set_const_val (0);
18840 low_default_is_valid
= 0;
18844 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
18845 if (attr
!= nullptr)
18846 attr_to_dynamic_prop (attr
, die
, cu
, &low
, base_type
);
18847 else if (!low_default_is_valid
)
18848 complaint (_("Missing DW_AT_lower_bound "
18849 "- DIE at %s [in module %s]"),
18850 sect_offset_str (die
->sect_off
),
18851 objfile_name (cu
->per_objfile
->objfile
));
18853 struct attribute
*attr_ub
, *attr_count
;
18854 attr
= attr_ub
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
18855 if (!attr_to_dynamic_prop (attr
, die
, cu
, &high
, base_type
))
18857 attr
= attr_count
= dwarf2_attr (die
, DW_AT_count
, cu
);
18858 if (attr_to_dynamic_prop (attr
, die
, cu
, &high
, base_type
))
18860 /* If bounds are constant do the final calculation here. */
18861 if (low
.kind () == PROP_CONST
&& high
.kind () == PROP_CONST
)
18862 high
.set_const_val (low
.const_val () + high
.const_val () - 1);
18864 high_bound_is_count
= 1;
18868 if (attr_ub
!= NULL
)
18869 complaint (_("Unresolved DW_AT_upper_bound "
18870 "- DIE at %s [in module %s]"),
18871 sect_offset_str (die
->sect_off
),
18872 objfile_name (cu
->per_objfile
->objfile
));
18873 if (attr_count
!= NULL
)
18874 complaint (_("Unresolved DW_AT_count "
18875 "- DIE at %s [in module %s]"),
18876 sect_offset_str (die
->sect_off
),
18877 objfile_name (cu
->per_objfile
->objfile
));
18882 struct attribute
*bias_attr
= dwarf2_attr (die
, DW_AT_GNU_bias
, cu
);
18883 if (bias_attr
!= nullptr && bias_attr
->form_is_constant ())
18884 bias
= bias_attr
->constant_value (0);
18886 /* Normally, the DWARF producers are expected to use a signed
18887 constant form (Eg. DW_FORM_sdata) to express negative bounds.
18888 But this is unfortunately not always the case, as witnessed
18889 with GCC, for instance, where the ambiguous DW_FORM_dataN form
18890 is used instead. To work around that ambiguity, we treat
18891 the bounds as signed, and thus sign-extend their values, when
18892 the base type is signed. */
18894 -((ULONGEST
) 1 << (TYPE_LENGTH (base_type
) * TARGET_CHAR_BIT
- 1));
18895 if (low
.kind () == PROP_CONST
18896 && !base_type
->is_unsigned () && (low
.const_val () & negative_mask
))
18897 low
.set_const_val (low
.const_val () | negative_mask
);
18898 if (high
.kind () == PROP_CONST
18899 && !base_type
->is_unsigned () && (high
.const_val () & negative_mask
))
18900 high
.set_const_val (high
.const_val () | negative_mask
);
18902 /* Check for bit and byte strides. */
18903 struct dynamic_prop byte_stride_prop
;
18904 attribute
*attr_byte_stride
= dwarf2_attr (die
, DW_AT_byte_stride
, cu
);
18905 if (attr_byte_stride
!= nullptr)
18907 struct type
*prop_type
= cu
->addr_sized_int_type (false);
18908 attr_to_dynamic_prop (attr_byte_stride
, die
, cu
, &byte_stride_prop
,
18912 struct dynamic_prop bit_stride_prop
;
18913 attribute
*attr_bit_stride
= dwarf2_attr (die
, DW_AT_bit_stride
, cu
);
18914 if (attr_bit_stride
!= nullptr)
18916 /* It only makes sense to have either a bit or byte stride. */
18917 if (attr_byte_stride
!= nullptr)
18919 complaint (_("Found DW_AT_bit_stride and DW_AT_byte_stride "
18920 "- DIE at %s [in module %s]"),
18921 sect_offset_str (die
->sect_off
),
18922 objfile_name (cu
->per_objfile
->objfile
));
18923 attr_bit_stride
= nullptr;
18927 struct type
*prop_type
= cu
->addr_sized_int_type (false);
18928 attr_to_dynamic_prop (attr_bit_stride
, die
, cu
, &bit_stride_prop
,
18933 if (attr_byte_stride
!= nullptr
18934 || attr_bit_stride
!= nullptr)
18936 bool byte_stride_p
= (attr_byte_stride
!= nullptr);
18937 struct dynamic_prop
*stride
18938 = byte_stride_p
? &byte_stride_prop
: &bit_stride_prop
;
18941 = create_range_type_with_stride (NULL
, orig_base_type
, &low
,
18942 &high
, bias
, stride
, byte_stride_p
);
18945 range_type
= create_range_type (NULL
, orig_base_type
, &low
, &high
, bias
);
18947 if (high_bound_is_count
)
18948 range_type
->bounds ()->flag_upper_bound_is_count
= 1;
18950 /* Ada expects an empty array on no boundary attributes. */
18951 if (attr
== NULL
&& cu
->language
!= language_ada
)
18952 range_type
->bounds ()->high
.set_undefined ();
18954 name
= dwarf2_name (die
, cu
);
18956 range_type
->set_name (name
);
18958 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
18959 if (attr
!= nullptr)
18960 TYPE_LENGTH (range_type
) = attr
->constant_value (0);
18962 maybe_set_alignment (cu
, die
, range_type
);
18964 set_die_type (die
, range_type
, cu
);
18966 /* set_die_type should be already done. */
18967 set_descriptive_type (range_type
, die
, cu
);
18972 static struct type
*
18973 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18977 type
= init_type (cu
->per_objfile
->objfile
, TYPE_CODE_VOID
, 0, NULL
);
18978 type
->set_name (dwarf2_name (die
, cu
));
18980 /* In Ada, an unspecified type is typically used when the description
18981 of the type is deferred to a different unit. When encountering
18982 such a type, we treat it as a stub, and try to resolve it later on,
18984 if (cu
->language
== language_ada
)
18985 type
->set_is_stub (true);
18987 return set_die_type (die
, type
, cu
);
18990 /* Read a single die and all its descendents. Set the die's sibling
18991 field to NULL; set other fields in the die correctly, and set all
18992 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
18993 location of the info_ptr after reading all of those dies. PARENT
18994 is the parent of the die in question. */
18996 static struct die_info
*
18997 read_die_and_children (const struct die_reader_specs
*reader
,
18998 const gdb_byte
*info_ptr
,
18999 const gdb_byte
**new_info_ptr
,
19000 struct die_info
*parent
)
19002 struct die_info
*die
;
19003 const gdb_byte
*cur_ptr
;
19005 cur_ptr
= read_full_die_1 (reader
, &die
, info_ptr
, 0);
19008 *new_info_ptr
= cur_ptr
;
19011 store_in_ref_table (die
, reader
->cu
);
19013 if (die
->has_children
)
19014 die
->child
= read_die_and_siblings_1 (reader
, cur_ptr
, new_info_ptr
, die
);
19018 *new_info_ptr
= cur_ptr
;
19021 die
->sibling
= NULL
;
19022 die
->parent
= parent
;
19026 /* Read a die, all of its descendents, and all of its siblings; set
19027 all of the fields of all of the dies correctly. Arguments are as
19028 in read_die_and_children. */
19030 static struct die_info
*
19031 read_die_and_siblings_1 (const struct die_reader_specs
*reader
,
19032 const gdb_byte
*info_ptr
,
19033 const gdb_byte
**new_info_ptr
,
19034 struct die_info
*parent
)
19036 struct die_info
*first_die
, *last_sibling
;
19037 const gdb_byte
*cur_ptr
;
19039 cur_ptr
= info_ptr
;
19040 first_die
= last_sibling
= NULL
;
19044 struct die_info
*die
19045 = read_die_and_children (reader
, cur_ptr
, &cur_ptr
, parent
);
19049 *new_info_ptr
= cur_ptr
;
19056 last_sibling
->sibling
= die
;
19058 last_sibling
= die
;
19062 /* Read a die, all of its descendents, and all of its siblings; set
19063 all of the fields of all of the dies correctly. Arguments are as
19064 in read_die_and_children.
19065 This the main entry point for reading a DIE and all its children. */
19067 static struct die_info
*
19068 read_die_and_siblings (const struct die_reader_specs
*reader
,
19069 const gdb_byte
*info_ptr
,
19070 const gdb_byte
**new_info_ptr
,
19071 struct die_info
*parent
)
19073 struct die_info
*die
= read_die_and_siblings_1 (reader
, info_ptr
,
19074 new_info_ptr
, parent
);
19076 if (dwarf_die_debug
)
19078 fprintf_unfiltered (gdb_stdlog
,
19079 "Read die from %s@0x%x of %s:\n",
19080 reader
->die_section
->get_name (),
19081 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
19082 bfd_get_filename (reader
->abfd
));
19083 dump_die (die
, dwarf_die_debug
);
19089 /* Read a die and all its attributes, leave space for NUM_EXTRA_ATTRS
19091 The caller is responsible for filling in the extra attributes
19092 and updating (*DIEP)->num_attrs.
19093 Set DIEP to point to a newly allocated die with its information,
19094 except for its child, sibling, and parent fields. */
19096 static const gdb_byte
*
19097 read_full_die_1 (const struct die_reader_specs
*reader
,
19098 struct die_info
**diep
, const gdb_byte
*info_ptr
,
19099 int num_extra_attrs
)
19101 unsigned int abbrev_number
, bytes_read
, i
;
19102 const struct abbrev_info
*abbrev
;
19103 struct die_info
*die
;
19104 struct dwarf2_cu
*cu
= reader
->cu
;
19105 bfd
*abfd
= reader
->abfd
;
19107 sect_offset sect_off
= (sect_offset
) (info_ptr
- reader
->buffer
);
19108 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
19109 info_ptr
+= bytes_read
;
19110 if (!abbrev_number
)
19116 abbrev
= reader
->abbrev_table
->lookup_abbrev (abbrev_number
);
19118 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
19120 bfd_get_filename (abfd
));
19122 die
= dwarf_alloc_die (cu
, abbrev
->num_attrs
+ num_extra_attrs
);
19123 die
->sect_off
= sect_off
;
19124 die
->tag
= abbrev
->tag
;
19125 die
->abbrev
= abbrev_number
;
19126 die
->has_children
= abbrev
->has_children
;
19128 /* Make the result usable.
19129 The caller needs to update num_attrs after adding the extra
19131 die
->num_attrs
= abbrev
->num_attrs
;
19133 bool any_need_reprocess
= false;
19134 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
19136 info_ptr
= read_attribute (reader
, &die
->attrs
[i
], &abbrev
->attrs
[i
],
19138 if (die
->attrs
[i
].requires_reprocessing_p ())
19139 any_need_reprocess
= true;
19142 struct attribute
*attr
= die
->attr (DW_AT_str_offsets_base
);
19143 if (attr
!= nullptr && attr
->form_is_unsigned ())
19144 cu
->str_offsets_base
= attr
->as_unsigned ();
19146 attr
= die
->attr (DW_AT_loclists_base
);
19147 if (attr
!= nullptr)
19148 cu
->loclist_base
= attr
->as_unsigned ();
19150 auto maybe_addr_base
= die
->addr_base ();
19151 if (maybe_addr_base
.has_value ())
19152 cu
->addr_base
= *maybe_addr_base
;
19154 attr
= die
->attr (DW_AT_rnglists_base
);
19155 if (attr
!= nullptr)
19156 cu
->rnglists_base
= attr
->as_unsigned ();
19158 if (any_need_reprocess
)
19160 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
19162 if (die
->attrs
[i
].requires_reprocessing_p ())
19163 read_attribute_reprocess (reader
, &die
->attrs
[i
], die
->tag
);
19170 /* Read a die and all its attributes.
19171 Set DIEP to point to a newly allocated die with its information,
19172 except for its child, sibling, and parent fields. */
19174 static const gdb_byte
*
19175 read_full_die (const struct die_reader_specs
*reader
,
19176 struct die_info
**diep
, const gdb_byte
*info_ptr
)
19178 const gdb_byte
*result
;
19180 result
= read_full_die_1 (reader
, diep
, info_ptr
, 0);
19182 if (dwarf_die_debug
)
19184 fprintf_unfiltered (gdb_stdlog
,
19185 "Read die from %s@0x%x of %s:\n",
19186 reader
->die_section
->get_name (),
19187 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
19188 bfd_get_filename (reader
->abfd
));
19189 dump_die (*diep
, dwarf_die_debug
);
19196 /* Returns nonzero if TAG represents a type that we might generate a partial
19200 is_type_tag_for_partial (int tag
, enum language lang
)
19205 /* Some types that would be reasonable to generate partial symbols for,
19206 that we don't at present. Note that normally this does not
19207 matter, mainly because C compilers don't give names to these
19208 types, but instead emit DW_TAG_typedef. */
19209 case DW_TAG_file_type
:
19210 case DW_TAG_ptr_to_member_type
:
19211 case DW_TAG_set_type
:
19212 case DW_TAG_string_type
:
19213 case DW_TAG_subroutine_type
:
19216 /* GNAT may emit an array with a name, but no typedef, so we
19217 need to make a symbol in this case. */
19218 case DW_TAG_array_type
:
19219 return lang
== language_ada
;
19221 case DW_TAG_base_type
:
19222 case DW_TAG_class_type
:
19223 case DW_TAG_interface_type
:
19224 case DW_TAG_enumeration_type
:
19225 case DW_TAG_structure_type
:
19226 case DW_TAG_subrange_type
:
19227 case DW_TAG_typedef
:
19228 case DW_TAG_union_type
:
19235 /* Load all DIEs that are interesting for partial symbols into memory. */
19237 static struct partial_die_info
*
19238 load_partial_dies (const struct die_reader_specs
*reader
,
19239 const gdb_byte
*info_ptr
, int building_psymtab
)
19241 struct dwarf2_cu
*cu
= reader
->cu
;
19242 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
19243 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
19244 unsigned int bytes_read
;
19245 unsigned int load_all
= 0;
19246 int nesting_level
= 1;
19251 gdb_assert (cu
->per_cu
!= NULL
);
19252 if (cu
->per_cu
->load_all_dies
)
19256 = htab_create_alloc_ex (cu
->header
.length
/ 12,
19260 &cu
->comp_unit_obstack
,
19261 hashtab_obstack_allocate
,
19262 dummy_obstack_deallocate
);
19266 const abbrev_info
*abbrev
= peek_die_abbrev (*reader
, info_ptr
,
19269 /* A NULL abbrev means the end of a series of children. */
19270 if (abbrev
== NULL
)
19272 if (--nesting_level
== 0)
19275 info_ptr
+= bytes_read
;
19276 last_die
= parent_die
;
19277 parent_die
= parent_die
->die_parent
;
19281 /* Check for template arguments. We never save these; if
19282 they're seen, we just mark the parent, and go on our way. */
19283 if (parent_die
!= NULL
19284 && cu
->language
== language_cplus
19285 && (abbrev
->tag
== DW_TAG_template_type_param
19286 || abbrev
->tag
== DW_TAG_template_value_param
))
19288 parent_die
->has_template_arguments
= 1;
19292 /* We don't need a partial DIE for the template argument. */
19293 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
19298 /* We only recurse into c++ subprograms looking for template arguments.
19299 Skip their other children. */
19301 && cu
->language
== language_cplus
19302 && parent_die
!= NULL
19303 && parent_die
->tag
== DW_TAG_subprogram
19304 && abbrev
->tag
!= DW_TAG_inlined_subroutine
)
19306 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
19310 /* Check whether this DIE is interesting enough to save. Normally
19311 we would not be interested in members here, but there may be
19312 later variables referencing them via DW_AT_specification (for
19313 static members). */
19315 && !is_type_tag_for_partial (abbrev
->tag
, cu
->language
)
19316 && abbrev
->tag
!= DW_TAG_constant
19317 && abbrev
->tag
!= DW_TAG_enumerator
19318 && abbrev
->tag
!= DW_TAG_subprogram
19319 && abbrev
->tag
!= DW_TAG_inlined_subroutine
19320 && abbrev
->tag
!= DW_TAG_lexical_block
19321 && abbrev
->tag
!= DW_TAG_variable
19322 && abbrev
->tag
!= DW_TAG_namespace
19323 && abbrev
->tag
!= DW_TAG_module
19324 && abbrev
->tag
!= DW_TAG_member
19325 && abbrev
->tag
!= DW_TAG_imported_unit
19326 && abbrev
->tag
!= DW_TAG_imported_declaration
)
19328 /* Otherwise we skip to the next sibling, if any. */
19329 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
19333 struct partial_die_info
pdi ((sect_offset
) (info_ptr
- reader
->buffer
),
19336 info_ptr
= pdi
.read (reader
, *abbrev
, info_ptr
+ bytes_read
);
19338 /* This two-pass algorithm for processing partial symbols has a
19339 high cost in cache pressure. Thus, handle some simple cases
19340 here which cover the majority of C partial symbols. DIEs
19341 which neither have specification tags in them, nor could have
19342 specification tags elsewhere pointing at them, can simply be
19343 processed and discarded.
19345 This segment is also optional; scan_partial_symbols and
19346 add_partial_symbol will handle these DIEs if we chain
19347 them in normally. When compilers which do not emit large
19348 quantities of duplicate debug information are more common,
19349 this code can probably be removed. */
19351 /* Any complete simple types at the top level (pretty much all
19352 of them, for a language without namespaces), can be processed
19354 if (parent_die
== NULL
19355 && pdi
.has_specification
== 0
19356 && pdi
.is_declaration
== 0
19357 && ((pdi
.tag
== DW_TAG_typedef
&& !pdi
.has_children
)
19358 || pdi
.tag
== DW_TAG_base_type
19359 || pdi
.tag
== DW_TAG_array_type
19360 || pdi
.tag
== DW_TAG_subrange_type
))
19362 if (building_psymtab
&& pdi
.raw_name
!= NULL
)
19363 add_partial_symbol (&pdi
, cu
);
19365 info_ptr
= locate_pdi_sibling (reader
, &pdi
, info_ptr
);
19369 /* The exception for DW_TAG_typedef with has_children above is
19370 a workaround of GCC PR debug/47510. In the case of this complaint
19371 type_name_or_error will error on such types later.
19373 GDB skipped children of DW_TAG_typedef by the shortcut above and then
19374 it could not find the child DIEs referenced later, this is checked
19375 above. In correct DWARF DW_TAG_typedef should have no children. */
19377 if (pdi
.tag
== DW_TAG_typedef
&& pdi
.has_children
)
19378 complaint (_("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
19379 "- DIE at %s [in module %s]"),
19380 sect_offset_str (pdi
.sect_off
), objfile_name (objfile
));
19382 /* If we're at the second level, and we're an enumerator, and
19383 our parent has no specification (meaning possibly lives in a
19384 namespace elsewhere), then we can add the partial symbol now
19385 instead of queueing it. */
19386 if (pdi
.tag
== DW_TAG_enumerator
19387 && parent_die
!= NULL
19388 && parent_die
->die_parent
== NULL
19389 && parent_die
->tag
== DW_TAG_enumeration_type
19390 && parent_die
->has_specification
== 0)
19392 if (pdi
.raw_name
== NULL
)
19393 complaint (_("malformed enumerator DIE ignored"));
19394 else if (building_psymtab
)
19395 add_partial_symbol (&pdi
, cu
);
19397 info_ptr
= locate_pdi_sibling (reader
, &pdi
, info_ptr
);
19401 struct partial_die_info
*part_die
19402 = new (&cu
->comp_unit_obstack
) partial_die_info (pdi
);
19404 /* We'll save this DIE so link it in. */
19405 part_die
->die_parent
= parent_die
;
19406 part_die
->die_sibling
= NULL
;
19407 part_die
->die_child
= NULL
;
19409 if (last_die
&& last_die
== parent_die
)
19410 last_die
->die_child
= part_die
;
19412 last_die
->die_sibling
= part_die
;
19414 last_die
= part_die
;
19416 if (first_die
== NULL
)
19417 first_die
= part_die
;
19419 /* Maybe add the DIE to the hash table. Not all DIEs that we
19420 find interesting need to be in the hash table, because we
19421 also have the parent/sibling/child chains; only those that we
19422 might refer to by offset later during partial symbol reading.
19424 For now this means things that might have be the target of a
19425 DW_AT_specification, DW_AT_abstract_origin, or
19426 DW_AT_extension. DW_AT_extension will refer only to
19427 namespaces; DW_AT_abstract_origin refers to functions (and
19428 many things under the function DIE, but we do not recurse
19429 into function DIEs during partial symbol reading) and
19430 possibly variables as well; DW_AT_specification refers to
19431 declarations. Declarations ought to have the DW_AT_declaration
19432 flag. It happens that GCC forgets to put it in sometimes, but
19433 only for functions, not for types.
19435 Adding more things than necessary to the hash table is harmless
19436 except for the performance cost. Adding too few will result in
19437 wasted time in find_partial_die, when we reread the compilation
19438 unit with load_all_dies set. */
19441 || abbrev
->tag
== DW_TAG_constant
19442 || abbrev
->tag
== DW_TAG_subprogram
19443 || abbrev
->tag
== DW_TAG_variable
19444 || abbrev
->tag
== DW_TAG_namespace
19445 || part_die
->is_declaration
)
19449 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
19450 to_underlying (part_die
->sect_off
),
19455 /* For some DIEs we want to follow their children (if any). For C
19456 we have no reason to follow the children of structures; for other
19457 languages we have to, so that we can get at method physnames
19458 to infer fully qualified class names, for DW_AT_specification,
19459 and for C++ template arguments. For C++, we also look one level
19460 inside functions to find template arguments (if the name of the
19461 function does not already contain the template arguments).
19463 For Ada and Fortran, we need to scan the children of subprograms
19464 and lexical blocks as well because these languages allow the
19465 definition of nested entities that could be interesting for the
19466 debugger, such as nested subprograms for instance. */
19467 if (last_die
->has_children
19469 || last_die
->tag
== DW_TAG_namespace
19470 || last_die
->tag
== DW_TAG_module
19471 || last_die
->tag
== DW_TAG_enumeration_type
19472 || (cu
->language
== language_cplus
19473 && last_die
->tag
== DW_TAG_subprogram
19474 && (last_die
->raw_name
== NULL
19475 || strchr (last_die
->raw_name
, '<') == NULL
))
19476 || (cu
->language
!= language_c
19477 && (last_die
->tag
== DW_TAG_class_type
19478 || last_die
->tag
== DW_TAG_interface_type
19479 || last_die
->tag
== DW_TAG_structure_type
19480 || last_die
->tag
== DW_TAG_union_type
))
19481 || ((cu
->language
== language_ada
19482 || cu
->language
== language_fortran
)
19483 && (last_die
->tag
== DW_TAG_subprogram
19484 || last_die
->tag
== DW_TAG_lexical_block
))))
19487 parent_die
= last_die
;
19491 /* Otherwise we skip to the next sibling, if any. */
19492 info_ptr
= locate_pdi_sibling (reader
, last_die
, info_ptr
);
19494 /* Back to the top, do it again. */
19498 partial_die_info::partial_die_info (sect_offset sect_off_
,
19499 const struct abbrev_info
*abbrev
)
19500 : partial_die_info (sect_off_
, abbrev
->tag
, abbrev
->has_children
)
19504 /* See class definition. */
19507 partial_die_info::name (dwarf2_cu
*cu
)
19509 if (!canonical_name
&& raw_name
!= nullptr)
19511 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
19512 raw_name
= dwarf2_canonicalize_name (raw_name
, cu
, objfile
);
19513 canonical_name
= 1;
19519 /* Read a minimal amount of information into the minimal die structure.
19520 INFO_PTR should point just after the initial uleb128 of a DIE. */
19523 partial_die_info::read (const struct die_reader_specs
*reader
,
19524 const struct abbrev_info
&abbrev
, const gdb_byte
*info_ptr
)
19526 struct dwarf2_cu
*cu
= reader
->cu
;
19527 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
19529 int has_low_pc_attr
= 0;
19530 int has_high_pc_attr
= 0;
19531 int high_pc_relative
= 0;
19533 for (i
= 0; i
< abbrev
.num_attrs
; ++i
)
19536 info_ptr
= read_attribute (reader
, &attr
, &abbrev
.attrs
[i
], info_ptr
);
19537 /* String and address offsets that need to do the reprocessing have
19538 already been read at this point, so there is no need to wait until
19539 the loop terminates to do the reprocessing. */
19540 if (attr
.requires_reprocessing_p ())
19541 read_attribute_reprocess (reader
, &attr
, tag
);
19542 /* Store the data if it is of an attribute we want to keep in a
19543 partial symbol table. */
19549 case DW_TAG_compile_unit
:
19550 case DW_TAG_partial_unit
:
19551 case DW_TAG_type_unit
:
19552 /* Compilation units have a DW_AT_name that is a filename, not
19553 a source language identifier. */
19554 case DW_TAG_enumeration_type
:
19555 case DW_TAG_enumerator
:
19556 /* These tags always have simple identifiers already; no need
19557 to canonicalize them. */
19558 canonical_name
= 1;
19559 raw_name
= attr
.as_string ();
19562 canonical_name
= 0;
19563 raw_name
= attr
.as_string ();
19567 case DW_AT_linkage_name
:
19568 case DW_AT_MIPS_linkage_name
:
19569 /* Note that both forms of linkage name might appear. We
19570 assume they will be the same, and we only store the last
19572 linkage_name
= attr
.as_string ();
19575 has_low_pc_attr
= 1;
19576 lowpc
= attr
.as_address ();
19578 case DW_AT_high_pc
:
19579 has_high_pc_attr
= 1;
19580 highpc
= attr
.as_address ();
19581 if (cu
->header
.version
>= 4 && attr
.form_is_constant ())
19582 high_pc_relative
= 1;
19584 case DW_AT_location
:
19585 /* Support the .debug_loc offsets. */
19586 if (attr
.form_is_block ())
19588 d
.locdesc
= attr
.as_block ();
19590 else if (attr
.form_is_section_offset ())
19592 dwarf2_complex_location_expr_complaint ();
19596 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
19597 "partial symbol information");
19600 case DW_AT_external
:
19601 is_external
= attr
.as_boolean ();
19603 case DW_AT_declaration
:
19604 is_declaration
= attr
.as_boolean ();
19609 case DW_AT_abstract_origin
:
19610 case DW_AT_specification
:
19611 case DW_AT_extension
:
19612 has_specification
= 1;
19613 spec_offset
= attr
.get_ref_die_offset ();
19614 spec_is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
19615 || cu
->per_cu
->is_dwz
);
19617 case DW_AT_sibling
:
19618 /* Ignore absolute siblings, they might point outside of
19619 the current compile unit. */
19620 if (attr
.form
== DW_FORM_ref_addr
)
19621 complaint (_("ignoring absolute DW_AT_sibling"));
19624 const gdb_byte
*buffer
= reader
->buffer
;
19625 sect_offset off
= attr
.get_ref_die_offset ();
19626 const gdb_byte
*sibling_ptr
= buffer
+ to_underlying (off
);
19628 if (sibling_ptr
< info_ptr
)
19629 complaint (_("DW_AT_sibling points backwards"));
19630 else if (sibling_ptr
> reader
->buffer_end
)
19631 reader
->die_section
->overflow_complaint ();
19633 sibling
= sibling_ptr
;
19636 case DW_AT_byte_size
:
19639 case DW_AT_const_value
:
19640 has_const_value
= 1;
19642 case DW_AT_calling_convention
:
19643 /* DWARF doesn't provide a way to identify a program's source-level
19644 entry point. DW_AT_calling_convention attributes are only meant
19645 to describe functions' calling conventions.
19647 However, because it's a necessary piece of information in
19648 Fortran, and before DWARF 4 DW_CC_program was the only
19649 piece of debugging information whose definition refers to
19650 a 'main program' at all, several compilers marked Fortran
19651 main programs with DW_CC_program --- even when those
19652 functions use the standard calling conventions.
19654 Although DWARF now specifies a way to provide this
19655 information, we support this practice for backward
19657 if (attr
.constant_value (0) == DW_CC_program
19658 && cu
->language
== language_fortran
)
19659 main_subprogram
= 1;
19663 LONGEST value
= attr
.constant_value (-1);
19664 if (value
== DW_INL_inlined
19665 || value
== DW_INL_declared_inlined
)
19666 may_be_inlined
= 1;
19671 if (tag
== DW_TAG_imported_unit
)
19673 d
.sect_off
= attr
.get_ref_die_offset ();
19674 is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
19675 || cu
->per_cu
->is_dwz
);
19679 case DW_AT_main_subprogram
:
19680 main_subprogram
= attr
.as_boolean ();
19685 /* Offset in the .debug_ranges or .debug_rnglist section (depending
19686 on DWARF version). */
19687 ULONGEST ranges_offset
= attr
.as_unsigned ();
19689 /* See dwarf2_cu::gnu_ranges_base's doc for why we might want to add
19691 if (tag
!= DW_TAG_compile_unit
)
19692 ranges_offset
+= cu
->gnu_ranges_base
;
19694 if (dwarf2_ranges_read (ranges_offset
, &lowpc
, &highpc
, cu
,
19705 /* For Ada, if both the name and the linkage name appear, we prefer
19706 the latter. This lets "catch exception" work better, regardless
19707 of the order in which the name and linkage name were emitted.
19708 Really, though, this is just a workaround for the fact that gdb
19709 doesn't store both the name and the linkage name. */
19710 if (cu
->language
== language_ada
&& linkage_name
!= nullptr)
19711 raw_name
= linkage_name
;
19713 if (high_pc_relative
)
19716 if (has_low_pc_attr
&& has_high_pc_attr
)
19718 /* When using the GNU linker, .gnu.linkonce. sections are used to
19719 eliminate duplicate copies of functions and vtables and such.
19720 The linker will arbitrarily choose one and discard the others.
19721 The AT_*_pc values for such functions refer to local labels in
19722 these sections. If the section from that file was discarded, the
19723 labels are not in the output, so the relocs get a value of 0.
19724 If this is a discarded function, mark the pc bounds as invalid,
19725 so that GDB will ignore it. */
19726 if (lowpc
== 0 && !per_objfile
->per_bfd
->has_section_at_zero
)
19728 struct objfile
*objfile
= per_objfile
->objfile
;
19729 struct gdbarch
*gdbarch
= objfile
->arch ();
19731 complaint (_("DW_AT_low_pc %s is zero "
19732 "for DIE at %s [in module %s]"),
19733 paddress (gdbarch
, lowpc
),
19734 sect_offset_str (sect_off
),
19735 objfile_name (objfile
));
19737 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
19738 else if (lowpc
>= highpc
)
19740 struct objfile
*objfile
= per_objfile
->objfile
;
19741 struct gdbarch
*gdbarch
= objfile
->arch ();
19743 complaint (_("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
19744 "for DIE at %s [in module %s]"),
19745 paddress (gdbarch
, lowpc
),
19746 paddress (gdbarch
, highpc
),
19747 sect_offset_str (sect_off
),
19748 objfile_name (objfile
));
19757 /* Find a cached partial DIE at OFFSET in CU. */
19759 struct partial_die_info
*
19760 dwarf2_cu::find_partial_die (sect_offset sect_off
)
19762 struct partial_die_info
*lookup_die
= NULL
;
19763 struct partial_die_info
part_die (sect_off
);
19765 lookup_die
= ((struct partial_die_info
*)
19766 htab_find_with_hash (partial_dies
, &part_die
,
19767 to_underlying (sect_off
)));
19772 /* Find a partial DIE at OFFSET, which may or may not be in CU,
19773 except in the case of .debug_types DIEs which do not reference
19774 outside their CU (they do however referencing other types via
19775 DW_FORM_ref_sig8). */
19777 static const struct cu_partial_die_info
19778 find_partial_die (sect_offset sect_off
, int offset_in_dwz
, struct dwarf2_cu
*cu
)
19780 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
19781 struct objfile
*objfile
= per_objfile
->objfile
;
19782 struct partial_die_info
*pd
= NULL
;
19784 if (offset_in_dwz
== cu
->per_cu
->is_dwz
19785 && cu
->header
.offset_in_cu_p (sect_off
))
19787 pd
= cu
->find_partial_die (sect_off
);
19790 /* We missed recording what we needed.
19791 Load all dies and try again. */
19795 /* TUs don't reference other CUs/TUs (except via type signatures). */
19796 if (cu
->per_cu
->is_debug_types
)
19798 error (_("Dwarf Error: Type Unit at offset %s contains"
19799 " external reference to offset %s [in module %s].\n"),
19800 sect_offset_str (cu
->header
.sect_off
), sect_offset_str (sect_off
),
19801 bfd_get_filename (objfile
->obfd
));
19803 dwarf2_per_cu_data
*per_cu
19804 = dwarf2_find_containing_comp_unit (sect_off
, offset_in_dwz
,
19807 cu
= per_objfile
->get_cu (per_cu
);
19808 if (cu
== NULL
|| cu
->partial_dies
== NULL
)
19809 load_partial_comp_unit (per_cu
, per_objfile
, nullptr);
19811 cu
= per_objfile
->get_cu (per_cu
);
19814 pd
= cu
->find_partial_die (sect_off
);
19817 /* If we didn't find it, and not all dies have been loaded,
19818 load them all and try again. */
19820 if (pd
== NULL
&& cu
->per_cu
->load_all_dies
== 0)
19822 cu
->per_cu
->load_all_dies
= 1;
19824 /* This is nasty. When we reread the DIEs, somewhere up the call chain
19825 THIS_CU->cu may already be in use. So we can't just free it and
19826 replace its DIEs with the ones we read in. Instead, we leave those
19827 DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
19828 and clobber THIS_CU->cu->partial_dies with the hash table for the new
19830 load_partial_comp_unit (cu
->per_cu
, per_objfile
, cu
);
19832 pd
= cu
->find_partial_die (sect_off
);
19836 error (_("Dwarf Error: Cannot not find DIE at %s [from module %s]\n"),
19837 sect_offset_str (sect_off
), bfd_get_filename (objfile
->obfd
));
19841 /* See if we can figure out if the class lives in a namespace. We do
19842 this by looking for a member function; its demangled name will
19843 contain namespace info, if there is any. */
19846 guess_partial_die_structure_name (struct partial_die_info
*struct_pdi
,
19847 struct dwarf2_cu
*cu
)
19849 /* NOTE: carlton/2003-10-07: Getting the info this way changes
19850 what template types look like, because the demangler
19851 frequently doesn't give the same name as the debug info. We
19852 could fix this by only using the demangled name to get the
19853 prefix (but see comment in read_structure_type). */
19855 struct partial_die_info
*real_pdi
;
19856 struct partial_die_info
*child_pdi
;
19858 /* If this DIE (this DIE's specification, if any) has a parent, then
19859 we should not do this. We'll prepend the parent's fully qualified
19860 name when we create the partial symbol. */
19862 real_pdi
= struct_pdi
;
19863 while (real_pdi
->has_specification
)
19865 auto res
= find_partial_die (real_pdi
->spec_offset
,
19866 real_pdi
->spec_is_dwz
, cu
);
19867 real_pdi
= res
.pdi
;
19871 if (real_pdi
->die_parent
!= NULL
)
19874 for (child_pdi
= struct_pdi
->die_child
;
19876 child_pdi
= child_pdi
->die_sibling
)
19878 if (child_pdi
->tag
== DW_TAG_subprogram
19879 && child_pdi
->linkage_name
!= NULL
)
19881 gdb::unique_xmalloc_ptr
<char> actual_class_name
19882 (cu
->language_defn
->class_name_from_physname
19883 (child_pdi
->linkage_name
));
19884 if (actual_class_name
!= NULL
)
19886 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
19887 struct_pdi
->raw_name
= objfile
->intern (actual_class_name
.get ());
19888 struct_pdi
->canonical_name
= 1;
19895 /* Return true if a DIE with TAG may have the DW_AT_const_value
19899 can_have_DW_AT_const_value_p (enum dwarf_tag tag
)
19903 case DW_TAG_constant
:
19904 case DW_TAG_enumerator
:
19905 case DW_TAG_formal_parameter
:
19906 case DW_TAG_template_value_param
:
19907 case DW_TAG_variable
:
19915 partial_die_info::fixup (struct dwarf2_cu
*cu
)
19917 /* Once we've fixed up a die, there's no point in doing so again.
19918 This also avoids a memory leak if we were to call
19919 guess_partial_die_structure_name multiple times. */
19923 /* If we found a reference attribute and the DIE has no name, try
19924 to find a name in the referred to DIE. */
19926 if (raw_name
== NULL
&& has_specification
)
19928 struct partial_die_info
*spec_die
;
19930 auto res
= find_partial_die (spec_offset
, spec_is_dwz
, cu
);
19931 spec_die
= res
.pdi
;
19934 spec_die
->fixup (cu
);
19936 if (spec_die
->raw_name
)
19938 raw_name
= spec_die
->raw_name
;
19939 canonical_name
= spec_die
->canonical_name
;
19941 /* Copy DW_AT_external attribute if it is set. */
19942 if (spec_die
->is_external
)
19943 is_external
= spec_die
->is_external
;
19947 if (!has_const_value
&& has_specification
19948 && can_have_DW_AT_const_value_p (tag
))
19950 struct partial_die_info
*spec_die
;
19952 auto res
= find_partial_die (spec_offset
, spec_is_dwz
, cu
);
19953 spec_die
= res
.pdi
;
19956 spec_die
->fixup (cu
);
19958 if (spec_die
->has_const_value
)
19960 /* Copy DW_AT_const_value attribute if it is set. */
19961 has_const_value
= spec_die
->has_const_value
;
19965 /* Set default names for some unnamed DIEs. */
19967 if (raw_name
== NULL
&& tag
== DW_TAG_namespace
)
19969 raw_name
= CP_ANONYMOUS_NAMESPACE_STR
;
19970 canonical_name
= 1;
19973 /* If there is no parent die to provide a namespace, and there are
19974 children, see if we can determine the namespace from their linkage
19976 if (cu
->language
== language_cplus
19977 && !cu
->per_objfile
->per_bfd
->types
.empty ()
19978 && die_parent
== NULL
19980 && (tag
== DW_TAG_class_type
19981 || tag
== DW_TAG_structure_type
19982 || tag
== DW_TAG_union_type
))
19983 guess_partial_die_structure_name (this, cu
);
19985 /* GCC might emit a nameless struct or union that has a linkage
19986 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
19987 if (raw_name
== NULL
19988 && (tag
== DW_TAG_class_type
19989 || tag
== DW_TAG_interface_type
19990 || tag
== DW_TAG_structure_type
19991 || tag
== DW_TAG_union_type
)
19992 && linkage_name
!= NULL
)
19994 gdb::unique_xmalloc_ptr
<char> demangled
19995 (gdb_demangle (linkage_name
, DMGL_TYPES
));
19996 if (demangled
!= nullptr)
20000 /* Strip any leading namespaces/classes, keep only the base name.
20001 DW_AT_name for named DIEs does not contain the prefixes. */
20002 base
= strrchr (demangled
.get (), ':');
20003 if (base
&& base
> demangled
.get () && base
[-1] == ':')
20006 base
= demangled
.get ();
20008 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
20009 raw_name
= objfile
->intern (base
);
20010 canonical_name
= 1;
20017 /* Read the .debug_loclists or .debug_rnglists header (they are the same format)
20018 contents from the given SECTION in the HEADER.
20020 HEADER_OFFSET is the offset of the header in the section. */
20022 read_loclists_rnglists_header (struct loclists_rnglists_header
*header
,
20023 struct dwarf2_section_info
*section
,
20024 sect_offset header_offset
)
20026 unsigned int bytes_read
;
20027 bfd
*abfd
= section
->get_bfd_owner ();
20028 const gdb_byte
*info_ptr
= section
->buffer
+ to_underlying (header_offset
);
20030 header
->length
= read_initial_length (abfd
, info_ptr
, &bytes_read
);
20031 info_ptr
+= bytes_read
;
20033 header
->version
= read_2_bytes (abfd
, info_ptr
);
20036 header
->addr_size
= read_1_byte (abfd
, info_ptr
);
20039 header
->segment_collector_size
= read_1_byte (abfd
, info_ptr
);
20042 header
->offset_entry_count
= read_4_bytes (abfd
, info_ptr
);
20045 /* Return the DW_AT_loclists_base value for the CU. */
20047 lookup_loclist_base (struct dwarf2_cu
*cu
)
20049 /* For the .dwo unit, the loclist_base points to the first offset following
20050 the header. The header consists of the following entities-
20051 1. Unit Length (4 bytes for 32 bit DWARF format, and 12 bytes for the 64
20053 2. version (2 bytes)
20054 3. address size (1 byte)
20055 4. segment selector size (1 byte)
20056 5. offset entry count (4 bytes)
20057 These sizes are derived as per the DWARFv5 standard. */
20058 if (cu
->dwo_unit
!= nullptr)
20060 if (cu
->header
.initial_length_size
== 4)
20061 return LOCLIST_HEADER_SIZE32
;
20062 return LOCLIST_HEADER_SIZE64
;
20064 return cu
->loclist_base
;
20067 /* Given a DW_FORM_loclistx value LOCLIST_INDEX, fetch the offset from the
20068 array of offsets in the .debug_loclists section. */
20071 read_loclist_index (struct dwarf2_cu
*cu
, ULONGEST loclist_index
)
20073 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
20074 struct objfile
*objfile
= per_objfile
->objfile
;
20075 bfd
*abfd
= objfile
->obfd
;
20076 ULONGEST loclist_header_size
=
20077 (cu
->header
.initial_length_size
== 4 ? LOCLIST_HEADER_SIZE32
20078 : LOCLIST_HEADER_SIZE64
);
20079 ULONGEST loclist_base
= lookup_loclist_base (cu
);
20081 /* Offset in .debug_loclists of the offset for LOCLIST_INDEX. */
20082 ULONGEST start_offset
=
20083 loclist_base
+ loclist_index
* cu
->header
.offset_size
;
20085 /* Get loclists section. */
20086 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
20088 /* Read the loclists section content. */
20089 section
->read (objfile
);
20090 if (section
->buffer
== NULL
)
20091 error (_("DW_FORM_loclistx used without .debug_loclists "
20092 "section [in module %s]"), objfile_name (objfile
));
20094 /* DW_AT_loclists_base points after the .debug_loclists contribution header,
20095 so if loclist_base is smaller than the header size, we have a problem. */
20096 if (loclist_base
< loclist_header_size
)
20097 error (_("DW_AT_loclists_base is smaller than header size [in module %s]"),
20098 objfile_name (objfile
));
20100 /* Read the header of the loclists contribution. */
20101 struct loclists_rnglists_header header
;
20102 read_loclists_rnglists_header (&header
, section
,
20103 (sect_offset
) (loclist_base
- loclist_header_size
));
20105 /* Verify the loclist index is valid. */
20106 if (loclist_index
>= header
.offset_entry_count
)
20107 error (_("DW_FORM_loclistx pointing outside of "
20108 ".debug_loclists offset array [in module %s]"),
20109 objfile_name (objfile
));
20111 /* Validate that reading won't go beyond the end of the section. */
20112 if (start_offset
+ cu
->header
.offset_size
> section
->size
)
20113 error (_("Reading DW_FORM_loclistx index beyond end of"
20114 ".debug_loclists section [in module %s]"),
20115 objfile_name (objfile
));
20117 const gdb_byte
*info_ptr
= section
->buffer
+ start_offset
;
20119 if (cu
->header
.offset_size
== 4)
20120 return (sect_offset
) (bfd_get_32 (abfd
, info_ptr
) + loclist_base
);
20122 return (sect_offset
) (bfd_get_64 (abfd
, info_ptr
) + loclist_base
);
20125 /* Given a DW_FORM_rnglistx value RNGLIST_INDEX, fetch the offset from the
20126 array of offsets in the .debug_rnglists section. */
20129 read_rnglist_index (struct dwarf2_cu
*cu
, ULONGEST rnglist_index
,
20132 struct dwarf2_per_objfile
*dwarf2_per_objfile
= cu
->per_objfile
;
20133 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
20134 bfd
*abfd
= objfile
->obfd
;
20135 ULONGEST rnglist_header_size
=
20136 (cu
->header
.initial_length_size
== 4 ? RNGLIST_HEADER_SIZE32
20137 : RNGLIST_HEADER_SIZE64
);
20139 /* When reading a DW_FORM_rnglistx from a DWO, we read from the DWO's
20140 .debug_rnglists.dwo section. The rnglists base given in the skeleton
20142 ULONGEST rnglist_base
=
20143 (cu
->dwo_unit
!= nullptr) ? rnglist_header_size
: cu
->rnglists_base
;
20145 /* Offset in .debug_rnglists of the offset for RNGLIST_INDEX. */
20146 ULONGEST start_offset
=
20147 rnglist_base
+ rnglist_index
* cu
->header
.offset_size
;
20149 /* Get rnglists section. */
20150 struct dwarf2_section_info
*section
= cu_debug_rnglists_section (cu
, tag
);
20152 /* Read the rnglists section content. */
20153 section
->read (objfile
);
20154 if (section
->buffer
== nullptr)
20155 error (_("DW_FORM_rnglistx used without .debug_rnglists section "
20157 objfile_name (objfile
));
20159 /* DW_AT_rnglists_base points after the .debug_rnglists contribution header,
20160 so if rnglist_base is smaller than the header size, we have a problem. */
20161 if (rnglist_base
< rnglist_header_size
)
20162 error (_("DW_AT_rnglists_base is smaller than header size [in module %s]"),
20163 objfile_name (objfile
));
20165 /* Read the header of the rnglists contribution. */
20166 struct loclists_rnglists_header header
;
20167 read_loclists_rnglists_header (&header
, section
,
20168 (sect_offset
) (rnglist_base
- rnglist_header_size
));
20170 /* Verify the rnglist index is valid. */
20171 if (rnglist_index
>= header
.offset_entry_count
)
20172 error (_("DW_FORM_rnglistx index pointing outside of "
20173 ".debug_rnglists offset array [in module %s]"),
20174 objfile_name (objfile
));
20176 /* Validate that reading won't go beyond the end of the section. */
20177 if (start_offset
+ cu
->header
.offset_size
> section
->size
)
20178 error (_("Reading DW_FORM_rnglistx index beyond end of"
20179 ".debug_rnglists section [in module %s]"),
20180 objfile_name (objfile
));
20182 const gdb_byte
*info_ptr
= section
->buffer
+ start_offset
;
20184 if (cu
->header
.offset_size
== 4)
20185 return (sect_offset
) (read_4_bytes (abfd
, info_ptr
) + rnglist_base
);
20187 return (sect_offset
) (read_8_bytes (abfd
, info_ptr
) + rnglist_base
);
20190 /* Process the attributes that had to be skipped in the first round. These
20191 attributes are the ones that need str_offsets_base or addr_base attributes.
20192 They could not have been processed in the first round, because at the time
20193 the values of str_offsets_base or addr_base may not have been known. */
20195 read_attribute_reprocess (const struct die_reader_specs
*reader
,
20196 struct attribute
*attr
, dwarf_tag tag
)
20198 struct dwarf2_cu
*cu
= reader
->cu
;
20199 switch (attr
->form
)
20201 case DW_FORM_addrx
:
20202 case DW_FORM_GNU_addr_index
:
20203 attr
->set_address (read_addr_index (cu
,
20204 attr
->as_unsigned_reprocess ()));
20206 case DW_FORM_loclistx
:
20208 sect_offset loclists_sect_off
20209 = read_loclist_index (cu
, attr
->as_unsigned_reprocess ());
20211 attr
->set_unsigned (to_underlying (loclists_sect_off
));
20214 case DW_FORM_rnglistx
:
20216 sect_offset rnglists_sect_off
20217 = read_rnglist_index (cu
, attr
->as_unsigned_reprocess (), tag
);
20219 attr
->set_unsigned (to_underlying (rnglists_sect_off
));
20223 case DW_FORM_strx1
:
20224 case DW_FORM_strx2
:
20225 case DW_FORM_strx3
:
20226 case DW_FORM_strx4
:
20227 case DW_FORM_GNU_str_index
:
20229 unsigned int str_index
= attr
->as_unsigned_reprocess ();
20230 gdb_assert (!attr
->canonical_string_p ());
20231 if (reader
->dwo_file
!= NULL
)
20232 attr
->set_string_noncanonical (read_dwo_str_index (reader
,
20235 attr
->set_string_noncanonical (read_stub_str_index (cu
,
20240 gdb_assert_not_reached (_("Unexpected DWARF form."));
20244 /* Read an attribute value described by an attribute form. */
20246 static const gdb_byte
*
20247 read_attribute_value (const struct die_reader_specs
*reader
,
20248 struct attribute
*attr
, unsigned form
,
20249 LONGEST implicit_const
, const gdb_byte
*info_ptr
)
20251 struct dwarf2_cu
*cu
= reader
->cu
;
20252 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
20253 struct objfile
*objfile
= per_objfile
->objfile
;
20254 bfd
*abfd
= reader
->abfd
;
20255 struct comp_unit_head
*cu_header
= &cu
->header
;
20256 unsigned int bytes_read
;
20257 struct dwarf_block
*blk
;
20259 attr
->form
= (enum dwarf_form
) form
;
20262 case DW_FORM_ref_addr
:
20263 if (cu_header
->version
== 2)
20264 attr
->set_unsigned (cu_header
->read_address (abfd
, info_ptr
,
20267 attr
->set_unsigned (cu_header
->read_offset (abfd
, info_ptr
,
20269 info_ptr
+= bytes_read
;
20271 case DW_FORM_GNU_ref_alt
:
20272 attr
->set_unsigned (cu_header
->read_offset (abfd
, info_ptr
,
20274 info_ptr
+= bytes_read
;
20278 struct gdbarch
*gdbarch
= objfile
->arch ();
20279 CORE_ADDR addr
= cu_header
->read_address (abfd
, info_ptr
, &bytes_read
);
20280 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, addr
);
20281 attr
->set_address (addr
);
20282 info_ptr
+= bytes_read
;
20285 case DW_FORM_block2
:
20286 blk
= dwarf_alloc_block (cu
);
20287 blk
->size
= read_2_bytes (abfd
, info_ptr
);
20289 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
20290 info_ptr
+= blk
->size
;
20291 attr
->set_block (blk
);
20293 case DW_FORM_block4
:
20294 blk
= dwarf_alloc_block (cu
);
20295 blk
->size
= read_4_bytes (abfd
, info_ptr
);
20297 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
20298 info_ptr
+= blk
->size
;
20299 attr
->set_block (blk
);
20301 case DW_FORM_data2
:
20302 attr
->set_unsigned (read_2_bytes (abfd
, info_ptr
));
20305 case DW_FORM_data4
:
20306 attr
->set_unsigned (read_4_bytes (abfd
, info_ptr
));
20309 case DW_FORM_data8
:
20310 attr
->set_unsigned (read_8_bytes (abfd
, info_ptr
));
20313 case DW_FORM_data16
:
20314 blk
= dwarf_alloc_block (cu
);
20316 blk
->data
= read_n_bytes (abfd
, info_ptr
, 16);
20318 attr
->set_block (blk
);
20320 case DW_FORM_sec_offset
:
20321 attr
->set_unsigned (cu_header
->read_offset (abfd
, info_ptr
,
20323 info_ptr
+= bytes_read
;
20325 case DW_FORM_loclistx
:
20327 attr
->set_unsigned_reprocess (read_unsigned_leb128 (abfd
, info_ptr
,
20329 info_ptr
+= bytes_read
;
20332 case DW_FORM_string
:
20333 attr
->set_string_noncanonical (read_direct_string (abfd
, info_ptr
,
20335 info_ptr
+= bytes_read
;
20338 if (!cu
->per_cu
->is_dwz
)
20340 attr
->set_string_noncanonical
20341 (read_indirect_string (per_objfile
,
20342 abfd
, info_ptr
, cu_header
,
20344 info_ptr
+= bytes_read
;
20348 case DW_FORM_line_strp
:
20349 if (!cu
->per_cu
->is_dwz
)
20351 attr
->set_string_noncanonical
20352 (per_objfile
->read_line_string (info_ptr
, cu_header
,
20354 info_ptr
+= bytes_read
;
20358 case DW_FORM_GNU_strp_alt
:
20360 dwz_file
*dwz
= dwarf2_get_dwz_file (per_objfile
->per_bfd
, true);
20361 LONGEST str_offset
= cu_header
->read_offset (abfd
, info_ptr
,
20364 attr
->set_string_noncanonical
20365 (dwz
->read_string (objfile
, str_offset
));
20366 info_ptr
+= bytes_read
;
20369 case DW_FORM_exprloc
:
20370 case DW_FORM_block
:
20371 blk
= dwarf_alloc_block (cu
);
20372 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
20373 info_ptr
+= bytes_read
;
20374 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
20375 info_ptr
+= blk
->size
;
20376 attr
->set_block (blk
);
20378 case DW_FORM_block1
:
20379 blk
= dwarf_alloc_block (cu
);
20380 blk
->size
= read_1_byte (abfd
, info_ptr
);
20382 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
20383 info_ptr
+= blk
->size
;
20384 attr
->set_block (blk
);
20386 case DW_FORM_data1
:
20388 attr
->set_unsigned (read_1_byte (abfd
, info_ptr
));
20391 case DW_FORM_flag_present
:
20392 attr
->set_unsigned (1);
20394 case DW_FORM_sdata
:
20395 attr
->set_signed (read_signed_leb128 (abfd
, info_ptr
, &bytes_read
));
20396 info_ptr
+= bytes_read
;
20398 case DW_FORM_rnglistx
:
20400 attr
->set_unsigned_reprocess (read_unsigned_leb128 (abfd
, info_ptr
,
20402 info_ptr
+= bytes_read
;
20405 case DW_FORM_udata
:
20406 attr
->set_unsigned (read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
20407 info_ptr
+= bytes_read
;
20410 attr
->set_unsigned ((to_underlying (cu_header
->sect_off
)
20411 + read_1_byte (abfd
, info_ptr
)));
20415 attr
->set_unsigned ((to_underlying (cu_header
->sect_off
)
20416 + read_2_bytes (abfd
, info_ptr
)));
20420 attr
->set_unsigned ((to_underlying (cu_header
->sect_off
)
20421 + read_4_bytes (abfd
, info_ptr
)));
20425 attr
->set_unsigned ((to_underlying (cu_header
->sect_off
)
20426 + read_8_bytes (abfd
, info_ptr
)));
20429 case DW_FORM_ref_sig8
:
20430 attr
->set_signature (read_8_bytes (abfd
, info_ptr
));
20433 case DW_FORM_ref_udata
:
20434 attr
->set_unsigned ((to_underlying (cu_header
->sect_off
)
20435 + read_unsigned_leb128 (abfd
, info_ptr
,
20437 info_ptr
+= bytes_read
;
20439 case DW_FORM_indirect
:
20440 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
20441 info_ptr
+= bytes_read
;
20442 if (form
== DW_FORM_implicit_const
)
20444 implicit_const
= read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
20445 info_ptr
+= bytes_read
;
20447 info_ptr
= read_attribute_value (reader
, attr
, form
, implicit_const
,
20450 case DW_FORM_implicit_const
:
20451 attr
->set_signed (implicit_const
);
20453 case DW_FORM_addrx
:
20454 case DW_FORM_GNU_addr_index
:
20455 attr
->set_unsigned_reprocess (read_unsigned_leb128 (abfd
, info_ptr
,
20457 info_ptr
+= bytes_read
;
20460 case DW_FORM_strx1
:
20461 case DW_FORM_strx2
:
20462 case DW_FORM_strx3
:
20463 case DW_FORM_strx4
:
20464 case DW_FORM_GNU_str_index
:
20466 ULONGEST str_index
;
20467 if (form
== DW_FORM_strx1
)
20469 str_index
= read_1_byte (abfd
, info_ptr
);
20472 else if (form
== DW_FORM_strx2
)
20474 str_index
= read_2_bytes (abfd
, info_ptr
);
20477 else if (form
== DW_FORM_strx3
)
20479 str_index
= read_3_bytes (abfd
, info_ptr
);
20482 else if (form
== DW_FORM_strx4
)
20484 str_index
= read_4_bytes (abfd
, info_ptr
);
20489 str_index
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
20490 info_ptr
+= bytes_read
;
20492 attr
->set_unsigned_reprocess (str_index
);
20496 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
20497 dwarf_form_name (form
),
20498 bfd_get_filename (abfd
));
20502 if (cu
->per_cu
->is_dwz
&& attr
->form_is_ref ())
20503 attr
->form
= DW_FORM_GNU_ref_alt
;
20505 /* We have seen instances where the compiler tried to emit a byte
20506 size attribute of -1 which ended up being encoded as an unsigned
20507 0xffffffff. Although 0xffffffff is technically a valid size value,
20508 an object of this size seems pretty unlikely so we can relatively
20509 safely treat these cases as if the size attribute was invalid and
20510 treat them as zero by default. */
20511 if (attr
->name
== DW_AT_byte_size
20512 && form
== DW_FORM_data4
20513 && attr
->as_unsigned () >= 0xffffffff)
20516 (_("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
20517 hex_string (attr
->as_unsigned ()));
20518 attr
->set_unsigned (0);
20524 /* Read an attribute described by an abbreviated attribute. */
20526 static const gdb_byte
*
20527 read_attribute (const struct die_reader_specs
*reader
,
20528 struct attribute
*attr
, const struct attr_abbrev
*abbrev
,
20529 const gdb_byte
*info_ptr
)
20531 attr
->name
= abbrev
->name
;
20532 attr
->string_is_canonical
= 0;
20533 attr
->requires_reprocessing
= 0;
20534 return read_attribute_value (reader
, attr
, abbrev
->form
,
20535 abbrev
->implicit_const
, info_ptr
);
20538 /* Return pointer to string at .debug_str offset STR_OFFSET. */
20540 static const char *
20541 read_indirect_string_at_offset (dwarf2_per_objfile
*per_objfile
,
20542 LONGEST str_offset
)
20544 return per_objfile
->per_bfd
->str
.read_string (per_objfile
->objfile
,
20545 str_offset
, "DW_FORM_strp");
20548 /* Return pointer to string at .debug_str offset as read from BUF.
20549 BUF is assumed to be in a compilation unit described by CU_HEADER.
20550 Return *BYTES_READ_PTR count of bytes read from BUF. */
20552 static const char *
20553 read_indirect_string (dwarf2_per_objfile
*per_objfile
, bfd
*abfd
,
20554 const gdb_byte
*buf
,
20555 const struct comp_unit_head
*cu_header
,
20556 unsigned int *bytes_read_ptr
)
20558 LONGEST str_offset
= cu_header
->read_offset (abfd
, buf
, bytes_read_ptr
);
20560 return read_indirect_string_at_offset (per_objfile
, str_offset
);
20566 dwarf2_per_objfile::read_line_string (const gdb_byte
*buf
,
20567 const struct comp_unit_head
*cu_header
,
20568 unsigned int *bytes_read_ptr
)
20570 bfd
*abfd
= objfile
->obfd
;
20571 LONGEST str_offset
= cu_header
->read_offset (abfd
, buf
, bytes_read_ptr
);
20573 return per_bfd
->line_str
.read_string (objfile
, str_offset
, "DW_FORM_line_strp");
20576 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
20577 ADDR_BASE is the DW_AT_addr_base (DW_AT_GNU_addr_base) attribute or zero.
20578 ADDR_SIZE is the size of addresses from the CU header. */
20581 read_addr_index_1 (dwarf2_per_objfile
*per_objfile
, unsigned int addr_index
,
20582 gdb::optional
<ULONGEST
> addr_base
, int addr_size
)
20584 struct objfile
*objfile
= per_objfile
->objfile
;
20585 bfd
*abfd
= objfile
->obfd
;
20586 const gdb_byte
*info_ptr
;
20587 ULONGEST addr_base_or_zero
= addr_base
.has_value () ? *addr_base
: 0;
20589 per_objfile
->per_bfd
->addr
.read (objfile
);
20590 if (per_objfile
->per_bfd
->addr
.buffer
== NULL
)
20591 error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
20592 objfile_name (objfile
));
20593 if (addr_base_or_zero
+ addr_index
* addr_size
20594 >= per_objfile
->per_bfd
->addr
.size
)
20595 error (_("DW_FORM_addr_index pointing outside of "
20596 ".debug_addr section [in module %s]"),
20597 objfile_name (objfile
));
20598 info_ptr
= (per_objfile
->per_bfd
->addr
.buffer
+ addr_base_or_zero
20599 + addr_index
* addr_size
);
20600 if (addr_size
== 4)
20601 return bfd_get_32 (abfd
, info_ptr
);
20603 return bfd_get_64 (abfd
, info_ptr
);
20606 /* Given index ADDR_INDEX in .debug_addr, fetch the value. */
20609 read_addr_index (struct dwarf2_cu
*cu
, unsigned int addr_index
)
20611 return read_addr_index_1 (cu
->per_objfile
, addr_index
,
20612 cu
->addr_base
, cu
->header
.addr_size
);
20615 /* Given a pointer to an leb128 value, fetch the value from .debug_addr. */
20618 read_addr_index_from_leb128 (struct dwarf2_cu
*cu
, const gdb_byte
*info_ptr
,
20619 unsigned int *bytes_read
)
20621 bfd
*abfd
= cu
->per_objfile
->objfile
->obfd
;
20622 unsigned int addr_index
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
20624 return read_addr_index (cu
, addr_index
);
20630 dwarf2_read_addr_index (dwarf2_per_cu_data
*per_cu
,
20631 dwarf2_per_objfile
*per_objfile
,
20632 unsigned int addr_index
)
20634 struct dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
20635 gdb::optional
<ULONGEST
> addr_base
;
20638 /* We need addr_base and addr_size.
20639 If we don't have PER_CU->cu, we have to get it.
20640 Nasty, but the alternative is storing the needed info in PER_CU,
20641 which at this point doesn't seem justified: it's not clear how frequently
20642 it would get used and it would increase the size of every PER_CU.
20643 Entry points like dwarf2_per_cu_addr_size do a similar thing
20644 so we're not in uncharted territory here.
20645 Alas we need to be a bit more complicated as addr_base is contained
20648 We don't need to read the entire CU(/TU).
20649 We just need the header and top level die.
20651 IWBN to use the aging mechanism to let us lazily later discard the CU.
20652 For now we skip this optimization. */
20656 addr_base
= cu
->addr_base
;
20657 addr_size
= cu
->header
.addr_size
;
20661 cutu_reader
reader (per_cu
, per_objfile
, nullptr, nullptr, false);
20662 addr_base
= reader
.cu
->addr_base
;
20663 addr_size
= reader
.cu
->header
.addr_size
;
20666 return read_addr_index_1 (per_objfile
, addr_index
, addr_base
, addr_size
);
20669 /* Given a DW_FORM_GNU_str_index value STR_INDEX, fetch the string.
20670 STR_SECTION, STR_OFFSETS_SECTION can be from a Fission stub or a
20673 static const char *
20674 read_str_index (struct dwarf2_cu
*cu
,
20675 struct dwarf2_section_info
*str_section
,
20676 struct dwarf2_section_info
*str_offsets_section
,
20677 ULONGEST str_offsets_base
, ULONGEST str_index
)
20679 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
20680 struct objfile
*objfile
= per_objfile
->objfile
;
20681 const char *objf_name
= objfile_name (objfile
);
20682 bfd
*abfd
= objfile
->obfd
;
20683 const gdb_byte
*info_ptr
;
20684 ULONGEST str_offset
;
20685 static const char form_name
[] = "DW_FORM_GNU_str_index or DW_FORM_strx";
20687 str_section
->read (objfile
);
20688 str_offsets_section
->read (objfile
);
20689 if (str_section
->buffer
== NULL
)
20690 error (_("%s used without %s section"
20691 " in CU at offset %s [in module %s]"),
20692 form_name
, str_section
->get_name (),
20693 sect_offset_str (cu
->header
.sect_off
), objf_name
);
20694 if (str_offsets_section
->buffer
== NULL
)
20695 error (_("%s used without %s section"
20696 " in CU at offset %s [in module %s]"),
20697 form_name
, str_section
->get_name (),
20698 sect_offset_str (cu
->header
.sect_off
), objf_name
);
20699 info_ptr
= (str_offsets_section
->buffer
20701 + str_index
* cu
->header
.offset_size
);
20702 if (cu
->header
.offset_size
== 4)
20703 str_offset
= bfd_get_32 (abfd
, info_ptr
);
20705 str_offset
= bfd_get_64 (abfd
, info_ptr
);
20706 if (str_offset
>= str_section
->size
)
20707 error (_("Offset from %s pointing outside of"
20708 " .debug_str.dwo section in CU at offset %s [in module %s]"),
20709 form_name
, sect_offset_str (cu
->header
.sect_off
), objf_name
);
20710 return (const char *) (str_section
->buffer
+ str_offset
);
20713 /* Given a DW_FORM_GNU_str_index from a DWO file, fetch the string. */
20715 static const char *
20716 read_dwo_str_index (const struct die_reader_specs
*reader
, ULONGEST str_index
)
20718 ULONGEST str_offsets_base
= reader
->cu
->header
.version
>= 5
20719 ? reader
->cu
->header
.addr_size
: 0;
20720 return read_str_index (reader
->cu
,
20721 &reader
->dwo_file
->sections
.str
,
20722 &reader
->dwo_file
->sections
.str_offsets
,
20723 str_offsets_base
, str_index
);
20726 /* Given a DW_FORM_GNU_str_index from a Fission stub, fetch the string. */
20728 static const char *
20729 read_stub_str_index (struct dwarf2_cu
*cu
, ULONGEST str_index
)
20731 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
20732 const char *objf_name
= objfile_name (objfile
);
20733 static const char form_name
[] = "DW_FORM_GNU_str_index";
20734 static const char str_offsets_attr_name
[] = "DW_AT_str_offsets";
20736 if (!cu
->str_offsets_base
.has_value ())
20737 error (_("%s used in Fission stub without %s"
20738 " in CU at offset 0x%lx [in module %s]"),
20739 form_name
, str_offsets_attr_name
,
20740 (long) cu
->header
.offset_size
, objf_name
);
20742 return read_str_index (cu
,
20743 &cu
->per_objfile
->per_bfd
->str
,
20744 &cu
->per_objfile
->per_bfd
->str_offsets
,
20745 *cu
->str_offsets_base
, str_index
);
20748 /* Return the length of an LEB128 number in BUF. */
20751 leb128_size (const gdb_byte
*buf
)
20753 const gdb_byte
*begin
= buf
;
20759 if ((byte
& 128) == 0)
20760 return buf
- begin
;
20765 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
20774 cu
->language
= language_c
;
20777 case DW_LANG_C_plus_plus
:
20778 case DW_LANG_C_plus_plus_11
:
20779 case DW_LANG_C_plus_plus_14
:
20780 cu
->language
= language_cplus
;
20783 cu
->language
= language_d
;
20785 case DW_LANG_Fortran77
:
20786 case DW_LANG_Fortran90
:
20787 case DW_LANG_Fortran95
:
20788 case DW_LANG_Fortran03
:
20789 case DW_LANG_Fortran08
:
20790 cu
->language
= language_fortran
;
20793 cu
->language
= language_go
;
20795 case DW_LANG_Mips_Assembler
:
20796 cu
->language
= language_asm
;
20798 case DW_LANG_Ada83
:
20799 case DW_LANG_Ada95
:
20800 cu
->language
= language_ada
;
20802 case DW_LANG_Modula2
:
20803 cu
->language
= language_m2
;
20805 case DW_LANG_Pascal83
:
20806 cu
->language
= language_pascal
;
20809 cu
->language
= language_objc
;
20812 case DW_LANG_Rust_old
:
20813 cu
->language
= language_rust
;
20815 case DW_LANG_Cobol74
:
20816 case DW_LANG_Cobol85
:
20818 cu
->language
= language_minimal
;
20821 cu
->language_defn
= language_def (cu
->language
);
20824 /* Return the named attribute or NULL if not there. */
20826 static struct attribute
*
20827 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
20832 struct attribute
*spec
= NULL
;
20834 for (i
= 0; i
< die
->num_attrs
; ++i
)
20836 if (die
->attrs
[i
].name
== name
)
20837 return &die
->attrs
[i
];
20838 if (die
->attrs
[i
].name
== DW_AT_specification
20839 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
20840 spec
= &die
->attrs
[i
];
20846 die
= follow_die_ref (die
, spec
, &cu
);
20852 /* Return the string associated with a string-typed attribute, or NULL if it
20853 is either not found or is of an incorrect type. */
20855 static const char *
20856 dwarf2_string_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
20858 struct attribute
*attr
;
20859 const char *str
= NULL
;
20861 attr
= dwarf2_attr (die
, name
, cu
);
20865 str
= attr
->as_string ();
20866 if (str
== nullptr)
20867 complaint (_("string type expected for attribute %s for "
20868 "DIE at %s in module %s"),
20869 dwarf_attr_name (name
), sect_offset_str (die
->sect_off
),
20870 objfile_name (cu
->per_objfile
->objfile
));
20876 /* Return the dwo name or NULL if not present. If present, it is in either
20877 DW_AT_GNU_dwo_name or DW_AT_dwo_name attribute. */
20878 static const char *
20879 dwarf2_dwo_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
20881 const char *dwo_name
= dwarf2_string_attr (die
, DW_AT_GNU_dwo_name
, cu
);
20882 if (dwo_name
== nullptr)
20883 dwo_name
= dwarf2_string_attr (die
, DW_AT_dwo_name
, cu
);
20887 /* Return non-zero iff the attribute NAME is defined for the given DIE,
20888 and holds a non-zero value. This function should only be used for
20889 DW_FORM_flag or DW_FORM_flag_present attributes. */
20892 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
20894 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
20896 return attr
!= nullptr && attr
->as_boolean ();
20900 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
20902 /* A DIE is a declaration if it has a DW_AT_declaration attribute
20903 which value is non-zero. However, we have to be careful with
20904 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
20905 (via dwarf2_flag_true_p) follows this attribute. So we may
20906 end up accidently finding a declaration attribute that belongs
20907 to a different DIE referenced by the specification attribute,
20908 even though the given DIE does not have a declaration attribute. */
20909 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
20910 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
20913 /* Return the die giving the specification for DIE, if there is
20914 one. *SPEC_CU is the CU containing DIE on input, and the CU
20915 containing the return value on output. If there is no
20916 specification, but there is an abstract origin, that is
20919 static struct die_info
*
20920 die_specification (struct die_info
*die
, struct dwarf2_cu
**spec_cu
)
20922 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
,
20925 if (spec_attr
== NULL
)
20926 spec_attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, *spec_cu
);
20928 if (spec_attr
== NULL
)
20931 return follow_die_ref (die
, spec_attr
, spec_cu
);
20934 /* Stub for free_line_header to match void * callback types. */
20937 free_line_header_voidp (void *arg
)
20939 struct line_header
*lh
= (struct line_header
*) arg
;
20944 /* A convenience function to find the proper .debug_line section for a CU. */
20946 static struct dwarf2_section_info
*
20947 get_debug_line_section (struct dwarf2_cu
*cu
)
20949 struct dwarf2_section_info
*section
;
20950 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
20952 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
20954 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
20955 section
= &cu
->dwo_unit
->dwo_file
->sections
.line
;
20956 else if (cu
->per_cu
->is_dwz
)
20958 dwz_file
*dwz
= dwarf2_get_dwz_file (per_objfile
->per_bfd
, true);
20960 section
= &dwz
->line
;
20963 section
= &per_objfile
->per_bfd
->line
;
20968 /* Read the statement program header starting at OFFSET in
20969 .debug_line, or .debug_line.dwo. Return a pointer
20970 to a struct line_header, allocated using xmalloc.
20971 Returns NULL if there is a problem reading the header, e.g., if it
20972 has a version we don't understand.
20974 NOTE: the strings in the include directory and file name tables of
20975 the returned object point into the dwarf line section buffer,
20976 and must not be freed. */
20978 static line_header_up
20979 dwarf_decode_line_header (sect_offset sect_off
, struct dwarf2_cu
*cu
)
20981 struct dwarf2_section_info
*section
;
20982 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
20984 section
= get_debug_line_section (cu
);
20985 section
->read (per_objfile
->objfile
);
20986 if (section
->buffer
== NULL
)
20988 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
20989 complaint (_("missing .debug_line.dwo section"));
20991 complaint (_("missing .debug_line section"));
20995 return dwarf_decode_line_header (sect_off
, cu
->per_cu
->is_dwz
,
20996 per_objfile
, section
, &cu
->header
);
20999 /* Subroutine of dwarf_decode_lines to simplify it.
21000 Return the file name of the psymtab for the given file_entry.
21001 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
21002 If space for the result is malloc'd, *NAME_HOLDER will be set.
21003 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename. */
21005 static const char *
21006 psymtab_include_file_name (const struct line_header
*lh
, const file_entry
&fe
,
21007 const dwarf2_psymtab
*pst
,
21008 const char *comp_dir
,
21009 gdb::unique_xmalloc_ptr
<char> *name_holder
)
21011 const char *include_name
= fe
.name
;
21012 const char *include_name_to_compare
= include_name
;
21013 const char *pst_filename
;
21016 const char *dir_name
= fe
.include_dir (lh
);
21018 gdb::unique_xmalloc_ptr
<char> hold_compare
;
21019 if (!IS_ABSOLUTE_PATH (include_name
)
21020 && (dir_name
!= NULL
|| comp_dir
!= NULL
))
21022 /* Avoid creating a duplicate psymtab for PST.
21023 We do this by comparing INCLUDE_NAME and PST_FILENAME.
21024 Before we do the comparison, however, we need to account
21025 for DIR_NAME and COMP_DIR.
21026 First prepend dir_name (if non-NULL). If we still don't
21027 have an absolute path prepend comp_dir (if non-NULL).
21028 However, the directory we record in the include-file's
21029 psymtab does not contain COMP_DIR (to match the
21030 corresponding symtab(s)).
21035 bash$ gcc -g ./hello.c
21036 include_name = "hello.c"
21038 DW_AT_comp_dir = comp_dir = "/tmp"
21039 DW_AT_name = "./hello.c"
21043 if (dir_name
!= NULL
)
21045 name_holder
->reset (concat (dir_name
, SLASH_STRING
,
21046 include_name
, (char *) NULL
));
21047 include_name
= name_holder
->get ();
21048 include_name_to_compare
= include_name
;
21050 if (!IS_ABSOLUTE_PATH (include_name
) && comp_dir
!= NULL
)
21052 hold_compare
.reset (concat (comp_dir
, SLASH_STRING
,
21053 include_name
, (char *) NULL
));
21054 include_name_to_compare
= hold_compare
.get ();
21058 pst_filename
= pst
->filename
;
21059 gdb::unique_xmalloc_ptr
<char> copied_name
;
21060 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
21062 copied_name
.reset (concat (pst
->dirname
, SLASH_STRING
,
21063 pst_filename
, (char *) NULL
));
21064 pst_filename
= copied_name
.get ();
21067 file_is_pst
= FILENAME_CMP (include_name_to_compare
, pst_filename
) == 0;
21071 return include_name
;
21074 /* State machine to track the state of the line number program. */
21076 class lnp_state_machine
21079 /* Initialize a machine state for the start of a line number
21081 lnp_state_machine (struct dwarf2_cu
*cu
, gdbarch
*arch
, line_header
*lh
,
21082 bool record_lines_p
);
21084 file_entry
*current_file ()
21086 /* lh->file_names is 0-based, but the file name numbers in the
21087 statement program are 1-based. */
21088 return m_line_header
->file_name_at (m_file
);
21091 /* Record the line in the state machine. END_SEQUENCE is true if
21092 we're processing the end of a sequence. */
21093 void record_line (bool end_sequence
);
21095 /* Check ADDRESS is -1, or zero and less than UNRELOCATED_LOWPC, and if true
21096 nop-out rest of the lines in this sequence. */
21097 void check_line_address (struct dwarf2_cu
*cu
,
21098 const gdb_byte
*line_ptr
,
21099 CORE_ADDR unrelocated_lowpc
, CORE_ADDR address
);
21101 void handle_set_discriminator (unsigned int discriminator
)
21103 m_discriminator
= discriminator
;
21104 m_line_has_non_zero_discriminator
|= discriminator
!= 0;
21107 /* Handle DW_LNE_set_address. */
21108 void handle_set_address (CORE_ADDR baseaddr
, CORE_ADDR address
)
21111 address
+= baseaddr
;
21112 m_address
= gdbarch_adjust_dwarf2_line (m_gdbarch
, address
, false);
21115 /* Handle DW_LNS_advance_pc. */
21116 void handle_advance_pc (CORE_ADDR adjust
);
21118 /* Handle a special opcode. */
21119 void handle_special_opcode (unsigned char op_code
);
21121 /* Handle DW_LNS_advance_line. */
21122 void handle_advance_line (int line_delta
)
21124 advance_line (line_delta
);
21127 /* Handle DW_LNS_set_file. */
21128 void handle_set_file (file_name_index file
);
21130 /* Handle DW_LNS_negate_stmt. */
21131 void handle_negate_stmt ()
21133 m_is_stmt
= !m_is_stmt
;
21136 /* Handle DW_LNS_const_add_pc. */
21137 void handle_const_add_pc ();
21139 /* Handle DW_LNS_fixed_advance_pc. */
21140 void handle_fixed_advance_pc (CORE_ADDR addr_adj
)
21142 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
21146 /* Handle DW_LNS_copy. */
21147 void handle_copy ()
21149 record_line (false);
21150 m_discriminator
= 0;
21153 /* Handle DW_LNE_end_sequence. */
21154 void handle_end_sequence ()
21156 m_currently_recording_lines
= true;
21160 /* Advance the line by LINE_DELTA. */
21161 void advance_line (int line_delta
)
21163 m_line
+= line_delta
;
21165 if (line_delta
!= 0)
21166 m_line_has_non_zero_discriminator
= m_discriminator
!= 0;
21169 struct dwarf2_cu
*m_cu
;
21171 gdbarch
*m_gdbarch
;
21173 /* True if we're recording lines.
21174 Otherwise we're building partial symtabs and are just interested in
21175 finding include files mentioned by the line number program. */
21176 bool m_record_lines_p
;
21178 /* The line number header. */
21179 line_header
*m_line_header
;
21181 /* These are part of the standard DWARF line number state machine,
21182 and initialized according to the DWARF spec. */
21184 unsigned char m_op_index
= 0;
21185 /* The line table index of the current file. */
21186 file_name_index m_file
= 1;
21187 unsigned int m_line
= 1;
21189 /* These are initialized in the constructor. */
21191 CORE_ADDR m_address
;
21193 unsigned int m_discriminator
;
21195 /* Additional bits of state we need to track. */
21197 /* The last file that we called dwarf2_start_subfile for.
21198 This is only used for TLLs. */
21199 unsigned int m_last_file
= 0;
21200 /* The last file a line number was recorded for. */
21201 struct subfile
*m_last_subfile
= NULL
;
21203 /* The address of the last line entry. */
21204 CORE_ADDR m_last_address
;
21206 /* Set to true when a previous line at the same address (using
21207 m_last_address) had m_is_stmt true. This is reset to false when a
21208 line entry at a new address (m_address different to m_last_address) is
21210 bool m_stmt_at_address
= false;
21212 /* When true, record the lines we decode. */
21213 bool m_currently_recording_lines
= false;
21215 /* The last line number that was recorded, used to coalesce
21216 consecutive entries for the same line. This can happen, for
21217 example, when discriminators are present. PR 17276. */
21218 unsigned int m_last_line
= 0;
21219 bool m_line_has_non_zero_discriminator
= false;
21223 lnp_state_machine::handle_advance_pc (CORE_ADDR adjust
)
21225 CORE_ADDR addr_adj
= (((m_op_index
+ adjust
)
21226 / m_line_header
->maximum_ops_per_instruction
)
21227 * m_line_header
->minimum_instruction_length
);
21228 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
21229 m_op_index
= ((m_op_index
+ adjust
)
21230 % m_line_header
->maximum_ops_per_instruction
);
21234 lnp_state_machine::handle_special_opcode (unsigned char op_code
)
21236 unsigned char adj_opcode
= op_code
- m_line_header
->opcode_base
;
21237 unsigned char adj_opcode_d
= adj_opcode
/ m_line_header
->line_range
;
21238 unsigned char adj_opcode_r
= adj_opcode
% m_line_header
->line_range
;
21239 CORE_ADDR addr_adj
= (((m_op_index
+ adj_opcode_d
)
21240 / m_line_header
->maximum_ops_per_instruction
)
21241 * m_line_header
->minimum_instruction_length
);
21242 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
21243 m_op_index
= ((m_op_index
+ adj_opcode_d
)
21244 % m_line_header
->maximum_ops_per_instruction
);
21246 int line_delta
= m_line_header
->line_base
+ adj_opcode_r
;
21247 advance_line (line_delta
);
21248 record_line (false);
21249 m_discriminator
= 0;
21253 lnp_state_machine::handle_set_file (file_name_index file
)
21257 const file_entry
*fe
= current_file ();
21259 dwarf2_debug_line_missing_file_complaint ();
21260 else if (m_record_lines_p
)
21262 const char *dir
= fe
->include_dir (m_line_header
);
21264 m_last_subfile
= m_cu
->get_builder ()->get_current_subfile ();
21265 m_line_has_non_zero_discriminator
= m_discriminator
!= 0;
21266 dwarf2_start_subfile (m_cu
, fe
->name
, dir
);
21271 lnp_state_machine::handle_const_add_pc ()
21274 = (255 - m_line_header
->opcode_base
) / m_line_header
->line_range
;
21277 = (((m_op_index
+ adjust
)
21278 / m_line_header
->maximum_ops_per_instruction
)
21279 * m_line_header
->minimum_instruction_length
);
21281 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
21282 m_op_index
= ((m_op_index
+ adjust
)
21283 % m_line_header
->maximum_ops_per_instruction
);
21286 /* Return non-zero if we should add LINE to the line number table.
21287 LINE is the line to add, LAST_LINE is the last line that was added,
21288 LAST_SUBFILE is the subfile for LAST_LINE.
21289 LINE_HAS_NON_ZERO_DISCRIMINATOR is non-zero if LINE has ever
21290 had a non-zero discriminator.
21292 We have to be careful in the presence of discriminators.
21293 E.g., for this line:
21295 for (i = 0; i < 100000; i++);
21297 clang can emit four line number entries for that one line,
21298 each with a different discriminator.
21299 See gdb.dwarf2/dw2-single-line-discriminators.exp for an example.
21301 However, we want gdb to coalesce all four entries into one.
21302 Otherwise the user could stepi into the middle of the line and
21303 gdb would get confused about whether the pc really was in the
21304 middle of the line.
21306 Things are further complicated by the fact that two consecutive
21307 line number entries for the same line is a heuristic used by gcc
21308 to denote the end of the prologue. So we can't just discard duplicate
21309 entries, we have to be selective about it. The heuristic we use is
21310 that we only collapse consecutive entries for the same line if at least
21311 one of those entries has a non-zero discriminator. PR 17276.
21313 Note: Addresses in the line number state machine can never go backwards
21314 within one sequence, thus this coalescing is ok. */
21317 dwarf_record_line_p (struct dwarf2_cu
*cu
,
21318 unsigned int line
, unsigned int last_line
,
21319 int line_has_non_zero_discriminator
,
21320 struct subfile
*last_subfile
)
21322 if (cu
->get_builder ()->get_current_subfile () != last_subfile
)
21324 if (line
!= last_line
)
21326 /* Same line for the same file that we've seen already.
21327 As a last check, for pr 17276, only record the line if the line
21328 has never had a non-zero discriminator. */
21329 if (!line_has_non_zero_discriminator
)
21334 /* Use the CU's builder to record line number LINE beginning at
21335 address ADDRESS in the line table of subfile SUBFILE. */
21338 dwarf_record_line_1 (struct gdbarch
*gdbarch
, struct subfile
*subfile
,
21339 unsigned int line
, CORE_ADDR address
, bool is_stmt
,
21340 struct dwarf2_cu
*cu
)
21342 CORE_ADDR addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
21344 if (dwarf_line_debug
)
21346 fprintf_unfiltered (gdb_stdlog
,
21347 "Recording line %u, file %s, address %s\n",
21348 line
, lbasename (subfile
->name
),
21349 paddress (gdbarch
, address
));
21353 cu
->get_builder ()->record_line (subfile
, line
, addr
, is_stmt
);
21356 /* Subroutine of dwarf_decode_lines_1 to simplify it.
21357 Mark the end of a set of line number records.
21358 The arguments are the same as for dwarf_record_line_1.
21359 If SUBFILE is NULL the request is ignored. */
21362 dwarf_finish_line (struct gdbarch
*gdbarch
, struct subfile
*subfile
,
21363 CORE_ADDR address
, struct dwarf2_cu
*cu
)
21365 if (subfile
== NULL
)
21368 if (dwarf_line_debug
)
21370 fprintf_unfiltered (gdb_stdlog
,
21371 "Finishing current line, file %s, address %s\n",
21372 lbasename (subfile
->name
),
21373 paddress (gdbarch
, address
));
21376 dwarf_record_line_1 (gdbarch
, subfile
, 0, address
, true, cu
);
21380 lnp_state_machine::record_line (bool end_sequence
)
21382 if (dwarf_line_debug
)
21384 fprintf_unfiltered (gdb_stdlog
,
21385 "Processing actual line %u: file %u,"
21386 " address %s, is_stmt %u, discrim %u%s\n",
21388 paddress (m_gdbarch
, m_address
),
21389 m_is_stmt
, m_discriminator
,
21390 (end_sequence
? "\t(end sequence)" : ""));
21393 file_entry
*fe
= current_file ();
21396 dwarf2_debug_line_missing_file_complaint ();
21397 /* For now we ignore lines not starting on an instruction boundary.
21398 But not when processing end_sequence for compatibility with the
21399 previous version of the code. */
21400 else if (m_op_index
== 0 || end_sequence
)
21402 fe
->included_p
= 1;
21403 if (m_record_lines_p
)
21405 /* When we switch files we insert an end maker in the first file,
21406 switch to the second file and add a new line entry. The
21407 problem is that the end marker inserted in the first file will
21408 discard any previous line entries at the same address. If the
21409 line entries in the first file are marked as is-stmt, while
21410 the new line in the second file is non-stmt, then this means
21411 the end marker will discard is-stmt lines so we can have a
21412 non-stmt line. This means that there are less addresses at
21413 which the user can insert a breakpoint.
21415 To improve this we track the last address in m_last_address,
21416 and whether we have seen an is-stmt at this address. Then
21417 when switching files, if we have seen a stmt at the current
21418 address, and we are switching to create a non-stmt line, then
21419 discard the new line. */
21421 = m_last_subfile
!= m_cu
->get_builder ()->get_current_subfile ();
21422 bool ignore_this_line
21423 = ((file_changed
&& !end_sequence
&& m_last_address
== m_address
21424 && !m_is_stmt
&& m_stmt_at_address
)
21425 || (!end_sequence
&& m_line
== 0));
21427 if ((file_changed
&& !ignore_this_line
) || end_sequence
)
21429 dwarf_finish_line (m_gdbarch
, m_last_subfile
, m_address
,
21430 m_currently_recording_lines
? m_cu
: nullptr);
21433 if (!end_sequence
&& !ignore_this_line
)
21435 bool is_stmt
= producer_is_codewarrior (m_cu
) || m_is_stmt
;
21437 if (dwarf_record_line_p (m_cu
, m_line
, m_last_line
,
21438 m_line_has_non_zero_discriminator
,
21441 buildsym_compunit
*builder
= m_cu
->get_builder ();
21442 dwarf_record_line_1 (m_gdbarch
,
21443 builder
->get_current_subfile (),
21444 m_line
, m_address
, is_stmt
,
21445 m_currently_recording_lines
? m_cu
: nullptr);
21447 m_last_subfile
= m_cu
->get_builder ()->get_current_subfile ();
21448 m_last_line
= m_line
;
21453 /* Track whether we have seen any m_is_stmt true at m_address in case we
21454 have multiple line table entries all at m_address. */
21455 if (m_last_address
!= m_address
)
21457 m_stmt_at_address
= false;
21458 m_last_address
= m_address
;
21460 m_stmt_at_address
|= m_is_stmt
;
21463 lnp_state_machine::lnp_state_machine (struct dwarf2_cu
*cu
, gdbarch
*arch
,
21464 line_header
*lh
, bool record_lines_p
)
21468 m_record_lines_p
= record_lines_p
;
21469 m_line_header
= lh
;
21471 m_currently_recording_lines
= true;
21473 /* Call `gdbarch_adjust_dwarf2_line' on the initial 0 address as if there
21474 was a line entry for it so that the backend has a chance to adjust it
21475 and also record it in case it needs it. This is currently used by MIPS
21476 code, cf. `mips_adjust_dwarf2_line'. */
21477 m_address
= gdbarch_adjust_dwarf2_line (arch
, 0, 0);
21478 m_is_stmt
= lh
->default_is_stmt
;
21479 m_discriminator
= 0;
21481 m_last_address
= m_address
;
21482 m_stmt_at_address
= false;
21486 lnp_state_machine::check_line_address (struct dwarf2_cu
*cu
,
21487 const gdb_byte
*line_ptr
,
21488 CORE_ADDR unrelocated_lowpc
, CORE_ADDR address
)
21490 /* Linkers resolve a symbolic relocation referencing a GC'd function to 0 or
21491 -1. If ADDRESS is 0, ignoring the opcode will err if the text section is
21492 located at 0x0. In this case, additionally check that if
21493 ADDRESS < UNRELOCATED_LOWPC. */
21495 if ((address
== 0 && address
< unrelocated_lowpc
)
21496 || address
== (CORE_ADDR
) -1)
21498 /* This line table is for a function which has been
21499 GCd by the linker. Ignore it. PR gdb/12528 */
21501 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
21502 long line_offset
= line_ptr
- get_debug_line_section (cu
)->buffer
;
21504 complaint (_(".debug_line address at offset 0x%lx is 0 [in module %s]"),
21505 line_offset
, objfile_name (objfile
));
21506 m_currently_recording_lines
= false;
21507 /* Note: m_currently_recording_lines is left as false until we see
21508 DW_LNE_end_sequence. */
21512 /* Subroutine of dwarf_decode_lines to simplify it.
21513 Process the line number information in LH.
21514 If DECODE_FOR_PST_P is non-zero, all we do is process the line number
21515 program in order to set included_p for every referenced header. */
21518 dwarf_decode_lines_1 (struct line_header
*lh
, struct dwarf2_cu
*cu
,
21519 const int decode_for_pst_p
, CORE_ADDR lowpc
)
21521 const gdb_byte
*line_ptr
, *extended_end
;
21522 const gdb_byte
*line_end
;
21523 unsigned int bytes_read
, extended_len
;
21524 unsigned char op_code
, extended_op
;
21525 CORE_ADDR baseaddr
;
21526 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
21527 bfd
*abfd
= objfile
->obfd
;
21528 struct gdbarch
*gdbarch
= objfile
->arch ();
21529 /* True if we're recording line info (as opposed to building partial
21530 symtabs and just interested in finding include files mentioned by
21531 the line number program). */
21532 bool record_lines_p
= !decode_for_pst_p
;
21534 baseaddr
= objfile
->text_section_offset ();
21536 line_ptr
= lh
->statement_program_start
;
21537 line_end
= lh
->statement_program_end
;
21539 /* Read the statement sequences until there's nothing left. */
21540 while (line_ptr
< line_end
)
21542 /* The DWARF line number program state machine. Reset the state
21543 machine at the start of each sequence. */
21544 lnp_state_machine
state_machine (cu
, gdbarch
, lh
, record_lines_p
);
21545 bool end_sequence
= false;
21547 if (record_lines_p
)
21549 /* Start a subfile for the current file of the state
21551 const file_entry
*fe
= state_machine
.current_file ();
21554 dwarf2_start_subfile (cu
, fe
->name
, fe
->include_dir (lh
));
21557 /* Decode the table. */
21558 while (line_ptr
< line_end
&& !end_sequence
)
21560 op_code
= read_1_byte (abfd
, line_ptr
);
21563 if (op_code
>= lh
->opcode_base
)
21565 /* Special opcode. */
21566 state_machine
.handle_special_opcode (op_code
);
21568 else switch (op_code
)
21570 case DW_LNS_extended_op
:
21571 extended_len
= read_unsigned_leb128 (abfd
, line_ptr
,
21573 line_ptr
+= bytes_read
;
21574 extended_end
= line_ptr
+ extended_len
;
21575 extended_op
= read_1_byte (abfd
, line_ptr
);
21577 if (DW_LNE_lo_user
<= extended_op
21578 && extended_op
<= DW_LNE_hi_user
)
21580 /* Vendor extension, ignore. */
21581 line_ptr
= extended_end
;
21584 switch (extended_op
)
21586 case DW_LNE_end_sequence
:
21587 state_machine
.handle_end_sequence ();
21588 end_sequence
= true;
21590 case DW_LNE_set_address
:
21593 = cu
->header
.read_address (abfd
, line_ptr
, &bytes_read
);
21594 line_ptr
+= bytes_read
;
21596 state_machine
.check_line_address (cu
, line_ptr
,
21597 lowpc
- baseaddr
, address
);
21598 state_machine
.handle_set_address (baseaddr
, address
);
21601 case DW_LNE_define_file
:
21603 const char *cur_file
;
21604 unsigned int mod_time
, length
;
21607 cur_file
= read_direct_string (abfd
, line_ptr
,
21609 line_ptr
+= bytes_read
;
21610 dindex
= (dir_index
)
21611 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21612 line_ptr
+= bytes_read
;
21614 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21615 line_ptr
+= bytes_read
;
21617 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21618 line_ptr
+= bytes_read
;
21619 lh
->add_file_name (cur_file
, dindex
, mod_time
, length
);
21622 case DW_LNE_set_discriminator
:
21624 /* The discriminator is not interesting to the
21625 debugger; just ignore it. We still need to
21626 check its value though:
21627 if there are consecutive entries for the same
21628 (non-prologue) line we want to coalesce them.
21631 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21632 line_ptr
+= bytes_read
;
21634 state_machine
.handle_set_discriminator (discr
);
21638 complaint (_("mangled .debug_line section"));
21641 /* Make sure that we parsed the extended op correctly. If e.g.
21642 we expected a different address size than the producer used,
21643 we may have read the wrong number of bytes. */
21644 if (line_ptr
!= extended_end
)
21646 complaint (_("mangled .debug_line section"));
21651 state_machine
.handle_copy ();
21653 case DW_LNS_advance_pc
:
21656 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21657 line_ptr
+= bytes_read
;
21659 state_machine
.handle_advance_pc (adjust
);
21662 case DW_LNS_advance_line
:
21665 = read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
21666 line_ptr
+= bytes_read
;
21668 state_machine
.handle_advance_line (line_delta
);
21671 case DW_LNS_set_file
:
21673 file_name_index file
21674 = (file_name_index
) read_unsigned_leb128 (abfd
, line_ptr
,
21676 line_ptr
+= bytes_read
;
21678 state_machine
.handle_set_file (file
);
21681 case DW_LNS_set_column
:
21682 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21683 line_ptr
+= bytes_read
;
21685 case DW_LNS_negate_stmt
:
21686 state_machine
.handle_negate_stmt ();
21688 case DW_LNS_set_basic_block
:
21690 /* Add to the address register of the state machine the
21691 address increment value corresponding to special opcode
21692 255. I.e., this value is scaled by the minimum
21693 instruction length since special opcode 255 would have
21694 scaled the increment. */
21695 case DW_LNS_const_add_pc
:
21696 state_machine
.handle_const_add_pc ();
21698 case DW_LNS_fixed_advance_pc
:
21700 CORE_ADDR addr_adj
= read_2_bytes (abfd
, line_ptr
);
21703 state_machine
.handle_fixed_advance_pc (addr_adj
);
21708 /* Unknown standard opcode, ignore it. */
21711 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
21713 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21714 line_ptr
+= bytes_read
;
21721 dwarf2_debug_line_missing_end_sequence_complaint ();
21723 /* We got a DW_LNE_end_sequence (or we ran off the end of the buffer,
21724 in which case we still finish recording the last line). */
21725 state_machine
.record_line (true);
21729 /* Decode the Line Number Program (LNP) for the given line_header
21730 structure and CU. The actual information extracted and the type
21731 of structures created from the LNP depends on the value of PST.
21733 1. If PST is NULL, then this procedure uses the data from the program
21734 to create all necessary symbol tables, and their linetables.
21736 2. If PST is not NULL, this procedure reads the program to determine
21737 the list of files included by the unit represented by PST, and
21738 builds all the associated partial symbol tables.
21740 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
21741 It is used for relative paths in the line table.
21742 NOTE: When processing partial symtabs (pst != NULL),
21743 comp_dir == pst->dirname.
21745 NOTE: It is important that psymtabs have the same file name (via strcmp)
21746 as the corresponding symtab. Since COMP_DIR is not used in the name of the
21747 symtab we don't use it in the name of the psymtabs we create.
21748 E.g. expand_line_sal requires this when finding psymtabs to expand.
21749 A good testcase for this is mb-inline.exp.
21751 LOWPC is the lowest address in CU (or 0 if not known).
21753 Boolean DECODE_MAPPING specifies we need to fully decode .debug_line
21754 for its PC<->lines mapping information. Otherwise only the filename
21755 table is read in. */
21758 dwarf_decode_lines (struct line_header
*lh
, const char *comp_dir
,
21759 struct dwarf2_cu
*cu
, dwarf2_psymtab
*pst
,
21760 CORE_ADDR lowpc
, int decode_mapping
)
21762 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
21763 const int decode_for_pst_p
= (pst
!= NULL
);
21765 if (decode_mapping
)
21766 dwarf_decode_lines_1 (lh
, cu
, decode_for_pst_p
, lowpc
);
21768 if (decode_for_pst_p
)
21770 /* Now that we're done scanning the Line Header Program, we can
21771 create the psymtab of each included file. */
21772 for (auto &file_entry
: lh
->file_names ())
21773 if (file_entry
.included_p
== 1)
21775 gdb::unique_xmalloc_ptr
<char> name_holder
;
21776 const char *include_name
=
21777 psymtab_include_file_name (lh
, file_entry
, pst
,
21778 comp_dir
, &name_holder
);
21779 if (include_name
!= NULL
)
21780 dwarf2_create_include_psymtab
21781 (cu
->per_objfile
->per_bfd
, include_name
, pst
,
21782 cu
->per_objfile
->per_bfd
->partial_symtabs
.get (),
21788 /* Make sure a symtab is created for every file, even files
21789 which contain only variables (i.e. no code with associated
21791 buildsym_compunit
*builder
= cu
->get_builder ();
21792 struct compunit_symtab
*cust
= builder
->get_compunit_symtab ();
21794 for (auto &fe
: lh
->file_names ())
21796 dwarf2_start_subfile (cu
, fe
.name
, fe
.include_dir (lh
));
21797 if (builder
->get_current_subfile ()->symtab
== NULL
)
21799 builder
->get_current_subfile ()->symtab
21800 = allocate_symtab (cust
,
21801 builder
->get_current_subfile ()->name
);
21803 fe
.symtab
= builder
->get_current_subfile ()->symtab
;
21808 /* Start a subfile for DWARF. FILENAME is the name of the file and
21809 DIRNAME the name of the source directory which contains FILENAME
21810 or NULL if not known.
21811 This routine tries to keep line numbers from identical absolute and
21812 relative file names in a common subfile.
21814 Using the `list' example from the GDB testsuite, which resides in
21815 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
21816 of /srcdir/list0.c yields the following debugging information for list0.c:
21818 DW_AT_name: /srcdir/list0.c
21819 DW_AT_comp_dir: /compdir
21820 files.files[0].name: list0.h
21821 files.files[0].dir: /srcdir
21822 files.files[1].name: list0.c
21823 files.files[1].dir: /srcdir
21825 The line number information for list0.c has to end up in a single
21826 subfile, so that `break /srcdir/list0.c:1' works as expected.
21827 start_subfile will ensure that this happens provided that we pass the
21828 concatenation of files.files[1].dir and files.files[1].name as the
21832 dwarf2_start_subfile (struct dwarf2_cu
*cu
, const char *filename
,
21833 const char *dirname
)
21835 gdb::unique_xmalloc_ptr
<char> copy
;
21837 /* In order not to lose the line information directory,
21838 we concatenate it to the filename when it makes sense.
21839 Note that the Dwarf3 standard says (speaking of filenames in line
21840 information): ``The directory index is ignored for file names
21841 that represent full path names''. Thus ignoring dirname in the
21842 `else' branch below isn't an issue. */
21844 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
21846 copy
.reset (concat (dirname
, SLASH_STRING
, filename
, (char *) NULL
));
21847 filename
= copy
.get ();
21850 cu
->get_builder ()->start_subfile (filename
);
21853 /* Start a symtab for DWARF. NAME, COMP_DIR, LOW_PC are passed to the
21854 buildsym_compunit constructor. */
21856 struct compunit_symtab
*
21857 dwarf2_cu::start_symtab (const char *name
, const char *comp_dir
,
21860 gdb_assert (m_builder
== nullptr);
21862 m_builder
.reset (new struct buildsym_compunit
21863 (this->per_objfile
->objfile
,
21864 name
, comp_dir
, language
, low_pc
));
21866 list_in_scope
= get_builder ()->get_file_symbols ();
21868 get_builder ()->record_debugformat ("DWARF 2");
21869 get_builder ()->record_producer (producer
);
21871 processing_has_namespace_info
= false;
21873 return get_builder ()->get_compunit_symtab ();
21877 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
21878 struct dwarf2_cu
*cu
)
21880 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
21881 struct comp_unit_head
*cu_header
= &cu
->header
;
21883 /* NOTE drow/2003-01-30: There used to be a comment and some special
21884 code here to turn a symbol with DW_AT_external and a
21885 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
21886 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
21887 with some versions of binutils) where shared libraries could have
21888 relocations against symbols in their debug information - the
21889 minimal symbol would have the right address, but the debug info
21890 would not. It's no longer necessary, because we will explicitly
21891 apply relocations when we read in the debug information now. */
21893 /* A DW_AT_location attribute with no contents indicates that a
21894 variable has been optimized away. */
21895 if (attr
->form_is_block () && attr
->as_block ()->size
== 0)
21897 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
21901 /* Handle one degenerate form of location expression specially, to
21902 preserve GDB's previous behavior when section offsets are
21903 specified. If this is just a DW_OP_addr, DW_OP_addrx, or
21904 DW_OP_GNU_addr_index then mark this symbol as LOC_STATIC. */
21906 if (attr
->form_is_block ())
21908 struct dwarf_block
*block
= attr
->as_block ();
21910 if ((block
->data
[0] == DW_OP_addr
21911 && block
->size
== 1 + cu_header
->addr_size
)
21912 || ((block
->data
[0] == DW_OP_GNU_addr_index
21913 || block
->data
[0] == DW_OP_addrx
)
21915 == 1 + leb128_size (&block
->data
[1]))))
21917 unsigned int dummy
;
21919 if (block
->data
[0] == DW_OP_addr
)
21920 SET_SYMBOL_VALUE_ADDRESS
21921 (sym
, cu
->header
.read_address (objfile
->obfd
,
21925 SET_SYMBOL_VALUE_ADDRESS
21926 (sym
, read_addr_index_from_leb128 (cu
, block
->data
+ 1,
21928 SYMBOL_ACLASS_INDEX (sym
) = LOC_STATIC
;
21929 fixup_symbol_section (sym
, objfile
);
21930 SET_SYMBOL_VALUE_ADDRESS
21932 SYMBOL_VALUE_ADDRESS (sym
)
21933 + objfile
->section_offsets
[sym
->section_index ()]);
21938 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
21939 expression evaluator, and use LOC_COMPUTED only when necessary
21940 (i.e. when the value of a register or memory location is
21941 referenced, or a thread-local block, etc.). Then again, it might
21942 not be worthwhile. I'm assuming that it isn't unless performance
21943 or memory numbers show me otherwise. */
21945 dwarf2_symbol_mark_computed (attr
, sym
, cu
, 0);
21947 if (SYMBOL_COMPUTED_OPS (sym
)->location_has_loclist
)
21948 cu
->has_loclist
= true;
21951 /* Given a pointer to a DWARF information entry, figure out if we need
21952 to make a symbol table entry for it, and if so, create a new entry
21953 and return a pointer to it.
21954 If TYPE is NULL, determine symbol type from the die, otherwise
21955 used the passed type.
21956 If SPACE is not NULL, use it to hold the new symbol. If it is
21957 NULL, allocate a new symbol on the objfile's obstack. */
21959 static struct symbol
*
21960 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
,
21961 struct symbol
*space
)
21963 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
21964 struct objfile
*objfile
= per_objfile
->objfile
;
21965 struct gdbarch
*gdbarch
= objfile
->arch ();
21966 struct symbol
*sym
= NULL
;
21968 struct attribute
*attr
= NULL
;
21969 struct attribute
*attr2
= NULL
;
21970 CORE_ADDR baseaddr
;
21971 struct pending
**list_to_add
= NULL
;
21973 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
21975 baseaddr
= objfile
->text_section_offset ();
21977 name
= dwarf2_name (die
, cu
);
21980 int suppress_add
= 0;
21985 sym
= new (&objfile
->objfile_obstack
) symbol
;
21986 OBJSTAT (objfile
, n_syms
++);
21988 /* Cache this symbol's name and the name's demangled form (if any). */
21989 sym
->set_language (cu
->language
, &objfile
->objfile_obstack
);
21990 /* Fortran does not have mangling standard and the mangling does differ
21991 between gfortran, iFort etc. */
21992 const char *physname
21993 = (cu
->language
== language_fortran
21994 ? dwarf2_full_name (name
, die
, cu
)
21995 : dwarf2_physname (name
, die
, cu
));
21996 const char *linkagename
= dw2_linkage_name (die
, cu
);
21998 if (linkagename
== nullptr || cu
->language
== language_ada
)
21999 sym
->set_linkage_name (physname
);
22002 sym
->set_demangled_name (physname
, &objfile
->objfile_obstack
);
22003 sym
->set_linkage_name (linkagename
);
22006 /* Default assumptions.
22007 Use the passed type or decode it from the die. */
22008 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
22009 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
22011 SYMBOL_TYPE (sym
) = type
;
22013 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
22014 attr
= dwarf2_attr (die
,
22015 inlined_func
? DW_AT_call_line
: DW_AT_decl_line
,
22017 if (attr
!= nullptr)
22018 SYMBOL_LINE (sym
) = attr
->constant_value (0);
22020 attr
= dwarf2_attr (die
,
22021 inlined_func
? DW_AT_call_file
: DW_AT_decl_file
,
22023 if (attr
!= nullptr && attr
->is_nonnegative ())
22025 file_name_index file_index
22026 = (file_name_index
) attr
->as_nonnegative ();
22027 struct file_entry
*fe
;
22029 if (cu
->line_header
!= NULL
)
22030 fe
= cu
->line_header
->file_name_at (file_index
);
22035 complaint (_("file index out of range"));
22037 symbol_set_symtab (sym
, fe
->symtab
);
22043 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
22044 if (attr
!= nullptr)
22048 addr
= attr
->as_address ();
22049 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, addr
+ baseaddr
);
22050 SET_SYMBOL_VALUE_ADDRESS (sym
, addr
);
22051 SYMBOL_ACLASS_INDEX (sym
) = LOC_LABEL
;
22054 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
22055 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_core_addr
;
22056 SYMBOL_DOMAIN (sym
) = LABEL_DOMAIN
;
22057 add_symbol_to_list (sym
, cu
->list_in_scope
);
22059 case DW_TAG_subprogram
:
22060 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
22062 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
22063 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
22064 if ((attr2
!= nullptr && attr2
->as_boolean ())
22065 || cu
->language
== language_ada
22066 || cu
->language
== language_fortran
)
22068 /* Subprograms marked external are stored as a global symbol.
22069 Ada and Fortran subprograms, whether marked external or
22070 not, are always stored as a global symbol, because we want
22071 to be able to access them globally. For instance, we want
22072 to be able to break on a nested subprogram without having
22073 to specify the context. */
22074 list_to_add
= cu
->get_builder ()->get_global_symbols ();
22078 list_to_add
= cu
->list_in_scope
;
22081 case DW_TAG_inlined_subroutine
:
22082 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
22084 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
22085 SYMBOL_INLINED (sym
) = 1;
22086 list_to_add
= cu
->list_in_scope
;
22088 case DW_TAG_template_value_param
:
22090 /* Fall through. */
22091 case DW_TAG_constant
:
22092 case DW_TAG_variable
:
22093 case DW_TAG_member
:
22094 /* Compilation with minimal debug info may result in
22095 variables with missing type entries. Change the
22096 misleading `void' type to something sensible. */
22097 if (SYMBOL_TYPE (sym
)->code () == TYPE_CODE_VOID
)
22098 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_int
;
22100 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
22101 /* In the case of DW_TAG_member, we should only be called for
22102 static const members. */
22103 if (die
->tag
== DW_TAG_member
)
22105 /* dwarf2_add_field uses die_is_declaration,
22106 so we do the same. */
22107 gdb_assert (die_is_declaration (die
, cu
));
22110 if (attr
!= nullptr)
22112 dwarf2_const_value (attr
, sym
, cu
);
22113 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
22116 if (attr2
!= nullptr && attr2
->as_boolean ())
22117 list_to_add
= cu
->get_builder ()->get_global_symbols ();
22119 list_to_add
= cu
->list_in_scope
;
22123 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
22124 if (attr
!= nullptr)
22126 var_decode_location (attr
, sym
, cu
);
22127 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
22129 /* Fortran explicitly imports any global symbols to the local
22130 scope by DW_TAG_common_block. */
22131 if (cu
->language
== language_fortran
&& die
->parent
22132 && die
->parent
->tag
== DW_TAG_common_block
)
22135 if (SYMBOL_CLASS (sym
) == LOC_STATIC
22136 && SYMBOL_VALUE_ADDRESS (sym
) == 0
22137 && !per_objfile
->per_bfd
->has_section_at_zero
)
22139 /* When a static variable is eliminated by the linker,
22140 the corresponding debug information is not stripped
22141 out, but the variable address is set to null;
22142 do not add such variables into symbol table. */
22144 else if (attr2
!= nullptr && attr2
->as_boolean ())
22146 if (SYMBOL_CLASS (sym
) == LOC_STATIC
22147 && (objfile
->flags
& OBJF_MAINLINE
) == 0
22148 && per_objfile
->per_bfd
->can_copy
)
22150 /* A global static variable might be subject to
22151 copy relocation. We first check for a local
22152 minsym, though, because maybe the symbol was
22153 marked hidden, in which case this would not
22155 bound_minimal_symbol found
22156 = (lookup_minimal_symbol_linkage
22157 (sym
->linkage_name (), objfile
));
22158 if (found
.minsym
!= nullptr)
22159 sym
->maybe_copied
= 1;
22162 /* A variable with DW_AT_external is never static,
22163 but it may be block-scoped. */
22165 = ((cu
->list_in_scope
22166 == cu
->get_builder ()->get_file_symbols ())
22167 ? cu
->get_builder ()->get_global_symbols ()
22168 : cu
->list_in_scope
);
22171 list_to_add
= cu
->list_in_scope
;
22175 /* We do not know the address of this symbol.
22176 If it is an external symbol and we have type information
22177 for it, enter the symbol as a LOC_UNRESOLVED symbol.
22178 The address of the variable will then be determined from
22179 the minimal symbol table whenever the variable is
22181 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
22183 /* Fortran explicitly imports any global symbols to the local
22184 scope by DW_TAG_common_block. */
22185 if (cu
->language
== language_fortran
&& die
->parent
22186 && die
->parent
->tag
== DW_TAG_common_block
)
22188 /* SYMBOL_CLASS doesn't matter here because
22189 read_common_block is going to reset it. */
22191 list_to_add
= cu
->list_in_scope
;
22193 else if (attr2
!= nullptr && attr2
->as_boolean ()
22194 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
22196 /* A variable with DW_AT_external is never static, but it
22197 may be block-scoped. */
22199 = ((cu
->list_in_scope
22200 == cu
->get_builder ()->get_file_symbols ())
22201 ? cu
->get_builder ()->get_global_symbols ()
22202 : cu
->list_in_scope
);
22204 SYMBOL_ACLASS_INDEX (sym
) = LOC_UNRESOLVED
;
22206 else if (!die_is_declaration (die
, cu
))
22208 /* Use the default LOC_OPTIMIZED_OUT class. */
22209 gdb_assert (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
);
22211 list_to_add
= cu
->list_in_scope
;
22215 case DW_TAG_formal_parameter
:
22217 /* If we are inside a function, mark this as an argument. If
22218 not, we might be looking at an argument to an inlined function
22219 when we do not have enough information to show inlined frames;
22220 pretend it's a local variable in that case so that the user can
22222 struct context_stack
*curr
22223 = cu
->get_builder ()->get_current_context_stack ();
22224 if (curr
!= nullptr && curr
->name
!= nullptr)
22225 SYMBOL_IS_ARGUMENT (sym
) = 1;
22226 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
22227 if (attr
!= nullptr)
22229 var_decode_location (attr
, sym
, cu
);
22231 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
22232 if (attr
!= nullptr)
22234 dwarf2_const_value (attr
, sym
, cu
);
22237 list_to_add
= cu
->list_in_scope
;
22240 case DW_TAG_unspecified_parameters
:
22241 /* From varargs functions; gdb doesn't seem to have any
22242 interest in this information, so just ignore it for now.
22245 case DW_TAG_template_type_param
:
22247 /* Fall through. */
22248 case DW_TAG_class_type
:
22249 case DW_TAG_interface_type
:
22250 case DW_TAG_structure_type
:
22251 case DW_TAG_union_type
:
22252 case DW_TAG_set_type
:
22253 case DW_TAG_enumeration_type
:
22254 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
22255 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
22258 /* NOTE: carlton/2003-11-10: C++ class symbols shouldn't
22259 really ever be static objects: otherwise, if you try
22260 to, say, break of a class's method and you're in a file
22261 which doesn't mention that class, it won't work unless
22262 the check for all static symbols in lookup_symbol_aux
22263 saves you. See the OtherFileClass tests in
22264 gdb.c++/namespace.exp. */
22268 buildsym_compunit
*builder
= cu
->get_builder ();
22270 = (cu
->list_in_scope
== builder
->get_file_symbols ()
22271 && cu
->language
== language_cplus
22272 ? builder
->get_global_symbols ()
22273 : cu
->list_in_scope
);
22275 /* The semantics of C++ state that "struct foo {
22276 ... }" also defines a typedef for "foo". */
22277 if (cu
->language
== language_cplus
22278 || cu
->language
== language_ada
22279 || cu
->language
== language_d
22280 || cu
->language
== language_rust
)
22282 /* The symbol's name is already allocated along
22283 with this objfile, so we don't need to
22284 duplicate it for the type. */
22285 if (SYMBOL_TYPE (sym
)->name () == 0)
22286 SYMBOL_TYPE (sym
)->set_name (sym
->search_name ());
22291 case DW_TAG_typedef
:
22292 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
22293 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
22294 list_to_add
= cu
->list_in_scope
;
22296 case DW_TAG_array_type
:
22297 case DW_TAG_base_type
:
22298 case DW_TAG_subrange_type
:
22299 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
22300 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
22301 list_to_add
= cu
->list_in_scope
;
22303 case DW_TAG_enumerator
:
22304 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
22305 if (attr
!= nullptr)
22307 dwarf2_const_value (attr
, sym
, cu
);
22310 /* NOTE: carlton/2003-11-10: See comment above in the
22311 DW_TAG_class_type, etc. block. */
22314 = (cu
->list_in_scope
== cu
->get_builder ()->get_file_symbols ()
22315 && cu
->language
== language_cplus
22316 ? cu
->get_builder ()->get_global_symbols ()
22317 : cu
->list_in_scope
);
22320 case DW_TAG_imported_declaration
:
22321 case DW_TAG_namespace
:
22322 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
22323 list_to_add
= cu
->get_builder ()->get_global_symbols ();
22325 case DW_TAG_module
:
22326 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
22327 SYMBOL_DOMAIN (sym
) = MODULE_DOMAIN
;
22328 list_to_add
= cu
->get_builder ()->get_global_symbols ();
22330 case DW_TAG_common_block
:
22331 SYMBOL_ACLASS_INDEX (sym
) = LOC_COMMON_BLOCK
;
22332 SYMBOL_DOMAIN (sym
) = COMMON_BLOCK_DOMAIN
;
22333 add_symbol_to_list (sym
, cu
->list_in_scope
);
22336 /* Not a tag we recognize. Hopefully we aren't processing
22337 trash data, but since we must specifically ignore things
22338 we don't recognize, there is nothing else we should do at
22340 complaint (_("unsupported tag: '%s'"),
22341 dwarf_tag_name (die
->tag
));
22347 sym
->hash_next
= objfile
->template_symbols
;
22348 objfile
->template_symbols
= sym
;
22349 list_to_add
= NULL
;
22352 if (list_to_add
!= NULL
)
22353 add_symbol_to_list (sym
, list_to_add
);
22355 /* For the benefit of old versions of GCC, check for anonymous
22356 namespaces based on the demangled name. */
22357 if (!cu
->processing_has_namespace_info
22358 && cu
->language
== language_cplus
)
22359 cp_scan_for_anonymous_namespaces (cu
->get_builder (), sym
, objfile
);
22364 /* Given an attr with a DW_FORM_dataN value in host byte order,
22365 zero-extend it as appropriate for the symbol's type. The DWARF
22366 standard (v4) is not entirely clear about the meaning of using
22367 DW_FORM_dataN for a constant with a signed type, where the type is
22368 wider than the data. The conclusion of a discussion on the DWARF
22369 list was that this is unspecified. We choose to always zero-extend
22370 because that is the interpretation long in use by GCC. */
22373 dwarf2_const_value_data (const struct attribute
*attr
, struct obstack
*obstack
,
22374 struct dwarf2_cu
*cu
, LONGEST
*value
, int bits
)
22376 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22377 enum bfd_endian byte_order
= bfd_big_endian (objfile
->obfd
) ?
22378 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
22379 LONGEST l
= attr
->constant_value (0);
22381 if (bits
< sizeof (*value
) * 8)
22383 l
&= ((LONGEST
) 1 << bits
) - 1;
22386 else if (bits
== sizeof (*value
) * 8)
22390 gdb_byte
*bytes
= (gdb_byte
*) obstack_alloc (obstack
, bits
/ 8);
22391 store_unsigned_integer (bytes
, bits
/ 8, byte_order
, l
);
22398 /* Read a constant value from an attribute. Either set *VALUE, or if
22399 the value does not fit in *VALUE, set *BYTES - either already
22400 allocated on the objfile obstack, or newly allocated on OBSTACK,
22401 or, set *BATON, if we translated the constant to a location
22405 dwarf2_const_value_attr (const struct attribute
*attr
, struct type
*type
,
22406 const char *name
, struct obstack
*obstack
,
22407 struct dwarf2_cu
*cu
,
22408 LONGEST
*value
, const gdb_byte
**bytes
,
22409 struct dwarf2_locexpr_baton
**baton
)
22411 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
22412 struct objfile
*objfile
= per_objfile
->objfile
;
22413 struct comp_unit_head
*cu_header
= &cu
->header
;
22414 struct dwarf_block
*blk
;
22415 enum bfd_endian byte_order
= (bfd_big_endian (objfile
->obfd
) ?
22416 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
22422 switch (attr
->form
)
22425 case DW_FORM_addrx
:
22426 case DW_FORM_GNU_addr_index
:
22430 if (TYPE_LENGTH (type
) != cu_header
->addr_size
)
22431 dwarf2_const_value_length_mismatch_complaint (name
,
22432 cu_header
->addr_size
,
22433 TYPE_LENGTH (type
));
22434 /* Symbols of this form are reasonably rare, so we just
22435 piggyback on the existing location code rather than writing
22436 a new implementation of symbol_computed_ops. */
22437 *baton
= XOBNEW (obstack
, struct dwarf2_locexpr_baton
);
22438 (*baton
)->per_objfile
= per_objfile
;
22439 (*baton
)->per_cu
= cu
->per_cu
;
22440 gdb_assert ((*baton
)->per_cu
);
22442 (*baton
)->size
= 2 + cu_header
->addr_size
;
22443 data
= (gdb_byte
*) obstack_alloc (obstack
, (*baton
)->size
);
22444 (*baton
)->data
= data
;
22446 data
[0] = DW_OP_addr
;
22447 store_unsigned_integer (&data
[1], cu_header
->addr_size
,
22448 byte_order
, attr
->as_address ());
22449 data
[cu_header
->addr_size
+ 1] = DW_OP_stack_value
;
22452 case DW_FORM_string
:
22455 case DW_FORM_GNU_str_index
:
22456 case DW_FORM_GNU_strp_alt
:
22457 /* The string is already allocated on the objfile obstack, point
22459 *bytes
= (const gdb_byte
*) attr
->as_string ();
22461 case DW_FORM_block1
:
22462 case DW_FORM_block2
:
22463 case DW_FORM_block4
:
22464 case DW_FORM_block
:
22465 case DW_FORM_exprloc
:
22466 case DW_FORM_data16
:
22467 blk
= attr
->as_block ();
22468 if (TYPE_LENGTH (type
) != blk
->size
)
22469 dwarf2_const_value_length_mismatch_complaint (name
, blk
->size
,
22470 TYPE_LENGTH (type
));
22471 *bytes
= blk
->data
;
22474 /* The DW_AT_const_value attributes are supposed to carry the
22475 symbol's value "represented as it would be on the target
22476 architecture." By the time we get here, it's already been
22477 converted to host endianness, so we just need to sign- or
22478 zero-extend it as appropriate. */
22479 case DW_FORM_data1
:
22480 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 8);
22482 case DW_FORM_data2
:
22483 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 16);
22485 case DW_FORM_data4
:
22486 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 32);
22488 case DW_FORM_data8
:
22489 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 64);
22492 case DW_FORM_sdata
:
22493 case DW_FORM_implicit_const
:
22494 *value
= attr
->as_signed ();
22497 case DW_FORM_udata
:
22498 *value
= attr
->as_unsigned ();
22502 complaint (_("unsupported const value attribute form: '%s'"),
22503 dwarf_form_name (attr
->form
));
22510 /* Copy constant value from an attribute to a symbol. */
22513 dwarf2_const_value (const struct attribute
*attr
, struct symbol
*sym
,
22514 struct dwarf2_cu
*cu
)
22516 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22518 const gdb_byte
*bytes
;
22519 struct dwarf2_locexpr_baton
*baton
;
22521 dwarf2_const_value_attr (attr
, SYMBOL_TYPE (sym
),
22522 sym
->print_name (),
22523 &objfile
->objfile_obstack
, cu
,
22524 &value
, &bytes
, &baton
);
22528 SYMBOL_LOCATION_BATON (sym
) = baton
;
22529 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
22531 else if (bytes
!= NULL
)
22533 SYMBOL_VALUE_BYTES (sym
) = bytes
;
22534 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST_BYTES
;
22538 SYMBOL_VALUE (sym
) = value
;
22539 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST
;
22543 /* Return the type of the die in question using its DW_AT_type attribute. */
22545 static struct type
*
22546 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
22548 struct attribute
*type_attr
;
22550 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
22553 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22554 /* A missing DW_AT_type represents a void type. */
22555 return objfile_type (objfile
)->builtin_void
;
22558 return lookup_die_type (die
, type_attr
, cu
);
22561 /* True iff CU's producer generates GNAT Ada auxiliary information
22562 that allows to find parallel types through that information instead
22563 of having to do expensive parallel lookups by type name. */
22566 need_gnat_info (struct dwarf2_cu
*cu
)
22568 /* Assume that the Ada compiler was GNAT, which always produces
22569 the auxiliary information. */
22570 return (cu
->language
== language_ada
);
22573 /* Return the auxiliary type of the die in question using its
22574 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
22575 attribute is not present. */
22577 static struct type
*
22578 die_descriptive_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
22580 struct attribute
*type_attr
;
22582 type_attr
= dwarf2_attr (die
, DW_AT_GNAT_descriptive_type
, cu
);
22586 return lookup_die_type (die
, type_attr
, cu
);
22589 /* If DIE has a descriptive_type attribute, then set the TYPE's
22590 descriptive type accordingly. */
22593 set_descriptive_type (struct type
*type
, struct die_info
*die
,
22594 struct dwarf2_cu
*cu
)
22596 struct type
*descriptive_type
= die_descriptive_type (die
, cu
);
22598 if (descriptive_type
)
22600 ALLOCATE_GNAT_AUX_TYPE (type
);
22601 TYPE_DESCRIPTIVE_TYPE (type
) = descriptive_type
;
22605 /* Return the containing type of the die in question using its
22606 DW_AT_containing_type attribute. */
22608 static struct type
*
22609 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
22611 struct attribute
*type_attr
;
22612 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22614 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
22616 error (_("Dwarf Error: Problem turning containing type into gdb type "
22617 "[in module %s]"), objfile_name (objfile
));
22619 return lookup_die_type (die
, type_attr
, cu
);
22622 /* Return an error marker type to use for the ill formed type in DIE/CU. */
22624 static struct type
*
22625 build_error_marker_type (struct dwarf2_cu
*cu
, struct die_info
*die
)
22627 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
22628 struct objfile
*objfile
= per_objfile
->objfile
;
22631 std::string message
22632 = string_printf (_("<unknown type in %s, CU %s, DIE %s>"),
22633 objfile_name (objfile
),
22634 sect_offset_str (cu
->header
.sect_off
),
22635 sect_offset_str (die
->sect_off
));
22636 saved
= obstack_strdup (&objfile
->objfile_obstack
, message
);
22638 return init_type (objfile
, TYPE_CODE_ERROR
, 0, saved
);
22641 /* Look up the type of DIE in CU using its type attribute ATTR.
22642 ATTR must be one of: DW_AT_type, DW_AT_GNAT_descriptive_type,
22643 DW_AT_containing_type.
22644 If there is no type substitute an error marker. */
22646 static struct type
*
22647 lookup_die_type (struct die_info
*die
, const struct attribute
*attr
,
22648 struct dwarf2_cu
*cu
)
22650 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
22651 struct objfile
*objfile
= per_objfile
->objfile
;
22652 struct type
*this_type
;
22654 gdb_assert (attr
->name
== DW_AT_type
22655 || attr
->name
== DW_AT_GNAT_descriptive_type
22656 || attr
->name
== DW_AT_containing_type
);
22658 /* First see if we have it cached. */
22660 if (attr
->form
== DW_FORM_GNU_ref_alt
)
22662 struct dwarf2_per_cu_data
*per_cu
;
22663 sect_offset sect_off
= attr
->get_ref_die_offset ();
22665 per_cu
= dwarf2_find_containing_comp_unit (sect_off
, 1, per_objfile
);
22666 this_type
= get_die_type_at_offset (sect_off
, per_cu
, per_objfile
);
22668 else if (attr
->form_is_ref ())
22670 sect_offset sect_off
= attr
->get_ref_die_offset ();
22672 this_type
= get_die_type_at_offset (sect_off
, cu
->per_cu
, per_objfile
);
22674 else if (attr
->form
== DW_FORM_ref_sig8
)
22676 ULONGEST signature
= attr
->as_signature ();
22678 return get_signatured_type (die
, signature
, cu
);
22682 complaint (_("Dwarf Error: Bad type attribute %s in DIE"
22683 " at %s [in module %s]"),
22684 dwarf_attr_name (attr
->name
), sect_offset_str (die
->sect_off
),
22685 objfile_name (objfile
));
22686 return build_error_marker_type (cu
, die
);
22689 /* If not cached we need to read it in. */
22691 if (this_type
== NULL
)
22693 struct die_info
*type_die
= NULL
;
22694 struct dwarf2_cu
*type_cu
= cu
;
22696 if (attr
->form_is_ref ())
22697 type_die
= follow_die_ref (die
, attr
, &type_cu
);
22698 if (type_die
== NULL
)
22699 return build_error_marker_type (cu
, die
);
22700 /* If we find the type now, it's probably because the type came
22701 from an inter-CU reference and the type's CU got expanded before
22703 this_type
= read_type_die (type_die
, type_cu
);
22706 /* If we still don't have a type use an error marker. */
22708 if (this_type
== NULL
)
22709 return build_error_marker_type (cu
, die
);
22714 /* Return the type in DIE, CU.
22715 Returns NULL for invalid types.
22717 This first does a lookup in die_type_hash,
22718 and only reads the die in if necessary.
22720 NOTE: This can be called when reading in partial or full symbols. */
22722 static struct type
*
22723 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
22725 struct type
*this_type
;
22727 this_type
= get_die_type (die
, cu
);
22731 return read_type_die_1 (die
, cu
);
22734 /* Read the type in DIE, CU.
22735 Returns NULL for invalid types. */
22737 static struct type
*
22738 read_type_die_1 (struct die_info
*die
, struct dwarf2_cu
*cu
)
22740 struct type
*this_type
= NULL
;
22744 case DW_TAG_class_type
:
22745 case DW_TAG_interface_type
:
22746 case DW_TAG_structure_type
:
22747 case DW_TAG_union_type
:
22748 this_type
= read_structure_type (die
, cu
);
22750 case DW_TAG_enumeration_type
:
22751 this_type
= read_enumeration_type (die
, cu
);
22753 case DW_TAG_subprogram
:
22754 case DW_TAG_subroutine_type
:
22755 case DW_TAG_inlined_subroutine
:
22756 this_type
= read_subroutine_type (die
, cu
);
22758 case DW_TAG_array_type
:
22759 this_type
= read_array_type (die
, cu
);
22761 case DW_TAG_set_type
:
22762 this_type
= read_set_type (die
, cu
);
22764 case DW_TAG_pointer_type
:
22765 this_type
= read_tag_pointer_type (die
, cu
);
22767 case DW_TAG_ptr_to_member_type
:
22768 this_type
= read_tag_ptr_to_member_type (die
, cu
);
22770 case DW_TAG_reference_type
:
22771 this_type
= read_tag_reference_type (die
, cu
, TYPE_CODE_REF
);
22773 case DW_TAG_rvalue_reference_type
:
22774 this_type
= read_tag_reference_type (die
, cu
, TYPE_CODE_RVALUE_REF
);
22776 case DW_TAG_const_type
:
22777 this_type
= read_tag_const_type (die
, cu
);
22779 case DW_TAG_volatile_type
:
22780 this_type
= read_tag_volatile_type (die
, cu
);
22782 case DW_TAG_restrict_type
:
22783 this_type
= read_tag_restrict_type (die
, cu
);
22785 case DW_TAG_string_type
:
22786 this_type
= read_tag_string_type (die
, cu
);
22788 case DW_TAG_typedef
:
22789 this_type
= read_typedef (die
, cu
);
22791 case DW_TAG_subrange_type
:
22792 this_type
= read_subrange_type (die
, cu
);
22794 case DW_TAG_base_type
:
22795 this_type
= read_base_type (die
, cu
);
22797 case DW_TAG_unspecified_type
:
22798 this_type
= read_unspecified_type (die
, cu
);
22800 case DW_TAG_namespace
:
22801 this_type
= read_namespace_type (die
, cu
);
22803 case DW_TAG_module
:
22804 this_type
= read_module_type (die
, cu
);
22806 case DW_TAG_atomic_type
:
22807 this_type
= read_tag_atomic_type (die
, cu
);
22810 complaint (_("unexpected tag in read_type_die: '%s'"),
22811 dwarf_tag_name (die
->tag
));
22818 /* See if we can figure out if the class lives in a namespace. We do
22819 this by looking for a member function; its demangled name will
22820 contain namespace info, if there is any.
22821 Return the computed name or NULL.
22822 Space for the result is allocated on the objfile's obstack.
22823 This is the full-die version of guess_partial_die_structure_name.
22824 In this case we know DIE has no useful parent. */
22826 static const char *
22827 guess_full_die_structure_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
22829 struct die_info
*spec_die
;
22830 struct dwarf2_cu
*spec_cu
;
22831 struct die_info
*child
;
22832 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22835 spec_die
= die_specification (die
, &spec_cu
);
22836 if (spec_die
!= NULL
)
22842 for (child
= die
->child
;
22844 child
= child
->sibling
)
22846 if (child
->tag
== DW_TAG_subprogram
)
22848 const char *linkage_name
= dw2_linkage_name (child
, cu
);
22850 if (linkage_name
!= NULL
)
22852 gdb::unique_xmalloc_ptr
<char> actual_name
22853 (cu
->language_defn
->class_name_from_physname (linkage_name
));
22854 const char *name
= NULL
;
22856 if (actual_name
!= NULL
)
22858 const char *die_name
= dwarf2_name (die
, cu
);
22860 if (die_name
!= NULL
22861 && strcmp (die_name
, actual_name
.get ()) != 0)
22863 /* Strip off the class name from the full name.
22864 We want the prefix. */
22865 int die_name_len
= strlen (die_name
);
22866 int actual_name_len
= strlen (actual_name
.get ());
22867 const char *ptr
= actual_name
.get ();
22869 /* Test for '::' as a sanity check. */
22870 if (actual_name_len
> die_name_len
+ 2
22871 && ptr
[actual_name_len
- die_name_len
- 1] == ':')
22872 name
= obstack_strndup (
22873 &objfile
->per_bfd
->storage_obstack
,
22874 ptr
, actual_name_len
- die_name_len
- 2);
22885 /* GCC might emit a nameless typedef that has a linkage name. Determine the
22886 prefix part in such case. See
22887 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
22889 static const char *
22890 anonymous_struct_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
22892 struct attribute
*attr
;
22895 if (die
->tag
!= DW_TAG_class_type
&& die
->tag
!= DW_TAG_interface_type
22896 && die
->tag
!= DW_TAG_structure_type
&& die
->tag
!= DW_TAG_union_type
)
22899 if (dwarf2_string_attr (die
, DW_AT_name
, cu
) != NULL
)
22902 attr
= dw2_linkage_name_attr (die
, cu
);
22903 const char *attr_name
= attr
->as_string ();
22904 if (attr
== NULL
|| attr_name
== NULL
)
22907 /* dwarf2_name had to be already called. */
22908 gdb_assert (attr
->canonical_string_p ());
22910 /* Strip the base name, keep any leading namespaces/classes. */
22911 base
= strrchr (attr_name
, ':');
22912 if (base
== NULL
|| base
== attr_name
|| base
[-1] != ':')
22915 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22916 return obstack_strndup (&objfile
->per_bfd
->storage_obstack
,
22918 &base
[-1] - attr_name
);
22921 /* Return the name of the namespace/class that DIE is defined within,
22922 or "" if we can't tell. The caller should not xfree the result.
22924 For example, if we're within the method foo() in the following
22934 then determine_prefix on foo's die will return "N::C". */
22936 static const char *
22937 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
22939 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
22940 struct die_info
*parent
, *spec_die
;
22941 struct dwarf2_cu
*spec_cu
;
22942 struct type
*parent_type
;
22943 const char *retval
;
22945 if (cu
->language
!= language_cplus
22946 && cu
->language
!= language_fortran
&& cu
->language
!= language_d
22947 && cu
->language
!= language_rust
)
22950 retval
= anonymous_struct_prefix (die
, cu
);
22954 /* We have to be careful in the presence of DW_AT_specification.
22955 For example, with GCC 3.4, given the code
22959 // Definition of N::foo.
22963 then we'll have a tree of DIEs like this:
22965 1: DW_TAG_compile_unit
22966 2: DW_TAG_namespace // N
22967 3: DW_TAG_subprogram // declaration of N::foo
22968 4: DW_TAG_subprogram // definition of N::foo
22969 DW_AT_specification // refers to die #3
22971 Thus, when processing die #4, we have to pretend that we're in
22972 the context of its DW_AT_specification, namely the contex of die
22975 spec_die
= die_specification (die
, &spec_cu
);
22976 if (spec_die
== NULL
)
22977 parent
= die
->parent
;
22980 parent
= spec_die
->parent
;
22984 if (parent
== NULL
)
22986 else if (parent
->building_fullname
)
22989 const char *parent_name
;
22991 /* It has been seen on RealView 2.2 built binaries,
22992 DW_TAG_template_type_param types actually _defined_ as
22993 children of the parent class:
22996 template class <class Enum> Class{};
22997 Class<enum E> class_e;
22999 1: DW_TAG_class_type (Class)
23000 2: DW_TAG_enumeration_type (E)
23001 3: DW_TAG_enumerator (enum1:0)
23002 3: DW_TAG_enumerator (enum2:1)
23004 2: DW_TAG_template_type_param
23005 DW_AT_type DW_FORM_ref_udata (E)
23007 Besides being broken debug info, it can put GDB into an
23008 infinite loop. Consider:
23010 When we're building the full name for Class<E>, we'll start
23011 at Class, and go look over its template type parameters,
23012 finding E. We'll then try to build the full name of E, and
23013 reach here. We're now trying to build the full name of E,
23014 and look over the parent DIE for containing scope. In the
23015 broken case, if we followed the parent DIE of E, we'd again
23016 find Class, and once again go look at its template type
23017 arguments, etc., etc. Simply don't consider such parent die
23018 as source-level parent of this die (it can't be, the language
23019 doesn't allow it), and break the loop here. */
23020 name
= dwarf2_name (die
, cu
);
23021 parent_name
= dwarf2_name (parent
, cu
);
23022 complaint (_("template param type '%s' defined within parent '%s'"),
23023 name
? name
: "<unknown>",
23024 parent_name
? parent_name
: "<unknown>");
23028 switch (parent
->tag
)
23030 case DW_TAG_namespace
:
23031 parent_type
= read_type_die (parent
, cu
);
23032 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
23033 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
23034 Work around this problem here. */
23035 if (cu
->language
== language_cplus
23036 && strcmp (parent_type
->name (), "::") == 0)
23038 /* We give a name to even anonymous namespaces. */
23039 return parent_type
->name ();
23040 case DW_TAG_class_type
:
23041 case DW_TAG_interface_type
:
23042 case DW_TAG_structure_type
:
23043 case DW_TAG_union_type
:
23044 case DW_TAG_module
:
23045 parent_type
= read_type_die (parent
, cu
);
23046 if (parent_type
->name () != NULL
)
23047 return parent_type
->name ();
23049 /* An anonymous structure is only allowed non-static data
23050 members; no typedefs, no member functions, et cetera.
23051 So it does not need a prefix. */
23053 case DW_TAG_compile_unit
:
23054 case DW_TAG_partial_unit
:
23055 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
23056 if (cu
->language
== language_cplus
23057 && !per_objfile
->per_bfd
->types
.empty ()
23058 && die
->child
!= NULL
23059 && (die
->tag
== DW_TAG_class_type
23060 || die
->tag
== DW_TAG_structure_type
23061 || die
->tag
== DW_TAG_union_type
))
23063 const char *name
= guess_full_die_structure_name (die
, cu
);
23068 case DW_TAG_subprogram
:
23069 /* Nested subroutines in Fortran get a prefix with the name
23070 of the parent's subroutine. */
23071 if (cu
->language
== language_fortran
)
23073 if ((die
->tag
== DW_TAG_subprogram
)
23074 && (dwarf2_name (parent
, cu
) != NULL
))
23075 return dwarf2_name (parent
, cu
);
23077 return determine_prefix (parent
, cu
);
23078 case DW_TAG_enumeration_type
:
23079 parent_type
= read_type_die (parent
, cu
);
23080 if (parent_type
->is_declared_class ())
23082 if (parent_type
->name () != NULL
)
23083 return parent_type
->name ();
23086 /* Fall through. */
23088 return determine_prefix (parent
, cu
);
23092 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
23093 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
23094 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
23095 an obconcat, otherwise allocate storage for the result. The CU argument is
23096 used to determine the language and hence, the appropriate separator. */
23098 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
23101 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
23102 int physname
, struct dwarf2_cu
*cu
)
23104 const char *lead
= "";
23107 if (suffix
== NULL
|| suffix
[0] == '\0'
23108 || prefix
== NULL
|| prefix
[0] == '\0')
23110 else if (cu
->language
== language_d
)
23112 /* For D, the 'main' function could be defined in any module, but it
23113 should never be prefixed. */
23114 if (strcmp (suffix
, "D main") == 0)
23122 else if (cu
->language
== language_fortran
&& physname
)
23124 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
23125 DW_AT_MIPS_linkage_name is preferred and used instead. */
23133 if (prefix
== NULL
)
23135 if (suffix
== NULL
)
23142 xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1));
23144 strcpy (retval
, lead
);
23145 strcat (retval
, prefix
);
23146 strcat (retval
, sep
);
23147 strcat (retval
, suffix
);
23152 /* We have an obstack. */
23153 return obconcat (obs
, lead
, prefix
, sep
, suffix
, (char *) NULL
);
23157 /* Get name of a die, return NULL if not found. */
23159 static const char *
23160 dwarf2_canonicalize_name (const char *name
, struct dwarf2_cu
*cu
,
23161 struct objfile
*objfile
)
23163 if (name
&& cu
->language
== language_cplus
)
23165 gdb::unique_xmalloc_ptr
<char> canon_name
23166 = cp_canonicalize_string (name
);
23168 if (canon_name
!= nullptr)
23169 name
= objfile
->intern (canon_name
.get ());
23175 /* Get name of a die, return NULL if not found.
23176 Anonymous namespaces are converted to their magic string. */
23178 static const char *
23179 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
23181 struct attribute
*attr
;
23182 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
23184 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
23185 const char *attr_name
= attr
== nullptr ? nullptr : attr
->as_string ();
23186 if (attr_name
== nullptr
23187 && die
->tag
!= DW_TAG_namespace
23188 && die
->tag
!= DW_TAG_class_type
23189 && die
->tag
!= DW_TAG_interface_type
23190 && die
->tag
!= DW_TAG_structure_type
23191 && die
->tag
!= DW_TAG_union_type
)
23196 case DW_TAG_compile_unit
:
23197 case DW_TAG_partial_unit
:
23198 /* Compilation units have a DW_AT_name that is a filename, not
23199 a source language identifier. */
23200 case DW_TAG_enumeration_type
:
23201 case DW_TAG_enumerator
:
23202 /* These tags always have simple identifiers already; no need
23203 to canonicalize them. */
23206 case DW_TAG_namespace
:
23207 if (attr_name
!= nullptr)
23209 return CP_ANONYMOUS_NAMESPACE_STR
;
23211 case DW_TAG_class_type
:
23212 case DW_TAG_interface_type
:
23213 case DW_TAG_structure_type
:
23214 case DW_TAG_union_type
:
23215 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
23216 structures or unions. These were of the form "._%d" in GCC 4.1,
23217 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
23218 and GCC 4.4. We work around this problem by ignoring these. */
23219 if (attr_name
!= nullptr
23220 && (startswith (attr_name
, "._")
23221 || startswith (attr_name
, "<anonymous")))
23224 /* GCC might emit a nameless typedef that has a linkage name. See
23225 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
23226 if (!attr
|| attr_name
== NULL
)
23228 attr
= dw2_linkage_name_attr (die
, cu
);
23229 attr_name
= attr
== nullptr ? nullptr : attr
->as_string ();
23230 if (attr
== NULL
|| attr_name
== NULL
)
23233 /* Avoid demangling attr_name the second time on a second
23234 call for the same DIE. */
23235 if (!attr
->canonical_string_p ())
23237 gdb::unique_xmalloc_ptr
<char> demangled
23238 (gdb_demangle (attr_name
, DMGL_TYPES
));
23239 if (demangled
== nullptr)
23242 attr
->set_string_canonical (objfile
->intern (demangled
.get ()));
23243 attr_name
= attr
->as_string ();
23246 /* Strip any leading namespaces/classes, keep only the
23247 base name. DW_AT_name for named DIEs does not
23248 contain the prefixes. */
23249 const char *base
= strrchr (attr_name
, ':');
23250 if (base
&& base
> attr_name
&& base
[-1] == ':')
23261 if (!attr
->canonical_string_p ())
23262 attr
->set_string_canonical (dwarf2_canonicalize_name (attr_name
, cu
,
23264 return attr
->as_string ();
23267 /* Return the die that this die in an extension of, or NULL if there
23268 is none. *EXT_CU is the CU containing DIE on input, and the CU
23269 containing the return value on output. */
23271 static struct die_info
*
23272 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
**ext_cu
)
23274 struct attribute
*attr
;
23276 attr
= dwarf2_attr (die
, DW_AT_extension
, *ext_cu
);
23280 return follow_die_ref (die
, attr
, ext_cu
);
23284 dump_die_shallow (struct ui_file
*f
, int indent
, struct die_info
*die
)
23288 print_spaces (indent
, f
);
23289 fprintf_unfiltered (f
, "Die: %s (abbrev %d, offset %s)\n",
23290 dwarf_tag_name (die
->tag
), die
->abbrev
,
23291 sect_offset_str (die
->sect_off
));
23293 if (die
->parent
!= NULL
)
23295 print_spaces (indent
, f
);
23296 fprintf_unfiltered (f
, " parent at offset: %s\n",
23297 sect_offset_str (die
->parent
->sect_off
));
23300 print_spaces (indent
, f
);
23301 fprintf_unfiltered (f
, " has children: %s\n",
23302 dwarf_bool_name (die
->child
!= NULL
));
23304 print_spaces (indent
, f
);
23305 fprintf_unfiltered (f
, " attributes:\n");
23307 for (i
= 0; i
< die
->num_attrs
; ++i
)
23309 print_spaces (indent
, f
);
23310 fprintf_unfiltered (f
, " %s (%s) ",
23311 dwarf_attr_name (die
->attrs
[i
].name
),
23312 dwarf_form_name (die
->attrs
[i
].form
));
23314 switch (die
->attrs
[i
].form
)
23317 case DW_FORM_addrx
:
23318 case DW_FORM_GNU_addr_index
:
23319 fprintf_unfiltered (f
, "address: ");
23320 fputs_filtered (hex_string (die
->attrs
[i
].as_address ()), f
);
23322 case DW_FORM_block2
:
23323 case DW_FORM_block4
:
23324 case DW_FORM_block
:
23325 case DW_FORM_block1
:
23326 fprintf_unfiltered (f
, "block: size %s",
23327 pulongest (die
->attrs
[i
].as_block ()->size
));
23329 case DW_FORM_exprloc
:
23330 fprintf_unfiltered (f
, "expression: size %s",
23331 pulongest (die
->attrs
[i
].as_block ()->size
));
23333 case DW_FORM_data16
:
23334 fprintf_unfiltered (f
, "constant of 16 bytes");
23336 case DW_FORM_ref_addr
:
23337 fprintf_unfiltered (f
, "ref address: ");
23338 fputs_filtered (hex_string (die
->attrs
[i
].as_unsigned ()), f
);
23340 case DW_FORM_GNU_ref_alt
:
23341 fprintf_unfiltered (f
, "alt ref address: ");
23342 fputs_filtered (hex_string (die
->attrs
[i
].as_unsigned ()), f
);
23348 case DW_FORM_ref_udata
:
23349 fprintf_unfiltered (f
, "constant ref: 0x%lx (adjusted)",
23350 (long) (die
->attrs
[i
].as_unsigned ()));
23352 case DW_FORM_data1
:
23353 case DW_FORM_data2
:
23354 case DW_FORM_data4
:
23355 case DW_FORM_data8
:
23356 case DW_FORM_udata
:
23357 fprintf_unfiltered (f
, "constant: %s",
23358 pulongest (die
->attrs
[i
].as_unsigned ()));
23360 case DW_FORM_sec_offset
:
23361 fprintf_unfiltered (f
, "section offset: %s",
23362 pulongest (die
->attrs
[i
].as_unsigned ()));
23364 case DW_FORM_ref_sig8
:
23365 fprintf_unfiltered (f
, "signature: %s",
23366 hex_string (die
->attrs
[i
].as_signature ()));
23368 case DW_FORM_string
:
23370 case DW_FORM_line_strp
:
23372 case DW_FORM_GNU_str_index
:
23373 case DW_FORM_GNU_strp_alt
:
23374 fprintf_unfiltered (f
, "string: \"%s\" (%s canonicalized)",
23375 die
->attrs
[i
].as_string ()
23376 ? die
->attrs
[i
].as_string () : "",
23377 die
->attrs
[i
].canonical_string_p () ? "is" : "not");
23380 if (die
->attrs
[i
].as_boolean ())
23381 fprintf_unfiltered (f
, "flag: TRUE");
23383 fprintf_unfiltered (f
, "flag: FALSE");
23385 case DW_FORM_flag_present
:
23386 fprintf_unfiltered (f
, "flag: TRUE");
23388 case DW_FORM_indirect
:
23389 /* The reader will have reduced the indirect form to
23390 the "base form" so this form should not occur. */
23391 fprintf_unfiltered (f
,
23392 "unexpected attribute form: DW_FORM_indirect");
23394 case DW_FORM_sdata
:
23395 case DW_FORM_implicit_const
:
23396 fprintf_unfiltered (f
, "constant: %s",
23397 plongest (die
->attrs
[i
].as_signed ()));
23400 fprintf_unfiltered (f
, "unsupported attribute form: %d.",
23401 die
->attrs
[i
].form
);
23404 fprintf_unfiltered (f
, "\n");
23409 dump_die_for_error (struct die_info
*die
)
23411 dump_die_shallow (gdb_stderr
, 0, die
);
23415 dump_die_1 (struct ui_file
*f
, int level
, int max_level
, struct die_info
*die
)
23417 int indent
= level
* 4;
23419 gdb_assert (die
!= NULL
);
23421 if (level
>= max_level
)
23424 dump_die_shallow (f
, indent
, die
);
23426 if (die
->child
!= NULL
)
23428 print_spaces (indent
, f
);
23429 fprintf_unfiltered (f
, " Children:");
23430 if (level
+ 1 < max_level
)
23432 fprintf_unfiltered (f
, "\n");
23433 dump_die_1 (f
, level
+ 1, max_level
, die
->child
);
23437 fprintf_unfiltered (f
,
23438 " [not printed, max nesting level reached]\n");
23442 if (die
->sibling
!= NULL
&& level
> 0)
23444 dump_die_1 (f
, level
, max_level
, die
->sibling
);
23448 /* This is called from the pdie macro in gdbinit.in.
23449 It's not static so gcc will keep a copy callable from gdb. */
23452 dump_die (struct die_info
*die
, int max_level
)
23454 dump_die_1 (gdb_stdlog
, 0, max_level
, die
);
23458 store_in_ref_table (struct die_info
*die
, struct dwarf2_cu
*cu
)
23462 slot
= htab_find_slot_with_hash (cu
->die_hash
, die
,
23463 to_underlying (die
->sect_off
),
23469 /* Follow reference or signature attribute ATTR of SRC_DIE.
23470 On entry *REF_CU is the CU of SRC_DIE.
23471 On exit *REF_CU is the CU of the result. */
23473 static struct die_info
*
23474 follow_die_ref_or_sig (struct die_info
*src_die
, const struct attribute
*attr
,
23475 struct dwarf2_cu
**ref_cu
)
23477 struct die_info
*die
;
23479 if (attr
->form_is_ref ())
23480 die
= follow_die_ref (src_die
, attr
, ref_cu
);
23481 else if (attr
->form
== DW_FORM_ref_sig8
)
23482 die
= follow_die_sig (src_die
, attr
, ref_cu
);
23485 dump_die_for_error (src_die
);
23486 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
23487 objfile_name ((*ref_cu
)->per_objfile
->objfile
));
23493 /* Follow reference OFFSET.
23494 On entry *REF_CU is the CU of the source die referencing OFFSET.
23495 On exit *REF_CU is the CU of the result.
23496 Returns NULL if OFFSET is invalid. */
23498 static struct die_info
*
23499 follow_die_offset (sect_offset sect_off
, int offset_in_dwz
,
23500 struct dwarf2_cu
**ref_cu
)
23502 struct die_info temp_die
;
23503 struct dwarf2_cu
*target_cu
, *cu
= *ref_cu
;
23504 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
23506 gdb_assert (cu
->per_cu
!= NULL
);
23510 dwarf_read_debug_printf_v ("source CU offset: %s, target offset: %s, "
23511 "source CU contains target offset: %d",
23512 sect_offset_str (cu
->per_cu
->sect_off
),
23513 sect_offset_str (sect_off
),
23514 cu
->header
.offset_in_cu_p (sect_off
));
23516 if (cu
->per_cu
->is_debug_types
)
23518 /* .debug_types CUs cannot reference anything outside their CU.
23519 If they need to, they have to reference a signatured type via
23520 DW_FORM_ref_sig8. */
23521 if (!cu
->header
.offset_in_cu_p (sect_off
))
23524 else if (offset_in_dwz
!= cu
->per_cu
->is_dwz
23525 || !cu
->header
.offset_in_cu_p (sect_off
))
23527 struct dwarf2_per_cu_data
*per_cu
;
23529 per_cu
= dwarf2_find_containing_comp_unit (sect_off
, offset_in_dwz
,
23532 dwarf_read_debug_printf_v ("target CU offset: %s, "
23533 "target CU DIEs loaded: %d",
23534 sect_offset_str (per_cu
->sect_off
),
23535 per_objfile
->get_cu (per_cu
) != nullptr);
23537 /* If necessary, add it to the queue and load its DIEs.
23539 Even if maybe_queue_comp_unit doesn't require us to load the CU's DIEs,
23540 it doesn't mean they are currently loaded. Since we require them
23541 to be loaded, we must check for ourselves. */
23542 if (maybe_queue_comp_unit (cu
, per_cu
, per_objfile
, cu
->language
)
23543 || per_objfile
->get_cu (per_cu
) == nullptr)
23544 load_full_comp_unit (per_cu
, per_objfile
, per_objfile
->get_cu (per_cu
),
23545 false, cu
->language
);
23547 target_cu
= per_objfile
->get_cu (per_cu
);
23548 gdb_assert (target_cu
!= nullptr);
23550 else if (cu
->dies
== NULL
)
23552 /* We're loading full DIEs during partial symbol reading. */
23553 gdb_assert (per_objfile
->per_bfd
->reading_partial_symbols
);
23554 load_full_comp_unit (cu
->per_cu
, per_objfile
, cu
, false,
23558 *ref_cu
= target_cu
;
23559 temp_die
.sect_off
= sect_off
;
23561 if (target_cu
!= cu
)
23562 target_cu
->ancestor
= cu
;
23564 return (struct die_info
*) htab_find_with_hash (target_cu
->die_hash
,
23566 to_underlying (sect_off
));
23569 /* Follow reference attribute ATTR of SRC_DIE.
23570 On entry *REF_CU is the CU of SRC_DIE.
23571 On exit *REF_CU is the CU of the result. */
23573 static struct die_info
*
23574 follow_die_ref (struct die_info
*src_die
, const struct attribute
*attr
,
23575 struct dwarf2_cu
**ref_cu
)
23577 sect_offset sect_off
= attr
->get_ref_die_offset ();
23578 struct dwarf2_cu
*cu
= *ref_cu
;
23579 struct die_info
*die
;
23581 die
= follow_die_offset (sect_off
,
23582 (attr
->form
== DW_FORM_GNU_ref_alt
23583 || cu
->per_cu
->is_dwz
),
23586 error (_("Dwarf Error: Cannot find DIE at %s referenced from DIE "
23587 "at %s [in module %s]"),
23588 sect_offset_str (sect_off
), sect_offset_str (src_die
->sect_off
),
23589 objfile_name (cu
->per_objfile
->objfile
));
23596 struct dwarf2_locexpr_baton
23597 dwarf2_fetch_die_loc_sect_off (sect_offset sect_off
,
23598 dwarf2_per_cu_data
*per_cu
,
23599 dwarf2_per_objfile
*per_objfile
,
23600 gdb::function_view
<CORE_ADDR ()> get_frame_pc
,
23601 bool resolve_abstract_p
)
23603 struct die_info
*die
;
23604 struct attribute
*attr
;
23605 struct dwarf2_locexpr_baton retval
;
23606 struct objfile
*objfile
= per_objfile
->objfile
;
23608 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
23610 cu
= load_cu (per_cu
, per_objfile
, false);
23614 /* We shouldn't get here for a dummy CU, but don't crash on the user.
23615 Instead just throw an error, not much else we can do. */
23616 error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23617 sect_offset_str (sect_off
), objfile_name (objfile
));
23620 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
23622 error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23623 sect_offset_str (sect_off
), objfile_name (objfile
));
23625 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
23626 if (!attr
&& resolve_abstract_p
23627 && (per_objfile
->per_bfd
->abstract_to_concrete
.find (die
->sect_off
)
23628 != per_objfile
->per_bfd
->abstract_to_concrete
.end ()))
23630 CORE_ADDR pc
= get_frame_pc ();
23631 CORE_ADDR baseaddr
= objfile
->text_section_offset ();
23632 struct gdbarch
*gdbarch
= objfile
->arch ();
23634 for (const auto &cand_off
23635 : per_objfile
->per_bfd
->abstract_to_concrete
[die
->sect_off
])
23637 struct dwarf2_cu
*cand_cu
= cu
;
23638 struct die_info
*cand
23639 = follow_die_offset (cand_off
, per_cu
->is_dwz
, &cand_cu
);
23642 || cand
->parent
->tag
!= DW_TAG_subprogram
)
23645 CORE_ADDR pc_low
, pc_high
;
23646 get_scope_pc_bounds (cand
->parent
, &pc_low
, &pc_high
, cu
);
23647 if (pc_low
== ((CORE_ADDR
) -1))
23649 pc_low
= gdbarch_adjust_dwarf2_addr (gdbarch
, pc_low
+ baseaddr
);
23650 pc_high
= gdbarch_adjust_dwarf2_addr (gdbarch
, pc_high
+ baseaddr
);
23651 if (!(pc_low
<= pc
&& pc
< pc_high
))
23655 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
23662 /* DWARF: "If there is no such attribute, then there is no effect.".
23663 DATA is ignored if SIZE is 0. */
23665 retval
.data
= NULL
;
23668 else if (attr
->form_is_section_offset ())
23670 struct dwarf2_loclist_baton loclist_baton
;
23671 CORE_ADDR pc
= get_frame_pc ();
23674 fill_in_loclist_baton (cu
, &loclist_baton
, attr
);
23676 retval
.data
= dwarf2_find_location_expression (&loclist_baton
,
23678 retval
.size
= size
;
23682 if (!attr
->form_is_block ())
23683 error (_("Dwarf Error: DIE at %s referenced in module %s "
23684 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
23685 sect_offset_str (sect_off
), objfile_name (objfile
));
23687 struct dwarf_block
*block
= attr
->as_block ();
23688 retval
.data
= block
->data
;
23689 retval
.size
= block
->size
;
23691 retval
.per_objfile
= per_objfile
;
23692 retval
.per_cu
= cu
->per_cu
;
23694 per_objfile
->age_comp_units ();
23701 struct dwarf2_locexpr_baton
23702 dwarf2_fetch_die_loc_cu_off (cu_offset offset_in_cu
,
23703 dwarf2_per_cu_data
*per_cu
,
23704 dwarf2_per_objfile
*per_objfile
,
23705 gdb::function_view
<CORE_ADDR ()> get_frame_pc
)
23707 sect_offset sect_off
= per_cu
->sect_off
+ to_underlying (offset_in_cu
);
23709 return dwarf2_fetch_die_loc_sect_off (sect_off
, per_cu
, per_objfile
,
23713 /* Write a constant of a given type as target-ordered bytes into
23716 static const gdb_byte
*
23717 write_constant_as_bytes (struct obstack
*obstack
,
23718 enum bfd_endian byte_order
,
23725 *len
= TYPE_LENGTH (type
);
23726 result
= (gdb_byte
*) obstack_alloc (obstack
, *len
);
23727 store_unsigned_integer (result
, *len
, byte_order
, value
);
23735 dwarf2_fetch_constant_bytes (sect_offset sect_off
,
23736 dwarf2_per_cu_data
*per_cu
,
23737 dwarf2_per_objfile
*per_objfile
,
23741 struct die_info
*die
;
23742 struct attribute
*attr
;
23743 const gdb_byte
*result
= NULL
;
23746 enum bfd_endian byte_order
;
23747 struct objfile
*objfile
= per_objfile
->objfile
;
23749 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
23751 cu
= load_cu (per_cu
, per_objfile
, false);
23755 /* We shouldn't get here for a dummy CU, but don't crash on the user.
23756 Instead just throw an error, not much else we can do. */
23757 error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23758 sect_offset_str (sect_off
), objfile_name (objfile
));
23761 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
23763 error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23764 sect_offset_str (sect_off
), objfile_name (objfile
));
23766 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
23770 byte_order
= (bfd_big_endian (objfile
->obfd
)
23771 ? BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
23773 switch (attr
->form
)
23776 case DW_FORM_addrx
:
23777 case DW_FORM_GNU_addr_index
:
23781 *len
= cu
->header
.addr_size
;
23782 tem
= (gdb_byte
*) obstack_alloc (obstack
, *len
);
23783 store_unsigned_integer (tem
, *len
, byte_order
, attr
->as_address ());
23787 case DW_FORM_string
:
23790 case DW_FORM_GNU_str_index
:
23791 case DW_FORM_GNU_strp_alt
:
23792 /* The string is already allocated on the objfile obstack, point
23795 const char *attr_name
= attr
->as_string ();
23796 result
= (const gdb_byte
*) attr_name
;
23797 *len
= strlen (attr_name
);
23800 case DW_FORM_block1
:
23801 case DW_FORM_block2
:
23802 case DW_FORM_block4
:
23803 case DW_FORM_block
:
23804 case DW_FORM_exprloc
:
23805 case DW_FORM_data16
:
23807 struct dwarf_block
*block
= attr
->as_block ();
23808 result
= block
->data
;
23809 *len
= block
->size
;
23813 /* The DW_AT_const_value attributes are supposed to carry the
23814 symbol's value "represented as it would be on the target
23815 architecture." By the time we get here, it's already been
23816 converted to host endianness, so we just need to sign- or
23817 zero-extend it as appropriate. */
23818 case DW_FORM_data1
:
23819 type
= die_type (die
, cu
);
23820 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 8);
23821 if (result
== NULL
)
23822 result
= write_constant_as_bytes (obstack
, byte_order
,
23825 case DW_FORM_data2
:
23826 type
= die_type (die
, cu
);
23827 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 16);
23828 if (result
== NULL
)
23829 result
= write_constant_as_bytes (obstack
, byte_order
,
23832 case DW_FORM_data4
:
23833 type
= die_type (die
, cu
);
23834 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 32);
23835 if (result
== NULL
)
23836 result
= write_constant_as_bytes (obstack
, byte_order
,
23839 case DW_FORM_data8
:
23840 type
= die_type (die
, cu
);
23841 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 64);
23842 if (result
== NULL
)
23843 result
= write_constant_as_bytes (obstack
, byte_order
,
23847 case DW_FORM_sdata
:
23848 case DW_FORM_implicit_const
:
23849 type
= die_type (die
, cu
);
23850 result
= write_constant_as_bytes (obstack
, byte_order
,
23851 type
, attr
->as_signed (), len
);
23854 case DW_FORM_udata
:
23855 type
= die_type (die
, cu
);
23856 result
= write_constant_as_bytes (obstack
, byte_order
,
23857 type
, attr
->as_unsigned (), len
);
23861 complaint (_("unsupported const value attribute form: '%s'"),
23862 dwarf_form_name (attr
->form
));
23872 dwarf2_fetch_die_type_sect_off (sect_offset sect_off
,
23873 dwarf2_per_cu_data
*per_cu
,
23874 dwarf2_per_objfile
*per_objfile
)
23876 struct die_info
*die
;
23878 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
23880 cu
= load_cu (per_cu
, per_objfile
, false);
23885 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
23889 return die_type (die
, cu
);
23895 dwarf2_get_die_type (cu_offset die_offset
,
23896 dwarf2_per_cu_data
*per_cu
,
23897 dwarf2_per_objfile
*per_objfile
)
23899 sect_offset die_offset_sect
= per_cu
->sect_off
+ to_underlying (die_offset
);
23900 return get_die_type_at_offset (die_offset_sect
, per_cu
, per_objfile
);
23903 /* Follow type unit SIG_TYPE referenced by SRC_DIE.
23904 On entry *REF_CU is the CU of SRC_DIE.
23905 On exit *REF_CU is the CU of the result.
23906 Returns NULL if the referenced DIE isn't found. */
23908 static struct die_info
*
23909 follow_die_sig_1 (struct die_info
*src_die
, struct signatured_type
*sig_type
,
23910 struct dwarf2_cu
**ref_cu
)
23912 struct die_info temp_die
;
23913 struct dwarf2_cu
*sig_cu
, *cu
= *ref_cu
;
23914 struct die_info
*die
;
23915 dwarf2_per_objfile
*per_objfile
= (*ref_cu
)->per_objfile
;
23918 /* While it might be nice to assert sig_type->type == NULL here,
23919 we can get here for DW_AT_imported_declaration where we need
23920 the DIE not the type. */
23922 /* If necessary, add it to the queue and load its DIEs.
23924 Even if maybe_queue_comp_unit doesn't require us to load the CU's DIEs,
23925 it doesn't mean they are currently loaded. Since we require them
23926 to be loaded, we must check for ourselves. */
23927 if (maybe_queue_comp_unit (*ref_cu
, &sig_type
->per_cu
, per_objfile
,
23929 || per_objfile
->get_cu (&sig_type
->per_cu
) == nullptr)
23930 read_signatured_type (sig_type
, per_objfile
);
23932 sig_cu
= per_objfile
->get_cu (&sig_type
->per_cu
);
23933 gdb_assert (sig_cu
!= NULL
);
23934 gdb_assert (to_underlying (sig_type
->type_offset_in_section
) != 0);
23935 temp_die
.sect_off
= sig_type
->type_offset_in_section
;
23936 die
= (struct die_info
*) htab_find_with_hash (sig_cu
->die_hash
, &temp_die
,
23937 to_underlying (temp_die
.sect_off
));
23940 /* For .gdb_index version 7 keep track of included TUs.
23941 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
23942 if (per_objfile
->per_bfd
->index_table
!= NULL
23943 && per_objfile
->per_bfd
->index_table
->version
<= 7)
23945 (*ref_cu
)->per_cu
->imported_symtabs_push (sig_cu
->per_cu
);
23950 sig_cu
->ancestor
= cu
;
23958 /* Follow signatured type referenced by ATTR in SRC_DIE.
23959 On entry *REF_CU is the CU of SRC_DIE.
23960 On exit *REF_CU is the CU of the result.
23961 The result is the DIE of the type.
23962 If the referenced type cannot be found an error is thrown. */
23964 static struct die_info
*
23965 follow_die_sig (struct die_info
*src_die
, const struct attribute
*attr
,
23966 struct dwarf2_cu
**ref_cu
)
23968 ULONGEST signature
= attr
->as_signature ();
23969 struct signatured_type
*sig_type
;
23970 struct die_info
*die
;
23972 gdb_assert (attr
->form
== DW_FORM_ref_sig8
);
23974 sig_type
= lookup_signatured_type (*ref_cu
, signature
);
23975 /* sig_type will be NULL if the signatured type is missing from
23977 if (sig_type
== NULL
)
23979 error (_("Dwarf Error: Cannot find signatured DIE %s referenced"
23980 " from DIE at %s [in module %s]"),
23981 hex_string (signature
), sect_offset_str (src_die
->sect_off
),
23982 objfile_name ((*ref_cu
)->per_objfile
->objfile
));
23985 die
= follow_die_sig_1 (src_die
, sig_type
, ref_cu
);
23988 dump_die_for_error (src_die
);
23989 error (_("Dwarf Error: Problem reading signatured DIE %s referenced"
23990 " from DIE at %s [in module %s]"),
23991 hex_string (signature
), sect_offset_str (src_die
->sect_off
),
23992 objfile_name ((*ref_cu
)->per_objfile
->objfile
));
23998 /* Get the type specified by SIGNATURE referenced in DIE/CU,
23999 reading in and processing the type unit if necessary. */
24001 static struct type
*
24002 get_signatured_type (struct die_info
*die
, ULONGEST signature
,
24003 struct dwarf2_cu
*cu
)
24005 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
24006 struct signatured_type
*sig_type
;
24007 struct dwarf2_cu
*type_cu
;
24008 struct die_info
*type_die
;
24011 sig_type
= lookup_signatured_type (cu
, signature
);
24012 /* sig_type will be NULL if the signatured type is missing from
24014 if (sig_type
== NULL
)
24016 complaint (_("Dwarf Error: Cannot find signatured DIE %s referenced"
24017 " from DIE at %s [in module %s]"),
24018 hex_string (signature
), sect_offset_str (die
->sect_off
),
24019 objfile_name (per_objfile
->objfile
));
24020 return build_error_marker_type (cu
, die
);
24023 /* If we already know the type we're done. */
24024 type
= per_objfile
->get_type_for_signatured_type (sig_type
);
24025 if (type
!= nullptr)
24029 type_die
= follow_die_sig_1 (die
, sig_type
, &type_cu
);
24030 if (type_die
!= NULL
)
24032 /* N.B. We need to call get_die_type to ensure only one type for this DIE
24033 is created. This is important, for example, because for c++ classes
24034 we need TYPE_NAME set which is only done by new_symbol. Blech. */
24035 type
= read_type_die (type_die
, type_cu
);
24038 complaint (_("Dwarf Error: Cannot build signatured type %s"
24039 " referenced from DIE at %s [in module %s]"),
24040 hex_string (signature
), sect_offset_str (die
->sect_off
),
24041 objfile_name (per_objfile
->objfile
));
24042 type
= build_error_marker_type (cu
, die
);
24047 complaint (_("Dwarf Error: Problem reading signatured DIE %s referenced"
24048 " from DIE at %s [in module %s]"),
24049 hex_string (signature
), sect_offset_str (die
->sect_off
),
24050 objfile_name (per_objfile
->objfile
));
24051 type
= build_error_marker_type (cu
, die
);
24054 per_objfile
->set_type_for_signatured_type (sig_type
, type
);
24059 /* Get the type specified by the DW_AT_signature ATTR in DIE/CU,
24060 reading in and processing the type unit if necessary. */
24062 static struct type
*
24063 get_DW_AT_signature_type (struct die_info
*die
, const struct attribute
*attr
,
24064 struct dwarf2_cu
*cu
) /* ARI: editCase function */
24066 /* Yes, DW_AT_signature can use a non-ref_sig8 reference. */
24067 if (attr
->form_is_ref ())
24069 struct dwarf2_cu
*type_cu
= cu
;
24070 struct die_info
*type_die
= follow_die_ref (die
, attr
, &type_cu
);
24072 return read_type_die (type_die
, type_cu
);
24074 else if (attr
->form
== DW_FORM_ref_sig8
)
24076 return get_signatured_type (die
, attr
->as_signature (), cu
);
24080 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
24082 complaint (_("Dwarf Error: DW_AT_signature has bad form %s in DIE"
24083 " at %s [in module %s]"),
24084 dwarf_form_name (attr
->form
), sect_offset_str (die
->sect_off
),
24085 objfile_name (per_objfile
->objfile
));
24086 return build_error_marker_type (cu
, die
);
24090 /* Load the DIEs associated with type unit PER_CU into memory. */
24093 load_full_type_unit (dwarf2_per_cu_data
*per_cu
,
24094 dwarf2_per_objfile
*per_objfile
)
24096 struct signatured_type
*sig_type
;
24098 /* Caller is responsible for ensuring type_unit_groups don't get here. */
24099 gdb_assert (! per_cu
->type_unit_group_p ());
24101 /* We have the per_cu, but we need the signatured_type.
24102 Fortunately this is an easy translation. */
24103 gdb_assert (per_cu
->is_debug_types
);
24104 sig_type
= (struct signatured_type
*) per_cu
;
24106 gdb_assert (per_objfile
->get_cu (per_cu
) == nullptr);
24108 read_signatured_type (sig_type
, per_objfile
);
24110 gdb_assert (per_objfile
->get_cu (per_cu
) != nullptr);
24113 /* Read in a signatured type and build its CU and DIEs.
24114 If the type is a stub for the real type in a DWO file,
24115 read in the real type from the DWO file as well. */
24118 read_signatured_type (signatured_type
*sig_type
,
24119 dwarf2_per_objfile
*per_objfile
)
24121 struct dwarf2_per_cu_data
*per_cu
= &sig_type
->per_cu
;
24123 gdb_assert (per_cu
->is_debug_types
);
24124 gdb_assert (per_objfile
->get_cu (per_cu
) == nullptr);
24126 cutu_reader
reader (per_cu
, per_objfile
, nullptr, nullptr, false);
24128 if (!reader
.dummy_p
)
24130 struct dwarf2_cu
*cu
= reader
.cu
;
24131 const gdb_byte
*info_ptr
= reader
.info_ptr
;
24133 gdb_assert (cu
->die_hash
== NULL
);
24135 htab_create_alloc_ex (cu
->header
.length
/ 12,
24139 &cu
->comp_unit_obstack
,
24140 hashtab_obstack_allocate
,
24141 dummy_obstack_deallocate
);
24143 if (reader
.comp_unit_die
->has_children
)
24144 reader
.comp_unit_die
->child
24145 = read_die_and_siblings (&reader
, info_ptr
, &info_ptr
,
24146 reader
.comp_unit_die
);
24147 cu
->dies
= reader
.comp_unit_die
;
24148 /* comp_unit_die is not stored in die_hash, no need. */
24150 /* We try not to read any attributes in this function, because
24151 not all CUs needed for references have been loaded yet, and
24152 symbol table processing isn't initialized. But we have to
24153 set the CU language, or we won't be able to build types
24154 correctly. Similarly, if we do not read the producer, we can
24155 not apply producer-specific interpretation. */
24156 prepare_one_comp_unit (cu
, cu
->dies
, language_minimal
);
24161 sig_type
->per_cu
.tu_read
= 1;
24164 /* Decode simple location descriptions.
24165 Given a pointer to a dwarf block that defines a location, compute
24166 the location and return the value. If COMPUTED is non-null, it is
24167 set to true to indicate that decoding was successful, and false
24168 otherwise. If COMPUTED is null, then this function may emit a
24172 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
, bool *computed
)
24174 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
24176 size_t size
= blk
->size
;
24177 const gdb_byte
*data
= blk
->data
;
24178 CORE_ADDR stack
[64];
24180 unsigned int bytes_read
, unsnd
;
24183 if (computed
!= nullptr)
24189 stack
[++stacki
] = 0;
24228 stack
[++stacki
] = op
- DW_OP_lit0
;
24263 stack
[++stacki
] = op
- DW_OP_reg0
;
24266 if (computed
== nullptr)
24267 dwarf2_complex_location_expr_complaint ();
24274 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
24276 stack
[++stacki
] = unsnd
;
24279 if (computed
== nullptr)
24280 dwarf2_complex_location_expr_complaint ();
24287 stack
[++stacki
] = cu
->header
.read_address (objfile
->obfd
, &data
[i
],
24292 case DW_OP_const1u
:
24293 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
24297 case DW_OP_const1s
:
24298 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
24302 case DW_OP_const2u
:
24303 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
24307 case DW_OP_const2s
:
24308 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
24312 case DW_OP_const4u
:
24313 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
24317 case DW_OP_const4s
:
24318 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
24322 case DW_OP_const8u
:
24323 stack
[++stacki
] = read_8_bytes (objfile
->obfd
, &data
[i
]);
24328 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
24334 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
24339 stack
[stacki
+ 1] = stack
[stacki
];
24344 stack
[stacki
- 1] += stack
[stacki
];
24348 case DW_OP_plus_uconst
:
24349 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
),
24355 stack
[stacki
- 1] -= stack
[stacki
];
24360 /* If we're not the last op, then we definitely can't encode
24361 this using GDB's address_class enum. This is valid for partial
24362 global symbols, although the variable's address will be bogus
24366 if (computed
== nullptr)
24367 dwarf2_complex_location_expr_complaint ();
24373 case DW_OP_GNU_push_tls_address
:
24374 case DW_OP_form_tls_address
:
24375 /* The top of the stack has the offset from the beginning
24376 of the thread control block at which the variable is located. */
24377 /* Nothing should follow this operator, so the top of stack would
24379 /* This is valid for partial global symbols, but the variable's
24380 address will be bogus in the psymtab. Make it always at least
24381 non-zero to not look as a variable garbage collected by linker
24382 which have DW_OP_addr 0. */
24385 if (computed
== nullptr)
24386 dwarf2_complex_location_expr_complaint ();
24393 case DW_OP_GNU_uninit
:
24394 if (computed
!= nullptr)
24399 case DW_OP_GNU_addr_index
:
24400 case DW_OP_GNU_const_index
:
24401 stack
[++stacki
] = read_addr_index_from_leb128 (cu
, &data
[i
],
24407 if (computed
== nullptr)
24409 const char *name
= get_DW_OP_name (op
);
24412 complaint (_("unsupported stack op: '%s'"),
24415 complaint (_("unsupported stack op: '%02x'"),
24419 return (stack
[stacki
]);
24422 /* Enforce maximum stack depth of SIZE-1 to avoid writing
24423 outside of the allocated space. Also enforce minimum>0. */
24424 if (stacki
>= ARRAY_SIZE (stack
) - 1)
24426 if (computed
== nullptr)
24427 complaint (_("location description stack overflow"));
24433 if (computed
== nullptr)
24434 complaint (_("location description stack underflow"));
24439 if (computed
!= nullptr)
24441 return (stack
[stacki
]);
24444 /* memory allocation interface */
24446 static struct dwarf_block
*
24447 dwarf_alloc_block (struct dwarf2_cu
*cu
)
24449 return XOBNEW (&cu
->comp_unit_obstack
, struct dwarf_block
);
24452 static struct die_info
*
24453 dwarf_alloc_die (struct dwarf2_cu
*cu
, int num_attrs
)
24455 struct die_info
*die
;
24456 size_t size
= sizeof (struct die_info
);
24459 size
+= (num_attrs
- 1) * sizeof (struct attribute
);
24461 die
= (struct die_info
*) obstack_alloc (&cu
->comp_unit_obstack
, size
);
24462 memset (die
, 0, sizeof (struct die_info
));
24468 /* Macro support. */
24470 /* An overload of dwarf_decode_macros that finds the correct section
24471 and ensures it is read in before calling the other overload. */
24474 dwarf_decode_macros (struct dwarf2_cu
*cu
, unsigned int offset
,
24475 int section_is_gnu
)
24477 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
24478 struct objfile
*objfile
= per_objfile
->objfile
;
24479 const struct line_header
*lh
= cu
->line_header
;
24480 unsigned int offset_size
= cu
->header
.offset_size
;
24481 struct dwarf2_section_info
*section
;
24482 const char *section_name
;
24484 if (cu
->dwo_unit
!= nullptr)
24486 if (section_is_gnu
)
24488 section
= &cu
->dwo_unit
->dwo_file
->sections
.macro
;
24489 section_name
= ".debug_macro.dwo";
24493 section
= &cu
->dwo_unit
->dwo_file
->sections
.macinfo
;
24494 section_name
= ".debug_macinfo.dwo";
24499 if (section_is_gnu
)
24501 section
= &per_objfile
->per_bfd
->macro
;
24502 section_name
= ".debug_macro";
24506 section
= &per_objfile
->per_bfd
->macinfo
;
24507 section_name
= ".debug_macinfo";
24511 section
->read (objfile
);
24512 if (section
->buffer
== nullptr)
24514 complaint (_("missing %s section"), section_name
);
24518 buildsym_compunit
*builder
= cu
->get_builder ();
24520 struct dwarf2_section_info
*str_offsets_section
;
24521 struct dwarf2_section_info
*str_section
;
24522 ULONGEST str_offsets_base
;
24524 if (cu
->dwo_unit
!= nullptr)
24526 str_offsets_section
= &cu
->dwo_unit
->dwo_file
24527 ->sections
.str_offsets
;
24528 str_section
= &cu
->dwo_unit
->dwo_file
->sections
.str
;
24529 str_offsets_base
= cu
->header
.addr_size
;
24533 str_offsets_section
= &per_objfile
->per_bfd
->str_offsets
;
24534 str_section
= &per_objfile
->per_bfd
->str
;
24535 str_offsets_base
= *cu
->str_offsets_base
;
24538 dwarf_decode_macros (per_objfile
, builder
, section
, lh
,
24539 offset_size
, offset
, str_section
, str_offsets_section
,
24540 str_offsets_base
, section_is_gnu
);
24543 /* Return the .debug_loc section to use for CU.
24544 For DWO files use .debug_loc.dwo. */
24546 static struct dwarf2_section_info
*
24547 cu_debug_loc_section (struct dwarf2_cu
*cu
)
24549 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
24553 struct dwo_sections
*sections
= &cu
->dwo_unit
->dwo_file
->sections
;
24555 return cu
->header
.version
>= 5 ? §ions
->loclists
: §ions
->loc
;
24557 return (cu
->header
.version
>= 5 ? &per_objfile
->per_bfd
->loclists
24558 : &per_objfile
->per_bfd
->loc
);
24561 /* Return the .debug_rnglists section to use for CU. */
24562 static struct dwarf2_section_info
*
24563 cu_debug_rnglists_section (struct dwarf2_cu
*cu
, dwarf_tag tag
)
24565 if (cu
->header
.version
< 5)
24566 error (_(".debug_rnglists section cannot be used in DWARF %d"),
24567 cu
->header
.version
);
24568 struct dwarf2_per_objfile
*dwarf2_per_objfile
= cu
->per_objfile
;
24570 /* Make sure we read the .debug_rnglists section from the file that
24571 contains the DW_AT_ranges attribute we are reading. Normally that
24572 would be the .dwo file, if there is one. However for DW_TAG_compile_unit
24573 or DW_TAG_skeleton unit, we always want to read from objfile/linked
24575 if (cu
->dwo_unit
!= nullptr
24576 && tag
!= DW_TAG_compile_unit
24577 && tag
!= DW_TAG_skeleton_unit
)
24579 struct dwo_sections
*sections
= &cu
->dwo_unit
->dwo_file
->sections
;
24581 if (sections
->rnglists
.size
> 0)
24582 return §ions
->rnglists
;
24584 error (_(".debug_rnglists section is missing from .dwo file."));
24586 return &dwarf2_per_objfile
->per_bfd
->rnglists
;
24589 /* A helper function that fills in a dwarf2_loclist_baton. */
24592 fill_in_loclist_baton (struct dwarf2_cu
*cu
,
24593 struct dwarf2_loclist_baton
*baton
,
24594 const struct attribute
*attr
)
24596 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
24597 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
24599 section
->read (per_objfile
->objfile
);
24601 baton
->per_objfile
= per_objfile
;
24602 baton
->per_cu
= cu
->per_cu
;
24603 gdb_assert (baton
->per_cu
);
24604 /* We don't know how long the location list is, but make sure we
24605 don't run off the edge of the section. */
24606 baton
->size
= section
->size
- attr
->as_unsigned ();
24607 baton
->data
= section
->buffer
+ attr
->as_unsigned ();
24608 if (cu
->base_address
.has_value ())
24609 baton
->base_address
= *cu
->base_address
;
24611 baton
->base_address
= 0;
24612 baton
->from_dwo
= cu
->dwo_unit
!= NULL
;
24616 dwarf2_symbol_mark_computed (const struct attribute
*attr
, struct symbol
*sym
,
24617 struct dwarf2_cu
*cu
, int is_block
)
24619 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
24620 struct objfile
*objfile
= per_objfile
->objfile
;
24621 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
24623 if (attr
->form_is_section_offset ()
24624 /* .debug_loc{,.dwo} may not exist at all, or the offset may be outside
24625 the section. If so, fall through to the complaint in the
24627 && attr
->as_unsigned () < section
->get_size (objfile
))
24629 struct dwarf2_loclist_baton
*baton
;
24631 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_loclist_baton
);
24633 fill_in_loclist_baton (cu
, baton
, attr
);
24635 if (!cu
->base_address
.has_value ())
24636 complaint (_("Location list used without "
24637 "specifying the CU base address."));
24639 SYMBOL_ACLASS_INDEX (sym
) = (is_block
24640 ? dwarf2_loclist_block_index
24641 : dwarf2_loclist_index
);
24642 SYMBOL_LOCATION_BATON (sym
) = baton
;
24646 struct dwarf2_locexpr_baton
*baton
;
24648 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
24649 baton
->per_objfile
= per_objfile
;
24650 baton
->per_cu
= cu
->per_cu
;
24651 gdb_assert (baton
->per_cu
);
24653 if (attr
->form_is_block ())
24655 /* Note that we're just copying the block's data pointer
24656 here, not the actual data. We're still pointing into the
24657 info_buffer for SYM's objfile; right now we never release
24658 that buffer, but when we do clean up properly this may
24660 struct dwarf_block
*block
= attr
->as_block ();
24661 baton
->size
= block
->size
;
24662 baton
->data
= block
->data
;
24666 dwarf2_invalid_attrib_class_complaint ("location description",
24667 sym
->natural_name ());
24671 SYMBOL_ACLASS_INDEX (sym
) = (is_block
24672 ? dwarf2_locexpr_block_index
24673 : dwarf2_locexpr_index
);
24674 SYMBOL_LOCATION_BATON (sym
) = baton
;
24680 const comp_unit_head
*
24681 dwarf2_per_cu_data::get_header () const
24683 if (!m_header_read_in
)
24685 const gdb_byte
*info_ptr
24686 = this->section
->buffer
+ to_underlying (this->sect_off
);
24688 memset (&m_header
, 0, sizeof (m_header
));
24690 read_comp_unit_head (&m_header
, info_ptr
, this->section
,
24691 rcuh_kind::COMPILE
);
24693 m_header_read_in
= true;
24702 dwarf2_per_cu_data::addr_size () const
24704 return this->get_header ()->addr_size
;
24710 dwarf2_per_cu_data::offset_size () const
24712 return this->get_header ()->offset_size
;
24718 dwarf2_per_cu_data::ref_addr_size () const
24720 const comp_unit_head
*header
= this->get_header ();
24722 if (header
->version
== 2)
24723 return header
->addr_size
;
24725 return header
->offset_size
;
24731 dwarf2_cu::addr_type () const
24733 struct objfile
*objfile
= this->per_objfile
->objfile
;
24734 struct type
*void_type
= objfile_type (objfile
)->builtin_void
;
24735 struct type
*addr_type
= lookup_pointer_type (void_type
);
24736 int addr_size
= this->per_cu
->addr_size ();
24738 if (TYPE_LENGTH (addr_type
) == addr_size
)
24741 addr_type
= addr_sized_int_type (addr_type
->is_unsigned ());
24745 /* A helper function for dwarf2_find_containing_comp_unit that returns
24746 the index of the result, and that searches a vector. It will
24747 return a result even if the offset in question does not actually
24748 occur in any CU. This is separate so that it can be unit
24752 dwarf2_find_containing_comp_unit
24753 (sect_offset sect_off
,
24754 unsigned int offset_in_dwz
,
24755 const std::vector
<dwarf2_per_cu_data
*> &all_comp_units
)
24760 high
= all_comp_units
.size () - 1;
24763 struct dwarf2_per_cu_data
*mid_cu
;
24764 int mid
= low
+ (high
- low
) / 2;
24766 mid_cu
= all_comp_units
[mid
];
24767 if (mid_cu
->is_dwz
> offset_in_dwz
24768 || (mid_cu
->is_dwz
== offset_in_dwz
24769 && mid_cu
->sect_off
+ mid_cu
->length
> sect_off
))
24774 gdb_assert (low
== high
);
24778 /* Locate the .debug_info compilation unit from CU's objfile which contains
24779 the DIE at OFFSET. Raises an error on failure. */
24781 static struct dwarf2_per_cu_data
*
24782 dwarf2_find_containing_comp_unit (sect_offset sect_off
,
24783 unsigned int offset_in_dwz
,
24784 dwarf2_per_objfile
*per_objfile
)
24786 int low
= dwarf2_find_containing_comp_unit
24787 (sect_off
, offset_in_dwz
, per_objfile
->per_bfd
->all_comp_units
);
24788 dwarf2_per_cu_data
*this_cu
= per_objfile
->per_bfd
->all_comp_units
[low
];
24790 if (this_cu
->is_dwz
!= offset_in_dwz
|| this_cu
->sect_off
> sect_off
)
24792 if (low
== 0 || this_cu
->is_dwz
!= offset_in_dwz
)
24793 error (_("Dwarf Error: could not find partial DIE containing "
24794 "offset %s [in module %s]"),
24795 sect_offset_str (sect_off
),
24796 bfd_get_filename (per_objfile
->objfile
->obfd
));
24798 gdb_assert (per_objfile
->per_bfd
->all_comp_units
[low
-1]->sect_off
24800 return per_objfile
->per_bfd
->all_comp_units
[low
-1];
24804 if (low
== per_objfile
->per_bfd
->all_comp_units
.size () - 1
24805 && sect_off
>= this_cu
->sect_off
+ this_cu
->length
)
24806 error (_("invalid dwarf2 offset %s"), sect_offset_str (sect_off
));
24807 gdb_assert (sect_off
< this_cu
->sect_off
+ this_cu
->length
);
24814 namespace selftests
{
24815 namespace find_containing_comp_unit
{
24820 struct dwarf2_per_cu_data one
{};
24821 struct dwarf2_per_cu_data two
{};
24822 struct dwarf2_per_cu_data three
{};
24823 struct dwarf2_per_cu_data four
{};
24826 two
.sect_off
= sect_offset (one
.length
);
24831 four
.sect_off
= sect_offset (three
.length
);
24835 std::vector
<dwarf2_per_cu_data
*> units
;
24836 units
.push_back (&one
);
24837 units
.push_back (&two
);
24838 units
.push_back (&three
);
24839 units
.push_back (&four
);
24843 result
= dwarf2_find_containing_comp_unit (sect_offset (0), 0, units
);
24844 SELF_CHECK (units
[result
] == &one
);
24845 result
= dwarf2_find_containing_comp_unit (sect_offset (3), 0, units
);
24846 SELF_CHECK (units
[result
] == &one
);
24847 result
= dwarf2_find_containing_comp_unit (sect_offset (5), 0, units
);
24848 SELF_CHECK (units
[result
] == &two
);
24850 result
= dwarf2_find_containing_comp_unit (sect_offset (0), 1, units
);
24851 SELF_CHECK (units
[result
] == &three
);
24852 result
= dwarf2_find_containing_comp_unit (sect_offset (3), 1, units
);
24853 SELF_CHECK (units
[result
] == &three
);
24854 result
= dwarf2_find_containing_comp_unit (sect_offset (5), 1, units
);
24855 SELF_CHECK (units
[result
] == &four
);
24861 #endif /* GDB_SELF_TEST */
24863 /* Initialize dwarf2_cu to read PER_CU, in the context of PER_OBJFILE. */
24865 dwarf2_cu::dwarf2_cu (dwarf2_per_cu_data
*per_cu
,
24866 dwarf2_per_objfile
*per_objfile
)
24868 per_objfile (per_objfile
),
24870 has_loclist (false),
24871 checked_producer (false),
24872 producer_is_gxx_lt_4_6 (false),
24873 producer_is_gcc_lt_4_3 (false),
24874 producer_is_icc (false),
24875 producer_is_icc_lt_14 (false),
24876 producer_is_codewarrior (false),
24877 processing_has_namespace_info (false)
24881 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
24884 prepare_one_comp_unit (struct dwarf2_cu
*cu
, struct die_info
*comp_unit_die
,
24885 enum language pretend_language
)
24887 struct attribute
*attr
;
24889 /* Set the language we're debugging. */
24890 attr
= dwarf2_attr (comp_unit_die
, DW_AT_language
, cu
);
24891 if (attr
!= nullptr)
24892 set_cu_language (attr
->constant_value (0), cu
);
24895 cu
->language
= pretend_language
;
24896 cu
->language_defn
= language_def (cu
->language
);
24899 cu
->producer
= dwarf2_string_attr (comp_unit_die
, DW_AT_producer
, cu
);
24905 dwarf2_per_objfile::get_cu (dwarf2_per_cu_data
*per_cu
)
24907 auto it
= m_dwarf2_cus
.find (per_cu
);
24908 if (it
== m_dwarf2_cus
.end ())
24917 dwarf2_per_objfile::set_cu (dwarf2_per_cu_data
*per_cu
, dwarf2_cu
*cu
)
24919 gdb_assert (this->get_cu (per_cu
) == nullptr);
24921 m_dwarf2_cus
[per_cu
] = cu
;
24927 dwarf2_per_objfile::age_comp_units ()
24929 dwarf_read_debug_printf_v ("running");
24931 /* This is not expected to be called in the middle of CU expansion. There is
24932 an invariant that if a CU is in the CUs-to-expand queue, its DIEs are
24933 loaded in memory. Calling age_comp_units while the queue is in use could
24934 make us free the DIEs for a CU that is in the queue and therefore break
24936 gdb_assert (!this->per_bfd
->queue
.has_value ());
24938 /* Start by clearing all marks. */
24939 for (auto pair
: m_dwarf2_cus
)
24940 pair
.second
->mark
= false;
24942 /* Traverse all CUs, mark them and their dependencies if used recently
24944 for (auto pair
: m_dwarf2_cus
)
24946 dwarf2_cu
*cu
= pair
.second
;
24949 if (cu
->last_used
<= dwarf_max_cache_age
)
24953 /* Delete all CUs still not marked. */
24954 for (auto it
= m_dwarf2_cus
.begin (); it
!= m_dwarf2_cus
.end ();)
24956 dwarf2_cu
*cu
= it
->second
;
24960 dwarf_read_debug_printf_v ("deleting old CU %s",
24961 sect_offset_str (cu
->per_cu
->sect_off
));
24963 it
= m_dwarf2_cus
.erase (it
);
24973 dwarf2_per_objfile::remove_cu (dwarf2_per_cu_data
*per_cu
)
24975 auto it
= m_dwarf2_cus
.find (per_cu
);
24976 if (it
== m_dwarf2_cus
.end ())
24981 m_dwarf2_cus
.erase (it
);
24984 dwarf2_per_objfile::~dwarf2_per_objfile ()
24989 /* A set of CU "per_cu" pointer, DIE offset, and GDB type pointer.
24990 We store these in a hash table separate from the DIEs, and preserve them
24991 when the DIEs are flushed out of cache.
24993 The CU "per_cu" pointer is needed because offset alone is not enough to
24994 uniquely identify the type. A file may have multiple .debug_types sections,
24995 or the type may come from a DWO file. Furthermore, while it's more logical
24996 to use per_cu->section+offset, with Fission the section with the data is in
24997 the DWO file but we don't know that section at the point we need it.
24998 We have to use something in dwarf2_per_cu_data (or the pointer to it)
24999 because we can enter the lookup routine, get_die_type_at_offset, from
25000 outside this file, and thus won't necessarily have PER_CU->cu.
25001 Fortunately, PER_CU is stable for the life of the objfile. */
25003 struct dwarf2_per_cu_offset_and_type
25005 const struct dwarf2_per_cu_data
*per_cu
;
25006 sect_offset sect_off
;
25010 /* Hash function for a dwarf2_per_cu_offset_and_type. */
25013 per_cu_offset_and_type_hash (const void *item
)
25015 const struct dwarf2_per_cu_offset_and_type
*ofs
25016 = (const struct dwarf2_per_cu_offset_and_type
*) item
;
25018 return (uintptr_t) ofs
->per_cu
+ to_underlying (ofs
->sect_off
);
25021 /* Equality function for a dwarf2_per_cu_offset_and_type. */
25024 per_cu_offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
25026 const struct dwarf2_per_cu_offset_and_type
*ofs_lhs
25027 = (const struct dwarf2_per_cu_offset_and_type
*) item_lhs
;
25028 const struct dwarf2_per_cu_offset_and_type
*ofs_rhs
25029 = (const struct dwarf2_per_cu_offset_and_type
*) item_rhs
;
25031 return (ofs_lhs
->per_cu
== ofs_rhs
->per_cu
25032 && ofs_lhs
->sect_off
== ofs_rhs
->sect_off
);
25035 /* Set the type associated with DIE to TYPE. Save it in CU's hash
25036 table if necessary. For convenience, return TYPE.
25038 The DIEs reading must have careful ordering to:
25039 * Not cause infinite loops trying to read in DIEs as a prerequisite for
25040 reading current DIE.
25041 * Not trying to dereference contents of still incompletely read in types
25042 while reading in other DIEs.
25043 * Enable referencing still incompletely read in types just by a pointer to
25044 the type without accessing its fields.
25046 Therefore caller should follow these rules:
25047 * Try to fetch any prerequisite types we may need to build this DIE type
25048 before building the type and calling set_die_type.
25049 * After building type call set_die_type for current DIE as soon as
25050 possible before fetching more types to complete the current type.
25051 * Make the type as complete as possible before fetching more types. */
25053 static struct type
*
25054 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
,
25055 bool skip_data_location
)
25057 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
25058 struct dwarf2_per_cu_offset_and_type
**slot
, ofs
;
25059 struct objfile
*objfile
= per_objfile
->objfile
;
25060 struct attribute
*attr
;
25061 struct dynamic_prop prop
;
25063 /* For Ada types, make sure that the gnat-specific data is always
25064 initialized (if not already set). There are a few types where
25065 we should not be doing so, because the type-specific area is
25066 already used to hold some other piece of info (eg: TYPE_CODE_FLT
25067 where the type-specific area is used to store the floatformat).
25068 But this is not a problem, because the gnat-specific information
25069 is actually not needed for these types. */
25070 if (need_gnat_info (cu
)
25071 && type
->code () != TYPE_CODE_FUNC
25072 && type
->code () != TYPE_CODE_FLT
25073 && type
->code () != TYPE_CODE_METHODPTR
25074 && type
->code () != TYPE_CODE_MEMBERPTR
25075 && type
->code () != TYPE_CODE_METHOD
25076 && type
->code () != TYPE_CODE_FIXED_POINT
25077 && !HAVE_GNAT_AUX_INFO (type
))
25078 INIT_GNAT_SPECIFIC (type
);
25080 /* Read DW_AT_allocated and set in type. */
25081 attr
= dwarf2_attr (die
, DW_AT_allocated
, cu
);
25084 struct type
*prop_type
= cu
->addr_sized_int_type (false);
25085 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
, prop_type
))
25086 type
->add_dyn_prop (DYN_PROP_ALLOCATED
, prop
);
25089 /* Read DW_AT_associated and set in type. */
25090 attr
= dwarf2_attr (die
, DW_AT_associated
, cu
);
25093 struct type
*prop_type
= cu
->addr_sized_int_type (false);
25094 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
, prop_type
))
25095 type
->add_dyn_prop (DYN_PROP_ASSOCIATED
, prop
);
25098 /* Read DW_AT_data_location and set in type. */
25099 if (!skip_data_location
)
25101 attr
= dwarf2_attr (die
, DW_AT_data_location
, cu
);
25102 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
, cu
->addr_type ()))
25103 type
->add_dyn_prop (DYN_PROP_DATA_LOCATION
, prop
);
25106 if (per_objfile
->die_type_hash
== NULL
)
25107 per_objfile
->die_type_hash
25108 = htab_up (htab_create_alloc (127,
25109 per_cu_offset_and_type_hash
,
25110 per_cu_offset_and_type_eq
,
25111 NULL
, xcalloc
, xfree
));
25113 ofs
.per_cu
= cu
->per_cu
;
25114 ofs
.sect_off
= die
->sect_off
;
25116 slot
= (struct dwarf2_per_cu_offset_and_type
**)
25117 htab_find_slot (per_objfile
->die_type_hash
.get (), &ofs
, INSERT
);
25119 complaint (_("A problem internal to GDB: DIE %s has type already set"),
25120 sect_offset_str (die
->sect_off
));
25121 *slot
= XOBNEW (&objfile
->objfile_obstack
,
25122 struct dwarf2_per_cu_offset_and_type
);
25127 /* Look up the type for the die at SECT_OFF in PER_CU in die_type_hash,
25128 or return NULL if the die does not have a saved type. */
25130 static struct type
*
25131 get_die_type_at_offset (sect_offset sect_off
,
25132 dwarf2_per_cu_data
*per_cu
,
25133 dwarf2_per_objfile
*per_objfile
)
25135 struct dwarf2_per_cu_offset_and_type
*slot
, ofs
;
25137 if (per_objfile
->die_type_hash
== NULL
)
25140 ofs
.per_cu
= per_cu
;
25141 ofs
.sect_off
= sect_off
;
25142 slot
= ((struct dwarf2_per_cu_offset_and_type
*)
25143 htab_find (per_objfile
->die_type_hash
.get (), &ofs
));
25150 /* Look up the type for DIE in CU in die_type_hash,
25151 or return NULL if DIE does not have a saved type. */
25153 static struct type
*
25154 get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
25156 return get_die_type_at_offset (die
->sect_off
, cu
->per_cu
, cu
->per_objfile
);
25159 /* Add a dependence relationship from CU to REF_PER_CU. */
25162 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
25163 struct dwarf2_per_cu_data
*ref_per_cu
)
25167 if (cu
->dependencies
== NULL
)
25169 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
25170 NULL
, &cu
->comp_unit_obstack
,
25171 hashtab_obstack_allocate
,
25172 dummy_obstack_deallocate
);
25174 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
25176 *slot
= ref_per_cu
;
25179 /* Subroutine of dwarf2_mark to pass to htab_traverse.
25180 Set the mark field in every compilation unit in the
25181 cache that we must keep because we are keeping CU.
25183 DATA is the dwarf2_per_objfile object in which to look up CUs. */
25186 dwarf2_mark_helper (void **slot
, void *data
)
25188 dwarf2_per_cu_data
*per_cu
= (dwarf2_per_cu_data
*) *slot
;
25189 dwarf2_per_objfile
*per_objfile
= (dwarf2_per_objfile
*) data
;
25190 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
25192 /* cu->dependencies references may not yet have been ever read if QUIT aborts
25193 reading of the chain. As such dependencies remain valid it is not much
25194 useful to track and undo them during QUIT cleanups. */
25203 if (cu
->dependencies
!= nullptr)
25204 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, per_objfile
);
25209 /* Set the mark field in CU and in every other compilation unit in the
25210 cache that we must keep because we are keeping CU. */
25213 dwarf2_mark (struct dwarf2_cu
*cu
)
25220 if (cu
->dependencies
!= nullptr)
25221 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, cu
->per_objfile
);
25224 /* Trivial hash function for partial_die_info: the hash value of a DIE
25225 is its offset in .debug_info for this objfile. */
25228 partial_die_hash (const void *item
)
25230 const struct partial_die_info
*part_die
25231 = (const struct partial_die_info
*) item
;
25233 return to_underlying (part_die
->sect_off
);
25236 /* Trivial comparison function for partial_die_info structures: two DIEs
25237 are equal if they have the same offset. */
25240 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
25242 const struct partial_die_info
*part_die_lhs
25243 = (const struct partial_die_info
*) item_lhs
;
25244 const struct partial_die_info
*part_die_rhs
25245 = (const struct partial_die_info
*) item_rhs
;
25247 return part_die_lhs
->sect_off
== part_die_rhs
->sect_off
;
25250 struct cmd_list_element
*set_dwarf_cmdlist
;
25251 struct cmd_list_element
*show_dwarf_cmdlist
;
25254 show_check_physname (struct ui_file
*file
, int from_tty
,
25255 struct cmd_list_element
*c
, const char *value
)
25257 fprintf_filtered (file
,
25258 _("Whether to check \"physname\" is %s.\n"),
25262 void _initialize_dwarf2_read ();
25264 _initialize_dwarf2_read ()
25266 add_basic_prefix_cmd ("dwarf", class_maintenance
, _("\
25267 Set DWARF specific variables.\n\
25268 Configure DWARF variables such as the cache size."),
25269 &set_dwarf_cmdlist
, "maintenance set dwarf ",
25270 0/*allow-unknown*/, &maintenance_set_cmdlist
);
25272 add_show_prefix_cmd ("dwarf", class_maintenance
, _("\
25273 Show DWARF specific variables.\n\
25274 Show DWARF variables such as the cache size."),
25275 &show_dwarf_cmdlist
, "maintenance show dwarf ",
25276 0/*allow-unknown*/, &maintenance_show_cmdlist
);
25278 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
25279 &dwarf_max_cache_age
, _("\
25280 Set the upper bound on the age of cached DWARF compilation units."), _("\
25281 Show the upper bound on the age of cached DWARF compilation units."), _("\
25282 A higher limit means that cached compilation units will be stored\n\
25283 in memory longer, and more total memory will be used. Zero disables\n\
25284 caching, which can slow down startup."),
25286 show_dwarf_max_cache_age
,
25287 &set_dwarf_cmdlist
,
25288 &show_dwarf_cmdlist
);
25290 add_setshow_zuinteger_cmd ("dwarf-read", no_class
, &dwarf_read_debug
, _("\
25291 Set debugging of the DWARF reader."), _("\
25292 Show debugging of the DWARF reader."), _("\
25293 When enabled (non-zero), debugging messages are printed during DWARF\n\
25294 reading and symtab expansion. A value of 1 (one) provides basic\n\
25295 information. A value greater than 1 provides more verbose information."),
25298 &setdebuglist
, &showdebuglist
);
25300 add_setshow_zuinteger_cmd ("dwarf-die", no_class
, &dwarf_die_debug
, _("\
25301 Set debugging of the DWARF DIE reader."), _("\
25302 Show debugging of the DWARF DIE reader."), _("\
25303 When enabled (non-zero), DIEs are dumped after they are read in.\n\
25304 The value is the maximum depth to print."),
25307 &setdebuglist
, &showdebuglist
);
25309 add_setshow_zuinteger_cmd ("dwarf-line", no_class
, &dwarf_line_debug
, _("\
25310 Set debugging of the dwarf line reader."), _("\
25311 Show debugging of the dwarf line reader."), _("\
25312 When enabled (non-zero), line number entries are dumped as they are read in.\n\
25313 A value of 1 (one) provides basic information.\n\
25314 A value greater than 1 provides more verbose information."),
25317 &setdebuglist
, &showdebuglist
);
25319 add_setshow_boolean_cmd ("check-physname", no_class
, &check_physname
, _("\
25320 Set cross-checking of \"physname\" code against demangler."), _("\
25321 Show cross-checking of \"physname\" code against demangler."), _("\
25322 When enabled, GDB's internal \"physname\" code is checked against\n\
25324 NULL
, show_check_physname
,
25325 &setdebuglist
, &showdebuglist
);
25327 add_setshow_boolean_cmd ("use-deprecated-index-sections",
25328 no_class
, &use_deprecated_index_sections
, _("\
25329 Set whether to use deprecated gdb_index sections."), _("\
25330 Show whether to use deprecated gdb_index sections."), _("\
25331 When enabled, deprecated .gdb_index sections are used anyway.\n\
25332 Normally they are ignored either because of a missing feature or\n\
25333 performance issue.\n\
25334 Warning: This option must be enabled before gdb reads the file."),
25337 &setlist
, &showlist
);
25339 dwarf2_locexpr_index
= register_symbol_computed_impl (LOC_COMPUTED
,
25340 &dwarf2_locexpr_funcs
);
25341 dwarf2_loclist_index
= register_symbol_computed_impl (LOC_COMPUTED
,
25342 &dwarf2_loclist_funcs
);
25344 dwarf2_locexpr_block_index
= register_symbol_block_impl (LOC_BLOCK
,
25345 &dwarf2_block_frame_base_locexpr_funcs
);
25346 dwarf2_loclist_block_index
= register_symbol_block_impl (LOC_BLOCK
,
25347 &dwarf2_block_frame_base_loclist_funcs
);
25350 selftests::register_test ("dw2_expand_symtabs_matching",
25351 selftests::dw2_expand_symtabs_matching::run_test
);
25352 selftests::register_test ("dwarf2_find_containing_comp_unit",
25353 selftests::find_containing_comp_unit::run_test
);