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 BFD
1955 doesn't require relocations and if there aren't partial symbols
1956 from some other reader. */
1957 if (!objfile
->has_partial_symbols ()
1958 && !gdb_bfd_requires_relocations (objfile
->obfd
))
1960 /* See if one has been created for this BFD yet. */
1961 per_bfd
= dwarf2_per_bfd_bfd_data_key
.get (objfile
->obfd
);
1963 if (per_bfd
== nullptr)
1965 /* No, create it now. */
1966 per_bfd
= new dwarf2_per_bfd (objfile
->obfd
, names
, can_copy
);
1967 dwarf2_per_bfd_bfd_data_key
.set (objfile
->obfd
, per_bfd
);
1972 /* No sharing possible, create one specifically for this objfile. */
1973 per_bfd
= new dwarf2_per_bfd (objfile
->obfd
, names
, can_copy
);
1974 dwarf2_per_bfd_objfile_data_key
.set (objfile
, per_bfd
);
1977 per_objfile
= dwarf2_objfile_data_key
.emplace (objfile
, objfile
, per_bfd
);
1980 return (!per_objfile
->per_bfd
->info
.is_virtual
1981 && per_objfile
->per_bfd
->info
.s
.section
!= NULL
1982 && !per_objfile
->per_bfd
->abbrev
.is_virtual
1983 && per_objfile
->per_bfd
->abbrev
.s
.section
!= NULL
);
1986 /* See declaration. */
1989 dwarf2_per_bfd::locate_sections (bfd
*abfd
, asection
*sectp
,
1990 const dwarf2_debug_sections
&names
)
1992 flagword aflag
= bfd_section_flags (sectp
);
1994 if ((aflag
& SEC_HAS_CONTENTS
) == 0)
1997 else if (elf_section_data (sectp
)->this_hdr
.sh_size
1998 > bfd_get_file_size (abfd
))
2000 bfd_size_type size
= elf_section_data (sectp
)->this_hdr
.sh_size
;
2001 warning (_("Discarding section %s which has a section size (%s"
2002 ") larger than the file size [in module %s]"),
2003 bfd_section_name (sectp
), phex_nz (size
, sizeof (size
)),
2004 bfd_get_filename (abfd
));
2006 else if (names
.info
.matches (sectp
->name
))
2008 this->info
.s
.section
= sectp
;
2009 this->info
.size
= bfd_section_size (sectp
);
2011 else if (names
.abbrev
.matches (sectp
->name
))
2013 this->abbrev
.s
.section
= sectp
;
2014 this->abbrev
.size
= bfd_section_size (sectp
);
2016 else if (names
.line
.matches (sectp
->name
))
2018 this->line
.s
.section
= sectp
;
2019 this->line
.size
= bfd_section_size (sectp
);
2021 else if (names
.loc
.matches (sectp
->name
))
2023 this->loc
.s
.section
= sectp
;
2024 this->loc
.size
= bfd_section_size (sectp
);
2026 else if (names
.loclists
.matches (sectp
->name
))
2028 this->loclists
.s
.section
= sectp
;
2029 this->loclists
.size
= bfd_section_size (sectp
);
2031 else if (names
.macinfo
.matches (sectp
->name
))
2033 this->macinfo
.s
.section
= sectp
;
2034 this->macinfo
.size
= bfd_section_size (sectp
);
2036 else if (names
.macro
.matches (sectp
->name
))
2038 this->macro
.s
.section
= sectp
;
2039 this->macro
.size
= bfd_section_size (sectp
);
2041 else if (names
.str
.matches (sectp
->name
))
2043 this->str
.s
.section
= sectp
;
2044 this->str
.size
= bfd_section_size (sectp
);
2046 else if (names
.str_offsets
.matches (sectp
->name
))
2048 this->str_offsets
.s
.section
= sectp
;
2049 this->str_offsets
.size
= bfd_section_size (sectp
);
2051 else if (names
.line_str
.matches (sectp
->name
))
2053 this->line_str
.s
.section
= sectp
;
2054 this->line_str
.size
= bfd_section_size (sectp
);
2056 else if (names
.addr
.matches (sectp
->name
))
2058 this->addr
.s
.section
= sectp
;
2059 this->addr
.size
= bfd_section_size (sectp
);
2061 else if (names
.frame
.matches (sectp
->name
))
2063 this->frame
.s
.section
= sectp
;
2064 this->frame
.size
= bfd_section_size (sectp
);
2066 else if (names
.eh_frame
.matches (sectp
->name
))
2068 this->eh_frame
.s
.section
= sectp
;
2069 this->eh_frame
.size
= bfd_section_size (sectp
);
2071 else if (names
.ranges
.matches (sectp
->name
))
2073 this->ranges
.s
.section
= sectp
;
2074 this->ranges
.size
= bfd_section_size (sectp
);
2076 else if (names
.rnglists
.matches (sectp
->name
))
2078 this->rnglists
.s
.section
= sectp
;
2079 this->rnglists
.size
= bfd_section_size (sectp
);
2081 else if (names
.types
.matches (sectp
->name
))
2083 struct dwarf2_section_info type_section
;
2085 memset (&type_section
, 0, sizeof (type_section
));
2086 type_section
.s
.section
= sectp
;
2087 type_section
.size
= bfd_section_size (sectp
);
2089 this->types
.push_back (type_section
);
2091 else if (names
.gdb_index
.matches (sectp
->name
))
2093 this->gdb_index
.s
.section
= sectp
;
2094 this->gdb_index
.size
= bfd_section_size (sectp
);
2096 else if (names
.debug_names
.matches (sectp
->name
))
2098 this->debug_names
.s
.section
= sectp
;
2099 this->debug_names
.size
= bfd_section_size (sectp
);
2101 else if (names
.debug_aranges
.matches (sectp
->name
))
2103 this->debug_aranges
.s
.section
= sectp
;
2104 this->debug_aranges
.size
= bfd_section_size (sectp
);
2107 if ((bfd_section_flags (sectp
) & (SEC_LOAD
| SEC_ALLOC
))
2108 && bfd_section_vma (sectp
) == 0)
2109 this->has_section_at_zero
= true;
2112 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
2116 dwarf2_get_section_info (struct objfile
*objfile
,
2117 enum dwarf2_section_enum sect
,
2118 asection
**sectp
, const gdb_byte
**bufp
,
2119 bfd_size_type
*sizep
)
2121 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
2122 struct dwarf2_section_info
*info
;
2124 /* We may see an objfile without any DWARF, in which case we just
2126 if (per_objfile
== NULL
)
2135 case DWARF2_DEBUG_FRAME
:
2136 info
= &per_objfile
->per_bfd
->frame
;
2138 case DWARF2_EH_FRAME
:
2139 info
= &per_objfile
->per_bfd
->eh_frame
;
2142 gdb_assert_not_reached ("unexpected section");
2145 info
->read (objfile
);
2147 *sectp
= info
->get_bfd_section ();
2148 *bufp
= info
->buffer
;
2149 *sizep
= info
->size
;
2153 /* DWARF quick_symbol_functions support. */
2155 /* TUs can share .debug_line entries, and there can be a lot more TUs than
2156 unique line tables, so we maintain a separate table of all .debug_line
2157 derived entries to support the sharing.
2158 All the quick functions need is the list of file names. We discard the
2159 line_header when we're done and don't need to record it here. */
2160 struct quick_file_names
2162 /* The data used to construct the hash key. */
2163 struct stmt_list_hash hash
;
2165 /* The number of entries in file_names, real_names. */
2166 unsigned int num_file_names
;
2168 /* The file names from the line table, after being run through
2170 const char **file_names
;
2172 /* The file names from the line table after being run through
2173 gdb_realpath. These are computed lazily. */
2174 const char **real_names
;
2177 /* When using the index (and thus not using psymtabs), each CU has an
2178 object of this type. This is used to hold information needed by
2179 the various "quick" methods. */
2180 struct dwarf2_per_cu_quick_data
2182 /* The file table. This can be NULL if there was no file table
2183 or it's currently not read in.
2184 NOTE: This points into dwarf2_per_objfile->per_bfd->quick_file_names_table. */
2185 struct quick_file_names
*file_names
;
2187 /* A temporary mark bit used when iterating over all CUs in
2188 expand_symtabs_matching. */
2189 unsigned int mark
: 1;
2191 /* True if we've tried to read the file table and found there isn't one.
2192 There will be no point in trying to read it again next time. */
2193 unsigned int no_file_data
: 1;
2196 struct dwarf2_base_index_functions
: public quick_symbol_functions
2198 bool has_symbols (struct objfile
*objfile
) override
;
2200 struct symtab
*find_last_source_symtab (struct objfile
*objfile
) override
;
2202 void forget_cached_source_info (struct objfile
*objfile
) override
;
2204 bool map_symtabs_matching_filename
2205 (struct objfile
*objfile
, const char *name
, const char *real_path
,
2206 gdb::function_view
<bool (symtab
*)> callback
) override
;
2208 enum language
lookup_global_symbol_language (struct objfile
*objfile
,
2211 bool *symbol_found_p
) override
2213 *symbol_found_p
= false;
2214 return language_unknown
;
2217 void print_stats (struct objfile
*objfile
, bool print_bcache
) override
;
2219 void expand_all_symtabs (struct objfile
*objfile
) override
;
2221 void expand_symtabs_with_fullname (struct objfile
*objfile
,
2222 const char *fullname
) override
;
2224 struct compunit_symtab
*find_pc_sect_compunit_symtab
2225 (struct objfile
*objfile
, struct bound_minimal_symbol msymbol
,
2226 CORE_ADDR pc
, struct obj_section
*section
, int warn_if_readin
) override
;
2228 struct compunit_symtab
*find_compunit_symtab_by_address
2229 (struct objfile
*objfile
, CORE_ADDR address
) override
2234 void map_symbol_filenames (struct objfile
*objfile
,
2235 symbol_filename_ftype
*fun
, void *data
,
2236 int need_fullname
) override
;
2239 struct dwarf2_gdb_index
: public dwarf2_base_index_functions
2241 struct compunit_symtab
*lookup_symbol (struct objfile
*objfile
,
2242 block_enum block_index
,
2244 domain_enum domain
) override
;
2246 void dump (struct objfile
*objfile
) override
;
2248 void expand_symtabs_for_function (struct objfile
*objfile
,
2249 const char *func_name
) override
;
2251 void map_matching_symbols
2253 const lookup_name_info
&lookup_name
,
2256 gdb::function_view
<symbol_found_callback_ftype
> callback
,
2257 symbol_compare_ftype
*ordered_compare
) override
;
2259 void expand_symtabs_matching
2260 (struct objfile
*objfile
,
2261 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
2262 const lookup_name_info
*lookup_name
,
2263 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
2264 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
2265 enum search_domain kind
) override
;
2268 struct dwarf2_debug_names_index
: public dwarf2_base_index_functions
2270 struct compunit_symtab
*lookup_symbol (struct objfile
*objfile
,
2271 block_enum block_index
,
2273 domain_enum domain
) override
;
2275 void dump (struct objfile
*objfile
) override
;
2277 void expand_symtabs_for_function (struct objfile
*objfile
,
2278 const char *func_name
) override
;
2280 void map_matching_symbols
2282 const lookup_name_info
&lookup_name
,
2285 gdb::function_view
<symbol_found_callback_ftype
> callback
,
2286 symbol_compare_ftype
*ordered_compare
) override
;
2288 void expand_symtabs_matching
2289 (struct objfile
*objfile
,
2290 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
2291 const lookup_name_info
*lookup_name
,
2292 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
2293 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
2294 enum search_domain kind
) override
;
2297 quick_symbol_functions_up
2298 make_dwarf_gdb_index ()
2300 return quick_symbol_functions_up (new dwarf2_gdb_index
);
2303 quick_symbol_functions_up
2304 make_dwarf_debug_names ()
2306 return quick_symbol_functions_up (new dwarf2_debug_names_index
);
2309 /* Utility hash function for a stmt_list_hash. */
2312 hash_stmt_list_entry (const struct stmt_list_hash
*stmt_list_hash
)
2316 if (stmt_list_hash
->dwo_unit
!= NULL
)
2317 v
+= (uintptr_t) stmt_list_hash
->dwo_unit
->dwo_file
;
2318 v
+= to_underlying (stmt_list_hash
->line_sect_off
);
2322 /* Utility equality function for a stmt_list_hash. */
2325 eq_stmt_list_entry (const struct stmt_list_hash
*lhs
,
2326 const struct stmt_list_hash
*rhs
)
2328 if ((lhs
->dwo_unit
!= NULL
) != (rhs
->dwo_unit
!= NULL
))
2330 if (lhs
->dwo_unit
!= NULL
2331 && lhs
->dwo_unit
->dwo_file
!= rhs
->dwo_unit
->dwo_file
)
2334 return lhs
->line_sect_off
== rhs
->line_sect_off
;
2337 /* Hash function for a quick_file_names. */
2340 hash_file_name_entry (const void *e
)
2342 const struct quick_file_names
*file_data
2343 = (const struct quick_file_names
*) e
;
2345 return hash_stmt_list_entry (&file_data
->hash
);
2348 /* Equality function for a quick_file_names. */
2351 eq_file_name_entry (const void *a
, const void *b
)
2353 const struct quick_file_names
*ea
= (const struct quick_file_names
*) a
;
2354 const struct quick_file_names
*eb
= (const struct quick_file_names
*) b
;
2356 return eq_stmt_list_entry (&ea
->hash
, &eb
->hash
);
2359 /* Delete function for a quick_file_names. */
2362 delete_file_name_entry (void *e
)
2364 struct quick_file_names
*file_data
= (struct quick_file_names
*) e
;
2367 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
2369 xfree ((void*) file_data
->file_names
[i
]);
2370 if (file_data
->real_names
)
2371 xfree ((void*) file_data
->real_names
[i
]);
2374 /* The space for the struct itself lives on the obstack, so we don't
2378 /* Create a quick_file_names hash table. */
2381 create_quick_file_names_table (unsigned int nr_initial_entries
)
2383 return htab_up (htab_create_alloc (nr_initial_entries
,
2384 hash_file_name_entry
, eq_file_name_entry
,
2385 delete_file_name_entry
, xcalloc
, xfree
));
2388 /* Read in CU (dwarf2_cu object) for PER_CU in the context of PER_OBJFILE. This
2389 function is unrelated to symtabs, symtab would have to be created afterwards.
2390 You should call age_cached_comp_units after processing the CU. */
2393 load_cu (dwarf2_per_cu_data
*per_cu
, dwarf2_per_objfile
*per_objfile
,
2396 if (per_cu
->is_debug_types
)
2397 load_full_type_unit (per_cu
, per_objfile
);
2399 load_full_comp_unit (per_cu
, per_objfile
, per_objfile
->get_cu (per_cu
),
2400 skip_partial
, language_minimal
);
2402 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
2404 return nullptr; /* Dummy CU. */
2406 dwarf2_find_base_address (cu
->dies
, cu
);
2411 /* Read in the symbols for PER_CU in the context of PER_OBJFILE. */
2414 dw2_do_instantiate_symtab (dwarf2_per_cu_data
*per_cu
,
2415 dwarf2_per_objfile
*per_objfile
, bool skip_partial
)
2417 /* Skip type_unit_groups, reading the type units they contain
2418 is handled elsewhere. */
2419 if (per_cu
->type_unit_group_p ())
2423 /* The destructor of dwarf2_queue_guard frees any entries left on
2424 the queue. After this point we're guaranteed to leave this function
2425 with the dwarf queue empty. */
2426 dwarf2_queue_guard
q_guard (per_objfile
);
2428 if (!per_objfile
->symtab_set_p (per_cu
))
2430 queue_comp_unit (per_cu
, per_objfile
, language_minimal
);
2431 dwarf2_cu
*cu
= load_cu (per_cu
, per_objfile
, skip_partial
);
2433 /* If we just loaded a CU from a DWO, and we're working with an index
2434 that may badly handle TUs, load all the TUs in that DWO as well.
2435 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
2436 if (!per_cu
->is_debug_types
2438 && cu
->dwo_unit
!= NULL
2439 && per_objfile
->per_bfd
->index_table
!= NULL
2440 && per_objfile
->per_bfd
->index_table
->version
<= 7
2441 /* DWP files aren't supported yet. */
2442 && get_dwp_file (per_objfile
) == NULL
)
2443 queue_and_load_all_dwo_tus (cu
);
2446 process_queue (per_objfile
);
2449 /* Age the cache, releasing compilation units that have not
2450 been used recently. */
2451 per_objfile
->age_comp_units ();
2454 /* Ensure that the symbols for PER_CU have been read in. DWARF2_PER_OBJFILE is
2455 the per-objfile for which this symtab is instantiated.
2457 Returns the resulting symbol table. */
2459 static struct compunit_symtab
*
2460 dw2_instantiate_symtab (dwarf2_per_cu_data
*per_cu
,
2461 dwarf2_per_objfile
*per_objfile
,
2464 gdb_assert (per_objfile
->per_bfd
->using_index
);
2466 if (!per_objfile
->symtab_set_p (per_cu
))
2468 free_cached_comp_units
freer (per_objfile
);
2469 scoped_restore decrementer
= increment_reading_symtab ();
2470 dw2_do_instantiate_symtab (per_cu
, per_objfile
, skip_partial
);
2471 process_cu_includes (per_objfile
);
2474 return per_objfile
->get_symtab (per_cu
);
2477 /* See declaration. */
2479 dwarf2_per_cu_data
*
2480 dwarf2_per_bfd::get_cutu (int index
)
2482 if (index
>= this->all_comp_units
.size ())
2484 index
-= this->all_comp_units
.size ();
2485 gdb_assert (index
< this->all_type_units
.size ());
2486 return &this->all_type_units
[index
]->per_cu
;
2489 return this->all_comp_units
[index
];
2492 /* See declaration. */
2494 dwarf2_per_cu_data
*
2495 dwarf2_per_bfd::get_cu (int index
)
2497 gdb_assert (index
>= 0 && index
< this->all_comp_units
.size ());
2499 return this->all_comp_units
[index
];
2502 /* See declaration. */
2505 dwarf2_per_bfd::get_tu (int index
)
2507 gdb_assert (index
>= 0 && index
< this->all_type_units
.size ());
2509 return this->all_type_units
[index
];
2514 dwarf2_per_cu_data
*
2515 dwarf2_per_bfd::allocate_per_cu ()
2517 dwarf2_per_cu_data
*result
= OBSTACK_ZALLOC (&obstack
, dwarf2_per_cu_data
);
2518 result
->per_bfd
= this;
2519 result
->index
= m_num_psymtabs
++;
2526 dwarf2_per_bfd::allocate_signatured_type ()
2528 signatured_type
*result
= OBSTACK_ZALLOC (&obstack
, signatured_type
);
2529 result
->per_cu
.per_bfd
= this;
2530 result
->per_cu
.index
= m_num_psymtabs
++;
2534 /* Return a new dwarf2_per_cu_data allocated on the per-bfd
2535 obstack, and constructed with the specified field values. */
2537 static dwarf2_per_cu_data
*
2538 create_cu_from_index_list (dwarf2_per_bfd
*per_bfd
,
2539 struct dwarf2_section_info
*section
,
2541 sect_offset sect_off
, ULONGEST length
)
2543 dwarf2_per_cu_data
*the_cu
= per_bfd
->allocate_per_cu ();
2544 the_cu
->sect_off
= sect_off
;
2545 the_cu
->length
= length
;
2546 the_cu
->section
= section
;
2547 the_cu
->v
.quick
= OBSTACK_ZALLOC (&per_bfd
->obstack
,
2548 struct dwarf2_per_cu_quick_data
);
2549 the_cu
->is_dwz
= is_dwz
;
2553 /* A helper for create_cus_from_index that handles a given list of
2557 create_cus_from_index_list (dwarf2_per_bfd
*per_bfd
,
2558 const gdb_byte
*cu_list
, offset_type n_elements
,
2559 struct dwarf2_section_info
*section
,
2562 for (offset_type i
= 0; i
< n_elements
; i
+= 2)
2564 gdb_static_assert (sizeof (ULONGEST
) >= 8);
2566 sect_offset sect_off
2567 = (sect_offset
) extract_unsigned_integer (cu_list
, 8, BFD_ENDIAN_LITTLE
);
2568 ULONGEST length
= extract_unsigned_integer (cu_list
+ 8, 8, BFD_ENDIAN_LITTLE
);
2571 dwarf2_per_cu_data
*per_cu
2572 = create_cu_from_index_list (per_bfd
, section
, is_dwz
, sect_off
,
2574 per_bfd
->all_comp_units
.push_back (per_cu
);
2578 /* Read the CU list from the mapped index, and use it to create all
2579 the CU objects for PER_BFD. */
2582 create_cus_from_index (dwarf2_per_bfd
*per_bfd
,
2583 const gdb_byte
*cu_list
, offset_type cu_list_elements
,
2584 const gdb_byte
*dwz_list
, offset_type dwz_elements
)
2586 gdb_assert (per_bfd
->all_comp_units
.empty ());
2587 per_bfd
->all_comp_units
.reserve ((cu_list_elements
+ dwz_elements
) / 2);
2589 create_cus_from_index_list (per_bfd
, cu_list
, cu_list_elements
,
2592 if (dwz_elements
== 0)
2595 dwz_file
*dwz
= dwarf2_get_dwz_file (per_bfd
);
2596 create_cus_from_index_list (per_bfd
, dwz_list
, dwz_elements
,
2600 /* Create the signatured type hash table from the index. */
2603 create_signatured_type_table_from_index
2604 (dwarf2_per_bfd
*per_bfd
, struct dwarf2_section_info
*section
,
2605 const gdb_byte
*bytes
, offset_type elements
)
2607 gdb_assert (per_bfd
->all_type_units
.empty ());
2608 per_bfd
->all_type_units
.reserve (elements
/ 3);
2610 htab_up sig_types_hash
= allocate_signatured_type_table ();
2612 for (offset_type i
= 0; i
< elements
; i
+= 3)
2614 struct signatured_type
*sig_type
;
2617 cu_offset type_offset_in_tu
;
2619 gdb_static_assert (sizeof (ULONGEST
) >= 8);
2620 sect_offset sect_off
2621 = (sect_offset
) extract_unsigned_integer (bytes
, 8, BFD_ENDIAN_LITTLE
);
2623 = (cu_offset
) extract_unsigned_integer (bytes
+ 8, 8,
2625 signature
= extract_unsigned_integer (bytes
+ 16, 8, BFD_ENDIAN_LITTLE
);
2628 sig_type
= per_bfd
->allocate_signatured_type ();
2629 sig_type
->signature
= signature
;
2630 sig_type
->type_offset_in_tu
= type_offset_in_tu
;
2631 sig_type
->per_cu
.is_debug_types
= 1;
2632 sig_type
->per_cu
.section
= section
;
2633 sig_type
->per_cu
.sect_off
= sect_off
;
2634 sig_type
->per_cu
.v
.quick
2635 = OBSTACK_ZALLOC (&per_bfd
->obstack
,
2636 struct dwarf2_per_cu_quick_data
);
2638 slot
= htab_find_slot (sig_types_hash
.get (), sig_type
, INSERT
);
2641 per_bfd
->all_type_units
.push_back (sig_type
);
2644 per_bfd
->signatured_types
= std::move (sig_types_hash
);
2647 /* Create the signatured type hash table from .debug_names. */
2650 create_signatured_type_table_from_debug_names
2651 (dwarf2_per_objfile
*per_objfile
,
2652 const mapped_debug_names
&map
,
2653 struct dwarf2_section_info
*section
,
2654 struct dwarf2_section_info
*abbrev_section
)
2656 struct objfile
*objfile
= per_objfile
->objfile
;
2658 section
->read (objfile
);
2659 abbrev_section
->read (objfile
);
2661 gdb_assert (per_objfile
->per_bfd
->all_type_units
.empty ());
2662 per_objfile
->per_bfd
->all_type_units
.reserve (map
.tu_count
);
2664 htab_up sig_types_hash
= allocate_signatured_type_table ();
2666 for (uint32_t i
= 0; i
< map
.tu_count
; ++i
)
2668 struct signatured_type
*sig_type
;
2671 sect_offset sect_off
2672 = (sect_offset
) (extract_unsigned_integer
2673 (map
.tu_table_reordered
+ i
* map
.offset_size
,
2675 map
.dwarf5_byte_order
));
2677 comp_unit_head cu_header
;
2678 read_and_check_comp_unit_head (per_objfile
, &cu_header
, section
,
2680 section
->buffer
+ to_underlying (sect_off
),
2683 sig_type
= per_objfile
->per_bfd
->allocate_signatured_type ();
2684 sig_type
->signature
= cu_header
.signature
;
2685 sig_type
->type_offset_in_tu
= cu_header
.type_cu_offset_in_tu
;
2686 sig_type
->per_cu
.is_debug_types
= 1;
2687 sig_type
->per_cu
.section
= section
;
2688 sig_type
->per_cu
.sect_off
= sect_off
;
2689 sig_type
->per_cu
.v
.quick
2690 = OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
,
2691 struct dwarf2_per_cu_quick_data
);
2693 slot
= htab_find_slot (sig_types_hash
.get (), sig_type
, INSERT
);
2696 per_objfile
->per_bfd
->all_type_units
.push_back (sig_type
);
2699 per_objfile
->per_bfd
->signatured_types
= std::move (sig_types_hash
);
2702 /* Read the address map data from the mapped index, and use it to
2703 populate the psymtabs_addrmap. */
2706 create_addrmap_from_index (dwarf2_per_objfile
*per_objfile
,
2707 struct mapped_index
*index
)
2709 struct objfile
*objfile
= per_objfile
->objfile
;
2710 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
2711 struct gdbarch
*gdbarch
= objfile
->arch ();
2712 const gdb_byte
*iter
, *end
;
2713 struct addrmap
*mutable_map
;
2716 auto_obstack temp_obstack
;
2718 mutable_map
= addrmap_create_mutable (&temp_obstack
);
2720 iter
= index
->address_table
.data ();
2721 end
= iter
+ index
->address_table
.size ();
2723 baseaddr
= objfile
->text_section_offset ();
2727 ULONGEST hi
, lo
, cu_index
;
2728 lo
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
2730 hi
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
2732 cu_index
= extract_unsigned_integer (iter
, 4, BFD_ENDIAN_LITTLE
);
2737 complaint (_(".gdb_index address table has invalid range (%s - %s)"),
2738 hex_string (lo
), hex_string (hi
));
2742 if (cu_index
>= per_bfd
->all_comp_units
.size ())
2744 complaint (_(".gdb_index address table has invalid CU number %u"),
2745 (unsigned) cu_index
);
2749 lo
= gdbarch_adjust_dwarf2_addr (gdbarch
, lo
+ baseaddr
) - baseaddr
;
2750 hi
= gdbarch_adjust_dwarf2_addr (gdbarch
, hi
+ baseaddr
) - baseaddr
;
2751 addrmap_set_empty (mutable_map
, lo
, hi
- 1,
2752 per_bfd
->get_cu (cu_index
));
2755 per_bfd
->index_addrmap
= addrmap_create_fixed (mutable_map
,
2759 /* Read the address map data from DWARF-5 .debug_aranges, and use it to
2760 populate the psymtabs_addrmap. */
2763 create_addrmap_from_aranges (dwarf2_per_objfile
*per_objfile
,
2764 struct dwarf2_section_info
*section
)
2766 struct objfile
*objfile
= per_objfile
->objfile
;
2767 bfd
*abfd
= objfile
->obfd
;
2768 struct gdbarch
*gdbarch
= objfile
->arch ();
2769 const CORE_ADDR baseaddr
= objfile
->text_section_offset ();
2770 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
2772 auto_obstack temp_obstack
;
2773 addrmap
*mutable_map
= addrmap_create_mutable (&temp_obstack
);
2775 std::unordered_map
<sect_offset
,
2776 dwarf2_per_cu_data
*,
2777 gdb::hash_enum
<sect_offset
>>
2778 debug_info_offset_to_per_cu
;
2779 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
2781 const auto insertpair
2782 = debug_info_offset_to_per_cu
.emplace (per_cu
->sect_off
, per_cu
);
2783 if (!insertpair
.second
)
2785 warning (_("Section .debug_aranges in %s has duplicate "
2786 "debug_info_offset %s, ignoring .debug_aranges."),
2787 objfile_name (objfile
), sect_offset_str (per_cu
->sect_off
));
2792 section
->read (objfile
);
2794 const bfd_endian dwarf5_byte_order
= gdbarch_byte_order (gdbarch
);
2796 const gdb_byte
*addr
= section
->buffer
;
2798 while (addr
< section
->buffer
+ section
->size
)
2800 const gdb_byte
*const entry_addr
= addr
;
2801 unsigned int bytes_read
;
2803 const LONGEST entry_length
= read_initial_length (abfd
, addr
,
2807 const gdb_byte
*const entry_end
= addr
+ entry_length
;
2808 const bool dwarf5_is_dwarf64
= bytes_read
!= 4;
2809 const uint8_t offset_size
= dwarf5_is_dwarf64
? 8 : 4;
2810 if (addr
+ entry_length
> section
->buffer
+ section
->size
)
2812 warning (_("Section .debug_aranges in %s entry at offset %s "
2813 "length %s exceeds section length %s, "
2814 "ignoring .debug_aranges."),
2815 objfile_name (objfile
),
2816 plongest (entry_addr
- section
->buffer
),
2817 plongest (bytes_read
+ entry_length
),
2818 pulongest (section
->size
));
2822 /* The version number. */
2823 const uint16_t version
= read_2_bytes (abfd
, addr
);
2827 warning (_("Section .debug_aranges in %s entry at offset %s "
2828 "has unsupported version %d, ignoring .debug_aranges."),
2829 objfile_name (objfile
),
2830 plongest (entry_addr
- section
->buffer
), version
);
2834 const uint64_t debug_info_offset
2835 = extract_unsigned_integer (addr
, offset_size
, dwarf5_byte_order
);
2836 addr
+= offset_size
;
2837 const auto per_cu_it
2838 = debug_info_offset_to_per_cu
.find (sect_offset (debug_info_offset
));
2839 if (per_cu_it
== debug_info_offset_to_per_cu
.cend ())
2841 warning (_("Section .debug_aranges in %s entry at offset %s "
2842 "debug_info_offset %s does not exists, "
2843 "ignoring .debug_aranges."),
2844 objfile_name (objfile
),
2845 plongest (entry_addr
- section
->buffer
),
2846 pulongest (debug_info_offset
));
2849 dwarf2_per_cu_data
*const per_cu
= per_cu_it
->second
;
2851 const uint8_t address_size
= *addr
++;
2852 if (address_size
< 1 || address_size
> 8)
2854 warning (_("Section .debug_aranges in %s entry at offset %s "
2855 "address_size %u is invalid, ignoring .debug_aranges."),
2856 objfile_name (objfile
),
2857 plongest (entry_addr
- section
->buffer
), address_size
);
2861 const uint8_t segment_selector_size
= *addr
++;
2862 if (segment_selector_size
!= 0)
2864 warning (_("Section .debug_aranges in %s entry at offset %s "
2865 "segment_selector_size %u is not supported, "
2866 "ignoring .debug_aranges."),
2867 objfile_name (objfile
),
2868 plongest (entry_addr
- section
->buffer
),
2869 segment_selector_size
);
2873 /* Must pad to an alignment boundary that is twice the address
2874 size. It is undocumented by the DWARF standard but GCC does
2876 for (size_t padding
= ((-(addr
- section
->buffer
))
2877 & (2 * address_size
- 1));
2878 padding
> 0; padding
--)
2881 warning (_("Section .debug_aranges in %s entry at offset %s "
2882 "padding is not zero, ignoring .debug_aranges."),
2883 objfile_name (objfile
),
2884 plongest (entry_addr
- section
->buffer
));
2890 if (addr
+ 2 * address_size
> entry_end
)
2892 warning (_("Section .debug_aranges in %s entry at offset %s "
2893 "address list is not properly terminated, "
2894 "ignoring .debug_aranges."),
2895 objfile_name (objfile
),
2896 plongest (entry_addr
- section
->buffer
));
2899 ULONGEST start
= extract_unsigned_integer (addr
, address_size
,
2901 addr
+= address_size
;
2902 ULONGEST length
= extract_unsigned_integer (addr
, address_size
,
2904 addr
+= address_size
;
2905 if (start
== 0 && length
== 0)
2907 if (start
== 0 && !per_bfd
->has_section_at_zero
)
2909 /* Symbol was eliminated due to a COMDAT group. */
2912 ULONGEST end
= start
+ length
;
2913 start
= (gdbarch_adjust_dwarf2_addr (gdbarch
, start
+ baseaddr
)
2915 end
= (gdbarch_adjust_dwarf2_addr (gdbarch
, end
+ baseaddr
)
2917 addrmap_set_empty (mutable_map
, start
, end
- 1, per_cu
);
2921 per_bfd
->index_addrmap
= addrmap_create_fixed (mutable_map
,
2925 /* Find a slot in the mapped index INDEX for the object named NAME.
2926 If NAME is found, set *VEC_OUT to point to the CU vector in the
2927 constant pool and return true. If NAME cannot be found, return
2931 find_slot_in_mapped_hash (struct mapped_index
*index
, const char *name
,
2932 offset_type
**vec_out
)
2935 offset_type slot
, step
;
2936 int (*cmp
) (const char *, const char *);
2938 gdb::unique_xmalloc_ptr
<char> without_params
;
2939 if (current_language
->la_language
== language_cplus
2940 || current_language
->la_language
== language_fortran
2941 || current_language
->la_language
== language_d
)
2943 /* NAME is already canonical. Drop any qualifiers as .gdb_index does
2946 if (strchr (name
, '(') != NULL
)
2948 without_params
= cp_remove_params (name
);
2950 if (without_params
!= NULL
)
2951 name
= without_params
.get ();
2955 /* Index version 4 did not support case insensitive searches. But the
2956 indices for case insensitive languages are built in lowercase, therefore
2957 simulate our NAME being searched is also lowercased. */
2958 hash
= mapped_index_string_hash ((index
->version
== 4
2959 && case_sensitivity
== case_sensitive_off
2960 ? 5 : index
->version
),
2963 slot
= hash
& (index
->symbol_table
.size () - 1);
2964 step
= ((hash
* 17) & (index
->symbol_table
.size () - 1)) | 1;
2965 cmp
= (case_sensitivity
== case_sensitive_on
? strcmp
: strcasecmp
);
2971 const auto &bucket
= index
->symbol_table
[slot
];
2972 if (bucket
.name
== 0 && bucket
.vec
== 0)
2975 str
= index
->constant_pool
+ MAYBE_SWAP (bucket
.name
);
2976 if (!cmp (name
, str
))
2978 *vec_out
= (offset_type
*) (index
->constant_pool
2979 + MAYBE_SWAP (bucket
.vec
));
2983 slot
= (slot
+ step
) & (index
->symbol_table
.size () - 1);
2987 /* A helper function that reads the .gdb_index from BUFFER and fills
2988 in MAP. FILENAME is the name of the file containing the data;
2989 it is used for error reporting. DEPRECATED_OK is true if it is
2990 ok to use deprecated sections.
2992 CU_LIST, CU_LIST_ELEMENTS, TYPES_LIST, and TYPES_LIST_ELEMENTS are
2993 out parameters that are filled in with information about the CU and
2994 TU lists in the section.
2996 Returns true if all went well, false otherwise. */
2999 read_gdb_index_from_buffer (const char *filename
,
3001 gdb::array_view
<const gdb_byte
> buffer
,
3002 struct mapped_index
*map
,
3003 const gdb_byte
**cu_list
,
3004 offset_type
*cu_list_elements
,
3005 const gdb_byte
**types_list
,
3006 offset_type
*types_list_elements
)
3008 const gdb_byte
*addr
= &buffer
[0];
3010 /* Version check. */
3011 offset_type version
= MAYBE_SWAP (*(offset_type
*) addr
);
3012 /* Versions earlier than 3 emitted every copy of a psymbol. This
3013 causes the index to behave very poorly for certain requests. Version 3
3014 contained incomplete addrmap. So, it seems better to just ignore such
3018 static int warning_printed
= 0;
3019 if (!warning_printed
)
3021 warning (_("Skipping obsolete .gdb_index section in %s."),
3023 warning_printed
= 1;
3027 /* Index version 4 uses a different hash function than index version
3030 Versions earlier than 6 did not emit psymbols for inlined
3031 functions. Using these files will cause GDB not to be able to
3032 set breakpoints on inlined functions by name, so we ignore these
3033 indices unless the user has done
3034 "set use-deprecated-index-sections on". */
3035 if (version
< 6 && !deprecated_ok
)
3037 static int warning_printed
= 0;
3038 if (!warning_printed
)
3041 Skipping deprecated .gdb_index section in %s.\n\
3042 Do \"set use-deprecated-index-sections on\" before the file is read\n\
3043 to use the section anyway."),
3045 warning_printed
= 1;
3049 /* Version 7 indices generated by gold refer to the CU for a symbol instead
3050 of the TU (for symbols coming from TUs),
3051 http://sourceware.org/bugzilla/show_bug.cgi?id=15021.
3052 Plus gold-generated indices can have duplicate entries for global symbols,
3053 http://sourceware.org/bugzilla/show_bug.cgi?id=15646.
3054 These are just performance bugs, and we can't distinguish gdb-generated
3055 indices from gold-generated ones, so issue no warning here. */
3057 /* Indexes with higher version than the one supported by GDB may be no
3058 longer backward compatible. */
3062 map
->version
= version
;
3064 offset_type
*metadata
= (offset_type
*) (addr
+ sizeof (offset_type
));
3067 *cu_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
3068 *cu_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1]) - MAYBE_SWAP (metadata
[i
]))
3072 *types_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
3073 *types_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1])
3074 - MAYBE_SWAP (metadata
[i
]))
3078 const gdb_byte
*address_table
= addr
+ MAYBE_SWAP (metadata
[i
]);
3079 const gdb_byte
*address_table_end
= addr
+ MAYBE_SWAP (metadata
[i
+ 1]);
3081 = gdb::array_view
<const gdb_byte
> (address_table
, address_table_end
);
3084 const gdb_byte
*symbol_table
= addr
+ MAYBE_SWAP (metadata
[i
]);
3085 const gdb_byte
*symbol_table_end
= addr
+ MAYBE_SWAP (metadata
[i
+ 1]);
3087 = gdb::array_view
<mapped_index::symbol_table_slot
>
3088 ((mapped_index::symbol_table_slot
*) symbol_table
,
3089 (mapped_index::symbol_table_slot
*) symbol_table_end
);
3092 map
->constant_pool
= (char *) (addr
+ MAYBE_SWAP (metadata
[i
]));
3097 /* Callback types for dwarf2_read_gdb_index. */
3099 typedef gdb::function_view
3100 <gdb::array_view
<const gdb_byte
>(objfile
*, dwarf2_per_bfd
*)>
3101 get_gdb_index_contents_ftype
;
3102 typedef gdb::function_view
3103 <gdb::array_view
<const gdb_byte
>(objfile
*, dwz_file
*)>
3104 get_gdb_index_contents_dwz_ftype
;
3106 /* Read .gdb_index. If everything went ok, initialize the "quick"
3107 elements of all the CUs and return 1. Otherwise, return 0. */
3110 dwarf2_read_gdb_index
3111 (dwarf2_per_objfile
*per_objfile
,
3112 get_gdb_index_contents_ftype get_gdb_index_contents
,
3113 get_gdb_index_contents_dwz_ftype get_gdb_index_contents_dwz
)
3115 const gdb_byte
*cu_list
, *types_list
, *dwz_list
= NULL
;
3116 offset_type cu_list_elements
, types_list_elements
, dwz_list_elements
= 0;
3117 struct dwz_file
*dwz
;
3118 struct objfile
*objfile
= per_objfile
->objfile
;
3119 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
3121 gdb::array_view
<const gdb_byte
> main_index_contents
3122 = get_gdb_index_contents (objfile
, per_bfd
);
3124 if (main_index_contents
.empty ())
3127 std::unique_ptr
<struct mapped_index
> map (new struct mapped_index
);
3128 if (!read_gdb_index_from_buffer (objfile_name (objfile
),
3129 use_deprecated_index_sections
,
3130 main_index_contents
, map
.get (), &cu_list
,
3131 &cu_list_elements
, &types_list
,
3132 &types_list_elements
))
3135 /* Don't use the index if it's empty. */
3136 if (map
->symbol_table
.empty ())
3139 /* If there is a .dwz file, read it so we can get its CU list as
3141 dwz
= dwarf2_get_dwz_file (per_bfd
);
3144 struct mapped_index dwz_map
;
3145 const gdb_byte
*dwz_types_ignore
;
3146 offset_type dwz_types_elements_ignore
;
3148 gdb::array_view
<const gdb_byte
> dwz_index_content
3149 = get_gdb_index_contents_dwz (objfile
, dwz
);
3151 if (dwz_index_content
.empty ())
3154 if (!read_gdb_index_from_buffer (bfd_get_filename (dwz
->dwz_bfd
.get ()),
3155 1, dwz_index_content
, &dwz_map
,
3156 &dwz_list
, &dwz_list_elements
,
3158 &dwz_types_elements_ignore
))
3160 warning (_("could not read '.gdb_index' section from %s; skipping"),
3161 bfd_get_filename (dwz
->dwz_bfd
.get ()));
3166 create_cus_from_index (per_bfd
, cu_list
, cu_list_elements
, dwz_list
,
3169 if (types_list_elements
)
3171 /* We can only handle a single .debug_types when we have an
3173 if (per_bfd
->types
.size () != 1)
3176 dwarf2_section_info
*section
= &per_bfd
->types
[0];
3178 create_signatured_type_table_from_index (per_bfd
, section
, types_list
,
3179 types_list_elements
);
3182 create_addrmap_from_index (per_objfile
, map
.get ());
3184 per_bfd
->index_table
= std::move (map
);
3185 per_bfd
->using_index
= 1;
3186 per_bfd
->quick_file_names_table
=
3187 create_quick_file_names_table (per_bfd
->all_comp_units
.size ());
3192 /* die_reader_func for dw2_get_file_names. */
3195 dw2_get_file_names_reader (const struct die_reader_specs
*reader
,
3196 struct die_info
*comp_unit_die
)
3198 struct dwarf2_cu
*cu
= reader
->cu
;
3199 struct dwarf2_per_cu_data
*this_cu
= cu
->per_cu
;
3200 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
3201 struct dwarf2_per_cu_data
*lh_cu
;
3202 struct attribute
*attr
;
3204 struct quick_file_names
*qfn
;
3206 gdb_assert (! this_cu
->is_debug_types
);
3208 /* Our callers never want to match partial units -- instead they
3209 will match the enclosing full CU. */
3210 if (comp_unit_die
->tag
== DW_TAG_partial_unit
)
3212 this_cu
->v
.quick
->no_file_data
= 1;
3220 sect_offset line_offset
{};
3222 attr
= dwarf2_attr (comp_unit_die
, DW_AT_stmt_list
, cu
);
3223 if (attr
!= nullptr && attr
->form_is_unsigned ())
3225 struct quick_file_names find_entry
;
3227 line_offset
= (sect_offset
) attr
->as_unsigned ();
3229 /* We may have already read in this line header (TU line header sharing).
3230 If we have we're done. */
3231 find_entry
.hash
.dwo_unit
= cu
->dwo_unit
;
3232 find_entry
.hash
.line_sect_off
= line_offset
;
3233 slot
= htab_find_slot (per_objfile
->per_bfd
->quick_file_names_table
.get (),
3234 &find_entry
, INSERT
);
3237 lh_cu
->v
.quick
->file_names
= (struct quick_file_names
*) *slot
;
3241 lh
= dwarf_decode_line_header (line_offset
, cu
);
3245 lh_cu
->v
.quick
->no_file_data
= 1;
3249 qfn
= XOBNEW (&per_objfile
->per_bfd
->obstack
, struct quick_file_names
);
3250 qfn
->hash
.dwo_unit
= cu
->dwo_unit
;
3251 qfn
->hash
.line_sect_off
= line_offset
;
3252 gdb_assert (slot
!= NULL
);
3255 file_and_directory fnd
= find_file_and_directory (comp_unit_die
, cu
);
3258 if (strcmp (fnd
.name
, "<unknown>") != 0)
3261 qfn
->num_file_names
= offset
+ lh
->file_names_size ();
3263 XOBNEWVEC (&per_objfile
->per_bfd
->obstack
, const char *,
3264 qfn
->num_file_names
);
3266 qfn
->file_names
[0] = xstrdup (fnd
.name
);
3267 for (int i
= 0; i
< lh
->file_names_size (); ++i
)
3268 qfn
->file_names
[i
+ offset
] = lh
->file_full_name (i
+ 1,
3269 fnd
.comp_dir
).release ();
3270 qfn
->real_names
= NULL
;
3272 lh_cu
->v
.quick
->file_names
= qfn
;
3275 /* A helper for the "quick" functions which attempts to read the line
3276 table for THIS_CU. */
3278 static struct quick_file_names
*
3279 dw2_get_file_names (dwarf2_per_cu_data
*this_cu
,
3280 dwarf2_per_objfile
*per_objfile
)
3282 /* This should never be called for TUs. */
3283 gdb_assert (! this_cu
->is_debug_types
);
3284 /* Nor type unit groups. */
3285 gdb_assert (! this_cu
->type_unit_group_p ());
3287 if (this_cu
->v
.quick
->file_names
!= NULL
)
3288 return this_cu
->v
.quick
->file_names
;
3289 /* If we know there is no line data, no point in looking again. */
3290 if (this_cu
->v
.quick
->no_file_data
)
3293 cutu_reader
reader (this_cu
, per_objfile
);
3294 if (!reader
.dummy_p
)
3295 dw2_get_file_names_reader (&reader
, reader
.comp_unit_die
);
3297 if (this_cu
->v
.quick
->no_file_data
)
3299 return this_cu
->v
.quick
->file_names
;
3302 /* A helper for the "quick" functions which computes and caches the
3303 real path for a given file name from the line table. */
3306 dw2_get_real_path (dwarf2_per_objfile
*per_objfile
,
3307 struct quick_file_names
*qfn
, int index
)
3309 if (qfn
->real_names
== NULL
)
3310 qfn
->real_names
= OBSTACK_CALLOC (&per_objfile
->per_bfd
->obstack
,
3311 qfn
->num_file_names
, const char *);
3313 if (qfn
->real_names
[index
] == NULL
)
3314 qfn
->real_names
[index
] = gdb_realpath (qfn
->file_names
[index
]).release ();
3316 return qfn
->real_names
[index
];
3320 dwarf2_base_index_functions::find_last_source_symtab (struct objfile
*objfile
)
3322 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3323 dwarf2_per_cu_data
*dwarf_cu
= per_objfile
->per_bfd
->all_comp_units
.back ();
3324 compunit_symtab
*cust
= dw2_instantiate_symtab (dwarf_cu
, per_objfile
, false);
3329 return compunit_primary_filetab (cust
);
3332 /* Traversal function for dw2_forget_cached_source_info. */
3335 dw2_free_cached_file_names (void **slot
, void *info
)
3337 struct quick_file_names
*file_data
= (struct quick_file_names
*) *slot
;
3339 if (file_data
->real_names
)
3343 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
3345 xfree ((void*) file_data
->real_names
[i
]);
3346 file_data
->real_names
[i
] = NULL
;
3354 dwarf2_base_index_functions::forget_cached_source_info
3355 (struct objfile
*objfile
)
3357 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3359 htab_traverse_noresize (per_objfile
->per_bfd
->quick_file_names_table
.get (),
3360 dw2_free_cached_file_names
, NULL
);
3363 /* Helper function for dw2_map_symtabs_matching_filename that expands
3364 the symtabs and calls the iterator. */
3367 dw2_map_expand_apply (struct objfile
*objfile
,
3368 struct dwarf2_per_cu_data
*per_cu
,
3369 const char *name
, const char *real_path
,
3370 gdb::function_view
<bool (symtab
*)> callback
)
3372 struct compunit_symtab
*last_made
= objfile
->compunit_symtabs
;
3374 /* Don't visit already-expanded CUs. */
3375 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3376 if (per_objfile
->symtab_set_p (per_cu
))
3379 /* This may expand more than one symtab, and we want to iterate over
3381 dw2_instantiate_symtab (per_cu
, per_objfile
, false);
3383 return iterate_over_some_symtabs (name
, real_path
, objfile
->compunit_symtabs
,
3384 last_made
, callback
);
3387 /* Implementation of the map_symtabs_matching_filename method. */
3390 dwarf2_base_index_functions::map_symtabs_matching_filename
3391 (struct objfile
*objfile
, const char *name
, const char *real_path
,
3392 gdb::function_view
<bool (symtab
*)> callback
)
3394 const char *name_basename
= lbasename (name
);
3395 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3397 /* The rule is CUs specify all the files, including those used by
3398 any TU, so there's no need to scan TUs here. */
3400 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
3402 /* We only need to look at symtabs not already expanded. */
3403 if (per_objfile
->symtab_set_p (per_cu
))
3406 quick_file_names
*file_data
= dw2_get_file_names (per_cu
, per_objfile
);
3407 if (file_data
== NULL
)
3410 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
3412 const char *this_name
= file_data
->file_names
[j
];
3413 const char *this_real_name
;
3415 if (compare_filenames_for_search (this_name
, name
))
3417 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3423 /* Before we invoke realpath, which can get expensive when many
3424 files are involved, do a quick comparison of the basenames. */
3425 if (! basenames_may_differ
3426 && FILENAME_CMP (lbasename (this_name
), name_basename
) != 0)
3429 this_real_name
= dw2_get_real_path (per_objfile
, file_data
, j
);
3430 if (compare_filenames_for_search (this_real_name
, name
))
3432 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3438 if (real_path
!= NULL
)
3440 gdb_assert (IS_ABSOLUTE_PATH (real_path
));
3441 gdb_assert (IS_ABSOLUTE_PATH (name
));
3442 if (this_real_name
!= NULL
3443 && FILENAME_CMP (real_path
, this_real_name
) == 0)
3445 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3457 /* Struct used to manage iterating over all CUs looking for a symbol. */
3459 struct dw2_symtab_iterator
3461 /* The dwarf2_per_objfile owning the CUs we are iterating on. */
3462 dwarf2_per_objfile
*per_objfile
;
3463 /* If set, only look for symbols that match that block. Valid values are
3464 GLOBAL_BLOCK and STATIC_BLOCK. */
3465 gdb::optional
<block_enum
> block_index
;
3466 /* The kind of symbol we're looking for. */
3468 /* The list of CUs from the index entry of the symbol,
3469 or NULL if not found. */
3471 /* The next element in VEC to look at. */
3473 /* The number of elements in VEC, or zero if there is no match. */
3475 /* Have we seen a global version of the symbol?
3476 If so we can ignore all further global instances.
3477 This is to work around gold/15646, inefficient gold-generated
3482 /* Initialize the index symtab iterator ITER, common part. */
3485 dw2_symtab_iter_init_common (struct dw2_symtab_iterator
*iter
,
3486 dwarf2_per_objfile
*per_objfile
,
3487 gdb::optional
<block_enum
> block_index
,
3490 iter
->per_objfile
= per_objfile
;
3491 iter
->block_index
= block_index
;
3492 iter
->domain
= domain
;
3494 iter
->global_seen
= 0;
3499 /* Initialize the index symtab iterator ITER, const char *NAME variant. */
3502 dw2_symtab_iter_init (struct dw2_symtab_iterator
*iter
,
3503 dwarf2_per_objfile
*per_objfile
,
3504 gdb::optional
<block_enum
> block_index
,
3508 dw2_symtab_iter_init_common (iter
, per_objfile
, block_index
, domain
);
3510 mapped_index
*index
= per_objfile
->per_bfd
->index_table
.get ();
3511 /* index is NULL if OBJF_READNOW. */
3515 if (find_slot_in_mapped_hash (index
, name
, &iter
->vec
))
3516 iter
->length
= MAYBE_SWAP (*iter
->vec
);
3519 /* Initialize the index symtab iterator ITER, offset_type NAMEI variant. */
3522 dw2_symtab_iter_init (struct dw2_symtab_iterator
*iter
,
3523 dwarf2_per_objfile
*per_objfile
,
3524 gdb::optional
<block_enum
> block_index
,
3525 domain_enum domain
, offset_type namei
)
3527 dw2_symtab_iter_init_common (iter
, per_objfile
, block_index
, domain
);
3529 mapped_index
*index
= per_objfile
->per_bfd
->index_table
.get ();
3530 /* index is NULL if OBJF_READNOW. */
3534 gdb_assert (!index
->symbol_name_slot_invalid (namei
));
3535 const auto &bucket
= index
->symbol_table
[namei
];
3537 iter
->vec
= (offset_type
*) (index
->constant_pool
3538 + MAYBE_SWAP (bucket
.vec
));
3539 iter
->length
= MAYBE_SWAP (*iter
->vec
);
3542 /* Return the next matching CU or NULL if there are no more. */
3544 static struct dwarf2_per_cu_data
*
3545 dw2_symtab_iter_next (struct dw2_symtab_iterator
*iter
)
3547 dwarf2_per_objfile
*per_objfile
= iter
->per_objfile
;
3549 for ( ; iter
->next
< iter
->length
; ++iter
->next
)
3551 offset_type cu_index_and_attrs
=
3552 MAYBE_SWAP (iter
->vec
[iter
->next
+ 1]);
3553 offset_type cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
3554 gdb_index_symbol_kind symbol_kind
=
3555 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
3556 /* Only check the symbol attributes if they're present.
3557 Indices prior to version 7 don't record them,
3558 and indices >= 7 may elide them for certain symbols
3559 (gold does this). */
3561 (per_objfile
->per_bfd
->index_table
->version
>= 7
3562 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_NONE
);
3564 /* Don't crash on bad data. */
3565 if (cu_index
>= (per_objfile
->per_bfd
->all_comp_units
.size ()
3566 + per_objfile
->per_bfd
->all_type_units
.size ()))
3568 complaint (_(".gdb_index entry has bad CU index"
3569 " [in module %s]"), objfile_name (per_objfile
->objfile
));
3573 dwarf2_per_cu_data
*per_cu
= per_objfile
->per_bfd
->get_cutu (cu_index
);
3575 /* Skip if already read in. */
3576 if (per_objfile
->symtab_set_p (per_cu
))
3579 /* Check static vs global. */
3582 bool is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs
);
3584 if (iter
->block_index
.has_value ())
3586 bool want_static
= *iter
->block_index
== STATIC_BLOCK
;
3588 if (is_static
!= want_static
)
3592 /* Work around gold/15646. */
3594 && symbol_kind
== GDB_INDEX_SYMBOL_KIND_TYPE
)
3596 if (iter
->global_seen
)
3599 iter
->global_seen
= 1;
3603 /* Only check the symbol's kind if it has one. */
3606 switch (iter
->domain
)
3609 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
3610 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
3611 /* Some types are also in VAR_DOMAIN. */
3612 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
3616 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
3620 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_OTHER
)
3624 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_OTHER
)
3639 struct compunit_symtab
*
3640 dwarf2_gdb_index::lookup_symbol (struct objfile
*objfile
,
3641 block_enum block_index
,
3642 const char *name
, domain_enum domain
)
3644 struct compunit_symtab
*stab_best
= NULL
;
3645 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3647 lookup_name_info
lookup_name (name
, symbol_name_match_type::FULL
);
3649 struct dw2_symtab_iterator iter
;
3650 struct dwarf2_per_cu_data
*per_cu
;
3652 dw2_symtab_iter_init (&iter
, per_objfile
, block_index
, domain
, name
);
3654 while ((per_cu
= dw2_symtab_iter_next (&iter
)) != NULL
)
3656 struct symbol
*sym
, *with_opaque
= NULL
;
3657 struct compunit_symtab
*stab
3658 = dw2_instantiate_symtab (per_cu
, per_objfile
, false);
3659 const struct blockvector
*bv
= COMPUNIT_BLOCKVECTOR (stab
);
3660 const struct block
*block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
3662 sym
= block_find_symbol (block
, name
, domain
,
3663 block_find_non_opaque_type_preferred
,
3666 /* Some caution must be observed with overloaded functions
3667 and methods, since the index will not contain any overload
3668 information (but NAME might contain it). */
3671 && SYMBOL_MATCHES_SEARCH_NAME (sym
, lookup_name
))
3673 if (with_opaque
!= NULL
3674 && SYMBOL_MATCHES_SEARCH_NAME (with_opaque
, lookup_name
))
3677 /* Keep looking through other CUs. */
3684 dwarf2_base_index_functions::print_stats (struct objfile
*objfile
,
3690 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3691 int total
= (per_objfile
->per_bfd
->all_comp_units
.size ()
3692 + per_objfile
->per_bfd
->all_type_units
.size ());
3695 for (int i
= 0; i
< total
; ++i
)
3697 dwarf2_per_cu_data
*per_cu
= per_objfile
->per_bfd
->get_cutu (i
);
3699 if (!per_objfile
->symtab_set_p (per_cu
))
3702 printf_filtered (_(" Number of read CUs: %d\n"), total
- count
);
3703 printf_filtered (_(" Number of unread CUs: %d\n"), count
);
3706 /* This dumps minimal information about the index.
3707 It is called via "mt print objfiles".
3708 One use is to verify .gdb_index has been loaded by the
3709 gdb.dwarf2/gdb-index.exp testcase. */
3712 dwarf2_gdb_index::dump (struct objfile
*objfile
)
3714 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3716 gdb_assert (per_objfile
->per_bfd
->using_index
);
3717 printf_filtered (".gdb_index:");
3718 if (per_objfile
->per_bfd
->index_table
!= NULL
)
3720 printf_filtered (" version %d\n",
3721 per_objfile
->per_bfd
->index_table
->version
);
3724 printf_filtered (" faked for \"readnow\"\n");
3725 printf_filtered ("\n");
3729 dwarf2_gdb_index::expand_symtabs_for_function (struct objfile
*objfile
,
3730 const char *func_name
)
3732 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3734 struct dw2_symtab_iterator iter
;
3735 struct dwarf2_per_cu_data
*per_cu
;
3737 dw2_symtab_iter_init (&iter
, per_objfile
, {}, VAR_DOMAIN
, func_name
);
3739 while ((per_cu
= dw2_symtab_iter_next (&iter
)) != NULL
)
3740 dw2_instantiate_symtab (per_cu
, per_objfile
, false);
3745 dwarf2_base_index_functions::expand_all_symtabs (struct objfile
*objfile
)
3747 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3748 int total_units
= (per_objfile
->per_bfd
->all_comp_units
.size ()
3749 + per_objfile
->per_bfd
->all_type_units
.size ());
3751 for (int i
= 0; i
< total_units
; ++i
)
3753 dwarf2_per_cu_data
*per_cu
= per_objfile
->per_bfd
->get_cutu (i
);
3755 /* We don't want to directly expand a partial CU, because if we
3756 read it with the wrong language, then assertion failures can
3757 be triggered later on. See PR symtab/23010. So, tell
3758 dw2_instantiate_symtab to skip partial CUs -- any important
3759 partial CU will be read via DW_TAG_imported_unit anyway. */
3760 dw2_instantiate_symtab (per_cu
, per_objfile
, true);
3765 dwarf2_base_index_functions::expand_symtabs_with_fullname
3766 (struct objfile
*objfile
, const char *fullname
)
3768 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3770 /* We don't need to consider type units here.
3771 This is only called for examining code, e.g. expand_line_sal.
3772 There can be an order of magnitude (or more) more type units
3773 than comp units, and we avoid them if we can. */
3775 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
3777 /* We only need to look at symtabs not already expanded. */
3778 if (per_objfile
->symtab_set_p (per_cu
))
3781 quick_file_names
*file_data
= dw2_get_file_names (per_cu
, per_objfile
);
3782 if (file_data
== NULL
)
3785 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
3787 const char *this_fullname
= file_data
->file_names
[j
];
3789 if (filename_cmp (this_fullname
, fullname
) == 0)
3791 dw2_instantiate_symtab (per_cu
, per_objfile
, false);
3799 dw2_expand_symtabs_matching_symbol
3800 (mapped_index_base
&index
,
3801 const lookup_name_info
&lookup_name_in
,
3802 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
3803 enum search_domain kind
,
3804 gdb::function_view
<bool (offset_type
)> match_callback
,
3805 dwarf2_per_objfile
*per_objfile
);
3808 dw2_expand_symtabs_matching_one
3809 (dwarf2_per_cu_data
*per_cu
,
3810 dwarf2_per_objfile
*per_objfile
,
3811 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
3812 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
);
3815 dw2_map_matching_symbols
3816 (struct objfile
*objfile
,
3817 const lookup_name_info
&name
, domain_enum domain
,
3819 gdb::function_view
<symbol_found_callback_ftype
> callback
,
3820 symbol_compare_ftype
*ordered_compare
)
3823 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3825 const block_enum block_kind
= global
? GLOBAL_BLOCK
: STATIC_BLOCK
;
3827 if (per_objfile
->per_bfd
->index_table
!= nullptr)
3829 mapped_index
&index
= *per_objfile
->per_bfd
->index_table
;
3831 const char *match_name
= name
.ada ().lookup_name ().c_str ();
3832 auto matcher
= [&] (const char *symname
)
3834 if (ordered_compare
== nullptr)
3836 return ordered_compare (symname
, match_name
) == 0;
3839 dw2_expand_symtabs_matching_symbol (index
, name
, matcher
, ALL_DOMAIN
,
3840 [&] (offset_type namei
)
3842 struct dw2_symtab_iterator iter
;
3843 struct dwarf2_per_cu_data
*per_cu
;
3845 dw2_symtab_iter_init (&iter
, per_objfile
, block_kind
, domain
,
3847 while ((per_cu
= dw2_symtab_iter_next (&iter
)) != NULL
)
3848 dw2_expand_symtabs_matching_one (per_cu
, per_objfile
, nullptr,
3855 /* We have -readnow: no .gdb_index, but no partial symtabs either. So,
3856 proceed assuming all symtabs have been read in. */
3859 for (compunit_symtab
*cust
: objfile
->compunits ())
3861 const struct block
*block
;
3865 block
= BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust
), block_kind
);
3866 if (!iterate_over_symbols_terminated (block
, name
,
3873 dwarf2_gdb_index::map_matching_symbols
3874 (struct objfile
*objfile
,
3875 const lookup_name_info
&name
, domain_enum domain
,
3877 gdb::function_view
<symbol_found_callback_ftype
> callback
,
3878 symbol_compare_ftype
*ordered_compare
)
3880 dw2_map_matching_symbols (objfile
, name
, domain
, global
, callback
,
3884 /* Starting from a search name, return the string that finds the upper
3885 bound of all strings that start with SEARCH_NAME in a sorted name
3886 list. Returns the empty string to indicate that the upper bound is
3887 the end of the list. */
3890 make_sort_after_prefix_name (const char *search_name
)
3892 /* When looking to complete "func", we find the upper bound of all
3893 symbols that start with "func" by looking for where we'd insert
3894 the closest string that would follow "func" in lexicographical
3895 order. Usually, that's "func"-with-last-character-incremented,
3896 i.e. "fund". Mind non-ASCII characters, though. Usually those
3897 will be UTF-8 multi-byte sequences, but we can't be certain.
3898 Especially mind the 0xff character, which is a valid character in
3899 non-UTF-8 source character sets (e.g. Latin1 'ÿ'), and we can't
3900 rule out compilers allowing it in identifiers. Note that
3901 conveniently, strcmp/strcasecmp are specified to compare
3902 characters interpreted as unsigned char. So what we do is treat
3903 the whole string as a base 256 number composed of a sequence of
3904 base 256 "digits" and add 1 to it. I.e., adding 1 to 0xff wraps
3905 to 0, and carries 1 to the following more-significant position.
3906 If the very first character in SEARCH_NAME ends up incremented
3907 and carries/overflows, then the upper bound is the end of the
3908 list. The string after the empty string is also the empty
3911 Some examples of this operation:
3913 SEARCH_NAME => "+1" RESULT
3917 "\xff" "a" "\xff" => "\xff" "b"
3922 Then, with these symbols for example:
3928 completing "func" looks for symbols between "func" and
3929 "func"-with-last-character-incremented, i.e. "fund" (exclusive),
3930 which finds "func" and "func1", but not "fund".
3934 funcÿ (Latin1 'ÿ' [0xff])
3938 completing "funcÿ" looks for symbols between "funcÿ" and "fund"
3939 (exclusive), which finds "funcÿ" and "funcÿ1", but not "fund".
3943 ÿÿ (Latin1 'ÿ' [0xff])
3946 completing "ÿ" or "ÿÿ" looks for symbols between between "ÿÿ" and
3947 the end of the list.
3949 std::string after
= search_name
;
3950 while (!after
.empty () && (unsigned char) after
.back () == 0xff)
3952 if (!after
.empty ())
3953 after
.back () = (unsigned char) after
.back () + 1;
3957 /* See declaration. */
3959 std::pair
<std::vector
<name_component
>::const_iterator
,
3960 std::vector
<name_component
>::const_iterator
>
3961 mapped_index_base::find_name_components_bounds
3962 (const lookup_name_info
&lookup_name_without_params
, language lang
,
3963 dwarf2_per_objfile
*per_objfile
) const
3966 = this->name_components_casing
== case_sensitive_on
? strcmp
: strcasecmp
;
3968 const char *lang_name
3969 = lookup_name_without_params
.language_lookup_name (lang
);
3971 /* Comparison function object for lower_bound that matches against a
3972 given symbol name. */
3973 auto lookup_compare_lower
= [&] (const name_component
&elem
,
3976 const char *elem_qualified
= this->symbol_name_at (elem
.idx
, per_objfile
);
3977 const char *elem_name
= elem_qualified
+ elem
.name_offset
;
3978 return name_cmp (elem_name
, name
) < 0;
3981 /* Comparison function object for upper_bound that matches against a
3982 given symbol name. */
3983 auto lookup_compare_upper
= [&] (const char *name
,
3984 const name_component
&elem
)
3986 const char *elem_qualified
= this->symbol_name_at (elem
.idx
, per_objfile
);
3987 const char *elem_name
= elem_qualified
+ elem
.name_offset
;
3988 return name_cmp (name
, elem_name
) < 0;
3991 auto begin
= this->name_components
.begin ();
3992 auto end
= this->name_components
.end ();
3994 /* Find the lower bound. */
3997 if (lookup_name_without_params
.completion_mode () && lang_name
[0] == '\0')
4000 return std::lower_bound (begin
, end
, lang_name
, lookup_compare_lower
);
4003 /* Find the upper bound. */
4006 if (lookup_name_without_params
.completion_mode ())
4008 /* In completion mode, we want UPPER to point past all
4009 symbols names that have the same prefix. I.e., with
4010 these symbols, and completing "func":
4012 function << lower bound
4014 other_function << upper bound
4016 We find the upper bound by looking for the insertion
4017 point of "func"-with-last-character-incremented,
4019 std::string after
= make_sort_after_prefix_name (lang_name
);
4022 return std::lower_bound (lower
, end
, after
.c_str (),
4023 lookup_compare_lower
);
4026 return std::upper_bound (lower
, end
, lang_name
, lookup_compare_upper
);
4029 return {lower
, upper
};
4032 /* See declaration. */
4035 mapped_index_base::build_name_components (dwarf2_per_objfile
*per_objfile
)
4037 if (!this->name_components
.empty ())
4040 this->name_components_casing
= case_sensitivity
;
4042 = this->name_components_casing
== case_sensitive_on
? strcmp
: strcasecmp
;
4044 /* The code below only knows how to break apart components of C++
4045 symbol names (and other languages that use '::' as
4046 namespace/module separator) and Ada symbol names. */
4047 auto count
= this->symbol_name_count ();
4048 for (offset_type idx
= 0; idx
< count
; idx
++)
4050 if (this->symbol_name_slot_invalid (idx
))
4053 const char *name
= this->symbol_name_at (idx
, per_objfile
);
4055 /* Add each name component to the name component table. */
4056 unsigned int previous_len
= 0;
4058 if (strstr (name
, "::") != nullptr)
4060 for (unsigned int current_len
= cp_find_first_component (name
);
4061 name
[current_len
] != '\0';
4062 current_len
+= cp_find_first_component (name
+ current_len
))
4064 gdb_assert (name
[current_len
] == ':');
4065 this->name_components
.push_back ({previous_len
, idx
});
4066 /* Skip the '::'. */
4068 previous_len
= current_len
;
4073 /* Handle the Ada encoded (aka mangled) form here. */
4074 for (const char *iter
= strstr (name
, "__");
4076 iter
= strstr (iter
, "__"))
4078 this->name_components
.push_back ({previous_len
, idx
});
4080 previous_len
= iter
- name
;
4084 this->name_components
.push_back ({previous_len
, idx
});
4087 /* Sort name_components elements by name. */
4088 auto name_comp_compare
= [&] (const name_component
&left
,
4089 const name_component
&right
)
4091 const char *left_qualified
4092 = this->symbol_name_at (left
.idx
, per_objfile
);
4093 const char *right_qualified
4094 = this->symbol_name_at (right
.idx
, per_objfile
);
4096 const char *left_name
= left_qualified
+ left
.name_offset
;
4097 const char *right_name
= right_qualified
+ right
.name_offset
;
4099 return name_cmp (left_name
, right_name
) < 0;
4102 std::sort (this->name_components
.begin (),
4103 this->name_components
.end (),
4107 /* Helper for dw2_expand_symtabs_matching that works with a
4108 mapped_index_base instead of the containing objfile. This is split
4109 to a separate function in order to be able to unit test the
4110 name_components matching using a mock mapped_index_base. For each
4111 symbol name that matches, calls MATCH_CALLBACK, passing it the
4112 symbol's index in the mapped_index_base symbol table. */
4115 dw2_expand_symtabs_matching_symbol
4116 (mapped_index_base
&index
,
4117 const lookup_name_info
&lookup_name_in
,
4118 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
4119 enum search_domain kind
,
4120 gdb::function_view
<bool (offset_type
)> match_callback
,
4121 dwarf2_per_objfile
*per_objfile
)
4123 lookup_name_info lookup_name_without_params
4124 = lookup_name_in
.make_ignore_params ();
4126 /* Build the symbol name component sorted vector, if we haven't
4128 index
.build_name_components (per_objfile
);
4130 /* The same symbol may appear more than once in the range though.
4131 E.g., if we're looking for symbols that complete "w", and we have
4132 a symbol named "w1::w2", we'll find the two name components for
4133 that same symbol in the range. To be sure we only call the
4134 callback once per symbol, we first collect the symbol name
4135 indexes that matched in a temporary vector and ignore
4137 std::vector
<offset_type
> matches
;
4139 struct name_and_matcher
4141 symbol_name_matcher_ftype
*matcher
;
4144 bool operator== (const name_and_matcher
&other
) const
4146 return matcher
== other
.matcher
&& strcmp (name
, other
.name
) == 0;
4150 /* A vector holding all the different symbol name matchers, for all
4152 std::vector
<name_and_matcher
> matchers
;
4154 for (int i
= 0; i
< nr_languages
; i
++)
4156 enum language lang_e
= (enum language
) i
;
4158 const language_defn
*lang
= language_def (lang_e
);
4159 symbol_name_matcher_ftype
*name_matcher
4160 = lang
->get_symbol_name_matcher (lookup_name_without_params
);
4162 name_and_matcher key
{
4164 lookup_name_without_params
.language_lookup_name (lang_e
)
4167 /* Don't insert the same comparison routine more than once.
4168 Note that we do this linear walk. This is not a problem in
4169 practice because the number of supported languages is
4171 if (std::find (matchers
.begin (), matchers
.end (), key
)
4174 matchers
.push_back (std::move (key
));
4177 = index
.find_name_components_bounds (lookup_name_without_params
,
4178 lang_e
, per_objfile
);
4180 /* Now for each symbol name in range, check to see if we have a name
4181 match, and if so, call the MATCH_CALLBACK callback. */
4183 for (; bounds
.first
!= bounds
.second
; ++bounds
.first
)
4185 const char *qualified
4186 = index
.symbol_name_at (bounds
.first
->idx
, per_objfile
);
4188 if (!name_matcher (qualified
, lookup_name_without_params
, NULL
)
4189 || (symbol_matcher
!= NULL
&& !symbol_matcher (qualified
)))
4192 matches
.push_back (bounds
.first
->idx
);
4196 std::sort (matches
.begin (), matches
.end ());
4198 /* Finally call the callback, once per match. */
4200 for (offset_type idx
: matches
)
4204 if (!match_callback (idx
))
4210 /* Above we use a type wider than idx's for 'prev', since 0 and
4211 (offset_type)-1 are both possible values. */
4212 static_assert (sizeof (prev
) > sizeof (offset_type
), "");
4217 namespace selftests
{ namespace dw2_expand_symtabs_matching
{
4219 /* A mock .gdb_index/.debug_names-like name index table, enough to
4220 exercise dw2_expand_symtabs_matching_symbol, which works with the
4221 mapped_index_base interface. Builds an index from the symbol list
4222 passed as parameter to the constructor. */
4223 class mock_mapped_index
: public mapped_index_base
4226 mock_mapped_index (gdb::array_view
<const char *> symbols
)
4227 : m_symbol_table (symbols
)
4230 DISABLE_COPY_AND_ASSIGN (mock_mapped_index
);
4232 /* Return the number of names in the symbol table. */
4233 size_t symbol_name_count () const override
4235 return m_symbol_table
.size ();
4238 /* Get the name of the symbol at IDX in the symbol table. */
4239 const char *symbol_name_at
4240 (offset_type idx
, dwarf2_per_objfile
*per_objfile
) const override
4242 return m_symbol_table
[idx
];
4246 gdb::array_view
<const char *> m_symbol_table
;
4249 /* Convenience function that converts a NULL pointer to a "<null>"
4250 string, to pass to print routines. */
4253 string_or_null (const char *str
)
4255 return str
!= NULL
? str
: "<null>";
4258 /* Check if a lookup_name_info built from
4259 NAME/MATCH_TYPE/COMPLETION_MODE matches the symbols in the mock
4260 index. EXPECTED_LIST is the list of expected matches, in expected
4261 matching order. If no match expected, then an empty list is
4262 specified. Returns true on success. On failure prints a warning
4263 indicating the file:line that failed, and returns false. */
4266 check_match (const char *file
, int line
,
4267 mock_mapped_index
&mock_index
,
4268 const char *name
, symbol_name_match_type match_type
,
4269 bool completion_mode
,
4270 std::initializer_list
<const char *> expected_list
,
4271 dwarf2_per_objfile
*per_objfile
)
4273 lookup_name_info
lookup_name (name
, match_type
, completion_mode
);
4275 bool matched
= true;
4277 auto mismatch
= [&] (const char *expected_str
,
4280 warning (_("%s:%d: match_type=%s, looking-for=\"%s\", "
4281 "expected=\"%s\", got=\"%s\"\n"),
4283 (match_type
== symbol_name_match_type::FULL
4285 name
, string_or_null (expected_str
), string_or_null (got
));
4289 auto expected_it
= expected_list
.begin ();
4290 auto expected_end
= expected_list
.end ();
4292 dw2_expand_symtabs_matching_symbol (mock_index
, lookup_name
,
4294 [&] (offset_type idx
)
4296 const char *matched_name
= mock_index
.symbol_name_at (idx
, per_objfile
);
4297 const char *expected_str
4298 = expected_it
== expected_end
? NULL
: *expected_it
++;
4300 if (expected_str
== NULL
|| strcmp (expected_str
, matched_name
) != 0)
4301 mismatch (expected_str
, matched_name
);
4305 const char *expected_str
4306 = expected_it
== expected_end
? NULL
: *expected_it
++;
4307 if (expected_str
!= NULL
)
4308 mismatch (expected_str
, NULL
);
4313 /* The symbols added to the mock mapped_index for testing (in
4315 static const char *test_symbols
[] = {
4324 "ns2::tmpl<int>::foo2",
4325 "(anonymous namespace)::A::B::C",
4327 /* These are used to check that the increment-last-char in the
4328 matching algorithm for completion doesn't match "t1_fund" when
4329 completing "t1_func". */
4335 /* A UTF-8 name with multi-byte sequences to make sure that
4336 cp-name-parser understands this as a single identifier ("função"
4337 is "function" in PT). */
4340 /* \377 (0xff) is Latin1 'ÿ'. */
4343 /* \377 (0xff) is Latin1 'ÿ'. */
4347 /* A name with all sorts of complications. Starts with "z" to make
4348 it easier for the completion tests below. */
4349 #define Z_SYM_NAME \
4350 "z::std::tuple<(anonymous namespace)::ui*, std::bar<(anonymous namespace)::ui> >" \
4351 "::tuple<(anonymous namespace)::ui*, " \
4352 "std::default_delete<(anonymous namespace)::ui>, void>"
4357 /* Returns true if the mapped_index_base::find_name_component_bounds
4358 method finds EXPECTED_SYMS in INDEX when looking for SEARCH_NAME,
4359 in completion mode. */
4362 check_find_bounds_finds (mapped_index_base
&index
,
4363 const char *search_name
,
4364 gdb::array_view
<const char *> expected_syms
,
4365 dwarf2_per_objfile
*per_objfile
)
4367 lookup_name_info
lookup_name (search_name
,
4368 symbol_name_match_type::FULL
, true);
4370 auto bounds
= index
.find_name_components_bounds (lookup_name
,
4374 size_t distance
= std::distance (bounds
.first
, bounds
.second
);
4375 if (distance
!= expected_syms
.size ())
4378 for (size_t exp_elem
= 0; exp_elem
< distance
; exp_elem
++)
4380 auto nc_elem
= bounds
.first
+ exp_elem
;
4381 const char *qualified
= index
.symbol_name_at (nc_elem
->idx
, per_objfile
);
4382 if (strcmp (qualified
, expected_syms
[exp_elem
]) != 0)
4389 /* Test the lower-level mapped_index::find_name_component_bounds
4393 test_mapped_index_find_name_component_bounds ()
4395 mock_mapped_index
mock_index (test_symbols
);
4397 mock_index
.build_name_components (NULL
/* per_objfile */);
4399 /* Test the lower-level mapped_index::find_name_component_bounds
4400 method in completion mode. */
4402 static const char *expected_syms
[] = {
4407 SELF_CHECK (check_find_bounds_finds
4408 (mock_index
, "t1_func", expected_syms
,
4409 NULL
/* per_objfile */));
4412 /* Check that the increment-last-char in the name matching algorithm
4413 for completion doesn't get confused with Ansi1 'ÿ' / 0xff. */
4415 static const char *expected_syms1
[] = {
4419 SELF_CHECK (check_find_bounds_finds
4420 (mock_index
, "\377", expected_syms1
, NULL
/* per_objfile */));
4422 static const char *expected_syms2
[] = {
4425 SELF_CHECK (check_find_bounds_finds
4426 (mock_index
, "\377\377", expected_syms2
,
4427 NULL
/* per_objfile */));
4431 /* Test dw2_expand_symtabs_matching_symbol. */
4434 test_dw2_expand_symtabs_matching_symbol ()
4436 mock_mapped_index
mock_index (test_symbols
);
4438 /* We let all tests run until the end even if some fails, for debug
4440 bool any_mismatch
= false;
4442 /* Create the expected symbols list (an initializer_list). Needed
4443 because lists have commas, and we need to pass them to CHECK,
4444 which is a macro. */
4445 #define EXPECT(...) { __VA_ARGS__ }
4447 /* Wrapper for check_match that passes down the current
4448 __FILE__/__LINE__. */
4449 #define CHECK_MATCH(NAME, MATCH_TYPE, COMPLETION_MODE, EXPECTED_LIST) \
4450 any_mismatch |= !check_match (__FILE__, __LINE__, \
4452 NAME, MATCH_TYPE, COMPLETION_MODE, \
4453 EXPECTED_LIST, NULL)
4455 /* Identity checks. */
4456 for (const char *sym
: test_symbols
)
4458 /* Should be able to match all existing symbols. */
4459 CHECK_MATCH (sym
, symbol_name_match_type::FULL
, false,
4462 /* Should be able to match all existing symbols with
4464 std::string with_params
= std::string (sym
) + "(int)";
4465 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
4468 /* Should be able to match all existing symbols with
4469 parameters and qualifiers. */
4470 with_params
= std::string (sym
) + " ( int ) const";
4471 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
4474 /* This should really find sym, but cp-name-parser.y doesn't
4475 know about lvalue/rvalue qualifiers yet. */
4476 with_params
= std::string (sym
) + " ( int ) &&";
4477 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
4481 /* Check that the name matching algorithm for completion doesn't get
4482 confused with Latin1 'ÿ' / 0xff. */
4484 static const char str
[] = "\377";
4485 CHECK_MATCH (str
, symbol_name_match_type::FULL
, true,
4486 EXPECT ("\377", "\377\377123"));
4489 /* Check that the increment-last-char in the matching algorithm for
4490 completion doesn't match "t1_fund" when completing "t1_func". */
4492 static const char str
[] = "t1_func";
4493 CHECK_MATCH (str
, symbol_name_match_type::FULL
, true,
4494 EXPECT ("t1_func", "t1_func1"));
4497 /* Check that completion mode works at each prefix of the expected
4500 static const char str
[] = "function(int)";
4501 size_t len
= strlen (str
);
4504 for (size_t i
= 1; i
< len
; i
++)
4506 lookup
.assign (str
, i
);
4507 CHECK_MATCH (lookup
.c_str (), symbol_name_match_type::FULL
, true,
4508 EXPECT ("function"));
4512 /* While "w" is a prefix of both components, the match function
4513 should still only be called once. */
4515 CHECK_MATCH ("w", symbol_name_match_type::FULL
, true,
4517 CHECK_MATCH ("w", symbol_name_match_type::WILD
, true,
4521 /* Same, with a "complicated" symbol. */
4523 static const char str
[] = Z_SYM_NAME
;
4524 size_t len
= strlen (str
);
4527 for (size_t i
= 1; i
< len
; i
++)
4529 lookup
.assign (str
, i
);
4530 CHECK_MATCH (lookup
.c_str (), symbol_name_match_type::FULL
, true,
4531 EXPECT (Z_SYM_NAME
));
4535 /* In FULL mode, an incomplete symbol doesn't match. */
4537 CHECK_MATCH ("std::zfunction(int", symbol_name_match_type::FULL
, false,
4541 /* A complete symbol with parameters matches any overload, since the
4542 index has no overload info. */
4544 CHECK_MATCH ("std::zfunction(int)", symbol_name_match_type::FULL
, true,
4545 EXPECT ("std::zfunction", "std::zfunction2"));
4546 CHECK_MATCH ("zfunction(int)", symbol_name_match_type::WILD
, true,
4547 EXPECT ("std::zfunction", "std::zfunction2"));
4548 CHECK_MATCH ("zfunc", symbol_name_match_type::WILD
, true,
4549 EXPECT ("std::zfunction", "std::zfunction2"));
4552 /* Check that whitespace is ignored appropriately. A symbol with a
4553 template argument list. */
4555 static const char expected
[] = "ns::foo<int>";
4556 CHECK_MATCH ("ns :: foo < int > ", symbol_name_match_type::FULL
, false,
4558 CHECK_MATCH ("foo < int > ", symbol_name_match_type::WILD
, false,
4562 /* Check that whitespace is ignored appropriately. A symbol with a
4563 template argument list that includes a pointer. */
4565 static const char expected
[] = "ns::foo<char*>";
4566 /* Try both completion and non-completion modes. */
4567 static const bool completion_mode
[2] = {false, true};
4568 for (size_t i
= 0; i
< 2; i
++)
4570 CHECK_MATCH ("ns :: foo < char * >", symbol_name_match_type::FULL
,
4571 completion_mode
[i
], EXPECT (expected
));
4572 CHECK_MATCH ("foo < char * >", symbol_name_match_type::WILD
,
4573 completion_mode
[i
], EXPECT (expected
));
4575 CHECK_MATCH ("ns :: foo < char * > (int)", symbol_name_match_type::FULL
,
4576 completion_mode
[i
], EXPECT (expected
));
4577 CHECK_MATCH ("foo < char * > (int)", symbol_name_match_type::WILD
,
4578 completion_mode
[i
], EXPECT (expected
));
4583 /* Check method qualifiers are ignored. */
4584 static const char expected
[] = "ns::foo<char*>";
4585 CHECK_MATCH ("ns :: foo < char * > ( int ) const",
4586 symbol_name_match_type::FULL
, true, EXPECT (expected
));
4587 CHECK_MATCH ("ns :: foo < char * > ( int ) &&",
4588 symbol_name_match_type::FULL
, true, EXPECT (expected
));
4589 CHECK_MATCH ("foo < char * > ( int ) const",
4590 symbol_name_match_type::WILD
, true, EXPECT (expected
));
4591 CHECK_MATCH ("foo < char * > ( int ) &&",
4592 symbol_name_match_type::WILD
, true, EXPECT (expected
));
4595 /* Test lookup names that don't match anything. */
4597 CHECK_MATCH ("bar2", symbol_name_match_type::WILD
, false,
4600 CHECK_MATCH ("doesntexist", symbol_name_match_type::FULL
, false,
4604 /* Some wild matching tests, exercising "(anonymous namespace)",
4605 which should not be confused with a parameter list. */
4607 static const char *syms
[] = {
4611 "A :: B :: C ( int )",
4616 for (const char *s
: syms
)
4618 CHECK_MATCH (s
, symbol_name_match_type::WILD
, false,
4619 EXPECT ("(anonymous namespace)::A::B::C"));
4624 static const char expected
[] = "ns2::tmpl<int>::foo2";
4625 CHECK_MATCH ("tmp", symbol_name_match_type::WILD
, true,
4627 CHECK_MATCH ("tmpl<", symbol_name_match_type::WILD
, true,
4631 SELF_CHECK (!any_mismatch
);
4640 test_mapped_index_find_name_component_bounds ();
4641 test_dw2_expand_symtabs_matching_symbol ();
4644 }} // namespace selftests::dw2_expand_symtabs_matching
4646 #endif /* GDB_SELF_TEST */
4648 /* If FILE_MATCHER is NULL or if PER_CU has
4649 dwarf2_per_cu_quick_data::MARK set (see
4650 dw_expand_symtabs_matching_file_matcher), expand the CU and call
4651 EXPANSION_NOTIFY on it. */
4654 dw2_expand_symtabs_matching_one
4655 (dwarf2_per_cu_data
*per_cu
,
4656 dwarf2_per_objfile
*per_objfile
,
4657 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
4658 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
)
4660 if (file_matcher
== NULL
|| per_cu
->v
.quick
->mark
)
4662 bool symtab_was_null
= !per_objfile
->symtab_set_p (per_cu
);
4664 compunit_symtab
*symtab
4665 = dw2_instantiate_symtab (per_cu
, per_objfile
, false);
4666 gdb_assert (symtab
!= nullptr);
4668 if (expansion_notify
!= NULL
&& symtab_was_null
)
4669 expansion_notify (symtab
);
4673 /* Helper for dw2_expand_matching symtabs. Called on each symbol
4674 matched, to expand corresponding CUs that were marked. IDX is the
4675 index of the symbol name that matched. */
4678 dw2_expand_marked_cus
4679 (dwarf2_per_objfile
*per_objfile
, offset_type idx
,
4680 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
4681 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
4684 offset_type
*vec
, vec_len
, vec_idx
;
4685 bool global_seen
= false;
4686 mapped_index
&index
= *per_objfile
->per_bfd
->index_table
;
4688 vec
= (offset_type
*) (index
.constant_pool
4689 + MAYBE_SWAP (index
.symbol_table
[idx
].vec
));
4690 vec_len
= MAYBE_SWAP (vec
[0]);
4691 for (vec_idx
= 0; vec_idx
< vec_len
; ++vec_idx
)
4693 offset_type cu_index_and_attrs
= MAYBE_SWAP (vec
[vec_idx
+ 1]);
4694 /* This value is only valid for index versions >= 7. */
4695 int is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs
);
4696 gdb_index_symbol_kind symbol_kind
=
4697 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
4698 int cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
4699 /* Only check the symbol attributes if they're present.
4700 Indices prior to version 7 don't record them,
4701 and indices >= 7 may elide them for certain symbols
4702 (gold does this). */
4705 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_NONE
);
4707 /* Work around gold/15646. */
4710 && symbol_kind
== GDB_INDEX_SYMBOL_KIND_TYPE
)
4718 /* Only check the symbol's kind if it has one. */
4723 case VARIABLES_DOMAIN
:
4724 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
)
4727 case FUNCTIONS_DOMAIN
:
4728 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
)
4732 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
4735 case MODULES_DOMAIN
:
4736 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_OTHER
)
4744 /* Don't crash on bad data. */
4745 if (cu_index
>= (per_objfile
->per_bfd
->all_comp_units
.size ()
4746 + per_objfile
->per_bfd
->all_type_units
.size ()))
4748 complaint (_(".gdb_index entry has bad CU index"
4749 " [in module %s]"), objfile_name (per_objfile
->objfile
));
4753 dwarf2_per_cu_data
*per_cu
= per_objfile
->per_bfd
->get_cutu (cu_index
);
4754 dw2_expand_symtabs_matching_one (per_cu
, per_objfile
, file_matcher
,
4759 /* If FILE_MATCHER is non-NULL, set all the
4760 dwarf2_per_cu_quick_data::MARK of the current DWARF2_PER_OBJFILE
4761 that match FILE_MATCHER. */
4764 dw_expand_symtabs_matching_file_matcher
4765 (dwarf2_per_objfile
*per_objfile
,
4766 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
)
4768 if (file_matcher
== NULL
)
4771 htab_up
visited_found (htab_create_alloc (10, htab_hash_pointer
,
4773 NULL
, xcalloc
, xfree
));
4774 htab_up
visited_not_found (htab_create_alloc (10, htab_hash_pointer
,
4776 NULL
, xcalloc
, xfree
));
4778 /* The rule is CUs specify all the files, including those used by
4779 any TU, so there's no need to scan TUs here. */
4781 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
4785 per_cu
->v
.quick
->mark
= 0;
4787 /* We only need to look at symtabs not already expanded. */
4788 if (per_objfile
->symtab_set_p (per_cu
))
4791 quick_file_names
*file_data
= dw2_get_file_names (per_cu
, per_objfile
);
4792 if (file_data
== NULL
)
4795 if (htab_find (visited_not_found
.get (), file_data
) != NULL
)
4797 else if (htab_find (visited_found
.get (), file_data
) != NULL
)
4799 per_cu
->v
.quick
->mark
= 1;
4803 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
4805 const char *this_real_name
;
4807 if (file_matcher (file_data
->file_names
[j
], false))
4809 per_cu
->v
.quick
->mark
= 1;
4813 /* Before we invoke realpath, which can get expensive when many
4814 files are involved, do a quick comparison of the basenames. */
4815 if (!basenames_may_differ
4816 && !file_matcher (lbasename (file_data
->file_names
[j
]),
4820 this_real_name
= dw2_get_real_path (per_objfile
, file_data
, j
);
4821 if (file_matcher (this_real_name
, false))
4823 per_cu
->v
.quick
->mark
= 1;
4828 void **slot
= htab_find_slot (per_cu
->v
.quick
->mark
4829 ? visited_found
.get ()
4830 : visited_not_found
.get (),
4837 dw2_expand_symtabs_matching
4838 (struct objfile
*objfile
,
4839 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
4840 const lookup_name_info
*lookup_name
,
4841 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
4842 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
4843 enum search_domain kind
)
4845 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
4847 /* index_table is NULL if OBJF_READNOW. */
4848 if (!per_objfile
->per_bfd
->index_table
)
4851 dw_expand_symtabs_matching_file_matcher (per_objfile
, file_matcher
);
4853 if (symbol_matcher
== NULL
&& lookup_name
== NULL
)
4855 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
4859 dw2_expand_symtabs_matching_one (per_cu
, per_objfile
,
4860 file_matcher
, expansion_notify
);
4865 mapped_index
&index
= *per_objfile
->per_bfd
->index_table
;
4867 dw2_expand_symtabs_matching_symbol (index
, *lookup_name
,
4869 kind
, [&] (offset_type idx
)
4871 dw2_expand_marked_cus (per_objfile
, idx
, file_matcher
, expansion_notify
,
4878 dwarf2_gdb_index::expand_symtabs_matching
4879 (struct objfile
*objfile
,
4880 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
4881 const lookup_name_info
*lookup_name
,
4882 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
4883 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
4884 enum search_domain kind
)
4886 dw2_expand_symtabs_matching (objfile
, file_matcher
, lookup_name
,
4887 symbol_matcher
, expansion_notify
, kind
);
4890 /* A helper for dw2_find_pc_sect_compunit_symtab which finds the most specific
4893 static struct compunit_symtab
*
4894 recursively_find_pc_sect_compunit_symtab (struct compunit_symtab
*cust
,
4899 if (COMPUNIT_BLOCKVECTOR (cust
) != NULL
4900 && blockvector_contains_pc (COMPUNIT_BLOCKVECTOR (cust
), pc
))
4903 if (cust
->includes
== NULL
)
4906 for (i
= 0; cust
->includes
[i
]; ++i
)
4908 struct compunit_symtab
*s
= cust
->includes
[i
];
4910 s
= recursively_find_pc_sect_compunit_symtab (s
, pc
);
4918 struct compunit_symtab
*
4919 dwarf2_base_index_functions::find_pc_sect_compunit_symtab
4920 (struct objfile
*objfile
,
4921 struct bound_minimal_symbol msymbol
,
4923 struct obj_section
*section
,
4926 struct dwarf2_per_cu_data
*data
;
4927 struct compunit_symtab
*result
;
4929 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
4930 if (per_objfile
->per_bfd
->index_addrmap
== nullptr)
4933 CORE_ADDR baseaddr
= objfile
->text_section_offset ();
4934 data
= ((struct dwarf2_per_cu_data
*)
4935 addrmap_find (per_objfile
->per_bfd
->index_addrmap
,
4940 if (warn_if_readin
&& per_objfile
->symtab_set_p (data
))
4941 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
4942 paddress (objfile
->arch (), pc
));
4944 result
= recursively_find_pc_sect_compunit_symtab
4945 (dw2_instantiate_symtab (data
, per_objfile
, false), pc
);
4947 gdb_assert (result
!= NULL
);
4952 dwarf2_base_index_functions::map_symbol_filenames (struct objfile
*objfile
,
4953 symbol_filename_ftype
*fun
,
4957 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
4959 if (!per_objfile
->per_bfd
->filenames_cache
)
4961 per_objfile
->per_bfd
->filenames_cache
.emplace ();
4963 htab_up
visited (htab_create_alloc (10,
4964 htab_hash_pointer
, htab_eq_pointer
,
4965 NULL
, xcalloc
, xfree
));
4967 /* The rule is CUs specify all the files, including those used
4968 by any TU, so there's no need to scan TUs here. We can
4969 ignore file names coming from already-expanded CUs. */
4971 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
4973 if (per_objfile
->symtab_set_p (per_cu
))
4975 void **slot
= htab_find_slot (visited
.get (),
4976 per_cu
->v
.quick
->file_names
,
4979 *slot
= per_cu
->v
.quick
->file_names
;
4983 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
4985 /* We only need to look at symtabs not already expanded. */
4986 if (per_objfile
->symtab_set_p (per_cu
))
4989 quick_file_names
*file_data
4990 = dw2_get_file_names (per_cu
, per_objfile
);
4991 if (file_data
== NULL
)
4994 void **slot
= htab_find_slot (visited
.get (), file_data
, INSERT
);
4997 /* Already visited. */
5002 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
5004 const char *filename
= file_data
->file_names
[j
];
5005 per_objfile
->per_bfd
->filenames_cache
->seen (filename
);
5010 per_objfile
->per_bfd
->filenames_cache
->traverse ([&] (const char *filename
)
5012 gdb::unique_xmalloc_ptr
<char> this_real_name
;
5015 this_real_name
= gdb_realpath (filename
);
5016 (*fun
) (filename
, this_real_name
.get (), data
);
5021 dwarf2_base_index_functions::has_symbols (struct objfile
*objfile
)
5026 /* DWARF-5 debug_names reader. */
5028 /* DWARF-5 augmentation string for GDB's DW_IDX_GNU_* extension. */
5029 static const gdb_byte dwarf5_augmentation
[] = { 'G', 'D', 'B', 0 };
5031 /* A helper function that reads the .debug_names section in SECTION
5032 and fills in MAP. FILENAME is the name of the file containing the
5033 section; it is used for error reporting.
5035 Returns true if all went well, false otherwise. */
5038 read_debug_names_from_section (struct objfile
*objfile
,
5039 const char *filename
,
5040 struct dwarf2_section_info
*section
,
5041 mapped_debug_names
&map
)
5043 if (section
->empty ())
5046 /* Older elfutils strip versions could keep the section in the main
5047 executable while splitting it for the separate debug info file. */
5048 if ((section
->get_flags () & SEC_HAS_CONTENTS
) == 0)
5051 section
->read (objfile
);
5053 map
.dwarf5_byte_order
= gdbarch_byte_order (objfile
->arch ());
5055 const gdb_byte
*addr
= section
->buffer
;
5057 bfd
*const abfd
= section
->get_bfd_owner ();
5059 unsigned int bytes_read
;
5060 LONGEST length
= read_initial_length (abfd
, addr
, &bytes_read
);
5063 map
.dwarf5_is_dwarf64
= bytes_read
!= 4;
5064 map
.offset_size
= map
.dwarf5_is_dwarf64
? 8 : 4;
5065 if (bytes_read
+ length
!= section
->size
)
5067 /* There may be multiple per-CU indices. */
5068 warning (_("Section .debug_names in %s length %s does not match "
5069 "section length %s, ignoring .debug_names."),
5070 filename
, plongest (bytes_read
+ length
),
5071 pulongest (section
->size
));
5075 /* The version number. */
5076 uint16_t version
= read_2_bytes (abfd
, addr
);
5080 warning (_("Section .debug_names in %s has unsupported version %d, "
5081 "ignoring .debug_names."),
5087 uint16_t padding
= read_2_bytes (abfd
, addr
);
5091 warning (_("Section .debug_names in %s has unsupported padding %d, "
5092 "ignoring .debug_names."),
5097 /* comp_unit_count - The number of CUs in the CU list. */
5098 map
.cu_count
= read_4_bytes (abfd
, addr
);
5101 /* local_type_unit_count - The number of TUs in the local TU
5103 map
.tu_count
= read_4_bytes (abfd
, addr
);
5106 /* foreign_type_unit_count - The number of TUs in the foreign TU
5108 uint32_t foreign_tu_count
= read_4_bytes (abfd
, addr
);
5110 if (foreign_tu_count
!= 0)
5112 warning (_("Section .debug_names in %s has unsupported %lu foreign TUs, "
5113 "ignoring .debug_names."),
5114 filename
, static_cast<unsigned long> (foreign_tu_count
));
5118 /* bucket_count - The number of hash buckets in the hash lookup
5120 map
.bucket_count
= read_4_bytes (abfd
, addr
);
5123 /* name_count - The number of unique names in the index. */
5124 map
.name_count
= read_4_bytes (abfd
, addr
);
5127 /* abbrev_table_size - The size in bytes of the abbreviations
5129 uint32_t abbrev_table_size
= read_4_bytes (abfd
, addr
);
5132 /* augmentation_string_size - The size in bytes of the augmentation
5133 string. This value is rounded up to a multiple of 4. */
5134 uint32_t augmentation_string_size
= read_4_bytes (abfd
, addr
);
5136 map
.augmentation_is_gdb
= ((augmentation_string_size
5137 == sizeof (dwarf5_augmentation
))
5138 && memcmp (addr
, dwarf5_augmentation
,
5139 sizeof (dwarf5_augmentation
)) == 0);
5140 augmentation_string_size
+= (-augmentation_string_size
) & 3;
5141 addr
+= augmentation_string_size
;
5144 map
.cu_table_reordered
= addr
;
5145 addr
+= map
.cu_count
* map
.offset_size
;
5147 /* List of Local TUs */
5148 map
.tu_table_reordered
= addr
;
5149 addr
+= map
.tu_count
* map
.offset_size
;
5151 /* Hash Lookup Table */
5152 map
.bucket_table_reordered
= reinterpret_cast<const uint32_t *> (addr
);
5153 addr
+= map
.bucket_count
* 4;
5154 map
.hash_table_reordered
= reinterpret_cast<const uint32_t *> (addr
);
5155 addr
+= map
.name_count
* 4;
5158 map
.name_table_string_offs_reordered
= addr
;
5159 addr
+= map
.name_count
* map
.offset_size
;
5160 map
.name_table_entry_offs_reordered
= addr
;
5161 addr
+= map
.name_count
* map
.offset_size
;
5163 const gdb_byte
*abbrev_table_start
= addr
;
5166 const ULONGEST index_num
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
5171 const auto insertpair
5172 = map
.abbrev_map
.emplace (index_num
, mapped_debug_names::index_val ());
5173 if (!insertpair
.second
)
5175 warning (_("Section .debug_names in %s has duplicate index %s, "
5176 "ignoring .debug_names."),
5177 filename
, pulongest (index_num
));
5180 mapped_debug_names::index_val
&indexval
= insertpair
.first
->second
;
5181 indexval
.dwarf_tag
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
5186 mapped_debug_names::index_val::attr attr
;
5187 attr
.dw_idx
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
5189 attr
.form
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
5191 if (attr
.form
== DW_FORM_implicit_const
)
5193 attr
.implicit_const
= read_signed_leb128 (abfd
, addr
,
5197 if (attr
.dw_idx
== 0 && attr
.form
== 0)
5199 indexval
.attr_vec
.push_back (std::move (attr
));
5202 if (addr
!= abbrev_table_start
+ abbrev_table_size
)
5204 warning (_("Section .debug_names in %s has abbreviation_table "
5205 "of size %s vs. written as %u, ignoring .debug_names."),
5206 filename
, plongest (addr
- abbrev_table_start
),
5210 map
.entry_pool
= addr
;
5215 /* A helper for create_cus_from_debug_names that handles the MAP's CU
5219 create_cus_from_debug_names_list (dwarf2_per_bfd
*per_bfd
,
5220 const mapped_debug_names
&map
,
5221 dwarf2_section_info
§ion
,
5224 if (!map
.augmentation_is_gdb
)
5226 for (uint32_t i
= 0; i
< map
.cu_count
; ++i
)
5228 sect_offset sect_off
5229 = (sect_offset
) (extract_unsigned_integer
5230 (map
.cu_table_reordered
+ i
* map
.offset_size
,
5232 map
.dwarf5_byte_order
));
5233 /* We don't know the length of the CU, because the CU list in a
5234 .debug_names index can be incomplete, so we can't use the start
5235 of the next CU as end of this CU. We create the CUs here with
5236 length 0, and in cutu_reader::cutu_reader we'll fill in the
5238 dwarf2_per_cu_data
*per_cu
5239 = create_cu_from_index_list (per_bfd
, §ion
, is_dwz
,
5241 per_bfd
->all_comp_units
.push_back (per_cu
);
5246 sect_offset sect_off_prev
;
5247 for (uint32_t i
= 0; i
<= map
.cu_count
; ++i
)
5249 sect_offset sect_off_next
;
5250 if (i
< map
.cu_count
)
5253 = (sect_offset
) (extract_unsigned_integer
5254 (map
.cu_table_reordered
+ i
* map
.offset_size
,
5256 map
.dwarf5_byte_order
));
5259 sect_off_next
= (sect_offset
) section
.size
;
5262 const ULONGEST length
= sect_off_next
- sect_off_prev
;
5263 dwarf2_per_cu_data
*per_cu
5264 = create_cu_from_index_list (per_bfd
, §ion
, is_dwz
,
5265 sect_off_prev
, length
);
5266 per_bfd
->all_comp_units
.push_back (per_cu
);
5268 sect_off_prev
= sect_off_next
;
5272 /* Read the CU list from the mapped index, and use it to create all
5273 the CU objects for this dwarf2_per_objfile. */
5276 create_cus_from_debug_names (dwarf2_per_bfd
*per_bfd
,
5277 const mapped_debug_names
&map
,
5278 const mapped_debug_names
&dwz_map
)
5280 gdb_assert (per_bfd
->all_comp_units
.empty ());
5281 per_bfd
->all_comp_units
.reserve (map
.cu_count
+ dwz_map
.cu_count
);
5283 create_cus_from_debug_names_list (per_bfd
, map
, per_bfd
->info
,
5284 false /* is_dwz */);
5286 if (dwz_map
.cu_count
== 0)
5289 dwz_file
*dwz
= dwarf2_get_dwz_file (per_bfd
);
5290 create_cus_from_debug_names_list (per_bfd
, dwz_map
, dwz
->info
,
5294 /* Read .debug_names. If everything went ok, initialize the "quick"
5295 elements of all the CUs and return true. Otherwise, return false. */
5298 dwarf2_read_debug_names (dwarf2_per_objfile
*per_objfile
)
5300 std::unique_ptr
<mapped_debug_names
> map (new mapped_debug_names
);
5301 mapped_debug_names dwz_map
;
5302 struct objfile
*objfile
= per_objfile
->objfile
;
5303 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
5305 if (!read_debug_names_from_section (objfile
, objfile_name (objfile
),
5306 &per_objfile
->per_bfd
->debug_names
, *map
))
5309 /* Don't use the index if it's empty. */
5310 if (map
->name_count
== 0)
5313 /* If there is a .dwz file, read it so we can get its CU list as
5315 dwz_file
*dwz
= dwarf2_get_dwz_file (per_bfd
);
5318 if (!read_debug_names_from_section (objfile
,
5319 bfd_get_filename (dwz
->dwz_bfd
.get ()),
5320 &dwz
->debug_names
, dwz_map
))
5322 warning (_("could not read '.debug_names' section from %s; skipping"),
5323 bfd_get_filename (dwz
->dwz_bfd
.get ()));
5328 create_cus_from_debug_names (per_bfd
, *map
, dwz_map
);
5330 if (map
->tu_count
!= 0)
5332 /* We can only handle a single .debug_types when we have an
5334 if (per_bfd
->types
.size () != 1)
5337 dwarf2_section_info
*section
= &per_bfd
->types
[0];
5339 create_signatured_type_table_from_debug_names
5340 (per_objfile
, *map
, section
, &per_bfd
->abbrev
);
5343 create_addrmap_from_aranges (per_objfile
, &per_bfd
->debug_aranges
);
5345 per_bfd
->debug_names_table
= std::move (map
);
5346 per_bfd
->using_index
= 1;
5347 per_bfd
->quick_file_names_table
=
5348 create_quick_file_names_table (per_objfile
->per_bfd
->all_comp_units
.size ());
5353 /* Type used to manage iterating over all CUs looking for a symbol for
5356 class dw2_debug_names_iterator
5359 dw2_debug_names_iterator (const mapped_debug_names
&map
,
5360 gdb::optional
<block_enum
> block_index
,
5362 const char *name
, dwarf2_per_objfile
*per_objfile
)
5363 : m_map (map
), m_block_index (block_index
), m_domain (domain
),
5364 m_addr (find_vec_in_debug_names (map
, name
, per_objfile
)),
5365 m_per_objfile (per_objfile
)
5368 dw2_debug_names_iterator (const mapped_debug_names
&map
,
5369 search_domain search
, uint32_t namei
, dwarf2_per_objfile
*per_objfile
)
5372 m_addr (find_vec_in_debug_names (map
, namei
, per_objfile
)),
5373 m_per_objfile (per_objfile
)
5376 dw2_debug_names_iterator (const mapped_debug_names
&map
,
5377 block_enum block_index
, domain_enum domain
,
5378 uint32_t namei
, dwarf2_per_objfile
*per_objfile
)
5379 : m_map (map
), m_block_index (block_index
), m_domain (domain
),
5380 m_addr (find_vec_in_debug_names (map
, namei
, per_objfile
)),
5381 m_per_objfile (per_objfile
)
5384 /* Return the next matching CU or NULL if there are no more. */
5385 dwarf2_per_cu_data
*next ();
5388 static const gdb_byte
*find_vec_in_debug_names (const mapped_debug_names
&map
,
5390 dwarf2_per_objfile
*per_objfile
);
5391 static const gdb_byte
*find_vec_in_debug_names (const mapped_debug_names
&map
,
5393 dwarf2_per_objfile
*per_objfile
);
5395 /* The internalized form of .debug_names. */
5396 const mapped_debug_names
&m_map
;
5398 /* If set, only look for symbols that match that block. Valid values are
5399 GLOBAL_BLOCK and STATIC_BLOCK. */
5400 const gdb::optional
<block_enum
> m_block_index
;
5402 /* The kind of symbol we're looking for. */
5403 const domain_enum m_domain
= UNDEF_DOMAIN
;
5404 const search_domain m_search
= ALL_DOMAIN
;
5406 /* The list of CUs from the index entry of the symbol, or NULL if
5408 const gdb_byte
*m_addr
;
5410 dwarf2_per_objfile
*m_per_objfile
;
5414 mapped_debug_names::namei_to_name
5415 (uint32_t namei
, dwarf2_per_objfile
*per_objfile
) const
5417 const ULONGEST namei_string_offs
5418 = extract_unsigned_integer ((name_table_string_offs_reordered
5419 + namei
* offset_size
),
5422 return read_indirect_string_at_offset (per_objfile
, namei_string_offs
);
5425 /* Find a slot in .debug_names for the object named NAME. If NAME is
5426 found, return pointer to its pool data. If NAME cannot be found,
5430 dw2_debug_names_iterator::find_vec_in_debug_names
5431 (const mapped_debug_names
&map
, const char *name
,
5432 dwarf2_per_objfile
*per_objfile
)
5434 int (*cmp
) (const char *, const char *);
5436 gdb::unique_xmalloc_ptr
<char> without_params
;
5437 if (current_language
->la_language
== language_cplus
5438 || current_language
->la_language
== language_fortran
5439 || current_language
->la_language
== language_d
)
5441 /* NAME is already canonical. Drop any qualifiers as
5442 .debug_names does not contain any. */
5444 if (strchr (name
, '(') != NULL
)
5446 without_params
= cp_remove_params (name
);
5447 if (without_params
!= NULL
)
5448 name
= without_params
.get ();
5452 cmp
= (case_sensitivity
== case_sensitive_on
? strcmp
: strcasecmp
);
5454 const uint32_t full_hash
= dwarf5_djb_hash (name
);
5456 = extract_unsigned_integer (reinterpret_cast<const gdb_byte
*>
5457 (map
.bucket_table_reordered
5458 + (full_hash
% map
.bucket_count
)), 4,
5459 map
.dwarf5_byte_order
);
5463 if (namei
>= map
.name_count
)
5465 complaint (_("Wrong .debug_names with name index %u but name_count=%u "
5467 namei
, map
.name_count
,
5468 objfile_name (per_objfile
->objfile
));
5474 const uint32_t namei_full_hash
5475 = extract_unsigned_integer (reinterpret_cast<const gdb_byte
*>
5476 (map
.hash_table_reordered
+ namei
), 4,
5477 map
.dwarf5_byte_order
);
5478 if (full_hash
% map
.bucket_count
!= namei_full_hash
% map
.bucket_count
)
5481 if (full_hash
== namei_full_hash
)
5483 const char *const namei_string
= map
.namei_to_name (namei
, per_objfile
);
5485 #if 0 /* An expensive sanity check. */
5486 if (namei_full_hash
!= dwarf5_djb_hash (namei_string
))
5488 complaint (_("Wrong .debug_names hash for string at index %u "
5490 namei
, objfile_name (dwarf2_per_objfile
->objfile
));
5495 if (cmp (namei_string
, name
) == 0)
5497 const ULONGEST namei_entry_offs
5498 = extract_unsigned_integer ((map
.name_table_entry_offs_reordered
5499 + namei
* map
.offset_size
),
5500 map
.offset_size
, map
.dwarf5_byte_order
);
5501 return map
.entry_pool
+ namei_entry_offs
;
5506 if (namei
>= map
.name_count
)
5512 dw2_debug_names_iterator::find_vec_in_debug_names
5513 (const mapped_debug_names
&map
, uint32_t namei
, dwarf2_per_objfile
*per_objfile
)
5515 if (namei
>= map
.name_count
)
5517 complaint (_("Wrong .debug_names with name index %u but name_count=%u "
5519 namei
, map
.name_count
,
5520 objfile_name (per_objfile
->objfile
));
5524 const ULONGEST namei_entry_offs
5525 = extract_unsigned_integer ((map
.name_table_entry_offs_reordered
5526 + namei
* map
.offset_size
),
5527 map
.offset_size
, map
.dwarf5_byte_order
);
5528 return map
.entry_pool
+ namei_entry_offs
;
5531 /* See dw2_debug_names_iterator. */
5533 dwarf2_per_cu_data
*
5534 dw2_debug_names_iterator::next ()
5539 dwarf2_per_bfd
*per_bfd
= m_per_objfile
->per_bfd
;
5540 struct objfile
*objfile
= m_per_objfile
->objfile
;
5541 bfd
*const abfd
= objfile
->obfd
;
5545 unsigned int bytes_read
;
5546 const ULONGEST abbrev
= read_unsigned_leb128 (abfd
, m_addr
, &bytes_read
);
5547 m_addr
+= bytes_read
;
5551 const auto indexval_it
= m_map
.abbrev_map
.find (abbrev
);
5552 if (indexval_it
== m_map
.abbrev_map
.cend ())
5554 complaint (_("Wrong .debug_names undefined abbrev code %s "
5556 pulongest (abbrev
), objfile_name (objfile
));
5559 const mapped_debug_names::index_val
&indexval
= indexval_it
->second
;
5560 enum class symbol_linkage
{
5564 } symbol_linkage_
= symbol_linkage::unknown
;
5565 dwarf2_per_cu_data
*per_cu
= NULL
;
5566 for (const mapped_debug_names::index_val::attr
&attr
: indexval
.attr_vec
)
5571 case DW_FORM_implicit_const
:
5572 ull
= attr
.implicit_const
;
5574 case DW_FORM_flag_present
:
5578 ull
= read_unsigned_leb128 (abfd
, m_addr
, &bytes_read
);
5579 m_addr
+= bytes_read
;
5582 ull
= read_4_bytes (abfd
, m_addr
);
5586 ull
= read_8_bytes (abfd
, m_addr
);
5589 case DW_FORM_ref_sig8
:
5590 ull
= read_8_bytes (abfd
, m_addr
);
5594 complaint (_("Unsupported .debug_names form %s [in module %s]"),
5595 dwarf_form_name (attr
.form
),
5596 objfile_name (objfile
));
5599 switch (attr
.dw_idx
)
5601 case DW_IDX_compile_unit
:
5602 /* Don't crash on bad data. */
5603 if (ull
>= m_per_objfile
->per_bfd
->all_comp_units
.size ())
5605 complaint (_(".debug_names entry has bad CU index %s"
5608 objfile_name (objfile
));
5611 per_cu
= per_bfd
->get_cutu (ull
);
5613 case DW_IDX_type_unit
:
5614 /* Don't crash on bad data. */
5615 if (ull
>= per_bfd
->all_type_units
.size ())
5617 complaint (_(".debug_names entry has bad TU index %s"
5620 objfile_name (objfile
));
5623 per_cu
= &per_bfd
->get_tu (ull
)->per_cu
;
5625 case DW_IDX_die_offset
:
5626 /* In a per-CU index (as opposed to a per-module index), index
5627 entries without CU attribute implicitly refer to the single CU. */
5629 per_cu
= per_bfd
->get_cu (0);
5631 case DW_IDX_GNU_internal
:
5632 if (!m_map
.augmentation_is_gdb
)
5634 symbol_linkage_
= symbol_linkage::static_
;
5636 case DW_IDX_GNU_external
:
5637 if (!m_map
.augmentation_is_gdb
)
5639 symbol_linkage_
= symbol_linkage::extern_
;
5644 /* Skip if already read in. */
5645 if (m_per_objfile
->symtab_set_p (per_cu
))
5648 /* Check static vs global. */
5649 if (symbol_linkage_
!= symbol_linkage::unknown
&& m_block_index
.has_value ())
5651 const bool want_static
= *m_block_index
== STATIC_BLOCK
;
5652 const bool symbol_is_static
=
5653 symbol_linkage_
== symbol_linkage::static_
;
5654 if (want_static
!= symbol_is_static
)
5658 /* Match dw2_symtab_iter_next, symbol_kind
5659 and debug_names::psymbol_tag. */
5663 switch (indexval
.dwarf_tag
)
5665 case DW_TAG_variable
:
5666 case DW_TAG_subprogram
:
5667 /* Some types are also in VAR_DOMAIN. */
5668 case DW_TAG_typedef
:
5669 case DW_TAG_structure_type
:
5676 switch (indexval
.dwarf_tag
)
5678 case DW_TAG_typedef
:
5679 case DW_TAG_structure_type
:
5686 switch (indexval
.dwarf_tag
)
5689 case DW_TAG_variable
:
5696 switch (indexval
.dwarf_tag
)
5708 /* Match dw2_expand_symtabs_matching, symbol_kind and
5709 debug_names::psymbol_tag. */
5712 case VARIABLES_DOMAIN
:
5713 switch (indexval
.dwarf_tag
)
5715 case DW_TAG_variable
:
5721 case FUNCTIONS_DOMAIN
:
5722 switch (indexval
.dwarf_tag
)
5724 case DW_TAG_subprogram
:
5731 switch (indexval
.dwarf_tag
)
5733 case DW_TAG_typedef
:
5734 case DW_TAG_structure_type
:
5740 case MODULES_DOMAIN
:
5741 switch (indexval
.dwarf_tag
)
5755 struct compunit_symtab
*
5756 dwarf2_debug_names_index::lookup_symbol
5757 (struct objfile
*objfile
, block_enum block_index
,
5758 const char *name
, domain_enum domain
)
5760 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
5762 const auto &mapp
= per_objfile
->per_bfd
->debug_names_table
;
5765 /* index is NULL if OBJF_READNOW. */
5768 const auto &map
= *mapp
;
5770 dw2_debug_names_iterator
iter (map
, block_index
, domain
, name
, per_objfile
);
5772 struct compunit_symtab
*stab_best
= NULL
;
5773 struct dwarf2_per_cu_data
*per_cu
;
5774 while ((per_cu
= iter
.next ()) != NULL
)
5776 struct symbol
*sym
, *with_opaque
= NULL
;
5777 compunit_symtab
*stab
5778 = dw2_instantiate_symtab (per_cu
, per_objfile
, false);
5779 const struct blockvector
*bv
= COMPUNIT_BLOCKVECTOR (stab
);
5780 const struct block
*block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
5782 sym
= block_find_symbol (block
, name
, domain
,
5783 block_find_non_opaque_type_preferred
,
5786 /* Some caution must be observed with overloaded functions and
5787 methods, since the index will not contain any overload
5788 information (but NAME might contain it). */
5791 && strcmp_iw (sym
->search_name (), name
) == 0)
5793 if (with_opaque
!= NULL
5794 && strcmp_iw (with_opaque
->search_name (), name
) == 0)
5797 /* Keep looking through other CUs. */
5803 /* This dumps minimal information about .debug_names. It is called
5804 via "mt print objfiles". The gdb.dwarf2/gdb-index.exp testcase
5805 uses this to verify that .debug_names has been loaded. */
5808 dwarf2_debug_names_index::dump (struct objfile
*objfile
)
5810 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
5812 gdb_assert (per_objfile
->per_bfd
->using_index
);
5813 printf_filtered (".debug_names:");
5814 if (per_objfile
->per_bfd
->debug_names_table
)
5815 printf_filtered (" exists\n");
5817 printf_filtered (" faked for \"readnow\"\n");
5818 printf_filtered ("\n");
5822 dwarf2_debug_names_index::expand_symtabs_for_function
5823 (struct objfile
*objfile
, const char *func_name
)
5825 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
5827 /* per_objfile->per_bfd->debug_names_table is NULL if OBJF_READNOW. */
5828 if (per_objfile
->per_bfd
->debug_names_table
)
5830 const mapped_debug_names
&map
= *per_objfile
->per_bfd
->debug_names_table
;
5832 dw2_debug_names_iterator
iter (map
, {}, VAR_DOMAIN
, func_name
,
5835 struct dwarf2_per_cu_data
*per_cu
;
5836 while ((per_cu
= iter
.next ()) != NULL
)
5837 dw2_instantiate_symtab (per_cu
, per_objfile
, false);
5842 dwarf2_debug_names_index::map_matching_symbols
5843 (struct objfile
*objfile
,
5844 const lookup_name_info
&name
, domain_enum domain
,
5846 gdb::function_view
<symbol_found_callback_ftype
> callback
,
5847 symbol_compare_ftype
*ordered_compare
)
5849 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
5851 /* debug_names_table is NULL if OBJF_READNOW. */
5852 if (!per_objfile
->per_bfd
->debug_names_table
)
5855 mapped_debug_names
&map
= *per_objfile
->per_bfd
->debug_names_table
;
5856 const block_enum block_kind
= global
? GLOBAL_BLOCK
: STATIC_BLOCK
;
5858 const char *match_name
= name
.ada ().lookup_name ().c_str ();
5859 auto matcher
= [&] (const char *symname
)
5861 if (ordered_compare
== nullptr)
5863 return ordered_compare (symname
, match_name
) == 0;
5866 dw2_expand_symtabs_matching_symbol (map
, name
, matcher
, ALL_DOMAIN
,
5867 [&] (offset_type namei
)
5869 /* The name was matched, now expand corresponding CUs that were
5871 dw2_debug_names_iterator
iter (map
, block_kind
, domain
, namei
,
5874 struct dwarf2_per_cu_data
*per_cu
;
5875 while ((per_cu
= iter
.next ()) != NULL
)
5876 dw2_expand_symtabs_matching_one (per_cu
, per_objfile
, nullptr,
5881 /* It's a shame we couldn't do this inside the
5882 dw2_expand_symtabs_matching_symbol callback, but that skips CUs
5883 that have already been expanded. Instead, this loop matches what
5884 the psymtab code does. */
5885 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
5887 compunit_symtab
*symtab
= per_objfile
->get_symtab (per_cu
);
5888 if (symtab
!= nullptr)
5890 const struct block
*block
5891 = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (symtab
), block_kind
);
5892 if (!iterate_over_symbols_terminated (block
, name
,
5900 dwarf2_debug_names_index::expand_symtabs_matching
5901 (struct objfile
*objfile
,
5902 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
5903 const lookup_name_info
*lookup_name
,
5904 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
5905 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
5906 enum search_domain kind
)
5908 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
5910 /* debug_names_table is NULL if OBJF_READNOW. */
5911 if (!per_objfile
->per_bfd
->debug_names_table
)
5914 dw_expand_symtabs_matching_file_matcher (per_objfile
, file_matcher
);
5916 if (symbol_matcher
== NULL
&& lookup_name
== NULL
)
5918 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
5922 dw2_expand_symtabs_matching_one (per_cu
, per_objfile
, file_matcher
,
5928 mapped_debug_names
&map
= *per_objfile
->per_bfd
->debug_names_table
;
5930 dw2_expand_symtabs_matching_symbol (map
, *lookup_name
,
5932 kind
, [&] (offset_type namei
)
5934 /* The name was matched, now expand corresponding CUs that were
5936 dw2_debug_names_iterator
iter (map
, kind
, namei
, per_objfile
);
5938 struct dwarf2_per_cu_data
*per_cu
;
5939 while ((per_cu
= iter
.next ()) != NULL
)
5940 dw2_expand_symtabs_matching_one (per_cu
, per_objfile
, file_matcher
,
5946 /* Get the content of the .gdb_index section of OBJ. SECTION_OWNER should point
5947 to either a dwarf2_per_bfd or dwz_file object. */
5949 template <typename T
>
5950 static gdb::array_view
<const gdb_byte
>
5951 get_gdb_index_contents_from_section (objfile
*obj
, T
*section_owner
)
5953 dwarf2_section_info
*section
= §ion_owner
->gdb_index
;
5955 if (section
->empty ())
5958 /* Older elfutils strip versions could keep the section in the main
5959 executable while splitting it for the separate debug info file. */
5960 if ((section
->get_flags () & SEC_HAS_CONTENTS
) == 0)
5963 section
->read (obj
);
5965 /* dwarf2_section_info::size is a bfd_size_type, while
5966 gdb::array_view works with size_t. On 32-bit hosts, with
5967 --enable-64-bit-bfd, bfd_size_type is a 64-bit type, while size_t
5968 is 32-bit. So we need an explicit narrowing conversion here.
5969 This is fine, because it's impossible to allocate or mmap an
5970 array/buffer larger than what size_t can represent. */
5971 return gdb::make_array_view (section
->buffer
, section
->size
);
5974 /* Lookup the index cache for the contents of the index associated to
5977 static gdb::array_view
<const gdb_byte
>
5978 get_gdb_index_contents_from_cache (objfile
*obj
, dwarf2_per_bfd
*dwarf2_per_bfd
)
5980 const bfd_build_id
*build_id
= build_id_bfd_get (obj
->obfd
);
5981 if (build_id
== nullptr)
5984 return global_index_cache
.lookup_gdb_index (build_id
,
5985 &dwarf2_per_bfd
->index_cache_res
);
5988 /* Same as the above, but for DWZ. */
5990 static gdb::array_view
<const gdb_byte
>
5991 get_gdb_index_contents_from_cache_dwz (objfile
*obj
, dwz_file
*dwz
)
5993 const bfd_build_id
*build_id
= build_id_bfd_get (dwz
->dwz_bfd
.get ());
5994 if (build_id
== nullptr)
5997 return global_index_cache
.lookup_gdb_index (build_id
, &dwz
->index_cache_res
);
6000 /* See symfile.h. */
6003 dwarf2_initialize_objfile (struct objfile
*objfile
, dw_index_kind
*index_kind
)
6005 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
6006 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
6008 dwarf_read_debug_printf ("called");
6010 /* If we're about to read full symbols, don't bother with the
6011 indices. In this case we also don't care if some other debug
6012 format is making psymtabs, because they are all about to be
6014 if ((objfile
->flags
& OBJF_READNOW
))
6016 dwarf_read_debug_printf ("readnow requested");
6018 /* When using READNOW, the using_index flag (set below) indicates that
6019 PER_BFD was already initialized, when we loaded some other objfile. */
6020 if (per_bfd
->using_index
)
6022 dwarf_read_debug_printf ("using_index already set");
6023 *index_kind
= dw_index_kind::GDB_INDEX
;
6024 per_objfile
->resize_symtabs ();
6028 per_bfd
->using_index
= 1;
6029 create_all_comp_units (per_objfile
);
6030 create_all_type_units (per_objfile
);
6031 per_bfd
->quick_file_names_table
6032 = create_quick_file_names_table (per_bfd
->all_comp_units
.size ());
6033 per_objfile
->resize_symtabs ();
6035 for (int i
= 0; i
< (per_bfd
->all_comp_units
.size ()
6036 + per_bfd
->all_type_units
.size ()); ++i
)
6038 dwarf2_per_cu_data
*per_cu
= per_bfd
->get_cutu (i
);
6040 per_cu
->v
.quick
= OBSTACK_ZALLOC (&per_bfd
->obstack
,
6041 struct dwarf2_per_cu_quick_data
);
6044 /* Return 1 so that gdb sees the "quick" functions. However,
6045 these functions will be no-ops because we will have expanded
6047 *index_kind
= dw_index_kind::GDB_INDEX
;
6051 /* Was a debug names index already read when we processed an objfile sharing
6053 if (per_bfd
->debug_names_table
!= nullptr)
6055 dwarf_read_debug_printf ("re-using shared debug names table");
6056 *index_kind
= dw_index_kind::DEBUG_NAMES
;
6057 per_objfile
->resize_symtabs ();
6061 /* Was a GDB index already read when we processed an objfile sharing
6063 if (per_bfd
->index_table
!= nullptr)
6065 dwarf_read_debug_printf ("re-using shared index table");
6066 *index_kind
= dw_index_kind::GDB_INDEX
;
6067 per_objfile
->resize_symtabs ();
6071 /* There might already be partial symtabs built for this BFD. This happens
6072 when loading the same binary twice with the index-cache enabled. If so,
6073 don't try to read an index. The objfile / per_objfile initialization will
6074 be completed in dwarf2_build_psymtabs, in the standard partial symtabs
6076 if (per_bfd
->partial_symtabs
!= nullptr)
6078 dwarf_read_debug_printf ("re-using shared partial symtabs");
6082 if (dwarf2_read_debug_names (per_objfile
))
6084 dwarf_read_debug_printf ("found debug names");
6085 *index_kind
= dw_index_kind::DEBUG_NAMES
;
6086 per_objfile
->resize_symtabs ();
6090 if (dwarf2_read_gdb_index (per_objfile
,
6091 get_gdb_index_contents_from_section
<struct dwarf2_per_bfd
>,
6092 get_gdb_index_contents_from_section
<dwz_file
>))
6094 dwarf_read_debug_printf ("found gdb index from file");
6095 *index_kind
= dw_index_kind::GDB_INDEX
;
6096 per_objfile
->resize_symtabs ();
6100 /* ... otherwise, try to find the index in the index cache. */
6101 if (dwarf2_read_gdb_index (per_objfile
,
6102 get_gdb_index_contents_from_cache
,
6103 get_gdb_index_contents_from_cache_dwz
))
6105 dwarf_read_debug_printf ("found gdb index from cache");
6106 global_index_cache
.hit ();
6107 *index_kind
= dw_index_kind::GDB_INDEX
;
6108 per_objfile
->resize_symtabs ();
6112 global_index_cache
.miss ();
6118 /* Build a partial symbol table. */
6121 dwarf2_build_psymtabs (struct objfile
*objfile
)
6123 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
6124 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
6126 if (per_bfd
->partial_symtabs
!= nullptr)
6128 /* Partial symbols were already read, so now we can simply
6130 objfile
->partial_symtabs
= per_bfd
->partial_symtabs
;
6131 per_objfile
->resize_symtabs ();
6135 /* Set the local reference to partial symtabs, so that we don't try
6136 to read them again if reading another objfile with the same BFD.
6137 If we can't in fact share, this won't make a difference anyway as
6138 the dwarf2_per_bfd object won't be shared. */
6139 per_bfd
->partial_symtabs
= objfile
->partial_symtabs
;
6143 /* This isn't really ideal: all the data we allocate on the
6144 objfile's obstack is still uselessly kept around. However,
6145 freeing it seems unsafe. */
6146 psymtab_discarder
psymtabs (objfile
->partial_symtabs
.get ());
6147 dwarf2_build_psymtabs_hard (per_objfile
);
6150 per_objfile
->resize_symtabs ();
6152 /* (maybe) store an index in the cache. */
6153 global_index_cache
.store (per_objfile
);
6155 catch (const gdb_exception_error
&except
)
6157 exception_print (gdb_stderr
, except
);
6161 /* Find the base address of the compilation unit for range lists and
6162 location lists. It will normally be specified by DW_AT_low_pc.
6163 In DWARF-3 draft 4, the base address could be overridden by
6164 DW_AT_entry_pc. It's been removed, but GCC still uses this for
6165 compilation units with discontinuous ranges. */
6168 dwarf2_find_base_address (struct die_info
*die
, struct dwarf2_cu
*cu
)
6170 struct attribute
*attr
;
6172 cu
->base_address
.reset ();
6174 attr
= dwarf2_attr (die
, DW_AT_entry_pc
, cu
);
6175 if (attr
!= nullptr)
6176 cu
->base_address
= attr
->as_address ();
6179 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
6180 if (attr
!= nullptr)
6181 cu
->base_address
= attr
->as_address ();
6185 /* Helper function that returns the proper abbrev section for
6188 static struct dwarf2_section_info
*
6189 get_abbrev_section_for_cu (struct dwarf2_per_cu_data
*this_cu
)
6191 struct dwarf2_section_info
*abbrev
;
6192 dwarf2_per_bfd
*per_bfd
= this_cu
->per_bfd
;
6194 if (this_cu
->is_dwz
)
6195 abbrev
= &dwarf2_get_dwz_file (per_bfd
, true)->abbrev
;
6197 abbrev
= &per_bfd
->abbrev
;
6202 /* Fetch the abbreviation table offset from a comp or type unit header. */
6205 read_abbrev_offset (dwarf2_per_objfile
*per_objfile
,
6206 struct dwarf2_section_info
*section
,
6207 sect_offset sect_off
)
6209 bfd
*abfd
= section
->get_bfd_owner ();
6210 const gdb_byte
*info_ptr
;
6211 unsigned int initial_length_size
, offset_size
;
6214 section
->read (per_objfile
->objfile
);
6215 info_ptr
= section
->buffer
+ to_underlying (sect_off
);
6216 read_initial_length (abfd
, info_ptr
, &initial_length_size
);
6217 offset_size
= initial_length_size
== 4 ? 4 : 8;
6218 info_ptr
+= initial_length_size
;
6220 version
= read_2_bytes (abfd
, info_ptr
);
6224 /* Skip unit type and address size. */
6228 return (sect_offset
) read_offset (abfd
, info_ptr
, offset_size
);
6231 /* A partial symtab that is used only for include files. */
6232 struct dwarf2_include_psymtab
: public partial_symtab
6234 dwarf2_include_psymtab (const char *filename
, struct objfile
*objfile
)
6235 : partial_symtab (filename
, objfile
)
6239 void read_symtab (struct objfile
*objfile
) override
6241 /* It's an include file, no symbols to read for it.
6242 Everything is in the includer symtab. */
6244 /* The expansion of a dwarf2_include_psymtab is just a trigger for
6245 expansion of the includer psymtab. We use the dependencies[0] field to
6246 model the includer. But if we go the regular route of calling
6247 expand_psymtab here, and having expand_psymtab call expand_dependencies
6248 to expand the includer, we'll only use expand_psymtab on the includer
6249 (making it a non-toplevel psymtab), while if we expand the includer via
6250 another path, we'll use read_symtab (making it a toplevel psymtab).
6251 So, don't pretend a dwarf2_include_psymtab is an actual toplevel
6252 psymtab, and trigger read_symtab on the includer here directly. */
6253 includer ()->read_symtab (objfile
);
6256 void expand_psymtab (struct objfile
*objfile
) override
6258 /* This is not called by read_symtab, and should not be called by any
6259 expand_dependencies. */
6263 bool readin_p (struct objfile
*objfile
) const override
6265 return includer ()->readin_p (objfile
);
6268 compunit_symtab
*get_compunit_symtab (struct objfile
*objfile
) const override
6274 partial_symtab
*includer () const
6276 /* An include psymtab has exactly one dependency: the psymtab that
6278 gdb_assert (this->number_of_dependencies
== 1);
6279 return this->dependencies
[0];
6283 /* Allocate a new partial symtab for file named NAME and mark this new
6284 partial symtab as being an include of PST. */
6287 dwarf2_create_include_psymtab (const char *name
, dwarf2_psymtab
*pst
,
6288 struct objfile
*objfile
)
6290 dwarf2_include_psymtab
*subpst
= new dwarf2_include_psymtab (name
, objfile
);
6292 if (!IS_ABSOLUTE_PATH (subpst
->filename
))
6293 subpst
->dirname
= pst
->dirname
;
6295 subpst
->dependencies
= objfile
->partial_symtabs
->allocate_dependencies (1);
6296 subpst
->dependencies
[0] = pst
;
6297 subpst
->number_of_dependencies
= 1;
6300 /* Read the Line Number Program data and extract the list of files
6301 included by the source file represented by PST. Build an include
6302 partial symtab for each of these included files. */
6305 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
6306 struct die_info
*die
,
6307 dwarf2_psymtab
*pst
)
6310 struct attribute
*attr
;
6312 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
6313 if (attr
!= nullptr && attr
->form_is_unsigned ())
6314 lh
= dwarf_decode_line_header ((sect_offset
) attr
->as_unsigned (), cu
);
6316 return; /* No linetable, so no includes. */
6318 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). Also note
6319 that we pass in the raw text_low here; that is ok because we're
6320 only decoding the line table to make include partial symtabs, and
6321 so the addresses aren't really used. */
6322 dwarf_decode_lines (lh
.get (), pst
->dirname
, cu
, pst
,
6323 pst
->raw_text_low (), 1);
6327 hash_signatured_type (const void *item
)
6329 const struct signatured_type
*sig_type
6330 = (const struct signatured_type
*) item
;
6332 /* This drops the top 32 bits of the signature, but is ok for a hash. */
6333 return sig_type
->signature
;
6337 eq_signatured_type (const void *item_lhs
, const void *item_rhs
)
6339 const struct signatured_type
*lhs
= (const struct signatured_type
*) item_lhs
;
6340 const struct signatured_type
*rhs
= (const struct signatured_type
*) item_rhs
;
6342 return lhs
->signature
== rhs
->signature
;
6345 /* Allocate a hash table for signatured types. */
6348 allocate_signatured_type_table ()
6350 return htab_up (htab_create_alloc (41,
6351 hash_signatured_type
,
6353 NULL
, xcalloc
, xfree
));
6356 /* A helper function to add a signatured type CU to a table. */
6359 add_signatured_type_cu_to_table (void **slot
, void *datum
)
6361 struct signatured_type
*sigt
= (struct signatured_type
*) *slot
;
6362 std::vector
<signatured_type
*> *all_type_units
6363 = (std::vector
<signatured_type
*> *) datum
;
6365 all_type_units
->push_back (sigt
);
6370 /* A helper for create_debug_types_hash_table. Read types from SECTION
6371 and fill them into TYPES_HTAB. It will process only type units,
6372 therefore DW_UT_type. */
6375 create_debug_type_hash_table (dwarf2_per_objfile
*per_objfile
,
6376 struct dwo_file
*dwo_file
,
6377 dwarf2_section_info
*section
, htab_up
&types_htab
,
6378 rcuh_kind section_kind
)
6380 struct objfile
*objfile
= per_objfile
->objfile
;
6381 struct dwarf2_section_info
*abbrev_section
;
6383 const gdb_byte
*info_ptr
, *end_ptr
;
6385 abbrev_section
= (dwo_file
!= NULL
6386 ? &dwo_file
->sections
.abbrev
6387 : &per_objfile
->per_bfd
->abbrev
);
6389 dwarf_read_debug_printf ("Reading %s for %s",
6390 section
->get_name (),
6391 abbrev_section
->get_file_name ());
6393 section
->read (objfile
);
6394 info_ptr
= section
->buffer
;
6396 if (info_ptr
== NULL
)
6399 /* We can't set abfd until now because the section may be empty or
6400 not present, in which case the bfd is unknown. */
6401 abfd
= section
->get_bfd_owner ();
6403 /* We don't use cutu_reader here because we don't need to read
6404 any dies: the signature is in the header. */
6406 end_ptr
= info_ptr
+ section
->size
;
6407 while (info_ptr
< end_ptr
)
6409 struct signatured_type
*sig_type
;
6410 struct dwo_unit
*dwo_tu
;
6412 const gdb_byte
*ptr
= info_ptr
;
6413 struct comp_unit_head header
;
6414 unsigned int length
;
6416 sect_offset sect_off
= (sect_offset
) (ptr
- section
->buffer
);
6418 /* Initialize it due to a false compiler warning. */
6419 header
.signature
= -1;
6420 header
.type_cu_offset_in_tu
= (cu_offset
) -1;
6422 /* We need to read the type's signature in order to build the hash
6423 table, but we don't need anything else just yet. */
6425 ptr
= read_and_check_comp_unit_head (per_objfile
, &header
, section
,
6426 abbrev_section
, ptr
, section_kind
);
6428 length
= header
.get_length ();
6430 /* Skip dummy type units. */
6431 if (ptr
>= info_ptr
+ length
6432 || peek_abbrev_code (abfd
, ptr
) == 0
6433 || (header
.unit_type
!= DW_UT_type
6434 && header
.unit_type
!= DW_UT_split_type
))
6440 if (types_htab
== NULL
)
6443 types_htab
= allocate_dwo_unit_table ();
6445 types_htab
= allocate_signatured_type_table ();
6451 dwo_tu
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, dwo_unit
);
6452 dwo_tu
->dwo_file
= dwo_file
;
6453 dwo_tu
->signature
= header
.signature
;
6454 dwo_tu
->type_offset_in_tu
= header
.type_cu_offset_in_tu
;
6455 dwo_tu
->section
= section
;
6456 dwo_tu
->sect_off
= sect_off
;
6457 dwo_tu
->length
= length
;
6461 /* N.B.: type_offset is not usable if this type uses a DWO file.
6462 The real type_offset is in the DWO file. */
6464 sig_type
= per_objfile
->per_bfd
->allocate_signatured_type ();
6465 sig_type
->signature
= header
.signature
;
6466 sig_type
->type_offset_in_tu
= header
.type_cu_offset_in_tu
;
6467 sig_type
->per_cu
.is_debug_types
= 1;
6468 sig_type
->per_cu
.section
= section
;
6469 sig_type
->per_cu
.sect_off
= sect_off
;
6470 sig_type
->per_cu
.length
= length
;
6473 slot
= htab_find_slot (types_htab
.get (),
6474 dwo_file
? (void*) dwo_tu
: (void *) sig_type
,
6476 gdb_assert (slot
!= NULL
);
6479 sect_offset dup_sect_off
;
6483 const struct dwo_unit
*dup_tu
6484 = (const struct dwo_unit
*) *slot
;
6486 dup_sect_off
= dup_tu
->sect_off
;
6490 const struct signatured_type
*dup_tu
6491 = (const struct signatured_type
*) *slot
;
6493 dup_sect_off
= dup_tu
->per_cu
.sect_off
;
6496 complaint (_("debug type entry at offset %s is duplicate to"
6497 " the entry at offset %s, signature %s"),
6498 sect_offset_str (sect_off
), sect_offset_str (dup_sect_off
),
6499 hex_string (header
.signature
));
6501 *slot
= dwo_file
? (void *) dwo_tu
: (void *) sig_type
;
6503 dwarf_read_debug_printf_v (" offset %s, signature %s",
6504 sect_offset_str (sect_off
),
6505 hex_string (header
.signature
));
6511 /* Create the hash table of all entries in the .debug_types
6512 (or .debug_types.dwo) section(s).
6513 If reading a DWO file, then DWO_FILE is a pointer to the DWO file object,
6514 otherwise it is NULL.
6516 The result is a pointer to the hash table or NULL if there are no types.
6518 Note: This function processes DWO files only, not DWP files. */
6521 create_debug_types_hash_table (dwarf2_per_objfile
*per_objfile
,
6522 struct dwo_file
*dwo_file
,
6523 gdb::array_view
<dwarf2_section_info
> type_sections
,
6524 htab_up
&types_htab
)
6526 for (dwarf2_section_info
§ion
: type_sections
)
6527 create_debug_type_hash_table (per_objfile
, dwo_file
, §ion
, types_htab
,
6531 /* Create the hash table of all entries in the .debug_types section,
6532 and initialize all_type_units.
6533 The result is zero if there is an error (e.g. missing .debug_types section),
6534 otherwise non-zero. */
6537 create_all_type_units (dwarf2_per_objfile
*per_objfile
)
6541 create_debug_type_hash_table (per_objfile
, NULL
, &per_objfile
->per_bfd
->info
,
6542 types_htab
, rcuh_kind::COMPILE
);
6543 create_debug_types_hash_table (per_objfile
, NULL
, per_objfile
->per_bfd
->types
,
6545 if (types_htab
== NULL
)
6547 per_objfile
->per_bfd
->signatured_types
= NULL
;
6551 per_objfile
->per_bfd
->signatured_types
= std::move (types_htab
);
6553 gdb_assert (per_objfile
->per_bfd
->all_type_units
.empty ());
6554 per_objfile
->per_bfd
->all_type_units
.reserve
6555 (htab_elements (per_objfile
->per_bfd
->signatured_types
.get ()));
6557 htab_traverse_noresize (per_objfile
->per_bfd
->signatured_types
.get (),
6558 add_signatured_type_cu_to_table
,
6559 &per_objfile
->per_bfd
->all_type_units
);
6564 /* Add an entry for signature SIG to dwarf2_per_objfile->per_bfd->signatured_types.
6565 If SLOT is non-NULL, it is the entry to use in the hash table.
6566 Otherwise we find one. */
6568 static struct signatured_type
*
6569 add_type_unit (dwarf2_per_objfile
*per_objfile
, ULONGEST sig
, void **slot
)
6571 if (per_objfile
->per_bfd
->all_type_units
.size ()
6572 == per_objfile
->per_bfd
->all_type_units
.capacity ())
6573 ++per_objfile
->per_bfd
->tu_stats
.nr_all_type_units_reallocs
;
6575 signatured_type
*sig_type
= per_objfile
->per_bfd
->allocate_signatured_type ();
6577 per_objfile
->resize_symtabs ();
6579 per_objfile
->per_bfd
->all_type_units
.push_back (sig_type
);
6580 sig_type
->signature
= sig
;
6581 sig_type
->per_cu
.is_debug_types
= 1;
6582 if (per_objfile
->per_bfd
->using_index
)
6584 sig_type
->per_cu
.v
.quick
=
6585 OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
,
6586 struct dwarf2_per_cu_quick_data
);
6591 slot
= htab_find_slot (per_objfile
->per_bfd
->signatured_types
.get (),
6594 gdb_assert (*slot
== NULL
);
6596 /* The rest of sig_type must be filled in by the caller. */
6600 /* Subroutine of lookup_dwo_signatured_type and lookup_dwp_signatured_type.
6601 Fill in SIG_ENTRY with DWO_ENTRY. */
6604 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile
*per_objfile
,
6605 struct signatured_type
*sig_entry
,
6606 struct dwo_unit
*dwo_entry
)
6608 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
6610 /* Make sure we're not clobbering something we don't expect to. */
6611 gdb_assert (! sig_entry
->per_cu
.queued
);
6612 gdb_assert (per_objfile
->get_cu (&sig_entry
->per_cu
) == NULL
);
6613 if (per_bfd
->using_index
)
6615 gdb_assert (sig_entry
->per_cu
.v
.quick
!= NULL
);
6616 gdb_assert (!per_objfile
->symtab_set_p (&sig_entry
->per_cu
));
6619 gdb_assert (sig_entry
->per_cu
.v
.psymtab
== NULL
);
6620 gdb_assert (sig_entry
->signature
== dwo_entry
->signature
);
6621 gdb_assert (to_underlying (sig_entry
->type_offset_in_section
) == 0);
6622 gdb_assert (sig_entry
->type_unit_group
== NULL
);
6623 gdb_assert (sig_entry
->dwo_unit
== NULL
);
6625 sig_entry
->per_cu
.section
= dwo_entry
->section
;
6626 sig_entry
->per_cu
.sect_off
= dwo_entry
->sect_off
;
6627 sig_entry
->per_cu
.length
= dwo_entry
->length
;
6628 sig_entry
->per_cu
.reading_dwo_directly
= 1;
6629 sig_entry
->per_cu
.per_bfd
= per_bfd
;
6630 sig_entry
->type_offset_in_tu
= dwo_entry
->type_offset_in_tu
;
6631 sig_entry
->dwo_unit
= dwo_entry
;
6634 /* Subroutine of lookup_signatured_type.
6635 If we haven't read the TU yet, create the signatured_type data structure
6636 for a TU to be read in directly from a DWO file, bypassing the stub.
6637 This is the "Stay in DWO Optimization": When there is no DWP file and we're
6638 using .gdb_index, then when reading a CU we want to stay in the DWO file
6639 containing that CU. Otherwise we could end up reading several other DWO
6640 files (due to comdat folding) to process the transitive closure of all the
6641 mentioned TUs, and that can be slow. The current DWO file will have every
6642 type signature that it needs.
6643 We only do this for .gdb_index because in the psymtab case we already have
6644 to read all the DWOs to build the type unit groups. */
6646 static struct signatured_type
*
6647 lookup_dwo_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
6649 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
6650 struct dwo_file
*dwo_file
;
6651 struct dwo_unit find_dwo_entry
, *dwo_entry
;
6652 struct signatured_type find_sig_entry
, *sig_entry
;
6655 gdb_assert (cu
->dwo_unit
&& per_objfile
->per_bfd
->using_index
);
6657 /* If TU skeletons have been removed then we may not have read in any
6659 if (per_objfile
->per_bfd
->signatured_types
== NULL
)
6660 per_objfile
->per_bfd
->signatured_types
= allocate_signatured_type_table ();
6662 /* We only ever need to read in one copy of a signatured type.
6663 Use the global signatured_types array to do our own comdat-folding
6664 of types. If this is the first time we're reading this TU, and
6665 the TU has an entry in .gdb_index, replace the recorded data from
6666 .gdb_index with this TU. */
6668 find_sig_entry
.signature
= sig
;
6669 slot
= htab_find_slot (per_objfile
->per_bfd
->signatured_types
.get (),
6670 &find_sig_entry
, INSERT
);
6671 sig_entry
= (struct signatured_type
*) *slot
;
6673 /* We can get here with the TU already read, *or* in the process of being
6674 read. Don't reassign the global entry to point to this DWO if that's
6675 the case. Also note that if the TU is already being read, it may not
6676 have come from a DWO, the program may be a mix of Fission-compiled
6677 code and non-Fission-compiled code. */
6679 /* Have we already tried to read this TU?
6680 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
6681 needn't exist in the global table yet). */
6682 if (sig_entry
!= NULL
&& sig_entry
->per_cu
.tu_read
)
6685 /* Note: cu->dwo_unit is the dwo_unit that references this TU, not the
6686 dwo_unit of the TU itself. */
6687 dwo_file
= cu
->dwo_unit
->dwo_file
;
6689 /* Ok, this is the first time we're reading this TU. */
6690 if (dwo_file
->tus
== NULL
)
6692 find_dwo_entry
.signature
= sig
;
6693 dwo_entry
= (struct dwo_unit
*) htab_find (dwo_file
->tus
.get (),
6695 if (dwo_entry
== NULL
)
6698 /* If the global table doesn't have an entry for this TU, add one. */
6699 if (sig_entry
== NULL
)
6700 sig_entry
= add_type_unit (per_objfile
, sig
, slot
);
6702 fill_in_sig_entry_from_dwo_entry (per_objfile
, sig_entry
, dwo_entry
);
6703 sig_entry
->per_cu
.tu_read
= 1;
6707 /* Subroutine of lookup_signatured_type.
6708 Look up the type for signature SIG, and if we can't find SIG in .gdb_index
6709 then try the DWP file. If the TU stub (skeleton) has been removed then
6710 it won't be in .gdb_index. */
6712 static struct signatured_type
*
6713 lookup_dwp_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
6715 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
6716 struct dwp_file
*dwp_file
= get_dwp_file (per_objfile
);
6717 struct dwo_unit
*dwo_entry
;
6718 struct signatured_type find_sig_entry
, *sig_entry
;
6721 gdb_assert (cu
->dwo_unit
&& per_objfile
->per_bfd
->using_index
);
6722 gdb_assert (dwp_file
!= NULL
);
6724 /* If TU skeletons have been removed then we may not have read in any
6726 if (per_objfile
->per_bfd
->signatured_types
== NULL
)
6727 per_objfile
->per_bfd
->signatured_types
= allocate_signatured_type_table ();
6729 find_sig_entry
.signature
= sig
;
6730 slot
= htab_find_slot (per_objfile
->per_bfd
->signatured_types
.get (),
6731 &find_sig_entry
, INSERT
);
6732 sig_entry
= (struct signatured_type
*) *slot
;
6734 /* Have we already tried to read this TU?
6735 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
6736 needn't exist in the global table yet). */
6737 if (sig_entry
!= NULL
)
6740 if (dwp_file
->tus
== NULL
)
6742 dwo_entry
= lookup_dwo_unit_in_dwp (per_objfile
, dwp_file
, NULL
, sig
,
6743 1 /* is_debug_types */);
6744 if (dwo_entry
== NULL
)
6747 sig_entry
= add_type_unit (per_objfile
, sig
, slot
);
6748 fill_in_sig_entry_from_dwo_entry (per_objfile
, sig_entry
, dwo_entry
);
6753 /* Lookup a signature based type for DW_FORM_ref_sig8.
6754 Returns NULL if signature SIG is not present in the table.
6755 It is up to the caller to complain about this. */
6757 static struct signatured_type
*
6758 lookup_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
6760 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
6762 if (cu
->dwo_unit
&& per_objfile
->per_bfd
->using_index
)
6764 /* We're in a DWO/DWP file, and we're using .gdb_index.
6765 These cases require special processing. */
6766 if (get_dwp_file (per_objfile
) == NULL
)
6767 return lookup_dwo_signatured_type (cu
, sig
);
6769 return lookup_dwp_signatured_type (cu
, sig
);
6773 struct signatured_type find_entry
, *entry
;
6775 if (per_objfile
->per_bfd
->signatured_types
== NULL
)
6777 find_entry
.signature
= sig
;
6778 entry
= ((struct signatured_type
*)
6779 htab_find (per_objfile
->per_bfd
->signatured_types
.get (),
6785 /* Low level DIE reading support. */
6787 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
6790 init_cu_die_reader (struct die_reader_specs
*reader
,
6791 struct dwarf2_cu
*cu
,
6792 struct dwarf2_section_info
*section
,
6793 struct dwo_file
*dwo_file
,
6794 struct abbrev_table
*abbrev_table
)
6796 gdb_assert (section
->readin
&& section
->buffer
!= NULL
);
6797 reader
->abfd
= section
->get_bfd_owner ();
6799 reader
->dwo_file
= dwo_file
;
6800 reader
->die_section
= section
;
6801 reader
->buffer
= section
->buffer
;
6802 reader
->buffer_end
= section
->buffer
+ section
->size
;
6803 reader
->abbrev_table
= abbrev_table
;
6806 /* Subroutine of cutu_reader to simplify it.
6807 Read in the rest of a CU/TU top level DIE from DWO_UNIT.
6808 There's just a lot of work to do, and cutu_reader is big enough
6811 STUB_COMP_UNIT_DIE is for the stub DIE, we copy over certain attributes
6812 from it to the DIE in the DWO. If NULL we are skipping the stub.
6813 STUB_COMP_DIR is similar to STUB_COMP_UNIT_DIE: When reading a TU directly
6814 from the DWO file, bypassing the stub, it contains the DW_AT_comp_dir
6815 attribute of the referencing CU. At most one of STUB_COMP_UNIT_DIE and
6816 STUB_COMP_DIR may be non-NULL.
6817 *RESULT_READER,*RESULT_INFO_PTR,*RESULT_COMP_UNIT_DIE
6818 are filled in with the info of the DIE from the DWO file.
6819 *RESULT_DWO_ABBREV_TABLE will be filled in with the abbrev table allocated
6820 from the dwo. Since *RESULT_READER references this abbrev table, it must be
6821 kept around for at least as long as *RESULT_READER.
6823 The result is non-zero if a valid (non-dummy) DIE was found. */
6826 read_cutu_die_from_dwo (dwarf2_cu
*cu
,
6827 struct dwo_unit
*dwo_unit
,
6828 struct die_info
*stub_comp_unit_die
,
6829 const char *stub_comp_dir
,
6830 struct die_reader_specs
*result_reader
,
6831 const gdb_byte
**result_info_ptr
,
6832 struct die_info
**result_comp_unit_die
,
6833 abbrev_table_up
*result_dwo_abbrev_table
)
6835 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
6836 dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
6837 struct objfile
*objfile
= per_objfile
->objfile
;
6839 const gdb_byte
*begin_info_ptr
, *info_ptr
;
6840 struct attribute
*comp_dir
, *stmt_list
, *low_pc
, *high_pc
, *ranges
;
6841 int i
,num_extra_attrs
;
6842 struct dwarf2_section_info
*dwo_abbrev_section
;
6843 struct die_info
*comp_unit_die
;
6845 /* At most one of these may be provided. */
6846 gdb_assert ((stub_comp_unit_die
!= NULL
) + (stub_comp_dir
!= NULL
) <= 1);
6848 /* These attributes aren't processed until later:
6849 DW_AT_stmt_list, DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges.
6850 DW_AT_comp_dir is used now, to find the DWO file, but it is also
6851 referenced later. However, these attributes are found in the stub
6852 which we won't have later. In order to not impose this complication
6853 on the rest of the code, we read them here and copy them to the
6862 if (stub_comp_unit_die
!= NULL
)
6864 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
6866 if (!per_cu
->is_debug_types
)
6867 stmt_list
= dwarf2_attr (stub_comp_unit_die
, DW_AT_stmt_list
, cu
);
6868 low_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_low_pc
, cu
);
6869 high_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_high_pc
, cu
);
6870 ranges
= dwarf2_attr (stub_comp_unit_die
, DW_AT_ranges
, cu
);
6871 comp_dir
= dwarf2_attr (stub_comp_unit_die
, DW_AT_comp_dir
, cu
);
6873 cu
->addr_base
= stub_comp_unit_die
->addr_base ();
6875 /* There should be a DW_AT_GNU_ranges_base attribute here (if needed).
6876 We need the value before we can process DW_AT_ranges values from the
6878 cu
->gnu_ranges_base
= stub_comp_unit_die
->gnu_ranges_base ();
6880 /* For DWARF5: record the DW_AT_rnglists_base value from the skeleton. If
6881 there are attributes of form DW_FORM_rnglistx in the skeleton, they'll
6882 need the rnglists base. Attributes of form DW_FORM_rnglistx in the
6883 split unit don't use it, as the DWO has its own .debug_rnglists.dwo
6885 cu
->rnglists_base
= stub_comp_unit_die
->rnglists_base ();
6887 else if (stub_comp_dir
!= NULL
)
6889 /* Reconstruct the comp_dir attribute to simplify the code below. */
6890 comp_dir
= OBSTACK_ZALLOC (&cu
->comp_unit_obstack
, struct attribute
);
6891 comp_dir
->name
= DW_AT_comp_dir
;
6892 comp_dir
->form
= DW_FORM_string
;
6893 comp_dir
->set_string_noncanonical (stub_comp_dir
);
6896 /* Set up for reading the DWO CU/TU. */
6897 cu
->dwo_unit
= dwo_unit
;
6898 dwarf2_section_info
*section
= dwo_unit
->section
;
6899 section
->read (objfile
);
6900 abfd
= section
->get_bfd_owner ();
6901 begin_info_ptr
= info_ptr
= (section
->buffer
6902 + to_underlying (dwo_unit
->sect_off
));
6903 dwo_abbrev_section
= &dwo_unit
->dwo_file
->sections
.abbrev
;
6905 if (per_cu
->is_debug_types
)
6907 signatured_type
*sig_type
= (struct signatured_type
*) per_cu
;
6909 info_ptr
= read_and_check_comp_unit_head (per_objfile
, &cu
->header
,
6910 section
, dwo_abbrev_section
,
6911 info_ptr
, rcuh_kind::TYPE
);
6912 /* This is not an assert because it can be caused by bad debug info. */
6913 if (sig_type
->signature
!= cu
->header
.signature
)
6915 error (_("Dwarf Error: signature mismatch %s vs %s while reading"
6916 " TU at offset %s [in module %s]"),
6917 hex_string (sig_type
->signature
),
6918 hex_string (cu
->header
.signature
),
6919 sect_offset_str (dwo_unit
->sect_off
),
6920 bfd_get_filename (abfd
));
6922 gdb_assert (dwo_unit
->sect_off
== cu
->header
.sect_off
);
6923 /* For DWOs coming from DWP files, we don't know the CU length
6924 nor the type's offset in the TU until now. */
6925 dwo_unit
->length
= cu
->header
.get_length ();
6926 dwo_unit
->type_offset_in_tu
= cu
->header
.type_cu_offset_in_tu
;
6928 /* Establish the type offset that can be used to lookup the type.
6929 For DWO files, we don't know it until now. */
6930 sig_type
->type_offset_in_section
6931 = dwo_unit
->sect_off
+ to_underlying (dwo_unit
->type_offset_in_tu
);
6935 info_ptr
= read_and_check_comp_unit_head (per_objfile
, &cu
->header
,
6936 section
, dwo_abbrev_section
,
6937 info_ptr
, rcuh_kind::COMPILE
);
6938 gdb_assert (dwo_unit
->sect_off
== cu
->header
.sect_off
);
6939 /* For DWOs coming from DWP files, we don't know the CU length
6941 dwo_unit
->length
= cu
->header
.get_length ();
6944 dwo_abbrev_section
->read (objfile
);
6945 *result_dwo_abbrev_table
6946 = abbrev_table::read (dwo_abbrev_section
, cu
->header
.abbrev_sect_off
);
6947 init_cu_die_reader (result_reader
, cu
, section
, dwo_unit
->dwo_file
,
6948 result_dwo_abbrev_table
->get ());
6950 /* Read in the die, but leave space to copy over the attributes
6951 from the stub. This has the benefit of simplifying the rest of
6952 the code - all the work to maintain the illusion of a single
6953 DW_TAG_{compile,type}_unit DIE is done here. */
6954 num_extra_attrs
= ((stmt_list
!= NULL
)
6958 + (comp_dir
!= NULL
));
6959 info_ptr
= read_full_die_1 (result_reader
, result_comp_unit_die
, info_ptr
,
6962 /* Copy over the attributes from the stub to the DIE we just read in. */
6963 comp_unit_die
= *result_comp_unit_die
;
6964 i
= comp_unit_die
->num_attrs
;
6965 if (stmt_list
!= NULL
)
6966 comp_unit_die
->attrs
[i
++] = *stmt_list
;
6968 comp_unit_die
->attrs
[i
++] = *low_pc
;
6969 if (high_pc
!= NULL
)
6970 comp_unit_die
->attrs
[i
++] = *high_pc
;
6972 comp_unit_die
->attrs
[i
++] = *ranges
;
6973 if (comp_dir
!= NULL
)
6974 comp_unit_die
->attrs
[i
++] = *comp_dir
;
6975 comp_unit_die
->num_attrs
+= num_extra_attrs
;
6977 if (dwarf_die_debug
)
6979 fprintf_unfiltered (gdb_stdlog
,
6980 "Read die from %s@0x%x of %s:\n",
6981 section
->get_name (),
6982 (unsigned) (begin_info_ptr
- section
->buffer
),
6983 bfd_get_filename (abfd
));
6984 dump_die (comp_unit_die
, dwarf_die_debug
);
6987 /* Skip dummy compilation units. */
6988 if (info_ptr
>= begin_info_ptr
+ dwo_unit
->length
6989 || peek_abbrev_code (abfd
, info_ptr
) == 0)
6992 *result_info_ptr
= info_ptr
;
6996 /* Return the signature of the compile unit, if found. In DWARF 4 and before,
6997 the signature is in the DW_AT_GNU_dwo_id attribute. In DWARF 5 and later, the
6998 signature is part of the header. */
6999 static gdb::optional
<ULONGEST
>
7000 lookup_dwo_id (struct dwarf2_cu
*cu
, struct die_info
* comp_unit_die
)
7002 if (cu
->header
.version
>= 5)
7003 return cu
->header
.signature
;
7004 struct attribute
*attr
;
7005 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_id
, cu
);
7006 if (attr
== nullptr || !attr
->form_is_unsigned ())
7007 return gdb::optional
<ULONGEST
> ();
7008 return attr
->as_unsigned ();
7011 /* Subroutine of cutu_reader to simplify it.
7012 Look up the DWO unit specified by COMP_UNIT_DIE of THIS_CU.
7013 Returns NULL if the specified DWO unit cannot be found. */
7015 static struct dwo_unit
*
7016 lookup_dwo_unit (dwarf2_cu
*cu
, die_info
*comp_unit_die
, const char *dwo_name
)
7018 dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
7019 struct dwo_unit
*dwo_unit
;
7020 const char *comp_dir
;
7022 gdb_assert (cu
!= NULL
);
7024 /* Yeah, we look dwo_name up again, but it simplifies the code. */
7025 dwo_name
= dwarf2_dwo_name (comp_unit_die
, cu
);
7026 comp_dir
= dwarf2_string_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
7028 if (per_cu
->is_debug_types
)
7029 dwo_unit
= lookup_dwo_type_unit (cu
, dwo_name
, comp_dir
);
7032 gdb::optional
<ULONGEST
> signature
= lookup_dwo_id (cu
, comp_unit_die
);
7034 if (!signature
.has_value ())
7035 error (_("Dwarf Error: missing dwo_id for dwo_name %s"
7037 dwo_name
, bfd_get_filename (per_cu
->per_bfd
->obfd
));
7039 dwo_unit
= lookup_dwo_comp_unit (cu
, dwo_name
, comp_dir
, *signature
);
7045 /* Subroutine of cutu_reader to simplify it.
7046 See it for a description of the parameters.
7047 Read a TU directly from a DWO file, bypassing the stub. */
7050 cutu_reader::init_tu_and_read_dwo_dies (dwarf2_per_cu_data
*this_cu
,
7051 dwarf2_per_objfile
*per_objfile
,
7052 dwarf2_cu
*existing_cu
)
7054 struct signatured_type
*sig_type
;
7056 /* Verify we can do the following downcast, and that we have the
7058 gdb_assert (this_cu
->is_debug_types
&& this_cu
->reading_dwo_directly
);
7059 sig_type
= (struct signatured_type
*) this_cu
;
7060 gdb_assert (sig_type
->dwo_unit
!= NULL
);
7064 if (existing_cu
!= nullptr)
7067 gdb_assert (cu
->dwo_unit
== sig_type
->dwo_unit
);
7068 /* There's no need to do the rereading_dwo_cu handling that
7069 cutu_reader does since we don't read the stub. */
7073 /* If an existing_cu is provided, a dwarf2_cu must not exist for this_cu
7074 in per_objfile yet. */
7075 gdb_assert (per_objfile
->get_cu (this_cu
) == nullptr);
7076 m_new_cu
.reset (new dwarf2_cu (this_cu
, per_objfile
));
7077 cu
= m_new_cu
.get ();
7080 /* A future optimization, if needed, would be to use an existing
7081 abbrev table. When reading DWOs with skeletonless TUs, all the TUs
7082 could share abbrev tables. */
7084 if (read_cutu_die_from_dwo (cu
, sig_type
->dwo_unit
,
7085 NULL
/* stub_comp_unit_die */,
7086 sig_type
->dwo_unit
->dwo_file
->comp_dir
,
7089 &m_dwo_abbrev_table
) == 0)
7096 /* Initialize a CU (or TU) and read its DIEs.
7097 If the CU defers to a DWO file, read the DWO file as well.
7099 ABBREV_TABLE, if non-NULL, is the abbreviation table to use.
7100 Otherwise the table specified in the comp unit header is read in and used.
7101 This is an optimization for when we already have the abbrev table.
7103 If EXISTING_CU is non-NULL, then use it. Otherwise, a new CU is
7106 cutu_reader::cutu_reader (dwarf2_per_cu_data
*this_cu
,
7107 dwarf2_per_objfile
*per_objfile
,
7108 struct abbrev_table
*abbrev_table
,
7109 dwarf2_cu
*existing_cu
,
7111 : die_reader_specs
{},
7114 struct objfile
*objfile
= per_objfile
->objfile
;
7115 struct dwarf2_section_info
*section
= this_cu
->section
;
7116 bfd
*abfd
= section
->get_bfd_owner ();
7117 const gdb_byte
*begin_info_ptr
;
7118 struct signatured_type
*sig_type
= NULL
;
7119 struct dwarf2_section_info
*abbrev_section
;
7120 /* Non-zero if CU currently points to a DWO file and we need to
7121 reread it. When this happens we need to reread the skeleton die
7122 before we can reread the DWO file (this only applies to CUs, not TUs). */
7123 int rereading_dwo_cu
= 0;
7125 if (dwarf_die_debug
)
7126 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset %s\n",
7127 this_cu
->is_debug_types
? "type" : "comp",
7128 sect_offset_str (this_cu
->sect_off
));
7130 /* If we're reading a TU directly from a DWO file, including a virtual DWO
7131 file (instead of going through the stub), short-circuit all of this. */
7132 if (this_cu
->reading_dwo_directly
)
7134 /* Narrow down the scope of possibilities to have to understand. */
7135 gdb_assert (this_cu
->is_debug_types
);
7136 gdb_assert (abbrev_table
== NULL
);
7137 init_tu_and_read_dwo_dies (this_cu
, per_objfile
, existing_cu
);
7141 /* This is cheap if the section is already read in. */
7142 section
->read (objfile
);
7144 begin_info_ptr
= info_ptr
= section
->buffer
+ to_underlying (this_cu
->sect_off
);
7146 abbrev_section
= get_abbrev_section_for_cu (this_cu
);
7150 if (existing_cu
!= nullptr)
7153 /* If this CU is from a DWO file we need to start over, we need to
7154 refetch the attributes from the skeleton CU.
7155 This could be optimized by retrieving those attributes from when we
7156 were here the first time: the previous comp_unit_die was stored in
7157 comp_unit_obstack. But there's no data yet that we need this
7159 if (cu
->dwo_unit
!= NULL
)
7160 rereading_dwo_cu
= 1;
7164 /* If an existing_cu is provided, a dwarf2_cu must not exist for this_cu
7165 in per_objfile yet. */
7166 gdb_assert (per_objfile
->get_cu (this_cu
) == nullptr);
7167 m_new_cu
.reset (new dwarf2_cu (this_cu
, per_objfile
));
7168 cu
= m_new_cu
.get ();
7171 /* Get the header. */
7172 if (to_underlying (cu
->header
.first_die_cu_offset
) != 0 && !rereading_dwo_cu
)
7174 /* We already have the header, there's no need to read it in again. */
7175 info_ptr
+= to_underlying (cu
->header
.first_die_cu_offset
);
7179 if (this_cu
->is_debug_types
)
7181 info_ptr
= read_and_check_comp_unit_head (per_objfile
, &cu
->header
,
7182 section
, abbrev_section
,
7183 info_ptr
, rcuh_kind::TYPE
);
7185 /* Since per_cu is the first member of struct signatured_type,
7186 we can go from a pointer to one to a pointer to the other. */
7187 sig_type
= (struct signatured_type
*) this_cu
;
7188 gdb_assert (sig_type
->signature
== cu
->header
.signature
);
7189 gdb_assert (sig_type
->type_offset_in_tu
7190 == cu
->header
.type_cu_offset_in_tu
);
7191 gdb_assert (this_cu
->sect_off
== cu
->header
.sect_off
);
7193 /* LENGTH has not been set yet for type units if we're
7194 using .gdb_index. */
7195 this_cu
->length
= cu
->header
.get_length ();
7197 /* Establish the type offset that can be used to lookup the type. */
7198 sig_type
->type_offset_in_section
=
7199 this_cu
->sect_off
+ to_underlying (sig_type
->type_offset_in_tu
);
7201 this_cu
->dwarf_version
= cu
->header
.version
;
7205 info_ptr
= read_and_check_comp_unit_head (per_objfile
, &cu
->header
,
7206 section
, abbrev_section
,
7208 rcuh_kind::COMPILE
);
7210 gdb_assert (this_cu
->sect_off
== cu
->header
.sect_off
);
7211 if (this_cu
->length
== 0)
7212 this_cu
->length
= cu
->header
.get_length ();
7214 gdb_assert (this_cu
->length
== cu
->header
.get_length ());
7215 this_cu
->dwarf_version
= cu
->header
.version
;
7219 /* Skip dummy compilation units. */
7220 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
7221 || peek_abbrev_code (abfd
, info_ptr
) == 0)
7227 /* If we don't have them yet, read the abbrevs for this compilation unit.
7228 And if we need to read them now, make sure they're freed when we're
7230 if (abbrev_table
!= NULL
)
7231 gdb_assert (cu
->header
.abbrev_sect_off
== abbrev_table
->sect_off
);
7234 abbrev_section
->read (objfile
);
7235 m_abbrev_table_holder
7236 = abbrev_table::read (abbrev_section
, cu
->header
.abbrev_sect_off
);
7237 abbrev_table
= m_abbrev_table_holder
.get ();
7240 /* Read the top level CU/TU die. */
7241 init_cu_die_reader (this, cu
, section
, NULL
, abbrev_table
);
7242 info_ptr
= read_full_die (this, &comp_unit_die
, info_ptr
);
7244 if (skip_partial
&& comp_unit_die
->tag
== DW_TAG_partial_unit
)
7250 /* If we are in a DWO stub, process it and then read in the "real" CU/TU
7251 from the DWO file. read_cutu_die_from_dwo will allocate the abbreviation
7252 table from the DWO file and pass the ownership over to us. It will be
7253 referenced from READER, so we must make sure to free it after we're done
7256 Note that if USE_EXISTING_OK != 0, and THIS_CU->cu already contains a
7257 DWO CU, that this test will fail (the attribute will not be present). */
7258 const char *dwo_name
= dwarf2_dwo_name (comp_unit_die
, cu
);
7259 if (dwo_name
!= nullptr)
7261 struct dwo_unit
*dwo_unit
;
7262 struct die_info
*dwo_comp_unit_die
;
7264 if (comp_unit_die
->has_children
)
7266 complaint (_("compilation unit with DW_AT_GNU_dwo_name"
7267 " has children (offset %s) [in module %s]"),
7268 sect_offset_str (this_cu
->sect_off
),
7269 bfd_get_filename (abfd
));
7271 dwo_unit
= lookup_dwo_unit (cu
, comp_unit_die
, dwo_name
);
7272 if (dwo_unit
!= NULL
)
7274 if (read_cutu_die_from_dwo (cu
, dwo_unit
,
7275 comp_unit_die
, NULL
,
7278 &m_dwo_abbrev_table
) == 0)
7284 comp_unit_die
= dwo_comp_unit_die
;
7288 /* Yikes, we couldn't find the rest of the DIE, we only have
7289 the stub. A complaint has already been logged. There's
7290 not much more we can do except pass on the stub DIE to
7291 die_reader_func. We don't want to throw an error on bad
7298 cutu_reader::keep ()
7300 /* Done, clean up. */
7301 gdb_assert (!dummy_p
);
7302 if (m_new_cu
!= NULL
)
7304 /* Save this dwarf2_cu in the per_objfile. The per_objfile owns it
7306 dwarf2_per_objfile
*per_objfile
= m_new_cu
->per_objfile
;
7307 per_objfile
->set_cu (m_this_cu
, m_new_cu
.release ());
7311 /* Read CU/TU THIS_CU but do not follow DW_AT_GNU_dwo_name (DW_AT_dwo_name)
7312 if present. DWO_FILE, if non-NULL, is the DWO file to read (the caller is
7313 assumed to have already done the lookup to find the DWO file).
7315 The caller is required to fill in THIS_CU->section, THIS_CU->offset, and
7316 THIS_CU->is_debug_types, but nothing else.
7318 We fill in THIS_CU->length.
7320 THIS_CU->cu is always freed when done.
7321 This is done in order to not leave THIS_CU->cu in a state where we have
7322 to care whether it refers to the "main" CU or the DWO CU.
7324 When parent_cu is passed, it is used to provide a default value for
7325 str_offsets_base and addr_base from the parent. */
7327 cutu_reader::cutu_reader (dwarf2_per_cu_data
*this_cu
,
7328 dwarf2_per_objfile
*per_objfile
,
7329 struct dwarf2_cu
*parent_cu
,
7330 struct dwo_file
*dwo_file
)
7331 : die_reader_specs
{},
7334 struct objfile
*objfile
= per_objfile
->objfile
;
7335 struct dwarf2_section_info
*section
= this_cu
->section
;
7336 bfd
*abfd
= section
->get_bfd_owner ();
7337 struct dwarf2_section_info
*abbrev_section
;
7338 const gdb_byte
*begin_info_ptr
, *info_ptr
;
7340 if (dwarf_die_debug
)
7341 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset %s\n",
7342 this_cu
->is_debug_types
? "type" : "comp",
7343 sect_offset_str (this_cu
->sect_off
));
7345 gdb_assert (per_objfile
->get_cu (this_cu
) == nullptr);
7347 abbrev_section
= (dwo_file
!= NULL
7348 ? &dwo_file
->sections
.abbrev
7349 : get_abbrev_section_for_cu (this_cu
));
7351 /* This is cheap if the section is already read in. */
7352 section
->read (objfile
);
7354 m_new_cu
.reset (new dwarf2_cu (this_cu
, per_objfile
));
7356 begin_info_ptr
= info_ptr
= section
->buffer
+ to_underlying (this_cu
->sect_off
);
7357 info_ptr
= read_and_check_comp_unit_head (per_objfile
, &m_new_cu
->header
,
7358 section
, abbrev_section
, info_ptr
,
7359 (this_cu
->is_debug_types
7361 : rcuh_kind::COMPILE
));
7363 if (parent_cu
!= nullptr)
7365 m_new_cu
->str_offsets_base
= parent_cu
->str_offsets_base
;
7366 m_new_cu
->addr_base
= parent_cu
->addr_base
;
7368 this_cu
->length
= m_new_cu
->header
.get_length ();
7370 /* Skip dummy compilation units. */
7371 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
7372 || peek_abbrev_code (abfd
, info_ptr
) == 0)
7378 abbrev_section
->read (objfile
);
7379 m_abbrev_table_holder
7380 = abbrev_table::read (abbrev_section
, m_new_cu
->header
.abbrev_sect_off
);
7382 init_cu_die_reader (this, m_new_cu
.get (), section
, dwo_file
,
7383 m_abbrev_table_holder
.get ());
7384 info_ptr
= read_full_die (this, &comp_unit_die
, info_ptr
);
7388 /* Type Unit Groups.
7390 Type Unit Groups are a way to collapse the set of all TUs (type units) into
7391 a more manageable set. The grouping is done by DW_AT_stmt_list entry
7392 so that all types coming from the same compilation (.o file) are grouped
7393 together. A future step could be to put the types in the same symtab as
7394 the CU the types ultimately came from. */
7397 hash_type_unit_group (const void *item
)
7399 const struct type_unit_group
*tu_group
7400 = (const struct type_unit_group
*) item
;
7402 return hash_stmt_list_entry (&tu_group
->hash
);
7406 eq_type_unit_group (const void *item_lhs
, const void *item_rhs
)
7408 const struct type_unit_group
*lhs
= (const struct type_unit_group
*) item_lhs
;
7409 const struct type_unit_group
*rhs
= (const struct type_unit_group
*) item_rhs
;
7411 return eq_stmt_list_entry (&lhs
->hash
, &rhs
->hash
);
7414 /* Allocate a hash table for type unit groups. */
7417 allocate_type_unit_groups_table ()
7419 return htab_up (htab_create_alloc (3,
7420 hash_type_unit_group
,
7422 NULL
, xcalloc
, xfree
));
7425 /* Type units that don't have DW_AT_stmt_list are grouped into their own
7426 partial symtabs. We combine several TUs per psymtab to not let the size
7427 of any one psymtab grow too big. */
7428 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB (1 << 31)
7429 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE 10
7431 /* Helper routine for get_type_unit_group.
7432 Create the type_unit_group object used to hold one or more TUs. */
7434 static struct type_unit_group
*
7435 create_type_unit_group (struct dwarf2_cu
*cu
, sect_offset line_offset_struct
)
7437 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
7438 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
7439 struct dwarf2_per_cu_data
*per_cu
;
7440 struct type_unit_group
*tu_group
;
7442 tu_group
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, type_unit_group
);
7443 per_cu
= &tu_group
->per_cu
;
7444 per_cu
->per_bfd
= per_bfd
;
7446 if (per_bfd
->using_index
)
7448 per_cu
->v
.quick
= OBSTACK_ZALLOC (&per_bfd
->obstack
,
7449 struct dwarf2_per_cu_quick_data
);
7453 unsigned int line_offset
= to_underlying (line_offset_struct
);
7454 dwarf2_psymtab
*pst
;
7457 /* Give the symtab a useful name for debug purposes. */
7458 if ((line_offset
& NO_STMT_LIST_TYPE_UNIT_PSYMTAB
) != 0)
7459 name
= string_printf ("<type_units_%d>",
7460 (line_offset
& ~NO_STMT_LIST_TYPE_UNIT_PSYMTAB
));
7462 name
= string_printf ("<type_units_at_0x%x>", line_offset
);
7464 pst
= create_partial_symtab (per_cu
, per_objfile
, name
.c_str ());
7465 pst
->anonymous
= true;
7468 tu_group
->hash
.dwo_unit
= cu
->dwo_unit
;
7469 tu_group
->hash
.line_sect_off
= line_offset_struct
;
7474 /* Look up the type_unit_group for type unit CU, and create it if necessary.
7475 STMT_LIST is a DW_AT_stmt_list attribute. */
7477 static struct type_unit_group
*
7478 get_type_unit_group (struct dwarf2_cu
*cu
, const struct attribute
*stmt_list
)
7480 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
7481 struct tu_stats
*tu_stats
= &per_objfile
->per_bfd
->tu_stats
;
7482 struct type_unit_group
*tu_group
;
7484 unsigned int line_offset
;
7485 struct type_unit_group type_unit_group_for_lookup
;
7487 if (per_objfile
->per_bfd
->type_unit_groups
== NULL
)
7488 per_objfile
->per_bfd
->type_unit_groups
= allocate_type_unit_groups_table ();
7490 /* Do we need to create a new group, or can we use an existing one? */
7492 if (stmt_list
!= nullptr && stmt_list
->form_is_unsigned ())
7494 line_offset
= stmt_list
->as_unsigned ();
7495 ++tu_stats
->nr_symtab_sharers
;
7499 /* Ugh, no stmt_list. Rare, but we have to handle it.
7500 We can do various things here like create one group per TU or
7501 spread them over multiple groups to split up the expansion work.
7502 To avoid worst case scenarios (too many groups or too large groups)
7503 we, umm, group them in bunches. */
7504 line_offset
= (NO_STMT_LIST_TYPE_UNIT_PSYMTAB
7505 | (tu_stats
->nr_stmt_less_type_units
7506 / NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE
));
7507 ++tu_stats
->nr_stmt_less_type_units
;
7510 type_unit_group_for_lookup
.hash
.dwo_unit
= cu
->dwo_unit
;
7511 type_unit_group_for_lookup
.hash
.line_sect_off
= (sect_offset
) line_offset
;
7512 slot
= htab_find_slot (per_objfile
->per_bfd
->type_unit_groups
.get (),
7513 &type_unit_group_for_lookup
, INSERT
);
7516 tu_group
= (struct type_unit_group
*) *slot
;
7517 gdb_assert (tu_group
!= NULL
);
7521 sect_offset line_offset_struct
= (sect_offset
) line_offset
;
7522 tu_group
= create_type_unit_group (cu
, line_offset_struct
);
7524 ++tu_stats
->nr_symtabs
;
7530 /* Partial symbol tables. */
7532 /* Create a psymtab named NAME and assign it to PER_CU.
7534 The caller must fill in the following details:
7535 dirname, textlow, texthigh. */
7537 static dwarf2_psymtab
*
7538 create_partial_symtab (dwarf2_per_cu_data
*per_cu
,
7539 dwarf2_per_objfile
*per_objfile
,
7542 struct objfile
*objfile
= per_objfile
->objfile
;
7543 dwarf2_psymtab
*pst
;
7545 pst
= new dwarf2_psymtab (name
, objfile
, per_cu
);
7547 pst
->psymtabs_addrmap_supported
= true;
7549 /* This is the glue that links PST into GDB's symbol API. */
7550 per_cu
->v
.psymtab
= pst
;
7555 /* DIE reader function for process_psymtab_comp_unit. */
7558 process_psymtab_comp_unit_reader (const struct die_reader_specs
*reader
,
7559 const gdb_byte
*info_ptr
,
7560 struct die_info
*comp_unit_die
,
7561 enum language pretend_language
)
7563 struct dwarf2_cu
*cu
= reader
->cu
;
7564 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
7565 struct objfile
*objfile
= per_objfile
->objfile
;
7566 struct gdbarch
*gdbarch
= objfile
->arch ();
7567 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
7569 CORE_ADDR best_lowpc
= 0, best_highpc
= 0;
7570 dwarf2_psymtab
*pst
;
7571 enum pc_bounds_kind cu_bounds_kind
;
7572 const char *filename
;
7574 gdb_assert (! per_cu
->is_debug_types
);
7576 prepare_one_comp_unit (cu
, comp_unit_die
, pretend_language
);
7578 /* Allocate a new partial symbol table structure. */
7579 gdb::unique_xmalloc_ptr
<char> debug_filename
;
7580 static const char artificial
[] = "<artificial>";
7581 filename
= dwarf2_string_attr (comp_unit_die
, DW_AT_name
, cu
);
7582 if (filename
== NULL
)
7584 else if (strcmp (filename
, artificial
) == 0)
7586 debug_filename
.reset (concat (artificial
, "@",
7587 sect_offset_str (per_cu
->sect_off
),
7589 filename
= debug_filename
.get ();
7592 pst
= create_partial_symtab (per_cu
, per_objfile
, filename
);
7594 /* This must be done before calling dwarf2_build_include_psymtabs. */
7595 pst
->dirname
= dwarf2_string_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
7597 baseaddr
= objfile
->text_section_offset ();
7599 dwarf2_find_base_address (comp_unit_die
, cu
);
7601 /* Possibly set the default values of LOWPC and HIGHPC from
7603 cu_bounds_kind
= dwarf2_get_pc_bounds (comp_unit_die
, &best_lowpc
,
7604 &best_highpc
, cu
, pst
);
7605 if (cu_bounds_kind
== PC_BOUNDS_HIGH_LOW
&& best_lowpc
< best_highpc
)
7608 = (gdbarch_adjust_dwarf2_addr (gdbarch
, best_lowpc
+ baseaddr
)
7611 = (gdbarch_adjust_dwarf2_addr (gdbarch
, best_highpc
+ baseaddr
)
7613 /* Store the contiguous range if it is not empty; it can be
7614 empty for CUs with no code. */
7615 addrmap_set_empty (objfile
->partial_symtabs
->psymtabs_addrmap
,
7619 /* Check if comp unit has_children.
7620 If so, read the rest of the partial symbols from this comp unit.
7621 If not, there's no more debug_info for this comp unit. */
7622 if (comp_unit_die
->has_children
)
7624 struct partial_die_info
*first_die
;
7625 CORE_ADDR lowpc
, highpc
;
7627 lowpc
= ((CORE_ADDR
) -1);
7628 highpc
= ((CORE_ADDR
) 0);
7630 first_die
= load_partial_dies (reader
, info_ptr
, 1);
7632 scan_partial_symbols (first_die
, &lowpc
, &highpc
,
7633 cu_bounds_kind
<= PC_BOUNDS_INVALID
, cu
);
7635 /* If we didn't find a lowpc, set it to highpc to avoid
7636 complaints from `maint check'. */
7637 if (lowpc
== ((CORE_ADDR
) -1))
7640 /* If the compilation unit didn't have an explicit address range,
7641 then use the information extracted from its child dies. */
7642 if (cu_bounds_kind
<= PC_BOUNDS_INVALID
)
7645 best_highpc
= highpc
;
7648 pst
->set_text_low (gdbarch_adjust_dwarf2_addr (gdbarch
,
7649 best_lowpc
+ baseaddr
)
7651 pst
->set_text_high (gdbarch_adjust_dwarf2_addr (gdbarch
,
7652 best_highpc
+ baseaddr
)
7657 if (!cu
->per_cu
->imported_symtabs_empty ())
7660 int len
= cu
->per_cu
->imported_symtabs_size ();
7662 /* Fill in 'dependencies' here; we fill in 'users' in a
7664 pst
->number_of_dependencies
= len
;
7666 = objfile
->partial_symtabs
->allocate_dependencies (len
);
7667 for (i
= 0; i
< len
; ++i
)
7669 pst
->dependencies
[i
]
7670 = cu
->per_cu
->imported_symtabs
->at (i
)->v
.psymtab
;
7673 cu
->per_cu
->imported_symtabs_free ();
7676 /* Get the list of files included in the current compilation unit,
7677 and build a psymtab for each of them. */
7678 dwarf2_build_include_psymtabs (cu
, comp_unit_die
, pst
);
7680 dwarf_read_debug_printf ("Psymtab for %s unit @%s: %s - %s"
7681 ", %d global, %d static syms",
7682 per_cu
->is_debug_types
? "type" : "comp",
7683 sect_offset_str (per_cu
->sect_off
),
7684 paddress (gdbarch
, pst
->text_low (objfile
)),
7685 paddress (gdbarch
, pst
->text_high (objfile
)),
7686 (int) pst
->global_psymbols
.size (),
7687 (int) pst
->static_psymbols
.size ());
7690 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
7691 Process compilation unit THIS_CU for a psymtab. */
7694 process_psymtab_comp_unit (dwarf2_per_cu_data
*this_cu
,
7695 dwarf2_per_objfile
*per_objfile
,
7696 bool want_partial_unit
,
7697 enum language pretend_language
)
7699 /* If this compilation unit was already read in, free the
7700 cached copy in order to read it in again. This is
7701 necessary because we skipped some symbols when we first
7702 read in the compilation unit (see load_partial_dies).
7703 This problem could be avoided, but the benefit is unclear. */
7704 per_objfile
->remove_cu (this_cu
);
7706 cutu_reader
reader (this_cu
, per_objfile
, nullptr, nullptr, false);
7708 switch (reader
.comp_unit_die
->tag
)
7710 case DW_TAG_compile_unit
:
7711 this_cu
->unit_type
= DW_UT_compile
;
7713 case DW_TAG_partial_unit
:
7714 this_cu
->unit_type
= DW_UT_partial
;
7716 case DW_TAG_type_unit
:
7717 this_cu
->unit_type
= DW_UT_type
;
7727 else if (this_cu
->is_debug_types
)
7728 build_type_psymtabs_reader (&reader
, reader
.info_ptr
,
7729 reader
.comp_unit_die
);
7730 else if (want_partial_unit
7731 || reader
.comp_unit_die
->tag
!= DW_TAG_partial_unit
)
7732 process_psymtab_comp_unit_reader (&reader
, reader
.info_ptr
,
7733 reader
.comp_unit_die
,
7736 this_cu
->lang
= reader
.cu
->language
;
7738 /* Age out any secondary CUs. */
7739 per_objfile
->age_comp_units ();
7742 /* Reader function for build_type_psymtabs. */
7745 build_type_psymtabs_reader (const struct die_reader_specs
*reader
,
7746 const gdb_byte
*info_ptr
,
7747 struct die_info
*type_unit_die
)
7749 dwarf2_per_objfile
*per_objfile
= reader
->cu
->per_objfile
;
7750 struct dwarf2_cu
*cu
= reader
->cu
;
7751 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
7752 struct signatured_type
*sig_type
;
7753 struct type_unit_group
*tu_group
;
7754 struct attribute
*attr
;
7755 struct partial_die_info
*first_die
;
7756 CORE_ADDR lowpc
, highpc
;
7757 dwarf2_psymtab
*pst
;
7759 gdb_assert (per_cu
->is_debug_types
);
7760 sig_type
= (struct signatured_type
*) per_cu
;
7762 if (! type_unit_die
->has_children
)
7765 attr
= type_unit_die
->attr (DW_AT_stmt_list
);
7766 tu_group
= get_type_unit_group (cu
, attr
);
7768 if (tu_group
->tus
== nullptr)
7769 tu_group
->tus
= new std::vector
<signatured_type
*>;
7770 tu_group
->tus
->push_back (sig_type
);
7772 prepare_one_comp_unit (cu
, type_unit_die
, language_minimal
);
7773 pst
= create_partial_symtab (per_cu
, per_objfile
, "");
7774 pst
->anonymous
= true;
7776 first_die
= load_partial_dies (reader
, info_ptr
, 1);
7778 lowpc
= (CORE_ADDR
) -1;
7779 highpc
= (CORE_ADDR
) 0;
7780 scan_partial_symbols (first_die
, &lowpc
, &highpc
, 0, cu
);
7785 /* Struct used to sort TUs by their abbreviation table offset. */
7787 struct tu_abbrev_offset
7789 tu_abbrev_offset (signatured_type
*sig_type_
, sect_offset abbrev_offset_
)
7790 : sig_type (sig_type_
), abbrev_offset (abbrev_offset_
)
7793 signatured_type
*sig_type
;
7794 sect_offset abbrev_offset
;
7797 /* Helper routine for build_type_psymtabs_1, passed to std::sort. */
7800 sort_tu_by_abbrev_offset (const struct tu_abbrev_offset
&a
,
7801 const struct tu_abbrev_offset
&b
)
7803 return a
.abbrev_offset
< b
.abbrev_offset
;
7806 /* Efficiently read all the type units.
7807 This does the bulk of the work for build_type_psymtabs.
7809 The efficiency is because we sort TUs by the abbrev table they use and
7810 only read each abbrev table once. In one program there are 200K TUs
7811 sharing 8K abbrev tables.
7813 The main purpose of this function is to support building the
7814 dwarf2_per_objfile->per_bfd->type_unit_groups table.
7815 TUs typically share the DW_AT_stmt_list of the CU they came from, so we
7816 can collapse the search space by grouping them by stmt_list.
7817 The savings can be significant, in the same program from above the 200K TUs
7818 share 8K stmt_list tables.
7820 FUNC is expected to call get_type_unit_group, which will create the
7821 struct type_unit_group if necessary and add it to
7822 dwarf2_per_objfile->per_bfd->type_unit_groups. */
7825 build_type_psymtabs_1 (dwarf2_per_objfile
*per_objfile
)
7827 struct tu_stats
*tu_stats
= &per_objfile
->per_bfd
->tu_stats
;
7828 abbrev_table_up abbrev_table
;
7829 sect_offset abbrev_offset
;
7831 /* It's up to the caller to not call us multiple times. */
7832 gdb_assert (per_objfile
->per_bfd
->type_unit_groups
== NULL
);
7834 if (per_objfile
->per_bfd
->all_type_units
.empty ())
7837 /* TUs typically share abbrev tables, and there can be way more TUs than
7838 abbrev tables. Sort by abbrev table to reduce the number of times we
7839 read each abbrev table in.
7840 Alternatives are to punt or to maintain a cache of abbrev tables.
7841 This is simpler and efficient enough for now.
7843 Later we group TUs by their DW_AT_stmt_list value (as this defines the
7844 symtab to use). Typically TUs with the same abbrev offset have the same
7845 stmt_list value too so in practice this should work well.
7847 The basic algorithm here is:
7849 sort TUs by abbrev table
7850 for each TU with same abbrev table:
7851 read abbrev table if first user
7852 read TU top level DIE
7853 [IWBN if DWO skeletons had DW_AT_stmt_list]
7856 dwarf_read_debug_printf ("Building type unit groups ...");
7858 /* Sort in a separate table to maintain the order of all_type_units
7859 for .gdb_index: TU indices directly index all_type_units. */
7860 std::vector
<tu_abbrev_offset
> sorted_by_abbrev
;
7861 sorted_by_abbrev
.reserve (per_objfile
->per_bfd
->all_type_units
.size ());
7863 for (signatured_type
*sig_type
: per_objfile
->per_bfd
->all_type_units
)
7864 sorted_by_abbrev
.emplace_back
7865 (sig_type
, read_abbrev_offset (per_objfile
, sig_type
->per_cu
.section
,
7866 sig_type
->per_cu
.sect_off
));
7868 std::sort (sorted_by_abbrev
.begin (), sorted_by_abbrev
.end (),
7869 sort_tu_by_abbrev_offset
);
7871 abbrev_offset
= (sect_offset
) ~(unsigned) 0;
7873 for (const tu_abbrev_offset
&tu
: sorted_by_abbrev
)
7875 /* Switch to the next abbrev table if necessary. */
7876 if (abbrev_table
== NULL
7877 || tu
.abbrev_offset
!= abbrev_offset
)
7879 abbrev_offset
= tu
.abbrev_offset
;
7880 per_objfile
->per_bfd
->abbrev
.read (per_objfile
->objfile
);
7882 abbrev_table::read (&per_objfile
->per_bfd
->abbrev
, abbrev_offset
);
7883 ++tu_stats
->nr_uniq_abbrev_tables
;
7886 cutu_reader
reader (&tu
.sig_type
->per_cu
, per_objfile
,
7887 abbrev_table
.get (), nullptr, false);
7888 if (!reader
.dummy_p
)
7889 build_type_psymtabs_reader (&reader
, reader
.info_ptr
,
7890 reader
.comp_unit_die
);
7894 /* Print collected type unit statistics. */
7897 print_tu_stats (dwarf2_per_objfile
*per_objfile
)
7899 struct tu_stats
*tu_stats
= &per_objfile
->per_bfd
->tu_stats
;
7901 dwarf_read_debug_printf ("Type unit statistics:");
7902 dwarf_read_debug_printf (" %zu TUs",
7903 per_objfile
->per_bfd
->all_type_units
.size ());
7904 dwarf_read_debug_printf (" %d uniq abbrev tables",
7905 tu_stats
->nr_uniq_abbrev_tables
);
7906 dwarf_read_debug_printf (" %d symtabs from stmt_list entries",
7907 tu_stats
->nr_symtabs
);
7908 dwarf_read_debug_printf (" %d symtab sharers",
7909 tu_stats
->nr_symtab_sharers
);
7910 dwarf_read_debug_printf (" %d type units without a stmt_list",
7911 tu_stats
->nr_stmt_less_type_units
);
7912 dwarf_read_debug_printf (" %d all_type_units reallocs",
7913 tu_stats
->nr_all_type_units_reallocs
);
7916 /* Traversal function for build_type_psymtabs. */
7919 build_type_psymtab_dependencies (void **slot
, void *info
)
7921 dwarf2_per_objfile
*per_objfile
= (dwarf2_per_objfile
*) info
;
7922 struct objfile
*objfile
= per_objfile
->objfile
;
7923 struct type_unit_group
*tu_group
= (struct type_unit_group
*) *slot
;
7924 struct dwarf2_per_cu_data
*per_cu
= &tu_group
->per_cu
;
7925 dwarf2_psymtab
*pst
= per_cu
->v
.psymtab
;
7926 int len
= (tu_group
->tus
== nullptr) ? 0 : tu_group
->tus
->size ();
7929 gdb_assert (len
> 0);
7930 gdb_assert (per_cu
->type_unit_group_p ());
7932 pst
->number_of_dependencies
= len
;
7933 pst
->dependencies
= objfile
->partial_symtabs
->allocate_dependencies (len
);
7934 for (i
= 0; i
< len
; ++i
)
7936 struct signatured_type
*iter
= tu_group
->tus
->at (i
);
7937 gdb_assert (iter
->per_cu
.is_debug_types
);
7938 pst
->dependencies
[i
] = iter
->per_cu
.v
.psymtab
;
7939 iter
->type_unit_group
= tu_group
;
7942 delete tu_group
->tus
;
7943 tu_group
->tus
= nullptr;
7948 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
7949 Build partial symbol tables for the .debug_types comp-units. */
7952 build_type_psymtabs (dwarf2_per_objfile
*per_objfile
)
7954 if (! create_all_type_units (per_objfile
))
7957 build_type_psymtabs_1 (per_objfile
);
7960 /* Traversal function for process_skeletonless_type_unit.
7961 Read a TU in a DWO file and build partial symbols for it. */
7964 process_skeletonless_type_unit (void **slot
, void *info
)
7966 struct dwo_unit
*dwo_unit
= (struct dwo_unit
*) *slot
;
7967 dwarf2_per_objfile
*per_objfile
= (dwarf2_per_objfile
*) info
;
7968 struct signatured_type find_entry
, *entry
;
7970 /* If this TU doesn't exist in the global table, add it and read it in. */
7972 if (per_objfile
->per_bfd
->signatured_types
== NULL
)
7973 per_objfile
->per_bfd
->signatured_types
= allocate_signatured_type_table ();
7975 find_entry
.signature
= dwo_unit
->signature
;
7976 slot
= htab_find_slot (per_objfile
->per_bfd
->signatured_types
.get (),
7977 &find_entry
, INSERT
);
7978 /* If we've already seen this type there's nothing to do. What's happening
7979 is we're doing our own version of comdat-folding here. */
7983 /* This does the job that create_all_type_units would have done for
7985 entry
= add_type_unit (per_objfile
, dwo_unit
->signature
, slot
);
7986 fill_in_sig_entry_from_dwo_entry (per_objfile
, entry
, dwo_unit
);
7989 /* This does the job that build_type_psymtabs_1 would have done. */
7990 cutu_reader
reader (&entry
->per_cu
, per_objfile
, nullptr, nullptr, false);
7991 if (!reader
.dummy_p
)
7992 build_type_psymtabs_reader (&reader
, reader
.info_ptr
,
7993 reader
.comp_unit_die
);
7998 /* Traversal function for process_skeletonless_type_units. */
8001 process_dwo_file_for_skeletonless_type_units (void **slot
, void *info
)
8003 struct dwo_file
*dwo_file
= (struct dwo_file
*) *slot
;
8005 if (dwo_file
->tus
!= NULL
)
8006 htab_traverse_noresize (dwo_file
->tus
.get (),
8007 process_skeletonless_type_unit
, info
);
8012 /* Scan all TUs of DWO files, verifying we've processed them.
8013 This is needed in case a TU was emitted without its skeleton.
8014 Note: This can't be done until we know what all the DWO files are. */
8017 process_skeletonless_type_units (dwarf2_per_objfile
*per_objfile
)
8019 /* Skeletonless TUs in DWP files without .gdb_index is not supported yet. */
8020 if (get_dwp_file (per_objfile
) == NULL
8021 && per_objfile
->per_bfd
->dwo_files
!= NULL
)
8023 htab_traverse_noresize (per_objfile
->per_bfd
->dwo_files
.get (),
8024 process_dwo_file_for_skeletonless_type_units
,
8029 /* Compute the 'user' field for each psymtab in DWARF2_PER_OBJFILE. */
8032 set_partial_user (dwarf2_per_objfile
*per_objfile
)
8034 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
8036 dwarf2_psymtab
*pst
= per_cu
->v
.psymtab
;
8041 for (int j
= 0; j
< pst
->number_of_dependencies
; ++j
)
8043 /* Set the 'user' field only if it is not already set. */
8044 if (pst
->dependencies
[j
]->user
== NULL
)
8045 pst
->dependencies
[j
]->user
= pst
;
8050 /* Build the partial symbol table by doing a quick pass through the
8051 .debug_info and .debug_abbrev sections. */
8054 dwarf2_build_psymtabs_hard (dwarf2_per_objfile
*per_objfile
)
8056 struct objfile
*objfile
= per_objfile
->objfile
;
8058 dwarf_read_debug_printf ("Building psymtabs of objfile %s ...",
8059 objfile_name (objfile
));
8061 scoped_restore restore_reading_psyms
8062 = make_scoped_restore (&per_objfile
->per_bfd
->reading_partial_symbols
,
8065 per_objfile
->per_bfd
->info
.read (objfile
);
8067 /* Any cached compilation units will be linked by the per-objfile
8068 read_in_chain. Make sure to free them when we're done. */
8069 free_cached_comp_units
freer (per_objfile
);
8071 build_type_psymtabs (per_objfile
);
8073 create_all_comp_units (per_objfile
);
8075 /* Create a temporary address map on a temporary obstack. We later
8076 copy this to the final obstack. */
8077 auto_obstack temp_obstack
;
8079 scoped_restore save_psymtabs_addrmap
8080 = make_scoped_restore (&objfile
->partial_symtabs
->psymtabs_addrmap
,
8081 addrmap_create_mutable (&temp_obstack
));
8083 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
8085 if (per_cu
->v
.psymtab
!= NULL
)
8086 /* In case a forward DW_TAG_imported_unit has read the CU already. */
8088 process_psymtab_comp_unit (per_cu
, per_objfile
, false,
8092 /* This has to wait until we read the CUs, we need the list of DWOs. */
8093 process_skeletonless_type_units (per_objfile
);
8095 /* Now that all TUs have been processed we can fill in the dependencies. */
8096 if (per_objfile
->per_bfd
->type_unit_groups
!= NULL
)
8098 htab_traverse_noresize (per_objfile
->per_bfd
->type_unit_groups
.get (),
8099 build_type_psymtab_dependencies
, per_objfile
);
8102 if (dwarf_read_debug
> 0)
8103 print_tu_stats (per_objfile
);
8105 set_partial_user (per_objfile
);
8107 objfile
->partial_symtabs
->psymtabs_addrmap
8108 = addrmap_create_fixed (objfile
->partial_symtabs
->psymtabs_addrmap
,
8109 objfile
->partial_symtabs
->obstack ());
8110 /* At this point we want to keep the address map. */
8111 save_psymtabs_addrmap
.release ();
8113 dwarf_read_debug_printf ("Done building psymtabs of %s",
8114 objfile_name (objfile
));
8117 /* Load the partial DIEs for a secondary CU into memory.
8118 This is also used when rereading a primary CU with load_all_dies. */
8121 load_partial_comp_unit (dwarf2_per_cu_data
*this_cu
,
8122 dwarf2_per_objfile
*per_objfile
,
8123 dwarf2_cu
*existing_cu
)
8125 cutu_reader
reader (this_cu
, per_objfile
, nullptr, existing_cu
, false);
8127 if (!reader
.dummy_p
)
8129 prepare_one_comp_unit (reader
.cu
, reader
.comp_unit_die
,
8132 /* Check if comp unit has_children.
8133 If so, read the rest of the partial symbols from this comp unit.
8134 If not, there's no more debug_info for this comp unit. */
8135 if (reader
.comp_unit_die
->has_children
)
8136 load_partial_dies (&reader
, reader
.info_ptr
, 0);
8143 read_comp_units_from_section (dwarf2_per_objfile
*per_objfile
,
8144 struct dwarf2_section_info
*section
,
8145 struct dwarf2_section_info
*abbrev_section
,
8146 unsigned int is_dwz
)
8148 const gdb_byte
*info_ptr
;
8149 struct objfile
*objfile
= per_objfile
->objfile
;
8151 dwarf_read_debug_printf ("Reading %s for %s",
8152 section
->get_name (),
8153 section
->get_file_name ());
8155 section
->read (objfile
);
8157 info_ptr
= section
->buffer
;
8159 while (info_ptr
< section
->buffer
+ section
->size
)
8161 struct dwarf2_per_cu_data
*this_cu
;
8163 sect_offset sect_off
= (sect_offset
) (info_ptr
- section
->buffer
);
8165 comp_unit_head cu_header
;
8166 read_and_check_comp_unit_head (per_objfile
, &cu_header
, section
,
8167 abbrev_section
, info_ptr
,
8168 rcuh_kind::COMPILE
);
8170 /* Save the compilation unit for later lookup. */
8171 if (cu_header
.unit_type
!= DW_UT_type
)
8172 this_cu
= per_objfile
->per_bfd
->allocate_per_cu ();
8175 auto sig_type
= per_objfile
->per_bfd
->allocate_signatured_type ();
8176 sig_type
->signature
= cu_header
.signature
;
8177 sig_type
->type_offset_in_tu
= cu_header
.type_cu_offset_in_tu
;
8178 this_cu
= &sig_type
->per_cu
;
8180 this_cu
->is_debug_types
= (cu_header
.unit_type
== DW_UT_type
);
8181 this_cu
->sect_off
= sect_off
;
8182 this_cu
->length
= cu_header
.length
+ cu_header
.initial_length_size
;
8183 this_cu
->is_dwz
= is_dwz
;
8184 this_cu
->section
= section
;
8186 per_objfile
->per_bfd
->all_comp_units
.push_back (this_cu
);
8188 info_ptr
= info_ptr
+ this_cu
->length
;
8192 /* Create a list of all compilation units in OBJFILE.
8193 This is only done for -readnow and building partial symtabs. */
8196 create_all_comp_units (dwarf2_per_objfile
*per_objfile
)
8198 gdb_assert (per_objfile
->per_bfd
->all_comp_units
.empty ());
8199 read_comp_units_from_section (per_objfile
, &per_objfile
->per_bfd
->info
,
8200 &per_objfile
->per_bfd
->abbrev
, 0);
8202 dwz_file
*dwz
= dwarf2_get_dwz_file (per_objfile
->per_bfd
);
8204 read_comp_units_from_section (per_objfile
, &dwz
->info
, &dwz
->abbrev
, 1);
8207 /* Process all loaded DIEs for compilation unit CU, starting at
8208 FIRST_DIE. The caller should pass SET_ADDRMAP == 1 if the compilation
8209 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
8210 DW_AT_ranges). See the comments of add_partial_subprogram on how
8211 SET_ADDRMAP is used and how *LOWPC and *HIGHPC are updated. */
8214 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
8215 CORE_ADDR
*highpc
, int set_addrmap
,
8216 struct dwarf2_cu
*cu
)
8218 struct partial_die_info
*pdi
;
8220 /* Now, march along the PDI's, descending into ones which have
8221 interesting children but skipping the children of the other ones,
8222 until we reach the end of the compilation unit. */
8230 /* Anonymous namespaces or modules have no name but have interesting
8231 children, so we need to look at them. Ditto for anonymous
8234 if (pdi
->raw_name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
8235 || pdi
->tag
== DW_TAG_module
|| pdi
->tag
== DW_TAG_enumeration_type
8236 || pdi
->tag
== DW_TAG_imported_unit
8237 || pdi
->tag
== DW_TAG_inlined_subroutine
)
8241 case DW_TAG_subprogram
:
8242 case DW_TAG_inlined_subroutine
:
8243 add_partial_subprogram (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
8244 if (cu
->language
== language_cplus
)
8245 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
,
8248 case DW_TAG_constant
:
8249 case DW_TAG_variable
:
8250 case DW_TAG_typedef
:
8251 case DW_TAG_union_type
:
8252 if (!pdi
->is_declaration
8253 || (pdi
->tag
== DW_TAG_variable
&& pdi
->is_external
))
8255 add_partial_symbol (pdi
, cu
);
8258 case DW_TAG_class_type
:
8259 case DW_TAG_interface_type
:
8260 case DW_TAG_structure_type
:
8261 if (!pdi
->is_declaration
)
8263 add_partial_symbol (pdi
, cu
);
8265 if ((cu
->language
== language_rust
8266 || cu
->language
== language_cplus
) && pdi
->has_children
)
8267 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
,
8270 case DW_TAG_enumeration_type
:
8271 if (!pdi
->is_declaration
)
8272 add_partial_enumeration (pdi
, cu
);
8274 case DW_TAG_base_type
:
8275 case DW_TAG_subrange_type
:
8276 /* File scope base type definitions are added to the partial
8278 add_partial_symbol (pdi
, cu
);
8280 case DW_TAG_namespace
:
8281 add_partial_namespace (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
8284 if (!pdi
->is_declaration
)
8285 add_partial_module (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
8287 case DW_TAG_imported_unit
:
8289 struct dwarf2_per_cu_data
*per_cu
;
8291 /* For now we don't handle imported units in type units. */
8292 if (cu
->per_cu
->is_debug_types
)
8294 error (_("Dwarf Error: DW_TAG_imported_unit is not"
8295 " supported in type units [in module %s]"),
8296 objfile_name (cu
->per_objfile
->objfile
));
8299 per_cu
= dwarf2_find_containing_comp_unit
8300 (pdi
->d
.sect_off
, pdi
->is_dwz
, cu
->per_objfile
);
8302 /* Go read the partial unit, if needed. */
8303 if (per_cu
->v
.psymtab
== NULL
)
8304 process_psymtab_comp_unit (per_cu
, cu
->per_objfile
, true,
8307 cu
->per_cu
->imported_symtabs_push (per_cu
);
8310 case DW_TAG_imported_declaration
:
8311 add_partial_symbol (pdi
, cu
);
8318 /* If the die has a sibling, skip to the sibling. */
8320 pdi
= pdi
->die_sibling
;
8324 /* Functions used to compute the fully scoped name of a partial DIE.
8326 Normally, this is simple. For C++, the parent DIE's fully scoped
8327 name is concatenated with "::" and the partial DIE's name.
8328 Enumerators are an exception; they use the scope of their parent
8329 enumeration type, i.e. the name of the enumeration type is not
8330 prepended to the enumerator.
8332 There are two complexities. One is DW_AT_specification; in this
8333 case "parent" means the parent of the target of the specification,
8334 instead of the direct parent of the DIE. The other is compilers
8335 which do not emit DW_TAG_namespace; in this case we try to guess
8336 the fully qualified name of structure types from their members'
8337 linkage names. This must be done using the DIE's children rather
8338 than the children of any DW_AT_specification target. We only need
8339 to do this for structures at the top level, i.e. if the target of
8340 any DW_AT_specification (if any; otherwise the DIE itself) does not
8343 /* Compute the scope prefix associated with PDI's parent, in
8344 compilation unit CU. The result will be allocated on CU's
8345 comp_unit_obstack, or a copy of the already allocated PDI->NAME
8346 field. NULL is returned if no prefix is necessary. */
8348 partial_die_parent_scope (struct partial_die_info
*pdi
,
8349 struct dwarf2_cu
*cu
)
8351 const char *grandparent_scope
;
8352 struct partial_die_info
*parent
, *real_pdi
;
8354 /* We need to look at our parent DIE; if we have a DW_AT_specification,
8355 then this means the parent of the specification DIE. */
8358 while (real_pdi
->has_specification
)
8360 auto res
= find_partial_die (real_pdi
->spec_offset
,
8361 real_pdi
->spec_is_dwz
, cu
);
8366 parent
= real_pdi
->die_parent
;
8370 if (parent
->scope_set
)
8371 return parent
->scope
;
8375 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
8377 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
8378 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
8379 Work around this problem here. */
8380 if (cu
->language
== language_cplus
8381 && parent
->tag
== DW_TAG_namespace
8382 && strcmp (parent
->name (cu
), "::") == 0
8383 && grandparent_scope
== NULL
)
8385 parent
->scope
= NULL
;
8386 parent
->scope_set
= 1;
8390 /* Nested subroutines in Fortran get a prefix. */
8391 if (pdi
->tag
== DW_TAG_enumerator
)
8392 /* Enumerators should not get the name of the enumeration as a prefix. */
8393 parent
->scope
= grandparent_scope
;
8394 else if (parent
->tag
== DW_TAG_namespace
8395 || parent
->tag
== DW_TAG_module
8396 || parent
->tag
== DW_TAG_structure_type
8397 || parent
->tag
== DW_TAG_class_type
8398 || parent
->tag
== DW_TAG_interface_type
8399 || parent
->tag
== DW_TAG_union_type
8400 || parent
->tag
== DW_TAG_enumeration_type
8401 || (cu
->language
== language_fortran
8402 && parent
->tag
== DW_TAG_subprogram
8403 && pdi
->tag
== DW_TAG_subprogram
))
8405 if (grandparent_scope
== NULL
)
8406 parent
->scope
= parent
->name (cu
);
8408 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
,
8410 parent
->name (cu
), 0, cu
);
8414 /* FIXME drow/2004-04-01: What should we be doing with
8415 function-local names? For partial symbols, we should probably be
8417 complaint (_("unhandled containing DIE tag %s for DIE at %s"),
8418 dwarf_tag_name (parent
->tag
),
8419 sect_offset_str (pdi
->sect_off
));
8420 parent
->scope
= grandparent_scope
;
8423 parent
->scope_set
= 1;
8424 return parent
->scope
;
8427 /* Return the fully scoped name associated with PDI, from compilation unit
8428 CU. The result will be allocated with malloc. */
8430 static gdb::unique_xmalloc_ptr
<char>
8431 partial_die_full_name (struct partial_die_info
*pdi
,
8432 struct dwarf2_cu
*cu
)
8434 const char *parent_scope
;
8436 /* If this is a template instantiation, we can not work out the
8437 template arguments from partial DIEs. So, unfortunately, we have
8438 to go through the full DIEs. At least any work we do building
8439 types here will be reused if full symbols are loaded later. */
8440 if (pdi
->has_template_arguments
)
8444 if (pdi
->name (cu
) != NULL
&& strchr (pdi
->name (cu
), '<') == NULL
)
8446 struct die_info
*die
;
8447 struct attribute attr
;
8448 struct dwarf2_cu
*ref_cu
= cu
;
8450 /* DW_FORM_ref_addr is using section offset. */
8451 attr
.name
= (enum dwarf_attribute
) 0;
8452 attr
.form
= DW_FORM_ref_addr
;
8453 attr
.u
.unsnd
= to_underlying (pdi
->sect_off
);
8454 die
= follow_die_ref (NULL
, &attr
, &ref_cu
);
8456 return make_unique_xstrdup (dwarf2_full_name (NULL
, die
, ref_cu
));
8460 parent_scope
= partial_die_parent_scope (pdi
, cu
);
8461 if (parent_scope
== NULL
)
8464 return gdb::unique_xmalloc_ptr
<char> (typename_concat (NULL
, parent_scope
,
8470 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
8472 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
8473 struct objfile
*objfile
= per_objfile
->objfile
;
8474 struct gdbarch
*gdbarch
= objfile
->arch ();
8476 const char *actual_name
= NULL
;
8479 baseaddr
= objfile
->text_section_offset ();
8481 gdb::unique_xmalloc_ptr
<char> built_actual_name
8482 = partial_die_full_name (pdi
, cu
);
8483 if (built_actual_name
!= NULL
)
8484 actual_name
= built_actual_name
.get ();
8486 if (actual_name
== NULL
)
8487 actual_name
= pdi
->name (cu
);
8489 partial_symbol psymbol
;
8490 memset (&psymbol
, 0, sizeof (psymbol
));
8491 psymbol
.ginfo
.set_language (cu
->language
, &objfile
->objfile_obstack
);
8492 psymbol
.ginfo
.set_section_index (-1);
8494 /* The code below indicates that the psymbol should be installed by
8496 gdb::optional
<psymbol_placement
> where
;
8500 case DW_TAG_inlined_subroutine
:
8501 case DW_TAG_subprogram
:
8502 addr
= (gdbarch_adjust_dwarf2_addr (gdbarch
, pdi
->lowpc
+ baseaddr
)
8504 if (pdi
->is_external
8505 || cu
->language
== language_ada
8506 || (cu
->language
== language_fortran
8507 && pdi
->die_parent
!= NULL
8508 && pdi
->die_parent
->tag
== DW_TAG_subprogram
))
8510 /* Normally, only "external" DIEs are part of the global scope.
8511 But in Ada and Fortran, we want to be able to access nested
8512 procedures globally. So all Ada and Fortran subprograms are
8513 stored in the global scope. */
8514 where
= psymbol_placement::GLOBAL
;
8517 where
= psymbol_placement::STATIC
;
8519 psymbol
.domain
= VAR_DOMAIN
;
8520 psymbol
.aclass
= LOC_BLOCK
;
8521 psymbol
.ginfo
.set_section_index (SECT_OFF_TEXT (objfile
));
8522 psymbol
.ginfo
.value
.address
= addr
;
8524 if (pdi
->main_subprogram
&& actual_name
!= NULL
)
8525 set_objfile_main_name (objfile
, actual_name
, cu
->language
);
8527 case DW_TAG_constant
:
8528 psymbol
.domain
= VAR_DOMAIN
;
8529 psymbol
.aclass
= LOC_STATIC
;
8530 where
= (pdi
->is_external
8531 ? psymbol_placement::GLOBAL
8532 : psymbol_placement::STATIC
);
8534 case DW_TAG_variable
:
8536 addr
= decode_locdesc (pdi
->d
.locdesc
, cu
);
8540 && !per_objfile
->per_bfd
->has_section_at_zero
)
8542 /* A global or static variable may also have been stripped
8543 out by the linker if unused, in which case its address
8544 will be nullified; do not add such variables into partial
8545 symbol table then. */
8547 else if (pdi
->is_external
)
8550 Don't enter into the minimal symbol tables as there is
8551 a minimal symbol table entry from the ELF symbols already.
8552 Enter into partial symbol table if it has a location
8553 descriptor or a type.
8554 If the location descriptor is missing, new_symbol will create
8555 a LOC_UNRESOLVED symbol, the address of the variable will then
8556 be determined from the minimal symbol table whenever the variable
8558 The address for the partial symbol table entry is not
8559 used by GDB, but it comes in handy for debugging partial symbol
8562 if (pdi
->d
.locdesc
|| pdi
->has_type
)
8564 psymbol
.domain
= VAR_DOMAIN
;
8565 psymbol
.aclass
= LOC_STATIC
;
8566 psymbol
.ginfo
.set_section_index (SECT_OFF_TEXT (objfile
));
8567 psymbol
.ginfo
.value
.address
= addr
;
8568 where
= psymbol_placement::GLOBAL
;
8573 int has_loc
= pdi
->d
.locdesc
!= NULL
;
8575 /* Static Variable. Skip symbols whose value we cannot know (those
8576 without location descriptors or constant values). */
8577 if (!has_loc
&& !pdi
->has_const_value
)
8580 psymbol
.domain
= VAR_DOMAIN
;
8581 psymbol
.aclass
= LOC_STATIC
;
8582 psymbol
.ginfo
.set_section_index (SECT_OFF_TEXT (objfile
));
8584 psymbol
.ginfo
.value
.address
= addr
;
8585 where
= psymbol_placement::STATIC
;
8588 case DW_TAG_array_type
:
8589 case DW_TAG_typedef
:
8590 case DW_TAG_base_type
:
8591 case DW_TAG_subrange_type
:
8592 psymbol
.domain
= VAR_DOMAIN
;
8593 psymbol
.aclass
= LOC_TYPEDEF
;
8594 where
= psymbol_placement::STATIC
;
8596 case DW_TAG_imported_declaration
:
8597 case DW_TAG_namespace
:
8598 psymbol
.domain
= VAR_DOMAIN
;
8599 psymbol
.aclass
= LOC_TYPEDEF
;
8600 where
= psymbol_placement::GLOBAL
;
8603 /* With Fortran 77 there might be a "BLOCK DATA" module
8604 available without any name. If so, we skip the module as it
8605 doesn't bring any value. */
8606 if (actual_name
!= nullptr)
8608 psymbol
.domain
= MODULE_DOMAIN
;
8609 psymbol
.aclass
= LOC_TYPEDEF
;
8610 where
= psymbol_placement::GLOBAL
;
8613 case DW_TAG_class_type
:
8614 case DW_TAG_interface_type
:
8615 case DW_TAG_structure_type
:
8616 case DW_TAG_union_type
:
8617 case DW_TAG_enumeration_type
:
8618 /* Skip external references. The DWARF standard says in the section
8619 about "Structure, Union, and Class Type Entries": "An incomplete
8620 structure, union or class type is represented by a structure,
8621 union or class entry that does not have a byte size attribute
8622 and that has a DW_AT_declaration attribute." */
8623 if (!pdi
->has_byte_size
&& pdi
->is_declaration
)
8626 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
8627 static vs. global. */
8628 psymbol
.domain
= STRUCT_DOMAIN
;
8629 psymbol
.aclass
= LOC_TYPEDEF
;
8630 where
= (cu
->language
== language_cplus
8631 ? psymbol_placement::GLOBAL
8632 : psymbol_placement::STATIC
);
8634 case DW_TAG_enumerator
:
8635 psymbol
.domain
= VAR_DOMAIN
;
8636 psymbol
.aclass
= LOC_CONST
;
8637 where
= (cu
->language
== language_cplus
8638 ? psymbol_placement::GLOBAL
8639 : psymbol_placement::STATIC
);
8645 if (where
.has_value ())
8647 if (built_actual_name
!= nullptr)
8648 actual_name
= objfile
->intern (actual_name
);
8649 if (pdi
->linkage_name
== nullptr || cu
->language
== language_ada
)
8650 psymbol
.ginfo
.set_linkage_name (actual_name
);
8653 psymbol
.ginfo
.set_demangled_name (actual_name
,
8654 &objfile
->objfile_obstack
);
8655 psymbol
.ginfo
.set_linkage_name (pdi
->linkage_name
);
8657 cu
->per_cu
->v
.psymtab
->add_psymbol (psymbol
, *where
, objfile
);
8661 /* Read a partial die corresponding to a namespace; also, add a symbol
8662 corresponding to that namespace to the symbol table. NAMESPACE is
8663 the name of the enclosing namespace. */
8666 add_partial_namespace (struct partial_die_info
*pdi
,
8667 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
8668 int set_addrmap
, struct dwarf2_cu
*cu
)
8670 /* Add a symbol for the namespace. */
8672 add_partial_symbol (pdi
, cu
);
8674 /* Now scan partial symbols in that namespace. */
8676 if (pdi
->has_children
)
8677 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, set_addrmap
, cu
);
8680 /* Read a partial die corresponding to a Fortran module. */
8683 add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
8684 CORE_ADDR
*highpc
, int set_addrmap
, struct dwarf2_cu
*cu
)
8686 /* Add a symbol for the namespace. */
8688 add_partial_symbol (pdi
, cu
);
8690 /* Now scan partial symbols in that module. */
8692 if (pdi
->has_children
)
8693 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, set_addrmap
, cu
);
8696 /* Read a partial die corresponding to a subprogram or an inlined
8697 subprogram and create a partial symbol for that subprogram.
8698 When the CU language allows it, this routine also defines a partial
8699 symbol for each nested subprogram that this subprogram contains.
8700 If SET_ADDRMAP is true, record the covered ranges in the addrmap.
8701 Set *LOWPC and *HIGHPC to the lowest and highest PC values found in PDI.
8703 PDI may also be a lexical block, in which case we simply search
8704 recursively for subprograms defined inside that lexical block.
8705 Again, this is only performed when the CU language allows this
8706 type of definitions. */
8709 add_partial_subprogram (struct partial_die_info
*pdi
,
8710 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
8711 int set_addrmap
, struct dwarf2_cu
*cu
)
8713 if (pdi
->tag
== DW_TAG_subprogram
|| pdi
->tag
== DW_TAG_inlined_subroutine
)
8715 if (pdi
->has_pc_info
)
8717 if (pdi
->lowpc
< *lowpc
)
8718 *lowpc
= pdi
->lowpc
;
8719 if (pdi
->highpc
> *highpc
)
8720 *highpc
= pdi
->highpc
;
8723 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
8724 struct gdbarch
*gdbarch
= objfile
->arch ();
8726 CORE_ADDR this_highpc
;
8727 CORE_ADDR this_lowpc
;
8729 baseaddr
= objfile
->text_section_offset ();
8731 = (gdbarch_adjust_dwarf2_addr (gdbarch
,
8732 pdi
->lowpc
+ baseaddr
)
8735 = (gdbarch_adjust_dwarf2_addr (gdbarch
,
8736 pdi
->highpc
+ baseaddr
)
8738 addrmap_set_empty (objfile
->partial_symtabs
->psymtabs_addrmap
,
8739 this_lowpc
, this_highpc
- 1,
8740 cu
->per_cu
->v
.psymtab
);
8744 if (pdi
->has_pc_info
|| (!pdi
->is_external
&& pdi
->may_be_inlined
))
8746 if (!pdi
->is_declaration
)
8747 /* Ignore subprogram DIEs that do not have a name, they are
8748 illegal. Do not emit a complaint at this point, we will
8749 do so when we convert this psymtab into a symtab. */
8751 add_partial_symbol (pdi
, cu
);
8755 if (! pdi
->has_children
)
8758 if (cu
->language
== language_ada
|| cu
->language
== language_fortran
)
8760 pdi
= pdi
->die_child
;
8764 if (pdi
->tag
== DW_TAG_subprogram
8765 || pdi
->tag
== DW_TAG_inlined_subroutine
8766 || pdi
->tag
== DW_TAG_lexical_block
)
8767 add_partial_subprogram (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
8768 pdi
= pdi
->die_sibling
;
8773 /* Read a partial die corresponding to an enumeration type. */
8776 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
8777 struct dwarf2_cu
*cu
)
8779 struct partial_die_info
*pdi
;
8781 if (enum_pdi
->name (cu
) != NULL
)
8782 add_partial_symbol (enum_pdi
, cu
);
8784 pdi
= enum_pdi
->die_child
;
8787 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->raw_name
== NULL
)
8788 complaint (_("malformed enumerator DIE ignored"));
8790 add_partial_symbol (pdi
, cu
);
8791 pdi
= pdi
->die_sibling
;
8795 /* Return the initial uleb128 in the die at INFO_PTR. */
8798 peek_abbrev_code (bfd
*abfd
, const gdb_byte
*info_ptr
)
8800 unsigned int bytes_read
;
8802 return read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
8805 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit
8806 READER::CU. Use READER::ABBREV_TABLE to lookup any abbreviation.
8808 Return the corresponding abbrev, or NULL if the number is zero (indicating
8809 an empty DIE). In either case *BYTES_READ will be set to the length of
8810 the initial number. */
8812 static const struct abbrev_info
*
8813 peek_die_abbrev (const die_reader_specs
&reader
,
8814 const gdb_byte
*info_ptr
, unsigned int *bytes_read
)
8816 dwarf2_cu
*cu
= reader
.cu
;
8817 bfd
*abfd
= reader
.abfd
;
8818 unsigned int abbrev_number
8819 = read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
8821 if (abbrev_number
== 0)
8824 const abbrev_info
*abbrev
8825 = reader
.abbrev_table
->lookup_abbrev (abbrev_number
);
8828 error (_("Dwarf Error: Could not find abbrev number %d in %s"
8829 " at offset %s [in module %s]"),
8830 abbrev_number
, cu
->per_cu
->is_debug_types
? "TU" : "CU",
8831 sect_offset_str (cu
->header
.sect_off
), bfd_get_filename (abfd
));
8837 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
8838 Returns a pointer to the end of a series of DIEs, terminated by an empty
8839 DIE. Any children of the skipped DIEs will also be skipped. */
8841 static const gdb_byte
*
8842 skip_children (const struct die_reader_specs
*reader
, const gdb_byte
*info_ptr
)
8846 unsigned int bytes_read
;
8847 const abbrev_info
*abbrev
= peek_die_abbrev (*reader
, info_ptr
,
8851 return info_ptr
+ bytes_read
;
8853 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
8857 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
8858 INFO_PTR should point just after the initial uleb128 of a DIE, and the
8859 abbrev corresponding to that skipped uleb128 should be passed in
8860 ABBREV. Returns a pointer to this DIE's sibling, skipping any
8863 static const gdb_byte
*
8864 skip_one_die (const struct die_reader_specs
*reader
, const gdb_byte
*info_ptr
,
8865 const struct abbrev_info
*abbrev
)
8867 unsigned int bytes_read
;
8868 struct attribute attr
;
8869 bfd
*abfd
= reader
->abfd
;
8870 struct dwarf2_cu
*cu
= reader
->cu
;
8871 const gdb_byte
*buffer
= reader
->buffer
;
8872 const gdb_byte
*buffer_end
= reader
->buffer_end
;
8873 unsigned int form
, i
;
8875 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
8877 /* The only abbrev we care about is DW_AT_sibling. */
8878 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
8880 read_attribute (reader
, &attr
, &abbrev
->attrs
[i
], info_ptr
);
8881 if (attr
.form
== DW_FORM_ref_addr
)
8882 complaint (_("ignoring absolute DW_AT_sibling"));
8885 sect_offset off
= attr
.get_ref_die_offset ();
8886 const gdb_byte
*sibling_ptr
= buffer
+ to_underlying (off
);
8888 if (sibling_ptr
< info_ptr
)
8889 complaint (_("DW_AT_sibling points backwards"));
8890 else if (sibling_ptr
> reader
->buffer_end
)
8891 reader
->die_section
->overflow_complaint ();
8897 /* If it isn't DW_AT_sibling, skip this attribute. */
8898 form
= abbrev
->attrs
[i
].form
;
8902 case DW_FORM_ref_addr
:
8903 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
8904 and later it is offset sized. */
8905 if (cu
->header
.version
== 2)
8906 info_ptr
+= cu
->header
.addr_size
;
8908 info_ptr
+= cu
->header
.offset_size
;
8910 case DW_FORM_GNU_ref_alt
:
8911 info_ptr
+= cu
->header
.offset_size
;
8914 info_ptr
+= cu
->header
.addr_size
;
8922 case DW_FORM_flag_present
:
8923 case DW_FORM_implicit_const
:
8940 case DW_FORM_ref_sig8
:
8943 case DW_FORM_data16
:
8946 case DW_FORM_string
:
8947 read_direct_string (abfd
, info_ptr
, &bytes_read
);
8948 info_ptr
+= bytes_read
;
8950 case DW_FORM_sec_offset
:
8952 case DW_FORM_GNU_strp_alt
:
8953 info_ptr
+= cu
->header
.offset_size
;
8955 case DW_FORM_exprloc
:
8957 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
8958 info_ptr
+= bytes_read
;
8960 case DW_FORM_block1
:
8961 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
8963 case DW_FORM_block2
:
8964 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
8966 case DW_FORM_block4
:
8967 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
8973 case DW_FORM_ref_udata
:
8974 case DW_FORM_GNU_addr_index
:
8975 case DW_FORM_GNU_str_index
:
8976 case DW_FORM_rnglistx
:
8977 case DW_FORM_loclistx
:
8978 info_ptr
= safe_skip_leb128 (info_ptr
, buffer_end
);
8980 case DW_FORM_indirect
:
8981 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
8982 info_ptr
+= bytes_read
;
8983 /* We need to continue parsing from here, so just go back to
8985 goto skip_attribute
;
8988 error (_("Dwarf Error: Cannot handle %s "
8989 "in DWARF reader [in module %s]"),
8990 dwarf_form_name (form
),
8991 bfd_get_filename (abfd
));
8995 if (abbrev
->has_children
)
8996 return skip_children (reader
, info_ptr
);
9001 /* Locate ORIG_PDI's sibling.
9002 INFO_PTR should point to the start of the next DIE after ORIG_PDI. */
9004 static const gdb_byte
*
9005 locate_pdi_sibling (const struct die_reader_specs
*reader
,
9006 struct partial_die_info
*orig_pdi
,
9007 const gdb_byte
*info_ptr
)
9009 /* Do we know the sibling already? */
9011 if (orig_pdi
->sibling
)
9012 return orig_pdi
->sibling
;
9014 /* Are there any children to deal with? */
9016 if (!orig_pdi
->has_children
)
9019 /* Skip the children the long way. */
9021 return skip_children (reader
, info_ptr
);
9024 /* Expand this partial symbol table into a full symbol table. SELF is
9028 dwarf2_psymtab::read_symtab (struct objfile
*objfile
)
9030 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
9032 gdb_assert (!per_objfile
->symtab_set_p (per_cu_data
));
9034 /* If this psymtab is constructed from a debug-only objfile, the
9035 has_section_at_zero flag will not necessarily be correct. We
9036 can get the correct value for this flag by looking at the data
9037 associated with the (presumably stripped) associated objfile. */
9038 if (objfile
->separate_debug_objfile_backlink
)
9040 dwarf2_per_objfile
*per_objfile_backlink
9041 = get_dwarf2_per_objfile (objfile
->separate_debug_objfile_backlink
);
9043 per_objfile
->per_bfd
->has_section_at_zero
9044 = per_objfile_backlink
->per_bfd
->has_section_at_zero
;
9047 expand_psymtab (objfile
);
9049 process_cu_includes (per_objfile
);
9052 /* Reading in full CUs. */
9054 /* Add PER_CU to the queue. */
9057 queue_comp_unit (dwarf2_per_cu_data
*per_cu
,
9058 dwarf2_per_objfile
*per_objfile
,
9059 enum language pretend_language
)
9063 gdb_assert (per_objfile
->per_bfd
->queue
.has_value ());
9064 per_cu
->per_bfd
->queue
->emplace (per_cu
, per_objfile
, pretend_language
);
9067 /* If PER_CU is not yet expanded of queued for expansion, add it to the queue.
9069 If DEPENDENT_CU is non-NULL, it has a reference to PER_CU so add a
9072 Return true if maybe_queue_comp_unit requires the caller to load the CU's
9073 DIEs, false otherwise.
9075 Explanation: there is an invariant that if a CU is queued for expansion
9076 (present in `dwarf2_per_bfd::queue`), then its DIEs are loaded
9077 (a dwarf2_cu object exists for this CU, and `dwarf2_per_objfile::get_cu`
9078 returns non-nullptr). If the CU gets enqueued by this function but its DIEs
9079 are not yet loaded, the the caller must load the CU's DIEs to ensure the
9080 invariant is respected.
9082 The caller is therefore not required to load the CU's DIEs (we return false)
9085 - the CU is already expanded, and therefore does not get enqueued
9086 - the CU gets enqueued for expansion, but its DIEs are already loaded
9088 Note that the caller should not use this function's return value as an
9089 indicator of whether the CU's DIEs are loaded right now, it should check
9090 that by calling `dwarf2_per_objfile::get_cu` instead. */
9093 maybe_queue_comp_unit (struct dwarf2_cu
*dependent_cu
,
9094 dwarf2_per_cu_data
*per_cu
,
9095 dwarf2_per_objfile
*per_objfile
,
9096 enum language pretend_language
)
9098 /* We may arrive here during partial symbol reading, if we need full
9099 DIEs to process an unusual case (e.g. template arguments). Do
9100 not queue PER_CU, just tell our caller to load its DIEs. */
9101 if (per_cu
->per_bfd
->reading_partial_symbols
)
9103 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
9105 if (cu
== NULL
|| cu
->dies
== NULL
)
9110 /* Mark the dependence relation so that we don't flush PER_CU
9112 if (dependent_cu
!= NULL
)
9113 dwarf2_add_dependence (dependent_cu
, per_cu
);
9115 /* If it's already on the queue, we have nothing to do. */
9118 /* Verify the invariant that if a CU is queued for expansion, its DIEs are
9120 gdb_assert (per_objfile
->get_cu (per_cu
) != nullptr);
9122 /* If the CU is queued for expansion, it should not already be
9124 gdb_assert (!per_objfile
->symtab_set_p (per_cu
));
9126 /* The DIEs are already loaded, the caller doesn't need to do it. */
9130 bool queued
= false;
9131 if (!per_objfile
->symtab_set_p (per_cu
))
9133 /* Add it to the queue. */
9134 queue_comp_unit (per_cu
, per_objfile
, pretend_language
);
9138 /* If the compilation unit is already loaded, just mark it as
9140 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
9144 /* Ask the caller to load the CU's DIEs if the CU got enqueued for expansion
9145 and the DIEs are not already loaded. */
9146 return queued
&& cu
== nullptr;
9149 /* Process the queue. */
9152 process_queue (dwarf2_per_objfile
*per_objfile
)
9154 dwarf_read_debug_printf ("Expanding one or more symtabs of objfile %s ...",
9155 objfile_name (per_objfile
->objfile
));
9157 /* The queue starts out with one item, but following a DIE reference
9158 may load a new CU, adding it to the end of the queue. */
9159 while (!per_objfile
->per_bfd
->queue
->empty ())
9161 dwarf2_queue_item
&item
= per_objfile
->per_bfd
->queue
->front ();
9162 dwarf2_per_cu_data
*per_cu
= item
.per_cu
;
9164 if (!per_objfile
->symtab_set_p (per_cu
))
9166 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
9168 /* Skip dummy CUs. */
9171 unsigned int debug_print_threshold
;
9174 if (per_cu
->is_debug_types
)
9176 struct signatured_type
*sig_type
=
9177 (struct signatured_type
*) per_cu
;
9179 sprintf (buf
, "TU %s at offset %s",
9180 hex_string (sig_type
->signature
),
9181 sect_offset_str (per_cu
->sect_off
));
9182 /* There can be 100s of TUs.
9183 Only print them in verbose mode. */
9184 debug_print_threshold
= 2;
9188 sprintf (buf
, "CU at offset %s",
9189 sect_offset_str (per_cu
->sect_off
));
9190 debug_print_threshold
= 1;
9193 if (dwarf_read_debug
>= debug_print_threshold
)
9194 dwarf_read_debug_printf ("Expanding symtab of %s", buf
);
9196 if (per_cu
->is_debug_types
)
9197 process_full_type_unit (cu
, item
.pretend_language
);
9199 process_full_comp_unit (cu
, item
.pretend_language
);
9201 if (dwarf_read_debug
>= debug_print_threshold
)
9202 dwarf_read_debug_printf ("Done expanding %s", buf
);
9207 per_objfile
->per_bfd
->queue
->pop ();
9210 dwarf_read_debug_printf ("Done expanding symtabs of %s.",
9211 objfile_name (per_objfile
->objfile
));
9214 /* Read in full symbols for PST, and anything it depends on. */
9217 dwarf2_psymtab::expand_psymtab (struct objfile
*objfile
)
9219 gdb_assert (!readin_p (objfile
));
9221 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
9222 free_cached_comp_units
freer (per_objfile
);
9223 expand_dependencies (objfile
);
9225 dw2_do_instantiate_symtab (per_cu_data
, per_objfile
, false);
9226 gdb_assert (get_compunit_symtab (objfile
) != nullptr);
9229 /* See psympriv.h. */
9232 dwarf2_psymtab::readin_p (struct objfile
*objfile
) const
9234 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
9235 return per_objfile
->symtab_set_p (per_cu_data
);
9238 /* See psympriv.h. */
9241 dwarf2_psymtab::get_compunit_symtab (struct objfile
*objfile
) const
9243 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
9244 return per_objfile
->get_symtab (per_cu_data
);
9247 /* Trivial hash function for die_info: the hash value of a DIE
9248 is its offset in .debug_info for this objfile. */
9251 die_hash (const void *item
)
9253 const struct die_info
*die
= (const struct die_info
*) item
;
9255 return to_underlying (die
->sect_off
);
9258 /* Trivial comparison function for die_info structures: two DIEs
9259 are equal if they have the same offset. */
9262 die_eq (const void *item_lhs
, const void *item_rhs
)
9264 const struct die_info
*die_lhs
= (const struct die_info
*) item_lhs
;
9265 const struct die_info
*die_rhs
= (const struct die_info
*) item_rhs
;
9267 return die_lhs
->sect_off
== die_rhs
->sect_off
;
9270 /* Load the DIEs associated with PER_CU into memory.
9272 In some cases, the caller, while reading partial symbols, will need to load
9273 the full symbols for the CU for some reason. It will already have a
9274 dwarf2_cu object for THIS_CU and pass it as EXISTING_CU, so it can be re-used
9275 rather than creating a new one. */
9278 load_full_comp_unit (dwarf2_per_cu_data
*this_cu
,
9279 dwarf2_per_objfile
*per_objfile
,
9280 dwarf2_cu
*existing_cu
,
9282 enum language pretend_language
)
9284 gdb_assert (! this_cu
->is_debug_types
);
9286 cutu_reader
reader (this_cu
, per_objfile
, NULL
, existing_cu
, skip_partial
);
9290 struct dwarf2_cu
*cu
= reader
.cu
;
9291 const gdb_byte
*info_ptr
= reader
.info_ptr
;
9293 gdb_assert (cu
->die_hash
== NULL
);
9295 htab_create_alloc_ex (cu
->header
.length
/ 12,
9299 &cu
->comp_unit_obstack
,
9300 hashtab_obstack_allocate
,
9301 dummy_obstack_deallocate
);
9303 if (reader
.comp_unit_die
->has_children
)
9304 reader
.comp_unit_die
->child
9305 = read_die_and_siblings (&reader
, reader
.info_ptr
,
9306 &info_ptr
, reader
.comp_unit_die
);
9307 cu
->dies
= reader
.comp_unit_die
;
9308 /* comp_unit_die is not stored in die_hash, no need. */
9310 /* We try not to read any attributes in this function, because not
9311 all CUs needed for references have been loaded yet, and symbol
9312 table processing isn't initialized. But we have to set the CU language,
9313 or we won't be able to build types correctly.
9314 Similarly, if we do not read the producer, we can not apply
9315 producer-specific interpretation. */
9316 prepare_one_comp_unit (cu
, cu
->dies
, pretend_language
);
9321 /* Add a DIE to the delayed physname list. */
9324 add_to_method_list (struct type
*type
, int fnfield_index
, int index
,
9325 const char *name
, struct die_info
*die
,
9326 struct dwarf2_cu
*cu
)
9328 struct delayed_method_info mi
;
9330 mi
.fnfield_index
= fnfield_index
;
9334 cu
->method_list
.push_back (mi
);
9337 /* Check whether [PHYSNAME, PHYSNAME+LEN) ends with a modifier like
9338 "const" / "volatile". If so, decrements LEN by the length of the
9339 modifier and return true. Otherwise return false. */
9343 check_modifier (const char *physname
, size_t &len
, const char (&mod
)[N
])
9345 size_t mod_len
= sizeof (mod
) - 1;
9346 if (len
> mod_len
&& startswith (physname
+ (len
- mod_len
), mod
))
9354 /* Compute the physnames of any methods on the CU's method list.
9356 The computation of method physnames is delayed in order to avoid the
9357 (bad) condition that one of the method's formal parameters is of an as yet
9361 compute_delayed_physnames (struct dwarf2_cu
*cu
)
9363 /* Only C++ delays computing physnames. */
9364 if (cu
->method_list
.empty ())
9366 gdb_assert (cu
->language
== language_cplus
);
9368 for (const delayed_method_info
&mi
: cu
->method_list
)
9370 const char *physname
;
9371 struct fn_fieldlist
*fn_flp
9372 = &TYPE_FN_FIELDLIST (mi
.type
, mi
.fnfield_index
);
9373 physname
= dwarf2_physname (mi
.name
, mi
.die
, cu
);
9374 TYPE_FN_FIELD_PHYSNAME (fn_flp
->fn_fields
, mi
.index
)
9375 = physname
? physname
: "";
9377 /* Since there's no tag to indicate whether a method is a
9378 const/volatile overload, extract that information out of the
9380 if (physname
!= NULL
)
9382 size_t len
= strlen (physname
);
9386 if (physname
[len
] == ')') /* shortcut */
9388 else if (check_modifier (physname
, len
, " const"))
9389 TYPE_FN_FIELD_CONST (fn_flp
->fn_fields
, mi
.index
) = 1;
9390 else if (check_modifier (physname
, len
, " volatile"))
9391 TYPE_FN_FIELD_VOLATILE (fn_flp
->fn_fields
, mi
.index
) = 1;
9398 /* The list is no longer needed. */
9399 cu
->method_list
.clear ();
9402 /* Go objects should be embedded in a DW_TAG_module DIE,
9403 and it's not clear if/how imported objects will appear.
9404 To keep Go support simple until that's worked out,
9405 go back through what we've read and create something usable.
9406 We could do this while processing each DIE, and feels kinda cleaner,
9407 but that way is more invasive.
9408 This is to, for example, allow the user to type "p var" or "b main"
9409 without having to specify the package name, and allow lookups
9410 of module.object to work in contexts that use the expression
9414 fixup_go_packaging (struct dwarf2_cu
*cu
)
9416 gdb::unique_xmalloc_ptr
<char> package_name
;
9417 struct pending
*list
;
9420 for (list
= *cu
->get_builder ()->get_global_symbols ();
9424 for (i
= 0; i
< list
->nsyms
; ++i
)
9426 struct symbol
*sym
= list
->symbol
[i
];
9428 if (sym
->language () == language_go
9429 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
9431 gdb::unique_xmalloc_ptr
<char> this_package_name
9432 (go_symbol_package_name (sym
));
9434 if (this_package_name
== NULL
)
9436 if (package_name
== NULL
)
9437 package_name
= std::move (this_package_name
);
9440 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
9441 if (strcmp (package_name
.get (), this_package_name
.get ()) != 0)
9442 complaint (_("Symtab %s has objects from two different Go packages: %s and %s"),
9443 (symbol_symtab (sym
) != NULL
9444 ? symtab_to_filename_for_display
9445 (symbol_symtab (sym
))
9446 : objfile_name (objfile
)),
9447 this_package_name
.get (), package_name
.get ());
9453 if (package_name
!= NULL
)
9455 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
9456 const char *saved_package_name
= objfile
->intern (package_name
.get ());
9457 struct type
*type
= init_type (objfile
, TYPE_CODE_MODULE
, 0,
9458 saved_package_name
);
9461 sym
= new (&objfile
->objfile_obstack
) symbol
;
9462 sym
->set_language (language_go
, &objfile
->objfile_obstack
);
9463 sym
->compute_and_set_names (saved_package_name
, false, objfile
->per_bfd
);
9464 /* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
9465 e.g., "main" finds the "main" module and not C's main(). */
9466 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
9467 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
9468 SYMBOL_TYPE (sym
) = type
;
9470 add_symbol_to_list (sym
, cu
->get_builder ()->get_global_symbols ());
9474 /* Allocate a fully-qualified name consisting of the two parts on the
9478 rust_fully_qualify (struct obstack
*obstack
, const char *p1
, const char *p2
)
9480 return obconcat (obstack
, p1
, "::", p2
, (char *) NULL
);
9483 /* A helper that allocates a variant part to attach to a Rust enum
9484 type. OBSTACK is where the results should be allocated. TYPE is
9485 the type we're processing. DISCRIMINANT_INDEX is the index of the
9486 discriminant. It must be the index of one of the fields of TYPE,
9487 or -1 to mean there is no discriminant (univariant enum).
9488 DEFAULT_INDEX is the index of the default field; or -1 if there is
9489 no default. RANGES is indexed by "effective" field number (the
9490 field index, but omitting the discriminant and default fields) and
9491 must hold the discriminant values used by the variants. Note that
9492 RANGES must have a lifetime at least as long as OBSTACK -- either
9493 already allocated on it, or static. */
9496 alloc_rust_variant (struct obstack
*obstack
, struct type
*type
,
9497 int discriminant_index
, int default_index
,
9498 gdb::array_view
<discriminant_range
> ranges
)
9500 /* When DISCRIMINANT_INDEX == -1, we have a univariant enum. */
9501 gdb_assert (discriminant_index
== -1
9502 || (discriminant_index
>= 0
9503 && discriminant_index
< type
->num_fields ()));
9504 gdb_assert (default_index
== -1
9505 || (default_index
>= 0 && default_index
< type
->num_fields ()));
9507 /* We have one variant for each non-discriminant field. */
9508 int n_variants
= type
->num_fields ();
9509 if (discriminant_index
!= -1)
9512 variant
*variants
= new (obstack
) variant
[n_variants
];
9515 for (int i
= 0; i
< type
->num_fields (); ++i
)
9517 if (i
== discriminant_index
)
9520 variants
[var_idx
].first_field
= i
;
9521 variants
[var_idx
].last_field
= i
+ 1;
9523 /* The default field does not need a range, but other fields do.
9524 We skipped the discriminant above. */
9525 if (i
!= default_index
)
9527 variants
[var_idx
].discriminants
= ranges
.slice (range_idx
, 1);
9534 gdb_assert (range_idx
== ranges
.size ());
9535 gdb_assert (var_idx
== n_variants
);
9537 variant_part
*part
= new (obstack
) variant_part
;
9538 part
->discriminant_index
= discriminant_index
;
9539 /* If there is no discriminant, then whether it is signed is of no
9542 = (discriminant_index
== -1
9544 : type
->field (discriminant_index
).type ()->is_unsigned ());
9545 part
->variants
= gdb::array_view
<variant
> (variants
, n_variants
);
9547 void *storage
= obstack_alloc (obstack
, sizeof (gdb::array_view
<variant_part
>));
9548 gdb::array_view
<variant_part
> *prop_value
9549 = new (storage
) gdb::array_view
<variant_part
> (part
, 1);
9551 struct dynamic_prop prop
;
9552 prop
.set_variant_parts (prop_value
);
9554 type
->add_dyn_prop (DYN_PROP_VARIANT_PARTS
, prop
);
9557 /* Some versions of rustc emitted enums in an unusual way.
9559 Ordinary enums were emitted as unions. The first element of each
9560 structure in the union was named "RUST$ENUM$DISR". This element
9561 held the discriminant.
9563 These versions of Rust also implemented the "non-zero"
9564 optimization. When the enum had two values, and one is empty and
9565 the other holds a pointer that cannot be zero, the pointer is used
9566 as the discriminant, with a zero value meaning the empty variant.
9567 Here, the union's first member is of the form
9568 RUST$ENCODED$ENUM$<fieldno>$<fieldno>$...$<variantname>
9569 where the fieldnos are the indices of the fields that should be
9570 traversed in order to find the field (which may be several fields deep)
9571 and the variantname is the name of the variant of the case when the
9574 This function recognizes whether TYPE is of one of these forms,
9575 and, if so, smashes it to be a variant type. */
9578 quirk_rust_enum (struct type
*type
, struct objfile
*objfile
)
9580 gdb_assert (type
->code () == TYPE_CODE_UNION
);
9582 /* We don't need to deal with empty enums. */
9583 if (type
->num_fields () == 0)
9586 #define RUST_ENUM_PREFIX "RUST$ENCODED$ENUM$"
9587 if (type
->num_fields () == 1
9588 && startswith (TYPE_FIELD_NAME (type
, 0), RUST_ENUM_PREFIX
))
9590 const char *name
= TYPE_FIELD_NAME (type
, 0) + strlen (RUST_ENUM_PREFIX
);
9592 /* Decode the field name to find the offset of the
9594 ULONGEST bit_offset
= 0;
9595 struct type
*field_type
= type
->field (0).type ();
9596 while (name
[0] >= '0' && name
[0] <= '9')
9599 unsigned long index
= strtoul (name
, &tail
, 10);
9602 || index
>= field_type
->num_fields ()
9603 || (TYPE_FIELD_LOC_KIND (field_type
, index
)
9604 != FIELD_LOC_KIND_BITPOS
))
9606 complaint (_("Could not parse Rust enum encoding string \"%s\""
9608 TYPE_FIELD_NAME (type
, 0),
9609 objfile_name (objfile
));
9614 bit_offset
+= TYPE_FIELD_BITPOS (field_type
, index
);
9615 field_type
= field_type
->field (index
).type ();
9618 /* Smash this type to be a structure type. We have to do this
9619 because the type has already been recorded. */
9620 type
->set_code (TYPE_CODE_STRUCT
);
9621 type
->set_num_fields (3);
9622 /* Save the field we care about. */
9623 struct field saved_field
= type
->field (0);
9625 ((struct field
*) TYPE_ZALLOC (type
, 3 * sizeof (struct field
)));
9627 /* Put the discriminant at index 0. */
9628 type
->field (0).set_type (field_type
);
9629 TYPE_FIELD_ARTIFICIAL (type
, 0) = 1;
9630 TYPE_FIELD_NAME (type
, 0) = "<<discriminant>>";
9631 SET_FIELD_BITPOS (type
->field (0), bit_offset
);
9633 /* The order of fields doesn't really matter, so put the real
9634 field at index 1 and the data-less field at index 2. */
9635 type
->field (1) = saved_field
;
9636 TYPE_FIELD_NAME (type
, 1)
9637 = rust_last_path_segment (type
->field (1).type ()->name ());
9638 type
->field (1).type ()->set_name
9639 (rust_fully_qualify (&objfile
->objfile_obstack
, type
->name (),
9640 TYPE_FIELD_NAME (type
, 1)));
9642 const char *dataless_name
9643 = rust_fully_qualify (&objfile
->objfile_obstack
, type
->name (),
9645 struct type
*dataless_type
= init_type (objfile
, TYPE_CODE_VOID
, 0,
9647 type
->field (2).set_type (dataless_type
);
9648 /* NAME points into the original discriminant name, which
9649 already has the correct lifetime. */
9650 TYPE_FIELD_NAME (type
, 2) = name
;
9651 SET_FIELD_BITPOS (type
->field (2), 0);
9653 /* Indicate that this is a variant type. */
9654 static discriminant_range ranges
[1] = { { 0, 0 } };
9655 alloc_rust_variant (&objfile
->objfile_obstack
, type
, 0, 1, ranges
);
9657 /* A union with a single anonymous field is probably an old-style
9659 else if (type
->num_fields () == 1 && streq (TYPE_FIELD_NAME (type
, 0), ""))
9661 /* Smash this type to be a structure type. We have to do this
9662 because the type has already been recorded. */
9663 type
->set_code (TYPE_CODE_STRUCT
);
9665 struct type
*field_type
= type
->field (0).type ();
9666 const char *variant_name
9667 = rust_last_path_segment (field_type
->name ());
9668 TYPE_FIELD_NAME (type
, 0) = variant_name
;
9669 field_type
->set_name
9670 (rust_fully_qualify (&objfile
->objfile_obstack
,
9671 type
->name (), variant_name
));
9673 alloc_rust_variant (&objfile
->objfile_obstack
, type
, -1, 0, {});
9677 struct type
*disr_type
= nullptr;
9678 for (int i
= 0; i
< type
->num_fields (); ++i
)
9680 disr_type
= type
->field (i
).type ();
9682 if (disr_type
->code () != TYPE_CODE_STRUCT
)
9684 /* All fields of a true enum will be structs. */
9687 else if (disr_type
->num_fields () == 0)
9689 /* Could be data-less variant, so keep going. */
9690 disr_type
= nullptr;
9692 else if (strcmp (TYPE_FIELD_NAME (disr_type
, 0),
9693 "RUST$ENUM$DISR") != 0)
9695 /* Not a Rust enum. */
9705 /* If we got here without a discriminant, then it's probably
9707 if (disr_type
== nullptr)
9710 /* Smash this type to be a structure type. We have to do this
9711 because the type has already been recorded. */
9712 type
->set_code (TYPE_CODE_STRUCT
);
9714 /* Make space for the discriminant field. */
9715 struct field
*disr_field
= &disr_type
->field (0);
9717 = (struct field
*) TYPE_ZALLOC (type
, ((type
->num_fields () + 1)
9718 * sizeof (struct field
)));
9719 memcpy (new_fields
+ 1, type
->fields (),
9720 type
->num_fields () * sizeof (struct field
));
9721 type
->set_fields (new_fields
);
9722 type
->set_num_fields (type
->num_fields () + 1);
9724 /* Install the discriminant at index 0 in the union. */
9725 type
->field (0) = *disr_field
;
9726 TYPE_FIELD_ARTIFICIAL (type
, 0) = 1;
9727 TYPE_FIELD_NAME (type
, 0) = "<<discriminant>>";
9729 /* We need a way to find the correct discriminant given a
9730 variant name. For convenience we build a map here. */
9731 struct type
*enum_type
= disr_field
->type ();
9732 std::unordered_map
<std::string
, ULONGEST
> discriminant_map
;
9733 for (int i
= 0; i
< enum_type
->num_fields (); ++i
)
9735 if (TYPE_FIELD_LOC_KIND (enum_type
, i
) == FIELD_LOC_KIND_ENUMVAL
)
9738 = rust_last_path_segment (TYPE_FIELD_NAME (enum_type
, i
));
9739 discriminant_map
[name
] = TYPE_FIELD_ENUMVAL (enum_type
, i
);
9743 int n_fields
= type
->num_fields ();
9744 /* We don't need a range entry for the discriminant, but we do
9745 need one for every other field, as there is no default
9747 discriminant_range
*ranges
= XOBNEWVEC (&objfile
->objfile_obstack
,
9750 /* Skip the discriminant here. */
9751 for (int i
= 1; i
< n_fields
; ++i
)
9753 /* Find the final word in the name of this variant's type.
9754 That name can be used to look up the correct
9756 const char *variant_name
9757 = rust_last_path_segment (type
->field (i
).type ()->name ());
9759 auto iter
= discriminant_map
.find (variant_name
);
9760 if (iter
!= discriminant_map
.end ())
9762 ranges
[i
- 1].low
= iter
->second
;
9763 ranges
[i
- 1].high
= iter
->second
;
9766 /* In Rust, each element should have the size of the
9768 TYPE_LENGTH (type
->field (i
).type ()) = TYPE_LENGTH (type
);
9770 /* Remove the discriminant field, if it exists. */
9771 struct type
*sub_type
= type
->field (i
).type ();
9772 if (sub_type
->num_fields () > 0)
9774 sub_type
->set_num_fields (sub_type
->num_fields () - 1);
9775 sub_type
->set_fields (sub_type
->fields () + 1);
9777 TYPE_FIELD_NAME (type
, i
) = variant_name
;
9779 (rust_fully_qualify (&objfile
->objfile_obstack
,
9780 type
->name (), variant_name
));
9783 /* Indicate that this is a variant type. */
9784 alloc_rust_variant (&objfile
->objfile_obstack
, type
, 0, -1,
9785 gdb::array_view
<discriminant_range
> (ranges
,
9790 /* Rewrite some Rust unions to be structures with variants parts. */
9793 rust_union_quirks (struct dwarf2_cu
*cu
)
9795 gdb_assert (cu
->language
== language_rust
);
9796 for (type
*type_
: cu
->rust_unions
)
9797 quirk_rust_enum (type_
, cu
->per_objfile
->objfile
);
9798 /* We don't need this any more. */
9799 cu
->rust_unions
.clear ();
9804 type_unit_group_unshareable
*
9805 dwarf2_per_objfile::get_type_unit_group_unshareable (type_unit_group
*tu_group
)
9807 auto iter
= this->m_type_units
.find (tu_group
);
9808 if (iter
!= this->m_type_units
.end ())
9809 return iter
->second
.get ();
9811 type_unit_group_unshareable_up
uniq (new type_unit_group_unshareable
);
9812 type_unit_group_unshareable
*result
= uniq
.get ();
9813 this->m_type_units
[tu_group
] = std::move (uniq
);
9818 dwarf2_per_objfile::get_type_for_signatured_type
9819 (signatured_type
*sig_type
) const
9821 auto iter
= this->m_type_map
.find (sig_type
);
9822 if (iter
== this->m_type_map
.end ())
9825 return iter
->second
;
9828 void dwarf2_per_objfile::set_type_for_signatured_type
9829 (signatured_type
*sig_type
, struct type
*type
)
9831 gdb_assert (this->m_type_map
.find (sig_type
) == this->m_type_map
.end ());
9833 this->m_type_map
[sig_type
] = type
;
9836 /* A helper function for computing the list of all symbol tables
9837 included by PER_CU. */
9840 recursively_compute_inclusions (std::vector
<compunit_symtab
*> *result
,
9841 htab_t all_children
, htab_t all_type_symtabs
,
9842 dwarf2_per_cu_data
*per_cu
,
9843 dwarf2_per_objfile
*per_objfile
,
9844 struct compunit_symtab
*immediate_parent
)
9846 void **slot
= htab_find_slot (all_children
, per_cu
, INSERT
);
9849 /* This inclusion and its children have been processed. */
9855 /* Only add a CU if it has a symbol table. */
9856 compunit_symtab
*cust
= per_objfile
->get_symtab (per_cu
);
9859 /* If this is a type unit only add its symbol table if we haven't
9860 seen it yet (type unit per_cu's can share symtabs). */
9861 if (per_cu
->is_debug_types
)
9863 slot
= htab_find_slot (all_type_symtabs
, cust
, INSERT
);
9867 result
->push_back (cust
);
9868 if (cust
->user
== NULL
)
9869 cust
->user
= immediate_parent
;
9874 result
->push_back (cust
);
9875 if (cust
->user
== NULL
)
9876 cust
->user
= immediate_parent
;
9880 if (!per_cu
->imported_symtabs_empty ())
9881 for (dwarf2_per_cu_data
*ptr
: *per_cu
->imported_symtabs
)
9883 recursively_compute_inclusions (result
, all_children
,
9884 all_type_symtabs
, ptr
, per_objfile
,
9889 /* Compute the compunit_symtab 'includes' fields for the compunit_symtab of
9893 compute_compunit_symtab_includes (dwarf2_per_cu_data
*per_cu
,
9894 dwarf2_per_objfile
*per_objfile
)
9896 gdb_assert (! per_cu
->is_debug_types
);
9898 if (!per_cu
->imported_symtabs_empty ())
9901 std::vector
<compunit_symtab
*> result_symtabs
;
9902 compunit_symtab
*cust
= per_objfile
->get_symtab (per_cu
);
9904 /* If we don't have a symtab, we can just skip this case. */
9908 htab_up
all_children (htab_create_alloc (1, htab_hash_pointer
,
9910 NULL
, xcalloc
, xfree
));
9911 htab_up
all_type_symtabs (htab_create_alloc (1, htab_hash_pointer
,
9913 NULL
, xcalloc
, xfree
));
9915 for (dwarf2_per_cu_data
*ptr
: *per_cu
->imported_symtabs
)
9917 recursively_compute_inclusions (&result_symtabs
, all_children
.get (),
9918 all_type_symtabs
.get (), ptr
,
9922 /* Now we have a transitive closure of all the included symtabs. */
9923 len
= result_symtabs
.size ();
9925 = XOBNEWVEC (&per_objfile
->objfile
->objfile_obstack
,
9926 struct compunit_symtab
*, len
+ 1);
9927 memcpy (cust
->includes
, result_symtabs
.data (),
9928 len
* sizeof (compunit_symtab
*));
9929 cust
->includes
[len
] = NULL
;
9933 /* Compute the 'includes' field for the symtabs of all the CUs we just
9937 process_cu_includes (dwarf2_per_objfile
*per_objfile
)
9939 for (dwarf2_per_cu_data
*iter
: per_objfile
->per_bfd
->just_read_cus
)
9941 if (! iter
->is_debug_types
)
9942 compute_compunit_symtab_includes (iter
, per_objfile
);
9945 per_objfile
->per_bfd
->just_read_cus
.clear ();
9948 /* Generate full symbol information for CU, whose DIEs have
9949 already been loaded into memory. */
9952 process_full_comp_unit (dwarf2_cu
*cu
, enum language pretend_language
)
9954 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
9955 struct objfile
*objfile
= per_objfile
->objfile
;
9956 struct gdbarch
*gdbarch
= objfile
->arch ();
9957 CORE_ADDR lowpc
, highpc
;
9958 struct compunit_symtab
*cust
;
9960 struct block
*static_block
;
9963 baseaddr
= objfile
->text_section_offset ();
9965 /* Clear the list here in case something was left over. */
9966 cu
->method_list
.clear ();
9968 cu
->language
= pretend_language
;
9969 cu
->language_defn
= language_def (cu
->language
);
9971 dwarf2_find_base_address (cu
->dies
, cu
);
9973 /* Do line number decoding in read_file_scope () */
9974 process_die (cu
->dies
, cu
);
9976 /* For now fudge the Go package. */
9977 if (cu
->language
== language_go
)
9978 fixup_go_packaging (cu
);
9980 /* Now that we have processed all the DIEs in the CU, all the types
9981 should be complete, and it should now be safe to compute all of the
9983 compute_delayed_physnames (cu
);
9985 if (cu
->language
== language_rust
)
9986 rust_union_quirks (cu
);
9988 /* Some compilers don't define a DW_AT_high_pc attribute for the
9989 compilation unit. If the DW_AT_high_pc is missing, synthesize
9990 it, by scanning the DIE's below the compilation unit. */
9991 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
9993 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
9994 static_block
= cu
->get_builder ()->end_symtab_get_static_block (addr
, 0, 1);
9996 /* If the comp unit has DW_AT_ranges, it may have discontiguous ranges.
9997 Also, DW_AT_ranges may record ranges not belonging to any child DIEs
9998 (such as virtual method tables). Record the ranges in STATIC_BLOCK's
9999 addrmap to help ensure it has an accurate map of pc values belonging to
10001 dwarf2_record_block_ranges (cu
->dies
, static_block
, baseaddr
, cu
);
10003 cust
= cu
->get_builder ()->end_symtab_from_static_block (static_block
,
10004 SECT_OFF_TEXT (objfile
),
10009 int gcc_4_minor
= producer_is_gcc_ge_4 (cu
->producer
);
10011 /* Set symtab language to language from DW_AT_language. If the
10012 compilation is from a C file generated by language preprocessors, do
10013 not set the language if it was already deduced by start_subfile. */
10014 if (!(cu
->language
== language_c
10015 && COMPUNIT_FILETABS (cust
)->language
!= language_unknown
))
10016 COMPUNIT_FILETABS (cust
)->language
= cu
->language
;
10018 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
10019 produce DW_AT_location with location lists but it can be possibly
10020 invalid without -fvar-tracking. Still up to GCC-4.4.x incl. 4.4.0
10021 there were bugs in prologue debug info, fixed later in GCC-4.5
10022 by "unwind info for epilogues" patch (which is not directly related).
10024 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
10025 needed, it would be wrong due to missing DW_AT_producer there.
10027 Still one can confuse GDB by using non-standard GCC compilation
10028 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
10030 if (cu
->has_loclist
&& gcc_4_minor
>= 5)
10031 cust
->locations_valid
= 1;
10033 if (gcc_4_minor
>= 5)
10034 cust
->epilogue_unwind_valid
= 1;
10036 cust
->call_site_htab
= cu
->call_site_htab
;
10039 per_objfile
->set_symtab (cu
->per_cu
, cust
);
10041 /* Push it for inclusion processing later. */
10042 per_objfile
->per_bfd
->just_read_cus
.push_back (cu
->per_cu
);
10044 /* Not needed any more. */
10045 cu
->reset_builder ();
10048 /* Generate full symbol information for type unit CU, whose DIEs have
10049 already been loaded into memory. */
10052 process_full_type_unit (dwarf2_cu
*cu
,
10053 enum language pretend_language
)
10055 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
10056 struct objfile
*objfile
= per_objfile
->objfile
;
10057 struct compunit_symtab
*cust
;
10058 struct signatured_type
*sig_type
;
10060 gdb_assert (cu
->per_cu
->is_debug_types
);
10061 sig_type
= (struct signatured_type
*) cu
->per_cu
;
10063 /* Clear the list here in case something was left over. */
10064 cu
->method_list
.clear ();
10066 cu
->language
= pretend_language
;
10067 cu
->language_defn
= language_def (cu
->language
);
10069 /* The symbol tables are set up in read_type_unit_scope. */
10070 process_die (cu
->dies
, cu
);
10072 /* For now fudge the Go package. */
10073 if (cu
->language
== language_go
)
10074 fixup_go_packaging (cu
);
10076 /* Now that we have processed all the DIEs in the CU, all the types
10077 should be complete, and it should now be safe to compute all of the
10079 compute_delayed_physnames (cu
);
10081 if (cu
->language
== language_rust
)
10082 rust_union_quirks (cu
);
10084 /* TUs share symbol tables.
10085 If this is the first TU to use this symtab, complete the construction
10086 of it with end_expandable_symtab. Otherwise, complete the addition of
10087 this TU's symbols to the existing symtab. */
10088 type_unit_group_unshareable
*tug_unshare
=
10089 per_objfile
->get_type_unit_group_unshareable (sig_type
->type_unit_group
);
10090 if (tug_unshare
->compunit_symtab
== NULL
)
10092 buildsym_compunit
*builder
= cu
->get_builder ();
10093 cust
= builder
->end_expandable_symtab (0, SECT_OFF_TEXT (objfile
));
10094 tug_unshare
->compunit_symtab
= cust
;
10098 /* Set symtab language to language from DW_AT_language. If the
10099 compilation is from a C file generated by language preprocessors,
10100 do not set the language if it was already deduced by
10102 if (!(cu
->language
== language_c
10103 && COMPUNIT_FILETABS (cust
)->language
!= language_c
))
10104 COMPUNIT_FILETABS (cust
)->language
= cu
->language
;
10109 cu
->get_builder ()->augment_type_symtab ();
10110 cust
= tug_unshare
->compunit_symtab
;
10113 per_objfile
->set_symtab (cu
->per_cu
, cust
);
10115 /* Not needed any more. */
10116 cu
->reset_builder ();
10119 /* Process an imported unit DIE. */
10122 process_imported_unit_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
10124 struct attribute
*attr
;
10126 /* For now we don't handle imported units in type units. */
10127 if (cu
->per_cu
->is_debug_types
)
10129 error (_("Dwarf Error: DW_TAG_imported_unit is not"
10130 " supported in type units [in module %s]"),
10131 objfile_name (cu
->per_objfile
->objfile
));
10134 attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
10137 sect_offset sect_off
= attr
->get_ref_die_offset ();
10138 bool is_dwz
= (attr
->form
== DW_FORM_GNU_ref_alt
|| cu
->per_cu
->is_dwz
);
10139 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
10140 dwarf2_per_cu_data
*per_cu
10141 = dwarf2_find_containing_comp_unit (sect_off
, is_dwz
, per_objfile
);
10143 /* We're importing a C++ compilation unit with tag DW_TAG_compile_unit
10144 into another compilation unit, at root level. Regard this as a hint,
10146 if (die
->parent
&& die
->parent
->parent
== NULL
10147 && per_cu
->unit_type
== DW_UT_compile
10148 && per_cu
->lang
== language_cplus
)
10151 /* If necessary, add it to the queue and load its DIEs. */
10152 if (maybe_queue_comp_unit (cu
, per_cu
, per_objfile
, cu
->language
))
10153 load_full_comp_unit (per_cu
, per_objfile
, per_objfile
->get_cu (per_cu
),
10154 false, cu
->language
);
10156 cu
->per_cu
->imported_symtabs_push (per_cu
);
10160 /* RAII object that represents a process_die scope: i.e.,
10161 starts/finishes processing a DIE. */
10162 class process_die_scope
10165 process_die_scope (die_info
*die
, dwarf2_cu
*cu
)
10166 : m_die (die
), m_cu (cu
)
10168 /* We should only be processing DIEs not already in process. */
10169 gdb_assert (!m_die
->in_process
);
10170 m_die
->in_process
= true;
10173 ~process_die_scope ()
10175 m_die
->in_process
= false;
10177 /* If we're done processing the DIE for the CU that owns the line
10178 header, we don't need the line header anymore. */
10179 if (m_cu
->line_header_die_owner
== m_die
)
10181 delete m_cu
->line_header
;
10182 m_cu
->line_header
= NULL
;
10183 m_cu
->line_header_die_owner
= NULL
;
10192 /* Process a die and its children. */
10195 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
10197 process_die_scope
scope (die
, cu
);
10201 case DW_TAG_padding
:
10203 case DW_TAG_compile_unit
:
10204 case DW_TAG_partial_unit
:
10205 read_file_scope (die
, cu
);
10207 case DW_TAG_type_unit
:
10208 read_type_unit_scope (die
, cu
);
10210 case DW_TAG_subprogram
:
10211 /* Nested subprograms in Fortran get a prefix. */
10212 if (cu
->language
== language_fortran
10213 && die
->parent
!= NULL
10214 && die
->parent
->tag
== DW_TAG_subprogram
)
10215 cu
->processing_has_namespace_info
= true;
10216 /* Fall through. */
10217 case DW_TAG_inlined_subroutine
:
10218 read_func_scope (die
, cu
);
10220 case DW_TAG_lexical_block
:
10221 case DW_TAG_try_block
:
10222 case DW_TAG_catch_block
:
10223 read_lexical_block_scope (die
, cu
);
10225 case DW_TAG_call_site
:
10226 case DW_TAG_GNU_call_site
:
10227 read_call_site_scope (die
, cu
);
10229 case DW_TAG_class_type
:
10230 case DW_TAG_interface_type
:
10231 case DW_TAG_structure_type
:
10232 case DW_TAG_union_type
:
10233 process_structure_scope (die
, cu
);
10235 case DW_TAG_enumeration_type
:
10236 process_enumeration_scope (die
, cu
);
10239 /* These dies have a type, but processing them does not create
10240 a symbol or recurse to process the children. Therefore we can
10241 read them on-demand through read_type_die. */
10242 case DW_TAG_subroutine_type
:
10243 case DW_TAG_set_type
:
10244 case DW_TAG_pointer_type
:
10245 case DW_TAG_ptr_to_member_type
:
10246 case DW_TAG_reference_type
:
10247 case DW_TAG_rvalue_reference_type
:
10248 case DW_TAG_string_type
:
10251 case DW_TAG_array_type
:
10252 /* We only need to handle this case for Ada -- in other
10253 languages, it's normal for the compiler to emit a typedef
10255 if (cu
->language
!= language_ada
)
10258 case DW_TAG_base_type
:
10259 case DW_TAG_subrange_type
:
10260 case DW_TAG_typedef
:
10261 /* Add a typedef symbol for the type definition, if it has a
10263 new_symbol (die
, read_type_die (die
, cu
), cu
);
10265 case DW_TAG_common_block
:
10266 read_common_block (die
, cu
);
10268 case DW_TAG_common_inclusion
:
10270 case DW_TAG_namespace
:
10271 cu
->processing_has_namespace_info
= true;
10272 read_namespace (die
, cu
);
10274 case DW_TAG_module
:
10275 cu
->processing_has_namespace_info
= true;
10276 read_module (die
, cu
);
10278 case DW_TAG_imported_declaration
:
10279 cu
->processing_has_namespace_info
= true;
10280 if (read_namespace_alias (die
, cu
))
10282 /* The declaration is not a global namespace alias. */
10283 /* Fall through. */
10284 case DW_TAG_imported_module
:
10285 cu
->processing_has_namespace_info
= true;
10286 if (die
->child
!= NULL
&& (die
->tag
== DW_TAG_imported_declaration
10287 || cu
->language
!= language_fortran
))
10288 complaint (_("Tag '%s' has unexpected children"),
10289 dwarf_tag_name (die
->tag
));
10290 read_import_statement (die
, cu
);
10293 case DW_TAG_imported_unit
:
10294 process_imported_unit_die (die
, cu
);
10297 case DW_TAG_variable
:
10298 read_variable (die
, cu
);
10302 new_symbol (die
, NULL
, cu
);
10307 /* DWARF name computation. */
10309 /* A helper function for dwarf2_compute_name which determines whether DIE
10310 needs to have the name of the scope prepended to the name listed in the
10314 die_needs_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
10316 struct attribute
*attr
;
10320 case DW_TAG_namespace
:
10321 case DW_TAG_typedef
:
10322 case DW_TAG_class_type
:
10323 case DW_TAG_interface_type
:
10324 case DW_TAG_structure_type
:
10325 case DW_TAG_union_type
:
10326 case DW_TAG_enumeration_type
:
10327 case DW_TAG_enumerator
:
10328 case DW_TAG_subprogram
:
10329 case DW_TAG_inlined_subroutine
:
10330 case DW_TAG_member
:
10331 case DW_TAG_imported_declaration
:
10334 case DW_TAG_variable
:
10335 case DW_TAG_constant
:
10336 /* We only need to prefix "globally" visible variables. These include
10337 any variable marked with DW_AT_external or any variable that
10338 lives in a namespace. [Variables in anonymous namespaces
10339 require prefixing, but they are not DW_AT_external.] */
10341 if (dwarf2_attr (die
, DW_AT_specification
, cu
))
10343 struct dwarf2_cu
*spec_cu
= cu
;
10345 return die_needs_namespace (die_specification (die
, &spec_cu
),
10349 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
10350 if (attr
== NULL
&& die
->parent
->tag
!= DW_TAG_namespace
10351 && die
->parent
->tag
!= DW_TAG_module
)
10353 /* A variable in a lexical block of some kind does not need a
10354 namespace, even though in C++ such variables may be external
10355 and have a mangled name. */
10356 if (die
->parent
->tag
== DW_TAG_lexical_block
10357 || die
->parent
->tag
== DW_TAG_try_block
10358 || die
->parent
->tag
== DW_TAG_catch_block
10359 || die
->parent
->tag
== DW_TAG_subprogram
)
10368 /* Return the DIE's linkage name attribute, either DW_AT_linkage_name
10369 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
10370 defined for the given DIE. */
10372 static struct attribute
*
10373 dw2_linkage_name_attr (struct die_info
*die
, struct dwarf2_cu
*cu
)
10375 struct attribute
*attr
;
10377 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
10379 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
10384 /* Return the DIE's linkage name as a string, either DW_AT_linkage_name
10385 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
10386 defined for the given DIE. */
10388 static const char *
10389 dw2_linkage_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
10391 const char *linkage_name
;
10393 linkage_name
= dwarf2_string_attr (die
, DW_AT_linkage_name
, cu
);
10394 if (linkage_name
== NULL
)
10395 linkage_name
= dwarf2_string_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
10397 /* rustc emits invalid values for DW_AT_linkage_name. Ignore these.
10398 See https://github.com/rust-lang/rust/issues/32925. */
10399 if (cu
->language
== language_rust
&& linkage_name
!= NULL
10400 && strchr (linkage_name
, '{') != NULL
)
10401 linkage_name
= NULL
;
10403 return linkage_name
;
10406 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
10407 compute the physname for the object, which include a method's:
10408 - formal parameters (C++),
10409 - receiver type (Go),
10411 The term "physname" is a bit confusing.
10412 For C++, for example, it is the demangled name.
10413 For Go, for example, it's the mangled name.
10415 For Ada, return the DIE's linkage name rather than the fully qualified
10416 name. PHYSNAME is ignored..
10418 The result is allocated on the objfile->per_bfd's obstack and
10421 static const char *
10422 dwarf2_compute_name (const char *name
,
10423 struct die_info
*die
, struct dwarf2_cu
*cu
,
10426 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
10429 name
= dwarf2_name (die
, cu
);
10431 /* For Fortran GDB prefers DW_AT_*linkage_name for the physname if present
10432 but otherwise compute it by typename_concat inside GDB.
10433 FIXME: Actually this is not really true, or at least not always true.
10434 It's all very confusing. compute_and_set_names doesn't try to demangle
10435 Fortran names because there is no mangling standard. So new_symbol
10436 will set the demangled name to the result of dwarf2_full_name, and it is
10437 the demangled name that GDB uses if it exists. */
10438 if (cu
->language
== language_ada
10439 || (cu
->language
== language_fortran
&& physname
))
10441 /* For Ada unit, we prefer the linkage name over the name, as
10442 the former contains the exported name, which the user expects
10443 to be able to reference. Ideally, we want the user to be able
10444 to reference this entity using either natural or linkage name,
10445 but we haven't started looking at this enhancement yet. */
10446 const char *linkage_name
= dw2_linkage_name (die
, cu
);
10448 if (linkage_name
!= NULL
)
10449 return linkage_name
;
10452 /* These are the only languages we know how to qualify names in. */
10454 && (cu
->language
== language_cplus
10455 || cu
->language
== language_fortran
|| cu
->language
== language_d
10456 || cu
->language
== language_rust
))
10458 if (die_needs_namespace (die
, cu
))
10460 const char *prefix
;
10461 const char *canonical_name
= NULL
;
10465 prefix
= determine_prefix (die
, cu
);
10466 if (*prefix
!= '\0')
10468 gdb::unique_xmalloc_ptr
<char> prefixed_name
10469 (typename_concat (NULL
, prefix
, name
, physname
, cu
));
10471 buf
.puts (prefixed_name
.get ());
10476 /* Template parameters may be specified in the DIE's DW_AT_name, or
10477 as children with DW_TAG_template_type_param or
10478 DW_TAG_value_type_param. If the latter, add them to the name
10479 here. If the name already has template parameters, then
10480 skip this step; some versions of GCC emit both, and
10481 it is more efficient to use the pre-computed name.
10483 Something to keep in mind about this process: it is very
10484 unlikely, or in some cases downright impossible, to produce
10485 something that will match the mangled name of a function.
10486 If the definition of the function has the same debug info,
10487 we should be able to match up with it anyway. But fallbacks
10488 using the minimal symbol, for instance to find a method
10489 implemented in a stripped copy of libstdc++, will not work.
10490 If we do not have debug info for the definition, we will have to
10491 match them up some other way.
10493 When we do name matching there is a related problem with function
10494 templates; two instantiated function templates are allowed to
10495 differ only by their return types, which we do not add here. */
10497 if (cu
->language
== language_cplus
&& strchr (name
, '<') == NULL
)
10499 struct attribute
*attr
;
10500 struct die_info
*child
;
10502 const language_defn
*cplus_lang
= language_def (cu
->language
);
10504 die
->building_fullname
= 1;
10506 for (child
= die
->child
; child
!= NULL
; child
= child
->sibling
)
10510 const gdb_byte
*bytes
;
10511 struct dwarf2_locexpr_baton
*baton
;
10514 if (child
->tag
!= DW_TAG_template_type_param
10515 && child
->tag
!= DW_TAG_template_value_param
)
10526 attr
= dwarf2_attr (child
, DW_AT_type
, cu
);
10529 complaint (_("template parameter missing DW_AT_type"));
10530 buf
.puts ("UNKNOWN_TYPE");
10533 type
= die_type (child
, cu
);
10535 if (child
->tag
== DW_TAG_template_type_param
)
10537 cplus_lang
->print_type (type
, "", &buf
, -1, 0,
10538 &type_print_raw_options
);
10542 attr
= dwarf2_attr (child
, DW_AT_const_value
, cu
);
10545 complaint (_("template parameter missing "
10546 "DW_AT_const_value"));
10547 buf
.puts ("UNKNOWN_VALUE");
10551 dwarf2_const_value_attr (attr
, type
, name
,
10552 &cu
->comp_unit_obstack
, cu
,
10553 &value
, &bytes
, &baton
);
10555 if (type
->has_no_signedness ())
10556 /* GDB prints characters as NUMBER 'CHAR'. If that's
10557 changed, this can use value_print instead. */
10558 cplus_lang
->printchar (value
, type
, &buf
);
10561 struct value_print_options opts
;
10564 v
= dwarf2_evaluate_loc_desc (type
, NULL
,
10568 baton
->per_objfile
);
10569 else if (bytes
!= NULL
)
10571 v
= allocate_value (type
);
10572 memcpy (value_contents_writeable (v
), bytes
,
10573 TYPE_LENGTH (type
));
10576 v
= value_from_longest (type
, value
);
10578 /* Specify decimal so that we do not depend on
10580 get_formatted_print_options (&opts
, 'd');
10582 value_print (v
, &buf
, &opts
);
10587 die
->building_fullname
= 0;
10591 /* Close the argument list, with a space if necessary
10592 (nested templates). */
10593 if (!buf
.empty () && buf
.string ().back () == '>')
10600 /* For C++ methods, append formal parameter type
10601 information, if PHYSNAME. */
10603 if (physname
&& die
->tag
== DW_TAG_subprogram
10604 && cu
->language
== language_cplus
)
10606 struct type
*type
= read_type_die (die
, cu
);
10608 c_type_print_args (type
, &buf
, 1, cu
->language
,
10609 &type_print_raw_options
);
10611 if (cu
->language
== language_cplus
)
10613 /* Assume that an artificial first parameter is
10614 "this", but do not crash if it is not. RealView
10615 marks unnamed (and thus unused) parameters as
10616 artificial; there is no way to differentiate
10618 if (type
->num_fields () > 0
10619 && TYPE_FIELD_ARTIFICIAL (type
, 0)
10620 && type
->field (0).type ()->code () == TYPE_CODE_PTR
10621 && TYPE_CONST (TYPE_TARGET_TYPE (type
->field (0).type ())))
10622 buf
.puts (" const");
10626 const std::string
&intermediate_name
= buf
.string ();
10628 if (cu
->language
== language_cplus
)
10630 = dwarf2_canonicalize_name (intermediate_name
.c_str (), cu
,
10633 /* If we only computed INTERMEDIATE_NAME, or if
10634 INTERMEDIATE_NAME is already canonical, then we need to
10636 if (canonical_name
== NULL
|| canonical_name
== intermediate_name
.c_str ())
10637 name
= objfile
->intern (intermediate_name
);
10639 name
= canonical_name
;
10646 /* Return the fully qualified name of DIE, based on its DW_AT_name.
10647 If scope qualifiers are appropriate they will be added. The result
10648 will be allocated on the storage_obstack, or NULL if the DIE does
10649 not have a name. NAME may either be from a previous call to
10650 dwarf2_name or NULL.
10652 The output string will be canonicalized (if C++). */
10654 static const char *
10655 dwarf2_full_name (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
10657 return dwarf2_compute_name (name
, die
, cu
, 0);
10660 /* Construct a physname for the given DIE in CU. NAME may either be
10661 from a previous call to dwarf2_name or NULL. The result will be
10662 allocated on the objfile_objstack or NULL if the DIE does not have a
10665 The output string will be canonicalized (if C++). */
10667 static const char *
10668 dwarf2_physname (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
10670 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
10671 const char *retval
, *mangled
= NULL
, *canon
= NULL
;
10674 /* In this case dwarf2_compute_name is just a shortcut not building anything
10676 if (!die_needs_namespace (die
, cu
))
10677 return dwarf2_compute_name (name
, die
, cu
, 1);
10679 if (cu
->language
!= language_rust
)
10680 mangled
= dw2_linkage_name (die
, cu
);
10682 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
10684 gdb::unique_xmalloc_ptr
<char> demangled
;
10685 if (mangled
!= NULL
)
10688 if (language_def (cu
->language
)->store_sym_names_in_linkage_form_p ())
10690 /* Do nothing (do not demangle the symbol name). */
10694 /* Use DMGL_RET_DROP for C++ template functions to suppress
10695 their return type. It is easier for GDB users to search
10696 for such functions as `name(params)' than `long name(params)'.
10697 In such case the minimal symbol names do not match the full
10698 symbol names but for template functions there is never a need
10699 to look up their definition from their declaration so
10700 the only disadvantage remains the minimal symbol variant
10701 `long name(params)' does not have the proper inferior type. */
10702 demangled
.reset (gdb_demangle (mangled
,
10703 (DMGL_PARAMS
| DMGL_ANSI
10704 | DMGL_RET_DROP
)));
10707 canon
= demangled
.get ();
10715 if (canon
== NULL
|| check_physname
)
10717 const char *physname
= dwarf2_compute_name (name
, die
, cu
, 1);
10719 if (canon
!= NULL
&& strcmp (physname
, canon
) != 0)
10721 /* It may not mean a bug in GDB. The compiler could also
10722 compute DW_AT_linkage_name incorrectly. But in such case
10723 GDB would need to be bug-to-bug compatible. */
10725 complaint (_("Computed physname <%s> does not match demangled <%s> "
10726 "(from linkage <%s>) - DIE at %s [in module %s]"),
10727 physname
, canon
, mangled
, sect_offset_str (die
->sect_off
),
10728 objfile_name (objfile
));
10730 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
10731 is available here - over computed PHYSNAME. It is safer
10732 against both buggy GDB and buggy compilers. */
10746 retval
= objfile
->intern (retval
);
10751 /* Inspect DIE in CU for a namespace alias. If one exists, record
10752 a new symbol for it.
10754 Returns 1 if a namespace alias was recorded, 0 otherwise. */
10757 read_namespace_alias (struct die_info
*die
, struct dwarf2_cu
*cu
)
10759 struct attribute
*attr
;
10761 /* If the die does not have a name, this is not a namespace
10763 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
10767 struct die_info
*d
= die
;
10768 struct dwarf2_cu
*imported_cu
= cu
;
10770 /* If the compiler has nested DW_AT_imported_declaration DIEs,
10771 keep inspecting DIEs until we hit the underlying import. */
10772 #define MAX_NESTED_IMPORTED_DECLARATIONS 100
10773 for (num
= 0; num
< MAX_NESTED_IMPORTED_DECLARATIONS
; ++num
)
10775 attr
= dwarf2_attr (d
, DW_AT_import
, cu
);
10779 d
= follow_die_ref (d
, attr
, &imported_cu
);
10780 if (d
->tag
!= DW_TAG_imported_declaration
)
10784 if (num
== MAX_NESTED_IMPORTED_DECLARATIONS
)
10786 complaint (_("DIE at %s has too many recursively imported "
10787 "declarations"), sect_offset_str (d
->sect_off
));
10794 sect_offset sect_off
= attr
->get_ref_die_offset ();
10796 type
= get_die_type_at_offset (sect_off
, cu
->per_cu
, cu
->per_objfile
);
10797 if (type
!= NULL
&& type
->code () == TYPE_CODE_NAMESPACE
)
10799 /* This declaration is a global namespace alias. Add
10800 a symbol for it whose type is the aliased namespace. */
10801 new_symbol (die
, type
, cu
);
10810 /* Return the using directives repository (global or local?) to use in the
10811 current context for CU.
10813 For Ada, imported declarations can materialize renamings, which *may* be
10814 global. However it is impossible (for now?) in DWARF to distinguish
10815 "external" imported declarations and "static" ones. As all imported
10816 declarations seem to be static in all other languages, make them all CU-wide
10817 global only in Ada. */
10819 static struct using_direct
**
10820 using_directives (struct dwarf2_cu
*cu
)
10822 if (cu
->language
== language_ada
10823 && cu
->get_builder ()->outermost_context_p ())
10824 return cu
->get_builder ()->get_global_using_directives ();
10826 return cu
->get_builder ()->get_local_using_directives ();
10829 /* Read the import statement specified by the given die and record it. */
10832 read_import_statement (struct die_info
*die
, struct dwarf2_cu
*cu
)
10834 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
10835 struct attribute
*import_attr
;
10836 struct die_info
*imported_die
, *child_die
;
10837 struct dwarf2_cu
*imported_cu
;
10838 const char *imported_name
;
10839 const char *imported_name_prefix
;
10840 const char *canonical_name
;
10841 const char *import_alias
;
10842 const char *imported_declaration
= NULL
;
10843 const char *import_prefix
;
10844 std::vector
<const char *> excludes
;
10846 import_attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
10847 if (import_attr
== NULL
)
10849 complaint (_("Tag '%s' has no DW_AT_import"),
10850 dwarf_tag_name (die
->tag
));
10855 imported_die
= follow_die_ref_or_sig (die
, import_attr
, &imported_cu
);
10856 imported_name
= dwarf2_name (imported_die
, imported_cu
);
10857 if (imported_name
== NULL
)
10859 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
10861 The import in the following code:
10875 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
10876 <52> DW_AT_decl_file : 1
10877 <53> DW_AT_decl_line : 6
10878 <54> DW_AT_import : <0x75>
10879 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
10880 <59> DW_AT_name : B
10881 <5b> DW_AT_decl_file : 1
10882 <5c> DW_AT_decl_line : 2
10883 <5d> DW_AT_type : <0x6e>
10885 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
10886 <76> DW_AT_byte_size : 4
10887 <77> DW_AT_encoding : 5 (signed)
10889 imports the wrong die ( 0x75 instead of 0x58 ).
10890 This case will be ignored until the gcc bug is fixed. */
10894 /* Figure out the local name after import. */
10895 import_alias
= dwarf2_name (die
, cu
);
10897 /* Figure out where the statement is being imported to. */
10898 import_prefix
= determine_prefix (die
, cu
);
10900 /* Figure out what the scope of the imported die is and prepend it
10901 to the name of the imported die. */
10902 imported_name_prefix
= determine_prefix (imported_die
, imported_cu
);
10904 if (imported_die
->tag
!= DW_TAG_namespace
10905 && imported_die
->tag
!= DW_TAG_module
)
10907 imported_declaration
= imported_name
;
10908 canonical_name
= imported_name_prefix
;
10910 else if (strlen (imported_name_prefix
) > 0)
10911 canonical_name
= obconcat (&objfile
->objfile_obstack
,
10912 imported_name_prefix
,
10913 (cu
->language
== language_d
? "." : "::"),
10914 imported_name
, (char *) NULL
);
10916 canonical_name
= imported_name
;
10918 if (die
->tag
== DW_TAG_imported_module
&& cu
->language
== language_fortran
)
10919 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
10920 child_die
= child_die
->sibling
)
10922 /* DWARF-4: A Fortran use statement with a “rename list” may be
10923 represented by an imported module entry with an import attribute
10924 referring to the module and owned entries corresponding to those
10925 entities that are renamed as part of being imported. */
10927 if (child_die
->tag
!= DW_TAG_imported_declaration
)
10929 complaint (_("child DW_TAG_imported_declaration expected "
10930 "- DIE at %s [in module %s]"),
10931 sect_offset_str (child_die
->sect_off
),
10932 objfile_name (objfile
));
10936 import_attr
= dwarf2_attr (child_die
, DW_AT_import
, cu
);
10937 if (import_attr
== NULL
)
10939 complaint (_("Tag '%s' has no DW_AT_import"),
10940 dwarf_tag_name (child_die
->tag
));
10945 imported_die
= follow_die_ref_or_sig (child_die
, import_attr
,
10947 imported_name
= dwarf2_name (imported_die
, imported_cu
);
10948 if (imported_name
== NULL
)
10950 complaint (_("child DW_TAG_imported_declaration has unknown "
10951 "imported name - DIE at %s [in module %s]"),
10952 sect_offset_str (child_die
->sect_off
),
10953 objfile_name (objfile
));
10957 excludes
.push_back (imported_name
);
10959 process_die (child_die
, cu
);
10962 add_using_directive (using_directives (cu
),
10966 imported_declaration
,
10969 &objfile
->objfile_obstack
);
10972 /* ICC<14 does not output the required DW_AT_declaration on incomplete
10973 types, but gives them a size of zero. Starting with version 14,
10974 ICC is compatible with GCC. */
10977 producer_is_icc_lt_14 (struct dwarf2_cu
*cu
)
10979 if (!cu
->checked_producer
)
10980 check_producer (cu
);
10982 return cu
->producer_is_icc_lt_14
;
10985 /* ICC generates a DW_AT_type for C void functions. This was observed on
10986 ICC 14.0.5.212, and appears to be against the DWARF spec (V5 3.3.2)
10987 which says that void functions should not have a DW_AT_type. */
10990 producer_is_icc (struct dwarf2_cu
*cu
)
10992 if (!cu
->checked_producer
)
10993 check_producer (cu
);
10995 return cu
->producer_is_icc
;
10998 /* Check for possibly missing DW_AT_comp_dir with relative .debug_line
10999 directory paths. GCC SVN r127613 (new option -fdebug-prefix-map) fixed
11000 this, it was first present in GCC release 4.3.0. */
11003 producer_is_gcc_lt_4_3 (struct dwarf2_cu
*cu
)
11005 if (!cu
->checked_producer
)
11006 check_producer (cu
);
11008 return cu
->producer_is_gcc_lt_4_3
;
11011 static file_and_directory
11012 find_file_and_directory (struct die_info
*die
, struct dwarf2_cu
*cu
)
11014 file_and_directory res
;
11016 /* Find the filename. Do not use dwarf2_name here, since the filename
11017 is not a source language identifier. */
11018 res
.name
= dwarf2_string_attr (die
, DW_AT_name
, cu
);
11019 res
.comp_dir
= dwarf2_string_attr (die
, DW_AT_comp_dir
, cu
);
11021 if (res
.comp_dir
== NULL
11022 && producer_is_gcc_lt_4_3 (cu
) && res
.name
!= NULL
11023 && IS_ABSOLUTE_PATH (res
.name
))
11025 res
.comp_dir_storage
= ldirname (res
.name
);
11026 if (!res
.comp_dir_storage
.empty ())
11027 res
.comp_dir
= res
.comp_dir_storage
.c_str ();
11029 if (res
.comp_dir
!= NULL
)
11031 /* Irix 6.2 native cc prepends <machine>.: to the compilation
11032 directory, get rid of it. */
11033 const char *cp
= strchr (res
.comp_dir
, ':');
11035 if (cp
&& cp
!= res
.comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
11036 res
.comp_dir
= cp
+ 1;
11039 if (res
.name
== NULL
)
11040 res
.name
= "<unknown>";
11045 /* Handle DW_AT_stmt_list for a compilation unit.
11046 DIE is the DW_TAG_compile_unit die for CU.
11047 COMP_DIR is the compilation directory. LOWPC is passed to
11048 dwarf_decode_lines. See dwarf_decode_lines comments about it. */
11051 handle_DW_AT_stmt_list (struct die_info
*die
, struct dwarf2_cu
*cu
,
11052 const char *comp_dir
, CORE_ADDR lowpc
) /* ARI: editCase function */
11054 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
11055 struct attribute
*attr
;
11056 struct line_header line_header_local
;
11057 hashval_t line_header_local_hash
;
11059 int decode_mapping
;
11061 gdb_assert (! cu
->per_cu
->is_debug_types
);
11063 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
11064 if (attr
== NULL
|| !attr
->form_is_unsigned ())
11067 sect_offset line_offset
= (sect_offset
) attr
->as_unsigned ();
11069 /* The line header hash table is only created if needed (it exists to
11070 prevent redundant reading of the line table for partial_units).
11071 If we're given a partial_unit, we'll need it. If we're given a
11072 compile_unit, then use the line header hash table if it's already
11073 created, but don't create one just yet. */
11075 if (per_objfile
->line_header_hash
== NULL
11076 && die
->tag
== DW_TAG_partial_unit
)
11078 per_objfile
->line_header_hash
11079 .reset (htab_create_alloc (127, line_header_hash_voidp
,
11080 line_header_eq_voidp
,
11081 free_line_header_voidp
,
11085 line_header_local
.sect_off
= line_offset
;
11086 line_header_local
.offset_in_dwz
= cu
->per_cu
->is_dwz
;
11087 line_header_local_hash
= line_header_hash (&line_header_local
);
11088 if (per_objfile
->line_header_hash
!= NULL
)
11090 slot
= htab_find_slot_with_hash (per_objfile
->line_header_hash
.get (),
11091 &line_header_local
,
11092 line_header_local_hash
, NO_INSERT
);
11094 /* For DW_TAG_compile_unit we need info like symtab::linetable which
11095 is not present in *SLOT (since if there is something in *SLOT then
11096 it will be for a partial_unit). */
11097 if (die
->tag
== DW_TAG_partial_unit
&& slot
!= NULL
)
11099 gdb_assert (*slot
!= NULL
);
11100 cu
->line_header
= (struct line_header
*) *slot
;
11105 /* dwarf_decode_line_header does not yet provide sufficient information.
11106 We always have to call also dwarf_decode_lines for it. */
11107 line_header_up lh
= dwarf_decode_line_header (line_offset
, cu
);
11111 cu
->line_header
= lh
.release ();
11112 cu
->line_header_die_owner
= die
;
11114 if (per_objfile
->line_header_hash
== NULL
)
11118 slot
= htab_find_slot_with_hash (per_objfile
->line_header_hash
.get (),
11119 &line_header_local
,
11120 line_header_local_hash
, INSERT
);
11121 gdb_assert (slot
!= NULL
);
11123 if (slot
!= NULL
&& *slot
== NULL
)
11125 /* This newly decoded line number information unit will be owned
11126 by line_header_hash hash table. */
11127 *slot
= cu
->line_header
;
11128 cu
->line_header_die_owner
= NULL
;
11132 /* We cannot free any current entry in (*slot) as that struct line_header
11133 may be already used by multiple CUs. Create only temporary decoded
11134 line_header for this CU - it may happen at most once for each line
11135 number information unit. And if we're not using line_header_hash
11136 then this is what we want as well. */
11137 gdb_assert (die
->tag
!= DW_TAG_partial_unit
);
11139 decode_mapping
= (die
->tag
!= DW_TAG_partial_unit
);
11140 dwarf_decode_lines (cu
->line_header
, comp_dir
, cu
, NULL
, lowpc
,
11145 /* Process DW_TAG_compile_unit or DW_TAG_partial_unit. */
11148 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
11150 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
11151 struct objfile
*objfile
= per_objfile
->objfile
;
11152 struct gdbarch
*gdbarch
= objfile
->arch ();
11153 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
11154 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
11155 struct attribute
*attr
;
11156 struct die_info
*child_die
;
11157 CORE_ADDR baseaddr
;
11159 prepare_one_comp_unit (cu
, die
, cu
->language
);
11160 baseaddr
= objfile
->text_section_offset ();
11162 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
11164 /* If we didn't find a lowpc, set it to highpc to avoid complaints
11165 from finish_block. */
11166 if (lowpc
== ((CORE_ADDR
) -1))
11168 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
11170 file_and_directory fnd
= find_file_and_directory (die
, cu
);
11172 /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
11173 standardised yet. As a workaround for the language detection we fall
11174 back to the DW_AT_producer string. */
11175 if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL") != NULL
)
11176 cu
->language
= language_opencl
;
11178 /* Similar hack for Go. */
11179 if (cu
->producer
&& strstr (cu
->producer
, "GNU Go ") != NULL
)
11180 set_cu_language (DW_LANG_Go
, cu
);
11182 cu
->start_symtab (fnd
.name
, fnd
.comp_dir
, lowpc
);
11184 /* Decode line number information if present. We do this before
11185 processing child DIEs, so that the line header table is available
11186 for DW_AT_decl_file. */
11187 handle_DW_AT_stmt_list (die
, cu
, fnd
.comp_dir
, lowpc
);
11189 /* Process all dies in compilation unit. */
11190 if (die
->child
!= NULL
)
11192 child_die
= die
->child
;
11193 while (child_die
&& child_die
->tag
)
11195 process_die (child_die
, cu
);
11196 child_die
= child_die
->sibling
;
11200 /* Decode macro information, if present. Dwarf 2 macro information
11201 refers to information in the line number info statement program
11202 header, so we can only read it if we've read the header
11204 attr
= dwarf2_attr (die
, DW_AT_macros
, cu
);
11206 attr
= dwarf2_attr (die
, DW_AT_GNU_macros
, cu
);
11207 if (attr
!= nullptr && attr
->form_is_unsigned () && cu
->line_header
)
11209 if (dwarf2_attr (die
, DW_AT_macro_info
, cu
))
11210 complaint (_("CU refers to both DW_AT_macros and DW_AT_macro_info"));
11212 dwarf_decode_macros (cu
, attr
->as_unsigned (), 1);
11216 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
11217 if (attr
!= nullptr && attr
->form_is_unsigned () && cu
->line_header
)
11219 unsigned int macro_offset
= attr
->as_unsigned ();
11221 dwarf_decode_macros (cu
, macro_offset
, 0);
11227 dwarf2_cu::setup_type_unit_groups (struct die_info
*die
)
11229 struct type_unit_group
*tu_group
;
11231 struct attribute
*attr
;
11233 struct signatured_type
*sig_type
;
11235 gdb_assert (per_cu
->is_debug_types
);
11236 sig_type
= (struct signatured_type
*) per_cu
;
11238 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, this);
11240 /* If we're using .gdb_index (includes -readnow) then
11241 per_cu->type_unit_group may not have been set up yet. */
11242 if (sig_type
->type_unit_group
== NULL
)
11243 sig_type
->type_unit_group
= get_type_unit_group (this, attr
);
11244 tu_group
= sig_type
->type_unit_group
;
11246 /* If we've already processed this stmt_list there's no real need to
11247 do it again, we could fake it and just recreate the part we need
11248 (file name,index -> symtab mapping). If data shows this optimization
11249 is useful we can do it then. */
11250 type_unit_group_unshareable
*tug_unshare
11251 = per_objfile
->get_type_unit_group_unshareable (tu_group
);
11252 first_time
= tug_unshare
->compunit_symtab
== NULL
;
11254 /* We have to handle the case of both a missing DW_AT_stmt_list or bad
11257 if (attr
!= NULL
&& attr
->form_is_unsigned ())
11259 sect_offset line_offset
= (sect_offset
) attr
->as_unsigned ();
11260 lh
= dwarf_decode_line_header (line_offset
, this);
11265 start_symtab ("", NULL
, 0);
11268 gdb_assert (tug_unshare
->symtabs
== NULL
);
11269 gdb_assert (m_builder
== nullptr);
11270 struct compunit_symtab
*cust
= tug_unshare
->compunit_symtab
;
11271 m_builder
.reset (new struct buildsym_compunit
11272 (COMPUNIT_OBJFILE (cust
), "",
11273 COMPUNIT_DIRNAME (cust
),
11274 compunit_language (cust
),
11276 list_in_scope
= get_builder ()->get_file_symbols ();
11281 line_header
= lh
.release ();
11282 line_header_die_owner
= die
;
11286 struct compunit_symtab
*cust
= start_symtab ("", NULL
, 0);
11288 /* Note: We don't assign tu_group->compunit_symtab yet because we're
11289 still initializing it, and our caller (a few levels up)
11290 process_full_type_unit still needs to know if this is the first
11293 tug_unshare
->symtabs
11294 = XOBNEWVEC (&COMPUNIT_OBJFILE (cust
)->objfile_obstack
,
11295 struct symtab
*, line_header
->file_names_size ());
11297 auto &file_names
= line_header
->file_names ();
11298 for (i
= 0; i
< file_names
.size (); ++i
)
11300 file_entry
&fe
= file_names
[i
];
11301 dwarf2_start_subfile (this, fe
.name
,
11302 fe
.include_dir (line_header
));
11303 buildsym_compunit
*b
= get_builder ();
11304 if (b
->get_current_subfile ()->symtab
== NULL
)
11306 /* NOTE: start_subfile will recognize when it's been
11307 passed a file it has already seen. So we can't
11308 assume there's a simple mapping from
11309 cu->line_header->file_names to subfiles, plus
11310 cu->line_header->file_names may contain dups. */
11311 b
->get_current_subfile ()->symtab
11312 = allocate_symtab (cust
, b
->get_current_subfile ()->name
);
11315 fe
.symtab
= b
->get_current_subfile ()->symtab
;
11316 tug_unshare
->symtabs
[i
] = fe
.symtab
;
11321 gdb_assert (m_builder
== nullptr);
11322 struct compunit_symtab
*cust
= tug_unshare
->compunit_symtab
;
11323 m_builder
.reset (new struct buildsym_compunit
11324 (COMPUNIT_OBJFILE (cust
), "",
11325 COMPUNIT_DIRNAME (cust
),
11326 compunit_language (cust
),
11328 list_in_scope
= get_builder ()->get_file_symbols ();
11330 auto &file_names
= line_header
->file_names ();
11331 for (i
= 0; i
< file_names
.size (); ++i
)
11333 file_entry
&fe
= file_names
[i
];
11334 fe
.symtab
= tug_unshare
->symtabs
[i
];
11338 /* The main symtab is allocated last. Type units don't have DW_AT_name
11339 so they don't have a "real" (so to speak) symtab anyway.
11340 There is later code that will assign the main symtab to all symbols
11341 that don't have one. We need to handle the case of a symbol with a
11342 missing symtab (DW_AT_decl_file) anyway. */
11345 /* Process DW_TAG_type_unit.
11346 For TUs we want to skip the first top level sibling if it's not the
11347 actual type being defined by this TU. In this case the first top
11348 level sibling is there to provide context only. */
11351 read_type_unit_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
11353 struct die_info
*child_die
;
11355 prepare_one_comp_unit (cu
, die
, language_minimal
);
11357 /* Initialize (or reinitialize) the machinery for building symtabs.
11358 We do this before processing child DIEs, so that the line header table
11359 is available for DW_AT_decl_file. */
11360 cu
->setup_type_unit_groups (die
);
11362 if (die
->child
!= NULL
)
11364 child_die
= die
->child
;
11365 while (child_die
&& child_die
->tag
)
11367 process_die (child_die
, cu
);
11368 child_die
= child_die
->sibling
;
11375 http://gcc.gnu.org/wiki/DebugFission
11376 http://gcc.gnu.org/wiki/DebugFissionDWP
11378 To simplify handling of both DWO files ("object" files with the DWARF info)
11379 and DWP files (a file with the DWOs packaged up into one file), we treat
11380 DWP files as having a collection of virtual DWO files. */
11383 hash_dwo_file (const void *item
)
11385 const struct dwo_file
*dwo_file
= (const struct dwo_file
*) item
;
11388 hash
= htab_hash_string (dwo_file
->dwo_name
);
11389 if (dwo_file
->comp_dir
!= NULL
)
11390 hash
+= htab_hash_string (dwo_file
->comp_dir
);
11395 eq_dwo_file (const void *item_lhs
, const void *item_rhs
)
11397 const struct dwo_file
*lhs
= (const struct dwo_file
*) item_lhs
;
11398 const struct dwo_file
*rhs
= (const struct dwo_file
*) item_rhs
;
11400 if (strcmp (lhs
->dwo_name
, rhs
->dwo_name
) != 0)
11402 if (lhs
->comp_dir
== NULL
|| rhs
->comp_dir
== NULL
)
11403 return lhs
->comp_dir
== rhs
->comp_dir
;
11404 return strcmp (lhs
->comp_dir
, rhs
->comp_dir
) == 0;
11407 /* Allocate a hash table for DWO files. */
11410 allocate_dwo_file_hash_table ()
11412 auto delete_dwo_file
= [] (void *item
)
11414 struct dwo_file
*dwo_file
= (struct dwo_file
*) item
;
11419 return htab_up (htab_create_alloc (41,
11426 /* Lookup DWO file DWO_NAME. */
11429 lookup_dwo_file_slot (dwarf2_per_objfile
*per_objfile
,
11430 const char *dwo_name
,
11431 const char *comp_dir
)
11433 struct dwo_file find_entry
;
11436 if (per_objfile
->per_bfd
->dwo_files
== NULL
)
11437 per_objfile
->per_bfd
->dwo_files
= allocate_dwo_file_hash_table ();
11439 find_entry
.dwo_name
= dwo_name
;
11440 find_entry
.comp_dir
= comp_dir
;
11441 slot
= htab_find_slot (per_objfile
->per_bfd
->dwo_files
.get (), &find_entry
,
11448 hash_dwo_unit (const void *item
)
11450 const struct dwo_unit
*dwo_unit
= (const struct dwo_unit
*) item
;
11452 /* This drops the top 32 bits of the id, but is ok for a hash. */
11453 return dwo_unit
->signature
;
11457 eq_dwo_unit (const void *item_lhs
, const void *item_rhs
)
11459 const struct dwo_unit
*lhs
= (const struct dwo_unit
*) item_lhs
;
11460 const struct dwo_unit
*rhs
= (const struct dwo_unit
*) item_rhs
;
11462 /* The signature is assumed to be unique within the DWO file.
11463 So while object file CU dwo_id's always have the value zero,
11464 that's OK, assuming each object file DWO file has only one CU,
11465 and that's the rule for now. */
11466 return lhs
->signature
== rhs
->signature
;
11469 /* Allocate a hash table for DWO CUs,TUs.
11470 There is one of these tables for each of CUs,TUs for each DWO file. */
11473 allocate_dwo_unit_table ()
11475 /* Start out with a pretty small number.
11476 Generally DWO files contain only one CU and maybe some TUs. */
11477 return htab_up (htab_create_alloc (3,
11480 NULL
, xcalloc
, xfree
));
11483 /* die_reader_func for create_dwo_cu. */
11486 create_dwo_cu_reader (const struct die_reader_specs
*reader
,
11487 const gdb_byte
*info_ptr
,
11488 struct die_info
*comp_unit_die
,
11489 struct dwo_file
*dwo_file
,
11490 struct dwo_unit
*dwo_unit
)
11492 struct dwarf2_cu
*cu
= reader
->cu
;
11493 sect_offset sect_off
= cu
->per_cu
->sect_off
;
11494 struct dwarf2_section_info
*section
= cu
->per_cu
->section
;
11496 gdb::optional
<ULONGEST
> signature
= lookup_dwo_id (cu
, comp_unit_die
);
11497 if (!signature
.has_value ())
11499 complaint (_("Dwarf Error: debug entry at offset %s is missing"
11500 " its dwo_id [in module %s]"),
11501 sect_offset_str (sect_off
), dwo_file
->dwo_name
);
11505 dwo_unit
->dwo_file
= dwo_file
;
11506 dwo_unit
->signature
= *signature
;
11507 dwo_unit
->section
= section
;
11508 dwo_unit
->sect_off
= sect_off
;
11509 dwo_unit
->length
= cu
->per_cu
->length
;
11511 dwarf_read_debug_printf (" offset %s, dwo_id %s",
11512 sect_offset_str (sect_off
),
11513 hex_string (dwo_unit
->signature
));
11516 /* Create the dwo_units for the CUs in a DWO_FILE.
11517 Note: This function processes DWO files only, not DWP files. */
11520 create_cus_hash_table (dwarf2_per_objfile
*per_objfile
,
11521 dwarf2_cu
*cu
, struct dwo_file
&dwo_file
,
11522 dwarf2_section_info
§ion
, htab_up
&cus_htab
)
11524 struct objfile
*objfile
= per_objfile
->objfile
;
11525 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
11526 const gdb_byte
*info_ptr
, *end_ptr
;
11528 section
.read (objfile
);
11529 info_ptr
= section
.buffer
;
11531 if (info_ptr
== NULL
)
11534 dwarf_read_debug_printf ("Reading %s for %s:",
11535 section
.get_name (),
11536 section
.get_file_name ());
11538 end_ptr
= info_ptr
+ section
.size
;
11539 while (info_ptr
< end_ptr
)
11541 struct dwarf2_per_cu_data per_cu
;
11542 struct dwo_unit read_unit
{};
11543 struct dwo_unit
*dwo_unit
;
11545 sect_offset sect_off
= (sect_offset
) (info_ptr
- section
.buffer
);
11547 memset (&per_cu
, 0, sizeof (per_cu
));
11548 per_cu
.per_bfd
= per_bfd
;
11549 per_cu
.is_debug_types
= 0;
11550 per_cu
.sect_off
= sect_offset (info_ptr
- section
.buffer
);
11551 per_cu
.section
= §ion
;
11553 cutu_reader
reader (&per_cu
, per_objfile
, cu
, &dwo_file
);
11554 if (!reader
.dummy_p
)
11555 create_dwo_cu_reader (&reader
, reader
.info_ptr
, reader
.comp_unit_die
,
11556 &dwo_file
, &read_unit
);
11557 info_ptr
+= per_cu
.length
;
11559 // If the unit could not be parsed, skip it.
11560 if (read_unit
.dwo_file
== NULL
)
11563 if (cus_htab
== NULL
)
11564 cus_htab
= allocate_dwo_unit_table ();
11566 dwo_unit
= OBSTACK_ZALLOC (&per_bfd
->obstack
,
11568 *dwo_unit
= read_unit
;
11569 slot
= htab_find_slot (cus_htab
.get (), dwo_unit
, INSERT
);
11570 gdb_assert (slot
!= NULL
);
11573 const struct dwo_unit
*dup_cu
= (const struct dwo_unit
*)*slot
;
11574 sect_offset dup_sect_off
= dup_cu
->sect_off
;
11576 complaint (_("debug cu entry at offset %s is duplicate to"
11577 " the entry at offset %s, signature %s"),
11578 sect_offset_str (sect_off
), sect_offset_str (dup_sect_off
),
11579 hex_string (dwo_unit
->signature
));
11581 *slot
= (void *)dwo_unit
;
11585 /* DWP file .debug_{cu,tu}_index section format:
11586 [ref: http://gcc.gnu.org/wiki/DebugFissionDWP]
11587 [ref: http://dwarfstd.org/doc/DWARF5.pdf, sect 7.3.5 "DWARF Package Files"]
11589 DWP Versions 1 & 2 are older, pre-standard format versions. The first
11590 officially standard DWP format was published with DWARF v5 and is called
11591 Version 5. There are no versions 3 or 4.
11595 Both index sections have the same format, and serve to map a 64-bit
11596 signature to a set of section numbers. Each section begins with a header,
11597 followed by a hash table of 64-bit signatures, a parallel table of 32-bit
11598 indexes, and a pool of 32-bit section numbers. The index sections will be
11599 aligned at 8-byte boundaries in the file.
11601 The index section header consists of:
11603 V, 32 bit version number
11605 N, 32 bit number of compilation units or type units in the index
11606 M, 32 bit number of slots in the hash table
11608 Numbers are recorded using the byte order of the application binary.
11610 The hash table begins at offset 16 in the section, and consists of an array
11611 of M 64-bit slots. Each slot contains a 64-bit signature (using the byte
11612 order of the application binary). Unused slots in the hash table are 0.
11613 (We rely on the extreme unlikeliness of a signature being exactly 0.)
11615 The parallel table begins immediately after the hash table
11616 (at offset 16 + 8 * M from the beginning of the section), and consists of an
11617 array of 32-bit indexes (using the byte order of the application binary),
11618 corresponding 1-1 with slots in the hash table. Each entry in the parallel
11619 table contains a 32-bit index into the pool of section numbers. For unused
11620 hash table slots, the corresponding entry in the parallel table will be 0.
11622 The pool of section numbers begins immediately following the hash table
11623 (at offset 16 + 12 * M from the beginning of the section). The pool of
11624 section numbers consists of an array of 32-bit words (using the byte order
11625 of the application binary). Each item in the array is indexed starting
11626 from 0. The hash table entry provides the index of the first section
11627 number in the set. Additional section numbers in the set follow, and the
11628 set is terminated by a 0 entry (section number 0 is not used in ELF).
11630 In each set of section numbers, the .debug_info.dwo or .debug_types.dwo
11631 section must be the first entry in the set, and the .debug_abbrev.dwo must
11632 be the second entry. Other members of the set may follow in any order.
11636 DWP Versions 2 and 5:
11638 DWP Versions 2 and 5 combine all the .debug_info, etc. sections into one,
11639 and the entries in the index tables are now offsets into these sections.
11640 CU offsets begin at 0. TU offsets begin at the size of the .debug_info
11643 Index Section Contents:
11645 Hash Table of Signatures dwp_hash_table.hash_table
11646 Parallel Table of Indices dwp_hash_table.unit_table
11647 Table of Section Offsets dwp_hash_table.{v2|v5}.{section_ids,offsets}
11648 Table of Section Sizes dwp_hash_table.{v2|v5}.sizes
11650 The index section header consists of:
11652 V, 32 bit version number
11653 L, 32 bit number of columns in the table of section offsets
11654 N, 32 bit number of compilation units or type units in the index
11655 M, 32 bit number of slots in the hash table
11657 Numbers are recorded using the byte order of the application binary.
11659 The hash table has the same format as version 1.
11660 The parallel table of indices has the same format as version 1,
11661 except that the entries are origin-1 indices into the table of sections
11662 offsets and the table of section sizes.
11664 The table of offsets begins immediately following the parallel table
11665 (at offset 16 + 12 * M from the beginning of the section). The table is
11666 a two-dimensional array of 32-bit words (using the byte order of the
11667 application binary), with L columns and N+1 rows, in row-major order.
11668 Each row in the array is indexed starting from 0. The first row provides
11669 a key to the remaining rows: each column in this row provides an identifier
11670 for a debug section, and the offsets in the same column of subsequent rows
11671 refer to that section. The section identifiers for Version 2 are:
11673 DW_SECT_INFO 1 .debug_info.dwo
11674 DW_SECT_TYPES 2 .debug_types.dwo
11675 DW_SECT_ABBREV 3 .debug_abbrev.dwo
11676 DW_SECT_LINE 4 .debug_line.dwo
11677 DW_SECT_LOC 5 .debug_loc.dwo
11678 DW_SECT_STR_OFFSETS 6 .debug_str_offsets.dwo
11679 DW_SECT_MACINFO 7 .debug_macinfo.dwo
11680 DW_SECT_MACRO 8 .debug_macro.dwo
11682 The section identifiers for Version 5 are:
11684 DW_SECT_INFO_V5 1 .debug_info.dwo
11685 DW_SECT_RESERVED_V5 2 --
11686 DW_SECT_ABBREV_V5 3 .debug_abbrev.dwo
11687 DW_SECT_LINE_V5 4 .debug_line.dwo
11688 DW_SECT_LOCLISTS_V5 5 .debug_loclists.dwo
11689 DW_SECT_STR_OFFSETS_V5 6 .debug_str_offsets.dwo
11690 DW_SECT_MACRO_V5 7 .debug_macro.dwo
11691 DW_SECT_RNGLISTS_V5 8 .debug_rnglists.dwo
11693 The offsets provided by the CU and TU index sections are the base offsets
11694 for the contributions made by each CU or TU to the corresponding section
11695 in the package file. Each CU and TU header contains an abbrev_offset
11696 field, used to find the abbreviations table for that CU or TU within the
11697 contribution to the .debug_abbrev.dwo section for that CU or TU, and should
11698 be interpreted as relative to the base offset given in the index section.
11699 Likewise, offsets into .debug_line.dwo from DW_AT_stmt_list attributes
11700 should be interpreted as relative to the base offset for .debug_line.dwo,
11701 and offsets into other debug sections obtained from DWARF attributes should
11702 also be interpreted as relative to the corresponding base offset.
11704 The table of sizes begins immediately following the table of offsets.
11705 Like the table of offsets, it is a two-dimensional array of 32-bit words,
11706 with L columns and N rows, in row-major order. Each row in the array is
11707 indexed starting from 1 (row 0 is shared by the two tables).
11711 Hash table lookup is handled the same in version 1 and 2:
11713 We assume that N and M will not exceed 2^32 - 1.
11714 The size of the hash table, M, must be 2^k such that 2^k > 3*N/2.
11716 Given a 64-bit compilation unit signature or a type signature S, an entry
11717 in the hash table is located as follows:
11719 1) Calculate a primary hash H = S & MASK(k), where MASK(k) is a mask with
11720 the low-order k bits all set to 1.
11722 2) Calculate a secondary hash H' = (((S >> 32) & MASK(k)) | 1).
11724 3) If the hash table entry at index H matches the signature, use that
11725 entry. If the hash table entry at index H is unused (all zeroes),
11726 terminate the search: the signature is not present in the table.
11728 4) Let H = (H + H') modulo M. Repeat at Step 3.
11730 Because M > N and H' and M are relatively prime, the search is guaranteed
11731 to stop at an unused slot or find the match. */
11733 /* Create a hash table to map DWO IDs to their CU/TU entry in
11734 .debug_{info,types}.dwo in DWP_FILE.
11735 Returns NULL if there isn't one.
11736 Note: This function processes DWP files only, not DWO files. */
11738 static struct dwp_hash_table
*
11739 create_dwp_hash_table (dwarf2_per_objfile
*per_objfile
,
11740 struct dwp_file
*dwp_file
, int is_debug_types
)
11742 struct objfile
*objfile
= per_objfile
->objfile
;
11743 bfd
*dbfd
= dwp_file
->dbfd
.get ();
11744 const gdb_byte
*index_ptr
, *index_end
;
11745 struct dwarf2_section_info
*index
;
11746 uint32_t version
, nr_columns
, nr_units
, nr_slots
;
11747 struct dwp_hash_table
*htab
;
11749 if (is_debug_types
)
11750 index
= &dwp_file
->sections
.tu_index
;
11752 index
= &dwp_file
->sections
.cu_index
;
11754 if (index
->empty ())
11756 index
->read (objfile
);
11758 index_ptr
= index
->buffer
;
11759 index_end
= index_ptr
+ index
->size
;
11761 /* For Version 5, the version is really 2 bytes of data & 2 bytes of padding.
11762 For now it's safe to just read 4 bytes (particularly as it's difficult to
11763 tell if you're dealing with Version 5 before you've read the version). */
11764 version
= read_4_bytes (dbfd
, index_ptr
);
11766 if (version
== 2 || version
== 5)
11767 nr_columns
= read_4_bytes (dbfd
, index_ptr
);
11771 nr_units
= read_4_bytes (dbfd
, index_ptr
);
11773 nr_slots
= read_4_bytes (dbfd
, index_ptr
);
11776 if (version
!= 1 && version
!= 2 && version
!= 5)
11778 error (_("Dwarf Error: unsupported DWP file version (%s)"
11779 " [in module %s]"),
11780 pulongest (version
), dwp_file
->name
);
11782 if (nr_slots
!= (nr_slots
& -nr_slots
))
11784 error (_("Dwarf Error: number of slots in DWP hash table (%s)"
11785 " is not power of 2 [in module %s]"),
11786 pulongest (nr_slots
), dwp_file
->name
);
11789 htab
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, struct dwp_hash_table
);
11790 htab
->version
= version
;
11791 htab
->nr_columns
= nr_columns
;
11792 htab
->nr_units
= nr_units
;
11793 htab
->nr_slots
= nr_slots
;
11794 htab
->hash_table
= index_ptr
;
11795 htab
->unit_table
= htab
->hash_table
+ sizeof (uint64_t) * nr_slots
;
11797 /* Exit early if the table is empty. */
11798 if (nr_slots
== 0 || nr_units
== 0
11799 || (version
== 2 && nr_columns
== 0)
11800 || (version
== 5 && nr_columns
== 0))
11802 /* All must be zero. */
11803 if (nr_slots
!= 0 || nr_units
!= 0
11804 || (version
== 2 && nr_columns
!= 0)
11805 || (version
== 5 && nr_columns
!= 0))
11807 complaint (_("Empty DWP but nr_slots,nr_units,nr_columns not"
11808 " all zero [in modules %s]"),
11816 htab
->section_pool
.v1
.indices
=
11817 htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
11818 /* It's harder to decide whether the section is too small in v1.
11819 V1 is deprecated anyway so we punt. */
11821 else if (version
== 2)
11823 const gdb_byte
*ids_ptr
= htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
11824 int *ids
= htab
->section_pool
.v2
.section_ids
;
11825 size_t sizeof_ids
= sizeof (htab
->section_pool
.v2
.section_ids
);
11826 /* Reverse map for error checking. */
11827 int ids_seen
[DW_SECT_MAX
+ 1];
11830 if (nr_columns
< 2)
11832 error (_("Dwarf Error: bad DWP hash table, too few columns"
11833 " in section table [in module %s]"),
11836 if (nr_columns
> MAX_NR_V2_DWO_SECTIONS
)
11838 error (_("Dwarf Error: bad DWP hash table, too many columns"
11839 " in section table [in module %s]"),
11842 memset (ids
, 255, sizeof_ids
);
11843 memset (ids_seen
, 255, sizeof (ids_seen
));
11844 for (i
= 0; i
< nr_columns
; ++i
)
11846 int id
= read_4_bytes (dbfd
, ids_ptr
+ i
* sizeof (uint32_t));
11848 if (id
< DW_SECT_MIN
|| id
> DW_SECT_MAX
)
11850 error (_("Dwarf Error: bad DWP hash table, bad section id %d"
11851 " in section table [in module %s]"),
11852 id
, dwp_file
->name
);
11854 if (ids_seen
[id
] != -1)
11856 error (_("Dwarf Error: bad DWP hash table, duplicate section"
11857 " id %d in section table [in module %s]"),
11858 id
, dwp_file
->name
);
11863 /* Must have exactly one info or types section. */
11864 if (((ids_seen
[DW_SECT_INFO
] != -1)
11865 + (ids_seen
[DW_SECT_TYPES
] != -1))
11868 error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
11869 " DWO info/types section [in module %s]"),
11872 /* Must have an abbrev section. */
11873 if (ids_seen
[DW_SECT_ABBREV
] == -1)
11875 error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
11876 " section [in module %s]"),
11879 htab
->section_pool
.v2
.offsets
= ids_ptr
+ sizeof (uint32_t) * nr_columns
;
11880 htab
->section_pool
.v2
.sizes
=
11881 htab
->section_pool
.v2
.offsets
+ (sizeof (uint32_t)
11882 * nr_units
* nr_columns
);
11883 if ((htab
->section_pool
.v2
.sizes
+ (sizeof (uint32_t)
11884 * nr_units
* nr_columns
))
11887 error (_("Dwarf Error: DWP index section is corrupt (too small)"
11888 " [in module %s]"),
11892 else /* version == 5 */
11894 const gdb_byte
*ids_ptr
= htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
11895 int *ids
= htab
->section_pool
.v5
.section_ids
;
11896 size_t sizeof_ids
= sizeof (htab
->section_pool
.v5
.section_ids
);
11897 /* Reverse map for error checking. */
11898 int ids_seen
[DW_SECT_MAX_V5
+ 1];
11900 if (nr_columns
< 2)
11902 error (_("Dwarf Error: bad DWP hash table, too few columns"
11903 " in section table [in module %s]"),
11906 if (nr_columns
> MAX_NR_V5_DWO_SECTIONS
)
11908 error (_("Dwarf Error: bad DWP hash table, too many columns"
11909 " in section table [in module %s]"),
11912 memset (ids
, 255, sizeof_ids
);
11913 memset (ids_seen
, 255, sizeof (ids_seen
));
11914 for (int i
= 0; i
< nr_columns
; ++i
)
11916 int id
= read_4_bytes (dbfd
, ids_ptr
+ i
* sizeof (uint32_t));
11918 if (id
< DW_SECT_MIN
|| id
> DW_SECT_MAX_V5
)
11920 error (_("Dwarf Error: bad DWP hash table, bad section id %d"
11921 " in section table [in module %s]"),
11922 id
, dwp_file
->name
);
11924 if (ids_seen
[id
] != -1)
11926 error (_("Dwarf Error: bad DWP hash table, duplicate section"
11927 " id %d in section table [in module %s]"),
11928 id
, dwp_file
->name
);
11933 /* Must have seen an info section. */
11934 if (ids_seen
[DW_SECT_INFO_V5
] == -1)
11936 error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
11937 " DWO info/types section [in module %s]"),
11940 /* Must have an abbrev section. */
11941 if (ids_seen
[DW_SECT_ABBREV_V5
] == -1)
11943 error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
11944 " section [in module %s]"),
11947 htab
->section_pool
.v5
.offsets
= ids_ptr
+ sizeof (uint32_t) * nr_columns
;
11948 htab
->section_pool
.v5
.sizes
11949 = htab
->section_pool
.v5
.offsets
+ (sizeof (uint32_t)
11950 * nr_units
* nr_columns
);
11951 if ((htab
->section_pool
.v5
.sizes
+ (sizeof (uint32_t)
11952 * nr_units
* nr_columns
))
11955 error (_("Dwarf Error: DWP index section is corrupt (too small)"
11956 " [in module %s]"),
11964 /* Update SECTIONS with the data from SECTP.
11966 This function is like the other "locate" section routines, but in
11967 this context the sections to read comes from the DWP V1 hash table,
11968 not the full ELF section table.
11970 The result is non-zero for success, or zero if an error was found. */
11973 locate_v1_virtual_dwo_sections (asection
*sectp
,
11974 struct virtual_v1_dwo_sections
*sections
)
11976 const struct dwop_section_names
*names
= &dwop_section_names
;
11978 if (names
->abbrev_dwo
.matches (sectp
->name
))
11980 /* There can be only one. */
11981 if (sections
->abbrev
.s
.section
!= NULL
)
11983 sections
->abbrev
.s
.section
= sectp
;
11984 sections
->abbrev
.size
= bfd_section_size (sectp
);
11986 else if (names
->info_dwo
.matches (sectp
->name
)
11987 || names
->types_dwo
.matches (sectp
->name
))
11989 /* There can be only one. */
11990 if (sections
->info_or_types
.s
.section
!= NULL
)
11992 sections
->info_or_types
.s
.section
= sectp
;
11993 sections
->info_or_types
.size
= bfd_section_size (sectp
);
11995 else if (names
->line_dwo
.matches (sectp
->name
))
11997 /* There can be only one. */
11998 if (sections
->line
.s
.section
!= NULL
)
12000 sections
->line
.s
.section
= sectp
;
12001 sections
->line
.size
= bfd_section_size (sectp
);
12003 else if (names
->loc_dwo
.matches (sectp
->name
))
12005 /* There can be only one. */
12006 if (sections
->loc
.s
.section
!= NULL
)
12008 sections
->loc
.s
.section
= sectp
;
12009 sections
->loc
.size
= bfd_section_size (sectp
);
12011 else if (names
->macinfo_dwo
.matches (sectp
->name
))
12013 /* There can be only one. */
12014 if (sections
->macinfo
.s
.section
!= NULL
)
12016 sections
->macinfo
.s
.section
= sectp
;
12017 sections
->macinfo
.size
= bfd_section_size (sectp
);
12019 else if (names
->macro_dwo
.matches (sectp
->name
))
12021 /* There can be only one. */
12022 if (sections
->macro
.s
.section
!= NULL
)
12024 sections
->macro
.s
.section
= sectp
;
12025 sections
->macro
.size
= bfd_section_size (sectp
);
12027 else if (names
->str_offsets_dwo
.matches (sectp
->name
))
12029 /* There can be only one. */
12030 if (sections
->str_offsets
.s
.section
!= NULL
)
12032 sections
->str_offsets
.s
.section
= sectp
;
12033 sections
->str_offsets
.size
= bfd_section_size (sectp
);
12037 /* No other kind of section is valid. */
12044 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12045 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12046 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12047 This is for DWP version 1 files. */
12049 static struct dwo_unit
*
12050 create_dwo_unit_in_dwp_v1 (dwarf2_per_objfile
*per_objfile
,
12051 struct dwp_file
*dwp_file
,
12052 uint32_t unit_index
,
12053 const char *comp_dir
,
12054 ULONGEST signature
, int is_debug_types
)
12056 const struct dwp_hash_table
*dwp_htab
=
12057 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12058 bfd
*dbfd
= dwp_file
->dbfd
.get ();
12059 const char *kind
= is_debug_types
? "TU" : "CU";
12060 struct dwo_file
*dwo_file
;
12061 struct dwo_unit
*dwo_unit
;
12062 struct virtual_v1_dwo_sections sections
;
12063 void **dwo_file_slot
;
12066 gdb_assert (dwp_file
->version
== 1);
12068 dwarf_read_debug_printf ("Reading %s %s/%s in DWP V1 file: %s",
12069 kind
, pulongest (unit_index
), hex_string (signature
),
12072 /* Fetch the sections of this DWO unit.
12073 Put a limit on the number of sections we look for so that bad data
12074 doesn't cause us to loop forever. */
12076 #define MAX_NR_V1_DWO_SECTIONS \
12077 (1 /* .debug_info or .debug_types */ \
12078 + 1 /* .debug_abbrev */ \
12079 + 1 /* .debug_line */ \
12080 + 1 /* .debug_loc */ \
12081 + 1 /* .debug_str_offsets */ \
12082 + 1 /* .debug_macro or .debug_macinfo */ \
12083 + 1 /* trailing zero */)
12085 memset (§ions
, 0, sizeof (sections
));
12087 for (i
= 0; i
< MAX_NR_V1_DWO_SECTIONS
; ++i
)
12090 uint32_t section_nr
=
12091 read_4_bytes (dbfd
,
12092 dwp_htab
->section_pool
.v1
.indices
12093 + (unit_index
+ i
) * sizeof (uint32_t));
12095 if (section_nr
== 0)
12097 if (section_nr
>= dwp_file
->num_sections
)
12099 error (_("Dwarf Error: bad DWP hash table, section number too large"
12100 " [in module %s]"),
12104 sectp
= dwp_file
->elf_sections
[section_nr
];
12105 if (! locate_v1_virtual_dwo_sections (sectp
, §ions
))
12107 error (_("Dwarf Error: bad DWP hash table, invalid section found"
12108 " [in module %s]"),
12114 || sections
.info_or_types
.empty ()
12115 || sections
.abbrev
.empty ())
12117 error (_("Dwarf Error: bad DWP hash table, missing DWO sections"
12118 " [in module %s]"),
12121 if (i
== MAX_NR_V1_DWO_SECTIONS
)
12123 error (_("Dwarf Error: bad DWP hash table, too many DWO sections"
12124 " [in module %s]"),
12128 /* It's easier for the rest of the code if we fake a struct dwo_file and
12129 have dwo_unit "live" in that. At least for now.
12131 The DWP file can be made up of a random collection of CUs and TUs.
12132 However, for each CU + set of TUs that came from the same original DWO
12133 file, we can combine them back into a virtual DWO file to save space
12134 (fewer struct dwo_file objects to allocate). Remember that for really
12135 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
12137 std::string virtual_dwo_name
=
12138 string_printf ("virtual-dwo/%d-%d-%d-%d",
12139 sections
.abbrev
.get_id (),
12140 sections
.line
.get_id (),
12141 sections
.loc
.get_id (),
12142 sections
.str_offsets
.get_id ());
12143 /* Can we use an existing virtual DWO file? */
12144 dwo_file_slot
= lookup_dwo_file_slot (per_objfile
, virtual_dwo_name
.c_str (),
12146 /* Create one if necessary. */
12147 if (*dwo_file_slot
== NULL
)
12149 dwarf_read_debug_printf ("Creating virtual DWO: %s",
12150 virtual_dwo_name
.c_str ());
12152 dwo_file
= new struct dwo_file
;
12153 dwo_file
->dwo_name
= per_objfile
->objfile
->intern (virtual_dwo_name
);
12154 dwo_file
->comp_dir
= comp_dir
;
12155 dwo_file
->sections
.abbrev
= sections
.abbrev
;
12156 dwo_file
->sections
.line
= sections
.line
;
12157 dwo_file
->sections
.loc
= sections
.loc
;
12158 dwo_file
->sections
.macinfo
= sections
.macinfo
;
12159 dwo_file
->sections
.macro
= sections
.macro
;
12160 dwo_file
->sections
.str_offsets
= sections
.str_offsets
;
12161 /* The "str" section is global to the entire DWP file. */
12162 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
12163 /* The info or types section is assigned below to dwo_unit,
12164 there's no need to record it in dwo_file.
12165 Also, we can't simply record type sections in dwo_file because
12166 we record a pointer into the vector in dwo_unit. As we collect more
12167 types we'll grow the vector and eventually have to reallocate space
12168 for it, invalidating all copies of pointers into the previous
12170 *dwo_file_slot
= dwo_file
;
12174 dwarf_read_debug_printf ("Using existing virtual DWO: %s",
12175 virtual_dwo_name
.c_str ());
12177 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
12180 dwo_unit
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, struct dwo_unit
);
12181 dwo_unit
->dwo_file
= dwo_file
;
12182 dwo_unit
->signature
= signature
;
12183 dwo_unit
->section
=
12184 XOBNEW (&per_objfile
->per_bfd
->obstack
, struct dwarf2_section_info
);
12185 *dwo_unit
->section
= sections
.info_or_types
;
12186 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12191 /* Subroutine of create_dwo_unit_in_dwp_v2 and create_dwo_unit_in_dwp_v5 to
12192 simplify them. Given a pointer to the containing section SECTION, and
12193 OFFSET,SIZE of the piece within that section used by a TU/CU, return a
12194 virtual section of just that piece. */
12196 static struct dwarf2_section_info
12197 create_dwp_v2_or_v5_section (dwarf2_per_objfile
*per_objfile
,
12198 struct dwarf2_section_info
*section
,
12199 bfd_size_type offset
, bfd_size_type size
)
12201 struct dwarf2_section_info result
;
12204 gdb_assert (section
!= NULL
);
12205 gdb_assert (!section
->is_virtual
);
12207 memset (&result
, 0, sizeof (result
));
12208 result
.s
.containing_section
= section
;
12209 result
.is_virtual
= true;
12214 sectp
= section
->get_bfd_section ();
12216 /* Flag an error if the piece denoted by OFFSET,SIZE is outside the
12217 bounds of the real section. This is a pretty-rare event, so just
12218 flag an error (easier) instead of a warning and trying to cope. */
12220 || offset
+ size
> bfd_section_size (sectp
))
12222 error (_("Dwarf Error: Bad DWP V2 or V5 section info, doesn't fit"
12223 " in section %s [in module %s]"),
12224 sectp
? bfd_section_name (sectp
) : "<unknown>",
12225 objfile_name (per_objfile
->objfile
));
12228 result
.virtual_offset
= offset
;
12229 result
.size
= size
;
12233 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12234 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12235 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12236 This is for DWP version 2 files. */
12238 static struct dwo_unit
*
12239 create_dwo_unit_in_dwp_v2 (dwarf2_per_objfile
*per_objfile
,
12240 struct dwp_file
*dwp_file
,
12241 uint32_t unit_index
,
12242 const char *comp_dir
,
12243 ULONGEST signature
, int is_debug_types
)
12245 const struct dwp_hash_table
*dwp_htab
=
12246 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12247 bfd
*dbfd
= dwp_file
->dbfd
.get ();
12248 const char *kind
= is_debug_types
? "TU" : "CU";
12249 struct dwo_file
*dwo_file
;
12250 struct dwo_unit
*dwo_unit
;
12251 struct virtual_v2_or_v5_dwo_sections sections
;
12252 void **dwo_file_slot
;
12255 gdb_assert (dwp_file
->version
== 2);
12257 dwarf_read_debug_printf ("Reading %s %s/%s in DWP V2 file: %s",
12258 kind
, pulongest (unit_index
), hex_string (signature
),
12261 /* Fetch the section offsets of this DWO unit. */
12263 memset (§ions
, 0, sizeof (sections
));
12265 for (i
= 0; i
< dwp_htab
->nr_columns
; ++i
)
12267 uint32_t offset
= read_4_bytes (dbfd
,
12268 dwp_htab
->section_pool
.v2
.offsets
12269 + (((unit_index
- 1) * dwp_htab
->nr_columns
12271 * sizeof (uint32_t)));
12272 uint32_t size
= read_4_bytes (dbfd
,
12273 dwp_htab
->section_pool
.v2
.sizes
12274 + (((unit_index
- 1) * dwp_htab
->nr_columns
12276 * sizeof (uint32_t)));
12278 switch (dwp_htab
->section_pool
.v2
.section_ids
[i
])
12281 case DW_SECT_TYPES
:
12282 sections
.info_or_types_offset
= offset
;
12283 sections
.info_or_types_size
= size
;
12285 case DW_SECT_ABBREV
:
12286 sections
.abbrev_offset
= offset
;
12287 sections
.abbrev_size
= size
;
12290 sections
.line_offset
= offset
;
12291 sections
.line_size
= size
;
12294 sections
.loc_offset
= offset
;
12295 sections
.loc_size
= size
;
12297 case DW_SECT_STR_OFFSETS
:
12298 sections
.str_offsets_offset
= offset
;
12299 sections
.str_offsets_size
= size
;
12301 case DW_SECT_MACINFO
:
12302 sections
.macinfo_offset
= offset
;
12303 sections
.macinfo_size
= size
;
12305 case DW_SECT_MACRO
:
12306 sections
.macro_offset
= offset
;
12307 sections
.macro_size
= size
;
12312 /* It's easier for the rest of the code if we fake a struct dwo_file and
12313 have dwo_unit "live" in that. At least for now.
12315 The DWP file can be made up of a random collection of CUs and TUs.
12316 However, for each CU + set of TUs that came from the same original DWO
12317 file, we can combine them back into a virtual DWO file to save space
12318 (fewer struct dwo_file objects to allocate). Remember that for really
12319 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
12321 std::string virtual_dwo_name
=
12322 string_printf ("virtual-dwo/%ld-%ld-%ld-%ld",
12323 (long) (sections
.abbrev_size
? sections
.abbrev_offset
: 0),
12324 (long) (sections
.line_size
? sections
.line_offset
: 0),
12325 (long) (sections
.loc_size
? sections
.loc_offset
: 0),
12326 (long) (sections
.str_offsets_size
12327 ? sections
.str_offsets_offset
: 0));
12328 /* Can we use an existing virtual DWO file? */
12329 dwo_file_slot
= lookup_dwo_file_slot (per_objfile
, virtual_dwo_name
.c_str (),
12331 /* Create one if necessary. */
12332 if (*dwo_file_slot
== NULL
)
12334 dwarf_read_debug_printf ("Creating virtual DWO: %s",
12335 virtual_dwo_name
.c_str ());
12337 dwo_file
= new struct dwo_file
;
12338 dwo_file
->dwo_name
= per_objfile
->objfile
->intern (virtual_dwo_name
);
12339 dwo_file
->comp_dir
= comp_dir
;
12340 dwo_file
->sections
.abbrev
=
12341 create_dwp_v2_or_v5_section (per_objfile
, &dwp_file
->sections
.abbrev
,
12342 sections
.abbrev_offset
,
12343 sections
.abbrev_size
);
12344 dwo_file
->sections
.line
=
12345 create_dwp_v2_or_v5_section (per_objfile
, &dwp_file
->sections
.line
,
12346 sections
.line_offset
,
12347 sections
.line_size
);
12348 dwo_file
->sections
.loc
=
12349 create_dwp_v2_or_v5_section (per_objfile
, &dwp_file
->sections
.loc
,
12350 sections
.loc_offset
, sections
.loc_size
);
12351 dwo_file
->sections
.macinfo
=
12352 create_dwp_v2_or_v5_section (per_objfile
, &dwp_file
->sections
.macinfo
,
12353 sections
.macinfo_offset
,
12354 sections
.macinfo_size
);
12355 dwo_file
->sections
.macro
=
12356 create_dwp_v2_or_v5_section (per_objfile
, &dwp_file
->sections
.macro
,
12357 sections
.macro_offset
,
12358 sections
.macro_size
);
12359 dwo_file
->sections
.str_offsets
=
12360 create_dwp_v2_or_v5_section (per_objfile
,
12361 &dwp_file
->sections
.str_offsets
,
12362 sections
.str_offsets_offset
,
12363 sections
.str_offsets_size
);
12364 /* The "str" section is global to the entire DWP file. */
12365 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
12366 /* The info or types section is assigned below to dwo_unit,
12367 there's no need to record it in dwo_file.
12368 Also, we can't simply record type sections in dwo_file because
12369 we record a pointer into the vector in dwo_unit. As we collect more
12370 types we'll grow the vector and eventually have to reallocate space
12371 for it, invalidating all copies of pointers into the previous
12373 *dwo_file_slot
= dwo_file
;
12377 dwarf_read_debug_printf ("Using existing virtual DWO: %s",
12378 virtual_dwo_name
.c_str ());
12380 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
12383 dwo_unit
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, struct dwo_unit
);
12384 dwo_unit
->dwo_file
= dwo_file
;
12385 dwo_unit
->signature
= signature
;
12386 dwo_unit
->section
=
12387 XOBNEW (&per_objfile
->per_bfd
->obstack
, struct dwarf2_section_info
);
12388 *dwo_unit
->section
= create_dwp_v2_or_v5_section
12391 ? &dwp_file
->sections
.types
12392 : &dwp_file
->sections
.info
,
12393 sections
.info_or_types_offset
,
12394 sections
.info_or_types_size
);
12395 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12400 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12401 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12402 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12403 This is for DWP version 5 files. */
12405 static struct dwo_unit
*
12406 create_dwo_unit_in_dwp_v5 (dwarf2_per_objfile
*per_objfile
,
12407 struct dwp_file
*dwp_file
,
12408 uint32_t unit_index
,
12409 const char *comp_dir
,
12410 ULONGEST signature
, int is_debug_types
)
12412 const struct dwp_hash_table
*dwp_htab
12413 = is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12414 bfd
*dbfd
= dwp_file
->dbfd
.get ();
12415 const char *kind
= is_debug_types
? "TU" : "CU";
12416 struct dwo_file
*dwo_file
;
12417 struct dwo_unit
*dwo_unit
;
12418 struct virtual_v2_or_v5_dwo_sections sections
{};
12419 void **dwo_file_slot
;
12421 gdb_assert (dwp_file
->version
== 5);
12423 dwarf_read_debug_printf ("Reading %s %s/%s in DWP V5 file: %s",
12424 kind
, pulongest (unit_index
), hex_string (signature
),
12427 /* Fetch the section offsets of this DWO unit. */
12429 /* memset (§ions, 0, sizeof (sections)); */
12431 for (int i
= 0; i
< dwp_htab
->nr_columns
; ++i
)
12433 uint32_t offset
= read_4_bytes (dbfd
,
12434 dwp_htab
->section_pool
.v5
.offsets
12435 + (((unit_index
- 1)
12436 * dwp_htab
->nr_columns
12438 * sizeof (uint32_t)));
12439 uint32_t size
= read_4_bytes (dbfd
,
12440 dwp_htab
->section_pool
.v5
.sizes
12441 + (((unit_index
- 1) * dwp_htab
->nr_columns
12443 * sizeof (uint32_t)));
12445 switch (dwp_htab
->section_pool
.v5
.section_ids
[i
])
12447 case DW_SECT_ABBREV_V5
:
12448 sections
.abbrev_offset
= offset
;
12449 sections
.abbrev_size
= size
;
12451 case DW_SECT_INFO_V5
:
12452 sections
.info_or_types_offset
= offset
;
12453 sections
.info_or_types_size
= size
;
12455 case DW_SECT_LINE_V5
:
12456 sections
.line_offset
= offset
;
12457 sections
.line_size
= size
;
12459 case DW_SECT_LOCLISTS_V5
:
12460 sections
.loclists_offset
= offset
;
12461 sections
.loclists_size
= size
;
12463 case DW_SECT_MACRO_V5
:
12464 sections
.macro_offset
= offset
;
12465 sections
.macro_size
= size
;
12467 case DW_SECT_RNGLISTS_V5
:
12468 sections
.rnglists_offset
= offset
;
12469 sections
.rnglists_size
= size
;
12471 case DW_SECT_STR_OFFSETS_V5
:
12472 sections
.str_offsets_offset
= offset
;
12473 sections
.str_offsets_size
= size
;
12475 case DW_SECT_RESERVED_V5
:
12481 /* It's easier for the rest of the code if we fake a struct dwo_file and
12482 have dwo_unit "live" in that. At least for now.
12484 The DWP file can be made up of a random collection of CUs and TUs.
12485 However, for each CU + set of TUs that came from the same original DWO
12486 file, we can combine them back into a virtual DWO file to save space
12487 (fewer struct dwo_file objects to allocate). Remember that for really
12488 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
12490 std::string virtual_dwo_name
=
12491 string_printf ("virtual-dwo/%ld-%ld-%ld-%ld-%ld-%ld",
12492 (long) (sections
.abbrev_size
? sections
.abbrev_offset
: 0),
12493 (long) (sections
.line_size
? sections
.line_offset
: 0),
12494 (long) (sections
.loclists_size
? sections
.loclists_offset
: 0),
12495 (long) (sections
.str_offsets_size
12496 ? sections
.str_offsets_offset
: 0),
12497 (long) (sections
.macro_size
? sections
.macro_offset
: 0),
12498 (long) (sections
.rnglists_size
? sections
.rnglists_offset
: 0));
12499 /* Can we use an existing virtual DWO file? */
12500 dwo_file_slot
= lookup_dwo_file_slot (per_objfile
,
12501 virtual_dwo_name
.c_str (),
12503 /* Create one if necessary. */
12504 if (*dwo_file_slot
== NULL
)
12506 dwarf_read_debug_printf ("Creating virtual DWO: %s",
12507 virtual_dwo_name
.c_str ());
12509 dwo_file
= new struct dwo_file
;
12510 dwo_file
->dwo_name
= per_objfile
->objfile
->intern (virtual_dwo_name
);
12511 dwo_file
->comp_dir
= comp_dir
;
12512 dwo_file
->sections
.abbrev
=
12513 create_dwp_v2_or_v5_section (per_objfile
,
12514 &dwp_file
->sections
.abbrev
,
12515 sections
.abbrev_offset
,
12516 sections
.abbrev_size
);
12517 dwo_file
->sections
.line
=
12518 create_dwp_v2_or_v5_section (per_objfile
,
12519 &dwp_file
->sections
.line
,
12520 sections
.line_offset
, sections
.line_size
);
12521 dwo_file
->sections
.macro
=
12522 create_dwp_v2_or_v5_section (per_objfile
,
12523 &dwp_file
->sections
.macro
,
12524 sections
.macro_offset
,
12525 sections
.macro_size
);
12526 dwo_file
->sections
.loclists
=
12527 create_dwp_v2_or_v5_section (per_objfile
,
12528 &dwp_file
->sections
.loclists
,
12529 sections
.loclists_offset
,
12530 sections
.loclists_size
);
12531 dwo_file
->sections
.rnglists
=
12532 create_dwp_v2_or_v5_section (per_objfile
,
12533 &dwp_file
->sections
.rnglists
,
12534 sections
.rnglists_offset
,
12535 sections
.rnglists_size
);
12536 dwo_file
->sections
.str_offsets
=
12537 create_dwp_v2_or_v5_section (per_objfile
,
12538 &dwp_file
->sections
.str_offsets
,
12539 sections
.str_offsets_offset
,
12540 sections
.str_offsets_size
);
12541 /* The "str" section is global to the entire DWP file. */
12542 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
12543 /* The info or types section is assigned below to dwo_unit,
12544 there's no need to record it in dwo_file.
12545 Also, we can't simply record type sections in dwo_file because
12546 we record a pointer into the vector in dwo_unit. As we collect more
12547 types we'll grow the vector and eventually have to reallocate space
12548 for it, invalidating all copies of pointers into the previous
12550 *dwo_file_slot
= dwo_file
;
12554 dwarf_read_debug_printf ("Using existing virtual DWO: %s",
12555 virtual_dwo_name
.c_str ());
12557 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
12560 dwo_unit
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, struct dwo_unit
);
12561 dwo_unit
->dwo_file
= dwo_file
;
12562 dwo_unit
->signature
= signature
;
12564 = XOBNEW (&per_objfile
->per_bfd
->obstack
, struct dwarf2_section_info
);
12565 *dwo_unit
->section
= create_dwp_v2_or_v5_section (per_objfile
,
12566 &dwp_file
->sections
.info
,
12567 sections
.info_or_types_offset
,
12568 sections
.info_or_types_size
);
12569 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12574 /* Lookup the DWO unit with SIGNATURE in DWP_FILE.
12575 Returns NULL if the signature isn't found. */
12577 static struct dwo_unit
*
12578 lookup_dwo_unit_in_dwp (dwarf2_per_objfile
*per_objfile
,
12579 struct dwp_file
*dwp_file
, const char *comp_dir
,
12580 ULONGEST signature
, int is_debug_types
)
12582 const struct dwp_hash_table
*dwp_htab
=
12583 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12584 bfd
*dbfd
= dwp_file
->dbfd
.get ();
12585 uint32_t mask
= dwp_htab
->nr_slots
- 1;
12586 uint32_t hash
= signature
& mask
;
12587 uint32_t hash2
= ((signature
>> 32) & mask
) | 1;
12590 struct dwo_unit find_dwo_cu
;
12592 memset (&find_dwo_cu
, 0, sizeof (find_dwo_cu
));
12593 find_dwo_cu
.signature
= signature
;
12594 slot
= htab_find_slot (is_debug_types
12595 ? dwp_file
->loaded_tus
.get ()
12596 : dwp_file
->loaded_cus
.get (),
12597 &find_dwo_cu
, INSERT
);
12600 return (struct dwo_unit
*) *slot
;
12602 /* Use a for loop so that we don't loop forever on bad debug info. */
12603 for (i
= 0; i
< dwp_htab
->nr_slots
; ++i
)
12605 ULONGEST signature_in_table
;
12607 signature_in_table
=
12608 read_8_bytes (dbfd
, dwp_htab
->hash_table
+ hash
* sizeof (uint64_t));
12609 if (signature_in_table
== signature
)
12611 uint32_t unit_index
=
12612 read_4_bytes (dbfd
,
12613 dwp_htab
->unit_table
+ hash
* sizeof (uint32_t));
12615 if (dwp_file
->version
== 1)
12617 *slot
= create_dwo_unit_in_dwp_v1 (per_objfile
, dwp_file
,
12618 unit_index
, comp_dir
,
12619 signature
, is_debug_types
);
12621 else if (dwp_file
->version
== 2)
12623 *slot
= create_dwo_unit_in_dwp_v2 (per_objfile
, dwp_file
,
12624 unit_index
, comp_dir
,
12625 signature
, is_debug_types
);
12627 else /* version == 5 */
12629 *slot
= create_dwo_unit_in_dwp_v5 (per_objfile
, dwp_file
,
12630 unit_index
, comp_dir
,
12631 signature
, is_debug_types
);
12633 return (struct dwo_unit
*) *slot
;
12635 if (signature_in_table
== 0)
12637 hash
= (hash
+ hash2
) & mask
;
12640 error (_("Dwarf Error: bad DWP hash table, lookup didn't terminate"
12641 " [in module %s]"),
12645 /* Subroutine of open_dwo_file,open_dwp_file to simplify them.
12646 Open the file specified by FILE_NAME and hand it off to BFD for
12647 preliminary analysis. Return a newly initialized bfd *, which
12648 includes a canonicalized copy of FILE_NAME.
12649 If IS_DWP is TRUE, we're opening a DWP file, otherwise a DWO file.
12650 SEARCH_CWD is true if the current directory is to be searched.
12651 It will be searched before debug-file-directory.
12652 If successful, the file is added to the bfd include table of the
12653 objfile's bfd (see gdb_bfd_record_inclusion).
12654 If unable to find/open the file, return NULL.
12655 NOTE: This function is derived from symfile_bfd_open. */
12657 static gdb_bfd_ref_ptr
12658 try_open_dwop_file (dwarf2_per_objfile
*per_objfile
,
12659 const char *file_name
, int is_dwp
, int search_cwd
)
12662 /* Blech. OPF_TRY_CWD_FIRST also disables searching the path list if
12663 FILE_NAME contains a '/'. So we can't use it. Instead prepend "."
12664 to debug_file_directory. */
12665 const char *search_path
;
12666 static const char dirname_separator_string
[] = { DIRNAME_SEPARATOR
, '\0' };
12668 gdb::unique_xmalloc_ptr
<char> search_path_holder
;
12671 if (*debug_file_directory
!= '\0')
12673 search_path_holder
.reset (concat (".", dirname_separator_string
,
12674 debug_file_directory
,
12676 search_path
= search_path_holder
.get ();
12682 search_path
= debug_file_directory
;
12684 openp_flags flags
= OPF_RETURN_REALPATH
;
12686 flags
|= OPF_SEARCH_IN_PATH
;
12688 gdb::unique_xmalloc_ptr
<char> absolute_name
;
12689 desc
= openp (search_path
, flags
, file_name
,
12690 O_RDONLY
| O_BINARY
, &absolute_name
);
12694 gdb_bfd_ref_ptr
sym_bfd (gdb_bfd_open (absolute_name
.get (),
12696 if (sym_bfd
== NULL
)
12698 bfd_set_cacheable (sym_bfd
.get (), 1);
12700 if (!bfd_check_format (sym_bfd
.get (), bfd_object
))
12703 /* Success. Record the bfd as having been included by the objfile's bfd.
12704 This is important because things like demangled_names_hash lives in the
12705 objfile's per_bfd space and may have references to things like symbol
12706 names that live in the DWO/DWP file's per_bfd space. PR 16426. */
12707 gdb_bfd_record_inclusion (per_objfile
->objfile
->obfd
, sym_bfd
.get ());
12712 /* Try to open DWO file FILE_NAME.
12713 COMP_DIR is the DW_AT_comp_dir attribute.
12714 The result is the bfd handle of the file.
12715 If there is a problem finding or opening the file, return NULL.
12716 Upon success, the canonicalized path of the file is stored in the bfd,
12717 same as symfile_bfd_open. */
12719 static gdb_bfd_ref_ptr
12720 open_dwo_file (dwarf2_per_objfile
*per_objfile
,
12721 const char *file_name
, const char *comp_dir
)
12723 if (IS_ABSOLUTE_PATH (file_name
))
12724 return try_open_dwop_file (per_objfile
, file_name
,
12725 0 /*is_dwp*/, 0 /*search_cwd*/);
12727 /* Before trying the search path, try DWO_NAME in COMP_DIR. */
12729 if (comp_dir
!= NULL
)
12731 gdb::unique_xmalloc_ptr
<char> path_to_try
12732 (concat (comp_dir
, SLASH_STRING
, file_name
, (char *) NULL
));
12734 /* NOTE: If comp_dir is a relative path, this will also try the
12735 search path, which seems useful. */
12736 gdb_bfd_ref_ptr
abfd (try_open_dwop_file (per_objfile
, path_to_try
.get (),
12738 1 /*search_cwd*/));
12743 /* That didn't work, try debug-file-directory, which, despite its name,
12744 is a list of paths. */
12746 if (*debug_file_directory
== '\0')
12749 return try_open_dwop_file (per_objfile
, file_name
,
12750 0 /*is_dwp*/, 1 /*search_cwd*/);
12753 /* This function is mapped across the sections and remembers the offset and
12754 size of each of the DWO debugging sections we are interested in. */
12757 dwarf2_locate_dwo_sections (bfd
*abfd
, asection
*sectp
,
12758 dwo_sections
*dwo_sections
)
12760 const struct dwop_section_names
*names
= &dwop_section_names
;
12762 if (names
->abbrev_dwo
.matches (sectp
->name
))
12764 dwo_sections
->abbrev
.s
.section
= sectp
;
12765 dwo_sections
->abbrev
.size
= bfd_section_size (sectp
);
12767 else if (names
->info_dwo
.matches (sectp
->name
))
12769 dwo_sections
->info
.s
.section
= sectp
;
12770 dwo_sections
->info
.size
= bfd_section_size (sectp
);
12772 else if (names
->line_dwo
.matches (sectp
->name
))
12774 dwo_sections
->line
.s
.section
= sectp
;
12775 dwo_sections
->line
.size
= bfd_section_size (sectp
);
12777 else if (names
->loc_dwo
.matches (sectp
->name
))
12779 dwo_sections
->loc
.s
.section
= sectp
;
12780 dwo_sections
->loc
.size
= bfd_section_size (sectp
);
12782 else if (names
->loclists_dwo
.matches (sectp
->name
))
12784 dwo_sections
->loclists
.s
.section
= sectp
;
12785 dwo_sections
->loclists
.size
= bfd_section_size (sectp
);
12787 else if (names
->macinfo_dwo
.matches (sectp
->name
))
12789 dwo_sections
->macinfo
.s
.section
= sectp
;
12790 dwo_sections
->macinfo
.size
= bfd_section_size (sectp
);
12792 else if (names
->macro_dwo
.matches (sectp
->name
))
12794 dwo_sections
->macro
.s
.section
= sectp
;
12795 dwo_sections
->macro
.size
= bfd_section_size (sectp
);
12797 else if (names
->rnglists_dwo
.matches (sectp
->name
))
12799 dwo_sections
->rnglists
.s
.section
= sectp
;
12800 dwo_sections
->rnglists
.size
= bfd_section_size (sectp
);
12802 else if (names
->str_dwo
.matches (sectp
->name
))
12804 dwo_sections
->str
.s
.section
= sectp
;
12805 dwo_sections
->str
.size
= bfd_section_size (sectp
);
12807 else if (names
->str_offsets_dwo
.matches (sectp
->name
))
12809 dwo_sections
->str_offsets
.s
.section
= sectp
;
12810 dwo_sections
->str_offsets
.size
= bfd_section_size (sectp
);
12812 else if (names
->types_dwo
.matches (sectp
->name
))
12814 struct dwarf2_section_info type_section
;
12816 memset (&type_section
, 0, sizeof (type_section
));
12817 type_section
.s
.section
= sectp
;
12818 type_section
.size
= bfd_section_size (sectp
);
12819 dwo_sections
->types
.push_back (type_section
);
12823 /* Initialize the use of the DWO file specified by DWO_NAME and referenced
12824 by PER_CU. This is for the non-DWP case.
12825 The result is NULL if DWO_NAME can't be found. */
12827 static struct dwo_file
*
12828 open_and_init_dwo_file (dwarf2_cu
*cu
, const char *dwo_name
,
12829 const char *comp_dir
)
12831 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
12833 gdb_bfd_ref_ptr dbfd
= open_dwo_file (per_objfile
, dwo_name
, comp_dir
);
12836 dwarf_read_debug_printf ("DWO file not found: %s", dwo_name
);
12841 dwo_file_up
dwo_file (new struct dwo_file
);
12842 dwo_file
->dwo_name
= dwo_name
;
12843 dwo_file
->comp_dir
= comp_dir
;
12844 dwo_file
->dbfd
= std::move (dbfd
);
12846 for (asection
*sec
: gdb_bfd_sections (dwo_file
->dbfd
))
12847 dwarf2_locate_dwo_sections (dwo_file
->dbfd
.get (), sec
,
12848 &dwo_file
->sections
);
12850 create_cus_hash_table (per_objfile
, cu
, *dwo_file
, dwo_file
->sections
.info
,
12853 if (cu
->per_cu
->dwarf_version
< 5)
12855 create_debug_types_hash_table (per_objfile
, dwo_file
.get (),
12856 dwo_file
->sections
.types
, dwo_file
->tus
);
12860 create_debug_type_hash_table (per_objfile
, dwo_file
.get (),
12861 &dwo_file
->sections
.info
, dwo_file
->tus
,
12862 rcuh_kind::COMPILE
);
12865 dwarf_read_debug_printf ("DWO file found: %s", dwo_name
);
12867 return dwo_file
.release ();
12870 /* This function is mapped across the sections and remembers the offset and
12871 size of each of the DWP debugging sections common to version 1 and 2 that
12872 we are interested in. */
12875 dwarf2_locate_common_dwp_sections (bfd
*abfd
, asection
*sectp
,
12876 dwp_file
*dwp_file
)
12878 const struct dwop_section_names
*names
= &dwop_section_names
;
12879 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
12881 /* Record the ELF section number for later lookup: this is what the
12882 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
12883 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
12884 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
12886 /* Look for specific sections that we need. */
12887 if (names
->str_dwo
.matches (sectp
->name
))
12889 dwp_file
->sections
.str
.s
.section
= sectp
;
12890 dwp_file
->sections
.str
.size
= bfd_section_size (sectp
);
12892 else if (names
->cu_index
.matches (sectp
->name
))
12894 dwp_file
->sections
.cu_index
.s
.section
= sectp
;
12895 dwp_file
->sections
.cu_index
.size
= bfd_section_size (sectp
);
12897 else if (names
->tu_index
.matches (sectp
->name
))
12899 dwp_file
->sections
.tu_index
.s
.section
= sectp
;
12900 dwp_file
->sections
.tu_index
.size
= bfd_section_size (sectp
);
12904 /* This function is mapped across the sections and remembers the offset and
12905 size of each of the DWP version 2 debugging sections that we are interested
12906 in. This is split into a separate function because we don't know if we
12907 have version 1 or 2 or 5 until we parse the cu_index/tu_index sections. */
12910 dwarf2_locate_v2_dwp_sections (bfd
*abfd
, asection
*sectp
, void *dwp_file_ptr
)
12912 struct dwp_file
*dwp_file
= (struct dwp_file
*) dwp_file_ptr
;
12913 const struct dwop_section_names
*names
= &dwop_section_names
;
12914 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
12916 /* Record the ELF section number for later lookup: this is what the
12917 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
12918 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
12919 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
12921 /* Look for specific sections that we need. */
12922 if (names
->abbrev_dwo
.matches (sectp
->name
))
12924 dwp_file
->sections
.abbrev
.s
.section
= sectp
;
12925 dwp_file
->sections
.abbrev
.size
= bfd_section_size (sectp
);
12927 else if (names
->info_dwo
.matches (sectp
->name
))
12929 dwp_file
->sections
.info
.s
.section
= sectp
;
12930 dwp_file
->sections
.info
.size
= bfd_section_size (sectp
);
12932 else if (names
->line_dwo
.matches (sectp
->name
))
12934 dwp_file
->sections
.line
.s
.section
= sectp
;
12935 dwp_file
->sections
.line
.size
= bfd_section_size (sectp
);
12937 else if (names
->loc_dwo
.matches (sectp
->name
))
12939 dwp_file
->sections
.loc
.s
.section
= sectp
;
12940 dwp_file
->sections
.loc
.size
= bfd_section_size (sectp
);
12942 else if (names
->macinfo_dwo
.matches (sectp
->name
))
12944 dwp_file
->sections
.macinfo
.s
.section
= sectp
;
12945 dwp_file
->sections
.macinfo
.size
= bfd_section_size (sectp
);
12947 else if (names
->macro_dwo
.matches (sectp
->name
))
12949 dwp_file
->sections
.macro
.s
.section
= sectp
;
12950 dwp_file
->sections
.macro
.size
= bfd_section_size (sectp
);
12952 else if (names
->str_offsets_dwo
.matches (sectp
->name
))
12954 dwp_file
->sections
.str_offsets
.s
.section
= sectp
;
12955 dwp_file
->sections
.str_offsets
.size
= bfd_section_size (sectp
);
12957 else if (names
->types_dwo
.matches (sectp
->name
))
12959 dwp_file
->sections
.types
.s
.section
= sectp
;
12960 dwp_file
->sections
.types
.size
= bfd_section_size (sectp
);
12964 /* This function is mapped across the sections and remembers the offset and
12965 size of each of the DWP version 5 debugging sections that we are interested
12966 in. This is split into a separate function because we don't know if we
12967 have version 1 or 2 or 5 until we parse the cu_index/tu_index sections. */
12970 dwarf2_locate_v5_dwp_sections (bfd
*abfd
, asection
*sectp
, void *dwp_file_ptr
)
12972 struct dwp_file
*dwp_file
= (struct dwp_file
*) dwp_file_ptr
;
12973 const struct dwop_section_names
*names
= &dwop_section_names
;
12974 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
12976 /* Record the ELF section number for later lookup: this is what the
12977 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
12978 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
12979 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
12981 /* Look for specific sections that we need. */
12982 if (names
->abbrev_dwo
.matches (sectp
->name
))
12984 dwp_file
->sections
.abbrev
.s
.section
= sectp
;
12985 dwp_file
->sections
.abbrev
.size
= bfd_section_size (sectp
);
12987 else if (names
->info_dwo
.matches (sectp
->name
))
12989 dwp_file
->sections
.info
.s
.section
= sectp
;
12990 dwp_file
->sections
.info
.size
= bfd_section_size (sectp
);
12992 else if (names
->line_dwo
.matches (sectp
->name
))
12994 dwp_file
->sections
.line
.s
.section
= sectp
;
12995 dwp_file
->sections
.line
.size
= bfd_section_size (sectp
);
12997 else if (names
->loclists_dwo
.matches (sectp
->name
))
12999 dwp_file
->sections
.loclists
.s
.section
= sectp
;
13000 dwp_file
->sections
.loclists
.size
= bfd_section_size (sectp
);
13002 else if (names
->macro_dwo
.matches (sectp
->name
))
13004 dwp_file
->sections
.macro
.s
.section
= sectp
;
13005 dwp_file
->sections
.macro
.size
= bfd_section_size (sectp
);
13007 else if (names
->rnglists_dwo
.matches (sectp
->name
))
13009 dwp_file
->sections
.rnglists
.s
.section
= sectp
;
13010 dwp_file
->sections
.rnglists
.size
= bfd_section_size (sectp
);
13012 else if (names
->str_offsets_dwo
.matches (sectp
->name
))
13014 dwp_file
->sections
.str_offsets
.s
.section
= sectp
;
13015 dwp_file
->sections
.str_offsets
.size
= bfd_section_size (sectp
);
13019 /* Hash function for dwp_file loaded CUs/TUs. */
13022 hash_dwp_loaded_cutus (const void *item
)
13024 const struct dwo_unit
*dwo_unit
= (const struct dwo_unit
*) item
;
13026 /* This drops the top 32 bits of the signature, but is ok for a hash. */
13027 return dwo_unit
->signature
;
13030 /* Equality function for dwp_file loaded CUs/TUs. */
13033 eq_dwp_loaded_cutus (const void *a
, const void *b
)
13035 const struct dwo_unit
*dua
= (const struct dwo_unit
*) a
;
13036 const struct dwo_unit
*dub
= (const struct dwo_unit
*) b
;
13038 return dua
->signature
== dub
->signature
;
13041 /* Allocate a hash table for dwp_file loaded CUs/TUs. */
13044 allocate_dwp_loaded_cutus_table ()
13046 return htab_up (htab_create_alloc (3,
13047 hash_dwp_loaded_cutus
,
13048 eq_dwp_loaded_cutus
,
13049 NULL
, xcalloc
, xfree
));
13052 /* Try to open DWP file FILE_NAME.
13053 The result is the bfd handle of the file.
13054 If there is a problem finding or opening the file, return NULL.
13055 Upon success, the canonicalized path of the file is stored in the bfd,
13056 same as symfile_bfd_open. */
13058 static gdb_bfd_ref_ptr
13059 open_dwp_file (dwarf2_per_objfile
*per_objfile
, const char *file_name
)
13061 gdb_bfd_ref_ptr
abfd (try_open_dwop_file (per_objfile
, file_name
,
13063 1 /*search_cwd*/));
13067 /* Work around upstream bug 15652.
13068 http://sourceware.org/bugzilla/show_bug.cgi?id=15652
13069 [Whether that's a "bug" is debatable, but it is getting in our way.]
13070 We have no real idea where the dwp file is, because gdb's realpath-ing
13071 of the executable's path may have discarded the needed info.
13072 [IWBN if the dwp file name was recorded in the executable, akin to
13073 .gnu_debuglink, but that doesn't exist yet.]
13074 Strip the directory from FILE_NAME and search again. */
13075 if (*debug_file_directory
!= '\0')
13077 /* Don't implicitly search the current directory here.
13078 If the user wants to search "." to handle this case,
13079 it must be added to debug-file-directory. */
13080 return try_open_dwop_file (per_objfile
, lbasename (file_name
),
13088 /* Initialize the use of the DWP file for the current objfile.
13089 By convention the name of the DWP file is ${objfile}.dwp.
13090 The result is NULL if it can't be found. */
13092 static std::unique_ptr
<struct dwp_file
>
13093 open_and_init_dwp_file (dwarf2_per_objfile
*per_objfile
)
13095 struct objfile
*objfile
= per_objfile
->objfile
;
13097 /* Try to find first .dwp for the binary file before any symbolic links
13100 /* If the objfile is a debug file, find the name of the real binary
13101 file and get the name of dwp file from there. */
13102 std::string dwp_name
;
13103 if (objfile
->separate_debug_objfile_backlink
!= NULL
)
13105 struct objfile
*backlink
= objfile
->separate_debug_objfile_backlink
;
13106 const char *backlink_basename
= lbasename (backlink
->original_name
);
13108 dwp_name
= ldirname (objfile
->original_name
) + SLASH_STRING
+ backlink_basename
;
13111 dwp_name
= objfile
->original_name
;
13113 dwp_name
+= ".dwp";
13115 gdb_bfd_ref_ptr
dbfd (open_dwp_file (per_objfile
, dwp_name
.c_str ()));
13117 && strcmp (objfile
->original_name
, objfile_name (objfile
)) != 0)
13119 /* Try to find .dwp for the binary file after gdb_realpath resolving. */
13120 dwp_name
= objfile_name (objfile
);
13121 dwp_name
+= ".dwp";
13122 dbfd
= open_dwp_file (per_objfile
, dwp_name
.c_str ());
13127 dwarf_read_debug_printf ("DWP file not found: %s", dwp_name
.c_str ());
13129 return std::unique_ptr
<dwp_file
> ();
13132 const char *name
= bfd_get_filename (dbfd
.get ());
13133 std::unique_ptr
<struct dwp_file
> dwp_file
13134 (new struct dwp_file (name
, std::move (dbfd
)));
13136 dwp_file
->num_sections
= elf_numsections (dwp_file
->dbfd
);
13137 dwp_file
->elf_sections
=
13138 OBSTACK_CALLOC (&per_objfile
->per_bfd
->obstack
,
13139 dwp_file
->num_sections
, asection
*);
13141 for (asection
*sec
: gdb_bfd_sections (dwp_file
->dbfd
))
13142 dwarf2_locate_common_dwp_sections (dwp_file
->dbfd
.get (), sec
,
13145 dwp_file
->cus
= create_dwp_hash_table (per_objfile
, dwp_file
.get (), 0);
13147 dwp_file
->tus
= create_dwp_hash_table (per_objfile
, dwp_file
.get (), 1);
13149 /* The DWP file version is stored in the hash table. Oh well. */
13150 if (dwp_file
->cus
&& dwp_file
->tus
13151 && dwp_file
->cus
->version
!= dwp_file
->tus
->version
)
13153 /* Technically speaking, we should try to limp along, but this is
13154 pretty bizarre. We use pulongest here because that's the established
13155 portability solution (e.g, we cannot use %u for uint32_t). */
13156 error (_("Dwarf Error: DWP file CU version %s doesn't match"
13157 " TU version %s [in DWP file %s]"),
13158 pulongest (dwp_file
->cus
->version
),
13159 pulongest (dwp_file
->tus
->version
), dwp_name
.c_str ());
13163 dwp_file
->version
= dwp_file
->cus
->version
;
13164 else if (dwp_file
->tus
)
13165 dwp_file
->version
= dwp_file
->tus
->version
;
13167 dwp_file
->version
= 2;
13169 for (asection
*sec
: gdb_bfd_sections (dwp_file
->dbfd
))
13171 if (dwp_file
->version
== 2)
13172 dwarf2_locate_v2_dwp_sections (dwp_file
->dbfd
.get (), sec
,
13175 dwarf2_locate_v5_dwp_sections (dwp_file
->dbfd
.get (), sec
,
13179 dwp_file
->loaded_cus
= allocate_dwp_loaded_cutus_table ();
13180 dwp_file
->loaded_tus
= allocate_dwp_loaded_cutus_table ();
13182 dwarf_read_debug_printf ("DWP file found: %s", dwp_file
->name
);
13183 dwarf_read_debug_printf (" %s CUs, %s TUs",
13184 pulongest (dwp_file
->cus
? dwp_file
->cus
->nr_units
: 0),
13185 pulongest (dwp_file
->tus
? dwp_file
->tus
->nr_units
: 0));
13190 /* Wrapper around open_and_init_dwp_file, only open it once. */
13192 static struct dwp_file
*
13193 get_dwp_file (dwarf2_per_objfile
*per_objfile
)
13195 if (!per_objfile
->per_bfd
->dwp_checked
)
13197 per_objfile
->per_bfd
->dwp_file
= open_and_init_dwp_file (per_objfile
);
13198 per_objfile
->per_bfd
->dwp_checked
= 1;
13200 return per_objfile
->per_bfd
->dwp_file
.get ();
13203 /* Subroutine of lookup_dwo_comp_unit, lookup_dwo_type_unit.
13204 Look up the CU/TU with signature SIGNATURE, either in DWO file DWO_NAME
13205 or in the DWP file for the objfile, referenced by THIS_UNIT.
13206 If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
13207 IS_DEBUG_TYPES is non-zero if reading a TU, otherwise read a CU.
13209 This is called, for example, when wanting to read a variable with a
13210 complex location. Therefore we don't want to do file i/o for every call.
13211 Therefore we don't want to look for a DWO file on every call.
13212 Therefore we first see if we've already seen SIGNATURE in a DWP file,
13213 then we check if we've already seen DWO_NAME, and only THEN do we check
13216 The result is a pointer to the dwo_unit object or NULL if we didn't find it
13217 (dwo_id mismatch or couldn't find the DWO/DWP file). */
13219 static struct dwo_unit
*
13220 lookup_dwo_cutu (dwarf2_cu
*cu
, const char *dwo_name
, const char *comp_dir
,
13221 ULONGEST signature
, int is_debug_types
)
13223 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
13224 struct objfile
*objfile
= per_objfile
->objfile
;
13225 const char *kind
= is_debug_types
? "TU" : "CU";
13226 void **dwo_file_slot
;
13227 struct dwo_file
*dwo_file
;
13228 struct dwp_file
*dwp_file
;
13230 /* First see if there's a DWP file.
13231 If we have a DWP file but didn't find the DWO inside it, don't
13232 look for the original DWO file. It makes gdb behave differently
13233 depending on whether one is debugging in the build tree. */
13235 dwp_file
= get_dwp_file (per_objfile
);
13236 if (dwp_file
!= NULL
)
13238 const struct dwp_hash_table
*dwp_htab
=
13239 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
13241 if (dwp_htab
!= NULL
)
13243 struct dwo_unit
*dwo_cutu
=
13244 lookup_dwo_unit_in_dwp (per_objfile
, dwp_file
, comp_dir
, signature
,
13247 if (dwo_cutu
!= NULL
)
13249 dwarf_read_debug_printf ("Virtual DWO %s %s found: @%s",
13250 kind
, hex_string (signature
),
13251 host_address_to_string (dwo_cutu
));
13259 /* No DWP file, look for the DWO file. */
13261 dwo_file_slot
= lookup_dwo_file_slot (per_objfile
, dwo_name
, comp_dir
);
13262 if (*dwo_file_slot
== NULL
)
13264 /* Read in the file and build a table of the CUs/TUs it contains. */
13265 *dwo_file_slot
= open_and_init_dwo_file (cu
, dwo_name
, comp_dir
);
13267 /* NOTE: This will be NULL if unable to open the file. */
13268 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
13270 if (dwo_file
!= NULL
)
13272 struct dwo_unit
*dwo_cutu
= NULL
;
13274 if (is_debug_types
&& dwo_file
->tus
)
13276 struct dwo_unit find_dwo_cutu
;
13278 memset (&find_dwo_cutu
, 0, sizeof (find_dwo_cutu
));
13279 find_dwo_cutu
.signature
= signature
;
13281 = (struct dwo_unit
*) htab_find (dwo_file
->tus
.get (),
13284 else if (!is_debug_types
&& dwo_file
->cus
)
13286 struct dwo_unit find_dwo_cutu
;
13288 memset (&find_dwo_cutu
, 0, sizeof (find_dwo_cutu
));
13289 find_dwo_cutu
.signature
= signature
;
13290 dwo_cutu
= (struct dwo_unit
*)htab_find (dwo_file
->cus
.get (),
13294 if (dwo_cutu
!= NULL
)
13296 dwarf_read_debug_printf ("DWO %s %s(%s) found: @%s",
13297 kind
, dwo_name
, hex_string (signature
),
13298 host_address_to_string (dwo_cutu
));
13305 /* We didn't find it. This could mean a dwo_id mismatch, or
13306 someone deleted the DWO/DWP file, or the search path isn't set up
13307 correctly to find the file. */
13309 dwarf_read_debug_printf ("DWO %s %s(%s) not found",
13310 kind
, dwo_name
, hex_string (signature
));
13312 /* This is a warning and not a complaint because it can be caused by
13313 pilot error (e.g., user accidentally deleting the DWO). */
13315 /* Print the name of the DWP file if we looked there, helps the user
13316 better diagnose the problem. */
13317 std::string dwp_text
;
13319 if (dwp_file
!= NULL
)
13320 dwp_text
= string_printf (" [in DWP file %s]",
13321 lbasename (dwp_file
->name
));
13323 warning (_("Could not find DWO %s %s(%s)%s referenced by %s at offset %s"
13324 " [in module %s]"),
13325 kind
, dwo_name
, hex_string (signature
), dwp_text
.c_str (), kind
,
13326 sect_offset_str (cu
->per_cu
->sect_off
), objfile_name (objfile
));
13331 /* Lookup the DWO CU DWO_NAME/SIGNATURE referenced from THIS_CU.
13332 See lookup_dwo_cutu_unit for details. */
13334 static struct dwo_unit
*
13335 lookup_dwo_comp_unit (dwarf2_cu
*cu
, const char *dwo_name
, const char *comp_dir
,
13336 ULONGEST signature
)
13338 gdb_assert (!cu
->per_cu
->is_debug_types
);
13340 return lookup_dwo_cutu (cu
, dwo_name
, comp_dir
, signature
, 0);
13343 /* Lookup the DWO TU DWO_NAME/SIGNATURE referenced from THIS_TU.
13344 See lookup_dwo_cutu_unit for details. */
13346 static struct dwo_unit
*
13347 lookup_dwo_type_unit (dwarf2_cu
*cu
, const char *dwo_name
, const char *comp_dir
)
13349 gdb_assert (cu
->per_cu
->is_debug_types
);
13351 signatured_type
*sig_type
= (signatured_type
*) cu
->per_cu
;
13353 return lookup_dwo_cutu (cu
, dwo_name
, comp_dir
, sig_type
->signature
, 1);
13356 /* Traversal function for queue_and_load_all_dwo_tus. */
13359 queue_and_load_dwo_tu (void **slot
, void *info
)
13361 struct dwo_unit
*dwo_unit
= (struct dwo_unit
*) *slot
;
13362 dwarf2_cu
*cu
= (dwarf2_cu
*) info
;
13363 ULONGEST signature
= dwo_unit
->signature
;
13364 signatured_type
*sig_type
= lookup_dwo_signatured_type (cu
, signature
);
13366 if (sig_type
!= NULL
)
13368 struct dwarf2_per_cu_data
*sig_cu
= &sig_type
->per_cu
;
13370 /* We pass NULL for DEPENDENT_CU because we don't yet know if there's
13371 a real dependency of PER_CU on SIG_TYPE. That is detected later
13372 while processing PER_CU. */
13373 if (maybe_queue_comp_unit (NULL
, sig_cu
, cu
->per_objfile
, cu
->language
))
13374 load_full_type_unit (sig_cu
, cu
->per_objfile
);
13375 cu
->per_cu
->imported_symtabs_push (sig_cu
);
13381 /* Queue all TUs contained in the DWO of CU to be read in.
13382 The DWO may have the only definition of the type, though it may not be
13383 referenced anywhere in PER_CU. Thus we have to load *all* its TUs.
13384 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
13387 queue_and_load_all_dwo_tus (dwarf2_cu
*cu
)
13389 struct dwo_unit
*dwo_unit
;
13390 struct dwo_file
*dwo_file
;
13392 gdb_assert (cu
!= nullptr);
13393 gdb_assert (!cu
->per_cu
->is_debug_types
);
13394 gdb_assert (get_dwp_file (cu
->per_objfile
) == nullptr);
13396 dwo_unit
= cu
->dwo_unit
;
13397 gdb_assert (dwo_unit
!= NULL
);
13399 dwo_file
= dwo_unit
->dwo_file
;
13400 if (dwo_file
->tus
!= NULL
)
13401 htab_traverse_noresize (dwo_file
->tus
.get (), queue_and_load_dwo_tu
, cu
);
13404 /* Read in various DIEs. */
13406 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
13407 Inherit only the children of the DW_AT_abstract_origin DIE not being
13408 already referenced by DW_AT_abstract_origin from the children of the
13412 inherit_abstract_dies (struct die_info
*die
, struct dwarf2_cu
*cu
)
13414 struct die_info
*child_die
;
13415 sect_offset
*offsetp
;
13416 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
13417 struct die_info
*origin_die
;
13418 /* Iterator of the ORIGIN_DIE children. */
13419 struct die_info
*origin_child_die
;
13420 struct attribute
*attr
;
13421 struct dwarf2_cu
*origin_cu
;
13422 struct pending
**origin_previous_list_in_scope
;
13424 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
13428 /* Note that following die references may follow to a die in a
13432 origin_die
= follow_die_ref (die
, attr
, &origin_cu
);
13434 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
13436 origin_previous_list_in_scope
= origin_cu
->list_in_scope
;
13437 origin_cu
->list_in_scope
= cu
->list_in_scope
;
13439 if (die
->tag
!= origin_die
->tag
13440 && !(die
->tag
== DW_TAG_inlined_subroutine
13441 && origin_die
->tag
== DW_TAG_subprogram
))
13442 complaint (_("DIE %s and its abstract origin %s have different tags"),
13443 sect_offset_str (die
->sect_off
),
13444 sect_offset_str (origin_die
->sect_off
));
13446 std::vector
<sect_offset
> offsets
;
13448 for (child_die
= die
->child
;
13449 child_die
&& child_die
->tag
;
13450 child_die
= child_die
->sibling
)
13452 struct die_info
*child_origin_die
;
13453 struct dwarf2_cu
*child_origin_cu
;
13455 /* We are trying to process concrete instance entries:
13456 DW_TAG_call_site DIEs indeed have a DW_AT_abstract_origin tag, but
13457 it's not relevant to our analysis here. i.e. detecting DIEs that are
13458 present in the abstract instance but not referenced in the concrete
13460 if (child_die
->tag
== DW_TAG_call_site
13461 || child_die
->tag
== DW_TAG_GNU_call_site
)
13464 /* For each CHILD_DIE, find the corresponding child of
13465 ORIGIN_DIE. If there is more than one layer of
13466 DW_AT_abstract_origin, follow them all; there shouldn't be,
13467 but GCC versions at least through 4.4 generate this (GCC PR
13469 child_origin_die
= child_die
;
13470 child_origin_cu
= cu
;
13473 attr
= dwarf2_attr (child_origin_die
, DW_AT_abstract_origin
,
13477 child_origin_die
= follow_die_ref (child_origin_die
, attr
,
13481 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
13482 counterpart may exist. */
13483 if (child_origin_die
!= child_die
)
13485 if (child_die
->tag
!= child_origin_die
->tag
13486 && !(child_die
->tag
== DW_TAG_inlined_subroutine
13487 && child_origin_die
->tag
== DW_TAG_subprogram
))
13488 complaint (_("Child DIE %s and its abstract origin %s have "
13490 sect_offset_str (child_die
->sect_off
),
13491 sect_offset_str (child_origin_die
->sect_off
));
13492 if (child_origin_die
->parent
!= origin_die
)
13493 complaint (_("Child DIE %s and its abstract origin %s have "
13494 "different parents"),
13495 sect_offset_str (child_die
->sect_off
),
13496 sect_offset_str (child_origin_die
->sect_off
));
13498 offsets
.push_back (child_origin_die
->sect_off
);
13501 std::sort (offsets
.begin (), offsets
.end ());
13502 sect_offset
*offsets_end
= offsets
.data () + offsets
.size ();
13503 for (offsetp
= offsets
.data () + 1; offsetp
< offsets_end
; offsetp
++)
13504 if (offsetp
[-1] == *offsetp
)
13505 complaint (_("Multiple children of DIE %s refer "
13506 "to DIE %s as their abstract origin"),
13507 sect_offset_str (die
->sect_off
), sect_offset_str (*offsetp
));
13509 offsetp
= offsets
.data ();
13510 origin_child_die
= origin_die
->child
;
13511 while (origin_child_die
&& origin_child_die
->tag
)
13513 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
13514 while (offsetp
< offsets_end
13515 && *offsetp
< origin_child_die
->sect_off
)
13517 if (offsetp
>= offsets_end
13518 || *offsetp
> origin_child_die
->sect_off
)
13520 /* Found that ORIGIN_CHILD_DIE is really not referenced.
13521 Check whether we're already processing ORIGIN_CHILD_DIE.
13522 This can happen with mutually referenced abstract_origins.
13524 if (!origin_child_die
->in_process
)
13525 process_die (origin_child_die
, origin_cu
);
13527 origin_child_die
= origin_child_die
->sibling
;
13529 origin_cu
->list_in_scope
= origin_previous_list_in_scope
;
13531 if (cu
!= origin_cu
)
13532 compute_delayed_physnames (origin_cu
);
13536 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13538 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
13539 struct gdbarch
*gdbarch
= objfile
->arch ();
13540 struct context_stack
*newobj
;
13543 struct die_info
*child_die
;
13544 struct attribute
*attr
, *call_line
, *call_file
;
13546 CORE_ADDR baseaddr
;
13547 struct block
*block
;
13548 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
13549 std::vector
<struct symbol
*> template_args
;
13550 struct template_symbol
*templ_func
= NULL
;
13554 /* If we do not have call site information, we can't show the
13555 caller of this inlined function. That's too confusing, so
13556 only use the scope for local variables. */
13557 call_line
= dwarf2_attr (die
, DW_AT_call_line
, cu
);
13558 call_file
= dwarf2_attr (die
, DW_AT_call_file
, cu
);
13559 if (call_line
== NULL
|| call_file
== NULL
)
13561 read_lexical_block_scope (die
, cu
);
13566 baseaddr
= objfile
->text_section_offset ();
13568 name
= dwarf2_name (die
, cu
);
13570 /* Ignore functions with missing or empty names. These are actually
13571 illegal according to the DWARF standard. */
13574 complaint (_("missing name for subprogram DIE at %s"),
13575 sect_offset_str (die
->sect_off
));
13579 /* Ignore functions with missing or invalid low and high pc attributes. */
13580 if (dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
)
13581 <= PC_BOUNDS_INVALID
)
13583 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
13584 if (attr
== nullptr || !attr
->as_boolean ())
13585 complaint (_("cannot get low and high bounds "
13586 "for subprogram DIE at %s"),
13587 sect_offset_str (die
->sect_off
));
13591 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
13592 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
13594 /* If we have any template arguments, then we must allocate a
13595 different sort of symbol. */
13596 for (child_die
= die
->child
; child_die
; child_die
= child_die
->sibling
)
13598 if (child_die
->tag
== DW_TAG_template_type_param
13599 || child_die
->tag
== DW_TAG_template_value_param
)
13601 templ_func
= new (&objfile
->objfile_obstack
) template_symbol
;
13602 templ_func
->subclass
= SYMBOL_TEMPLATE
;
13607 newobj
= cu
->get_builder ()->push_context (0, lowpc
);
13608 newobj
->name
= new_symbol (die
, read_type_die (die
, cu
), cu
,
13609 (struct symbol
*) templ_func
);
13611 if (dwarf2_flag_true_p (die
, DW_AT_main_subprogram
, cu
))
13612 set_objfile_main_name (objfile
, newobj
->name
->linkage_name (),
13615 /* If there is a location expression for DW_AT_frame_base, record
13617 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
13618 if (attr
!= nullptr)
13619 dwarf2_symbol_mark_computed (attr
, newobj
->name
, cu
, 1);
13621 /* If there is a location for the static link, record it. */
13622 newobj
->static_link
= NULL
;
13623 attr
= dwarf2_attr (die
, DW_AT_static_link
, cu
);
13624 if (attr
!= nullptr)
13626 newobj
->static_link
13627 = XOBNEW (&objfile
->objfile_obstack
, struct dynamic_prop
);
13628 attr_to_dynamic_prop (attr
, die
, cu
, newobj
->static_link
,
13632 cu
->list_in_scope
= cu
->get_builder ()->get_local_symbols ();
13634 if (die
->child
!= NULL
)
13636 child_die
= die
->child
;
13637 while (child_die
&& child_die
->tag
)
13639 if (child_die
->tag
== DW_TAG_template_type_param
13640 || child_die
->tag
== DW_TAG_template_value_param
)
13642 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
13645 template_args
.push_back (arg
);
13648 process_die (child_die
, cu
);
13649 child_die
= child_die
->sibling
;
13653 inherit_abstract_dies (die
, cu
);
13655 /* If we have a DW_AT_specification, we might need to import using
13656 directives from the context of the specification DIE. See the
13657 comment in determine_prefix. */
13658 if (cu
->language
== language_cplus
13659 && dwarf2_attr (die
, DW_AT_specification
, cu
))
13661 struct dwarf2_cu
*spec_cu
= cu
;
13662 struct die_info
*spec_die
= die_specification (die
, &spec_cu
);
13666 child_die
= spec_die
->child
;
13667 while (child_die
&& child_die
->tag
)
13669 if (child_die
->tag
== DW_TAG_imported_module
)
13670 process_die (child_die
, spec_cu
);
13671 child_die
= child_die
->sibling
;
13674 /* In some cases, GCC generates specification DIEs that
13675 themselves contain DW_AT_specification attributes. */
13676 spec_die
= die_specification (spec_die
, &spec_cu
);
13680 struct context_stack cstk
= cu
->get_builder ()->pop_context ();
13681 /* Make a block for the local symbols within. */
13682 block
= cu
->get_builder ()->finish_block (cstk
.name
, cstk
.old_blocks
,
13683 cstk
.static_link
, lowpc
, highpc
);
13685 /* For C++, set the block's scope. */
13686 if ((cu
->language
== language_cplus
13687 || cu
->language
== language_fortran
13688 || cu
->language
== language_d
13689 || cu
->language
== language_rust
)
13690 && cu
->processing_has_namespace_info
)
13691 block_set_scope (block
, determine_prefix (die
, cu
),
13692 &objfile
->objfile_obstack
);
13694 /* If we have address ranges, record them. */
13695 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
13697 gdbarch_make_symbol_special (gdbarch
, cstk
.name
, objfile
);
13699 /* Attach template arguments to function. */
13700 if (!template_args
.empty ())
13702 gdb_assert (templ_func
!= NULL
);
13704 templ_func
->n_template_arguments
= template_args
.size ();
13705 templ_func
->template_arguments
13706 = XOBNEWVEC (&objfile
->objfile_obstack
, struct symbol
*,
13707 templ_func
->n_template_arguments
);
13708 memcpy (templ_func
->template_arguments
,
13709 template_args
.data (),
13710 (templ_func
->n_template_arguments
* sizeof (struct symbol
*)));
13712 /* Make sure that the symtab is set on the new symbols. Even
13713 though they don't appear in this symtab directly, other parts
13714 of gdb assume that symbols do, and this is reasonably
13716 for (symbol
*sym
: template_args
)
13717 symbol_set_symtab (sym
, symbol_symtab (templ_func
));
13720 /* In C++, we can have functions nested inside functions (e.g., when
13721 a function declares a class that has methods). This means that
13722 when we finish processing a function scope, we may need to go
13723 back to building a containing block's symbol lists. */
13724 *cu
->get_builder ()->get_local_symbols () = cstk
.locals
;
13725 cu
->get_builder ()->set_local_using_directives (cstk
.local_using_directives
);
13727 /* If we've finished processing a top-level function, subsequent
13728 symbols go in the file symbol list. */
13729 if (cu
->get_builder ()->outermost_context_p ())
13730 cu
->list_in_scope
= cu
->get_builder ()->get_file_symbols ();
13733 /* Process all the DIES contained within a lexical block scope. Start
13734 a new scope, process the dies, and then close the scope. */
13737 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13739 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
13740 struct gdbarch
*gdbarch
= objfile
->arch ();
13741 CORE_ADDR lowpc
, highpc
;
13742 struct die_info
*child_die
;
13743 CORE_ADDR baseaddr
;
13745 baseaddr
= objfile
->text_section_offset ();
13747 /* Ignore blocks with missing or invalid low and high pc attributes. */
13748 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
13749 as multiple lexical blocks? Handling children in a sane way would
13750 be nasty. Might be easier to properly extend generic blocks to
13751 describe ranges. */
13752 switch (dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
13754 case PC_BOUNDS_NOT_PRESENT
:
13755 /* DW_TAG_lexical_block has no attributes, process its children as if
13756 there was no wrapping by that DW_TAG_lexical_block.
13757 GCC does no longer produces such DWARF since GCC r224161. */
13758 for (child_die
= die
->child
;
13759 child_die
!= NULL
&& child_die
->tag
;
13760 child_die
= child_die
->sibling
)
13762 /* We might already be processing this DIE. This can happen
13763 in an unusual circumstance -- where a subroutine A
13764 appears lexically in another subroutine B, but A actually
13765 inlines B. The recursion is broken here, rather than in
13766 inherit_abstract_dies, because it seems better to simply
13767 drop concrete children here. */
13768 if (!child_die
->in_process
)
13769 process_die (child_die
, cu
);
13772 case PC_BOUNDS_INVALID
:
13775 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
13776 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
13778 cu
->get_builder ()->push_context (0, lowpc
);
13779 if (die
->child
!= NULL
)
13781 child_die
= die
->child
;
13782 while (child_die
&& child_die
->tag
)
13784 process_die (child_die
, cu
);
13785 child_die
= child_die
->sibling
;
13788 inherit_abstract_dies (die
, cu
);
13789 struct context_stack cstk
= cu
->get_builder ()->pop_context ();
13791 if (*cu
->get_builder ()->get_local_symbols () != NULL
13792 || (*cu
->get_builder ()->get_local_using_directives ()) != NULL
)
13794 struct block
*block
13795 = cu
->get_builder ()->finish_block (0, cstk
.old_blocks
, NULL
,
13796 cstk
.start_addr
, highpc
);
13798 /* Note that recording ranges after traversing children, as we
13799 do here, means that recording a parent's ranges entails
13800 walking across all its children's ranges as they appear in
13801 the address map, which is quadratic behavior.
13803 It would be nicer to record the parent's ranges before
13804 traversing its children, simply overriding whatever you find
13805 there. But since we don't even decide whether to create a
13806 block until after we've traversed its children, that's hard
13808 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
13810 *cu
->get_builder ()->get_local_symbols () = cstk
.locals
;
13811 cu
->get_builder ()->set_local_using_directives (cstk
.local_using_directives
);
13814 /* Read in DW_TAG_call_site and insert it to CU->call_site_htab. */
13817 read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13819 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
13820 struct objfile
*objfile
= per_objfile
->objfile
;
13821 struct gdbarch
*gdbarch
= objfile
->arch ();
13822 CORE_ADDR pc
, baseaddr
;
13823 struct attribute
*attr
;
13824 struct call_site
*call_site
, call_site_local
;
13827 struct die_info
*child_die
;
13829 baseaddr
= objfile
->text_section_offset ();
13831 attr
= dwarf2_attr (die
, DW_AT_call_return_pc
, cu
);
13834 /* This was a pre-DWARF-5 GNU extension alias
13835 for DW_AT_call_return_pc. */
13836 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
13840 complaint (_("missing DW_AT_call_return_pc for DW_TAG_call_site "
13841 "DIE %s [in module %s]"),
13842 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
13845 pc
= attr
->as_address () + baseaddr
;
13846 pc
= gdbarch_adjust_dwarf2_addr (gdbarch
, pc
);
13848 if (cu
->call_site_htab
== NULL
)
13849 cu
->call_site_htab
= htab_create_alloc_ex (16, core_addr_hash
, core_addr_eq
,
13850 NULL
, &objfile
->objfile_obstack
,
13851 hashtab_obstack_allocate
, NULL
);
13852 call_site_local
.pc
= pc
;
13853 slot
= htab_find_slot (cu
->call_site_htab
, &call_site_local
, INSERT
);
13856 complaint (_("Duplicate PC %s for DW_TAG_call_site "
13857 "DIE %s [in module %s]"),
13858 paddress (gdbarch
, pc
), sect_offset_str (die
->sect_off
),
13859 objfile_name (objfile
));
13863 /* Count parameters at the caller. */
13866 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
13867 child_die
= child_die
->sibling
)
13869 if (child_die
->tag
!= DW_TAG_call_site_parameter
13870 && child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
13872 complaint (_("Tag %d is not DW_TAG_call_site_parameter in "
13873 "DW_TAG_call_site child DIE %s [in module %s]"),
13874 child_die
->tag
, sect_offset_str (child_die
->sect_off
),
13875 objfile_name (objfile
));
13883 = ((struct call_site
*)
13884 obstack_alloc (&objfile
->objfile_obstack
,
13885 sizeof (*call_site
)
13886 + (sizeof (*call_site
->parameter
) * (nparams
- 1))));
13888 memset (call_site
, 0, sizeof (*call_site
) - sizeof (*call_site
->parameter
));
13889 call_site
->pc
= pc
;
13891 if (dwarf2_flag_true_p (die
, DW_AT_call_tail_call
, cu
)
13892 || dwarf2_flag_true_p (die
, DW_AT_GNU_tail_call
, cu
))
13894 struct die_info
*func_die
;
13896 /* Skip also over DW_TAG_inlined_subroutine. */
13897 for (func_die
= die
->parent
;
13898 func_die
&& func_die
->tag
!= DW_TAG_subprogram
13899 && func_die
->tag
!= DW_TAG_subroutine_type
;
13900 func_die
= func_die
->parent
);
13902 /* DW_AT_call_all_calls is a superset
13903 of DW_AT_call_all_tail_calls. */
13905 && !dwarf2_flag_true_p (func_die
, DW_AT_call_all_calls
, cu
)
13906 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_call_sites
, cu
)
13907 && !dwarf2_flag_true_p (func_die
, DW_AT_call_all_tail_calls
, cu
)
13908 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_tail_call_sites
, cu
))
13910 /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
13911 not complete. But keep CALL_SITE for look ups via call_site_htab,
13912 both the initial caller containing the real return address PC and
13913 the final callee containing the current PC of a chain of tail
13914 calls do not need to have the tail call list complete. But any
13915 function candidate for a virtual tail call frame searched via
13916 TYPE_TAIL_CALL_LIST must have the tail call list complete to be
13917 determined unambiguously. */
13921 struct type
*func_type
= NULL
;
13924 func_type
= get_die_type (func_die
, cu
);
13925 if (func_type
!= NULL
)
13927 gdb_assert (func_type
->code () == TYPE_CODE_FUNC
);
13929 /* Enlist this call site to the function. */
13930 call_site
->tail_call_next
= TYPE_TAIL_CALL_LIST (func_type
);
13931 TYPE_TAIL_CALL_LIST (func_type
) = call_site
;
13934 complaint (_("Cannot find function owning DW_TAG_call_site "
13935 "DIE %s [in module %s]"),
13936 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
13940 attr
= dwarf2_attr (die
, DW_AT_call_target
, cu
);
13942 attr
= dwarf2_attr (die
, DW_AT_GNU_call_site_target
, cu
);
13944 attr
= dwarf2_attr (die
, DW_AT_call_origin
, cu
);
13947 /* This was a pre-DWARF-5 GNU extension alias for DW_AT_call_origin. */
13948 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
13950 SET_FIELD_DWARF_BLOCK (call_site
->target
, NULL
);
13951 if (!attr
|| (attr
->form_is_block () && attr
->as_block ()->size
== 0))
13952 /* Keep NULL DWARF_BLOCK. */;
13953 else if (attr
->form_is_block ())
13955 struct dwarf2_locexpr_baton
*dlbaton
;
13956 struct dwarf_block
*block
= attr
->as_block ();
13958 dlbaton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
13959 dlbaton
->data
= block
->data
;
13960 dlbaton
->size
= block
->size
;
13961 dlbaton
->per_objfile
= per_objfile
;
13962 dlbaton
->per_cu
= cu
->per_cu
;
13964 SET_FIELD_DWARF_BLOCK (call_site
->target
, dlbaton
);
13966 else if (attr
->form_is_ref ())
13968 struct dwarf2_cu
*target_cu
= cu
;
13969 struct die_info
*target_die
;
13971 target_die
= follow_die_ref (die
, attr
, &target_cu
);
13972 gdb_assert (target_cu
->per_objfile
->objfile
== objfile
);
13973 if (die_is_declaration (target_die
, target_cu
))
13975 const char *target_physname
;
13977 /* Prefer the mangled name; otherwise compute the demangled one. */
13978 target_physname
= dw2_linkage_name (target_die
, target_cu
);
13979 if (target_physname
== NULL
)
13980 target_physname
= dwarf2_physname (NULL
, target_die
, target_cu
);
13981 if (target_physname
== NULL
)
13982 complaint (_("DW_AT_call_target target DIE has invalid "
13983 "physname, for referencing DIE %s [in module %s]"),
13984 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
13986 SET_FIELD_PHYSNAME (call_site
->target
, target_physname
);
13992 /* DW_AT_entry_pc should be preferred. */
13993 if (dwarf2_get_pc_bounds (target_die
, &lowpc
, NULL
, target_cu
, NULL
)
13994 <= PC_BOUNDS_INVALID
)
13995 complaint (_("DW_AT_call_target target DIE has invalid "
13996 "low pc, for referencing DIE %s [in module %s]"),
13997 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
14000 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
14001 SET_FIELD_PHYSADDR (call_site
->target
, lowpc
);
14006 complaint (_("DW_TAG_call_site DW_AT_call_target is neither "
14007 "block nor reference, for DIE %s [in module %s]"),
14008 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
14010 call_site
->per_cu
= cu
->per_cu
;
14011 call_site
->per_objfile
= per_objfile
;
14013 for (child_die
= die
->child
;
14014 child_die
&& child_die
->tag
;
14015 child_die
= child_die
->sibling
)
14017 struct call_site_parameter
*parameter
;
14018 struct attribute
*loc
, *origin
;
14020 if (child_die
->tag
!= DW_TAG_call_site_parameter
14021 && child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
14023 /* Already printed the complaint above. */
14027 gdb_assert (call_site
->parameter_count
< nparams
);
14028 parameter
= &call_site
->parameter
[call_site
->parameter_count
];
14030 /* DW_AT_location specifies the register number or DW_AT_abstract_origin
14031 specifies DW_TAG_formal_parameter. Value of the data assumed for the
14032 register is contained in DW_AT_call_value. */
14034 loc
= dwarf2_attr (child_die
, DW_AT_location
, cu
);
14035 origin
= dwarf2_attr (child_die
, DW_AT_call_parameter
, cu
);
14036 if (origin
== NULL
)
14038 /* This was a pre-DWARF-5 GNU extension alias
14039 for DW_AT_call_parameter. */
14040 origin
= dwarf2_attr (child_die
, DW_AT_abstract_origin
, cu
);
14042 if (loc
== NULL
&& origin
!= NULL
&& origin
->form_is_ref ())
14044 parameter
->kind
= CALL_SITE_PARAMETER_PARAM_OFFSET
;
14046 sect_offset sect_off
= origin
->get_ref_die_offset ();
14047 if (!cu
->header
.offset_in_cu_p (sect_off
))
14049 /* As DW_OP_GNU_parameter_ref uses CU-relative offset this
14050 binding can be done only inside one CU. Such referenced DIE
14051 therefore cannot be even moved to DW_TAG_partial_unit. */
14052 complaint (_("DW_AT_call_parameter offset is not in CU for "
14053 "DW_TAG_call_site child DIE %s [in module %s]"),
14054 sect_offset_str (child_die
->sect_off
),
14055 objfile_name (objfile
));
14058 parameter
->u
.param_cu_off
14059 = (cu_offset
) (sect_off
- cu
->header
.sect_off
);
14061 else if (loc
== NULL
|| origin
!= NULL
|| !loc
->form_is_block ())
14063 complaint (_("No DW_FORM_block* DW_AT_location for "
14064 "DW_TAG_call_site child DIE %s [in module %s]"),
14065 sect_offset_str (child_die
->sect_off
), objfile_name (objfile
));
14070 struct dwarf_block
*block
= loc
->as_block ();
14072 parameter
->u
.dwarf_reg
= dwarf_block_to_dwarf_reg
14073 (block
->data
, &block
->data
[block
->size
]);
14074 if (parameter
->u
.dwarf_reg
!= -1)
14075 parameter
->kind
= CALL_SITE_PARAMETER_DWARF_REG
;
14076 else if (dwarf_block_to_sp_offset (gdbarch
, block
->data
,
14077 &block
->data
[block
->size
],
14078 ¶meter
->u
.fb_offset
))
14079 parameter
->kind
= CALL_SITE_PARAMETER_FB_OFFSET
;
14082 complaint (_("Only single DW_OP_reg or DW_OP_fbreg is supported "
14083 "for DW_FORM_block* DW_AT_location is supported for "
14084 "DW_TAG_call_site child DIE %s "
14086 sect_offset_str (child_die
->sect_off
),
14087 objfile_name (objfile
));
14092 attr
= dwarf2_attr (child_die
, DW_AT_call_value
, cu
);
14094 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_value
, cu
);
14095 if (attr
== NULL
|| !attr
->form_is_block ())
14097 complaint (_("No DW_FORM_block* DW_AT_call_value for "
14098 "DW_TAG_call_site child DIE %s [in module %s]"),
14099 sect_offset_str (child_die
->sect_off
),
14100 objfile_name (objfile
));
14104 struct dwarf_block
*block
= attr
->as_block ();
14105 parameter
->value
= block
->data
;
14106 parameter
->value_size
= block
->size
;
14108 /* Parameters are not pre-cleared by memset above. */
14109 parameter
->data_value
= NULL
;
14110 parameter
->data_value_size
= 0;
14111 call_site
->parameter_count
++;
14113 attr
= dwarf2_attr (child_die
, DW_AT_call_data_value
, cu
);
14115 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_data_value
, cu
);
14116 if (attr
!= nullptr)
14118 if (!attr
->form_is_block ())
14119 complaint (_("No DW_FORM_block* DW_AT_call_data_value for "
14120 "DW_TAG_call_site child DIE %s [in module %s]"),
14121 sect_offset_str (child_die
->sect_off
),
14122 objfile_name (objfile
));
14125 block
= attr
->as_block ();
14126 parameter
->data_value
= block
->data
;
14127 parameter
->data_value_size
= block
->size
;
14133 /* Helper function for read_variable. If DIE represents a virtual
14134 table, then return the type of the concrete object that is
14135 associated with the virtual table. Otherwise, return NULL. */
14137 static struct type
*
14138 rust_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14140 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
14144 /* Find the type DIE. */
14145 struct die_info
*type_die
= NULL
;
14146 struct dwarf2_cu
*type_cu
= cu
;
14148 if (attr
->form_is_ref ())
14149 type_die
= follow_die_ref (die
, attr
, &type_cu
);
14150 if (type_die
== NULL
)
14153 if (dwarf2_attr (type_die
, DW_AT_containing_type
, type_cu
) == NULL
)
14155 return die_containing_type (type_die
, type_cu
);
14158 /* Read a variable (DW_TAG_variable) DIE and create a new symbol. */
14161 read_variable (struct die_info
*die
, struct dwarf2_cu
*cu
)
14163 struct rust_vtable_symbol
*storage
= NULL
;
14165 if (cu
->language
== language_rust
)
14167 struct type
*containing_type
= rust_containing_type (die
, cu
);
14169 if (containing_type
!= NULL
)
14171 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
14173 storage
= new (&objfile
->objfile_obstack
) rust_vtable_symbol
;
14174 storage
->concrete_type
= containing_type
;
14175 storage
->subclass
= SYMBOL_RUST_VTABLE
;
14179 struct symbol
*res
= new_symbol (die
, NULL
, cu
, storage
);
14180 struct attribute
*abstract_origin
14181 = dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
14182 struct attribute
*loc
= dwarf2_attr (die
, DW_AT_location
, cu
);
14183 if (res
== NULL
&& loc
&& abstract_origin
)
14185 /* We have a variable without a name, but with a location and an abstract
14186 origin. This may be a concrete instance of an abstract variable
14187 referenced from an DW_OP_GNU_variable_value, so save it to find it back
14189 struct dwarf2_cu
*origin_cu
= cu
;
14190 struct die_info
*origin_die
14191 = follow_die_ref (die
, abstract_origin
, &origin_cu
);
14192 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
14193 per_objfile
->per_bfd
->abstract_to_concrete
14194 [origin_die
->sect_off
].push_back (die
->sect_off
);
14198 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET
14199 reading .debug_rnglists.
14200 Callback's type should be:
14201 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14202 Return true if the attributes are present and valid, otherwise,
14205 template <typename Callback
>
14207 dwarf2_rnglists_process (unsigned offset
, struct dwarf2_cu
*cu
,
14208 dwarf_tag tag
, Callback
&&callback
)
14210 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
14211 struct objfile
*objfile
= per_objfile
->objfile
;
14212 bfd
*obfd
= objfile
->obfd
;
14213 /* Base address selection entry. */
14214 gdb::optional
<CORE_ADDR
> base
;
14215 const gdb_byte
*buffer
;
14216 CORE_ADDR baseaddr
;
14217 bool overflow
= false;
14218 ULONGEST addr_index
;
14219 struct dwarf2_section_info
*rnglists_section
;
14221 base
= cu
->base_address
;
14222 rnglists_section
= cu_debug_rnglists_section (cu
, tag
);
14223 rnglists_section
->read (objfile
);
14225 if (offset
>= rnglists_section
->size
)
14227 complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
14231 buffer
= rnglists_section
->buffer
+ offset
;
14233 baseaddr
= objfile
->text_section_offset ();
14237 /* Initialize it due to a false compiler warning. */
14238 CORE_ADDR range_beginning
= 0, range_end
= 0;
14239 const gdb_byte
*buf_end
= (rnglists_section
->buffer
14240 + rnglists_section
->size
);
14241 unsigned int bytes_read
;
14243 if (buffer
== buf_end
)
14248 const auto rlet
= static_cast<enum dwarf_range_list_entry
>(*buffer
++);
14251 case DW_RLE_end_of_list
:
14253 case DW_RLE_base_address
:
14254 if (buffer
+ cu
->header
.addr_size
> buf_end
)
14259 base
= cu
->header
.read_address (obfd
, buffer
, &bytes_read
);
14260 buffer
+= bytes_read
;
14262 case DW_RLE_base_addressx
:
14263 addr_index
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14264 buffer
+= bytes_read
;
14265 base
= read_addr_index (cu
, addr_index
);
14267 case DW_RLE_start_length
:
14268 if (buffer
+ cu
->header
.addr_size
> buf_end
)
14273 range_beginning
= cu
->header
.read_address (obfd
, buffer
,
14275 buffer
+= bytes_read
;
14276 range_end
= (range_beginning
14277 + read_unsigned_leb128 (obfd
, buffer
, &bytes_read
));
14278 buffer
+= bytes_read
;
14279 if (buffer
> buf_end
)
14285 case DW_RLE_startx_length
:
14286 addr_index
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14287 buffer
+= bytes_read
;
14288 range_beginning
= read_addr_index (cu
, addr_index
);
14289 if (buffer
> buf_end
)
14294 range_end
= (range_beginning
14295 + read_unsigned_leb128 (obfd
, buffer
, &bytes_read
));
14296 buffer
+= bytes_read
;
14298 case DW_RLE_offset_pair
:
14299 range_beginning
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14300 buffer
+= bytes_read
;
14301 if (buffer
> buf_end
)
14306 range_end
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14307 buffer
+= bytes_read
;
14308 if (buffer
> buf_end
)
14314 case DW_RLE_start_end
:
14315 if (buffer
+ 2 * cu
->header
.addr_size
> buf_end
)
14320 range_beginning
= cu
->header
.read_address (obfd
, buffer
,
14322 buffer
+= bytes_read
;
14323 range_end
= cu
->header
.read_address (obfd
, buffer
, &bytes_read
);
14324 buffer
+= bytes_read
;
14326 case DW_RLE_startx_endx
:
14327 addr_index
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14328 buffer
+= bytes_read
;
14329 range_beginning
= read_addr_index (cu
, addr_index
);
14330 if (buffer
> buf_end
)
14335 addr_index
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14336 buffer
+= bytes_read
;
14337 range_end
= read_addr_index (cu
, addr_index
);
14340 complaint (_("Invalid .debug_rnglists data (no base address)"));
14343 if (rlet
== DW_RLE_end_of_list
|| overflow
)
14345 if (rlet
== DW_RLE_base_address
)
14348 if (range_beginning
> range_end
)
14350 /* Inverted range entries are invalid. */
14351 complaint (_("Invalid .debug_rnglists data (inverted range)"));
14355 /* Empty range entries have no effect. */
14356 if (range_beginning
== range_end
)
14359 /* Only DW_RLE_offset_pair needs the base address added. */
14360 if (rlet
== DW_RLE_offset_pair
)
14362 if (!base
.has_value ())
14364 /* We have no valid base address for the DW_RLE_offset_pair. */
14365 complaint (_("Invalid .debug_rnglists data (no base address for "
14366 "DW_RLE_offset_pair)"));
14370 range_beginning
+= *base
;
14371 range_end
+= *base
;
14374 /* A not-uncommon case of bad debug info.
14375 Don't pollute the addrmap with bad data. */
14376 if (range_beginning
+ baseaddr
== 0
14377 && !per_objfile
->per_bfd
->has_section_at_zero
)
14379 complaint (_(".debug_rnglists entry has start address of zero"
14380 " [in module %s]"), objfile_name (objfile
));
14384 callback (range_beginning
, range_end
);
14389 complaint (_("Offset %d is not terminated "
14390 "for DW_AT_ranges attribute"),
14398 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET reading .debug_ranges.
14399 Callback's type should be:
14400 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14401 Return 1 if the attributes are present and valid, otherwise, return 0. */
14403 template <typename Callback
>
14405 dwarf2_ranges_process (unsigned offset
, struct dwarf2_cu
*cu
, dwarf_tag tag
,
14406 Callback
&&callback
)
14408 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
14409 struct objfile
*objfile
= per_objfile
->objfile
;
14410 struct comp_unit_head
*cu_header
= &cu
->header
;
14411 bfd
*obfd
= objfile
->obfd
;
14412 unsigned int addr_size
= cu_header
->addr_size
;
14413 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
14414 /* Base address selection entry. */
14415 gdb::optional
<CORE_ADDR
> base
;
14416 unsigned int dummy
;
14417 const gdb_byte
*buffer
;
14418 CORE_ADDR baseaddr
;
14420 if (cu_header
->version
>= 5)
14421 return dwarf2_rnglists_process (offset
, cu
, tag
, callback
);
14423 base
= cu
->base_address
;
14425 per_objfile
->per_bfd
->ranges
.read (objfile
);
14426 if (offset
>= per_objfile
->per_bfd
->ranges
.size
)
14428 complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
14432 buffer
= per_objfile
->per_bfd
->ranges
.buffer
+ offset
;
14434 baseaddr
= objfile
->text_section_offset ();
14438 CORE_ADDR range_beginning
, range_end
;
14440 range_beginning
= cu
->header
.read_address (obfd
, buffer
, &dummy
);
14441 buffer
+= addr_size
;
14442 range_end
= cu
->header
.read_address (obfd
, buffer
, &dummy
);
14443 buffer
+= addr_size
;
14444 offset
+= 2 * addr_size
;
14446 /* An end of list marker is a pair of zero addresses. */
14447 if (range_beginning
== 0 && range_end
== 0)
14448 /* Found the end of list entry. */
14451 /* Each base address selection entry is a pair of 2 values.
14452 The first is the largest possible address, the second is
14453 the base address. Check for a base address here. */
14454 if ((range_beginning
& mask
) == mask
)
14456 /* If we found the largest possible address, then we already
14457 have the base address in range_end. */
14462 if (!base
.has_value ())
14464 /* We have no valid base address for the ranges
14466 complaint (_("Invalid .debug_ranges data (no base address)"));
14470 if (range_beginning
> range_end
)
14472 /* Inverted range entries are invalid. */
14473 complaint (_("Invalid .debug_ranges data (inverted range)"));
14477 /* Empty range entries have no effect. */
14478 if (range_beginning
== range_end
)
14481 range_beginning
+= *base
;
14482 range_end
+= *base
;
14484 /* A not-uncommon case of bad debug info.
14485 Don't pollute the addrmap with bad data. */
14486 if (range_beginning
+ baseaddr
== 0
14487 && !per_objfile
->per_bfd
->has_section_at_zero
)
14489 complaint (_(".debug_ranges entry has start address of zero"
14490 " [in module %s]"), objfile_name (objfile
));
14494 callback (range_beginning
, range_end
);
14500 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
14501 Return 1 if the attributes are present and valid, otherwise, return 0.
14502 If RANGES_PST is not NULL we should set up the `psymtabs_addrmap'. */
14505 dwarf2_ranges_read (unsigned offset
, CORE_ADDR
*low_return
,
14506 CORE_ADDR
*high_return
, struct dwarf2_cu
*cu
,
14507 dwarf2_psymtab
*ranges_pst
, dwarf_tag tag
)
14509 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
14510 struct gdbarch
*gdbarch
= objfile
->arch ();
14511 const CORE_ADDR baseaddr
= objfile
->text_section_offset ();
14514 CORE_ADDR high
= 0;
14517 retval
= dwarf2_ranges_process (offset
, cu
, tag
,
14518 [&] (CORE_ADDR range_beginning
, CORE_ADDR range_end
)
14520 if (ranges_pst
!= NULL
)
14525 lowpc
= (gdbarch_adjust_dwarf2_addr (gdbarch
,
14526 range_beginning
+ baseaddr
)
14528 highpc
= (gdbarch_adjust_dwarf2_addr (gdbarch
,
14529 range_end
+ baseaddr
)
14531 addrmap_set_empty (objfile
->partial_symtabs
->psymtabs_addrmap
,
14532 lowpc
, highpc
- 1, ranges_pst
);
14535 /* FIXME: This is recording everything as a low-high
14536 segment of consecutive addresses. We should have a
14537 data structure for discontiguous block ranges
14541 low
= range_beginning
;
14547 if (range_beginning
< low
)
14548 low
= range_beginning
;
14549 if (range_end
> high
)
14557 /* If the first entry is an end-of-list marker, the range
14558 describes an empty scope, i.e. no instructions. */
14564 *high_return
= high
;
14568 /* Get low and high pc attributes from a die. See enum pc_bounds_kind
14569 definition for the return value. *LOWPC and *HIGHPC are set iff
14570 neither PC_BOUNDS_NOT_PRESENT nor PC_BOUNDS_INVALID are returned. */
14572 static enum pc_bounds_kind
14573 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
14574 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
,
14575 dwarf2_psymtab
*pst
)
14577 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
14578 struct attribute
*attr
;
14579 struct attribute
*attr_high
;
14581 CORE_ADDR high
= 0;
14582 enum pc_bounds_kind ret
;
14584 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
14587 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
14588 if (attr
!= nullptr)
14590 low
= attr
->as_address ();
14591 high
= attr_high
->as_address ();
14592 if (cu
->header
.version
>= 4 && attr_high
->form_is_constant ())
14596 /* Found high w/o low attribute. */
14597 return PC_BOUNDS_INVALID
;
14599 /* Found consecutive range of addresses. */
14600 ret
= PC_BOUNDS_HIGH_LOW
;
14604 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
14605 if (attr
!= nullptr && attr
->form_is_unsigned ())
14607 /* Offset in the .debug_ranges or .debug_rnglist section (depending
14608 on DWARF version). */
14609 ULONGEST ranges_offset
= attr
->as_unsigned ();
14611 /* See dwarf2_cu::gnu_ranges_base's doc for why we might want to add
14613 if (die
->tag
!= DW_TAG_compile_unit
)
14614 ranges_offset
+= cu
->gnu_ranges_base
;
14616 /* Value of the DW_AT_ranges attribute is the offset in the
14617 .debug_ranges section. */
14618 if (!dwarf2_ranges_read (ranges_offset
, &low
, &high
, cu
, pst
,
14620 return PC_BOUNDS_INVALID
;
14621 /* Found discontinuous range of addresses. */
14622 ret
= PC_BOUNDS_RANGES
;
14625 return PC_BOUNDS_NOT_PRESENT
;
14628 /* partial_die_info::read has also the strict LOW < HIGH requirement. */
14630 return PC_BOUNDS_INVALID
;
14632 /* When using the GNU linker, .gnu.linkonce. sections are used to
14633 eliminate duplicate copies of functions and vtables and such.
14634 The linker will arbitrarily choose one and discard the others.
14635 The AT_*_pc values for such functions refer to local labels in
14636 these sections. If the section from that file was discarded, the
14637 labels are not in the output, so the relocs get a value of 0.
14638 If this is a discarded function, mark the pc bounds as invalid,
14639 so that GDB will ignore it. */
14640 if (low
== 0 && !per_objfile
->per_bfd
->has_section_at_zero
)
14641 return PC_BOUNDS_INVALID
;
14649 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
14650 its low and high PC addresses. Do nothing if these addresses could not
14651 be determined. Otherwise, set LOWPC to the low address if it is smaller,
14652 and HIGHPC to the high address if greater than HIGHPC. */
14655 dwarf2_get_subprogram_pc_bounds (struct die_info
*die
,
14656 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
14657 struct dwarf2_cu
*cu
)
14659 CORE_ADDR low
, high
;
14660 struct die_info
*child
= die
->child
;
14662 if (dwarf2_get_pc_bounds (die
, &low
, &high
, cu
, NULL
) >= PC_BOUNDS_RANGES
)
14664 *lowpc
= std::min (*lowpc
, low
);
14665 *highpc
= std::max (*highpc
, high
);
14668 /* If the language does not allow nested subprograms (either inside
14669 subprograms or lexical blocks), we're done. */
14670 if (cu
->language
!= language_ada
)
14673 /* Check all the children of the given DIE. If it contains nested
14674 subprograms, then check their pc bounds. Likewise, we need to
14675 check lexical blocks as well, as they may also contain subprogram
14677 while (child
&& child
->tag
)
14679 if (child
->tag
== DW_TAG_subprogram
14680 || child
->tag
== DW_TAG_lexical_block
)
14681 dwarf2_get_subprogram_pc_bounds (child
, lowpc
, highpc
, cu
);
14682 child
= child
->sibling
;
14686 /* Get the low and high pc's represented by the scope DIE, and store
14687 them in *LOWPC and *HIGHPC. If the correct values can't be
14688 determined, set *LOWPC to -1 and *HIGHPC to 0. */
14691 get_scope_pc_bounds (struct die_info
*die
,
14692 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
14693 struct dwarf2_cu
*cu
)
14695 CORE_ADDR best_low
= (CORE_ADDR
) -1;
14696 CORE_ADDR best_high
= (CORE_ADDR
) 0;
14697 CORE_ADDR current_low
, current_high
;
14699 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
, NULL
)
14700 >= PC_BOUNDS_RANGES
)
14702 best_low
= current_low
;
14703 best_high
= current_high
;
14707 struct die_info
*child
= die
->child
;
14709 while (child
&& child
->tag
)
14711 switch (child
->tag
) {
14712 case DW_TAG_subprogram
:
14713 dwarf2_get_subprogram_pc_bounds (child
, &best_low
, &best_high
, cu
);
14715 case DW_TAG_namespace
:
14716 case DW_TAG_module
:
14717 /* FIXME: carlton/2004-01-16: Should we do this for
14718 DW_TAG_class_type/DW_TAG_structure_type, too? I think
14719 that current GCC's always emit the DIEs corresponding
14720 to definitions of methods of classes as children of a
14721 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
14722 the DIEs giving the declarations, which could be
14723 anywhere). But I don't see any reason why the
14724 standards says that they have to be there. */
14725 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
14727 if (current_low
!= ((CORE_ADDR
) -1))
14729 best_low
= std::min (best_low
, current_low
);
14730 best_high
= std::max (best_high
, current_high
);
14738 child
= child
->sibling
;
14743 *highpc
= best_high
;
14746 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
14750 dwarf2_record_block_ranges (struct die_info
*die
, struct block
*block
,
14751 CORE_ADDR baseaddr
, struct dwarf2_cu
*cu
)
14753 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
14754 struct gdbarch
*gdbarch
= objfile
->arch ();
14755 struct attribute
*attr
;
14756 struct attribute
*attr_high
;
14758 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
14761 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
14762 if (attr
!= nullptr)
14764 CORE_ADDR low
= attr
->as_address ();
14765 CORE_ADDR high
= attr_high
->as_address ();
14767 if (cu
->header
.version
>= 4 && attr_high
->form_is_constant ())
14770 low
= gdbarch_adjust_dwarf2_addr (gdbarch
, low
+ baseaddr
);
14771 high
= gdbarch_adjust_dwarf2_addr (gdbarch
, high
+ baseaddr
);
14772 cu
->get_builder ()->record_block_range (block
, low
, high
- 1);
14776 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
14777 if (attr
!= nullptr && attr
->form_is_unsigned ())
14779 /* Offset in the .debug_ranges or .debug_rnglist section (depending
14780 on DWARF version). */
14781 ULONGEST ranges_offset
= attr
->as_unsigned ();
14783 /* See dwarf2_cu::gnu_ranges_base's doc for why we might want to add
14785 if (die
->tag
!= DW_TAG_compile_unit
)
14786 ranges_offset
+= cu
->gnu_ranges_base
;
14788 std::vector
<blockrange
> blockvec
;
14789 dwarf2_ranges_process (ranges_offset
, cu
, die
->tag
,
14790 [&] (CORE_ADDR start
, CORE_ADDR end
)
14794 start
= gdbarch_adjust_dwarf2_addr (gdbarch
, start
);
14795 end
= gdbarch_adjust_dwarf2_addr (gdbarch
, end
);
14796 cu
->get_builder ()->record_block_range (block
, start
, end
- 1);
14797 blockvec
.emplace_back (start
, end
);
14800 BLOCK_RANGES(block
) = make_blockranges (objfile
, blockvec
);
14804 /* Check whether the producer field indicates either of GCC < 4.6, or the
14805 Intel C/C++ compiler, and cache the result in CU. */
14808 check_producer (struct dwarf2_cu
*cu
)
14812 if (cu
->producer
== NULL
)
14814 /* For unknown compilers expect their behavior is DWARF version
14817 GCC started to support .debug_types sections by -gdwarf-4 since
14818 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
14819 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
14820 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
14821 interpreted incorrectly by GDB now - GCC PR debug/48229. */
14823 else if (producer_is_gcc (cu
->producer
, &major
, &minor
))
14825 cu
->producer_is_gxx_lt_4_6
= major
< 4 || (major
== 4 && minor
< 6);
14826 cu
->producer_is_gcc_lt_4_3
= major
< 4 || (major
== 4 && minor
< 3);
14828 else if (producer_is_icc (cu
->producer
, &major
, &minor
))
14830 cu
->producer_is_icc
= true;
14831 cu
->producer_is_icc_lt_14
= major
< 14;
14833 else if (startswith (cu
->producer
, "CodeWarrior S12/L-ISA"))
14834 cu
->producer_is_codewarrior
= true;
14837 /* For other non-GCC compilers, expect their behavior is DWARF version
14841 cu
->checked_producer
= true;
14844 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
14845 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
14846 during 4.6.0 experimental. */
14849 producer_is_gxx_lt_4_6 (struct dwarf2_cu
*cu
)
14851 if (!cu
->checked_producer
)
14852 check_producer (cu
);
14854 return cu
->producer_is_gxx_lt_4_6
;
14858 /* Codewarrior (at least as of version 5.0.40) generates dwarf line information
14859 with incorrect is_stmt attributes. */
14862 producer_is_codewarrior (struct dwarf2_cu
*cu
)
14864 if (!cu
->checked_producer
)
14865 check_producer (cu
);
14867 return cu
->producer_is_codewarrior
;
14870 /* Return the accessibility of DIE, as given by DW_AT_accessibility.
14871 If that attribute is not available, return the appropriate
14874 static enum dwarf_access_attribute
14875 dwarf2_access_attribute (struct die_info
*die
, struct dwarf2_cu
*cu
)
14877 attribute
*attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
14878 if (attr
!= nullptr)
14880 LONGEST value
= attr
->constant_value (-1);
14881 if (value
== DW_ACCESS_public
14882 || value
== DW_ACCESS_protected
14883 || value
== DW_ACCESS_private
)
14884 return (dwarf_access_attribute
) value
;
14885 complaint (_("Unhandled DW_AT_accessibility value (%s)"),
14889 if (cu
->header
.version
< 3 || producer_is_gxx_lt_4_6 (cu
))
14891 /* The default DWARF 2 accessibility for members is public, the default
14892 accessibility for inheritance is private. */
14894 if (die
->tag
!= DW_TAG_inheritance
)
14895 return DW_ACCESS_public
;
14897 return DW_ACCESS_private
;
14901 /* DWARF 3+ defines the default accessibility a different way. The same
14902 rules apply now for DW_TAG_inheritance as for the members and it only
14903 depends on the container kind. */
14905 if (die
->parent
->tag
== DW_TAG_class_type
)
14906 return DW_ACCESS_private
;
14908 return DW_ACCESS_public
;
14912 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
14913 offset. If the attribute was not found return 0, otherwise return
14914 1. If it was found but could not properly be handled, set *OFFSET
14918 handle_data_member_location (struct die_info
*die
, struct dwarf2_cu
*cu
,
14921 struct attribute
*attr
;
14923 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
14928 /* Note that we do not check for a section offset first here.
14929 This is because DW_AT_data_member_location is new in DWARF 4,
14930 so if we see it, we can assume that a constant form is really
14931 a constant and not a section offset. */
14932 if (attr
->form_is_constant ())
14933 *offset
= attr
->constant_value (0);
14934 else if (attr
->form_is_section_offset ())
14935 dwarf2_complex_location_expr_complaint ();
14936 else if (attr
->form_is_block ())
14937 *offset
= decode_locdesc (attr
->as_block (), cu
);
14939 dwarf2_complex_location_expr_complaint ();
14947 /* Look for DW_AT_data_member_location and store the results in FIELD. */
14950 handle_data_member_location (struct die_info
*die
, struct dwarf2_cu
*cu
,
14951 struct field
*field
)
14953 struct attribute
*attr
;
14955 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
14958 if (attr
->form_is_constant ())
14960 LONGEST offset
= attr
->constant_value (0);
14961 SET_FIELD_BITPOS (*field
, offset
* bits_per_byte
);
14963 else if (attr
->form_is_section_offset ())
14964 dwarf2_complex_location_expr_complaint ();
14965 else if (attr
->form_is_block ())
14968 CORE_ADDR offset
= decode_locdesc (attr
->as_block (), cu
, &handled
);
14970 SET_FIELD_BITPOS (*field
, offset
* bits_per_byte
);
14973 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
14974 struct objfile
*objfile
= per_objfile
->objfile
;
14975 struct dwarf2_locexpr_baton
*dlbaton
14976 = XOBNEW (&objfile
->objfile_obstack
,
14977 struct dwarf2_locexpr_baton
);
14978 dlbaton
->data
= attr
->as_block ()->data
;
14979 dlbaton
->size
= attr
->as_block ()->size
;
14980 /* When using this baton, we want to compute the address
14981 of the field, not the value. This is why
14982 is_reference is set to false here. */
14983 dlbaton
->is_reference
= false;
14984 dlbaton
->per_objfile
= per_objfile
;
14985 dlbaton
->per_cu
= cu
->per_cu
;
14987 SET_FIELD_DWARF_BLOCK (*field
, dlbaton
);
14991 dwarf2_complex_location_expr_complaint ();
14995 /* Add an aggregate field to the field list. */
14998 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
14999 struct dwarf2_cu
*cu
)
15001 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
15002 struct gdbarch
*gdbarch
= objfile
->arch ();
15003 struct nextfield
*new_field
;
15004 struct attribute
*attr
;
15006 const char *fieldname
= "";
15008 if (die
->tag
== DW_TAG_inheritance
)
15010 fip
->baseclasses
.emplace_back ();
15011 new_field
= &fip
->baseclasses
.back ();
15015 fip
->fields
.emplace_back ();
15016 new_field
= &fip
->fields
.back ();
15019 new_field
->offset
= die
->sect_off
;
15021 new_field
->accessibility
= dwarf2_access_attribute (die
, cu
);
15022 if (new_field
->accessibility
!= DW_ACCESS_public
)
15023 fip
->non_public_fields
= true;
15025 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
15026 if (attr
!= nullptr)
15027 new_field
->virtuality
= attr
->as_virtuality ();
15029 new_field
->virtuality
= DW_VIRTUALITY_none
;
15031 fp
= &new_field
->field
;
15033 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
15035 /* Data member other than a C++ static data member. */
15037 /* Get type of field. */
15038 fp
->set_type (die_type (die
, cu
));
15040 SET_FIELD_BITPOS (*fp
, 0);
15042 /* Get bit size of field (zero if none). */
15043 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
15044 if (attr
!= nullptr)
15046 FIELD_BITSIZE (*fp
) = attr
->constant_value (0);
15050 FIELD_BITSIZE (*fp
) = 0;
15053 /* Get bit offset of field. */
15054 handle_data_member_location (die
, cu
, fp
);
15055 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
15056 if (attr
!= nullptr && attr
->form_is_constant ())
15058 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
)
15060 /* For big endian bits, the DW_AT_bit_offset gives the
15061 additional bit offset from the MSB of the containing
15062 anonymous object to the MSB of the field. We don't
15063 have to do anything special since we don't need to
15064 know the size of the anonymous object. */
15065 SET_FIELD_BITPOS (*fp
, (FIELD_BITPOS (*fp
)
15066 + attr
->constant_value (0)));
15070 /* For little endian bits, compute the bit offset to the
15071 MSB of the anonymous object, subtract off the number of
15072 bits from the MSB of the field to the MSB of the
15073 object, and then subtract off the number of bits of
15074 the field itself. The result is the bit offset of
15075 the LSB of the field. */
15076 int anonymous_size
;
15077 int bit_offset
= attr
->constant_value (0);
15079 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
15080 if (attr
!= nullptr && attr
->form_is_constant ())
15082 /* The size of the anonymous object containing
15083 the bit field is explicit, so use the
15084 indicated size (in bytes). */
15085 anonymous_size
= attr
->constant_value (0);
15089 /* The size of the anonymous object containing
15090 the bit field must be inferred from the type
15091 attribute of the data member containing the
15093 anonymous_size
= TYPE_LENGTH (fp
->type ());
15095 SET_FIELD_BITPOS (*fp
,
15096 (FIELD_BITPOS (*fp
)
15097 + anonymous_size
* bits_per_byte
15098 - bit_offset
- FIELD_BITSIZE (*fp
)));
15101 attr
= dwarf2_attr (die
, DW_AT_data_bit_offset
, cu
);
15103 SET_FIELD_BITPOS (*fp
, (FIELD_BITPOS (*fp
)
15104 + attr
->constant_value (0)));
15106 /* Get name of field. */
15107 fieldname
= dwarf2_name (die
, cu
);
15108 if (fieldname
== NULL
)
15111 /* The name is already allocated along with this objfile, so we don't
15112 need to duplicate it for the type. */
15113 fp
->name
= fieldname
;
15115 /* Change accessibility for artificial fields (e.g. virtual table
15116 pointer or virtual base class pointer) to private. */
15117 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
15119 FIELD_ARTIFICIAL (*fp
) = 1;
15120 new_field
->accessibility
= DW_ACCESS_private
;
15121 fip
->non_public_fields
= true;
15124 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
15126 /* C++ static member. */
15128 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
15129 is a declaration, but all versions of G++ as of this writing
15130 (so through at least 3.2.1) incorrectly generate
15131 DW_TAG_variable tags. */
15133 const char *physname
;
15135 /* Get name of field. */
15136 fieldname
= dwarf2_name (die
, cu
);
15137 if (fieldname
== NULL
)
15140 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
15142 /* Only create a symbol if this is an external value.
15143 new_symbol checks this and puts the value in the global symbol
15144 table, which we want. If it is not external, new_symbol
15145 will try to put the value in cu->list_in_scope which is wrong. */
15146 && dwarf2_flag_true_p (die
, DW_AT_external
, cu
))
15148 /* A static const member, not much different than an enum as far as
15149 we're concerned, except that we can support more types. */
15150 new_symbol (die
, NULL
, cu
);
15153 /* Get physical name. */
15154 physname
= dwarf2_physname (fieldname
, die
, cu
);
15156 /* The name is already allocated along with this objfile, so we don't
15157 need to duplicate it for the type. */
15158 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
15159 fp
->set_type (die_type (die
, cu
));
15160 FIELD_NAME (*fp
) = fieldname
;
15162 else if (die
->tag
== DW_TAG_inheritance
)
15164 /* C++ base class field. */
15165 handle_data_member_location (die
, cu
, fp
);
15166 FIELD_BITSIZE (*fp
) = 0;
15167 fp
->set_type (die_type (die
, cu
));
15168 FIELD_NAME (*fp
) = fp
->type ()->name ();
15171 gdb_assert_not_reached ("missing case in dwarf2_add_field");
15174 /* Can the type given by DIE define another type? */
15177 type_can_define_types (const struct die_info
*die
)
15181 case DW_TAG_typedef
:
15182 case DW_TAG_class_type
:
15183 case DW_TAG_structure_type
:
15184 case DW_TAG_union_type
:
15185 case DW_TAG_enumeration_type
:
15193 /* Add a type definition defined in the scope of the FIP's class. */
15196 dwarf2_add_type_defn (struct field_info
*fip
, struct die_info
*die
,
15197 struct dwarf2_cu
*cu
)
15199 struct decl_field fp
;
15200 memset (&fp
, 0, sizeof (fp
));
15202 gdb_assert (type_can_define_types (die
));
15204 /* Get name of field. NULL is okay here, meaning an anonymous type. */
15205 fp
.name
= dwarf2_name (die
, cu
);
15206 fp
.type
= read_type_die (die
, cu
);
15208 /* Save accessibility. */
15209 dwarf_access_attribute accessibility
= dwarf2_access_attribute (die
, cu
);
15210 switch (accessibility
)
15212 case DW_ACCESS_public
:
15213 /* The assumed value if neither private nor protected. */
15215 case DW_ACCESS_private
:
15218 case DW_ACCESS_protected
:
15219 fp
.is_protected
= 1;
15223 if (die
->tag
== DW_TAG_typedef
)
15224 fip
->typedef_field_list
.push_back (fp
);
15226 fip
->nested_types_list
.push_back (fp
);
15229 /* A convenience typedef that's used when finding the discriminant
15230 field for a variant part. */
15231 typedef std::unordered_map
<sect_offset
, int, gdb::hash_enum
<sect_offset
>>
15234 /* Compute the discriminant range for a given variant. OBSTACK is
15235 where the results will be stored. VARIANT is the variant to
15236 process. IS_UNSIGNED indicates whether the discriminant is signed
15239 static const gdb::array_view
<discriminant_range
>
15240 convert_variant_range (struct obstack
*obstack
, const variant_field
&variant
,
15243 std::vector
<discriminant_range
> ranges
;
15245 if (variant
.default_branch
)
15248 if (variant
.discr_list_data
== nullptr)
15250 discriminant_range r
15251 = {variant
.discriminant_value
, variant
.discriminant_value
};
15252 ranges
.push_back (r
);
15256 gdb::array_view
<const gdb_byte
> data (variant
.discr_list_data
->data
,
15257 variant
.discr_list_data
->size
);
15258 while (!data
.empty ())
15260 if (data
[0] != DW_DSC_range
&& data
[0] != DW_DSC_label
)
15262 complaint (_("invalid discriminant marker: %d"), data
[0]);
15265 bool is_range
= data
[0] == DW_DSC_range
;
15266 data
= data
.slice (1);
15268 ULONGEST low
, high
;
15269 unsigned int bytes_read
;
15273 complaint (_("DW_AT_discr_list missing low value"));
15277 low
= read_unsigned_leb128 (nullptr, data
.data (), &bytes_read
);
15279 low
= (ULONGEST
) read_signed_leb128 (nullptr, data
.data (),
15281 data
= data
.slice (bytes_read
);
15287 complaint (_("DW_AT_discr_list missing high value"));
15291 high
= read_unsigned_leb128 (nullptr, data
.data (),
15294 high
= (LONGEST
) read_signed_leb128 (nullptr, data
.data (),
15296 data
= data
.slice (bytes_read
);
15301 ranges
.push_back ({ low
, high
});
15305 discriminant_range
*result
= XOBNEWVEC (obstack
, discriminant_range
,
15307 std::copy (ranges
.begin (), ranges
.end (), result
);
15308 return gdb::array_view
<discriminant_range
> (result
, ranges
.size ());
15311 static const gdb::array_view
<variant_part
> create_variant_parts
15312 (struct obstack
*obstack
,
15313 const offset_map_type
&offset_map
,
15314 struct field_info
*fi
,
15315 const std::vector
<variant_part_builder
> &variant_parts
);
15317 /* Fill in a "struct variant" for a given variant field. RESULT is
15318 the variant to fill in. OBSTACK is where any needed allocations
15319 will be done. OFFSET_MAP holds the mapping from section offsets to
15320 fields for the type. FI describes the fields of the type we're
15321 processing. FIELD is the variant field we're converting. */
15324 create_one_variant (variant
&result
, struct obstack
*obstack
,
15325 const offset_map_type
&offset_map
,
15326 struct field_info
*fi
, const variant_field
&field
)
15328 result
.discriminants
= convert_variant_range (obstack
, field
, false);
15329 result
.first_field
= field
.first_field
+ fi
->baseclasses
.size ();
15330 result
.last_field
= field
.last_field
+ fi
->baseclasses
.size ();
15331 result
.parts
= create_variant_parts (obstack
, offset_map
, fi
,
15332 field
.variant_parts
);
15335 /* Fill in a "struct variant_part" for a given variant part. RESULT
15336 is the variant part to fill in. OBSTACK is where any needed
15337 allocations will be done. OFFSET_MAP holds the mapping from
15338 section offsets to fields for the type. FI describes the fields of
15339 the type we're processing. BUILDER is the variant part to be
15343 create_one_variant_part (variant_part
&result
,
15344 struct obstack
*obstack
,
15345 const offset_map_type
&offset_map
,
15346 struct field_info
*fi
,
15347 const variant_part_builder
&builder
)
15349 auto iter
= offset_map
.find (builder
.discriminant_offset
);
15350 if (iter
== offset_map
.end ())
15352 result
.discriminant_index
= -1;
15353 /* Doesn't matter. */
15354 result
.is_unsigned
= false;
15358 result
.discriminant_index
= iter
->second
;
15360 = fi
->fields
[result
.discriminant_index
].field
.type ()->is_unsigned ();
15363 size_t n
= builder
.variants
.size ();
15364 variant
*output
= new (obstack
) variant
[n
];
15365 for (size_t i
= 0; i
< n
; ++i
)
15366 create_one_variant (output
[i
], obstack
, offset_map
, fi
,
15367 builder
.variants
[i
]);
15369 result
.variants
= gdb::array_view
<variant
> (output
, n
);
15372 /* Create a vector of variant parts that can be attached to a type.
15373 OBSTACK is where any needed allocations will be done. OFFSET_MAP
15374 holds the mapping from section offsets to fields for the type. FI
15375 describes the fields of the type we're processing. VARIANT_PARTS
15376 is the vector to convert. */
15378 static const gdb::array_view
<variant_part
>
15379 create_variant_parts (struct obstack
*obstack
,
15380 const offset_map_type
&offset_map
,
15381 struct field_info
*fi
,
15382 const std::vector
<variant_part_builder
> &variant_parts
)
15384 if (variant_parts
.empty ())
15387 size_t n
= variant_parts
.size ();
15388 variant_part
*result
= new (obstack
) variant_part
[n
];
15389 for (size_t i
= 0; i
< n
; ++i
)
15390 create_one_variant_part (result
[i
], obstack
, offset_map
, fi
,
15393 return gdb::array_view
<variant_part
> (result
, n
);
15396 /* Compute the variant part vector for FIP, attaching it to TYPE when
15400 add_variant_property (struct field_info
*fip
, struct type
*type
,
15401 struct dwarf2_cu
*cu
)
15403 /* Map section offsets of fields to their field index. Note the
15404 field index here does not take the number of baseclasses into
15406 offset_map_type offset_map
;
15407 for (int i
= 0; i
< fip
->fields
.size (); ++i
)
15408 offset_map
[fip
->fields
[i
].offset
] = i
;
15410 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
15411 gdb::array_view
<variant_part
> parts
15412 = create_variant_parts (&objfile
->objfile_obstack
, offset_map
, fip
,
15413 fip
->variant_parts
);
15415 struct dynamic_prop prop
;
15416 prop
.set_variant_parts ((gdb::array_view
<variant_part
> *)
15417 obstack_copy (&objfile
->objfile_obstack
, &parts
,
15420 type
->add_dyn_prop (DYN_PROP_VARIANT_PARTS
, prop
);
15423 /* Create the vector of fields, and attach it to the type. */
15426 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
15427 struct dwarf2_cu
*cu
)
15429 int nfields
= fip
->nfields ();
15431 /* Record the field count, allocate space for the array of fields,
15432 and create blank accessibility bitfields if necessary. */
15433 type
->set_num_fields (nfields
);
15435 ((struct field
*) TYPE_ZALLOC (type
, sizeof (struct field
) * nfields
));
15437 if (fip
->non_public_fields
&& cu
->language
!= language_ada
)
15439 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15441 TYPE_FIELD_PRIVATE_BITS (type
) =
15442 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
15443 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
15445 TYPE_FIELD_PROTECTED_BITS (type
) =
15446 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
15447 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
15449 TYPE_FIELD_IGNORE_BITS (type
) =
15450 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
15451 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
15454 /* If the type has baseclasses, allocate and clear a bit vector for
15455 TYPE_FIELD_VIRTUAL_BITS. */
15456 if (!fip
->baseclasses
.empty () && cu
->language
!= language_ada
)
15458 int num_bytes
= B_BYTES (fip
->baseclasses
.size ());
15459 unsigned char *pointer
;
15461 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15462 pointer
= (unsigned char *) TYPE_ALLOC (type
, num_bytes
);
15463 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
15464 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->baseclasses
.size ());
15465 TYPE_N_BASECLASSES (type
) = fip
->baseclasses
.size ();
15468 if (!fip
->variant_parts
.empty ())
15469 add_variant_property (fip
, type
, cu
);
15471 /* Copy the saved-up fields into the field vector. */
15472 for (int i
= 0; i
< nfields
; ++i
)
15474 struct nextfield
&field
15475 = ((i
< fip
->baseclasses
.size ()) ? fip
->baseclasses
[i
]
15476 : fip
->fields
[i
- fip
->baseclasses
.size ()]);
15478 type
->field (i
) = field
.field
;
15479 switch (field
.accessibility
)
15481 case DW_ACCESS_private
:
15482 if (cu
->language
!= language_ada
)
15483 SET_TYPE_FIELD_PRIVATE (type
, i
);
15486 case DW_ACCESS_protected
:
15487 if (cu
->language
!= language_ada
)
15488 SET_TYPE_FIELD_PROTECTED (type
, i
);
15491 case DW_ACCESS_public
:
15495 /* Unknown accessibility. Complain and treat it as public. */
15497 complaint (_("unsupported accessibility %d"),
15498 field
.accessibility
);
15502 if (i
< fip
->baseclasses
.size ())
15504 switch (field
.virtuality
)
15506 case DW_VIRTUALITY_virtual
:
15507 case DW_VIRTUALITY_pure_virtual
:
15508 if (cu
->language
== language_ada
)
15509 error (_("unexpected virtuality in component of Ada type"));
15510 SET_TYPE_FIELD_VIRTUAL (type
, i
);
15517 /* Return true if this member function is a constructor, false
15521 dwarf2_is_constructor (struct die_info
*die
, struct dwarf2_cu
*cu
)
15523 const char *fieldname
;
15524 const char *type_name
;
15527 if (die
->parent
== NULL
)
15530 if (die
->parent
->tag
!= DW_TAG_structure_type
15531 && die
->parent
->tag
!= DW_TAG_union_type
15532 && die
->parent
->tag
!= DW_TAG_class_type
)
15535 fieldname
= dwarf2_name (die
, cu
);
15536 type_name
= dwarf2_name (die
->parent
, cu
);
15537 if (fieldname
== NULL
|| type_name
== NULL
)
15540 len
= strlen (fieldname
);
15541 return (strncmp (fieldname
, type_name
, len
) == 0
15542 && (type_name
[len
] == '\0' || type_name
[len
] == '<'));
15545 /* Add a member function to the proper fieldlist. */
15548 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
15549 struct type
*type
, struct dwarf2_cu
*cu
)
15551 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
15552 struct attribute
*attr
;
15554 struct fnfieldlist
*flp
= nullptr;
15555 struct fn_field
*fnp
;
15556 const char *fieldname
;
15557 struct type
*this_type
;
15559 if (cu
->language
== language_ada
)
15560 error (_("unexpected member function in Ada type"));
15562 /* Get name of member function. */
15563 fieldname
= dwarf2_name (die
, cu
);
15564 if (fieldname
== NULL
)
15567 /* Look up member function name in fieldlist. */
15568 for (i
= 0; i
< fip
->fnfieldlists
.size (); i
++)
15570 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
15572 flp
= &fip
->fnfieldlists
[i
];
15577 /* Create a new fnfieldlist if necessary. */
15578 if (flp
== nullptr)
15580 fip
->fnfieldlists
.emplace_back ();
15581 flp
= &fip
->fnfieldlists
.back ();
15582 flp
->name
= fieldname
;
15583 i
= fip
->fnfieldlists
.size () - 1;
15586 /* Create a new member function field and add it to the vector of
15588 flp
->fnfields
.emplace_back ();
15589 fnp
= &flp
->fnfields
.back ();
15591 /* Delay processing of the physname until later. */
15592 if (cu
->language
== language_cplus
)
15593 add_to_method_list (type
, i
, flp
->fnfields
.size () - 1, fieldname
,
15597 const char *physname
= dwarf2_physname (fieldname
, die
, cu
);
15598 fnp
->physname
= physname
? physname
: "";
15601 fnp
->type
= alloc_type (objfile
);
15602 this_type
= read_type_die (die
, cu
);
15603 if (this_type
&& this_type
->code () == TYPE_CODE_FUNC
)
15605 int nparams
= this_type
->num_fields ();
15607 /* TYPE is the domain of this method, and THIS_TYPE is the type
15608 of the method itself (TYPE_CODE_METHOD). */
15609 smash_to_method_type (fnp
->type
, type
,
15610 TYPE_TARGET_TYPE (this_type
),
15611 this_type
->fields (),
15612 this_type
->num_fields (),
15613 this_type
->has_varargs ());
15615 /* Handle static member functions.
15616 Dwarf2 has no clean way to discern C++ static and non-static
15617 member functions. G++ helps GDB by marking the first
15618 parameter for non-static member functions (which is the this
15619 pointer) as artificial. We obtain this information from
15620 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
15621 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (this_type
, 0) == 0)
15622 fnp
->voffset
= VOFFSET_STATIC
;
15625 complaint (_("member function type missing for '%s'"),
15626 dwarf2_full_name (fieldname
, die
, cu
));
15628 /* Get fcontext from DW_AT_containing_type if present. */
15629 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
15630 fnp
->fcontext
= die_containing_type (die
, cu
);
15632 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
15633 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
15635 /* Get accessibility. */
15636 dwarf_access_attribute accessibility
= dwarf2_access_attribute (die
, cu
);
15637 switch (accessibility
)
15639 case DW_ACCESS_private
:
15640 fnp
->is_private
= 1;
15642 case DW_ACCESS_protected
:
15643 fnp
->is_protected
= 1;
15647 /* Check for artificial methods. */
15648 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
15649 if (attr
&& attr
->as_boolean ())
15650 fnp
->is_artificial
= 1;
15652 /* Check for defaulted methods. */
15653 attr
= dwarf2_attr (die
, DW_AT_defaulted
, cu
);
15654 if (attr
!= nullptr)
15655 fnp
->defaulted
= attr
->defaulted ();
15657 /* Check for deleted methods. */
15658 attr
= dwarf2_attr (die
, DW_AT_deleted
, cu
);
15659 if (attr
!= nullptr && attr
->as_boolean ())
15660 fnp
->is_deleted
= 1;
15662 fnp
->is_constructor
= dwarf2_is_constructor (die
, cu
);
15664 /* Get index in virtual function table if it is a virtual member
15665 function. For older versions of GCC, this is an offset in the
15666 appropriate virtual table, as specified by DW_AT_containing_type.
15667 For everyone else, it is an expression to be evaluated relative
15668 to the object address. */
15670 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
15671 if (attr
!= nullptr)
15673 if (attr
->form_is_block () && attr
->as_block ()->size
> 0)
15675 struct dwarf_block
*block
= attr
->as_block ();
15677 if (block
->data
[0] == DW_OP_constu
)
15679 /* Old-style GCC. */
15680 fnp
->voffset
= decode_locdesc (block
, cu
) + 2;
15682 else if (block
->data
[0] == DW_OP_deref
15683 || (block
->size
> 1
15684 && block
->data
[0] == DW_OP_deref_size
15685 && block
->data
[1] == cu
->header
.addr_size
))
15687 fnp
->voffset
= decode_locdesc (block
, cu
);
15688 if ((fnp
->voffset
% cu
->header
.addr_size
) != 0)
15689 dwarf2_complex_location_expr_complaint ();
15691 fnp
->voffset
/= cu
->header
.addr_size
;
15695 dwarf2_complex_location_expr_complaint ();
15697 if (!fnp
->fcontext
)
15699 /* If there is no `this' field and no DW_AT_containing_type,
15700 we cannot actually find a base class context for the
15702 if (this_type
->num_fields () == 0
15703 || !TYPE_FIELD_ARTIFICIAL (this_type
, 0))
15705 complaint (_("cannot determine context for virtual member "
15706 "function \"%s\" (offset %s)"),
15707 fieldname
, sect_offset_str (die
->sect_off
));
15712 = TYPE_TARGET_TYPE (this_type
->field (0).type ());
15716 else if (attr
->form_is_section_offset ())
15718 dwarf2_complex_location_expr_complaint ();
15722 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
15728 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
15729 if (attr
!= nullptr && attr
->as_virtuality () != DW_VIRTUALITY_none
)
15731 /* GCC does this, as of 2008-08-25; PR debug/37237. */
15732 complaint (_("Member function \"%s\" (offset %s) is virtual "
15733 "but the vtable offset is not specified"),
15734 fieldname
, sect_offset_str (die
->sect_off
));
15735 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15736 TYPE_CPLUS_DYNAMIC (type
) = 1;
15741 /* Create the vector of member function fields, and attach it to the type. */
15744 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
15745 struct dwarf2_cu
*cu
)
15747 if (cu
->language
== language_ada
)
15748 error (_("unexpected member functions in Ada type"));
15750 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15751 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
15753 sizeof (struct fn_fieldlist
) * fip
->fnfieldlists
.size ());
15755 for (int i
= 0; i
< fip
->fnfieldlists
.size (); i
++)
15757 struct fnfieldlist
&nf
= fip
->fnfieldlists
[i
];
15758 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
15760 TYPE_FN_FIELDLIST_NAME (type
, i
) = nf
.name
;
15761 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = nf
.fnfields
.size ();
15762 fn_flp
->fn_fields
= (struct fn_field
*)
15763 TYPE_ALLOC (type
, sizeof (struct fn_field
) * nf
.fnfields
.size ());
15765 for (int k
= 0; k
< nf
.fnfields
.size (); ++k
)
15766 fn_flp
->fn_fields
[k
] = nf
.fnfields
[k
];
15769 TYPE_NFN_FIELDS (type
) = fip
->fnfieldlists
.size ();
15772 /* Returns non-zero if NAME is the name of a vtable member in CU's
15773 language, zero otherwise. */
15775 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
15777 static const char vptr
[] = "_vptr";
15779 /* Look for the C++ form of the vtable. */
15780 if (startswith (name
, vptr
) && is_cplus_marker (name
[sizeof (vptr
) - 1]))
15786 /* GCC outputs unnamed structures that are really pointers to member
15787 functions, with the ABI-specified layout. If TYPE describes
15788 such a structure, smash it into a member function type.
15790 GCC shouldn't do this; it should just output pointer to member DIEs.
15791 This is GCC PR debug/28767. */
15794 quirk_gcc_member_function_pointer (struct type
*type
, struct objfile
*objfile
)
15796 struct type
*pfn_type
, *self_type
, *new_type
;
15798 /* Check for a structure with no name and two children. */
15799 if (type
->code () != TYPE_CODE_STRUCT
|| type
->num_fields () != 2)
15802 /* Check for __pfn and __delta members. */
15803 if (TYPE_FIELD_NAME (type
, 0) == NULL
15804 || strcmp (TYPE_FIELD_NAME (type
, 0), "__pfn") != 0
15805 || TYPE_FIELD_NAME (type
, 1) == NULL
15806 || strcmp (TYPE_FIELD_NAME (type
, 1), "__delta") != 0)
15809 /* Find the type of the method. */
15810 pfn_type
= type
->field (0).type ();
15811 if (pfn_type
== NULL
15812 || pfn_type
->code () != TYPE_CODE_PTR
15813 || TYPE_TARGET_TYPE (pfn_type
)->code () != TYPE_CODE_FUNC
)
15816 /* Look for the "this" argument. */
15817 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
15818 if (pfn_type
->num_fields () == 0
15819 /* || pfn_type->field (0).type () == NULL */
15820 || pfn_type
->field (0).type ()->code () != TYPE_CODE_PTR
)
15823 self_type
= TYPE_TARGET_TYPE (pfn_type
->field (0).type ());
15824 new_type
= alloc_type (objfile
);
15825 smash_to_method_type (new_type
, self_type
, TYPE_TARGET_TYPE (pfn_type
),
15826 pfn_type
->fields (), pfn_type
->num_fields (),
15827 pfn_type
->has_varargs ());
15828 smash_to_methodptr_type (type
, new_type
);
15831 /* Helper for quirk_ada_thick_pointer. If TYPE is an array type that
15832 requires rewriting, then copy it and return the updated copy.
15833 Otherwise return nullptr. */
15835 static struct type
*
15836 rewrite_array_type (struct type
*type
)
15838 if (type
->code () != TYPE_CODE_ARRAY
)
15841 struct type
*index_type
= type
->index_type ();
15842 range_bounds
*current_bounds
= index_type
->bounds ();
15844 /* Handle multi-dimensional arrays. */
15845 struct type
*new_target
= rewrite_array_type (TYPE_TARGET_TYPE (type
));
15846 if (new_target
== nullptr)
15848 /* Maybe we don't need to rewrite this array. */
15849 if (current_bounds
->low
.kind () == PROP_CONST
15850 && current_bounds
->high
.kind () == PROP_CONST
)
15854 /* Either the target type was rewritten, or the bounds have to be
15855 updated. Either way we want to copy the type and update
15857 struct type
*copy
= copy_type (type
);
15858 int nfields
= copy
->num_fields ();
15860 = ((struct field
*) TYPE_ZALLOC (copy
,
15861 nfields
* sizeof (struct field
)));
15862 memcpy (new_fields
, copy
->fields (), nfields
* sizeof (struct field
));
15863 copy
->set_fields (new_fields
);
15864 if (new_target
!= nullptr)
15865 TYPE_TARGET_TYPE (copy
) = new_target
;
15867 struct type
*index_copy
= copy_type (index_type
);
15868 range_bounds
*bounds
15869 = (struct range_bounds
*) TYPE_ZALLOC (index_copy
,
15870 sizeof (range_bounds
));
15871 *bounds
= *current_bounds
;
15872 bounds
->low
.set_const_val (1);
15873 bounds
->high
.set_const_val (0);
15874 index_copy
->set_bounds (bounds
);
15875 copy
->set_index_type (index_copy
);
15880 /* While some versions of GCC will generate complicated DWARF for an
15881 array (see quirk_ada_thick_pointer), more recent versions were
15882 modified to emit an explicit thick pointer structure. However, in
15883 this case, the array still has DWARF expressions for its ranges,
15884 and these must be ignored. */
15887 quirk_ada_thick_pointer_struct (struct die_info
*die
, struct dwarf2_cu
*cu
,
15890 gdb_assert (cu
->language
== language_ada
);
15892 /* Check for a structure with two children. */
15893 if (type
->code () != TYPE_CODE_STRUCT
|| type
->num_fields () != 2)
15896 /* Check for P_ARRAY and P_BOUNDS members. */
15897 if (TYPE_FIELD_NAME (type
, 0) == NULL
15898 || strcmp (TYPE_FIELD_NAME (type
, 0), "P_ARRAY") != 0
15899 || TYPE_FIELD_NAME (type
, 1) == NULL
15900 || strcmp (TYPE_FIELD_NAME (type
, 1), "P_BOUNDS") != 0)
15903 /* Make sure we're looking at a pointer to an array. */
15904 if (type
->field (0).type ()->code () != TYPE_CODE_PTR
)
15907 /* The Ada code already knows how to handle these types, so all that
15908 we need to do is turn the bounds into static bounds. However, we
15909 don't want to rewrite existing array or index types in-place,
15910 because those may be referenced in other contexts where this
15911 rewriting is undesirable. */
15912 struct type
*new_ary_type
15913 = rewrite_array_type (TYPE_TARGET_TYPE (type
->field (0).type ()));
15914 if (new_ary_type
!= nullptr)
15915 type
->field (0).set_type (lookup_pointer_type (new_ary_type
));
15918 /* If the DIE has a DW_AT_alignment attribute, return its value, doing
15919 appropriate error checking and issuing complaints if there is a
15923 get_alignment (struct dwarf2_cu
*cu
, struct die_info
*die
)
15925 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_alignment
, cu
);
15927 if (attr
== nullptr)
15930 if (!attr
->form_is_constant ())
15932 complaint (_("DW_AT_alignment must have constant form"
15933 " - DIE at %s [in module %s]"),
15934 sect_offset_str (die
->sect_off
),
15935 objfile_name (cu
->per_objfile
->objfile
));
15939 LONGEST val
= attr
->constant_value (0);
15942 complaint (_("DW_AT_alignment value must not be negative"
15943 " - DIE at %s [in module %s]"),
15944 sect_offset_str (die
->sect_off
),
15945 objfile_name (cu
->per_objfile
->objfile
));
15948 ULONGEST align
= val
;
15952 complaint (_("DW_AT_alignment value must not be zero"
15953 " - DIE at %s [in module %s]"),
15954 sect_offset_str (die
->sect_off
),
15955 objfile_name (cu
->per_objfile
->objfile
));
15958 if ((align
& (align
- 1)) != 0)
15960 complaint (_("DW_AT_alignment value must be a power of 2"
15961 " - DIE at %s [in module %s]"),
15962 sect_offset_str (die
->sect_off
),
15963 objfile_name (cu
->per_objfile
->objfile
));
15970 /* If the DIE has a DW_AT_alignment attribute, use its value to set
15971 the alignment for TYPE. */
15974 maybe_set_alignment (struct dwarf2_cu
*cu
, struct die_info
*die
,
15977 if (!set_type_align (type
, get_alignment (cu
, die
)))
15978 complaint (_("DW_AT_alignment value too large"
15979 " - DIE at %s [in module %s]"),
15980 sect_offset_str (die
->sect_off
),
15981 objfile_name (cu
->per_objfile
->objfile
));
15984 /* Check if the given VALUE is a valid enum dwarf_calling_convention
15985 constant for a type, according to DWARF5 spec, Table 5.5. */
15988 is_valid_DW_AT_calling_convention_for_type (ULONGEST value
)
15993 case DW_CC_pass_by_reference
:
15994 case DW_CC_pass_by_value
:
15998 complaint (_("unrecognized DW_AT_calling_convention value "
15999 "(%s) for a type"), pulongest (value
));
16004 /* Check if the given VALUE is a valid enum dwarf_calling_convention
16005 constant for a subroutine, according to DWARF5 spec, Table 3.3, and
16006 also according to GNU-specific values (see include/dwarf2.h). */
16009 is_valid_DW_AT_calling_convention_for_subroutine (ULONGEST value
)
16014 case DW_CC_program
:
16018 case DW_CC_GNU_renesas_sh
:
16019 case DW_CC_GNU_borland_fastcall_i386
:
16020 case DW_CC_GDB_IBM_OpenCL
:
16024 complaint (_("unrecognized DW_AT_calling_convention value "
16025 "(%s) for a subroutine"), pulongest (value
));
16030 /* Called when we find the DIE that starts a structure or union scope
16031 (definition) to create a type for the structure or union. Fill in
16032 the type's name and general properties; the members will not be
16033 processed until process_structure_scope. A symbol table entry for
16034 the type will also not be done until process_structure_scope (assuming
16035 the type has a name).
16037 NOTE: we need to call these functions regardless of whether or not the
16038 DIE has a DW_AT_name attribute, since it might be an anonymous
16039 structure or union. This gets the type entered into our set of
16040 user defined types. */
16042 static struct type
*
16043 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16045 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
16047 struct attribute
*attr
;
16050 /* If the definition of this type lives in .debug_types, read that type.
16051 Don't follow DW_AT_specification though, that will take us back up
16052 the chain and we want to go down. */
16053 attr
= die
->attr (DW_AT_signature
);
16054 if (attr
!= nullptr)
16056 type
= get_DW_AT_signature_type (die
, attr
, cu
);
16058 /* The type's CU may not be the same as CU.
16059 Ensure TYPE is recorded with CU in die_type_hash. */
16060 return set_die_type (die
, type
, cu
);
16063 type
= alloc_type (objfile
);
16064 INIT_CPLUS_SPECIFIC (type
);
16066 name
= dwarf2_name (die
, cu
);
16069 if (cu
->language
== language_cplus
16070 || cu
->language
== language_d
16071 || cu
->language
== language_rust
)
16073 const char *full_name
= dwarf2_full_name (name
, die
, cu
);
16075 /* dwarf2_full_name might have already finished building the DIE's
16076 type. If so, there is no need to continue. */
16077 if (get_die_type (die
, cu
) != NULL
)
16078 return get_die_type (die
, cu
);
16080 type
->set_name (full_name
);
16084 /* The name is already allocated along with this objfile, so
16085 we don't need to duplicate it for the type. */
16086 type
->set_name (name
);
16090 if (die
->tag
== DW_TAG_structure_type
)
16092 type
->set_code (TYPE_CODE_STRUCT
);
16094 else if (die
->tag
== DW_TAG_union_type
)
16096 type
->set_code (TYPE_CODE_UNION
);
16100 type
->set_code (TYPE_CODE_STRUCT
);
16103 if (cu
->language
== language_cplus
&& die
->tag
== DW_TAG_class_type
)
16104 TYPE_DECLARED_CLASS (type
) = 1;
16106 /* Store the calling convention in the type if it's available in
16107 the die. Otherwise the calling convention remains set to
16108 the default value DW_CC_normal. */
16109 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
16110 if (attr
!= nullptr
16111 && is_valid_DW_AT_calling_convention_for_type (attr
->constant_value (0)))
16113 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
16114 TYPE_CPLUS_CALLING_CONVENTION (type
)
16115 = (enum dwarf_calling_convention
) (attr
->constant_value (0));
16118 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16119 if (attr
!= nullptr)
16121 if (attr
->form_is_constant ())
16122 TYPE_LENGTH (type
) = attr
->constant_value (0);
16125 struct dynamic_prop prop
;
16126 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
, cu
->addr_type ()))
16127 type
->add_dyn_prop (DYN_PROP_BYTE_SIZE
, prop
);
16128 TYPE_LENGTH (type
) = 0;
16133 TYPE_LENGTH (type
) = 0;
16136 maybe_set_alignment (cu
, die
, type
);
16138 if (producer_is_icc_lt_14 (cu
) && (TYPE_LENGTH (type
) == 0))
16140 /* ICC<14 does not output the required DW_AT_declaration on
16141 incomplete types, but gives them a size of zero. */
16142 type
->set_is_stub (true);
16145 type
->set_stub_is_supported (true);
16147 if (die_is_declaration (die
, cu
))
16148 type
->set_is_stub (true);
16149 else if (attr
== NULL
&& die
->child
== NULL
16150 && producer_is_realview (cu
->producer
))
16151 /* RealView does not output the required DW_AT_declaration
16152 on incomplete types. */
16153 type
->set_is_stub (true);
16155 /* We need to add the type field to the die immediately so we don't
16156 infinitely recurse when dealing with pointers to the structure
16157 type within the structure itself. */
16158 set_die_type (die
, type
, cu
);
16160 /* set_die_type should be already done. */
16161 set_descriptive_type (type
, die
, cu
);
16166 static void handle_struct_member_die
16167 (struct die_info
*child_die
,
16169 struct field_info
*fi
,
16170 std::vector
<struct symbol
*> *template_args
,
16171 struct dwarf2_cu
*cu
);
16173 /* A helper for handle_struct_member_die that handles
16174 DW_TAG_variant_part. */
16177 handle_variant_part (struct die_info
*die
, struct type
*type
,
16178 struct field_info
*fi
,
16179 std::vector
<struct symbol
*> *template_args
,
16180 struct dwarf2_cu
*cu
)
16182 variant_part_builder
*new_part
;
16183 if (fi
->current_variant_part
== nullptr)
16185 fi
->variant_parts
.emplace_back ();
16186 new_part
= &fi
->variant_parts
.back ();
16188 else if (!fi
->current_variant_part
->processing_variant
)
16190 complaint (_("nested DW_TAG_variant_part seen "
16191 "- DIE at %s [in module %s]"),
16192 sect_offset_str (die
->sect_off
),
16193 objfile_name (cu
->per_objfile
->objfile
));
16198 variant_field
¤t
= fi
->current_variant_part
->variants
.back ();
16199 current
.variant_parts
.emplace_back ();
16200 new_part
= ¤t
.variant_parts
.back ();
16203 /* When we recurse, we want callees to add to this new variant
16205 scoped_restore save_current_variant_part
16206 = make_scoped_restore (&fi
->current_variant_part
, new_part
);
16208 struct attribute
*discr
= dwarf2_attr (die
, DW_AT_discr
, cu
);
16211 /* It's a univariant form, an extension we support. */
16213 else if (discr
->form_is_ref ())
16215 struct dwarf2_cu
*target_cu
= cu
;
16216 struct die_info
*target_die
= follow_die_ref (die
, discr
, &target_cu
);
16218 new_part
->discriminant_offset
= target_die
->sect_off
;
16222 complaint (_("DW_AT_discr does not have DIE reference form"
16223 " - DIE at %s [in module %s]"),
16224 sect_offset_str (die
->sect_off
),
16225 objfile_name (cu
->per_objfile
->objfile
));
16228 for (die_info
*child_die
= die
->child
;
16230 child_die
= child_die
->sibling
)
16231 handle_struct_member_die (child_die
, type
, fi
, template_args
, cu
);
16234 /* A helper for handle_struct_member_die that handles
16238 handle_variant (struct die_info
*die
, struct type
*type
,
16239 struct field_info
*fi
,
16240 std::vector
<struct symbol
*> *template_args
,
16241 struct dwarf2_cu
*cu
)
16243 if (fi
->current_variant_part
== nullptr)
16245 complaint (_("saw DW_TAG_variant outside DW_TAG_variant_part "
16246 "- DIE at %s [in module %s]"),
16247 sect_offset_str (die
->sect_off
),
16248 objfile_name (cu
->per_objfile
->objfile
));
16251 if (fi
->current_variant_part
->processing_variant
)
16253 complaint (_("nested DW_TAG_variant seen "
16254 "- DIE at %s [in module %s]"),
16255 sect_offset_str (die
->sect_off
),
16256 objfile_name (cu
->per_objfile
->objfile
));
16260 scoped_restore save_processing_variant
16261 = make_scoped_restore (&fi
->current_variant_part
->processing_variant
,
16264 fi
->current_variant_part
->variants
.emplace_back ();
16265 variant_field
&variant
= fi
->current_variant_part
->variants
.back ();
16266 variant
.first_field
= fi
->fields
.size ();
16268 /* In a variant we want to get the discriminant and also add a
16269 field for our sole member child. */
16270 struct attribute
*discr
= dwarf2_attr (die
, DW_AT_discr_value
, cu
);
16271 if (discr
== nullptr || !discr
->form_is_constant ())
16273 discr
= dwarf2_attr (die
, DW_AT_discr_list
, cu
);
16274 if (discr
== nullptr || discr
->as_block ()->size
== 0)
16275 variant
.default_branch
= true;
16277 variant
.discr_list_data
= discr
->as_block ();
16280 variant
.discriminant_value
= discr
->constant_value (0);
16282 for (die_info
*variant_child
= die
->child
;
16283 variant_child
!= NULL
;
16284 variant_child
= variant_child
->sibling
)
16285 handle_struct_member_die (variant_child
, type
, fi
, template_args
, cu
);
16287 variant
.last_field
= fi
->fields
.size ();
16290 /* A helper for process_structure_scope that handles a single member
16294 handle_struct_member_die (struct die_info
*child_die
, struct type
*type
,
16295 struct field_info
*fi
,
16296 std::vector
<struct symbol
*> *template_args
,
16297 struct dwarf2_cu
*cu
)
16299 if (child_die
->tag
== DW_TAG_member
16300 || child_die
->tag
== DW_TAG_variable
)
16302 /* NOTE: carlton/2002-11-05: A C++ static data member
16303 should be a DW_TAG_member that is a declaration, but
16304 all versions of G++ as of this writing (so through at
16305 least 3.2.1) incorrectly generate DW_TAG_variable
16306 tags for them instead. */
16307 dwarf2_add_field (fi
, child_die
, cu
);
16309 else if (child_die
->tag
== DW_TAG_subprogram
)
16311 /* Rust doesn't have member functions in the C++ sense.
16312 However, it does emit ordinary functions as children
16313 of a struct DIE. */
16314 if (cu
->language
== language_rust
)
16315 read_func_scope (child_die
, cu
);
16318 /* C++ member function. */
16319 dwarf2_add_member_fn (fi
, child_die
, type
, cu
);
16322 else if (child_die
->tag
== DW_TAG_inheritance
)
16324 /* C++ base class field. */
16325 dwarf2_add_field (fi
, child_die
, cu
);
16327 else if (type_can_define_types (child_die
))
16328 dwarf2_add_type_defn (fi
, child_die
, cu
);
16329 else if (child_die
->tag
== DW_TAG_template_type_param
16330 || child_die
->tag
== DW_TAG_template_value_param
)
16332 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
16335 template_args
->push_back (arg
);
16337 else if (child_die
->tag
== DW_TAG_variant_part
)
16338 handle_variant_part (child_die
, type
, fi
, template_args
, cu
);
16339 else if (child_die
->tag
== DW_TAG_variant
)
16340 handle_variant (child_die
, type
, fi
, template_args
, cu
);
16343 /* Finish creating a structure or union type, including filling in
16344 its members and creating a symbol for it. */
16347 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
16349 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
16350 struct die_info
*child_die
;
16353 type
= get_die_type (die
, cu
);
16355 type
= read_structure_type (die
, cu
);
16357 bool has_template_parameters
= false;
16358 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
16360 struct field_info fi
;
16361 std::vector
<struct symbol
*> template_args
;
16363 child_die
= die
->child
;
16365 while (child_die
&& child_die
->tag
)
16367 handle_struct_member_die (child_die
, type
, &fi
, &template_args
, cu
);
16368 child_die
= child_die
->sibling
;
16371 /* Attach template arguments to type. */
16372 if (!template_args
.empty ())
16374 has_template_parameters
= true;
16375 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
16376 TYPE_N_TEMPLATE_ARGUMENTS (type
) = template_args
.size ();
16377 TYPE_TEMPLATE_ARGUMENTS (type
)
16378 = XOBNEWVEC (&objfile
->objfile_obstack
,
16380 TYPE_N_TEMPLATE_ARGUMENTS (type
));
16381 memcpy (TYPE_TEMPLATE_ARGUMENTS (type
),
16382 template_args
.data (),
16383 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
16384 * sizeof (struct symbol
*)));
16387 /* Attach fields and member functions to the type. */
16388 if (fi
.nfields () > 0)
16389 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
16390 if (!fi
.fnfieldlists
.empty ())
16392 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
16394 /* Get the type which refers to the base class (possibly this
16395 class itself) which contains the vtable pointer for the current
16396 class from the DW_AT_containing_type attribute. This use of
16397 DW_AT_containing_type is a GNU extension. */
16399 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
16401 struct type
*t
= die_containing_type (die
, cu
);
16403 set_type_vptr_basetype (type
, t
);
16408 /* Our own class provides vtbl ptr. */
16409 for (i
= t
->num_fields () - 1;
16410 i
>= TYPE_N_BASECLASSES (t
);
16413 const char *fieldname
= TYPE_FIELD_NAME (t
, i
);
16415 if (is_vtable_name (fieldname
, cu
))
16417 set_type_vptr_fieldno (type
, i
);
16422 /* Complain if virtual function table field not found. */
16423 if (i
< TYPE_N_BASECLASSES (t
))
16424 complaint (_("virtual function table pointer "
16425 "not found when defining class '%s'"),
16426 type
->name () ? type
->name () : "");
16430 set_type_vptr_fieldno (type
, TYPE_VPTR_FIELDNO (t
));
16433 else if (cu
->producer
16434 && startswith (cu
->producer
, "IBM(R) XL C/C++ Advanced Edition"))
16436 /* The IBM XLC compiler does not provide direct indication
16437 of the containing type, but the vtable pointer is
16438 always named __vfp. */
16442 for (i
= type
->num_fields () - 1;
16443 i
>= TYPE_N_BASECLASSES (type
);
16446 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
16448 set_type_vptr_fieldno (type
, i
);
16449 set_type_vptr_basetype (type
, type
);
16456 /* Copy fi.typedef_field_list linked list elements content into the
16457 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
16458 if (!fi
.typedef_field_list
.empty ())
16460 int count
= fi
.typedef_field_list
.size ();
16462 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
16463 TYPE_TYPEDEF_FIELD_ARRAY (type
)
16464 = ((struct decl_field
*)
16466 sizeof (TYPE_TYPEDEF_FIELD (type
, 0)) * count
));
16467 TYPE_TYPEDEF_FIELD_COUNT (type
) = count
;
16469 for (int i
= 0; i
< fi
.typedef_field_list
.size (); ++i
)
16470 TYPE_TYPEDEF_FIELD (type
, i
) = fi
.typedef_field_list
[i
];
16473 /* Copy fi.nested_types_list linked list elements content into the
16474 allocated array TYPE_NESTED_TYPES_ARRAY (type). */
16475 if (!fi
.nested_types_list
.empty () && cu
->language
!= language_ada
)
16477 int count
= fi
.nested_types_list
.size ();
16479 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
16480 TYPE_NESTED_TYPES_ARRAY (type
)
16481 = ((struct decl_field
*)
16482 TYPE_ALLOC (type
, sizeof (struct decl_field
) * count
));
16483 TYPE_NESTED_TYPES_COUNT (type
) = count
;
16485 for (int i
= 0; i
< fi
.nested_types_list
.size (); ++i
)
16486 TYPE_NESTED_TYPES_FIELD (type
, i
) = fi
.nested_types_list
[i
];
16490 quirk_gcc_member_function_pointer (type
, objfile
);
16491 if (cu
->language
== language_rust
&& die
->tag
== DW_TAG_union_type
)
16492 cu
->rust_unions
.push_back (type
);
16493 else if (cu
->language
== language_ada
)
16494 quirk_ada_thick_pointer_struct (die
, cu
, type
);
16496 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
16497 snapshots) has been known to create a die giving a declaration
16498 for a class that has, as a child, a die giving a definition for a
16499 nested class. So we have to process our children even if the
16500 current die is a declaration. Normally, of course, a declaration
16501 won't have any children at all. */
16503 child_die
= die
->child
;
16505 while (child_die
!= NULL
&& child_die
->tag
)
16507 if (child_die
->tag
== DW_TAG_member
16508 || child_die
->tag
== DW_TAG_variable
16509 || child_die
->tag
== DW_TAG_inheritance
16510 || child_die
->tag
== DW_TAG_template_value_param
16511 || child_die
->tag
== DW_TAG_template_type_param
)
16516 process_die (child_die
, cu
);
16518 child_die
= child_die
->sibling
;
16521 /* Do not consider external references. According to the DWARF standard,
16522 these DIEs are identified by the fact that they have no byte_size
16523 attribute, and a declaration attribute. */
16524 if (dwarf2_attr (die
, DW_AT_byte_size
, cu
) != NULL
16525 || !die_is_declaration (die
, cu
)
16526 || dwarf2_attr (die
, DW_AT_signature
, cu
) != NULL
)
16528 struct symbol
*sym
= new_symbol (die
, type
, cu
);
16530 if (has_template_parameters
)
16532 struct symtab
*symtab
;
16533 if (sym
!= nullptr)
16534 symtab
= symbol_symtab (sym
);
16535 else if (cu
->line_header
!= nullptr)
16537 /* Any related symtab will do. */
16539 = cu
->line_header
->file_names ()[0].symtab
;
16544 complaint (_("could not find suitable "
16545 "symtab for template parameter"
16546 " - DIE at %s [in module %s]"),
16547 sect_offset_str (die
->sect_off
),
16548 objfile_name (objfile
));
16551 if (symtab
!= nullptr)
16553 /* Make sure that the symtab is set on the new symbols.
16554 Even though they don't appear in this symtab directly,
16555 other parts of gdb assume that symbols do, and this is
16556 reasonably true. */
16557 for (int i
= 0; i
< TYPE_N_TEMPLATE_ARGUMENTS (type
); ++i
)
16558 symbol_set_symtab (TYPE_TEMPLATE_ARGUMENT (type
, i
), symtab
);
16564 /* Assuming DIE is an enumeration type, and TYPE is its associated
16565 type, update TYPE using some information only available in DIE's
16566 children. In particular, the fields are computed. */
16569 update_enumeration_type_from_children (struct die_info
*die
,
16571 struct dwarf2_cu
*cu
)
16573 struct die_info
*child_die
;
16574 int unsigned_enum
= 1;
16577 auto_obstack obstack
;
16578 std::vector
<struct field
> fields
;
16580 for (child_die
= die
->child
;
16581 child_die
!= NULL
&& child_die
->tag
;
16582 child_die
= child_die
->sibling
)
16584 struct attribute
*attr
;
16586 const gdb_byte
*bytes
;
16587 struct dwarf2_locexpr_baton
*baton
;
16590 if (child_die
->tag
!= DW_TAG_enumerator
)
16593 attr
= dwarf2_attr (child_die
, DW_AT_const_value
, cu
);
16597 name
= dwarf2_name (child_die
, cu
);
16599 name
= "<anonymous enumerator>";
16601 dwarf2_const_value_attr (attr
, type
, name
, &obstack
, cu
,
16602 &value
, &bytes
, &baton
);
16610 if (count_one_bits_ll (value
) >= 2)
16614 fields
.emplace_back ();
16615 struct field
&field
= fields
.back ();
16616 FIELD_NAME (field
) = dwarf2_physname (name
, child_die
, cu
);
16617 SET_FIELD_ENUMVAL (field
, value
);
16620 if (!fields
.empty ())
16622 type
->set_num_fields (fields
.size ());
16625 TYPE_ALLOC (type
, sizeof (struct field
) * fields
.size ()));
16626 memcpy (type
->fields (), fields
.data (),
16627 sizeof (struct field
) * fields
.size ());
16631 type
->set_is_unsigned (true);
16634 TYPE_FLAG_ENUM (type
) = 1;
16637 /* Given a DW_AT_enumeration_type die, set its type. We do not
16638 complete the type's fields yet, or create any symbols. */
16640 static struct type
*
16641 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16643 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
16645 struct attribute
*attr
;
16648 /* If the definition of this type lives in .debug_types, read that type.
16649 Don't follow DW_AT_specification though, that will take us back up
16650 the chain and we want to go down. */
16651 attr
= die
->attr (DW_AT_signature
);
16652 if (attr
!= nullptr)
16654 type
= get_DW_AT_signature_type (die
, attr
, cu
);
16656 /* The type's CU may not be the same as CU.
16657 Ensure TYPE is recorded with CU in die_type_hash. */
16658 return set_die_type (die
, type
, cu
);
16661 type
= alloc_type (objfile
);
16663 type
->set_code (TYPE_CODE_ENUM
);
16664 name
= dwarf2_full_name (NULL
, die
, cu
);
16666 type
->set_name (name
);
16668 attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
16671 struct type
*underlying_type
= die_type (die
, cu
);
16673 TYPE_TARGET_TYPE (type
) = underlying_type
;
16676 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16677 if (attr
!= nullptr)
16679 TYPE_LENGTH (type
) = attr
->constant_value (0);
16683 TYPE_LENGTH (type
) = 0;
16686 maybe_set_alignment (cu
, die
, type
);
16688 /* The enumeration DIE can be incomplete. In Ada, any type can be
16689 declared as private in the package spec, and then defined only
16690 inside the package body. Such types are known as Taft Amendment
16691 Types. When another package uses such a type, an incomplete DIE
16692 may be generated by the compiler. */
16693 if (die_is_declaration (die
, cu
))
16694 type
->set_is_stub (true);
16696 /* If this type has an underlying type that is not a stub, then we
16697 may use its attributes. We always use the "unsigned" attribute
16698 in this situation, because ordinarily we guess whether the type
16699 is unsigned -- but the guess can be wrong and the underlying type
16700 can tell us the reality. However, we defer to a local size
16701 attribute if one exists, because this lets the compiler override
16702 the underlying type if needed. */
16703 if (TYPE_TARGET_TYPE (type
) != NULL
&& !TYPE_TARGET_TYPE (type
)->is_stub ())
16705 struct type
*underlying_type
= TYPE_TARGET_TYPE (type
);
16706 underlying_type
= check_typedef (underlying_type
);
16708 type
->set_is_unsigned (underlying_type
->is_unsigned ());
16710 if (TYPE_LENGTH (type
) == 0)
16711 TYPE_LENGTH (type
) = TYPE_LENGTH (underlying_type
);
16713 if (TYPE_RAW_ALIGN (type
) == 0
16714 && TYPE_RAW_ALIGN (underlying_type
) != 0)
16715 set_type_align (type
, TYPE_RAW_ALIGN (underlying_type
));
16718 TYPE_DECLARED_CLASS (type
) = dwarf2_flag_true_p (die
, DW_AT_enum_class
, cu
);
16720 set_die_type (die
, type
, cu
);
16722 /* Finish the creation of this type by using the enum's children.
16723 Note that, as usual, this must come after set_die_type to avoid
16724 infinite recursion when trying to compute the names of the
16726 update_enumeration_type_from_children (die
, type
, cu
);
16731 /* Given a pointer to a die which begins an enumeration, process all
16732 the dies that define the members of the enumeration, and create the
16733 symbol for the enumeration type.
16735 NOTE: We reverse the order of the element list. */
16738 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
16740 struct type
*this_type
;
16742 this_type
= get_die_type (die
, cu
);
16743 if (this_type
== NULL
)
16744 this_type
= read_enumeration_type (die
, cu
);
16746 if (die
->child
!= NULL
)
16748 struct die_info
*child_die
;
16751 child_die
= die
->child
;
16752 while (child_die
&& child_die
->tag
)
16754 if (child_die
->tag
!= DW_TAG_enumerator
)
16756 process_die (child_die
, cu
);
16760 name
= dwarf2_name (child_die
, cu
);
16762 new_symbol (child_die
, this_type
, cu
);
16765 child_die
= child_die
->sibling
;
16769 /* If we are reading an enum from a .debug_types unit, and the enum
16770 is a declaration, and the enum is not the signatured type in the
16771 unit, then we do not want to add a symbol for it. Adding a
16772 symbol would in some cases obscure the true definition of the
16773 enum, giving users an incomplete type when the definition is
16774 actually available. Note that we do not want to do this for all
16775 enums which are just declarations, because C++0x allows forward
16776 enum declarations. */
16777 if (cu
->per_cu
->is_debug_types
16778 && die_is_declaration (die
, cu
))
16780 struct signatured_type
*sig_type
;
16782 sig_type
= (struct signatured_type
*) cu
->per_cu
;
16783 gdb_assert (to_underlying (sig_type
->type_offset_in_section
) != 0);
16784 if (sig_type
->type_offset_in_section
!= die
->sect_off
)
16788 new_symbol (die
, this_type
, cu
);
16791 /* Helper function for quirk_ada_thick_pointer that examines a bounds
16792 expression for an index type and finds the corresponding field
16793 offset in the hidden "P_BOUNDS" structure. Returns true on success
16794 and updates *FIELD, false if it fails to recognize an
16798 recognize_bound_expression (struct die_info
*die
, enum dwarf_attribute name
,
16799 int *bounds_offset
, struct field
*field
,
16800 struct dwarf2_cu
*cu
)
16802 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
16803 if (attr
== nullptr || !attr
->form_is_block ())
16806 const struct dwarf_block
*block
= attr
->as_block ();
16807 const gdb_byte
*start
= block
->data
;
16808 const gdb_byte
*end
= block
->data
+ block
->size
;
16810 /* The expression to recognize generally looks like:
16812 (DW_OP_push_object_address; DW_OP_plus_uconst: 8; DW_OP_deref;
16813 DW_OP_plus_uconst: 4; DW_OP_deref_size: 4)
16815 However, the second "plus_uconst" may be missing:
16817 (DW_OP_push_object_address; DW_OP_plus_uconst: 8; DW_OP_deref;
16818 DW_OP_deref_size: 4)
16820 This happens when the field is at the start of the structure.
16822 Also, the final deref may not be sized:
16824 (DW_OP_push_object_address; DW_OP_plus_uconst: 4; DW_OP_deref;
16827 This happens when the size of the index type happens to be the
16828 same as the architecture's word size. This can occur with or
16829 without the second plus_uconst. */
16831 if (end
- start
< 2)
16833 if (*start
++ != DW_OP_push_object_address
)
16835 if (*start
++ != DW_OP_plus_uconst
)
16838 uint64_t this_bound_off
;
16839 start
= gdb_read_uleb128 (start
, end
, &this_bound_off
);
16840 if (start
== nullptr || (int) this_bound_off
!= this_bound_off
)
16842 /* Update *BOUNDS_OFFSET if needed, or alternatively verify that it
16843 is consistent among all bounds. */
16844 if (*bounds_offset
== -1)
16845 *bounds_offset
= this_bound_off
;
16846 else if (*bounds_offset
!= this_bound_off
)
16849 if (start
== end
|| *start
++ != DW_OP_deref
)
16855 else if (*start
== DW_OP_deref_size
|| *start
== DW_OP_deref
)
16857 /* This means an offset of 0. */
16859 else if (*start
++ != DW_OP_plus_uconst
)
16863 /* The size is the parameter to DW_OP_plus_uconst. */
16865 start
= gdb_read_uleb128 (start
, end
, &val
);
16866 if (start
== nullptr)
16868 if ((int) val
!= val
)
16877 if (*start
== DW_OP_deref_size
)
16879 start
= gdb_read_uleb128 (start
+ 1, end
, &size
);
16880 if (start
== nullptr)
16883 else if (*start
== DW_OP_deref
)
16885 size
= cu
->header
.addr_size
;
16891 SET_FIELD_BITPOS (*field
, 8 * offset
);
16892 if (size
!= TYPE_LENGTH (field
->type ()))
16893 FIELD_BITSIZE (*field
) = 8 * size
;
16898 /* With -fgnat-encodings=minimal, gcc will emit some unusual DWARF for
16899 some kinds of Ada arrays:
16901 <1><11db>: Abbrev Number: 7 (DW_TAG_array_type)
16902 <11dc> DW_AT_name : (indirect string, offset: 0x1bb8): string
16903 <11e0> DW_AT_data_location: 2 byte block: 97 6
16904 (DW_OP_push_object_address; DW_OP_deref)
16905 <11e3> DW_AT_type : <0x1173>
16906 <11e7> DW_AT_sibling : <0x1201>
16907 <2><11eb>: Abbrev Number: 8 (DW_TAG_subrange_type)
16908 <11ec> DW_AT_type : <0x1206>
16909 <11f0> DW_AT_lower_bound : 6 byte block: 97 23 8 6 94 4
16910 (DW_OP_push_object_address; DW_OP_plus_uconst: 8; DW_OP_deref;
16911 DW_OP_deref_size: 4)
16912 <11f7> DW_AT_upper_bound : 8 byte block: 97 23 8 6 23 4 94 4
16913 (DW_OP_push_object_address; DW_OP_plus_uconst: 8; DW_OP_deref;
16914 DW_OP_plus_uconst: 4; DW_OP_deref_size: 4)
16916 This actually represents a "thick pointer", which is a structure
16917 with two elements: one that is a pointer to the array data, and one
16918 that is a pointer to another structure; this second structure holds
16921 This returns a new type on success, or nullptr if this didn't
16922 recognize the type. */
16924 static struct type
*
16925 quirk_ada_thick_pointer (struct die_info
*die
, struct dwarf2_cu
*cu
,
16928 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_data_location
, cu
);
16929 /* So far we've only seen this with block form. */
16930 if (attr
== nullptr || !attr
->form_is_block ())
16933 /* Note that this will fail if the structure layout is changed by
16934 the compiler. However, we have no good way to recognize some
16935 other layout, because we don't know what expression the compiler
16936 might choose to emit should this happen. */
16937 struct dwarf_block
*blk
= attr
->as_block ();
16939 || blk
->data
[0] != DW_OP_push_object_address
16940 || blk
->data
[1] != DW_OP_deref
)
16943 int bounds_offset
= -1;
16944 int max_align
= -1;
16945 std::vector
<struct field
> range_fields
;
16946 for (struct die_info
*child_die
= die
->child
;
16948 child_die
= child_die
->sibling
)
16950 if (child_die
->tag
== DW_TAG_subrange_type
)
16952 struct type
*underlying
= read_subrange_index_type (child_die
, cu
);
16954 int this_align
= type_align (underlying
);
16955 if (this_align
> max_align
)
16956 max_align
= this_align
;
16958 range_fields
.emplace_back ();
16959 range_fields
.emplace_back ();
16961 struct field
&lower
= range_fields
[range_fields
.size () - 2];
16962 struct field
&upper
= range_fields
[range_fields
.size () - 1];
16964 lower
.set_type (underlying
);
16965 FIELD_ARTIFICIAL (lower
) = 1;
16967 upper
.set_type (underlying
);
16968 FIELD_ARTIFICIAL (upper
) = 1;
16970 if (!recognize_bound_expression (child_die
, DW_AT_lower_bound
,
16971 &bounds_offset
, &lower
, cu
)
16972 || !recognize_bound_expression (child_die
, DW_AT_upper_bound
,
16973 &bounds_offset
, &upper
, cu
))
16978 /* This shouldn't really happen, but double-check that we found
16979 where the bounds are stored. */
16980 if (bounds_offset
== -1)
16983 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
16984 for (int i
= 0; i
< range_fields
.size (); i
+= 2)
16988 /* Set the name of each field in the bounds. */
16989 xsnprintf (name
, sizeof (name
), "LB%d", i
/ 2);
16990 FIELD_NAME (range_fields
[i
]) = objfile
->intern (name
);
16991 xsnprintf (name
, sizeof (name
), "UB%d", i
/ 2);
16992 FIELD_NAME (range_fields
[i
+ 1]) = objfile
->intern (name
);
16995 struct type
*bounds
= alloc_type (objfile
);
16996 bounds
->set_code (TYPE_CODE_STRUCT
);
16998 bounds
->set_num_fields (range_fields
.size ());
17000 ((struct field
*) TYPE_ALLOC (bounds
, (bounds
->num_fields ()
17001 * sizeof (struct field
))));
17002 memcpy (bounds
->fields (), range_fields
.data (),
17003 bounds
->num_fields () * sizeof (struct field
));
17005 int last_fieldno
= range_fields
.size () - 1;
17006 int bounds_size
= (TYPE_FIELD_BITPOS (bounds
, last_fieldno
) / 8
17007 + TYPE_LENGTH (bounds
->field (last_fieldno
).type ()));
17008 TYPE_LENGTH (bounds
) = align_up (bounds_size
, max_align
);
17010 /* Rewrite the existing array type in place. Specifically, we
17011 remove any dynamic properties we might have read, and we replace
17012 the index types. */
17013 struct type
*iter
= type
;
17014 for (int i
= 0; i
< range_fields
.size (); i
+= 2)
17016 gdb_assert (iter
->code () == TYPE_CODE_ARRAY
);
17017 iter
->main_type
->dyn_prop_list
= nullptr;
17018 iter
->set_index_type
17019 (create_static_range_type (NULL
, bounds
->field (i
).type (), 1, 0));
17020 iter
= TYPE_TARGET_TYPE (iter
);
17023 struct type
*result
= alloc_type (objfile
);
17024 result
->set_code (TYPE_CODE_STRUCT
);
17026 result
->set_num_fields (2);
17028 ((struct field
*) TYPE_ZALLOC (result
, (result
->num_fields ()
17029 * sizeof (struct field
))));
17031 /* The names are chosen to coincide with what the compiler does with
17032 -fgnat-encodings=all, which the Ada code in gdb already
17034 TYPE_FIELD_NAME (result
, 0) = "P_ARRAY";
17035 result
->field (0).set_type (lookup_pointer_type (type
));
17037 TYPE_FIELD_NAME (result
, 1) = "P_BOUNDS";
17038 result
->field (1).set_type (lookup_pointer_type (bounds
));
17039 SET_FIELD_BITPOS (result
->field (1), 8 * bounds_offset
);
17041 result
->set_name (type
->name ());
17042 TYPE_LENGTH (result
) = (TYPE_LENGTH (result
->field (0).type ())
17043 + TYPE_LENGTH (result
->field (1).type ()));
17048 /* Extract all information from a DW_TAG_array_type DIE and put it in
17049 the DIE's type field. For now, this only handles one dimensional
17052 static struct type
*
17053 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17055 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17056 struct die_info
*child_die
;
17058 struct type
*element_type
, *range_type
, *index_type
;
17059 struct attribute
*attr
;
17061 struct dynamic_prop
*byte_stride_prop
= NULL
;
17062 unsigned int bit_stride
= 0;
17064 element_type
= die_type (die
, cu
);
17066 /* The die_type call above may have already set the type for this DIE. */
17067 type
= get_die_type (die
, cu
);
17071 attr
= dwarf2_attr (die
, DW_AT_byte_stride
, cu
);
17075 struct type
*prop_type
= cu
->addr_sized_int_type (false);
17078 = (struct dynamic_prop
*) alloca (sizeof (struct dynamic_prop
));
17079 stride_ok
= attr_to_dynamic_prop (attr
, die
, cu
, byte_stride_prop
,
17083 complaint (_("unable to read array DW_AT_byte_stride "
17084 " - DIE at %s [in module %s]"),
17085 sect_offset_str (die
->sect_off
),
17086 objfile_name (cu
->per_objfile
->objfile
));
17087 /* Ignore this attribute. We will likely not be able to print
17088 arrays of this type correctly, but there is little we can do
17089 to help if we cannot read the attribute's value. */
17090 byte_stride_prop
= NULL
;
17094 attr
= dwarf2_attr (die
, DW_AT_bit_stride
, cu
);
17096 bit_stride
= attr
->constant_value (0);
17098 /* Irix 6.2 native cc creates array types without children for
17099 arrays with unspecified length. */
17100 if (die
->child
== NULL
)
17102 index_type
= objfile_type (objfile
)->builtin_int
;
17103 range_type
= create_static_range_type (NULL
, index_type
, 0, -1);
17104 type
= create_array_type_with_stride (NULL
, element_type
, range_type
,
17105 byte_stride_prop
, bit_stride
);
17106 return set_die_type (die
, type
, cu
);
17109 std::vector
<struct type
*> range_types
;
17110 child_die
= die
->child
;
17111 while (child_die
&& child_die
->tag
)
17113 if (child_die
->tag
== DW_TAG_subrange_type
)
17115 struct type
*child_type
= read_type_die (child_die
, cu
);
17117 if (child_type
!= NULL
)
17119 /* The range type was succesfully read. Save it for the
17120 array type creation. */
17121 range_types
.push_back (child_type
);
17124 child_die
= child_die
->sibling
;
17127 if (range_types
.empty ())
17129 complaint (_("unable to find array range - DIE at %s [in module %s]"),
17130 sect_offset_str (die
->sect_off
),
17131 objfile_name (cu
->per_objfile
->objfile
));
17135 /* Dwarf2 dimensions are output from left to right, create the
17136 necessary array types in backwards order. */
17138 type
= element_type
;
17140 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
17144 while (i
< range_types
.size ())
17146 type
= create_array_type_with_stride (NULL
, type
, range_types
[i
++],
17147 byte_stride_prop
, bit_stride
);
17149 byte_stride_prop
= nullptr;
17154 size_t ndim
= range_types
.size ();
17157 type
= create_array_type_with_stride (NULL
, type
, range_types
[ndim
],
17158 byte_stride_prop
, bit_stride
);
17160 byte_stride_prop
= nullptr;
17164 gdb_assert (type
!= element_type
);
17166 /* Understand Dwarf2 support for vector types (like they occur on
17167 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
17168 array type. This is not part of the Dwarf2/3 standard yet, but a
17169 custom vendor extension. The main difference between a regular
17170 array and the vector variant is that vectors are passed by value
17172 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
17173 if (attr
!= nullptr)
17174 make_vector_type (type
);
17176 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
17177 implementation may choose to implement triple vectors using this
17179 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17180 if (attr
!= nullptr && attr
->form_is_unsigned ())
17182 if (attr
->as_unsigned () >= TYPE_LENGTH (type
))
17183 TYPE_LENGTH (type
) = attr
->as_unsigned ();
17185 complaint (_("DW_AT_byte_size for array type smaller "
17186 "than the total size of elements"));
17189 name
= dwarf2_name (die
, cu
);
17191 type
->set_name (name
);
17193 maybe_set_alignment (cu
, die
, type
);
17195 struct type
*replacement_type
= nullptr;
17196 if (cu
->language
== language_ada
)
17198 replacement_type
= quirk_ada_thick_pointer (die
, cu
, type
);
17199 if (replacement_type
!= nullptr)
17200 type
= replacement_type
;
17203 /* Install the type in the die. */
17204 set_die_type (die
, type
, cu
, replacement_type
!= nullptr);
17206 /* set_die_type should be already done. */
17207 set_descriptive_type (type
, die
, cu
);
17212 static enum dwarf_array_dim_ordering
17213 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
17215 struct attribute
*attr
;
17217 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
17219 if (attr
!= nullptr)
17221 LONGEST val
= attr
->constant_value (-1);
17222 if (val
== DW_ORD_row_major
|| val
== DW_ORD_col_major
)
17223 return (enum dwarf_array_dim_ordering
) val
;
17226 /* GNU F77 is a special case, as at 08/2004 array type info is the
17227 opposite order to the dwarf2 specification, but data is still
17228 laid out as per normal fortran.
17230 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
17231 version checking. */
17233 if (cu
->language
== language_fortran
17234 && cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
17236 return DW_ORD_row_major
;
17239 switch (cu
->language_defn
->array_ordering ())
17241 case array_column_major
:
17242 return DW_ORD_col_major
;
17243 case array_row_major
:
17245 return DW_ORD_row_major
;
17249 /* Extract all information from a DW_TAG_set_type DIE and put it in
17250 the DIE's type field. */
17252 static struct type
*
17253 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17255 struct type
*domain_type
, *set_type
;
17256 struct attribute
*attr
;
17258 domain_type
= die_type (die
, cu
);
17260 /* The die_type call above may have already set the type for this DIE. */
17261 set_type
= get_die_type (die
, cu
);
17265 set_type
= create_set_type (NULL
, domain_type
);
17267 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17268 if (attr
!= nullptr && attr
->form_is_unsigned ())
17269 TYPE_LENGTH (set_type
) = attr
->as_unsigned ();
17271 maybe_set_alignment (cu
, die
, set_type
);
17273 return set_die_type (die
, set_type
, cu
);
17276 /* A helper for read_common_block that creates a locexpr baton.
17277 SYM is the symbol which we are marking as computed.
17278 COMMON_DIE is the DIE for the common block.
17279 COMMON_LOC is the location expression attribute for the common
17281 MEMBER_LOC is the location expression attribute for the particular
17282 member of the common block that we are processing.
17283 CU is the CU from which the above come. */
17286 mark_common_block_symbol_computed (struct symbol
*sym
,
17287 struct die_info
*common_die
,
17288 struct attribute
*common_loc
,
17289 struct attribute
*member_loc
,
17290 struct dwarf2_cu
*cu
)
17292 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
17293 struct objfile
*objfile
= per_objfile
->objfile
;
17294 struct dwarf2_locexpr_baton
*baton
;
17296 unsigned int cu_off
;
17297 enum bfd_endian byte_order
= gdbarch_byte_order (objfile
->arch ());
17298 LONGEST offset
= 0;
17300 gdb_assert (common_loc
&& member_loc
);
17301 gdb_assert (common_loc
->form_is_block ());
17302 gdb_assert (member_loc
->form_is_block ()
17303 || member_loc
->form_is_constant ());
17305 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
17306 baton
->per_objfile
= per_objfile
;
17307 baton
->per_cu
= cu
->per_cu
;
17308 gdb_assert (baton
->per_cu
);
17310 baton
->size
= 5 /* DW_OP_call4 */ + 1 /* DW_OP_plus */;
17312 if (member_loc
->form_is_constant ())
17314 offset
= member_loc
->constant_value (0);
17315 baton
->size
+= 1 /* DW_OP_addr */ + cu
->header
.addr_size
;
17318 baton
->size
+= member_loc
->as_block ()->size
;
17320 ptr
= (gdb_byte
*) obstack_alloc (&objfile
->objfile_obstack
, baton
->size
);
17323 *ptr
++ = DW_OP_call4
;
17324 cu_off
= common_die
->sect_off
- cu
->per_cu
->sect_off
;
17325 store_unsigned_integer (ptr
, 4, byte_order
, cu_off
);
17328 if (member_loc
->form_is_constant ())
17330 *ptr
++ = DW_OP_addr
;
17331 store_unsigned_integer (ptr
, cu
->header
.addr_size
, byte_order
, offset
);
17332 ptr
+= cu
->header
.addr_size
;
17336 /* We have to copy the data here, because DW_OP_call4 will only
17337 use a DW_AT_location attribute. */
17338 struct dwarf_block
*block
= member_loc
->as_block ();
17339 memcpy (ptr
, block
->data
, block
->size
);
17340 ptr
+= block
->size
;
17343 *ptr
++ = DW_OP_plus
;
17344 gdb_assert (ptr
- baton
->data
== baton
->size
);
17346 SYMBOL_LOCATION_BATON (sym
) = baton
;
17347 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
17350 /* Create appropriate locally-scoped variables for all the
17351 DW_TAG_common_block entries. Also create a struct common_block
17352 listing all such variables for `info common'. COMMON_BLOCK_DOMAIN
17353 is used to separate the common blocks name namespace from regular
17357 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
17359 struct attribute
*attr
;
17361 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
17362 if (attr
!= nullptr)
17364 /* Support the .debug_loc offsets. */
17365 if (attr
->form_is_block ())
17369 else if (attr
->form_is_section_offset ())
17371 dwarf2_complex_location_expr_complaint ();
17376 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
17377 "common block member");
17382 if (die
->child
!= NULL
)
17384 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17385 struct die_info
*child_die
;
17386 size_t n_entries
= 0, size
;
17387 struct common_block
*common_block
;
17388 struct symbol
*sym
;
17390 for (child_die
= die
->child
;
17391 child_die
&& child_die
->tag
;
17392 child_die
= child_die
->sibling
)
17395 size
= (sizeof (struct common_block
)
17396 + (n_entries
- 1) * sizeof (struct symbol
*));
17398 = (struct common_block
*) obstack_alloc (&objfile
->objfile_obstack
,
17400 memset (common_block
->contents
, 0, n_entries
* sizeof (struct symbol
*));
17401 common_block
->n_entries
= 0;
17403 for (child_die
= die
->child
;
17404 child_die
&& child_die
->tag
;
17405 child_die
= child_die
->sibling
)
17407 /* Create the symbol in the DW_TAG_common_block block in the current
17409 sym
= new_symbol (child_die
, NULL
, cu
);
17412 struct attribute
*member_loc
;
17414 common_block
->contents
[common_block
->n_entries
++] = sym
;
17416 member_loc
= dwarf2_attr (child_die
, DW_AT_data_member_location
,
17420 /* GDB has handled this for a long time, but it is
17421 not specified by DWARF. It seems to have been
17422 emitted by gfortran at least as recently as:
17423 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=23057. */
17424 complaint (_("Variable in common block has "
17425 "DW_AT_data_member_location "
17426 "- DIE at %s [in module %s]"),
17427 sect_offset_str (child_die
->sect_off
),
17428 objfile_name (objfile
));
17430 if (member_loc
->form_is_section_offset ())
17431 dwarf2_complex_location_expr_complaint ();
17432 else if (member_loc
->form_is_constant ()
17433 || member_loc
->form_is_block ())
17435 if (attr
!= nullptr)
17436 mark_common_block_symbol_computed (sym
, die
, attr
,
17440 dwarf2_complex_location_expr_complaint ();
17445 sym
= new_symbol (die
, objfile_type (objfile
)->builtin_void
, cu
);
17446 SYMBOL_VALUE_COMMON_BLOCK (sym
) = common_block
;
17450 /* Create a type for a C++ namespace. */
17452 static struct type
*
17453 read_namespace_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17455 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17456 const char *previous_prefix
, *name
;
17460 /* For extensions, reuse the type of the original namespace. */
17461 if (dwarf2_attr (die
, DW_AT_extension
, cu
) != NULL
)
17463 struct die_info
*ext_die
;
17464 struct dwarf2_cu
*ext_cu
= cu
;
17466 ext_die
= dwarf2_extension (die
, &ext_cu
);
17467 type
= read_type_die (ext_die
, ext_cu
);
17469 /* EXT_CU may not be the same as CU.
17470 Ensure TYPE is recorded with CU in die_type_hash. */
17471 return set_die_type (die
, type
, cu
);
17474 name
= namespace_name (die
, &is_anonymous
, cu
);
17476 /* Now build the name of the current namespace. */
17478 previous_prefix
= determine_prefix (die
, cu
);
17479 if (previous_prefix
[0] != '\0')
17480 name
= typename_concat (&objfile
->objfile_obstack
,
17481 previous_prefix
, name
, 0, cu
);
17483 /* Create the type. */
17484 type
= init_type (objfile
, TYPE_CODE_NAMESPACE
, 0, name
);
17486 return set_die_type (die
, type
, cu
);
17489 /* Read a namespace scope. */
17492 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
17494 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17497 /* Add a symbol associated to this if we haven't seen the namespace
17498 before. Also, add a using directive if it's an anonymous
17501 if (dwarf2_attr (die
, DW_AT_extension
, cu
) == NULL
)
17505 type
= read_type_die (die
, cu
);
17506 new_symbol (die
, type
, cu
);
17508 namespace_name (die
, &is_anonymous
, cu
);
17511 const char *previous_prefix
= determine_prefix (die
, cu
);
17513 std::vector
<const char *> excludes
;
17514 add_using_directive (using_directives (cu
),
17515 previous_prefix
, type
->name (), NULL
,
17516 NULL
, excludes
, 0, &objfile
->objfile_obstack
);
17520 if (die
->child
!= NULL
)
17522 struct die_info
*child_die
= die
->child
;
17524 while (child_die
&& child_die
->tag
)
17526 process_die (child_die
, cu
);
17527 child_die
= child_die
->sibling
;
17532 /* Read a Fortran module as type. This DIE can be only a declaration used for
17533 imported module. Still we need that type as local Fortran "use ... only"
17534 declaration imports depend on the created type in determine_prefix. */
17536 static struct type
*
17537 read_module_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17539 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17540 const char *module_name
;
17543 module_name
= dwarf2_name (die
, cu
);
17544 type
= init_type (objfile
, TYPE_CODE_MODULE
, 0, module_name
);
17546 return set_die_type (die
, type
, cu
);
17549 /* Read a Fortran module. */
17552 read_module (struct die_info
*die
, struct dwarf2_cu
*cu
)
17554 struct die_info
*child_die
= die
->child
;
17557 type
= read_type_die (die
, cu
);
17558 new_symbol (die
, type
, cu
);
17560 while (child_die
&& child_die
->tag
)
17562 process_die (child_die
, cu
);
17563 child_die
= child_die
->sibling
;
17567 /* Return the name of the namespace represented by DIE. Set
17568 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
17571 static const char *
17572 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
17574 struct die_info
*current_die
;
17575 const char *name
= NULL
;
17577 /* Loop through the extensions until we find a name. */
17579 for (current_die
= die
;
17580 current_die
!= NULL
;
17581 current_die
= dwarf2_extension (die
, &cu
))
17583 /* We don't use dwarf2_name here so that we can detect the absence
17584 of a name -> anonymous namespace. */
17585 name
= dwarf2_string_attr (die
, DW_AT_name
, cu
);
17591 /* Is it an anonymous namespace? */
17593 *is_anonymous
= (name
== NULL
);
17595 name
= CP_ANONYMOUS_NAMESPACE_STR
;
17600 /* Extract all information from a DW_TAG_pointer_type DIE and add to
17601 the user defined type vector. */
17603 static struct type
*
17604 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17606 struct gdbarch
*gdbarch
= cu
->per_objfile
->objfile
->arch ();
17607 struct comp_unit_head
*cu_header
= &cu
->header
;
17609 struct attribute
*attr_byte_size
;
17610 struct attribute
*attr_address_class
;
17611 int byte_size
, addr_class
;
17612 struct type
*target_type
;
17614 target_type
= die_type (die
, cu
);
17616 /* The die_type call above may have already set the type for this DIE. */
17617 type
= get_die_type (die
, cu
);
17621 type
= lookup_pointer_type (target_type
);
17623 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17624 if (attr_byte_size
)
17625 byte_size
= attr_byte_size
->constant_value (cu_header
->addr_size
);
17627 byte_size
= cu_header
->addr_size
;
17629 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
17630 if (attr_address_class
)
17631 addr_class
= attr_address_class
->constant_value (DW_ADDR_none
);
17633 addr_class
= DW_ADDR_none
;
17635 ULONGEST alignment
= get_alignment (cu
, die
);
17637 /* If the pointer size, alignment, or address class is different
17638 than the default, create a type variant marked as such and set
17639 the length accordingly. */
17640 if (TYPE_LENGTH (type
) != byte_size
17641 || (alignment
!= 0 && TYPE_RAW_ALIGN (type
) != 0
17642 && alignment
!= TYPE_RAW_ALIGN (type
))
17643 || addr_class
!= DW_ADDR_none
)
17645 if (gdbarch_address_class_type_flags_p (gdbarch
))
17647 type_instance_flags type_flags
17648 = gdbarch_address_class_type_flags (gdbarch
, byte_size
,
17650 gdb_assert ((type_flags
& ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
17652 type
= make_type_with_address_space (type
, type_flags
);
17654 else if (TYPE_LENGTH (type
) != byte_size
)
17656 complaint (_("invalid pointer size %d"), byte_size
);
17658 else if (TYPE_RAW_ALIGN (type
) != alignment
)
17660 complaint (_("Invalid DW_AT_alignment"
17661 " - DIE at %s [in module %s]"),
17662 sect_offset_str (die
->sect_off
),
17663 objfile_name (cu
->per_objfile
->objfile
));
17667 /* Should we also complain about unhandled address classes? */
17671 TYPE_LENGTH (type
) = byte_size
;
17672 set_type_align (type
, alignment
);
17673 return set_die_type (die
, type
, cu
);
17676 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
17677 the user defined type vector. */
17679 static struct type
*
17680 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17683 struct type
*to_type
;
17684 struct type
*domain
;
17686 to_type
= die_type (die
, cu
);
17687 domain
= die_containing_type (die
, cu
);
17689 /* The calls above may have already set the type for this DIE. */
17690 type
= get_die_type (die
, cu
);
17694 if (check_typedef (to_type
)->code () == TYPE_CODE_METHOD
)
17695 type
= lookup_methodptr_type (to_type
);
17696 else if (check_typedef (to_type
)->code () == TYPE_CODE_FUNC
)
17698 struct type
*new_type
= alloc_type (cu
->per_objfile
->objfile
);
17700 smash_to_method_type (new_type
, domain
, TYPE_TARGET_TYPE (to_type
),
17701 to_type
->fields (), to_type
->num_fields (),
17702 to_type
->has_varargs ());
17703 type
= lookup_methodptr_type (new_type
);
17706 type
= lookup_memberptr_type (to_type
, domain
);
17708 return set_die_type (die
, type
, cu
);
17711 /* Extract all information from a DW_TAG_{rvalue_,}reference_type DIE and add to
17712 the user defined type vector. */
17714 static struct type
*
17715 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
,
17716 enum type_code refcode
)
17718 struct comp_unit_head
*cu_header
= &cu
->header
;
17719 struct type
*type
, *target_type
;
17720 struct attribute
*attr
;
17722 gdb_assert (refcode
== TYPE_CODE_REF
|| refcode
== TYPE_CODE_RVALUE_REF
);
17724 target_type
= die_type (die
, cu
);
17726 /* The die_type call above may have already set the type for this DIE. */
17727 type
= get_die_type (die
, cu
);
17731 type
= lookup_reference_type (target_type
, refcode
);
17732 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17733 if (attr
!= nullptr)
17735 TYPE_LENGTH (type
) = attr
->constant_value (cu_header
->addr_size
);
17739 TYPE_LENGTH (type
) = cu_header
->addr_size
;
17741 maybe_set_alignment (cu
, die
, type
);
17742 return set_die_type (die
, type
, cu
);
17745 /* Add the given cv-qualifiers to the element type of the array. GCC
17746 outputs DWARF type qualifiers that apply to an array, not the
17747 element type. But GDB relies on the array element type to carry
17748 the cv-qualifiers. This mimics section 6.7.3 of the C99
17751 static struct type
*
17752 add_array_cv_type (struct die_info
*die
, struct dwarf2_cu
*cu
,
17753 struct type
*base_type
, int cnst
, int voltl
)
17755 struct type
*el_type
, *inner_array
;
17757 base_type
= copy_type (base_type
);
17758 inner_array
= base_type
;
17760 while (TYPE_TARGET_TYPE (inner_array
)->code () == TYPE_CODE_ARRAY
)
17762 TYPE_TARGET_TYPE (inner_array
) =
17763 copy_type (TYPE_TARGET_TYPE (inner_array
));
17764 inner_array
= TYPE_TARGET_TYPE (inner_array
);
17767 el_type
= TYPE_TARGET_TYPE (inner_array
);
17768 cnst
|= TYPE_CONST (el_type
);
17769 voltl
|= TYPE_VOLATILE (el_type
);
17770 TYPE_TARGET_TYPE (inner_array
) = make_cv_type (cnst
, voltl
, el_type
, NULL
);
17772 return set_die_type (die
, base_type
, cu
);
17775 static struct type
*
17776 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17778 struct type
*base_type
, *cv_type
;
17780 base_type
= die_type (die
, cu
);
17782 /* The die_type call above may have already set the type for this DIE. */
17783 cv_type
= get_die_type (die
, cu
);
17787 /* In case the const qualifier is applied to an array type, the element type
17788 is so qualified, not the array type (section 6.7.3 of C99). */
17789 if (base_type
->code () == TYPE_CODE_ARRAY
)
17790 return add_array_cv_type (die
, cu
, base_type
, 1, 0);
17792 cv_type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
17793 return set_die_type (die
, cv_type
, cu
);
17796 static struct type
*
17797 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17799 struct type
*base_type
, *cv_type
;
17801 base_type
= die_type (die
, cu
);
17803 /* The die_type call above may have already set the type for this DIE. */
17804 cv_type
= get_die_type (die
, cu
);
17808 /* In case the volatile qualifier is applied to an array type, the
17809 element type is so qualified, not the array type (section 6.7.3
17811 if (base_type
->code () == TYPE_CODE_ARRAY
)
17812 return add_array_cv_type (die
, cu
, base_type
, 0, 1);
17814 cv_type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
17815 return set_die_type (die
, cv_type
, cu
);
17818 /* Handle DW_TAG_restrict_type. */
17820 static struct type
*
17821 read_tag_restrict_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17823 struct type
*base_type
, *cv_type
;
17825 base_type
= die_type (die
, cu
);
17827 /* The die_type call above may have already set the type for this DIE. */
17828 cv_type
= get_die_type (die
, cu
);
17832 cv_type
= make_restrict_type (base_type
);
17833 return set_die_type (die
, cv_type
, cu
);
17836 /* Handle DW_TAG_atomic_type. */
17838 static struct type
*
17839 read_tag_atomic_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17841 struct type
*base_type
, *cv_type
;
17843 base_type
= die_type (die
, cu
);
17845 /* The die_type call above may have already set the type for this DIE. */
17846 cv_type
= get_die_type (die
, cu
);
17850 cv_type
= make_atomic_type (base_type
);
17851 return set_die_type (die
, cv_type
, cu
);
17854 /* Extract all information from a DW_TAG_string_type DIE and add to
17855 the user defined type vector. It isn't really a user defined type,
17856 but it behaves like one, with other DIE's using an AT_user_def_type
17857 attribute to reference it. */
17859 static struct type
*
17860 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17862 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17863 struct gdbarch
*gdbarch
= objfile
->arch ();
17864 struct type
*type
, *range_type
, *index_type
, *char_type
;
17865 struct attribute
*attr
;
17866 struct dynamic_prop prop
;
17867 bool length_is_constant
= true;
17870 /* There are a couple of places where bit sizes might be made use of
17871 when parsing a DW_TAG_string_type, however, no producer that we know
17872 of make use of these. Handling bit sizes that are a multiple of the
17873 byte size is easy enough, but what about other bit sizes? Lets deal
17874 with that problem when we have to. Warn about these attributes being
17875 unsupported, then parse the type and ignore them like we always
17877 if (dwarf2_attr (die
, DW_AT_bit_size
, cu
) != nullptr
17878 || dwarf2_attr (die
, DW_AT_string_length_bit_size
, cu
) != nullptr)
17880 static bool warning_printed
= false;
17881 if (!warning_printed
)
17883 warning (_("DW_AT_bit_size and DW_AT_string_length_bit_size not "
17884 "currently supported on DW_TAG_string_type."));
17885 warning_printed
= true;
17889 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
17890 if (attr
!= nullptr && !attr
->form_is_constant ())
17892 /* The string length describes the location at which the length of
17893 the string can be found. The size of the length field can be
17894 specified with one of the attributes below. */
17895 struct type
*prop_type
;
17896 struct attribute
*len
17897 = dwarf2_attr (die
, DW_AT_string_length_byte_size
, cu
);
17898 if (len
== nullptr)
17899 len
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17900 if (len
!= nullptr && len
->form_is_constant ())
17902 /* Pass 0 as the default as we know this attribute is constant
17903 and the default value will not be returned. */
17904 LONGEST sz
= len
->constant_value (0);
17905 prop_type
= cu
->per_objfile
->int_type (sz
, true);
17909 /* If the size is not specified then we assume it is the size of
17910 an address on this target. */
17911 prop_type
= cu
->addr_sized_int_type (true);
17914 /* Convert the attribute into a dynamic property. */
17915 if (!attr_to_dynamic_prop (attr
, die
, cu
, &prop
, prop_type
))
17918 length_is_constant
= false;
17920 else if (attr
!= nullptr)
17922 /* This DW_AT_string_length just contains the length with no
17923 indirection. There's no need to create a dynamic property in this
17924 case. Pass 0 for the default value as we know it will not be
17925 returned in this case. */
17926 length
= attr
->constant_value (0);
17928 else if ((attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
)) != nullptr)
17930 /* We don't currently support non-constant byte sizes for strings. */
17931 length
= attr
->constant_value (1);
17935 /* Use 1 as a fallback length if we have nothing else. */
17939 index_type
= objfile_type (objfile
)->builtin_int
;
17940 if (length_is_constant
)
17941 range_type
= create_static_range_type (NULL
, index_type
, 1, length
);
17944 struct dynamic_prop low_bound
;
17946 low_bound
.set_const_val (1);
17947 range_type
= create_range_type (NULL
, index_type
, &low_bound
, &prop
, 0);
17949 char_type
= language_string_char_type (cu
->language_defn
, gdbarch
);
17950 type
= create_string_type (NULL
, char_type
, range_type
);
17952 return set_die_type (die
, type
, cu
);
17955 /* Assuming that DIE corresponds to a function, returns nonzero
17956 if the function is prototyped. */
17959 prototyped_function_p (struct die_info
*die
, struct dwarf2_cu
*cu
)
17961 struct attribute
*attr
;
17963 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
17964 if (attr
&& attr
->as_boolean ())
17967 /* The DWARF standard implies that the DW_AT_prototyped attribute
17968 is only meaningful for C, but the concept also extends to other
17969 languages that allow unprototyped functions (Eg: Objective C).
17970 For all other languages, assume that functions are always
17972 if (cu
->language
!= language_c
17973 && cu
->language
!= language_objc
17974 && cu
->language
!= language_opencl
)
17977 /* RealView does not emit DW_AT_prototyped. We can not distinguish
17978 prototyped and unprototyped functions; default to prototyped,
17979 since that is more common in modern code (and RealView warns
17980 about unprototyped functions). */
17981 if (producer_is_realview (cu
->producer
))
17987 /* Handle DIES due to C code like:
17991 int (*funcp)(int a, long l);
17995 ('funcp' generates a DW_TAG_subroutine_type DIE). */
17997 static struct type
*
17998 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18000 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
18001 struct type
*type
; /* Type that this function returns. */
18002 struct type
*ftype
; /* Function that returns above type. */
18003 struct attribute
*attr
;
18005 type
= die_type (die
, cu
);
18007 /* The die_type call above may have already set the type for this DIE. */
18008 ftype
= get_die_type (die
, cu
);
18012 ftype
= lookup_function_type (type
);
18014 if (prototyped_function_p (die
, cu
))
18015 ftype
->set_is_prototyped (true);
18017 /* Store the calling convention in the type if it's available in
18018 the subroutine die. Otherwise set the calling convention to
18019 the default value DW_CC_normal. */
18020 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
18021 if (attr
!= nullptr
18022 && is_valid_DW_AT_calling_convention_for_subroutine (attr
->constant_value (0)))
18023 TYPE_CALLING_CONVENTION (ftype
)
18024 = (enum dwarf_calling_convention
) attr
->constant_value (0);
18025 else if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL"))
18026 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_GDB_IBM_OpenCL
;
18028 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_normal
;
18030 /* Record whether the function returns normally to its caller or not
18031 if the DWARF producer set that information. */
18032 attr
= dwarf2_attr (die
, DW_AT_noreturn
, cu
);
18033 if (attr
&& attr
->as_boolean ())
18034 TYPE_NO_RETURN (ftype
) = 1;
18036 /* We need to add the subroutine type to the die immediately so
18037 we don't infinitely recurse when dealing with parameters
18038 declared as the same subroutine type. */
18039 set_die_type (die
, ftype
, cu
);
18041 if (die
->child
!= NULL
)
18043 struct type
*void_type
= objfile_type (objfile
)->builtin_void
;
18044 struct die_info
*child_die
;
18045 int nparams
, iparams
;
18047 /* Count the number of parameters.
18048 FIXME: GDB currently ignores vararg functions, but knows about
18049 vararg member functions. */
18051 child_die
= die
->child
;
18052 while (child_die
&& child_die
->tag
)
18054 if (child_die
->tag
== DW_TAG_formal_parameter
)
18056 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
18057 ftype
->set_has_varargs (true);
18059 child_die
= child_die
->sibling
;
18062 /* Allocate storage for parameters and fill them in. */
18063 ftype
->set_num_fields (nparams
);
18065 ((struct field
*) TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
)));
18067 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
18068 even if we error out during the parameters reading below. */
18069 for (iparams
= 0; iparams
< nparams
; iparams
++)
18070 ftype
->field (iparams
).set_type (void_type
);
18073 child_die
= die
->child
;
18074 while (child_die
&& child_die
->tag
)
18076 if (child_die
->tag
== DW_TAG_formal_parameter
)
18078 struct type
*arg_type
;
18080 /* DWARF version 2 has no clean way to discern C++
18081 static and non-static member functions. G++ helps
18082 GDB by marking the first parameter for non-static
18083 member functions (which is the this pointer) as
18084 artificial. We pass this information to
18085 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
18087 DWARF version 3 added DW_AT_object_pointer, which GCC
18088 4.5 does not yet generate. */
18089 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
18090 if (attr
!= nullptr)
18091 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = attr
->as_boolean ();
18093 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
18094 arg_type
= die_type (child_die
, cu
);
18096 /* RealView does not mark THIS as const, which the testsuite
18097 expects. GCC marks THIS as const in method definitions,
18098 but not in the class specifications (GCC PR 43053). */
18099 if (cu
->language
== language_cplus
&& !TYPE_CONST (arg_type
)
18100 && TYPE_FIELD_ARTIFICIAL (ftype
, iparams
))
18103 struct dwarf2_cu
*arg_cu
= cu
;
18104 const char *name
= dwarf2_name (child_die
, cu
);
18106 attr
= dwarf2_attr (die
, DW_AT_object_pointer
, cu
);
18107 if (attr
!= nullptr)
18109 /* If the compiler emits this, use it. */
18110 if (follow_die_ref (die
, attr
, &arg_cu
) == child_die
)
18113 else if (name
&& strcmp (name
, "this") == 0)
18114 /* Function definitions will have the argument names. */
18116 else if (name
== NULL
&& iparams
== 0)
18117 /* Declarations may not have the names, so like
18118 elsewhere in GDB, assume an artificial first
18119 argument is "this". */
18123 arg_type
= make_cv_type (1, TYPE_VOLATILE (arg_type
),
18127 ftype
->field (iparams
).set_type (arg_type
);
18130 child_die
= child_die
->sibling
;
18137 static struct type
*
18138 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
18140 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
18141 const char *name
= NULL
;
18142 struct type
*this_type
, *target_type
;
18144 name
= dwarf2_full_name (NULL
, die
, cu
);
18145 this_type
= init_type (objfile
, TYPE_CODE_TYPEDEF
, 0, name
);
18146 this_type
->set_target_is_stub (true);
18147 set_die_type (die
, this_type
, cu
);
18148 target_type
= die_type (die
, cu
);
18149 if (target_type
!= this_type
)
18150 TYPE_TARGET_TYPE (this_type
) = target_type
;
18153 /* Self-referential typedefs are, it seems, not allowed by the DWARF
18154 spec and cause infinite loops in GDB. */
18155 complaint (_("Self-referential DW_TAG_typedef "
18156 "- DIE at %s [in module %s]"),
18157 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
18158 TYPE_TARGET_TYPE (this_type
) = NULL
;
18162 /* Gcc-7 and before supports -feliminate-dwarf2-dups, which generates
18163 anonymous typedefs, which is, strictly speaking, invalid DWARF.
18164 Handle these by just returning the target type, rather than
18165 constructing an anonymous typedef type and trying to handle this
18167 set_die_type (die
, target_type
, cu
);
18168 return target_type
;
18173 /* Helper for get_dwarf2_rational_constant that computes the value of
18174 a given gmp_mpz given an attribute. */
18177 get_mpz (struct dwarf2_cu
*cu
, gdb_mpz
*value
, struct attribute
*attr
)
18179 /* GCC will sometimes emit a 16-byte constant value as a DWARF
18180 location expression that pushes an implicit value. */
18181 if (attr
->form
== DW_FORM_exprloc
)
18183 dwarf_block
*blk
= attr
->as_block ();
18184 if (blk
->size
> 0 && blk
->data
[0] == DW_OP_implicit_value
)
18187 const gdb_byte
*ptr
= safe_read_uleb128 (blk
->data
+ 1,
18188 blk
->data
+ blk
->size
,
18190 if (ptr
- blk
->data
+ len
<= blk
->size
)
18192 mpz_import (value
->val
, len
,
18193 bfd_big_endian (cu
->per_objfile
->objfile
->obfd
) ? 1 : -1,
18199 /* On failure set it to 1. */
18200 *value
= gdb_mpz (1);
18202 else if (attr
->form_is_block ())
18204 dwarf_block
*blk
= attr
->as_block ();
18205 mpz_import (value
->val
, blk
->size
,
18206 bfd_big_endian (cu
->per_objfile
->objfile
->obfd
) ? 1 : -1,
18207 1, 0, 0, blk
->data
);
18210 *value
= gdb_mpz (attr
->constant_value (1));
18213 /* Assuming DIE is a rational DW_TAG_constant, read the DIE's
18214 numerator and denominator into NUMERATOR and DENOMINATOR (resp).
18216 If the numerator and/or numerator attribute is missing,
18217 a complaint is filed, and NUMERATOR and DENOMINATOR are left
18221 get_dwarf2_rational_constant (struct die_info
*die
, struct dwarf2_cu
*cu
,
18222 gdb_mpz
*numerator
, gdb_mpz
*denominator
)
18224 struct attribute
*num_attr
, *denom_attr
;
18226 num_attr
= dwarf2_attr (die
, DW_AT_GNU_numerator
, cu
);
18227 if (num_attr
== nullptr)
18228 complaint (_("DW_AT_GNU_numerator missing in %s DIE at %s"),
18229 dwarf_tag_name (die
->tag
), sect_offset_str (die
->sect_off
));
18231 denom_attr
= dwarf2_attr (die
, DW_AT_GNU_denominator
, cu
);
18232 if (denom_attr
== nullptr)
18233 complaint (_("DW_AT_GNU_denominator missing in %s DIE at %s"),
18234 dwarf_tag_name (die
->tag
), sect_offset_str (die
->sect_off
));
18236 if (num_attr
== nullptr || denom_attr
== nullptr)
18239 get_mpz (cu
, numerator
, num_attr
);
18240 get_mpz (cu
, denominator
, denom_attr
);
18243 /* Same as get_dwarf2_rational_constant, but extracting an unsigned
18244 rational constant, rather than a signed one.
18246 If the rational constant has a negative value, a complaint
18247 is filed, and NUMERATOR and DENOMINATOR are left untouched. */
18250 get_dwarf2_unsigned_rational_constant (struct die_info
*die
,
18251 struct dwarf2_cu
*cu
,
18252 gdb_mpz
*numerator
,
18253 gdb_mpz
*denominator
)
18258 get_dwarf2_rational_constant (die
, cu
, &num
, &denom
);
18259 if (mpz_sgn (num
.val
) == -1 && mpz_sgn (denom
.val
) == -1)
18261 mpz_neg (num
.val
, num
.val
);
18262 mpz_neg (denom
.val
, denom
.val
);
18264 else if (mpz_sgn (num
.val
) == -1)
18266 complaint (_("unexpected negative value for DW_AT_GNU_numerator"
18268 sect_offset_str (die
->sect_off
));
18271 else if (mpz_sgn (denom
.val
) == -1)
18273 complaint (_("unexpected negative value for DW_AT_GNU_denominator"
18275 sect_offset_str (die
->sect_off
));
18279 *numerator
= std::move (num
);
18280 *denominator
= std::move (denom
);
18283 /* Assuming that ENCODING is a string whose contents starting at the
18284 K'th character is "_nn" where "nn" is a decimal number, scan that
18285 number and set RESULT to the value. K is updated to point to the
18286 character immediately following the number.
18288 If the string does not conform to the format described above, false
18289 is returned, and K may or may not be changed. */
18292 ada_get_gnat_encoded_number (const char *encoding
, int &k
, gdb_mpz
*result
)
18294 /* The next character should be an underscore ('_') followed
18296 if (encoding
[k
] != '_' || !isdigit (encoding
[k
+ 1]))
18299 /* Skip the underscore. */
18303 /* Determine the number of digits for our number. */
18304 while (isdigit (encoding
[k
]))
18309 std::string
copy (&encoding
[start
], k
- start
);
18310 if (mpz_set_str (result
->val
, copy
.c_str (), 10) == -1)
18316 /* Scan two numbers from ENCODING at OFFSET, assuming the string is of
18317 the form _NN_DD, where NN and DD are decimal numbers. Set NUM and
18318 DENOM, update OFFSET, and return true on success. Return false on
18322 ada_get_gnat_encoded_ratio (const char *encoding
, int &offset
,
18323 gdb_mpz
*num
, gdb_mpz
*denom
)
18325 if (!ada_get_gnat_encoded_number (encoding
, offset
, num
))
18327 return ada_get_gnat_encoded_number (encoding
, offset
, denom
);
18330 /* Assuming DIE corresponds to a fixed point type, finish the creation
18331 of the corresponding TYPE by setting its type-specific data. CU is
18332 the DIE's CU. SUFFIX is the "XF" type name suffix coming from GNAT
18333 encodings. It is nullptr if the GNAT encoding should be
18337 finish_fixed_point_type (struct type
*type
, const char *suffix
,
18338 struct die_info
*die
, struct dwarf2_cu
*cu
)
18340 gdb_assert (type
->code () == TYPE_CODE_FIXED_POINT
18341 && TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_FIXED_POINT
);
18343 /* If GNAT encodings are preferred, don't examine the
18345 struct attribute
*attr
= nullptr;
18346 if (suffix
== nullptr)
18348 attr
= dwarf2_attr (die
, DW_AT_binary_scale
, cu
);
18349 if (attr
== nullptr)
18350 attr
= dwarf2_attr (die
, DW_AT_decimal_scale
, cu
);
18351 if (attr
== nullptr)
18352 attr
= dwarf2_attr (die
, DW_AT_small
, cu
);
18355 /* Numerator and denominator of our fixed-point type's scaling factor.
18356 The default is a scaling factor of 1, which we use as a fallback
18357 when we are not able to decode it (problem with the debugging info,
18358 unsupported forms, bug in GDB, etc...). Using that as the default
18359 allows us to at least print the unscaled value, which might still
18360 be useful to a user. */
18361 gdb_mpz
scale_num (1);
18362 gdb_mpz
scale_denom (1);
18364 if (attr
== nullptr)
18367 if (suffix
!= nullptr
18368 && ada_get_gnat_encoded_ratio (suffix
, offset
, &scale_num
,
18370 /* The number might be encoded as _nn_dd_nn_dd, where the
18371 second ratio is the 'small value. In this situation, we
18372 want the second value. */
18373 && (suffix
[offset
] != '_'
18374 || ada_get_gnat_encoded_ratio (suffix
, offset
, &scale_num
,
18381 /* Scaling factor not found. Assume a scaling factor of 1,
18382 and hope for the best. At least the user will be able to
18383 see the encoded value. */
18386 complaint (_("no scale found for fixed-point type (DIE at %s)"),
18387 sect_offset_str (die
->sect_off
));
18390 else if (attr
->name
== DW_AT_binary_scale
)
18392 LONGEST scale_exp
= attr
->constant_value (0);
18393 gdb_mpz
*num_or_denom
= scale_exp
> 0 ? &scale_num
: &scale_denom
;
18395 mpz_mul_2exp (num_or_denom
->val
, num_or_denom
->val
, std::abs (scale_exp
));
18397 else if (attr
->name
== DW_AT_decimal_scale
)
18399 LONGEST scale_exp
= attr
->constant_value (0);
18400 gdb_mpz
*num_or_denom
= scale_exp
> 0 ? &scale_num
: &scale_denom
;
18402 mpz_ui_pow_ui (num_or_denom
->val
, 10, std::abs (scale_exp
));
18404 else if (attr
->name
== DW_AT_small
)
18406 struct die_info
*scale_die
;
18407 struct dwarf2_cu
*scale_cu
= cu
;
18409 scale_die
= follow_die_ref (die
, attr
, &scale_cu
);
18410 if (scale_die
->tag
== DW_TAG_constant
)
18411 get_dwarf2_unsigned_rational_constant (scale_die
, scale_cu
,
18412 &scale_num
, &scale_denom
);
18414 complaint (_("%s DIE not supported as target of DW_AT_small attribute"
18416 dwarf_tag_name (die
->tag
), sect_offset_str (die
->sect_off
));
18420 complaint (_("unsupported scale attribute %s for fixed-point type"
18422 dwarf_attr_name (attr
->name
),
18423 sect_offset_str (die
->sect_off
));
18426 gdb_mpq
&scaling_factor
= type
->fixed_point_info ().scaling_factor
;
18427 mpz_set (mpq_numref (scaling_factor
.val
), scale_num
.val
);
18428 mpz_set (mpq_denref (scaling_factor
.val
), scale_denom
.val
);
18429 mpq_canonicalize (scaling_factor
.val
);
18432 /* The gnat-encoding suffix for fixed point. */
18434 #define GNAT_FIXED_POINT_SUFFIX "___XF_"
18436 /* If NAME encodes an Ada fixed-point type, return a pointer to the
18437 "XF" suffix of the name. The text after this is what encodes the
18438 'small and 'delta information. Otherwise, return nullptr. */
18440 static const char *
18441 gnat_encoded_fixed_point_type_info (const char *name
)
18443 return strstr (name
, GNAT_FIXED_POINT_SUFFIX
);
18446 /* Allocate a floating-point type of size BITS and name NAME. Pass NAME_HINT
18447 (which may be different from NAME) to the architecture back-end to allow
18448 it to guess the correct format if necessary. */
18450 static struct type
*
18451 dwarf2_init_float_type (struct objfile
*objfile
, int bits
, const char *name
,
18452 const char *name_hint
, enum bfd_endian byte_order
)
18454 struct gdbarch
*gdbarch
= objfile
->arch ();
18455 const struct floatformat
**format
;
18458 format
= gdbarch_floatformat_for_type (gdbarch
, name_hint
, bits
);
18460 type
= init_float_type (objfile
, bits
, name
, format
, byte_order
);
18462 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
, name
);
18467 /* Allocate an integer type of size BITS and name NAME. */
18469 static struct type
*
18470 dwarf2_init_integer_type (struct dwarf2_cu
*cu
, struct objfile
*objfile
,
18471 int bits
, int unsigned_p
, const char *name
)
18475 /* Versions of Intel's C Compiler generate an integer type called "void"
18476 instead of using DW_TAG_unspecified_type. This has been seen on
18477 at least versions 14, 17, and 18. */
18478 if (bits
== 0 && producer_is_icc (cu
) && name
!= nullptr
18479 && strcmp (name
, "void") == 0)
18480 type
= objfile_type (objfile
)->builtin_void
;
18482 type
= init_integer_type (objfile
, bits
, unsigned_p
, name
);
18487 /* Return true if DIE has a DW_AT_small attribute whose value is
18488 a constant rational, where both the numerator and denominator
18491 CU is the DIE's Compilation Unit. */
18494 has_zero_over_zero_small_attribute (struct die_info
*die
,
18495 struct dwarf2_cu
*cu
)
18497 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_small
, cu
);
18498 if (attr
== nullptr)
18501 struct dwarf2_cu
*scale_cu
= cu
;
18502 struct die_info
*scale_die
18503 = follow_die_ref (die
, attr
, &scale_cu
);
18505 if (scale_die
->tag
!= DW_TAG_constant
)
18508 gdb_mpz
num (1), denom (1);
18509 get_dwarf2_rational_constant (scale_die
, cu
, &num
, &denom
);
18510 return mpz_sgn (num
.val
) == 0 && mpz_sgn (denom
.val
) == 0;
18513 /* Initialise and return a floating point type of size BITS suitable for
18514 use as a component of a complex number. The NAME_HINT is passed through
18515 when initialising the floating point type and is the name of the complex
18518 As DWARF doesn't currently provide an explicit name for the components
18519 of a complex number, but it can be helpful to have these components
18520 named, we try to select a suitable name based on the size of the
18522 static struct type
*
18523 dwarf2_init_complex_target_type (struct dwarf2_cu
*cu
,
18524 struct objfile
*objfile
,
18525 int bits
, const char *name_hint
,
18526 enum bfd_endian byte_order
)
18528 gdbarch
*gdbarch
= objfile
->arch ();
18529 struct type
*tt
= nullptr;
18531 /* Try to find a suitable floating point builtin type of size BITS.
18532 We're going to use the name of this type as the name for the complex
18533 target type that we are about to create. */
18534 switch (cu
->language
)
18536 case language_fortran
:
18540 tt
= builtin_f_type (gdbarch
)->builtin_real
;
18543 tt
= builtin_f_type (gdbarch
)->builtin_real_s8
;
18545 case 96: /* The x86-32 ABI specifies 96-bit long double. */
18547 tt
= builtin_f_type (gdbarch
)->builtin_real_s16
;
18555 tt
= builtin_type (gdbarch
)->builtin_float
;
18558 tt
= builtin_type (gdbarch
)->builtin_double
;
18560 case 96: /* The x86-32 ABI specifies 96-bit long double. */
18562 tt
= builtin_type (gdbarch
)->builtin_long_double
;
18568 /* If the type we found doesn't match the size we were looking for, then
18569 pretend we didn't find a type at all, the complex target type we
18570 create will then be nameless. */
18571 if (tt
!= nullptr && TYPE_LENGTH (tt
) * TARGET_CHAR_BIT
!= bits
)
18574 const char *name
= (tt
== nullptr) ? nullptr : tt
->name ();
18575 return dwarf2_init_float_type (objfile
, bits
, name
, name_hint
, byte_order
);
18578 /* Find a representation of a given base type and install
18579 it in the TYPE field of the die. */
18581 static struct type
*
18582 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18584 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
18586 struct attribute
*attr
;
18587 int encoding
= 0, bits
= 0;
18591 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
18592 if (attr
!= nullptr && attr
->form_is_constant ())
18593 encoding
= attr
->constant_value (0);
18594 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
18595 if (attr
!= nullptr)
18596 bits
= attr
->constant_value (0) * TARGET_CHAR_BIT
;
18597 name
= dwarf2_name (die
, cu
);
18599 complaint (_("DW_AT_name missing from DW_TAG_base_type"));
18601 arch
= objfile
->arch ();
18602 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
18604 attr
= dwarf2_attr (die
, DW_AT_endianity
, cu
);
18605 if (attr
!= nullptr && attr
->form_is_constant ())
18607 int endianity
= attr
->constant_value (0);
18612 byte_order
= BFD_ENDIAN_BIG
;
18614 case DW_END_little
:
18615 byte_order
= BFD_ENDIAN_LITTLE
;
18618 complaint (_("DW_AT_endianity has unrecognized value %d"), endianity
);
18623 if ((encoding
== DW_ATE_signed_fixed
|| encoding
== DW_ATE_unsigned_fixed
)
18624 && cu
->language
== language_ada
18625 && has_zero_over_zero_small_attribute (die
, cu
))
18627 /* brobecker/2018-02-24: This is a fixed point type for which
18628 the scaling factor is represented as fraction whose value
18629 does not make sense (zero divided by zero), so we should
18630 normally never see these. However, there is a small category
18631 of fixed point types for which GNAT is unable to provide
18632 the scaling factor via the standard DWARF mechanisms, and
18633 for which the info is provided via the GNAT encodings instead.
18634 This is likely what this DIE is about. */
18635 encoding
= (encoding
== DW_ATE_signed_fixed
18637 : DW_ATE_unsigned
);
18640 /* With GNAT encodings, fixed-point information will be encoded in
18641 the type name. Note that this can also occur with the above
18642 zero-over-zero case, which is why this is a separate "if" rather
18643 than an "else if". */
18644 const char *gnat_encoding_suffix
= nullptr;
18645 if ((encoding
== DW_ATE_signed
|| encoding
== DW_ATE_unsigned
)
18646 && cu
->language
== language_ada
18647 && name
!= nullptr)
18649 gnat_encoding_suffix
= gnat_encoded_fixed_point_type_info (name
);
18650 if (gnat_encoding_suffix
!= nullptr)
18652 gdb_assert (startswith (gnat_encoding_suffix
,
18653 GNAT_FIXED_POINT_SUFFIX
));
18654 name
= obstack_strndup (&cu
->per_objfile
->objfile
->objfile_obstack
,
18655 name
, gnat_encoding_suffix
- name
);
18656 /* Use -1 here so that SUFFIX points at the "_" after the
18658 gnat_encoding_suffix
+= strlen (GNAT_FIXED_POINT_SUFFIX
) - 1;
18660 encoding
= (encoding
== DW_ATE_signed
18661 ? DW_ATE_signed_fixed
18662 : DW_ATE_unsigned_fixed
);
18668 case DW_ATE_address
:
18669 /* Turn DW_ATE_address into a void * pointer. */
18670 type
= init_type (objfile
, TYPE_CODE_VOID
, TARGET_CHAR_BIT
, NULL
);
18671 type
= init_pointer_type (objfile
, bits
, name
, type
);
18673 case DW_ATE_boolean
:
18674 type
= init_boolean_type (objfile
, bits
, 1, name
);
18676 case DW_ATE_complex_float
:
18677 type
= dwarf2_init_complex_target_type (cu
, objfile
, bits
/ 2, name
,
18679 if (type
->code () == TYPE_CODE_ERROR
)
18681 if (name
== nullptr)
18683 struct obstack
*obstack
18684 = &cu
->per_objfile
->objfile
->objfile_obstack
;
18685 name
= obconcat (obstack
, "_Complex ", type
->name (),
18688 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
, name
);
18691 type
= init_complex_type (name
, type
);
18693 case DW_ATE_decimal_float
:
18694 type
= init_decfloat_type (objfile
, bits
, name
);
18697 type
= dwarf2_init_float_type (objfile
, bits
, name
, name
, byte_order
);
18699 case DW_ATE_signed
:
18700 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 0, name
);
18702 case DW_ATE_unsigned
:
18703 if (cu
->language
== language_fortran
18705 && startswith (name
, "character("))
18706 type
= init_character_type (objfile
, bits
, 1, name
);
18708 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 1, name
);
18710 case DW_ATE_signed_char
:
18711 if (cu
->language
== language_ada
|| cu
->language
== language_m2
18712 || cu
->language
== language_pascal
18713 || cu
->language
== language_fortran
)
18714 type
= init_character_type (objfile
, bits
, 0, name
);
18716 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 0, name
);
18718 case DW_ATE_unsigned_char
:
18719 if (cu
->language
== language_ada
|| cu
->language
== language_m2
18720 || cu
->language
== language_pascal
18721 || cu
->language
== language_fortran
18722 || cu
->language
== language_rust
)
18723 type
= init_character_type (objfile
, bits
, 1, name
);
18725 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 1, name
);
18730 type
= builtin_type (arch
)->builtin_char16
;
18731 else if (bits
== 32)
18732 type
= builtin_type (arch
)->builtin_char32
;
18735 complaint (_("unsupported DW_ATE_UTF bit size: '%d'"),
18737 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 1, name
);
18739 return set_die_type (die
, type
, cu
);
18742 case DW_ATE_signed_fixed
:
18743 type
= init_fixed_point_type (objfile
, bits
, 0, name
);
18744 finish_fixed_point_type (type
, gnat_encoding_suffix
, die
, cu
);
18746 case DW_ATE_unsigned_fixed
:
18747 type
= init_fixed_point_type (objfile
, bits
, 1, name
);
18748 finish_fixed_point_type (type
, gnat_encoding_suffix
, die
, cu
);
18752 complaint (_("unsupported DW_AT_encoding: '%s'"),
18753 dwarf_type_encoding_name (encoding
));
18754 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
, name
);
18758 if (name
&& strcmp (name
, "char") == 0)
18759 type
->set_has_no_signedness (true);
18761 maybe_set_alignment (cu
, die
, type
);
18763 type
->set_endianity_is_not_default (gdbarch_byte_order (arch
) != byte_order
);
18765 if (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_INT
)
18767 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
18768 if (attr
!= nullptr && attr
->as_unsigned () <= 8 * TYPE_LENGTH (type
))
18770 unsigned real_bit_size
= attr
->as_unsigned ();
18771 attr
= dwarf2_attr (die
, DW_AT_data_bit_offset
, cu
);
18772 /* Only use the attributes if they make sense together. */
18773 if (attr
== nullptr
18774 || (attr
->as_unsigned () + real_bit_size
18775 <= 8 * TYPE_LENGTH (type
)))
18777 TYPE_MAIN_TYPE (type
)->type_specific
.int_stuff
.bit_size
18779 if (attr
!= nullptr)
18780 TYPE_MAIN_TYPE (type
)->type_specific
.int_stuff
.bit_offset
18781 = attr
->as_unsigned ();
18786 return set_die_type (die
, type
, cu
);
18789 /* Parse dwarf attribute if it's a block, reference or constant and put the
18790 resulting value of the attribute into struct bound_prop.
18791 Returns 1 if ATTR could be resolved into PROP, 0 otherwise. */
18794 attr_to_dynamic_prop (const struct attribute
*attr
, struct die_info
*die
,
18795 struct dwarf2_cu
*cu
, struct dynamic_prop
*prop
,
18796 struct type
*default_type
)
18798 struct dwarf2_property_baton
*baton
;
18799 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
18800 struct objfile
*objfile
= per_objfile
->objfile
;
18801 struct obstack
*obstack
= &objfile
->objfile_obstack
;
18803 gdb_assert (default_type
!= NULL
);
18805 if (attr
== NULL
|| prop
== NULL
)
18808 if (attr
->form_is_block ())
18810 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
18811 baton
->property_type
= default_type
;
18812 baton
->locexpr
.per_cu
= cu
->per_cu
;
18813 baton
->locexpr
.per_objfile
= per_objfile
;
18815 struct dwarf_block
*block
= attr
->as_block ();
18816 baton
->locexpr
.size
= block
->size
;
18817 baton
->locexpr
.data
= block
->data
;
18818 switch (attr
->name
)
18820 case DW_AT_string_length
:
18821 baton
->locexpr
.is_reference
= true;
18824 baton
->locexpr
.is_reference
= false;
18828 prop
->set_locexpr (baton
);
18829 gdb_assert (prop
->baton () != NULL
);
18831 else if (attr
->form_is_ref ())
18833 struct dwarf2_cu
*target_cu
= cu
;
18834 struct die_info
*target_die
;
18835 struct attribute
*target_attr
;
18837 target_die
= follow_die_ref (die
, attr
, &target_cu
);
18838 target_attr
= dwarf2_attr (target_die
, DW_AT_location
, target_cu
);
18839 if (target_attr
== NULL
)
18840 target_attr
= dwarf2_attr (target_die
, DW_AT_data_member_location
,
18842 if (target_attr
== NULL
)
18845 switch (target_attr
->name
)
18847 case DW_AT_location
:
18848 if (target_attr
->form_is_section_offset ())
18850 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
18851 baton
->property_type
= die_type (target_die
, target_cu
);
18852 fill_in_loclist_baton (cu
, &baton
->loclist
, target_attr
);
18853 prop
->set_loclist (baton
);
18854 gdb_assert (prop
->baton () != NULL
);
18856 else if (target_attr
->form_is_block ())
18858 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
18859 baton
->property_type
= die_type (target_die
, target_cu
);
18860 baton
->locexpr
.per_cu
= cu
->per_cu
;
18861 baton
->locexpr
.per_objfile
= per_objfile
;
18862 struct dwarf_block
*block
= target_attr
->as_block ();
18863 baton
->locexpr
.size
= block
->size
;
18864 baton
->locexpr
.data
= block
->data
;
18865 baton
->locexpr
.is_reference
= true;
18866 prop
->set_locexpr (baton
);
18867 gdb_assert (prop
->baton () != NULL
);
18871 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
18872 "dynamic property");
18876 case DW_AT_data_member_location
:
18880 if (!handle_data_member_location (target_die
, target_cu
,
18884 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
18885 baton
->property_type
= read_type_die (target_die
->parent
,
18887 baton
->offset_info
.offset
= offset
;
18888 baton
->offset_info
.type
= die_type (target_die
, target_cu
);
18889 prop
->set_addr_offset (baton
);
18894 else if (attr
->form_is_constant ())
18895 prop
->set_const_val (attr
->constant_value (0));
18898 dwarf2_invalid_attrib_class_complaint (dwarf_form_name (attr
->form
),
18899 dwarf2_name (die
, cu
));
18909 dwarf2_per_objfile::int_type (int size_in_bytes
, bool unsigned_p
) const
18911 struct type
*int_type
;
18913 /* Helper macro to examine the various builtin types. */
18914 #define TRY_TYPE(F) \
18915 int_type = (unsigned_p \
18916 ? objfile_type (objfile)->builtin_unsigned_ ## F \
18917 : objfile_type (objfile)->builtin_ ## F); \
18918 if (int_type != NULL && TYPE_LENGTH (int_type) == size_in_bytes) \
18925 TRY_TYPE (long_long
);
18929 gdb_assert_not_reached ("unable to find suitable integer type");
18935 dwarf2_cu::addr_sized_int_type (bool unsigned_p
) const
18937 int addr_size
= this->per_cu
->addr_size ();
18938 return this->per_objfile
->int_type (addr_size
, unsigned_p
);
18941 /* Read the DW_AT_type attribute for a sub-range. If this attribute is not
18942 present (which is valid) then compute the default type based on the
18943 compilation units address size. */
18945 static struct type
*
18946 read_subrange_index_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18948 struct type
*index_type
= die_type (die
, cu
);
18950 /* Dwarf-2 specifications explicitly allows to create subrange types
18951 without specifying a base type.
18952 In that case, the base type must be set to the type of
18953 the lower bound, upper bound or count, in that order, if any of these
18954 three attributes references an object that has a type.
18955 If no base type is found, the Dwarf-2 specifications say that
18956 a signed integer type of size equal to the size of an address should
18958 For the following C code: `extern char gdb_int [];'
18959 GCC produces an empty range DIE.
18960 FIXME: muller/2010-05-28: Possible references to object for low bound,
18961 high bound or count are not yet handled by this code. */
18962 if (index_type
->code () == TYPE_CODE_VOID
)
18963 index_type
= cu
->addr_sized_int_type (false);
18968 /* Read the given DW_AT_subrange DIE. */
18970 static struct type
*
18971 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18973 struct type
*base_type
, *orig_base_type
;
18974 struct type
*range_type
;
18975 struct attribute
*attr
;
18976 struct dynamic_prop low
, high
;
18977 int low_default_is_valid
;
18978 int high_bound_is_count
= 0;
18980 ULONGEST negative_mask
;
18982 orig_base_type
= read_subrange_index_type (die
, cu
);
18984 /* If ORIG_BASE_TYPE is a typedef, it will not be TYPE_UNSIGNED,
18985 whereas the real type might be. So, we use ORIG_BASE_TYPE when
18986 creating the range type, but we use the result of check_typedef
18987 when examining properties of the type. */
18988 base_type
= check_typedef (orig_base_type
);
18990 /* The die_type call above may have already set the type for this DIE. */
18991 range_type
= get_die_type (die
, cu
);
18995 high
.set_const_val (0);
18997 /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
18998 omitting DW_AT_lower_bound. */
18999 switch (cu
->language
)
19002 case language_cplus
:
19003 low
.set_const_val (0);
19004 low_default_is_valid
= 1;
19006 case language_fortran
:
19007 low
.set_const_val (1);
19008 low_default_is_valid
= 1;
19011 case language_objc
:
19012 case language_rust
:
19013 low
.set_const_val (0);
19014 low_default_is_valid
= (cu
->header
.version
>= 4);
19018 case language_pascal
:
19019 low
.set_const_val (1);
19020 low_default_is_valid
= (cu
->header
.version
>= 4);
19023 low
.set_const_val (0);
19024 low_default_is_valid
= 0;
19028 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
19029 if (attr
!= nullptr)
19030 attr_to_dynamic_prop (attr
, die
, cu
, &low
, base_type
);
19031 else if (!low_default_is_valid
)
19032 complaint (_("Missing DW_AT_lower_bound "
19033 "- DIE at %s [in module %s]"),
19034 sect_offset_str (die
->sect_off
),
19035 objfile_name (cu
->per_objfile
->objfile
));
19037 struct attribute
*attr_ub
, *attr_count
;
19038 attr
= attr_ub
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
19039 if (!attr_to_dynamic_prop (attr
, die
, cu
, &high
, base_type
))
19041 attr
= attr_count
= dwarf2_attr (die
, DW_AT_count
, cu
);
19042 if (attr_to_dynamic_prop (attr
, die
, cu
, &high
, base_type
))
19044 /* If bounds are constant do the final calculation here. */
19045 if (low
.kind () == PROP_CONST
&& high
.kind () == PROP_CONST
)
19046 high
.set_const_val (low
.const_val () + high
.const_val () - 1);
19048 high_bound_is_count
= 1;
19052 if (attr_ub
!= NULL
)
19053 complaint (_("Unresolved DW_AT_upper_bound "
19054 "- DIE at %s [in module %s]"),
19055 sect_offset_str (die
->sect_off
),
19056 objfile_name (cu
->per_objfile
->objfile
));
19057 if (attr_count
!= NULL
)
19058 complaint (_("Unresolved DW_AT_count "
19059 "- DIE at %s [in module %s]"),
19060 sect_offset_str (die
->sect_off
),
19061 objfile_name (cu
->per_objfile
->objfile
));
19066 struct attribute
*bias_attr
= dwarf2_attr (die
, DW_AT_GNU_bias
, cu
);
19067 if (bias_attr
!= nullptr && bias_attr
->form_is_constant ())
19068 bias
= bias_attr
->constant_value (0);
19070 /* Normally, the DWARF producers are expected to use a signed
19071 constant form (Eg. DW_FORM_sdata) to express negative bounds.
19072 But this is unfortunately not always the case, as witnessed
19073 with GCC, for instance, where the ambiguous DW_FORM_dataN form
19074 is used instead. To work around that ambiguity, we treat
19075 the bounds as signed, and thus sign-extend their values, when
19076 the base type is signed. */
19078 -((ULONGEST
) 1 << (TYPE_LENGTH (base_type
) * TARGET_CHAR_BIT
- 1));
19079 if (low
.kind () == PROP_CONST
19080 && !base_type
->is_unsigned () && (low
.const_val () & negative_mask
))
19081 low
.set_const_val (low
.const_val () | negative_mask
);
19082 if (high
.kind () == PROP_CONST
19083 && !base_type
->is_unsigned () && (high
.const_val () & negative_mask
))
19084 high
.set_const_val (high
.const_val () | negative_mask
);
19086 /* Check for bit and byte strides. */
19087 struct dynamic_prop byte_stride_prop
;
19088 attribute
*attr_byte_stride
= dwarf2_attr (die
, DW_AT_byte_stride
, cu
);
19089 if (attr_byte_stride
!= nullptr)
19091 struct type
*prop_type
= cu
->addr_sized_int_type (false);
19092 attr_to_dynamic_prop (attr_byte_stride
, die
, cu
, &byte_stride_prop
,
19096 struct dynamic_prop bit_stride_prop
;
19097 attribute
*attr_bit_stride
= dwarf2_attr (die
, DW_AT_bit_stride
, cu
);
19098 if (attr_bit_stride
!= nullptr)
19100 /* It only makes sense to have either a bit or byte stride. */
19101 if (attr_byte_stride
!= nullptr)
19103 complaint (_("Found DW_AT_bit_stride and DW_AT_byte_stride "
19104 "- DIE at %s [in module %s]"),
19105 sect_offset_str (die
->sect_off
),
19106 objfile_name (cu
->per_objfile
->objfile
));
19107 attr_bit_stride
= nullptr;
19111 struct type
*prop_type
= cu
->addr_sized_int_type (false);
19112 attr_to_dynamic_prop (attr_bit_stride
, die
, cu
, &bit_stride_prop
,
19117 if (attr_byte_stride
!= nullptr
19118 || attr_bit_stride
!= nullptr)
19120 bool byte_stride_p
= (attr_byte_stride
!= nullptr);
19121 struct dynamic_prop
*stride
19122 = byte_stride_p
? &byte_stride_prop
: &bit_stride_prop
;
19125 = create_range_type_with_stride (NULL
, orig_base_type
, &low
,
19126 &high
, bias
, stride
, byte_stride_p
);
19129 range_type
= create_range_type (NULL
, orig_base_type
, &low
, &high
, bias
);
19131 if (high_bound_is_count
)
19132 range_type
->bounds ()->flag_upper_bound_is_count
= 1;
19134 /* Ada expects an empty array on no boundary attributes. */
19135 if (attr
== NULL
&& cu
->language
!= language_ada
)
19136 range_type
->bounds ()->high
.set_undefined ();
19138 name
= dwarf2_name (die
, cu
);
19140 range_type
->set_name (name
);
19142 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
19143 if (attr
!= nullptr)
19144 TYPE_LENGTH (range_type
) = attr
->constant_value (0);
19146 maybe_set_alignment (cu
, die
, range_type
);
19148 set_die_type (die
, range_type
, cu
);
19150 /* set_die_type should be already done. */
19151 set_descriptive_type (range_type
, die
, cu
);
19156 static struct type
*
19157 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
19161 type
= init_type (cu
->per_objfile
->objfile
, TYPE_CODE_VOID
, 0, NULL
);
19162 type
->set_name (dwarf2_name (die
, cu
));
19164 /* In Ada, an unspecified type is typically used when the description
19165 of the type is deferred to a different unit. When encountering
19166 such a type, we treat it as a stub, and try to resolve it later on,
19168 if (cu
->language
== language_ada
)
19169 type
->set_is_stub (true);
19171 return set_die_type (die
, type
, cu
);
19174 /* Read a single die and all its descendents. Set the die's sibling
19175 field to NULL; set other fields in the die correctly, and set all
19176 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
19177 location of the info_ptr after reading all of those dies. PARENT
19178 is the parent of the die in question. */
19180 static struct die_info
*
19181 read_die_and_children (const struct die_reader_specs
*reader
,
19182 const gdb_byte
*info_ptr
,
19183 const gdb_byte
**new_info_ptr
,
19184 struct die_info
*parent
)
19186 struct die_info
*die
;
19187 const gdb_byte
*cur_ptr
;
19189 cur_ptr
= read_full_die_1 (reader
, &die
, info_ptr
, 0);
19192 *new_info_ptr
= cur_ptr
;
19195 store_in_ref_table (die
, reader
->cu
);
19197 if (die
->has_children
)
19198 die
->child
= read_die_and_siblings_1 (reader
, cur_ptr
, new_info_ptr
, die
);
19202 *new_info_ptr
= cur_ptr
;
19205 die
->sibling
= NULL
;
19206 die
->parent
= parent
;
19210 /* Read a die, all of its descendents, and all of its siblings; set
19211 all of the fields of all of the dies correctly. Arguments are as
19212 in read_die_and_children. */
19214 static struct die_info
*
19215 read_die_and_siblings_1 (const struct die_reader_specs
*reader
,
19216 const gdb_byte
*info_ptr
,
19217 const gdb_byte
**new_info_ptr
,
19218 struct die_info
*parent
)
19220 struct die_info
*first_die
, *last_sibling
;
19221 const gdb_byte
*cur_ptr
;
19223 cur_ptr
= info_ptr
;
19224 first_die
= last_sibling
= NULL
;
19228 struct die_info
*die
19229 = read_die_and_children (reader
, cur_ptr
, &cur_ptr
, parent
);
19233 *new_info_ptr
= cur_ptr
;
19240 last_sibling
->sibling
= die
;
19242 last_sibling
= die
;
19246 /* Read a die, all of its descendents, and all of its siblings; set
19247 all of the fields of all of the dies correctly. Arguments are as
19248 in read_die_and_children.
19249 This the main entry point for reading a DIE and all its children. */
19251 static struct die_info
*
19252 read_die_and_siblings (const struct die_reader_specs
*reader
,
19253 const gdb_byte
*info_ptr
,
19254 const gdb_byte
**new_info_ptr
,
19255 struct die_info
*parent
)
19257 struct die_info
*die
= read_die_and_siblings_1 (reader
, info_ptr
,
19258 new_info_ptr
, parent
);
19260 if (dwarf_die_debug
)
19262 fprintf_unfiltered (gdb_stdlog
,
19263 "Read die from %s@0x%x of %s:\n",
19264 reader
->die_section
->get_name (),
19265 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
19266 bfd_get_filename (reader
->abfd
));
19267 dump_die (die
, dwarf_die_debug
);
19273 /* Read a die and all its attributes, leave space for NUM_EXTRA_ATTRS
19275 The caller is responsible for filling in the extra attributes
19276 and updating (*DIEP)->num_attrs.
19277 Set DIEP to point to a newly allocated die with its information,
19278 except for its child, sibling, and parent fields. */
19280 static const gdb_byte
*
19281 read_full_die_1 (const struct die_reader_specs
*reader
,
19282 struct die_info
**diep
, const gdb_byte
*info_ptr
,
19283 int num_extra_attrs
)
19285 unsigned int abbrev_number
, bytes_read
, i
;
19286 const struct abbrev_info
*abbrev
;
19287 struct die_info
*die
;
19288 struct dwarf2_cu
*cu
= reader
->cu
;
19289 bfd
*abfd
= reader
->abfd
;
19291 sect_offset sect_off
= (sect_offset
) (info_ptr
- reader
->buffer
);
19292 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
19293 info_ptr
+= bytes_read
;
19294 if (!abbrev_number
)
19300 abbrev
= reader
->abbrev_table
->lookup_abbrev (abbrev_number
);
19302 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
19304 bfd_get_filename (abfd
));
19306 die
= dwarf_alloc_die (cu
, abbrev
->num_attrs
+ num_extra_attrs
);
19307 die
->sect_off
= sect_off
;
19308 die
->tag
= abbrev
->tag
;
19309 die
->abbrev
= abbrev_number
;
19310 die
->has_children
= abbrev
->has_children
;
19312 /* Make the result usable.
19313 The caller needs to update num_attrs after adding the extra
19315 die
->num_attrs
= abbrev
->num_attrs
;
19317 bool any_need_reprocess
= false;
19318 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
19320 info_ptr
= read_attribute (reader
, &die
->attrs
[i
], &abbrev
->attrs
[i
],
19322 if (die
->attrs
[i
].requires_reprocessing_p ())
19323 any_need_reprocess
= true;
19326 struct attribute
*attr
= die
->attr (DW_AT_str_offsets_base
);
19327 if (attr
!= nullptr && attr
->form_is_unsigned ())
19328 cu
->str_offsets_base
= attr
->as_unsigned ();
19330 attr
= die
->attr (DW_AT_loclists_base
);
19331 if (attr
!= nullptr)
19332 cu
->loclist_base
= attr
->as_unsigned ();
19334 auto maybe_addr_base
= die
->addr_base ();
19335 if (maybe_addr_base
.has_value ())
19336 cu
->addr_base
= *maybe_addr_base
;
19338 attr
= die
->attr (DW_AT_rnglists_base
);
19339 if (attr
!= nullptr)
19340 cu
->rnglists_base
= attr
->as_unsigned ();
19342 if (any_need_reprocess
)
19344 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
19346 if (die
->attrs
[i
].requires_reprocessing_p ())
19347 read_attribute_reprocess (reader
, &die
->attrs
[i
], die
->tag
);
19354 /* Read a die and all its attributes.
19355 Set DIEP to point to a newly allocated die with its information,
19356 except for its child, sibling, and parent fields. */
19358 static const gdb_byte
*
19359 read_full_die (const struct die_reader_specs
*reader
,
19360 struct die_info
**diep
, const gdb_byte
*info_ptr
)
19362 const gdb_byte
*result
;
19364 result
= read_full_die_1 (reader
, diep
, info_ptr
, 0);
19366 if (dwarf_die_debug
)
19368 fprintf_unfiltered (gdb_stdlog
,
19369 "Read die from %s@0x%x of %s:\n",
19370 reader
->die_section
->get_name (),
19371 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
19372 bfd_get_filename (reader
->abfd
));
19373 dump_die (*diep
, dwarf_die_debug
);
19380 /* Returns nonzero if TAG represents a type that we might generate a partial
19384 is_type_tag_for_partial (int tag
, enum language lang
)
19389 /* Some types that would be reasonable to generate partial symbols for,
19390 that we don't at present. Note that normally this does not
19391 matter, mainly because C compilers don't give names to these
19392 types, but instead emit DW_TAG_typedef. */
19393 case DW_TAG_file_type
:
19394 case DW_TAG_ptr_to_member_type
:
19395 case DW_TAG_set_type
:
19396 case DW_TAG_string_type
:
19397 case DW_TAG_subroutine_type
:
19400 /* GNAT may emit an array with a name, but no typedef, so we
19401 need to make a symbol in this case. */
19402 case DW_TAG_array_type
:
19403 return lang
== language_ada
;
19405 case DW_TAG_base_type
:
19406 case DW_TAG_class_type
:
19407 case DW_TAG_interface_type
:
19408 case DW_TAG_enumeration_type
:
19409 case DW_TAG_structure_type
:
19410 case DW_TAG_subrange_type
:
19411 case DW_TAG_typedef
:
19412 case DW_TAG_union_type
:
19419 /* Load all DIEs that are interesting for partial symbols into memory. */
19421 static struct partial_die_info
*
19422 load_partial_dies (const struct die_reader_specs
*reader
,
19423 const gdb_byte
*info_ptr
, int building_psymtab
)
19425 struct dwarf2_cu
*cu
= reader
->cu
;
19426 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
19427 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
19428 unsigned int bytes_read
;
19429 unsigned int load_all
= 0;
19430 int nesting_level
= 1;
19435 gdb_assert (cu
->per_cu
!= NULL
);
19436 if (cu
->per_cu
->load_all_dies
)
19440 = htab_create_alloc_ex (cu
->header
.length
/ 12,
19444 &cu
->comp_unit_obstack
,
19445 hashtab_obstack_allocate
,
19446 dummy_obstack_deallocate
);
19450 const abbrev_info
*abbrev
= peek_die_abbrev (*reader
, info_ptr
,
19453 /* A NULL abbrev means the end of a series of children. */
19454 if (abbrev
== NULL
)
19456 if (--nesting_level
== 0)
19459 info_ptr
+= bytes_read
;
19460 last_die
= parent_die
;
19461 parent_die
= parent_die
->die_parent
;
19465 /* Check for template arguments. We never save these; if
19466 they're seen, we just mark the parent, and go on our way. */
19467 if (parent_die
!= NULL
19468 && cu
->language
== language_cplus
19469 && (abbrev
->tag
== DW_TAG_template_type_param
19470 || abbrev
->tag
== DW_TAG_template_value_param
))
19472 parent_die
->has_template_arguments
= 1;
19476 /* We don't need a partial DIE for the template argument. */
19477 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
19482 /* We only recurse into c++ subprograms looking for template arguments.
19483 Skip their other children. */
19485 && cu
->language
== language_cplus
19486 && parent_die
!= NULL
19487 && parent_die
->tag
== DW_TAG_subprogram
19488 && abbrev
->tag
!= DW_TAG_inlined_subroutine
)
19490 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
19494 /* Check whether this DIE is interesting enough to save. Normally
19495 we would not be interested in members here, but there may be
19496 later variables referencing them via DW_AT_specification (for
19497 static members). */
19499 && !is_type_tag_for_partial (abbrev
->tag
, cu
->language
)
19500 && abbrev
->tag
!= DW_TAG_constant
19501 && abbrev
->tag
!= DW_TAG_enumerator
19502 && abbrev
->tag
!= DW_TAG_subprogram
19503 && abbrev
->tag
!= DW_TAG_inlined_subroutine
19504 && abbrev
->tag
!= DW_TAG_lexical_block
19505 && abbrev
->tag
!= DW_TAG_variable
19506 && abbrev
->tag
!= DW_TAG_namespace
19507 && abbrev
->tag
!= DW_TAG_module
19508 && abbrev
->tag
!= DW_TAG_member
19509 && abbrev
->tag
!= DW_TAG_imported_unit
19510 && abbrev
->tag
!= DW_TAG_imported_declaration
)
19512 /* Otherwise we skip to the next sibling, if any. */
19513 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
19517 struct partial_die_info
pdi ((sect_offset
) (info_ptr
- reader
->buffer
),
19520 info_ptr
= pdi
.read (reader
, *abbrev
, info_ptr
+ bytes_read
);
19522 /* This two-pass algorithm for processing partial symbols has a
19523 high cost in cache pressure. Thus, handle some simple cases
19524 here which cover the majority of C partial symbols. DIEs
19525 which neither have specification tags in them, nor could have
19526 specification tags elsewhere pointing at them, can simply be
19527 processed and discarded.
19529 This segment is also optional; scan_partial_symbols and
19530 add_partial_symbol will handle these DIEs if we chain
19531 them in normally. When compilers which do not emit large
19532 quantities of duplicate debug information are more common,
19533 this code can probably be removed. */
19535 /* Any complete simple types at the top level (pretty much all
19536 of them, for a language without namespaces), can be processed
19538 if (parent_die
== NULL
19539 && pdi
.has_specification
== 0
19540 && pdi
.is_declaration
== 0
19541 && ((pdi
.tag
== DW_TAG_typedef
&& !pdi
.has_children
)
19542 || pdi
.tag
== DW_TAG_base_type
19543 || pdi
.tag
== DW_TAG_array_type
19544 || pdi
.tag
== DW_TAG_subrange_type
))
19546 if (building_psymtab
&& pdi
.raw_name
!= NULL
)
19547 add_partial_symbol (&pdi
, cu
);
19549 info_ptr
= locate_pdi_sibling (reader
, &pdi
, info_ptr
);
19553 /* The exception for DW_TAG_typedef with has_children above is
19554 a workaround of GCC PR debug/47510. In the case of this complaint
19555 type_name_or_error will error on such types later.
19557 GDB skipped children of DW_TAG_typedef by the shortcut above and then
19558 it could not find the child DIEs referenced later, this is checked
19559 above. In correct DWARF DW_TAG_typedef should have no children. */
19561 if (pdi
.tag
== DW_TAG_typedef
&& pdi
.has_children
)
19562 complaint (_("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
19563 "- DIE at %s [in module %s]"),
19564 sect_offset_str (pdi
.sect_off
), objfile_name (objfile
));
19566 /* If we're at the second level, and we're an enumerator, and
19567 our parent has no specification (meaning possibly lives in a
19568 namespace elsewhere), then we can add the partial symbol now
19569 instead of queueing it. */
19570 if (pdi
.tag
== DW_TAG_enumerator
19571 && parent_die
!= NULL
19572 && parent_die
->die_parent
== NULL
19573 && parent_die
->tag
== DW_TAG_enumeration_type
19574 && parent_die
->has_specification
== 0)
19576 if (pdi
.raw_name
== NULL
)
19577 complaint (_("malformed enumerator DIE ignored"));
19578 else if (building_psymtab
)
19579 add_partial_symbol (&pdi
, cu
);
19581 info_ptr
= locate_pdi_sibling (reader
, &pdi
, info_ptr
);
19585 struct partial_die_info
*part_die
19586 = new (&cu
->comp_unit_obstack
) partial_die_info (pdi
);
19588 /* We'll save this DIE so link it in. */
19589 part_die
->die_parent
= parent_die
;
19590 part_die
->die_sibling
= NULL
;
19591 part_die
->die_child
= NULL
;
19593 if (last_die
&& last_die
== parent_die
)
19594 last_die
->die_child
= part_die
;
19596 last_die
->die_sibling
= part_die
;
19598 last_die
= part_die
;
19600 if (first_die
== NULL
)
19601 first_die
= part_die
;
19603 /* Maybe add the DIE to the hash table. Not all DIEs that we
19604 find interesting need to be in the hash table, because we
19605 also have the parent/sibling/child chains; only those that we
19606 might refer to by offset later during partial symbol reading.
19608 For now this means things that might have be the target of a
19609 DW_AT_specification, DW_AT_abstract_origin, or
19610 DW_AT_extension. DW_AT_extension will refer only to
19611 namespaces; DW_AT_abstract_origin refers to functions (and
19612 many things under the function DIE, but we do not recurse
19613 into function DIEs during partial symbol reading) and
19614 possibly variables as well; DW_AT_specification refers to
19615 declarations. Declarations ought to have the DW_AT_declaration
19616 flag. It happens that GCC forgets to put it in sometimes, but
19617 only for functions, not for types.
19619 Adding more things than necessary to the hash table is harmless
19620 except for the performance cost. Adding too few will result in
19621 wasted time in find_partial_die, when we reread the compilation
19622 unit with load_all_dies set. */
19625 || abbrev
->tag
== DW_TAG_constant
19626 || abbrev
->tag
== DW_TAG_subprogram
19627 || abbrev
->tag
== DW_TAG_variable
19628 || abbrev
->tag
== DW_TAG_namespace
19629 || part_die
->is_declaration
)
19633 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
19634 to_underlying (part_die
->sect_off
),
19639 /* For some DIEs we want to follow their children (if any). For C
19640 we have no reason to follow the children of structures; for other
19641 languages we have to, so that we can get at method physnames
19642 to infer fully qualified class names, for DW_AT_specification,
19643 and for C++ template arguments. For C++, we also look one level
19644 inside functions to find template arguments (if the name of the
19645 function does not already contain the template arguments).
19647 For Ada and Fortran, we need to scan the children of subprograms
19648 and lexical blocks as well because these languages allow the
19649 definition of nested entities that could be interesting for the
19650 debugger, such as nested subprograms for instance. */
19651 if (last_die
->has_children
19653 || last_die
->tag
== DW_TAG_namespace
19654 || last_die
->tag
== DW_TAG_module
19655 || last_die
->tag
== DW_TAG_enumeration_type
19656 || (cu
->language
== language_cplus
19657 && last_die
->tag
== DW_TAG_subprogram
19658 && (last_die
->raw_name
== NULL
19659 || strchr (last_die
->raw_name
, '<') == NULL
))
19660 || (cu
->language
!= language_c
19661 && (last_die
->tag
== DW_TAG_class_type
19662 || last_die
->tag
== DW_TAG_interface_type
19663 || last_die
->tag
== DW_TAG_structure_type
19664 || last_die
->tag
== DW_TAG_union_type
))
19665 || ((cu
->language
== language_ada
19666 || cu
->language
== language_fortran
)
19667 && (last_die
->tag
== DW_TAG_subprogram
19668 || last_die
->tag
== DW_TAG_lexical_block
))))
19671 parent_die
= last_die
;
19675 /* Otherwise we skip to the next sibling, if any. */
19676 info_ptr
= locate_pdi_sibling (reader
, last_die
, info_ptr
);
19678 /* Back to the top, do it again. */
19682 partial_die_info::partial_die_info (sect_offset sect_off_
,
19683 const struct abbrev_info
*abbrev
)
19684 : partial_die_info (sect_off_
, abbrev
->tag
, abbrev
->has_children
)
19688 /* See class definition. */
19691 partial_die_info::name (dwarf2_cu
*cu
)
19693 if (!canonical_name
&& raw_name
!= nullptr)
19695 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
19696 raw_name
= dwarf2_canonicalize_name (raw_name
, cu
, objfile
);
19697 canonical_name
= 1;
19703 /* Read a minimal amount of information into the minimal die structure.
19704 INFO_PTR should point just after the initial uleb128 of a DIE. */
19707 partial_die_info::read (const struct die_reader_specs
*reader
,
19708 const struct abbrev_info
&abbrev
, const gdb_byte
*info_ptr
)
19710 struct dwarf2_cu
*cu
= reader
->cu
;
19711 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
19713 int has_low_pc_attr
= 0;
19714 int has_high_pc_attr
= 0;
19715 int high_pc_relative
= 0;
19717 for (i
= 0; i
< abbrev
.num_attrs
; ++i
)
19720 info_ptr
= read_attribute (reader
, &attr
, &abbrev
.attrs
[i
], info_ptr
);
19721 /* String and address offsets that need to do the reprocessing have
19722 already been read at this point, so there is no need to wait until
19723 the loop terminates to do the reprocessing. */
19724 if (attr
.requires_reprocessing_p ())
19725 read_attribute_reprocess (reader
, &attr
, tag
);
19726 /* Store the data if it is of an attribute we want to keep in a
19727 partial symbol table. */
19733 case DW_TAG_compile_unit
:
19734 case DW_TAG_partial_unit
:
19735 case DW_TAG_type_unit
:
19736 /* Compilation units have a DW_AT_name that is a filename, not
19737 a source language identifier. */
19738 case DW_TAG_enumeration_type
:
19739 case DW_TAG_enumerator
:
19740 /* These tags always have simple identifiers already; no need
19741 to canonicalize them. */
19742 canonical_name
= 1;
19743 raw_name
= attr
.as_string ();
19746 canonical_name
= 0;
19747 raw_name
= attr
.as_string ();
19751 case DW_AT_linkage_name
:
19752 case DW_AT_MIPS_linkage_name
:
19753 /* Note that both forms of linkage name might appear. We
19754 assume they will be the same, and we only store the last
19756 linkage_name
= attr
.as_string ();
19759 has_low_pc_attr
= 1;
19760 lowpc
= attr
.as_address ();
19762 case DW_AT_high_pc
:
19763 has_high_pc_attr
= 1;
19764 highpc
= attr
.as_address ();
19765 if (cu
->header
.version
>= 4 && attr
.form_is_constant ())
19766 high_pc_relative
= 1;
19768 case DW_AT_location
:
19769 /* Support the .debug_loc offsets. */
19770 if (attr
.form_is_block ())
19772 d
.locdesc
= attr
.as_block ();
19774 else if (attr
.form_is_section_offset ())
19776 dwarf2_complex_location_expr_complaint ();
19780 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
19781 "partial symbol information");
19784 case DW_AT_external
:
19785 is_external
= attr
.as_boolean ();
19787 case DW_AT_declaration
:
19788 is_declaration
= attr
.as_boolean ();
19793 case DW_AT_abstract_origin
:
19794 case DW_AT_specification
:
19795 case DW_AT_extension
:
19796 has_specification
= 1;
19797 spec_offset
= attr
.get_ref_die_offset ();
19798 spec_is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
19799 || cu
->per_cu
->is_dwz
);
19801 case DW_AT_sibling
:
19802 /* Ignore absolute siblings, they might point outside of
19803 the current compile unit. */
19804 if (attr
.form
== DW_FORM_ref_addr
)
19805 complaint (_("ignoring absolute DW_AT_sibling"));
19808 const gdb_byte
*buffer
= reader
->buffer
;
19809 sect_offset off
= attr
.get_ref_die_offset ();
19810 const gdb_byte
*sibling_ptr
= buffer
+ to_underlying (off
);
19812 if (sibling_ptr
< info_ptr
)
19813 complaint (_("DW_AT_sibling points backwards"));
19814 else if (sibling_ptr
> reader
->buffer_end
)
19815 reader
->die_section
->overflow_complaint ();
19817 sibling
= sibling_ptr
;
19820 case DW_AT_byte_size
:
19823 case DW_AT_const_value
:
19824 has_const_value
= 1;
19826 case DW_AT_calling_convention
:
19827 /* DWARF doesn't provide a way to identify a program's source-level
19828 entry point. DW_AT_calling_convention attributes are only meant
19829 to describe functions' calling conventions.
19831 However, because it's a necessary piece of information in
19832 Fortran, and before DWARF 4 DW_CC_program was the only
19833 piece of debugging information whose definition refers to
19834 a 'main program' at all, several compilers marked Fortran
19835 main programs with DW_CC_program --- even when those
19836 functions use the standard calling conventions.
19838 Although DWARF now specifies a way to provide this
19839 information, we support this practice for backward
19841 if (attr
.constant_value (0) == DW_CC_program
19842 && cu
->language
== language_fortran
)
19843 main_subprogram
= 1;
19847 LONGEST value
= attr
.constant_value (-1);
19848 if (value
== DW_INL_inlined
19849 || value
== DW_INL_declared_inlined
)
19850 may_be_inlined
= 1;
19855 if (tag
== DW_TAG_imported_unit
)
19857 d
.sect_off
= attr
.get_ref_die_offset ();
19858 is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
19859 || cu
->per_cu
->is_dwz
);
19863 case DW_AT_main_subprogram
:
19864 main_subprogram
= attr
.as_boolean ();
19869 /* Offset in the .debug_ranges or .debug_rnglist section (depending
19870 on DWARF version). */
19871 ULONGEST ranges_offset
= attr
.as_unsigned ();
19873 /* See dwarf2_cu::gnu_ranges_base's doc for why we might want to add
19875 if (tag
!= DW_TAG_compile_unit
)
19876 ranges_offset
+= cu
->gnu_ranges_base
;
19878 if (dwarf2_ranges_read (ranges_offset
, &lowpc
, &highpc
, cu
,
19889 /* For Ada, if both the name and the linkage name appear, we prefer
19890 the latter. This lets "catch exception" work better, regardless
19891 of the order in which the name and linkage name were emitted.
19892 Really, though, this is just a workaround for the fact that gdb
19893 doesn't store both the name and the linkage name. */
19894 if (cu
->language
== language_ada
&& linkage_name
!= nullptr)
19895 raw_name
= linkage_name
;
19897 if (high_pc_relative
)
19900 if (has_low_pc_attr
&& has_high_pc_attr
)
19902 /* When using the GNU linker, .gnu.linkonce. sections are used to
19903 eliminate duplicate copies of functions and vtables and such.
19904 The linker will arbitrarily choose one and discard the others.
19905 The AT_*_pc values for such functions refer to local labels in
19906 these sections. If the section from that file was discarded, the
19907 labels are not in the output, so the relocs get a value of 0.
19908 If this is a discarded function, mark the pc bounds as invalid,
19909 so that GDB will ignore it. */
19910 if (lowpc
== 0 && !per_objfile
->per_bfd
->has_section_at_zero
)
19912 struct objfile
*objfile
= per_objfile
->objfile
;
19913 struct gdbarch
*gdbarch
= objfile
->arch ();
19915 complaint (_("DW_AT_low_pc %s is zero "
19916 "for DIE at %s [in module %s]"),
19917 paddress (gdbarch
, lowpc
),
19918 sect_offset_str (sect_off
),
19919 objfile_name (objfile
));
19921 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
19922 else if (lowpc
>= highpc
)
19924 struct objfile
*objfile
= per_objfile
->objfile
;
19925 struct gdbarch
*gdbarch
= objfile
->arch ();
19927 complaint (_("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
19928 "for DIE at %s [in module %s]"),
19929 paddress (gdbarch
, lowpc
),
19930 paddress (gdbarch
, highpc
),
19931 sect_offset_str (sect_off
),
19932 objfile_name (objfile
));
19941 /* Find a cached partial DIE at OFFSET in CU. */
19943 struct partial_die_info
*
19944 dwarf2_cu::find_partial_die (sect_offset sect_off
)
19946 struct partial_die_info
*lookup_die
= NULL
;
19947 struct partial_die_info
part_die (sect_off
);
19949 lookup_die
= ((struct partial_die_info
*)
19950 htab_find_with_hash (partial_dies
, &part_die
,
19951 to_underlying (sect_off
)));
19956 /* Find a partial DIE at OFFSET, which may or may not be in CU,
19957 except in the case of .debug_types DIEs which do not reference
19958 outside their CU (they do however referencing other types via
19959 DW_FORM_ref_sig8). */
19961 static const struct cu_partial_die_info
19962 find_partial_die (sect_offset sect_off
, int offset_in_dwz
, struct dwarf2_cu
*cu
)
19964 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
19965 struct objfile
*objfile
= per_objfile
->objfile
;
19966 struct partial_die_info
*pd
= NULL
;
19968 if (offset_in_dwz
== cu
->per_cu
->is_dwz
19969 && cu
->header
.offset_in_cu_p (sect_off
))
19971 pd
= cu
->find_partial_die (sect_off
);
19974 /* We missed recording what we needed.
19975 Load all dies and try again. */
19979 /* TUs don't reference other CUs/TUs (except via type signatures). */
19980 if (cu
->per_cu
->is_debug_types
)
19982 error (_("Dwarf Error: Type Unit at offset %s contains"
19983 " external reference to offset %s [in module %s].\n"),
19984 sect_offset_str (cu
->header
.sect_off
), sect_offset_str (sect_off
),
19985 bfd_get_filename (objfile
->obfd
));
19987 dwarf2_per_cu_data
*per_cu
19988 = dwarf2_find_containing_comp_unit (sect_off
, offset_in_dwz
,
19991 cu
= per_objfile
->get_cu (per_cu
);
19992 if (cu
== NULL
|| cu
->partial_dies
== NULL
)
19993 load_partial_comp_unit (per_cu
, per_objfile
, nullptr);
19995 cu
= per_objfile
->get_cu (per_cu
);
19998 pd
= cu
->find_partial_die (sect_off
);
20001 /* If we didn't find it, and not all dies have been loaded,
20002 load them all and try again. */
20004 if (pd
== NULL
&& cu
->per_cu
->load_all_dies
== 0)
20006 cu
->per_cu
->load_all_dies
= 1;
20008 /* This is nasty. When we reread the DIEs, somewhere up the call chain
20009 THIS_CU->cu may already be in use. So we can't just free it and
20010 replace its DIEs with the ones we read in. Instead, we leave those
20011 DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
20012 and clobber THIS_CU->cu->partial_dies with the hash table for the new
20014 load_partial_comp_unit (cu
->per_cu
, per_objfile
, cu
);
20016 pd
= cu
->find_partial_die (sect_off
);
20020 error (_("Dwarf Error: Cannot not find DIE at %s [from module %s]\n"),
20021 sect_offset_str (sect_off
), bfd_get_filename (objfile
->obfd
));
20025 /* See if we can figure out if the class lives in a namespace. We do
20026 this by looking for a member function; its demangled name will
20027 contain namespace info, if there is any. */
20030 guess_partial_die_structure_name (struct partial_die_info
*struct_pdi
,
20031 struct dwarf2_cu
*cu
)
20033 /* NOTE: carlton/2003-10-07: Getting the info this way changes
20034 what template types look like, because the demangler
20035 frequently doesn't give the same name as the debug info. We
20036 could fix this by only using the demangled name to get the
20037 prefix (but see comment in read_structure_type). */
20039 struct partial_die_info
*real_pdi
;
20040 struct partial_die_info
*child_pdi
;
20042 /* If this DIE (this DIE's specification, if any) has a parent, then
20043 we should not do this. We'll prepend the parent's fully qualified
20044 name when we create the partial symbol. */
20046 real_pdi
= struct_pdi
;
20047 while (real_pdi
->has_specification
)
20049 auto res
= find_partial_die (real_pdi
->spec_offset
,
20050 real_pdi
->spec_is_dwz
, cu
);
20051 real_pdi
= res
.pdi
;
20055 if (real_pdi
->die_parent
!= NULL
)
20058 for (child_pdi
= struct_pdi
->die_child
;
20060 child_pdi
= child_pdi
->die_sibling
)
20062 if (child_pdi
->tag
== DW_TAG_subprogram
20063 && child_pdi
->linkage_name
!= NULL
)
20065 gdb::unique_xmalloc_ptr
<char> actual_class_name
20066 (cu
->language_defn
->class_name_from_physname
20067 (child_pdi
->linkage_name
));
20068 if (actual_class_name
!= NULL
)
20070 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
20071 struct_pdi
->raw_name
= objfile
->intern (actual_class_name
.get ());
20072 struct_pdi
->canonical_name
= 1;
20079 /* Return true if a DIE with TAG may have the DW_AT_const_value
20083 can_have_DW_AT_const_value_p (enum dwarf_tag tag
)
20087 case DW_TAG_constant
:
20088 case DW_TAG_enumerator
:
20089 case DW_TAG_formal_parameter
:
20090 case DW_TAG_template_value_param
:
20091 case DW_TAG_variable
:
20099 partial_die_info::fixup (struct dwarf2_cu
*cu
)
20101 /* Once we've fixed up a die, there's no point in doing so again.
20102 This also avoids a memory leak if we were to call
20103 guess_partial_die_structure_name multiple times. */
20107 /* If we found a reference attribute and the DIE has no name, try
20108 to find a name in the referred to DIE. */
20110 if (raw_name
== NULL
&& has_specification
)
20112 struct partial_die_info
*spec_die
;
20114 auto res
= find_partial_die (spec_offset
, spec_is_dwz
, cu
);
20115 spec_die
= res
.pdi
;
20118 spec_die
->fixup (cu
);
20120 if (spec_die
->raw_name
)
20122 raw_name
= spec_die
->raw_name
;
20123 canonical_name
= spec_die
->canonical_name
;
20125 /* Copy DW_AT_external attribute if it is set. */
20126 if (spec_die
->is_external
)
20127 is_external
= spec_die
->is_external
;
20131 if (!has_const_value
&& has_specification
20132 && can_have_DW_AT_const_value_p (tag
))
20134 struct partial_die_info
*spec_die
;
20136 auto res
= find_partial_die (spec_offset
, spec_is_dwz
, cu
);
20137 spec_die
= res
.pdi
;
20140 spec_die
->fixup (cu
);
20142 if (spec_die
->has_const_value
)
20144 /* Copy DW_AT_const_value attribute if it is set. */
20145 has_const_value
= spec_die
->has_const_value
;
20149 /* Set default names for some unnamed DIEs. */
20151 if (raw_name
== NULL
&& tag
== DW_TAG_namespace
)
20153 raw_name
= CP_ANONYMOUS_NAMESPACE_STR
;
20154 canonical_name
= 1;
20157 /* If there is no parent die to provide a namespace, and there are
20158 children, see if we can determine the namespace from their linkage
20160 if (cu
->language
== language_cplus
20161 && !cu
->per_objfile
->per_bfd
->types
.empty ()
20162 && die_parent
== NULL
20164 && (tag
== DW_TAG_class_type
20165 || tag
== DW_TAG_structure_type
20166 || tag
== DW_TAG_union_type
))
20167 guess_partial_die_structure_name (this, cu
);
20169 /* GCC might emit a nameless struct or union that has a linkage
20170 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
20171 if (raw_name
== NULL
20172 && (tag
== DW_TAG_class_type
20173 || tag
== DW_TAG_interface_type
20174 || tag
== DW_TAG_structure_type
20175 || tag
== DW_TAG_union_type
)
20176 && linkage_name
!= NULL
)
20178 gdb::unique_xmalloc_ptr
<char> demangled
20179 (gdb_demangle (linkage_name
, DMGL_TYPES
));
20180 if (demangled
!= nullptr)
20184 /* Strip any leading namespaces/classes, keep only the base name.
20185 DW_AT_name for named DIEs does not contain the prefixes. */
20186 base
= strrchr (demangled
.get (), ':');
20187 if (base
&& base
> demangled
.get () && base
[-1] == ':')
20190 base
= demangled
.get ();
20192 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
20193 raw_name
= objfile
->intern (base
);
20194 canonical_name
= 1;
20201 /* Read the .debug_loclists or .debug_rnglists header (they are the same format)
20202 contents from the given SECTION in the HEADER.
20204 HEADER_OFFSET is the offset of the header in the section. */
20206 read_loclists_rnglists_header (struct loclists_rnglists_header
*header
,
20207 struct dwarf2_section_info
*section
,
20208 sect_offset header_offset
)
20210 unsigned int bytes_read
;
20211 bfd
*abfd
= section
->get_bfd_owner ();
20212 const gdb_byte
*info_ptr
= section
->buffer
+ to_underlying (header_offset
);
20214 header
->length
= read_initial_length (abfd
, info_ptr
, &bytes_read
);
20215 info_ptr
+= bytes_read
;
20217 header
->version
= read_2_bytes (abfd
, info_ptr
);
20220 header
->addr_size
= read_1_byte (abfd
, info_ptr
);
20223 header
->segment_collector_size
= read_1_byte (abfd
, info_ptr
);
20226 header
->offset_entry_count
= read_4_bytes (abfd
, info_ptr
);
20229 /* Return the DW_AT_loclists_base value for the CU. */
20231 lookup_loclist_base (struct dwarf2_cu
*cu
)
20233 /* For the .dwo unit, the loclist_base points to the first offset following
20234 the header. The header consists of the following entities-
20235 1. Unit Length (4 bytes for 32 bit DWARF format, and 12 bytes for the 64
20237 2. version (2 bytes)
20238 3. address size (1 byte)
20239 4. segment selector size (1 byte)
20240 5. offset entry count (4 bytes)
20241 These sizes are derived as per the DWARFv5 standard. */
20242 if (cu
->dwo_unit
!= nullptr)
20244 if (cu
->header
.initial_length_size
== 4)
20245 return LOCLIST_HEADER_SIZE32
;
20246 return LOCLIST_HEADER_SIZE64
;
20248 return cu
->loclist_base
;
20251 /* Given a DW_FORM_loclistx value LOCLIST_INDEX, fetch the offset from the
20252 array of offsets in the .debug_loclists section. */
20255 read_loclist_index (struct dwarf2_cu
*cu
, ULONGEST loclist_index
)
20257 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
20258 struct objfile
*objfile
= per_objfile
->objfile
;
20259 bfd
*abfd
= objfile
->obfd
;
20260 ULONGEST loclist_header_size
=
20261 (cu
->header
.initial_length_size
== 4 ? LOCLIST_HEADER_SIZE32
20262 : LOCLIST_HEADER_SIZE64
);
20263 ULONGEST loclist_base
= lookup_loclist_base (cu
);
20265 /* Offset in .debug_loclists of the offset for LOCLIST_INDEX. */
20266 ULONGEST start_offset
=
20267 loclist_base
+ loclist_index
* cu
->header
.offset_size
;
20269 /* Get loclists section. */
20270 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
20272 /* Read the loclists section content. */
20273 section
->read (objfile
);
20274 if (section
->buffer
== NULL
)
20275 error (_("DW_FORM_loclistx used without .debug_loclists "
20276 "section [in module %s]"), objfile_name (objfile
));
20278 /* DW_AT_loclists_base points after the .debug_loclists contribution header,
20279 so if loclist_base is smaller than the header size, we have a problem. */
20280 if (loclist_base
< loclist_header_size
)
20281 error (_("DW_AT_loclists_base is smaller than header size [in module %s]"),
20282 objfile_name (objfile
));
20284 /* Read the header of the loclists contribution. */
20285 struct loclists_rnglists_header header
;
20286 read_loclists_rnglists_header (&header
, section
,
20287 (sect_offset
) (loclist_base
- loclist_header_size
));
20289 /* Verify the loclist index is valid. */
20290 if (loclist_index
>= header
.offset_entry_count
)
20291 error (_("DW_FORM_loclistx pointing outside of "
20292 ".debug_loclists offset array [in module %s]"),
20293 objfile_name (objfile
));
20295 /* Validate that reading won't go beyond the end of the section. */
20296 if (start_offset
+ cu
->header
.offset_size
> section
->size
)
20297 error (_("Reading DW_FORM_loclistx index beyond end of"
20298 ".debug_loclists section [in module %s]"),
20299 objfile_name (objfile
));
20301 const gdb_byte
*info_ptr
= section
->buffer
+ start_offset
;
20303 if (cu
->header
.offset_size
== 4)
20304 return (sect_offset
) (bfd_get_32 (abfd
, info_ptr
) + loclist_base
);
20306 return (sect_offset
) (bfd_get_64 (abfd
, info_ptr
) + loclist_base
);
20309 /* Given a DW_FORM_rnglistx value RNGLIST_INDEX, fetch the offset from the
20310 array of offsets in the .debug_rnglists section. */
20313 read_rnglist_index (struct dwarf2_cu
*cu
, ULONGEST rnglist_index
,
20316 struct dwarf2_per_objfile
*dwarf2_per_objfile
= cu
->per_objfile
;
20317 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
20318 bfd
*abfd
= objfile
->obfd
;
20319 ULONGEST rnglist_header_size
=
20320 (cu
->header
.initial_length_size
== 4 ? RNGLIST_HEADER_SIZE32
20321 : RNGLIST_HEADER_SIZE64
);
20323 /* When reading a DW_FORM_rnglistx from a DWO, we read from the DWO's
20324 .debug_rnglists.dwo section. The rnglists base given in the skeleton
20326 ULONGEST rnglist_base
=
20327 (cu
->dwo_unit
!= nullptr) ? rnglist_header_size
: cu
->rnglists_base
;
20329 /* Offset in .debug_rnglists of the offset for RNGLIST_INDEX. */
20330 ULONGEST start_offset
=
20331 rnglist_base
+ rnglist_index
* cu
->header
.offset_size
;
20333 /* Get rnglists section. */
20334 struct dwarf2_section_info
*section
= cu_debug_rnglists_section (cu
, tag
);
20336 /* Read the rnglists section content. */
20337 section
->read (objfile
);
20338 if (section
->buffer
== nullptr)
20339 error (_("DW_FORM_rnglistx used without .debug_rnglists section "
20341 objfile_name (objfile
));
20343 /* DW_AT_rnglists_base points after the .debug_rnglists contribution header,
20344 so if rnglist_base is smaller than the header size, we have a problem. */
20345 if (rnglist_base
< rnglist_header_size
)
20346 error (_("DW_AT_rnglists_base is smaller than header size [in module %s]"),
20347 objfile_name (objfile
));
20349 /* Read the header of the rnglists contribution. */
20350 struct loclists_rnglists_header header
;
20351 read_loclists_rnglists_header (&header
, section
,
20352 (sect_offset
) (rnglist_base
- rnglist_header_size
));
20354 /* Verify the rnglist index is valid. */
20355 if (rnglist_index
>= header
.offset_entry_count
)
20356 error (_("DW_FORM_rnglistx index pointing outside of "
20357 ".debug_rnglists offset array [in module %s]"),
20358 objfile_name (objfile
));
20360 /* Validate that reading won't go beyond the end of the section. */
20361 if (start_offset
+ cu
->header
.offset_size
> section
->size
)
20362 error (_("Reading DW_FORM_rnglistx index beyond end of"
20363 ".debug_rnglists section [in module %s]"),
20364 objfile_name (objfile
));
20366 const gdb_byte
*info_ptr
= section
->buffer
+ start_offset
;
20368 if (cu
->header
.offset_size
== 4)
20369 return (sect_offset
) (read_4_bytes (abfd
, info_ptr
) + rnglist_base
);
20371 return (sect_offset
) (read_8_bytes (abfd
, info_ptr
) + rnglist_base
);
20374 /* Process the attributes that had to be skipped in the first round. These
20375 attributes are the ones that need str_offsets_base or addr_base attributes.
20376 They could not have been processed in the first round, because at the time
20377 the values of str_offsets_base or addr_base may not have been known. */
20379 read_attribute_reprocess (const struct die_reader_specs
*reader
,
20380 struct attribute
*attr
, dwarf_tag tag
)
20382 struct dwarf2_cu
*cu
= reader
->cu
;
20383 switch (attr
->form
)
20385 case DW_FORM_addrx
:
20386 case DW_FORM_GNU_addr_index
:
20387 attr
->set_address (read_addr_index (cu
,
20388 attr
->as_unsigned_reprocess ()));
20390 case DW_FORM_loclistx
:
20392 sect_offset loclists_sect_off
20393 = read_loclist_index (cu
, attr
->as_unsigned_reprocess ());
20395 attr
->set_unsigned (to_underlying (loclists_sect_off
));
20398 case DW_FORM_rnglistx
:
20400 sect_offset rnglists_sect_off
20401 = read_rnglist_index (cu
, attr
->as_unsigned_reprocess (), tag
);
20403 attr
->set_unsigned (to_underlying (rnglists_sect_off
));
20407 case DW_FORM_strx1
:
20408 case DW_FORM_strx2
:
20409 case DW_FORM_strx3
:
20410 case DW_FORM_strx4
:
20411 case DW_FORM_GNU_str_index
:
20413 unsigned int str_index
= attr
->as_unsigned_reprocess ();
20414 gdb_assert (!attr
->canonical_string_p ());
20415 if (reader
->dwo_file
!= NULL
)
20416 attr
->set_string_noncanonical (read_dwo_str_index (reader
,
20419 attr
->set_string_noncanonical (read_stub_str_index (cu
,
20424 gdb_assert_not_reached (_("Unexpected DWARF form."));
20428 /* Read an attribute value described by an attribute form. */
20430 static const gdb_byte
*
20431 read_attribute_value (const struct die_reader_specs
*reader
,
20432 struct attribute
*attr
, unsigned form
,
20433 LONGEST implicit_const
, const gdb_byte
*info_ptr
)
20435 struct dwarf2_cu
*cu
= reader
->cu
;
20436 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
20437 struct objfile
*objfile
= per_objfile
->objfile
;
20438 bfd
*abfd
= reader
->abfd
;
20439 struct comp_unit_head
*cu_header
= &cu
->header
;
20440 unsigned int bytes_read
;
20441 struct dwarf_block
*blk
;
20443 attr
->form
= (enum dwarf_form
) form
;
20446 case DW_FORM_ref_addr
:
20447 if (cu_header
->version
== 2)
20448 attr
->set_unsigned (cu_header
->read_address (abfd
, info_ptr
,
20451 attr
->set_unsigned (cu_header
->read_offset (abfd
, info_ptr
,
20453 info_ptr
+= bytes_read
;
20455 case DW_FORM_GNU_ref_alt
:
20456 attr
->set_unsigned (cu_header
->read_offset (abfd
, info_ptr
,
20458 info_ptr
+= bytes_read
;
20462 struct gdbarch
*gdbarch
= objfile
->arch ();
20463 CORE_ADDR addr
= cu_header
->read_address (abfd
, info_ptr
, &bytes_read
);
20464 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, addr
);
20465 attr
->set_address (addr
);
20466 info_ptr
+= bytes_read
;
20469 case DW_FORM_block2
:
20470 blk
= dwarf_alloc_block (cu
);
20471 blk
->size
= read_2_bytes (abfd
, info_ptr
);
20473 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
20474 info_ptr
+= blk
->size
;
20475 attr
->set_block (blk
);
20477 case DW_FORM_block4
:
20478 blk
= dwarf_alloc_block (cu
);
20479 blk
->size
= read_4_bytes (abfd
, info_ptr
);
20481 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
20482 info_ptr
+= blk
->size
;
20483 attr
->set_block (blk
);
20485 case DW_FORM_data2
:
20486 attr
->set_unsigned (read_2_bytes (abfd
, info_ptr
));
20489 case DW_FORM_data4
:
20490 attr
->set_unsigned (read_4_bytes (abfd
, info_ptr
));
20493 case DW_FORM_data8
:
20494 attr
->set_unsigned (read_8_bytes (abfd
, info_ptr
));
20497 case DW_FORM_data16
:
20498 blk
= dwarf_alloc_block (cu
);
20500 blk
->data
= read_n_bytes (abfd
, info_ptr
, 16);
20502 attr
->set_block (blk
);
20504 case DW_FORM_sec_offset
:
20505 attr
->set_unsigned (cu_header
->read_offset (abfd
, info_ptr
,
20507 info_ptr
+= bytes_read
;
20509 case DW_FORM_loclistx
:
20511 attr
->set_unsigned_reprocess (read_unsigned_leb128 (abfd
, info_ptr
,
20513 info_ptr
+= bytes_read
;
20516 case DW_FORM_string
:
20517 attr
->set_string_noncanonical (read_direct_string (abfd
, info_ptr
,
20519 info_ptr
+= bytes_read
;
20522 if (!cu
->per_cu
->is_dwz
)
20524 attr
->set_string_noncanonical
20525 (read_indirect_string (per_objfile
,
20526 abfd
, info_ptr
, cu_header
,
20528 info_ptr
+= bytes_read
;
20532 case DW_FORM_line_strp
:
20533 if (!cu
->per_cu
->is_dwz
)
20535 attr
->set_string_noncanonical
20536 (per_objfile
->read_line_string (info_ptr
, cu_header
,
20538 info_ptr
+= bytes_read
;
20542 case DW_FORM_GNU_strp_alt
:
20544 dwz_file
*dwz
= dwarf2_get_dwz_file (per_objfile
->per_bfd
, true);
20545 LONGEST str_offset
= cu_header
->read_offset (abfd
, info_ptr
,
20548 attr
->set_string_noncanonical
20549 (dwz
->read_string (objfile
, str_offset
));
20550 info_ptr
+= bytes_read
;
20553 case DW_FORM_exprloc
:
20554 case DW_FORM_block
:
20555 blk
= dwarf_alloc_block (cu
);
20556 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
20557 info_ptr
+= bytes_read
;
20558 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
20559 info_ptr
+= blk
->size
;
20560 attr
->set_block (blk
);
20562 case DW_FORM_block1
:
20563 blk
= dwarf_alloc_block (cu
);
20564 blk
->size
= read_1_byte (abfd
, info_ptr
);
20566 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
20567 info_ptr
+= blk
->size
;
20568 attr
->set_block (blk
);
20570 case DW_FORM_data1
:
20572 attr
->set_unsigned (read_1_byte (abfd
, info_ptr
));
20575 case DW_FORM_flag_present
:
20576 attr
->set_unsigned (1);
20578 case DW_FORM_sdata
:
20579 attr
->set_signed (read_signed_leb128 (abfd
, info_ptr
, &bytes_read
));
20580 info_ptr
+= bytes_read
;
20582 case DW_FORM_rnglistx
:
20584 attr
->set_unsigned_reprocess (read_unsigned_leb128 (abfd
, info_ptr
,
20586 info_ptr
+= bytes_read
;
20589 case DW_FORM_udata
:
20590 attr
->set_unsigned (read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
20591 info_ptr
+= bytes_read
;
20594 attr
->set_unsigned ((to_underlying (cu_header
->sect_off
)
20595 + read_1_byte (abfd
, info_ptr
)));
20599 attr
->set_unsigned ((to_underlying (cu_header
->sect_off
)
20600 + read_2_bytes (abfd
, info_ptr
)));
20604 attr
->set_unsigned ((to_underlying (cu_header
->sect_off
)
20605 + read_4_bytes (abfd
, info_ptr
)));
20609 attr
->set_unsigned ((to_underlying (cu_header
->sect_off
)
20610 + read_8_bytes (abfd
, info_ptr
)));
20613 case DW_FORM_ref_sig8
:
20614 attr
->set_signature (read_8_bytes (abfd
, info_ptr
));
20617 case DW_FORM_ref_udata
:
20618 attr
->set_unsigned ((to_underlying (cu_header
->sect_off
)
20619 + read_unsigned_leb128 (abfd
, info_ptr
,
20621 info_ptr
+= bytes_read
;
20623 case DW_FORM_indirect
:
20624 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
20625 info_ptr
+= bytes_read
;
20626 if (form
== DW_FORM_implicit_const
)
20628 implicit_const
= read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
20629 info_ptr
+= bytes_read
;
20631 info_ptr
= read_attribute_value (reader
, attr
, form
, implicit_const
,
20634 case DW_FORM_implicit_const
:
20635 attr
->set_signed (implicit_const
);
20637 case DW_FORM_addrx
:
20638 case DW_FORM_GNU_addr_index
:
20639 attr
->set_unsigned_reprocess (read_unsigned_leb128 (abfd
, info_ptr
,
20641 info_ptr
+= bytes_read
;
20644 case DW_FORM_strx1
:
20645 case DW_FORM_strx2
:
20646 case DW_FORM_strx3
:
20647 case DW_FORM_strx4
:
20648 case DW_FORM_GNU_str_index
:
20650 ULONGEST str_index
;
20651 if (form
== DW_FORM_strx1
)
20653 str_index
= read_1_byte (abfd
, info_ptr
);
20656 else if (form
== DW_FORM_strx2
)
20658 str_index
= read_2_bytes (abfd
, info_ptr
);
20661 else if (form
== DW_FORM_strx3
)
20663 str_index
= read_3_bytes (abfd
, info_ptr
);
20666 else if (form
== DW_FORM_strx4
)
20668 str_index
= read_4_bytes (abfd
, info_ptr
);
20673 str_index
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
20674 info_ptr
+= bytes_read
;
20676 attr
->set_unsigned_reprocess (str_index
);
20680 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
20681 dwarf_form_name (form
),
20682 bfd_get_filename (abfd
));
20686 if (cu
->per_cu
->is_dwz
&& attr
->form_is_ref ())
20687 attr
->form
= DW_FORM_GNU_ref_alt
;
20689 /* We have seen instances where the compiler tried to emit a byte
20690 size attribute of -1 which ended up being encoded as an unsigned
20691 0xffffffff. Although 0xffffffff is technically a valid size value,
20692 an object of this size seems pretty unlikely so we can relatively
20693 safely treat these cases as if the size attribute was invalid and
20694 treat them as zero by default. */
20695 if (attr
->name
== DW_AT_byte_size
20696 && form
== DW_FORM_data4
20697 && attr
->as_unsigned () >= 0xffffffff)
20700 (_("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
20701 hex_string (attr
->as_unsigned ()));
20702 attr
->set_unsigned (0);
20708 /* Read an attribute described by an abbreviated attribute. */
20710 static const gdb_byte
*
20711 read_attribute (const struct die_reader_specs
*reader
,
20712 struct attribute
*attr
, const struct attr_abbrev
*abbrev
,
20713 const gdb_byte
*info_ptr
)
20715 attr
->name
= abbrev
->name
;
20716 attr
->string_is_canonical
= 0;
20717 attr
->requires_reprocessing
= 0;
20718 return read_attribute_value (reader
, attr
, abbrev
->form
,
20719 abbrev
->implicit_const
, info_ptr
);
20722 /* Return pointer to string at .debug_str offset STR_OFFSET. */
20724 static const char *
20725 read_indirect_string_at_offset (dwarf2_per_objfile
*per_objfile
,
20726 LONGEST str_offset
)
20728 return per_objfile
->per_bfd
->str
.read_string (per_objfile
->objfile
,
20729 str_offset
, "DW_FORM_strp");
20732 /* Return pointer to string at .debug_str offset as read from BUF.
20733 BUF is assumed to be in a compilation unit described by CU_HEADER.
20734 Return *BYTES_READ_PTR count of bytes read from BUF. */
20736 static const char *
20737 read_indirect_string (dwarf2_per_objfile
*per_objfile
, bfd
*abfd
,
20738 const gdb_byte
*buf
,
20739 const struct comp_unit_head
*cu_header
,
20740 unsigned int *bytes_read_ptr
)
20742 LONGEST str_offset
= cu_header
->read_offset (abfd
, buf
, bytes_read_ptr
);
20744 return read_indirect_string_at_offset (per_objfile
, str_offset
);
20750 dwarf2_per_objfile::read_line_string (const gdb_byte
*buf
,
20751 const struct comp_unit_head
*cu_header
,
20752 unsigned int *bytes_read_ptr
)
20754 bfd
*abfd
= objfile
->obfd
;
20755 LONGEST str_offset
= cu_header
->read_offset (abfd
, buf
, bytes_read_ptr
);
20757 return per_bfd
->line_str
.read_string (objfile
, str_offset
, "DW_FORM_line_strp");
20760 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
20761 ADDR_BASE is the DW_AT_addr_base (DW_AT_GNU_addr_base) attribute or zero.
20762 ADDR_SIZE is the size of addresses from the CU header. */
20765 read_addr_index_1 (dwarf2_per_objfile
*per_objfile
, unsigned int addr_index
,
20766 gdb::optional
<ULONGEST
> addr_base
, int addr_size
)
20768 struct objfile
*objfile
= per_objfile
->objfile
;
20769 bfd
*abfd
= objfile
->obfd
;
20770 const gdb_byte
*info_ptr
;
20771 ULONGEST addr_base_or_zero
= addr_base
.has_value () ? *addr_base
: 0;
20773 per_objfile
->per_bfd
->addr
.read (objfile
);
20774 if (per_objfile
->per_bfd
->addr
.buffer
== NULL
)
20775 error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
20776 objfile_name (objfile
));
20777 if (addr_base_or_zero
+ addr_index
* addr_size
20778 >= per_objfile
->per_bfd
->addr
.size
)
20779 error (_("DW_FORM_addr_index pointing outside of "
20780 ".debug_addr section [in module %s]"),
20781 objfile_name (objfile
));
20782 info_ptr
= (per_objfile
->per_bfd
->addr
.buffer
+ addr_base_or_zero
20783 + addr_index
* addr_size
);
20784 if (addr_size
== 4)
20785 return bfd_get_32 (abfd
, info_ptr
);
20787 return bfd_get_64 (abfd
, info_ptr
);
20790 /* Given index ADDR_INDEX in .debug_addr, fetch the value. */
20793 read_addr_index (struct dwarf2_cu
*cu
, unsigned int addr_index
)
20795 return read_addr_index_1 (cu
->per_objfile
, addr_index
,
20796 cu
->addr_base
, cu
->header
.addr_size
);
20799 /* Given a pointer to an leb128 value, fetch the value from .debug_addr. */
20802 read_addr_index_from_leb128 (struct dwarf2_cu
*cu
, const gdb_byte
*info_ptr
,
20803 unsigned int *bytes_read
)
20805 bfd
*abfd
= cu
->per_objfile
->objfile
->obfd
;
20806 unsigned int addr_index
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
20808 return read_addr_index (cu
, addr_index
);
20814 dwarf2_read_addr_index (dwarf2_per_cu_data
*per_cu
,
20815 dwarf2_per_objfile
*per_objfile
,
20816 unsigned int addr_index
)
20818 struct dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
20819 gdb::optional
<ULONGEST
> addr_base
;
20822 /* We need addr_base and addr_size.
20823 If we don't have PER_CU->cu, we have to get it.
20824 Nasty, but the alternative is storing the needed info in PER_CU,
20825 which at this point doesn't seem justified: it's not clear how frequently
20826 it would get used and it would increase the size of every PER_CU.
20827 Entry points like dwarf2_per_cu_addr_size do a similar thing
20828 so we're not in uncharted territory here.
20829 Alas we need to be a bit more complicated as addr_base is contained
20832 We don't need to read the entire CU(/TU).
20833 We just need the header and top level die.
20835 IWBN to use the aging mechanism to let us lazily later discard the CU.
20836 For now we skip this optimization. */
20840 addr_base
= cu
->addr_base
;
20841 addr_size
= cu
->header
.addr_size
;
20845 cutu_reader
reader (per_cu
, per_objfile
, nullptr, nullptr, false);
20846 addr_base
= reader
.cu
->addr_base
;
20847 addr_size
= reader
.cu
->header
.addr_size
;
20850 return read_addr_index_1 (per_objfile
, addr_index
, addr_base
, addr_size
);
20853 /* Given a DW_FORM_GNU_str_index value STR_INDEX, fetch the string.
20854 STR_SECTION, STR_OFFSETS_SECTION can be from a Fission stub or a
20857 static const char *
20858 read_str_index (struct dwarf2_cu
*cu
,
20859 struct dwarf2_section_info
*str_section
,
20860 struct dwarf2_section_info
*str_offsets_section
,
20861 ULONGEST str_offsets_base
, ULONGEST str_index
)
20863 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
20864 struct objfile
*objfile
= per_objfile
->objfile
;
20865 const char *objf_name
= objfile_name (objfile
);
20866 bfd
*abfd
= objfile
->obfd
;
20867 const gdb_byte
*info_ptr
;
20868 ULONGEST str_offset
;
20869 static const char form_name
[] = "DW_FORM_GNU_str_index or DW_FORM_strx";
20871 str_section
->read (objfile
);
20872 str_offsets_section
->read (objfile
);
20873 if (str_section
->buffer
== NULL
)
20874 error (_("%s used without %s section"
20875 " in CU at offset %s [in module %s]"),
20876 form_name
, str_section
->get_name (),
20877 sect_offset_str (cu
->header
.sect_off
), objf_name
);
20878 if (str_offsets_section
->buffer
== NULL
)
20879 error (_("%s used without %s section"
20880 " in CU at offset %s [in module %s]"),
20881 form_name
, str_section
->get_name (),
20882 sect_offset_str (cu
->header
.sect_off
), objf_name
);
20883 info_ptr
= (str_offsets_section
->buffer
20885 + str_index
* cu
->header
.offset_size
);
20886 if (cu
->header
.offset_size
== 4)
20887 str_offset
= bfd_get_32 (abfd
, info_ptr
);
20889 str_offset
= bfd_get_64 (abfd
, info_ptr
);
20890 if (str_offset
>= str_section
->size
)
20891 error (_("Offset from %s pointing outside of"
20892 " .debug_str.dwo section in CU at offset %s [in module %s]"),
20893 form_name
, sect_offset_str (cu
->header
.sect_off
), objf_name
);
20894 return (const char *) (str_section
->buffer
+ str_offset
);
20897 /* Given a DW_FORM_GNU_str_index from a DWO file, fetch the string. */
20899 static const char *
20900 read_dwo_str_index (const struct die_reader_specs
*reader
, ULONGEST str_index
)
20902 ULONGEST str_offsets_base
= reader
->cu
->header
.version
>= 5
20903 ? reader
->cu
->header
.addr_size
: 0;
20904 return read_str_index (reader
->cu
,
20905 &reader
->dwo_file
->sections
.str
,
20906 &reader
->dwo_file
->sections
.str_offsets
,
20907 str_offsets_base
, str_index
);
20910 /* Given a DW_FORM_GNU_str_index from a Fission stub, fetch the string. */
20912 static const char *
20913 read_stub_str_index (struct dwarf2_cu
*cu
, ULONGEST str_index
)
20915 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
20916 const char *objf_name
= objfile_name (objfile
);
20917 static const char form_name
[] = "DW_FORM_GNU_str_index";
20918 static const char str_offsets_attr_name
[] = "DW_AT_str_offsets";
20920 if (!cu
->str_offsets_base
.has_value ())
20921 error (_("%s used in Fission stub without %s"
20922 " in CU at offset 0x%lx [in module %s]"),
20923 form_name
, str_offsets_attr_name
,
20924 (long) cu
->header
.offset_size
, objf_name
);
20926 return read_str_index (cu
,
20927 &cu
->per_objfile
->per_bfd
->str
,
20928 &cu
->per_objfile
->per_bfd
->str_offsets
,
20929 *cu
->str_offsets_base
, str_index
);
20932 /* Return the length of an LEB128 number in BUF. */
20935 leb128_size (const gdb_byte
*buf
)
20937 const gdb_byte
*begin
= buf
;
20943 if ((byte
& 128) == 0)
20944 return buf
- begin
;
20949 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
20958 cu
->language
= language_c
;
20961 case DW_LANG_C_plus_plus
:
20962 case DW_LANG_C_plus_plus_11
:
20963 case DW_LANG_C_plus_plus_14
:
20964 cu
->language
= language_cplus
;
20967 cu
->language
= language_d
;
20969 case DW_LANG_Fortran77
:
20970 case DW_LANG_Fortran90
:
20971 case DW_LANG_Fortran95
:
20972 case DW_LANG_Fortran03
:
20973 case DW_LANG_Fortran08
:
20974 cu
->language
= language_fortran
;
20977 cu
->language
= language_go
;
20979 case DW_LANG_Mips_Assembler
:
20980 cu
->language
= language_asm
;
20982 case DW_LANG_Ada83
:
20983 case DW_LANG_Ada95
:
20984 cu
->language
= language_ada
;
20986 case DW_LANG_Modula2
:
20987 cu
->language
= language_m2
;
20989 case DW_LANG_Pascal83
:
20990 cu
->language
= language_pascal
;
20993 cu
->language
= language_objc
;
20996 case DW_LANG_Rust_old
:
20997 cu
->language
= language_rust
;
20999 case DW_LANG_Cobol74
:
21000 case DW_LANG_Cobol85
:
21002 cu
->language
= language_minimal
;
21005 cu
->language_defn
= language_def (cu
->language
);
21008 /* Return the named attribute or NULL if not there. */
21010 static struct attribute
*
21011 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
21016 struct attribute
*spec
= NULL
;
21018 for (i
= 0; i
< die
->num_attrs
; ++i
)
21020 if (die
->attrs
[i
].name
== name
)
21021 return &die
->attrs
[i
];
21022 if (die
->attrs
[i
].name
== DW_AT_specification
21023 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
21024 spec
= &die
->attrs
[i
];
21030 die
= follow_die_ref (die
, spec
, &cu
);
21036 /* Return the string associated with a string-typed attribute, or NULL if it
21037 is either not found or is of an incorrect type. */
21039 static const char *
21040 dwarf2_string_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
21042 struct attribute
*attr
;
21043 const char *str
= NULL
;
21045 attr
= dwarf2_attr (die
, name
, cu
);
21049 str
= attr
->as_string ();
21050 if (str
== nullptr)
21051 complaint (_("string type expected for attribute %s for "
21052 "DIE at %s in module %s"),
21053 dwarf_attr_name (name
), sect_offset_str (die
->sect_off
),
21054 objfile_name (cu
->per_objfile
->objfile
));
21060 /* Return the dwo name or NULL if not present. If present, it is in either
21061 DW_AT_GNU_dwo_name or DW_AT_dwo_name attribute. */
21062 static const char *
21063 dwarf2_dwo_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
21065 const char *dwo_name
= dwarf2_string_attr (die
, DW_AT_GNU_dwo_name
, cu
);
21066 if (dwo_name
== nullptr)
21067 dwo_name
= dwarf2_string_attr (die
, DW_AT_dwo_name
, cu
);
21071 /* Return non-zero iff the attribute NAME is defined for the given DIE,
21072 and holds a non-zero value. This function should only be used for
21073 DW_FORM_flag or DW_FORM_flag_present attributes. */
21076 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
21078 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
21080 return attr
!= nullptr && attr
->as_boolean ();
21084 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
21086 /* A DIE is a declaration if it has a DW_AT_declaration attribute
21087 which value is non-zero. However, we have to be careful with
21088 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
21089 (via dwarf2_flag_true_p) follows this attribute. So we may
21090 end up accidently finding a declaration attribute that belongs
21091 to a different DIE referenced by the specification attribute,
21092 even though the given DIE does not have a declaration attribute. */
21093 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
21094 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
21097 /* Return the die giving the specification for DIE, if there is
21098 one. *SPEC_CU is the CU containing DIE on input, and the CU
21099 containing the return value on output. If there is no
21100 specification, but there is an abstract origin, that is
21103 static struct die_info
*
21104 die_specification (struct die_info
*die
, struct dwarf2_cu
**spec_cu
)
21106 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
,
21109 if (spec_attr
== NULL
)
21110 spec_attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, *spec_cu
);
21112 if (spec_attr
== NULL
)
21115 return follow_die_ref (die
, spec_attr
, spec_cu
);
21118 /* Stub for free_line_header to match void * callback types. */
21121 free_line_header_voidp (void *arg
)
21123 struct line_header
*lh
= (struct line_header
*) arg
;
21128 /* A convenience function to find the proper .debug_line section for a CU. */
21130 static struct dwarf2_section_info
*
21131 get_debug_line_section (struct dwarf2_cu
*cu
)
21133 struct dwarf2_section_info
*section
;
21134 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
21136 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
21138 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
21139 section
= &cu
->dwo_unit
->dwo_file
->sections
.line
;
21140 else if (cu
->per_cu
->is_dwz
)
21142 dwz_file
*dwz
= dwarf2_get_dwz_file (per_objfile
->per_bfd
, true);
21144 section
= &dwz
->line
;
21147 section
= &per_objfile
->per_bfd
->line
;
21152 /* Read the statement program header starting at OFFSET in
21153 .debug_line, or .debug_line.dwo. Return a pointer
21154 to a struct line_header, allocated using xmalloc.
21155 Returns NULL if there is a problem reading the header, e.g., if it
21156 has a version we don't understand.
21158 NOTE: the strings in the include directory and file name tables of
21159 the returned object point into the dwarf line section buffer,
21160 and must not be freed. */
21162 static line_header_up
21163 dwarf_decode_line_header (sect_offset sect_off
, struct dwarf2_cu
*cu
)
21165 struct dwarf2_section_info
*section
;
21166 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
21168 section
= get_debug_line_section (cu
);
21169 section
->read (per_objfile
->objfile
);
21170 if (section
->buffer
== NULL
)
21172 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
21173 complaint (_("missing .debug_line.dwo section"));
21175 complaint (_("missing .debug_line section"));
21179 return dwarf_decode_line_header (sect_off
, cu
->per_cu
->is_dwz
,
21180 per_objfile
, section
, &cu
->header
);
21183 /* Subroutine of dwarf_decode_lines to simplify it.
21184 Return the file name of the psymtab for the given file_entry.
21185 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
21186 If space for the result is malloc'd, *NAME_HOLDER will be set.
21187 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename. */
21189 static const char *
21190 psymtab_include_file_name (const struct line_header
*lh
, const file_entry
&fe
,
21191 const dwarf2_psymtab
*pst
,
21192 const char *comp_dir
,
21193 gdb::unique_xmalloc_ptr
<char> *name_holder
)
21195 const char *include_name
= fe
.name
;
21196 const char *include_name_to_compare
= include_name
;
21197 const char *pst_filename
;
21200 const char *dir_name
= fe
.include_dir (lh
);
21202 gdb::unique_xmalloc_ptr
<char> hold_compare
;
21203 if (!IS_ABSOLUTE_PATH (include_name
)
21204 && (dir_name
!= NULL
|| comp_dir
!= NULL
))
21206 /* Avoid creating a duplicate psymtab for PST.
21207 We do this by comparing INCLUDE_NAME and PST_FILENAME.
21208 Before we do the comparison, however, we need to account
21209 for DIR_NAME and COMP_DIR.
21210 First prepend dir_name (if non-NULL). If we still don't
21211 have an absolute path prepend comp_dir (if non-NULL).
21212 However, the directory we record in the include-file's
21213 psymtab does not contain COMP_DIR (to match the
21214 corresponding symtab(s)).
21219 bash$ gcc -g ./hello.c
21220 include_name = "hello.c"
21222 DW_AT_comp_dir = comp_dir = "/tmp"
21223 DW_AT_name = "./hello.c"
21227 if (dir_name
!= NULL
)
21229 name_holder
->reset (concat (dir_name
, SLASH_STRING
,
21230 include_name
, (char *) NULL
));
21231 include_name
= name_holder
->get ();
21232 include_name_to_compare
= include_name
;
21234 if (!IS_ABSOLUTE_PATH (include_name
) && comp_dir
!= NULL
)
21236 hold_compare
.reset (concat (comp_dir
, SLASH_STRING
,
21237 include_name
, (char *) NULL
));
21238 include_name_to_compare
= hold_compare
.get ();
21242 pst_filename
= pst
->filename
;
21243 gdb::unique_xmalloc_ptr
<char> copied_name
;
21244 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
21246 copied_name
.reset (concat (pst
->dirname
, SLASH_STRING
,
21247 pst_filename
, (char *) NULL
));
21248 pst_filename
= copied_name
.get ();
21251 file_is_pst
= FILENAME_CMP (include_name_to_compare
, pst_filename
) == 0;
21255 return include_name
;
21258 /* State machine to track the state of the line number program. */
21260 class lnp_state_machine
21263 /* Initialize a machine state for the start of a line number
21265 lnp_state_machine (struct dwarf2_cu
*cu
, gdbarch
*arch
, line_header
*lh
,
21266 bool record_lines_p
);
21268 file_entry
*current_file ()
21270 /* lh->file_names is 0-based, but the file name numbers in the
21271 statement program are 1-based. */
21272 return m_line_header
->file_name_at (m_file
);
21275 /* Record the line in the state machine. END_SEQUENCE is true if
21276 we're processing the end of a sequence. */
21277 void record_line (bool end_sequence
);
21279 /* Check ADDRESS is -1, or zero and less than UNRELOCATED_LOWPC, and if true
21280 nop-out rest of the lines in this sequence. */
21281 void check_line_address (struct dwarf2_cu
*cu
,
21282 const gdb_byte
*line_ptr
,
21283 CORE_ADDR unrelocated_lowpc
, CORE_ADDR address
);
21285 void handle_set_discriminator (unsigned int discriminator
)
21287 m_discriminator
= discriminator
;
21288 m_line_has_non_zero_discriminator
|= discriminator
!= 0;
21291 /* Handle DW_LNE_set_address. */
21292 void handle_set_address (CORE_ADDR baseaddr
, CORE_ADDR address
)
21295 address
+= baseaddr
;
21296 m_address
= gdbarch_adjust_dwarf2_line (m_gdbarch
, address
, false);
21299 /* Handle DW_LNS_advance_pc. */
21300 void handle_advance_pc (CORE_ADDR adjust
);
21302 /* Handle a special opcode. */
21303 void handle_special_opcode (unsigned char op_code
);
21305 /* Handle DW_LNS_advance_line. */
21306 void handle_advance_line (int line_delta
)
21308 advance_line (line_delta
);
21311 /* Handle DW_LNS_set_file. */
21312 void handle_set_file (file_name_index file
);
21314 /* Handle DW_LNS_negate_stmt. */
21315 void handle_negate_stmt ()
21317 m_is_stmt
= !m_is_stmt
;
21320 /* Handle DW_LNS_const_add_pc. */
21321 void handle_const_add_pc ();
21323 /* Handle DW_LNS_fixed_advance_pc. */
21324 void handle_fixed_advance_pc (CORE_ADDR addr_adj
)
21326 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
21330 /* Handle DW_LNS_copy. */
21331 void handle_copy ()
21333 record_line (false);
21334 m_discriminator
= 0;
21337 /* Handle DW_LNE_end_sequence. */
21338 void handle_end_sequence ()
21340 m_currently_recording_lines
= true;
21344 /* Advance the line by LINE_DELTA. */
21345 void advance_line (int line_delta
)
21347 m_line
+= line_delta
;
21349 if (line_delta
!= 0)
21350 m_line_has_non_zero_discriminator
= m_discriminator
!= 0;
21353 struct dwarf2_cu
*m_cu
;
21355 gdbarch
*m_gdbarch
;
21357 /* True if we're recording lines.
21358 Otherwise we're building partial symtabs and are just interested in
21359 finding include files mentioned by the line number program. */
21360 bool m_record_lines_p
;
21362 /* The line number header. */
21363 line_header
*m_line_header
;
21365 /* These are part of the standard DWARF line number state machine,
21366 and initialized according to the DWARF spec. */
21368 unsigned char m_op_index
= 0;
21369 /* The line table index of the current file. */
21370 file_name_index m_file
= 1;
21371 unsigned int m_line
= 1;
21373 /* These are initialized in the constructor. */
21375 CORE_ADDR m_address
;
21377 unsigned int m_discriminator
;
21379 /* Additional bits of state we need to track. */
21381 /* The last file that we called dwarf2_start_subfile for.
21382 This is only used for TLLs. */
21383 unsigned int m_last_file
= 0;
21384 /* The last file a line number was recorded for. */
21385 struct subfile
*m_last_subfile
= NULL
;
21387 /* The address of the last line entry. */
21388 CORE_ADDR m_last_address
;
21390 /* Set to true when a previous line at the same address (using
21391 m_last_address) had m_is_stmt true. This is reset to false when a
21392 line entry at a new address (m_address different to m_last_address) is
21394 bool m_stmt_at_address
= false;
21396 /* When true, record the lines we decode. */
21397 bool m_currently_recording_lines
= false;
21399 /* The last line number that was recorded, used to coalesce
21400 consecutive entries for the same line. This can happen, for
21401 example, when discriminators are present. PR 17276. */
21402 unsigned int m_last_line
= 0;
21403 bool m_line_has_non_zero_discriminator
= false;
21407 lnp_state_machine::handle_advance_pc (CORE_ADDR adjust
)
21409 CORE_ADDR addr_adj
= (((m_op_index
+ adjust
)
21410 / m_line_header
->maximum_ops_per_instruction
)
21411 * m_line_header
->minimum_instruction_length
);
21412 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
21413 m_op_index
= ((m_op_index
+ adjust
)
21414 % m_line_header
->maximum_ops_per_instruction
);
21418 lnp_state_machine::handle_special_opcode (unsigned char op_code
)
21420 unsigned char adj_opcode
= op_code
- m_line_header
->opcode_base
;
21421 unsigned char adj_opcode_d
= adj_opcode
/ m_line_header
->line_range
;
21422 unsigned char adj_opcode_r
= adj_opcode
% m_line_header
->line_range
;
21423 CORE_ADDR addr_adj
= (((m_op_index
+ adj_opcode_d
)
21424 / m_line_header
->maximum_ops_per_instruction
)
21425 * m_line_header
->minimum_instruction_length
);
21426 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
21427 m_op_index
= ((m_op_index
+ adj_opcode_d
)
21428 % m_line_header
->maximum_ops_per_instruction
);
21430 int line_delta
= m_line_header
->line_base
+ adj_opcode_r
;
21431 advance_line (line_delta
);
21432 record_line (false);
21433 m_discriminator
= 0;
21437 lnp_state_machine::handle_set_file (file_name_index file
)
21441 const file_entry
*fe
= current_file ();
21443 dwarf2_debug_line_missing_file_complaint ();
21444 else if (m_record_lines_p
)
21446 const char *dir
= fe
->include_dir (m_line_header
);
21448 m_last_subfile
= m_cu
->get_builder ()->get_current_subfile ();
21449 m_line_has_non_zero_discriminator
= m_discriminator
!= 0;
21450 dwarf2_start_subfile (m_cu
, fe
->name
, dir
);
21455 lnp_state_machine::handle_const_add_pc ()
21458 = (255 - m_line_header
->opcode_base
) / m_line_header
->line_range
;
21461 = (((m_op_index
+ adjust
)
21462 / m_line_header
->maximum_ops_per_instruction
)
21463 * m_line_header
->minimum_instruction_length
);
21465 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
21466 m_op_index
= ((m_op_index
+ adjust
)
21467 % m_line_header
->maximum_ops_per_instruction
);
21470 /* Return non-zero if we should add LINE to the line number table.
21471 LINE is the line to add, LAST_LINE is the last line that was added,
21472 LAST_SUBFILE is the subfile for LAST_LINE.
21473 LINE_HAS_NON_ZERO_DISCRIMINATOR is non-zero if LINE has ever
21474 had a non-zero discriminator.
21476 We have to be careful in the presence of discriminators.
21477 E.g., for this line:
21479 for (i = 0; i < 100000; i++);
21481 clang can emit four line number entries for that one line,
21482 each with a different discriminator.
21483 See gdb.dwarf2/dw2-single-line-discriminators.exp for an example.
21485 However, we want gdb to coalesce all four entries into one.
21486 Otherwise the user could stepi into the middle of the line and
21487 gdb would get confused about whether the pc really was in the
21488 middle of the line.
21490 Things are further complicated by the fact that two consecutive
21491 line number entries for the same line is a heuristic used by gcc
21492 to denote the end of the prologue. So we can't just discard duplicate
21493 entries, we have to be selective about it. The heuristic we use is
21494 that we only collapse consecutive entries for the same line if at least
21495 one of those entries has a non-zero discriminator. PR 17276.
21497 Note: Addresses in the line number state machine can never go backwards
21498 within one sequence, thus this coalescing is ok. */
21501 dwarf_record_line_p (struct dwarf2_cu
*cu
,
21502 unsigned int line
, unsigned int last_line
,
21503 int line_has_non_zero_discriminator
,
21504 struct subfile
*last_subfile
)
21506 if (cu
->get_builder ()->get_current_subfile () != last_subfile
)
21508 if (line
!= last_line
)
21510 /* Same line for the same file that we've seen already.
21511 As a last check, for pr 17276, only record the line if the line
21512 has never had a non-zero discriminator. */
21513 if (!line_has_non_zero_discriminator
)
21518 /* Use the CU's builder to record line number LINE beginning at
21519 address ADDRESS in the line table of subfile SUBFILE. */
21522 dwarf_record_line_1 (struct gdbarch
*gdbarch
, struct subfile
*subfile
,
21523 unsigned int line
, CORE_ADDR address
, bool is_stmt
,
21524 struct dwarf2_cu
*cu
)
21526 CORE_ADDR addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
21528 if (dwarf_line_debug
)
21530 fprintf_unfiltered (gdb_stdlog
,
21531 "Recording line %u, file %s, address %s\n",
21532 line
, lbasename (subfile
->name
),
21533 paddress (gdbarch
, address
));
21537 cu
->get_builder ()->record_line (subfile
, line
, addr
, is_stmt
);
21540 /* Subroutine of dwarf_decode_lines_1 to simplify it.
21541 Mark the end of a set of line number records.
21542 The arguments are the same as for dwarf_record_line_1.
21543 If SUBFILE is NULL the request is ignored. */
21546 dwarf_finish_line (struct gdbarch
*gdbarch
, struct subfile
*subfile
,
21547 CORE_ADDR address
, struct dwarf2_cu
*cu
)
21549 if (subfile
== NULL
)
21552 if (dwarf_line_debug
)
21554 fprintf_unfiltered (gdb_stdlog
,
21555 "Finishing current line, file %s, address %s\n",
21556 lbasename (subfile
->name
),
21557 paddress (gdbarch
, address
));
21560 dwarf_record_line_1 (gdbarch
, subfile
, 0, address
, true, cu
);
21564 lnp_state_machine::record_line (bool end_sequence
)
21566 if (dwarf_line_debug
)
21568 fprintf_unfiltered (gdb_stdlog
,
21569 "Processing actual line %u: file %u,"
21570 " address %s, is_stmt %u, discrim %u%s\n",
21572 paddress (m_gdbarch
, m_address
),
21573 m_is_stmt
, m_discriminator
,
21574 (end_sequence
? "\t(end sequence)" : ""));
21577 file_entry
*fe
= current_file ();
21580 dwarf2_debug_line_missing_file_complaint ();
21581 /* For now we ignore lines not starting on an instruction boundary.
21582 But not when processing end_sequence for compatibility with the
21583 previous version of the code. */
21584 else if (m_op_index
== 0 || end_sequence
)
21586 fe
->included_p
= 1;
21587 if (m_record_lines_p
)
21589 /* When we switch files we insert an end maker in the first file,
21590 switch to the second file and add a new line entry. The
21591 problem is that the end marker inserted in the first file will
21592 discard any previous line entries at the same address. If the
21593 line entries in the first file are marked as is-stmt, while
21594 the new line in the second file is non-stmt, then this means
21595 the end marker will discard is-stmt lines so we can have a
21596 non-stmt line. This means that there are less addresses at
21597 which the user can insert a breakpoint.
21599 To improve this we track the last address in m_last_address,
21600 and whether we have seen an is-stmt at this address. Then
21601 when switching files, if we have seen a stmt at the current
21602 address, and we are switching to create a non-stmt line, then
21603 discard the new line. */
21605 = m_last_subfile
!= m_cu
->get_builder ()->get_current_subfile ();
21606 bool ignore_this_line
21607 = ((file_changed
&& !end_sequence
&& m_last_address
== m_address
21608 && !m_is_stmt
&& m_stmt_at_address
)
21609 || (!end_sequence
&& m_line
== 0));
21611 if ((file_changed
&& !ignore_this_line
) || end_sequence
)
21613 dwarf_finish_line (m_gdbarch
, m_last_subfile
, m_address
,
21614 m_currently_recording_lines
? m_cu
: nullptr);
21617 if (!end_sequence
&& !ignore_this_line
)
21619 bool is_stmt
= producer_is_codewarrior (m_cu
) || m_is_stmt
;
21621 if (dwarf_record_line_p (m_cu
, m_line
, m_last_line
,
21622 m_line_has_non_zero_discriminator
,
21625 buildsym_compunit
*builder
= m_cu
->get_builder ();
21626 dwarf_record_line_1 (m_gdbarch
,
21627 builder
->get_current_subfile (),
21628 m_line
, m_address
, is_stmt
,
21629 m_currently_recording_lines
? m_cu
: nullptr);
21631 m_last_subfile
= m_cu
->get_builder ()->get_current_subfile ();
21632 m_last_line
= m_line
;
21637 /* Track whether we have seen any m_is_stmt true at m_address in case we
21638 have multiple line table entries all at m_address. */
21639 if (m_last_address
!= m_address
)
21641 m_stmt_at_address
= false;
21642 m_last_address
= m_address
;
21644 m_stmt_at_address
|= m_is_stmt
;
21647 lnp_state_machine::lnp_state_machine (struct dwarf2_cu
*cu
, gdbarch
*arch
,
21648 line_header
*lh
, bool record_lines_p
)
21652 m_record_lines_p
= record_lines_p
;
21653 m_line_header
= lh
;
21655 m_currently_recording_lines
= true;
21657 /* Call `gdbarch_adjust_dwarf2_line' on the initial 0 address as if there
21658 was a line entry for it so that the backend has a chance to adjust it
21659 and also record it in case it needs it. This is currently used by MIPS
21660 code, cf. `mips_adjust_dwarf2_line'. */
21661 m_address
= gdbarch_adjust_dwarf2_line (arch
, 0, 0);
21662 m_is_stmt
= lh
->default_is_stmt
;
21663 m_discriminator
= 0;
21665 m_last_address
= m_address
;
21666 m_stmt_at_address
= false;
21670 lnp_state_machine::check_line_address (struct dwarf2_cu
*cu
,
21671 const gdb_byte
*line_ptr
,
21672 CORE_ADDR unrelocated_lowpc
, CORE_ADDR address
)
21674 /* Linkers resolve a symbolic relocation referencing a GC'd function to 0 or
21675 -1. If ADDRESS is 0, ignoring the opcode will err if the text section is
21676 located at 0x0. In this case, additionally check that if
21677 ADDRESS < UNRELOCATED_LOWPC. */
21679 if ((address
== 0 && address
< unrelocated_lowpc
)
21680 || address
== (CORE_ADDR
) -1)
21682 /* This line table is for a function which has been
21683 GCd by the linker. Ignore it. PR gdb/12528 */
21685 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
21686 long line_offset
= line_ptr
- get_debug_line_section (cu
)->buffer
;
21688 complaint (_(".debug_line address at offset 0x%lx is 0 [in module %s]"),
21689 line_offset
, objfile_name (objfile
));
21690 m_currently_recording_lines
= false;
21691 /* Note: m_currently_recording_lines is left as false until we see
21692 DW_LNE_end_sequence. */
21696 /* Subroutine of dwarf_decode_lines to simplify it.
21697 Process the line number information in LH.
21698 If DECODE_FOR_PST_P is non-zero, all we do is process the line number
21699 program in order to set included_p for every referenced header. */
21702 dwarf_decode_lines_1 (struct line_header
*lh
, struct dwarf2_cu
*cu
,
21703 const int decode_for_pst_p
, CORE_ADDR lowpc
)
21705 const gdb_byte
*line_ptr
, *extended_end
;
21706 const gdb_byte
*line_end
;
21707 unsigned int bytes_read
, extended_len
;
21708 unsigned char op_code
, extended_op
;
21709 CORE_ADDR baseaddr
;
21710 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
21711 bfd
*abfd
= objfile
->obfd
;
21712 struct gdbarch
*gdbarch
= objfile
->arch ();
21713 /* True if we're recording line info (as opposed to building partial
21714 symtabs and just interested in finding include files mentioned by
21715 the line number program). */
21716 bool record_lines_p
= !decode_for_pst_p
;
21718 baseaddr
= objfile
->text_section_offset ();
21720 line_ptr
= lh
->statement_program_start
;
21721 line_end
= lh
->statement_program_end
;
21723 /* Read the statement sequences until there's nothing left. */
21724 while (line_ptr
< line_end
)
21726 /* The DWARF line number program state machine. Reset the state
21727 machine at the start of each sequence. */
21728 lnp_state_machine
state_machine (cu
, gdbarch
, lh
, record_lines_p
);
21729 bool end_sequence
= false;
21731 if (record_lines_p
)
21733 /* Start a subfile for the current file of the state
21735 const file_entry
*fe
= state_machine
.current_file ();
21738 dwarf2_start_subfile (cu
, fe
->name
, fe
->include_dir (lh
));
21741 /* Decode the table. */
21742 while (line_ptr
< line_end
&& !end_sequence
)
21744 op_code
= read_1_byte (abfd
, line_ptr
);
21747 if (op_code
>= lh
->opcode_base
)
21749 /* Special opcode. */
21750 state_machine
.handle_special_opcode (op_code
);
21752 else switch (op_code
)
21754 case DW_LNS_extended_op
:
21755 extended_len
= read_unsigned_leb128 (abfd
, line_ptr
,
21757 line_ptr
+= bytes_read
;
21758 extended_end
= line_ptr
+ extended_len
;
21759 extended_op
= read_1_byte (abfd
, line_ptr
);
21761 if (DW_LNE_lo_user
<= extended_op
21762 && extended_op
<= DW_LNE_hi_user
)
21764 /* Vendor extension, ignore. */
21765 line_ptr
= extended_end
;
21768 switch (extended_op
)
21770 case DW_LNE_end_sequence
:
21771 state_machine
.handle_end_sequence ();
21772 end_sequence
= true;
21774 case DW_LNE_set_address
:
21777 = cu
->header
.read_address (abfd
, line_ptr
, &bytes_read
);
21778 line_ptr
+= bytes_read
;
21780 state_machine
.check_line_address (cu
, line_ptr
,
21781 lowpc
- baseaddr
, address
);
21782 state_machine
.handle_set_address (baseaddr
, address
);
21785 case DW_LNE_define_file
:
21787 const char *cur_file
;
21788 unsigned int mod_time
, length
;
21791 cur_file
= read_direct_string (abfd
, line_ptr
,
21793 line_ptr
+= bytes_read
;
21794 dindex
= (dir_index
)
21795 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21796 line_ptr
+= bytes_read
;
21798 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21799 line_ptr
+= bytes_read
;
21801 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21802 line_ptr
+= bytes_read
;
21803 lh
->add_file_name (cur_file
, dindex
, mod_time
, length
);
21806 case DW_LNE_set_discriminator
:
21808 /* The discriminator is not interesting to the
21809 debugger; just ignore it. We still need to
21810 check its value though:
21811 if there are consecutive entries for the same
21812 (non-prologue) line we want to coalesce them.
21815 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21816 line_ptr
+= bytes_read
;
21818 state_machine
.handle_set_discriminator (discr
);
21822 complaint (_("mangled .debug_line section"));
21825 /* Make sure that we parsed the extended op correctly. If e.g.
21826 we expected a different address size than the producer used,
21827 we may have read the wrong number of bytes. */
21828 if (line_ptr
!= extended_end
)
21830 complaint (_("mangled .debug_line section"));
21835 state_machine
.handle_copy ();
21837 case DW_LNS_advance_pc
:
21840 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21841 line_ptr
+= bytes_read
;
21843 state_machine
.handle_advance_pc (adjust
);
21846 case DW_LNS_advance_line
:
21849 = read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
21850 line_ptr
+= bytes_read
;
21852 state_machine
.handle_advance_line (line_delta
);
21855 case DW_LNS_set_file
:
21857 file_name_index file
21858 = (file_name_index
) read_unsigned_leb128 (abfd
, line_ptr
,
21860 line_ptr
+= bytes_read
;
21862 state_machine
.handle_set_file (file
);
21865 case DW_LNS_set_column
:
21866 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21867 line_ptr
+= bytes_read
;
21869 case DW_LNS_negate_stmt
:
21870 state_machine
.handle_negate_stmt ();
21872 case DW_LNS_set_basic_block
:
21874 /* Add to the address register of the state machine the
21875 address increment value corresponding to special opcode
21876 255. I.e., this value is scaled by the minimum
21877 instruction length since special opcode 255 would have
21878 scaled the increment. */
21879 case DW_LNS_const_add_pc
:
21880 state_machine
.handle_const_add_pc ();
21882 case DW_LNS_fixed_advance_pc
:
21884 CORE_ADDR addr_adj
= read_2_bytes (abfd
, line_ptr
);
21887 state_machine
.handle_fixed_advance_pc (addr_adj
);
21892 /* Unknown standard opcode, ignore it. */
21895 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
21897 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21898 line_ptr
+= bytes_read
;
21905 dwarf2_debug_line_missing_end_sequence_complaint ();
21907 /* We got a DW_LNE_end_sequence (or we ran off the end of the buffer,
21908 in which case we still finish recording the last line). */
21909 state_machine
.record_line (true);
21913 /* Decode the Line Number Program (LNP) for the given line_header
21914 structure and CU. The actual information extracted and the type
21915 of structures created from the LNP depends on the value of PST.
21917 1. If PST is NULL, then this procedure uses the data from the program
21918 to create all necessary symbol tables, and their linetables.
21920 2. If PST is not NULL, this procedure reads the program to determine
21921 the list of files included by the unit represented by PST, and
21922 builds all the associated partial symbol tables.
21924 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
21925 It is used for relative paths in the line table.
21926 NOTE: When processing partial symtabs (pst != NULL),
21927 comp_dir == pst->dirname.
21929 NOTE: It is important that psymtabs have the same file name (via strcmp)
21930 as the corresponding symtab. Since COMP_DIR is not used in the name of the
21931 symtab we don't use it in the name of the psymtabs we create.
21932 E.g. expand_line_sal requires this when finding psymtabs to expand.
21933 A good testcase for this is mb-inline.exp.
21935 LOWPC is the lowest address in CU (or 0 if not known).
21937 Boolean DECODE_MAPPING specifies we need to fully decode .debug_line
21938 for its PC<->lines mapping information. Otherwise only the filename
21939 table is read in. */
21942 dwarf_decode_lines (struct line_header
*lh
, const char *comp_dir
,
21943 struct dwarf2_cu
*cu
, dwarf2_psymtab
*pst
,
21944 CORE_ADDR lowpc
, int decode_mapping
)
21946 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
21947 const int decode_for_pst_p
= (pst
!= NULL
);
21949 if (decode_mapping
)
21950 dwarf_decode_lines_1 (lh
, cu
, decode_for_pst_p
, lowpc
);
21952 if (decode_for_pst_p
)
21954 /* Now that we're done scanning the Line Header Program, we can
21955 create the psymtab of each included file. */
21956 for (auto &file_entry
: lh
->file_names ())
21957 if (file_entry
.included_p
== 1)
21959 gdb::unique_xmalloc_ptr
<char> name_holder
;
21960 const char *include_name
=
21961 psymtab_include_file_name (lh
, file_entry
, pst
,
21962 comp_dir
, &name_holder
);
21963 if (include_name
!= NULL
)
21964 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
21969 /* Make sure a symtab is created for every file, even files
21970 which contain only variables (i.e. no code with associated
21972 buildsym_compunit
*builder
= cu
->get_builder ();
21973 struct compunit_symtab
*cust
= builder
->get_compunit_symtab ();
21975 for (auto &fe
: lh
->file_names ())
21977 dwarf2_start_subfile (cu
, fe
.name
, fe
.include_dir (lh
));
21978 if (builder
->get_current_subfile ()->symtab
== NULL
)
21980 builder
->get_current_subfile ()->symtab
21981 = allocate_symtab (cust
,
21982 builder
->get_current_subfile ()->name
);
21984 fe
.symtab
= builder
->get_current_subfile ()->symtab
;
21989 /* Start a subfile for DWARF. FILENAME is the name of the file and
21990 DIRNAME the name of the source directory which contains FILENAME
21991 or NULL if not known.
21992 This routine tries to keep line numbers from identical absolute and
21993 relative file names in a common subfile.
21995 Using the `list' example from the GDB testsuite, which resides in
21996 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
21997 of /srcdir/list0.c yields the following debugging information for list0.c:
21999 DW_AT_name: /srcdir/list0.c
22000 DW_AT_comp_dir: /compdir
22001 files.files[0].name: list0.h
22002 files.files[0].dir: /srcdir
22003 files.files[1].name: list0.c
22004 files.files[1].dir: /srcdir
22006 The line number information for list0.c has to end up in a single
22007 subfile, so that `break /srcdir/list0.c:1' works as expected.
22008 start_subfile will ensure that this happens provided that we pass the
22009 concatenation of files.files[1].dir and files.files[1].name as the
22013 dwarf2_start_subfile (struct dwarf2_cu
*cu
, const char *filename
,
22014 const char *dirname
)
22016 gdb::unique_xmalloc_ptr
<char> copy
;
22018 /* In order not to lose the line information directory,
22019 we concatenate it to the filename when it makes sense.
22020 Note that the Dwarf3 standard says (speaking of filenames in line
22021 information): ``The directory index is ignored for file names
22022 that represent full path names''. Thus ignoring dirname in the
22023 `else' branch below isn't an issue. */
22025 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
22027 copy
.reset (concat (dirname
, SLASH_STRING
, filename
, (char *) NULL
));
22028 filename
= copy
.get ();
22031 cu
->get_builder ()->start_subfile (filename
);
22034 /* Start a symtab for DWARF. NAME, COMP_DIR, LOW_PC are passed to the
22035 buildsym_compunit constructor. */
22037 struct compunit_symtab
*
22038 dwarf2_cu::start_symtab (const char *name
, const char *comp_dir
,
22041 gdb_assert (m_builder
== nullptr);
22043 m_builder
.reset (new struct buildsym_compunit
22044 (this->per_objfile
->objfile
,
22045 name
, comp_dir
, language
, low_pc
));
22047 list_in_scope
= get_builder ()->get_file_symbols ();
22049 get_builder ()->record_debugformat ("DWARF 2");
22050 get_builder ()->record_producer (producer
);
22052 processing_has_namespace_info
= false;
22054 return get_builder ()->get_compunit_symtab ();
22058 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
22059 struct dwarf2_cu
*cu
)
22061 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22062 struct comp_unit_head
*cu_header
= &cu
->header
;
22064 /* NOTE drow/2003-01-30: There used to be a comment and some special
22065 code here to turn a symbol with DW_AT_external and a
22066 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
22067 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
22068 with some versions of binutils) where shared libraries could have
22069 relocations against symbols in their debug information - the
22070 minimal symbol would have the right address, but the debug info
22071 would not. It's no longer necessary, because we will explicitly
22072 apply relocations when we read in the debug information now. */
22074 /* A DW_AT_location attribute with no contents indicates that a
22075 variable has been optimized away. */
22076 if (attr
->form_is_block () && attr
->as_block ()->size
== 0)
22078 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
22082 /* Handle one degenerate form of location expression specially, to
22083 preserve GDB's previous behavior when section offsets are
22084 specified. If this is just a DW_OP_addr, DW_OP_addrx, or
22085 DW_OP_GNU_addr_index then mark this symbol as LOC_STATIC. */
22087 if (attr
->form_is_block ())
22089 struct dwarf_block
*block
= attr
->as_block ();
22091 if ((block
->data
[0] == DW_OP_addr
22092 && block
->size
== 1 + cu_header
->addr_size
)
22093 || ((block
->data
[0] == DW_OP_GNU_addr_index
22094 || block
->data
[0] == DW_OP_addrx
)
22096 == 1 + leb128_size (&block
->data
[1]))))
22098 unsigned int dummy
;
22100 if (block
->data
[0] == DW_OP_addr
)
22101 SET_SYMBOL_VALUE_ADDRESS
22102 (sym
, cu
->header
.read_address (objfile
->obfd
,
22106 SET_SYMBOL_VALUE_ADDRESS
22107 (sym
, read_addr_index_from_leb128 (cu
, block
->data
+ 1,
22109 SYMBOL_ACLASS_INDEX (sym
) = LOC_STATIC
;
22110 fixup_symbol_section (sym
, objfile
);
22111 SET_SYMBOL_VALUE_ADDRESS
22113 SYMBOL_VALUE_ADDRESS (sym
)
22114 + objfile
->section_offsets
[sym
->section_index ()]);
22119 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
22120 expression evaluator, and use LOC_COMPUTED only when necessary
22121 (i.e. when the value of a register or memory location is
22122 referenced, or a thread-local block, etc.). Then again, it might
22123 not be worthwhile. I'm assuming that it isn't unless performance
22124 or memory numbers show me otherwise. */
22126 dwarf2_symbol_mark_computed (attr
, sym
, cu
, 0);
22128 if (SYMBOL_COMPUTED_OPS (sym
)->location_has_loclist
)
22129 cu
->has_loclist
= true;
22132 /* Given a pointer to a DWARF information entry, figure out if we need
22133 to make a symbol table entry for it, and if so, create a new entry
22134 and return a pointer to it.
22135 If TYPE is NULL, determine symbol type from the die, otherwise
22136 used the passed type.
22137 If SPACE is not NULL, use it to hold the new symbol. If it is
22138 NULL, allocate a new symbol on the objfile's obstack. */
22140 static struct symbol
*
22141 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
,
22142 struct symbol
*space
)
22144 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
22145 struct objfile
*objfile
= per_objfile
->objfile
;
22146 struct gdbarch
*gdbarch
= objfile
->arch ();
22147 struct symbol
*sym
= NULL
;
22149 struct attribute
*attr
= NULL
;
22150 struct attribute
*attr2
= NULL
;
22151 CORE_ADDR baseaddr
;
22152 struct pending
**list_to_add
= NULL
;
22154 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
22156 baseaddr
= objfile
->text_section_offset ();
22158 name
= dwarf2_name (die
, cu
);
22161 int suppress_add
= 0;
22166 sym
= new (&objfile
->objfile_obstack
) symbol
;
22167 OBJSTAT (objfile
, n_syms
++);
22169 /* Cache this symbol's name and the name's demangled form (if any). */
22170 sym
->set_language (cu
->language
, &objfile
->objfile_obstack
);
22171 /* Fortran does not have mangling standard and the mangling does differ
22172 between gfortran, iFort etc. */
22173 const char *physname
22174 = (cu
->language
== language_fortran
22175 ? dwarf2_full_name (name
, die
, cu
)
22176 : dwarf2_physname (name
, die
, cu
));
22177 const char *linkagename
= dw2_linkage_name (die
, cu
);
22179 if (linkagename
== nullptr || cu
->language
== language_ada
)
22180 sym
->set_linkage_name (physname
);
22183 sym
->set_demangled_name (physname
, &objfile
->objfile_obstack
);
22184 sym
->set_linkage_name (linkagename
);
22187 /* Default assumptions.
22188 Use the passed type or decode it from the die. */
22189 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
22190 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
22192 SYMBOL_TYPE (sym
) = type
;
22194 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
22195 attr
= dwarf2_attr (die
,
22196 inlined_func
? DW_AT_call_line
: DW_AT_decl_line
,
22198 if (attr
!= nullptr)
22199 SYMBOL_LINE (sym
) = attr
->constant_value (0);
22201 attr
= dwarf2_attr (die
,
22202 inlined_func
? DW_AT_call_file
: DW_AT_decl_file
,
22204 if (attr
!= nullptr && attr
->is_nonnegative ())
22206 file_name_index file_index
22207 = (file_name_index
) attr
->as_nonnegative ();
22208 struct file_entry
*fe
;
22210 if (cu
->line_header
!= NULL
)
22211 fe
= cu
->line_header
->file_name_at (file_index
);
22216 complaint (_("file index out of range"));
22218 symbol_set_symtab (sym
, fe
->symtab
);
22224 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
22225 if (attr
!= nullptr)
22229 addr
= attr
->as_address ();
22230 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, addr
+ baseaddr
);
22231 SET_SYMBOL_VALUE_ADDRESS (sym
, addr
);
22232 SYMBOL_ACLASS_INDEX (sym
) = LOC_LABEL
;
22235 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
22236 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_core_addr
;
22237 SYMBOL_DOMAIN (sym
) = LABEL_DOMAIN
;
22238 add_symbol_to_list (sym
, cu
->list_in_scope
);
22240 case DW_TAG_subprogram
:
22241 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
22243 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
22244 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
22245 if ((attr2
!= nullptr && attr2
->as_boolean ())
22246 || cu
->language
== language_ada
22247 || cu
->language
== language_fortran
)
22249 /* Subprograms marked external are stored as a global symbol.
22250 Ada and Fortran subprograms, whether marked external or
22251 not, are always stored as a global symbol, because we want
22252 to be able to access them globally. For instance, we want
22253 to be able to break on a nested subprogram without having
22254 to specify the context. */
22255 list_to_add
= cu
->get_builder ()->get_global_symbols ();
22259 list_to_add
= cu
->list_in_scope
;
22262 case DW_TAG_inlined_subroutine
:
22263 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
22265 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
22266 SYMBOL_INLINED (sym
) = 1;
22267 list_to_add
= cu
->list_in_scope
;
22269 case DW_TAG_template_value_param
:
22271 /* Fall through. */
22272 case DW_TAG_constant
:
22273 case DW_TAG_variable
:
22274 case DW_TAG_member
:
22275 /* Compilation with minimal debug info may result in
22276 variables with missing type entries. Change the
22277 misleading `void' type to something sensible. */
22278 if (SYMBOL_TYPE (sym
)->code () == TYPE_CODE_VOID
)
22279 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_int
;
22281 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
22282 /* In the case of DW_TAG_member, we should only be called for
22283 static const members. */
22284 if (die
->tag
== DW_TAG_member
)
22286 /* dwarf2_add_field uses die_is_declaration,
22287 so we do the same. */
22288 gdb_assert (die_is_declaration (die
, cu
));
22291 if (attr
!= nullptr)
22293 dwarf2_const_value (attr
, sym
, cu
);
22294 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
22297 if (attr2
!= nullptr && attr2
->as_boolean ())
22298 list_to_add
= cu
->get_builder ()->get_global_symbols ();
22300 list_to_add
= cu
->list_in_scope
;
22304 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
22305 if (attr
!= nullptr)
22307 var_decode_location (attr
, sym
, cu
);
22308 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
22310 /* Fortran explicitly imports any global symbols to the local
22311 scope by DW_TAG_common_block. */
22312 if (cu
->language
== language_fortran
&& die
->parent
22313 && die
->parent
->tag
== DW_TAG_common_block
)
22316 if (SYMBOL_CLASS (sym
) == LOC_STATIC
22317 && SYMBOL_VALUE_ADDRESS (sym
) == 0
22318 && !per_objfile
->per_bfd
->has_section_at_zero
)
22320 /* When a static variable is eliminated by the linker,
22321 the corresponding debug information is not stripped
22322 out, but the variable address is set to null;
22323 do not add such variables into symbol table. */
22325 else if (attr2
!= nullptr && attr2
->as_boolean ())
22327 if (SYMBOL_CLASS (sym
) == LOC_STATIC
22328 && (objfile
->flags
& OBJF_MAINLINE
) == 0
22329 && per_objfile
->per_bfd
->can_copy
)
22331 /* A global static variable might be subject to
22332 copy relocation. We first check for a local
22333 minsym, though, because maybe the symbol was
22334 marked hidden, in which case this would not
22336 bound_minimal_symbol found
22337 = (lookup_minimal_symbol_linkage
22338 (sym
->linkage_name (), objfile
));
22339 if (found
.minsym
!= nullptr)
22340 sym
->maybe_copied
= 1;
22343 /* A variable with DW_AT_external is never static,
22344 but it may be block-scoped. */
22346 = ((cu
->list_in_scope
22347 == cu
->get_builder ()->get_file_symbols ())
22348 ? cu
->get_builder ()->get_global_symbols ()
22349 : cu
->list_in_scope
);
22352 list_to_add
= cu
->list_in_scope
;
22356 /* We do not know the address of this symbol.
22357 If it is an external symbol and we have type information
22358 for it, enter the symbol as a LOC_UNRESOLVED symbol.
22359 The address of the variable will then be determined from
22360 the minimal symbol table whenever the variable is
22362 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
22364 /* Fortran explicitly imports any global symbols to the local
22365 scope by DW_TAG_common_block. */
22366 if (cu
->language
== language_fortran
&& die
->parent
22367 && die
->parent
->tag
== DW_TAG_common_block
)
22369 /* SYMBOL_CLASS doesn't matter here because
22370 read_common_block is going to reset it. */
22372 list_to_add
= cu
->list_in_scope
;
22374 else if (attr2
!= nullptr && attr2
->as_boolean ()
22375 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
22377 /* A variable with DW_AT_external is never static, but it
22378 may be block-scoped. */
22380 = ((cu
->list_in_scope
22381 == cu
->get_builder ()->get_file_symbols ())
22382 ? cu
->get_builder ()->get_global_symbols ()
22383 : cu
->list_in_scope
);
22385 SYMBOL_ACLASS_INDEX (sym
) = LOC_UNRESOLVED
;
22387 else if (!die_is_declaration (die
, cu
))
22389 /* Use the default LOC_OPTIMIZED_OUT class. */
22390 gdb_assert (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
);
22392 list_to_add
= cu
->list_in_scope
;
22396 case DW_TAG_formal_parameter
:
22398 /* If we are inside a function, mark this as an argument. If
22399 not, we might be looking at an argument to an inlined function
22400 when we do not have enough information to show inlined frames;
22401 pretend it's a local variable in that case so that the user can
22403 struct context_stack
*curr
22404 = cu
->get_builder ()->get_current_context_stack ();
22405 if (curr
!= nullptr && curr
->name
!= nullptr)
22406 SYMBOL_IS_ARGUMENT (sym
) = 1;
22407 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
22408 if (attr
!= nullptr)
22410 var_decode_location (attr
, sym
, cu
);
22412 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
22413 if (attr
!= nullptr)
22415 dwarf2_const_value (attr
, sym
, cu
);
22418 list_to_add
= cu
->list_in_scope
;
22421 case DW_TAG_unspecified_parameters
:
22422 /* From varargs functions; gdb doesn't seem to have any
22423 interest in this information, so just ignore it for now.
22426 case DW_TAG_template_type_param
:
22428 /* Fall through. */
22429 case DW_TAG_class_type
:
22430 case DW_TAG_interface_type
:
22431 case DW_TAG_structure_type
:
22432 case DW_TAG_union_type
:
22433 case DW_TAG_set_type
:
22434 case DW_TAG_enumeration_type
:
22435 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
22436 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
22439 /* NOTE: carlton/2003-11-10: C++ class symbols shouldn't
22440 really ever be static objects: otherwise, if you try
22441 to, say, break of a class's method and you're in a file
22442 which doesn't mention that class, it won't work unless
22443 the check for all static symbols in lookup_symbol_aux
22444 saves you. See the OtherFileClass tests in
22445 gdb.c++/namespace.exp. */
22449 buildsym_compunit
*builder
= cu
->get_builder ();
22451 = (cu
->list_in_scope
== builder
->get_file_symbols ()
22452 && cu
->language
== language_cplus
22453 ? builder
->get_global_symbols ()
22454 : cu
->list_in_scope
);
22456 /* The semantics of C++ state that "struct foo {
22457 ... }" also defines a typedef for "foo". */
22458 if (cu
->language
== language_cplus
22459 || cu
->language
== language_ada
22460 || cu
->language
== language_d
22461 || cu
->language
== language_rust
)
22463 /* The symbol's name is already allocated along
22464 with this objfile, so we don't need to
22465 duplicate it for the type. */
22466 if (SYMBOL_TYPE (sym
)->name () == 0)
22467 SYMBOL_TYPE (sym
)->set_name (sym
->search_name ());
22472 case DW_TAG_typedef
:
22473 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
22474 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
22475 list_to_add
= cu
->list_in_scope
;
22477 case DW_TAG_array_type
:
22478 case DW_TAG_base_type
:
22479 case DW_TAG_subrange_type
:
22480 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
22481 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
22482 list_to_add
= cu
->list_in_scope
;
22484 case DW_TAG_enumerator
:
22485 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
22486 if (attr
!= nullptr)
22488 dwarf2_const_value (attr
, sym
, cu
);
22491 /* NOTE: carlton/2003-11-10: See comment above in the
22492 DW_TAG_class_type, etc. block. */
22495 = (cu
->list_in_scope
== cu
->get_builder ()->get_file_symbols ()
22496 && cu
->language
== language_cplus
22497 ? cu
->get_builder ()->get_global_symbols ()
22498 : cu
->list_in_scope
);
22501 case DW_TAG_imported_declaration
:
22502 case DW_TAG_namespace
:
22503 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
22504 list_to_add
= cu
->get_builder ()->get_global_symbols ();
22506 case DW_TAG_module
:
22507 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
22508 SYMBOL_DOMAIN (sym
) = MODULE_DOMAIN
;
22509 list_to_add
= cu
->get_builder ()->get_global_symbols ();
22511 case DW_TAG_common_block
:
22512 SYMBOL_ACLASS_INDEX (sym
) = LOC_COMMON_BLOCK
;
22513 SYMBOL_DOMAIN (sym
) = COMMON_BLOCK_DOMAIN
;
22514 add_symbol_to_list (sym
, cu
->list_in_scope
);
22517 /* Not a tag we recognize. Hopefully we aren't processing
22518 trash data, but since we must specifically ignore things
22519 we don't recognize, there is nothing else we should do at
22521 complaint (_("unsupported tag: '%s'"),
22522 dwarf_tag_name (die
->tag
));
22528 sym
->hash_next
= objfile
->template_symbols
;
22529 objfile
->template_symbols
= sym
;
22530 list_to_add
= NULL
;
22533 if (list_to_add
!= NULL
)
22534 add_symbol_to_list (sym
, list_to_add
);
22536 /* For the benefit of old versions of GCC, check for anonymous
22537 namespaces based on the demangled name. */
22538 if (!cu
->processing_has_namespace_info
22539 && cu
->language
== language_cplus
)
22540 cp_scan_for_anonymous_namespaces (cu
->get_builder (), sym
, objfile
);
22545 /* Given an attr with a DW_FORM_dataN value in host byte order,
22546 zero-extend it as appropriate for the symbol's type. The DWARF
22547 standard (v4) is not entirely clear about the meaning of using
22548 DW_FORM_dataN for a constant with a signed type, where the type is
22549 wider than the data. The conclusion of a discussion on the DWARF
22550 list was that this is unspecified. We choose to always zero-extend
22551 because that is the interpretation long in use by GCC. */
22554 dwarf2_const_value_data (const struct attribute
*attr
, struct obstack
*obstack
,
22555 struct dwarf2_cu
*cu
, LONGEST
*value
, int bits
)
22557 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22558 enum bfd_endian byte_order
= bfd_big_endian (objfile
->obfd
) ?
22559 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
22560 LONGEST l
= attr
->constant_value (0);
22562 if (bits
< sizeof (*value
) * 8)
22564 l
&= ((LONGEST
) 1 << bits
) - 1;
22567 else if (bits
== sizeof (*value
) * 8)
22571 gdb_byte
*bytes
= (gdb_byte
*) obstack_alloc (obstack
, bits
/ 8);
22572 store_unsigned_integer (bytes
, bits
/ 8, byte_order
, l
);
22579 /* Read a constant value from an attribute. Either set *VALUE, or if
22580 the value does not fit in *VALUE, set *BYTES - either already
22581 allocated on the objfile obstack, or newly allocated on OBSTACK,
22582 or, set *BATON, if we translated the constant to a location
22586 dwarf2_const_value_attr (const struct attribute
*attr
, struct type
*type
,
22587 const char *name
, struct obstack
*obstack
,
22588 struct dwarf2_cu
*cu
,
22589 LONGEST
*value
, const gdb_byte
**bytes
,
22590 struct dwarf2_locexpr_baton
**baton
)
22592 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
22593 struct objfile
*objfile
= per_objfile
->objfile
;
22594 struct comp_unit_head
*cu_header
= &cu
->header
;
22595 struct dwarf_block
*blk
;
22596 enum bfd_endian byte_order
= (bfd_big_endian (objfile
->obfd
) ?
22597 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
22603 switch (attr
->form
)
22606 case DW_FORM_addrx
:
22607 case DW_FORM_GNU_addr_index
:
22611 if (TYPE_LENGTH (type
) != cu_header
->addr_size
)
22612 dwarf2_const_value_length_mismatch_complaint (name
,
22613 cu_header
->addr_size
,
22614 TYPE_LENGTH (type
));
22615 /* Symbols of this form are reasonably rare, so we just
22616 piggyback on the existing location code rather than writing
22617 a new implementation of symbol_computed_ops. */
22618 *baton
= XOBNEW (obstack
, struct dwarf2_locexpr_baton
);
22619 (*baton
)->per_objfile
= per_objfile
;
22620 (*baton
)->per_cu
= cu
->per_cu
;
22621 gdb_assert ((*baton
)->per_cu
);
22623 (*baton
)->size
= 2 + cu_header
->addr_size
;
22624 data
= (gdb_byte
*) obstack_alloc (obstack
, (*baton
)->size
);
22625 (*baton
)->data
= data
;
22627 data
[0] = DW_OP_addr
;
22628 store_unsigned_integer (&data
[1], cu_header
->addr_size
,
22629 byte_order
, attr
->as_address ());
22630 data
[cu_header
->addr_size
+ 1] = DW_OP_stack_value
;
22633 case DW_FORM_string
:
22636 case DW_FORM_GNU_str_index
:
22637 case DW_FORM_GNU_strp_alt
:
22638 /* The string is already allocated on the objfile obstack, point
22640 *bytes
= (const gdb_byte
*) attr
->as_string ();
22642 case DW_FORM_block1
:
22643 case DW_FORM_block2
:
22644 case DW_FORM_block4
:
22645 case DW_FORM_block
:
22646 case DW_FORM_exprloc
:
22647 case DW_FORM_data16
:
22648 blk
= attr
->as_block ();
22649 if (TYPE_LENGTH (type
) != blk
->size
)
22650 dwarf2_const_value_length_mismatch_complaint (name
, blk
->size
,
22651 TYPE_LENGTH (type
));
22652 *bytes
= blk
->data
;
22655 /* The DW_AT_const_value attributes are supposed to carry the
22656 symbol's value "represented as it would be on the target
22657 architecture." By the time we get here, it's already been
22658 converted to host endianness, so we just need to sign- or
22659 zero-extend it as appropriate. */
22660 case DW_FORM_data1
:
22661 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 8);
22663 case DW_FORM_data2
:
22664 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 16);
22666 case DW_FORM_data4
:
22667 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 32);
22669 case DW_FORM_data8
:
22670 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 64);
22673 case DW_FORM_sdata
:
22674 case DW_FORM_implicit_const
:
22675 *value
= attr
->as_signed ();
22678 case DW_FORM_udata
:
22679 *value
= attr
->as_unsigned ();
22683 complaint (_("unsupported const value attribute form: '%s'"),
22684 dwarf_form_name (attr
->form
));
22691 /* Copy constant value from an attribute to a symbol. */
22694 dwarf2_const_value (const struct attribute
*attr
, struct symbol
*sym
,
22695 struct dwarf2_cu
*cu
)
22697 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22699 const gdb_byte
*bytes
;
22700 struct dwarf2_locexpr_baton
*baton
;
22702 dwarf2_const_value_attr (attr
, SYMBOL_TYPE (sym
),
22703 sym
->print_name (),
22704 &objfile
->objfile_obstack
, cu
,
22705 &value
, &bytes
, &baton
);
22709 SYMBOL_LOCATION_BATON (sym
) = baton
;
22710 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
22712 else if (bytes
!= NULL
)
22714 SYMBOL_VALUE_BYTES (sym
) = bytes
;
22715 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST_BYTES
;
22719 SYMBOL_VALUE (sym
) = value
;
22720 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST
;
22724 /* Return the type of the die in question using its DW_AT_type attribute. */
22726 static struct type
*
22727 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
22729 struct attribute
*type_attr
;
22731 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
22734 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22735 /* A missing DW_AT_type represents a void type. */
22736 return objfile_type (objfile
)->builtin_void
;
22739 return lookup_die_type (die
, type_attr
, cu
);
22742 /* True iff CU's producer generates GNAT Ada auxiliary information
22743 that allows to find parallel types through that information instead
22744 of having to do expensive parallel lookups by type name. */
22747 need_gnat_info (struct dwarf2_cu
*cu
)
22749 /* Assume that the Ada compiler was GNAT, which always produces
22750 the auxiliary information. */
22751 return (cu
->language
== language_ada
);
22754 /* Return the auxiliary type of the die in question using its
22755 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
22756 attribute is not present. */
22758 static struct type
*
22759 die_descriptive_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
22761 struct attribute
*type_attr
;
22763 type_attr
= dwarf2_attr (die
, DW_AT_GNAT_descriptive_type
, cu
);
22767 return lookup_die_type (die
, type_attr
, cu
);
22770 /* If DIE has a descriptive_type attribute, then set the TYPE's
22771 descriptive type accordingly. */
22774 set_descriptive_type (struct type
*type
, struct die_info
*die
,
22775 struct dwarf2_cu
*cu
)
22777 struct type
*descriptive_type
= die_descriptive_type (die
, cu
);
22779 if (descriptive_type
)
22781 ALLOCATE_GNAT_AUX_TYPE (type
);
22782 TYPE_DESCRIPTIVE_TYPE (type
) = descriptive_type
;
22786 /* Return the containing type of the die in question using its
22787 DW_AT_containing_type attribute. */
22789 static struct type
*
22790 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
22792 struct attribute
*type_attr
;
22793 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22795 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
22797 error (_("Dwarf Error: Problem turning containing type into gdb type "
22798 "[in module %s]"), objfile_name (objfile
));
22800 return lookup_die_type (die
, type_attr
, cu
);
22803 /* Return an error marker type to use for the ill formed type in DIE/CU. */
22805 static struct type
*
22806 build_error_marker_type (struct dwarf2_cu
*cu
, struct die_info
*die
)
22808 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
22809 struct objfile
*objfile
= per_objfile
->objfile
;
22812 std::string message
22813 = string_printf (_("<unknown type in %s, CU %s, DIE %s>"),
22814 objfile_name (objfile
),
22815 sect_offset_str (cu
->header
.sect_off
),
22816 sect_offset_str (die
->sect_off
));
22817 saved
= obstack_strdup (&objfile
->objfile_obstack
, message
);
22819 return init_type (objfile
, TYPE_CODE_ERROR
, 0, saved
);
22822 /* Look up the type of DIE in CU using its type attribute ATTR.
22823 ATTR must be one of: DW_AT_type, DW_AT_GNAT_descriptive_type,
22824 DW_AT_containing_type.
22825 If there is no type substitute an error marker. */
22827 static struct type
*
22828 lookup_die_type (struct die_info
*die
, const struct attribute
*attr
,
22829 struct dwarf2_cu
*cu
)
22831 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
22832 struct objfile
*objfile
= per_objfile
->objfile
;
22833 struct type
*this_type
;
22835 gdb_assert (attr
->name
== DW_AT_type
22836 || attr
->name
== DW_AT_GNAT_descriptive_type
22837 || attr
->name
== DW_AT_containing_type
);
22839 /* First see if we have it cached. */
22841 if (attr
->form
== DW_FORM_GNU_ref_alt
)
22843 struct dwarf2_per_cu_data
*per_cu
;
22844 sect_offset sect_off
= attr
->get_ref_die_offset ();
22846 per_cu
= dwarf2_find_containing_comp_unit (sect_off
, 1, per_objfile
);
22847 this_type
= get_die_type_at_offset (sect_off
, per_cu
, per_objfile
);
22849 else if (attr
->form_is_ref ())
22851 sect_offset sect_off
= attr
->get_ref_die_offset ();
22853 this_type
= get_die_type_at_offset (sect_off
, cu
->per_cu
, per_objfile
);
22855 else if (attr
->form
== DW_FORM_ref_sig8
)
22857 ULONGEST signature
= attr
->as_signature ();
22859 return get_signatured_type (die
, signature
, cu
);
22863 complaint (_("Dwarf Error: Bad type attribute %s in DIE"
22864 " at %s [in module %s]"),
22865 dwarf_attr_name (attr
->name
), sect_offset_str (die
->sect_off
),
22866 objfile_name (objfile
));
22867 return build_error_marker_type (cu
, die
);
22870 /* If not cached we need to read it in. */
22872 if (this_type
== NULL
)
22874 struct die_info
*type_die
= NULL
;
22875 struct dwarf2_cu
*type_cu
= cu
;
22877 if (attr
->form_is_ref ())
22878 type_die
= follow_die_ref (die
, attr
, &type_cu
);
22879 if (type_die
== NULL
)
22880 return build_error_marker_type (cu
, die
);
22881 /* If we find the type now, it's probably because the type came
22882 from an inter-CU reference and the type's CU got expanded before
22884 this_type
= read_type_die (type_die
, type_cu
);
22887 /* If we still don't have a type use an error marker. */
22889 if (this_type
== NULL
)
22890 return build_error_marker_type (cu
, die
);
22895 /* Return the type in DIE, CU.
22896 Returns NULL for invalid types.
22898 This first does a lookup in die_type_hash,
22899 and only reads the die in if necessary.
22901 NOTE: This can be called when reading in partial or full symbols. */
22903 static struct type
*
22904 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
22906 struct type
*this_type
;
22908 this_type
= get_die_type (die
, cu
);
22912 return read_type_die_1 (die
, cu
);
22915 /* Read the type in DIE, CU.
22916 Returns NULL for invalid types. */
22918 static struct type
*
22919 read_type_die_1 (struct die_info
*die
, struct dwarf2_cu
*cu
)
22921 struct type
*this_type
= NULL
;
22925 case DW_TAG_class_type
:
22926 case DW_TAG_interface_type
:
22927 case DW_TAG_structure_type
:
22928 case DW_TAG_union_type
:
22929 this_type
= read_structure_type (die
, cu
);
22931 case DW_TAG_enumeration_type
:
22932 this_type
= read_enumeration_type (die
, cu
);
22934 case DW_TAG_subprogram
:
22935 case DW_TAG_subroutine_type
:
22936 case DW_TAG_inlined_subroutine
:
22937 this_type
= read_subroutine_type (die
, cu
);
22939 case DW_TAG_array_type
:
22940 this_type
= read_array_type (die
, cu
);
22942 case DW_TAG_set_type
:
22943 this_type
= read_set_type (die
, cu
);
22945 case DW_TAG_pointer_type
:
22946 this_type
= read_tag_pointer_type (die
, cu
);
22948 case DW_TAG_ptr_to_member_type
:
22949 this_type
= read_tag_ptr_to_member_type (die
, cu
);
22951 case DW_TAG_reference_type
:
22952 this_type
= read_tag_reference_type (die
, cu
, TYPE_CODE_REF
);
22954 case DW_TAG_rvalue_reference_type
:
22955 this_type
= read_tag_reference_type (die
, cu
, TYPE_CODE_RVALUE_REF
);
22957 case DW_TAG_const_type
:
22958 this_type
= read_tag_const_type (die
, cu
);
22960 case DW_TAG_volatile_type
:
22961 this_type
= read_tag_volatile_type (die
, cu
);
22963 case DW_TAG_restrict_type
:
22964 this_type
= read_tag_restrict_type (die
, cu
);
22966 case DW_TAG_string_type
:
22967 this_type
= read_tag_string_type (die
, cu
);
22969 case DW_TAG_typedef
:
22970 this_type
= read_typedef (die
, cu
);
22972 case DW_TAG_subrange_type
:
22973 this_type
= read_subrange_type (die
, cu
);
22975 case DW_TAG_base_type
:
22976 this_type
= read_base_type (die
, cu
);
22978 case DW_TAG_unspecified_type
:
22979 this_type
= read_unspecified_type (die
, cu
);
22981 case DW_TAG_namespace
:
22982 this_type
= read_namespace_type (die
, cu
);
22984 case DW_TAG_module
:
22985 this_type
= read_module_type (die
, cu
);
22987 case DW_TAG_atomic_type
:
22988 this_type
= read_tag_atomic_type (die
, cu
);
22991 complaint (_("unexpected tag in read_type_die: '%s'"),
22992 dwarf_tag_name (die
->tag
));
22999 /* See if we can figure out if the class lives in a namespace. We do
23000 this by looking for a member function; its demangled name will
23001 contain namespace info, if there is any.
23002 Return the computed name or NULL.
23003 Space for the result is allocated on the objfile's obstack.
23004 This is the full-die version of guess_partial_die_structure_name.
23005 In this case we know DIE has no useful parent. */
23007 static const char *
23008 guess_full_die_structure_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
23010 struct die_info
*spec_die
;
23011 struct dwarf2_cu
*spec_cu
;
23012 struct die_info
*child
;
23013 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
23016 spec_die
= die_specification (die
, &spec_cu
);
23017 if (spec_die
!= NULL
)
23023 for (child
= die
->child
;
23025 child
= child
->sibling
)
23027 if (child
->tag
== DW_TAG_subprogram
)
23029 const char *linkage_name
= dw2_linkage_name (child
, cu
);
23031 if (linkage_name
!= NULL
)
23033 gdb::unique_xmalloc_ptr
<char> actual_name
23034 (cu
->language_defn
->class_name_from_physname (linkage_name
));
23035 const char *name
= NULL
;
23037 if (actual_name
!= NULL
)
23039 const char *die_name
= dwarf2_name (die
, cu
);
23041 if (die_name
!= NULL
23042 && strcmp (die_name
, actual_name
.get ()) != 0)
23044 /* Strip off the class name from the full name.
23045 We want the prefix. */
23046 int die_name_len
= strlen (die_name
);
23047 int actual_name_len
= strlen (actual_name
.get ());
23048 const char *ptr
= actual_name
.get ();
23050 /* Test for '::' as a sanity check. */
23051 if (actual_name_len
> die_name_len
+ 2
23052 && ptr
[actual_name_len
- die_name_len
- 1] == ':')
23053 name
= obstack_strndup (
23054 &objfile
->per_bfd
->storage_obstack
,
23055 ptr
, actual_name_len
- die_name_len
- 2);
23066 /* GCC might emit a nameless typedef that has a linkage name. Determine the
23067 prefix part in such case. See
23068 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
23070 static const char *
23071 anonymous_struct_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
23073 struct attribute
*attr
;
23076 if (die
->tag
!= DW_TAG_class_type
&& die
->tag
!= DW_TAG_interface_type
23077 && die
->tag
!= DW_TAG_structure_type
&& die
->tag
!= DW_TAG_union_type
)
23080 if (dwarf2_string_attr (die
, DW_AT_name
, cu
) != NULL
)
23083 attr
= dw2_linkage_name_attr (die
, cu
);
23084 const char *attr_name
= attr
->as_string ();
23085 if (attr
== NULL
|| attr_name
== NULL
)
23088 /* dwarf2_name had to be already called. */
23089 gdb_assert (attr
->canonical_string_p ());
23091 /* Strip the base name, keep any leading namespaces/classes. */
23092 base
= strrchr (attr_name
, ':');
23093 if (base
== NULL
|| base
== attr_name
|| base
[-1] != ':')
23096 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
23097 return obstack_strndup (&objfile
->per_bfd
->storage_obstack
,
23099 &base
[-1] - attr_name
);
23102 /* Return the name of the namespace/class that DIE is defined within,
23103 or "" if we can't tell. The caller should not xfree the result.
23105 For example, if we're within the method foo() in the following
23115 then determine_prefix on foo's die will return "N::C". */
23117 static const char *
23118 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
23120 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
23121 struct die_info
*parent
, *spec_die
;
23122 struct dwarf2_cu
*spec_cu
;
23123 struct type
*parent_type
;
23124 const char *retval
;
23126 if (cu
->language
!= language_cplus
23127 && cu
->language
!= language_fortran
&& cu
->language
!= language_d
23128 && cu
->language
!= language_rust
)
23131 retval
= anonymous_struct_prefix (die
, cu
);
23135 /* We have to be careful in the presence of DW_AT_specification.
23136 For example, with GCC 3.4, given the code
23140 // Definition of N::foo.
23144 then we'll have a tree of DIEs like this:
23146 1: DW_TAG_compile_unit
23147 2: DW_TAG_namespace // N
23148 3: DW_TAG_subprogram // declaration of N::foo
23149 4: DW_TAG_subprogram // definition of N::foo
23150 DW_AT_specification // refers to die #3
23152 Thus, when processing die #4, we have to pretend that we're in
23153 the context of its DW_AT_specification, namely the contex of die
23156 spec_die
= die_specification (die
, &spec_cu
);
23157 if (spec_die
== NULL
)
23158 parent
= die
->parent
;
23161 parent
= spec_die
->parent
;
23165 if (parent
== NULL
)
23167 else if (parent
->building_fullname
)
23170 const char *parent_name
;
23172 /* It has been seen on RealView 2.2 built binaries,
23173 DW_TAG_template_type_param types actually _defined_ as
23174 children of the parent class:
23177 template class <class Enum> Class{};
23178 Class<enum E> class_e;
23180 1: DW_TAG_class_type (Class)
23181 2: DW_TAG_enumeration_type (E)
23182 3: DW_TAG_enumerator (enum1:0)
23183 3: DW_TAG_enumerator (enum2:1)
23185 2: DW_TAG_template_type_param
23186 DW_AT_type DW_FORM_ref_udata (E)
23188 Besides being broken debug info, it can put GDB into an
23189 infinite loop. Consider:
23191 When we're building the full name for Class<E>, we'll start
23192 at Class, and go look over its template type parameters,
23193 finding E. We'll then try to build the full name of E, and
23194 reach here. We're now trying to build the full name of E,
23195 and look over the parent DIE for containing scope. In the
23196 broken case, if we followed the parent DIE of E, we'd again
23197 find Class, and once again go look at its template type
23198 arguments, etc., etc. Simply don't consider such parent die
23199 as source-level parent of this die (it can't be, the language
23200 doesn't allow it), and break the loop here. */
23201 name
= dwarf2_name (die
, cu
);
23202 parent_name
= dwarf2_name (parent
, cu
);
23203 complaint (_("template param type '%s' defined within parent '%s'"),
23204 name
? name
: "<unknown>",
23205 parent_name
? parent_name
: "<unknown>");
23209 switch (parent
->tag
)
23211 case DW_TAG_namespace
:
23212 parent_type
= read_type_die (parent
, cu
);
23213 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
23214 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
23215 Work around this problem here. */
23216 if (cu
->language
== language_cplus
23217 && strcmp (parent_type
->name (), "::") == 0)
23219 /* We give a name to even anonymous namespaces. */
23220 return parent_type
->name ();
23221 case DW_TAG_class_type
:
23222 case DW_TAG_interface_type
:
23223 case DW_TAG_structure_type
:
23224 case DW_TAG_union_type
:
23225 case DW_TAG_module
:
23226 parent_type
= read_type_die (parent
, cu
);
23227 if (parent_type
->name () != NULL
)
23228 return parent_type
->name ();
23230 /* An anonymous structure is only allowed non-static data
23231 members; no typedefs, no member functions, et cetera.
23232 So it does not need a prefix. */
23234 case DW_TAG_compile_unit
:
23235 case DW_TAG_partial_unit
:
23236 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
23237 if (cu
->language
== language_cplus
23238 && !per_objfile
->per_bfd
->types
.empty ()
23239 && die
->child
!= NULL
23240 && (die
->tag
== DW_TAG_class_type
23241 || die
->tag
== DW_TAG_structure_type
23242 || die
->tag
== DW_TAG_union_type
))
23244 const char *name
= guess_full_die_structure_name (die
, cu
);
23249 case DW_TAG_subprogram
:
23250 /* Nested subroutines in Fortran get a prefix with the name
23251 of the parent's subroutine. */
23252 if (cu
->language
== language_fortran
)
23254 if ((die
->tag
== DW_TAG_subprogram
)
23255 && (dwarf2_name (parent
, cu
) != NULL
))
23256 return dwarf2_name (parent
, cu
);
23258 return determine_prefix (parent
, cu
);
23259 case DW_TAG_enumeration_type
:
23260 parent_type
= read_type_die (parent
, cu
);
23261 if (TYPE_DECLARED_CLASS (parent_type
))
23263 if (parent_type
->name () != NULL
)
23264 return parent_type
->name ();
23267 /* Fall through. */
23269 return determine_prefix (parent
, cu
);
23273 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
23274 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
23275 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
23276 an obconcat, otherwise allocate storage for the result. The CU argument is
23277 used to determine the language and hence, the appropriate separator. */
23279 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
23282 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
23283 int physname
, struct dwarf2_cu
*cu
)
23285 const char *lead
= "";
23288 if (suffix
== NULL
|| suffix
[0] == '\0'
23289 || prefix
== NULL
|| prefix
[0] == '\0')
23291 else if (cu
->language
== language_d
)
23293 /* For D, the 'main' function could be defined in any module, but it
23294 should never be prefixed. */
23295 if (strcmp (suffix
, "D main") == 0)
23303 else if (cu
->language
== language_fortran
&& physname
)
23305 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
23306 DW_AT_MIPS_linkage_name is preferred and used instead. */
23314 if (prefix
== NULL
)
23316 if (suffix
== NULL
)
23323 xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1));
23325 strcpy (retval
, lead
);
23326 strcat (retval
, prefix
);
23327 strcat (retval
, sep
);
23328 strcat (retval
, suffix
);
23333 /* We have an obstack. */
23334 return obconcat (obs
, lead
, prefix
, sep
, suffix
, (char *) NULL
);
23338 /* Get name of a die, return NULL if not found. */
23340 static const char *
23341 dwarf2_canonicalize_name (const char *name
, struct dwarf2_cu
*cu
,
23342 struct objfile
*objfile
)
23344 if (name
&& cu
->language
== language_cplus
)
23346 gdb::unique_xmalloc_ptr
<char> canon_name
23347 = cp_canonicalize_string (name
);
23349 if (canon_name
!= nullptr)
23350 name
= objfile
->intern (canon_name
.get ());
23356 /* Get name of a die, return NULL if not found.
23357 Anonymous namespaces are converted to their magic string. */
23359 static const char *
23360 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
23362 struct attribute
*attr
;
23363 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
23365 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
23366 const char *attr_name
= attr
== nullptr ? nullptr : attr
->as_string ();
23367 if (attr_name
== nullptr
23368 && die
->tag
!= DW_TAG_namespace
23369 && die
->tag
!= DW_TAG_class_type
23370 && die
->tag
!= DW_TAG_interface_type
23371 && die
->tag
!= DW_TAG_structure_type
23372 && die
->tag
!= DW_TAG_union_type
)
23377 case DW_TAG_compile_unit
:
23378 case DW_TAG_partial_unit
:
23379 /* Compilation units have a DW_AT_name that is a filename, not
23380 a source language identifier. */
23381 case DW_TAG_enumeration_type
:
23382 case DW_TAG_enumerator
:
23383 /* These tags always have simple identifiers already; no need
23384 to canonicalize them. */
23387 case DW_TAG_namespace
:
23388 if (attr_name
!= nullptr)
23390 return CP_ANONYMOUS_NAMESPACE_STR
;
23392 case DW_TAG_class_type
:
23393 case DW_TAG_interface_type
:
23394 case DW_TAG_structure_type
:
23395 case DW_TAG_union_type
:
23396 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
23397 structures or unions. These were of the form "._%d" in GCC 4.1,
23398 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
23399 and GCC 4.4. We work around this problem by ignoring these. */
23400 if (attr_name
!= nullptr
23401 && (startswith (attr_name
, "._")
23402 || startswith (attr_name
, "<anonymous")))
23405 /* GCC might emit a nameless typedef that has a linkage name. See
23406 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
23407 if (!attr
|| attr_name
== NULL
)
23409 attr
= dw2_linkage_name_attr (die
, cu
);
23410 attr_name
= attr
== nullptr ? nullptr : attr
->as_string ();
23411 if (attr
== NULL
|| attr_name
== NULL
)
23414 /* Avoid demangling attr_name the second time on a second
23415 call for the same DIE. */
23416 if (!attr
->canonical_string_p ())
23418 gdb::unique_xmalloc_ptr
<char> demangled
23419 (gdb_demangle (attr_name
, DMGL_TYPES
));
23420 if (demangled
== nullptr)
23423 attr
->set_string_canonical (objfile
->intern (demangled
.get ()));
23424 attr_name
= attr
->as_string ();
23427 /* Strip any leading namespaces/classes, keep only the
23428 base name. DW_AT_name for named DIEs does not
23429 contain the prefixes. */
23430 const char *base
= strrchr (attr_name
, ':');
23431 if (base
&& base
> attr_name
&& base
[-1] == ':')
23442 if (!attr
->canonical_string_p ())
23443 attr
->set_string_canonical (dwarf2_canonicalize_name (attr_name
, cu
,
23445 return attr
->as_string ();
23448 /* Return the die that this die in an extension of, or NULL if there
23449 is none. *EXT_CU is the CU containing DIE on input, and the CU
23450 containing the return value on output. */
23452 static struct die_info
*
23453 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
**ext_cu
)
23455 struct attribute
*attr
;
23457 attr
= dwarf2_attr (die
, DW_AT_extension
, *ext_cu
);
23461 return follow_die_ref (die
, attr
, ext_cu
);
23465 dump_die_shallow (struct ui_file
*f
, int indent
, struct die_info
*die
)
23469 print_spaces (indent
, f
);
23470 fprintf_unfiltered (f
, "Die: %s (abbrev %d, offset %s)\n",
23471 dwarf_tag_name (die
->tag
), die
->abbrev
,
23472 sect_offset_str (die
->sect_off
));
23474 if (die
->parent
!= NULL
)
23476 print_spaces (indent
, f
);
23477 fprintf_unfiltered (f
, " parent at offset: %s\n",
23478 sect_offset_str (die
->parent
->sect_off
));
23481 print_spaces (indent
, f
);
23482 fprintf_unfiltered (f
, " has children: %s\n",
23483 dwarf_bool_name (die
->child
!= NULL
));
23485 print_spaces (indent
, f
);
23486 fprintf_unfiltered (f
, " attributes:\n");
23488 for (i
= 0; i
< die
->num_attrs
; ++i
)
23490 print_spaces (indent
, f
);
23491 fprintf_unfiltered (f
, " %s (%s) ",
23492 dwarf_attr_name (die
->attrs
[i
].name
),
23493 dwarf_form_name (die
->attrs
[i
].form
));
23495 switch (die
->attrs
[i
].form
)
23498 case DW_FORM_addrx
:
23499 case DW_FORM_GNU_addr_index
:
23500 fprintf_unfiltered (f
, "address: ");
23501 fputs_filtered (hex_string (die
->attrs
[i
].as_address ()), f
);
23503 case DW_FORM_block2
:
23504 case DW_FORM_block4
:
23505 case DW_FORM_block
:
23506 case DW_FORM_block1
:
23507 fprintf_unfiltered (f
, "block: size %s",
23508 pulongest (die
->attrs
[i
].as_block ()->size
));
23510 case DW_FORM_exprloc
:
23511 fprintf_unfiltered (f
, "expression: size %s",
23512 pulongest (die
->attrs
[i
].as_block ()->size
));
23514 case DW_FORM_data16
:
23515 fprintf_unfiltered (f
, "constant of 16 bytes");
23517 case DW_FORM_ref_addr
:
23518 fprintf_unfiltered (f
, "ref address: ");
23519 fputs_filtered (hex_string (die
->attrs
[i
].as_unsigned ()), f
);
23521 case DW_FORM_GNU_ref_alt
:
23522 fprintf_unfiltered (f
, "alt ref address: ");
23523 fputs_filtered (hex_string (die
->attrs
[i
].as_unsigned ()), f
);
23529 case DW_FORM_ref_udata
:
23530 fprintf_unfiltered (f
, "constant ref: 0x%lx (adjusted)",
23531 (long) (die
->attrs
[i
].as_unsigned ()));
23533 case DW_FORM_data1
:
23534 case DW_FORM_data2
:
23535 case DW_FORM_data4
:
23536 case DW_FORM_data8
:
23537 case DW_FORM_udata
:
23538 fprintf_unfiltered (f
, "constant: %s",
23539 pulongest (die
->attrs
[i
].as_unsigned ()));
23541 case DW_FORM_sec_offset
:
23542 fprintf_unfiltered (f
, "section offset: %s",
23543 pulongest (die
->attrs
[i
].as_unsigned ()));
23545 case DW_FORM_ref_sig8
:
23546 fprintf_unfiltered (f
, "signature: %s",
23547 hex_string (die
->attrs
[i
].as_signature ()));
23549 case DW_FORM_string
:
23551 case DW_FORM_line_strp
:
23553 case DW_FORM_GNU_str_index
:
23554 case DW_FORM_GNU_strp_alt
:
23555 fprintf_unfiltered (f
, "string: \"%s\" (%s canonicalized)",
23556 die
->attrs
[i
].as_string ()
23557 ? die
->attrs
[i
].as_string () : "",
23558 die
->attrs
[i
].canonical_string_p () ? "is" : "not");
23561 if (die
->attrs
[i
].as_boolean ())
23562 fprintf_unfiltered (f
, "flag: TRUE");
23564 fprintf_unfiltered (f
, "flag: FALSE");
23566 case DW_FORM_flag_present
:
23567 fprintf_unfiltered (f
, "flag: TRUE");
23569 case DW_FORM_indirect
:
23570 /* The reader will have reduced the indirect form to
23571 the "base form" so this form should not occur. */
23572 fprintf_unfiltered (f
,
23573 "unexpected attribute form: DW_FORM_indirect");
23575 case DW_FORM_sdata
:
23576 case DW_FORM_implicit_const
:
23577 fprintf_unfiltered (f
, "constant: %s",
23578 plongest (die
->attrs
[i
].as_signed ()));
23581 fprintf_unfiltered (f
, "unsupported attribute form: %d.",
23582 die
->attrs
[i
].form
);
23585 fprintf_unfiltered (f
, "\n");
23590 dump_die_for_error (struct die_info
*die
)
23592 dump_die_shallow (gdb_stderr
, 0, die
);
23596 dump_die_1 (struct ui_file
*f
, int level
, int max_level
, struct die_info
*die
)
23598 int indent
= level
* 4;
23600 gdb_assert (die
!= NULL
);
23602 if (level
>= max_level
)
23605 dump_die_shallow (f
, indent
, die
);
23607 if (die
->child
!= NULL
)
23609 print_spaces (indent
, f
);
23610 fprintf_unfiltered (f
, " Children:");
23611 if (level
+ 1 < max_level
)
23613 fprintf_unfiltered (f
, "\n");
23614 dump_die_1 (f
, level
+ 1, max_level
, die
->child
);
23618 fprintf_unfiltered (f
,
23619 " [not printed, max nesting level reached]\n");
23623 if (die
->sibling
!= NULL
&& level
> 0)
23625 dump_die_1 (f
, level
, max_level
, die
->sibling
);
23629 /* This is called from the pdie macro in gdbinit.in.
23630 It's not static so gcc will keep a copy callable from gdb. */
23633 dump_die (struct die_info
*die
, int max_level
)
23635 dump_die_1 (gdb_stdlog
, 0, max_level
, die
);
23639 store_in_ref_table (struct die_info
*die
, struct dwarf2_cu
*cu
)
23643 slot
= htab_find_slot_with_hash (cu
->die_hash
, die
,
23644 to_underlying (die
->sect_off
),
23650 /* Follow reference or signature attribute ATTR of SRC_DIE.
23651 On entry *REF_CU is the CU of SRC_DIE.
23652 On exit *REF_CU is the CU of the result. */
23654 static struct die_info
*
23655 follow_die_ref_or_sig (struct die_info
*src_die
, const struct attribute
*attr
,
23656 struct dwarf2_cu
**ref_cu
)
23658 struct die_info
*die
;
23660 if (attr
->form_is_ref ())
23661 die
= follow_die_ref (src_die
, attr
, ref_cu
);
23662 else if (attr
->form
== DW_FORM_ref_sig8
)
23663 die
= follow_die_sig (src_die
, attr
, ref_cu
);
23666 dump_die_for_error (src_die
);
23667 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
23668 objfile_name ((*ref_cu
)->per_objfile
->objfile
));
23674 /* Follow reference OFFSET.
23675 On entry *REF_CU is the CU of the source die referencing OFFSET.
23676 On exit *REF_CU is the CU of the result.
23677 Returns NULL if OFFSET is invalid. */
23679 static struct die_info
*
23680 follow_die_offset (sect_offset sect_off
, int offset_in_dwz
,
23681 struct dwarf2_cu
**ref_cu
)
23683 struct die_info temp_die
;
23684 struct dwarf2_cu
*target_cu
, *cu
= *ref_cu
;
23685 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
23687 gdb_assert (cu
->per_cu
!= NULL
);
23691 dwarf_read_debug_printf_v ("source CU offset: %s, target offset: %s, "
23692 "source CU contains target offset: %d",
23693 sect_offset_str (cu
->per_cu
->sect_off
),
23694 sect_offset_str (sect_off
),
23695 cu
->header
.offset_in_cu_p (sect_off
));
23697 if (cu
->per_cu
->is_debug_types
)
23699 /* .debug_types CUs cannot reference anything outside their CU.
23700 If they need to, they have to reference a signatured type via
23701 DW_FORM_ref_sig8. */
23702 if (!cu
->header
.offset_in_cu_p (sect_off
))
23705 else if (offset_in_dwz
!= cu
->per_cu
->is_dwz
23706 || !cu
->header
.offset_in_cu_p (sect_off
))
23708 struct dwarf2_per_cu_data
*per_cu
;
23710 per_cu
= dwarf2_find_containing_comp_unit (sect_off
, offset_in_dwz
,
23713 dwarf_read_debug_printf_v ("target CU offset: %s, "
23714 "target CU DIEs loaded: %d",
23715 sect_offset_str (per_cu
->sect_off
),
23716 per_objfile
->get_cu (per_cu
) != nullptr);
23718 /* If necessary, add it to the queue and load its DIEs.
23720 Even if maybe_queue_comp_unit doesn't require us to load the CU's DIEs,
23721 it doesn't mean they are currently loaded. Since we require them
23722 to be loaded, we must check for ourselves. */
23723 if (maybe_queue_comp_unit (cu
, per_cu
, per_objfile
, cu
->language
)
23724 || per_objfile
->get_cu (per_cu
) == nullptr)
23725 load_full_comp_unit (per_cu
, per_objfile
, per_objfile
->get_cu (per_cu
),
23726 false, cu
->language
);
23728 target_cu
= per_objfile
->get_cu (per_cu
);
23729 gdb_assert (target_cu
!= nullptr);
23731 else if (cu
->dies
== NULL
)
23733 /* We're loading full DIEs during partial symbol reading. */
23734 gdb_assert (per_objfile
->per_bfd
->reading_partial_symbols
);
23735 load_full_comp_unit (cu
->per_cu
, per_objfile
, cu
, false,
23739 *ref_cu
= target_cu
;
23740 temp_die
.sect_off
= sect_off
;
23742 if (target_cu
!= cu
)
23743 target_cu
->ancestor
= cu
;
23745 return (struct die_info
*) htab_find_with_hash (target_cu
->die_hash
,
23747 to_underlying (sect_off
));
23750 /* Follow reference attribute ATTR of SRC_DIE.
23751 On entry *REF_CU is the CU of SRC_DIE.
23752 On exit *REF_CU is the CU of the result. */
23754 static struct die_info
*
23755 follow_die_ref (struct die_info
*src_die
, const struct attribute
*attr
,
23756 struct dwarf2_cu
**ref_cu
)
23758 sect_offset sect_off
= attr
->get_ref_die_offset ();
23759 struct dwarf2_cu
*cu
= *ref_cu
;
23760 struct die_info
*die
;
23762 die
= follow_die_offset (sect_off
,
23763 (attr
->form
== DW_FORM_GNU_ref_alt
23764 || cu
->per_cu
->is_dwz
),
23767 error (_("Dwarf Error: Cannot find DIE at %s referenced from DIE "
23768 "at %s [in module %s]"),
23769 sect_offset_str (sect_off
), sect_offset_str (src_die
->sect_off
),
23770 objfile_name (cu
->per_objfile
->objfile
));
23777 struct dwarf2_locexpr_baton
23778 dwarf2_fetch_die_loc_sect_off (sect_offset sect_off
,
23779 dwarf2_per_cu_data
*per_cu
,
23780 dwarf2_per_objfile
*per_objfile
,
23781 gdb::function_view
<CORE_ADDR ()> get_frame_pc
,
23782 bool resolve_abstract_p
)
23784 struct die_info
*die
;
23785 struct attribute
*attr
;
23786 struct dwarf2_locexpr_baton retval
;
23787 struct objfile
*objfile
= per_objfile
->objfile
;
23789 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
23791 cu
= load_cu (per_cu
, per_objfile
, false);
23795 /* We shouldn't get here for a dummy CU, but don't crash on the user.
23796 Instead just throw an error, not much else we can do. */
23797 error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23798 sect_offset_str (sect_off
), objfile_name (objfile
));
23801 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
23803 error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23804 sect_offset_str (sect_off
), objfile_name (objfile
));
23806 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
23807 if (!attr
&& resolve_abstract_p
23808 && (per_objfile
->per_bfd
->abstract_to_concrete
.find (die
->sect_off
)
23809 != per_objfile
->per_bfd
->abstract_to_concrete
.end ()))
23811 CORE_ADDR pc
= get_frame_pc ();
23812 CORE_ADDR baseaddr
= objfile
->text_section_offset ();
23813 struct gdbarch
*gdbarch
= objfile
->arch ();
23815 for (const auto &cand_off
23816 : per_objfile
->per_bfd
->abstract_to_concrete
[die
->sect_off
])
23818 struct dwarf2_cu
*cand_cu
= cu
;
23819 struct die_info
*cand
23820 = follow_die_offset (cand_off
, per_cu
->is_dwz
, &cand_cu
);
23823 || cand
->parent
->tag
!= DW_TAG_subprogram
)
23826 CORE_ADDR pc_low
, pc_high
;
23827 get_scope_pc_bounds (cand
->parent
, &pc_low
, &pc_high
, cu
);
23828 if (pc_low
== ((CORE_ADDR
) -1))
23830 pc_low
= gdbarch_adjust_dwarf2_addr (gdbarch
, pc_low
+ baseaddr
);
23831 pc_high
= gdbarch_adjust_dwarf2_addr (gdbarch
, pc_high
+ baseaddr
);
23832 if (!(pc_low
<= pc
&& pc
< pc_high
))
23836 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
23843 /* DWARF: "If there is no such attribute, then there is no effect.".
23844 DATA is ignored if SIZE is 0. */
23846 retval
.data
= NULL
;
23849 else if (attr
->form_is_section_offset ())
23851 struct dwarf2_loclist_baton loclist_baton
;
23852 CORE_ADDR pc
= get_frame_pc ();
23855 fill_in_loclist_baton (cu
, &loclist_baton
, attr
);
23857 retval
.data
= dwarf2_find_location_expression (&loclist_baton
,
23859 retval
.size
= size
;
23863 if (!attr
->form_is_block ())
23864 error (_("Dwarf Error: DIE at %s referenced in module %s "
23865 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
23866 sect_offset_str (sect_off
), objfile_name (objfile
));
23868 struct dwarf_block
*block
= attr
->as_block ();
23869 retval
.data
= block
->data
;
23870 retval
.size
= block
->size
;
23872 retval
.per_objfile
= per_objfile
;
23873 retval
.per_cu
= cu
->per_cu
;
23875 per_objfile
->age_comp_units ();
23882 struct dwarf2_locexpr_baton
23883 dwarf2_fetch_die_loc_cu_off (cu_offset offset_in_cu
,
23884 dwarf2_per_cu_data
*per_cu
,
23885 dwarf2_per_objfile
*per_objfile
,
23886 gdb::function_view
<CORE_ADDR ()> get_frame_pc
)
23888 sect_offset sect_off
= per_cu
->sect_off
+ to_underlying (offset_in_cu
);
23890 return dwarf2_fetch_die_loc_sect_off (sect_off
, per_cu
, per_objfile
,
23894 /* Write a constant of a given type as target-ordered bytes into
23897 static const gdb_byte
*
23898 write_constant_as_bytes (struct obstack
*obstack
,
23899 enum bfd_endian byte_order
,
23906 *len
= TYPE_LENGTH (type
);
23907 result
= (gdb_byte
*) obstack_alloc (obstack
, *len
);
23908 store_unsigned_integer (result
, *len
, byte_order
, value
);
23916 dwarf2_fetch_constant_bytes (sect_offset sect_off
,
23917 dwarf2_per_cu_data
*per_cu
,
23918 dwarf2_per_objfile
*per_objfile
,
23922 struct die_info
*die
;
23923 struct attribute
*attr
;
23924 const gdb_byte
*result
= NULL
;
23927 enum bfd_endian byte_order
;
23928 struct objfile
*objfile
= per_objfile
->objfile
;
23930 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
23932 cu
= load_cu (per_cu
, per_objfile
, false);
23936 /* We shouldn't get here for a dummy CU, but don't crash on the user.
23937 Instead just throw an error, not much else we can do. */
23938 error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23939 sect_offset_str (sect_off
), objfile_name (objfile
));
23942 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
23944 error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23945 sect_offset_str (sect_off
), objfile_name (objfile
));
23947 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
23951 byte_order
= (bfd_big_endian (objfile
->obfd
)
23952 ? BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
23954 switch (attr
->form
)
23957 case DW_FORM_addrx
:
23958 case DW_FORM_GNU_addr_index
:
23962 *len
= cu
->header
.addr_size
;
23963 tem
= (gdb_byte
*) obstack_alloc (obstack
, *len
);
23964 store_unsigned_integer (tem
, *len
, byte_order
, attr
->as_address ());
23968 case DW_FORM_string
:
23971 case DW_FORM_GNU_str_index
:
23972 case DW_FORM_GNU_strp_alt
:
23973 /* The string is already allocated on the objfile obstack, point
23976 const char *attr_name
= attr
->as_string ();
23977 result
= (const gdb_byte
*) attr_name
;
23978 *len
= strlen (attr_name
);
23981 case DW_FORM_block1
:
23982 case DW_FORM_block2
:
23983 case DW_FORM_block4
:
23984 case DW_FORM_block
:
23985 case DW_FORM_exprloc
:
23986 case DW_FORM_data16
:
23988 struct dwarf_block
*block
= attr
->as_block ();
23989 result
= block
->data
;
23990 *len
= block
->size
;
23994 /* The DW_AT_const_value attributes are supposed to carry the
23995 symbol's value "represented as it would be on the target
23996 architecture." By the time we get here, it's already been
23997 converted to host endianness, so we just need to sign- or
23998 zero-extend it as appropriate. */
23999 case DW_FORM_data1
:
24000 type
= die_type (die
, cu
);
24001 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 8);
24002 if (result
== NULL
)
24003 result
= write_constant_as_bytes (obstack
, byte_order
,
24006 case DW_FORM_data2
:
24007 type
= die_type (die
, cu
);
24008 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 16);
24009 if (result
== NULL
)
24010 result
= write_constant_as_bytes (obstack
, byte_order
,
24013 case DW_FORM_data4
:
24014 type
= die_type (die
, cu
);
24015 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 32);
24016 if (result
== NULL
)
24017 result
= write_constant_as_bytes (obstack
, byte_order
,
24020 case DW_FORM_data8
:
24021 type
= die_type (die
, cu
);
24022 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 64);
24023 if (result
== NULL
)
24024 result
= write_constant_as_bytes (obstack
, byte_order
,
24028 case DW_FORM_sdata
:
24029 case DW_FORM_implicit_const
:
24030 type
= die_type (die
, cu
);
24031 result
= write_constant_as_bytes (obstack
, byte_order
,
24032 type
, attr
->as_signed (), len
);
24035 case DW_FORM_udata
:
24036 type
= die_type (die
, cu
);
24037 result
= write_constant_as_bytes (obstack
, byte_order
,
24038 type
, attr
->as_unsigned (), len
);
24042 complaint (_("unsupported const value attribute form: '%s'"),
24043 dwarf_form_name (attr
->form
));
24053 dwarf2_fetch_die_type_sect_off (sect_offset sect_off
,
24054 dwarf2_per_cu_data
*per_cu
,
24055 dwarf2_per_objfile
*per_objfile
)
24057 struct die_info
*die
;
24059 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
24061 cu
= load_cu (per_cu
, per_objfile
, false);
24066 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
24070 return die_type (die
, cu
);
24076 dwarf2_get_die_type (cu_offset die_offset
,
24077 dwarf2_per_cu_data
*per_cu
,
24078 dwarf2_per_objfile
*per_objfile
)
24080 sect_offset die_offset_sect
= per_cu
->sect_off
+ to_underlying (die_offset
);
24081 return get_die_type_at_offset (die_offset_sect
, per_cu
, per_objfile
);
24084 /* Follow type unit SIG_TYPE referenced by SRC_DIE.
24085 On entry *REF_CU is the CU of SRC_DIE.
24086 On exit *REF_CU is the CU of the result.
24087 Returns NULL if the referenced DIE isn't found. */
24089 static struct die_info
*
24090 follow_die_sig_1 (struct die_info
*src_die
, struct signatured_type
*sig_type
,
24091 struct dwarf2_cu
**ref_cu
)
24093 struct die_info temp_die
;
24094 struct dwarf2_cu
*sig_cu
, *cu
= *ref_cu
;
24095 struct die_info
*die
;
24096 dwarf2_per_objfile
*per_objfile
= (*ref_cu
)->per_objfile
;
24099 /* While it might be nice to assert sig_type->type == NULL here,
24100 we can get here for DW_AT_imported_declaration where we need
24101 the DIE not the type. */
24103 /* If necessary, add it to the queue and load its DIEs.
24105 Even if maybe_queue_comp_unit doesn't require us to load the CU's DIEs,
24106 it doesn't mean they are currently loaded. Since we require them
24107 to be loaded, we must check for ourselves. */
24108 if (maybe_queue_comp_unit (*ref_cu
, &sig_type
->per_cu
, per_objfile
,
24110 || per_objfile
->get_cu (&sig_type
->per_cu
) == nullptr)
24111 read_signatured_type (sig_type
, per_objfile
);
24113 sig_cu
= per_objfile
->get_cu (&sig_type
->per_cu
);
24114 gdb_assert (sig_cu
!= NULL
);
24115 gdb_assert (to_underlying (sig_type
->type_offset_in_section
) != 0);
24116 temp_die
.sect_off
= sig_type
->type_offset_in_section
;
24117 die
= (struct die_info
*) htab_find_with_hash (sig_cu
->die_hash
, &temp_die
,
24118 to_underlying (temp_die
.sect_off
));
24121 /* For .gdb_index version 7 keep track of included TUs.
24122 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
24123 if (per_objfile
->per_bfd
->index_table
!= NULL
24124 && per_objfile
->per_bfd
->index_table
->version
<= 7)
24126 (*ref_cu
)->per_cu
->imported_symtabs_push (sig_cu
->per_cu
);
24131 sig_cu
->ancestor
= cu
;
24139 /* Follow signatured type referenced by ATTR in SRC_DIE.
24140 On entry *REF_CU is the CU of SRC_DIE.
24141 On exit *REF_CU is the CU of the result.
24142 The result is the DIE of the type.
24143 If the referenced type cannot be found an error is thrown. */
24145 static struct die_info
*
24146 follow_die_sig (struct die_info
*src_die
, const struct attribute
*attr
,
24147 struct dwarf2_cu
**ref_cu
)
24149 ULONGEST signature
= attr
->as_signature ();
24150 struct signatured_type
*sig_type
;
24151 struct die_info
*die
;
24153 gdb_assert (attr
->form
== DW_FORM_ref_sig8
);
24155 sig_type
= lookup_signatured_type (*ref_cu
, signature
);
24156 /* sig_type will be NULL if the signatured type is missing from
24158 if (sig_type
== NULL
)
24160 error (_("Dwarf Error: Cannot find signatured DIE %s referenced"
24161 " from DIE at %s [in module %s]"),
24162 hex_string (signature
), sect_offset_str (src_die
->sect_off
),
24163 objfile_name ((*ref_cu
)->per_objfile
->objfile
));
24166 die
= follow_die_sig_1 (src_die
, sig_type
, ref_cu
);
24169 dump_die_for_error (src_die
);
24170 error (_("Dwarf Error: Problem reading signatured DIE %s referenced"
24171 " from DIE at %s [in module %s]"),
24172 hex_string (signature
), sect_offset_str (src_die
->sect_off
),
24173 objfile_name ((*ref_cu
)->per_objfile
->objfile
));
24179 /* Get the type specified by SIGNATURE referenced in DIE/CU,
24180 reading in and processing the type unit if necessary. */
24182 static struct type
*
24183 get_signatured_type (struct die_info
*die
, ULONGEST signature
,
24184 struct dwarf2_cu
*cu
)
24186 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
24187 struct signatured_type
*sig_type
;
24188 struct dwarf2_cu
*type_cu
;
24189 struct die_info
*type_die
;
24192 sig_type
= lookup_signatured_type (cu
, signature
);
24193 /* sig_type will be NULL if the signatured type is missing from
24195 if (sig_type
== NULL
)
24197 complaint (_("Dwarf Error: Cannot find signatured DIE %s referenced"
24198 " from DIE at %s [in module %s]"),
24199 hex_string (signature
), sect_offset_str (die
->sect_off
),
24200 objfile_name (per_objfile
->objfile
));
24201 return build_error_marker_type (cu
, die
);
24204 /* If we already know the type we're done. */
24205 type
= per_objfile
->get_type_for_signatured_type (sig_type
);
24206 if (type
!= nullptr)
24210 type_die
= follow_die_sig_1 (die
, sig_type
, &type_cu
);
24211 if (type_die
!= NULL
)
24213 /* N.B. We need to call get_die_type to ensure only one type for this DIE
24214 is created. This is important, for example, because for c++ classes
24215 we need TYPE_NAME set which is only done by new_symbol. Blech. */
24216 type
= read_type_die (type_die
, type_cu
);
24219 complaint (_("Dwarf Error: Cannot build signatured type %s"
24220 " referenced from DIE at %s [in module %s]"),
24221 hex_string (signature
), sect_offset_str (die
->sect_off
),
24222 objfile_name (per_objfile
->objfile
));
24223 type
= build_error_marker_type (cu
, die
);
24228 complaint (_("Dwarf Error: Problem reading signatured DIE %s referenced"
24229 " from DIE at %s [in module %s]"),
24230 hex_string (signature
), sect_offset_str (die
->sect_off
),
24231 objfile_name (per_objfile
->objfile
));
24232 type
= build_error_marker_type (cu
, die
);
24235 per_objfile
->set_type_for_signatured_type (sig_type
, type
);
24240 /* Get the type specified by the DW_AT_signature ATTR in DIE/CU,
24241 reading in and processing the type unit if necessary. */
24243 static struct type
*
24244 get_DW_AT_signature_type (struct die_info
*die
, const struct attribute
*attr
,
24245 struct dwarf2_cu
*cu
) /* ARI: editCase function */
24247 /* Yes, DW_AT_signature can use a non-ref_sig8 reference. */
24248 if (attr
->form_is_ref ())
24250 struct dwarf2_cu
*type_cu
= cu
;
24251 struct die_info
*type_die
= follow_die_ref (die
, attr
, &type_cu
);
24253 return read_type_die (type_die
, type_cu
);
24255 else if (attr
->form
== DW_FORM_ref_sig8
)
24257 return get_signatured_type (die
, attr
->as_signature (), cu
);
24261 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
24263 complaint (_("Dwarf Error: DW_AT_signature has bad form %s in DIE"
24264 " at %s [in module %s]"),
24265 dwarf_form_name (attr
->form
), sect_offset_str (die
->sect_off
),
24266 objfile_name (per_objfile
->objfile
));
24267 return build_error_marker_type (cu
, die
);
24271 /* Load the DIEs associated with type unit PER_CU into memory. */
24274 load_full_type_unit (dwarf2_per_cu_data
*per_cu
,
24275 dwarf2_per_objfile
*per_objfile
)
24277 struct signatured_type
*sig_type
;
24279 /* Caller is responsible for ensuring type_unit_groups don't get here. */
24280 gdb_assert (! per_cu
->type_unit_group_p ());
24282 /* We have the per_cu, but we need the signatured_type.
24283 Fortunately this is an easy translation. */
24284 gdb_assert (per_cu
->is_debug_types
);
24285 sig_type
= (struct signatured_type
*) per_cu
;
24287 gdb_assert (per_objfile
->get_cu (per_cu
) == nullptr);
24289 read_signatured_type (sig_type
, per_objfile
);
24291 gdb_assert (per_objfile
->get_cu (per_cu
) != nullptr);
24294 /* Read in a signatured type and build its CU and DIEs.
24295 If the type is a stub for the real type in a DWO file,
24296 read in the real type from the DWO file as well. */
24299 read_signatured_type (signatured_type
*sig_type
,
24300 dwarf2_per_objfile
*per_objfile
)
24302 struct dwarf2_per_cu_data
*per_cu
= &sig_type
->per_cu
;
24304 gdb_assert (per_cu
->is_debug_types
);
24305 gdb_assert (per_objfile
->get_cu (per_cu
) == nullptr);
24307 cutu_reader
reader (per_cu
, per_objfile
, nullptr, nullptr, false);
24309 if (!reader
.dummy_p
)
24311 struct dwarf2_cu
*cu
= reader
.cu
;
24312 const gdb_byte
*info_ptr
= reader
.info_ptr
;
24314 gdb_assert (cu
->die_hash
== NULL
);
24316 htab_create_alloc_ex (cu
->header
.length
/ 12,
24320 &cu
->comp_unit_obstack
,
24321 hashtab_obstack_allocate
,
24322 dummy_obstack_deallocate
);
24324 if (reader
.comp_unit_die
->has_children
)
24325 reader
.comp_unit_die
->child
24326 = read_die_and_siblings (&reader
, info_ptr
, &info_ptr
,
24327 reader
.comp_unit_die
);
24328 cu
->dies
= reader
.comp_unit_die
;
24329 /* comp_unit_die is not stored in die_hash, no need. */
24331 /* We try not to read any attributes in this function, because
24332 not all CUs needed for references have been loaded yet, and
24333 symbol table processing isn't initialized. But we have to
24334 set the CU language, or we won't be able to build types
24335 correctly. Similarly, if we do not read the producer, we can
24336 not apply producer-specific interpretation. */
24337 prepare_one_comp_unit (cu
, cu
->dies
, language_minimal
);
24342 sig_type
->per_cu
.tu_read
= 1;
24345 /* Decode simple location descriptions.
24346 Given a pointer to a dwarf block that defines a location, compute
24347 the location and return the value. If COMPUTED is non-null, it is
24348 set to true to indicate that decoding was successful, and false
24349 otherwise. If COMPUTED is null, then this function may emit a
24353 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
, bool *computed
)
24355 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
24357 size_t size
= blk
->size
;
24358 const gdb_byte
*data
= blk
->data
;
24359 CORE_ADDR stack
[64];
24361 unsigned int bytes_read
, unsnd
;
24364 if (computed
!= nullptr)
24370 stack
[++stacki
] = 0;
24409 stack
[++stacki
] = op
- DW_OP_lit0
;
24444 stack
[++stacki
] = op
- DW_OP_reg0
;
24447 if (computed
== nullptr)
24448 dwarf2_complex_location_expr_complaint ();
24455 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
24457 stack
[++stacki
] = unsnd
;
24460 if (computed
== nullptr)
24461 dwarf2_complex_location_expr_complaint ();
24468 stack
[++stacki
] = cu
->header
.read_address (objfile
->obfd
, &data
[i
],
24473 case DW_OP_const1u
:
24474 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
24478 case DW_OP_const1s
:
24479 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
24483 case DW_OP_const2u
:
24484 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
24488 case DW_OP_const2s
:
24489 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
24493 case DW_OP_const4u
:
24494 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
24498 case DW_OP_const4s
:
24499 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
24503 case DW_OP_const8u
:
24504 stack
[++stacki
] = read_8_bytes (objfile
->obfd
, &data
[i
]);
24509 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
24515 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
24520 stack
[stacki
+ 1] = stack
[stacki
];
24525 stack
[stacki
- 1] += stack
[stacki
];
24529 case DW_OP_plus_uconst
:
24530 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
),
24536 stack
[stacki
- 1] -= stack
[stacki
];
24541 /* If we're not the last op, then we definitely can't encode
24542 this using GDB's address_class enum. This is valid for partial
24543 global symbols, although the variable's address will be bogus
24547 if (computed
== nullptr)
24548 dwarf2_complex_location_expr_complaint ();
24554 case DW_OP_GNU_push_tls_address
:
24555 case DW_OP_form_tls_address
:
24556 /* The top of the stack has the offset from the beginning
24557 of the thread control block at which the variable is located. */
24558 /* Nothing should follow this operator, so the top of stack would
24560 /* This is valid for partial global symbols, but the variable's
24561 address will be bogus in the psymtab. Make it always at least
24562 non-zero to not look as a variable garbage collected by linker
24563 which have DW_OP_addr 0. */
24566 if (computed
== nullptr)
24567 dwarf2_complex_location_expr_complaint ();
24574 case DW_OP_GNU_uninit
:
24575 if (computed
!= nullptr)
24580 case DW_OP_GNU_addr_index
:
24581 case DW_OP_GNU_const_index
:
24582 stack
[++stacki
] = read_addr_index_from_leb128 (cu
, &data
[i
],
24588 if (computed
== nullptr)
24590 const char *name
= get_DW_OP_name (op
);
24593 complaint (_("unsupported stack op: '%s'"),
24596 complaint (_("unsupported stack op: '%02x'"),
24600 return (stack
[stacki
]);
24603 /* Enforce maximum stack depth of SIZE-1 to avoid writing
24604 outside of the allocated space. Also enforce minimum>0. */
24605 if (stacki
>= ARRAY_SIZE (stack
) - 1)
24607 if (computed
== nullptr)
24608 complaint (_("location description stack overflow"));
24614 if (computed
== nullptr)
24615 complaint (_("location description stack underflow"));
24620 if (computed
!= nullptr)
24622 return (stack
[stacki
]);
24625 /* memory allocation interface */
24627 static struct dwarf_block
*
24628 dwarf_alloc_block (struct dwarf2_cu
*cu
)
24630 return XOBNEW (&cu
->comp_unit_obstack
, struct dwarf_block
);
24633 static struct die_info
*
24634 dwarf_alloc_die (struct dwarf2_cu
*cu
, int num_attrs
)
24636 struct die_info
*die
;
24637 size_t size
= sizeof (struct die_info
);
24640 size
+= (num_attrs
- 1) * sizeof (struct attribute
);
24642 die
= (struct die_info
*) obstack_alloc (&cu
->comp_unit_obstack
, size
);
24643 memset (die
, 0, sizeof (struct die_info
));
24649 /* Macro support. */
24651 /* An overload of dwarf_decode_macros that finds the correct section
24652 and ensures it is read in before calling the other overload. */
24655 dwarf_decode_macros (struct dwarf2_cu
*cu
, unsigned int offset
,
24656 int section_is_gnu
)
24658 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
24659 struct objfile
*objfile
= per_objfile
->objfile
;
24660 const struct line_header
*lh
= cu
->line_header
;
24661 unsigned int offset_size
= cu
->header
.offset_size
;
24662 struct dwarf2_section_info
*section
;
24663 const char *section_name
;
24665 if (cu
->dwo_unit
!= nullptr)
24667 if (section_is_gnu
)
24669 section
= &cu
->dwo_unit
->dwo_file
->sections
.macro
;
24670 section_name
= ".debug_macro.dwo";
24674 section
= &cu
->dwo_unit
->dwo_file
->sections
.macinfo
;
24675 section_name
= ".debug_macinfo.dwo";
24680 if (section_is_gnu
)
24682 section
= &per_objfile
->per_bfd
->macro
;
24683 section_name
= ".debug_macro";
24687 section
= &per_objfile
->per_bfd
->macinfo
;
24688 section_name
= ".debug_macinfo";
24692 section
->read (objfile
);
24693 if (section
->buffer
== nullptr)
24695 complaint (_("missing %s section"), section_name
);
24699 buildsym_compunit
*builder
= cu
->get_builder ();
24701 struct dwarf2_section_info
*str_offsets_section
;
24702 struct dwarf2_section_info
*str_section
;
24703 ULONGEST str_offsets_base
;
24705 if (cu
->dwo_unit
!= nullptr)
24707 str_offsets_section
= &cu
->dwo_unit
->dwo_file
24708 ->sections
.str_offsets
;
24709 str_section
= &cu
->dwo_unit
->dwo_file
->sections
.str
;
24710 str_offsets_base
= cu
->header
.addr_size
;
24714 str_offsets_section
= &per_objfile
->per_bfd
->str_offsets
;
24715 str_section
= &per_objfile
->per_bfd
->str
;
24716 str_offsets_base
= *cu
->str_offsets_base
;
24719 dwarf_decode_macros (per_objfile
, builder
, section
, lh
,
24720 offset_size
, offset
, str_section
, str_offsets_section
,
24721 str_offsets_base
, section_is_gnu
);
24724 /* Return the .debug_loc section to use for CU.
24725 For DWO files use .debug_loc.dwo. */
24727 static struct dwarf2_section_info
*
24728 cu_debug_loc_section (struct dwarf2_cu
*cu
)
24730 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
24734 struct dwo_sections
*sections
= &cu
->dwo_unit
->dwo_file
->sections
;
24736 return cu
->header
.version
>= 5 ? §ions
->loclists
: §ions
->loc
;
24738 return (cu
->header
.version
>= 5 ? &per_objfile
->per_bfd
->loclists
24739 : &per_objfile
->per_bfd
->loc
);
24742 /* Return the .debug_rnglists section to use for CU. */
24743 static struct dwarf2_section_info
*
24744 cu_debug_rnglists_section (struct dwarf2_cu
*cu
, dwarf_tag tag
)
24746 if (cu
->header
.version
< 5)
24747 error (_(".debug_rnglists section cannot be used in DWARF %d"),
24748 cu
->header
.version
);
24749 struct dwarf2_per_objfile
*dwarf2_per_objfile
= cu
->per_objfile
;
24751 /* Make sure we read the .debug_rnglists section from the file that
24752 contains the DW_AT_ranges attribute we are reading. Normally that
24753 would be the .dwo file, if there is one. However for DW_TAG_compile_unit
24754 or DW_TAG_skeleton unit, we always want to read from objfile/linked
24756 if (cu
->dwo_unit
!= nullptr
24757 && tag
!= DW_TAG_compile_unit
24758 && tag
!= DW_TAG_skeleton_unit
)
24760 struct dwo_sections
*sections
= &cu
->dwo_unit
->dwo_file
->sections
;
24762 if (sections
->rnglists
.size
> 0)
24763 return §ions
->rnglists
;
24765 error (_(".debug_rnglists section is missing from .dwo file."));
24767 return &dwarf2_per_objfile
->per_bfd
->rnglists
;
24770 /* A helper function that fills in a dwarf2_loclist_baton. */
24773 fill_in_loclist_baton (struct dwarf2_cu
*cu
,
24774 struct dwarf2_loclist_baton
*baton
,
24775 const struct attribute
*attr
)
24777 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
24778 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
24780 section
->read (per_objfile
->objfile
);
24782 baton
->per_objfile
= per_objfile
;
24783 baton
->per_cu
= cu
->per_cu
;
24784 gdb_assert (baton
->per_cu
);
24785 /* We don't know how long the location list is, but make sure we
24786 don't run off the edge of the section. */
24787 baton
->size
= section
->size
- attr
->as_unsigned ();
24788 baton
->data
= section
->buffer
+ attr
->as_unsigned ();
24789 if (cu
->base_address
.has_value ())
24790 baton
->base_address
= *cu
->base_address
;
24792 baton
->base_address
= 0;
24793 baton
->from_dwo
= cu
->dwo_unit
!= NULL
;
24797 dwarf2_symbol_mark_computed (const struct attribute
*attr
, struct symbol
*sym
,
24798 struct dwarf2_cu
*cu
, int is_block
)
24800 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
24801 struct objfile
*objfile
= per_objfile
->objfile
;
24802 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
24804 if (attr
->form_is_section_offset ()
24805 /* .debug_loc{,.dwo} may not exist at all, or the offset may be outside
24806 the section. If so, fall through to the complaint in the
24808 && attr
->as_unsigned () < section
->get_size (objfile
))
24810 struct dwarf2_loclist_baton
*baton
;
24812 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_loclist_baton
);
24814 fill_in_loclist_baton (cu
, baton
, attr
);
24816 if (!cu
->base_address
.has_value ())
24817 complaint (_("Location list used without "
24818 "specifying the CU base address."));
24820 SYMBOL_ACLASS_INDEX (sym
) = (is_block
24821 ? dwarf2_loclist_block_index
24822 : dwarf2_loclist_index
);
24823 SYMBOL_LOCATION_BATON (sym
) = baton
;
24827 struct dwarf2_locexpr_baton
*baton
;
24829 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
24830 baton
->per_objfile
= per_objfile
;
24831 baton
->per_cu
= cu
->per_cu
;
24832 gdb_assert (baton
->per_cu
);
24834 if (attr
->form_is_block ())
24836 /* Note that we're just copying the block's data pointer
24837 here, not the actual data. We're still pointing into the
24838 info_buffer for SYM's objfile; right now we never release
24839 that buffer, but when we do clean up properly this may
24841 struct dwarf_block
*block
= attr
->as_block ();
24842 baton
->size
= block
->size
;
24843 baton
->data
= block
->data
;
24847 dwarf2_invalid_attrib_class_complaint ("location description",
24848 sym
->natural_name ());
24852 SYMBOL_ACLASS_INDEX (sym
) = (is_block
24853 ? dwarf2_locexpr_block_index
24854 : dwarf2_locexpr_index
);
24855 SYMBOL_LOCATION_BATON (sym
) = baton
;
24861 const comp_unit_head
*
24862 dwarf2_per_cu_data::get_header () const
24864 if (!m_header_read_in
)
24866 const gdb_byte
*info_ptr
24867 = this->section
->buffer
+ to_underlying (this->sect_off
);
24869 memset (&m_header
, 0, sizeof (m_header
));
24871 read_comp_unit_head (&m_header
, info_ptr
, this->section
,
24872 rcuh_kind::COMPILE
);
24874 m_header_read_in
= true;
24883 dwarf2_per_cu_data::addr_size () const
24885 return this->get_header ()->addr_size
;
24891 dwarf2_per_cu_data::offset_size () const
24893 return this->get_header ()->offset_size
;
24899 dwarf2_per_cu_data::ref_addr_size () const
24901 const comp_unit_head
*header
= this->get_header ();
24903 if (header
->version
== 2)
24904 return header
->addr_size
;
24906 return header
->offset_size
;
24912 dwarf2_cu::addr_type () const
24914 struct objfile
*objfile
= this->per_objfile
->objfile
;
24915 struct type
*void_type
= objfile_type (objfile
)->builtin_void
;
24916 struct type
*addr_type
= lookup_pointer_type (void_type
);
24917 int addr_size
= this->per_cu
->addr_size ();
24919 if (TYPE_LENGTH (addr_type
) == addr_size
)
24922 addr_type
= addr_sized_int_type (addr_type
->is_unsigned ());
24926 /* A helper function for dwarf2_find_containing_comp_unit that returns
24927 the index of the result, and that searches a vector. It will
24928 return a result even if the offset in question does not actually
24929 occur in any CU. This is separate so that it can be unit
24933 dwarf2_find_containing_comp_unit
24934 (sect_offset sect_off
,
24935 unsigned int offset_in_dwz
,
24936 const std::vector
<dwarf2_per_cu_data
*> &all_comp_units
)
24941 high
= all_comp_units
.size () - 1;
24944 struct dwarf2_per_cu_data
*mid_cu
;
24945 int mid
= low
+ (high
- low
) / 2;
24947 mid_cu
= all_comp_units
[mid
];
24948 if (mid_cu
->is_dwz
> offset_in_dwz
24949 || (mid_cu
->is_dwz
== offset_in_dwz
24950 && mid_cu
->sect_off
+ mid_cu
->length
> sect_off
))
24955 gdb_assert (low
== high
);
24959 /* Locate the .debug_info compilation unit from CU's objfile which contains
24960 the DIE at OFFSET. Raises an error on failure. */
24962 static struct dwarf2_per_cu_data
*
24963 dwarf2_find_containing_comp_unit (sect_offset sect_off
,
24964 unsigned int offset_in_dwz
,
24965 dwarf2_per_objfile
*per_objfile
)
24967 int low
= dwarf2_find_containing_comp_unit
24968 (sect_off
, offset_in_dwz
, per_objfile
->per_bfd
->all_comp_units
);
24969 dwarf2_per_cu_data
*this_cu
= per_objfile
->per_bfd
->all_comp_units
[low
];
24971 if (this_cu
->is_dwz
!= offset_in_dwz
|| this_cu
->sect_off
> sect_off
)
24973 if (low
== 0 || this_cu
->is_dwz
!= offset_in_dwz
)
24974 error (_("Dwarf Error: could not find partial DIE containing "
24975 "offset %s [in module %s]"),
24976 sect_offset_str (sect_off
),
24977 bfd_get_filename (per_objfile
->objfile
->obfd
));
24979 gdb_assert (per_objfile
->per_bfd
->all_comp_units
[low
-1]->sect_off
24981 return per_objfile
->per_bfd
->all_comp_units
[low
-1];
24985 if (low
== per_objfile
->per_bfd
->all_comp_units
.size () - 1
24986 && sect_off
>= this_cu
->sect_off
+ this_cu
->length
)
24987 error (_("invalid dwarf2 offset %s"), sect_offset_str (sect_off
));
24988 gdb_assert (sect_off
< this_cu
->sect_off
+ this_cu
->length
);
24995 namespace selftests
{
24996 namespace find_containing_comp_unit
{
25001 struct dwarf2_per_cu_data one
{};
25002 struct dwarf2_per_cu_data two
{};
25003 struct dwarf2_per_cu_data three
{};
25004 struct dwarf2_per_cu_data four
{};
25007 two
.sect_off
= sect_offset (one
.length
);
25012 four
.sect_off
= sect_offset (three
.length
);
25016 std::vector
<dwarf2_per_cu_data
*> units
;
25017 units
.push_back (&one
);
25018 units
.push_back (&two
);
25019 units
.push_back (&three
);
25020 units
.push_back (&four
);
25024 result
= dwarf2_find_containing_comp_unit (sect_offset (0), 0, units
);
25025 SELF_CHECK (units
[result
] == &one
);
25026 result
= dwarf2_find_containing_comp_unit (sect_offset (3), 0, units
);
25027 SELF_CHECK (units
[result
] == &one
);
25028 result
= dwarf2_find_containing_comp_unit (sect_offset (5), 0, units
);
25029 SELF_CHECK (units
[result
] == &two
);
25031 result
= dwarf2_find_containing_comp_unit (sect_offset (0), 1, units
);
25032 SELF_CHECK (units
[result
] == &three
);
25033 result
= dwarf2_find_containing_comp_unit (sect_offset (3), 1, units
);
25034 SELF_CHECK (units
[result
] == &three
);
25035 result
= dwarf2_find_containing_comp_unit (sect_offset (5), 1, units
);
25036 SELF_CHECK (units
[result
] == &four
);
25042 #endif /* GDB_SELF_TEST */
25044 /* Initialize dwarf2_cu to read PER_CU, in the context of PER_OBJFILE. */
25046 dwarf2_cu::dwarf2_cu (dwarf2_per_cu_data
*per_cu
,
25047 dwarf2_per_objfile
*per_objfile
)
25049 per_objfile (per_objfile
),
25051 has_loclist (false),
25052 checked_producer (false),
25053 producer_is_gxx_lt_4_6 (false),
25054 producer_is_gcc_lt_4_3 (false),
25055 producer_is_icc (false),
25056 producer_is_icc_lt_14 (false),
25057 producer_is_codewarrior (false),
25058 processing_has_namespace_info (false)
25062 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
25065 prepare_one_comp_unit (struct dwarf2_cu
*cu
, struct die_info
*comp_unit_die
,
25066 enum language pretend_language
)
25068 struct attribute
*attr
;
25070 /* Set the language we're debugging. */
25071 attr
= dwarf2_attr (comp_unit_die
, DW_AT_language
, cu
);
25072 if (attr
!= nullptr)
25073 set_cu_language (attr
->constant_value (0), cu
);
25076 cu
->language
= pretend_language
;
25077 cu
->language_defn
= language_def (cu
->language
);
25080 cu
->producer
= dwarf2_string_attr (comp_unit_die
, DW_AT_producer
, cu
);
25086 dwarf2_per_objfile::get_cu (dwarf2_per_cu_data
*per_cu
)
25088 auto it
= m_dwarf2_cus
.find (per_cu
);
25089 if (it
== m_dwarf2_cus
.end ())
25098 dwarf2_per_objfile::set_cu (dwarf2_per_cu_data
*per_cu
, dwarf2_cu
*cu
)
25100 gdb_assert (this->get_cu (per_cu
) == nullptr);
25102 m_dwarf2_cus
[per_cu
] = cu
;
25108 dwarf2_per_objfile::age_comp_units ()
25110 dwarf_read_debug_printf_v ("running");
25112 /* This is not expected to be called in the middle of CU expansion. There is
25113 an invariant that if a CU is in the CUs-to-expand queue, its DIEs are
25114 loaded in memory. Calling age_comp_units while the queue is in use could
25115 make us free the DIEs for a CU that is in the queue and therefore break
25117 gdb_assert (!this->per_bfd
->queue
.has_value ());
25119 /* Start by clearing all marks. */
25120 for (auto pair
: m_dwarf2_cus
)
25121 pair
.second
->mark
= false;
25123 /* Traverse all CUs, mark them and their dependencies if used recently
25125 for (auto pair
: m_dwarf2_cus
)
25127 dwarf2_cu
*cu
= pair
.second
;
25130 if (cu
->last_used
<= dwarf_max_cache_age
)
25134 /* Delete all CUs still not marked. */
25135 for (auto it
= m_dwarf2_cus
.begin (); it
!= m_dwarf2_cus
.end ();)
25137 dwarf2_cu
*cu
= it
->second
;
25141 dwarf_read_debug_printf_v ("deleting old CU %s",
25142 sect_offset_str (cu
->per_cu
->sect_off
));
25144 it
= m_dwarf2_cus
.erase (it
);
25154 dwarf2_per_objfile::remove_cu (dwarf2_per_cu_data
*per_cu
)
25156 auto it
= m_dwarf2_cus
.find (per_cu
);
25157 if (it
== m_dwarf2_cus
.end ())
25162 m_dwarf2_cus
.erase (it
);
25165 dwarf2_per_objfile::~dwarf2_per_objfile ()
25170 /* A set of CU "per_cu" pointer, DIE offset, and GDB type pointer.
25171 We store these in a hash table separate from the DIEs, and preserve them
25172 when the DIEs are flushed out of cache.
25174 The CU "per_cu" pointer is needed because offset alone is not enough to
25175 uniquely identify the type. A file may have multiple .debug_types sections,
25176 or the type may come from a DWO file. Furthermore, while it's more logical
25177 to use per_cu->section+offset, with Fission the section with the data is in
25178 the DWO file but we don't know that section at the point we need it.
25179 We have to use something in dwarf2_per_cu_data (or the pointer to it)
25180 because we can enter the lookup routine, get_die_type_at_offset, from
25181 outside this file, and thus won't necessarily have PER_CU->cu.
25182 Fortunately, PER_CU is stable for the life of the objfile. */
25184 struct dwarf2_per_cu_offset_and_type
25186 const struct dwarf2_per_cu_data
*per_cu
;
25187 sect_offset sect_off
;
25191 /* Hash function for a dwarf2_per_cu_offset_and_type. */
25194 per_cu_offset_and_type_hash (const void *item
)
25196 const struct dwarf2_per_cu_offset_and_type
*ofs
25197 = (const struct dwarf2_per_cu_offset_and_type
*) item
;
25199 return (uintptr_t) ofs
->per_cu
+ to_underlying (ofs
->sect_off
);
25202 /* Equality function for a dwarf2_per_cu_offset_and_type. */
25205 per_cu_offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
25207 const struct dwarf2_per_cu_offset_and_type
*ofs_lhs
25208 = (const struct dwarf2_per_cu_offset_and_type
*) item_lhs
;
25209 const struct dwarf2_per_cu_offset_and_type
*ofs_rhs
25210 = (const struct dwarf2_per_cu_offset_and_type
*) item_rhs
;
25212 return (ofs_lhs
->per_cu
== ofs_rhs
->per_cu
25213 && ofs_lhs
->sect_off
== ofs_rhs
->sect_off
);
25216 /* Set the type associated with DIE to TYPE. Save it in CU's hash
25217 table if necessary. For convenience, return TYPE.
25219 The DIEs reading must have careful ordering to:
25220 * Not cause infinite loops trying to read in DIEs as a prerequisite for
25221 reading current DIE.
25222 * Not trying to dereference contents of still incompletely read in types
25223 while reading in other DIEs.
25224 * Enable referencing still incompletely read in types just by a pointer to
25225 the type without accessing its fields.
25227 Therefore caller should follow these rules:
25228 * Try to fetch any prerequisite types we may need to build this DIE type
25229 before building the type and calling set_die_type.
25230 * After building type call set_die_type for current DIE as soon as
25231 possible before fetching more types to complete the current type.
25232 * Make the type as complete as possible before fetching more types. */
25234 static struct type
*
25235 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
,
25236 bool skip_data_location
)
25238 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
25239 struct dwarf2_per_cu_offset_and_type
**slot
, ofs
;
25240 struct objfile
*objfile
= per_objfile
->objfile
;
25241 struct attribute
*attr
;
25242 struct dynamic_prop prop
;
25244 /* For Ada types, make sure that the gnat-specific data is always
25245 initialized (if not already set). There are a few types where
25246 we should not be doing so, because the type-specific area is
25247 already used to hold some other piece of info (eg: TYPE_CODE_FLT
25248 where the type-specific area is used to store the floatformat).
25249 But this is not a problem, because the gnat-specific information
25250 is actually not needed for these types. */
25251 if (need_gnat_info (cu
)
25252 && type
->code () != TYPE_CODE_FUNC
25253 && type
->code () != TYPE_CODE_FLT
25254 && type
->code () != TYPE_CODE_METHODPTR
25255 && type
->code () != TYPE_CODE_MEMBERPTR
25256 && type
->code () != TYPE_CODE_METHOD
25257 && type
->code () != TYPE_CODE_FIXED_POINT
25258 && !HAVE_GNAT_AUX_INFO (type
))
25259 INIT_GNAT_SPECIFIC (type
);
25261 /* Read DW_AT_allocated and set in type. */
25262 attr
= dwarf2_attr (die
, DW_AT_allocated
, cu
);
25265 struct type
*prop_type
= cu
->addr_sized_int_type (false);
25266 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
, prop_type
))
25267 type
->add_dyn_prop (DYN_PROP_ALLOCATED
, prop
);
25270 /* Read DW_AT_associated and set in type. */
25271 attr
= dwarf2_attr (die
, DW_AT_associated
, cu
);
25274 struct type
*prop_type
= cu
->addr_sized_int_type (false);
25275 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
, prop_type
))
25276 type
->add_dyn_prop (DYN_PROP_ASSOCIATED
, prop
);
25279 /* Read DW_AT_data_location and set in type. */
25280 if (!skip_data_location
)
25282 attr
= dwarf2_attr (die
, DW_AT_data_location
, cu
);
25283 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
, cu
->addr_type ()))
25284 type
->add_dyn_prop (DYN_PROP_DATA_LOCATION
, prop
);
25287 if (per_objfile
->die_type_hash
== NULL
)
25288 per_objfile
->die_type_hash
25289 = htab_up (htab_create_alloc (127,
25290 per_cu_offset_and_type_hash
,
25291 per_cu_offset_and_type_eq
,
25292 NULL
, xcalloc
, xfree
));
25294 ofs
.per_cu
= cu
->per_cu
;
25295 ofs
.sect_off
= die
->sect_off
;
25297 slot
= (struct dwarf2_per_cu_offset_and_type
**)
25298 htab_find_slot (per_objfile
->die_type_hash
.get (), &ofs
, INSERT
);
25300 complaint (_("A problem internal to GDB: DIE %s has type already set"),
25301 sect_offset_str (die
->sect_off
));
25302 *slot
= XOBNEW (&objfile
->objfile_obstack
,
25303 struct dwarf2_per_cu_offset_and_type
);
25308 /* Look up the type for the die at SECT_OFF in PER_CU in die_type_hash,
25309 or return NULL if the die does not have a saved type. */
25311 static struct type
*
25312 get_die_type_at_offset (sect_offset sect_off
,
25313 dwarf2_per_cu_data
*per_cu
,
25314 dwarf2_per_objfile
*per_objfile
)
25316 struct dwarf2_per_cu_offset_and_type
*slot
, ofs
;
25318 if (per_objfile
->die_type_hash
== NULL
)
25321 ofs
.per_cu
= per_cu
;
25322 ofs
.sect_off
= sect_off
;
25323 slot
= ((struct dwarf2_per_cu_offset_and_type
*)
25324 htab_find (per_objfile
->die_type_hash
.get (), &ofs
));
25331 /* Look up the type for DIE in CU in die_type_hash,
25332 or return NULL if DIE does not have a saved type. */
25334 static struct type
*
25335 get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
25337 return get_die_type_at_offset (die
->sect_off
, cu
->per_cu
, cu
->per_objfile
);
25340 /* Add a dependence relationship from CU to REF_PER_CU. */
25343 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
25344 struct dwarf2_per_cu_data
*ref_per_cu
)
25348 if (cu
->dependencies
== NULL
)
25350 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
25351 NULL
, &cu
->comp_unit_obstack
,
25352 hashtab_obstack_allocate
,
25353 dummy_obstack_deallocate
);
25355 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
25357 *slot
= ref_per_cu
;
25360 /* Subroutine of dwarf2_mark to pass to htab_traverse.
25361 Set the mark field in every compilation unit in the
25362 cache that we must keep because we are keeping CU.
25364 DATA is the dwarf2_per_objfile object in which to look up CUs. */
25367 dwarf2_mark_helper (void **slot
, void *data
)
25369 dwarf2_per_cu_data
*per_cu
= (dwarf2_per_cu_data
*) *slot
;
25370 dwarf2_per_objfile
*per_objfile
= (dwarf2_per_objfile
*) data
;
25371 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
25373 /* cu->dependencies references may not yet have been ever read if QUIT aborts
25374 reading of the chain. As such dependencies remain valid it is not much
25375 useful to track and undo them during QUIT cleanups. */
25384 if (cu
->dependencies
!= nullptr)
25385 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, per_objfile
);
25390 /* Set the mark field in CU and in every other compilation unit in the
25391 cache that we must keep because we are keeping CU. */
25394 dwarf2_mark (struct dwarf2_cu
*cu
)
25401 if (cu
->dependencies
!= nullptr)
25402 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, cu
->per_objfile
);
25405 /* Trivial hash function for partial_die_info: the hash value of a DIE
25406 is its offset in .debug_info for this objfile. */
25409 partial_die_hash (const void *item
)
25411 const struct partial_die_info
*part_die
25412 = (const struct partial_die_info
*) item
;
25414 return to_underlying (part_die
->sect_off
);
25417 /* Trivial comparison function for partial_die_info structures: two DIEs
25418 are equal if they have the same offset. */
25421 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
25423 const struct partial_die_info
*part_die_lhs
25424 = (const struct partial_die_info
*) item_lhs
;
25425 const struct partial_die_info
*part_die_rhs
25426 = (const struct partial_die_info
*) item_rhs
;
25428 return part_die_lhs
->sect_off
== part_die_rhs
->sect_off
;
25431 struct cmd_list_element
*set_dwarf_cmdlist
;
25432 struct cmd_list_element
*show_dwarf_cmdlist
;
25435 show_check_physname (struct ui_file
*file
, int from_tty
,
25436 struct cmd_list_element
*c
, const char *value
)
25438 fprintf_filtered (file
,
25439 _("Whether to check \"physname\" is %s.\n"),
25443 void _initialize_dwarf2_read ();
25445 _initialize_dwarf2_read ()
25447 add_basic_prefix_cmd ("dwarf", class_maintenance
, _("\
25448 Set DWARF specific variables.\n\
25449 Configure DWARF variables such as the cache size."),
25450 &set_dwarf_cmdlist
, "maintenance set dwarf ",
25451 0/*allow-unknown*/, &maintenance_set_cmdlist
);
25453 add_show_prefix_cmd ("dwarf", class_maintenance
, _("\
25454 Show DWARF specific variables.\n\
25455 Show DWARF variables such as the cache size."),
25456 &show_dwarf_cmdlist
, "maintenance show dwarf ",
25457 0/*allow-unknown*/, &maintenance_show_cmdlist
);
25459 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
25460 &dwarf_max_cache_age
, _("\
25461 Set the upper bound on the age of cached DWARF compilation units."), _("\
25462 Show the upper bound on the age of cached DWARF compilation units."), _("\
25463 A higher limit means that cached compilation units will be stored\n\
25464 in memory longer, and more total memory will be used. Zero disables\n\
25465 caching, which can slow down startup."),
25467 show_dwarf_max_cache_age
,
25468 &set_dwarf_cmdlist
,
25469 &show_dwarf_cmdlist
);
25471 add_setshow_zuinteger_cmd ("dwarf-read", no_class
, &dwarf_read_debug
, _("\
25472 Set debugging of the DWARF reader."), _("\
25473 Show debugging of the DWARF reader."), _("\
25474 When enabled (non-zero), debugging messages are printed during DWARF\n\
25475 reading and symtab expansion. A value of 1 (one) provides basic\n\
25476 information. A value greater than 1 provides more verbose information."),
25479 &setdebuglist
, &showdebuglist
);
25481 add_setshow_zuinteger_cmd ("dwarf-die", no_class
, &dwarf_die_debug
, _("\
25482 Set debugging of the DWARF DIE reader."), _("\
25483 Show debugging of the DWARF DIE reader."), _("\
25484 When enabled (non-zero), DIEs are dumped after they are read in.\n\
25485 The value is the maximum depth to print."),
25488 &setdebuglist
, &showdebuglist
);
25490 add_setshow_zuinteger_cmd ("dwarf-line", no_class
, &dwarf_line_debug
, _("\
25491 Set debugging of the dwarf line reader."), _("\
25492 Show debugging of the dwarf line reader."), _("\
25493 When enabled (non-zero), line number entries are dumped as they are read in.\n\
25494 A value of 1 (one) provides basic information.\n\
25495 A value greater than 1 provides more verbose information."),
25498 &setdebuglist
, &showdebuglist
);
25500 add_setshow_boolean_cmd ("check-physname", no_class
, &check_physname
, _("\
25501 Set cross-checking of \"physname\" code against demangler."), _("\
25502 Show cross-checking of \"physname\" code against demangler."), _("\
25503 When enabled, GDB's internal \"physname\" code is checked against\n\
25505 NULL
, show_check_physname
,
25506 &setdebuglist
, &showdebuglist
);
25508 add_setshow_boolean_cmd ("use-deprecated-index-sections",
25509 no_class
, &use_deprecated_index_sections
, _("\
25510 Set whether to use deprecated gdb_index sections."), _("\
25511 Show whether to use deprecated gdb_index sections."), _("\
25512 When enabled, deprecated .gdb_index sections are used anyway.\n\
25513 Normally they are ignored either because of a missing feature or\n\
25514 performance issue.\n\
25515 Warning: This option must be enabled before gdb reads the file."),
25518 &setlist
, &showlist
);
25520 dwarf2_locexpr_index
= register_symbol_computed_impl (LOC_COMPUTED
,
25521 &dwarf2_locexpr_funcs
);
25522 dwarf2_loclist_index
= register_symbol_computed_impl (LOC_COMPUTED
,
25523 &dwarf2_loclist_funcs
);
25525 dwarf2_locexpr_block_index
= register_symbol_block_impl (LOC_BLOCK
,
25526 &dwarf2_block_frame_base_locexpr_funcs
);
25527 dwarf2_loclist_block_index
= register_symbol_block_impl (LOC_BLOCK
,
25528 &dwarf2_block_frame_base_loclist_funcs
);
25531 selftests::register_test ("dw2_expand_symtabs_matching",
25532 selftests::dw2_expand_symtabs_matching::run_test
);
25533 selftests::register_test ("dwarf2_find_containing_comp_unit",
25534 selftests::find_containing_comp_unit::run_test
);